version 3.0.4

fix some KA issues
add testing (not yet produce the exe)

Change-Id: I38cc19189018841a32cc0c929c750ddf4039f15d
Signed-off-by: aa7133@att.com <aa7133@att.com>

diff --git a/RIC-E2-TERMINATION/TEST/T1/E2Builder.h b/RIC-E2-TERMINATION/TEST/T1/E2Builder.h
new file mode 100644 (file)
index 0000000..11fa3f1
--- /dev/null
+++ b/RIC-E2-TERMINATION/TEST/T1/E2Builder.h
@@ -0,0 +1,365 @@
+/*
+ * Copyright 2019 AT&T Intellectual Property
+ * Copyright 2019 Nokia
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//
+// Created by adi ENZEL on 12/10/19.
+//
+
+#ifndef E2_E2BUILDER_H
+#define E2_E2BUILDER_H
+
+#include <cstring>
+#include <cstdio>
+#include <cerrno>
+#include <cstdlib>
+#include <sys/types.h>
+#include <error.h>
+#include <mdclog/mdclog.h>
+
+
+#include <mdclog/mdclog.h>
+
+
+#include "asn1cFiles/E2AP-PDU.h"
+#include "asn1cFiles/InitiatingMessage.h"
+#include "asn1cFiles/SuccessfulOutcome.h"
+#include "asn1cFiles/UnsuccessfulOutcome.h"
+
+#include "asn1cFiles/ProtocolIE-Field.h"
+
+#include "asn1cFiles/constr_TYPE.h"
+
+using namespace std;
+
+class E2Builder {
+public:
+
+    static void checkAndPrint(asn_TYPE_descriptor_t *typeDescriptor, void *data, char *dataType, const char *function) {
+        char errbuf[128]; /* Buffer for error message */
+        size_t errlen = sizeof(errbuf); /* Size of the buffer */
+        if (asn_check_constraints(typeDescriptor, data, errbuf, &errlen) != 0) {
+            mdclog_write(MDCLOG_ERR, "%s Constraint validation failed: %s", dataType, errbuf);
+        } else if (mdclog_level_get() >= MDCLOG_DEBUG) {
+            mdclog_write(MDCLOG_DEBUG, "%s successes function %s", dataType, function);
+        }
+    }
+
+    static void buildInitiatingMessagePDU(E2AP_PDU_t &pdu, InitiatingMessage_t *initMsg) {
+        pdu.present = E2AP_PDU_PR_initiatingMessage;
+        pdu.choice.initiatingMessage = initMsg;
+    }
+
+    template<typename T>
+    static void buildInitMsg(InitiatingMessage_t &initMsg,
+                             InitiatingMessage__value_PR present,
+                             ProcedureCode_t procedureCode,
+                             Criticality_t     criticality,
+                             T *value) {
+        initMsg.value.present = present;
+        initMsg.procedureCode = procedureCode;
+        initMsg.criticality = criticality;
+
+        switch (present) {
+            case InitiatingMessage__value_PR_RICsubscriptionRequest: {
+                memcpy(&initMsg.value.choice.RICsubscriptionRequest, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_RICsubscriptionDeleteRequest: {
+                memcpy(&initMsg.value.choice.RICsubscriptionDeleteRequest, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_RICserviceUpdate: {
+                memcpy(&initMsg.value.choice.RICserviceUpdate, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_RICcontrolRequest: {
+                memcpy(&initMsg.value.choice.RICcontrolRequest, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_X2SetupRequest: {
+                memcpy(&initMsg.value.choice.X2SetupRequest, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_ENDCX2SetupRequest: {
+                memcpy(&initMsg.value.choice.ENDCX2SetupRequest, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_ResourceStatusRequest: {
+                memcpy(&initMsg.value.choice.ResourceStatusRequest, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_ENBConfigurationUpdate: {
+                memcpy(&initMsg.value.choice.ENBConfigurationUpdate, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_ENDCConfigurationUpdate: {
+                memcpy(&initMsg.value.choice.ENDCConfigurationUpdate, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_ResetRequest: {
+                memcpy(&initMsg.value.choice.ResetRequest, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_RICindication: {
+                memcpy(&initMsg.value.choice.RICindication, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_RICserviceQuery: {
+                memcpy(&initMsg.value.choice.RICserviceQuery, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_LoadInformation: {
+                memcpy(&initMsg.value.choice.LoadInformation, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_GNBStatusIndication: {
+                memcpy(&initMsg.value.choice.GNBStatusIndication, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_ResourceStatusUpdate: {
+                memcpy(&initMsg.value.choice.ResourceStatusUpdate, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_ErrorIndication: {
+                memcpy(&initMsg.value.choice.ErrorIndication, value, sizeof(*value));
+                break;
+            }
+            case InitiatingMessage__value_PR_NOTHING:
+            default : {
+                break;
+            }
+        }
+    }
+
+    static void buildSuccsesfulMessagePDU(E2AP_PDU_t &pdu, SuccessfulOutcome_t *succMsg) {
+        pdu.present = E2AP_PDU_PR_successfulOutcome;
+        pdu.choice.successfulOutcome = succMsg;
+    }
+
+    template<typename T>
+    static void buildSuccMsg(SuccessfulOutcome_t &succMsg,
+                             SuccessfulOutcome__value_PR present,
+                             ProcedureCode_t procedureCode,
+                             Criticality_t     criticality,
+                             T *value) {
+        succMsg.value.present = present;
+        succMsg.procedureCode = procedureCode;
+        succMsg.criticality = criticality;
+
+        switch (present) {
+            case SuccessfulOutcome__value_PR_RICsubscriptionResponse: {
+                memcpy(&succMsg.value.choice.RICsubscriptionResponse, value, sizeof(*value));
+                break;
+            }
+            case SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse: {
+                memcpy(&succMsg.value.choice.RICsubscriptionDeleteResponse, value, sizeof(*value));
+                break;
+            }
+            case SuccessfulOutcome__value_PR_RICserviceUpdateAcknowledge: {
+                memcpy(&succMsg.value.choice.RICserviceUpdateAcknowledge, value, sizeof(*value));
+                break;
+            }
+            case SuccessfulOutcome__value_PR_RICcontrolAcknowledge: {
+                memcpy(&succMsg.value.choice.RICcontrolAcknowledge, value, sizeof(*value));
+                break;
+            }
+            case SuccessfulOutcome__value_PR_X2SetupResponse: {
+                memcpy(&succMsg.value.choice.X2SetupResponse, value, sizeof(*value));
+                break;
+            }
+            case SuccessfulOutcome__value_PR_ENDCX2SetupResponse: {
+                memcpy(&succMsg.value.choice.ENDCX2SetupResponse, value, sizeof(*value));
+                break;
+            }
+            case SuccessfulOutcome__value_PR_ResourceStatusResponse: {
+                memcpy(&succMsg.value.choice.ResourceStatusResponse, value, sizeof(*value));
+                break;
+            }
+            case SuccessfulOutcome__value_PR_ENBConfigurationUpdateAcknowledge: {
+                memcpy(&succMsg.value.choice.ENBConfigurationUpdateAcknowledge, value, sizeof(*value));
+                break;
+            }
+            case SuccessfulOutcome__value_PR_ENDCConfigurationUpdateAcknowledge: {
+                memcpy(&succMsg.value.choice.ENDCConfigurationUpdateAcknowledge, value, sizeof(*value));
+                break;
+            }
+            case SuccessfulOutcome__value_PR_ResetResponse: {
+                memcpy(&succMsg.value.choice.ResetResponse, value, sizeof(*value));
+                break;
+            }
+            case SuccessfulOutcome__value_PR_NOTHING:
+            default:
+                break;
+        }
+    }
+
+
+
+
+
+    static void buildUnSucssesfullMessagePDU(E2AP_PDU_t &pdu,UnsuccessfulOutcome_t *unSuccMsg) {
+        pdu.present = E2AP_PDU_PR_unsuccessfulOutcome;
+        pdu.choice.unsuccessfulOutcome = unSuccMsg;
+    }
+
+    template<typename T>
+    static void buildUnSuccMsg(UnsuccessfulOutcome_t &unSuccMsg,
+                             UnsuccessfulOutcome__value_PR present,
+                             ProcedureCode_t procedureCode,
+                             Criticality_t     criticality,
+                             T *value) {
+        unSuccMsg.value.present = present;
+        unSuccMsg.procedureCode = procedureCode;
+        unSuccMsg.criticality = criticality;
+
+        switch (present) {
+            case UnsuccessfulOutcome__value_PR_RICsubscriptionFailure: {
+                memcpy(&unSuccMsg.value.choice.RICsubscriptionFailure, value, sizeof(*value));
+                break;
+            }
+            case UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure: {
+                memcpy(&unSuccMsg.value.choice.RICsubscriptionDeleteFailure, value, sizeof(*value));
+                break;
+            }
+            case UnsuccessfulOutcome__value_PR_RICserviceUpdateFailure: {
+                memcpy(&unSuccMsg.value.choice.RICserviceUpdateFailure, value, sizeof(*value));
+                break;
+            }
+            case UnsuccessfulOutcome__value_PR_RICcontrolFailure: {
+                memcpy(&unSuccMsg.value.choice.RICcontrolFailure, value, sizeof(*value));
+                break;
+            }
+            case UnsuccessfulOutcome__value_PR_X2SetupFailure: {
+                memcpy(&unSuccMsg.value.choice.X2SetupFailure, value, sizeof(*value));
+                break;
+            }
+            case UnsuccessfulOutcome__value_PR_ENDCX2SetupFailure: {
+                memcpy(&unSuccMsg.value.choice.ENDCX2SetupFailure, value, sizeof(*value));
+                break;
+            }
+            case UnsuccessfulOutcome__value_PR_ResourceStatusFailure: {
+                memcpy(&unSuccMsg.value.choice.ResourceStatusFailure, value, sizeof(*value));
+                break;
+            }
+            case UnsuccessfulOutcome__value_PR_ENBConfigurationUpdateFailure: {
+                memcpy(&unSuccMsg.value.choice.ENBConfigurationUpdateFailure, value, sizeof(*value));
+                break;
+            }
+            case UnsuccessfulOutcome__value_PR_ENDCConfigurationUpdateFailure: {
+                memcpy(&unSuccMsg.value.choice.ENDCConfigurationUpdateFailure, value, sizeof(*value));
+                break;
+            }
+            case UnsuccessfulOutcome__value_PR_NOTHING:
+            default:
+                break;
+        }
+    }
+
+
+    static void createPLMN_ID(PLMN_Identity_t &plmnId, const unsigned char *data) {
+        //printEntry("PLMN_Identity_t", __func__)
+        //PLMN_Identity_t *plmnId = calloc(1, sizeof(PLMN_Identity_t));
+        ASN_STRUCT_RESET(asn_DEF_PLMN_Identity, &plmnId);
+        plmnId.size = 3;
+        plmnId.buf = (uint8_t *)calloc(1, 3);
+        memcpy(plmnId.buf, data, 3);
+
+        if (mdclog_level_get() >= MDCLOG_DEBUG) {
+            checkAndPrint(&asn_DEF_PLMN_Identity, &plmnId, (char *)"PLMN_Identity_t", __func__);
+        }
+
+    }
+
+    static void createENB_ID(ENB_ID_t &enb, ENB_ID_PR enbType, unsigned char *data) {
+        //printEntry("ENB_ID_t", __func__)
+        ASN_STRUCT_RESET(asn_DEF_ENB_ID, &enb);
+        enb.present = enbType;
+        switch (enbType) {
+            case ENB_ID_PR_macro_eNB_ID: { // 20 bit 3 bytes
+                enb.choice.macro_eNB_ID.size = 3;
+                enb.choice.macro_eNB_ID.bits_unused = 4;
+
+                enb.present = ENB_ID_PR_macro_eNB_ID;
+
+                enb.choice.macro_eNB_ID.buf = (uint8_t *)calloc(1, enb.choice.macro_eNB_ID.size);
+                data[enb.choice.macro_eNB_ID.size - 1] = ((unsigned)(data[enb.choice.macro_eNB_ID.size - 1]
+                        >> (unsigned)enb.choice.macro_eNB_ID.bits_unused)
+                        << (unsigned)enb.choice.macro_eNB_ID.bits_unused);
+                memcpy(enb.choice.macro_eNB_ID.buf, data, enb.choice.macro_eNB_ID.size);
+
+                break;
+            }
+            case ENB_ID_PR_home_eNB_ID: { // 28 bit 4 bytes
+                enb.choice.home_eNB_ID.size = 4;
+                enb.choice.home_eNB_ID.bits_unused = 4;
+                enb.present = ENB_ID_PR_home_eNB_ID;
+
+                enb.choice.home_eNB_ID.buf = (uint8_t *)calloc(1, enb.choice.home_eNB_ID.size);
+                data[enb.choice.home_eNB_ID.size - 1] = ((unsigned)(data[enb.choice.home_eNB_ID.size - 1]
+                        >> (unsigned)enb.choice.home_eNB_ID.bits_unused)
+                        << (unsigned)enb.choice.home_eNB_ID.bits_unused);
+                memcpy(enb.choice.home_eNB_ID.buf, data, enb.choice.home_eNB_ID.size);
+                break;
+            }
+            case ENB_ID_PR_short_Macro_eNB_ID: { // 18 bit - 3 bytes
+                enb.choice.short_Macro_eNB_ID.size = 3;
+                enb.choice.short_Macro_eNB_ID.bits_unused = 6;
+                enb.present = ENB_ID_PR_short_Macro_eNB_ID;
+
+                enb.choice.short_Macro_eNB_ID.buf = (uint8_t *)calloc(1, enb.choice.short_Macro_eNB_ID.size);
+                data[enb.choice.short_Macro_eNB_ID.size - 1] = ((unsigned)(data[enb.choice.short_Macro_eNB_ID.size - 1]
+                        >> (unsigned)enb.choice.short_Macro_eNB_ID.bits_unused)
+                        << (unsigned)enb.choice.short_Macro_eNB_ID.bits_unused);
+                memcpy(enb.choice.short_Macro_eNB_ID.buf, data, enb.choice.short_Macro_eNB_ID.size);
+                break;
+            }
+            case ENB_ID_PR_long_Macro_eNB_ID: { // 21
+                enb.choice.long_Macro_eNB_ID.size = 3;
+                enb.choice.long_Macro_eNB_ID.bits_unused = 3;
+                enb.present = ENB_ID_PR_long_Macro_eNB_ID;
+
+                enb.choice.long_Macro_eNB_ID.buf = (uint8_t *)calloc(1, enb.choice.long_Macro_eNB_ID.size);
+                data[enb.choice.long_Macro_eNB_ID.size - 1] = ((unsigned)(data[enb.choice.long_Macro_eNB_ID.size - 1]
+                        >> (unsigned)enb.choice.long_Macro_eNB_ID.bits_unused)
+                        << (unsigned)enb.choice.long_Macro_eNB_ID.bits_unused);
+                memcpy(enb.choice.long_Macro_eNB_ID.buf, data, enb.choice.long_Macro_eNB_ID.size);
+                break;
+            }
+            default:
+                break;
+        }
+
+        if (mdclog_level_get() >= MDCLOG_DEBUG) {
+            checkAndPrint(&asn_DEF_ENB_ID, &enb, (char *)"ENB_ID_t", __func__);
+        }
+    }
+
+
+    static void buildGlobalENB_ID(GlobalENB_ID_t *gnbId,
+            const unsigned char *gnbData,
+            ENB_ID_PR enbType,
+            unsigned char *enbData) {
+        createPLMN_ID(gnbId->pLMN_Identity, gnbData);
+        createENB_ID(gnbId->eNB_ID, enbType, enbData);
+        if (mdclog_level_get() >= MDCLOG_DEBUG) {
+            checkAndPrint(&asn_DEF_GlobalENB_ID, gnbId, (char *)"GlobalENB_ID_t", __func__);
+        }
+    }
+};
+
+
+#endif //E2_E2BUILDER_H

diff --git a/RIC-E2-TERMINATION/TEST/T1/E2Setup.cpp b/RIC-E2-TERMINATION/TEST/T1/E2Setup.cpp
new file mode 100644 (file)
index 0000000..5637dbb
--- /dev/null
+++ b/RIC-E2-TERMINATION/TEST/T1/E2Setup.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2019 AT&T Intellectual Property
+ * Copyright 2019 Nokia
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//
+// Created by adi ENZEL on 12/10/19.
+//
+
+#include "E2Builder.h"
+
+#include "asn1cFiles/ProtocolIE-Field.h"
+
+template<typename T>
+void buildX2SetupIE(X2SetupRequest_IEs_t *x2SetupIE,
+        ProtocolIE_ID_t id,
+        Criticality_t criticality,
+        X2SetupRequest_IEs__value_PR present,
+        T *value) {
+    x2SetupIE->id = id;
+    x2SetupIE->criticality = criticality;
+    x2SetupIE->value.present = present;
+
+    switch (present) {
+        case X2SetupRequest_IEs__value_PR_GlobalENB_ID: {
+            memcpy(&x2SetupIE->value.choice.GlobalENB_ID, value, sizeof(GlobalENB_ID_t));
+            break;
+        }
+        case X2SetupRequest_IEs__value_PR_ServedCells: {
+            memcpy(&x2SetupIE->value.choice.ServedCells, value, sizeof(*value));
+            break;
+        }
+        case X2SetupRequest_IEs__value_PR_GUGroupIDList: {
+            memcpy(&x2SetupIE->value.choice.GUGroupIDList, value, sizeof(*value));
+            break;
+        }
+        case X2SetupRequest_IEs__value_PR_LHN_ID: {
+            memcpy(&x2SetupIE->value.choice.LHN_ID, value, sizeof(*value));
+            break;
+        }
+        case X2SetupRequest_IEs__value_PR_NOTHING:
+        default:
+            break;
+    }
+}
+
+void buildE2SetupRequest(X2SetupRequest_t *x2Setup) {
+
+}
\ No newline at end of file

diff --git a/RIC-E2-TERMINATION/TEST/T1/Test1.cpp b/RIC-E2-TERMINATION/TEST/T1/Test1.cpp
index 872a88c..f4e3794 100644 (file)
--- a/RIC-E2-TERMINATION/TEST/T1/Test1.cpp
+++ b/RIC-E2-TERMINATION/TEST/T1/Test1.cpp
@@ -21,25 +21,17 @@
 
 #include <mdclog/mdclog.h>
 
-#include "asn/type_defs.h"
-#include "asn/per/codec.hpp"
-#include "asn/printer.hpp"
+#include "asn1cFiles/E2AP-PDU.h"
+#include "asn1cFiles/InitiatingMessage.h"
+
 
-#include "X2AP-CommonDataTypes.hpp"
-#include "X2AP-Containers.hpp"
-#include "X2AP-Constants.hpp"
-#include "X2AP-IEs.hpp"
-#include "X2AP-PDU-Contents.hpp"
 
-#include "E2AP-Constants.hpp"
-#include "E2AP-IEs.hpp"
-#include "E2AP-PDU-Contents.hpp"
-#include "E2AP-PDU-Descriptions.hpp"
 
 #include <iostream>
 #include <cstdio>
 #include <cctype>
 #include <cstring>
+#include <unistd.h>
 
 #include <pthread.h>
 #include <rmr/rmr.h>
@@ -150,7 +142,7 @@ int main(const int argc, char **argv) {
         mdclog_write(MDCLOG_INFO, "RMR running");
     }
 
-    E2AP_PDU pdu {};
+    E2AP_PDU_t pdu {};
     auto &initiatingMsg = pdu.select_initiatingMessage();
     initiatingMsg.ref_procedureCode().select_id_x2Setup();
     initiatingMsg.ref_criticality().select_id_x2Setup();

diff --git a/RIC-E2-TERMINATION/TEST/e2sm.c b/RIC-E2-TERMINATION/TEST/e2sm.c
index 5fff9e3..fff8d6b 100644 (file)
--- a/RIC-E2-TERMINATION/TEST/e2sm.c
+++ b/RIC-E2-TERMINATION/TEST/e2sm.c
@@ -94,6 +94,9 @@ ENB_ID_t *createENB_ID(ENB_ID_PR enbType, unsigned char *data) {
     printEntry("ENB_ID_t", __func__)
     ENB_ID_t *enb = calloc(1, sizeof(ENB_ID_t));
     ASN_STRUCT_RESET(asn_DEF_ENB_ID, enb);
+
+    enb->present = enbType;
+
     switch (enbType) {
         case ENB_ID_PR_macro_eNB_ID: { // 20 bit 3 bytes
             enb->choice.macro_eNB_ID.size = 3;

diff --git a/RIC-E2-TERMINATION/container-tag.yaml b/RIC-E2-TERMINATION/container-tag.yaml
index a34401d..4818173 100644 (file)
--- a/RIC-E2-TERMINATION/container-tag.yaml
+++ b/RIC-E2-TERMINATION/container-tag.yaml
@@ -1,3 +1,3 @@
 # The Jenkins job requires a tag to build the Docker image.
 # Global-JJB script assumes this file is in the repo root.
-tag: 3.0.3
+tag: 3.0.4

diff --git a/RIC-E2-TERMINATION/sctpThread.cpp b/RIC-E2-TERMINATION/sctpThread.cpp
index 6874b4b..5acf491 100644 (file)
--- a/RIC-E2-TERMINATION/sctpThread.cpp
+++ b/RIC-E2-TERMINATION/sctpThread.cpp
@@ -278,6 +278,11 @@ int main(const int argc, char **argv) {
 }
 
 void handleTermInit(sctp_params_t &sctpParams) {
+    sctpParams.ka_message_length = snprintf(sctpParams.ka_message, 4096, "{\"address\": \"%s:%d\","
+                                                                         "\"fqdn\": \"%s\"}",
+                                            (const char *)sctpParams.myIP.c_str(),
+                                            sctpParams.rmrPort,
+                                            sctpParams.fqdn.c_str());
     sendTermInit(sctpParams);
     //send to e2 manager init of e2 term
     //E2_TERM_INIT
@@ -301,18 +306,12 @@ void handleTermInit(sctp_params_t &sctpParams) {
 
 void sendTermInit(sctp_params_t &sctpParams) {
     auto term_init = false;
-    char buff[4096];
-    auto len = snprintf(buff, 4096, "{\"address\": \"%s:%d\","
-                                     "\"fqdn\": \"%s\"}",
-                                     (const char *)sctpParams.myIP.c_str(),
-                                     sctpParams.rmrPort,
-                                     sctpParams.fqdn.c_str());
-    rmr_mbuf_t *msg = rmr_alloc_msg(sctpParams.rmrCtx, len);
+    rmr_mbuf_t *msg = rmr_alloc_msg(sctpParams.rmrCtx, sctpParams.ka_message_length);
     auto count = 0;
     while (!term_init) {
         msg->mtype = E2_TERM_INIT;
         msg->state = 0;
-        rmr_bytes2payload(msg, (unsigned char *) buff, len);
+        rmr_bytes2payload(msg, (unsigned char *)sctpParams.ka_message, len);
         static unsigned char tx[32];
         auto txLen = snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++);
         rmr_bytes2xact(msg, tx, txLen);
@@ -441,11 +440,9 @@ void listener(sctp_params_t *params) {
 
     rmrMessageBuffer.rcvMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE);
     rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE);
-    auto len = snprintf(rmrMessageBuffer.ka_message, 4096, "{\"address\": \"%s:%d\",\"fqdn\": \"%s\"}",
-                        (const char *) params->myIP.c_str(),
-                        params->rmrPort,
-                        params->fqdn.c_str());
-    rmrMessageBuffer.ka_message[len] = 0;
+    memcpy(rmrMessageBuffer.ka_message, params->ka_message, params->ka_message_length);
+    rmrMessageBuffer.ka_message_len = params->ka_message_length;
+    rmrMessageBuffer.ka_message[rmrMessageBuffer.ka_message_len] = 0;
 
     ReportingMessages_t message {};
 
@@ -2083,9 +2080,12 @@ int receiveXappMessages(int epoll_fd,
         }
         case E2_TERM_KEEP_ALIVE_REQ: {
             // send message back
+            if (mdclog_level_get() >= MDCLOG_INFO) {
+                mdclog_write(MDCLOG_INFO, "Got Keep Alive Request send : %s", rmrMessageBuffer.ka_message);
+            }
             rmr_bytes2payload(rmrMessageBuffer.sendMessage,
                     (unsigned char *)rmrMessageBuffer.ka_message,
-                    rmrMessageBuffer.len);
+                    rmrMessageBuffer.ka_message_len);
             rmrMessageBuffer.sendMessage->mtype = E2_TERM_KEEP_ALIVE_RESP;
             rmrMessageBuffer.sendMessage->state = 0;
             static unsigned char tx[32];

diff --git a/RIC-E2-TERMINATION/sctpThread.h b/RIC-E2-TERMINATION/sctpThread.h
index 6be9fbd..ae9ab10 100644 (file)
--- a/RIC-E2-TERMINATION/sctpThread.h
+++ b/RIC-E2-TERMINATION/sctpThread.h
@@ -119,6 +119,8 @@ typedef struct sctp_params {
     int      inotifyWD = 0;
     void     *rmrCtx = nullptr;
     Sctp_Map_t *sctpMap = nullptr;
+    char      ka_message[4096] {};
+    int       ka_message_length = 0;
     char       rmrAddress[256] {}; // "tcp:portnumber" "tcp:5566" listen to all address on port 5566
     mdclog_severity_t logLevel = MDCLOG_INFO;
     char volume[VOLUME_URL_SIZE];
@@ -144,7 +146,7 @@ typedef struct ConnectedCU {
 #define MAX_RMR_BUFF_ARRY 32
 typedef struct RmrMessagesBuffer {
     char ka_message[4096] {};
-    int  len = 0;
+    int  ka_message_len = 0;
     void *rmrCtx;
     rmr_mbuf_t *sendMessage;
     rmr_mbuf_t *sendBufferedMessages[MAX_RMR_BUFF_ARRY];

diff --git a/T1 b/T1
new file mode 100755 (executable)
index 0000000..ac0c82c
Binary files /dev/null and b/T1 differ