Merge remote-tracking branch 'origin/fhi72-mplane' into integration_2025_w13 (!3216)

FHI72: Management plane support

At the moment, tested with Benetel 550 and 650 RUs FW v1.2.2
- support for multiple RUs
- RPCs implemented: <connect>, <subscribe>, <get>, <supervision-watchdog-reset>,
  <edit-config>, <validate>, <commit>, <disconnect>
- read PTP sync status from operational datastore xml
- get vendor name, and for xran store RU MAC, MTU and IQ bitwidth and PRACH
  offset, and transfer this info
- store interface name, low-level-tx/rx-endpoint names, tx/rx-carrier names,...,
  from operational datastore xml
- add reference gNB/DU config files with M-plane support
- update FHI readme

cmake_targets/build_oai

@@ -99,7 +99,7 @@ Options:
    USRP, BLADERF, LMSSDR, IRIS, SIMU, AW2SORI, AERIAL, None (Default)
    Adds this RF board support (in external packages installation and in compilation)
 -t | --transport
-   Selects the transport protocol type, options: None, Ethernet, benetel4g, benetel5g, oran_fhlib_5g
+   Selects the transport protocol type, options: None, Ethernet, benetel4g, benetel5g, oran_fhlib_5g, oran_fhlib_5g_mplane
 -P | --phy_simulators
    Makes the unitary tests Layer 1 simulators
 -s | --check
@@ -304,6 +304,10 @@ function main() {
                 TARGET_LIST="$TARGET_LIST $2"
                 CMAKE_CMD="$CMAKE_CMD -DOAI_FHI72=ON"
                 ;;
+              "oran_fhlib_5g_mplane")
+                TARGET_LIST="$TARGET_LIST $2"
+                CMAKE_CMD="$CMAKE_CMD -DOAI_FHI72=ON -DOAI_FHI72_MPLANE=ON"
+                ;;
               "None")
                 ;;
               *)
@@ -504,12 +508,6 @@ function main() {
 	echo_info "Built Doxygen based documentation. The documentation file is located here: $DIR/$BUILD_DIR/build/doc/html/index.html"
     fi
 
-    # TODO: once we got the CMakeLists.txt file done for the ORAN files, remove the following lines
-    if [[ $TARGET_LIST =~ "oran_fhlib_5g" ]]; then
-      rm -f liboai_transpro.so
-      ln -s liboran_fhlib_5g.so liboai_transpro.so
-    fi
-
     if [ "$UE" = 1 ] ; then
 
       echo_info "Compiling UE specific part"

cmake_targets/tools/MODULES/FindLibXml2.cmake

-# - Try to find the LibXml2 xml processing library
-# Once done this will define
-#
-#  LIBXML2_FOUND - System has LibXml2
-#  LIBXML2_INCLUDE_DIR - The LibXml2 include directory
-#  LIBXML2_LIBRARIES - The libraries needed to use LibXml2
-#  LIBXML2_DEFINITIONS - Compiler switches required for using LibXml2
-#  LIBXML2_XMLLINT_EXECUTABLE - The XML checking tool xmllint coming with LibXml2
-
-#=============================================================================
-# Copyright 2006-2009 Kitware, Inc.
-# Copyright 2006 Alexander Neundorf <neundorf@kde.org>
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distributed this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-# use pkg-config to get the directories and then use these values
-# in the FIND_PATH() and FIND_LIBRARY() calls
-FIND_PACKAGE(PkgConfig)
-PKG_CHECK_MODULES(PC_LIBXML libxml-2.0)
-SET(LIBXML2_DEFINITIONS ${PC_LIBXML_CFLAGS_OTHER})
-
-FIND_PATH(LIBXML2_INCLUDE_DIR NAMES libxml/xpath.h
-   HINTS
-   ${PC_LIBXML_INCLUDEDIR}
-   ${PC_LIBXML_INCLUDE_DIRS}
-   PATH_SUFFIXES libxml2
-   )
-
-FIND_LIBRARY(LIBXML2_LIBRARIES NAMES xml2 libxml2
-   HINTS
-   ${PC_LIBXML_LIBDIR}
-   ${PC_LIBXML_LIBRARY_DIRS}
-   )
-
-FIND_PROGRAM(LIBXML2_XMLLINT_EXECUTABLE xmllint)
-# for backwards compat. with KDE 4.0.x:
-SET(XMLLINT_EXECUTABLE "${LIBXML2_XMLLINT_EXECUTABLE}")
-
-# handle the QUIETLY and REQUIRED arguments and set LIBXML2_FOUND to TRUE if 
-# all listed variables are TRUE
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibXml2 DEFAULT_MSG LIBXML2_LIBRARIES LIBXML2_INCLUDE_DIR)
-
-MARK_AS_ADVANCED(LIBXML2_INCLUDE_DIR LIBXML2_LIBRARIES LIBXML2_XMLLINT_EXECUTABLE)
-

cmake_targets/tools/MODULES/Findxran.cmake

@@ -75,7 +75,6 @@ endif()
 
 find_path(xran_INCLUDE_DIR
   NAMES
-    xran_common.h
     xran_compression.h
     xran_cp_api.h
     xran_ecpri_owd_measurements.h
@@ -84,7 +83,7 @@ find_path(xran_INCLUDE_DIR
     xran_pkt_up.h
     xran_sync_api.h
   HINTS ${xran_LOCATION}
-  PATH_SUFFIXES api include
+  PATH_SUFFIXES api
   NO_DEFAULT_PATH
 )
 find_library(xran_LIBRARY
@@ -127,16 +126,19 @@ find_package_handle_standard_args(xran
   VERSION_VAR xran_VERSION
 )
 
+# in proper usage of cmake, include directory should only contain "api", but not header files under "src" directory;
+# however, we use xran_dev_get_ctx() and xran_dev_get_ctx_by_id() functions which are defined in xran_common.h;
+# since xran_common.h is under "src" directory, we have to include it in ${xran_INCLUDE_DIRS}
 if(xran_FOUND)
   set(xran_LIBRARIES ${xran_LIBRARY})
-  set(xran_INCLUDE_DIRS ${xran_INCLUDE_DIR})
+  set(xran_INCLUDE_DIRS ${xran_INCLUDE_DIR} ${xran_INCLUDE_DIR}/../src)
 endif()
 
 if(xran_FOUND AND NOT TARGET xran::xran)
   add_library(xran::xran UNKNOWN IMPORTED)
   set_target_properties(xran::xran PROPERTIES
     IMPORTED_LOCATION "${xran_LIBRARY}"
-    INTERFACE_INCLUDE_DIRECTORIES "${xran_INCLUDE_DIR}"
+    INTERFACE_INCLUDE_DIRECTORIES "${xran_INCLUDE_DIRS}"
   )
 endif()
 

cmake_targets/tools/build_helper

@@ -546,7 +546,10 @@ check_install_additional_tools (){
         libforms-bin \
         libforms-dev \
         libxft-dev \
-        xmlstarlet"
+        xmlstarlet \
+        libpcre3-dev \
+        libssh-dev \
+        libxml2-dev"
   elif [[ "$OS_DISTRO" == "rhel" ]] || [[ "$OS_DISTRO" == "centos" ]] || [[ "$OS_DISTRO" == "rocky" ]] ||  [[ "$OS_DISTRO" == "fedora" ]]; then
     PACKAGE_LIST="\
       doxygen \
@@ -556,7 +559,10 @@ check_install_additional_tools (){
       libXft-devel \
       xforms \
       xforms-devel \
-      xmlstarlet"
+      xmlstarlet \
+      pcre-devel \
+      libssh-devel \
+      libxml2-devel"
   fi
     $SUDO $INSTALLER install -y $PACKAGE_LIST $optional_packages
 }

common/utils/LOG/log.c

@@ -52,6 +52,13 @@
 
 // main log variables
 
+/** @defgroup _max_length Maximum Length of LOG
+ *  @ingroup _macro
+ *  @brief the macros that describe the maximum length of LOG
+ * @{*/
+
+#define MAX_LOG_TOTAL 16384 /*!< \brief the maximum length of a log */
+
 // Fixme: a better place to be shure it is called 
 void read_cpu_hardware (void) __attribute__ ((constructor));
 #if !defined(__arm__) && !defined(__aarch64__) 
@@ -877,31 +884,32 @@ static void log_output_memory(log_component_t *c, const char *file, const char *
    * correctly. It was not a big problem because in practice MAX_LOG_TOTAL is
    * big enough so that the buffer is never full.
    */
-  char log_buffer[MAX_LOG_TOTAL];
+  static_assert(4 * MAX_LOG_TOTAL <= 65536, "log buffer limited to 64kB, please reduce MAX_LOG_TOTAL\n");
+  char log_buffer[4 * MAX_LOG_TOTAL];
 
   // make sure that for log trace the extra info is only printed once, reset when the level changes
   if (level < OAILOG_TRACE) {
-    int n = log_header(c, log_buffer+len, MAX_LOG_TOTAL, file, func, line, level);
+    int n = log_header(c, log_buffer+len, sizeof(log_buffer), file, func, line, level);
     if (n > 0) {
       len += n;
-      if (len > MAX_LOG_TOTAL) {
-        len = MAX_LOG_TOTAL;
+      if (len > sizeof(log_buffer)) {
+        len = sizeof(log_buffer);
       }
     }
   }
-  int n = vsnprintf(log_buffer+len, MAX_LOG_TOTAL-len, format, args);
+  int n = vsnprintf(log_buffer+len, sizeof(log_buffer)-len, format, args);
   if (n > 0) {
     len += n;
-    if (len > MAX_LOG_TOTAL) {
-      len = MAX_LOG_TOTAL;
+    if (len > sizeof(log_buffer)) {
+      len = sizeof(log_buffer);
     }
   }
   if (!((g_log->flag) & FLAG_NOCOLOR)) {
-    int n = snprintf(log_buffer+len, MAX_LOG_TOTAL-len, "%s", log_level_highlight_end[level]);
+    int n = snprintf(log_buffer+len, sizeof(log_buffer)-len, "%s", log_level_highlight_end[level]);
     if (n > 0) {
       len += n;
-      if (len > MAX_LOG_TOTAL) {
-        len = MAX_LOG_TOTAL;
+      if (len > sizeof(log_buffer)) {
+        len = sizeof(log_buffer);
       }
     }
   }
@@ -941,7 +949,7 @@ static void log_output_memory(log_component_t *c, const char *file, const char *
         }
       }
   }else{
-    AssertFatal(len >= 0 && len <= MAX_LOG_TOTAL, "Bad len %d\n", len);
+    AssertFatal(len >= 0 && len <= sizeof(log_buffer), "Bad len %d\n", len);
     if (write(fileno(c->stream), log_buffer, len)) {};
   }
 }

common/utils/LOG/log.h

@@ -65,12 +65,6 @@
 extern "C" {
 #endif
 
-/** @defgroup _max_length Maximum Length of LOG
- *  @ingroup _macro
- *  @brief the macros that describe the maximum length of LOG
- * @{*/
-
-#define MAX_LOG_TOTAL 16384 /*!< \brief the maximum length of a log */
 /** @}*/
 
 /** @defgroup _log_level Message levels defined by LOG

radio/fhi_72/CMakeLists.txt

@@ -30,18 +30,19 @@ endif()
 add_compile_options(-Wno-packed-not-aligned)
 
 set_target_properties(oran_fhlib_5g PROPERTIES COMPILE_FLAGS "-fvisibility=hidden -march=native")
-target_link_libraries(oran_fhlib_5g PRIVATE xran::xran)
-target_link_libraries(oran_fhlib_5g PRIVATE ${dpdk_LINK_LIBRARIES})
+target_link_libraries(oran_fhlib_5g PRIVATE xran::xran ${dpdk_LINK_LIBRARIES} ${T_LIB} pthread dl rt m numa)
 target_include_directories(oran_fhlib_5g PRIVATE ${dpdk_INCLUDE_DIRS})
-target_link_libraries(oran_fhlib_5g PRIVATE pthread dl rt m numa)
-target_link_libraries(oran_fhlib_5g PRIVATE ${T_LIB})
-
-# TODO: can be removed?
-target_include_directories(oran_fhlib_5g PRIVATE ${xran_INCLUDE_DIRS}/../src/)
 
 add_boolean_option(OAI_FHI72_USE_POLLING OFF "Enable polling in FHI72 driver" ON)
 
+message(STATUS "Building FHI72 CUS library")
+
 set_target_properties(oran_fhlib_5g PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 add_custom_command(TARGET oran_fhlib_5g POST_BUILD
                    COMMAND ${CMAKE_COMMAND} -E create_symlink liboran_fhlib_5g.so liboai_transpro.so
                    WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+
+add_boolean_option(OAI_FHI72_MPLANE OFF "Activate OAI's FHI 7.2 M-plane support" OFF)
+if(OAI_FHI72_MPLANE)
+  add_subdirectory(mplane)
+endif()

radio/fhi_72/mplane/CMakeLists.txt

+add_library(oran_fhlib_5g_mplane MODULE
+            ../oran_isolate.c
+            ../oaioran.c
+            ../oran-config.c
+            ../oran-init.c
+)
+add_dependencies(oran_fhlib_5g_mplane oran_fhlib_5g)
+
+if(xran_VERSION VERSION_EQUAL 5.1.4)
+  target_compile_definitions(oran_fhlib_5g_mplane PRIVATE E_RELEASE)
+elseif(xran_VERSION VERSION_EQUAL 6.1.1)
+  target_compile_definitions(oran_fhlib_5g_mplane PRIVATE F_RELEASE)
+endif()
+
+# Ignore xran-specific warning: we don't care/can't change the following warning, so suppress
+# alignment 1 of 'struct XYZ' is less than 2
+add_compile_options(-Wno-packed-not-aligned)
+
+set_target_properties(oran_fhlib_5g_mplane PROPERTIES COMPILE_FLAGS "-fvisibility=hidden -march=native")
+target_link_libraries(oran_fhlib_5g_mplane PRIVATE xran::xran ${dpdk_LINK_LIBRARIES} ${T_LIB} pthread dl rt m numa)
+target_include_directories(oran_fhlib_5g_mplane PRIVATE ${dpdk_INCLUDE_DIRS})
+
+target_compile_definitions(oran_fhlib_5g_mplane PRIVATE OAI_MPLANE)
+
+###################################################
+
+target_sources(oran_fhlib_5g_mplane PRIVATE
+               init-mplane.c
+               connect-mplane.c
+               rpc-send-recv.c
+               get-mplane.c
+               subscribe-mplane.c
+               config-mplane.c
+               ru-mplane-api.c
+               xml/get-xml.c
+               yang/get-yang.c
+               yang/create-yang-config.c
+)
+
+pkg_check_modules(libyang REQUIRED libyang)
+pkg_check_modules(libnetconf2 REQUIRED libnetconf2)
+
+if(libyang_VERSION VERSION_LESS_EQUAL 1.0.240 AND libnetconf2_VERSION VERSION_LESS_EQUAL 1.1.46)
+  target_compile_definitions(oran_fhlib_5g_mplane PRIVATE MPLANE_V1)
+elseif((libyang_VERSION VERSION_GREATER 1.0.240 AND libyang_VERSION VERSION_LESS 2.1.4))
+  message(FATAL_ERROR "Minimum libyang v2 subversion required is v2.1.4, but found ${libyang_VERSION}")
+elseif((libnetconf2_VERSION VERSION_GREATER 1.1.46 AND libnetconf2_VERSION VERSION_LESS 2.1.25))
+  message(FATAL_ERROR "Minimum libnetconf2 v2 subversion required is v2.1.25, but found ${libnetconf2_VERSION}")
+elseif((libyang_VERSION VERSION_GREATER_EQUAL 2.1.4 AND libyang_VERSION VERSION_LESS_EQUAL 2.1.111) AND (libnetconf2_VERSION VERSION_GREATER_EQUAL 2.1.25 AND libnetconf2_VERSION VERSION_LESS_EQUAL 2.1.37))
+  target_compile_definitions(oran_fhlib_5g_mplane PRIVATE MPLANE_V2)
+else()
+  message(FATAL_ERROR "Unknown libyang version ${libyang_VERSION} and libnetconf2 version ${libnetconf2_VERSION}")
+endif()
+
+target_include_directories(oran_fhlib_5g_mplane PRIVATE ${libyang_INCLUDE_DIRS} ${libnetconf2_INCLUDE_DIRS})
+target_link_libraries(oran_fhlib_5g_mplane PRIVATE ${libyang_LDFLAGS} ${libyang_LINK_LIBRARIES} ${libnetconf2_LINK_LIBRARIES})
+
+pkg_check_modules(libssh REQUIRED libssh)
+target_include_directories(oran_fhlib_5g_mplane PRIVATE ${libssh_INCLUDE_DIRS})
+target_link_libraries(oran_fhlib_5g_mplane PRIVATE ${libssh_LINK_LIBRARIES})
+
+find_package(LibXml2 REQUIRED)
+target_link_libraries(oran_fhlib_5g_mplane PRIVATE LibXml2::LibXml2)
+
+set(YANG_MODELS "${CMAKE_SOURCE_DIR}/radio/fhi_72/mplane/yang/models")
+target_compile_definitions(oran_fhlib_5g_mplane PRIVATE YANG_MODELS="${YANG_MODELS}")
+
+message(STATUS "Building FHI72 CUSM library")
+
+set_target_properties(oran_fhlib_5g_mplane PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+add_custom_command(TARGET oran_fhlib_5g_mplane POST_BUILD
+                   COMMAND ${CMAKE_COMMAND} -E create_symlink liboran_fhlib_5g_mplane.so liboai_transpro.so
+                   WORKING_DIRECTORY ${CMAKE_BINARY_DIR})

radio/fhi_72/mplane/config-mplane.c

+/*
+ * 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
+ */
+
+#include "config-mplane.h"
+#include "rpc-send-recv.h"
+#include "yang/get-yang.h"
+#include "yang/create-yang-config.h"
+#include "common/utils/assertions.h"
+
+#include <libyang/libyang.h>
+#include <nc_client.h>
+
+bool edit_config_mplane(ru_session_t *ru_session, const char *buffer, const openair0_config_t *oai, const size_t num_rus)
+{
+  int timeout = CLI_RPC_REPLY_TIMEOUT;
+  struct nc_rpc *rpc;
+  NC_WD_MODE wd = NC_WD_ALL;
+  NC_PARAMTYPE param = NC_PARAMTYPE_CONST;
+  NC_DATASTORE target = NC_DATASTORE_CANDIDATE;
+  NC_RPC_EDIT_DFLTOP op = NC_RPC_EDIT_DFLTOP_MERGE;
+  NC_RPC_EDIT_TESTOPT test = NC_RPC_EDIT_TESTOPT_UNKNOWN;
+  NC_RPC_EDIT_ERROPT err = NC_RPC_EDIT_ERROPT_UNKNOWN;
+
+  bool success = false;
+
+  struct ly_ctx *ctx = NULL;
+  success = load_yang_models(ru_session, buffer, &ctx);
+  AssertError(success, return false, "[MPLANE] Unable to continue.\n");
+
+  char *content = NULL;
+  success = configure_ru_from_yang(&ctx, ru_session, oai, num_rus, &content);
+  AssertError(success, return false, "[MPLANE] Unable to create content for <edit-config> RPC.\n");
+
+  MP_LOG_I("RPC request to RU \"%s\" = <edit-config>:\n%s\n", ru_session->ru_ip_add, content);
+  rpc = nc_rpc_edit(target, op, test, err, content, param);
+  AssertError(rpc != NULL, return false, "[MPLANE] <edit-config> RPC creation failed.\n");
+
+  success = rpc_send_recv((struct nc_session *)ru_session->session, rpc, wd, timeout, NULL);
+  AssertError(success, return false, "[MPLANE] Failed to edit configuration for the candidate datastore.\n");
+
+  MP_LOG_I("Successfully edited the candidate datastore for RU \"%s\".\n", ru_session->ru_ip_add);
+
+  nc_rpc_free(rpc);
+  free(content);
+#ifdef MPLANE_V1
+  ly_ctx_destroy(ctx, NULL);
+#elif defined MPLANE_V2
+  ly_ctx_destroy(ctx);
+#endif
+
+  return true;
+}
+
+bool validate_config_mplane(ru_session_t *ru_session)
+{
+  int timeout = CLI_RPC_REPLY_TIMEOUT;
+  struct nc_rpc *rpc;
+  NC_WD_MODE wd = NC_WD_ALL;
+  NC_PARAMTYPE param = NC_PARAMTYPE_CONST;
+  char *src_start = NULL;
+  NC_DATASTORE source = NC_DATASTORE_CANDIDATE;
+
+  MP_LOG_I("RPC request to RU \"%s\" = <validate> candidate datastore.\n", ru_session->ru_ip_add);
+  rpc = nc_rpc_validate(source, src_start, param);
+  AssertError(rpc != NULL, return false, "[MPLANE] <validate> RPC creation failed.\n");
+
+  bool success = rpc_send_recv((struct nc_session *)ru_session->session, rpc, wd, timeout, NULL);
+  AssertError(success, return false, "[MPLANE] Failed to validate candidate datastore.\n");
+
+  MP_LOG_I("Successfully validated candidate datastore for RU \"%s\".\n", ru_session->ru_ip_add);
+
+  nc_rpc_free(rpc);
+
+  return true;
+}
+
+bool commit_config_mplane(ru_session_t *ru_session)
+{
+  int timeout = CLI_RPC_REPLY_TIMEOUT;
+  struct nc_rpc *rpc;
+  NC_WD_MODE wd = NC_WD_ALL;
+  NC_PARAMTYPE param = NC_PARAMTYPE_CONST;
+  int confirmed = 0;
+  int32_t confirm_timeout = 0;
+  char *persist = NULL, *persist_id = NULL;
+
+  MP_LOG_I("RPC request to RU \"%s\" = <commit> candidate datastore.\n", ru_session->ru_ip_add);
+  rpc = nc_rpc_commit(confirmed, confirm_timeout, persist, persist_id, param);
+  AssertError(rpc != NULL, return false, "[MPLANE] <commit> RPC creation failed.\n");
+
+  bool success = rpc_send_recv((struct nc_session *)ru_session->session, rpc, wd, timeout, NULL);
+  AssertError(success, return false, "[MPLANE] Failed to commit candidate datastore.\n");
+
+  MP_LOG_I("Successfully commited CU-planes configuration into running datastore for RU \"%s\".\n", ru_session->ru_ip_add);
+
+  nc_rpc_free(rpc);
+
+  return true;
+}

radio/fhi_72/mplane/config-mplane.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 CONFIGURE_MPLANE_H
+#define CONFIGURE_MPLANE_H
+
+#include "ru-mplane-api.h"
+#include "radio/COMMON/common_lib.h"
+
+bool edit_config_mplane(ru_session_t *ru_session, const char *buffer, const openair0_config_t *oai, const size_t num_rus);
+
+bool validate_config_mplane(ru_session_t *ru_session);
+
+bool commit_config_mplane(ru_session_t *ru_session);
+
+#endif /* CONFIGURE_MPLANE_H */

radio/fhi_72/mplane/connect-mplane.c

+/*
+ * 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
+ */
+
+#include "connect-mplane.h"
+#include "common/utils/assertions.h"
+
+#include <libyang/libyang.h>
+#include <nc_client.h>
+
+static int my_auth_hostkey_check(const char *hostname, ssh_session session, void *priv)
+{
+  (void)hostname;
+  (void)session;
+  (void)priv;
+
+  return 0;
+}
+
+bool connect_mplane(ru_session_t *ru_session)
+{
+  int port = NC_PORT_SSH;
+  char *user = "oranbenetel";
+
+  nc_client_ssh_set_username(user);
+
+  nc_client_ssh_set_auth_pref(NC_SSH_AUTH_PUBLICKEY, 1);  // ssh-key identification
+  nc_client_ssh_set_auth_pref(NC_SSH_AUTH_PASSWORD, -1);
+  nc_client_ssh_set_auth_pref(NC_SSH_AUTH_INTERACTIVE, -1);
+
+  nc_client_ssh_set_auth_hostkey_check_clb(my_auth_hostkey_check, "DATA");  // host-key identification
+
+  MP_LOG_I("RPC request to RU \"%s\" = <connect> with username \"%s\" and port ID \"%d\".\n", ru_session->ru_ip_add, user, port);
+  ru_session->session = nc_connect_ssh(ru_session->ru_ip_add, port, NULL);
+  AssertError(ru_session->session != NULL, return false, "[MPLANE] RU IP address %s unreachable. Maybe M-plane is disabled on the RU?\n", ru_session->ru_ip_add);
+
+  MP_LOG_I("Successfuly connected to RU \"%s\" with username \"%s\" and port ID \"%d\".\n", ru_session->ru_ip_add, user, port);
+
+  return true;
+}
+
+void disconnect_mplane(void *rus_disconnect)
+{
+  ru_session_list_t *ru_session_list = (ru_session_list_t *)rus_disconnect;
+
+  for (size_t i = 0; i <ru_session_list->num_rus; i++) {
+    ru_session_t *ru_session = &ru_session_list->ru_session[i];
+    if (ru_session->session == NULL)
+      continue;
+    MP_LOG_I("Disconnecting from RU \"%s\".\n", ru_session->ru_ip_add);
+    nc_session_free(ru_session->session, NULL);
+    ru_session->session = NULL;
+  }
+
+  nc_client_destroy();
+}

radio/fhi_72/mplane/connect-mplane.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 CONNECT_MPLANE_H
+#define CONNECT_MPLANE_H
+
+#include "ru-mplane-api.h"
+
+bool connect_mplane(ru_session_t *ru_session);
+
+void disconnect_mplane(void *rus_disconnect);
+
+#endif /* CONNECT_MPLANE_H */

radio/fhi_72/mplane/get-mplane.c

+/*
+ * 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
+ */
+
+#include "get-mplane.h"
+#include "rpc-send-recv.h"
+
+#include "common/utils/assertions.h"
+
+bool get_mplane(ru_session_t *ru_session, char **answer)
+{
+  int timeout = CLI_RPC_REPLY_TIMEOUT;
+  struct nc_rpc *rpc;
+  char *filter = NULL; // e.g. "/o-ran-delay-management:delay-management";
+  NC_WD_MODE wd = NC_WD_ALL;
+  NC_PARAMTYPE param = NC_PARAMTYPE_CONST;
+
+  MP_LOG_I("RPC request to RU \"%s\" = <get> operational datastore.\n", ru_session->ru_ip_add);
+  rpc = nc_rpc_get(filter, wd, param);
+  AssertError(rpc != NULL, return false, "[MPLANE] <get> RPC creation failed.\n");
+
+  bool success = rpc_send_recv((struct nc_session *)ru_session->session, rpc, wd, timeout, answer);
+  AssertError(success, return false, "[MPLANE] Unable to retrieve operational datastore.\n");
+
+  MP_LOG_I("Successfully retrieved operational datastore from RU \"%s\".\n", ru_session->ru_ip_add);
+
+  nc_rpc_free(rpc);
+
+  return true;
+}

radio/fhi_72/mplane/get-mplane.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 GET_MPLANE_H
+#define GET_MPLANE_H
+
+#include "ru-mplane-api.h"
+
+bool get_mplane(ru_session_t *ru_session, char **answer);
+
+#endif /* GET_MPLANE_H */

radio/fhi_72/mplane/init-mplane.c

+/*
+ * 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
+ */
+
+#include "init-mplane.h"
+#include "radio/fhi_72/oran-params.h"
+#include "get-mplane.h"
+#include "subscribe-mplane.h"
+#include "config-mplane.h"
+#include "xml/get-xml.h"
+
+#include <libyang/libyang.h>
+#include <nc_client.h>
+
+static void lnc2_print_clb(NC_VERB_LEVEL level, const char *msg)
+{
+  switch (level) {
+    case NC_VERB_ERROR:
+      MP_LOG_I("[LIBNETCONF2] ERROR: %s.\n", msg);
+      break;
+    case NC_VERB_WARNING:
+      MP_LOG_I("[LIBNETCONF2] WARNING: %s.\n", msg);
+      break;
+    case NC_VERB_VERBOSE:
+      MP_LOG_I("[LIBNETCONF2] VERBOSE: %s.\n", msg);
+      break;
+    case NC_VERB_DEBUG:
+    case NC_VERB_DEBUG_LOWLVL:
+      MP_LOG_I("[LIBNETCONF2] DEBUG: %s.\n", msg);
+      break;
+    default:
+      assert(false && "[LIBNETCONF2] Unknown log level.");
+  }
+}
+
+static void ly_print_clb(LY_LOG_LEVEL level, const char *msg, const char *path)
+{
+  switch (level) {
+    case LY_LLERR:
+      MP_LOG_I("[LIBYANG] ERROR: %s (path: %s).\n", msg, path);
+      break;
+    case LY_LLWRN:
+      MP_LOG_I("[LIBYANG] WARNING: %s (path: %s).\n", msg, path);
+      break;
+    case LY_LLVRB:
+      MP_LOG_I("[LIBYANG] VERBOSE: %s (path: %s).\n", msg, path);
+      break;
+    case LY_LLDBG:
+      MP_LOG_I("[LIBYANG] DEBUG: %s (path: %s).\n", msg, path);
+      break;
+    default:
+      assert(false && "[LIBYANG] Unknown log level.");
+  }
+}
+
+static const paramdef_t *gpd(const paramdef_t *pd, int num, const char *name)
+{
+  /* the config module does not know const-correctness... */
+  int idx = config_paramidx_fromname((paramdef_t *)pd, num, (char *)name);
+  DevAssert(idx >= 0);
+  return &pd[idx];
+}
+
+bool init_mplane(ru_session_list_t *ru_session_list)
+{
+  paramdef_t fhip[] = ORAN_GLOBALPARAMS_DESC;
+  int nump = sizeofArray(fhip);
+  int ret = config_get(config_get_if(), fhip, nump, CONFIG_STRING_ORAN);
+  if (ret <= 0) {
+    MP_LOG_I("Problem reading section \"%s\".\n", CONFIG_STRING_ORAN);
+    return false;
+  }
+
+  ru_session_list->du_key_pair = gpd(fhip, nump, ORAN_CONFIG_DU_KEYPAIR)->strlistptr;
+  int num_keys = gpd(fhip, nump, ORAN_CONFIG_DU_KEYPAIR)->numelt;
+  AssertError(num_keys == 2, return false, "[MPLANE] Expected {pub-key-path, priv-key-path}. Loaded {%s, %s}.\n", ru_session_list->du_key_pair[0], ru_session_list->du_key_pair[1]);
+
+  char **ru_ip_addrs = gpd(fhip, nump, ORAN_CONFIG_RU_IP_ADDR)->strlistptr;
+  int num_rus = gpd(fhip, nump, ORAN_CONFIG_RU_IP_ADDR)->numelt;
+  char **du_mac_addr = gpd(fhip, nump, ORAN_CONFIG_DU_ADDR)->strlistptr;
+  int num_dus = gpd(fhip, nump, ORAN_CONFIG_DU_ADDR)->numelt;
+  int32_t *vlan_tag = gpd(fhip, nump, ORAN_CONFIG_VLAN_TAG)->iptr;
+  int num_vlan_tags = gpd(fhip, nump, ORAN_CONFIG_VLAN_TAG)->numelt;
+
+  AssertError(num_dus == num_vlan_tags, return false, "[MPLANE] Number of DU MAC addresses should be equal to the number of VLAN tags.\n");
+ 
+  int num_cu_planes = num_dus / num_rus;
+
+  ru_session_list->num_rus = num_rus;
+  ru_session_list->ru_session = calloc(num_rus, sizeof(ru_session_t));
+  for (size_t i = 0; i < num_rus; i++) {
+    ru_session_t *ru_session = &ru_session_list->ru_session[i];
+    ru_session->session = NULL;
+    ru_session->ru_ip_add = calloc(strlen(ru_ip_addrs[i]) + 1, sizeof(char));
+    memcpy(ru_session->ru_ip_add, ru_ip_addrs[i], strlen(ru_ip_addrs[i]) + 1);
+
+    // store DU MAC addresses and VLAN tags
+    ru_session->ru_mplane_config.num_cu_planes = num_cu_planes;
+    ru_session->ru_mplane_config.du_mac_addr = calloc_or_fail(num_cu_planes, sizeof(char*));
+    ru_session->ru_mplane_config.vlan_tag = calloc_or_fail(num_cu_planes, sizeof(int32_t));
+    for (int j = 0; j < num_cu_planes; j++) {
+      const int idx = i*num_cu_planes+j;
+      ru_session->ru_mplane_config.du_mac_addr[j] = calloc(1, strlen(du_mac_addr[idx]) + 1);
+      memcpy(ru_session->ru_mplane_config.du_mac_addr[j], du_mac_addr[idx], strlen(du_mac_addr[idx]) + 1);
+      ru_session->ru_mplane_config.vlan_tag[j] = vlan_tag[idx];
+    }
+  }
+
+  nc_client_init();
+  int keypair_ret = nc_client_ssh_add_keypair(ru_session_list->du_key_pair[0], ru_session_list->du_key_pair[1]);
+  AssertError(keypair_ret == 0, return false, "[MPLANE] Unable to add DU ssh key pair.\n");
+
+  // logs for netconf2 and yang libraries
+  nc_set_print_clb(lnc2_print_clb); 
+  ly_set_log_clb(ly_print_clb, 1);
+
+  return true;
+}
+
+bool manage_ru(ru_session_t *ru_session, const openair0_config_t *oai, const size_t num_rus)
+{
+  bool success = false;
+
+  char *operational_ds = NULL;
+  success = get_mplane(ru_session, &operational_ds);
+  AssertError(success, return false, "[MPLANE] Unable to continue: could not get RU answer via get_mplane().\n");
+
+  bool ptp_state = false;
+  const char *sync_state = get_ru_xml_node(operational_ds, "sync-state");
+  if (strcmp(sync_state, "LOCKED") == 0) {
+    MP_LOG_I("RU is already PTP synchronized.\n");
+    ptp_state = true;
+  }
+
+  /* 1) as per M-plane spec, RU must be in supervised mode,
+        where stream = NULL && filter = "/o-ran-supervision:supervision-notification";
+     2) additionally, we want to subscribe to PTP state change,
+        where stream = NULL && filter = "/o-ran-sync:synchronization-state-change";
+    => since more than one subscription at the time within one session is not possible, we will subscribe to all notifications */
+  const char *stream = "NETCONF";
+  const char *filter = NULL;
+  ru_session->ru_notif.ptp_state = ptp_state;
+  success = subscribe_mplane(ru_session, stream, filter, (void *)&ru_session->ru_notif);
+  AssertError(success, return false, "[MPLANE] Unable to continue: could not get RU answer via subscribe_mplane().\n");
+
+  // when subscribed to the supervision notification, the watchdog timer needs to be updated
+  char *watchdog_answer = NULL;
+  success = update_timer_mplane(ru_session, &watchdog_answer);
+  AssertError(success, return false, "[MPLANE] Unable to update the watchdog timer. RU will do a reset after default supervision timer of (60+10)[s] expires.\n");
+  MP_LOG_I("Watchdog timer answer: \n\t%s\n", watchdog_answer);
+
+  // save RU info for xran
+  const int max_num_ant = max(oai->tx_num_channels/num_rus, oai->rx_num_channels/num_rus);
+  success = get_config_for_xran(operational_ds, max_num_ant, &ru_session->xran_mplane);
+  AssertError(success, return false, "[MPLANE] Unable to retrieve required info for xran from RU \"%s\".\n", ru_session->ru_ip_add);
+
+  // save the U-plane info
+  success = get_uplane_info(operational_ds, &ru_session->ru_mplane_config);
+  AssertError(success, return false, "[MPLANE] Unable to get U-plane info from RU operational datastore.\n");
+
+  if (ru_session->ru_notif.ptp_state) {
+    success = edit_config_mplane(ru_session, operational_ds, oai, num_rus);
+    AssertError(success, return false, "[MPLANE] Unable to edit the RU configuration.\n");
+
+    success = validate_config_mplane(ru_session);
+    AssertError(success, return false, "[MPLANE] Unable to validate the RU configuration.\n");
+
+    success = commit_config_mplane(ru_session);
+    AssertError(success, return false, "[MPLANE] Unable to commit the RU configuration.\n");
+  }
+
+  const char *usage_state = get_ru_xml_node(operational_ds, "usage-state");
+  MP_LOG_I("Usage state = \"%s\" for RU \"%s\".\n", usage_state, ru_session->ru_ip_add);
+  if (strcmp(usage_state, "busy") == 0) { // carriers are already activated
+    ru_session->ru_notif.rx_carrier_state = true;
+    ru_session->ru_notif.tx_carrier_state = true;
+    ru_session->ru_notif.config_change = true;
+  } else {
+    ru_session->ru_notif.rx_carrier_state = false;
+    ru_session->ru_notif.tx_carrier_state = false;
+    ru_session->ru_notif.config_change = false;
+  }
+
+  free(operational_ds);
+  free(watchdog_answer);
+
+  return true;
+}

radio/fhi_72/mplane/init-mplane.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 OAI_MPLANE_H
+#define OAI_MPLANE_H
+
+#include "ru-mplane-api.h"
+#include "radio/COMMON/common_lib.h"
+
+bool init_mplane(ru_session_list_t *ru_session_list);
+
+bool manage_ru(ru_session_t *ru_session, const openair0_config_t *oai, const size_t num_rus);
+
+#endif /* OAI_MPLANE_H */

radio/fhi_72/mplane/rpc-send-recv.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 RPC_SEND_RECEIVE_MPLANE_H
+#define RPC_SEND_RECEIVE_MPLANE_H
+
+#include "ru-mplane-api.h"
+
+#include <libyang/libyang.h>
+#include <nc_client.h>
+
+#define CLI_RPC_REPLY_TIMEOUT 60000   // time [ms] to wait for server reply
+
+bool rpc_send_recv(struct nc_session *session, struct nc_rpc *rpc, const NC_WD_MODE wd_mode, const int timeout_ms, char **answer);
+
+#endif /* RPC_SEND_RECEIVE_MPLANE_H */

radio/fhi_72/mplane/ru-mplane-api.c

+/*
+ * 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
+ */
+
+#include "ru-mplane-api.h"
+#include "xml/get-xml.h"
+#include "common/utils/assertions.h"
+
+#include <string.h>
+
+static void free_match_list(char **match_list, size_t count)
+{
+  for (size_t i = 0; i < count; i++) {
+    free(match_list[i]);
+  }
+  free(match_list);
+}
+
+static void fix_benetel_setting(xran_mplane_t *xran_mplane, const uint32_t interface_mtu, const int16_t first_iq_width, const int max_num_ant)
+{
+  if (interface_mtu == 1500) {
+    MP_LOG_I("Interface MTU %d unreliable/not correctly reported by Benetel O-RU, hardcoding to 9600.\n", interface_mtu);
+    xran_mplane->mtu = 9600;
+  } else {
+    xran_mplane->mtu = interface_mtu;
+  }
+
+  if (first_iq_width != 9) {
+    MP_LOG_I("IQ bitwidth %d unreliable/not correctly reported by Benetel O-RU, hardcoding to 9.\n", first_iq_width);
+    xran_mplane->iq_width = 9;
+  } else {
+    xran_mplane->iq_width = first_iq_width;
+  }
+
+  xran_mplane->prach_offset = max_num_ant;
+}
+
+bool get_config_for_xran(const char *buffer, const int max_num_ant, xran_mplane_t *xran_mplane)
+{
+  /* some O-RU vendors are not fully compliant as per M-plane specifications */
+  const char *ru_vendor = get_ru_xml_node(buffer, "mfg-name");
+
+  // RU MAC
+  xran_mplane->ru_mac_addr = get_ru_xml_node(buffer, "mac-address"); // TODO: support for VVDN, as it defines multiple MAC addresses
+
+  // MTU
+  const uint32_t interface_mtu = (uint32_t)atoi(get_ru_xml_node(buffer, "interface-mtu"));
+
+  // IQ bitwidth
+  char **match_list = NULL;
+  size_t count = 0;
+  get_ru_xml_list(buffer, "iq-bitwidth", &match_list, &count);
+  const int16_t first_iq_width = (int16_t)atoi((char *)match_list[0]);
+  free_match_list(match_list, count);
+
+  // PRACH offset
+  // xran_mplane->prach_offset
+
+  // DU port ID bitmask
+  xran_mplane->du_port_bitmask = 0xf000;
+  // Band sector bitmask
+  xran_mplane->band_sector_bitmask = 0x0f00;
+  // CC ID bitmask
+  xran_mplane->ccid_bitmask = 0x00f0;
+  // RU port ID bitmask
+  xran_mplane->ru_port_bitmask = 0x000f;
+
+  // DU port ID
+  xran_mplane->du_port = 0;
+  // Band sector
+  xran_mplane->band_sector = 0;
+  // CC ID
+  xran_mplane->ccid = 0;
+  // RU port ID
+  xran_mplane->ru_port = 0;
+
+  if (strcasecmp(ru_vendor, "BENETEL") == 0 /* || strcmp(ru_vendor, "VVDN-LPRU") == 0 || strcmp(ru_vendor, "Metanoia") == 0 */) {
+    fix_benetel_setting(xran_mplane, interface_mtu, first_iq_width, max_num_ant);
+  } else {
+    AssertError(false, return false, "[MPLANE] %s RU currently not supported.\n", ru_vendor);
+  }
+
+  MP_LOG_I("Storing the following information to forward to xran:\n\
+    RU MAC address %s\n\
+    MTU %d\n\
+    IQ bitwidth %d\n\
+    PRACH offset %d\n\
+    DU port bitmask %d\n\
+    Band sector bitmask %d\n\
+    CC ID bitmask %d\n\
+    RU port ID bitmask %d\n\
+    DU port ID %d\n\
+    Band sector ID %d\n\
+    CC ID %d\n\
+    RU port ID %d\n",
+      xran_mplane->ru_mac_addr,
+      xran_mplane->mtu,
+      xran_mplane->iq_width,
+      xran_mplane->prach_offset,
+      xran_mplane->du_port_bitmask,
+      xran_mplane->band_sector_bitmask,
+      xran_mplane->ccid_bitmask,
+      xran_mplane->ru_port_bitmask,
+      xran_mplane->du_port,
+      xran_mplane->band_sector,
+      xran_mplane->ccid,
+      xran_mplane->ru_port);
+
+  return true;
+}
+
+bool get_uplane_info(const char *buffer, ru_mplane_config_t *ru_mplane_config)
+{
+  // Interface name
+  ru_mplane_config->interface_name = get_ru_xml_node(buffer, "interface");
+
+  // PDSCH
+  uplane_info_t *tx_end = &ru_mplane_config->tx_endpoints;
+  get_ru_xml_list(buffer, "static-low-level-tx-endpoints", &tx_end->name, &tx_end->num);
+  AssertError(tx_end->name != NULL, return false, "[MPLANE] Cannot get TX endpoint names.\n");
+
+  // TX carriers
+  uplane_info_t *tx_carriers = &ru_mplane_config->tx_carriers;
+  get_ru_xml_list(buffer, "tx-arrays", &tx_carriers->name, &tx_carriers->num);
+  AssertError(tx_carriers->name != NULL, return false, "[MPLANE] Cannot get TX carrier names.\n");
+
+  // PUSCH and PRACH
+  uplane_info_t *rx_end = &ru_mplane_config->rx_endpoints;
+  get_ru_xml_list(buffer, "static-low-level-rx-endpoints", &rx_end->name, &rx_end->num);
+  AssertError(rx_end->name != NULL, return false, "[MPLANE] Cannot get RX endpoint names.\n");
+
+  // RX carriers
+  uplane_info_t *rx_carriers = &ru_mplane_config->rx_carriers;
+  get_ru_xml_list(buffer, "rx-arrays", &rx_carriers->name, &rx_carriers->num);
+  AssertError(rx_carriers->name != NULL, return false, "[MPLANE] Cannot get RX carrier names.\n");
+
+  MP_LOG_I("Successfully retrieved all the U-plane info - interface name, TX/RX carrier names, and TX/RX endpoint names.\n");
+
+  return true;
+}

radio/fhi_72/mplane/ru-mplane-api.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 RU_MPLANE_API_H
+#define RU_MPLANE_API_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#include "common/utils/LOG/log.h"
+
+#define MP_LOG_I(x, args...) LOG_I(HW, "[MPLANE] " x, ##args)
+#define MP_LOG_W(x, args...) LOG_W(HW, "[MPLANE] " x, ##args)
+
+typedef struct {
+  bool ptp_state;
+  bool rx_carrier_state;
+  bool tx_carrier_state;
+  bool config_change;
+  // to be extended with any notification callback
+
+} ru_notif_t;
+
+typedef struct {
+  char *ru_mac_addr;
+  uint32_t mtu;
+  int16_t iq_width;
+  uint8_t prach_offset;
+
+  // DU sends to RU and xran
+  uint16_t du_port_bitmask;
+  uint16_t band_sector_bitmask;
+  uint16_t ccid_bitmask;
+  uint16_t ru_port_bitmask;
+
+  // DU retrieves from RU, and sends to xran
+  uint8_t du_port;
+  uint8_t band_sector;
+  uint8_t ccid;
+  uint8_t ru_port;
+
+} xran_mplane_t;
+
+typedef struct {
+  size_t num;
+  char **name;
+} uplane_info_t;
+
+typedef struct {
+  size_t num_cu_planes;
+  char **du_mac_addr; // one or two VF(s) for CU-planes
+  int32_t *vlan_tag;  // one or two VF(s) for CU-planes
+  char *interface_name;
+  uplane_info_t tx_endpoints;
+  uplane_info_t rx_endpoints;
+  uplane_info_t tx_carriers;
+  uplane_info_t rx_carriers;
+
+} ru_mplane_config_t;
+
+typedef struct {
+  char *ru_ip_add;
+  ru_mplane_config_t ru_mplane_config;
+  void *session;
+  xran_mplane_t xran_mplane;
+  ru_notif_t ru_notif;
+
+} ru_session_t;
+
+typedef struct {
+  size_t num_rus;
+  ru_session_t *ru_session;
+  char **du_key_pair;
+
+} ru_session_list_t;
+
+bool get_config_for_xran(const char *buffer, const int max_num_ant, xran_mplane_t *xran_mplane);
+
+bool get_uplane_info(const char *buffer, ru_mplane_config_t *ru_mplane_config);
+
+#endif /* RU_MPLANE_API_H */

radio/fhi_72/mplane/subscribe-mplane.c

+/*
+ * 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
+ */
+
+#include "subscribe-mplane.h"
+#include "rpc-send-recv.h"
+#include "common/utils/assertions.h"
+
+#include <libyang/libyang.h>
+#include <nc_client.h>
+
+#ifdef MPLANE_V1
+static void recv_notif_v1(const struct nc_notif *notif, ru_notif_t *answer)
+{
+  const char *node_name = notif->tree->child->attr->name;
+  const char *value = notif->tree->child->attr->value_str;
+  if (strcmp(node_name, "sync-state")) {
+    if (strcmp(value, "LOCKED") == 0) {
+      answer->ptp_state = true;
+    } else {
+      answer->ptp_state = false;
+    }
+  }
+
+  // carriers state - to be filled
+}
+
+static void notif_clb_v1(struct nc_session *session, const struct nc_notif *notif)
+{
+  ru_notif_t *answer = nc_session_get_data(session);
+  LYD_FORMAT output_format = LYD_JSON;
+
+  char *subs_reply = NULL;
+  lyd_print_mem(&subs_reply, notif->tree, output_format, LYP_WITHSIBLINGS);
+  MP_LOG_I("\nReceived notification at (%s)\n%s\n", notif->datetime, subs_reply);
+
+  recv_notif_v1(notif, answer);
+}
+#elif MPLANE_V2
+static void recv_notif_v2(struct lyd_node_inner *op, ru_notif_t *answer)
+{
+  const char *notif = op->schema->name;
+
+  if (strcmp(notif, "synchronization-state-change") == 0) {
+    const char *value = lyd_get_value(op->child);
+    if (strcmp(value, "LOCKED") == 0) {
+      answer->ptp_state = true;
+    } else { // "FREERUN" or "HOLDOVER"
+      answer->ptp_state = false;
+    }
+  } else if (strcmp(notif, "rx-array-carriers-state-change") == 0) {
+    const char *value = lyd_get_value(lyd_child(op->child)->next);
+    if (strcmp(value, "READY") == 0) {
+      answer->rx_carrier_state = true;
+    } else { // "DISABLED" or "BUSY"
+      answer->rx_carrier_state = false;
+    }
+  } else if (strcmp(notif, "tx-array-carriers-state-change") == 0) {
+    const char *value = lyd_get_value(lyd_child(op->child)->next);
+    if (strcmp(value, "READY") == 0) {
+      answer->tx_carrier_state = true;
+    } else { // "DISABLED" or "BUSY"
+      answer->tx_carrier_state = false;
+    }
+  } else if (strcmp(notif, "netconf-config-change") == 0) {
+    answer->config_change = true;
+  }
+}
+
+static void notif_clb_v2(struct nc_session *session, const struct lyd_node *envp, const struct lyd_node *op, void *user_data)
+{
+  ru_notif_t *answer = (ru_notif_t *)user_data;
+  LYD_FORMAT output_format = LYD_JSON;
+
+  char *subs_reply = NULL;
+  lyd_print_mem(&subs_reply, op, output_format, LYD_PRINT_WITHSIBLINGS);
+  const char *ru_ip_add = nc_session_get_host(session);
+  MP_LOG_I("Received notification from RU \"%s\" at (%s)\n%s\n", ru_ip_add, ((struct lyd_node_opaq *)lyd_child(envp))->value, subs_reply);
+
+  recv_notif_v2((struct lyd_node_inner *)op, answer);
+}
+#endif
+
+bool subscribe_mplane(ru_session_t *ru_session, const char *stream, const char *filter, void *answer)
+{
+  int timeout = CLI_RPC_REPLY_TIMEOUT;
+  struct nc_rpc *rpc;
+  NC_WD_MODE wd = NC_WD_ALL;
+  NC_PARAMTYPE param = NC_PARAMTYPE_CONST;
+  char *start_time = NULL, *stop_time = NULL;
+
+  MP_LOG_I("RPC request to RU \"%s\" = <subscribe> with stream \"%s\" and filter \"%s\".\n", ru_session->ru_ip_add, stream, filter);
+  rpc = nc_rpc_subscribe(stream, NULL, start_time, stop_time, param);
+  AssertError(rpc != NULL, return false, "[MPLANE] <subscribe> RPC creation failed.\n");
+
+  /* create notification thread so that notifications can immediately be received */
+#ifdef MPLANE_V1
+  if (!nc_session_ntf_thread_running(ru_session->session)) {
+    nc_session_set_data(ru_session->session, answer);
+    int ret = nc_recv_notif_dispatch(ru_session->session, notif_clb_v1);
+    AssertError(ret == 0, return false, "[MPLANE] Failed to create notification thread.\n");
+  } else {
+    MP_LOG_I("Notification thread is already running for RU %s.\n", ru_session->ru_ip_add);
+  }
+#elif MPLANE_V2
+  int ret = nc_recv_notif_dispatch_data(ru_session->session, notif_clb_v2, answer, NULL);
+  AssertError(ret == 0, return false, "[MPLANE] Failed to create notification thread.\n");
+#endif
+
+  bool success = rpc_send_recv((struct nc_session *)ru_session->session, rpc, wd, timeout, NULL);
+  AssertError(success, return false, "[MPLANE] Failed to subscribe to: stream \"%s\", filter \"%s\".\n", stream, filter);
+
+  MP_LOG_I("Successfully subscribed to all notifications from RU \"%s\".\n", ru_session->ru_ip_add);
+
+  nc_rpc_free(rpc);
+
+  return true;
+}
+
+bool update_timer_mplane(ru_session_t *ru_session, char **answer)
+{
+  int timeout = CLI_RPC_REPLY_TIMEOUT;
+  struct nc_rpc *rpc;
+  NC_WD_MODE wd = NC_WD_ALL;
+  NC_PARAMTYPE param = NC_PARAMTYPE_CONST;
+  const char *content = "<supervision-watchdog-reset xmlns=\"urn:o-ran:supervision:1.0\">\n\
+<supervision-notification-interval>65535</supervision-notification-interval>\n\
+<guard-timer-overhead>65535</guard-timer-overhead>\n\
+</supervision-watchdog-reset>";
+
+  MP_LOG_I("RPC request to RU \"%s\" = \"%s\".\n", ru_session->ru_ip_add, content);
+  rpc = nc_rpc_act_generic_xml(content, param);
+  AssertError(rpc != NULL, return false, "[MPLANE] <supervision-watchdog-reset> RPC creation failed.\n");
+
+  bool success = rpc_send_recv((struct nc_session *)ru_session->session, rpc, wd, timeout, answer);
+  AssertError(success, return false, "[MPLANE] Failed to update the watchdog timer.\n");
+
+  MP_LOG_I("Successfully updated supervision timer to (65535+65535)[s] for RU \"%s\".\n", ru_session->ru_ip_add);
+
+  nc_rpc_free(rpc);
+
+  return true;
+}

radio/fhi_72/mplane/subscribe-mplane.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 SUBSCRIBE_MPLANE_H
+#define SUBSCRIBE_MPLANE_H
+
+#include "ru-mplane-api.h"
+
+#include <stdbool.h>
+
+bool subscribe_mplane(ru_session_t *ru_session, const char *stream, const char *filter, void *answer);
+
+bool update_timer_mplane(ru_session_t *ru_session, char **answer);
+
+#endif /* SUBSCRIBE_MPLANE_H */

radio/fhi_72/mplane/xml/get-xml.c

+/*
+ * 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
+ */
+
+#include "get-xml.h"
+
+#include <libxml/parser.h>
+#include <string.h>
+
+static char *find_ru_xml_node(xmlNode *node, const char *filter)
+{
+  for (xmlNode *cur_node = node; cur_node; cur_node = cur_node->next) {
+    if (cur_node->type != XML_ELEMENT_NODE)
+      continue;
+
+    if (strcmp((const char *)cur_node->name, filter) == 0) {
+      xmlNode *target_node = cur_node;
+
+      for(xmlNode *cur_node2 = cur_node->children; cur_node2; cur_node2 = cur_node2->next) {
+        if (cur_node2->type == XML_ELEMENT_NODE && strcmp((const char *)cur_node2->name, "name") == 0) {
+          target_node = cur_node2;
+          break;
+        }
+      }
+      return (char *)xmlNodeGetContent(target_node);
+    }
+    char *answer = find_ru_xml_node(cur_node->children, filter);
+    if (answer != NULL) {
+      return answer;
+    }
+  }
+  return NULL;
+}
+
+char *get_ru_xml_node(const char *buffer, const char *filter)
+{
+  // Initialize the xml file
+  size_t len = strlen(buffer) + 1;
+  xmlDoc *doc = xmlReadMemory(buffer, len, NULL, NULL, 0);
+  xmlNode *root_element = xmlDocGetRootElement(doc);
+
+  return find_ru_xml_node(root_element->children, filter);
+}
+
+static void find_ru_xml_list(xmlNode *node, const char *filter, char ***match_list, size_t *count)
+{
+  for (xmlNode *cur_node = node; cur_node; cur_node = cur_node->next) {
+    if (cur_node->type != XML_ELEMENT_NODE)
+      continue;
+    if (strcmp((const char *)cur_node->name, filter) == 0) {
+      xmlNode *name_node = NULL;
+
+      for (xmlNode *cur_node2 = cur_node->children; cur_node2; cur_node2 = cur_node2->next) {
+        if (cur_node2->type == XML_ELEMENT_NODE && strcmp((const char *)cur_node2->name, "name") == 0) {
+          name_node = cur_node2;
+          break;
+        }
+      }
+      const char *content = (const char *)xmlNodeGetContent(name_node ? name_node : cur_node);
+      if (content) {
+        *match_list = realloc(*match_list, (*count + 1) * sizeof(char *));
+        (*match_list)[*count] = strdup(content);
+        (*count)++;
+      }
+    }
+    find_ru_xml_list(cur_node->children, filter, match_list, count);
+  }
+}
+
+void get_ru_xml_list(const char *buffer, const char *filter, char ***match_list, size_t *count)
+{
+  // Initialize the xml file
+  size_t len = strlen(buffer) + 1;
+  xmlDoc *doc = xmlReadMemory(buffer, len, NULL, NULL, 0);
+  xmlNode *root_element = xmlDocGetRootElement(doc);
+
+  find_ru_xml_list(root_element->children, filter, match_list, count);
+}

radio/fhi_72/mplane/xml/get-xml.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 GET_MPLANE_INFO_XML_H
+#define GET_MPLANE_INFO_XML_H
+
+#include <stdio.h>
+#include <stdbool.h>
+
+/**
+ * @brief retrieves the node value that matches filter.
+ *
+ * @param[in] buffer Buffer in xml format.
+ * @param[in] filter The node name (matching criteria).
+ * @return Expected one string that matches the node name.
+ */
+char *get_ru_xml_node(const char *buffer, const char *filter);
+
+/**
+ * @brief retrieves the node values that matches filter.
+ *
+ * @param[in] buffer Buffer in xml format.
+ * @param[in] filter The node name (matching criteria).
+ * @param[out] match_list Resulting list containing node values.
+ * @param[out] count The number of nodes that match criteria.
+ * @return Void.
+ */
+void get_ru_xml_list(const char *buffer, const char *filter, char ***match_list, size_t *count);
+
+#endif /* GET_MPLANE_INFO_XML_H */

radio/fhi_72/mplane/yang/create-yang-config.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 CREATE_MPLANE_YANG_CONFIG_H
+#define CREATE_MPLANE_YANG_CONFIG_H
+
+#include "../ru-mplane-api.h"
+#include "radio/COMMON/common_lib.h"
+
+#include <libyang/libyang.h>
+
+bool configure_ru_from_yang(struct ly_ctx **ctx, const ru_session_t *ru_session, const openair0_config_t *oai, const size_t num_rus, char **result);
+
+#endif /* CREATE_MPLANE_YANG_CONFIG_H */

radio/fhi_72/mplane/yang/get-yang.c

+/*
+ * 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
+ */
+
+#include "get-yang.h"
+#include "../rpc-send-recv.h"
+#include "common/utils/assertions.h"
+
+#include <libxml/parser.h>
+
+static bool store_schemas(xmlNode *node, ru_session_t *ru_session, struct ly_ctx **ctx)
+{
+  int timeout = CLI_RPC_REPLY_TIMEOUT;
+  NC_WD_MODE wd = NC_WD_ALL;
+  NC_PARAMTYPE param = NC_PARAMTYPE_CONST;
+  LYS_INFORMAT ly_format = LYS_IN_YANG;
+
+#ifdef MPLANE_V1
+  *ctx = ly_ctx_new(NULL, 0);
+#elif defined MPLANE_V2
+  ly_ctx_new(NULL, 0, ctx);
+#endif
+
+  for (xmlNode *cur_node = node; cur_node; cur_node = cur_node->next) {
+    if (strcmp((const char *)cur_node->name, "schema") == 0) {
+
+      xmlNode *name_node = xmlFirstElementChild(cur_node);
+      char *module_name = (char *)xmlNodeGetContent(name_node);
+      xmlNode *revision_node = xmlNextElementSibling(name_node);
+      char *module_revision = (char *)xmlNodeGetContent(revision_node);
+      xmlNode *format_node = xmlNextElementSibling(revision_node);
+      char *module_format = (char *)xmlNodeGetContent(format_node);
+
+      if (strcmp(module_format, "yang") != 0)
+        continue;
+
+      MP_LOG_I("RPC request to RU \"%s\" = <get-schema> for module \"%s\".\n", ru_session->ru_ip_add, module_name);
+      struct nc_rpc *get_schema_rpc = nc_rpc_getschema(module_name, module_revision, "yang", param);
+      char *schema_data = NULL;
+      bool success = rpc_send_recv((struct nc_session *)ru_session->session, get_schema_rpc, wd, timeout, &schema_data);
+      AssertError(success, return false, "[MPLANE] Unable to get schema for module \"%s\" from RU \"%s\".\n", module_name, ru_session->ru_ip_add);
+
+      if (schema_data) {
+#ifdef MPLANE_V1
+        const struct lys_module *mod = lys_parse_mem(*ctx, schema_data, ly_format);
+#elif defined MPLANE_V2
+        struct lys_module *mod = NULL;
+        lys_parse_mem(*ctx, schema_data, ly_format, &mod);
+#endif
+        free(schema_data);
+        if (!mod) {
+          MP_LOG_W("Unable to load module \"%s\" from RU \"%s\".\n", module_name, ru_session->ru_ip_add);
+	        nc_rpc_free(get_schema_rpc);
+          ly_ctx_destroy(*ctx);
+	        return false;
+	      }
+      }
+      nc_rpc_free(get_schema_rpc);
+    }
+  }
+
+  return true;
+}
+
+static bool load_from_operational_ds(xmlNode *node, ru_session_t *ru_session, struct ly_ctx **ctx)
+{
+  for (xmlNode *schemas_node = node; schemas_node; schemas_node = schemas_node->next) {
+    if(schemas_node->type != XML_ELEMENT_NODE)
+      continue;
+    if (strcmp((const char *)schemas_node->name, "schemas") == 0) {
+      return store_schemas(schemas_node->children, ru_session, ctx);
+    } else {
+      bool success = load_from_operational_ds(schemas_node->children, ru_session, ctx);
+      if (success)
+        return true;
+    }
+  }
+  return false;
+}
+
+bool load_yang_models(ru_session_t *ru_session, const char *buffer, struct ly_ctx **ctx)
+{
+  // Initialize the xml file
+  size_t len = strlen(buffer) + 1;
+  xmlDoc *doc = xmlReadMemory(buffer, len, NULL, NULL, 0);
+  xmlNode *root_element = xmlDocGetRootElement(doc);
+
+  bool success = load_from_operational_ds(root_element->children, ru_session, ctx);
+  if (success) {
+    MP_LOG_I("Successfully loaded all yang modules from operational datastore for RU \"%s\".\n", ru_session->ru_ip_add);
+    return true;
+  } else {
+    MP_LOG_W("Unable to load all yang modules from operational datastore for RU \"%s\". Using yang models present in \"models\" subfolder.\n", ru_session->ru_ip_add);
+  }
+
+  /* ideally, we should load the yang models from the operational datastore, but the issues are following:
+    1) the yang models order is not good - the dependancy models have to be loaded first
+    2) earlier O-RAN yang versions (e.g. v4) is not properly defined (i.e. optional parameters should not be included by default) */
+  const char *yang_dir = YANG_MODELS;
+  const char *yang_models[] = {"ietf-interfaces", "iana-if-type", "ietf-ip", "iana-hardware", "ietf-hardware", "o-ran-interfaces", "o-ran-module-cap", "o-ran-compression-factors", "o-ran-processing-element", "o-ran-uplane-conf"};
+
+#ifdef MPLANE_V1
+  *ctx = ly_ctx_new(yang_dir, 0);
+  AssertError(*ctx != NULL, return false, "[MPLANE] Unable to create libyang context: %s.\n", ly_errmsg(*ctx));
+#elif defined MPLANE_V2
+  LY_ERR ret = ly_ctx_new(yang_dir, 0, ctx);
+  AssertError(ret == LY_SUCCESS, return false, "[MPLANE] Unable to create libyang context: %s.\n", ly_errmsg(*ctx));
+#endif
+
+  const size_t num_models = sizeof(yang_models) / sizeof(yang_models[0]);
+  for (size_t i = 0; i < num_models; ++i) {
+#ifdef MPLANE_V1
+    const struct lys_module *mod = ly_ctx_load_module(*ctx, yang_models[i], NULL);
+    AssertError(mod != NULL, return false, "[MPLANE] Failed to load yang model %s.\n", yang_models[i]);
+#elif defined MPLANE_V2
+    const struct lys_module *mod = ly_ctx_load_module(*ctx, yang_models[i], NULL, NULL);
+    AssertError(mod != NULL, return false, "[MPLANE] Failed to load yang model %s.\n", yang_models[i]);
+#endif
+  }
+
+  MP_LOG_I("Successfully loaded all yang modules for RU \"%s\".\n", ru_session->ru_ip_add);
+
+  return true;
+}

radio/fhi_72/mplane/yang/get-yang.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 GET_MPLANE_YANG_MODELS_H
+#define GET_MPLANE_YANG_MODELS_H
+
+#include "../ru-mplane-api.h"
+
+#include <libyang/libyang.h>
+
+bool load_yang_models(ru_session_t *ru_session, const char *buffer, struct ly_ctx **ctx);
+
+#endif /* GET_MPLANE_YANG_MODELS_H */

radio/fhi_72/mplane/yang/models/iana-hardware.yang

+module iana-hardware {
+yang-version 1.1;
+namespace "urn:ietf:params:xml:ns:yang:iana-hardware";
+prefix ianahw;
+
+organization "IANA";
+contact
+  "        Internet Assigned Numbers Authority
+   Postal: ICANN
+           12025 Waterfront Drive, Suite 300
+           Los Angeles, CA  90094-2536
+           United States of America
+   Tel:    +1 310 301 5800
+   E-Mail: iana@iana.org>";
+
+description
+  "IANA-defined identities for hardware class.
+   The latest revision of this YANG module can be obtained from
+   the IANA website.
+   Requests for new values should be made to IANA via
+   email (iana@iana.org).
+   Copyright (c) 2018 IETF Trust and the persons identified as
+   authors of the code.  All rights reserved.
+   Redistribution and use in source and binary forms, with or
+   without modification, is permitted pursuant to, and subject
+   to the license terms contained in, the Simplified BSD License
+   set forth in Section 4.c of the IETF Trust's Legal Provisions
+   Relating to IETF Documents
+   (https://trustee.ietf.org/license-info).
+   The initial version of this YANG module is part of RFC 8348;
+   see the RFC itself for full legal notices.";
+reference
+  "https://www.iana.org/assignments/yang-parameters";
+
+revision 2018-03-13 {
+  description
+    "Initial revision.";
+  reference
+    "RFC 8348: A YANG Data Model for Hardware Management";
+}
+
+/*
+ * Identities
+ */
+
+identity hardware-class {
+  description
+    "This identity is the base for all hardware class
+     identifiers.";
+}
+
+identity unknown {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is unknown
+     to the server.";
+}
+
+identity chassis {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is an
+     overall container for networking equipment.  Any class of
+     physical component, except a stack, may be contained within a
+     chassis; a chassis may only be contained within a stack.";
+}
+
+identity backplane {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is some sort
+     of device for aggregating and forwarding networking traffic,
+     such as a shared backplane in a modular ethernet switch.  Note
+     that an implementation may model a backplane as a single
+     physical component, which is actually implemented as multiple
+     discrete physical components (within a chassis or stack).";
+}
+
+identity container {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is capable
+     of containing one or more removable physical entities,
+     possibly of different types.  For example, each (empty or
+     full) slot in a chassis will be modeled as a container.  Note
+     that all removable physical components should be modeled
+     within a container component, such as field-replaceable
+     modules, fans, or power supplies.  Note that all known
+     containers should be modeled by the agent, including empty
+     containers.";
+}
+
+identity power-supply {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is a
+     power-supplying component.";
+}
+
+identity fan {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is a fan or
+     other heat-reduction component.";
+}
+
+identity sensor {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is some sort
+     of sensor, such as a temperature sensor within a router
+     chassis.";
+}
+
+identity module {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is some sort
+     of self-contained sub-system.  If a module component is
+     removable, then it should be modeled within a container
+     component; otherwise, it should be modeled directly within
+     another physical component (e.g., a chassis or another
+     module).";
+}
+
+identity port {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is some sort
+     of networking port capable of receiving and/or transmitting
+     networking traffic.";
+}
+
+identity stack {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is some sort
+     of super-container (possibly virtual) intended to group
+     together multiple chassis entities.  A stack may be realized
+     by a virtual cable, a real interconnect cable attached to
+     multiple chassis, or multiple interconnect cables.  A stack
+     should not be modeled within any other physical components,
+     but a stack may be contained within another stack.  Only
+     chassis components should be contained within a stack.";
+}
+
+identity cpu {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is some sort
+     of central processing unit.";
+}
+
+identity energy-object {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is some sort
+     of energy object, i.e., it is a piece of equipment that is
+     part of or attached to a communications network that is
+     monitored, it is controlled, or it aids in the management of
+     another device for Energy Management.";
+}
+
+identity battery {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is some sort
+     of battery.";
+}
+
+identity storage-drive {
+  base ianahw:hardware-class;
+  description
+    "This identity is applicable if the hardware class is some sort
+     of component with data storage capability as its main
+     functionality, e.g., hard disk drive (HDD), solid-state device
+     (SSD), solid-state hybrid drive (SSHD), object storage device
+     (OSD), or other.";
+}
+}

radio/fhi_72/oran-config.h

@@ -29,7 +29,7 @@ struct xran_fh_init;
 struct xran_fh_config;
 struct openair0_config;
 
-bool get_xran_config(const struct openair0_config *openair0_cfg, struct xran_fh_init *fh_init, struct xran_fh_config *fh_config);
+bool get_xran_config(void *mplane_api, const struct openair0_config *openair0_cfg, struct xran_fh_init *fh_init, struct xran_fh_config *fh_config);
 
 void print_fh_init(const struct xran_fh_init *fh_init);
 void print_fh_config(const struct xran_fh_config *fh_config);

radio/fhi_72/oran-init.c

@@ -443,7 +443,7 @@ int *oai_oran_initialize(struct xran_fh_init *xran_fh_init, struct xran_fh_confi
     pi->prach_tag = tag;
     pi->pusch_tag = tag;
 #ifdef E_RELEASE
-    LOG_W(PHY, "Please be aware that E release support will be removed in the future. Consider switching to F release.\n");
+    LOG_W(HW, "Please be aware that E release support will be removed in the future. Consider switching to F release.\n");
     oran_allocate_buffers(gxran_handle, o_xu_id, 1, pi, &xran_fh_config[o_xu_id]);
 #elif defined F_RELEASE
     oran_allocate_buffers(gxran_handle, o_xu_id, 1, pi, xran_fh_init->mtu, &xran_fh_config[o_xu_id]);