Merge remote-tracking branch 'origin/e1-bearer-mod-failure' into integration_2025_w20 (!3384)

Add enc/dec library and unit test for E1 Bearer Context Modification Failure

This MR is adding:

- the enc/dec library
- unit test
- handler and callback in stack

For the E1 Bearer Context Modification Failure.

openair2/COMMON/e1ap_messages_def.h

@@ -44,6 +44,8 @@ MESSAGE_DEF(E1AP_BEARER_CONTEXT_SETUP_FAILURE , MESSAGE_PRIORITY_MED , e1ap_bear
 MESSAGE_DEF(E1AP_BEARER_CONTEXT_MODIFICATION_REQ , MESSAGE_PRIORITY_MED , e1ap_bearer_mod_req_t , e1ap_bearer_mod_req)
 /* E1AP Bearer Context Modification Response: gNB-CU-UP -> gNB-CU-CP */
 MESSAGE_DEF(E1AP_BEARER_CONTEXT_MODIFICATION_RESP, MESSAGE_PRIORITY_MED, e1ap_bearer_modif_resp_t, e1ap_bearer_modif_resp)
+/* E1AP Bearer Context Modification Failure: gNB-CU-UP -> gNB-CU-CP */
+MESSAGE_DEF(E1AP_BEARER_CONTEXT_MODIFICATION_FAIL, MESSAGE_PRIORITY_MED, e1ap_bearer_context_mod_failure_t, e1ap_bearer_modif_fail)
 /* E1AP Bearer Context Release Request: gNB-CU-CP -> gNB-CU-UP */
 MESSAGE_DEF(E1AP_BEARER_CONTEXT_RELEASE_CMD, MESSAGE_PRIORITY_MED, e1ap_bearer_release_cmd_t, e1ap_bearer_release_cmd)
 /* E1AP Bearer Context Release Response: gNB-CU-UP -> gNB-CU-CP */

openair2/COMMON/e1ap_messages_types.h

@@ -53,6 +53,7 @@
 #define E1AP_BEARER_CONTEXT_SETUP_FAILURE(mSGpTR)         (mSGpTR)->ittiMsg.e1ap_bearer_setup_fail
 #define E1AP_BEARER_CONTEXT_MODIFICATION_REQ(mSGpTR)      (mSGpTR)->ittiMsg.e1ap_bearer_mod_req
 #define E1AP_BEARER_CONTEXT_MODIFICATION_RESP(mSGpTR)     (mSGpTR)->ittiMsg.e1ap_bearer_modif_resp
+#define E1AP_BEARER_CONTEXT_MODIFICATION_FAIL(mSGpTR)     (mSGpTR)->ittiMsg.e1ap_bearer_modif_fail
 #define E1AP_BEARER_CONTEXT_RELEASE_CMD(mSGpTR)           (mSGpTR)->ittiMsg.e1ap_bearer_release_cmd
 #define E1AP_BEARER_CONTEXT_RELEASE_CPLT(mSGpTR)          (mSGpTR)->ittiMsg.e1ap_bearer_release_cplt
 #define E1AP_LOST_CONNECTION(mSGpTR)                      (mSGpTR)->ittiMsg.e1ap_lost_connection
@@ -625,5 +626,14 @@ typedef struct e1ap_lost_connection_t {
   int dummy;
 } e1ap_lost_connection_t;
 
+/// @brief 9.2.2.6 BEARER CONTEXT MODIFICATION FAILURE
+typedef struct e1ap_bearer_context_mod_failure_s {
+  // gNB-CU-CP UE E1AP ID (M)
+  uint32_t gNB_cu_cp_ue_id;
+  // gNB-CU-UP UE E1AP ID (M)
+  uint32_t gNB_cu_up_ue_id;
+  // NG-RAN PDU Session Resource Modified List (O)
+  e1ap_cause_t cause;
+} e1ap_bearer_context_mod_failure_t;
 
 #endif /* E1AP_MESSAGES_TYPES_H */

openair2/E1AP/e1ap.c

@@ -57,7 +57,7 @@ const e1ap_message_processing_t e1ap_message_processing[E1AP_NUM_MSG_HANDLERS][3
      e1apCUCP_handle_BEARER_CONTEXT_SETUP_FAILURE}, /* bearerContextSetup */
     {e1apCUUP_handle_BEARER_CONTEXT_MODIFICATION_REQUEST,
      e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_RESPONSE,
-     0}, /* bearerContextModification */
+     e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_FAILURE}, /* bearerContextModification */
     {0, 0, 0}, /* bearerContextModificationRequired */
     {e1apCUUP_handle_BEARER_CONTEXT_RELEASE_COMMAND, e1apCUCP_handle_BEARER_CONTEXT_RELEASE_COMPLETE, 0}, /* bearerContextRelease */
     {0, 0, 0}, /* bearerContextReleaseRequired */
@@ -451,10 +451,11 @@ static int e1apCUUP_send_BEARER_CONTEXT_MODIFICATION_RESPONSE(sctp_assoc_t assoc
   return e1ap_encode_send(UPtype, assoc_id, pdu, 0, __func__);
 }
 
-int e1apCUUP_send_BEARER_CONTEXT_MODIFICATION_FAILURE(instance_t instance)
+static int e1apCUUP_send_BEARER_CONTEXT_MODIFICATION_FAILURE(sctp_assoc_t assoc_id, const e1ap_bearer_context_mod_failure_t *out)
 {
-  AssertFatal(false, "Not implemented yet\n");
-  return -1;
+  E1AP_E1AP_PDU_t *pdu = encode_E1_bearer_context_mod_failure(out);
+  e1ap_encode_send(UPtype, assoc_id, pdu, 0, __func__);
+  return 0;
 }
 
 /**
@@ -490,13 +491,21 @@ int e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_RESPONSE(sctp_assoc_t assoc_id,
   return 0;
 }
 
-int e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_FAILURE(instance_t instance,
-                                                        sctp_assoc_t assoc_id,
-                                                        uint32_t stream,
-                                                        E1AP_E1AP_PDU_t *pdu)
+int e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_FAILURE(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst, const E1AP_E1AP_PDU_t *pdu)
 {
-  AssertFatal(false, "Not implemented yet\n");
-  return -1;
+  e1ap_bearer_context_mod_failure_t failure = {0};
+  if (!decode_E1_bearer_context_mod_failure(&failure, pdu)) {
+    free_E1_bearer_context_mod_failure(&failure);
+    return -1;
+  }
+  LOG_E(E1AP,
+        "Received Bearer Context Modification Failure from CU-UP %d with cause value %d \n",
+        failure.gNB_cu_up_ue_id,
+        failure.cause.value);
+  MessageDef *msg = itti_alloc_new_message(TASK_CUUP_E1, 0, E1AP_BEARER_CONTEXT_MODIFICATION_FAIL);
+  E1AP_BEARER_CONTEXT_MODIFICATION_FAIL(msg) = cp_E1_bearer_context_mod_failure(&failure);
+  itti_send_msg_to_task(TASK_RRC_GNB, 0, msg);
+  return 0;
 }
 
 int e1apCUUP_send_BEARER_CONTEXT_MODIFICATION_REQUIRED(instance_t instance)
@@ -928,6 +937,14 @@ void *E1AP_CUUP_task(void *arg)
         free_e1ap_context_mod_response(resp);
       } break;
 
+      case E1AP_BEARER_CONTEXT_MODIFICATION_FAIL: {
+        const e1ap_bearer_context_mod_failure_t *fail = &E1AP_BEARER_CONTEXT_MODIFICATION_FAIL(msg);
+        const e1ap_upcp_inst_t *inst = getCxtE1(myInstance);
+        AssertFatal(inst, "no E1 instance found for instance %ld\n", myInstance);
+        e1apCUUP_send_BEARER_CONTEXT_MODIFICATION_FAILURE(inst->cuup.assoc_id, fail);
+        free_E1_bearer_context_mod_failure(fail);
+      } break;
+
       case E1AP_BEARER_CONTEXT_RELEASE_CPLT: {
         const e1ap_bearer_release_cplt_t *cplt = &E1AP_BEARER_CONTEXT_RELEASE_CPLT(msg);
         const e1ap_upcp_inst_t *inst = getCxtE1(myInstance);

openair2/E1AP/e1ap.h

@@ -44,6 +44,8 @@ int e1apCUUP_handle_BEARER_CONTEXT_MODIFICATION_REQUEST(sctp_assoc_t assoc_id, e
 
 int e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_RESPONSE(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *e1_inst, const E1AP_E1AP_PDU_t *pdu);
 
+int e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_FAILURE(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst, const E1AP_E1AP_PDU_t *pdu);
+
 void e1apCUUP_send_BEARER_CONTEXT_SETUP_RESPONSE(sctp_assoc_t assoc_id, const e1ap_bearer_setup_resp_t *resp);
 
 int e1apCUUP_handle_BEARER_CONTEXT_RELEASE_COMMAND(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst, const E1AP_E1AP_PDU_t *pdu);

openair2/E1AP/lib/e1ap_bearer_context_management.c

@@ -2434,3 +2434,101 @@ void free_e1ap_context_mod_response(const e1ap_bearer_modif_resp_t *msg)
     free(msg->pduSessionMod[i].ng_DL_UP_TL_info);
   }
 }
+
+/* ===========================================
+ *   E1AP Bearer Context Modification Failure
+ * ============================================ */
+
+/** @brief Bearer Context Modification Failure encoding (9.2.2.6 38.463)
+ *         gNB-CU-UP → gNB-CU-CP */
+struct E1AP_E1AP_PDU *encode_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg)
+{
+  E1AP_E1AP_PDU_t *pdu = calloc_or_fail(1, sizeof(*pdu));
+  pdu->present = E1AP_E1AP_PDU_PR_unsuccessfulOutcome;
+  asn1cCalloc(pdu->choice.unsuccessfulOutcome, type);
+  type->procedureCode = E1AP_ProcedureCode_id_bearerContextModification;
+  type->criticality = E1AP_Criticality_reject;
+  type->value.present = E1AP_UnsuccessfulOutcome__value_PR_BearerContextModificationFailure;
+  E1AP_BearerContextModificationFailure_t *out = &type->value.choice.BearerContextModificationFailure;
+  // gNB-CU-CP UE E1AP ID (M)
+  asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextModificationFailureIEs_t, ie1);
+  ie1->id = E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID;
+  ie1->criticality = E1AP_Criticality_reject;
+  ie1->value.present = E1AP_BearerContextModificationFailureIEs__value_PR_GNB_CU_CP_UE_E1AP_ID;
+  ie1->value.choice.GNB_CU_CP_UE_E1AP_ID = msg->gNB_cu_cp_ue_id;
+  // gNB-CU-UP UE E1AP ID (M)
+  asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextModificationFailureIEs_t, ie2);
+  ie2->id = E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID;
+  ie2->criticality = E1AP_Criticality_reject;
+  ie2->value.present = E1AP_BearerContextModificationFailureIEs__value_PR_GNB_CU_UP_UE_E1AP_ID;
+  ie2->value.choice.GNB_CU_UP_UE_E1AP_ID = msg->gNB_cu_up_ue_id;
+  // Cause (M)
+  asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextModificationFailureIEs_t, ie3);
+  ie3->id = E1AP_ProtocolIE_ID_id_Cause;
+  ie3->criticality = E1AP_Criticality_reject;
+  ie3->value.present = E1AP_BearerContextModificationFailureIEs__value_PR_Cause;
+  ie3->value.choice.Cause = e1_encode_cause_ie(&msg->cause);
+  return pdu;
+}
+
+/** @brief Bearer Context Modification Failure decoding (9.2.2.6 38.463)
+ *         gNB-CU-UP → gNB-CU-CP */
+bool decode_E1_bearer_context_mod_failure(e1ap_bearer_context_mod_failure_t *out, const E1AP_E1AP_PDU_t *pdu)
+{
+  DevAssert(pdu != NULL);
+  _E1_EQ_CHECK_INT(pdu->present, E1AP_E1AP_PDU_PR_unsuccessfulOutcome);
+  E1AP_UnsuccessfulOutcome_t *type = pdu->choice.unsuccessfulOutcome;
+  _E1_EQ_CHECK_LONG(type->procedureCode, E1AP_ProcedureCode_id_bearerContextModification);
+  _E1_EQ_CHECK_INT(type->value.present, E1AP_UnsuccessfulOutcome__value_PR_BearerContextModificationFailure);
+  const E1AP_BearerContextModificationFailure_t *in = &type->value.choice.BearerContextModificationFailure;
+  // Check mandatory IEs first
+  E1AP_BearerContextModificationFailureIEs_t *ie;
+  E1AP_LIB_FIND_IE(E1AP_BearerContextModificationFailureIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID, true);
+  E1AP_LIB_FIND_IE(E1AP_BearerContextModificationFailureIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID, true);
+  E1AP_LIB_FIND_IE(E1AP_BearerContextModificationFailureIEs_t, ie, in, E1AP_ProtocolIE_ID_id_Cause, true);
+  for (int i = 0; i < in->protocolIEs.list.count; i++) {
+    ie = in->protocolIEs.list.array[i];
+    AssertFatal(ie != NULL, "in->protocolIEs.list.array[i] shall not be null");
+    switch (ie->id) {
+      case E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID:
+        out->gNB_cu_cp_ue_id = ie->value.choice.GNB_CU_CP_UE_E1AP_ID;
+        break;
+      case E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID:
+        out->gNB_cu_up_ue_id = ie->value.choice.GNB_CU_UP_UE_E1AP_ID;
+        break;
+      case E1AP_ProtocolIE_ID_id_Cause:
+        out->cause = e1_decode_cause_ie(&ie->value.choice.Cause);
+        break;
+      default:
+        PRINT_ERROR("Invalid or unhandled optional IE (%ld) in Bearer Context Modification Failure message\n", ie->id);
+        break;
+    }
+  }
+  return true;
+}
+
+/** @brief E1AP Bearer Context Modification Failure: deep copy */
+e1ap_bearer_context_mod_failure_t cp_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg)
+{
+  e1ap_bearer_context_mod_failure_t cp = {0};
+  cp = *msg;
+  return cp;
+}
+
+/** @brief E1AP Bearer Context Modification Failure: equality check */
+bool eq_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *a, const e1ap_bearer_context_mod_failure_t *b)
+{
+  if (!a || !b)
+    return false; // Null-check both inputs
+  _E1_EQ_CHECK_INT(a->gNB_cu_cp_ue_id, b->gNB_cu_cp_ue_id);
+  _E1_EQ_CHECK_INT(a->gNB_cu_up_ue_id, b->gNB_cu_up_ue_id);
+  _E1_EQ_CHECK_INT(a->cause.type, b->cause.type);
+  _E1_EQ_CHECK_INT(a->cause.value, b->cause.value);
+  return true;
+}
+
+/** @brief E1AP Bearer Context Modification Failure: free */
+void free_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg)
+{
+  // do nothing
+}

openair2/E1AP/lib/e1ap_bearer_context_management.h

@@ -70,4 +70,10 @@ void free_e1ap_context_mod_response(const e1ap_bearer_modif_resp_t *msg);
 e1ap_bearer_modif_resp_t cp_bearer_context_mod_response(const e1ap_bearer_modif_resp_t *msg);
 bool eq_bearer_context_mod_response(const e1ap_bearer_modif_resp_t *a, const e1ap_bearer_modif_resp_t *b);
 
+struct E1AP_E1AP_PDU *encode_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg);
+bool decode_E1_bearer_context_mod_failure(e1ap_bearer_context_mod_failure_t *out, const struct E1AP_E1AP_PDU *pdu);
+void free_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg);
+e1ap_bearer_context_mod_failure_t cp_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg);
+bool eq_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *a, const e1ap_bearer_context_mod_failure_t *b);
+
 #endif /* E1AP_BEARER_CONTEXT_MANAGEMENT_H_ */

openair2/E1AP/tests/e1ap_lib_test.c

@@ -740,6 +740,49 @@ static void test_bearer_context_modification_response_fail(void)
   free_e1ap_context_mod_response(&orig);
 }
 
+/** @brief Test E1AP Bearer Context Modification Failure encoding/decoding */
+static void test_bearer_context_modification_failure(void)
+{
+  // Create the original failure struct
+  e1ap_bearer_context_mod_failure_t orig = {
+      .gNB_cu_cp_ue_id = 0x1111,
+      .gNB_cu_up_ue_id = 0x2222,
+      .cause.type = E1AP_CAUSE_TRANSPORT,
+      .cause.value = E1AP_TRANSPORT_CAUSE_RESOURCE_UNAVAILABLE,
+  };
+
+  // Encode the original message
+  E1AP_E1AP_PDU_t *enc = encode_E1_bearer_context_mod_failure(&orig);
+
+  // Decode the encoded message
+  E1AP_E1AP_PDU_t *dec = e1ap_encode_decode(enc);
+
+  // Free the encoded message
+  e1ap_msg_free(enc);
+
+  // Decode into a new struct
+  e1ap_bearer_context_mod_failure_t decoded = {0};
+  AssertFatal(decode_E1_bearer_context_mod_failure(&decoded, dec),
+              "decode_E1_bearer_context_mod_failure(): could not decode message\n");
+
+  // Free the decoded PDU
+  e1ap_msg_free(dec);
+
+  // Compare original and decoded messages
+  AssertFatal(eq_E1_bearer_context_mod_failure(&orig, &decoded),
+              "eq_E1_bearer_context_mod_failure(): decoded message doesn't match\n");
+
+  // Deep copy the original message
+  e1ap_bearer_context_mod_failure_t cp = cp_E1_bearer_context_mod_failure(&orig);
+
+  // Compare original and copied messages
+  AssertFatal(eq_E1_bearer_context_mod_failure(&orig, &cp), "eq_E1_bearer_context_mod_failure(): copied message doesn't match\n");
+
+  // Free the decoded and copied messages
+  free_E1_bearer_context_mod_failure(&decoded);
+  free_E1_bearer_context_mod_failure(&cp);
+}
+
 int main()
 {
   // E1 Bearer Context Setup
@@ -750,10 +793,11 @@ int main()
   test_e1_cuup_setup_request();
   test_e1_cuup_setup_response();
   test_e1_cuup_setup_failure();
-  // E1 Bearer Context Modification Request
+  // E1 Bearer Context Modification
   test_bearer_context_modification_request();
   test_bearer_context_modification_response();
   test_bearer_context_modification_response_fail();
+  test_bearer_context_modification_failure();
   // Bearer Context Release
   test_bearer_context_release_command();
   test_bearer_context_release_complete();

openair2/RRC/NR/rrc_gNB.c

@@ -2582,6 +2582,23 @@ void rrc_gNB_process_e1_bearer_context_modif_resp(const e1ap_bearer_modif_resp_t
   }
 }
 
+/** @brief E1AP Bearer Context Modification Failure processing on CU-CP */
+static void rrc_gNB_process_e1_bearer_context_modif_fail(const e1ap_bearer_context_mod_failure_t *fail)
+{
+  gNB_RRC_INST *rrc = RC.nrrrc[0];
+  rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context(rrc, fail->gNB_cu_cp_ue_id);
+  if (ue_context_p == NULL) {
+    LOG_E(NR_RRC, "No UE with CU-CP UE ID %d found (Bearer Context Modification Failure)\n", fail->gNB_cu_cp_ue_id);
+    return;
+  }
+
+  LOG_W(NR_RRC,
+        "Bearer Context Modification Failure received for UE ID %d (CU-UP ID %d), cause: %d\n",
+        fail->gNB_cu_cp_ue_id,
+        fail->gNB_cu_up_ue_id,
+        fail->cause.value);
+}
+
 /**
  * @brief E1AP Bearer Context Release processing
  */
@@ -2886,6 +2903,10 @@ void *rrc_gnb_task(void *args_p) {
         free_e1ap_context_mod_response(&E1AP_BEARER_CONTEXT_MODIFICATION_RESP(msg_p));
         break;
 
+      case E1AP_BEARER_CONTEXT_MODIFICATION_FAIL:
+        rrc_gNB_process_e1_bearer_context_modif_fail(&E1AP_BEARER_CONTEXT_MODIFICATION_FAIL(msg_p));
+        break;
+
       case E1AP_BEARER_CONTEXT_RELEASE_CPLT:
         rrc_gNB_process_e1_bearer_context_release_cplt(&E1AP_BEARER_CONTEXT_RELEASE_CPLT(msg_p));
         break;