Add F1AP trp information failure message enc/dec + test

Reference: 3GPP 38.473 v16.21.0
Mandatory fields:
Transcation ID (supported)
Cause (supported)
Optional fields:
Criticality Diagnostics (not supported)

openair2/COMMON/f1ap_messages_types.h

@@ -1338,4 +1338,13 @@ typedef struct f1ap_trp_information_resp_s {
   f1ap_trp_information_list_t trp_information_list;
 } f1ap_trp_information_resp_t;
 
+typedef struct f1ap_trp_information_failure_s {
+  // IE 9.3.1.23 (mandatory)
+  uint8_t transaction_id;
+  // IE 9.3.1.2 (mandatory)
+  f1ap_Cause_t cause;
+  // IE 9.3.1.2 (mandatory)
+  long cause_value;
+} f1ap_trp_information_failure_t;
+
 #endif /* F1AP_MESSAGES_TYPES_H_ */

openair2/F1AP/lib/f1ap_positioning.c

@@ -4356,3 +4356,108 @@ void free_trp_information_resp(f1ap_trp_information_resp_t *msg)
   }
   free(msg->trp_information_list.trp_information_item);
 }
+
+/**
+ * @brief Encode F1 TRP information failure to ASN.1
+ */
+F1AP_F1AP_PDU_t *encode_trp_information_failure(const f1ap_trp_information_failure_t *msg)
+{
+  F1AP_F1AP_PDU_t *pdu = calloc_or_fail(1, sizeof(*pdu));
+
+  /* Message Type */
+  pdu->present = F1AP_F1AP_PDU_PR_unsuccessfulOutcome;
+  asn1cCalloc(pdu->choice.unsuccessfulOutcome, tmp);
+  tmp->procedureCode = F1AP_ProcedureCode_id_TRPInformationExchange;
+  tmp->criticality = F1AP_Criticality_reject;
+  tmp->value.present = F1AP_UnsuccessfulOutcome__value_PR_TRPInformationFailure;
+  F1AP_TRPInformationFailure_t *out = &tmp->value.choice.TRPInformationFailure;
+
+  /* mandatory : TransactionID */
+  asn1cSequenceAdd(out->protocolIEs.list, F1AP_TRPInformationFailureIEs_t, ie1);
+  ie1->id = F1AP_ProtocolIE_ID_id_TransactionID;
+  ie1->criticality = F1AP_Criticality_reject;
+  ie1->value.present = F1AP_TRPInformationFailureIEs__value_PR_TransactionID;
+  ie1->value.choice.TransactionID = msg->transaction_id;
+
+  /* mandatory : Cause */
+  asn1cSequenceAdd(out->protocolIEs.list, F1AP_TRPInformationFailureIEs_t, ie3);
+  ie3->id = F1AP_ProtocolIE_ID_id_Cause;
+  ie3->criticality = F1AP_Criticality_ignore;
+  ie3->value.present = F1AP_TRPInformationFailureIEs__value_PR_Cause;
+  ie3->value.choice.Cause = encode_f1ap_cause(msg->cause, msg->cause_value);
+
+  return pdu;
+}
+
+/**
+ * @brief Decode F1 TRP information failure
+ */
+bool decode_trp_information_failure(const F1AP_F1AP_PDU_t *pdu, f1ap_trp_information_failure_t *out)
+{
+  DevAssert(out != NULL);
+  memset(out, 0, sizeof(*out));
+
+  F1AP_TRPInformationFailure_t *in = &pdu->choice.unsuccessfulOutcome->value.choice.TRPInformationFailure;
+  F1AP_TRPInformationFailureIEs_t *ie;
+
+  F1AP_LIB_FIND_IE(F1AP_TRPInformationFailureIEs_t, ie, &in->protocolIEs.list, F1AP_ProtocolIE_ID_id_TransactionID, true);
+  F1AP_LIB_FIND_IE(F1AP_TRPInformationFailureIEs_t, ie, &in->protocolIEs.list, F1AP_ProtocolIE_ID_id_Cause, 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_TransactionID:
+        _F1_EQ_CHECK_INT(ie->value.present, F1AP_TRPInformationFailureIEs__value_PR_TransactionID);
+        out->transaction_id = ie->value.choice.TransactionID;
+        break;
+      case F1AP_ProtocolIE_ID_id_Cause:
+        _F1_EQ_CHECK_INT(ie->value.present, F1AP_TRPInformationFailureIEs__value_PR_Cause);
+        _F1_CHECK_EXP(decode_f1ap_cause(ie->value.choice.Cause, &out->cause, &out->cause_value));
+        break;
+      case F1AP_ProtocolIE_ID_id_CriticalityDiagnostics:
+        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 trp information failure deep copy
+ */
+f1ap_trp_information_failure_t cp_trp_information_failure(const f1ap_trp_information_failure_t *orig)
+{
+  /* copy all mandatory fields that are not dynamic memory */
+  f1ap_trp_information_failure_t cp = {
+      .transaction_id = orig->transaction_id,
+      .cause = orig->cause,
+      .cause_value = orig->cause_value,
+  };
+
+  return cp;
+}
+
+/**
+ * @brief F1 trp information failure equality check
+ */
+bool eq_trp_information_failure(const f1ap_trp_information_failure_t *a, const f1ap_trp_information_failure_t *b)
+{
+  _F1_EQ_CHECK_INT(a->transaction_id, b->transaction_id);
+  _F1_EQ_CHECK_INT(a->cause, b->cause);
+  _F1_EQ_CHECK_LONG(a->cause_value, b->cause_value);
+
+  return true;
+}
+
+/**
+ * @brief Free Allocated F1 trp information failure
+ */
+void free_trp_information_failure(f1ap_trp_information_failure_t *msg)
+{
+  // nothing to free
+}

openair2/F1AP/lib/f1ap_positioning.h

@@ -100,4 +100,11 @@ f1ap_trp_information_resp_t cp_trp_information_resp(const f1ap_trp_information_r
 bool eq_trp_information_resp(const f1ap_trp_information_resp_t *a, const f1ap_trp_information_resp_t *b);
 void free_trp_information_resp(f1ap_trp_information_resp_t *msg);
 
+// trp information failure
+struct F1AP_F1AP_PDU *encode_trp_information_failure(const f1ap_trp_information_failure_t *msg);
+bool decode_trp_information_failure(const struct F1AP_F1AP_PDU *pdu, f1ap_trp_information_failure_t *out);
+f1ap_trp_information_failure_t cp_trp_information_failure(const f1ap_trp_information_failure_t *orig);
+bool eq_trp_information_failure(const f1ap_trp_information_failure_t *a, const f1ap_trp_information_failure_t *b);
+void free_trp_information_failure(f1ap_trp_information_failure_t *msg);
+
 #endif /* F1AP_POSITIONING_H_ */

openair2/F1AP/tests/f1ap_lib_test.c

@@ -1946,6 +1946,35 @@ static void test_f1ap_trp_information_response()
   printf("%s() successful\n", __func__);
 }
 
+static void test_f1ap_trp_information_failure()
+{
+  f1ap_trp_information_failure_t orig = {
+      .transaction_id = 12,
+      .cause = F1AP_CAUSE_MISC,
+      .cause_value = 3,
+  };
+  F1AP_F1AP_PDU_t *f1enc = encode_trp_information_failure(&orig);
+  F1AP_F1AP_PDU_t *f1dec = f1ap_encode_decode(f1enc);
+  f1ap_msg_free(f1enc);
+
+  f1ap_trp_information_failure_t decoded = {0};
+  bool ret = decode_trp_information_failure(f1dec, &decoded);
+  AssertFatal(ret, "decode_trp_information_failure(): could not decode message\n");
+  f1ap_msg_free(f1dec);
+
+  ret = eq_trp_information_failure(&orig, &decoded);
+  AssertFatal(ret, "eq_trp_information_failure(): decoded message doesn't match\n");
+  free_trp_information_failure(&decoded);
+
+  f1ap_trp_information_failure_t cp = cp_trp_information_failure(&orig);
+  ret = eq_trp_information_failure(&orig, &cp);
+  AssertFatal(ret, "eq_trp_information_failure(): copied message doesn't match\n");
+  free_trp_information_failure(&orig);
+  free_trp_information_failure(&cp);
+
+  printf("%s() successful\n", __func__);
+}
+
 int main()
 {
   test_initial_ul_rrc_message_transfer();
@@ -1982,5 +2011,6 @@ int main()
   test_f1ap_positioning_information_update();
   test_f1ap_trp_information_request();
   test_f1ap_trp_information_response();
+  test_f1ap_trp_information_failure();
   return 0;
 }