Merge remote-tracking branch 'origin/e1-setup-encdec-tests' into integration_2025_w04 (!3152)

E1 Setup enc/dec library and unit test

This MR is adding a library for E1 Setup enc/dec functions:

- E1 CU-UP Setup Request
- E1 CU-UP Setup Response
- E1 Setup Failure

and relevant unit tests

openair2/COMMON/e1ap_messages_def.h

@@ -26,11 +26,11 @@ MESSAGE_DEF(E1AP_REGISTER_REQ, MESSAGE_PRIORITY_MED, e1ap_register_req_t, e1ap_r
 MESSAGE_DEF(E1AP_LOST_CONNECTION, MESSAGE_PRIORITY_MED, e1ap_lost_connection_t, e1ap_lost_connection)
 
 /* E1AP Interface Management Messages */
-/* E1AP Setup Request: gNB-CU-UP -> gNB-CU-CP */
+/* GNB-CU-UP E1 Setup Request: gNB-CU-UP -> gNB-CU-CP */
 MESSAGE_DEF(E1AP_SETUP_REQ  , MESSAGE_PRIORITY_MED , e1ap_setup_req_t , e1ap_setup_req)
-/* E1AP Setup Response: gNB-CU-CP -> gNB-CU-UP */
+/* GNB-CU-UP E1 Setup Response: gNB-CU-CP -> gNB-CU-UP */
 MESSAGE_DEF(E1AP_SETUP_RESP , MESSAGE_PRIORITY_MED, e1ap_setup_resp_t , e1ap_setup_resp)
-/* E1AP Setup Failure: gNB-CU-CP -> gNB-CU-UP */
+/* GNB-CU-UP E1 Setup Failure: gNB-CU-CP -> gNB-CU-UP */
 MESSAGE_DEF(E1AP_SETUP_FAIL, MESSAGE_PRIORITY_MED, e1ap_setup_fail_t, e1ap_setup_fail)
 
 /* E1AP Bearer Context Management Procedures */

openair2/COMMON/e1ap_messages_types.h

@@ -40,6 +40,9 @@
 #define E1AP_MAX_NUM_DRBS 32
 #define E1AP_MAX_NUM_UP_PARAM 4
 #define E1AP_SECURITY_KEY_SIZE 16 // keys have 128 bits length
+#define E1AP_MAX_TL_ADDRESSES 16
+#define E1AP_MAX_GTP_TL_ADDRESSES 16
+#define E1AP_MAX_NUM_ERRORS 256
 
 #define E1AP_REGISTER_REQ(mSGpTR)                         (mSGpTR)->ittiMsg.e1ap_register_req
 #define E1AP_SETUP_REQ(mSGpTR)                            (mSGpTR)->ittiMsg.e1ap_setup_req
@@ -55,6 +58,80 @@
 
 typedef net_ip_address_t e1ap_net_ip_address_t;
 
+typedef enum {
+    E1AP_RADIO_CAUSE_UNSPECIFIED = 0,
+    E1AP_RADIO_CAUSE_UNKNOWN_ALREADY_ALLOCATED_GNB_CU_CP_UE_E1AP_ID,
+    E1AP_RADIO_CAUSE_UNKNOWN_ALREADY_ALLOCATED_GNB_CU_UP_UE_E1AP_ID,
+    E1AP_RADIO_CAUSE_UNKNOWN_INCONSISTENT_PAIR_UE_E1AP_ID,
+    E1AP_RADIO_CAUSE_INTERACTION_WITH_OTHER_PROCEDURE,
+    E1AP_RADIO_CAUSE_PDCP_COUNT_WRAP_AROUND,
+    E1AP_RADIO_CAUSE_UNSUPPORTED_QCI_VALUE,
+    E1AP_RADIO_CAUSE_UNSUPPORTED_5QI_VALUE,
+    E1AP_RADIO_CAUSE_ENCRYPTION_ALGORITHMS_NOT_SUPPORTED,
+    E1AP_RADIO_CAUSE_INTEGRITY_PROTECTION_ALGORITHMS_NOT_SUPPORTED,
+    E1AP_RADIO_CAUSE_UP_INTEGRITY_PROTECTION_NOT_POSSIBLE,
+    E1AP_RADIO_CAUSE_UP_CONFIDENTIALITY_PROTECTION_NOT_POSSIBLE,
+    E1AP_RADIO_CAUSE_MULTIPLE_PDU_SESSION_ID_INSTANCES,
+    E1AP_RADIO_CAUSE_UNKNOWN_PDU_SESSION_ID,
+    E1AP_RADIO_CAUSE_MULTIPLE_QOS_FLOW_ID_INSTANCES,
+    E1AP_RADIO_CAUSE_UNKNOWN_QOS_FLOW_ID,
+    E1AP_RADIO_CAUSE_MULTIPLE_DRB_ID_INSTANCES,
+    E1AP_RADIO_CAUSE_UNKNOWN_DRB_ID,
+    E1AP_RADIO_CAUSE_INVALID_QOS_COMBINATION,
+    E1AP_RADIO_CAUSE_PROCEDURE_CANCELLED,
+    E1AP_RADIO_CAUSE_NORMAL_RELEASE,
+    E1AP_RADIO_CAUSE_NO_RADIO_RESOURCES_AVAILABLE,
+    E1AP_RADIO_CAUSE_ACTION_DESIRABLE_FOR_RADIO_REASONS,
+    E1AP_RADIO_CAUSE_RESOURCES_NOT_AVAILABLE_FOR_SLICE,
+    E1AP_RADIO_CAUSE_PDCP_CONFIG_NOT_SUPPORTED,
+    E1AP_RADIO_CAUSE_UE_DL_MAX_INTEGRITY_PROTECTED_DATA_RATE_REASON,
+    E1AP_RADIO_CAUSE_UP_INTEGRITY_PROTECTION_FAILURE,
+    E1AP_RADIO_CAUSE_RELEASE_DUE_TO_PREEMPTION,
+    E1AP_RADIO_CAUSE_RSN_NOT_AVAILABLE_FOR_UP,
+    E1AP_RADIO_CAUSE_NPN_NOT_SUPPORTED,
+    E1AP_RADIO_CAUSE_OTHER
+} e1ap_cause_radio_t;
+
+typedef enum {
+    E1AP_TRANSPORT_CAUSE_UNSPECIFIED = 0,
+    E1AP_TRANSPORT_CAUSE_RESOURCE_UNAVAILABLE,
+    E1AP_TRANSPORT_CAUSE_UNKNOWN_TNL_ADDRESS_FOR_IAB,
+    E1AP_TRANSPORT_CAUSE_OTHER
+} e1ap_cause_transport_t;
+
+typedef enum {
+    E1AP_PROTOCOL_CAUSE_TRANSFER_SYNTAX_ERROR = 0,
+    E1AP_PROTOCOL_CAUSE_ABSTRACT_SYNTAX_ERROR_REJECT,
+    E1AP_PROTOCOL_CAUSE_ABSTRACT_SYNTAX_ERROR_IGNORE_NOTIFY,
+    E1AP_PROTOCOL_CAUSE_MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE,
+    E1AP_PROTOCOL_CAUSE_SEMANTIC_ERROR,
+    E1AP_PROTOCOL_CAUSE_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE,
+    E1AP_PROTOCOL_CAUSE_UNSPECIFIED,
+    E1AP_PROTOCOL_CAUSE_OTHER
+} e1ap_cause_protocol_t;
+
+typedef enum {
+    E1AP_MISC_CAUSE_CONTROL_PROCESSING_OVERLOAD,
+    E1AP_MISC_CAUSE_NOT_ENOUGH_USER_PLANE_PROCESSING_RESOURCES,
+    E1AP_MISC_CAUSE_HARDWARE_FAILURE,
+    E1AP_MISC_CAUSE_OM_INTERVENTION,
+    E1AP_MISC_CAUSE_UNSPECIFIED,
+    E1AP_MISC_CAUSE_OTHER
+} e1ap_cause_misc_t;
+
+typedef enum e1ap_cause_group_e {
+  E1AP_CAUSE_NOTHING,
+  E1AP_CAUSE_RADIO_NETWORK,
+  E1AP_CAUSE_TRANSPORT,
+  E1AP_CAUSE_PROTOCOL,
+  E1AP_CAUSE_MISC
+} e1ap_cause_group_t;
+
+typedef struct e1ap_cause_s {
+  e1ap_cause_group_t type;
+  uint8_t value;
+} e1ap_cause_t;
+
 typedef enum BEARER_CONTEXT_STATUS_e {
   BEARER_ACTIVE = 0,
   BEARER_SUSPEND,
@@ -72,12 +149,59 @@ typedef enum cell_group_id_e {
   SCG,
 } cell_group_id_t;
 
+typedef enum CN_Support_e {
+  cn_support_EPC = 0,
+  cn_support_5GC,
+} cn_Support_t;
+
 typedef struct PLMN_ID_s {
   int mcc;
   int mnc;
   int mnc_digit_length;
 } PLMN_ID_t;
 
+typedef enum { CRITICALITY_REJECT = 0, CRITICALITY_IGNORE, CRITICALITY_NOTIFY } criticality_t;
+
+typedef enum {
+  ERROR_TYPE_NOT_UNDERSTOOD = 0,
+  ERROR_TYPE_MISSING,
+} error_type_t;
+
+typedef enum {
+  TRIGGERING_MSG_INITIATING = 0,
+  TRIGGERING_MSG_SUCCESSFUL_OUTCOME,
+  TRIGGERING_MSG_UNSUCCESSFUL_OUTCOME
+} triggering_msg_t;
+
+typedef struct criticality_diagnostics_ie_s {
+  criticality_t criticality;
+  int ie_id;
+  error_type_t error_type;
+} criticality_diagnostics_ie_t;
+
+typedef struct criticality_diagnostics_s {
+  int *procedure_code;
+  triggering_msg_t *triggering_msg;
+  criticality_t *procedure_criticality;
+  int num_errors;
+  criticality_diagnostics_ie_t errors[E1AP_MAX_NUM_ERRORS];
+} criticality_diagnostics_t;
+
+typedef struct {
+  in_addr_t ipsec_tl_address;
+  uint8_t num_gtp_tl_addresses;
+  in_addr_t gtp_tl_addresses[E1AP_MAX_GTP_TL_ADDRESSES];
+} tnl_address_info_item_t;
+
+typedef struct {
+  // Transport UP LayerAddresses Info to Add List
+  tnl_address_info_item_t addresses_to_add[E1AP_MAX_TL_ADDRESSES];
+  uint8_t num_addresses_to_add;
+  // Transport UP Layer Addresses Info to Remove List
+  tnl_address_info_item_t addresses_to_remove[E1AP_MAX_TL_ADDRESSES];
+  uint8_t num_addresses_to_remove;
+} tnl_address_info_t;
+
 typedef nssai_t e1ap_nssai_t;
 
 typedef struct e1ap_net_config_t {
@@ -91,11 +215,14 @@ typedef struct e1ap_net_config_t {
   uint16_t remotePortN3;
 } e1ap_net_config_t;
 
+/* GNB-CU-UP E1 Setup Request */
 typedef struct e1ap_setup_req_s {
   uint64_t              gNB_cu_up_id;
   char *                gNB_cu_up_name;
   uint64_t              transac_id;
   int                   supported_plmns;
+  // CN Support
+  cn_Support_t cn_support;
   struct {
     PLMN_ID_t id;
     int supported_slices;
@@ -103,6 +230,11 @@ typedef struct e1ap_setup_req_s {
   } plmn[E1AP_MAX_NUM_PLMNS];
 } e1ap_setup_req_t;
 
+typedef struct e1ap_cucp_setup_req_s {
+  char* gNB_cu_cp_name;
+  uint64_t transac_id;
+} e1ap_cucp_setup_req_t;
+
 typedef struct e1ap_register_req_t {
   e1ap_setup_req_t setup_req;
   e1ap_net_config_t net_config;
@@ -110,12 +242,20 @@ typedef struct e1ap_register_req_t {
 } e1ap_register_req_t;
 
 typedef struct e1ap_setup_resp_s {
+  // Transaction ID
   long transac_id;
+  // gNB-CU-CP Name
+  char* gNB_cu_cp_name;
+  // Transport Network Layer Address Info
+  tnl_address_info_t* tnla_info;
 } e1ap_setup_resp_t;
 
 /* E1AP Setup Failure */
 typedef struct e1ap_setup_fail_s {
   long transac_id;
+  e1ap_cause_t cause;
+  long *time_to_wait;
+  criticality_diagnostics_t *crit_diag;
 } e1ap_setup_fail_t;
 
 typedef struct up_params_s {

openair2/E1AP/e1ap_setup.c

@@ -101,6 +101,9 @@ MessageDef *RCconfig_NR_CU_E1(const E1_t *entity)
     if (*gnbParms[GNB_GNB_NAME_IDX].strptr)
       e1Setup->gNB_cu_up_name = *(gnbParms[GNB_GNB_NAME_IDX].strptr);
 
+    // Only 5GC supported
+    e1Setup->cn_support = cn_support_5GC;
+
     paramdef_t PLMNParams[] = GNBPLMNPARAMS_DESC;
     paramlist_def_t PLMNParamList = {GNB_CONFIG_STRING_PLMN_LIST, NULL, 0};
     /* map parameter checking array instances to parameter definition array instances */

openair2/E1AP/lib/CMakeLists.txt

 add_library(e1ap_lib OBJECT
             e1ap_bearer_context_management.c
+            e1ap_interface_management.c
 )
 
 target_link_libraries(e1ap_lib PRIVATE asn1_e1ap)

openair2/E1AP/lib/e1ap_interface_management.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#ifndef E1AP_INTERFACE_MANAGEMENT_H_
+#define E1AP_INTERFACE_MANAGEMENT_H_
+
+#include <stdbool.h>
+#include "openair2/COMMON/e1ap_messages_types.h"
+#include "common/platform_types.h"
+
+/* GNB-CU-UP E1 Setup Request */
+struct E1AP_E1AP_PDU *encode_e1ap_cuup_setup_request(const e1ap_setup_req_t *msg);
+bool decode_e1ap_cuup_setup_request(const struct E1AP_E1AP_PDU *pdu, e1ap_setup_req_t *out);
+e1ap_setup_req_t cp_e1ap_cuup_setup_request(const e1ap_setup_req_t *msg);
+void free_e1ap_cuup_setup_request(e1ap_setup_req_t *msg);
+bool eq_e1ap_cuup_setup_request(const e1ap_setup_req_t *a, const e1ap_setup_req_t *b);
+
+/* GNB-CU-UP E1 Setup Response */
+struct E1AP_E1AP_PDU *encode_e1ap_cuup_setup_response(const e1ap_setup_resp_t *msg);
+bool decode_e1ap_cuup_setup_response(const struct E1AP_E1AP_PDU *pdu, e1ap_setup_resp_t *out);
+e1ap_setup_resp_t cp_e1ap_cuup_setup_response(const e1ap_setup_resp_t *msg);
+void free_e1ap_cuup_setup_response(e1ap_setup_resp_t *msg);
+bool eq_e1ap_cuup_setup_response(const e1ap_setup_resp_t *a, const e1ap_setup_resp_t *b);
+
+/* GNB-CU-UP E1 Setup Failure */
+struct E1AP_E1AP_PDU *encode_e1ap_cuup_setup_failure(const e1ap_setup_fail_t *msg);
+bool decode_e1ap_cuup_setup_failure(const struct E1AP_E1AP_PDU *pdu, e1ap_setup_fail_t *out);
+e1ap_setup_fail_t cp_e1ap_cuup_setup_failure(const e1ap_setup_fail_t *msg);
+void free_e1ap_cuup_setup_failure(e1ap_setup_fail_t *msg);
+bool eq_e1ap_cuup_setup_failure(const e1ap_setup_fail_t *a, const e1ap_setup_fail_t *b);
+
+#endif /* E1AP_INTERFACE_MANAGEMENT_H_ */

openair2/E1AP/lib/e1ap_lib_includes.h

@@ -25,6 +25,8 @@
 #include "E1AP_E1AP-PDU.h"
 #include "E1AP_ProcedureCode.h"
 #include "E1AP_SuccessfulOutcome.h"
+#include "E1AP_UnsuccessfulOutcome.h"
+#include "E1AP_CriticalityDiagnostics-IE-List.h"
 #include "E1AP_InitiatingMessage.h"
 #include "E1AP_ProtocolIE-ID.h"
 #include "E1AP_ProtocolIE-Field.h"
@@ -53,5 +55,16 @@
 #include "E1AP_QoS-Flow-Item.h"
 #include "E1AP_DRB-Failed-List-NG-RAN.h"
 #include "E1AP_DRB-Failed-Item-NG-RAN.h"
+// E1 Setup
+#include "E1AP_SupportedPLMNs-Item.h"
+#include "E1AP_Slice-Support-List.h"
+#include "E1AP_Slice-Support-Item.h"
+#include "E1AP_ProtocolIE-Field.h"
+#include "E1AP_Transport-UP-Layer-Addresses-Info-To-Add-List.h"
+#include "E1AP_Transport-UP-Layer-Addresses-Info-To-Add-Item.h"
+#include "E1AP_Transport-UP-Layer-Addresses-Info-To-Remove-List.h"
+#include "E1AP_Transport-UP-Layer-Addresses-Info-To-Remove-Item.h"
+#include "E1AP_GTPTLAs.h"
+#include "E1AP_GTPTLA-Item.h"
 
 #endif /* E1AP_LIB_INCLUDES_H_ */

openair2/E1AP/tests/e1ap_lib_test.c

@@ -30,8 +30,10 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "E1AP/lib/e1ap_bearer_context_management.h"
-#include "E1AP/lib/e1ap_lib_includes.h"
+#include "common/utils/utils.h"
+#include "e1ap_bearer_context_management.h"
+#include "e1ap_interface_management.h"
+#include "e1ap_lib_includes.h"
 #include "common/utils/assertions.h"
 
 void exit_function(const char *file, const char *function, const int line, const char *s, const int assert)
@@ -216,10 +218,131 @@ static void test_bearer_context_setup_response(void)
   free_e1ap_context_setup_response(&orig);
 }
 
+/**
+ * @brief Test CU-UP Setup Request encoding/decoding
+ */
+static void test_e1_cuup_setup_request(void)
+{
+  e1ap_setup_req_t orig = {.gNB_cu_up_id = 1234,
+                           .gNB_cu_up_name = strdup("OAI CU-UP"),
+                           .transac_id = 42,
+                           .supported_plmns = 1,
+                           .cn_support = cn_support_5GC,
+                           .plmn[0] = {.id = {.mcc = 001, .mnc = 01, .mnc_digit_length = 2},
+                                       .supported_slices = 1}};
+  orig.plmn[0].slice = malloc_or_fail(sizeof(*orig.plmn[0].slice));
+  orig.plmn[0].slice->sst = 0x01;
+  orig.plmn[0].slice->sd = 0x01;
+
+  E1AP_E1AP_PDU_t *encoded = encode_e1ap_cuup_setup_request(&orig);
+  E1AP_E1AP_PDU_t *decoded_msg = e1ap_encode_decode(encoded);
+  e1ap_msg_free(encoded);
+
+  e1ap_setup_req_t decoded = {0};
+  bool ret = decode_e1ap_cuup_setup_request(decoded_msg, &decoded);
+  AssertFatal(ret, "Failed to decode setup request");
+  e1ap_msg_free(decoded_msg);
+
+  ret = eq_e1ap_cuup_setup_request(&orig, &decoded);
+  AssertFatal(ret, "Decoded setup request doesn't match original");
+  free_e1ap_cuup_setup_request(&decoded);
+
+  e1ap_setup_req_t cp = cp_e1ap_cuup_setup_request(&orig);
+  ret = eq_e1ap_cuup_setup_request(&orig, &cp);
+  AssertFatal(ret, "eq_e1ap_cuup_setup_request(): copied message doesn't match\n");
+
+  free_e1ap_cuup_setup_request(&orig);
+  free_e1ap_cuup_setup_request(&cp);
+}
+
+/**
+ * @brief Test CU-UP Setup Response encoding/decoding
+ */
+static void test_e1_cuup_setup_response(void)
+{
+  e1ap_setup_resp_t orig = {.transac_id = 42,
+                            .gNB_cu_cp_name = strdup("OAI CU-CP"),
+                            .tnla_info = malloc(sizeof(tnl_address_info_t))};
+  orig.tnla_info->num_addresses_to_add = 1;
+  orig.tnla_info->num_addresses_to_remove = 1;
+  orig.tnla_info->addresses_to_add[0].num_gtp_tl_addresses = 1;
+  orig.tnla_info->addresses_to_add[0].ipsec_tl_address = 0xC0A80001;
+  orig.tnla_info->addresses_to_add[0].gtp_tl_addresses[0] = 0xC0A80002;
+  orig.tnla_info->num_addresses_to_remove = 1;
+  orig.tnla_info->addresses_to_remove[0].num_gtp_tl_addresses = 1;
+  orig.tnla_info->addresses_to_remove[0].ipsec_tl_address = 0xC0A80003;
+  orig.tnla_info->addresses_to_remove[0].gtp_tl_addresses[0] = 0xC0A80004;
+
+  E1AP_E1AP_PDU_t *encoded = encode_e1ap_cuup_setup_response(&orig);
+  E1AP_E1AP_PDU_t *decoded_msg = e1ap_encode_decode(encoded);
+  e1ap_msg_free(encoded);
+
+  e1ap_setup_resp_t decoded = {0};
+  bool ret = decode_e1ap_cuup_setup_response(decoded_msg, &decoded);
+  AssertFatal(ret, "Failed to decode setup response");
+  e1ap_msg_free(decoded_msg);
+
+  ret = eq_e1ap_cuup_setup_response(&orig, &decoded);
+  AssertFatal(ret, "Decoded setup response doesn't match original");
+  free_e1ap_cuup_setup_response(&decoded);
+
+  e1ap_setup_resp_t cp = cp_e1ap_cuup_setup_response(&orig);
+  ret = eq_e1ap_cuup_setup_response(&orig, &cp);
+  AssertFatal(ret, "eq_e1ap_cuup_setup_response(): copied message doesn't match\n");
+
+  free_e1ap_cuup_setup_response(&orig);
+  free_e1ap_cuup_setup_response(&cp);
+}
+
+// Test for E1AP CU-UP Setup Failure
+static void test_e1_cuup_setup_failure(void)
+{
+  e1ap_setup_fail_t orig = {.transac_id = 42,
+                            .cause.type = E1AP_CAUSE_RADIO_NETWORK,
+                            .cause.value = E1AP_RADIO_CAUSE_NORMAL_RELEASE,
+                            .time_to_wait = malloc_or_fail(sizeof(long)),
+                            .crit_diag = malloc_or_fail(sizeof(criticality_diagnostics_t))};
+  *orig.time_to_wait = 5;
+  orig.crit_diag->procedure_code = malloc_or_fail(sizeof(*orig.crit_diag->procedure_code));
+  *orig.crit_diag->procedure_code = 99;
+  orig.crit_diag->triggering_msg = malloc_or_fail(sizeof(*orig.crit_diag->triggering_msg));
+  *orig.crit_diag->triggering_msg = TRIGGERING_MSG_SUCCESSFUL_OUTCOME;
+  orig.crit_diag->procedure_criticality = malloc_or_fail(sizeof(*orig.crit_diag->procedure_criticality));
+  *orig.crit_diag->procedure_criticality = CRITICALITY_IGNORE;
+  orig.crit_diag->num_errors = 1;
+  orig.crit_diag->errors[0].ie_id = 66;
+  orig.crit_diag->errors[0].error_type = ERROR_TYPE_MISSING;
+  orig.crit_diag->errors[0].criticality = CRITICALITY_IGNORE;
+
+  E1AP_E1AP_PDU_t *encoded = encode_e1ap_cuup_setup_failure(&orig);
+  E1AP_E1AP_PDU_t *decoded_msg = e1ap_encode_decode(encoded);
+  e1ap_msg_free(encoded);
+
+  e1ap_setup_fail_t decoded = {0};
+  bool ret = decode_e1ap_cuup_setup_failure(decoded_msg, &decoded);
+  AssertFatal(ret, "Failed to decode setup failure");
+  e1ap_msg_free(decoded_msg);
+
+  ret = eq_e1ap_cuup_setup_failure(&orig, &decoded);
+  AssertFatal(ret, "Decoded setup failure doesn't match original");
+  free_e1ap_cuup_setup_failure(&decoded);
+
+  e1ap_setup_fail_t cp = cp_e1ap_cuup_setup_failure(&orig);
+  ret = eq_e1ap_cuup_setup_failure(&orig, &cp);
+  AssertFatal(ret, "eq_e1ap_cuup_setup_failure(): copied message doesn't match\n");
+
+  free_e1ap_cuup_setup_failure(&cp);
+  free_e1ap_cuup_setup_failure(&orig);
+}
+
 int main()
 {
   // E1 Bearer Context Setup
   test_bearer_context_setup_request();
   test_bearer_context_setup_response();
+  // E1 Interface Management
+  test_e1_cuup_setup_request();
+  test_e1_cuup_setup_response();
+  test_e1_cuup_setup_failure();
   return 0;
 }

openair2/RRC/NR/nr_rrc_proto.h

@@ -85,7 +85,7 @@ void rrc_gNB_generate_dedicatedRRCReconfiguration_release(gNB_RRC_INST *rrc,
 bool ue_associated_to_cuup(const gNB_RRC_INST *rrc, const gNB_RRC_UE_t *ue);
 sctp_assoc_t get_existing_cuup_for_ue(const gNB_RRC_INST *rrc, const gNB_RRC_UE_t *ue);
 sctp_assoc_t get_new_cuup_for_ue(const gNB_RRC_INST *rrc, const gNB_RRC_UE_t *ue, int sst, int sd);
-int rrc_gNB_process_e1_setup_req(sctp_assoc_t assoc_id, e1ap_setup_req_t *req);
+int rrc_gNB_process_e1_setup_req(sctp_assoc_t assoc_id, const e1ap_setup_req_t *req);
 bool is_cuup_associated(gNB_RRC_INST *rrc);
 
 /* Process indication of E1 connection loss on CU-CP */

openair2/RRC/NR/rrc_gNB.c

@@ -95,6 +95,7 @@
 #include "x2ap_messages_types.h"
 #include "xer_encoder.h"
 #include "E1AP/lib/e1ap_bearer_context_management.h"
+#include "E1AP/lib/e1ap_interface_management.h"
 
 #ifdef E2_AGENT
 #include "openair2/E2AP/RAN_FUNCTION/O-RAN/ran_func_rc_extern.h"
@@ -2643,6 +2644,7 @@ void *rrc_gnb_task(void *args_p) {
 
       case E1AP_SETUP_REQ:
         rrc_gNB_process_e1_setup_req(msg_p->ittiMsgHeader.originInstance, &E1AP_SETUP_REQ(msg_p));
+        free_e1ap_cuup_setup_request(&E1AP_SETUP_REQ(msg_p));
         break;
 
       case E1AP_BEARER_CONTEXT_SETUP_RESP:

openair2/RRC/NR/rrc_gNB_cuup.c

@@ -37,6 +37,7 @@
 #include "openair2/F1AP/f1ap_ids.h"
 #include "rrc_messages_types.h"
 #include "tree.h"
+#include "e1ap_interface_management.h"
 
 static int cuup_compare(const nr_rrc_cuup_container_t *a, const nr_rrc_cuup_container_t *b)
 {
@@ -154,12 +155,13 @@ sctp_assoc_t get_new_cuup_for_ue(const gNB_RRC_INST *rrc, const gNB_RRC_UE_t *ue
 /**
  * @brief Trigger E1AP Setup Failure on CU-CP
 */
-static void e1ap_setup_failure(sctp_assoc_t assoc_id, uint64_t transac_id)
+static void e1ap_setup_failure(sctp_assoc_t assoc_id, uint64_t transac_id, e1ap_cause_t cause)
 {
   MessageDef *msg_p = itti_alloc_new_message(TASK_RRC_GNB, 0, E1AP_SETUP_FAIL);
   msg_p->ittiMsgHeader.originInstance = assoc_id;
   e1ap_setup_fail_t *setup_fail = &E1AP_SETUP_FAIL(msg_p);
   setup_fail->transac_id = transac_id;
+  setup_fail->cause = cause;
   LOG_I(NR_RRC, "Triggering E1AP Setup Failure for transac_id %ld, assoc_id %ld\n",
         transac_id,
         msg_p->ittiMsgHeader.originInstance);
@@ -169,7 +171,7 @@ static void e1ap_setup_failure(sctp_assoc_t assoc_id, uint64_t transac_id)
 /**
  * @brief E1AP Setup Request processing on CU-CP
 */
-int rrc_gNB_process_e1_setup_req(sctp_assoc_t assoc_id, e1ap_setup_req_t *req)
+int rrc_gNB_process_e1_setup_req(sctp_assoc_t assoc_id, const e1ap_setup_req_t *req)
 {
   AssertFatal(req->supported_plmns <= PLMN_LIST_MAX_SIZE, "Supported PLMNs is more than PLMN_LIST_MAX_SIZE\n");
   gNB_RRC_INST *rrc = RC.nrrrc[0];
@@ -185,13 +187,14 @@ int rrc_gNB_process_e1_setup_req(sctp_assoc_t assoc_id, e1ap_setup_req_t *req)
             c->setup_req->gNB_cu_up_id,
             c->setup_req->gNB_cu_up_name,
             c->assoc_id);
-      e1ap_setup_failure(assoc_id, req->transac_id);
+      e1ap_cause_t cause = { .type = E1AP_CAUSE_RADIO_NETWORK, .value = E1AP_RADIO_CAUSE_UNKNOWN_ALREADY_ALLOCATED_GNB_CU_UP_UE_E1AP_ID};
+      e1ap_setup_failure(assoc_id, req->transac_id, cause);
       return -1;
     }
   }
 
   for (int i = 0; i < req->supported_plmns; i++) {
-    PLMN_ID_t *id = &req->plmn[i].id;
+    const PLMN_ID_t *id = &req->plmn[i].id;
     if (rrc->configuration.mcc[i] != id->mcc || rrc->configuration.mnc[i] != id->mnc) {
       LOG_E(NR_RRC,
             "PLMNs received from CUUP (mcc:%d, mnc:%d) did not match with PLMNs in RRC (mcc:%d, mnc:%d)\n",
@@ -199,16 +202,16 @@ int rrc_gNB_process_e1_setup_req(sctp_assoc_t assoc_id, e1ap_setup_req_t *req)
             id->mnc,
             rrc->configuration.mcc[i],
             rrc->configuration.mnc[i]);
-      e1ap_setup_failure(assoc_id, req->transac_id);
+      e1ap_cause_t cause = { .type = E1AP_CAUSE_RADIO_NETWORK, .value = E1AP_RADIO_CAUSE_OTHER};
+      e1ap_setup_failure(assoc_id, req->transac_id, cause);
       return -1;
     }
   }
 
   LOG_I(NR_RRC, "Accepting new CU-UP ID %ld name %s (assoc_id %d)\n", req->gNB_cu_up_id, req->gNB_cu_up_name, assoc_id);
-  nr_rrc_cuup_container_t *cuup = malloc(sizeof(*cuup));
-  AssertFatal(cuup, "out of memory\n");
-  cuup->setup_req = malloc(sizeof(*cuup->setup_req));
-  *cuup->setup_req = *req;
+  nr_rrc_cuup_container_t *cuup = malloc_or_fail(sizeof(*cuup));
+  cuup->setup_req = malloc_or_fail(sizeof(*cuup->setup_req));
+  *cuup->setup_req = cp_e1ap_cuup_setup_request(req);
   cuup->assoc_id = assoc_id;
   RB_INSERT(rrc_cuup_tree, &rrc->cuups, cuup);
   rrc->num_cuups++;