From: Tuan Nguyen Date: Thu, 16 Nov 2023 18:18:44 +0000 (+0000) Subject: SIM-116: Update list of performance metrics in E2 setup request for oransim X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?p=sim%2Fe2-interface.git;a=commitdiff_plain SIM-116: Update list of performance metrics in E2 setup request for oransim Change-Id: Ie325e09c6ddf205a854825ad6628cfa4ffa4bbf7 Signed-off-by: Tuan Nguyen --- diff --git a/e2sim/e2sm_examples/kpm_e2sm/src/kpm/encode_kpm.cpp b/e2sim/e2sm_examples/kpm_e2sm/src/kpm/encode_kpm.cpp index 8bfe7c6..c34c370 100755 --- a/e2sim/e2sm_examples/kpm_e2sm/src/kpm/encode_kpm.cpp +++ b/e2sim/e2sm_examples/kpm_e2sm/src/kpm/encode_kpm.cpp @@ -27,15 +27,26 @@ #include "e2sim_defs.h" using namespace std; +const char* performance_measurements[] = { + "DRB.RlcSduTransmittedVolumeDL_Filter", + "DRB.RlcSduTransmittedVolumeUL_Filter", + "DRB.PerDataVolumeDLDist.Bin ", + "DRB.PerDataVolumeULDist.Bin", + "DRB.RlcPacketDropRateDLDist", + "DRB.PacketLossRateULDist", + "L1M.DL-SS-RSRP.SSB", + "L1M.DL-SS-SINR.SSB", + "L1M.UL-SRS-RSRP" + }; + +int NUMBER_MEASUREMENTS = 9; + void encode_kpm_function_description(E2SM_KPM_RANfunction_Description_t* ranfunc_desc) { uint8_t* short_name = (uint8_t*)"ORAN-E2SM-KPM"; uint8_t* func_desc = (uint8_t*)"KPM Monitor"; uint8_t* e2sm_odi = (uint8_t*)"OID123"; LOG_I("short_name: %s, func_desc: %s, e2sm_odi: %s", short_name, func_desc, e2sm_odi); - - long inst = 1; - ASN_STRUCT_RESET(asn_DEF_E2SM_KPM_RANfunction_Description, ranfunc_desc); ranfunc_desc->ranFunction_Name.ranFunction_ShortName.size = strlen((char*)short_name); @@ -49,7 +60,8 @@ void encode_kpm_function_description(E2SM_KPM_RANfunction_Description_t* ranfunc memcpy(ranfunc_desc->ranFunction_Name.ranFunction_Description.buf, func_desc, strlen((char*)func_desc)); ranfunc_desc->ranFunction_Name.ranFunction_Description.size = strlen((char*)func_desc); - ranfunc_desc->ranFunction_Name.ranFunction_Instance = &inst; + ranfunc_desc->ranFunction_Name.ranFunction_Instance = (long *)calloc(1, sizeof(long)); + *ranfunc_desc->ranFunction_Name.ranFunction_Instance = 1; ranfunc_desc->ranFunction_Name.ranFunction_E2SM_OID.buf = (uint8_t*)calloc(1, strlen((char*)e2sm_odi)); @@ -66,7 +78,7 @@ void encode_kpm_function_description(E2SM_KPM_RANfunction_Description_t* ranfunc trigger_style->ric_EventTriggerStyle_Name.buf = (uint8_t*)calloc(1, strlen((char*)style_name)); memcpy(trigger_style->ric_EventTriggerStyle_Name.buf, style_name, strlen((char*)style_name)); trigger_style->ric_EventTriggerStyle_Name.size = strlen((char*)style_name); - trigger_style->ric_EventTriggerFormat_Type = 5; + trigger_style->ric_EventTriggerFormat_Type = 1; ranfunc_desc->ric_EventTriggerStyle_List = (E2SM_KPM_RANfunction_Description:: @@ -80,10 +92,9 @@ void encode_kpm_function_description(E2SM_KPM_RANfunction_Description_t* ranfunc MeasurementInfo_Action_List_t* measInfo_Action_List = (MeasurementInfo_Action_List_t*)calloc(1, sizeof(MeasurementInfo_Action_List_t)); - uint8_t* measured_metrics[] = {(uint8_t*)"CQI", (uint8_t*)"RSRP", (uint8_t*)"RSRQ"}; - for (int i = 0; i < 3; i++) { - uint8_t* metrics = measured_metrics[i]; + for (int i = 0; i < NUMBER_MEASUREMENTS; i++) { + uint8_t* metrics = (uint8_t *)performance_measurements[i]; MeasurementInfo_Action_Item_t* measItem = (MeasurementInfo_Action_Item_t*)calloc(1, sizeof(MeasurementInfo_Action_Item_t)); measItem->measName.buf = (uint8_t*)calloc(1, strlen((char*)metrics)); @@ -218,90 +229,67 @@ void kpm_report_indication_header_initialized(E2SM_KPM_IndicationHeader_t* ihead ind_header->colletStartTime = *ts; if (ts) free(ts); - uint8_t* buf5 = (uint8_t*)"1.0"; - ind_header->fileFormatversion = (PrintableString_t*)calloc(1, sizeof(PrintableString_t)); - ind_header->fileFormatversion->buf = (uint8_t*)calloc(1, strlen((char*)buf5)); - memcpy(ind_header->fileFormatversion->buf, buf5, strlen((char*)buf5)); - ind_header->fileFormatversion->size = strlen((char*)buf5); - ihead->indicationHeader_formats.present = E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1; ihead->indicationHeader_formats.choice.indicationHeader_Format1 = ind_header; - // xer_fprint(stderr, &asn_DEF_E2SM_KPM_IndicationHeader, ihead); } void ue_meas_kpm_report_indication_message_initialized( E2SM_KPM_IndicationMessage_t* indicationmessage, uint8_t* nrcellid_buf, uint8_t* crnti_buf, const uint8_t* serving_buf, const uint8_t* neighbor_buf) { - GranularityPeriod_t period = 1; - MeasurementData_t* measData = (MeasurementData_t*)calloc(1, sizeof(MeasurementData_t)); - MeasurementDataItem_t* measDataItem = - (MeasurementDataItem_t*)calloc(1, sizeof(MeasurementDataItem_t)); - MeasurementRecord_t* measDataItem_record = - (MeasurementRecord_t*)calloc(1, sizeof(MeasurementRecord_t)); - MeasurementRecordItem_t* measDataRecordItem = - (MeasurementRecordItem_t*)calloc(1, sizeof(MeasurementRecordItem_t)); - - unsigned long val = 1; - measDataRecordItem->present = MeasurementRecordItem_PR_integer; - measDataRecordItem->choice.integer = val; - - ASN_SEQUENCE_ADD(&measDataItem_record->list, measDataRecordItem); + + MeasurementRecord_t* measDataItem_record = (MeasurementRecord_t*)calloc(1, sizeof(MeasurementRecord_t)); + for (size_t i = 0; i < NUMBER_MEASUREMENTS; i++) + { + MeasurementRecordItem_t* measDataRecordItem = (MeasurementRecordItem_t*)calloc(1, sizeof(MeasurementRecordItem_t)); + measDataRecordItem->present = MeasurementRecordItem_PR_integer; + measDataRecordItem->choice.integer = 1; + + ASN_SEQUENCE_ADD(&measDataItem_record->list, measDataRecordItem); + } + MeasurementDataItem_t* measDataItem = (MeasurementDataItem_t*)calloc(1, sizeof(MeasurementDataItem_t)); measDataItem->measRecord = *measDataItem_record; - long incomplete = 0; measDataItem->incompleteFlag = (long*)calloc(1, sizeof(long)); - *measDataItem->incompleteFlag = incomplete; + *measDataItem->incompleteFlag = 0; + + MeasurementData_t* measData = (MeasurementData_t*)calloc(1, sizeof(MeasurementData_t)); ASN_SEQUENCE_ADD(&measData->list, measDataItem); + MeasurementInfoList_t* measList = (MeasurementInfoList_t*)calloc(1, sizeof(MeasurementInfoList_t)); + for (size_t i = 0; i < NUMBER_MEASUREMENTS; i++) + { + MeasurementLabel_t* measLabel = (MeasurementLabel_t*)calloc(1, sizeof(MeasurementLabel_t)); + measLabel->noLabel = (long *)calloc(1, sizeof(long)); + *measLabel->noLabel = 0; + + LabelInfoItem_t* labelItem = (LabelInfoItem_t*)calloc(1, sizeof(LabelInfoItem_t)); + labelItem->measLabel = *measLabel; + + LabelInfoList_t* labelList = (LabelInfoList_t*)calloc(1, sizeof(LabelInfoList_t)); + ASN_SEQUENCE_ADD(&labelList->list, labelItem); + + MeasurementType_t measType; + measType.present = MeasurementType_PR_measID; + uint8_t* metrics = (uint8_t *)performance_measurements[i]; + measType.choice.measName.buf = (uint8_t*)calloc(1, strlen((char*)metrics)); + memcpy(measType.choice.measName.buf, metrics, strlen((char*)metrics)); + measType.choice.measName.size = strlen((char*)metrics); + + MeasurementInfoItem_t* measItem = (MeasurementInfoItem_t*)calloc(1, sizeof(MeasurementInfoItem_t)); + measItem->measType = measType; + measItem->labelInfoList = *labelList; + if (labelList) free(labelList); + + ASN_SEQUENCE_ADD(&measList->list, measItem); + } + E2SM_KPM_IndicationMessage_Format1_t* format = (E2SM_KPM_IndicationMessage_Format1_t*)calloc( 1, sizeof(E2SM_KPM_IndicationMessage_Format1_t)); format->granulPeriod = (GranularityPeriod_t*)calloc(1, sizeof(GranularityPeriod_t)); - *format->granulPeriod = period; + *format->granulPeriod = 1; format->measData = *measData; - - MeasurementInfoList_t* measList = - (MeasurementInfoList_t*)calloc(1, sizeof(MeasurementInfoList_t)); - MeasurementInfoItem_t* measItem = - (MeasurementInfoItem_t*)calloc(1, sizeof(MeasurementInfoItem_t)); - LabelInfoList_t* labelList = (LabelInfoList_t*)calloc(1, sizeof(LabelInfoList_t)); - LabelInfoItem_t* labelItem = (LabelInfoItem_t*)calloc(1, sizeof(LabelInfoItem_t)); - MeasurementLabel_t* measLabel = (MeasurementLabel_t*)calloc(1, sizeof(MeasurementLabel_t)); - - uint8_t* plmnid_buf = (uint8_t*)"747"; - uint8_t* sst_buf = (uint8_t*)"1"; - uint8_t* sd_buf = (uint8_t*)"100"; - - S_NSSAI_t* snssai = (S_NSSAI_t*)calloc(1, sizeof(S_NSSAI_t)); - snssai->sST.buf = (uint8_t*)calloc(strlen((char*)sst_buf), sizeof(uint8_t)); - snssai->sST.size = strlen((char*)sst_buf); - memcpy(snssai->sST.buf, sst_buf, strlen((char*)sst_buf)); - - snssai->sD = (SD_t*)calloc(1, sizeof(SD_t)); - snssai->sD->buf = (uint8_t*)calloc(strlen((char*)sd_buf), sizeof(uint8_t)); - snssai->sD->size = strlen((char*)sd_buf); - memcpy(snssai->sD->buf, sd_buf, strlen((char*)sd_buf)); - - int plmnid_size = strlen((char*)plmnid_buf); - PLMNIdentity_t* plmnidstr = (PLMNIdentity_t*)calloc(1, sizeof(PLMNIdentity_t)); - plmnidstr->buf = (uint8_t*)calloc(plmnid_size, 1); - plmnidstr->size = plmnid_size; - memcpy(plmnidstr->buf, plmnid_buf, plmnidstr->size); - - measLabel->plmnID = plmnidstr; - measLabel->sliceID = snssai; - - labelItem->measLabel = *measLabel; - ASN_SEQUENCE_ADD(&labelList->list, labelItem); - measItem->labelInfoList = *labelList; - if (labelList) free(labelList); - MeasurementType_t measType; - measType.present = MeasurementType_PR_measID; - measType.choice.measID = 1; - measItem->measType = measType; - ASN_SEQUENCE_ADD(&measList->list, measItem); - format->measInfoList = measList; E2SM_KPM_IndicationMessage__indicationMessage_formats_PR pres = @@ -417,7 +405,6 @@ void cell_meas_kpm_report_indication_message_style_1_initialized( if (ret) { LOG_I("Constraint validation of indication message failed: %s\n", error_buf); } - // xer_fprint(stderr, &asn_DEF_E2SM_KPM_IndicationMessage, indicationmessage); } void encode_kpm_report_style1(E2SM_KPM_IndicationMessage_t* indicationmessage) { @@ -478,9 +465,11 @@ void encode_kpm_report_style1(E2SM_KPM_IndicationMessage_t* indicationmessage) { indicationmessage, e2smbuffer, e2smbuffer_size); if (er.encoded == -1) { - LOG_I("Failed to serialize message. Detail: %s.\n", asn_DEF_E2SM_KPM_IndicationMessage.name); + LOG_E("Failed to serialize message. Detail: %s.\n", asn_DEF_E2SM_KPM_IndicationMessage.name); + exit(1); } else if (er.encoded > e2smbuffer_size) { - LOG_I("Buffer of size %zu is too small for %s, need %zu\n", e2smbuffer_size, asn_DEF_E2SM_KPM_IndicationMessage.name, er.encoded); + LOG_E("Buffer of size %zu is too small for %s, need %zu\n", e2smbuffer_size, asn_DEF_E2SM_KPM_IndicationMessage.name, er.encoded); + exit(1); } } diff --git a/e2sim/src/base/e2sim.cpp b/e2sim/src/base/e2sim.cpp index 9c3ec42..45927e5 100755 --- a/e2sim/src/base/e2sim.cpp +++ b/e2sim/src/base/e2sim.cpp @@ -79,9 +79,7 @@ void E2Sim::encode_and_send_sctp_data(E2AP_PDU_t* pdu) memcpy(data.buffer, buf, min(data.len, MAX_SCTP_BUFFER)); if (buf) free(buf); - LOG_I("Number of bytes sent via SCTP connection %d", min(data.len, MAX_SCTP_BUFFER)); - - sctp_send_data(client_fd, data); + sctp_send_data(client_fd, data); } diff --git a/e2sim/src/messagerouting/e2ap_message_handler.cpp b/e2sim/src/messagerouting/e2ap_message_handler.cpp index 57d28c2..c08d55c 100755 --- a/e2sim/src/messagerouting/e2ap_message_handler.cpp +++ b/e2sim/src/messagerouting/e2ap_message_handler.cpp @@ -23,223 +23,198 @@ //#include //#include -#include "encode_e2apv1.hpp" - - #include -void e2ap_handle_sctp_data(int &socket_fd, sctp_buffer_t &data, bool xmlenc, E2Sim *e2sim) -{ - fprintf(stderr, "in e2ap_handle_sctp_data()\n"); - //decode the data into E2AP-PDU +#include "encode_e2apv1.hpp" + +void e2ap_handle_sctp_data(int& socket_fd, sctp_buffer_t& data, bool xmlenc, E2Sim* e2sim) { E2AP_PDU_t* pdu = (E2AP_PDU_t*)calloc(1, sizeof(E2AP_PDU)); ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); - fprintf(stderr, "decoding...\n"); - asn_transfer_syntax syntax; - syntax = ATS_ALIGNED_BASIC_PER; - + auto rval = asn_decode(nullptr, syntax, &asn_DEF_E2AP_PDU, (void**)&pdu, data.buffer, data.len); - fprintf(stderr, "full buffer\n%s\n", data.buffer); - // e2ap_asn1c_decode_pdu(pdu, data.buffer, data.len); - - auto rval = asn_decode(nullptr, syntax, &asn_DEF_E2AP_PDU, (void **) &pdu, - data.buffer, data.len); - + switch (rval.code) { + case RC_WMORE: + case RC_FAIL: + default: + LOG_E("Failed to decode E2AP data from SCTP connection"); + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + exit(1); + } - int index = (int)pdu->present; - fprintf(stderr, "length of data %d\n", rval.consumed); - fprintf(stderr, "result %d\n", rval.code); - fprintf(stderr, "index is %d\n", index); - - fprintf(stderr, "showing xer of data\n"); - - xer_fprint(stderr, &asn_DEF_E2AP_PDU, pdu); - int procedureCode = e2ap_asn1c_get_procedureCode(pdu); - index = (int)pdu->present; + int index = (int)pdu->present; - LOG_D("[E2AP] Unpacked E2AP-PDU: index = %d, procedureCode = %d\n", - index, procedureCode); + LOG_D("Unpacked E2AP-PDU: index = %d, procedureCode = %d\n", index, procedureCode); - switch(procedureCode) - { - + switch (procedureCode) { case ProcedureCode_id_E2setup: - switch(index) - { + LOG_I("Received a message of E2 setup procedure"); + switch (index) { case E2AP_PDU_PR_initiatingMessage: - e2ap_handle_E2SetupRequest(pdu, socket_fd); - LOG_I("[E2AP] Received SETUP-REQUEST"); + e2ap_handle_E2SetupRequest(pdu, socket_fd); + LOG_I("Received SETUP-REQUEST"); break; - + case E2AP_PDU_PR_successfulOutcome: - LOG_I("[E2AP] Received SETUP-RESPONSE-SUCCESS"); + LOG_I("Received SETUP-RESPONSE-SUCCESS"); break; - + case E2AP_PDU_PR_unsuccessfulOutcome: - LOG_I("[E2AP] Received SETUP-RESPONSE-FAILURE"); + LOG_I("Received SETUP-RESPONSE-FAILURE"); break; - + default: - LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU", index); + LOG_E("Invalid message index=%d in E2AP-PDU", index); break; - } - break; - - case ProcedureCode_id_Reset: //reset = 7 - switch(index) - { + } + break; + + case ProcedureCode_id_Reset: // reset = 7 + LOG_I("Received a message of Reset procedure"); + switch (index) { case E2AP_PDU_PR_initiatingMessage: - LOG_I("[E2AP] Received RESET-REQUEST"); + LOG_I("Received RESET-REQUEST"); break; - + case E2AP_PDU_PR_successfulOutcome: break; - + case E2AP_PDU_PR_unsuccessfulOutcome: break; - + default: - LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU", index); + LOG_E("Invalid message index=%d in E2AP-PDU", index); break; - } + } break; - - case ProcedureCode_id_RICsubscription: //RIC SUBSCRIPTION = 201 - switch(index) - { - case E2AP_PDU_PR_initiatingMessage: { //initiatingMessage - LOG_I("[E2AP] Received RIC-SUBSCRIPTION-REQUEST"); - // e2ap_handle_RICSubscriptionRequest(pdu, socket_fd); - long func_id = encoding::get_function_id_from_subscription(pdu); - fprintf(stderr, "Function Id of message is %d\n", func_id); - SubscriptionCallback cb; - - bool func_exists = true; - - try { - cb = e2sim->get_subscription_callback(func_id); - } catch(const std::out_of_range& e) { - func_exists = false; - } - - if (func_exists) { - fprintf(stderr, "Calling callback function\n"); - cb(pdu); - } else { - fprintf(stderr, "Error: No RAN Function with this ID exists\n"); - } - // callback_kpm_subscription_request(pdu, socket_fd); - - } - break; - + + case ProcedureCode_id_RICsubscription: // RIC SUBSCRIPTION = 201 + LOG_I("Received a message of RIC subscription procedure"); + switch (index) { + case E2AP_PDU_PR_initiatingMessage: { // initiatingMessage + LOG_I("Received RIC-SUBSCRIPTION-REQUEST"); + // e2ap_handle_RICSubscriptionRequest(pdu, socket_fd); + long func_id = encoding::get_function_id_from_subscription(pdu); + fprintf(stderr, "Function Id of message is %d\n", func_id); + SubscriptionCallback cb; + + bool func_exists = true; + + try { + cb = e2sim->get_subscription_callback(func_id); + } catch (const std::out_of_range& e) { + func_exists = false; + } + + if (func_exists) { + fprintf(stderr, "Calling callback function\n"); + cb(pdu); + } else { + fprintf(stderr, "Error: No RAN Function with this ID exists\n"); + } + // callback_kpm_subscription_request(pdu, socket_fd); + + } break; + case E2AP_PDU_PR_successfulOutcome: - LOG_I("[E2AP] Received RIC-SUBSCRIPTION-RESPONSE"); + LOG_I("Received RIC-SUBSCRIPTION-RESPONSE"); break; - + case E2AP_PDU_PR_unsuccessfulOutcome: - LOG_I("[E2AP] Received RIC-SUBSCRIPTION-FAILURE"); + LOG_I("Received RIC-SUBSCRIPTION-FAILURE"); break; - + default: - LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU", index); + LOG_E("Invalid message index=%d in E2AP-PDU", index); break; - } + } break; - case ProcedureCode_id_RICindication: // 205 - switch(index) - { - case E2AP_PDU_PR_initiatingMessage: //initiatingMessage - LOG_I("[E2AP] Received RIC-INDICATION-REQUEST"); + case ProcedureCode_id_RICindication: // 205 + LOG_I("Received a message of RIC indication procedure"); + switch (index) { + case E2AP_PDU_PR_initiatingMessage: // initiatingMessage + LOG_I("Received RIC-INDICATION-REQUEST"); // e2ap_handle_RICSubscriptionRequest(pdu, socket_fd); break; case E2AP_PDU_PR_successfulOutcome: - LOG_I("[E2AP] Received RIC-INDICATION-RESPONSE"); + LOG_I("Received RIC-INDICATION-RESPONSE"); break; - + case E2AP_PDU_PR_unsuccessfulOutcome: - LOG_I("[E2AP] Received RIC-INDICATION-FAILURE"); + LOG_I("Received RIC-INDICATION-FAILURE"); break; - + default: - LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU %d", index, - (int)ProcedureCode_id_RICindication); + LOG_E("Invalid message index=%d in E2AP-PDU %d", index, (int)ProcedureCode_id_RICindication); break; - } + } break; case ProcedureCode_id_RICserviceQuery: - switch (index) - { - case E2AP_PDU_PR_initiatingMessage: - LOG_I("[E2AP] Received RIC-Service-Query") + LOG_I("Received a message of RIC service query procedure"); + switch (index) { + case E2AP_PDU_PR_initiatingMessage: + LOG_I("Received RIC-Service-Query") e2ap_handle_E2SeviceRequest(pdu, socket_fd, e2sim); break; - default: - LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU %d", index, - (int)ProcedureCode_id_RICserviceQuery); + default: + LOG_E("Invalid message index=%d in E2AP-PDU %d", index, (int)ProcedureCode_id_RICserviceQuery); break; - } + } break; case ProcedureCode_id_E2nodeConfigurationUpdate: - switch (index) - { - case E2AP_PDU_PR_successfulOutcome: - LOG_I("[E2AP] Received E2nodeConfigurationUpdate") + LOG_I("Received a message of E2 node configuration update procedure"); + switch (index) { + case E2AP_PDU_PR_successfulOutcome: + LOG_I("Received E2nodeConfigurationUpdate") break; - default: - LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU %d", index, - (int)ProcedureCode_id_E2nodeConfigurationUpdate); + default: + LOG_E("Invalid message index=%d in E2AP-PDU %d", index, (int)ProcedureCode_id_E2nodeConfigurationUpdate); break; - } + } break; case ProcedureCode_id_RICserviceUpdate: - switch (index) - { - case E2AP_PDU_PR_successfulOutcome: - LOG_I("[E2AP] Received RIC-SERVICE-UPDATE-SUCCESS") + LOG_I("Received a message of RIC service update procedure"); + switch (index) { + case E2AP_PDU_PR_successfulOutcome: + LOG_I("Received RIC-SERVICE-UPDATE-SUCCESS") break; - case E2AP_PDU_PR_unsuccessfulOutcome: - LOG_I("[E2AP] Received RIC-SERVICE-UPDATE-FAILURE") + case E2AP_PDU_PR_unsuccessfulOutcome: + LOG_I("Received RIC-SERVICE-UPDATE-FAILURE") break; - default: - LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU %d", index, - (int)ProcedureCode_id_RICserviceUpdate); + default: + LOG_E("Invalid message index=%d in E2AP-PDU %d", index, (int)ProcedureCode_id_RICserviceUpdate); break; - } + } break; - - default: - - LOG_E("[E2AP] No available handler for procedureCode=%d", procedureCode); + default: + LOG_E("No available handler for procedureCode=%d", procedureCode); break; - } + } ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); } -void e2ap_handle_E2SeviceRequest(E2AP_PDU_t* pdu, int &socket_fd, E2Sim *e2sim) { - +void e2ap_handle_E2SeviceRequest(E2AP_PDU_t* pdu, int& socket_fd, E2Sim* e2sim) { auto buffer_size = MAX_SCTP_BUFFER; unsigned char buffer[MAX_SCTP_BUFFER]; - E2AP_PDU_t* res_pdu = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU)); + E2AP_PDU_t* res_pdu = (E2AP_PDU_t*)calloc(1, sizeof(E2AP_PDU)); // prepare ran function defination std::vector all_funcs; - //Loop through RAN function definitions that are registered + // Loop through RAN function definitions that are registered for (std::pair elem : e2sim->getRegistered_ran_functions()) { printf("looping through ran func\n"); @@ -250,18 +225,20 @@ void e2ap_handle_E2SeviceRequest(E2AP_PDU_t* pdu, int &socket_fd, E2Sim *e2sim) next_func.ranFunctionRev = (long)3; all_funcs.push_back(next_func); } - + printf("about to call service update encode\n"); encoding::generate_e2apv1_service_update(res_pdu, all_funcs); - LOG_D("[E2AP] Created E2-SERVICE-UPDATE"); + LOG_D("Created E2-SERVICE-UPDATE"); e2ap_asn1c_print_pdu(res_pdu); sctp_buffer_t data; - char error_buf[300] = {0, }; + char error_buf[300] = { + 0, + }; size_t errlen = 0; asn_check_constraints(&asn_DEF_E2AP_PDU, res_pdu, error_buf, &errlen); @@ -269,92 +246,107 @@ void e2ap_handle_E2SeviceRequest(E2AP_PDU_t* pdu, int &socket_fd, E2Sim *e2sim) printf("error buf %s\n", error_buf); auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, res_pdu, buffer, buffer_size); + + if (er.encoded == -1) { + LOG_E("Failed to serialize message. Detail: %s.\n", asn_DEF_E2AP_PDU.name); + exit(1); + } else if (er.encoded > buffer_size) { + LOG_E("Buffer of size %zu is too small for %s, need %zu\n", buffer_size, asn_DEF_E2AP_PDU.name, er.encoded); + exit(1); + } data.len = er.encoded; - fprintf(stderr, "er encoded is %d\n", er.encoded); memcpy(data.buffer, buffer, er.encoded); - //send response data over sctp - if(sctp_send_data(socket_fd, data) > 0) { - LOG_I("[SCTP] Sent E2-SERVICE-UPDATE"); + // send response data over sctp + if (sctp_send_data(socket_fd, data) > 0) { + LOG_I("Sent E2-SERVICE-UPDATE"); } else { - LOG_E("[SCTP] Unable to send E2-SERVICE-UPDATE to peer"); + LOG_E("Unable to send E2-SERVICE-UPDATE to peer"); } } -void e2ap_send_e2nodeConfigUpdate(int &socket_fd) { - +void e2ap_send_e2nodeConfigUpdate(int& socket_fd) { auto buffer_size = MAX_SCTP_BUFFER; unsigned char buffer[MAX_SCTP_BUFFER]; - E2AP_PDU_t* pdu = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU)); + E2AP_PDU_t* pdu = (E2AP_PDU_t*)calloc(1, sizeof(E2AP_PDU)); - LOG_D("about to call e2nodeconfigUpdate encode\n"); + LOG_I("Generating E2 node configure update"); encoding::generate_e2apv2_config_update(pdu); - LOG_D("[E2AP] Created E2nodeConfigUpdate"); - e2ap_asn1c_print_pdu(pdu); sctp_buffer_t data; - char error_buf[300] = {0, }; + char error_buf[300] = { + 0, + }; size_t errlen = 0; asn_check_constraints(&asn_DEF_E2AP_PDU, pdu, error_buf, &errlen); auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu, buffer, buffer_size); + if (er.encoded == -1) { + LOG_E("Failed to serialize message. Detail: %s.\n", asn_DEF_E2AP_PDU.name); + exit(1); + } else if (er.encoded > buffer_size) { + LOG_E("Buffer of size %zu is too small for %s, need %zu\n", buffer_size, asn_DEF_E2AP_PDU.name, er.encoded); + exit(1); + } + data.len = er.encoded; - fprintf(stderr, "er encoded is %d\n", er.encoded); memcpy(data.buffer, buffer, er.encoded); - //send response data over sctp - if(sctp_send_data(socket_fd, data) > 0) { - LOG_I("[SCTP] Sent E2nodeConfigUpdate"); + // send response data over sctp + if (sctp_send_data(socket_fd, data) > 0) { + LOG_I("Sent E2nodeConfigUpdate"); } else { LOG_E("[SCTP] Unable to send E2nodeConfigUpdate to peer"); } } -void e2ap_handle_E2SetupRequest(E2AP_PDU_t* pdu, int &socket_fd) { - - +void e2ap_handle_E2SetupRequest(E2AP_PDU_t* pdu, int& socket_fd) { E2AP_PDU_t* res_pdu = (E2AP_PDU_t*)calloc(1, sizeof(E2AP_PDU)); encoding::generate_e2apv1_setup_response(res_pdu); - - LOG_D("[E2AP] Created E2-SETUP-RESPONSE"); + LOG_D("Created E2-SETUP-RESPONSE"); e2ap_asn1c_print_pdu(res_pdu); - auto buffer_size = MAX_SCTP_BUFFER; unsigned char buffer[MAX_SCTP_BUFFER]; - + sctp_buffer_t data; auto er = asn_encode_to_buffer(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, res_pdu, buffer, buffer_size); + if (er.encoded == -1) { + LOG_E("Failed to serialize message. Detail: %s.\n", asn_DEF_E2AP_PDU.name); + exit(1); + } else if (er.encoded > buffer_size) { + LOG_E("Buffer of size %zu is too small for %s, need %zu\n", buffer_size, asn_DEF_E2AP_PDU.name, er.encoded); + exit(1); + } + data.len = er.encoded; - fprintf(stderr, "er encoded is %d\n", er.encoded); - //data.len = e2ap_asn1c_encode_pdu(res_pdu, &buf); memcpy(data.buffer, buffer, er.encoded); - //send response data over sctp - if(sctp_send_data(socket_fd, data) > 0) { - LOG_I("[SCTP] Sent E2-SETUP-RESPONSE"); + // send response data over sctp + if (sctp_send_data(socket_fd, data) > 0) { + LOG_I("Sent E2-SETUP-RESPONSE"); } else { LOG_E("[SCTP] Unable to send E2-SETUP-RESPONSE to peer"); } sleep(5); - //Sending Subscription Request + // Sending Subscription Request - E2AP_PDU_t* pdu_sub = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU)); + E2AP_PDU_t* pdu_sub = (E2AP_PDU_t*)calloc(1, sizeof(E2AP_PDU)); encoding::generate_e2apv1_subscription_request(pdu_sub); @@ -362,23 +354,27 @@ void e2ap_handle_E2SetupRequest(E2AP_PDU_t* pdu, int &socket_fd) { auto buffer_size2 = MAX_SCTP_BUFFER; unsigned char buffer2[MAX_SCTP_BUFFER]; - + sctp_buffer_t data2; auto er2 = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu_sub, buffer2, buffer_size2); - + + if (er2.encoded == -1) { + LOG_E("Failed to serialize message. Detail: %s.\n", asn_DEF_E2AP_PDU.name); + exit(1); + } else if (er2.encoded > buffer_size2) { + LOG_E("Buffer of size %zu is too small for %s, need %zu\n", buffer_size2, asn_DEF_E2AP_PDU.name, er2.encoded); + exit(1); + } + data2.len = er2.encoded; memcpy(data2.buffer, buffer2, er2.encoded); - - fprintf(stderr, "er encded is %d\n", er2.encoded); - if(sctp_send_data(socket_fd, data2) > 0) { - LOG_I("[SCTP] Sent E2-SUBSCRIPTION-REQUEST"); + if (sctp_send_data(socket_fd, data2) > 0) { + LOG_I("Sent E2-SUBSCRIPTION-REQUEST"); } else { LOG_E("[SCTP] Unable to send E2-SUBSCRIPTION-REQUEST to peer"); - } - - + } } /* @@ -397,7 +393,7 @@ void e2ap_handle_RICSubscriptionRequest(E2AP_PDU_t* pdu, int &socket_fd) auto buffer_size2 = MAX_SCTP_BUFFER; unsigned char buffer2[MAX_SCTP_BUFFER]; - + sctp_buffer_t data2; auto er2 = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu_resp, buffer2, buffer_size2); @@ -408,12 +404,12 @@ void e2ap_handle_RICSubscriptionRequest(E2AP_PDU_t* pdu, int &socket_fd) memcpy(data2.buffer, buffer2, er2.encoded); if(sctp_send_data(socket_fd, data2) > 0) { - LOG_I("[SCTP] Sent RIC-SUBSCRIPTION-RESPONSE"); + LOG_I("Sent RIC-SUBSCRIPTION-RESPONSE"); } else { LOG_E("[SCTP] Unable to send RIC-SUBSCRIPTION-RESPONSE to peer"); } - - + + //Send back an Indication E2AP_PDU_t* pdu_ind = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU)); @@ -424,7 +420,7 @@ void e2ap_handle_RICSubscriptionRequest(E2AP_PDU_t* pdu, int &socket_fd) auto buffer_size = MAX_SCTP_BUFFER; unsigned char buffer[MAX_SCTP_BUFFER]; - + sctp_buffer_t data; auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu_ind, buffer, buffer_size); @@ -435,13 +431,10 @@ void e2ap_handle_RICSubscriptionRequest(E2AP_PDU_t* pdu, int &socket_fd) memcpy(data.buffer, buffer, er.encoded); if(sctp_send_data(socket_fd, data) > 0) { - LOG_I("[SCTP] Sent RIC-INDICATION-REQUEST"); + LOG_I("Sent RIC-INDICATION-REQUEST"); } else { LOG_E("[SCTP] Unable to send RIC-INDICATION-REQUEST to peer"); - } + } } */ - - -