From f2617ceb3f4ec718c9d161e541b70f060cd0b40d Mon Sep 17 00:00:00 2001 From: aditverm Date: Thu, 22 Feb 2024 09:12:08 +0200 Subject: [PATCH] RIC-1002: Robustness on E2 Components Change-Id: I8cef8d072111b99d08de90aaf97881f438713ed0 Signed-off-by: aditverm --- .../3rdparty/oranE2/ProtocolIE-Field.c | 4 +- RIC-E2-TERMINATION/3rdparty/oranE2/ProtocolIE-ID.h | 4 +- RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp | 1358 +++++++++++++++++--- RIC-E2-TERMINATION/sctpThread.cpp | 926 ++++++++++--- RIC-E2-TERMINATION/sctpThread.h | 67 +- 5 files changed, 2020 insertions(+), 339 deletions(-) diff --git a/RIC-E2-TERMINATION/3rdparty/oranE2/ProtocolIE-Field.c b/RIC-E2-TERMINATION/3rdparty/oranE2/ProtocolIE-Field.c index 06ce54f..ba17a8b 100644 --- a/RIC-E2-TERMINATION/3rdparty/oranE2/ProtocolIE-Field.c +++ b/RIC-E2-TERMINATION/3rdparty/oranE2/ProtocolIE-Field.c @@ -43,7 +43,7 @@ static const asn_ioc_cell_t asn_IOS_RICaction_NotAdmitted_ItemIEs_1_rows[] = { static const asn_ioc_set_t asn_IOS_RICaction_NotAdmitted_ItemIEs_1[] = { { 1, 4, asn_IOS_RICaction_NotAdmitted_ItemIEs_1_rows } }; -static const long asn_VAL_24_id_RICsubscription_withCause_Item = 51; +static const long asn_VAL_24_id_RICsubscription_withCause_Item = 61; static const long asn_VAL_24_ignore = 1; static const long asn_VAL_24_mandatory = 2; static const asn_ioc_cell_t asn_IOS_RICsubscription_withCause_ItemIEs_1_rows[] = { @@ -374,7 +374,7 @@ static const asn_ioc_cell_t asn_IOS_RICsubscriptionDeleteFailure_IEs_1_rows[] = static const asn_ioc_set_t asn_IOS_RICsubscriptionDeleteFailure_IEs_1[] = { { 4, 4, asn_IOS_RICsubscriptionDeleteFailure_IEs_1_rows } }; -static const long asn_VAL_23_id_RICsubscriptionToBeRemoved = 50; +static const long asn_VAL_23_id_RICsubscriptionToBeRemoved = 60; static const long asn_VAL_23_ignore = 1; static const long asn_VAL_23_mandatory = 2; static const asn_ioc_cell_t asn_IOS_RICsubscriptionDeleteRequired_IEs_1_rows[] = { diff --git a/RIC-E2-TERMINATION/3rdparty/oranE2/ProtocolIE-ID.h b/RIC-E2-TERMINATION/3rdparty/oranE2/ProtocolIE-ID.h index 697ebe3..11c13b4 100644 --- a/RIC-E2-TERMINATION/3rdparty/oranE2/ProtocolIE-ID.h +++ b/RIC-E2-TERMINATION/3rdparty/oranE2/ProtocolIE-ID.h @@ -92,8 +92,8 @@ per_type_encoder_f ProtocolIE_ID_encode_aper; #define ProtocolIE_ID_id_E2nodeComponentConfigRemovalAck_Item ((ProtocolIE_ID_t)57) #define ProtocolIE_ID_id_E2nodeTNLassociationRemoval ((ProtocolIE_ID_t)58) #define ProtocolIE_ID_id_E2nodeTNLassociationRemoval_Item ((ProtocolIE_ID_t)59) -#define ProtocolIE_ID_id_RICsubscriptionToBeRemoved ((ProtocolIE_ID_t)50) -#define ProtocolIE_ID_id_RICsubscription_withCause_Item ((ProtocolIE_ID_t)51) +#define ProtocolIE_ID_id_RICsubscriptionToBeRemoved ((ProtocolIE_ID_t)60) +#define ProtocolIE_ID_id_RICsubscription_withCause_Item ((ProtocolIE_ID_t)61) #ifdef __cplusplus } diff --git a/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp b/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp index 73655ab..7b9dbd8 100644 --- a/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp +++ b/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp @@ -25,55 +25,83 @@ typedef struct { unsigned char srcip[RMR_MAX_SRC]; // ip address and port of the source } uta_mhdr_t; +constexpr int numberSix = 6; +constexpr int numberSeven = 7; +constexpr int numberEight = 8; +constexpr int numberNine = 9; +constexpr int numberTen = 10; +constexpr int numberEleven = 11; +constexpr int numberTwelve = 12; +constexpr int numberThirteen = 13; +constexpr int numberFourteen = 14; +constexpr int numberFifteen = 15; +constexpr int numberSixteen = 16; +constexpr int numberSeventeen = 17; +constexpr int numberForty = 40; +constexpr int numberHundred = 100; +constexpr int rmrPort = 38000; +constexpr auto dummyIp = "1.2.3.4"; +constexpr int ricRequestorId = 12345; + +extern std::map connectionHandlingPerE2NodeMap; + void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params); +void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer,bool IsRICIndication, bool IsE2SetupReq, bool IsErrorIndication); +void setE2SetupProcedureNotInitiatedToMap(char *enodbName); +void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer); +void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer); +void resetToDefaultValueAsTeardown(char *enodbName) +{ + setE2SetupProcedureNotInitiatedToMap(enodbName); +} TEST(sctp, TEST1) { mdclog_level_set(MDCLOG_DEBUG); string s; - s = translateRmrErrorMessages(0); + s = translateRmrErrorMessages(numberZero); EXPECT_THAT(s, HasSubstr("RMR_OK")); - s = translateRmrErrorMessages(1); + s = translateRmrErrorMessages(numberOne); EXPECT_THAT(s, HasSubstr("RMR_ERR_BADARG")); - s = translateRmrErrorMessages(2); + s = translateRmrErrorMessages(numberTwo); EXPECT_THAT(s, HasSubstr("RMR_ERR_NOENDPT")); - s = translateRmrErrorMessages(3); + s = translateRmrErrorMessages(numberThree); EXPECT_THAT(s, HasSubstr("RMR_ERR_EMPTY")); - s = translateRmrErrorMessages(4); + s = translateRmrErrorMessages(numberFour); EXPECT_THAT(s, HasSubstr("RMR_ERR_NOHDR")); - s = translateRmrErrorMessages(5); + s = translateRmrErrorMessages(numberFive); EXPECT_THAT(s, HasSubstr("RMR_ERR_SENDFAILED")); - s = translateRmrErrorMessages(6); + s = translateRmrErrorMessages(numberSix); EXPECT_THAT(s, HasSubstr("RMR_ERR_CALLFAILED")); - s = translateRmrErrorMessages(7); + s = translateRmrErrorMessages(numberSeven); EXPECT_THAT(s, HasSubstr("RMR_ERR_NOWHOPEN")); - s = translateRmrErrorMessages(8); + s = translateRmrErrorMessages(numberEight); EXPECT_THAT(s, HasSubstr("RMR_ERR_WHID")); - s = translateRmrErrorMessages(9); + s = translateRmrErrorMessages(numberNine); EXPECT_THAT(s, HasSubstr("RMR_ERR_OVERFLOW")); - s = translateRmrErrorMessages(10); + s = translateRmrErrorMessages(numberTen); EXPECT_THAT(s, HasSubstr("RMR_ERR_RETRY")); - s = translateRmrErrorMessages(11); + s = translateRmrErrorMessages(numberEleven); EXPECT_THAT(s, HasSubstr("RMR_ERR_RCVFAILED")); - s = translateRmrErrorMessages(12); + s = translateRmrErrorMessages(numberTwelve); EXPECT_THAT(s, HasSubstr("RMR_ERR_TIMEOUT")); - s = translateRmrErrorMessages(13); + s = translateRmrErrorMessages(numberThirteen); EXPECT_THAT(s, HasSubstr("RMR_ERR_UNSET")); - s = translateRmrErrorMessages(14); + s = translateRmrErrorMessages(numberFourteen); EXPECT_THAT(s, HasSubstr("RMR_ERR_TRUNC")); - s = translateRmrErrorMessages(15); + s = translateRmrErrorMessages(numberFifteen); EXPECT_THAT(s, HasSubstr("RMR_ERR_INITFAILED")); - s = translateRmrErrorMessages(16); + s = translateRmrErrorMessages(numberSixteen); EXPECT_THAT(s, HasSubstr("RMR_ERR_NOTSUPP")); - s = translateRmrErrorMessages(17); + s = translateRmrErrorMessages(numberSeventeen); EXPECT_THAT(s, HasSubstr("UNDOCUMENTED RMR_ERR")); } -auto *peerInfo = (ConnectedCU_t *)calloc(1, sizeof(ConnectedCU_t)); +auto *peerInfo = (ConnectedCU_t *)calloc(numberOne, sizeof(ConnectedCU_t)); TEST(sctp, TEST2) { struct epoll_event event; event.events = EPOLLIN; - event.data.fd = 0; + event.data.fd = numberZero; ConnectedCU_t data1; ConnectedCU_t *data = &data1; event.data.ptr = (void *)data; @@ -84,12 +112,12 @@ TEST(sctp, TEST2) { handleEinprogressMessages(event,reporting_msg,rmrmessagesbuffer,sctp); } -TEST(sctp, TEST3) { +TEST(sctp, TestSctpAbortThenE2tShouldNotCrash) { struct epoll_event event; event.events = EPOLLIN; - event.data.fd = 0; + event.data.fd = numberZero; ConnectedCU_t data1; - ConnectedCU_t *data = &data1; + ConnectedCU_t *data = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t)); event.data.ptr = (void *)data; sctp_params_t sctp_ut_params; sctp_params_t* sctp = &sctp_ut_params; @@ -102,10 +130,10 @@ TEST(sctp, TEST3) { TEST(sctp, TEST4) { ConnectedCU_t cu; - ConnectedCU_t* connected_cu = &cu; + ConnectedCU_t* connected_cu1 = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t)); Sctp_Map_t m1; Sctp_Map_t *m = &m1; - cleanHashEntry(connected_cu,m); + cleanHashEntry(connected_cu1,m); } TEST(sctp, TEST5) { @@ -117,12 +145,24 @@ TEST(sctp, TEST5) { } TEST(sctp, TEST6) { - int epoll_fd = epoll_create1(0); + int epoll_fd = epoll_create1(numberZero); ConnectedCU_t cu; - ConnectedCU_t* peerinfo = &cu; + ConnectedCU_t* peerinfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t)); Sctp_Map_t m1; Sctp_Map_t *m = &m1; - modifyToEpoll(epoll_fd,peerinfo,2,m, (char*)"enodeb1",2); + modifyToEpoll(epoll_fd,peerinfo,numberTwo,m, (char*)"enodeb1",numberTwo); +} + +TEST(sctp, TEST17) { + sctp_params_t sctpParams; + sctpParams.inotifyFD = negativeOne; + buildInotify(sctpParams); +} + +TEST(sctp, TEST18) { + sctp_params_t sctpParams; + sctpParams.inotifyWD = negativeOne; + buildInotify(sctpParams); } @@ -131,31 +171,78 @@ void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessage message.peerInfo = peerInfo; message.peerInfo->sctpParams = &sctp_ut_params; snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb"); - - sctp_ut_params.myIP = "1.2.3.4"; - sctp_ut_params.rmrPort = 38000; + + sctp_ut_params.myIP = dummyIp; + sctp_ut_params.rmrPort = rmrPort; snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort)); - + rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t)); rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t)); rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from NOKIA "); rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA"); } -void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) { - +void deleteMemoryForE2SetupReq(E2AP_PDU_t *pdu) +{ + if( (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) && + (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]) ) { + free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = NULL; + } + if( (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) && + (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne]) ) { + free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne]); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne] = NULL; + } + if(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) { + free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = NULL; + } + + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = numberZero; + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = numberZero; +} + +void deleteMemoryForRicIndication(E2AP_PDU_t *pdu) +{ if( (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) && - (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]) ) { - free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]); - pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = NULL; + (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero]) ) { + free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero]); + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero] = NULL; } if(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) { free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array); pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = NULL; } - pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 0; - pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = 0; - + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = numberZero; + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = numberZero; +} + +void deleteMemoryForErrorIndication(E2AP_PDU_t *pdu) +{ + if( (pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array) && + (pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero]) ) { + free(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero]); + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero] = NULL; + } + if(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array) { + free(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array); + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array = NULL; + } + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count = numberZero; + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.size = numberZero; +} + +void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer,bool IsRICIndication, bool IsE2SetupReq, bool IsErrorIndication) { + if(IsE2SetupReq){ + deleteMemoryForE2SetupReq(pdu); + } + if(IsRICIndication){ + deleteMemoryForRicIndication(pdu); + } + if(IsErrorIndication){ + deleteMemoryForErrorIndication(pdu); + } if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) { free(rmrMessageBuffer.sendMessage->header); rmrMessageBuffer.sendMessage->header = NULL; @@ -174,6 +261,128 @@ void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmr } } +void create_asnInitiatingReq_Procedure_E2Setup(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2setup */ + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_E2setup; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest; + + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = (E2setupRequestIEs**) malloc(1 * sizeof(E2setupRequestIEs*)); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = 2; + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = sizeof(E2setupRequestIEs); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs)); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs)); + E2setupRequestIEs_t *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]; + ie->id = ProtocolIE_ID_id_GlobalE2node_ID; + ie->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID; + ie->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB; + + ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne]; + ie->id = ProtocolIE_ID_id_TransactionID; + ie->value.present = E2setupRequestIEs__value_PR_TransactionID; + ie->value.choice.TransactionID = numberOne; + + int streamId = numberZero; + + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, true, false); +} + +void unsupportedRicSubscriptionDelReq(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICsubscriptionDeleteRequired */ + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICsubscriptionDeleteRequired; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequired; + + int streamId = numberZero; + + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false); +} + +void unsupportedE2ConnectionUpdateAck(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2connectionUpdate */ + pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_E2connectionUpdate; + pdu->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_E2connectionUpdateAcknowledge; + + asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer); + // delete_memories_successfulOutcome(pdu, rmrMessageBuffer); +} + +void deleteMemoriesForUnsupportedE2ConnectionUpdate(RmrMessagesBuffer_t &rmrMessageBuffer) +{ + if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) { + free(rmrMessageBuffer.sendMessage->header); + rmrMessageBuffer.sendMessage->header = NULL; + } + if(rmrMessageBuffer.sendMessage->payload) { + free(rmrMessageBuffer.sendMessage->payload); + rmrMessageBuffer.sendMessage->payload = NULL; + } + if(rmrMessageBuffer.sendMessage) { + free(rmrMessageBuffer.sendMessage); + rmrMessageBuffer.sendMessage = NULL; + } +} + +void unsupportedE2ConnectionUpdateFail(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2connectionUpdate */ + pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_E2connectionUpdate; + pdu->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcome__value_PR_E2nodeConfigurationUpdateFailure; + + asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer); + + deleteMemoriesForUnsupportedE2ConnectionUpdate(rmrMessageBuffer); +} + +void create_asnInitiatingReq_Procedure_E2SetupWithoutTransactionID(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2setup */ + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_E2setup; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest; + + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = (E2setupRequestIEs**) malloc(1 * sizeof(E2setupRequestIEs*)); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = numberOne; + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = sizeof(E2setupRequestIEs); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs)); + E2setupRequestIEs_t *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]; + ie->id = ProtocolIE_ID_id_GlobalE2node_ID; + ie->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID; + ie->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB; + + int streamId = numberZero; + + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, true, false); +} + void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, @@ -184,10 +393,11 @@ void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu, /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */ pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICserviceUpdate; pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICserviceUpdate; - - int streamId = 0; + + int streamId = numberZero; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); - delete_memories_initiatingMessage(pdu, rmrMessageBuffer); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false); } void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu, @@ -195,23 +405,24 @@ void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params) { - + init_memories(message, rmrMessageBuffer, sctp_ut_params); /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */ pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICindication; pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICindication; pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = (RICindication_IEs**) malloc(1 * sizeof(RICindication_IEs*)); - pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 1; + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = numberOne; pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = sizeof(RICindication_IEs); - pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs)); - RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]; + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs)); + RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero]; ie->id = ProtocolIE_ID_id_RICrequestID; ie->value.present = RICindication_IEs__value_PR_RICrequestID; - ie->value.choice.RICrequestID.ricRequestorID = 12345; - ie->value.choice.RICrequestID.ricInstanceID = 1; - int streamId = 0; + ie->value.choice.RICrequestID.ricRequestorID = ricRequestorId; + ie->value.choice.RICrequestID.ricInstanceID = numberOne; + int streamId = numberZero; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); - delete_memories_initiatingMessage(pdu, rmrMessageBuffer); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,true, false, false); } void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu, @@ -224,9 +435,10 @@ void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu, /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */ pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication; pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication; - int streamId = 0; + int streamId = numberZero; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer, streamId); - delete_memories_initiatingMessage(pdu, rmrMessageBuffer); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false); } void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu, @@ -239,23 +451,56 @@ void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu, /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */ pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset; pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest; - int streamId =0; + int streamId =numberZero; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); - delete_memories_initiatingMessage(pdu, rmrMessageBuffer); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false); } -TEST(sctp, TEST7) { +void setE2SetupProcedureNotInitiatedToMap(char *enbName) +{ + printEntryPresentInMap(); + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return; + } + else + { + mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map"); + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + while(itr != connectionHandlingPerE2NodeMap.end()) + { + mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus); + int result = itr->first.compare(enbName); + if (result == 0) + { + mdclog_write(MDCLOG_DEBUG, "Updating to E2SetupOngoing Procedure"); + itr->second.e2tProcedureOngoingStatus = E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED; + mdclog_write(MDCLOG_DEBUG, "Current procedure updated to %d", itr->second.e2tProcedureOngoingStatus); + itr->second.e2SetupProcedureTransactionId = negativeOne; + break; + } + ++itr; + } + } +} +TEST(sctp, TESTBeforeE2SetupReqThenDropTheMessage) { E2AP_PDU_t pdu; Sctp_Map_t *sctpMap = new Sctp_Map_t(); ReportingMessages_t message; RmrMessagesBuffer_t rmrMessageBuffer; sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; pdu.present = E2AP_PDU_PR_initiatingMessage; pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); - memset( (void*)pdu.choice.initiatingMessage, 0, sizeof(pdu.choice.initiatingMessage)); - memset( (void*)&message, 0, sizeof(message)); - memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); @@ -270,9 +515,10 @@ TEST(sctp, TEST7) { create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); /* For Procedure's Default case. */ pdu.choice.initiatingMessage->procedureCode = ((ProcedureCode_t)100); - int streamId =0; + int streamId =numberZero; + asnInitiatingRequest(&pdu, sctpMap, message, rmrMessageBuffer,streamId); - + if(pdu.choice.initiatingMessage) { free(pdu.choice.initiatingMessage); pdu.choice.initiatingMessage = NULL; @@ -281,22 +527,24 @@ TEST(sctp, TEST7) { delete sctpMap; sctpMap = NULL; } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); } /* TEST8 Begin: */ void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) { - if( (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) && - (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]) ) { - free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]); - pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = NULL; + if( (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) && + (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero]) ) { + free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero]); + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero] = NULL; } if(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) { free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array); pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = NULL; } - pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 0; - pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = 0; + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = numberZero; + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = numberZero; if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) { free(rmrMessageBuffer.sendMessage->header); @@ -333,12 +581,12 @@ void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, sctp_params_t &sctp_ut_params) { init_memories(message, rmrMessageBuffer, sctp_ut_params); - + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = (RICcontrolAcknowledge_IEs_t**) malloc(1 * sizeof(RICcontrolAcknowledge_IEs_t*)); - pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 1; + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = numberOne; pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = sizeof(RICcontrolAcknowledge_IEs_t); - pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t)); - RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]; + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t)); + RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero]; ie->id = ProtocolIE_ID_id_RICrequestID; ie->value.present = RICcontrolAcknowledge_IEs__value_PR_RICrequestID; @@ -383,9 +631,9 @@ TEST(sctp, TEST8) { pdu.present = E2AP_PDU_PR_successfulOutcome; pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome)); - memset( (void*)pdu.choice.successfulOutcome, 0, sizeof(pdu.choice.successfulOutcome)); - memset( (void*)&message, 0, sizeof(message)); - memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1"); @@ -398,9 +646,9 @@ TEST(sctp, TEST8) { /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */ create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); /* For Procedure's Default case. */ - pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)100); + pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)numberHundred); asnSuccessfulMsg(&pdu, sctpMap, message, rmrMessageBuffer); - + if(pdu.choice.successfulOutcome) { free(pdu.choice.successfulOutcome); pdu.choice.successfulOutcome = NULL; @@ -415,16 +663,16 @@ TEST(sctp, TEST8) { void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) { if( (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) && - (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]) ) { - free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]); - pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = NULL; + (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero]) ) { + free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero]); + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero] = NULL; } if(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) { free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array); pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = NULL; } - pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 0; - pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = 0; + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = numberZero; + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = numberZero; if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) { free(rmrMessageBuffer.sendMessage->header); @@ -447,12 +695,12 @@ void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, sctp_params_t &sctp_ut_params) { init_memories(message, rmrMessageBuffer, sctp_ut_params); - + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = (RICcontrolFailure_IEs_t**) malloc(1*sizeof(RICcontrolFailure_IEs_t*)); - pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 1; + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = numberOne; pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = sizeof(RICcontrolFailure_IEs_t); - pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t)); - RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]; + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t)); + RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero]; ie->id = ProtocolIE_ID_id_RICrequestID; ie->value.present = RICcontrolFailure_IEs__value_PR_RICrequestID; @@ -480,7 +728,6 @@ void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params) { - init_memories(message, rmrMessageBuffer, sctp_ut_params); /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */ pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete; @@ -497,9 +744,9 @@ TEST(sctp, TEST9) { pdu.present = E2AP_PDU_PR_unsuccessfulOutcome; pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome)); - memset( (void*)pdu.choice.unsuccessfulOutcome, 0, sizeof(pdu.choice.unsuccessfulOutcome)); - memset( (void*)&message, 0, sizeof(message)); - memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1"); @@ -510,9 +757,9 @@ TEST(sctp, TEST9) { /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */ create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); /* For Procedure's Default case. */ - pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100); + pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)numberHundred); asnUnSuccsesfulMsg(&pdu, sctpMap, message, rmrMessageBuffer); - + if(pdu.choice.unsuccessfulOutcome) { free(pdu.choice.unsuccessfulOutcome); pdu.choice.unsuccessfulOutcome = NULL; @@ -525,36 +772,40 @@ TEST(sctp, TEST9) { TEST(sctp, TEST10) { - int epoll_fd = epoll_create1(0); + int epoll_fd = epoll_create1(numberZero); ConnectedCU_t cu; - ConnectedCU_t* peerinfo = &cu; + ConnectedCU_t* peerinfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t)); Sctp_Map_t m1; Sctp_Map_t *m = &m1; - addToEpoll(epoll_fd, peerinfo, 2, m, (char*)"enodeb1", 0); + addToEpoll(epoll_fd, peerinfo, numberTwo, m, (char*)"enodeb1", numberZero); } TEST(sctp, TEST11) { sctp_params_t sctpParams; int argc = 5; char **argv = (char**) calloc(argc, sizeof(char*)); - argv[0] = (char*) malloc(40 * sizeof(char)); - argv[1] = (char*) malloc(40 * sizeof(char)); - argv[2] = (char*) malloc(40 * sizeof(char)); - argv[3] = (char*) malloc(40 * sizeof(char)); - argv[4] = (char*) malloc(40 * sizeof(char)); - snprintf(argv[0], strlen("./e2 "), "%s", (char*)"./e2"); - snprintf(argv[1], strlen("-p "), "%s", (char*)"-p"); - snprintf(argv[2], strlen("/opt/e2/RIC-E2-TERMINATION/config "), "%s", (char*)"/opt/e2/RIC-E2-TERMINATION/config"); - snprintf(argv[3], strlen("-f "), "%s", (char*)"-f"); - snprintf(argv[4], strlen("config.conf "), "%s", (char*)"config.conf"); - + argv[numberZero] = (char*) malloc(numberForty * sizeof(char)); + argv[numberOne] = (char*) malloc(numberForty * sizeof(char)); + argv[numberTwo] = (char*) malloc(numberForty * sizeof(char)); + argv[numberThree] = (char*) malloc(numberForty * sizeof(char)); + argv[numberFour] = (char*) malloc(numberForty * sizeof(char)); + snprintf(argv[numberZero], strlen("./e2 "), "%s", (char*)"./e2"); + snprintf(argv[numberOne], strlen("-p "), "%s", (char*)"-p"); + snprintf(argv[numberTwo], strlen("/opt/e2/RIC-E2-TERMINATION/config "), "%s", (char*)"/opt/e2/RIC-E2-TERMINATION/config"); + snprintf(argv[numberThree], strlen("-f "), "%s", (char*)"-f"); + snprintf(argv[numberFour], strlen("config.conf "), "%s", (char*)"config.conf"); + auto result = parse(argc, argv, sctpParams); sctpParams.podName.assign("E2TermAlpha_pod"); sctpParams.sctpMap = new mapWrapper(); - sctpParams.epoll_fd = epoll_create1(0); + sctpParams.epoll_fd = epoll_create1(numberZero); buildConfiguration(sctpParams); // getRmrContext(sctpParams); buildInotify(sctpParams); + sctpParams.inotifyFD = negativeOne; + buildInotify(sctpParams); + sctpParams.inotifyWD = negativeOne; + buildInotify(sctpParams); buildListeningPort(sctpParams); listener(&sctpParams); @@ -563,16 +814,16 @@ TEST(sctp, TEST11) { sctpParams.sctpMap = NULL; } if(argv) { - free(argv[0]); - argv[0] = NULL; - free(argv[1]); - argv[1] = NULL; - free(argv[2]); - argv[2] = NULL; - free(argv[3]); - argv[3] = NULL; - free(argv[4]); - argv[4] = NULL; + free(argv[numberZero]); + argv[numberZero] = NULL; + free(argv[numberOne]); + argv[numberOne] = NULL; + free(argv[numberTwo]); + argv[numberTwo] = NULL; + free(argv[numberThree]); + argv[numberThree] = NULL; + free(argv[numberFour]); + argv[numberFour] = NULL; free(argv); argv=NULL; } @@ -741,13 +992,29 @@ void create_receiveXappMessages_RIC_E2_SETUP_RESP(Sctp_Map_t *sctpMap, Reporting delete_memories_rcv(rmrMessageBuffer); } +void create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_ACK(Sctp_Map_t *sctpMap, ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer) { + inti_buffers_rcv(message, rmrMessageBuffer); + rmrMessageBuffer.rcvMessage->mtype = RIC_E2NODE_CONFIG_UPDATE_ACK; + receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time); + delete_memories_rcv(rmrMessageBuffer); +} + +void create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer) { + inti_buffers_rcv(message, rmrMessageBuffer); + rmrMessageBuffer.rcvMessage->mtype = RIC_E2NODE_CONFIG_UPDATE_FAILURE; + receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time); + delete_memories_rcv(rmrMessageBuffer); +} + TEST(sctp, TEST13) { Sctp_Map_t *sctpMap = new Sctp_Map_t(); ReportingMessages_t message; RmrMessagesBuffer_t rmrMessageBuffer; - memset( (void*)&message, 0, sizeof(message)); - memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); // Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset create_receiveXappMessages_RIC_E2_SETUP_FAILURE(sctpMap, message, rmrMessageBuffer); @@ -764,6 +1031,8 @@ TEST(sctp, TEST13) { create_receiveXappMessages_RIC_SERVICE_QUERY(sctpMap, message, rmrMessageBuffer); create_receiveXappMessages_RIC_SUB_DEL_REQ(sctpMap, message, rmrMessageBuffer); create_receiveXappMessages_RIC_E2_SETUP_RESP(sctpMap, message, rmrMessageBuffer); + create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_ACK(sctpMap, message, rmrMessageBuffer); + create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_FAILURE(sctpMap, message, rmrMessageBuffer); inti_buffers_rcv(message, rmrMessageBuffer); rmrMessageBuffer.rcvMessage->mtype = 52345; /*Dummy Integer Value for default case*/ @@ -774,95 +1043,822 @@ TEST(sctp, TEST13) { delete sctpMap; sctpMap = NULL; } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); } -/* TEST 14 Begin: */ -void receiveDataFromSctp_asnSuccessfulMsg_Procedure_Default( E2AP_PDU_t *pdu, - RmrMessagesBuffer_t &rmrMessageBuffer) { - pdu->present = E2AP_PDU_PR_successfulOutcome; - pdu->choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome)); - memset( (void*)pdu->choice.successfulOutcome, 0, sizeof(pdu->choice.successfulOutcome)); - pdu->choice.successfulOutcome->procedureCode = ((ProcedureCode_t)100); - rmrMessageBuffer.sendMessage->tp_buf = pdu; +TEST(sctp, TESTForDebug) { +char* log_level = "4"; +update_mdc_log_level_severity(log_level); } -void delete_pdu_memories(E2AP_PDU_t *pdu) { - if(pdu->choice.successfulOutcome) { - free(pdu->choice.successfulOutcome); - pdu->choice.successfulOutcome = NULL; +TEST(sctp, TestE2SetupRequest) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; } - if(pdu->choice.unsuccessfulOutcome) { - free(pdu->choice.unsuccessfulOutcome); - pdu->choice.unsuccessfulOutcome = NULL; + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; } } -/*void receiveDataFromSctp_asnUnSuccsesfulMsg_Procedure_Default(E2AP_PDU_t *pdu, - RmrMessagesBuffer_t &rmrMessageBuffer) { - pdu->present = E2AP_PDU_PR_unsuccessfulOutcome; - pdu->choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome)); - memset( (void*)pdu->choice.unsuccessfulOutcome, 0, sizeof(pdu->choice.unsuccessfulOutcome)); - pdu->choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100); - - rmrMessageBuffer.sendMessage->tp_buf = pdu; -}*/ - -TEST(sctp, TEST14) { +TEST(sctp, TestE2SetupRequestWhenReceivedWithoutTransactionIDThenIgnoreE2SetupProcedure) { E2AP_PDU_t pdu; - struct epoll_event events; - Sctp_Map_t *sctpMap = new Sctp_Map_t(); - int numOfMessages=0; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; RmrMessagesBuffer_t rmrMessageBuffer; - struct timespec ts; - ConnectedCU_t *peerInfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t)); - events.data.ptr = peerInfo; - snprintf(peerInfo->enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb"); + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; - rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t)); - rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t)); - rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from NOKIA "); - rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA"); + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); - clock_gettime(CLOCK_MONOTONIC, &ts); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); - receiveDataFromSctp_asnSuccessfulMsg_Procedure_Default(&pdu, rmrMessageBuffer); - receiveDataFromSctp(&events, sctpMap, numOfMessages, rmrMessageBuffer, ts); - delete_pdu_memories(&pdu); + create_asnInitiatingReq_Procedure_E2SetupWithoutTransactionID(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); - if(rmrMessageBuffer.sendMessage->payload) { - free(rmrMessageBuffer.sendMessage->payload); - rmrMessageBuffer.sendMessage->payload = NULL; + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; } +} - /*rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA"); - receiveDataFromSctp_asnUnSuccsesfulMsg_Procedure_Default(&pdu, rmrMessageBuffer); - receiveDataFromSctp(&events, sctpMap, numOfMessages, rmrMessageBuffer, ts); - delete_pdu_memories(&pdu); - if(rmrMessageBuffer.sendMessage->payload) { - free(rmrMessageBuffer.sendMessage->payload); - rmrMessageBuffer.sendMessage->payload = NULL; - }*/ - if(rmrMessageBuffer.sendMessage->header) { - free(rmrMessageBuffer.sendMessage->header); - rmrMessageBuffer.sendMessage->header = NULL; +TEST(sctp, TestErrorIndicationWhenE2SetupOngoingProcedureOccurred) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + + create_receiveXappMessages_RIC_E2_SETUP_RESP(sctpMap, message, rmrMessageBuffer); + + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; } - if(rmrMessageBuffer.sendMessage) { - free(rmrMessageBuffer.sendMessage); + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; } - if(peerInfo) { - free(peerInfo); - peerInfo = NULL; +} + + +TEST(sctp, TestE2SetupRequestReceivedThenErrorIndicationMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; } + if(sctpMap) { delete sctpMap; sctpMap = NULL; } } -int main(int argc, char **argv) { +TEST(sctp, TestE2SetupRequestReceivedThenRICindicationMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} +TEST(sctp, TestE2SetupRequestReceivedThenRICserviceUpdateMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenResetMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} +TEST(sctp, TestE2SetupRequestReceivedThenRICcontrolMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenRICcontrolMessageTriggeredAndGotControlFailure) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionMessageTriggeredAndGotSubsFailure) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionDeleteMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + resetToDefaultValueAsTeardown(message.message.enodbName); + + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionDeleteMessageTriggeredAndGotSubDelFailure) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + resetToDefaultValueAsTeardown(message.message.enodbName); + + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +void errorIndicationBasedOnProcedureCodeOrProcedureStatus(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication; + + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array = (ErrorIndication_IEs**) malloc(1 * sizeof(ErrorIndication_IEs*)); + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count = 1; + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.size = sizeof(ErrorIndication_IEs); + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero] = (ErrorIndication_IEs*) malloc(sizeof(ErrorIndication_IEs)); + + ErrorIndication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero]; + + ie->id = ProtocolIE_ID_id_TransactionID; + ie->criticality = Criticality_reject; + ie->value.present = ErrorIndication_IEs__value_PR_TransactionID; + ie->value.choice.TransactionID = numberThree; + + int streamId = numberZero; + + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer, streamId); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, true); +} + +TEST(sctp, TestDropErrorIndicationReceivedWithInvalidTidWhenE2SetupOngoingProcedureOccurredBasedOnOngoingProcedureStatus) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + errorIndicationBasedOnProcedureCodeOrProcedureStatus(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestRemovalOfE2ConnectionEntryFromMap) { + + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + removeE2ConnectionEntryFromMap(message.message.enodbName); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestUnsupportedRicSubsDelRequiredBeforeE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + unsupportedRicSubscriptionDelReq(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); +} + +TEST(sctp, TestUnsupportedRicSubsDelRequiredAfterE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + unsupportedRicSubscriptionDelReq(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); +} + +TEST(sctp, TestUnsupportedE2ConnectionUpdateAckBeforeE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome)); + memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + unsupportedE2ConnectionUpdateAck(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + if(pdu.choice.successfulOutcome) { + free(pdu.choice.successfulOutcome); + pdu.choice.successfulOutcome = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); +} + +TEST(sctp, TestUnsupportedE2ConnectionUpdateAckAfterE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome)); + memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome)); + + unsupportedE2ConnectionUpdateAck(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(pdu.choice.successfulOutcome) { + free(pdu.choice.successfulOutcome); + pdu.choice.successfulOutcome = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + +} + +TEST(sctp, TestUnsupportedE2ConnectionUpdateFailBeforeE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome)); + memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + unsupportedE2ConnectionUpdateFail(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + if(pdu.choice.unsuccessfulOutcome) { + free(pdu.choice.unsuccessfulOutcome); + pdu.choice.unsuccessfulOutcome = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); +} + +TEST(sctp, TestUnsupportedE2ConnectionUpdateFailAfterE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome)); + memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome)); + + unsupportedE2ConnectionUpdateFail(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(pdu.choice.unsuccessfulOutcome) { + free(pdu.choice.unsuccessfulOutcome); + pdu.choice.unsuccessfulOutcome = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); +} + +TEST(sctp, TestForInfo) { +char* log_level = "3"; +update_mdc_log_level_severity(log_level); +} + +TEST(sctp, TestForWarn) { +char* log_level = "2"; +update_mdc_log_level_severity(log_level); +} + +TEST(sctp, TestForErr) { +char* log_level = "1"; +update_mdc_log_level_severity(log_level); +} + +int main(int argc, char **argv) { + + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/RIC-E2-TERMINATION/sctpThread.cpp b/RIC-E2-TERMINATION/sctpThread.cpp index 1ec624c..6ad9fdf 100644 --- a/RIC-E2-TERMINATION/sctpThread.cpp +++ b/RIC-E2-TERMINATION/sctpThread.cpp @@ -61,6 +61,7 @@ BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(my_logger, src::logger_mt) boost::shared_ptr> boostLogger; // double cpuClock = 0.0; bool jsonTrace = false; +std::map connectionHandlingPerE2NodeMap; char* getinterfaceip() { @@ -642,8 +643,8 @@ int main(const int argc, char **argv) { auto result = parse(argc, argv, sctpParams); - if (buildConfiguration(sctpParams) != 0) { - exit(-1); + if (buildConfiguration(sctpParams) != numberZero) { + exit(negativeOne); } //auto registry = std::make_shared(); @@ -688,15 +689,15 @@ int main(const int argc, char **argv) { std::vector threads(num_cpus); // std::vector threads; - num_cpus = 3; - for (unsigned int i = 0; i < num_cpus; i++) { + num_cpus = numberOne; + for (unsigned int i = numberZero; i < num_cpus; i++) { threads[i] = std::thread(listener, &sctpParams); cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(i, &cpuset); int rc = pthread_setaffinity_np(threads[i].native_handle(), sizeof(cpu_set_t), &cpuset); - if (rc != 0) { + if (rc != numberZero) { mdclog_write(MDCLOG_ERR, "Error calling pthread_setaffinity_np: %d", rc); } } @@ -896,13 +897,13 @@ void listener(sctp_params_t *params) { #else auto numOfEvents = 1; #endif - if (numOfEvents == 0) { // time out + if (numOfEvents == numberZero) { // time out #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "got epoll timeout"); } continue; - } else if (numOfEvents < 0) { + } else if (numOfEvents < numberZero) { if (errno == EINTR) { if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "got EINTR : %s", strerror(errno)); @@ -918,7 +919,7 @@ void listener(sctp_params_t *params) { return; #endif } - for (auto i = 0; i < numOfEvents; i++) { + for (auto i = numberZero; i < numOfEvents; i++) { if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "handling epoll event %d out of %d", i + 1, numOfEvents); } @@ -950,7 +951,7 @@ void listener(sctp_params_t *params) { } peerInfo->sctpParams = params; peerInfo->fileDescriptor = accept(params->listenFD, &in_addr, &in_len); - if (peerInfo->fileDescriptor == -1) { + if (peerInfo->fileDescriptor == negativeOne) { #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) { /* We have processed all incoming connections. */ @@ -1218,6 +1219,13 @@ void handleEinprogressMessages(struct epoll_event &event, message.message.asnLength = rmrMessageBuffer.sendMessage->len; mdclog_write(MDCLOG_ERR, "%s", rmrMessageBuffer.sendMessage->payload); message.message.direction = 'N'; + mdclog_write(MDCLOG_DEBUG, "Checking the peerInfo->enodbName - %s", peerInfo->enodbName); + if (peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]) + { + mdclog_write(MDCLOG_DEBUG, "Incrementing SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]->Increment(); + mdclog_write(MDCLOG_DEBUG, "Incremented SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + } if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "SCTP_CONNECTION_FAIL message failed to send to xAPP"); } @@ -1247,7 +1255,7 @@ void handleEinprogressMessages(struct epoll_event &event, } if (sendSctpMsg(peerInfo, message, params->sctpMap) != 0) { if (mdclog_level_get() >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "Error write to SCTP %s %d", __func__, __LINE__); + mdclog_write(MDCLOG_ERR, "Error write to SCTP %s %d", __func__, __LINE__); } return; } @@ -1276,13 +1284,29 @@ void handlepoll_error(struct epoll_event &event, memcpy(message.message.enodbName, peerInfo->enodbName, sizeof(peerInfo->enodbName)); message.message.direction = 'N'; + mdclog_write(MDCLOG_DEBUG, "Checking the peerInfo->enodbName - %s", peerInfo->enodbName); + if (peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]) + { + mdclog_write(MDCLOG_DEBUG, "Incrementing SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]->Increment(); + mdclog_write(MDCLOG_DEBUG, "Incremented SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + } if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "SCTP_CONNECTION_FAIL message failed to send to xAPP"); } #endif close(peerInfo->fileDescriptor); + mdclog_write(MDCLOG_DEBUG, "Before event.data.ptr %p and data is %d", (void *)event.data.ptr, *((ConnectedCU_t *)event.data.ptr)); + mdclog_write(MDCLOG_DEBUG, "Erasing Entry from Map for Key %s", peerInfo->enodbName); + removeE2ConnectionEntryFromMap(peerInfo->enodbName); //params->sctpMap->erase(peerInfo->enodbName); cleanHashEntry((ConnectedCU_t *) event.data.ptr, params->sctpMap); + if (event.data.ptr != nullptr) + { + mdclog_write(MDCLOG_DEBUG, "Not assigned event.data.ptr = NULL"); + event.data.ptr = nullptr; + } + mdclog_write(MDCLOG_DEBUG, "After event.data.ptr %p", (void *)event.data.ptr); } else { mdclog_write(MDCLOG_ERR, "epoll error, events %0x on RMR FD", event.events); } @@ -1315,7 +1339,9 @@ int setSocketNoBlocking(int socket) { * @param m */ void cleanHashEntry(ConnectedCU_t *val, Sctp_Map_t *m) { - if(val != nullptr) { + if(val != nullptr) + { + mdclog_write(MDCLOG_DEBUG, "Inside cleanHashEntry"); char *dummy; auto port = (uint16_t) strtol(val->portNumber, &dummy, 10); char searchBuff[2048]{}; @@ -1329,12 +1355,9 @@ void cleanHashEntry(ConnectedCU_t *val, Sctp_Map_t *m) { mdclog_write(MDCLOG_DEBUG, "remove key enodbName = %s from %s at line %d", val->enodbName, __FUNCTION__, __LINE__); m->erase(val->enodbName); } -#ifndef UNIT_TEST - if(val) { - free(val); - val = nullptr; - } -#endif + free(val); + val = nullptr; + mdclog_write(MDCLOG_DEBUG, "After free"); } } @@ -1375,7 +1398,14 @@ int sendSctpMsg(ConnectedCU_t *peerInfo, ReportingMessages_t &message, Sctp_Map_ } #endif #ifndef UNIT_TEST + mdclog_write(MDCLOG_DEBUG, "Erasing Entry from Map for Key %s", peerInfo->enodbName); + removeE2ConnectionEntryFromMap(peerInfo->enodbName); cleanHashEntry(peerInfo, m); + if (peerInfo != nullptr) + { + mdclog_write(MDCLOG_DEBUG, "Not assigned peerInfo = NULL"); + peerInfo = nullptr; + } close(fd); #endif char key[MAX_ENODB_NAME_SIZE * 2]; @@ -1423,7 +1453,30 @@ void getRequestMetaData(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMe } } +void removeE2ConnectionEntryFromMap(char* enbName) +{ + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return; + } + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + mdclog_write(MDCLOG_DEBUG, "Iterating Map e2NodeIdConnectionStatusMap"); + while (itr != connectionHandlingPerE2NodeMap.end()) + { + int result = itr->first.compare(enbName); + if (result == 0) + { + mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus); + mdclog_write(MDCLOG_DEBUG, "Removing the Entry from map for %s", enbName); + connectionHandlingPerE2NodeMap.erase(itr); + mdclog_write(MDCLOG_DEBUG, "Deleted the Entry Successfully from map for %s", enbName); + break; + } + ++itr; + } +} /** * @@ -1503,8 +1556,8 @@ int receiveDataFromSctp(struct epoll_event *events, } else if (message.message.asnLength == 0) { /* End of file. The remote has closed the connection. */ if (loglevel >= MDCLOG_INFO) { - mdclog_write(MDCLOG_INFO, "END of File Closed connection - descriptor = %d", - message.peerInfo->fileDescriptor); + mdclog_write(MDCLOG_INFO, "END of File Closed connection - descriptor = %d and %s", + message.peerInfo->fileDescriptor, message.peerInfo->enodbName); } done = 1; break; @@ -1603,6 +1656,14 @@ int receiveDataFromSctp(struct epoll_event *events, "%s|CU disconnected unexpectedly", message.peerInfo->enodbName); message.message.asndata = rmrMessageBuffer.sendMessage->payload; + #ifndef UNIT_TEST + if (message.peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]) + { + mdclog_write(MDCLOG_DEBUG, "Incrementing SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + message.peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]->Increment(); + mdclog_write(MDCLOG_DEBUG, "Incremented SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + } + #endif #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, @@ -1611,6 +1672,8 @@ int receiveDataFromSctp(struct epoll_event *events, } #endif + mdclog_write(MDCLOG_DEBUG, "Erasing Entry from Map for Key %s", message.peerInfo->enodbName); + removeE2ConnectionEntryFromMap(message.peerInfo->enodbName); /* Closing descriptor make epoll remove it from the set of descriptors which are monitored. */ #ifndef UNIT_TEST pthread_mutex_lock(&thread_lock); @@ -1618,11 +1681,21 @@ int receiveDataFromSctp(struct epoll_event *events, mdclog_write(MDCLOG_DEBUG, "Closing connection - descriptor = %d", message.peerInfo->fileDescriptor); close(message.peerInfo->fileDescriptor); cleanHashEntry((ConnectedCU_t *) events->data.ptr, sctpMap); + if (events->data.ptr != nullptr) + { + mdclog_write(MDCLOG_DEBUG, "Not assigned events->data.ptr = NULL"); + events->data.ptr = nullptr; + } } pthread_mutex_unlock(&thread_lock); #else close(message.peerInfo->fileDescriptor); cleanHashEntry((ConnectedCU_t *) events->data.ptr, sctpMap); + if (events->data.ptr != nullptr) + { + mdclog_write(MDCLOG_DEBUG, "[SCTP_ABORT]: Not assigned events->data.ptr = NULL"); + events->data.ptr = nullptr; + } #endif } if (loglevel >= MDCLOG_DEBUG) { @@ -1633,7 +1706,7 @@ int receiveDataFromSctp(struct epoll_event *events, } return 0; } - +#ifndef UNIT_TEST static void buildAndSendSetupRequest(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, E2AP_PDU_t *pdu/*, @@ -1766,6 +1839,7 @@ static void buildAndSendSetupRequest(ReportingMessages_t &message, return; } +#endif #if 0 int RAN_Function_list_To_Vector(RANfunctions_List_t& list, vector &runFunXML_v) { @@ -2023,8 +2097,18 @@ void buildPrometheusList(ConnectedCU_t *peerInfo, Family *prometheusFam peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_RICsubscriptionDeleteRequired)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteRequired", "Messages"}}); peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_RICsubscriptionDeleteRequired)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteRequired", "Bytes"}}); + peerInfo->counters[IN_SUCC][MSG_COUNTER][(ProcedureCode_id_E2connectionUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"UnsupportedE2ConnectionUpdateAck", "Messages"}}); + peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_E2connectionUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"UnsupportedE2ConnectionUpdateFail", "Messages"}}); } +#ifndef UNIT_TEST +void buildInternalCounterPrometheusList(ConnectedCU_t *peerInfo, Family *prometheusFamily) +{ + mdclog_write(MDCLOG_DEBUG, "Inside buildInternalCounterPrometheusList"); + peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE] = &prometheusFamily->Add({{"NODEB", peerInfo->enodbName}, {"counter", "SctpAbortInitiatedByE2Node"}}); + peerInfo->e2tInternalCounters[E2T_Internal_Counters::INVALID_MESSAGE_RECEIVED] = &prometheusFamily->Add({{"NODEB", peerInfo->enodbName}, {"counter", "InvalidMessageReceived"}}); +} +#endif /** * * @param pdu @@ -2033,21 +2117,24 @@ void buildPrometheusList(ConnectedCU_t *peerInfo, Family *prometheusFam * @param RANfunctionsAdded_v * @return */ -int collectSetupRequestData(E2AP_PDU_t *pdu, - Sctp_Map_t *sctpMap, - ReportingMessages_t &message /*, vector &RANfunctionsAdded_v*/) { - memset(message.peerInfo->enodbName, 0 , MAX_ENODB_NAME_SIZE); - for (auto i = 0; i < pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count; i++) { +long collectSetupRequestData(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message /*, vector &RANfunctionsAdded_v*/) { + long transactionId = negativeOne; + memset(message.peerInfo->enodbName, numberZero , MAX_ENODB_NAME_SIZE); + for (auto i = numberZero; i < pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count; i++) { auto *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[i]; if (ie->id == ProtocolIE_ID_id_GlobalE2node_ID) { // get the ran name for meid if (ie->value.present == E2setupRequestIEs__value_PR_GlobalE2node_ID) { - if (buildRanName(message.peerInfo->enodbName, ie) < 0) { + mdclog_write(MDCLOG_DEBUG, "GnbId is present"); + #ifndef UNIT_TEST + if (buildRanName(message.peerInfo->enodbName, ie) < numberZero) { mdclog_write(MDCLOG_ERR, "Bad param in E2setupRequestIEs GlobalE2node_ID.\n"); // no message will be sent - return -1; + return negativeOne; } - + #endif memcpy(message.message.enodbName, message.peerInfo->enodbName, strlen(message.peerInfo->enodbName)); sctpMap->setkey(message.message.enodbName, message.peerInfo); } @@ -2062,12 +2149,20 @@ int collectSetupRequestData(E2AP_PDU_t *pdu, } } } */ + if (ie->id == ProtocolIE_ID_id_TransactionID) { + if (ie->value.present == E2setupRequestIEs__value_PR_TransactionID) { + mdclog_write(MDCLOG_DEBUG, "TransactionId is present in E2SetupReq"); + + transactionId = ie->value.choice.TransactionID; + mdclog_write(MDCLOG_DEBUG, "TransactionId is %ld", transactionId); + } + } } // if (mdclog_level_get() >= MDCLOG_DEBUG) { // mdclog_write(MDCLOG_DEBUG, "Run function vector have %ld entries", // RANfunctionsAdded_v.size()); // } - return 0; + return transactionId; } int XML_From_PER(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { @@ -2138,6 +2233,7 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, } switch (procedureCode) { case ProcedureCode_id_E2setup: { + if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got E2setup"); } @@ -2146,51 +2242,34 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, // vector RANfunctionsModified_v; // RANfunctionsAdded_v.clear(); // RANfunctionsModified_v.clear(); - if (collectSetupRequestData(pdu, sctpMap, message) != 0) { - break; - } - struct sctp_status status; - int stat_size = sizeof(status); - getsockopt( message.peerInfo->fileDescriptor, SOL_SCTP, SCTP_STATUS,(void *)&status, (socklen_t *)&stat_size ); - if (logLevel >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "Start from SCTP %d fd", message.peerInfo->fileDescriptor); - mdclog_write(MDCLOG_DEBUG, "SCTP status assoc id %d instrms %d outstrms %d", status.sstat_assoc_id, - status.sstat_instrms, status.sstat_outstrms); - } - if(status.sstat_outstrms == 1 || status.sstat_instrms == 1) + long transactionID = collectSetupRequestData(pdu, sctpMap, message); + mdclog_write(MDCLOG_DEBUG, "transactionID returned is %ld", transactionID); + + if (transactionID < numberZero) { - message.peerInfo->isSingleStream = true; - message.peerInfo->singleStreamId = streamId; - if (status.sstat_outstrms == 1 && status.sstat_instrms == 1){ - if (logLevel >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "Single SCTP stream is used for sending from now on, assoc id %d streamId %d #instrms %d #outstrms %d, %s",status.sstat_assoc_id, streamId, status.sstat_instrms, status.sstat_outstrms, __FUNCTION__); - } - } - else { - mdclog_write(MDCLOG_ERR, "Single SCTP stream used for sending messages even if there is a mismatch in number of in & out streams, assoc id %d instrms %d outstrms %d", status.sstat_assoc_id, - status.sstat_instrms, status.sstat_outstrms); - } + mdclog_write(MDCLOG_ERR, "Invalid TransactionID or GnbIb"); + break; } - buildPrometheusList(message.peerInfo, message.peerInfo->sctpParams->prometheusFamily); - - string messageName("E2setupRequest"); - string ieName("E2setupRequestIEs"); - message.message.messageType = RIC_E2_SETUP_REQ; - message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); - message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment((double)message.message.asnLength); - - // Update E2T instance level metrics - message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); - message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment((double)message.message.asnLength); - - buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); + mdclog_write(MDCLOG_DEBUG, "Calling handleE2SetupReq"); + handleE2SetupReq(message, rmrMessageBuffer, pdu, transactionID, streamId, sctpMap); break; } case ProcedureCode_id_RICserviceUpdate: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived) + { + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICserviceUpdate"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICserviceUpdate %s", message.message.enodbName); } + + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state is %d", message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); // vector RANfunctionsAdded_v; // vector RANfunctionsModified_v; // RANfunctionsAdded_v.clear(); @@ -2211,11 +2290,24 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment((double)message.message.asnLength); #endif + #ifndef UNIT_TEST buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); + #endif + + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state is %d", message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, RIC_SERVICE_UPDATE_PROCEDURE_ONGOING); break; } case ProcedureCode_id_E2nodeConfigurationUpdate: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived) + { + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received E2nodeConfigurationUpdate"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got E2nodeConfigurationUpdate %s", message.message.enodbName); } @@ -2230,29 +2322,111 @@ case ProcedureCode_id_E2nodeConfigurationUpdate: { // Update E2T instance level metrics message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment(); message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment((double)message.message.asnLength); -#endif + buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); +#endif break; } case ProcedureCode_id_ErrorIndication: { - if (logLevel >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "Got ErrorIndication %s", message.message.enodbName); + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received ErrorIndication"); + return ; } -#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + + asn_fprint(stdout, &asn_DEF_E2AP_PDU, pdu); + + mdclog_write(MDCLOG_INFO, "Got ErrorIndication %s sub id = %d, mtype = %d", message.message.enodbName, + rmrMessageBuffer.sendMessage->sub_id, rmrMessageBuffer.sendMessage->mtype); + + int procedureCode = numberZero; + bitset isRequiredIesPresent(0); // TransactionId==0, RicRequestId==1, Cause==2 + + for (auto i = numberZero; i < pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count; i++) { + ErrorIndication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[i]; + if (ie->id == ProtocolIE_ID_id_TransactionID) { + if (ie->value.present == ErrorIndication_IEs__value_PR_TransactionID) { + mdclog_write(MDCLOG_DEBUG, "TransactionID in ErrorIndication Message is %ld ", ie->value.choice.TransactionID); + if (e2NodeConnectionHandling.e2SetupProcedureTransactionId == ie->value.choice.TransactionID) + { + isRequiredIesPresent.set(transactionIdIeBitSetPosition); + } + } + } + if (ie->id == ProtocolIE_ID_id_RICrequestID) { + if (ie->value.present == ErrorIndication_IEs__value_PR_RICrequestID) { + isRequiredIesPresent.set(ricRequestIdIeBitSetPosition); + mdclog_write(MDCLOG_DEBUG, "RIC instance id %ld, RIC requestor id = %ld", + ie->value.choice.RICrequestID.ricInstanceID, + ie->value.choice.RICrequestID.ricRequestorID); + } + } + if (ie->id == ProtocolIE_ID_id_Cause) { + if (ie->value.present == ErrorIndication_IEs__value_PR_Cause) { + isRequiredIesPresent.set(causeIeBitSetPosition); + } + } + if (ie->id == ProtocolIE_ID_id_CriticalityDiagnostics) { + if (ie->value.present == ErrorIndication_IEs__value_PR_CriticalityDiagnostics) { + if (ie->value.choice.CriticalityDiagnostics.procedureCode) + { + procedureCode = *(ie->value.choice.CriticalityDiagnostics.procedureCode); + mdclog_write(MDCLOG_DEBUG, "ProcedureCode Value is %ld", procedureCode); + } + } + } + } + + // Msg being sent to E2M = 0, Msg being sent to SubMgr = 1 + bitset sendMsgTo = getSendMsgBitSetValue(procedureCode, isRequiredIesPresent, message.message.enodbName); + + if(sendMsgTo.test(sendMsgToE2MBitSetPosition)) + { + message.message.messageType = RIC_E2_RIC_ERROR_INDICATION; + mdclog_write(MDCLOG_INFO, "Sending ErrorIndication Message to E2Manager"); + #ifndef UNIT_TEST + buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); + #endif + } + else if (sendMsgTo.test(sendMsgToSubMgrBitSetPosition)) + { + if (sendRequestToXapp(message, RIC_E2_RAN_ERROR_INDICATION, rmrMessageBuffer) != 0) { + mdclog_write(MDCLOG_ERR, "Subscription successful message failed to send to SubMgr"); + } + else { + mdclog_write(MDCLOG_INFO, "Successfully Sent ErrorIndication Message to SubMgr"); + } + } + else + { + mdclog_write(MDCLOG_INFO, "No action taken on ErrorIndication Message as TransactionId/Ric RequestID/Cause not present/invalid"); + } + + #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment((double)message.message.asnLength); // Update E2T instance level metrics message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(); message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment((double)message.message.asnLength); -#endif + #endif + + /*Not to break below functionality which is used to send to Xapp*/ if (sendRequestToXapp(message, RIC_ERROR_INDICATION, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "RIC_ERROR_INDICATION failed to send to xAPP"); } break; } case ProcedureCode_id_Reset: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received Reset"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got Reset %s", message.message.enodbName); } @@ -2264,20 +2438,31 @@ case ProcedureCode_id_E2nodeConfigurationUpdate: { message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment((double)message.message.asnLength); #endif - if (XML_From_PER(message, rmrMessageBuffer) < 0) { + if (XML_From_PER(message, rmrMessageBuffer) < numberZero) { break; } - if (sendRequestToXapp(message, RIC_E2_RESET_REQ, rmrMessageBuffer) != 0) { + if (sendRequestToXapp(message, RIC_E2_RESET_REQ, rmrMessageBuffer) != numberZero) { mdclog_write(MDCLOG_ERR, "RIC_E2_RESET_REQ message failed to send to xAPP"); } break; } case ProcedureCode_id_RICindication: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICIndication"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICindication %s", message.message.enodbName); } - for (auto i = 0; i < pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count; i++) { + + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure State is %d", message.message.enodbName, RIC_INDICATION_PROCEDURE_ONGOING); + setE2ProcedureOngoingStatus(message.message.enodbName, RIC_INDICATION_PROCEDURE_ONGOING); + + for (auto i = numberZero; i < pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count; i++) { auto messageSent = false; RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[i]; if (logLevel >= MDCLOG_DEBUG) { @@ -2295,7 +2480,7 @@ case ProcedureCode_id_E2nodeConfigurationUpdate: { rmr_bytes2meid(rmrMessageBuffer.sendMessage, (unsigned char *)message.message.enodbName, strlen(message.message.enodbName)); - rmrMessageBuffer.sendMessage->state = 0; + rmrMessageBuffer.sendMessage->state = numberZero; rmrMessageBuffer.sendMessage->sub_id = (int)ie->value.choice.RICrequestID.ricInstanceID; //ie->value.choice.RICrequestID.ricInstanceID; @@ -2321,12 +2506,22 @@ case ProcedureCode_id_E2nodeConfigurationUpdate: { } } if (messageSent) { + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure State is %d", message.message.enodbName, RIC_INDICATION_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, RIC_INDICATION_PROCEDURE_COMPLETED); break; } } break; } case ProcedureCode_id_RICsubscriptionDeleteRequired: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + mdclog_write(MDCLOG_ERR, "Undefined or not supported message = %ld", procedureCode); + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring Unsupported Message with procedureCode = %ld", procedureCode); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscriptionDeleteRequired %s", message.message.enodbName); } @@ -2345,8 +2540,25 @@ case ProcedureCode_id_E2nodeConfigurationUpdate: { } default: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; mdclog_write(MDCLOG_ERR, "Undefined or not supported message = %ld", procedureCode); - message.message.messageType = 0; // no RMR message type yet + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring Unsupported Message with procedureCode = %ld", procedureCode); + return ; + } + message.message.messageType = numberZero; // no RMR message type yet + mdclog_write(MDCLOG_ERR, "Invalid Message Received at E2T"); + mdclog_write(MDCLOG_ERR, "Counter Incrementing for Invalid Message"); + #ifndef UNIT_TEST + if (message.peerInfo->e2tInternalCounters[E2T_Internal_Counters::INVALID_MESSAGE_RECEIVED]) + { + mdclog_write(MDCLOG_DEBUG, "Incrementing INVALID_MESSAGE_RECEIVED Counter"); + message.peerInfo->e2tInternalCounters[E2T_Internal_Counters::INVALID_MESSAGE_RECEIVED]->Increment(); + mdclog_write(MDCLOG_DEBUG, "Incremented INVALID_MESSAGE_RECEIVED Counter"); + } + #endif buildJsonMessage(message); @@ -2372,6 +2584,14 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, } switch (procedureCode) { case ProcedureCode_id_Reset: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived) + { + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received Reset message"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got Reset %s", message.message.enodbName); } @@ -2383,7 +2603,7 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, message.peerInfo->sctpParams->e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->sctpParams->e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment((double)message.message.asnLength); #endif - if (XML_From_PER(message, rmrMessageBuffer) < 0) { + if (XML_From_PER(message, rmrMessageBuffer) < numberZero) { break; } if (sendRequestToXapp(message, RIC_E2_RESET_RESP, rmrMessageBuffer) != 0) { @@ -2392,10 +2612,17 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, break; } case ProcedureCode_id_RICcontrol: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICcontrol"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICcontrol %s", message.message.enodbName); } - for (auto i = 0; + for (auto i = numberZero; i < pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count; i++) { auto messageSent = false; RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[i]; @@ -2408,7 +2635,7 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, } if (ie->value.present == RICcontrolAcknowledge_IEs__value_PR_RICrequestID) { message.message.messageType = rmrMessageBuffer.sendMessage->mtype = RIC_CONTROL_ACK; - rmrMessageBuffer.sendMessage->state = 0; + rmrMessageBuffer.sendMessage->state = numberZero; // rmrMessageBuffer.sendMessage->sub_id = (int) ie->value.choice.RICrequestID.ricRequestorID; rmrMessageBuffer.sendMessage->sub_id = (int)ie->value.choice.RICrequestID.ricInstanceID; @@ -2433,6 +2660,8 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, } } if (messageSent) { + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure State is %d", message.message.enodbName, CONTROL_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, CONTROL_PROCEDURE_COMPLETED); break; } } @@ -2440,6 +2669,13 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, break; } case ProcedureCode_id_RICsubscription: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICsubscription"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscription %s", message.message.enodbName); } @@ -2451,15 +2687,27 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, message.peerInfo->sctpParams->e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->sctpParams->e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment((double)message.message.asnLength); #endif - if (sendRequestToXapp(message, RIC_SUB_RESP, rmrMessageBuffer) != 0) { + if (sendRequestToXapp(message, RIC_SUB_RESP, rmrMessageBuffer) != numberZero) { mdclog_write(MDCLOG_ERR, "Subscription successful message failed to send to xAPP"); } + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure State is %d", message.message.enodbName, RIC_INDICATION_PROCEDURE_ONGOING); + setE2ProcedureOngoingStatus(message.message.enodbName, RIC_INDICATION_PROCEDURE_ONGOING); break; } case ProcedureCode_id_RICsubscriptionDelete: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICsubscriptionDelete"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscriptionDelete %s", message.message.enodbName); } + + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state is %d", message.message.enodbName, RIC_SUBS_DEL_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, RIC_SUBS_DEL_PROCEDURE_COMPLETED); #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment((double)message.message.asnLength); @@ -2468,14 +2716,44 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, message.peerInfo->sctpParams->e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); message.peerInfo->sctpParams->e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment((double)message.message.asnLength); #endif - if (sendRequestToXapp(message, RIC_SUB_DEL_RESP, rmrMessageBuffer) != 0) { + if (sendRequestToXapp(message, RIC_SUB_DEL_RESP, rmrMessageBuffer) != numberZero) { mdclog_write(MDCLOG_ERR, "Subscription delete successful message failed to send to xAPP"); } + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure State is %d", message.message.enodbName, RIC_INDICATION_PROCEDURE_ONGOING); + setE2ProcedureOngoingStatus(message.message.enodbName, RIC_INDICATION_PROCEDURE_ONGOING); break; } default: { - mdclog_write(MDCLOG_WARN, "Undefined or not supported message = %ld", procedureCode); - message.message.messageType = 0; // no RMR message type yet + struct E2NodeConnectionHandling e2NodeConnectionHandling; + mdclog_write(MDCLOG_ERR, "Undefined or not supported message = %ld", procedureCode); + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring Unsupported Message with procedureCode = %ld", procedureCode); + return ; + } + message.message.messageType = numberZero; // no RMR message type yet + if (procedureCode == ProcedureCode_id_E2connectionUpdate) + { + mdclog_write(MDCLOG_ERR, "Unsupported message E2Connection Update Ack Received at E2T, procedureCode = %ld", procedureCode); + + mdclog_write(MDCLOG_ERR, "Counter Incrementing for Unsupported E2Connection Update Ack Message"); + #ifndef UNIT_TEST + message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_E2connectionUpdate]->Increment(); + #endif + } + else { + mdclog_write(MDCLOG_ERR, "Invalid Message Received at E2T"); + mdclog_write(MDCLOG_ERR, "Counter Incrementing for Invalid Message"); + #ifndef UNIT_TEST + if (message.peerInfo->e2tInternalCounters[E2T_Internal_Counters::INVALID_MESSAGE_RECEIVED]) + { + mdclog_write(MDCLOG_DEBUG, "Incrementing INVALID_MESSAGE_RECEIVED Counter"); + message.peerInfo->e2tInternalCounters[E2T_Internal_Counters::INVALID_MESSAGE_RECEIVED]->Increment(); + mdclog_write(MDCLOG_DEBUG, "Incremented INVALID_MESSAGE_RECEIVED Counter"); + } + #endif + } buildJsonMessage(message); break; @@ -2500,6 +2778,14 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, } switch (procedureCode) { case ProcedureCode_id_RICcontrol: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived) + { + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICcontrol"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICcontrol %s", message.message.enodbName); } @@ -2545,6 +2831,13 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, break; } case ProcedureCode_id_RICsubscription: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICsubscription"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscription %s", message.message.enodbName); } @@ -2562,6 +2855,13 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, break; } case ProcedureCode_id_RICsubscriptionDelete: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICsubscriptionDelete"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscriptionDelete %s", message.message.enodbName); } @@ -2579,16 +2879,299 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, break; } default: { - mdclog_write(MDCLOG_WARN, "Undefined or not supported message = %ld", procedureCode); - message.message.messageType = 0; // no RMR message type yet -#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + struct E2NodeConnectionHandling e2NodeConnectionHandling; + mdclog_write(MDCLOG_ERR, "Undefined or not supported message = %ld", procedureCode); + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring Unsupported Message with procedureCode = %ld", procedureCode); + return ; + } + + message.message.messageType = numberZero; // no RMR message type yet + if (procedureCode == ProcedureCode_id_E2connectionUpdate) + { + mdclog_write(MDCLOG_ERR, "Unsupported message E2Connection Update Failure Received at E2T, procedureCode = %ld", procedureCode); + + mdclog_write(MDCLOG_ERR, "Counter Incrementing for Unsupported E2Connection Update Failure Message"); + #ifndef UNIT_TEST + message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2connectionUpdate]->Increment(); + #endif + } + else { + mdclog_write(MDCLOG_ERR, "Invalid Message Received at E2T"); + mdclog_write(MDCLOG_ERR, "Counter Incrementing for Invalid Message"); + #ifndef UNIT_TEST + if (message.peerInfo->e2tInternalCounters[E2T_Internal_Counters::INVALID_MESSAGE_RECEIVED]) + { + mdclog_write(MDCLOG_DEBUG, "Incrementing INVALID_MESSAGE_RECEIVED Counter"); + message.peerInfo->e2tInternalCounters[E2T_Internal_Counters::INVALID_MESSAGE_RECEIVED]->Increment(); + mdclog_write(MDCLOG_DEBUG, "Incremented INVALID_MESSAGE_RECEIVED Counter"); + } + #endif + } buildJsonMessage(message); -#endif break; } } } +bool getE2tProcedureOngoingStatus(char *enbName, E2NodeConnectionHandling &e2NodeConnectionHandling) +{ + mdclog_write(MDCLOG_DEBUG, "Inside getE2tProcedureOngoingStatus, Checking for enb %s", enbName); + if(strcmp(enbName, "") == 0) + { + mdclog_write(MDCLOG_DEBUG, "enbName is empty"); + return false; + } + else if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return false; + } + else + { + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + while (itr != connectionHandlingPerE2NodeMap.end()) + { + int result = itr->first.compare(enbName); + if (result == 0) + { + mdclog_write(MDCLOG_DEBUG, "enb name in map :%s, status :%d", itr->first.c_str(), itr->second.e2tProcedureOngoingStatus); + e2NodeConnectionHandling = itr->second; + return true; + break; + } + ++itr; + } + } + return false; +} + +void setE2ProcedureOngoingStatus(char *enbName, E2T_Procedure_States state) +{ + printEntryPresentInMap(); + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return; + } + else + { + mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map"); + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + while(itr != connectionHandlingPerE2NodeMap.end()) + { + int result = itr->first.compare(enbName); + if (result == 0) + { + mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus); + itr->second.e2tProcedureOngoingStatus = state; + mdclog_write(MDCLOG_DEBUG, "Current procedure updated to %d", itr->second.e2tProcedureOngoingStatus); + break; + } + ++itr; + } + } +} + +void insertE2SetupProcedureOngoing(char *enbName, long &transactionID) +{ + struct E2NodeConnectionHandling e2NodeConnectionHandling; + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_ONGOING; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = transactionID; + + std::string key(enbName); + printEntryPresentInMap(); + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + mdclog_write(MDCLOG_DEBUG, "Inserting %s to connectionHandlingPerE2NodeMap Map", enbName); + + connectionHandlingPerE2NodeMap.insert(std::make_pair(key, e2NodeConnectionHandling)); + + mdclog_write(MDCLOG_DEBUG, "Default Value after Inserting Key for %s - Value is {e2tProcedureOngoingStatus is %d, e2SetupProcedureTransactionId: %ld}", + key.c_str(), + e2NodeConnectionHandling.e2tProcedureOngoingStatus, + e2NodeConnectionHandling.e2SetupProcedureTransactionId); + return; + } + else + { + mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map"); + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + bool enodebNameFound = false; + while(itr != connectionHandlingPerE2NodeMap.end()) + { + int result = itr->first.compare(enbName); + if (result == 0) + { + enodebNameFound = true; + break; + } + ++itr; + } + if (enodebNameFound == false) + { + mdclog_write(MDCLOG_DEBUG, "Inserting %s to connectionHandlingPerE2NodeMap Map", enbName); + connectionHandlingPerE2NodeMap.insert(std::make_pair(key, e2NodeConnectionHandling)); + + mdclog_write(MDCLOG_DEBUG, "Default Value after Inserting Key for %s - Value is {e2tProcedureOngoingStatus is %d, e2SetupProcedureTransactionId: %ld}", + key.c_str(), + e2NodeConnectionHandling.e2tProcedureOngoingStatus, + e2NodeConnectionHandling.e2SetupProcedureTransactionId); + } + else + { + mdclog_write(MDCLOG_DEBUG, "Processing E2Setup Req received for same gnb - %s", enbName); + setE2ProcedureOngoingStatus(enbName, E2_SETUP_PROCEDURE_ONGOING); + } + } +} + +E2T_Procedure_States currentE2tProcedureOngoingStatus(char *enbName) +{ + printEntryPresentInMap(); + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return E2_SETUP_PROCEDURE_NOT_INITIATED; + } + else + { + mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map"); + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + while(itr != connectionHandlingPerE2NodeMap.end()) + { + int result = itr->first.compare(enbName); + if (result == 0) + { + mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus); + mdclog_write(MDCLOG_DEBUG, "%s Entry has found", enbName); + return itr->second.e2tProcedureOngoingStatus; + } + ++itr; + } + mdclog_write(MDCLOG_DEBUG, "No Key %s Found in connectionHandlingPerE2NodeMap Map", enbName); + return E2_SETUP_PROCEDURE_NOT_INITIATED; + } +} + +bitset getSendMsgBitSetValue(int procedureCode, bitset isRequiredIesPresent, char* enbName) +{ + bitset sendMsgTo(0); // Msg being sent to E2M = 0, Msg being sent to SubMgr = 1 + switch(procedureCode) + { + case numberZero: + { + E2T_Procedure_States currentProcedureOngoing = currentE2tProcedureOngoingStatus(enbName); + if ((currentProcedureOngoing == E2_SETUP_PROCEDURE_COMPLETED || + currentProcedureOngoing == RIC_SERVICE_UPDATE_PROCEDURE_ONGOING) && + (isRequiredIesPresent.test(transactionIdIeBitSetPosition))) + { + sendMsgTo.set(sendMsgToE2MBitSetPosition); + } + else if ((currentProcedureOngoing == RIC_SUBS_PROCEDURE_ONGOING) && + isRequiredIesPresent.test(ricRequestIdIeBitSetPosition) && isRequiredIesPresent.test(causeIeBitSetPosition)) + { + sendMsgTo.set(sendMsgToSubMgrBitSetPosition); + } + break; + } + case ProcedureCode_id_E2setup: + case ProcedureCode_id_RICserviceUpdate: + { + if(isRequiredIesPresent.test(transactionIdIeBitSetPosition)) + { + sendMsgTo.set(sendMsgToE2MBitSetPosition); + } + break; + + } + case ProcedureCode_id_RICsubscription: + { + if(isRequiredIesPresent.test(ricRequestIdIeBitSetPosition) && isRequiredIesPresent.test(causeIeBitSetPosition)) + { + sendMsgTo.set(sendMsgToSubMgrBitSetPosition); + } + break; + } + default: + { + mdclog_write(MDCLOG_ERR, "Invalid procedure code received"); + } + } + return sendMsgTo; +} + +void printEntryPresentInMap() +{ + mdclog_write(MDCLOG_DEBUG, "Inside printEntryPresentInMap"); + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return; + } + else + { + mdclog_write(MDCLOG_DEBUG, "Entry Present in Map"); + std::map::iterator it = connectionHandlingPerE2NodeMap.begin(); + while (it != connectionHandlingPerE2NodeMap.end()) + { + mdclog_write(MDCLOG_DEBUG, "Key -> { enb name in map : %s }, Value -> { e2tProcedureOngoingStatus is %d, e2SetupProcedureTransactionId is %ld }", it->first.c_str(), it->second.e2tProcedureOngoingStatus, it->second.e2SetupProcedureTransactionId); + ++it; + } + mdclog_write(MDCLOG_DEBUG, "All entries currently present in connectionHandlingPerE2NodeMap are printed successfully"); + } +} + +void handleE2SetupReq(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, E2AP_PDU_t *pdu, long &transactionID, int streamId, Sctp_Map_t *sctpMap) +{ + auto logLevel = mdclog_level_get(); + + #ifndef UNIT_TEST + buildPrometheusList(message.peerInfo, message.peerInfo->sctpParams->prometheusFamily); + buildInternalCounterPrometheusList(message.peerInfo, message.peerInfo->sctpParams->prometheusFamily); + #endif + + struct sctp_status status; + int stat_size = sizeof(status); + getsockopt( message.peerInfo->fileDescriptor, SOL_SCTP, SCTP_STATUS,(void *)&status, (socklen_t *)&stat_size ); + + if (logLevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "Start from SCTP %d fd", message.peerInfo->fileDescriptor); + mdclog_write(MDCLOG_DEBUG, "SCTP status assoc id %d instrms %d outstrms %d", status.sstat_assoc_id, + status.sstat_instrms, status.sstat_outstrms); + } + if(status.sstat_outstrms == numberOne || status.sstat_instrms == numberOne) + { + message.peerInfo->isSingleStream = true; + message.peerInfo->singleStreamId = streamId; + if (status.sstat_outstrms == numberOne && status.sstat_instrms == numberOne){ + if (logLevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "Single SCTP stream is used for sending from now on, assoc id %d streamId %d #instrms %d #outstrms %d, %s",status.sstat_assoc_id, streamId, status.sstat_instrms, status.sstat_outstrms, __FUNCTION__); + } + } + else { + mdclog_write(MDCLOG_ERR, "Single SCTP stream used for sending messages even if there is a mismatch in number of in & out streams, assoc id %d instrms %d outstrms %d", status.sstat_assoc_id, + status.sstat_instrms, status.sstat_outstrms); + } + } + + string messageName("E2setupRequest"); + string ieName("E2setupRequestIEs"); + message.message.messageType = RIC_E2_SETUP_REQ; + #ifndef UNIT_TEST + message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); + message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment((double)message.message.asnLength); + + buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); //UT - Segmentation Fault Happening. + #endif + + mdclog_write(MDCLOG_DEBUG, "Called insertE2ProcedureOngoing: EnbName is %s and transactionID is %ld", message.message.enodbName, transactionID); + insertE2SetupProcedureOngoing(message.message.enodbName, transactionID); +} + /** * * @param message @@ -2603,7 +3186,7 @@ int sendRequestToXapp(ReportingMessages_t &message, (unsigned char *)message.message.enodbName, strlen(message.message.enodbName)); message.message.messageType = rmrMmessageBuffer.sendMessage->mtype = requestId; - rmrMmessageBuffer.sendMessage->state = 0; + rmrMmessageBuffer.sendMessage->state = numberZero; static unsigned char tx[32]; snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++); rmr_bytes2xact(rmrMmessageBuffer.sendMessage, tx, strlen((const char *) tx)); @@ -2624,6 +3207,7 @@ void getRmrContext(sctp_params_t &pSctpParams) { return; } + rmr_set_low_latency(pSctpParams.rmrCtx); rmr_set_stimeout(pSctpParams.rmrCtx, 0); // disable retries for any send operation // we need to find that routing table exist and we can run if (mdclog_level_get() >= MDCLOG_INFO) { @@ -2738,7 +3322,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (rmrMessageBuffer.rcvMessage == nullptr) { //we have error mdclog_write(MDCLOG_ERR, "RMR Allocation message, %s", strerror(errno)); - return -1; + return negativeOne; } // if (loglevel >= MDCLOG_DEBUG) { @@ -2760,9 +3344,9 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #ifdef UNIT_TEST rmrMessageBuffer.rcvMessage->state = 0; #endif - if (rmrMessageBuffer.rcvMessage->state != 0) { + if (rmrMessageBuffer.rcvMessage->state != numberZero) { mdclog_write(MDCLOG_ERR, "RMR Receiving message with stat = %d", rmrMessageBuffer.rcvMessage->state); - return -1; + return negativeOne; } rmr_get_meid(rmrMessageBuffer.rcvMessage, (unsigned char *)message.message.enodbName); message.peerInfo = (ConnectedCU_t *) sctpMap->find(message.message.enodbName); @@ -2778,12 +3362,12 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; #endif mdclog_write(MDCLOG_ERR, "Failed to send message no CU entry %s", message.message.enodbName); - return -1; + return negativeOne; } } if (rmrMessageBuffer.rcvMessage->mtype != RIC_HEALTH_CHECK_REQ) { - num_of_XAPP_messages.fetch_add(1, std::memory_order_release); + num_of_XAPP_messages.fetch_add(numberOne, std::memory_order_release); } switch (rmrMessageBuffer.rcvMessage->mtype) { @@ -2791,7 +3375,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_E2_SETUP_RESP"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) @@ -2802,17 +3386,19 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_SETUP_RESP"); - return -6; + return negativeSix; } + mdclog_write(MDCLOG_DEBUG, "Successfully Sent E2_SETUP_RESP to E2Node"); + setE2ProcedureOngoingStatus(message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); break; } case RIC_E2_SETUP_FAILURE : { if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_E2_SETUP_FAILURE"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) @@ -2823,10 +3409,13 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); message.peerInfo->sctpParams->e2tCounters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_SETUP_FAILURE"); - return -6; + return negativeSix; } + + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure State is %d", message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); break; } @@ -2834,7 +3423,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_E2NODE_CONFIG_UPDATE_ACK"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) @@ -2845,7 +3434,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment(); message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2NODE_CONFIG_UPDATE_ACK"); return -6; } @@ -2856,7 +3445,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_E2NODE_CONFIG_UPDATE_FAILURE"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) @@ -2867,7 +3456,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment(); message.peerInfo->sctpParams->e2tCounters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2NODE_CONFIG_UPDATE_FAILURE"); return -6; } @@ -2886,9 +3475,9 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(); message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_ERROR_INDICATION"); - return -6; + return negativeSix; } break; } @@ -2896,6 +3485,9 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_SUB_REQ"); } + + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state is %d", message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment(rmrMessageBuffer.rcvMessage->len); @@ -2904,16 +3496,21 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->sctpParams->e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SUB_REQ"); - return -6; + return negativeSix; } + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state", message.message.enodbName); + setE2ProcedureOngoingStatus(message.message.enodbName, RIC_SUBS_PROCEDURE_ONGOING); break; } case RIC_SUB_DEL_REQ: { if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_SUB_DEL_REQ"); } + + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state is %d", message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(rmrMessageBuffer.rcvMessage->len); @@ -2922,16 +3519,20 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); message.peerInfo->sctpParams->e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SUB_DEL_REQ"); - return -6; + return negativeSix; } + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure State is %d", message.message.enodbName, RIC_SUBS_DEL_PROCEDURE_ONGOING); + setE2ProcedureOngoingStatus(message.message.enodbName, RIC_SUBS_DEL_PROCEDURE_ONGOING); break; } case RIC_CONTROL_REQ: { if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_CONTROL_REQ"); } + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state is %d", message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment(rmrMessageBuffer.rcvMessage->len); @@ -2940,17 +3541,19 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); message.peerInfo->sctpParams->e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_CONTROL_REQ"); - return -6; + return negativeSix; } + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Proedure State is %d", message.message.enodbName, CONTROL_PROCEDURE_ONGOING); + setE2ProcedureOngoingStatus(message.message.enodbName, CONTROL_PROCEDURE_ONGOING); break; } case RIC_SERVICE_QUERY: { if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_SERVICE_QUERY"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) @@ -2961,17 +3564,19 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceQuery]->Increment(); message.peerInfo->sctpParams->e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SERVICE_QUERY"); - return -6; + return negativeSix; } + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state is %d", message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, RIC_SERVICE_UPDATE_PROCEDURE_ONGOING); break; } case RIC_SERVICE_UPDATE_ACK: { if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_SERVICE_UPDATE_ACK"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { mdclog_write(MDCLOG_ERR, "error in PER_FromXML"); break; } @@ -2986,9 +3591,9 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Before sending to CU"); } - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SERVICE_UPDATE_ACK"); - return -6; + return negativeSix; } break; } @@ -2996,7 +3601,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_SERVICE_UPDATE_FAILURE"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) @@ -3007,9 +3612,9 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); message.peerInfo->sctpParams->e2tCounters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SERVICE_UPDATE_FAILURE"); - return -6; + return negativeSix; } break; } @@ -3017,7 +3622,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_E2_RESET_REQ"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) @@ -3038,7 +3643,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_E2_RESET_RESP"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) @@ -3049,7 +3654,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment(rmrMessageBuffer.rcvMessage->len); #endif - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_RESET_RESP"); return -6; } @@ -3079,7 +3684,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, peerInfo->enodbName); message.message.asndata = rmrMessageBuffer.sendMessage->payload; mdclog_write(MDCLOG_INFO, "%s", message.message.asndata); - if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != 0) { + if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != numberZero) { mdclog_write(MDCLOG_ERR, "SCTP_CONNECTION_FAIL message failed to send to xAPP"); } free(peerInfo); @@ -3097,7 +3702,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, (unsigned char *)rmrMessageBuffer.ka_message, rmrMessageBuffer.ka_message_len); rmrMessageBuffer.sendMessage->mtype = E2_TERM_KEEP_ALIVE_RESP; - rmrMessageBuffer.sendMessage->state = 0; + rmrMessageBuffer.sendMessage->state = numberZero; static unsigned char tx[32]; auto txLen = snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++); rmr_bytes2xact(rmrMessageBuffer.sendMessage, tx, txLen); @@ -3107,7 +3712,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (rmrMessageBuffer.sendMessage == nullptr) { rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); mdclog_write(MDCLOG_ERR, "Failed to send E2_TERM_KEEP_ALIVE_RESP RMR message returned NULL"); - } else if (rmrMessageBuffer.sendMessage->state != 0) { + } else if (rmrMessageBuffer.sendMessage->state != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send E2_TERM_KEEP_ALIVE_RESP, on RMR state = %d ( %s)", rmrMessageBuffer.sendMessage->state, translateRmrErrorMessages(rmrMessageBuffer.sendMessage->state).c_str()); } else if (loglevel >= MDCLOG_DEBUG) { @@ -3117,13 +3722,13 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_HEALTH_CHECK_REQ: { - static int counter = 0; + static int counter = numberZero; // send message back rmr_bytes2payload(rmrMessageBuffer.rcvMessage, (unsigned char *)"OK", - 2); + numberTwo); rmrMessageBuffer.rcvMessage->mtype = RIC_HEALTH_CHECK_RESP; - rmrMessageBuffer.rcvMessage->state = 0; + rmrMessageBuffer.rcvMessage->state = numberZero; static unsigned char tx[32]; auto txLen = snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++); rmr_bytes2xact(rmrMessageBuffer.rcvMessage, tx, txLen); @@ -3132,10 +3737,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (rmrMessageBuffer.rcvMessage == nullptr) { rmrMessageBuffer.rcvMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); mdclog_write(MDCLOG_ERR, "Failed to send RIC_HEALTH_CHECK_RESP RMR message returned NULL"); - } else if (rmrMessageBuffer.rcvMessage->state != 0) { + } else if (rmrMessageBuffer.rcvMessage->state != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_HEALTH_CHECK_RESP, on RMR state = %d ( %s)", rmrMessageBuffer.rcvMessage->state, translateRmrErrorMessages(rmrMessageBuffer.rcvMessage->state).c_str()); - } else if (loglevel >= MDCLOG_DEBUG && (++counter % 100 == 0)) { + } else if (loglevel >= MDCLOG_DEBUG && (++counter % 100 == numberZero)) { mdclog_write(MDCLOG_DEBUG, "Got %d RIC_HEALTH_CHECK_REQ Request send : OK", counter); } @@ -3143,7 +3748,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, } default: - mdclog_write(MDCLOG_WARN, "Message Type : %d is not supported", rmrMessageBuffer.rcvMessage->mtype); + mdclog_write(MDCLOG_ERR, "Message Type : %d is not supported", rmrMessageBuffer.rcvMessage->mtype); message.message.asndata = rmrMessageBuffer.rcvMessage->payload; message.message.asnLength = rmrMessageBuffer.rcvMessage->len; message.message.time.tv_nsec = ts.tv_nsec; @@ -3153,12 +3758,12 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, buildJsonMessage(message); - return -7; + return negativeSeven; } if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "EXIT OK from %s", __FUNCTION__); } - return 0; + return numberZero; } /** @@ -3200,6 +3805,7 @@ int sendMessagetoCu(Sctp_Map_t *sctpMap, int failedMesgId) { // get the FD message.message.messageType = messageBuffer.rcvMessage->mtype; + mdclog_write(MDCLOG_DEBUG, "message.message.messageType is %d", message.message.messageType); auto rc = sendSctpMsg(message.peerInfo, message, sctpMap); return rc; } @@ -3225,7 +3831,7 @@ int addToEpoll(int epoll_fd, struct epoll_event event{}; event.data.ptr = peerInfo; event.events = events; - if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, peerInfo->fileDescriptor, &event) < 0) { + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, peerInfo->fileDescriptor, &event) < numberZero) { #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "epoll_ctl EPOLL_CTL_ADD (may check not to quit here), %s, %s %d", @@ -3233,9 +3839,16 @@ int addToEpoll(int epoll_fd, } close(peerInfo->fileDescriptor); if (enodbName != nullptr) { + mdclog_write(MDCLOG_DEBUG, "Erasing Entry from Map for Key %s", enodbName); + removeE2ConnectionEntryFromMap(enodbName); cleanHashEntry(peerInfo, sctpMap); - char key[MAX_ENODB_NAME_SIZE * 2]; - snprintf(key, MAX_ENODB_NAME_SIZE * 2, "msg:%s|%d", enodbName, msgType); + if (peerInfo != nullptr) + { + mdclog_write(MDCLOG_DEBUG, "Not assigned peerInfo = NULL"); + peerInfo = nullptr; + } + char key[MAX_ENODB_NAME_SIZE * numberTwo]; + snprintf(key, MAX_ENODB_NAME_SIZE * numberTwo, "msg:%s|%d", enodbName, msgType); if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "remove key = %s from %s at line %d", key, __FUNCTION__, __LINE__); } @@ -3246,13 +3859,13 @@ int addToEpoll(int epoll_fd, sctpMap->erase(key); } } else { - peerInfo->enodbName[0] = 0; + peerInfo->enodbName[numberZero] = numberZero; } mdclog_write(MDCLOG_ERR, "epoll_ctl EPOLL_CTL_ADD (may check not to quit here)"); - return -1; + return negativeOne; #endif } - return 0; + return numberZero; } /** @@ -3275,15 +3888,22 @@ int modifyToEpoll(int epoll_fd, struct epoll_event event{}; event.data.ptr = peerInfo; event.events = events; - if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, peerInfo->fileDescriptor, &event) < 0) { + if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, peerInfo->fileDescriptor, &event) < numberZero) { if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "epoll_ctl EPOLL_CTL_MOD (may check not to quit here), %s, %s %d", strerror(errno), __func__, __LINE__); } close(peerInfo->fileDescriptor); + mdclog_write(MDCLOG_DEBUG, "Erasing Entry from Map for Key %s", enodbName); + removeE2ConnectionEntryFromMap(enodbName); cleanHashEntry(peerInfo, sctpMap); - char key[MAX_ENODB_NAME_SIZE * 2]; - snprintf(key, MAX_ENODB_NAME_SIZE * 2, "msg:%s|%d", enodbName, msgType); + if (peerInfo != nullptr) + { + mdclog_write(MDCLOG_DEBUG, "Not assigned peerInfo = NULL"); + peerInfo = nullptr; + } + char key[MAX_ENODB_NAME_SIZE * numberTwo]; + snprintf(key, MAX_ENODB_NAME_SIZE * numberTwo, "msg:%s|%d", enodbName, msgType); if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "remove key = %s from %s at line %d", key, __FUNCTION__, __LINE__); } @@ -3294,9 +3914,9 @@ int modifyToEpoll(int epoll_fd, sctpMap->erase(key); } mdclog_write(MDCLOG_ERR, "epoll_ctl EPOLL_CTL_ADD (may check not to quit here)"); - return -1; + return negativeOne; } - return 0; + return numberZero; } @@ -3310,14 +3930,14 @@ int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &m if (rmrMessageBuffer.sendMessage == nullptr) { rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); mdclog_write(MDCLOG_ERR, "RMR failed send message returned with NULL pointer"); - return -1; + return negativeOne; } - if (rmrMessageBuffer.sendMessage->state != 0) { + if (rmrMessageBuffer.sendMessage->state != numberZero) { char meid[RMR_MAX_MEID]{}; if (rmrMessageBuffer.sendMessage->state == RMR_ERR_RETRY) { - usleep(5); - rmrMessageBuffer.sendMessage->state = 0; + usleep(numberFive); + rmrMessageBuffer.sendMessage->state = numberZero; mdclog_write(MDCLOG_INFO, "RETRY sending Message type %d to Xapp from %s", rmrMessageBuffer.sendMessage->mtype, rmr_get_meid(rmrMessageBuffer.sendMessage, (unsigned char *)meid)); @@ -3327,8 +3947,8 @@ int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &m if (rmrMessageBuffer.sendMessage == nullptr) { mdclog_write(MDCLOG_ERR, "RMR failed send message returned with NULL pointer"); rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); - return -1; - } else if (rmrMessageBuffer.sendMessage->state != 0) { + return negativeOne; + } else if (rmrMessageBuffer.sendMessage->state != numberZero) { mdclog_write(MDCLOG_ERR, "Message state %s while sending request %d to Xapp from %s after retry of 10 microseconds", translateRmrErrorMessages(rmrMessageBuffer.sendMessage->state).c_str(), @@ -3475,15 +4095,15 @@ int fetchStreamId(ConnectedCU_t *peerInfo, ReportingMessages_t &message) case RIC_SERVICE_QUERY: case RIC_SERVICE_UPDATE_ACK: case RIC_SERVICE_UPDATE_FAILURE: - streamId = 0; + streamId = numberZero; break; case RIC_SUB_REQ: case RIC_SUB_DEL_REQ: case RIC_CONTROL_REQ: - streamId = 1; + streamId = numberOne; break; default: - streamId = 0; + streamId = numberZero; break; } if (loglevel >= MDCLOG_DEBUG) { diff --git a/RIC-E2-TERMINATION/sctpThread.h b/RIC-E2-TERMINATION/sctpThread.h index f1045f1..f5c4fb9 100644 --- a/RIC-E2-TERMINATION/sctpThread.h +++ b/RIC-E2-TERMINATION/sctpThread.h @@ -53,6 +53,7 @@ #include #include #include +#include #include #include @@ -114,7 +115,7 @@ namespace expr = boost::log::expressions; #define MAXEVENTS 128 -#define RECEIVE_SCTP_BUFFER_SIZE (256 * 1024) +#define RECEIVE_SCTP_BUFFER_SIZE (8 * 1024) #define RECEIVE_XAPP_BUFFER_SIZE RECEIVE_SCTP_BUFFER_SIZE typedef mapWrapper Sctp_Map_t; @@ -124,6 +125,13 @@ typedef mapWrapper Sctp_Map_t; #define VOLUME_URL_SIZE 256 #define KA_MESSAGE_SIZE 2048 +enum E2T_Internal_Counters +{ + SCTP_ABORT_INITIATED_BY_E2NODE = 0, + INVALID_MESSAGE_RECEIVED = 1, + E2T_MAX_INTERNAL_COUNTER = 2, +}; + typedef struct sctp_params { int epollTimeOut = -1; uint16_t rmrPort = 0; @@ -150,6 +158,7 @@ typedef struct sctp_params { Family *prometheusFamily; Exposer *prometheusExposer = nullptr; Counter *e2tCounters[6][2][ProcedureCode_id_RICsubscriptionDeleteRequired + 1] {}; + Counter *e2tInternalCounters[E2T_Internal_Counters::E2T_MAX_INTERNAL_COUNTER] {}; } sctp_params_t; // RAN to RIC @@ -181,6 +190,7 @@ typedef struct ConnectedCU { Counter *counters[6][2][ProcedureCode_id_RICsubscriptionDeleteRequired + 1] {}; bool isSingleStream = false; int singleStreamId = 0; + Counter *e2tInternalCounters[E2T_Internal_Counters::E2T_MAX_INTERNAL_COUNTER] {}; } ConnectedCU_t ; @@ -212,6 +222,53 @@ typedef struct ReportingMessages { char buffer[RECEIVE_SCTP_BUFFER_SIZE * 8] {}; } ReportingMessages_t; +enum E2T_Procedure_States +{ + E2_SETUP_PROCEDURE_NOT_INITIATED = 0, + E2_SETUP_PROCEDURE_ONGOING = 1, + E2_SETUP_PROCEDURE_COMPLETED = 2, + RIC_SERVICE_UPDATE_PROCEDURE_ONGOING = 3, + RIC_SERVICE_UPDATE_PROCEDURE_COMPLETED = 4, + RIC_SUBS_PROCEDURE_ONGOING = 5, + RIC_SUBS_PROCEDURE_COMPLETED = 6, + RIC_INDICATION_PROCEDURE_ONGOING = 7, + RIC_INDICATION_PROCEDURE_COMPLETED = 8, + RIC_SUBS_DEL_PROCEDURE_ONGOING = 9, + RIC_SUBS_DEL_PROCEDURE_COMPLETED = 10, + CONTROL_PROCEDURE_ONGOING = 11, + CONTROL_PROCEDURE_COMPLETED = 12, + E2_NODE_CONF_UPDATE_PROCEDURE_ONGOING = 13, + E2_NODE_CONF_UPDATE_PROCEDURE_COMPLETED = 14, + RESET_PROCEDURE_ONGOING = 15, + RESET_PROCEDURE_COMPLETED = 16, +}; + +struct E2NodeConnectionHandling +{ + E2T_Procedure_States e2tProcedureOngoingStatus; + long e2SetupProcedureTransactionId; +}; + +constexpr int negativeOne = -1; +constexpr int negativeSix = -6; +constexpr int negativeSeven = -7; +constexpr int numberZero = 0; +constexpr int numberOne = 1; +constexpr int numberTwo = 2; +constexpr int numberThree = 3; +constexpr int numberFour = 4; +constexpr int numberFive = 5; +constexpr int numberTwenty = 20; + +constexpr uint8_t sendMsgMaxBitPosition = 2; +constexpr uint8_t sendMsgToE2MBitSetPosition = 0; +constexpr uint8_t sendMsgToSubMgrBitSetPosition = 1; + +constexpr uint8_t requiredIePresentMaxBitSetPosition = 3; +constexpr uint8_t transactionIdIeBitSetPosition = 0; +constexpr uint8_t ricRequestIdIeBitSetPosition = 1; +constexpr uint8_t causeIeBitSetPosition = 2; + cxxopts::ParseResult parse(int argc, char *argv[], sctp_params_t &pSctpParams); int buildInotify(sctp_params_t &sctpParams); @@ -444,4 +501,12 @@ int buildListeningPort(sctp_params_t &sctpParams); void buildE2TPrometheusCounters(sctp_params_t &sctpParams); int fetchStreamId(ConnectedCU_t *peerInfo, ReportingMessages_t &message); +void removeE2ConnectionEntryFromMap(char* eNBName); +bool getE2tProcedureOngoingStatus(char *enbName, E2NodeConnectionHandling &e2NodeConnectionHandling); +void setE2ProcedureOngoingStatus(char *enbName, E2T_Procedure_States state); +void insertE2ProcedureOngoing(char *enbName, long &transactionID); +E2T_Procedure_States currentE2tProcedureOngoingStatus(char *enbName); +void printEntryPresentInMap(); +void handleE2SetupReq(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, E2AP_PDU_t *pdu, long &transactionID, int streamId, Sctp_Map_t *sctpMap); +bitset getSendMsgBitSetValue(int procedureCode, bitset isRequiredIesPresent, char* enbName); #endif //X2_SCTP_THREAD_H -- 2.16.6