diff --git a/openair2/COMMON/f1ap_messages_types.h b/openair2/COMMON/f1ap_messages_types.h index 3dc0987129..a92f14ca50 100644 --- a/openair2/COMMON/f1ap_messages_types.h +++ b/openair2/COMMON/f1ap_messages_types.h @@ -1592,4 +1592,16 @@ typedef struct f1ap_positioning_measurement_failure_indication_s { // IE 9.3.1.2 (mandatory) long cause_value; } f1ap_positioning_measurement_failure_indication_t; + +typedef struct f1ap_positioning_measurement_update_s { + // IE 9.3.1.23 (mandatory) + uint8_t transaction_id; + // (mandatory) + uint16_t lmf_measurement_id; + // (mandatory) + uint16_t ran_measurement_id; + // IE 9.3.1.192 (optional) + f1ap_srs_configuration_t *srs_configuration; +} f1ap_positioning_measurement_update_t; + #endif /* F1AP_MESSAGES_TYPES_H_ */ diff --git a/openair2/F1AP/lib/f1ap_positioning.c b/openair2/F1AP/lib/f1ap_positioning.c index bcbeea6a3d..4fd1e6a18f 100644 --- a/openair2/F1AP/lib/f1ap_positioning.c +++ b/openair2/F1AP/lib/f1ap_positioning.c @@ -6250,3 +6250,171 @@ void free_positioning_measurement_failure_indication(f1ap_positioning_measuremen { // nothing to free } + +/** + * @brief Encode F1 positioning measurement update to ASN.1 + */ +F1AP_F1AP_PDU_t *encode_positioning_measurement_update(const f1ap_positioning_measurement_update_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_PositioningMeasurementUpdate; + tmp->criticality = F1AP_Criticality_ignore; + tmp->value.present = F1AP_InitiatingMessage__value_PR_PositioningMeasurementUpdate; + F1AP_PositioningMeasurementUpdate_t *out = &tmp->value.choice.PositioningMeasurementUpdate; + + /* mandatory : TransactionID */ + asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningMeasurementUpdateIEs_t, ie1); + ie1->id = F1AP_ProtocolIE_ID_id_TransactionID; + ie1->criticality = F1AP_Criticality_reject; + ie1->value.present = F1AP_PositioningMeasurementUpdateIEs__value_PR_TransactionID; + ie1->value.choice.TransactionID = msg->transaction_id; + + /* mandatory : LMF_MeasurementID */ + asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningMeasurementUpdateIEs_t, ie2); + ie2->id = F1AP_ProtocolIE_ID_id_LMF_MeasurementID; + ie2->criticality = F1AP_Criticality_reject; + ie2->value.present = F1AP_PositioningMeasurementUpdateIEs__value_PR_LMF_MeasurementID; + ie2->value.choice.LMF_MeasurementID = msg->lmf_measurement_id; + + /* mandatory : RAN_MeasurementID */ + asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningMeasurementUpdateIEs_t, ie3); + ie3->id = F1AP_ProtocolIE_ID_id_RAN_MeasurementID; + ie3->criticality = F1AP_Criticality_reject; + ie3->value.present = F1AP_PositioningMeasurementUpdateIEs__value_PR_RAN_MeasurementID; + ie3->value.choice.RAN_MeasurementID = msg->ran_measurement_id; + + /* optional: SRS Configuration */ + if (msg->srs_configuration) { + asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningMeasurementUpdateIEs_t, ie4); + ie4->id = F1AP_ProtocolIE_ID_id_SRSConfiguration; + ie4->criticality = F1AP_Criticality_ignore; + ie4->value.present = F1AP_PositioningMeasurementUpdateIEs__value_PR_SRSConfiguration; + f1ap_srs_carrier_list_t *srs_carrier_list = &msg->srs_configuration->srs_carrier_list; + ie4->value.choice.SRSConfiguration.sRSCarrier_List = encode_srs_carrier_list(srs_carrier_list); + } + + return pdu; +} + +/** + * @brief Decode F1 Positioning Measurement Update + */ +bool decode_positioning_measurement_update(const F1AP_F1AP_PDU_t *pdu, f1ap_positioning_measurement_update_t *out) +{ + DevAssert(out != NULL); + memset(out, 0, sizeof(*out)); + + F1AP_PositioningMeasurementUpdate_t *in = &pdu->choice.initiatingMessage->value.choice.PositioningMeasurementUpdate; + F1AP_PositioningMeasurementUpdateIEs_t *ie; + + F1AP_LIB_FIND_IE(F1AP_PositioningMeasurementUpdateIEs_t, ie, &in->protocolIEs.list, F1AP_ProtocolIE_ID_id_TransactionID, true); + F1AP_LIB_FIND_IE(F1AP_PositioningMeasurementUpdateIEs_t, + ie, + &in->protocolIEs.list, + F1AP_ProtocolIE_ID_id_LMF_MeasurementID, + true); + F1AP_LIB_FIND_IE(F1AP_PositioningMeasurementUpdateIEs_t, + ie, + &in->protocolIEs.list, + F1AP_ProtocolIE_ID_id_RAN_MeasurementID, + true); + F1AP_LIB_FIND_IE(F1AP_PositioningMeasurementUpdateIEs_t, + ie, + &in->protocolIEs.list, + F1AP_ProtocolIE_ID_id_SRSConfiguration, + false); + + 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_TransactionID: + _F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningMeasurementUpdateIEs__value_PR_TransactionID); + out->transaction_id = ie->value.choice.TransactionID; + break; + case F1AP_ProtocolIE_ID_id_LMF_MeasurementID: + _F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningMeasurementUpdateIEs__value_PR_LMF_MeasurementID); + out->lmf_measurement_id = ie->value.choice.LMF_MeasurementID; + break; + case F1AP_ProtocolIE_ID_id_RAN_MeasurementID: + _F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningMeasurementUpdateIEs__value_PR_RAN_MeasurementID); + out->ran_measurement_id = ie->value.choice.RAN_MeasurementID; + break; + case F1AP_ProtocolIE_ID_id_SRSConfiguration: + _F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningMeasurementUpdateIEs__value_PR_SRSConfiguration); + F1AP_SRSCarrier_List_t *f1_sRSCarrier_List = &ie->value.choice.SRSConfiguration.sRSCarrier_List; + out->srs_configuration = calloc_or_fail(1, sizeof(*out->srs_configuration)); + f1ap_srs_carrier_list_t *srs_carrier_list = &out->srs_configuration->srs_carrier_list; + decode_srs_carrier_list(srs_carrier_list, f1_sRSCarrier_List); + break; + default: + PRINT_ERROR("F1AP_ProtocolIE_ID_id %ld unknown, skipping\n", ie->id); + break; + } + } + + return true; +} + +/** + * @brief F1 Positioning Measurement Update deep copy + */ +f1ap_positioning_measurement_update_t cp_positioning_measurement_update(const f1ap_positioning_measurement_update_t *orig) +{ + // copy all mandatory fields that are not dynamic memory + f1ap_positioning_measurement_update_t cp = { + .transaction_id = orig->transaction_id, + .lmf_measurement_id = orig->lmf_measurement_id, + .ran_measurement_id = orig->ran_measurement_id, + }; + + /* optional: SRS Configuration */ + if (orig->srs_configuration) { + cp.srs_configuration = calloc_or_fail(1, sizeof(*cp.srs_configuration)); + f1ap_srs_carrier_list_t *srs_carrier_list_cp = &cp.srs_configuration->srs_carrier_list; + f1ap_srs_carrier_list_t *srs_carrier_list = &orig->srs_configuration->srs_carrier_list; + *srs_carrier_list_cp = cp_srs_carrier_list(srs_carrier_list); + } + + return cp; +} + +/** + * @brief F1 Positioning Measurement Update equality check + */ +bool eq_positioning_measurement_update(const f1ap_positioning_measurement_update_t *a, + const f1ap_positioning_measurement_update_t *b) +{ + _F1_EQ_CHECK_INT(a->transaction_id, b->transaction_id); + _F1_EQ_CHECK_INT(a->lmf_measurement_id, b->lmf_measurement_id); + _F1_EQ_CHECK_INT(a->ran_measurement_id, b->ran_measurement_id); + + /* optional: SRS Configuration */ + if ((a->srs_configuration == NULL) != (b->srs_configuration == NULL)) { + return false; + } + if (a->srs_configuration) { + f1ap_srs_carrier_list_t *srs_carrier_list_a = &a->srs_configuration->srs_carrier_list; + f1ap_srs_carrier_list_t *srs_carrier_list_b = &b->srs_configuration->srs_carrier_list; + _F1_CHECK_EXP(eq_srs_carrier_list(srs_carrier_list_a, srs_carrier_list_b)); + } + + return true; +} + +/** + * @brief Free Allocated F1 Positioning Measurement Update + */ +void free_positioning_measurement_update(f1ap_positioning_measurement_update_t *msg) +{ + /* SRS Configuration */ + if (msg->srs_configuration) { + f1ap_srs_carrier_list_t *srs_carrier_list = &msg->srs_configuration->srs_carrier_list; + free_srs_carrier_list(srs_carrier_list); + free(msg->srs_configuration); + } +} diff --git a/openair2/F1AP/lib/f1ap_positioning.h b/openair2/F1AP/lib/f1ap_positioning.h index d09ccb85dd..585f3f5a81 100644 --- a/openair2/F1AP/lib/f1ap_positioning.h +++ b/openair2/F1AP/lib/f1ap_positioning.h @@ -154,4 +154,12 @@ f1ap_positioning_measurement_failure_indication_t cp_positioning_measurement_fai bool eq_positioning_measurement_failure_indication(const f1ap_positioning_measurement_failure_indication_t *a, const f1ap_positioning_measurement_failure_indication_t *b); void free_positioning_measurement_failure_indication(f1ap_positioning_measurement_failure_indication_t *msg); + +// positioning measurement update +struct F1AP_F1AP_PDU *encode_positioning_measurement_update(const f1ap_positioning_measurement_update_t *msg); +bool decode_positioning_measurement_update(const struct F1AP_F1AP_PDU *pdu, f1ap_positioning_measurement_update_t *out); +f1ap_positioning_measurement_update_t cp_positioning_measurement_update(const f1ap_positioning_measurement_update_t *orig); +bool eq_positioning_measurement_update(const f1ap_positioning_measurement_update_t *a, + const f1ap_positioning_measurement_update_t *b); +void free_positioning_measurement_update(f1ap_positioning_measurement_update_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 65ebe55b15..75fa75bcc1 100644 --- a/openair2/F1AP/tests/f1ap_lib_test.c +++ b/openair2/F1AP/tests/f1ap_lib_test.c @@ -2328,6 +2328,41 @@ static void test_f1ap_positioning_measurement_failure_indication() printf("%s() successful\n", __func__); } +static void test_f1ap_positioning_measurement_update() +{ + f1ap_positioning_measurement_update_t orig = { + .transaction_id = 12, + .lmf_measurement_id = 1999, + .ran_measurement_id = 2225, + }; + + // SRS configuration + orig.srs_configuration = calloc_or_fail(1, sizeof(*orig.srs_configuration)); + f1ap_srs_carrier_list_t *srs_carrier_list = &orig.srs_configuration->srs_carrier_list; + fill_srs_carrier_list(srs_carrier_list); + + F1AP_F1AP_PDU_t *f1enc = encode_positioning_measurement_update(&orig); + F1AP_F1AP_PDU_t *f1dec = f1ap_encode_decode(f1enc); + f1ap_msg_free(f1enc); + + f1ap_positioning_measurement_update_t decoded = {0}; + bool ret = decode_positioning_measurement_update(f1dec, &decoded); + AssertFatal(ret, "decode_positioning_measurement_update(): could not decode message\n"); + f1ap_msg_free(f1dec); + + ret = eq_positioning_measurement_update(&orig, &decoded); + AssertFatal(ret, "eq_positioning_measurement_update(): decoded message doesn't match\n"); + free_positioning_measurement_update(&decoded); + + f1ap_positioning_measurement_update_t cp = cp_positioning_measurement_update(&orig); + ret = eq_positioning_measurement_update(&orig, &cp); + AssertFatal(ret, "eq_positioning_measurement_update(): copied message doesn't match\n"); + free_positioning_measurement_update(&orig); + free_positioning_measurement_update(&cp); + + printf("%s() successful\n", __func__); +} + int main() { test_initial_ul_rrc_message_transfer(); @@ -2371,5 +2406,6 @@ int main() test_f1ap_positioning_measurement_report(); test_f1ap_positioning_measurement_abort(); test_f1ap_positioning_measurement_failure_indication(); + test_f1ap_positioning_measurement_update(); return 0; }