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<std::string, E2NodeConnectionHandling> 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;
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;
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) {
}
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);
}
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;
}
}
+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,
/* 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,
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,
/* 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,
/* 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<std::string, E2NodeConnectionHandling>::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);
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;
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);
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;
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");
/* 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;
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);
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;
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;
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");
/* 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;
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);
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;
}
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);
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*/
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();
}
boost::shared_ptr<sinks::synchronous_sink<sinks::text_file_backend>> boostLogger;
// double cpuClock = 0.0;
bool jsonTrace = false;
+std::map<std::string, E2NodeConnectionHandling> connectionHandlingPerE2NodeMap;
char* getinterfaceip()
{
auto result = parse(argc, argv, sctpParams);
- if (buildConfiguration(sctpParams) != 0) {
- exit(-1);
+ if (buildConfiguration(sctpParams) != numberZero) {
+ exit(negativeOne);
}
//auto registry = std::make_shared<Registry>();
std::vector<std::thread> threads(num_cpus);
// std::vector<std::thread> 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);
}
}
#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));
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);
}
}
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. */
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");
}
}
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;
}
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);
}
* @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]{};
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");
}
}
}
#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];
}
}
+void removeE2ConnectionEntryFromMap(char* enbName)
+{
+ if(connectionHandlingPerE2NodeMap.empty())
+ {
+ mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty");
+ return;
+ }
+ std::map<std::string, E2NodeConnectionHandling>::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;
+ }
+}
/**
*
} 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;
"%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,
}
#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);
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) {
}
return 0;
}
-
+#ifndef UNIT_TEST
static void buildAndSendSetupRequest(ReportingMessages_t &message,
RmrMessagesBuffer_t &rmrMessageBuffer,
E2AP_PDU_t *pdu/*,
return;
}
+#endif
#if 0
int RAN_Function_list_To_Vector(RANfunctions_List_t& list, vector <string> &runFunXML_v) {
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<Counter> *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
* @param RANfunctionsAdded_v
* @return
*/
-int collectSetupRequestData(E2AP_PDU_t *pdu,
- Sctp_Map_t *sctpMap,
- ReportingMessages_t &message /*, vector <string> &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 <string> &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);
}
}
}
} */
+ 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) {
}
switch (procedureCode) {
case ProcedureCode_id_E2setup: {
+
if (logLevel >= MDCLOG_DEBUG) {
mdclog_write(MDCLOG_DEBUG, "Got E2setup");
}
// vector <string> 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 <string> RANfunctionsAdded_v;
// vector <string> RANfunctionsModified_v;
// RANfunctionsAdded_v.clear();
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);
}
// 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<requiredIePresentMaxBitSetPosition> 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<sendMsgMaxBitPosition> 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);
}
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) {
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;
}
}
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);
}
}
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);
}
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);
}
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) {
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];
}
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;
}
}
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;
}
}
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);
}
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);
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;
}
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);
}
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);
}
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);
}
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<std::string, E2NodeConnectionHandling>::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<std::string, E2NodeConnectionHandling>::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<std::string, E2NodeConnectionHandling>::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<std::string, E2NodeConnectionHandling>::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<sendMsgMaxBitPosition> getSendMsgBitSetValue(int procedureCode, bitset<requiredIePresentMaxBitSetPosition> isRequiredIesPresent, char* enbName)
+{
+ bitset<sendMsgMaxBitPosition> 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<std::string, E2NodeConnectionHandling>::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
(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));
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) {
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) {
#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);
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) {
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))
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))
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;
}
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))
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;
}
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))
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;
}
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;
}
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);
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);
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);
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))
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;
}
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;
}
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))
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;
}
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))
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))
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;
}
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);
(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);
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) {
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);
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);
}
}
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;
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;
}
/**
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;
}
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",
}
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__);
}
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;
}
/**
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__);
}
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;
}
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));
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(),
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) {
Code Review / ric-plt / e2.git / commitdiff