maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/e1-setup-encdec-tests' into integration_2025_w04 (!3152)

Browse Source 
E1 Setup enc/dec library and unit test

This MR is adding a library for E1 Setup enc/dec functions:

- E1 CU-UP Setup Request
- E1 CU-UP Setup Response
- E1 Setup Failure

and relevant unit tests
This commit is contained in:
Robert Schmidt
2025-01-27 11:43:46 +01:00
parent f6243e9078 124f4ab9c5
commit 377ff8970e
12 changed files with 1112 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files
openair2/E1AP/e1ap.c
+35 -234
View File
@@ -34,6 +34,7 @@
#include "gtp_itf.h"
#include "openair2/LAYER2/nr_pdcp/cucp_cuup_handler.h"
#include "lib/e1ap_bearer_context_management.h"
#include "lib/e1ap_interface_management.h"
#define E1AP_NUM_MSG_HANDLERS 14
typedef int (*e1ap_message_processing_t)(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst, const E1AP_E1AP_PDU_t *message_p);
@@ -161,221 +162,20 @@ int e1ap_send_ERROR_INDICATION(instance_t instance, E1AP_ErrorIndication_t *Erro
return -1;
}
/*
E1 Setup: can be sent on both ways, to be refined
*/
static void fill_SETUP_REQUEST(e1ap_setup_req_t *setup, E1AP_E1AP_PDU_t *pdu)
{
/* Create */
/* 0. pdu Type */
pdu->present = E1AP_E1AP_PDU_PR_initiatingMessage;
asn1cCalloc(pdu->choice.initiatingMessage, initMsg);
initMsg->procedureCode = E1AP_ProcedureCode_id_gNB_CU_UP_E1Setup;
initMsg->criticality = E1AP_Criticality_reject;
initMsg->value.present = E1AP_InitiatingMessage__value_PR_GNB_CU_UP_E1SetupRequest;
E1AP_GNB_CU_UP_E1SetupRequest_t *e1SetupUP = &initMsg->value.choice.GNB_CU_UP_E1SetupRequest;
/* mandatory */
/* c1. Transaction ID (integer value) */
asn1cSequenceAdd(e1SetupUP->protocolIEs.list, E1AP_GNB_CU_UP_E1SetupRequestIEs_t, ieC1);
ieC1->id = E1AP_ProtocolIE_ID_id_TransactionID;
ieC1->criticality = E1AP_Criticality_reject;
ieC1->value.present = E1AP_GNB_CU_UP_E1SetupRequestIEs__value_PR_TransactionID;
setup->transac_id = E1AP_get_next_transaction_identifier();
ieC1->value.choice.TransactionID = setup->transac_id;
LOG_D(E1AP, "Transaction ID of setup request %ld\n", setup->transac_id);
/* mandatory */
/* c2. GNB_CU_ID (integer value) */
asn1cSequenceAdd(e1SetupUP->protocolIEs.list, E1AP_GNB_CU_UP_E1SetupRequestIEs_t, ieC2);
ieC2->id = E1AP_ProtocolIE_ID_id_gNB_CU_UP_ID;
ieC2->criticality = E1AP_Criticality_reject;
ieC2->value.present = E1AP_GNB_CU_UP_E1SetupRequestIEs__value_PR_GNB_CU_UP_ID;
asn_int642INTEGER(&ieC2->value.choice.GNB_CU_UP_ID, setup->gNB_cu_up_id);
/* optional */
if (setup->gNB_cu_up_name) {
asn1cSequenceAdd(e1SetupUP->protocolIEs.list, E1AP_GNB_CU_UP_E1SetupRequestIEs_t, ieC3);
ieC3->id = E1AP_ProtocolIE_ID_id_gNB_CU_UP_Name;
ieC3->criticality = E1AP_Criticality_ignore;
ieC3->value.present = E1AP_GNB_CU_UP_E1SetupRequestIEs__value_PR_GNB_CU_UP_Name;
OCTET_STRING_fromBuf(&ieC3->value.choice.GNB_CU_UP_Name, setup->gNB_cu_up_name, strlen(setup->gNB_cu_up_name));
}
/* mandatory */
/* c4. CN Support */
asn1cSequenceAdd(e1SetupUP->protocolIEs.list, E1AP_GNB_CU_UP_E1SetupRequestIEs_t, ieC4);
ieC4->id = E1AP_ProtocolIE_ID_id_CNSupport;
ieC4->criticality = E1AP_Criticality_reject;
ieC4->value.present = E1AP_GNB_CU_UP_E1SetupRequestIEs__value_PR_CNSupport;
ieC4->value.choice.CNSupport = E1AP_CNSupport_c_5gc; /* only 5GC supported */
/* mandatory */
/* c5. Supported PLMNs */
asn1cSequenceAdd(e1SetupUP->protocolIEs.list, E1AP_GNB_CU_UP_E1SetupRequestIEs_t, ieC5);
ieC5->id = E1AP_ProtocolIE_ID_id_SupportedPLMNs;
ieC5->criticality = E1AP_Criticality_reject;
ieC5->value.present = E1AP_GNB_CU_UP_E1SetupRequestIEs__value_PR_SupportedPLMNs_List;
int numSupportedPLMNs = setup->supported_plmns;
for (int i = 0; i < numSupportedPLMNs; i++) {
asn1cSequenceAdd(ieC5->value.choice.SupportedPLMNs_List.list, E1AP_SupportedPLMNs_Item_t, supportedPLMN);
/* 5.1 PLMN Identity */
PLMN_ID_t *id = &setup->plmn[i].id;
MCC_MNC_TO_PLMNID(id->mcc, id->mnc, id->mnc_digit_length, &supportedPLMN->pLMN_Identity);
int n = setup->plmn[i].supported_slices;
if (setup->plmn[i].slice != NULL && n > 0) {
supportedPLMN->slice_Support_List = calloc(1, sizeof(*supportedPLMN->slice_Support_List));
AssertFatal(supportedPLMN->slice_Support_List != NULL, "out of memory\n");
for (int s = 0; s < n; ++s) {
asn1cSequenceAdd(supportedPLMN->slice_Support_List->list, E1AP_Slice_Support_Item_t, slice);
e1ap_nssai_t *nssai = &setup->plmn[i].slice[s];
INT8_TO_OCTET_STRING(nssai->sst, &slice->sNSSAI.sST);
if (nssai->sd != 0xffffff) {
slice->sNSSAI.sD = malloc(sizeof(*slice->sNSSAI.sD));
AssertFatal(slice->sNSSAI.sD != NULL, "out of memory\n");
INT24_TO_OCTET_STRING(nssai->sd, slice->sNSSAI.sD);
}
}
}
}
}
static void fill_SETUP_RESPONSE(const e1ap_setup_resp_t *e1ap_setup_resp, E1AP_E1AP_PDU_t *pdu)
{
/* Create */
/* 0. pdu Type */
pdu->present = E1AP_E1AP_PDU_PR_successfulOutcome;
asn1cCalloc(pdu->choice.successfulOutcome, initMsg);
initMsg->procedureCode = E1AP_ProcedureCode_id_gNB_CU_UP_E1Setup;
initMsg->criticality = E1AP_Criticality_reject;
initMsg->value.present = E1AP_SuccessfulOutcome__value_PR_GNB_CU_UP_E1SetupResponse;
E1AP_GNB_CU_UP_E1SetupResponse_t *out = &pdu->choice.successfulOutcome->value.choice.GNB_CU_UP_E1SetupResponse;
/* mandatory */
/* c1. Transaction ID (integer value) */
asn1cSequenceAdd(out->protocolIEs.list, E1AP_GNB_CU_UP_E1SetupResponseIEs_t, ieC1);
ieC1->id = E1AP_ProtocolIE_ID_id_TransactionID;
ieC1->criticality = E1AP_Criticality_reject;
ieC1->value.present = E1AP_GNB_CU_UP_E1SetupResponseIEs__value_PR_TransactionID;
ieC1->value.choice.TransactionID = e1ap_setup_resp->transac_id;
}
void e1ap_send_SETUP_RESPONSE(sctp_assoc_t assoc_id, const e1ap_setup_resp_t *e1ap_setup_resp)
{
E1AP_E1AP_PDU_t pdu = {0};
fill_SETUP_RESPONSE(e1ap_setup_resp, &pdu);
e1ap_encode_send(CPtype, assoc_id, &pdu, 0, __func__);
}
/**
* @brief E1 Setup Failure ASN1 messager builder
* @ref 9.2.1.6 GNB-CU-UP E1 SETUP FAILURE of 3GPP TS 38.463
*/
static void fill_SETUP_FAILURE(long transac_id, E1AP_E1AP_PDU_t *pdu)
{
/* Create */
/* 0. pdu Type */
pdu->present = E1AP_E1AP_PDU_PR_unsuccessfulOutcome;
asn1cCalloc(pdu->choice.unsuccessfulOutcome, initMsg);
/* mandatory */
/**
* Message Type IE
* - procedureCode (integer)
* - Type of Message (choice)
* @ref clause 9.3.1.1 of 3GPP TS 38.463
*/
initMsg->procedureCode = E1AP_ProcedureCode_id_gNB_CU_UP_E1Setup;
initMsg->criticality = E1AP_Criticality_reject;
initMsg->value.present = E1AP_UnsuccessfulOutcome__value_PR_GNB_CU_UP_E1SetupFailure;
E1AP_GNB_CU_UP_E1SetupFailure_t *out = &pdu->choice.unsuccessfulOutcome->value.choice.GNB_CU_UP_E1SetupFailure;
/* mandatory */
/* c1. Transaction ID (integer value), clause 9.3.1.53 of 3GPP TS 38.463 */
asn1cSequenceAdd(out->protocolIEs.list, E1AP_GNB_CU_UP_E1SetupFailureIEs_t, ieC1);
ieC1->id = E1AP_ProtocolIE_ID_id_TransactionID;
ieC1->criticality = E1AP_Criticality_reject;
ieC1->value.present = E1AP_GNB_CU_UP_E1SetupFailureIEs__value_PR_TransactionID;
ieC1->value.choice.TransactionID = transac_id;
/* mandatory */
/* c2. cause (integer value), clause 9.3.1.2 of 3GPP TS 38.463 */
asn1cSequenceAdd(out->protocolIEs.list, E1AP_GNB_CU_UP_E1SetupFailureIEs_t, ieC2);
ieC2->id = E1AP_ProtocolIE_ID_id_Cause;
ieC2->criticality = E1AP_Criticality_ignore;
ieC2->value.present = E1AP_GNB_CU_UP_E1SetupFailureIEs__value_PR_Cause;
ieC2->value.choice.Cause.present = E1AP_Cause_PR_radioNetwork; //choose this accordingly
ieC2->value.choice.Cause.choice.radioNetwork = E1AP_CauseRadioNetwork_unspecified;
E1AP_E1AP_PDU_t *pdu = encode_e1ap_cuup_setup_response(e1ap_setup_resp);
e1ap_encode_send(CPtype, assoc_id, pdu, 0, __func__);
}
/**
* @brief E1 Setup Failure ASN1 messager encoder
*/
void e1apCUCP_send_SETUP_FAILURE(sctp_assoc_t assoc_id, long transac_id)
static void e1apCUCP_send_SETUP_FAILURE(sctp_assoc_t assoc_id, const e1ap_setup_fail_t *msg)
{
LOG_D(E1AP, "CU-CP: Encoding E1AP Setup Failure for transac_id %ld...\n", transac_id);
E1AP_E1AP_PDU_t pdu = {0};
fill_SETUP_FAILURE(transac_id, &pdu);
e1ap_encode_send(CPtype, assoc_id, &pdu, 0, __func__);
}
static void extract_SETUP_REQUEST(const E1AP_E1AP_PDU_t *pdu, e1ap_setup_req_t *req)
{
E1AP_GNB_CU_UP_E1SetupRequestIEs_t *ie;
E1AP_GNB_CU_UP_E1SetupRequest_t *in = &pdu->choice.initiatingMessage->value.choice.GNB_CU_UP_E1SetupRequest;
/* transac_id */
F1AP_FIND_PROTOCOLIE_BY_ID(E1AP_GNB_CU_UP_E1SetupRequestIEs_t, ie, in, E1AP_ProtocolIE_ID_id_TransactionID, true);
req->transac_id = ie->value.choice.TransactionID;
LOG_D(E1AP, "gNB CU UP E1 setup request transaction ID: %ld\n", req->transac_id);
/* gNB CU UP ID */
F1AP_FIND_PROTOCOLIE_BY_ID(E1AP_GNB_CU_UP_E1SetupRequestIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_UP_ID, true);
asn_INTEGER2ulong(&ie->value.choice.GNB_CU_UP_ID, &req->gNB_cu_up_id);
LOG_D(E1AP, "gNB CU UP ID: %ld\n", req->gNB_cu_up_id);
/* gNB CU UP name */
F1AP_FIND_PROTOCOLIE_BY_ID(E1AP_GNB_CU_UP_E1SetupRequestIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_UP_Name, false);
req->gNB_cu_up_name = NULL;
if (ie != NULL) {
req->gNB_cu_up_name = calloc(ie->value.choice.GNB_CU_UP_Name.size + 1, sizeof(char));
AssertFatal(req->gNB_cu_up_name != NULL, "out of memory\n");
memcpy(req->gNB_cu_up_name, ie->value.choice.GNB_CU_UP_Name.buf, ie->value.choice.GNB_CU_UP_Name.size);
LOG_D(E1AP, "req->gNB_cu_up_name %s\n", req->gNB_cu_up_name);
}
/* CN Support */
F1AP_FIND_PROTOCOLIE_BY_ID(E1AP_GNB_CU_UP_E1SetupRequestIEs_t, ie, in, E1AP_ProtocolIE_ID_id_CNSupport, true);
AssertFatal(ie->value.choice.CNSupport == E1AP_CNSupport_c_5gc, "only 5GC CN Support supported\n");
/* Supported PLMNs */
F1AP_FIND_PROTOCOLIE_BY_ID(E1AP_GNB_CU_UP_E1SetupRequestIEs_t, ie, in, E1AP_ProtocolIE_ID_id_SupportedPLMNs, true);
req->supported_plmns = ie->value.choice.SupportedPLMNs_List.list.count;
LOG_D(E1AP, "Number of supported PLMNs: %d\n", req->supported_plmns);
for (int i = 0; i < req->supported_plmns; i++) {
E1AP_SupportedPLMNs_Item_t *supported_plmn_item =
(E1AP_SupportedPLMNs_Item_t *)(ie->value.choice.SupportedPLMNs_List.list.array[i]);
/* PLMN Identity */
PLMN_ID_t *id = &req->plmn[i].id;
PLMNID_TO_MCC_MNC(&supported_plmn_item->pLMN_Identity, id->mcc, id->mnc, id->mnc_digit_length);
LOG_D(E1AP, "MCC %d MNC %d\n", id->mcc, id->mnc);
/* NSSAI */
if (supported_plmn_item->slice_Support_List) {
int n = supported_plmn_item->slice_Support_List->list.count;
req->plmn[i].supported_slices = n;
req->plmn[i].slice = calloc(n, sizeof(*req->plmn[i].slice));
AssertFatal(req->plmn[i].slice != NULL, "out of memory\n");
for (int s = 0; s < n; ++s) {
e1ap_nssai_t *slice = &req->plmn[i].slice[s];
const E1AP_SNSSAI_t *es = &supported_plmn_item->slice_Support_List->list.array[s]->sNSSAI;
OCTET_STRING_TO_INT8(&es->sST, slice->sst);
slice->sd = 0xffffff;
if (es->sD != NULL)
OCTET_STRING_TO_INT24(es->sD, slice->sd);
LOG_D(E1AP, "SST %d SD %06x\n", slice->sst, slice->sd);
}
}
}
LOG_D(E1AP, "CU-CP: Encoding E1AP Setup Failure for transac_id %ld...\n", msg->transac_id);
E1AP_E1AP_PDU_t *pdu = encode_e1ap_cuup_setup_failure(msg);
e1ap_encode_send(CPtype, assoc_id, pdu, 0, __func__);
}
int e1apCUCP_handle_SETUP_REQUEST(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst, const E1AP_E1AP_PDU_t *pdu)
@@ -383,13 +183,20 @@ int e1apCUCP_handle_SETUP_REQUEST(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst,
DevAssert(pdu != NULL);
/* Create ITTI message and send to queue */
MessageDef *msg_p = itti_alloc_new_message(TASK_CUCP_E1, 0 /*unused by callee*/, E1AP_SETUP_REQ);
extract_SETUP_REQUEST(pdu, &E1AP_SETUP_REQ(msg_p));
// Decode E1 CU-UP Setup Request
if (!decode_e1ap_cuup_setup_request(pdu, &E1AP_SETUP_REQ(msg_p))) {
free_e1ap_cuup_setup_request(&E1AP_SETUP_REQ(msg_p));
return -1;
}
msg_p->ittiMsgHeader.originInstance = assoc_id;
if (E1AP_SETUP_REQ(msg_p).supported_plmns > 0) {
itti_send_msg_to_task(TASK_RRC_GNB, 0 /*unused by callee*/, msg_p);
} else {
e1apCUCP_send_SETUP_FAILURE(assoc_id, E1AP_SETUP_REQ(msg_p).transac_id);
e1ap_cause_t cause = { .type = E1AP_CAUSE_PROTOCOL, .value = E1AP_PROTOCOL_CAUSE_SEMANTIC_ERROR};
e1ap_setup_fail_t setup_fail = {.transac_id = E1AP_SETUP_REQ(msg_p).transac_id, .cause = cause};
e1apCUCP_send_SETUP_FAILURE(assoc_id, &setup_fail);
itti_free(TASK_CUCP_E1, msg_p);
return -1;
}
@@ -399,28 +206,19 @@ int e1apCUCP_handle_SETUP_REQUEST(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst,
int e1apCUUP_handle_SETUP_RESPONSE(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst, const E1AP_E1AP_PDU_t *pdu)
{
LOG_D(E1AP, "%s\n", __func__);
DevAssert(pdu->present == E1AP_E1AP_PDU_PR_successfulOutcome);
DevAssert(pdu->choice.successfulOutcome->procedureCode == E1AP_ProcedureCode_id_gNB_CU_UP_E1Setup);
DevAssert(pdu->choice.successfulOutcome->criticality == E1AP_Criticality_reject);
DevAssert(pdu->choice.successfulOutcome->value.present == E1AP_SuccessfulOutcome__value_PR_GNB_CU_UP_E1SetupResponse);
const E1AP_GNB_CU_UP_E1SetupResponse_t *in = &pdu->choice.successfulOutcome->value.choice.GNB_CU_UP_E1SetupResponse;
E1AP_GNB_CU_UP_E1SetupResponseIEs_t *ie;
/* transac_id */
long transaction_id;
// Decode E1 CU-UP Setup Response
e1ap_setup_resp_t out = {0};
if (!decode_e1ap_cuup_setup_response(pdu, &out)) {
free_e1ap_cuup_setup_response(&out);
return -1;
}
long old_transaction_id = inst->cuup.setupReq.transac_id;
F1AP_FIND_PROTOCOLIE_BY_ID(E1AP_GNB_CU_UP_E1SetupResponseIEs_t, ie, in, E1AP_ProtocolIE_ID_id_TransactionID, true);
transaction_id = ie->value.choice.TransactionID;
LOG_D(E1AP, "gNB CU UP E1 setup response transaction ID: %ld\n", transaction_id);
if (old_transaction_id != transaction_id)
LOG_E(E1AP, "Transaction IDs do not match %ld != %ld\n", old_transaction_id, transaction_id);
E1AP_free_transaction_identifier(transaction_id);
/* do the required processing */
if (old_transaction_id != out.transac_id) {
LOG_E(E1AP, "Transaction IDs do not match %ld != %ld\n", old_transaction_id, out.transac_id);
free_e1ap_cuup_setup_response(&out);
return -1;
}
free_e1ap_cuup_setup_response(&out);
return 0;
}
@@ -1276,9 +1074,10 @@ static void e1_task_send_sctp_association_req(long task_id, instance_t instance,
static void e1apCUUP_send_SETUP_REQUEST(sctp_assoc_t assoc_id, e1ap_setup_req_t *setup)
{
E1AP_E1AP_PDU_t pdu = {0};
fill_SETUP_REQUEST(setup, &pdu);
e1ap_encode_send(UPtype, assoc_id, &pdu, 0, __func__);
setup->transac_id = E1AP_get_next_transaction_identifier();
LOG_D(E1AP, "Transaction ID of setup request %ld\n", setup->transac_id);
E1AP_E1AP_PDU_t *pdu = encode_e1ap_cuup_setup_request(setup);
e1ap_encode_send(UPtype, assoc_id, pdu, 0, __func__);
}
/**
@@ -1443,10 +1242,12 @@ void *E1AP_CUCP_task(void *arg)
case E1AP_SETUP_RESP:
e1ap_send_SETUP_RESPONSE(assoc_id, &E1AP_SETUP_RESP(msg));
free_e1ap_cuup_setup_response(&E1AP_SETUP_RESP(msg));
break;
case E1AP_SETUP_FAIL:
e1apCUCP_send_SETUP_FAILURE(assoc_id, E1AP_SETUP_FAIL(msg).transac_id);
e1apCUCP_send_SETUP_FAILURE(assoc_id, &E1AP_SETUP_FAIL(msg));
free_e1ap_cuup_setup_failure(&E1AP_SETUP_FAIL(msg));
break;
case E1AP_BEARER_CONTEXT_SETUP_REQ: