XNAP: add encode/decode and unit test for Xn Handover Request Acknowledge

- Add Xn Handover Request Acknowledge message type definitions
- Implement encoder and decoder for Xn Handover Request Acknowledge
    Xn Handover Request Acknowledge (3GPP TS 38.423v16.2.0 §9.1.1.2)
    - Source NG-RAN node UE XnAP ID (M)
    - Target NG-RAN node UE XnAP ID (M)
    - PDU Session Resources Admitted List (M)
    - Target NG-RAN node To Source NG-RAN node Transparent Container (M)
- Add equality check and memory management helpers
- Extend XNAP library unit tests to cover Handover Request Acknowledge

Co-authored-by: Venkatareddy Akumalla <venkatareddy@fsid-iisc.in>
Signed-off-by: Rakesh BB <rakesh.bb@fsid-iisc.in>

openair2/COMMON/xnap_messages_types.h

@@ -292,4 +292,33 @@ typedef struct {
   ue_history_info_t *ue_history_info;
 } xnap_handover_req_t;
 
+/* QoS Flows Admitted Item */
+typedef struct {
+  // QoS Flow Identifier
+  uint8_t qfi;
+} xnap_qos_admitted_item_t;
+
+/* 3GPP TS 38.423 9.2.1.2 – PDU Session Resources Admitted Item */
+typedef struct {
+  // PDU Session ID
+  uint8_t pdusession_id;
+  // QoS Flows Admitted List
+  uint8_t num_qos;
+  xnap_qos_admitted_item_t *qos_list;
+} xnap_pdusession_admitted_item_t;
+
+/* 3GPP TS 38.423 9.1.1.2 – Handover Request Acknowledge */
+typedef struct {
+  // Source NG-RAN node UE XnAP ID (M)
+  uint32_t s_ng_node_ue_xnap_id;
+  // Target NG-RAN node UE XnAP ID (M)
+  uint32_t t_ng_node_ue_xnap_id;
+  // PDU Session Resources Admitted List (M)
+  uint8_t num_pdu_admitted;
+  xnap_pdusession_admitted_item_t *pdusession_admitted_list;
+  // Target NG-RAN node To Source NG-RAN node Transparent Container (M)
+  // (3GPP TS 38.331 11.2.2 HandoverCommand message )
+  byte_array_t target2source;
+} xnap_handover_req_ack_t;
+
 #endif /* XNAP_MESSAGES_TYPES_H_ */

openair2/XNAP/lib/xnap_gNB_mobility_management.c

@@ -151,7 +151,7 @@ static bool decode_xnap_qos_flows_to_be_setup_list(const XNAP_QoSFlowsToBeSetup_
 /**
  * @brief XnAP Handover Request encoding
  */
-XNAP_XnAP_PDU_t *encode_xnap_handover_request(xnap_handover_req_t *req)
+XNAP_XnAP_PDU_t *encode_xnap_handover_request(const xnap_handover_req_t *req)
 {
   XNAP_XnAP_PDU_t *pdu = calloc_or_fail(1, sizeof(*pdu));
 
@@ -597,7 +597,7 @@ static void free_xnap_ue_history_info_list(ue_history_info_t *history_list, uint
 /**
  * @brief XnAP Handover Request memory management
  */
-void free_xnap_handover_request(const xnap_handover_req_t *msg)
+void free_xnap_handover_request(xnap_handover_req_t *msg)
 {
   DevAssert(msg != NULL);
 
@@ -607,3 +607,248 @@ void free_xnap_handover_request(const xnap_handover_req_t *msg)
   // Free UE history information
   free_xnap_ue_history_info_list(msg->ue_history_info, msg->num_last_visited_cells);
 }
+
+/**
+ * @brief XnAP Handover Request Acknowledge encoding
+ */
+XNAP_XnAP_PDU_t *encode_xnap_handover_request_acknowledge(const xnap_handover_req_ack_t *ack)
+{
+  XNAP_XnAP_PDU_t *pdu = calloc_or_fail(1, sizeof(*pdu));
+
+  /* Message type: Successful Outcome */
+  pdu->present = XNAP_XnAP_PDU_PR_successfulOutcome;
+  asn1cCalloc(pdu->choice.successfulOutcome, succMsg);
+  succMsg->procedureCode = XNAP_ProcedureCode_id_handoverPreparation;
+  succMsg->criticality = XNAP_Criticality_reject;
+  succMsg->value.present = XNAP_SuccessfulOutcome__value_PR_HandoverRequestAcknowledge;
+
+  XNAP_HandoverRequestAcknowledge_t *out = &succMsg->value.choice.HandoverRequestAcknowledge;
+
+  /* Source NG-RAN node UE XnAP ID (M) */
+  asn1cSequenceAdd(out->protocolIEs.list, XNAP_HandoverRequestAcknowledge_IEs_t, ie1);
+  ie1->id = XNAP_ProtocolIE_ID_id_sourceNG_RANnodeUEXnAPID;
+  ie1->criticality = XNAP_Criticality_ignore;
+  ie1->value.present = XNAP_HandoverRequestAcknowledge_IEs__value_PR_NG_RANnodeUEXnAPID;
+  ie1->value.choice.NG_RANnodeUEXnAPID = ack->s_ng_node_ue_xnap_id;
+
+  /* Target NG-RAN node UE XnAP ID (M) */
+  asn1cSequenceAdd(out->protocolIEs.list, XNAP_HandoverRequestAcknowledge_IEs_t, ie2);
+  ie2->id = XNAP_ProtocolIE_ID_id_targetNG_RANnodeUEXnAPID;
+  ie2->criticality = XNAP_Criticality_ignore;
+  ie2->value.present = XNAP_HandoverRequestAcknowledge_IEs__value_PR_NG_RANnodeUEXnAPID_1;
+  ie2->value.choice.NG_RANnodeUEXnAPID_1 = ack->t_ng_node_ue_xnap_id;
+
+  /* PDU Session Resources Admitted List (M) */
+  asn1cSequenceAdd(out->protocolIEs.list, XNAP_HandoverRequestAcknowledge_IEs_t, ie3);
+  ie3->id = XNAP_ProtocolIE_ID_id_PDUSessionResourcesAdmitted_List;
+  ie3->criticality = XNAP_Criticality_ignore;
+  ie3->value.present = XNAP_HandoverRequestAcknowledge_IEs__value_PR_PDUSessionResourcesAdmitted_List;
+
+  for (int i = 0; i < ack->num_pdu_admitted; i++) {
+    const xnap_pdusession_admitted_item_t *pdu = &ack->pdusession_admitted_list[i];
+    asn1cSequenceAdd(ie3->value.choice.PDUSessionResourcesAdmitted_List.list, XNAP_PDUSessionResourcesAdmitted_Item_t, pduItem);
+
+    /* PDU Session ID */
+    pduItem->pduSessionId = pdu->pdusession_id;
+
+    /* QoS Flows Admitted List */
+    for (int j = 0; j < pdu->num_qos; j++) {
+      const xnap_qos_admitted_item_t *qos = &pdu->qos_list[j];
+      asn1cSequenceAdd(pduItem->pduSessionResourceAdmittedInfo.qosFlowsAdmitted_List.list, XNAP_QoSFlowsAdmitted_Item_t, qosItem);
+
+      /* QoS Flow Identifier */
+      qosItem->qfi = qos->qfi;
+    }
+  }
+
+  /* Target NG-RAN node To Source NG-RAN node Transparent Container (M) */
+  asn1cSequenceAdd(out->protocolIEs.list, XNAP_HandoverRequestAcknowledge_IEs_t, ie4);
+  ie4->id = XNAP_ProtocolIE_ID_id_Target2SourceNG_RANnodeTranspContainer;
+  ie4->criticality = XNAP_Criticality_ignore;
+  ie4->value.present = XNAP_HandoverRequestAcknowledge_IEs__value_PR_OCTET_STRING;
+  OCTET_STRING_fromBuf(&ie4->value.choice.OCTET_STRING, (const char *)ack->target2source.buf, ack->target2source.len);
+
+  return pdu;
+}
+
+/**
+ * @brief XnAP Handover Request Acknowledge Decoding
+ */
+bool decode_xnap_handover_request_acknowledge(xnap_handover_req_ack_t *out, const XNAP_XnAP_PDU_t *pdu)
+{
+  /* Check message type */
+  _EQ_CHECK_INT(pdu->present, XNAP_XnAP_PDU_PR_successfulOutcome);
+  AssertError(pdu->choice.successfulOutcome != NULL, return false, "successfulOutcome is NULL");
+  _EQ_CHECK_LONG(pdu->choice.successfulOutcome->procedureCode, XNAP_ProcedureCode_id_handoverPreparation);
+  _EQ_CHECK_INT(pdu->choice.successfulOutcome->value.present, XNAP_SuccessfulOutcome__value_PR_HandoverRequestAcknowledge);
+
+  XNAP_HandoverRequestAcknowledge_t *in = &pdu->choice.successfulOutcome->value.choice.HandoverRequestAcknowledge;
+  XNAP_HandoverRequestAcknowledge_IEs_t *ie;
+
+  /* Check presence of mandatory IEs */
+  XNAP_LIB_FIND_IE(XNAP_HandoverRequestAcknowledge_IEs_t,
+                   ie,
+                   &in->protocolIEs.list,
+                   XNAP_ProtocolIE_ID_id_sourceNG_RANnodeUEXnAPID,
+                   true);
+  XNAP_LIB_FIND_IE(XNAP_HandoverRequestAcknowledge_IEs_t,
+                   ie,
+                   &in->protocolIEs.list,
+                   XNAP_ProtocolIE_ID_id_targetNG_RANnodeUEXnAPID,
+                   true);
+  XNAP_LIB_FIND_IE(XNAP_HandoverRequestAcknowledge_IEs_t,
+                   ie,
+                   &in->protocolIEs.list,
+                   XNAP_ProtocolIE_ID_id_PDUSessionResourcesAdmitted_List,
+                   true);
+  XNAP_LIB_FIND_IE(XNAP_HandoverRequestAcknowledge_IEs_t,
+                   ie,
+                   &in->protocolIEs.list,
+                   XNAP_ProtocolIE_ID_id_Target2SourceNG_RANnodeTranspContainer,
+                   true);
+
+  /* Loop over all IEs */
+  for (int i = 0; i < in->protocolIEs.list.count; i++) {
+    DevAssert(in->protocolIEs.list.array[i]);
+
+    ie = in->protocolIEs.list.array[i];
+
+    switch (ie->id) {
+      case XNAP_ProtocolIE_ID_id_sourceNG_RANnodeUEXnAPID: {
+        _EQ_CHECK_INT(ie->value.present, XNAP_HandoverRequestAcknowledge_IEs__value_PR_NG_RANnodeUEXnAPID);
+        out->s_ng_node_ue_xnap_id = ie->value.choice.NG_RANnodeUEXnAPID;
+      } break;
+
+      case XNAP_ProtocolIE_ID_id_targetNG_RANnodeUEXnAPID: {
+        _EQ_CHECK_INT(ie->value.present, XNAP_HandoverRequestAcknowledge_IEs__value_PR_NG_RANnodeUEXnAPID_1);
+        out->t_ng_node_ue_xnap_id = ie->value.choice.NG_RANnodeUEXnAPID_1;
+      } break;
+
+      case XNAP_ProtocolIE_ID_id_PDUSessionResourcesAdmitted_List: {
+        _EQ_CHECK_INT(ie->value.present, XNAP_HandoverRequestAcknowledge_IEs__value_PR_PDUSessionResourcesAdmitted_List);
+
+        XNAP_PDUSessionResourcesAdmitted_List_t *pduList = &ie->value.choice.PDUSessionResourcesAdmitted_List;
+        out->num_pdu_admitted = pduList->list.count;
+
+        if (out->num_pdu_admitted > 0) {
+          out->pdusession_admitted_list = calloc_or_fail(out->num_pdu_admitted, sizeof(*out->pdusession_admitted_list));
+
+          for (int j = 0; j < out->num_pdu_admitted; j++) {
+            XNAP_PDUSessionResourcesAdmitted_Item_t *pduItem = pduList->list.array[j];
+            xnap_pdusession_admitted_item_t *dst = &out->pdusession_admitted_list[j];
+
+            /* PDU Session ID */
+            dst->pdusession_id = pduItem->pduSessionId;
+
+            /* QoS Flows Admitted List */
+            dst->num_qos = pduItem->pduSessionResourceAdmittedInfo.qosFlowsAdmitted_List.list.count;
+            if (dst->num_qos > 0) {
+              dst->qos_list = calloc_or_fail(dst->num_qos, sizeof(*dst->qos_list));
+
+              for (int k = 0; k < dst->num_qos; k++) {
+                XNAP_QoSFlowsAdmitted_Item_t *qosItem = pduItem->pduSessionResourceAdmittedInfo.qosFlowsAdmitted_List.list.array[k];
+                dst->qos_list[k].qfi = qosItem->qfi;
+              }
+            }
+          }
+        }
+      } break;
+
+      case XNAP_ProtocolIE_ID_id_Target2SourceNG_RANnodeTranspContainer: {
+        _EQ_CHECK_INT(ie->value.present, XNAP_HandoverRequestAcknowledge_IEs__value_PR_OCTET_STRING);
+        OCTET_STRING_t *container = &ie->value.choice.OCTET_STRING;
+        out->target2source = create_byte_array(container->size, container->buf);
+      } break;
+
+      default:
+        AssertError(0, return false, "Unknown XnAP IE id %ld\n", ie->id);
+        break;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * @brief Compare two QoS Flows Admitted items for equality
+ */
+static bool eq_xnap_qos_admitted_item(const xnap_qos_admitted_item_t *a, const xnap_qos_admitted_item_t *b)
+{
+  _EQ_CHECK_INT(a->qfi, b->qfi);
+  return true;
+}
+
+/**
+ * @brief Compare two PDU Session Resources Admitted items for equality
+ */
+static bool eq_xnap_pdusession_admitted_item(const xnap_pdusession_admitted_item_t *a, const xnap_pdusession_admitted_item_t *b)
+{
+  _EQ_CHECK_INT(a->pdusession_id, b->pdusession_id);
+
+  _EQ_CHECK_INT(a->num_qos, b->num_qos);
+  for (int i = 0; i < a->num_qos; i++) {
+    if (!eq_xnap_qos_admitted_item(&a->qos_list[i], &b->qos_list[i]))
+      return false;
+  }
+
+  return true;
+}
+
+/**
+ * @brief XnAP Handover Request Acknowledge equality function
+ **/
+bool eq_xnap_handover_request_acknowledge(const xnap_handover_req_ack_t *a, const xnap_handover_req_ack_t *b)
+{
+  _EQ_CHECK_UINT32(a->s_ng_node_ue_xnap_id, b->s_ng_node_ue_xnap_id);
+  _EQ_CHECK_UINT32(a->t_ng_node_ue_xnap_id, b->t_ng_node_ue_xnap_id);
+
+  _EQ_CHECK_INT(a->num_pdu_admitted, b->num_pdu_admitted);
+  for (int i = 0; i < a->num_pdu_admitted; i++) {
+    if (!eq_xnap_pdusession_admitted_item(&a->pdusession_admitted_list[i], &b->pdusession_admitted_list[i]))
+      return false;
+  }
+
+  if (!eq_byte_array(&a->target2source, &b->target2source))
+    return false;
+
+  return true;
+}
+
+/**
+ * @brief Free QoS Flows Admitted list
+ */
+static void free_xnap_qos_admitted_list(xnap_qos_admitted_item_t *qos_list)
+{
+  DevAssert(qos_list);
+
+  /* QoS admitted items have no dynamically allocated members */
+  free(qos_list);
+}
+
+/**
+ * @brief Free PDU Session Resources Admitted list
+ */
+static void free_xnap_pdusession_admitted_list(xnap_pdusession_admitted_item_t *pdu_list, uint8_t num_pdu)
+{
+  DevAssert(pdu_list && num_pdu > 0);
+
+  for (int i = 0; i < num_pdu; i++) {
+    free_xnap_qos_admitted_list(pdu_list[i].qos_list);
+  }
+  free(pdu_list);
+}
+
+/**
+ * @brief XnAP Handover Request Acknowledge memory management
+ */
+void free_xnap_handover_request_acknowledge(xnap_handover_req_ack_t *msg)
+{
+  if (!msg)
+    return;
+
+  /* Free PDU Session Resources Admitted List */
+  free_xnap_pdusession_admitted_list(msg->pdusession_admitted_list, msg->num_pdu_admitted);
+
+  /* Free Target to Source transparent container */
+  free_byte_array(msg->target2source);
+}

openair2/XNAP/lib/xnap_gNB_mobility_management.h

@@ -8,12 +8,16 @@
 #include "xnap_messages_types.h"
 typedef struct XNAP_XnAP_PDU XNAP_XnAP_PDU_t;
 
-XNAP_XnAP_PDU_t *encode_xnap_handover_request(xnap_handover_req_t *xnap_handover_req);
+XNAP_XnAP_PDU_t *encode_xnap_handover_request(const xnap_handover_req_t *xnap_handover_req);
+XNAP_XnAP_PDU_t *encode_xnap_handover_request_acknowledge(const xnap_handover_req_ack_t *xnap_handover_req_ack);
 
 bool decode_xnap_handover_request(xnap_handover_req_t *req, const XNAP_XnAP_PDU_t *pdu);
+bool decode_xnap_handover_request_acknowledge(xnap_handover_req_ack_t *out, const XNAP_XnAP_PDU_t *pdu);
 
 bool eq_xnap_handover_request(const xnap_handover_req_t *a, const xnap_handover_req_t *b);
+bool eq_xnap_handover_request_acknowledge(const xnap_handover_req_ack_t *a, const xnap_handover_req_ack_t *b);
 
-void free_xnap_handover_request(const xnap_handover_req_t *msg);
+void free_xnap_handover_request(xnap_handover_req_t *msg);
+void free_xnap_handover_request_acknowledge(xnap_handover_req_ack_t *msg);
 
 #endif // XNAP_GNB_MOBILITY_MANAGEMENT_H_

openair2/XNAP/lib/xnap_lib_includes.h

@@ -32,5 +32,8 @@
 #include "XNAP_AllocationandRetentionPriority.h"
 #include "XNAP_LastVisitedCell-Item.h"
 
+#include "XNAP_PDUSessionResourcesAdmitted-Item.h"
+#include "XNAP_QoSFlowsAdmitted-Item.h"
+
 #endif // XNAP_LIB_INCLUDES_H
 

openair2/XNAP/tests/xnap_lib_test.c

@@ -408,6 +408,91 @@ static void test_xn_handover_request(void)
   printf("%s() successful\n", __func__);
 }
 
+/**
+ * 5. Xn Handover Request Acknowledge
+ */
+static void test_xn_handover_request_acknowledge(void)
+{
+  /* ---------- create message ---------- */
+
+  /* Create QoS Flows Admitted List for first PDU session */
+  xnap_qos_admitted_item_t *qos_list_1 = calloc_or_fail(2, sizeof(xnap_qos_admitted_item_t));
+  qos_list_1[0].qfi = 5;
+  qos_list_1[1].qfi = 9;
+
+  /* Create QoS Flows Admitted List for second PDU session */
+  xnap_qos_admitted_item_t *qos_list_2 = calloc_or_fail(1, sizeof(xnap_qos_admitted_item_t));
+  qos_list_2[0].qfi = 1;
+
+  /* Create PDU Session Resources Admitted List */
+  xnap_pdusession_admitted_item_t *pdu_list = calloc_or_fail(2, sizeof(xnap_pdusession_admitted_item_t));
+  pdu_list[0].pdusession_id = 10;
+  pdu_list[0].num_qos = 2;
+  pdu_list[0].qos_list = qos_list_1;
+
+  pdu_list[1].pdusession_id = 15;
+  pdu_list[1].num_qos = 1;
+  pdu_list[1].qos_list = qos_list_2;
+
+  /* Create transparent container ( Dummy data for RRC HandoverCommand) */
+  uint8_t container_data[] = {
+      0x00,
+      0x01,
+      0x02,
+      0x03,
+      0x04,
+      0x05,
+      0x06,
+      0x07,
+      0x08,
+      0x09,
+      0x0a,
+      0x0b,
+      0x0c,
+      0x0d,
+      0x0e,
+      0x0f,
+  };
+
+  uint8_t *container_buf = malloc(sizeof(container_data));
+  memcpy(container_buf, container_data, sizeof(container_data));
+
+  xnap_handover_req_ack_t orig = {
+      .s_ng_node_ue_xnap_id = 123456,
+      .t_ng_node_ue_xnap_id = 789012,
+      .num_pdu_admitted = 2,
+      .pdusession_admitted_list = pdu_list,
+      .target2source =
+          {
+              .len = sizeof(container_data),
+              .buf = container_buf,
+          },
+  };
+
+  /* ---------- encode ---------- */
+  XNAP_XnAP_PDU_t *xnenc = encode_xnap_handover_request_acknowledge(&orig);
+  AssertFatal(xnenc != NULL, "encode_xnap_handover_request_acknowledge failed");
+
+  XNAP_XnAP_PDU_t *xndec = xnap_encode_decode(xnenc);
+  xnap_msg_free(xnenc);
+
+  /* ---------- decode ---------- */
+  xnap_handover_req_ack_t decoded = {0};
+  bool ret = decode_xnap_handover_request_acknowledge(&decoded, xndec);
+  AssertFatal(ret, "decode_xnap_handover_request_acknowledge failed");
+  xnap_msg_free(xndec);
+
+  /* ---------- equality ---------- */
+  ret = eq_xnap_handover_request_acknowledge(&orig, &decoded);
+  AssertFatal(ret, "XnAP Handover Request Acknowledge mismatch\n");
+
+  /* ---------- cleanup ---------- */
+  free_xnap_handover_request_acknowledge(&decoded);
+  free_xnap_handover_request_acknowledge(&orig);
+
+  printf("%s() successful \n", __func__);
+}
+
 int main() {
   printf("Starting XnAP Library Unit Tests...\n");
 
@@ -418,6 +503,7 @@ int main() {
 
   /* Xn Handover Testing*/
   test_xn_handover_request();
+  test_xn_handover_request_acknowledge();
 
   printf("All XnAP tests passed!\n");
   return 0;