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=94827f98f0a8b8c4b9f05daac37319778ca99ace;hpb=4aeeda23c37871c044341b043ac19f8217853567;p=ric-plt%2Fe2.git

diff --git a/RIC-E2-TERMINATION/sctpThread.cpp b/RIC-E2-TERMINATION/sctpThread.cpp
index 94827f9..6ad9fdf 100644
--- a/RIC-E2-TERMINATION/sctpThread.cpp
+++ b/RIC-E2-TERMINATION/sctpThread.cpp
@@ -23,10 +23,16 @@
 #include <3rdparty/oranE2/RANfunctions-List.h>
 #include "sctpThread.h"
 #include "BuildRunName.h"
-
-#include "3rdparty/oranE2SM/E2SM-gNB-NRT-RANfunction-Definition.h"
-#include "BuildXml.h"
-#include "pugixml/src/pugixml.hpp"
+#include <unistd.h>
+//#include "3rdparty/oranE2SM/E2SM-gNB-NRT-RANfunction-Definition.h"
+//#include "BuildXml.h"
+//#include "pugixml/src/pugixml.hpp"
+#include <pthread.h>
+#include <sys/time.h>
+#include <sys/inotify.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <arpa/inet.h>
 
 using namespace std;
 //using namespace std::placeholders;
@@ -41,6 +47,8 @@ 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();
@@ -51,65 +59,340 @@ static void catch_function(int signal) {
 BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(my_logger, src::logger_mt)
 
 boost::shared_ptr<sinks::synchronous_sink<sinks::text_file_backend>> boostLogger;
-double cpuClock = 0.0;
-bool jsonTrace = true;
+// double cpuClock = 0.0;
+bool jsonTrace = false;
+std::map<std::string, E2NodeConnectionHandling> 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)
+{
+    int ret = -1;
+    struct stat fileInfo;
+    if ( lstat(fileName,&fileInfo) == 0 )
+    {
+        ret = register_log_change_notify(fileName);
+    }
+    return ret;
+}
+
+
+static int register_log_change_notify(const char *fileName)
+{
+    pthread_attr_t cb_attr;
+    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 *)fileName);
+}
+
+
+static void * monitor_loglevel_change_handler(void* arg)
+{
+    char *fileName = (char*) arg;
+    int ifd;                   // the inotify file des
+    int wfd;                   // the watched file des
+    ssize_t n = 0;
+    char rbuf[4096];           // large read buffer as the event is var len
+    fd_set fds;
+    int res = 0;
+    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
+    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 ) );
+    } else {
+        wfd = inotify_add_watch( ifd, dname, IN_MOVED_TO | IN_CLOSE_WRITE ); // we only care about close write changes
+
+        if( wfd < 0 ) {
+            fprintf( stderr, "### ERR ### unable to add watch on config file %s: %s\n", fileName, strerror( errno ) );
+        } else {
+            FD_ZERO (&fds);
+            FD_SET (ifd, &fds);
+            while( 1 ) {
+                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
+                    if(log_level != NULL) {
+                        mdclog_write(MDCLOG_INFO, "MDC log level updated to %s", log_level);
+                        free(log_level);
+                    }
+                }
+            }
+            inotify_rm_watch(ifd,wfd);
+        }
+        close(ifd);
+    }
+    free(bname);
+    free(dname);
+    free(fileName);
+
+    pthread_exit(NULL);
+}
+
+void  update_mdc_log_level_severity(char* log_level)
+{
+    mdclog_severity_t level = MDCLOG_ERR;
+
+    if(log_level == NULL)
+    {
+        printf("### ERR ### Invalid Log-Level Configuration in ConfigMap, Default Log-Level Applied:   %d\n",level);
+    }
+    else if(strcasecmp(log_level,"1")==0)
+    {
+        level = MDCLOG_ERR;
+    }
+    else if(strcasecmp(log_level,"2")==0)
+    {
+        level = MDCLOG_WARN;
+    }
+    else if(strcasecmp(log_level,"3")==0)
+    {
+        level = MDCLOG_INFO;
+    }
+    else if(strcasecmp(log_level,"4")==0)
+    {
+        level = MDCLOG_DEBUG;
+    }
+
+    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;
+    bool found = false;
+    FILE *file = fopen ( filename, "r" );
+
+    if ( file != NULL )
+    {
+        char line [ 128 ];
+        while ( fgets ( line, sizeof(line), file ) != NULL )
+        {
+            token = strtok(line, ":");
+            token = trim(token);
+            if (strcmp(token,"log-level") == 0) {
+                found = true;
+                token = strtok(NULL, "\n");
+                token = trim(token);
+                break;
+            }
+        }
+        fclose ( file );
+     }
+     if(found)
+         return(strdup(token));
+     else
+         return(NULL);
+}
+
+char *read_env_param(const char*envkey)
+{
+    if(envkey)
+    {
+        char *value = getenv(envkey);
+        if(value)
+            return strdup(value);
+    }
+    return NULL;
+}
+
+void dynamic_log_level_change()
+{
+    char *logFile_Name = read_env_param(LOG_FILE_CONFIG_MAP);
+    char* log_level_init=NULL;
+    if(logFile_Name)
+    {
+        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);
+}
 
 void init_log() {
+    int log_change_monitor = 0;
     mdclog_attr_t *attr;
     mdclog_attr_init(&attr);
     mdclog_attr_set_ident(attr, "E2Terminator");
     mdclog_init(attr);
+    if(mdclog_format_initialize(log_change_monitor)!=0)
+        mdclog_write(MDCLOG_ERR, "Failed to intialize MDC log format !!!");
+    dynamic_log_level_change();
     mdclog_attr_destroy(attr);
 }
-auto start_time = std::chrono::high_resolution_clock::now();
-typedef std::chrono::duration<double, std::ratio<1,1>> seconds_t;
+//auto start_time = std::chrono::high_resolution_clock::now();
+//typedef std::chrono::duration<double, std::ratio<1,1>> 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<int64_t> rmrCounter{0};
 std::atomic<int64_t> num_of_messages{0};
 std::atomic<int64_t> 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);
-    struct sockaddr_in6 servaddr {};
-    servaddr.sin6_family = AF_INET6;
-    servaddr.sin6_addr   = in6addr_any;
-    servaddr.sin6_port = htons(sctpParams.sctpPort);
-    if (bind(sctpParams.listenFD, (SA *)&servaddr, sizeof(servaddr)) < 0 ) {
-        mdclog_write(MDCLOG_ERR, "Error binding. %s\n", strerror(errno));
+    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));
         return -1;
     }
     if (mdclog_level_get() >= MDCLOG_DEBUG) {
-        struct sockaddr_in6 cliaddr {};
-        socklen_t len = sizeof(cliaddr);
-        getsockname(sctpParams.listenFD, (SA *)&cliaddr, &len);
+        struct sockaddr_in6 clientAddress {};
+        socklen_t len = sizeof(clientAddress);
+        getsockname(sctpParams.listenFD, (SA *)&clientAddress, &len);
         char buff[1024] {};
-        inet_ntop(AF_INET6, &cliaddr.sin6_addr, buff, sizeof(buff));
-        mdclog_write(MDCLOG_DEBUG, "My address: %s, port %d\n", buff, htons(cliaddr.sin6_port));
+        inet_ntop(AF_INET6, &clientAddress.sin6_addr, buff, sizeof(buff));
+        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;
@@ -117,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;
@@ -131,53 +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) {
-        mdclog_write(MDCLOG_ERR, "illigal RMR port ");
+#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("loglevel");
-    if (tmpStr.length() == 0) {
-        mdclog_write(MDCLOG_ERR, "illigal loglevel. Set loglevel to MDCLOG_INFO");
-        tmpStr = "info";
-    }
-    transform(tmpStr.begin(), tmpStr.end(), tmpStr.begin(), ::tolower);
-
-    if ((tmpStr.compare("debug")) == 0) {
-        sctpParams.logLevel = MDCLOG_DEBUG;
-    } else if ((tmpStr.compare("info")) == 0) {
-        sctpParams.logLevel = MDCLOG_INFO;
-    } else if ((tmpStr.compare("warning")) == 0) {
-        sctpParams.logLevel = MDCLOG_WARN;
-    } else if ((tmpStr.compare("error")) == 0) {
-        sctpParams.logLevel = MDCLOG_ERR;
-    } else {
-        mdclog_write(MDCLOG_ERR, "illigal loglevel = %s. Set loglevel to MDCLOG_INFO", tmpStr.c_str());
-        sctpParams.logLevel = MDCLOG_INFO;
-    }
-    mdclog_level_set(sctpParams.logLevel);
-
-    tmpStr = conf.getStringValue("volume");
+    auto tmpStr = conf.getStringValue("volume");
     if (tmpStr.length() == 0) {
-        mdclog_write(MDCLOG_ERR, "illigal volume.");
+#if !(defined(UNIT_TEST) || defined(MODULE_TEST))
+        mdclog_write(MDCLOG_ERR, "illegal volume.");
         return -1;
+#endif
     }
 
     char tmpLogFilespec[VOLUME_URL_SIZE];
@@ -193,71 +466,67 @@ int buildConfiguration(sctp_params_t &sctpParams) {
 
     sctpParams.myIP = conf.getStringValue("local-ip");
     if (sctpParams.myIP.length() == 0) {
-        mdclog_write(MDCLOG_ERR, "illigal local-ip.");
+#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) {
-        mdclog_write(MDCLOG_ERR, "illigal SCTP port ");
+#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) {
-        mdclog_write(MDCLOG_ERR, "illigal external-fqdn");
+#if !(defined(UNIT_TEST) || defined(MODULE_TEST))
+        mdclog_write(MDCLOG_ERR, "illegal external-fqdn");
         return -1;
+#endif
     }
 
     std::string pod = conf.getStringValue("pod_name");
+#ifndef UNIT_TEST
     if (pod.length() == 0) {
-        mdclog_write(MDCLOG_ERR, "illigal pod_name in config file");
+        mdclog_write(MDCLOG_ERR, "illegal pod_name in config file");
         return -1;
     }
     auto *podName = getenv(pod.c_str());
     if (podName == nullptr) {
-        mdclog_write(MDCLOG_ERR, "illigal pod_name or environment varible not exists : %s", pod.c_str());
+        mdclog_write(MDCLOG_ERR, "illegal pod_name or environment variable not exists : %s", pod.c_str());
         return -1;
 
     } else {
         sctpParams.podName.assign(podName);
         if (sctpParams.podName.length() == 0) {
-            mdclog_write(MDCLOG_ERR, "illigal pod_name");
+            mdclog_write(MDCLOG_ERR, "illegal pod_name");
             return -1;
         }
     }
-
+#endif
     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;
 
     sctpParams.epollTimeOut = -1;
-    tmpStr = conf.getStringValue("prometheusMode");
-    transform(tmpStr.begin(), tmpStr.end(), tmpStr.begin(), ::tolower);
-    if (tmpStr.length() != 0) {
-        if (tmpStr.compare("push") == 0) {
-            sctpParams.prometheusPushAddress = tmpStr;
-            auto timeout = conf.getIntValue("prometheusPushTimeOut");
-            if (timeout >= 5 && timeout <= 300) {
-                sctpParams.epollTimeOut = timeout * 1000;
-            } else {
-                sctpParams.epollTimeOut = 10 * 1000;
-            }
-        }
-    }
-
-    tmpStr = conf.getStringValue("prometheusPushAddr");
-    if (tmpStr.length() != 0) {
-        sctpParams.prometheusMode = tmpStr;
-    }
 
     tmpStr = conf.getStringValue("prometheusPort");
     if (tmpStr.length() != 0) {
@@ -273,16 +542,14 @@ int buildConfiguration(sctp_params_t &sctpParams) {
                                             sctpParams.podName.c_str());
 
     if (mdclog_level_get() >= MDCLOG_INFO) {
-        mdclog_mdc_add("RMR Port", to_string(sctpParams.rmrPort).c_str());
-        mdclog_mdc_add("LogLevel", to_string(sctpParams.logLevel).c_str());
-        mdclog_mdc_add("volume", sctpParams.volume);
-        mdclog_mdc_add("tmpLogFilespec", tmpLogFilespec);
-        mdclog_mdc_add("my ip", sctpParams.myIP.c_str());
-        mdclog_mdc_add("pod name", sctpParams.podName.c_str());
+        mdclog_write(MDCLOG_DEBUG,"RMR Port: %s", to_string(sctpParams.rmrPort).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());
+        mdclog_write(MDCLOG_DEBUG,"pod name: %s", sctpParams.podName.c_str());
 
         mdclog_write(MDCLOG_INFO, "running parameters for instance : %s", sctpParams.ka_message);
     }
-    mdclog_mdc_clean();
 
     // Files written to the current working directory
     boostLogger = logging::add_file_log(
@@ -293,7 +560,7 @@ int buildConfiguration(sctp_params_t &sctpParams) {
             //keywords::format = "[%TimeStamp%]: %Message%" // use each tmpStr with time stamp
     );
 
-    // Setup a destination folder for collecting rotated (closed) files --since the same volumn can use rename()
+    // Setup a destination folder for collecting rotated (closed) files --since the same volume can use rename()
     boostLogger->locked_backend()->set_file_collector(sinks::file::make_collector(
             keywords::target = sctpParams.volume
     ));
@@ -309,20 +576,41 @@ int buildConfiguration(sctp_params_t &sctpParams) {
     return 0;
 }
 
-static std::string GetHostName() {
-    char hostname[1024];
-
-    if (::gethostname(hostname, sizeof(hostname))) {
-        return {};
+void startPrometheus(sctp_params_t &sctpParams) {
+    auto podName = std::getenv("POD_NAME");
+    string metric = "E2TBeta";
+    if (strstr(podName, "alpha") != NULL) {
+        metric = "E2TAlpha";
     }
-    return hostname;
-}
+    //Get eth0 interface IP
+    char* host = getinterfaceip();
+    string hostip = host;
+
+    sctpParams.prometheusFamily = &BuildCounter()
+            .Name(metric.c_str())
+            .Help("E2T instance metrics")
+            .Labels({{"POD_NAME", sctpParams.podName}})
+            .Register(*sctpParams.prometheusRegistry);
 
+    // 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());
+    }
+    sctpParams.prometheusExposer = new Exposer(prometheusPath, 1);
+    sctpParams.prometheusExposer->RegisterCollectable(sctpParams.prometheusRegistry);
+}
+#ifndef UNIT_TEST
 
 int main(const int argc, char **argv) {
     sctp_params_t sctpParams;
-
     {
         std::random_device device{};
         std::mt19937 generator(device());
@@ -336,8 +624,6 @@ int main(const int argc, char **argv) {
 
     unsigned num_cpus = std::thread::hardware_concurrency();
     init_log();
-    mdclog_level_set(MDCLOG_INFO);
-
     if (std::signal(SIGINT, catch_function) == SIG_ERR) {
         mdclog_write(MDCLOG_ERR, "Error initializing SIGINT");
         exit(1);
@@ -351,27 +637,22 @@ 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<Registry>();
     sctpParams.prometheusRegistry = std::make_shared<Registry>();
 
-    //sctpParams.promtheusFamily = new Family<Counter>("E2T", "E2T message counter", {{"E", sctpParams.podName}});
-
-    sctpParams.prometheusFamily = &BuildCounter()
-            .Name("E2T")
-            .Help("E2T message counter")
-            .Labels({{"E", sctpParams.podName}})
-            .Register(*sctpParams.prometheusRegistry);
+    //sctpParams.prometheusFamily = new Family<Counter>("E2T", "E2T message counter", {{"E", sctpParams.podName}});
 
+    startPrometheus(sctpParams);
 
     // start epoll
     sctpParams.epoll_fd = epoll_create1(0);
@@ -379,7 +660,6 @@ int main(const int argc, char **argv) {
         mdclog_write(MDCLOG_ERR, "failed to open epoll descriptor");
         exit(-1);
     }
-
     getRmrContext(sctpParams);
     if (sctpParams.rmrCtx == nullptr) {
         close(sctpParams.epoll_fd);
@@ -402,39 +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<std::thread> threads(num_cpus);
 //    std::vector<std::thread> threads;
 
-    if (sctpParams.prometheusMode.compare("pull") == 0) {
-        sctpParams.prometheusExposer = new Exposer(sctpParams.myIP + ":" + sctpParams.prometheusPort, 1);
-        sctpParams.prometheusExposer->RegisterCollectable(sctpParams.prometheusRegistry);
-    } else if (sctpParams.prometheusMode.compare("push") == 0) {
-        const auto labels = Gateway::GetInstanceLabel(GetHostName());
-        string address {};
-        string port {};
-        char ch = ':';
-        auto found = sctpParams.prometheusPushAddress.find_last_of(ch);
-        // If string doesn't have
-        // character ch present in it
-        if (found != string::npos) {
-            address = sctpParams.prometheusPushAddress.substr(0,found);
-            port = sctpParams.prometheusPushAddress.substr(found + 1);
-            sctpParams.prometheusGateway = new Gateway(address, port, "E2T", labels);
-            sctpParams.prometheusGateway->RegisterCollectable(sctpParams.prometheusRegistry);
-        } else {
-            mdclog_write(MDCLOG_ERR, "failed to build Prometheus gateway no stats will be sent");
-        }
-    }
-
-    num_cpus = 1;
-    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);
         }
     }
@@ -446,10 +709,10 @@ int main(const int argc, char **argv) {
     for (auto &t : threads) {
         t.join();
     }
-
+    pthread_mutex_destroy(&thread_lock);
     return 0;
 }
-
+#endif
 void handleTermInit(sctp_params_t &sctpParams) {
     sendTermInit(sctpParams);
     //send to e2 manager init of e2 term
@@ -460,7 +723,7 @@ void handleTermInit(sctp_params_t &sctpParams) {
         auto xappMessages = num_of_XAPP_messages.load(std::memory_order_acquire);
         if (xappMessages > 0) {
             if (mdclog_level_get() >=  MDCLOG_INFO) {
-                mdclog_write(MDCLOG_INFO, "Got a message from some appliction, stop sending E2_TERM_INIT");
+                mdclog_write(MDCLOG_INFO, "Got a message from some application, stop sending E2_TERM_INIT");
             }
             return;
         }
@@ -489,7 +752,7 @@ void sendTermInit(sctp_params_t &sctpParams) {
         } else if (msg->state == 0) {
             rmr_free_msg(msg);
             if (mdclog_level_get() >=  MDCLOG_INFO) {
-                mdclog_write(MDCLOG_INFO, "E2_TERM_INIT succsesfuly sent ");
+                mdclog_write(MDCLOG_INFO, "E2_TERM_INIT successfully sent ");
             }
             return;
         } else {
@@ -517,7 +780,7 @@ cxxopts::ParseResult parse(int argc, char *argv[], sctp_params_t &sctpParams) {
             ("f,file", "config file name", cxxopts::value<std::string>(sctpParams.configFileName)->default_value("config.conf"))
             ("h,help", "Print help");
 
-    auto result = options.parse(argc, argv);
+    auto result = options.parse(argc, (const char **&)argv);
 
     if (result.count("help")) {
         std::cout << options.help({""}) << std::endl;
@@ -535,9 +798,6 @@ int buildInotify(sctp_params_t &sctpParams) {
     sctpParams.inotifyFD = inotify_init1(IN_NONBLOCK);
     if (sctpParams.inotifyFD == -1) {
         mdclog_write(MDCLOG_ERR, "Failed to init inotify (inotify_init1) %s", strerror(errno));
-        close(sctpParams.rmrListenFd);
-        rmr_close(sctpParams.rmrCtx);
-        close(sctpParams.epoll_fd);
         return -1;
     }
 
@@ -572,11 +832,14 @@ int buildInotify(sctp_params_t &sctpParams) {
 void listener(sctp_params_t *params) {
     int num_of_SCTP_messages = 0;
     auto totalTime = 0.0;
-    mdclog_mdc_clean();
-    mdclog_level_set(params->logLevel);
-
     std::thread::id this_id = std::this_thread::get_id();
     //save cout
+    auto pod_name = std::getenv("POD_NAME");
+    auto container_name = std::getenv("CONTAINER_NAME");
+    auto service_name = std::getenv("SERVICE_NAME");
+    auto host_name = std::getenv("HOST_NAME");
+    auto system_name = std::getenv("SYSTEM_NAME");
+    auto pid = std::to_string(getpid()).c_str();
     streambuf *oldCout = cout.rdbuf();
     ostringstream memCout;
     // create new cout
@@ -588,7 +851,12 @@ void listener(sctp_params_t *params) {
     char tid[32];
     memcpy(tid, memCout.str().c_str(), memCout.str().length() < 32 ? memCout.str().length() : 31);
     tid[memCout.str().length()] = 0;
-    mdclog_mdc_add("thread id", tid);
+    mdclog_mdc_add("SYSTEM_NAME", system_name);
+    mdclog_mdc_add("HOST_NAME", host_name);
+    mdclog_mdc_add("SERVICE_NAME", service_name);
+    mdclog_mdc_add("CONTAINER_NAME", container_name);
+    mdclog_mdc_add("POD_NAME", pod_name);
+    mdclog_mdc_add("PID", pid);
 
     if (mdclog_level_get() >= MDCLOG_DEBUG) {
         mdclog_write(MDCLOG_DEBUG, "started thread number %s", tid);
@@ -615,26 +883,27 @@ void listener(sctp_params_t *params) {
 
     ReportingMessages_t message {};
 
-//    for (int i = 0; i < MAX_RMR_BUFF_ARRY; i++) {
+//    for (int i = 0; i < MAX_RMR_BUFF_ARRAY; i++) {
 //        rmrMessageBuffer.rcvBufferedMessages[i] = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE);
 //        rmrMessageBuffer.sendBufferedMessages[i] = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE);
 //    }
 
-    bool gatewayflag = false;
     while (true) {
-        future<int> gateWay;
-
         if (mdclog_level_get() >= MDCLOG_DEBUG) {
             mdclog_write(MDCLOG_DEBUG, "Start EPOLL Wait. Timeout = %d", params->epollTimeOut);
         }
+#ifndef UNIT_TEST
         auto numOfEvents = epoll_wait(params->epoll_fd, events, MAXEVENTS, params->epollTimeOut);
-        if (numOfEvents == 0) {
-            if (params->prometheusGateway != nullptr) {
-                gateWay = params->prometheusGateway->AsyncPush();
-                gatewayflag = true;
+#else
+        auto numOfEvents = 1;
+#endif
+        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));
@@ -642,18 +911,15 @@ void listener(sctp_params_t *params) {
                 continue;
             }
             mdclog_write(MDCLOG_ERR, "Epoll wait failed, errno = %s", strerror(errno));
-            return;
-        }
-        if (gatewayflag) {
-            gatewayflag = false;
-            auto rc = gateWay.get();
-            if (rc != 200) {
-                mdclog_write(MDCLOG_ERR, "Async Send to Promethues faild with Return Code %d", rc);
-            } else if (mdclog_level_get() >= MDCLOG_DEBUG) {
-                mdclog_write(MDCLOG_DEBUG, "Stats sent to Prometheus");
+            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);
             }
@@ -679,13 +945,26 @@ void listener(sctp_params_t *params) {
 
                     in_len = sizeof(in_addr);
                     auto *peerInfo = (ConnectedCU_t *)calloc(1, sizeof(ConnectedCU_t));
+                    if(peerInfo == nullptr){
+                        mdclog_write(MDCLOG_ERR, "calloc failed");
+                        break;
+                    }
                     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;
                         }
@@ -693,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) {
@@ -713,16 +1022,20 @@ void listener(sctp_params_t *params) {
                                    (EPOLLIN | EPOLLET),
                                    params->sctpMap, nullptr,
                                    0) != 0) {
+                        if(peerInfo) {
+                            free(peerInfo);
+                            peerInfo = nullptr;
+                        }
                         break;
                     }
                     break;
                 }
             } else if (params->rmrListenFd == events[i].data.fd) {
                 // got message from XAPP
-                num_of_XAPP_messages.fetch_add(1, std::memory_order_release);
+                //num_of_XAPP_messages.fetch_add(1, std::memory_order_release);
                 num_of_messages.fetch_add(1, std::memory_order_release);
                 if (mdclog_level_get() >= MDCLOG_DEBUG) {
-                    mdclog_write(MDCLOG_DEBUG, "new message from RMR");
+                    mdclog_write(MDCLOG_DEBUG, "new RMR message");
                 }
                 if (receiveXappMessages(params->sctpMap,
                                         rmrMessageBuffer,
@@ -758,6 +1071,9 @@ void listener(sctp_params_t *params) {
                              end.tv_nsec - start.tv_nsec);
             }
         }
+#ifdef UNIT_TEST
+    break;
+#endif
     }
 }
 
@@ -769,12 +1085,19 @@ void handleConfigChange(sctp_params_t *sctpParams) {
     char buf[4096] __attribute__ ((aligned(__alignof__(struct inotify_event))));
     const struct inotify_event *event;
     char *ptr;
-
+#ifdef UNIT_TEST
+    struct inotify_event tmpEvent;
+#endif
     path p = (sctpParams->configFilePath + "/" + sctpParams->configFileName).c_str();
     auto endlessLoop = true;
     while (endlessLoop) {
+#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;
@@ -784,10 +1107,16 @@ void handleConfigChange(sctp_params_t *sctpParams) {
                 endlessLoop = false;
                 continue;
             }
+#endif
         }
 
         for (ptr = buf; ptr < buf + len; ptr += sizeof(struct inotify_event) + event->len) {
-            event = (const struct inotify_event *)ptr;
+#ifndef UNIT_TEST
+    event = (const struct inotify_event *)ptr;
+#else
+    tmpEvent.mask = (uint32_t)IN_CLOSE_WRITE;
+    event = &tmpEvent;
+#endif
             if (event->mask & (uint32_t)IN_ISDIR) {
                 continue;
             }
@@ -797,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) {
@@ -825,36 +1156,9 @@ 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, "illigal 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, "illigal 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, "illigal trace. Set trace to stop");
+                    mdclog_write(MDCLOG_ERR, "illegal trace. Set trace to stop");
                     tmpStr = "stop";
                 }
 
@@ -871,18 +1175,12 @@ void handleConfigChange(sctp_params_t *sctpParams) {
                 }
                 jsonTrace = sctpParams->trace;
 
-                if (sctpParams->prometheusMode.compare("push") == 0) {
-                    auto timeout = conf.getIntValue("prometheusPushTimeOut");
-                    if (timeout >= 5 && timeout <= 300) {
-                        sctpParams->epollTimeOut = timeout * 1000;
-                    } else {
-                        mdclog_write(MDCLOG_ERR, "prometheusPushTimeOut set wrong value %d, values are [5..300]",
-                                     timeout);
-                    }
-                }
 
                 endlessLoop = false;
             }
+#ifdef UNIT_TEST
+            break;
+#endif
         }
     }
 }
@@ -906,6 +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) {
+#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",
@@ -920,15 +1219,23 @@ 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");
         }
+#endif
         memset(peerInfo->asnData, 0, peerInfo->asnLength);
         peerInfo->asnLength = 0;
         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,
@@ -948,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;
     }
@@ -956,6 +1263,7 @@ void handleEinprogressMessages(struct epoll_event &event,
     memset(peerInfo->asnData, 0, peerInfo->asnLength);
     peerInfo->asnLength = 0;
     peerInfo->mtype = 0;
+#endif
 }
 
 
@@ -963,11 +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);
-
+#if !(defined(UNIT_TEST) || defined(MODULE_TEST))
         rmrMessageBuffer.sendMessage->len = snprintf((char *)rmrMessageBuffer.sendMessage->payload, 256,
                                                      "%s|Failed SCTP Connection",
                                                      peerInfo->enodbName);
@@ -976,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);
     }
@@ -996,17 +1320,13 @@ int setSocketNoBlocking(int socket) {
     auto flags = fcntl(socket, F_GETFL, 0);
 
     if (flags == -1) {
-        mdclog_mdc_add("func", "fcntl");
         mdclog_write(MDCLOG_ERR, "%s, %s", __FUNCTION__, strerror(errno));
-        mdclog_mdc_clean();
         return -1;
     }
 
     flags = (unsigned) flags | (unsigned) O_NONBLOCK;
     if (fcntl(socket, F_SETFL, flags) == -1) {
-        mdclog_mdc_add("func", "fcntl");
         mdclog_write(MDCLOG_ERR, "%s, %s", __FUNCTION__, strerror(errno));
-        mdclog_mdc_clean();
         return -1;
     }
 
@@ -1019,47 +1339,75 @@ 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);
-    free(val);
+        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");
+    }
 }
 
 /**
  *
- * @param fd file discriptor
+ * @param fd file descriptor
  * @param data the asn data to send
  * @param len  length of the data
  * @param enodbName the enodbName as in the map for printing purpose
  * @param m map host information
  * @param mtype message number
- * @return 0 success, anegative number on fail
+ * @return 0 success, a negative number on fail
  */
 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);
                 return -1;
             }
+#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);
@@ -1069,9 +1417,12 @@ 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
             return -1;
+#endif
         }
         message.message.direction = 'D';
         // send report.buffer of size
@@ -1102,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<std::string, E2NodeConnectionHandling>::iterator itr = connectionHandlingPerE2NodeMap.begin();
+    mdclog_write(MDCLOG_DEBUG, "Iterating Map e2NodeIdConnectionStatusMap");
+    while (itr != connectionHandlingPerE2NodeMap.end())
+    {
+        int result = itr->first.compare(enbName);
+        if (result == 0)
+        {
+            mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus);
+            mdclog_write(MDCLOG_DEBUG, "Removing the Entry from map for %s", enbName);
+            connectionHandlingPerE2NodeMap.erase(itr);
+            mdclog_write(MDCLOG_DEBUG, "Deleted the Entry Successfully from map for %s", enbName);
+            break;
+        }
+        ++itr;
+    }
+}
 
 /**
  *
@@ -1124,12 +1498,17 @@ 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};
+    struct timespec decodeStart{0, 0};
     struct timespec end{0, 0};
 
     E2AP_PDU_t *pdu = nullptr;
@@ -1141,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",
@@ -1170,15 +1556,15 @@ 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;
         }
 
         if (loglevel >= MDCLOG_DEBUG) {
-            char printBuffer[4096]{};
+            char printBuffer[RECEIVE_SCTP_BUFFER_SIZE]{};
             char *tmp = printBuffer;
             for (size_t i = 0; i < (size_t)message.message.asnLength; ++i) {
                 snprintf(tmp, 3, "%02x", message.message.asndata[i]);
@@ -1190,36 +1576,47 @@ int receiveDataFromSctp(struct epoll_event *events,
                          message.peerInfo->enodbName, end.tv_sec - start.tv_sec, end.tv_nsec - start.tv_nsec);
             mdclog_write(MDCLOG_DEBUG, "PDU buffer length = %ld, data =  : %s", message.message.asnLength,
                          printBuffer);
-            clock_gettime(CLOCK_MONOTONIC, &decodestart);
+            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;
         }
 
         if (loglevel >= MDCLOG_DEBUG) {
             clock_gettime(CLOCK_MONOTONIC, &end);
             mdclog_write(MDCLOG_DEBUG, "After Encoding E2AP PDU for : %s, Read time is : %ld seconds, %ld nanoseconds",
-                         message.peerInfo->enodbName, end.tv_sec - decodestart.tv_sec, end.tv_nsec - decodestart.tv_nsec);
+                         message.peerInfo->enodbName, end.tv_sec - decodeStart.tv_sec, end.tv_nsec - decodeStart.tv_nsec);
             char *printBuffer;
             size_t size;
             FILE *stream = open_memstream(&printBuffer, &size);
             asn_fprint(stream, &asn_DEF_E2AP_PDU, pdu);
             mdclog_write(MDCLOG_DEBUG, "Encoding E2AP PDU past : %s", printBuffer);
-            clock_gettime(CLOCK_MONOTONIC, &decodestart);
+            clock_gettime(CLOCK_MONOTONIC, &decodeStart);
+
+            fclose(stream);
+            free(printBuffer);
         }
 
         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
-                asnSuccsesfulMsg(pdu, sctpMap, message,  rmrMessageBuffer);
+                asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
                 break;
             }
             case E2AP_PDU_PR_unsuccessfulOutcome: { //Unsuccessful Outcome
@@ -1234,14 +1631,19 @@ int receiveDataFromSctp(struct epoll_event *events,
             clock_gettime(CLOCK_MONOTONIC, &end);
             mdclog_write(MDCLOG_DEBUG,
                          "After processing message and sent to rmr for : %s, Read time is : %ld seconds, %ld nanoseconds",
-                         message.peerInfo->enodbName, end.tv_sec - decodestart.tv_sec, end.tv_nsec - decodestart.tv_nsec);
+                         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) {
@@ -1254,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);
@@ -1273,58 +1706,85 @@ int receiveDataFromSctp(struct epoll_event *events,
     }
     return 0;
 }
-
-static void buildAndsendSetupRequest(ReportingMessages_t &message,
+#ifndef UNIT_TEST
+static void buildAndSendSetupRequest(ReportingMessages_t &message,
                                      RmrMessagesBuffer_t &rmrMessageBuffer,
-                                     E2AP_PDU_t *pdu,
+                                     E2AP_PDU_t *pdu/*,
                                      string const &messageName,
                                      string const &ieName,
                                      vector<string> &functionsToAdd_v,
-                                     vector<string> &functionsToModified_v) {
+                                     vector<string> &functionsToModified_v*/) {
     auto logLevel = mdclog_level_get();
     // now we can send the data to e2Mgr
 
     asn_enc_rval_t er;
     auto buffer_size = RECEIVE_SCTP_BUFFER_SIZE * 2;
-    unsigned char *buffer;
+    unsigned char *buffer = nullptr;
+    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) {
-        buffer = (unsigned char *)malloc(buffer_size);
         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);
             buffer_size = er.encoded + 128;
-            free(buffer);
+
+            unsigned char *newBuffer = nullptr;
+            newBuffer = (unsigned char *) realloc(buffer, buffer_size);
+            if (!newBuffer)
+            {
+                // 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;
     }
     // encode to xml
 
-    string res {};
-    if (!functionsToAdd_v.empty() || !functionsToModified_v.empty()) {
-        res = buildXmlData(messageName, ieName, functionsToAdd_v, functionsToModified_v, buffer, (size_t) er.encoded);
-    }
+    string res((char *)buffer);
+    res.erase(std::remove(res.begin(), res.end(), '\n'), res.end());
+    res.erase(std::remove(res.begin(), res.end(), '\t'), res.end());
+    res.erase(std::remove(res.begin(), res.end(), ' '), res.end());
+
+//    string res {};
+//    if (!functionsToAdd_v.empty() || !functionsToModified_v.empty()) {
+//        res = buildXmlData(messageName, ieName, functionsToAdd_v, functionsToModified_v, buffer, (size_t) er.encoded);
+//    }
     rmr_mbuf_t *rmrMsg;
-    if (res.length() == 0) {
-        rmrMsg = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, buffer_size + 256);
-        rmrMsg->len = snprintf((char *) rmrMsg->payload, RECEIVE_SCTP_BUFFER_SIZE * 2, "%s:%d|%s",
-                               message.peerInfo->sctpParams->myIP.c_str(),
-                               message.peerInfo->sctpParams->rmrPort,
-                               buffer);
-    } else {
+//    if (res.length() == 0) {
+//        rmrMsg = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, buffer_size + 256);
+//        rmrMsg->len = snprintf((char *) rmrMsg->payload, RECEIVE_SCTP_BUFFER_SIZE * 2, "%s:%d|%s",
+//                               message.peerInfo->sctpParams->myIP.c_str(),
+//                               message.peerInfo->sctpParams->rmrPort,
+//                               buffer);
+//    } else {
         rmrMsg = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, (int)res.length() + 256);
         rmrMsg->len = snprintf((char *) rmrMsg->payload, res.length() + 256, "%s:%d|%s",
                                message.peerInfo->sctpParams->myIP.c_str(),
                                message.peerInfo->sctpParams->rmrPort,
                                res.c_str());
-    }
+//    }
 
     if (logLevel >= MDCLOG_DEBUG) {
         mdclog_write(MDCLOG_DEBUG, "Setup request of size %d :\n %s\n", rmrMsg->len, rmrMsg->payload);
@@ -1337,8 +1797,9 @@ static void buildAndsendSetupRequest(ReportingMessages_t &message,
     static unsigned char tx[32];
     snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++);
     rmr_bytes2xact(rmrMsg, tx, strlen((const char *) tx));
-
+#ifndef UNIT_TEST
     rmrMsg = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMsg);
+#endif
     if (rmrMsg == nullptr) {
         mdclog_write(MDCLOG_ERR, "RMR failed to send returned nullptr");
     } else if (rmrMsg->state != 0) {
@@ -1348,7 +1809,9 @@ static void buildAndsendSetupRequest(ReportingMessages_t &message,
             rmrMsg->state = 0;
             mdclog_write(MDCLOG_INFO, "RETRY sending Message %d to Xapp from %s",
                          rmrMsg->mtype, rmr_get_meid(rmrMsg, (unsigned char *) meid));
+#ifndef UNIT_TEST
             rmrMsg = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMsg);
+#endif
             if (rmrMsg == nullptr) {
                 mdclog_write(MDCLOG_ERR, "RMR failed send returned nullptr");
             } else if (rmrMsg->state != 0) {
@@ -1367,12 +1830,18 @@ static void buildAndsendSetupRequest(ReportingMessages_t &message,
     }
     message.peerInfo->gotSetup = true;
     buildJsonMessage(message);
+
     if (rmrMsg != nullptr) {
         rmr_free_msg(rmrMsg);
     }
     free(buffer);
+    buffer = nullptr;
+
+    return;
 }
+#endif
 
+#if 0
 int RAN_Function_list_To_Vector(RANfunctions_List_t& list, vector <string> &runFunXML_v) {
     auto index = 0;
     runFunXML_v.clear();
@@ -1465,80 +1934,181 @@ int collectServiceUpdate_RequestData(E2AP_PDU_t *pdu,
     return 0;
 }
 
+#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"}});
 
-void buildPrometheuslist(ConnectedCU_t *peerInfo, Family<Counter> *prometheusFamily) {
-    peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_E2setup - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"SetupRequest", "Messages"}});
-    peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_E2setup - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"SetupRequest", "Bytes"}});
+    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"}});
 
-    peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_ErrorIndication - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ErrorIndication", "Messages"}});
-    peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_ErrorIndication - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ErrorIndication", "Bytes"}});
+    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"}});
 
-    peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_RICindication - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICindication", "Messages"}});
-    peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_RICindication - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICindication", "Bytes"}});
+    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"}});
 
-    peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_Reset - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ResetRequest", "Messages"}});
-    peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_Reset - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ResetRequest", "Bytes"}});
+    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"}});
 
-    peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_RICserviceUpdate - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICserviceUpdate", "Messages"}});
-    peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_RICserviceUpdate - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICserviceUpdate", "Bytes"}});
+    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<Counter> *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"}});
+
+    peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_RICindication)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICindication", "Messages"}});
+    peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_RICindication)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICindication", "Bytes"}});
+
+    peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_Reset)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ResetRequest", "Messages"}});
+    peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_Reset)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ResetRequest", "Bytes"}});
+
+    peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_RICserviceUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICserviceUpdate", "Messages"}});
+    peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_RICserviceUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICserviceUpdate", "Bytes"}});
     // ---------------------------------------------
-    peerInfo->counters[IN_SUCC][MSG_COUNTER][(ProcedureCode_id_Reset - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ResetACK", "Messages"}});
-    peerInfo->counters[IN_SUCC][BYTES_COUNTER][(ProcedureCode_id_Reset - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ResetACK", "Bytes"}});
+    peerInfo->counters[IN_SUCC][MSG_COUNTER][(ProcedureCode_id_Reset)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ResetACK", "Messages"}});
+    peerInfo->counters[IN_SUCC][BYTES_COUNTER][(ProcedureCode_id_Reset)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"ResetACK", "Bytes"}});
 
-    peerInfo->counters[IN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICcontrol - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICcontrolACK", "Messages"}});
-    peerInfo->counters[IN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICcontrol - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICcontrolACK", "Bytes"}});
+    peerInfo->counters[IN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICcontrol)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICcontrolACK", "Messages"}});
+    peerInfo->counters[IN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICcontrol)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICcontrolACK", "Bytes"}});
 
-    peerInfo->counters[IN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICsubscription - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionACK", "Messages"}});
-    peerInfo->counters[IN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICsubscription - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionACK", "Bytes"}});
+    peerInfo->counters[IN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICsubscription)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionACK", "Messages"}});
+    peerInfo->counters[IN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICsubscription)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionACK", "Bytes"}});
 
-    peerInfo->counters[IN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICsubscriptionDelete - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteACK", "Messages"}});
-    peerInfo->counters[IN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICsubscriptionDelete - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteACK", "Bytes"}});
+    peerInfo->counters[IN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICsubscriptionDelete)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteACK", "Messages"}});
+    peerInfo->counters[IN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICsubscriptionDelete)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteACK", "Bytes"}});
     //-------------------------------------------------------------
 
-    peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICcontrol - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICcontrolFailure", "Messages"}});
-    peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICcontrol - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICcontrolFailure", "Bytes"}});
+    peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICcontrol)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICcontrolFailure", "Messages"}});
+    peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICcontrol)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICcontrolFailure", "Bytes"}});
 
-    peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICsubscription - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionFailure", "Messages"}});
-    peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICsubscription - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionFailure", "Bytes"}});
+    peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICsubscription)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionFailure", "Messages"}});
+    peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICsubscription)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionFailure", "Bytes"}});
 
-    peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICsubscriptionDelete - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteFailure", "Messages"}});
-    peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICsubscriptionDelete - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteFailure", "Bytes"}});
+    peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICsubscriptionDelete)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteFailure", "Messages"}});
+    peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICsubscriptionDelete)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"RICsubscriptionDeleteFailure", "Bytes"}});
 
     //====================================================================================
-    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_ErrorIndication - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ErrorIndication", "Messages"}});
-    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_ErrorIndication - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ErrorIndication", "Bytes"}});
+    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_ErrorIndication)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ErrorIndication", "Messages"}});
+    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_ErrorIndication)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ErrorIndication", "Bytes"}});
 
-    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_Reset - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ResetRequest", "Messages"}});
-    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_Reset - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ResetRequest", "Bytes"}});
+    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_Reset)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ResetRequest", "Messages"}});
+    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_Reset)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ResetRequest", "Bytes"}});
 
-    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_RICcontrol - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICcontrol", "Messages"}});
-    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_RICcontrol - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICcontrol", "Bytes"}});
+    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_RICcontrol)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICcontrol", "Messages"}});
+    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_RICcontrol)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICcontrol", "Bytes"}});
 
-    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_RICserviceQuery - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceQuery", "Messages"}});
-    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_RICserviceQuery - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceQuery", "Bytes"}});
+    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_RICserviceQuery)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceQuery", "Messages"}});
+    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_RICserviceQuery)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceQuery", "Bytes"}});
 
-    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_RICsubscription - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICsubscription", "Messages"}});
-    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_RICsubscription - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICsubscription", "Bytes"}});
+    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_RICsubscription)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICsubscription", "Messages"}});
+    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_RICsubscription)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICsubscription", "Bytes"}});
 
-    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_RICsubscriptionDelete - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICsubscriptionDelete", "Messages"}});
-    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_RICsubscriptionDelete - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICsubscriptionDelete", "Bytes"}});
+    peerInfo->counters[OUT_INITI][MSG_COUNTER][(ProcedureCode_id_RICsubscriptionDelete)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICsubscriptionDelete", "Messages"}});
+    peerInfo->counters[OUT_INITI][BYTES_COUNTER][(ProcedureCode_id_RICsubscriptionDelete)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICsubscriptionDelete", "Bytes"}});
     //---------------------------------------------------------------------------------------------------------
-    peerInfo->counters[OUT_SUCC][MSG_COUNTER][(ProcedureCode_id_E2setup - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"SetupResponse", "Messages"}});
-    peerInfo->counters[OUT_SUCC][BYTES_COUNTER][(ProcedureCode_id_E2setup - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"SetupResponse", "Bytes"}});
+    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 - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ResetACK", "Messages"}});
-    peerInfo->counters[OUT_SUCC][BYTES_COUNTER][(ProcedureCode_id_Reset - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"ResetACK", "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"}});
 
-    peerInfo->counters[OUT_SUCC][MSG_COUNTER][(ProcedureCode_id_RICserviceUpdate - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceUpdateResponse", "Messages"}});
-    peerInfo->counters[OUT_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICserviceUpdate - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceUpdateResponse", "Bytes"}});
+    peerInfo->counters[OUT_SUCC][MSG_COUNTER][(ProcedureCode_id_RICserviceUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceUpdateResponse", "Messages"}});
+    peerInfo->counters[OUT_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICserviceUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceUpdateResponse", "Bytes"}});
     //----------------------------------------------------------------------------------------------------------------
-    peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_E2setup - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"SetupRequestFailure", "Messages"}});
-    peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_E2setup - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"SetupRequestFailure", "Bytes"}});
+    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"}});
+}
 
-    peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICserviceUpdate - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceUpdateFailure", "Messages"}});
-    peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICserviceUpdate - 1)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceUpdateFailure", "Bytes"}});
+#ifndef UNIT_TEST
+void buildInternalCounterPrometheusList(ConnectedCU_t *peerInfo, Family<Counter> *prometheusFamily)
+{
+    mdclog_write(MDCLOG_DEBUG, "Inside buildInternalCounterPrometheusList");
+    peerInfo->e2tInternalCounters[E2T_Internal_Counters::SCTP_ABORT_INITIATED_BY_E2NODE] = &prometheusFamily->Add({{"NODEB", peerInfo->enodbName}, {"counter", "SctpAbortInitiatedByE2Node"}});
+    peerInfo->e2tInternalCounters[E2T_Internal_Counters::INVALID_MESSAGE_RECEIVED] = &prometheusFamily->Add({{"NODEB", peerInfo->enodbName}, {"counter", "InvalidMessageReceived"}});
 }
+#endif
 /**
  *
  * @param pdu
@@ -1547,26 +2117,28 @@ void buildPrometheuslist(ConnectedCU_t *peerInfo, Family<Counter> *prometheusFam
  * @param RANfunctionsAdded_v
  * @return
  */
-int collectSetupRequestData(E2AP_PDU_t *pdu,
-                                     Sctp_Map_t *sctpMap,
-                                     ReportingMessages_t &message,
-                                     vector <string> &RANfunctionsAdded_v) {
-    memset(message.peerInfo->enodbName, 0 , MAX_ENODB_NAME_SIZE);
-    for (auto i = 0; i < pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count; i++) {
+long collectSetupRequestData(E2AP_PDU_t *pdu,
+                            Sctp_Map_t *sctpMap,
+                            ReportingMessages_t &message /*, vector <string> &RANfunctionsAdded_v*/) {
+    long transactionId = negativeOne;
+    memset(message.peerInfo->enodbName, numberZero , MAX_ENODB_NAME_SIZE);
+    for (auto i = numberZero; i < pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count; i++) {
         auto *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[i];
         if (ie->id == ProtocolIE_ID_id_GlobalE2node_ID) {
             // get the ran name for meid
             if (ie->value.present == E2setupRequestIEs__value_PR_GlobalE2node_ID) {
-                if (buildRanName(message.peerInfo->enodbName, ie) < 0) {
+                mdclog_write(MDCLOG_DEBUG, "GnbId is present");
+                #ifndef UNIT_TEST
+                if (buildRanName(message.peerInfo->enodbName, ie) < numberZero) {
                     mdclog_write(MDCLOG_ERR, "Bad param in E2setupRequestIEs GlobalE2node_ID.\n");
-                    // no mesage will be sent
-                    return -1;
+                    // no message will be sent
+                    return negativeOne;
                 }
-
+                #endif
                 memcpy(message.message.enodbName, message.peerInfo->enodbName, strlen(message.peerInfo->enodbName));
                 sctpMap->setkey(message.message.enodbName, message.peerInfo);
             }
-        } else if (ie->id == ProtocolIE_ID_id_RANfunctionsAdded) {
+        } /*else if (ie->id == ProtocolIE_ID_id_RANfunctionsAdded) {
             if (ie->value.present == E2setupRequestIEs__value_PR_RANfunctions_List) {
                 if (mdclog_level_get() >= MDCLOG_DEBUG) {
                     mdclog_write(MDCLOG_DEBUG, "Run function list have %d entries",
@@ -1576,13 +2148,21 @@ int collectSetupRequestData(E2AP_PDU_t *pdu,
                     return -1;
                 }
             }
+        } */
+        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;
+//    if (mdclog_level_get() >= MDCLOG_DEBUG) {
+//        mdclog_write(MDCLOG_DEBUG, "Run function vector have %ld entries",
+//                     RANfunctionsAdded_v.size());
+//    }
+    return transactionId;
 }
 
 int XML_From_PER(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
@@ -1598,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;
     }
 
@@ -1606,16 +2190,28 @@ 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));
-        return -1;
+        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",
                      (int)rmrMessageBuffer.sendMessage->len,
                      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;
 
 }
@@ -1629,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) {
@@ -1637,82 +2233,236 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu,
     }
     switch (procedureCode) {
         case ProcedureCode_id_E2setup: {
+
             if (logLevel >= MDCLOG_DEBUG) {
                 mdclog_write(MDCLOG_DEBUG, "Got E2setup");
             }
 
-            vector <string> RANfunctionsAdded_v;
-            vector <string> RANfunctionsModified_v;
-            RANfunctionsAdded_v.clear();
-            RANfunctionsModified_v.clear();
-            if (collectSetupRequestData(pdu, sctpMap, message, RANfunctionsAdded_v) != 0) {
+//            vector <string> RANfunctionsAdded_v;
+//            vector <string> RANfunctionsModified_v;
+//            RANfunctionsAdded_v.clear();
+//            RANfunctionsModified_v.clear();
+            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 - 1]->Increment();
-            message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_E2setup - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
-            buildAndsendSetupRequest(message, rmrMessageBuffer, pdu, messageName, ieName, RANfunctionsAdded_v, RANfunctionsModified_v);
+            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);
             }
-            vector <string> RANfunctionsAdded_v;
-            vector <string> RANfunctionsModified_v;
-            RANfunctionsAdded_v.clear();
-            RANfunctionsModified_v.clear();
-            if (collectServiceUpdate_RequestData(pdu, sctpMap, message,
-                                                 RANfunctionsAdded_v, RANfunctionsModified_v) != 0) {
-                break;
-            }
+
+            mdclog_write(MDCLOG_DEBUG, "EnbName is %s New Procedure state is %d", message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED);
+            setE2ProcedureOngoingStatus(message.message.enodbName, E2_SETUP_PROCEDURE_COMPLETED);
+//            vector <string> RANfunctionsAdded_v;
+//            vector <string> RANfunctionsModified_v;
+//            RANfunctionsAdded_v.clear();
+//            RANfunctionsModified_v.clear();
+//            if (collectServiceUpdate_RequestData(pdu, sctpMap, message,
+//                                                 RANfunctionsAdded_v, RANfunctionsModified_v) != 0) {
+//                break;
+//            }
 
             string messageName("RICserviceUpdate");
             string ieName("RICserviceUpdateIEs");
             message.message.messageType = RIC_SERVICE_UPDATE;
-            message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate - 1]->Increment();
-            message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
+#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_E2nodeConfigurationUpdate: {
+            struct E2NodeConnectionHandling e2NodeConnectionHandling;
+            bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling);
+            mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false");
+            if (!isE2SetupRequestReceived)
+            {
+                mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received E2nodeConfigurationUpdate");
+                return ;
+            }
+            if (logLevel >= MDCLOG_DEBUG) {
+                mdclog_write(MDCLOG_DEBUG, "Got E2nodeConfigurationUpdate %s", message.message.enodbName);
+            }
 
-            buildAndsendSetupRequest(message, rmrMessageBuffer, pdu, messageName, ieName, RANfunctionsAdded_v, RANfunctionsModified_v);
+            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: {
-            if (logLevel >= MDCLOG_DEBUG) {
-                mdclog_write(MDCLOG_DEBUG, "Got ErrorIndication %s", message.message.enodbName);
+            struct E2NodeConnectionHandling e2NodeConnectionHandling;
+            bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling);            
+            if (!isE2SetupRequestReceived){
+                mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received ErrorIndication");
+                return ;
+            }
+            
+            asn_fprint(stdout, &asn_DEF_E2AP_PDU, pdu);
+
+            mdclog_write(MDCLOG_INFO, "Got ErrorIndication %s sub id = %d, mtype = %d", message.message.enodbName,
+                        rmrMessageBuffer.sendMessage->sub_id, rmrMessageBuffer.sendMessage->mtype);
+
+            int procedureCode = numberZero;
+            bitset<requiredIePresentMaxBitSetPosition> isRequiredIesPresent(0); // TransactionId==0, RicRequestId==1, Cause==2
+
+            for (auto i = numberZero; i < pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count; i++) {
+                ErrorIndication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[i];
+                if (ie->id == ProtocolIE_ID_id_TransactionID) {
+                    if (ie->value.present == ErrorIndication_IEs__value_PR_TransactionID) {
+                        mdclog_write(MDCLOG_DEBUG, "TransactionID in ErrorIndication Message is %ld ", ie->value.choice.TransactionID);
+                        if (e2NodeConnectionHandling.e2SetupProcedureTransactionId == ie->value.choice.TransactionID)
+                        {
+                            isRequiredIesPresent.set(transactionIdIeBitSetPosition);
+                        }
+                    }
+                }
+                if (ie->id == ProtocolIE_ID_id_RICrequestID) {        
+                    if (ie->value.present == ErrorIndication_IEs__value_PR_RICrequestID) {
+                        isRequiredIesPresent.set(ricRequestIdIeBitSetPosition);
+                        mdclog_write(MDCLOG_DEBUG, "RIC instance id %ld, RIC requestor id = %ld",
+                                    ie->value.choice.RICrequestID.ricInstanceID,
+                                    ie->value.choice.RICrequestID.ricRequestorID);
+                    }
+                }
+                if (ie->id == ProtocolIE_ID_id_Cause) {
+                    if (ie->value.present == ErrorIndication_IEs__value_PR_Cause) {
+                        isRequiredIesPresent.set(causeIeBitSetPosition);
+                    }
+                }                     
+                if (ie->id == ProtocolIE_ID_id_CriticalityDiagnostics) {
+                    if (ie->value.present == ErrorIndication_IEs__value_PR_CriticalityDiagnostics) {
+                        if (ie->value.choice.CriticalityDiagnostics.procedureCode)
+                        {
+                            procedureCode = *(ie->value.choice.CriticalityDiagnostics.procedureCode);
+                            mdclog_write(MDCLOG_DEBUG, "ProcedureCode Value is %ld", procedureCode);
+                        }                           
+                    } 
+                }
+            }
+
+            // Msg being sent to E2M = 0, Msg being sent to SubMgr = 1
+            bitset<sendMsgMaxBitPosition> sendMsgTo = getSendMsgBitSetValue(procedureCode, isRequiredIesPresent, message.message.enodbName);
+
+            if(sendMsgTo.test(sendMsgToE2MBitSetPosition))
+            {
+                message.message.messageType = RIC_E2_RIC_ERROR_INDICATION;
+                mdclog_write(MDCLOG_INFO, "Sending ErrorIndication Message to E2Manager");
+                #ifndef UNIT_TEST
+                buildAndSendSetupRequest(message, rmrMessageBuffer, pdu);
+                #endif
+            }
+            else if (sendMsgTo.test(sendMsgToSubMgrBitSetPosition))
+            {
+                if (sendRequestToXapp(message, RIC_E2_RAN_ERROR_INDICATION, rmrMessageBuffer) != 0) {
+                    mdclog_write(MDCLOG_ERR, "Subscription successful message failed to send to SubMgr");
+                }
+                else {
+                    mdclog_write(MDCLOG_INFO, "Successfully Sent ErrorIndication Message to SubMgr");                
+                }
             }
-            message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication - 1]->Increment();
-            message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
+            else
+            {
+                mdclog_write(MDCLOG_INFO, "No action taken on ErrorIndication Message as TransactionId/Ric RequestID/Cause not present/invalid");      
+            }
+
+            #if !(defined(UNIT_TEST) || defined(MODULE_TEST))
+            message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment();
+            message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment((double)message.message.asnLength);
+
+            // Update E2T instance level metrics
+            message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment();
+            message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment((double)message.message.asnLength);
+            #endif
+
+            /*Not to break below functionality which is used to send to Xapp*/
             if (sendRequestToXapp(message, RIC_ERROR_INDICATION, rmrMessageBuffer) != 0) {
                 mdclog_write(MDCLOG_ERR, "RIC_ERROR_INDICATION failed to send to xAPP");
             }
             break;
         }
         case ProcedureCode_id_Reset: {
+            struct E2NodeConnectionHandling e2NodeConnectionHandling;
+            bool isE2SetupRequestReceived = getE2tProcedureOngoingStatus(message.message.enodbName, e2NodeConnectionHandling);
+            mdclog_write(MDCLOG_DEBUG, "Value of isE2SetupRequestReceived is %s", isE2SetupRequestReceived == true ? "true" : "false");
+            if (!isE2SetupRequestReceived){
+                mdclog_write(MDCLOG_WARN, "E2Setup procedure is not initiated, ignoring received Reset");
+                return ;
+            }
             if (logLevel >= MDCLOG_DEBUG) {
                 mdclog_write(MDCLOG_DEBUG, "Got Reset %s", message.message.enodbName);
             }
-
-            message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_Reset - 1]->Increment();
-            message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_Reset - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
-            if (XML_From_PER(message, rmrMessageBuffer) < 0) {
+#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) < 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) {
@@ -1730,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;
@@ -1741,23 +2491,74 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu,
                                          ie->value.choice.RICrequestID.ricInstanceID,
                                          ie->value.choice.RICrequestID.ricRequestorID);
                         }
-                        message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICindication - 1]->Increment();
-                        message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICindication - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
+#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;
                     } else {
-                        mdclog_write(MDCLOG_ERR, "RIC request id missing illigal request");
+                        mdclog_write(MDCLOG_ERR, "RIC request id missing illegal request");
                     }
                 }
                 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);
 
@@ -1772,7 +2573,7 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu,
  * @param message
  * @param rmrMessageBuffer
  */
-void asnSuccsesfulMsg(E2AP_PDU_t *pdu,
+void asnSuccessfulMsg(E2AP_PDU_t *pdu,
                       Sctp_Map_t *sctpMap,
                       ReportingMessages_t &message,
                       RmrMessagesBuffer_t &rmrMessageBuffer) {
@@ -1783,12 +2584,26 @@ void asnSuccsesfulMsg(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);
             }
-            message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_Reset - 1]->Increment();
-            message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
-            if (XML_From_PER(message, rmrMessageBuffer) < 0) {
+#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) < numberZero) {
                 break;
             }
             if (sendRequestToXapp(message, RIC_E2_RESET_RESP, rmrMessageBuffer) != 0) {
@@ -1797,10 +2612,17 @@ void asnSuccsesfulMsg(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];
@@ -1813,7 +2635,7 @@ void asnSuccsesfulMsg(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;
 
@@ -1823,16 +2645,23 @@ void asnSuccsesfulMsg(E2AP_PDU_t *pdu,
                         rmr_bytes2meid(rmrMessageBuffer.sendMessage,
                                        (unsigned char *)message.message.enodbName,
                                        strlen(message.message.enodbName));
-
-                        message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol - 1]->Increment();
-                        message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
+#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;
                     } else {
-                        mdclog_write(MDCLOG_ERR, "RIC request id missing illigal request");
+                        mdclog_write(MDCLOG_ERR, "RIC request id missing illegal request");
                     }
                 }
                 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;
                 }
             }
@@ -1840,30 +2669,91 @@ void asnSuccsesfulMsg(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);
             }
-            message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription - 1]->Increment();
-            message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
-            if (sendRequestToXapp(message, RIC_SUB_RESP, rmrMessageBuffer) != 0) {
+#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) != 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);
             }
-            message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete - 1]->Increment();
-            message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
-            if (sendRequestToXapp(message, RIC_SUB_DEL_RESP, rmrMessageBuffer) != 0) {
+
+            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) != 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;
@@ -1888,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);
             }
@@ -1912,12 +2810,18 @@ 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));
-                        message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol - 1]->Increment();
-                        message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
+#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);
+
+                        // 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 {
-                        mdclog_write(MDCLOG_ERR, "RIC request id missing illigal request");
+                        mdclog_write(MDCLOG_ERR, "RIC request id missing illegal request");
                     }
                 }
                 if (messageSent) {
@@ -1927,38 +2831,347 @@ 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);
             }
-            message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription - 1]->Increment();
-            message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
+#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");
             }
             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);
             }
-            message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete - 1]->Increment();
-            message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete - 1]->Increment((double)rmrMessageBuffer.rcvMessage->len);
+#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");
             }
             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<std::string, E2NodeConnectionHandling>::iterator itr = connectionHandlingPerE2NodeMap.begin();
+        while (itr != connectionHandlingPerE2NodeMap.end())
+        {
+            int result = itr->first.compare(enbName);
+            if (result == 0)
+            {
+                mdclog_write(MDCLOG_DEBUG, "enb name in map :%s, status :%d", itr->first.c_str(), itr->second.e2tProcedureOngoingStatus);
+                e2NodeConnectionHandling = itr->second;
+                return true;
+                break;
+            }
+            ++itr;
+        }
+    }
+    return false;
+}
+
+void setE2ProcedureOngoingStatus(char *enbName, E2T_Procedure_States state)
+{
+    printEntryPresentInMap();
+    if(connectionHandlingPerE2NodeMap.empty())
+    {
+        mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty");
+        return;
+    }
+    else
+    {
+        mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map");
+        std::map<std::string, E2NodeConnectionHandling>::iterator itr = connectionHandlingPerE2NodeMap.begin();
+        while(itr != connectionHandlingPerE2NodeMap.end())
+        {
+            int result = itr->first.compare(enbName);
+            if (result == 0)
+            {
+                mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus);
+                itr->second.e2tProcedureOngoingStatus = state;
+                mdclog_write(MDCLOG_DEBUG, "Current procedure updated to %d", itr->second.e2tProcedureOngoingStatus);
+                break;
+            }
+            ++itr; 
+        }
+    }
+}
+
+void insertE2SetupProcedureOngoing(char *enbName, long &transactionID)
+{
+    struct E2NodeConnectionHandling e2NodeConnectionHandling;
+    e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_ONGOING;
+    e2NodeConnectionHandling.e2SetupProcedureTransactionId = transactionID;
+
+    std::string key(enbName);
+    printEntryPresentInMap();
+    if(connectionHandlingPerE2NodeMap.empty())
+    {
+        mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty");
+        mdclog_write(MDCLOG_DEBUG, "Inserting %s to connectionHandlingPerE2NodeMap Map", enbName);
+
+        connectionHandlingPerE2NodeMap.insert(std::make_pair(key, e2NodeConnectionHandling));
+
+        mdclog_write(MDCLOG_DEBUG, "Default Value after Inserting Key for %s - Value is {e2tProcedureOngoingStatus is %d, e2SetupProcedureTransactionId: %ld}", 
+                key.c_str(),
+                e2NodeConnectionHandling.e2tProcedureOngoingStatus,
+                e2NodeConnectionHandling.e2SetupProcedureTransactionId);
+        return;
+    }
+    else
+    {
+        mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map");
+        std::map<std::string, E2NodeConnectionHandling>::iterator itr = connectionHandlingPerE2NodeMap.begin();
+        bool enodebNameFound = false;
+        while(itr != connectionHandlingPerE2NodeMap.end())
+        {
+            int result = itr->first.compare(enbName);
+            if (result == 0)
+            {
+                enodebNameFound = true;
+                break;
+            }
+            ++itr;
+        }
+        if (enodebNameFound == false)
+        {
+            mdclog_write(MDCLOG_DEBUG, "Inserting %s to connectionHandlingPerE2NodeMap Map", enbName);
+            connectionHandlingPerE2NodeMap.insert(std::make_pair(key, e2NodeConnectionHandling));
+
+            mdclog_write(MDCLOG_DEBUG, "Default Value after Inserting Key for %s - Value is {e2tProcedureOngoingStatus is %d, e2SetupProcedureTransactionId: %ld}", 
+                key.c_str(),
+                e2NodeConnectionHandling.e2tProcedureOngoingStatus,
+                e2NodeConnectionHandling.e2SetupProcedureTransactionId);
+        }
+        else
+        {
+            mdclog_write(MDCLOG_DEBUG, "Processing E2Setup Req received for same gnb - %s", enbName);
+            setE2ProcedureOngoingStatus(enbName, E2_SETUP_PROCEDURE_ONGOING);
+        }
+    }
+}
 
+E2T_Procedure_States currentE2tProcedureOngoingStatus(char *enbName)
+{
+    printEntryPresentInMap();
+    if(connectionHandlingPerE2NodeMap.empty())
+    {
+        mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty");
+        return E2_SETUP_PROCEDURE_NOT_INITIATED;
+    }
+    else
+    {
+        mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map");
+        std::map<std::string, E2NodeConnectionHandling>::iterator itr = connectionHandlingPerE2NodeMap.begin();
+        while(itr != connectionHandlingPerE2NodeMap.end())
+        {
+            int result = itr->first.compare(enbName);
+            if (result == 0)
+            {
+                mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus);
+                mdclog_write(MDCLOG_DEBUG, "%s Entry has found", enbName);
+                return itr->second.e2tProcedureOngoingStatus;
+            }
+            ++itr;
+        }
+        mdclog_write(MDCLOG_DEBUG, "No Key %s Found in connectionHandlingPerE2NodeMap Map", enbName);
+        return E2_SETUP_PROCEDURE_NOT_INITIATED;
+    }
+}
+
+bitset<sendMsgMaxBitPosition> getSendMsgBitSetValue(int procedureCode, bitset<requiredIePresentMaxBitSetPosition> isRequiredIesPresent, char* enbName)
+{
+    bitset<sendMsgMaxBitPosition> sendMsgTo(0); // Msg being sent to E2M = 0, Msg being sent to SubMgr = 1
+    switch(procedureCode)
+    {
+        case numberZero:
+        {
+            E2T_Procedure_States currentProcedureOngoing = currentE2tProcedureOngoingStatus(enbName); 
+            if ((currentProcedureOngoing == E2_SETUP_PROCEDURE_COMPLETED || 
+                 currentProcedureOngoing == RIC_SERVICE_UPDATE_PROCEDURE_ONGOING) &&
+                 (isRequiredIesPresent.test(transactionIdIeBitSetPosition)))
+            {
+                sendMsgTo.set(sendMsgToE2MBitSetPosition);
+            }
+            else if ((currentProcedureOngoing == RIC_SUBS_PROCEDURE_ONGOING) &&
+                      isRequiredIesPresent.test(ricRequestIdIeBitSetPosition) && isRequiredIesPresent.test(causeIeBitSetPosition))
+            {
+                sendMsgTo.set(sendMsgToSubMgrBitSetPosition);
+            }        
             break;
         }
+        case ProcedureCode_id_E2setup:
+        case ProcedureCode_id_RICserviceUpdate:
+        {
+            if(isRequiredIesPresent.test(transactionIdIeBitSetPosition))
+            {
+                sendMsgTo.set(sendMsgToE2MBitSetPosition);
+            }
+            break;
+
+        }
+        case ProcedureCode_id_RICsubscription:
+        {
+            if(isRequiredIesPresent.test(ricRequestIdIeBitSetPosition) && isRequiredIesPresent.test(causeIeBitSetPosition))
+            {
+                sendMsgTo.set(sendMsgToSubMgrBitSetPosition);
+            }
+            break;
+        }
+        default:
+        {
+            mdclog_write(MDCLOG_ERR, "Invalid procedure code received");
+        }
+    }
+    return sendMsgTo;
+}
+
+void printEntryPresentInMap()
+{
+    mdclog_write(MDCLOG_DEBUG, "Inside printEntryPresentInMap");
+    if(connectionHandlingPerE2NodeMap.empty())
+    {
+        mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty");
+        return;
+    }
+    else
+    {
+        mdclog_write(MDCLOG_DEBUG, "Entry Present in Map");
+        std::map<std::string, E2NodeConnectionHandling>::iterator it = connectionHandlingPerE2NodeMap.begin();
+        while (it != connectionHandlingPerE2NodeMap.end())
+        {
+            mdclog_write(MDCLOG_DEBUG, "Key -> { enb name in map : %s }, Value -> { e2tProcedureOngoingStatus is %d, e2SetupProcedureTransactionId is %ld }", it->first.c_str(), it->second.e2tProcedureOngoingStatus, it->second.e2SetupProcedureTransactionId);
+            ++it;
+        }
+        mdclog_write(MDCLOG_DEBUG, "All entries currently present in connectionHandlingPerE2NodeMap are printed successfully");
     }
 }
 
+void handleE2SetupReq(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, E2AP_PDU_t *pdu, long &transactionID, int streamId, Sctp_Map_t *sctpMap)
+{
+    auto logLevel = mdclog_level_get();
+
+    #ifndef UNIT_TEST
+    buildPrometheusList(message.peerInfo, message.peerInfo->sctpParams->prometheusFamily);
+    buildInternalCounterPrometheusList(message.peerInfo, message.peerInfo->sctpParams->prometheusFamily);
+    #endif
+
+    struct sctp_status status;
+    int stat_size = sizeof(status);
+    getsockopt( message.peerInfo->fileDescriptor, SOL_SCTP, SCTP_STATUS,(void *)&status, (socklen_t *)&stat_size );
+
+    if (logLevel >= MDCLOG_DEBUG) {
+        mdclog_write(MDCLOG_DEBUG, "Start from SCTP %d fd", message.peerInfo->fileDescriptor);
+        mdclog_write(MDCLOG_DEBUG, "SCTP status assoc id %d instrms %d outstrms %d", status.sstat_assoc_id,
+                status.sstat_instrms, status.sstat_outstrms);
+    }
+    if(status.sstat_outstrms == numberOne || status.sstat_instrms == numberOne)
+    {
+        message.peerInfo->isSingleStream = true;
+        message.peerInfo->singleStreamId = streamId;
+        if (status.sstat_outstrms == numberOne && status.sstat_instrms == numberOne){
+            if (logLevel >= MDCLOG_DEBUG) {
+                mdclog_write(MDCLOG_DEBUG, "Single SCTP stream is used for sending from now on, assoc id %d streamId %d #instrms %d #outstrms %d, %s",status.sstat_assoc_id, streamId, status.sstat_instrms, status.sstat_outstrms, __FUNCTION__);
+            }
+        }
+        else {
+            mdclog_write(MDCLOG_ERR, "Single SCTP stream used for sending messages even if there is a mismatch in number of in & out streams, assoc id %d instrms %d outstrms %d", status.sstat_assoc_id,
+                status.sstat_instrms, status.sstat_outstrms);
+        }
+    }
+
+    string messageName("E2setupRequest");
+    string ieName("E2setupRequestIEs");
+    message.message.messageType = RIC_E2_SETUP_REQ;
+    #ifndef UNIT_TEST
+    message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment();
+    message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment((double)message.message.asnLength);
+
+    buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); //UT - Segmentation Fault Happening.
+    #endif
+
+    mdclog_write(MDCLOG_DEBUG, "Called insertE2ProcedureOngoing: EnbName is %s and transactionID is %ld", message.message.enodbName, transactionID);
+    insertE2SetupProcedureOngoing(message.message.enodbName, transactionID);
+}
+
 /**
  *
  * @param message
@@ -1973,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));
@@ -1994,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) {
@@ -2044,18 +3258,35 @@ int PER_FromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuf
     }
     auto rval = asn_decode(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, (void **) &pdu,
                            rmrMessageBuffer.rcvMessage->payload, rmrMessageBuffer.rcvMessage->len);
+    if (mdclog_level_get() >= MDCLOG_DEBUG) {
+        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;
     }
 
     int buff_size = RECEIVE_XAPP_BUFFER_SIZE;
     auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu,
                                    rmrMessageBuffer.rcvMessage->payload, buff_size);
+    if (mdclog_level_get() >= MDCLOG_DEBUG) {
+        mdclog_write(MDCLOG_DEBUG, "%s After encoding PDU to PER", __func__ );
+    }
     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",
@@ -2063,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;
 }
 
@@ -2079,18 +3318,19 @@ int PER_FromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuf
 int receiveXappMessages(Sctp_Map_t *sctpMap,
                         RmrMessagesBuffer_t &rmrMessageBuffer,
                         struct timespec &ts) {
+    int loglevel = mdclog_level_get();
     if (rmrMessageBuffer.rcvMessage == nullptr) {
         //we have error
         mdclog_write(MDCLOG_ERR, "RMR Allocation message, %s", strerror(errno));
-        return -1;
+        return negativeOne;
     }
 
-    if (mdclog_level_get() >= MDCLOG_DEBUG) {
-        mdclog_write(MDCLOG_DEBUG, "Call to rmr_rcv_msg");
-    }
+//    if (loglevel >= MDCLOG_DEBUG) {
+//        mdclog_write(MDCLOG_DEBUG, "Call to rmr_rcv_msg");
+//    }
     rmrMessageBuffer.rcvMessage = rmr_rcv_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.rcvMessage);
     if (rmrMessageBuffer.rcvMessage == nullptr) {
-        mdclog_write(MDCLOG_ERR, "RMR Receving message with null pointer, Realloc rmr mesage buffer");
+        mdclog_write(MDCLOG_ERR, "RMR Receiving message with null pointer, Reallocated rmr message buffer");
         rmrMessageBuffer.rcvMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE);
         return -2;
     }
@@ -2101,9 +3341,12 @@ int receiveXappMessages(Sctp_Map_t *sctpMap,
 
     // get message payload
     //auto msgData = msg->payload;
-    if (rmrMessageBuffer.rcvMessage->state != 0) {
-        mdclog_write(MDCLOG_ERR, "RMR Receving message with stat = %d", rmrMessageBuffer.rcvMessage->state);
-        return -1;
+#ifdef UNIT_TEST
+    rmrMessageBuffer.rcvMessage->state = 0;
+#endif
+    if (rmrMessageBuffer.rcvMessage->state != numberZero) {
+        mdclog_write(MDCLOG_ERR, "RMR Receiving message with stat = %d", rmrMessageBuffer.rcvMessage->state);
+        return negativeOne;
     }
     rmr_get_meid(rmrMessageBuffer.rcvMessage, (unsigned char *)message.message.enodbName);
     message.peerInfo = (ConnectedCU_t *) sctpMap->find(message.message.enodbName);
@@ -2115,114 +3358,281 @@ 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(numberOne, std::memory_order_release);
+
+    }
     switch (rmrMessageBuffer.rcvMessage->mtype) {
         case RIC_E2_SETUP_RESP : {
-            if (PER_FromXML(message, rmrMessageBuffer) != 0) {
+            if (loglevel >= MDCLOG_DEBUG) {
+                mdclog_write(MDCLOG_DEBUG, "RIC_E2_SETUP_RESP");
+            }
+            if (PER_FromXML(message, rmrMessageBuffer) != numberZero) {
                 break;
             }
-            message.peerInfo->counters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup - 1]->Increment();
-            message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
-            if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) {
+#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);
+
+            // 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 (PER_FromXML(message, rmrMessageBuffer) != 0) {
+            if (loglevel >= MDCLOG_DEBUG) {
+                mdclog_write(MDCLOG_DEBUG, "RIC_E2_SETUP_FAILURE");
+            }
+            if (PER_FromXML(message, rmrMessageBuffer) != numberZero) {
                 break;
             }
-            message.peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup - 1]->Increment();
-            message.peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
-            if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) {
+#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);
+
+            // 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: {
-            message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication - 1]->Increment();
-            message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
-            if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) {
+            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);
+
+            // 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;
         }
         case RIC_SUB_REQ: {
-            message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscription - 1]->Increment();
-            message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscription - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
-            if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) {
+            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);
+
+            // 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: {
-            message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete - 1]->Increment();
-            message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
-            if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) {
+            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);
+
+            // 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: {
-            message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICcontrol - 1]->Increment();
-            message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICcontrol - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
-            if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) {
+            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);
+
+            // 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 (PER_FromXML(message, rmrMessageBuffer) != 0) {
+            if (loglevel >= MDCLOG_DEBUG) {
+                mdclog_write(MDCLOG_DEBUG, "RIC_SERVICE_QUERY");
+            }
+            if (PER_FromXML(message, rmrMessageBuffer) != numberZero) {
                 break;
             }
-            message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceQuery - 1]->Increment();
-            message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
-            if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) {
+#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);
+
+            // 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 (PER_FromXML(message, rmrMessageBuffer) != 0) {
+            if (loglevel >= MDCLOG_DEBUG) {
+                mdclog_write(MDCLOG_DEBUG, "RIC_SERVICE_UPDATE_ACK");
+            }
+            if (PER_FromXML(message, rmrMessageBuffer) != numberZero) {
+                mdclog_write(MDCLOG_ERR, "error in PER_FromXML");
                 break;
             }
-            message.peerInfo->counters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate - 1]->Increment();
-            message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
-            if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) {
+#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, numberZero, sctpMap) != numberZero) {
                 mdclog_write(MDCLOG_ERR, "Failed to send RIC_SERVICE_UPDATE_ACK");
-                return -6;
+                return negativeSix;
             }
             break;
         }
         case RIC_SERVICE_UPDATE_FAILURE: {
-            if (PER_FromXML(message, rmrMessageBuffer) != 0) {
+            if (loglevel >= MDCLOG_DEBUG) {
+                mdclog_write(MDCLOG_DEBUG, "RIC_SERVICE_UPDATE_FAILURE");
+            }
+            if (PER_FromXML(message, rmrMessageBuffer) != numberZero) {
                 break;
             }
-            message.peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate - 1]->Increment();
-            message.peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
-            if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) {
+#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);
+
+            // 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;
         }
         case RIC_E2_RESET_REQ: {
-            if (PER_FromXML(message, rmrMessageBuffer) != 0) {
+            if (loglevel >= MDCLOG_DEBUG) {
+                mdclog_write(MDCLOG_DEBUG, "RIC_E2_RESET_REQ");
+            }
+            if (PER_FromXML(message, rmrMessageBuffer) != numberZero) {
                 break;
             }
-            message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_Reset - 1]->Increment();
-            message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_Reset - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
+#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;
@@ -2230,12 +3640,21 @@ int receiveXappMessages(Sctp_Map_t *sctpMap,
             break;
         }
         case RIC_E2_RESET_RESP: {
-            if (PER_FromXML(message, rmrMessageBuffer) != 0) {
+            if (loglevel >= MDCLOG_DEBUG) {
+                mdclog_write(MDCLOG_DEBUG, "RIC_E2_RESET_RESP");
+            }
+            if (PER_FromXML(message, rmrMessageBuffer) != numberZero) {
                 break;
             }
-            message.peerInfo->counters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_Reset - 1]->Increment();
-            message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset - 1]->Increment(rmrMessageBuffer.rcvMessage->len);
-            if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) {
+#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);
+
+            // 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;
             }
@@ -2265,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;
                 }
             }
 
@@ -2282,49 +3702,53 @@ 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);
+#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 (mdclog_level_get() >= MDCLOG_DEBUG) {
+            } else if (loglevel >= MDCLOG_DEBUG) {
                 mdclog_write(MDCLOG_DEBUG, "Got Keep Alive Request send : %s", rmrMessageBuffer.ka_message);
             }
 
             break;
         }
         case RIC_HEALTH_CHECK_REQ: {
+            static int counter = numberZero;
             // send message back
-            rmr_bytes2payload(rmrMessageBuffer.sendMessage,
+            rmr_bytes2payload(rmrMessageBuffer.rcvMessage,
                               (unsigned char *)"OK",
-                              2);
-            rmrMessageBuffer.sendMessage->mtype = RIC_HEALTH_CHECK_RESP;
-            rmrMessageBuffer.sendMessage->state = 0;
+                              numberTwo);
+            rmrMessageBuffer.rcvMessage->mtype = RIC_HEALTH_CHECK_RESP;
+            rmrMessageBuffer.rcvMessage->state = numberZero;
             static unsigned char tx[32];
             auto txLen = snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++);
-            rmr_bytes2xact(rmrMessageBuffer.sendMessage, tx, txLen);
-            rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage);
-            if (rmrMessageBuffer.sendMessage == nullptr) {
-                rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE);
+            rmr_bytes2xact(rmrMessageBuffer.rcvMessage, tx, txLen);
+            rmrMessageBuffer.rcvMessage = rmr_rts_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.rcvMessage);
+            //rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage);
+            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.sendMessage->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.sendMessage->state, translateRmrErrorMessages(rmrMessageBuffer.sendMessage->state).c_str());
-            } else if (mdclog_level_get() >= MDCLOG_DEBUG) {
-                mdclog_write(MDCLOG_DEBUG, "Got RIC_HEALTH_CHECK_REQ Request send : OK");
+                             rmrMessageBuffer.rcvMessage->state, translateRmrErrorMessages(rmrMessageBuffer.rcvMessage->state).c_str());
+            } else if (loglevel >= MDCLOG_DEBUG && (++counter % 100 == numberZero)) {
+                mdclog_write(MDCLOG_DEBUG, "Got %d RIC_HEALTH_CHECK_REQ Request send : OK", counter);
             }
 
             break;
         }
 
         default:
-            mdclog_write(MDCLOG_WARN, "Message Type : %d is not seported", 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;
@@ -2334,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;
 }
 
 /**
@@ -2354,6 +3778,9 @@ int sendDirectionalSctpMsg(RmrMessagesBuffer_t &messageBuffer,
                            ReportingMessages_t &message,
                            int failedMsgId,
                            Sctp_Map_t *sctpMap) {
+    if (mdclog_level_get() >= MDCLOG_DEBUG) {
+        mdclog_write(MDCLOG_DEBUG, "send message: %d to %s address", message.message.messageType, message.message.enodbName);
+    }
 
     getRequestMetaData(message, messageBuffer);
     if (mdclog_level_get() >= MDCLOG_INFO) {
@@ -2378,36 +3805,11 @@ 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;
 }
 
-/**
- *
- * @param rmrCtx the rmr context to send and receive
- * @param msg the msg we got fromxApp
- * @param metaData data from xApp in ordered struct
- * @param failedMesgId the return message type error
- */
-void
-sendFailedSendingMessagetoXapp(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &message, int failedMesgId) {
-    rmr_mbuf_t *msg = rmrMessageBuffer.sendMessage;
-    msg->len = snprintf((char *) msg->payload, 200, "the gNb/eNode name %s not found",
-                        message.message.enodbName);
-    if (mdclog_level_get() >= MDCLOG_INFO) {
-        mdclog_write(MDCLOG_INFO, "%s", msg->payload);
-    }
-    msg->mtype = failedMesgId;
-    msg->state = 0;
-
-    static unsigned char tx[32];
-    snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++);
-    rmr_bytes2xact(msg, tx, strlen((const char *) tx));
-
-    sendRmrMessage(rmrMessageBuffer, message);
-}
-
-
 
 /**
  *
@@ -2429,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 chack not to quit here), %s, %s %d",
+            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 chack not to quit here)");
-        return -1;
+        mdclog_write(MDCLOG_ERR, "epoll_ctl EPOLL_CTL_ADD (may check not to quit here)");
+        return negativeOne;
+#endif
     }
-    return 0;
+    return numberZero;
 }
 
 /**
@@ -2476,55 +3888,67 @@ 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 chack not to quit here), %s, %s %d",
+            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 chack not to quit here)");
-        return -1;
+        mdclog_write(MDCLOG_ERR, "epoll_ctl EPOLL_CTL_ADD (may check not to quit here)");
+        return negativeOne;
     }
-    return 0;
+    return numberZero;
 }
 
 
 int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &message) {
     buildJsonMessage(message);
-
+#ifndef UNIT_TEST
     rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage);
-
+#else
+    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));
+#ifndef UNIT_TEST
             rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage);
+#endif
             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(),
@@ -2545,6 +3969,9 @@ int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &m
 }
 
 void buildJsonMessage(ReportingMessages_t &message) {
+#ifdef UNIT_TEST
+    jsonTrace = true;
+#endif
     if (jsonTrace) {
         message.outLen = sizeof(message.base64Data);
         base64::encode((const unsigned char *) message.message.asndata,
@@ -2590,7 +4017,7 @@ string translateRmrErrorMessages(int state) {
             str = "RMR_OK - state is good";
             break;
         case RMR_ERR_BADARG:
-            str = "RMR_ERR_BADARG - argument passd to function was unusable";
+            str = "RMR_ERR_BADARG - argument passed to function was unusable";
             break;
         case RMR_ERR_NOENDPT:
             str = "RMR_ERR_NOENDPT - send//call could not find an endpoint based on msg type";
@@ -2645,5 +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;
+}