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

Add F1AP positioning deactivation message enc/dec + test

Browse Source 
Reference: 3GPP 38.473 v16.21.0
Mandatory fields:
gNB-CU UE F1AP ID (supported)
gNB-DU UE F1AP ID (supported)
CHOICE Abort Transmission
 > SRS Resource Set ID deactivation
 > Release ALL
This commit is contained in:
Rakesh Mundlamuri
2026-01-15 15:00:31 +05:30
parent 99b1bfbdfd
commit f579e03b16
4 changed files with 261 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
openair2/COMMON/f1ap_messages_types.h
+25
View File
@@ -1031,6 +1031,22 @@ typedef struct f1ap_srs_type_s {
f1ap_srs_type_u choice;
} f1ap_srs_type_t;
typedef union f1ap_abort_transmission_c {
uint8_t srs_resource_set_id;
bool release_all;
} f1ap_abort_transmission_u;
typedef enum f1ap_abort_transmission_e {
F1AP_ABORT_TRANSMISSION_PR_NOTHING,
F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID,
F1AP_ABORT_TRANSMISSION_PR_RELEASEALL
} f1ap_abort_transmission_pr;
typedef struct f1ap_abort_transmission_s {
f1ap_abort_transmission_pr present;
f1ap_abort_transmission_u choice;
} f1ap_abort_transmission_t;
typedef struct f1ap_positioning_information_req_s {
// IE 9.3.1.4 (mandatory)
uint32_t gNB_CU_ue_id;
@@ -1085,4 +1101,13 @@ typedef struct f1ap_positioning_activation_failure_s {
long cause_value;
} f1ap_positioning_activation_failure_t;
typedef struct f1ap_positioning_deactivation_s {
// IE 9.3.1.4 (mandatory)
uint32_t gNB_CU_ue_id;
// IE 9.3.1.5 (mandatory)
uint32_t gNB_DU_ue_id;
// (mandatory)
f1ap_abort_transmission_t abort_transmission;
} f1ap_positioning_deactivation_t;
#endif /* F1AP_MESSAGES_TYPES_H_ */
openair2/F1AP/lib/f1ap_positioning.c
+185
View File
@@ -2032,6 +2032,48 @@ static bool decode_f1ap_srstype(const F1AP_SRSType_t *srs_type, f1ap_srs_type_t
return true;
}
static F1AP_AbortTransmission_t encode_f1ap_abort_transmission(const f1ap_abort_transmission_t *abort_tx)
{
F1AP_AbortTransmission_t f1_abort_tx = {0};
switch (abort_tx->present) {
case F1AP_ABORT_TRANSMISSION_PR_NOTHING:
f1_abort_tx.present = F1AP_AbortTransmission_PR_NOTHING;
break;
case F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID:
f1_abort_tx.present = F1AP_AbortTransmission_PR_sRSResourceSetID;
f1_abort_tx.choice.sRSResourceSetID = abort_tx->choice.srs_resource_set_id;
break;
case F1AP_ABORT_TRANSMISSION_PR_RELEASEALL:
f1_abort_tx.present = F1AP_AbortTransmission_PR_releaseALL;
break;
default:
AssertFatal(false, "unknown Abort Transmission %d\n", abort_tx->present);
break;
}
return f1_abort_tx;
}
static bool decode_f1ap_abort_transmission(const F1AP_AbortTransmission_t *in, f1ap_abort_transmission_t *out)
{
switch (in->present) {
case F1AP_AbortTransmission_PR_NOTHING:
out->present = F1AP_ABORT_TRANSMISSION_PR_NOTHING;
break;
case F1AP_AbortTransmission_PR_sRSResourceSetID:
out->present = F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID;
out->choice.srs_resource_set_id = in->choice.sRSResourceSetID;
break;
case F1AP_AbortTransmission_PR_releaseALL:
out->present = F1AP_ABORT_TRANSMISSION_PR_RELEASEALL;
out->choice.release_all = true;
break;
default:
AssertError(false, return false, "received illegal Abort Transmission %d\n", in->present);
break;
}
return true;
}
/**
* @brief Encode F1 positioning information request to ASN.1
*/
@@ -2848,3 +2890,146 @@ void free_positioning_activation_failure(f1ap_positioning_activation_failure_t *
{
// nothing to free
}
/**
* @brief Encode F1 positioning deactivation to ASN.1
*/
F1AP_F1AP_PDU_t *encode_positioning_deactivation(const f1ap_positioning_deactivation_t *msg)
{
F1AP_F1AP_PDU_t *pdu = calloc_or_fail(1, sizeof(*pdu));
/* Message Type */
pdu->present = F1AP_F1AP_PDU_PR_initiatingMessage;
asn1cCalloc(pdu->choice.initiatingMessage, tmp);
tmp->procedureCode = F1AP_ProcedureCode_id_PositioningDeactivation;
tmp->criticality = F1AP_Criticality_ignore;
tmp->value.present = F1AP_InitiatingMessage__value_PR_PositioningDeactivation;
F1AP_PositioningDeactivation_t *out = &tmp->value.choice.PositioningDeactivation;
/* mandatory : GNB_CU_UE_F1AP_ID */
asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningDeactivationIEs_t, ie1);
ie1->id = F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
ie1->criticality = F1AP_Criticality_reject;
ie1->value.present = F1AP_PositioningDeactivationIEs__value_PR_GNB_CU_UE_F1AP_ID;
ie1->value.choice.GNB_CU_UE_F1AP_ID = msg->gNB_CU_ue_id;
/* mandatory : GNB_DU_UE_F1AP_ID */
asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningDeactivationIEs_t, ie2);
ie2->id = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
ie2->criticality = F1AP_Criticality_reject;
ie2->value.present = F1AP_PositioningDeactivationIEs__value_PR_GNB_DU_UE_F1AP_ID;
ie2->value.choice.GNB_DU_UE_F1AP_ID = msg->gNB_DU_ue_id;
/* mandatory : CHOICE ABORT TRANSMISSION */
asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningDeactivationIEs_t, ie3);
ie3->id = F1AP_ProtocolIE_ID_id_AbortTransmission;
ie3->criticality = F1AP_Criticality_ignore;
ie3->value.present = F1AP_PositioningDeactivationIEs__value_PR_AbortTransmission;
ie3->value.choice.AbortTransmission = encode_f1ap_abort_transmission(&msg->abort_transmission);
return pdu;
}
/**
* @brief Decode F1 positioning deactivation
*/
bool decode_positioning_deactivation(const F1AP_F1AP_PDU_t *pdu, f1ap_positioning_deactivation_t *out)
{
DevAssert(out != NULL);
memset(out, 0, sizeof(*out));
F1AP_PositioningDeactivation_t *in = &pdu->choice.initiatingMessage->value.choice.PositioningDeactivation;
F1AP_PositioningDeactivationIEs_t *ie;
F1AP_LIB_FIND_IE(F1AP_PositioningDeactivationIEs_t, ie, &in->protocolIEs.list, F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID, true);
F1AP_LIB_FIND_IE(F1AP_PositioningDeactivationIEs_t, ie, &in->protocolIEs.list, F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, true);
F1AP_LIB_FIND_IE(F1AP_PositioningDeactivationIEs_t, ie, &in->protocolIEs.list, F1AP_ProtocolIE_ID_id_AbortTransmission, true);
for (int i = 0; i < in->protocolIEs.list.count; ++i) {
ie = in->protocolIEs.list.array[i];
AssertError(ie != NULL, return false, "in->protocolIEs.list.array[i] is NULL");
switch (ie->id) {
case F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
_F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningDeactivationIEs__value_PR_GNB_CU_UE_F1AP_ID);
out->gNB_CU_ue_id = ie->value.choice.GNB_CU_UE_F1AP_ID;
break;
case F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
_F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningDeactivationIEs__value_PR_GNB_DU_UE_F1AP_ID);
out->gNB_DU_ue_id = ie->value.choice.GNB_DU_UE_F1AP_ID;
break;
case F1AP_ProtocolIE_ID_id_AbortTransmission:
_F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningDeactivationIEs__value_PR_AbortTransmission);
_F1_CHECK_EXP(decode_f1ap_abort_transmission(&ie->value.choice.AbortTransmission, &out->abort_transmission));
break;
default:
PRINT_ERROR("F1AP_ProtocolIE_ID_id %ld unknown, skipping\n", ie->id);
break;
}
}
return true;
}
/**
* @brief F1 positioning deactivation deep copy
*/
f1ap_positioning_deactivation_t cp_positioning_deactivation(const f1ap_positioning_deactivation_t *orig)
{
/* copy all mandatory fields that are not dynamic memory */
f1ap_positioning_deactivation_t cp = {
.gNB_CU_ue_id = orig->gNB_CU_ue_id,
.gNB_DU_ue_id = orig->gNB_DU_ue_id,
.abort_transmission.present = orig->abort_transmission.present,
};
// do this properly abort mission
switch (orig->abort_transmission.present) {
case F1AP_ABORT_TRANSMISSION_PR_NOTHING:
// nothing to copy
break;
case F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID:
cp.abort_transmission.choice.srs_resource_set_id = orig->abort_transmission.choice.srs_resource_set_id;
break;
case F1AP_ABORT_TRANSMISSION_PR_RELEASEALL:
cp.abort_transmission.choice.release_all = orig->abort_transmission.choice.release_all;
break;
default:
PRINT_ERROR("received illegal Abort Transmission value %d\n", orig->abort_transmission.present);
break;
}
return cp;
}
/**
* @brief F1 positioning deactivation equality check
*/
bool eq_positioning_deactivation(const f1ap_positioning_deactivation_t *a, const f1ap_positioning_deactivation_t *b)
{
_F1_EQ_CHECK_INT(a->gNB_CU_ue_id, b->gNB_CU_ue_id);
_F1_EQ_CHECK_INT(a->gNB_DU_ue_id, b->gNB_DU_ue_id);
_F1_EQ_CHECK_INT(a->abort_transmission.present, b->abort_transmission.present);
switch (a->abort_transmission.present) {
case F1AP_ABORT_TRANSMISSION_PR_NOTHING:
// nothing to check
break;
case F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID:
_F1_EQ_CHECK_INT(a->abort_transmission.choice.srs_resource_set_id, b->abort_transmission.choice.srs_resource_set_id);
break;
case F1AP_ABORT_TRANSMISSION_PR_RELEASEALL:
_F1_EQ_CHECK_INT(a->abort_transmission.choice.release_all, b->abort_transmission.choice.release_all);
break;
default:
PRINT_ERROR("received illegal Abort Transmission value %d\n", a->abort_transmission.present);
break;
}
return true;
}
/**
* @brief Free Allocated F1 positioning activation failure
*/
void free_positioning_deactivation(f1ap_positioning_deactivation_t *msg)
{
// nothing to free
}
openair2/F1AP/lib/f1ap_positioning.h
+7
View File
@@ -71,4 +71,11 @@ bool eq_positioning_activation_failure(const f1ap_positioning_activation_failure
const f1ap_positioning_activation_failure_t *b);
void free_positioning_activation_failure(f1ap_positioning_activation_failure_t *msg);
// positioning deactivation
struct F1AP_F1AP_PDU *encode_positioning_deactivation(const f1ap_positioning_deactivation_t *msg);
bool decode_positioning_deactivation(const struct F1AP_F1AP_PDU *pdu, f1ap_positioning_deactivation_t *out);
f1ap_positioning_deactivation_t cp_positioning_deactivation(const f1ap_positioning_deactivation_t *orig);
bool eq_positioning_deactivation(const f1ap_positioning_deactivation_t *a, const f1ap_positioning_deactivation_t *b);
void free_positioning_deactivation(f1ap_positioning_deactivation_t *msg);
#endif /* F1AP_POSITIONING_H_ */
openair2/F1AP/tests/f1ap_lib_test.c
+44
View File
@@ -1746,6 +1746,49 @@ static void test_f1ap_positioning_activation_failure()
printf("%s() successful\n", __func__);
}
static void test_f1ap_positioning_deactivation_msg(f1ap_positioning_deactivation_t *orig)
{
F1AP_F1AP_PDU_t *f1enc = encode_positioning_deactivation(orig);
F1AP_F1AP_PDU_t *f1dec = f1ap_encode_decode(f1enc);
f1ap_msg_free(f1enc);
f1ap_positioning_deactivation_t decoded = {0};
bool ret = decode_positioning_deactivation(f1dec, &decoded);
AssertFatal(ret, "decode_positioning_deactivation(): could not decode message\n");
f1ap_msg_free(f1dec);
ret = eq_positioning_deactivation(orig, &decoded);
AssertFatal(ret, "eq_positioning_deactivation(): decoded message doesn't match\n");
free_positioning_deactivation(&decoded);
f1ap_positioning_deactivation_t cp = cp_positioning_deactivation(orig);
ret = eq_positioning_deactivation(orig, &cp);
AssertFatal(ret, "eq_positioning_deactivation(): copied message doesn't match\n");
free_positioning_deactivation(orig);
free_positioning_deactivation(&cp);
}
static void test_f1ap_positioning_deactivation()
{
/* Abort Transmission SRS Resource Set ID test*/
f1ap_positioning_deactivation_t orig = {
.gNB_CU_ue_id = 12,
.gNB_DU_ue_id = 19,
.abort_transmission.present = F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID,
.abort_transmission.choice.srs_resource_set_id = 10,
};
test_f1ap_positioning_deactivation_msg(&orig);
/* Abort Transmission release ALL test*/
orig.gNB_CU_ue_id = 12;
orig.gNB_DU_ue_id = 19;
orig.abort_transmission.present = F1AP_ABORT_TRANSMISSION_PR_RELEASEALL;
orig.abort_transmission.choice.release_all = true;
test_f1ap_positioning_deactivation_msg(&orig);
printf("%s() successful\n", __func__);
}
int main()
{
test_initial_ul_rrc_message_transfer();
@@ -1778,5 +1821,6 @@ int main()
test_f1ap_positioning_activation_request();
test_f1ap_positioning_activation_response();
test_f1ap_positioning_activation_failure();
test_f1ap_positioning_deactivation();
return 0;
}