diff --git a/openair2/COMMON/f1ap_messages_types.h b/openair2/COMMON/f1ap_messages_types.h index 0127f9e4da..4e8e949991 100644 --- a/openair2/COMMON/f1ap_messages_types.h +++ b/openair2/COMMON/f1ap_messages_types.h @@ -1015,6 +1015,22 @@ typedef struct f1ap_srs_configuration_s { f1ap_srs_carrier_list_t srs_carrier_list; } f1ap_srs_configuration_t; +typedef union f1ap_srs_type_c { + uint8_t *srs_resource_set_id; + bool *aperiodic; +} f1ap_srs_type_u; + +typedef enum f1ap_srs_type_e { + F1AP_SRS_TYPE_PR_NOTHING, + F1AP_SRS_TYPE_PR_SEMIPERSISTENTSRS, + F1AP_SRS_TYPE_PR_APERIODICSRS +} f1ap_srs_type_pr; + +typedef struct f1ap_srs_type_s { + f1ap_srs_type_pr present; + f1ap_srs_type_u choice; +} f1ap_srs_type_t; + typedef struct f1ap_positioning_information_req_s { // IE 9.3.1.4 (mandatory) uint32_t gNB_CU_ue_id; @@ -1042,4 +1058,13 @@ typedef struct f1ap_positioning_information_failure_s { long cause_value; } f1ap_positioning_information_failure_t; +typedef struct f1ap_positioning_activation_req_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_srs_type_t srs_type; +} f1ap_positioning_activation_req_t; + #endif /* F1AP_MESSAGES_TYPES_H_ */ diff --git a/openair2/F1AP/lib/f1ap_lib_includes.h b/openair2/F1AP/lib/f1ap_lib_includes.h index 3ebafe0222..fa24b65918 100644 --- a/openair2/F1AP/lib/f1ap_lib_includes.h +++ b/openair2/F1AP/lib/f1ap_lib_includes.h @@ -71,5 +71,7 @@ #include "F1AP_PosResourceSetTypePR.h" #include "F1AP_PosResourceSetTypeSP.h" #include "F1AP_PosResourceSetTypeAP.h" +#include "F1AP_SemipersistentSRS.h" +#include "F1AP_AperiodicSRS.h" #endif /* F1AP_LIB_INCLUDES_H_ */ diff --git a/openair2/F1AP/lib/f1ap_positioning.c b/openair2/F1AP/lib/f1ap_positioning.c index e6ee6187a5..a6ef670da2 100644 --- a/openair2/F1AP/lib/f1ap_positioning.c +++ b/openair2/F1AP/lib/f1ap_positioning.c @@ -1984,6 +1984,54 @@ static void free_srs_carrier_list(f1ap_srs_carrier_list_t *srs_carrier_list) free(srs_carrier_list->srs_carrier_list_item); } +static F1AP_SRSType_t encode_f1ap_srstype(const f1ap_srs_type_t *srs_type) +{ + F1AP_SRSType_t f1_srstype = {0}; + switch (srs_type->present) { + case F1AP_SRS_TYPE_PR_NOTHING: + f1_srstype.present = F1AP_SRSType_PR_NOTHING; + break; + case F1AP_SRS_TYPE_PR_SEMIPERSISTENTSRS: + f1_srstype.present = F1AP_SRSType_PR_semipersistentSRS; + asn1cCalloc(f1_srstype.choice.semipersistentSRS, sp_srs); + sp_srs->sRSResourceSetID = *srs_type->choice.srs_resource_set_id; + break; + case F1AP_SRS_TYPE_PR_APERIODICSRS: + f1_srstype.present = F1AP_SRSType_PR_aperiodicSRS; + asn1cCalloc(f1_srstype.choice.aperiodicSRS, ap_srs); + ap_srs->aperiodic = *srs_type->choice.aperiodic; + break; + default: + AssertFatal(false, "unknown SRS type %d\n", srs_type->present); + break; + } + return f1_srstype; +} + +static bool decode_f1ap_srstype(const F1AP_SRSType_t *srs_type, f1ap_srs_type_t *out) +{ + switch (srs_type->present) { + case F1AP_SRSType_PR_NOTHING: + out->present = F1AP_SRS_TYPE_PR_NOTHING; + break; + case F1AP_SRSType_PR_semipersistentSRS: + out->present = F1AP_SRS_TYPE_PR_SEMIPERSISTENTSRS; + out->choice.srs_resource_set_id = calloc_or_fail(1, sizeof(*out->choice.srs_resource_set_id)); + *out->choice.srs_resource_set_id = srs_type->choice.semipersistentSRS->sRSResourceSetID; + break; + case F1AP_SRSType_PR_aperiodicSRS: + out->present = F1AP_SRS_TYPE_PR_APERIODICSRS; + out->choice.aperiodic = calloc_or_fail(1, sizeof(*out->choice.aperiodic)); + *out->choice.aperiodic = srs_type->choice.aperiodicSRS->aperiodic; + break; + default: + PRINT_ERROR("received illegal SRS type %d\n", srs_type->present); + return false; + break; + } + return true; +} + /** * @brief Encode F1 positioning information request to ASN.1 */ @@ -2381,3 +2429,177 @@ void free_positioning_information_failure(f1ap_positioning_information_failure_t { // nothing to free } + +/** + * @brief Encode F1 positioning activation request to ASN.1 + */ +F1AP_F1AP_PDU_t *encode_positioning_activation_req(const f1ap_positioning_activation_req_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_PositioningActivation; + tmp->criticality = F1AP_Criticality_reject; + tmp->value.present = F1AP_InitiatingMessage__value_PR_PositioningActivationRequest; + F1AP_PositioningActivationRequest_t *out = &tmp->value.choice.PositioningActivationRequest; + + /* mandatory : GNB_CU_UE_F1AP_ID */ + asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningActivationRequestIEs_t, ie1); + ie1->id = F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID; + ie1->criticality = F1AP_Criticality_reject; + ie1->value.present = F1AP_PositioningActivationRequestIEs__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_PositioningActivationRequestIEs_t, ie2); + ie2->id = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID; + ie2->criticality = F1AP_Criticality_reject; + ie2->value.present = F1AP_PositioningActivationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID; + ie2->value.choice.GNB_DU_UE_F1AP_ID = msg->gNB_DU_ue_id; + + /* mandatory : SRS type */ + asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningActivationRequestIEs_t, ie3); + ie3->id = F1AP_ProtocolIE_ID_id_SRSType; + ie3->criticality = F1AP_Criticality_reject; + ie3->value.present = F1AP_PositioningActivationRequestIEs__value_PR_SRSType; + ie3->value.choice.SRSType = encode_f1ap_srstype(&msg->srs_type); + + return pdu; +} + +/** + * @brief Decode F1 positioning activation request + */ +bool decode_positioning_activation_req(const F1AP_F1AP_PDU_t *pdu, f1ap_positioning_activation_req_t *out) +{ + DevAssert(out != NULL); + memset(out, 0, sizeof(*out)); + + F1AP_PositioningActivationRequest_t *in = &pdu->choice.initiatingMessage->value.choice.PositioningActivationRequest; + F1AP_PositioningActivationRequestIEs_t *ie; + + F1AP_LIB_FIND_IE(F1AP_PositioningActivationRequestIEs_t, + ie, + &in->protocolIEs.list, + F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID, + true); + F1AP_LIB_FIND_IE(F1AP_PositioningActivationRequestIEs_t, + ie, + &in->protocolIEs.list, + F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, + true); + F1AP_LIB_FIND_IE(F1AP_PositioningActivationRequestIEs_t, ie, &in->protocolIEs.list, F1AP_ProtocolIE_ID_id_SRSType, 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_PositioningActivationRequestIEs__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_PositioningActivationRequestIEs__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_SRSType: + _F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningActivationRequestIEs__value_PR_SRSType); + _F1_CHECK_EXP(decode_f1ap_srstype(&ie->value.choice.SRSType, &out->srs_type)); + break; + case F1AP_ProtocolIE_ID_id_ActivationTime: + PRINT_ERROR("F1AP_ProtocolIE_ID_id %ld not handled, skipping\n", ie->id); + break; + default: + PRINT_ERROR("F1AP_ProtocolIE_ID_id %ld unknown, skipping\n", ie->id); + break; + } + } + + return true; +} + +/** + * @brief F1 positioning activation request deep copy + */ +f1ap_positioning_activation_req_t cp_positioning_activation_req(const f1ap_positioning_activation_req_t *orig) +{ + /* copy all mandatory fields that are not dynamic memory */ + f1ap_positioning_activation_req_t cp = { + .gNB_CU_ue_id = orig->gNB_CU_ue_id, + .gNB_DU_ue_id = orig->gNB_DU_ue_id, + .srs_type.present = orig->srs_type.present, + }; + + switch (orig->srs_type.present) { + case F1AP_SRS_TYPE_PR_NOTHING: + // nothing to copy + break; + case F1AP_SRS_TYPE_PR_SEMIPERSISTENTSRS: + cp.srs_type.choice.srs_resource_set_id = calloc_or_fail(1, sizeof(*cp.srs_type.choice.srs_resource_set_id)); + *cp.srs_type.choice.srs_resource_set_id = *orig->srs_type.choice.srs_resource_set_id; + break; + case F1AP_SRS_TYPE_PR_APERIODICSRS: + cp.srs_type.choice.aperiodic = calloc_or_fail(1, sizeof(*cp.srs_type.choice.aperiodic)); + *cp.srs_type.choice.aperiodic = *orig->srs_type.choice.aperiodic; + break; + default: + PRINT_ERROR("received illegal SRS type %d\n", orig->srs_type.present); + break; + } + + return cp; +} + +/** + * @brief F1 positioning activation request equality check + */ +bool eq_positioning_activation_req(const f1ap_positioning_activation_req_t *a, const f1ap_positioning_activation_req_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->srs_type.present, b->srs_type.present); + + const f1ap_srs_type_t *srs_type_a = &a->srs_type; + const f1ap_srs_type_t *srs_type_b = &b->srs_type; + switch (srs_type_a->present) { + case F1AP_SRS_TYPE_PR_NOTHING: + // nothing to check + break; + case F1AP_SRS_TYPE_PR_SEMIPERSISTENTSRS: + _F1_EQ_CHECK_INT(*srs_type_a->choice.srs_resource_set_id, *srs_type_b->choice.srs_resource_set_id); + break; + case F1AP_SRS_TYPE_PR_APERIODICSRS: + _F1_EQ_CHECK_INT(*srs_type_a->choice.aperiodic, *srs_type_b->choice.aperiodic); + break; + default: + PRINT_ERROR("received illegal SRS type %d\n", srs_type_a->present); + break; + } + + return true; +} + +/** + * @brief Free Allocated F1 activation request + */ +void free_positioning_activation_req(f1ap_positioning_activation_req_t *msg) +{ + DevAssert(msg != NULL); + + switch (msg->srs_type.present) { + case F1AP_SRS_TYPE_PR_NOTHING: + // nothing to free + return; + case F1AP_SRS_TYPE_PR_SEMIPERSISTENTSRS: + free(msg->srs_type.choice.srs_resource_set_id); + break; + case F1AP_SRS_TYPE_PR_APERIODICSRS: + free(msg->srs_type.choice.aperiodic); + break; + default: + PRINT_ERROR("received illegal SRS type %d\n", msg->srs_type.present); + break; + } +} diff --git a/openair2/F1AP/lib/f1ap_positioning.h b/openair2/F1AP/lib/f1ap_positioning.h index 86b1f437d6..f4b5dac3b1 100644 --- a/openair2/F1AP/lib/f1ap_positioning.h +++ b/openair2/F1AP/lib/f1ap_positioning.h @@ -49,4 +49,11 @@ bool eq_positioning_information_failure(const f1ap_positioning_information_failu const f1ap_positioning_information_failure_t *b); void free_positioning_information_failure(f1ap_positioning_information_failure_t *msg); +// positioning activation request +struct F1AP_F1AP_PDU *encode_positioning_activation_req(const f1ap_positioning_activation_req_t *msg); +bool decode_positioning_activation_req(const struct F1AP_F1AP_PDU *pdu, f1ap_positioning_activation_req_t *out); +f1ap_positioning_activation_req_t cp_positioning_activation_req(const f1ap_positioning_activation_req_t *orig); +bool eq_positioning_activation_req(const f1ap_positioning_activation_req_t *a, const f1ap_positioning_activation_req_t *b); +void free_positioning_activation_req(f1ap_positioning_activation_req_t *msg); + #endif /* F1AP_POSITIONING_H_ */ diff --git a/openair2/F1AP/tests/f1ap_lib_test.c b/openair2/F1AP/tests/f1ap_lib_test.c index 6cc3ce9cbb..3ba6879acc 100644 --- a/openair2/F1AP/tests/f1ap_lib_test.c +++ b/openair2/F1AP/tests/f1ap_lib_test.c @@ -1640,6 +1640,53 @@ static void test_f1ap_positioning_information_failure() printf("%s() successful\n", __func__); } +static void test_f1ap_positioning_activation_request_msg(f1ap_positioning_activation_req_t *orig) +{ + F1AP_F1AP_PDU_t *f1enc = encode_positioning_activation_req(orig); + F1AP_F1AP_PDU_t *f1dec = f1ap_encode_decode(f1enc); + f1ap_msg_free(f1enc); + + f1ap_positioning_activation_req_t decoded = {0}; + bool ret = decode_positioning_activation_req(f1dec, &decoded); + AssertFatal(ret, "decode_positioning_activation_request(): could not decode message\n"); + f1ap_msg_free(f1dec); + + ret = eq_positioning_activation_req(orig, &decoded); + AssertFatal(ret, "eq_positioning_activation_request(): decoded message doesn't match\n"); + free_positioning_activation_req(&decoded); + + f1ap_positioning_activation_req_t cp = cp_positioning_activation_req(orig); + ret = eq_positioning_activation_req(orig, &cp); + AssertFatal(ret, "eq_positioning_activation_request(): copied message doesn't match\n"); + free_positioning_activation_req(&cp); + free_positioning_activation_req(orig); +} + +static void test_f1ap_positioning_activation_request() +{ + /* semipersistent srs test*/ + f1ap_positioning_activation_req_t orig = { + .gNB_CU_ue_id = 12, + .gNB_DU_ue_id = 19, + .srs_type.present = F1AP_SRS_TYPE_PR_SEMIPERSISTENTSRS, + }; + + orig.srs_type.choice.srs_resource_set_id = calloc_or_fail(1, sizeof(*orig.srs_type.choice.srs_resource_set_id)); + *orig.srs_type.choice.srs_resource_set_id = 1; + test_f1ap_positioning_activation_request_msg(&orig); + + /* aperiodic srs test*/ + orig.gNB_CU_ue_id = 12; + orig.gNB_DU_ue_id = 19; + orig.srs_type.present = F1AP_SRS_TYPE_PR_APERIODICSRS; + orig.srs_type.choice.aperiodic = calloc_or_fail(1, sizeof(*orig.srs_type.choice.aperiodic)); + // set aperiodic = 0 to enable + *orig.srs_type.choice.aperiodic = 0; + test_f1ap_positioning_activation_request_msg(&orig); + + printf("%s() successful\n", __func__); +} + int main() { test_initial_ul_rrc_message_transfer(); @@ -1669,5 +1716,6 @@ int main() test_f1ap_positioning_information_request(); test_f1ap_positioning_information_response(); test_f1ap_positioning_information_failure(); + test_f1ap_positioning_activation_request(); return 0; }