X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=RIC-E2-TERMINATION%2FsctpThread.cpp;h=a6a18ead57b29cb9193714128bd75dc62a4223f3;hb=c9575aa9ebb0b795671123b112085cc2c842b87a;hp=e2f6e8be5d012cf9c5a775043a72b716dcce6724;hpb=96c9b882e2aed3838bcec26689dda01b3d11bc94;p=ric-plt%2Fe2.git diff --git a/RIC-E2-TERMINATION/sctpThread.cpp b/RIC-E2-TERMINATION/sctpThread.cpp index e2f6e8b..a6a18ea 100644 --- a/RIC-E2-TERMINATION/sctpThread.cpp +++ b/RIC-E2-TERMINATION/sctpThread.cpp @@ -20,9 +20,14 @@ +#include <3rdparty/oranE2/RANfunctions-List.h> #include "sctpThread.h" #include "BuildRunName.h" +#include "3rdparty/oranE2SM/E2SM-gNB-NRT-RANfunction-Definition.h" + +#include "pugixml/src/pugixml.hpp" + using namespace std; //using namespace std::placeholders; using namespace boost::filesystem; @@ -416,7 +421,8 @@ void sendTermInit(sctp_params_t &sctpParams) { rmr_bytes2xact(msg, tx, txLen); msg = rmr_send_msg(sctpParams.rmrCtx, msg); if (msg == nullptr) { - msg = rmr_alloc_msg(sctpParams.rmrCtx, sctpParams.myIP.length()); + //TODO fix it + msg = rmr_alloc_msg(sctpParams.rmrCtx, sctpParams.ka_message_length); } else if (msg->state == 0) { rmr_free_msg(msg); if (mdclog_level_get() >= MDCLOG_INFO) { @@ -547,10 +553,10 @@ void listener(sctp_params_t *params) { ReportingMessages_t message {}; - for (int i = 0; i < MAX_RMR_BUFF_ARRY; i++) { - rmrMessageBuffer.rcvBufferedMessages[i] = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); - rmrMessageBuffer.sendBufferedMessages[i] = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); - } +// for (int i = 0; i < MAX_RMR_BUFF_ARRY; i++) { +// rmrMessageBuffer.rcvBufferedMessages[i] = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); +// rmrMessageBuffer.sendBufferedMessages[i] = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); +// } message.statCollector = StatCollector::GetInstance(); @@ -713,12 +719,16 @@ void handleConfigChange(sctp_params_t *sctpParams) { // not the directory } if (event->len) { - if (!(sctpParams->configFileName.compare(event->name))) { + auto retVal = strcmp(sctpParams->configFileName.c_str(), event->name); + if (retVal != 0) { continue; } } // only the file we want if (event->mask & (uint32_t)IN_CLOSE_WRITE) { + if (mdclog_level_get() >= MDCLOG_INFO) { + mdclog_write(MDCLOG_INFO, "Configuration file changed"); + } if (exists(p)) { const int size = 2048; auto fileSize = file_size(p); @@ -882,6 +892,7 @@ void handlepoll_error(struct epoll_event &event, } close(peerInfo->fileDescriptor); + params->sctpMap->erase(peerInfo->enodbName); cleanHashEntry((ConnectedCU_t *) event.data.ptr, params->sctpMap); } else { mdclog_write(MDCLOG_ERR, "epoll error, events %0x on RMR FD", event.events); @@ -973,7 +984,7 @@ int sendSctpMsg(ConnectedCU_t *peerInfo, ReportingMessages_t &message, Sctp_Map_ m->erase(key); return -1; } - message.statCollector->incSentMessage(string(message.message.enodbName)); + //message.statCollector->incSentMessage(string(message.message.enodbName)); message.message.direction = 'D'; // send report.buffer of size buildJsonMessage(message); @@ -1083,7 +1094,6 @@ int receiveDataFromSctp(struct epoll_event *events, break; } - asn_dec_rval_t rval; if (loglevel >= MDCLOG_DEBUG) { char printBuffer[4096]{}; char *tmp = printBuffer; @@ -1100,11 +1110,12 @@ int receiveDataFromSctp(struct epoll_event *events, clock_gettime(CLOCK_MONOTONIC, &decodestart); } - rval = asn_decode(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void **) &pdu, + auto rval = asn_decode(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void **) &pdu, message.message.asndata, message.message.asnLength); if (rval.code != RC_OK) { mdclog_write(MDCLOG_ERR, "Error %d Decoding (unpack) E2AP PDU from RAN : %s", rval.code, message.peerInfo->enodbName); + //todo may need reset to pdu break; } @@ -1122,15 +1133,15 @@ int receiveDataFromSctp(struct epoll_event *events, switch (pdu->present) { case E2AP_PDU_PR_initiatingMessage: {//initiating message - asnInitiatingRequest(pdu, message, rmrMessageBuffer); + asnInitiatingRequest(pdu, sctpMap,message, rmrMessageBuffer); break; } case E2AP_PDU_PR_successfulOutcome: { //successful outcome - asnSuccsesfulMsg(pdu, message, rmrMessageBuffer); + asnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer); break; } case E2AP_PDU_PR_unsuccessfulOutcome: { //Unsuccessful Outcome - asnUnSuccsesfulMsg(pdu, message, rmrMessageBuffer); + asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer); break; } default: @@ -1148,17 +1159,18 @@ int receiveDataFromSctp(struct epoll_event *events, //break; if (pdu != nullptr) { //TODO need to test ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); to get better performance - //ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); - ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); - pdu = nullptr; + ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); + //ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + //pdu = nullptr; } //clock_gettime(CLOCK_MONOTONIC, &start); } // in case of break to avoid memory leak - if (pdu != nullptr) { - ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); - pdu = nullptr; - } +// if (pdu != nullptr) { +// //ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); +// ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); +// //pdu = nullptr; +// } if (done) { if (loglevel >= MDCLOG_INFO) { @@ -1191,17 +1203,11 @@ int receiveDataFromSctp(struct epoll_event *events, } static void buildAndsendSetupRequest(ReportingMessages_t &message, - E2setupRequestIEs_t *ie, RmrMessagesBuffer_t &rmrMessageBuffer, - E2AP_PDU_t *pdu) { + E2AP_PDU_t *pdu, + vector repValues) { auto logLevel = mdclog_level_get(); - - if (buildRanName(message.peerInfo->enodbName, ie) < 0) { - mdclog_write(MDCLOG_ERR, "Bad param in E2setupRequestIEs GlobalE2node_ID.\n"); - } else { - memcpy(message.message.enodbName, message.peerInfo->enodbName, strlen(message.peerInfo->enodbName)); - } // now we can send the data to e2Mgr auto buffer_size = RECEIVE_SCTP_BUFFER_SIZE * 2; @@ -1212,15 +1218,68 @@ static void buildAndsendSetupRequest(ReportingMessages_t &message, // unsigned char *buffer = &rmrMsg->payload[j]; unsigned char buffer[RECEIVE_SCTP_BUFFER_SIZE * 2]; // encode to xml - asn_enc_rval_t er; - er = asn_encode_to_buffer(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, pdu, buffer, buffer_size); + auto er = asn_encode_to_buffer(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, pdu, buffer, buffer_size); if (er.encoded == -1) { mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); } else if (er.encoded > (ssize_t) buffer_size) { - mdclog_write(MDCLOG_ERR, "Buffer of size %d is to small for %s", + mdclog_write(MDCLOG_ERR, "Buffer of size %d is to small for %s, at %s line %d", (int) buffer_size, - asn_DEF_E2AP_PDU.name); + asn_DEF_E2AP_PDU.name, __func__, __LINE__); } else { + // we have the XML + pugi::xml_document doc; + pugi::xml_parse_result result = doc.load_string((const char *)buffer); + if (result) { + unsigned int index = 0; + for (auto tool : doc.child("E2AP-PDU") + .child("initiatingMessage") + .child("value") + .child("E2setupRequest") + .child("protocolIEs") + .children("E2setupRequestIEs")) { + for (auto n : tool.child("value").child("RANfunctions-List").child( + "ProtocolIE-SingleContainer").children()) { + //ProtocolIE-SingleContainer + //cout << "\t1 " << n.name() << endl; + if (strcmp(n.name(), "value") == 0) { + for (auto l : tool.child("value").children()) { + //cout << "\t\t2 " << l.name() << endl; + for (auto f : l.children()) { + //cout << "\t\t\t3 " << f.name() << endl; + for (auto g : f.child("value").children()) { + //cout << "\t\t\t\t4 " << g.name() << endl; + for (auto a : g.children()) { + if (strcmp(a.name(), "ranFunctionDefinition") == 0) { + if (repValues.size() > index) { + a.remove_children(); + string val = repValues.at(index++); + // here we get vector with counter + a.append_child(pugi::node_pcdata).set_value(val.c_str()); + + } + } + //cout << "\t\t\t\t\t5 " << a.name() << " " << a.child_value() << endl; + } + } + } + } + } + } + } + +// memstream strinBuf(buffer, RECEIVE_SCTP_BUFFER_SIZE * 2); +// +// strinBuf.read(, RECEIVE_SCTP_BUFFER_SIZE * 2); + + streambuf *oldCout = cout.rdbuf(); + ostringstream memCout; + // create new cout + cout.rdbuf(memCout.rdbuf()); + doc.save(std::cout); + //return to the normal cout + cout.rdbuf(oldCout); + memcpy(buffer, memCout.str().c_str(), memCout.str().length()); + } rmrMsg->len = snprintf((char *)rmrMsg->payload, RECEIVE_SCTP_BUFFER_SIZE * 2, "%s:%d|%s", message.peerInfo->sctpParams->myIP.c_str(), message.peerInfo->sctpParams->rmrPort, @@ -1279,6 +1338,7 @@ static void buildAndsendSetupRequest(ReportingMessages_t &message, * @param rmrMessageBuffer */ void asnInitiatingRequest(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { auto logLevel = mdclog_level_get(); @@ -1292,16 +1352,114 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, mdclog_write(MDCLOG_DEBUG, "Got E2setup\n"); } + // first get the message as XML buffer + auto setup_xml_buffer_size = RECEIVE_SCTP_BUFFER_SIZE * 2; + unsigned char setup_xml_buffer[RECEIVE_SCTP_BUFFER_SIZE * 2]; + //unsigned char *tmp_buff_cursor = setup_xml_buffer; + + auto er = asn_encode_to_buffer(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, pdu, setup_xml_buffer, setup_xml_buffer_size); + if (er.encoded == -1) { + mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); + } else if (er.encoded > (ssize_t) setup_xml_buffer_size) { + mdclog_write(MDCLOG_ERR, "Buffer of size %d is to small for %s, at %s line %d", + (int)setup_xml_buffer_size, + asn_DEF_E2AP_PDU.name, __func__, __LINE__); + } + std::string xmlString(setup_xml_buffer_size, setup_xml_buffer_size + er.encoded); + + vector runFunDEFXML_v; + runFunDEFXML_v.clear(); + string runFuncStr = {}; + auto failed = false; memset(message.peerInfo->enodbName, 0 , MAX_ENODB_NAME_SIZE); for (auto i = 0; 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) { - buildAndsendSetupRequest(message, ie, rmrMessageBuffer, pdu); - break; + if (buildRanName(message.peerInfo->enodbName, ie) < 0) { + mdclog_write(MDCLOG_ERR, "Bad param in E2setupRequestIEs GlobalE2node_ID.\n"); + // no mesage will be sent + break; + } + memcpy(message.message.enodbName, message.peerInfo->enodbName, strlen(message.peerInfo->enodbName)); + sctpMap->setkey(message.message.enodbName, message.peerInfo); } } + // reformat RANFUNCTION Definition to XML + if (ie->id == ProtocolIE_ID_id_RANfunctionsAdded) { + if (ie->value.present == E2setupRequestIEs__value_PR_RANfunctions_List) { + for (auto j = 0; i < ie->value.choice.RANfunctions_List.list.count; i++) { + auto *raNfunctionItemIEs = (RANfunction_ItemIEs_t *)ie->value.choice.RANfunctions_List.list.array[j]; + if (raNfunctionItemIEs->id == ProtocolIE_ID_id_RANfunction_Item && + (raNfunctionItemIEs->value.present == RANfunction_ItemIEs__value_PR_RANfunction_Item)) { + // encode to xml + E2SM_gNB_NRT_RANfunction_Definition_t *ranFunDef = nullptr; + auto rval = asn_decode(nullptr, ATS_ALIGNED_BASIC_PER, + &asn_DEF_E2SM_gNB_NRT_RANfunction_Definition, + (void **)&ranFunDef, + raNfunctionItemIEs->value.choice.RANfunction_Item.ranFunctionDefinition.buf, + raNfunctionItemIEs->value.choice.RANfunction_Item.ranFunctionDefinition.size); + if (rval.code != RC_OK) { + mdclog_write(MDCLOG_ERR, "Error %d Decoding (unpack) E2SM message from : %s", + rval.code, + asn_DEF_E2SM_gNB_NRT_RANfunction_Definition.name); + failed = true; + break; + } + + if (mdclog_level_get() >= MDCLOG_DEBUG) { + char *printBuffer; + size_t size; + FILE *stream = open_memstream(&printBuffer, &size); + asn_fprint(stream, &asn_DEF_E2SM_gNB_NRT_RANfunction_Definition, ranFunDef); + mdclog_write(MDCLOG_DEBUG, "Encoding E2SM %s PDU past : %s", + asn_DEF_E2SM_gNB_NRT_RANfunction_Definition.name, + printBuffer); + } + auto xml_buffer_size = RECEIVE_SCTP_BUFFER_SIZE * 2; + unsigned char xml_buffer[RECEIVE_SCTP_BUFFER_SIZE * 2]; + // encode to xml + er = asn_encode_to_buffer(nullptr, + ATS_BASIC_XER, + &asn_DEF_E2SM_gNB_NRT_RANfunction_Definition, + ranFunDef, + xml_buffer, + xml_buffer_size); + if (er.encoded == -1) { + mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", + asn_DEF_E2SM_gNB_NRT_RANfunction_Definition.name, + strerror(errno)); + } else if (er.encoded > (ssize_t)xml_buffer_size) { + mdclog_write(MDCLOG_ERR, "Buffer of size %d is to small for %s, at %s line %d", + (int) xml_buffer_size, + asn_DEF_E2SM_gNB_NRT_RANfunction_Definition.name, __func__, __LINE__); + } else { + if (mdclog_level_get() >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "Encoding E2SM %s PDU past : %s", + asn_DEF_E2SM_gNB_NRT_RANfunction_Definition.name, + xml_buffer); + } + //TODO replace the ranFunctionDefinition with the XML + string runFuncs = (char *)(xml_buffer); + runFunDEFXML_v.emplace_back(runFuncs); + } + + } + } + if (failed) { + break; + } + } + } + } + if (failed) { + break; } + + //build all parts and send the XML (need to copy the XML with the header to the rmrMessageBuffer payload + //TODO replace with new function + buildAndsendSetupRequest(message, rmrMessageBuffer, pdu, runFunDEFXML_v); break; } case ProcedureCode_id_ErrorIndication: { @@ -1413,7 +1571,10 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, * @param message * @param rmrMessageBuffer */ -void asnSuccsesfulMsg(E2AP_PDU_t *pdu, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { +void asnSuccsesfulMsg(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer) { auto procedureCode = pdu->choice.successfulOutcome->procedureCode; auto logLevel = mdclog_level_get(); if (logLevel >= MDCLOG_INFO) { @@ -1574,6 +1735,7 @@ void asnSuccsesfulMsg(E2AP_PDU_t *pdu, ReportingMessages_t &message, RmrMessages * @param rmrMessageBuffer */ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { auto procedureCode = pdu->choice.unsuccessfulOutcome->procedureCode; @@ -1794,6 +1956,39 @@ void getRmrContext(sctp_params_t &pSctpParams) { } } +int BuildPERSetupResponseMessaeFromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + E2AP_PDU_t *pdu; + + if (mdclog_level_get() >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "got xml setup response \n %s\n", rmrMessageBuffer.rcvMessage->payload); + } + auto rval = asn_decode(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, (void **) &pdu, + rmrMessageBuffer.rcvMessage->payload, rmrMessageBuffer.rcvMessage->len); + if (rval.code != RC_OK) { + mdclog_write(MDCLOG_ERR, "Error %d Decoding (unpack) setup response from E2MGR : %s", + rval.code, + message.message.enodbName); + return -1; + } + + int buff_size = RECEIVE_XAPP_BUFFER_SIZE; + auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu, + rmrMessageBuffer.rcvMessage->payload, buff_size); + if (er.encoded == -1) { + mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); + return -1; + } else if (er.encoded > (ssize_t)buff_size) { + mdclog_write(MDCLOG_ERR, "Buffer of size %d is to small for %s, at %s line %d", + (int)rmrMessageBuffer.rcvMessage->len, + asn_DEF_E2AP_PDU.name, + __func__, + __LINE__); + return -1; + } + rmrMessageBuffer.rcvMessage->len = er.encoded; + return 0; +} + /** * * @param sctpMap @@ -1830,8 +2025,13 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, mdclog_write(MDCLOG_ERR, "RMR Receving message with stat = %d", rmrMessageBuffer.rcvMessage->state); return -1; } + rmr_get_meid(rmrMessageBuffer.rcvMessage, (unsigned char *)message.message.enodbName); switch (rmrMessageBuffer.rcvMessage->mtype) { case RIC_E2_SETUP_RESP : { + if (BuildPERSetupResponseMessaeFromXML(message, rmrMessageBuffer) != 0) { + break; + } + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_SETUP_RESP"); return -6; @@ -1839,6 +2039,9 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_E2_SETUP_FAILURE : { + if (BuildPERSetupResponseMessaeFromXML(message, rmrMessageBuffer) != 0) { + break; + } if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_SETUP_FAILURE"); return -6;