e2: add e2 connection update procedure, that sends failure

Author: Piotr Gawlowicz

lib/e2/CMakeLists.txt

@@ -12,6 +12,7 @@ set(SOURCES
     procedures/e2_subscription_delete_procedure.cpp
     procedures/e2_indication_procedure.cpp
     procedures/e2_ric_control_procedure.cpp
+    procedures/e2_connection_update_procedure.cpp
     common/e2_connection_handler.cpp
     common/e2ap_asn1_packer.cpp
     common/e2_factory.cpp

lib/e2/common/e2_impl.cpp

@@ -10,6 +10,7 @@
 
 #include "e2_impl.h"
 #include "e2ap_asn1_helpers.h"
+#include "procedures/e2_connection_update_procedure.h"
 #include "srsran/asn1/e2ap/e2ap.h"
 #include "srsran/e2/e2.h"
 #include "srsran/ran/nr_cgi.h"
@@ -152,6 +153,12 @@ void e2_impl::handle_ric_subscription_delete_request(const asn1::e2ap::ric_sub_d
       msg, *events, *tx_pdu_notifier, subscription_proc, timers, logger));
 }
 
+void e2_impl::handle_e2_connection_update(const asn1::e2ap::e2conn_upd_s& msg)
+{
+  logger.info("Received E2 Connection Update");
+  async_tasks.schedule(launch_async<e2_connection_update_procedure>(msg, *tx_pdu_notifier, timers, logger));
+}
+
 void e2_impl::handle_message(const e2_message& msg)
 {
   logger.info("Handling E2 PDU of type {}", msg.pdu.type().to_string());
@@ -195,6 +202,9 @@ void e2_impl::handle_initiating_message(const asn1::e2ap::init_msg_s& msg)
     case asn1::e2ap::e2ap_elem_procs_o::init_msg_c::types_opts::options::ric_ctrl_request:
       handle_ric_control_request(msg.value.ric_ctrl_request());
       break;
+    case asn1::e2ap::e2ap_elem_procs_o::init_msg_c::types_opts::options::e2conn_upd:
+      handle_e2_connection_update(msg.value.e2conn_upd());
+      break;
     default:
       logger.error("Invalid E2AP initiating message type");
       break;

lib/e2/common/e2_impl.h

@@ -85,6 +85,10 @@ class e2_impl final : public e2_interface
   /// \param[in] msg The received ric subscription delete request message.
   void handle_ric_subscription_delete_request(const asn1::e2ap::ric_sub_delete_request_s& msg);
 
+  /// \brief Notify about the reception of a E2 Connection Update message.
+  /// \param[in] msg The received E2 Connection Update message.
+  void handle_e2_connection_update(const asn1::e2ap::e2conn_upd_s& msg);
+
   /// \brief handle e2 setup response message from the ric interface.
   /// @param[in] msg  The received e2 setup response message.
   void handle_e2_setup_response(const e2_setup_response_message& msg);

lib/e2/procedures/e2_connection_update_procedure.cpp

@@ -0,0 +1,55 @@
+/*
+ *
+ * Copyright 2021-2025 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#include "e2_connection_update_procedure.h"
+using namespace srsran;
+using namespace asn1::e2ap;
+
+e2_connection_update_procedure::e2_connection_update_procedure(const e2conn_upd_s&   request_,
+                                                               e2_message_notifier&  ric_notif_,
+                                                               timer_factory         timers_,
+                                                               srslog::basic_logger& logger_) :
+  request(request_), logger(logger_), ric_notif(ric_notif_), timers(timers_)
+{
+}
+
+void e2_connection_update_procedure::operator()(coro_context<async_task<void>>& ctx)
+{
+  logger.info("E2AP: Received E2 Connection Update");
+  CORO_BEGIN(ctx);
+  logger.debug("\"{}\" initialized", name());
+
+  // E2 Connection Update not implemented -> always send failure.
+  send_e2_connection_update_failure();
+
+  logger.debug("\"{}\" finalized", name());
+  CORO_RETURN();
+}
+
+void e2_connection_update_procedure::send_e2_connection_update_ack()
+{
+  logger.info("E2AP: Sending E2 Connection Update Ack");
+  e2_message msg;
+  msg.pdu.set_successful_outcome().load_info_obj(ASN1_E2AP_ID_E2CONN_UPD);
+  msg.pdu.successful_outcome().value.e2conn_upd_ack()->transaction_id = request->transaction_id;
+  ric_notif.on_new_message(msg);
+}
+
+void e2_connection_update_procedure::send_e2_connection_update_failure()
+{
+  logger.info("E2AP: Sending E2 Connection Update Failure");
+  e2_message msg;
+  msg.pdu.set_unsuccessful_outcome().load_info_obj(ASN1_E2AP_ID_E2CONN_UPD);
+  msg.pdu.unsuccessful_outcome().value.e2conn_upd_fail()->transaction_id = request->transaction_id;
+  msg.pdu.unsuccessful_outcome().value.e2conn_upd_fail()->cause_present  = true;
+  msg.pdu.unsuccessful_outcome().value.e2conn_upd_fail()->cause.set_transport() =
+      cause_transport_e::transport_res_unavailable;
+  ric_notif.on_new_message(msg);
+}

lib/e2/procedures/e2_connection_update_procedure.h

@@ -0,0 +1,44 @@
+/*
+ *
+ * Copyright 2021-2025 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#pragma once
+
+#include "srsran/asn1/e2ap/e2ap.h"
+#include "srsran/e2/e2.h"
+#include "srsran/e2/e2_event_manager.h"
+#include "srsran/support/async/async_task.h"
+#include "srsran/support/timers.h"
+
+namespace srsran {
+
+class e2_connection_update_procedure
+{
+public:
+  e2_connection_update_procedure(const asn1::e2ap::e2conn_upd_s& request_,
+                                 e2_message_notifier&            ric_notif_,
+                                 timer_factory                   timers_,
+                                 srslog::basic_logger&           logger_);
+
+  void operator()(coro_context<async_task<void>>& ctx);
+
+  static const char* name() { return "E2 Connection Update Procedure"; }
+
+private:
+  // results senders
+  void send_e2_connection_update_ack();
+  void send_e2_connection_update_failure();
+
+  const asn1::e2ap::e2conn_upd_s request;
+  srslog::basic_logger&          logger;
+  e2_message_notifier&           ric_notif;
+  timer_factory                  timers;
+};
+
+} // namespace srsran

tests/unittests/e2/CMakeLists.txt

@@ -53,3 +53,8 @@ add_executable(e2sm_kpm_test e2sm_kpm_test.cpp)
 target_link_libraries(e2sm_kpm_test srslog srsran_network srsran_e2 e2ap_asn1 srsran_pcap srsran_gateway srsran_support gtest gtest_main)
 target_include_directories(e2sm_kpm_test PRIVATE ${CMAKE_SOURCE_DIR})
 gtest_discover_tests(e2sm_kpm_test)
+
+add_executable(e2_conn_upd_procedure_test e2_conn_upd_procedure_test.cpp)
+target_link_libraries(e2_conn_upd_procedure_test srslog srsran_network srsran_e2 e2ap_asn1 srsran_pcap srsran_gateway srsran_support gtest gtest_main)
+target_include_directories(e2_conn_upd_procedure_test PRIVATE ${CMAKE_SOURCE_DIR})
+gtest_discover_tests(e2_conn_upd_procedure_test)

tests/unittests/e2/common/e2_test_helpers.h

@@ -583,6 +583,16 @@ inline e2_message generate_e2_setup_response(unsigned transaction_id)
   setup->ran_functions_accepted.push_back(ran_func_item);
   setup->global_ric_id.plmn_id.from_number(131014);
   setup->global_ric_id.ric_id.from_number(699598);
+  // fill the required part with dummy data
+  setup->e2node_component_cfg_addition_ack.resize(1);
+  asn1::e2ap::e2node_component_cfg_addition_ack_item_s& e2node_component_cfg_addition_ack_item =
+      setup->e2node_component_cfg_addition_ack[0].value().e2node_component_cfg_addition_ack_item();
+  e2node_component_cfg_addition_ack_item.e2node_component_interface_type =
+      asn1::e2ap::e2node_component_interface_type_e::e2node_component_interface_type_opts::e1;
+  e2node_component_cfg_addition_ack_item.e2node_component_id.set_e2node_component_interface_type_e1().gnb_cu_up_id =
+      123;
+  e2node_component_cfg_addition_ack_item.e2node_component_cfg_ack.upd_outcome =
+      asn1::e2ap::e2node_component_cfg_ack_s::upd_outcome_opts::success;
   return e2_setup_response;
 }
 

tests/unittests/e2/e2_conn_upd_procedure_test.cpp

@@ -0,0 +1,154 @@
+/*
+ *
+ * Copyright 2021-2025 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#include "lib/e2/common/e2ap_asn1_packer.h"
+#include "lib/e2/e2sm/e2sm_kpm/e2sm_kpm_cu_meas_provider_impl.h"
+#include "lib/e2/e2sm/e2sm_kpm/e2sm_kpm_du_meas_provider_impl.h"
+#include "tests/unittests/e2/common/e2_test_helpers.h"
+#include "srsran/support/executors/task_worker.h"
+#include "srsran/support/srsran_test.h"
+#include <gtest/gtest.h>
+
+using namespace srsran;
+
+// Helper global variables to pass pcap_writer to all tests.
+bool      g_enable_pcap = false;
+dlt_pcap* g_pcap        = nullptr;
+
+class e2_agent_test_with_pcap : public e2_test_base_with_pcap
+{
+protected:
+  dlt_pcap* external_pcap_writer;
+
+  void SetUp() override
+  {
+    external_pcap_writer = GetParam();
+
+    srslog::fetch_basic_logger("TEST").set_level(srslog::basic_levels::debug);
+    srslog::init();
+
+    cfg                  = config_helpers::make_default_e2ap_config();
+    cfg.e2sm_kpm_enabled = true;
+
+    gw   = std::make_unique<dummy_network_gateway_data_handler>();
+    pcap = std::make_unique<dummy_e2ap_pcap>();
+    if (external_pcap_writer) {
+      packer = std::make_unique<srsran::e2ap_asn1_packer>(*gw, *e2, *external_pcap_writer);
+    } else {
+      packer = std::make_unique<srsran::e2ap_asn1_packer>(*gw, *e2, *pcap);
+    }
+    e2_client                = std::make_unique<dummy_e2_connection_client>();
+    du_metrics               = std::make_unique<dummy_e2_du_metrics>();
+    f1ap_ue_id_mapper        = std::make_unique<dummy_f1ap_ue_id_translator>();
+    factory                  = timer_factory{timers, task_worker};
+    du_rc_param_configurator = std::make_unique<dummy_du_configurator>();
+    e2agent                  = create_e2_du_agent(cfg,
+                                 *e2_client,
+                                 du_metrics.get(),
+                                 f1ap_ue_id_mapper.get(),
+                                 du_rc_param_configurator.get(),
+                                 factory,
+                                 task_worker);
+  }
+
+  void TearDown() override
+  {
+    // flush logger after each test
+    srslog::flush();
+    pcap->close();
+  }
+};
+
+TEST_P(e2_agent_test_with_pcap, e2_connection_update_failure)
+{
+  // We need this test to generate E2 Setup Request, so Wireshark can decode the following RIC indication messages.
+  test_logger.info("Launch e2 setup request procedure with task worker...");
+  e2agent->start();
+
+  if (g_enable_pcap) {
+    // Save E2 Setup Request
+    packer->handle_message(e2_client->last_tx_e2_pdu);
+  }
+
+  // Need to send setup response, so the transaction can be completed.
+  unsigned   transaction_id    = get_transaction_id(e2_client->last_tx_e2_pdu.pdu).value();
+  e2_message e2_setup_response = generate_e2_setup_response(transaction_id);
+  e2_setup_response.pdu.successful_outcome()
+      .value.e2setup_resp()
+      ->ran_functions_accepted[0]
+      ->ran_function_id_item()
+      .ran_function_id = e2sm_kpm_asn1_packer::ran_func_id;
+  test_logger.info("Injecting E2SetupResponse");
+
+  if (g_enable_pcap) {
+    // Save E2 Setup Request (send to pcap)
+    packer->handle_message(e2_setup_response);
+  }
+  e2agent->get_e2_interface().handle_message(e2_setup_response);
+
+  // Inject packed E2 Connection Update.
+  uint8_t     e2_conn_upd[]   = {0x00, 0x0b, 0x00, 0x1b, 0x00, 0x00, 0x02, 0x00, 0x31, 0x00, 0x02,
+                                 0x00, 0x03, 0x00, 0x2c, 0x00, 0x0e, 0x00, 0x00, 0x2b, 0x40, 0x09,
+                                 0x21, 0xf0, 0x0a, 0x2a, 0x00, 0x61, 0x8e, 0x45, 0x40};
+  byte_buffer e2_conn_upd_buf = byte_buffer::create(e2_conn_upd, e2_conn_upd + sizeof(e2_conn_upd)).value();
+
+  asn1::cbit_ref bref(e2_conn_upd_buf);
+  e2_message     e2_conn_upd_msg = {};
+  if (e2_conn_upd_msg.pdu.unpack(bref) != asn1::SRSASN_SUCCESS) {
+    return;
+  }
+  if (g_enable_pcap) {
+    // Save E2 Setup Request (send to pcap)
+    packer->handle_message(e2_conn_upd_msg);
+  }
+  e2agent->get_e2_interface().handle_message(e2_conn_upd_msg);
+
+  e2_message& msg = e2_client->last_tx_e2_pdu;
+  if (g_enable_pcap) {
+    // Save E2 Setup Request (send to pcap)
+    packer->handle_message(msg);
+  }
+
+  // Currently, E2 Connection Update is not implemented, so always return failure.
+  ASSERT_EQ(msg.pdu.type().value, asn1::e2ap::e2ap_pdu_c::types_opts::unsuccessful_outcome);
+  ASSERT_EQ(msg.pdu.unsuccessful_outcome().value.type().value,
+            asn1::e2ap::e2ap_elem_procs_o::unsuccessful_outcome_c::types_opts::e2conn_upd_fail);
+  e2agent->stop();
+}
+
+INSTANTIATE_TEST_SUITE_P(e2_agent_test_with_pcap, e2_agent_test_with_pcap, testing::Values(g_pcap));
+
+int main(int argc, char** argv)
+{
+  // Check for '--enable_pcap' cmd line argument, do not use getopt as it interferes with gtest.
+  for (int i = 1; i < argc; ++i) {
+    std::string arg = argv[i];
+    if (arg == "--enable_pcap") {
+      g_enable_pcap = true;
+    }
+  }
+
+  srslog::init();
+
+  std::unique_ptr<task_worker_executor> pcap_exec;
+  std::unique_ptr<task_worker>          pcap_worker;
+  std::unique_ptr<dlt_pcap>             common_pcap_writer;
+
+  if (g_enable_pcap) {
+    pcap_worker        = std::make_unique<task_worker>("pcap_worker", 128);
+    pcap_exec          = std::make_unique<task_worker_executor>(*pcap_worker);
+    common_pcap_writer = create_e2ap_pcap("/tmp/e2_conn_upd_test.pcap", *pcap_exec);
+    g_pcap             = common_pcap_writer.get();
+  }
+
+  ::testing::InitGoogleTest(&argc, argv);
+  int ret = RUN_ALL_TESTS();
+  return ret;
+}