X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=RIC-E2-TERMINATION%2FsctpThread.cpp;h=6ad9fdf0ea342fb575273a7376ec762ab44b4ea2;hb=f2617ceb3f4ec718c9d161e541b70f060cd0b40d;hp=2d7e76b4b27627099f71f9fdc1b073311cfb934b;hpb=60f8bef9fe0d1dcec9505783bcc94d42e2c8529e;p=ric-plt%2Fe2.git diff --git a/RIC-E2-TERMINATION/sctpThread.cpp b/RIC-E2-TERMINATION/sctpThread.cpp index 2d7e76b..6ad9fdf 100644 --- a/RIC-E2-TERMINATION/sctpThread.cpp +++ b/RIC-E2-TERMINATION/sctpThread.cpp @@ -32,8 +32,7 @@ #include #include #include - - +#include using namespace std; //using namespace std::placeholders; @@ -49,6 +48,7 @@ using namespace prometheus; // need to expose without the include of gcov extern "C" void __gcov_flush(void); #define LOG_FILE_CONFIG_MAP "CONFIG_MAP_NAME" +#define E2AP_PPID 70 // as per E2GAP chapter 6.1 static void catch_function(int signal) { __gcov_flush(); @@ -59,8 +59,25 @@ static void catch_function(int signal) { BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(my_logger, src::logger_mt) boost::shared_ptr> boostLogger; -double cpuClock = 0.0; +// double cpuClock = 0.0; bool jsonTrace = false; +std::map connectionHandlingPerE2NodeMap; + +char* getinterfaceip() +{ + char hostname[256]; + char *IP; + struct hostent *host_entry; + int retVal; + retVal = gethostname(hostname, sizeof(hostname)); + if ( retVal == -1 ) + return NULL; + host_entry = gethostbyname(hostname); + if ( host_entry == NULL ) + return NULL; + IP = inet_ntoa(*((struct in_addr*) host_entry->h_addr_list[0])); + return IP; +} static int enable_log_change_notify(const char* fileName) @@ -81,7 +98,7 @@ static int register_log_change_notify(const char *fileName) pthread_t tid; pthread_attr_init(&cb_attr); pthread_attr_setdetachstate(&cb_attr,PTHREAD_CREATE_DETACHED); - return pthread_create(&tid, &cb_attr,&monitor_loglevel_change_handler,(void *)strdup(fileName)); + return pthread_create(&tid, &cb_attr,&monitor_loglevel_change_handler,(void *)fileName); } @@ -94,19 +111,17 @@ static void * monitor_loglevel_change_handler(void* arg) char rbuf[4096]; // large read buffer as the event is var len fd_set fds; int res = 0; - struct timeval timeout; char* dname=NULL; // directory name char* bname = NULL; // basename char* tok=NULL; char* log_level=NULL; - dname = strdup( fileName); // defrock the file name into dir and basename + dname = strdup( fileName ); // defrock the file name into dir and basename if( (tok = strrchr( dname, '/' )) != NULL ) { *tok = '\0'; bname = strdup( tok+1 ); } - ifd = inotify_init1( 0 ); // initialise watcher setting blocking read (no option) if( ifd < 0 ) { fprintf( stderr, "### ERR ### unable to initialise file watch %s\n", strerror( errno ) ); @@ -116,29 +131,30 @@ static void * monitor_loglevel_change_handler(void* arg) if( wfd < 0 ) { fprintf( stderr, "### ERR ### unable to add watch on config file %s: %s\n", fileName, strerror( errno ) ); } else { - - - memset( &timeout, 0, sizeof(timeout) ); + FD_ZERO (&fds); + FD_SET (ifd, &fds); while( 1 ) { - FD_ZERO (&fds); - FD_SET (ifd, &fds); - timeout.tv_sec=1; - res = select (ifd + 1, &fds, NULL, NULL, &timeout); + res = select (ifd + 1, &fds, NULL, NULL, NULL); if(res) { n = read( ifd, rbuf, sizeof( rbuf ) ); // read the event if( n < 0 ) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if( errno == EAGAIN ) { } else { fprintf( stderr, "### CRIT ### config listener read err: %s\n", strerror( errno ) ); } continue; +#endif } //Retrieving Log Level from configmap by parsing configmap file log_level = parse_file(fileName); update_mdc_log_level_severity(log_level); //setting log level - free(log_level); + if(log_level != NULL) { + mdclog_write(MDCLOG_INFO, "MDC log level updated to %s", log_level); + free(log_level); + } } } inotify_rm_watch(ifd,wfd); @@ -147,6 +163,7 @@ static void * monitor_loglevel_change_handler(void* arg) } free(bname); free(dname); + free(fileName); pthread_exit(NULL); } @@ -178,24 +195,52 @@ void update_mdc_log_level_severity(char* log_level) mdclog_level_set(level); } + +/** + * @brief Remove leading and trailing spaces from s. + * + * If the string was allocated dynamically, the caller cannot + * overwrite the returned pointer. + * + * @param s the string we want to remove spaces. + * @return Returns a null-terminated substring of "s". + */ +static inline char *trim(char *s) +{ + char *end; + /* skip leading spaces */ + while (isspace(*s)) s++; + + /* all spaces */ + if (*s == '\0') return s; + + /* skip trailing spaces */ + end = s + strlen(s) - 1; + while (end > s && isspace(*end)) end--; + + /* write null character */ + *(end+1) = '\0'; + + return s; +} + static char* parse_file(char* filename) { char *token=NULL; - char *search = ": "; - char *string_match = "log-level"; bool found = false; FILE *file = fopen ( filename, "r" ); + if ( file != NULL ) { char line [ 128 ]; - while ( fgets ( line, sizeof line, file ) != NULL ) + while ( fgets ( line, sizeof(line), file ) != NULL ) { - token = strtok(line, search); - if(strcmp(token,string_match)==0) - { + token = strtok(line, ":"); + token = trim(token); + if (strcmp(token,"log-level") == 0) { found = true; - token = strtok(NULL, search); - token = strtok(token, "\n");//removing newline if any + token = strtok(NULL, "\n"); + token = trim(token); break; } } @@ -226,12 +271,11 @@ void dynamic_log_level_change() { log_level_init = parse_file(logFile_Name); update_mdc_log_level_severity(log_level_init); //setting log level + mdclog_write(MDCLOG_INFO, "MDC log level set to %s", log_level_init); free(log_level_init); } enable_log_change_notify(logFile_Name); - free(logFile_Name); - } void init_log() { @@ -245,43 +289,57 @@ void init_log() { dynamic_log_level_change(); mdclog_attr_destroy(attr); } -auto start_time = std::chrono::high_resolution_clock::now(); -typedef std::chrono::duration> seconds_t; +//auto start_time = std::chrono::high_resolution_clock::now(); +//typedef std::chrono::duration> seconds_t; -double age() { - return seconds_t(std::chrono::high_resolution_clock::now() - start_time).count(); -} +//double age() { +// return seconds_t(std::chrono::high_resolution_clock::now() - start_time).count(); +//} -double approx_CPU_MHz(unsigned sleepTime) { - using namespace std::chrono_literals; - uint32_t aux = 0; - uint64_t cycles_start = rdtscp(aux); - double time_start = age(); - std::this_thread::sleep_for(sleepTime * 1ms); - uint64_t elapsed_cycles = rdtscp(aux) - cycles_start; - double elapsed_time = age() - time_start; - return elapsed_cycles / elapsed_time; -} +// If model name in "/proc/cpuinfo" is happens to be "Common KVM processor" then +// approx_CPU_MHz() results in "SIGILL - Illegal Instruction" signal. +// +// double approx_CPU_MHz(unsigned sleepTime) { +// using namespace std::chrono_literals; +// uint32_t aux = 0; +// uint64_t cycles_start = rdtscp(aux); +// double time_start = age(); +// std::this_thread::sleep_for(sleepTime * 1ms); +// uint64_t elapsed_cycles = rdtscp(aux) - cycles_start; +// double elapsed_time = age() - time_start; +// return elapsed_cycles / elapsed_time; +//} //std::atomic rmrCounter{0}; std::atomic num_of_messages{0}; std::atomic num_of_XAPP_messages{0}; static long transactionCounter = 0; +pthread_mutex_t thread_lock; int buildListeningPort(sctp_params_t &sctpParams) { sctpParams.listenFD = socket(AF_INET6, SOCK_STREAM, IPPROTO_SCTP); if (sctpParams.listenFD <= 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Error Opening socket, %s", strerror(errno)); return -1; +#endif } + struct sctp_initmsg initmsg; + memset (&initmsg, 0, sizeof (initmsg)); + initmsg.sinit_num_ostreams = 2; + initmsg.sinit_max_instreams = 2; + initmsg.sinit_max_attempts = 4; + setsockopt (sctpParams.listenFD, IPPROTO_SCTP, SCTP_INITMSG, &initmsg, sizeof (initmsg)); struct sockaddr_in6 serverAddress {}; serverAddress.sin6_family = AF_INET6; serverAddress.sin6_addr = in6addr_any; serverAddress.sin6_port = htons(sctpParams.sctpPort); if (bind(sctpParams.listenFD, (SA *)&serverAddress, sizeof(serverAddress)) < 0 ) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Error binding port %d. %s", sctpParams.sctpPort, strerror(errno)); return -1; +#endif } if (setSocketNoBlocking(sctpParams.listenFD) == -1) { //mdclog_write(MDCLOG_ERR, "Error binding. %s", strerror(errno)); @@ -296,9 +354,45 @@ int buildListeningPort(sctp_params_t &sctpParams) { mdclog_write(MDCLOG_DEBUG, "My address: %s, port %d\n", buff, htons(clientAddress.sin6_port)); } + // SCTP_HB_INTERVAL is in milisec + char *sctp_hb_interval = std::getenv("SCTP_HB_INTERVAL"); + if (sctp_hb_interval) { + // Setting the heartbeat interval timeout value + struct sctp_paddrparams sckt_parms; + memset(&sckt_parms, 0, sizeof(sckt_parms)); + unsigned int sckt_parms_size = sizeof(sckt_parms); + sckt_parms.spp_address.ss_family = AF_INET6; + sckt_parms.spp_flags |= SPP_HB_ENABLE; + sctp_opt_info(sctpParams.listenFD, 0, SCTP_PEER_ADDR_PARAMS, &sckt_parms, &sckt_parms_size); + if (sckt_parms_size != sizeof(sckt_parms)) { + fprintf(stderr, "Invalid size of sctp_paddrparams socket option: {} / {}", sckt_parms_size, (socklen_t)sizeof(sckt_parms)); + } else { + sckt_parms.spp_hbinterval = atoi(sctp_hb_interval); + setsockopt(sctpParams.listenFD, IPPROTO_SCTP, SCTP_PEER_ADDR_PARAMS, &sckt_parms, sizeof(sckt_parms)); + } + } + + char *sctp_max_retries = std::getenv("SCTP_MAX_RETRIES"); + if (sctp_max_retries) { + // Setting the max retries config for the socket if rechability loss + struct sctp_assocparams sckt_assoc; + memset(&sckt_assoc, 0, sizeof(sckt_assoc)); + unsigned int str_assoc_size = sizeof(sckt_assoc); + sctp_opt_info(sctpParams.listenFD, 0, SCTP_ASSOCINFO, &sckt_assoc, &str_assoc_size); + if (str_assoc_size != sizeof(sckt_assoc)) { + fprintf(stderr, "Invalid size of sctp_assocparams socket option: {} / {}", str_assoc_size, (socklen_t)sizeof(sckt_assoc)); + } else { + sckt_assoc.sasoc_asocmaxrxt = atoi(sctp_max_retries); + setsockopt(sctpParams.listenFD, IPPROTO_SCTP, SCTP_ASSOCINFO, &sckt_assoc, sizeof(sckt_assoc)); + } + } + + if (listen(sctpParams.listenFD, SOMAXCONN) < 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Error listening. %s\n", strerror(errno)); return -1; +#endif } struct epoll_event event {}; event.events = EPOLLIN | EPOLLET; @@ -306,9 +400,11 @@ int buildListeningPort(sctp_params_t &sctpParams) { // add listening port to epoll if (epoll_ctl(sctpParams.epoll_fd, EPOLL_CTL_ADD, sctpParams.listenFD, &event)) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) printf("Failed to add descriptor to epoll\n"); mdclog_write(MDCLOG_ERR, "Failed to add descriptor to epoll. %s\n", strerror(errno)); return -1; +#endif } return 0; @@ -320,31 +416,41 @@ int buildConfiguration(sctp_params_t &sctpParams) { const int size = 2048; auto fileSize = file_size(p); if (fileSize > size) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "File %s larger than %d", p.string().c_str(), size); return -1; +#endif } } else { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Configuration File %s not exists", p.string().c_str()); return -1; +#endif } ReadConfigFile conf; if (conf.openConfigFile(p.string()) == -1) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Filed to open config file %s, %s", p.string().c_str(), strerror(errno)); return -1; +#endif } int rmrPort = conf.getIntValue("nano"); if (rmrPort == -1) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "illegal RMR port "); return -1; +#endif } sctpParams.rmrPort = (uint16_t)rmrPort; snprintf(sctpParams.rmrAddress, sizeof(sctpParams.rmrAddress), "%d", (int) (sctpParams.rmrPort)); auto tmpStr = conf.getStringValue("volume"); if (tmpStr.length() == 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "illegal volume."); return -1; +#endif } char tmpLogFilespec[VOLUME_URL_SIZE]; @@ -360,21 +466,27 @@ int buildConfiguration(sctp_params_t &sctpParams) { sctpParams.myIP = conf.getStringValue("local-ip"); if (sctpParams.myIP.length() == 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "illegal local-ip."); return -1; +#endif } int sctpPort = conf.getIntValue("sctp-port"); if (sctpPort == -1) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "illegal SCTP port "); return -1; +#endif } sctpParams.sctpPort = (uint16_t)sctpPort; sctpParams.fqdn = conf.getStringValue("external-fqdn"); if (sctpParams.fqdn.length() == 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "illegal external-fqdn"); return -1; +#endif } std::string pod = conf.getStringValue("pod_name"); @@ -399,14 +511,18 @@ int buildConfiguration(sctp_params_t &sctpParams) { tmpStr = conf.getStringValue("trace"); transform(tmpStr.begin(), tmpStr.end(), tmpStr.begin(), ::tolower); if ((tmpStr.compare("start")) == 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_INFO, "Trace set to: start"); sctpParams.trace = true; +#endif } else if ((tmpStr.compare("stop")) == 0) { mdclog_write(MDCLOG_INFO, "Trace set to: stop"); sctpParams.trace = false; } else { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Trace was set to wrong value %s, set to stop", tmpStr.c_str()); sctpParams.trace = false; +#endif } jsonTrace = sctpParams.trace; @@ -427,7 +543,6 @@ int buildConfiguration(sctp_params_t &sctpParams) { if (mdclog_level_get() >= MDCLOG_INFO) { mdclog_write(MDCLOG_DEBUG,"RMR Port: %s", to_string(sctpParams.rmrPort).c_str()); - mdclog_write(MDCLOG_DEBUG,"LogLevel: %s", to_string(sctpParams.logLevel).c_str()); mdclog_write(MDCLOG_DEBUG,"volume: %s", sctpParams.volume); mdclog_write(MDCLOG_DEBUG,"tmpLogFilespec: %s", tmpLogFilespec); mdclog_write(MDCLOG_DEBUG,"my ip: %s", sctpParams.myIP.c_str()); @@ -462,13 +577,30 @@ int buildConfiguration(sctp_params_t &sctpParams) { } void startPrometheus(sctp_params_t &sctpParams) { + auto podName = std::getenv("POD_NAME"); + string metric = "E2TBeta"; + if (strstr(podName, "alpha") != NULL) { + metric = "E2TAlpha"; + } + //Get eth0 interface IP + char* host = getinterfaceip(); + string hostip = host; + sctpParams.prometheusFamily = &BuildCounter() - .Name("E2T") - .Help("E2T message counter") + .Name(metric.c_str()) + .Help("E2T instance metrics") .Labels({{"POD_NAME", sctpParams.podName}}) .Register(*sctpParams.prometheusRegistry); - string prometheusPath = sctpParams.prometheusPort + "," + "[::]:" + sctpParams.prometheusPort; + // Build E2T instance level metrics + buildE2TPrometheusCounters(sctpParams); + + string prometheusPath; + if (hostip.empty()) + prometheusPath = sctpParams.prometheusPort + "," + "[::]:" + sctpParams.prometheusPort; + else + prometheusPath = hostip + ":" + sctpParams.prometheusPort; + if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Start Prometheus Pull mode on %s", prometheusPath.c_str()); } @@ -505,14 +637,14 @@ int main(const int argc, char **argv) { exit(1); } - cpuClock = approx_CPU_MHz(100); +// cpuClock = approx_CPU_MHz(100); - mdclog_write(MDCLOG_DEBUG, "CPU speed %11.11f", cpuClock); +// mdclog_write(MDCLOG_DEBUG, "CPU speed %11.11f", cpuClock); auto result = parse(argc, argv, sctpParams); - if (buildConfiguration(sctpParams) != 0) { - exit(-1); + if (buildConfiguration(sctpParams) != numberZero) { + exit(negativeOne); } //auto registry = std::make_shared(); @@ -550,18 +682,22 @@ int main(const int argc, char **argv) { sctpParams.sctpMap = new mapWrapper(); + if (pthread_mutex_init(&thread_lock, NULL) != 0) { + mdclog_write(MDCLOG_ERR, "failed to init thread lock"); + exit(-1); + } std::vector threads(num_cpus); // std::vector threads; - num_cpus = 3; - for (unsigned int i = 0; i < num_cpus; i++) { + num_cpus = numberOne; + for (unsigned int i = numberZero; i < num_cpus; i++) { threads[i] = std::thread(listener, &sctpParams); cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(i, &cpuset); int rc = pthread_setaffinity_np(threads[i].native_handle(), sizeof(cpu_set_t), &cpuset); - if (rc != 0) { + if (rc != numberZero) { mdclog_write(MDCLOG_ERR, "Error calling pthread_setaffinity_np: %d", rc); } } @@ -573,7 +709,7 @@ int main(const int argc, char **argv) { for (auto &t : threads) { t.join(); } - + pthread_mutex_destroy(&thread_lock); return 0; } #endif @@ -761,12 +897,13 @@ void listener(sctp_params_t *params) { #else auto numOfEvents = 1; #endif - if (numOfEvents == 0) { // time out + if (numOfEvents == numberZero) { // time out +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "got epoll timeout"); } continue; - } else if (numOfEvents < 0) { + } else if (numOfEvents < numberZero) { if (errno == EINTR) { if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "got EINTR : %s", strerror(errno)); @@ -774,9 +911,15 @@ void listener(sctp_params_t *params) { continue; } mdclog_write(MDCLOG_ERR, "Epoll wait failed, errno = %s", strerror(errno)); + if(events) + { + free(events); + events = nullptr; + } 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); } @@ -808,11 +951,20 @@ void listener(sctp_params_t *params) { } peerInfo->sctpParams = params; peerInfo->fileDescriptor = accept(params->listenFD, &in_addr, &in_len); - if (peerInfo->fileDescriptor == -1) { + if (peerInfo->fileDescriptor == negativeOne) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) { /* We have processed all incoming connections. */ + if(peerInfo) { + free(peerInfo); + peerInfo = nullptr; + } break; } else { + if(peerInfo) { + free(peerInfo); + peerInfo = nullptr; + } mdclog_write(MDCLOG_ERR, "Accept error, errno = %s", strerror(errno)); break; } @@ -820,14 +972,44 @@ void listener(sctp_params_t *params) { if (setSocketNoBlocking(peerInfo->fileDescriptor) == -1) { mdclog_write(MDCLOG_ERR, "setSocketNoBlocking failed to set new connection %s on port %s\n", hostBuff, portBuff); close(peerInfo->fileDescriptor); + if(peerInfo) { + free(peerInfo); + peerInfo = nullptr; + } break; +#endif } + struct sctp_event_subscribe sctpevents; + memset( (void *)&sctpevents, 0, sizeof(sctpevents) ); + sctpevents.sctp_data_io_event = 1; + setsockopt(peerInfo->fileDescriptor, SOL_SCTP, SCTP_EVENTS,(const void *)&sctpevents, sizeof(sctpevents) ); + + { + char *value = getenv("SCTP_ASSOC_MAX_RETRANS"); + if (value) + { + int int_val = atoi(value); + mdclog_write(MDCLOG_INFO, "Changing sctp_association_max_retrans to %s, %d\n", value, int_val); + if (int_val > 0) + { + struct sctp_assocparams sctpassocparams; + memset((void *)&sctpassocparams, 0, sizeof(sctpassocparams)); + sctpassocparams.sasoc_asocmaxrxt = int_val; + setsockopt(peerInfo->fileDescriptor, SOL_SCTP, SCTP_ASSOCINFO, (const void *)&sctpassocparams, sizeof(sctpassocparams)); + } + } + } + auto ans = getnameinfo(&in_addr, in_len, peerInfo->hostName, NI_MAXHOST, peerInfo->portNumber, NI_MAXSERV, (unsigned )((unsigned int)NI_NUMERICHOST | (unsigned int)NI_NUMERICSERV)); if (ans < 0) { mdclog_write(MDCLOG_ERR, "Failed to get info on connection request. %s\n", strerror(errno)); close(peerInfo->fileDescriptor); + if(peerInfo) { + free(peerInfo); + peerInfo = nullptr; + } break; } if (mdclog_level_get() >= MDCLOG_DEBUG) { @@ -840,6 +1022,10 @@ void listener(sctp_params_t *params) { (EPOLLIN | EPOLLET), params->sctpMap, nullptr, 0) != 0) { + if(peerInfo) { + free(peerInfo); + peerInfo = nullptr; + } break; } break; @@ -886,7 +1072,7 @@ void listener(sctp_params_t *params) { } } #ifdef UNIT_TEST - break; + break; #endif } } @@ -905,12 +1091,13 @@ void handleConfigChange(sctp_params_t *sctpParams) { path p = (sctpParams->configFilePath + "/" + sctpParams->configFileName).c_str(); auto endlessLoop = true; while (endlessLoop) { -#ifndef UNIT_TEST - auto len = read(sctpParams->inotifyFD, buf, sizeof buf); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + auto len = read(sctpParams->inotifyFD, buf, sizeof buf); #else auto len=10; #endif if (len == -1) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (errno != EAGAIN) { mdclog_write(MDCLOG_ERR, "read %s ", strerror(errno)); endlessLoop = false; @@ -920,6 +1107,7 @@ void handleConfigChange(sctp_params_t *sctpParams) { endlessLoop = false; continue; } +#endif } for (ptr = buf; ptr < buf + len; ptr += sizeof(struct inotify_event) + event->len) { @@ -938,10 +1126,12 @@ void handleConfigChange(sctp_params_t *sctpParams) { // not the directory } if (event->len) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) auto retVal = strcmp(sctpParams->configFileName.c_str(), event->name); if (retVal != 0) { continue; } +#endif } // only the file we want if (event->mask & (uint32_t)IN_CLOSE_WRITE) { @@ -966,31 +1156,7 @@ void handleConfigChange(sctp_params_t *sctpParams) { p.string().c_str(), strerror(errno)); return; } - auto tmpStr = conf.getStringValue("loglevel"); - if (tmpStr.length() == 0) { - mdclog_write(MDCLOG_ERR, "illegal loglevel. Set loglevel to MDCLOG_INFO"); - tmpStr = "info"; - } - transform(tmpStr.begin(), tmpStr.end(), tmpStr.begin(), ::tolower); - - if ((tmpStr.compare("debug")) == 0) { - mdclog_write(MDCLOG_INFO, "Log level set to MDCLOG_DEBUG"); - sctpParams->logLevel = MDCLOG_DEBUG; - } else if ((tmpStr.compare("info")) == 0) { - mdclog_write(MDCLOG_INFO, "Log level set to MDCLOG_INFO"); - sctpParams->logLevel = MDCLOG_INFO; - } else if ((tmpStr.compare("warning")) == 0) { - mdclog_write(MDCLOG_INFO, "Log level set to MDCLOG_WARN"); - sctpParams->logLevel = MDCLOG_WARN; - } else if ((tmpStr.compare("error")) == 0) { - mdclog_write(MDCLOG_INFO, "Log level set to MDCLOG_ERR"); - sctpParams->logLevel = MDCLOG_ERR; - } else { - mdclog_write(MDCLOG_ERR, "illegal loglevel = %s. Set loglevel to MDCLOG_INFO", tmpStr.c_str()); - sctpParams->logLevel = MDCLOG_INFO; - } - mdclog_level_set(sctpParams->logLevel); - tmpStr = conf.getStringValue("trace"); + auto tmpStr = conf.getStringValue("trace"); if (tmpStr.length() == 0) { mdclog_write(MDCLOG_ERR, "illegal trace. Set trace to stop"); tmpStr = "stop"; @@ -1038,7 +1204,7 @@ void handleEinprogressMessages(struct epoll_event &event, socklen_t retValLen = 0; auto rc = getsockopt(peerInfo->fileDescriptor, SOL_SOCKET, SO_ERROR, &retVal, &retValLen); if (rc != 0 || retVal != 0) { -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (rc != 0) { rmrMessageBuffer.sendMessage->len = snprintf((char *)rmrMessageBuffer.sendMessage->payload, 256, "%s|Failed SCTP Connection, after EINPROGRESS the getsockopt%s", @@ -1053,6 +1219,13 @@ void handleEinprogressMessages(struct epoll_event &event, message.message.asnLength = rmrMessageBuffer.sendMessage->len; mdclog_write(MDCLOG_ERR, "%s", rmrMessageBuffer.sendMessage->payload); message.message.direction = 'N'; + mdclog_write(MDCLOG_DEBUG, "Checking the peerInfo->enodbName - %s", peerInfo->enodbName); + if (peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]) + { + mdclog_write(MDCLOG_DEBUG, "Incrementing SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]->Increment(); + mdclog_write(MDCLOG_DEBUG, "Incremented SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + } if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "SCTP_CONNECTION_FAIL message failed to send to xAPP"); } @@ -1062,7 +1235,7 @@ void handleEinprogressMessages(struct epoll_event &event, peerInfo->mtype = 0; return; } - +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) peerInfo->isConnected = true; if (modifyToEpoll(params->epoll_fd, peerInfo, (EPOLLIN | EPOLLET), params->sctpMap, peerInfo->enodbName, @@ -1082,7 +1255,7 @@ void handleEinprogressMessages(struct epoll_event &event, } if (sendSctpMsg(peerInfo, message, params->sctpMap) != 0) { if (mdclog_level_get() >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "Error write to SCTP %s %d", __func__, __LINE__); + mdclog_write(MDCLOG_ERR, "Error write to SCTP %s %d", __func__, __LINE__); } return; } @@ -1090,6 +1263,7 @@ void handleEinprogressMessages(struct epoll_event &event, memset(peerInfo->asnData, 0, peerInfo->asnLength); peerInfo->asnLength = 0; peerInfo->mtype = 0; +#endif } @@ -1097,12 +1271,11 @@ void handlepoll_error(struct epoll_event &event, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t *params) { - if (event.data.fd != params->rmrListenFd) { + if ((event.data.fd != params->rmrListenFd) && (event.data.ptr != nullptr)) { auto *peerInfo = (ConnectedCU_t *)event.data.ptr; mdclog_write(MDCLOG_ERR, "epoll error, events %0x on fd %d, RAN NAME : %s", event.events, peerInfo->fileDescriptor, peerInfo->enodbName); -#ifndef UNIT_TEST - +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) rmrMessageBuffer.sendMessage->len = snprintf((char *)rmrMessageBuffer.sendMessage->payload, 256, "%s|Failed SCTP Connection", peerInfo->enodbName); @@ -1111,13 +1284,29 @@ void handlepoll_error(struct epoll_event &event, memcpy(message.message.enodbName, peerInfo->enodbName, sizeof(peerInfo->enodbName)); message.message.direction = 'N'; + mdclog_write(MDCLOG_DEBUG, "Checking the peerInfo->enodbName - %s", peerInfo->enodbName); + if (peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]) + { + mdclog_write(MDCLOG_DEBUG, "Incrementing SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]->Increment(); + mdclog_write(MDCLOG_DEBUG, "Incremented SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + } if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "SCTP_CONNECTION_FAIL message failed to send to xAPP"); } #endif close(peerInfo->fileDescriptor); - params->sctpMap->erase(peerInfo->enodbName); + 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); } @@ -1150,17 +1339,26 @@ int setSocketNoBlocking(int socket) { * @param m */ void cleanHashEntry(ConnectedCU_t *val, Sctp_Map_t *m) { - char *dummy; - auto port = (uint16_t) strtol(val->portNumber, &dummy, 10); - char searchBuff[2048]{}; - - snprintf(searchBuff, sizeof searchBuff, "host:%s:%d", val->hostName, port); - m->erase(searchBuff); + if(val != nullptr) + { + mdclog_write(MDCLOG_DEBUG, "Inside cleanHashEntry"); + char *dummy; + auto port = (uint16_t) strtol(val->portNumber, &dummy, 10); + char searchBuff[2048]{}; + + snprintf(searchBuff, sizeof searchBuff, "host:%s:%d", val->hostName, port); + if(m->find(searchBuff)) { + m->erase(searchBuff); + } - m->erase(val->enodbName); -#ifndef UNIT_TEST - free(val); -#endif + if(m->find(val->enodbName)) { + mdclog_write(MDCLOG_DEBUG, "remove key enodbName = %s from %s at line %d", val->enodbName, __FUNCTION__, __LINE__); + m->erase(val->enodbName); + } + free(val); + val = nullptr; + mdclog_write(MDCLOG_DEBUG, "After free"); + } } /** @@ -1175,26 +1373,41 @@ void cleanHashEntry(ConnectedCU_t *val, Sctp_Map_t *m) { */ int sendSctpMsg(ConnectedCU_t *peerInfo, ReportingMessages_t &message, Sctp_Map_t *m) { auto loglevel = mdclog_level_get(); +#ifndef UNIT_TEST int fd = peerInfo->fileDescriptor; + int streamId = fetchStreamId(peerInfo,message); +#else + int fd = FILE_DESCRIPTOR; + int streamId = 0; +#endif if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Send SCTP message for CU %s, %s", message.message.enodbName, __FUNCTION__); } while (true) { - if (send(fd,message.message.asndata, message.message.asnLength,MSG_NOSIGNAL) < 0) { + if (sctp_sendmsg(fd,message.message.asndata, message.message.asnLength,(struct sockaddr *) NULL, 0, htonl(E2AP_PPID), 0,streamId,0,0) < 0) { if (errno == EINTR) { continue; } mdclog_write(MDCLOG_ERR, "error writing to CU a message, %s ", strerror(errno)); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (!peerInfo->isConnected) { mdclog_write(MDCLOG_ERR, "connection to CU %s is still in progress.", message.message.enodbName); -#ifndef UNIT_TEST return -1; -#endif } +#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]; snprintf(key, MAX_ENODB_NAME_SIZE * 2, "msg:%s|%d", message.message.enodbName, message.message.messageType); @@ -1204,6 +1417,7 @@ int sendSctpMsg(ConnectedCU_t *peerInfo, ReportingMessages_t &message, Sctp_Map_ auto tmp = m->find(key); if (tmp) { free(tmp); + tmp = nullptr; } m->erase(key); #ifndef UNIT_TEST @@ -1239,7 +1453,30 @@ void getRequestMetaData(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMe } } +void removeE2ConnectionEntryFromMap(char* enbName) +{ + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return; + } + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + mdclog_write(MDCLOG_DEBUG, "Iterating Map e2NodeIdConnectionStatusMap"); + while (itr != connectionHandlingPerE2NodeMap.end()) + { + int result = itr->first.compare(enbName); + if (result == 0) + { + mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus); + mdclog_write(MDCLOG_DEBUG, "Removing the Entry from map for %s", enbName); + connectionHandlingPerE2NodeMap.erase(itr); + mdclog_write(MDCLOG_DEBUG, "Deleted the Entry Successfully from map for %s", enbName); + break; + } + ++itr; + } +} /** * @@ -1261,9 +1498,14 @@ int receiveDataFromSctp(struct epoll_event *events, ReportingMessages_t message {}; auto done = 0; auto loglevel = mdclog_level_get(); + struct sctp_sndrcvinfo sndrcvinfo; + int flags; + int streamId; // get the identity of the interface - message.peerInfo = (ConnectedCU_t *)events->data.ptr; + if (events->data.ptr != nullptr){ + message.peerInfo = (ConnectedCU_t *)events->data.ptr; + } struct timespec start{0, 0}; struct timespec decodeStart{0, 0}; @@ -1278,8 +1520,15 @@ int receiveDataFromSctp(struct epoll_event *events, } // read the buffer directly to rmr payload message.message.asndata = rmrMessageBuffer.sendMessage->payload; +#ifndef UNIT_TEST message.message.asnLength = rmrMessageBuffer.sendMessage->len = - read(message.peerInfo->fileDescriptor, rmrMessageBuffer.sendMessage->payload, RECEIVE_SCTP_BUFFER_SIZE); + sctp_recvmsg(message.peerInfo->fileDescriptor, rmrMessageBuffer.sendMessage->payload, RECEIVE_SCTP_BUFFER_SIZE,(struct sockaddr *) NULL, 0, &sndrcvinfo, &flags); + mdclog_write(MDCLOG_DEBUG, "Start Read from SCTP fd %d stream %d ", message.peerInfo->fileDescriptor, sndrcvinfo.sinfo_stream); + streamId = sndrcvinfo.sinfo_stream; +#else + message.message.asnLength = rmrMessageBuffer.sendMessage->len; + streamId = 0; +#endif if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Finish Read from SCTP %d fd message length = %ld", @@ -1307,8 +1556,8 @@ int receiveDataFromSctp(struct epoll_event *events, } else if (message.message.asnLength == 0) { /* End of file. The remote has closed the connection. */ if (loglevel >= MDCLOG_INFO) { - mdclog_write(MDCLOG_INFO, "END of File Closed connection - descriptor = %d", - message.peerInfo->fileDescriptor); + mdclog_write(MDCLOG_INFO, "END of File Closed connection - descriptor = %d and %s", + message.peerInfo->fileDescriptor, message.peerInfo->enodbName); } done = 1; break; @@ -1329,12 +1578,20 @@ int receiveDataFromSctp(struct epoll_event *events, printBuffer); clock_gettime(CLOCK_MONOTONIC, &decodeStart); } - +#ifndef UNIT_TEST auto rval = asn_decode(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void **) &pdu, - message.message.asndata, message.message.asnLength); + message.message.asndata, message.message.asnLength); +#else + asn_dec_rval_t rval = {RC_OK, 0}; + pdu = (E2AP_PDU_t*)rmrMessageBuffer.sendMessage->tp_buf; +#endif if (rval.code != RC_OK) { mdclog_write(MDCLOG_ERR, "Error %d Decoding (unpack) E2AP PDU from RAN : %s", rval.code, message.peerInfo->enodbName); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } break; } @@ -1355,7 +1612,7 @@ int receiveDataFromSctp(struct epoll_event *events, switch (pdu->present) { case E2AP_PDU_PR_initiatingMessage: {//initiating message - asnInitiatingRequest(pdu, sctpMap,message, rmrMessageBuffer); + asnInitiatingRequest(pdu, sctpMap,message, rmrMessageBuffer, streamId); break; } case E2AP_PDU_PR_successfulOutcome: { //successful outcome @@ -1377,11 +1634,16 @@ int receiveDataFromSctp(struct epoll_event *events, message.peerInfo->enodbName, end.tv_sec - decodeStart.tv_sec, end.tv_nsec - decodeStart.tv_nsec); } numOfMessages++; +#ifndef UNIT_TEST if (pdu != nullptr) { - 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); /* With reset we were not freeing the memory and was causing the leak here. */ + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; } +#else + done = 1; + break; +#endif } if (done) { @@ -1394,16 +1656,47 @@ int receiveDataFromSctp(struct epoll_event *events, "%s|CU disconnected unexpectedly", message.peerInfo->enodbName); message.message.asndata = rmrMessageBuffer.sendMessage->payload; - + #ifndef UNIT_TEST + if (message.peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]) + { + mdclog_write(MDCLOG_DEBUG, "Incrementing SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + message.peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE]->Increment(); + mdclog_write(MDCLOG_DEBUG, "Incremented SCTP_ABORT_INITIATED_BY_E2NODE Counter"); + } + #endif +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "SCTP_CONNECTION_FAIL message failed to send to xAPP"); } +#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); + if (fcntl(message.peerInfo->fileDescriptor, F_GETFD) != -1) { + 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) { clock_gettime(CLOCK_MONOTONIC, &end); @@ -1413,7 +1706,7 @@ int receiveDataFromSctp(struct epoll_event *events, } return 0; } - +#ifndef UNIT_TEST static void buildAndSendSetupRequest(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, E2AP_PDU_t *pdu/*, @@ -1430,16 +1723,21 @@ static void buildAndSendSetupRequest(ReportingMessages_t &message, buffer = (unsigned char *) calloc(buffer_size, sizeof(unsigned char)); if(!buffer) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Allocating buffer for %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); return; +#endif } while (true) { er = asn_encode_to_buffer(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, pdu, buffer, buffer_size); if (er.encoded == -1) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); return; +#endif } else if (er.encoded > (ssize_t) buffer_size) { buffer_size = er.encoded + 128; +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_WARN, "Buffer of size %d is to small for %s. Reallocate buffer of size %d", (int) buffer_size, asn_DEF_E2AP_PDU.name, buffer_size); @@ -1452,10 +1750,12 @@ static void buildAndSendSetupRequest(ReportingMessages_t &message, // out of memory mdclog_write(MDCLOG_ERR, "Reallocating buffer for %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); free(buffer); + buffer = nullptr; return; } buffer = newBuffer; continue; +#endif } buffer[er.encoded] = '\0'; break; @@ -1535,9 +1835,11 @@ static void buildAndSendSetupRequest(ReportingMessages_t &message, rmr_free_msg(rmrMsg); } free(buffer); + buffer = nullptr; return; } +#endif #if 0 int RAN_Function_list_To_Vector(RANfunctions_List_t& list, vector &runFunXML_v) { @@ -1635,10 +1937,88 @@ int collectServiceUpdate_RequestData(E2AP_PDU_t *pdu, #endif +void buildE2TPrometheusCounters(sctp_params_t &sctpParams) { + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_E2setup)] = &sctpParams.prometheusFamily->Add({{"counter", "SetupRequestMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_E2setup)] = &sctpParams.prometheusFamily->Add({{"counter", "SetupRequestBytes"}}); + + sctpParams.e2tCounters[OUT_SUCC][MSG_COUNTER][(ProcedureCode_id_E2setup)] = &sctpParams.prometheusFamily->Add({{"counter", "SetupResponseMsgs"}}); + sctpParams.e2tCounters[OUT_SUCC][BYTES_COUNTER][(ProcedureCode_id_E2setup)] = &sctpParams.prometheusFamily->Add({{"counter", "SetupResponseBytes"}}); + + sctpParams.e2tCounters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup] = &sctpParams.prometheusFamily->Add({{"counter", "SetupRequestFailureMsgs"}}); + sctpParams.e2tCounters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup] = &sctpParams.prometheusFamily->Add({{"counter", "SetupRequestFailureBytes"}}); + + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_E2nodeConfigurationUpdate)] = &sctpParams.prometheusFamily->Add({{"counter", "E2NodeConfigUpdateMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_E2nodeConfigurationUpdate)] = &sctpParams.prometheusFamily->Add({{"counter", "E2NodeConfigUpdateBytes"}}); + + sctpParams.e2tCounters[OUT_SUCC][MSG_COUNTER][(ProcedureCode_id_E2nodeConfigurationUpdate)] = &sctpParams.prometheusFamily->Add({{"counter", "E2NodeConfigUpdateResponseMsgs"}}); + sctpParams.e2tCounters[OUT_SUCC][BYTES_COUNTER][(ProcedureCode_id_E2nodeConfigurationUpdate)] = &sctpParams.prometheusFamily->Add({{"counter", "E2NodeConfigUpdateResponseBytes"}}); + + sctpParams.e2tCounters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "E2NodeConfigUpdateFailureMsgs"}}); + sctpParams.e2tCounters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "E2NodeConfigUpdateFailureBytes"}}); + + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_ErrorIndication)] = &sctpParams.prometheusFamily->Add({{"counter", "ErrorIndicationMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_ErrorIndication)] = &sctpParams.prometheusFamily->Add({{"counter", "ErrorIndicationBytes"}}); + + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_Reset] = &sctpParams.prometheusFamily->Add({{"counter", "ResetRequestMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_Reset] = &sctpParams.prometheusFamily->Add({{"counter", "ResetRequestBytes"}}); + + sctpParams.e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_Reset] = &sctpParams.prometheusFamily->Add({{"counter", "ResetAckMsgs"}}); + sctpParams.e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset] = &sctpParams.prometheusFamily->Add({{"counter", "ResetAckBytes"}}); + + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateBytes"}}); + + sctpParams.e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateRespMsgs"}}); + sctpParams.e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateRespBytes"}}); + + sctpParams.e2tCounters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateFailureMsgs"}}); + sctpParams.e2tCounters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateFailureBytes"}}); + + sctpParams.e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlMsgs"}}); + sctpParams.e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlBytes"}}); + + sctpParams.e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlAckMsgs"}}); + sctpParams.e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlAckBytes"}}); + + sctpParams.e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlFailureMsgs"}}); + sctpParams.e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlFailureBytes"}}); + + sctpParams.e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionMsgs"}}); + sctpParams.e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionBytes"}}); + + sctpParams.e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionAckMsgs"}}); + sctpParams.e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionAckBytes"}}); + + sctpParams.e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionFailureMsgs"}}); + sctpParams.e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionFailureBytes"}}); + + sctpParams.e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteMsgs"}}); + sctpParams.e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteBytes"}}); + + sctpParams.e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteAckMsgs"}}); + sctpParams.e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteAckBytes"}}); + + sctpParams.e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteFailMsgs"}}); + sctpParams.e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteFailBytes"}}); + + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICindication] = &sctpParams.prometheusFamily->Add({{"counter", "RICIndicationMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICindication] = &sctpParams.prometheusFamily->Add({{"counter", "RICIndicationBytes"}}); + + sctpParams.e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceQuery] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceQueryMsgs"}}); + sctpParams.e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceQueryBytes"}}); + + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDeleteRequired] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteRequiredMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDeleteRequired] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteRequiredBytes"}}); + +} + void buildPrometheusList(ConnectedCU_t *peerInfo, Family *prometheusFamily) { peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_E2setup)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"SetupRequest", "Messages"}}); peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_E2setup)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"SetupRequest", "Bytes"}}); + peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_E2nodeConfigurationUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"E2NodeConfigUpdate", "Messages"}}); + peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_E2nodeConfigurationUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"E2NodeConfigUpdate", "Bytes"}}); + peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_ErrorIndication)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ErrorIndication", "Messages"}}); peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_ErrorIndication)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ErrorIndication", "Bytes"}}); @@ -1695,6 +2075,9 @@ void buildPrometheusList(ConnectedCU_t *peerInfo, Family *prometheusFam peerInfo->counters[OUT_SUCC][MSG_COUNTER][(ProcedureCode_id_E2setup)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"SetupResponse", "Messages"}}); peerInfo->counters[OUT_SUCC][BYTES_COUNTER][(ProcedureCode_id_E2setup)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"SetupResponse", "Bytes"}}); + peerInfo->counters[OUT_SUCC][MSG_COUNTER][(ProcedureCode_id_E2nodeConfigurationUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"E2NodeConfigUpdateSuccess", "Messages"}}); + peerInfo->counters[OUT_SUCC][BYTES_COUNTER][(ProcedureCode_id_E2nodeConfigurationUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"E2NodeConfigUpdateSuccess", "Bytes"}}); + peerInfo->counters[OUT_SUCC][MSG_COUNTER][(ProcedureCode_id_Reset)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ResetACK", "Messages"}}); peerInfo->counters[OUT_SUCC][BYTES_COUNTER][(ProcedureCode_id_Reset)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ResetACK", "Bytes"}}); @@ -1704,9 +2087,28 @@ void buildPrometheusList(ConnectedCU_t *peerInfo, Family *prometheusFam peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_E2setup)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"SetupRequestFailure", "Messages"}}); peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_E2setup)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"SetupRequestFailure", "Bytes"}}); + peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_E2nodeConfigurationUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"E2NodeConfigUpdateFailure", "Messages"}}); + peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_E2nodeConfigurationUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"E2NodeConfigUpdateFailure", "Bytes"}}); + peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICserviceUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceUpdateFailure", "Messages"}}); peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICserviceUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceUpdateFailure", "Bytes"}}); + + + peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_RICsubscriptionDeleteRequired)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteRequired", "Messages"}}); + peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_RICsubscriptionDeleteRequired)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteRequired", "Bytes"}}); + + peerInfo->counters[IN_SUCC][MSG_COUNTER][(ProcedureCode_id_E2connectionUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"UnsupportedE2ConnectionUpdateAck", "Messages"}}); + peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_E2connectionUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"UnsupportedE2ConnectionUpdateFail", "Messages"}}); +} + +#ifndef UNIT_TEST +void buildInternalCounterPrometheusList(ConnectedCU_t *peerInfo, Family *prometheusFamily) +{ + mdclog_write(MDCLOG_DEBUG, "Inside buildInternalCounterPrometheusList"); + peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE] = &prometheusFamily->Add({{"NODEB", peerInfo->enodbName}, {"counter", "SctpAbortInitiatedByE2Node"}}); + peerInfo->e2tInternalCounters[E2T_Internal_Counters::INVALID_MESSAGE_RECEIVED] = &prometheusFamily->Add({{"NODEB", peerInfo->enodbName}, {"counter", "InvalidMessageReceived"}}); } +#endif /** * * @param pdu @@ -1715,21 +2117,24 @@ void buildPrometheusList(ConnectedCU_t *peerInfo, Family *prometheusFam * @param RANfunctionsAdded_v * @return */ -int collectSetupRequestData(E2AP_PDU_t *pdu, - Sctp_Map_t *sctpMap, - ReportingMessages_t &message /*, vector &RANfunctionsAdded_v*/) { - memset(message.peerInfo->enodbName, 0 , MAX_ENODB_NAME_SIZE); - for (auto i = 0; i < pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count; i++) { +long collectSetupRequestData(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message /*, vector &RANfunctionsAdded_v*/) { + long transactionId = negativeOne; + memset(message.peerInfo->enodbName, numberZero , MAX_ENODB_NAME_SIZE); + for (auto i = numberZero; i < pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count; i++) { auto *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[i]; if (ie->id == ProtocolIE_ID_id_GlobalE2node_ID) { // get the ran name for meid if (ie->value.present == E2setupRequestIEs__value_PR_GlobalE2node_ID) { - if (buildRanName(message.peerInfo->enodbName, ie) < 0) { + mdclog_write(MDCLOG_DEBUG, "GnbId is present"); + #ifndef UNIT_TEST + if (buildRanName(message.peerInfo->enodbName, ie) < numberZero) { mdclog_write(MDCLOG_ERR, "Bad param in E2setupRequestIEs GlobalE2node_ID.\n"); // no message will be sent - return -1; + return negativeOne; } - + #endif memcpy(message.message.enodbName, message.peerInfo->enodbName, strlen(message.peerInfo->enodbName)); sctpMap->setkey(message.message.enodbName, message.peerInfo); } @@ -1744,12 +2149,20 @@ int collectSetupRequestData(E2AP_PDU_t *pdu, } } } */ + if (ie->id == ProtocolIE_ID_id_TransactionID) { + if (ie->value.present == E2setupRequestIEs__value_PR_TransactionID) { + mdclog_write(MDCLOG_DEBUG, "TransactionId is present in E2SetupReq"); + + transactionId = ie->value.choice.TransactionID; + mdclog_write(MDCLOG_DEBUG, "TransactionId is %ld", transactionId); + } + } } // if (mdclog_level_get() >= MDCLOG_DEBUG) { // mdclog_write(MDCLOG_DEBUG, "Run function vector have %ld entries", // RANfunctionsAdded_v.size()); // } - return 0; + return transactionId; } int XML_From_PER(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { @@ -1765,6 +2178,10 @@ int XML_From_PER(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBu mdclog_write(MDCLOG_ERR, "Error %d Decoding (unpack) setup response from E2MGR : %s", rval.code, message.message.enodbName); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return -1; } @@ -1773,6 +2190,10 @@ int XML_From_PER(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBu rmrMessageBuffer.sendMessage->payload, buff_size); if (er.encoded == -1) { mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } 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", @@ -1780,9 +2201,17 @@ int XML_From_PER(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBu asn_DEF_E2AP_PDU.name, __func__, __LINE__); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return -1; } rmrMessageBuffer.sendMessage->len = er.encoded; + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return 0; } @@ -1796,7 +2225,7 @@ int XML_From_PER(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBu void asnInitiatingRequest(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, - RmrMessagesBuffer_t &rmrMessageBuffer) { + RmrMessagesBuffer_t &rmrMessageBuffer, int streamId) { auto logLevel = mdclog_level_get(); auto procedureCode = ((InitiatingMessage_t *) pdu->choice.initiatingMessage)->procedureCode; if (logLevel >= MDCLOG_DEBUG) { @@ -1804,6 +2233,7 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, } switch (procedureCode) { case ProcedureCode_id_E2setup: { + if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got E2setup"); } @@ -1812,24 +2242,34 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, // vector RANfunctionsModified_v; // RANfunctionsAdded_v.clear(); // RANfunctionsModified_v.clear(); - if (collectSetupRequestData(pdu, sctpMap, message) != 0) { + long transactionID = collectSetupRequestData(pdu, sctpMap, message); + mdclog_write(MDCLOG_DEBUG, "transactionID returned is %ld", transactionID); + + if (transactionID < numberZero) + { + 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); - buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); + mdclog_write(MDCLOG_DEBUG, "Calling handleE2SetupReq"); + handleE2SetupReq(message, rmrMessageBuffer, pdu, transactionID, streamId, sctpMap); break; } case ProcedureCode_id_RICserviceUpdate: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived) + { + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICserviceUpdate"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICserviceUpdate %s", message.message.enodbName); } + + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state is %d", message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); // vector RANfunctionsAdded_v; // vector RANfunctionsModified_v; // RANfunctionsAdded_v.clear(); @@ -1842,48 +2282,187 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, string messageName("RICserviceUpdate"); string ieName("RICserviceUpdateIEs"); message.message.messageType = RIC_SERVICE_UPDATE; -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + 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_ErrorIndication: { + +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 ErrorIndication %s", message.message.enodbName); + mdclog_write(MDCLOG_DEBUG, "Got E2nodeConfigurationUpdate %s", message.message.enodbName); } -#ifndef UNIT_TEST + + string messageName("RICE2nodeConfigurationUpdate"); + string ieName("RICE2nodeConfigurationUpdateIEs"); + message.message.messageType = RIC_E2NODE_CONFIG_UPDATE; +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment(); + message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment((double)message.message.asnLength); + + // 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); + + buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); +#endif + break; + } + + case ProcedureCode_id_ErrorIndication: { + 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 ; + } + + asn_fprint(stdout, &asn_DEF_E2AP_PDU, pdu); + + mdclog_write(MDCLOG_INFO, "Got ErrorIndication %s sub id = %d, mtype = %d", message.message.enodbName, + rmrMessageBuffer.sendMessage->sub_id, rmrMessageBuffer.sendMessage->mtype); + + int procedureCode = numberZero; + bitset isRequiredIesPresent(0); // TransactionId==0, RicRequestId==1, Cause==2 + + for (auto i = numberZero; i < pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count; i++) { + ErrorIndication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[i]; + if (ie->id == ProtocolIE_ID_id_TransactionID) { + if (ie->value.present == ErrorIndication_IEs__value_PR_TransactionID) { + mdclog_write(MDCLOG_DEBUG, "TransactionID in ErrorIndication Message is %ld ", ie->value.choice.TransactionID); + if (e2NodeConnectionHandling.e2SetupProcedureTransactionId == ie->value.choice.TransactionID) + { + isRequiredIesPresent.set(transactionIdIeBitSetPosition); + } + } + } + if (ie->id == ProtocolIE_ID_id_RICrequestID) { + if (ie->value.present == ErrorIndication_IEs__value_PR_RICrequestID) { + isRequiredIesPresent.set(ricRequestIdIeBitSetPosition); + mdclog_write(MDCLOG_DEBUG, "RIC instance id %ld, RIC requestor id = %ld", + ie->value.choice.RICrequestID.ricInstanceID, + ie->value.choice.RICrequestID.ricRequestorID); + } + } + if (ie->id == ProtocolIE_ID_id_Cause) { + if (ie->value.present == ErrorIndication_IEs__value_PR_Cause) { + isRequiredIesPresent.set(causeIeBitSetPosition); + } + } + if (ie->id == ProtocolIE_ID_id_CriticalityDiagnostics) { + if (ie->value.present == ErrorIndication_IEs__value_PR_CriticalityDiagnostics) { + if (ie->value.choice.CriticalityDiagnostics.procedureCode) + { + procedureCode = *(ie->value.choice.CriticalityDiagnostics.procedureCode); + mdclog_write(MDCLOG_DEBUG, "ProcedureCode Value is %ld", procedureCode); + } + } + } + } + + // Msg being sent to E2M = 0, Msg being sent to SubMgr = 1 + bitset sendMsgTo = getSendMsgBitSetValue(procedureCode, isRequiredIesPresent, message.message.enodbName); + + if(sendMsgTo.test(sendMsgToE2MBitSetPosition)) + { + message.message.messageType = RIC_E2_RIC_ERROR_INDICATION; + mdclog_write(MDCLOG_INFO, "Sending ErrorIndication Message to E2Manager"); + #ifndef UNIT_TEST + buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); + #endif + } + else if (sendMsgTo.test(sendMsgToSubMgrBitSetPosition)) + { + if (sendRequestToXapp(message, RIC_E2_RAN_ERROR_INDICATION, rmrMessageBuffer) != 0) { + mdclog_write(MDCLOG_ERR, "Subscription successful message failed to send to SubMgr"); + } + else { + mdclog_write(MDCLOG_INFO, "Successfully Sent ErrorIndication Message to SubMgr"); + } + } + else + { + mdclog_write(MDCLOG_INFO, "No action taken on ErrorIndication Message as TransactionId/Ric RequestID/Cause not present/invalid"); + } + + #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment((double)message.message.asnLength); -#endif + + // 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 + + /*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); } -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + 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) { @@ -1901,7 +2480,7 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, 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; @@ -1912,9 +2491,13 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, ie->value.choice.RICrequestID.ricInstanceID, ie->value.choice.RICrequestID.ricRequestorID); } -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICindication]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICindication]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICindication]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICindication]->Increment((double)message.message.asnLength); #endif sendRmrMessage(rmrMessageBuffer, message); messageSent = true; @@ -1923,14 +2506,59 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, } } 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); + } + #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDeleteRequired]->Increment(); + message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDeleteRequired]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDeleteRequired]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDeleteRequired]->Increment((double)message.message.asnLength); + #endif + if (sendRequestToXapp(message, RIC_SUB_DEL_REQUIRED, rmrMessageBuffer) != 0) { + mdclog_write(MDCLOG_ERR, "Subscription Delete Required message failed to send to xAPP"); + } + break; + } + 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); @@ -1956,14 +2584,26 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, } switch (procedureCode) { case ProcedureCode_id_Reset: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived) + { + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received Reset message"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got Reset %s", message.message.enodbName); } -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + 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) { @@ -1972,10 +2612,17 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, break; } case ProcedureCode_id_RICcontrol: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICcontrol"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICcontrol %s", message.message.enodbName); } - for (auto i = 0; + for (auto i = numberZero; i < pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count; i++) { auto messageSent = false; RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[i]; @@ -1988,7 +2635,7 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, } if (ie->value.present == RICcontrolAcknowledge_IEs__value_PR_RICrequestID) { message.message.messageType = rmrMessageBuffer.sendMessage->mtype = RIC_CONTROL_ACK; - rmrMessageBuffer.sendMessage->state = 0; + rmrMessageBuffer.sendMessage->state = numberZero; // rmrMessageBuffer.sendMessage->sub_id = (int) ie->value.choice.RICrequestID.ricRequestorID; rmrMessageBuffer.sendMessage->sub_id = (int)ie->value.choice.RICrequestID.ricInstanceID; @@ -1998,9 +2645,13 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, rmr_bytes2meid(rmrMessageBuffer.sendMessage, (unsigned char *)message.message.enodbName, strlen(message.message.enodbName)); -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment((double)message.message.asnLength); #endif sendRmrMessage(rmrMessageBuffer, message); messageSent = true; @@ -2009,6 +2660,8 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, } } if (messageSent) { + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure State is %d", message.message.enodbName, CONTROL_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, CONTROL_PROCEDURE_COMPLETED); break; } } @@ -2016,34 +2669,91 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, break; } case ProcedureCode_id_RICsubscription: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICsubscription"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscription %s", message.message.enodbName); } -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + 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); } -#ifndef UNIT_TEST + + 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); + + // Update E2T instance level metrics + 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; @@ -2068,6 +2778,14 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, } switch (procedureCode) { case ProcedureCode_id_RICcontrol: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived) + { + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICcontrol"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICcontrol %s", message.message.enodbName); } @@ -2092,10 +2810,14 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, rmr_bytes2xact(rmrMessageBuffer.sendMessage, tx, strlen((const char *) tx)); rmr_bytes2meid(rmrMessageBuffer.sendMessage, (unsigned char *) message.message.enodbName, strlen(message.message.enodbName)); -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment((double)message.message.asnLength); -#endif + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment((double)message.message.asnLength); +#endif sendRmrMessage(rmrMessageBuffer, message); messageSent = true; } else { @@ -2109,12 +2831,23 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, break; } case ProcedureCode_id_RICsubscription: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICsubscription"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscription %s", message.message.enodbName); } -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment((double)message.message.asnLength); #endif if (sendRequestToXapp(message, RIC_SUB_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "Subscription unsuccessful message failed to send to xAPP"); @@ -2122,12 +2855,23 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, break; } case ProcedureCode_id_RICsubscriptionDelete: { + struct E2NodeConnectionHandling e2NodeConnectionHandling; + bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling); + mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false"); + if (!isE2SetupRequestReceived){ + mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received RICsubscriptionDelete"); + return ; + } if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscriptionDelete %s", message.message.enodbName); } -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment((double)message.message.asnLength); #endif if (sendRequestToXapp(message, RIC_SUB_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "Subscription Delete unsuccessful message failed to send to xAPP"); @@ -2135,14 +2879,297 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, break; } default: { - mdclog_write(MDCLOG_WARN, "Undefined or not supported message = %ld", procedureCode); - message.message.messageType = 0; // no RMR message type yet - + 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); + break; + } + } +} +bool getE2tProcedureOngoingStatus(char *enbName, E2NodeConnectionHandling &e2NodeConnectionHandling) +{ + mdclog_write(MDCLOG_DEBUG, "Inside getE2tProcedureOngoingStatus, Checking for enb %s", enbName); + if(strcmp(enbName, "") == 0) + { + mdclog_write(MDCLOG_DEBUG, "enbName is empty"); + return false; + } + else if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return false; + } + else + { + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + while (itr != connectionHandlingPerE2NodeMap.end()) + { + int result = itr->first.compare(enbName); + if (result == 0) + { + mdclog_write(MDCLOG_DEBUG, "enb name in map :%s, status :%d", itr->first.c_str(), itr->second.e2tProcedureOngoingStatus); + e2NodeConnectionHandling = itr->second; + return true; + break; + } + ++itr; + } + } + return false; +} + +void setE2ProcedureOngoingStatus(char *enbName, E2T_Procedure_States state) +{ + printEntryPresentInMap(); + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return; + } + else + { + mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map"); + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + while(itr != connectionHandlingPerE2NodeMap.end()) + { + int result = itr->first.compare(enbName); + if (result == 0) + { + mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus); + itr->second.e2tProcedureOngoingStatus = state; + mdclog_write(MDCLOG_DEBUG, "Current procedure updated to %d", itr->second.e2tProcedureOngoingStatus); + break; + } + ++itr; + } + } +} + +void insertE2SetupProcedureOngoing(char *enbName, long &transactionID) +{ + struct E2NodeConnectionHandling e2NodeConnectionHandling; + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_ONGOING; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = transactionID; + + std::string key(enbName); + printEntryPresentInMap(); + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + mdclog_write(MDCLOG_DEBUG, "Inserting %s to connectionHandlingPerE2NodeMap Map", enbName); + + connectionHandlingPerE2NodeMap.insert(std::make_pair(key, e2NodeConnectionHandling)); + + mdclog_write(MDCLOG_DEBUG, "Default Value after Inserting Key for %s - Value is {e2tProcedureOngoingStatus is %d, e2SetupProcedureTransactionId: %ld}", + key.c_str(), + e2NodeConnectionHandling.e2tProcedureOngoingStatus, + e2NodeConnectionHandling.e2SetupProcedureTransactionId); + return; + } + else + { + mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map"); + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + bool enodebNameFound = false; + while(itr != connectionHandlingPerE2NodeMap.end()) + { + int result = itr->first.compare(enbName); + if (result == 0) + { + enodebNameFound = true; + break; + } + ++itr; + } + if (enodebNameFound == false) + { + mdclog_write(MDCLOG_DEBUG, "Inserting %s to connectionHandlingPerE2NodeMap Map", enbName); + connectionHandlingPerE2NodeMap.insert(std::make_pair(key, e2NodeConnectionHandling)); + + mdclog_write(MDCLOG_DEBUG, "Default Value after Inserting Key for %s - Value is {e2tProcedureOngoingStatus is %d, e2SetupProcedureTransactionId: %ld}", + key.c_str(), + e2NodeConnectionHandling.e2tProcedureOngoingStatus, + e2NodeConnectionHandling.e2SetupProcedureTransactionId); + } + else + { + mdclog_write(MDCLOG_DEBUG, "Processing E2Setup Req received for same gnb - %s", enbName); + setE2ProcedureOngoingStatus(enbName, E2_SETUP_PROCEDURE_ONGOING); + } + } +} + +E2T_Procedure_States currentE2tProcedureOngoingStatus(char *enbName) +{ + printEntryPresentInMap(); + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return E2_SETUP_PROCEDURE_NOT_INITIATED; + } + else + { + mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map"); + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + while(itr != connectionHandlingPerE2NodeMap.end()) + { + int result = itr->first.compare(enbName); + if (result == 0) + { + mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus); + mdclog_write(MDCLOG_DEBUG, "%s Entry has found", enbName); + return itr->second.e2tProcedureOngoingStatus; + } + ++itr; + } + mdclog_write(MDCLOG_DEBUG, "No Key %s Found in connectionHandlingPerE2NodeMap Map", enbName); + return E2_SETUP_PROCEDURE_NOT_INITIATED; + } +} + +bitset getSendMsgBitSetValue(int procedureCode, bitset isRequiredIesPresent, char* enbName) +{ + bitset sendMsgTo(0); // Msg being sent to E2M = 0, Msg being sent to SubMgr = 1 + switch(procedureCode) + { + case numberZero: + { + E2T_Procedure_States currentProcedureOngoing = currentE2tProcedureOngoingStatus(enbName); + if ((currentProcedureOngoing == E2_SETUP_PROCEDURE_COMPLETED || + currentProcedureOngoing == RIC_SERVICE_UPDATE_PROCEDURE_ONGOING) && + (isRequiredIesPresent.test(transactionIdIeBitSetPosition))) + { + sendMsgTo.set(sendMsgToE2MBitSetPosition); + } + else if ((currentProcedureOngoing == RIC_SUBS_PROCEDURE_ONGOING) && + isRequiredIesPresent.test(ricRequestIdIeBitSetPosition) && isRequiredIesPresent.test(causeIeBitSetPosition)) + { + sendMsgTo.set(sendMsgToSubMgrBitSetPosition); + } break; } + case ProcedureCode_id_E2setup: + case ProcedureCode_id_RICserviceUpdate: + { + if(isRequiredIesPresent.test(transactionIdIeBitSetPosition)) + { + sendMsgTo.set(sendMsgToE2MBitSetPosition); + } + break; + + } + case ProcedureCode_id_RICsubscription: + { + if(isRequiredIesPresent.test(ricRequestIdIeBitSetPosition) && isRequiredIesPresent.test(causeIeBitSetPosition)) + { + sendMsgTo.set(sendMsgToSubMgrBitSetPosition); + } + break; + } + default: + { + mdclog_write(MDCLOG_ERR, "Invalid procedure code received"); + } } + return sendMsgTo; +} + +void printEntryPresentInMap() +{ + mdclog_write(MDCLOG_DEBUG, "Inside printEntryPresentInMap"); + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return; + } + else + { + mdclog_write(MDCLOG_DEBUG, "Entry Present in Map"); + std::map::iterator it = connectionHandlingPerE2NodeMap.begin(); + while (it != connectionHandlingPerE2NodeMap.end()) + { + mdclog_write(MDCLOG_DEBUG, "Key -> { enb name in map : %s }, Value -> { e2tProcedureOngoingStatus is %d, e2SetupProcedureTransactionId is %ld }", it->first.c_str(), it->second.e2tProcedureOngoingStatus, it->second.e2SetupProcedureTransactionId); + ++it; + } + mdclog_write(MDCLOG_DEBUG, "All entries currently present in connectionHandlingPerE2NodeMap are printed successfully"); + } +} + +void handleE2SetupReq(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, E2AP_PDU_t *pdu, long &transactionID, int streamId, Sctp_Map_t *sctpMap) +{ + auto logLevel = mdclog_level_get(); + + #ifndef UNIT_TEST + buildPrometheusList(message.peerInfo, message.peerInfo->sctpParams->prometheusFamily); + buildInternalCounterPrometheusList(message.peerInfo, message.peerInfo->sctpParams->prometheusFamily); + #endif + + struct sctp_status status; + int stat_size = sizeof(status); + getsockopt( message.peerInfo->fileDescriptor, SOL_SCTP, SCTP_STATUS,(void *)&status, (socklen_t *)&stat_size ); + + if (logLevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "Start from SCTP %d fd", message.peerInfo->fileDescriptor); + mdclog_write(MDCLOG_DEBUG, "SCTP status assoc id %d instrms %d outstrms %d", status.sstat_assoc_id, + status.sstat_instrms, status.sstat_outstrms); + } + if(status.sstat_outstrms == numberOne || status.sstat_instrms == numberOne) + { + message.peerInfo->isSingleStream = true; + message.peerInfo->singleStreamId = streamId; + if (status.sstat_outstrms == numberOne && status.sstat_instrms == numberOne){ + if (logLevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "Single SCTP stream is used for sending from now on, assoc id %d streamId %d #instrms %d #outstrms %d, %s",status.sstat_assoc_id, streamId, status.sstat_instrms, status.sstat_outstrms, __FUNCTION__); + } + } + else { + mdclog_write(MDCLOG_ERR, "Single SCTP stream used for sending messages even if there is a mismatch in number of in & out streams, assoc id %d instrms %d outstrms %d", status.sstat_assoc_id, + status.sstat_instrms, status.sstat_outstrms); + } + } + + string messageName("E2setupRequest"); + string ieName("E2setupRequestIEs"); + message.message.messageType = RIC_E2_SETUP_REQ; + #ifndef UNIT_TEST + message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); + message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment((double)message.message.asnLength); + + buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); //UT - Segmentation Fault Happening. + #endif + + mdclog_write(MDCLOG_DEBUG, "Called insertE2ProcedureOngoing: EnbName is %s and transactionID is %ld", message.message.enodbName, transactionID); + insertE2SetupProcedureOngoing(message.message.enodbName, transactionID); } /** @@ -2159,7 +3186,7 @@ int sendRequestToXapp(ReportingMessages_t &message, (unsigned char *)message.message.enodbName, strlen(message.message.enodbName)); message.message.messageType = rmrMmessageBuffer.sendMessage->mtype = requestId; - rmrMmessageBuffer.sendMessage->state = 0; + rmrMmessageBuffer.sendMessage->state = numberZero; static unsigned char tx[32]; snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++); rmr_bytes2xact(rmrMmessageBuffer.sendMessage, tx, strlen((const char *) tx)); @@ -2180,6 +3207,7 @@ void getRmrContext(sctp_params_t &pSctpParams) { return; } + rmr_set_low_latency(pSctpParams.rmrCtx); rmr_set_stimeout(pSctpParams.rmrCtx, 0); // disable retries for any send operation // we need to find that routing table exist and we can run if (mdclog_level_get() >= MDCLOG_INFO) { @@ -2234,9 +3262,16 @@ int PER_FromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuf mdclog_write(MDCLOG_DEBUG, "%s After decoding the XML to PDU", __func__ ); } if (rval.code != RC_OK) { +#ifdef UNIT_TEST + return 0; +#endif mdclog_write(MDCLOG_ERR, "Error %d Decoding (unpack) setup response from E2MGR : %s", rval.code, message.message.enodbName); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return -1; } @@ -2248,6 +3283,10 @@ int PER_FromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuf } if (er.encoded == -1) { mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } 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", @@ -2255,9 +3294,17 @@ int PER_FromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuf asn_DEF_E2AP_PDU.name, __func__, __LINE__); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return -1; } rmrMessageBuffer.rcvMessage->len = er.encoded; + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return 0; } @@ -2275,7 +3322,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (rmrMessageBuffer.rcvMessage == nullptr) { //we have error mdclog_write(MDCLOG_ERR, "RMR Allocation message, %s", strerror(errno)); - return -1; + return negativeOne; } // if (loglevel >= MDCLOG_DEBUG) { @@ -2295,11 +3342,11 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, // get message payload //auto msgData = msg->payload; #ifdef UNIT_TEST - rmrMessageBuffer.rcvMessage->state = 0; + 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); @@ -2311,13 +3358,16 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, case RIC_HEALTH_CHECK_REQ: break; default: +#ifdef UNIT_TEST + 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) { @@ -2325,41 +3375,109 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_E2_SETUP_RESP"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment(rmrMessageBuffer.rcvMessage->len); - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + + // Update E2T instance level metrics + 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, 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->counters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); message.peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment(rmrMessageBuffer.rcvMessage->len); - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + + // Update E2T instance level metrics + 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, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_SETUP_FAILURE"); + 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; + } + + case RIC_E2NODE_CONFIG_UPDATE_ACK: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_E2NODE_CONFIG_UPDATE_ACK"); + } + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { + break; + } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + message.peerInfo->counters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment(); + message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + 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, numberZero, sctpMap) != numberZero) { + mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2NODE_CONFIG_UPDATE_ACK"); return -6; } break; } + + case RIC_E2NODE_CONFIG_UPDATE_FAILURE: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_E2NODE_CONFIG_UPDATE_FAILURE"); + } + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { + break; + } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + message.peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment(); + message.peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_E2nodeConfigurationUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + 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, numberZero, sctpMap) != numberZero) { + mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2NODE_CONFIG_UPDATE_FAILURE"); + return -6; + } + break; + } + case RIC_ERROR_INDICATION: { if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_ERROR_INDICATION"); } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(rmrMessageBuffer.rcvMessage->len); - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + + // 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(rmrMessageBuffer.rcvMessage->len); +#endif + if (sendDirectionalSctpMsg(rmrMessageBuffer, message, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_ERROR_INDICATION"); - return -6; + return negativeSix; } break; } @@ -2367,69 +3485,115 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_SUB_REQ"); } + + mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state is %d", message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); + setE2ProcedureOngoingStatus(message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment(rmrMessageBuffer.rcvMessage->len); - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + + // Update E2T instance level metrics + 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, 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); - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + + // Update E2T instance level metrics + 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, 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); - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + + // Update E2T instance level metrics + 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, 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->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceQuery]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery]->Increment(rmrMessageBuffer.rcvMessage->len); - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + + // Update E2T instance level metrics + 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, 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 !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); + message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif 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; } @@ -2437,14 +3601,20 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_SERVICE_UPDATE_FAILURE"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); message.peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + + // Update E2T instance level metrics + 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, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SERVICE_UPDATE_FAILURE"); - return -6; + return negativeSix; } break; } @@ -2452,11 +3622,17 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_E2_RESET_REQ"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_RESET"); return -6; @@ -2467,12 +3643,18 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "RIC_E2_RESET_RESP"); } - if (PER_FromXML(message, rmrMessageBuffer) != 0) { + if (PER_FromXML(message, rmrMessageBuffer) != numberZero) { break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment(rmrMessageBuffer.rcvMessage->len); - if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { + + // Update E2T instance level metrics + 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, numberZero, sctpMap) != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_RESET_RESP"); return -6; } @@ -2502,10 +3684,11 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, peerInfo->enodbName); message.message.asndata = rmrMessageBuffer.sendMessage->payload; mdclog_write(MDCLOG_INFO, "%s", message.message.asndata); - if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != 0) { + if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != numberZero) { mdclog_write(MDCLOG_ERR, "SCTP_CONNECTION_FAIL message failed to send to xAPP"); } free(peerInfo); + peerInfo = nullptr; } } @@ -2519,17 +3702,17 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, (unsigned char *)rmrMessageBuffer.ka_message, rmrMessageBuffer.ka_message_len); rmrMessageBuffer.sendMessage->mtype = E2_TERM_KEEP_ALIVE_RESP; - rmrMessageBuffer.sendMessage->state = 0; + rmrMessageBuffer.sendMessage->state = numberZero; static unsigned char tx[32]; auto txLen = snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++); rmr_bytes2xact(rmrMessageBuffer.sendMessage, tx, txLen); -#ifndef UNIT_TEST +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage); #endif 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) { @@ -2539,13 +3722,13 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_HEALTH_CHECK_REQ: { - static int counter = 0; + static int counter = numberZero; // send message back rmr_bytes2payload(rmrMessageBuffer.rcvMessage, (unsigned char *)"OK", - 2); + numberTwo); rmrMessageBuffer.rcvMessage->mtype = RIC_HEALTH_CHECK_RESP; - rmrMessageBuffer.rcvMessage->state = 0; + rmrMessageBuffer.rcvMessage->state = numberZero; static unsigned char tx[32]; auto txLen = snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++); rmr_bytes2xact(rmrMessageBuffer.rcvMessage, tx, txLen); @@ -2554,10 +3737,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, if (rmrMessageBuffer.rcvMessage == nullptr) { rmrMessageBuffer.rcvMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); mdclog_write(MDCLOG_ERR, "Failed to send RIC_HEALTH_CHECK_RESP RMR message returned NULL"); - } else if (rmrMessageBuffer.rcvMessage->state != 0) { + } else if (rmrMessageBuffer.rcvMessage->state != numberZero) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_HEALTH_CHECK_RESP, on RMR state = %d ( %s)", rmrMessageBuffer.rcvMessage->state, translateRmrErrorMessages(rmrMessageBuffer.rcvMessage->state).c_str()); - } else if (loglevel >= MDCLOG_DEBUG && ++counter % 100 == 0) { + } else if (loglevel >= MDCLOG_DEBUG && (++counter % 100 == numberZero)) { mdclog_write(MDCLOG_DEBUG, "Got %d RIC_HEALTH_CHECK_REQ Request send : OK", counter); } @@ -2565,7 +3748,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, } default: - mdclog_write(MDCLOG_WARN, "Message Type : %d is not supported", rmrMessageBuffer.rcvMessage->mtype); + mdclog_write(MDCLOG_ERR, "Message Type : %d is not supported", rmrMessageBuffer.rcvMessage->mtype); message.message.asndata = rmrMessageBuffer.rcvMessage->payload; message.message.asnLength = rmrMessageBuffer.rcvMessage->len; message.message.time.tv_nsec = ts.tv_nsec; @@ -2575,12 +3758,12 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, buildJsonMessage(message); - return -7; + return negativeSeven; } if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "EXIT OK from %s", __FUNCTION__); } - return 0; + return numberZero; } /** @@ -2622,6 +3805,7 @@ int sendMessagetoCu(Sctp_Map_t *sctpMap, int failedMesgId) { // get the FD message.message.messageType = messageBuffer.rcvMessage->mtype; + mdclog_write(MDCLOG_DEBUG, "message.message.messageType is %d", message.message.messageType); auto rc = sendSctpMsg(message.peerInfo, message, sctpMap); return rc; } @@ -2647,31 +3831,41 @@ int addToEpoll(int epoll_fd, struct epoll_event event{}; event.data.ptr = peerInfo; event.events = events; - if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, peerInfo->fileDescriptor, &event) < 0) { + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, peerInfo->fileDescriptor, &event) < numberZero) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "epoll_ctl EPOLL_CTL_ADD (may check not to quit here), %s, %s %d", strerror(errno), __func__, __LINE__); } 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__); } auto tmp = sctpMap->find(key); if (tmp) { free(tmp); + tmp = nullptr; 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; } /** @@ -2694,27 +3888,35 @@ int modifyToEpoll(int epoll_fd, struct epoll_event event{}; event.data.ptr = peerInfo; event.events = events; - if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, peerInfo->fileDescriptor, &event) < 0) { + if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, peerInfo->fileDescriptor, &event) < numberZero) { if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "epoll_ctl EPOLL_CTL_MOD (may check not to quit here), %s, %s %d", strerror(errno), __func__, __LINE__); } close(peerInfo->fileDescriptor); + mdclog_write(MDCLOG_DEBUG, "Erasing Entry from Map for Key %s", enodbName); + removeE2ConnectionEntryFromMap(enodbName); cleanHashEntry(peerInfo, sctpMap); - char key[MAX_ENODB_NAME_SIZE * 2]; - snprintf(key, MAX_ENODB_NAME_SIZE * 2, "msg:%s|%d", enodbName, msgType); + if (peerInfo != nullptr) + { + mdclog_write(MDCLOG_DEBUG, "Not assigned peerInfo = NULL"); + peerInfo = nullptr; + } + char key[MAX_ENODB_NAME_SIZE * numberTwo]; + snprintf(key, MAX_ENODB_NAME_SIZE * numberTwo, "msg:%s|%d", enodbName, msgType); if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "remove key = %s from %s at line %d", key, __FUNCTION__, __LINE__); } auto tmp = sctpMap->find(key); if (tmp) { free(tmp); + tmp = nullptr; + sctpMap->erase(key); } - 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; } @@ -2723,19 +3925,19 @@ int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &m #ifndef UNIT_TEST rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage); #else - rmrMessageBuffer.sendMessage->state = RMR_ERR_RETRY; + rmrMessageBuffer.sendMessage->state = RMR_ERR_RETRY; #endif 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)); @@ -2745,8 +3947,8 @@ int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &m if (rmrMessageBuffer.sendMessage == nullptr) { mdclog_write(MDCLOG_ERR, "RMR failed send message returned with NULL pointer"); rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); - return -1; - } else if (rmrMessageBuffer.sendMessage->state != 0) { + return negativeOne; + } else if (rmrMessageBuffer.sendMessage->state != numberZero) { mdclog_write(MDCLOG_ERR, "Message state %s while sending request %d to Xapp from %s after retry of 10 microseconds", translateRmrErrorMessages(rmrMessageBuffer.sendMessage->state).c_str(), @@ -2768,7 +3970,7 @@ int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &m void buildJsonMessage(ReportingMessages_t &message) { #ifdef UNIT_TEST - jsonTrace = true; + jsonTrace = true; #endif if (jsonTrace) { message.outLen = sizeof(message.base64Data); @@ -2870,3 +4072,43 @@ string translateRmrErrorMessages(int state) { } return str; } +int fetchStreamId(ConnectedCU_t *peerInfo, ReportingMessages_t &message) +{ + auto loglevel = mdclog_level_get(); + int streamId = INVALID_STREAM_ID; + if(message.peerInfo->isSingleStream != false) + { + streamId = message.peerInfo->singleStreamId; + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "Send SCTP message for SINGLE_STREAM streamId %d , Messeage Type %d ,%s", + streamId,message.message.messageType, __FUNCTION__); + } + return streamId; + } + int msgType = message.message.messageType; + switch (msgType){ + case RIC_E2_RESET_REQ: + case RIC_E2_RESET_RESP: + case RIC_E2_SETUP_RESP: + case RIC_E2_SETUP_FAILURE: + case RIC_ERROR_INDICATION: + case RIC_SERVICE_QUERY: + case RIC_SERVICE_UPDATE_ACK: + case RIC_SERVICE_UPDATE_FAILURE: + streamId = numberZero; + break; + case RIC_SUB_REQ: + case RIC_SUB_DEL_REQ: + case RIC_CONTROL_REQ: + streamId = numberOne; + break; + default: + streamId = numberZero; + break; + } + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "Send SCTP message for streamId %d Messeage Type %d, %s", + streamId, message.message.messageType, __FUNCTION__); + } + return streamId; +}