Merge remote-tracking branch 'origin/noCore' into integration_2020_wk45_2

Conflicts:
	openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_bch.c

ci-scripts/checkCodingFormattingRules.sh

@@ -59,7 +59,7 @@ if [ $# -eq 0 ]
 then
     echo " ---- Checking the whole repository ----"
     echo ""
-    NB_FILES_TO_FORMAT=`astyle --dry-run --options=ci-scripts/astyle-options.txt --recursive *.c *.h | grep -c Formatted `
+    NB_FILES_TO_FORMAT=`astyle --dry-run --options=ci-scripts/astyle-options.txt --recursive *.c *.h | grep -c Formatted || true`
     echo "Nb Files that do NOT follow OAI rules: $NB_FILES_TO_FORMAT"
     echo $NB_FILES_TO_FORMAT > ./oai_rules_result.txt
 
@@ -67,17 +67,17 @@ then
     awk '/#[ \t]*ifndef/ { gsub("^.*ifndef *",""); if (names[$1]!="") print "files with same {define ", FILENAME, names[$1]; names[$1]=FILENAME } /#[ \t]*define/ { gsub("^.*define *",""); if(names[$1]!=FILENAME) print "error in declaration", FILENAME, $1, names[$1]; nextfile }' `find openair* common targets executables -name *.h |grep -v LFDS` > header-files-w-incorrect-define.txt
 
     # Testing if explicit GNU GPL license banner
-    egrep -irl --exclude-dir=.git --include=*.cpp --include=*.c --include=*.h "General Public License" . > files-w-gnu-gpl-license-banner.txt
+    egrep -irl --exclude-dir=.git --include=*.cpp --include=*.c --include=*.h "General Public License" . | egrep -v "openair3/NAS/COMMON/milenage.h" > files-w-gnu-gpl-license-banner.txt
 
     # Looking at exotic/suspect banner
     LIST_OF_FILES_W_BANNER=`egrep -irl --exclude-dir=.git --include=*.cpp --include=*.c --include=*.h "Copyright|copyleft" .`
     if [ -f ./files-w-suspect-banner.txt ]; then rm -f ./files-w-suspect-banner.txt; fi
     for FILE in $LIST_OF_FILES_W_BANNER
     do
-       IS_NFAPI=`echo $FILE | egrep -c "nfapi/open-nFAPI|nfapi/oai_integration/vendor_ext"`
+       IS_NFAPI=`echo $FILE | egrep -c "nfapi/open-nFAPI|nfapi/oai_integration/vendor_ext" || true`
-       IS_OAI_LICENCE_PRESENT=`egrep -c "OAI Public License" $FILE`
+       IS_OAI_LICENCE_PRESENT=`egrep -c "OAI Public License" $FILE || true`
-       IS_BSD_LICENCE_PRESENT=`egrep -c "the terms of the BSD Licence" $FILE`
+       IS_BSD_LICENCE_PRESENT=`egrep -c "the terms of the BSD Licence" $FILE || true`
-       IS_EXCEPTION=`echo $FILE | egrep -c "common/utils/collection/tree.h|common/utils/collection/queue.h|common/utils/itti_analyzer/common/queue.h|openair3/UTILS/tree.h|openair3/UTILS/queue.h|openair3/GTPV1-U/nw-gtpv1u|openair2/UTIL/OPT/ws_"`
+       IS_EXCEPTION=`echo $FILE | egrep -c "common/utils/collection/tree.h|common/utils/collection/queue.h|common/utils/itti_analyzer/common/queue.h|openair3/UTILS/tree.h|openair3/UTILS/queue.h|openair3/GTPV1-U/nw-gtpv1u|openair2/UTIL/OPT/ws_|openair3/NAS/COMMON/milenage.h" || true`
        if [ $IS_OAI_LICENCE_PRESENT -eq 0 ] && [ $IS_BSD_LICENCE_PRESENT -eq 0 ]
        then
            if [ $IS_NFAPI -eq 0 ] && [ $IS_EXCEPTION -eq 0 ]
@@ -178,7 +178,7 @@ do
     EXT="${filename##*.}"
     if [ $EXT = "c" ] || [ $EXT = "h" ] || [ $EXT = "cpp" ] || [ $EXT = "hpp" ]
     then
-        TO_FORMAT=`astyle --dry-run --options=ci-scripts/astyle-options.txt $FULLFILE | grep -c Formatted `
+        TO_FORMAT=`astyle --dry-run --options=ci-scripts/astyle-options.txt $FULLFILE | grep -c Formatted || true`
         NB_TO_FORMAT=$((NB_TO_FORMAT + TO_FORMAT))
         if [ $TO_FORMAT -ne 0 ]
         then
@@ -186,15 +186,19 @@ do
             echo $FULLFILE >> ./oai_rules_result_list.txt
         fi
         # Testing if explicit GNU GPL license banner
-        egrep -i "General Public License" $FULLFILE >> files-w-gnu-gpl-license-banner.txt
+        GNU_EXCEPTION=`echo $FULLFILE | egrep -c "openair3/NAS/COMMON/milenage.h" || true`
+        if [ $GNU_EXCEPTION -eq 0 ]
+        then
+            egrep -il "General Public License" $FULLFILE >> files-w-gnu-gpl-license-banner.txt
+        fi
         # Looking at exotic/suspect banner
-        IS_BANNER=`egrep -i -c "Copyright|copyleft" $FULLFILE`
+        IS_BANNER=`egrep -i -c "Copyright|copyleft" $FULLFILE || true`
         if [ $IS_BANNER -ne 0 ]
         then
-            IS_NFAPI=`echo $FULLFILE | egrep -c "nfapi/open-nFAPI|nfapi/oai_integration/vendor_ext"`
+            IS_NFAPI=`echo $FULLFILE | egrep -c "nfapi/open-nFAPI|nfapi/oai_integration/vendor_ext" || true`
-            IS_OAI_LICENCE_PRESENT=`egrep -c "OAI Public License" $FULLFILE`
+            IS_OAI_LICENCE_PRESENT=`egrep -c "OAI Public License" $FULLFILE || true`
-            IS_BSD_LICENCE_PRESENT=`egrep -c "the terms of the BSD Licence" $FULLFILE`
+            IS_BSD_LICENCE_PRESENT=`egrep -c "the terms of the BSD Licence" $FULLFILE || true`
-            IS_EXCEPTION=`echo $FULLFILE | egrep -c "common/utils/collection/tree.h|common/utils/collection/queue.h|common/utils/itti_analyzer/common/queue.h|openair3/UTILS/tree.h|openair3/UTILS/queue.h|openair3/GTPV1-U/nw-gtpv1u|openair2/UTIL/OPT/ws_"`
+            IS_EXCEPTION=`echo $FULLFILE | egrep -c "common/utils/collection/tree.h|common/utils/collection/queue.h|common/utils/itti_analyzer/common/queue.h|openair3/UTILS/tree.h|openair3/UTILS/queue.h|openair3/GTPV1-U/nw-gtpv1u|openair2/UTIL/OPT/ws_|openair3/NAS/COMMON/milenage.h" || true`
             if [ $IS_OAI_LICENCE_PRESENT -eq 0 ] && [ $IS_BSD_LICENCE_PRESENT -eq 0 ]
             then
                 if [ $IS_NFAPI -eq 0 ] && [ $IS_EXCEPTION -eq 0 ]

ci-scripts/conf_files/gnb.band78.tm1.fr1.106PRB.usrpb210.conf

@@ -291,3 +291,6 @@ THREAD_STRUCT = (
        rrc_log_verbosity                     ="medium";
     };
 
+uicc: {
+opc = "testopc";
+};

cmake_targets/CMakeLists.txt

@@ -23,6 +23,114 @@
 
 cmake_minimum_required (VERSION 3.0)
 
+
+# System packages that are required
+# We use either the cmake buildin, in ubuntu are in: /usr/share/cmake*/Modules/
+# or cmake provide a generic interface to pkg-config that widely used
+###################################
+include(FindPkgConfig)
+
+pkg_search_module(LIBXML2 libxml-2.0 REQUIRED)
+include_directories(${LIBXML2_INCLUDE_DIRS})
+
+pkg_search_module(LIBXSLT libxslt REQUIRED)
+include_directories(${LIBXSLT_INCLUDE_DIRS})
+
+pkg_search_module(OPENSSL openssl REQUIRED)
+include_directories(${OPENSSL_INCLUDE_DIRS})
+
+pkg_search_module(CONFIG libconfig REQUIRED)
+include_directories(${CONFIG_INCLUDE_DIRS})
+
+pkg_search_module(CRYPTO libcrypto REQUIRED)
+include_directories(${CRYPTO_INCLUDE_DIRS})
+
+#use native cmake method as this package is not in pkg-config
+if (${RF_BOARD} STREQUAL "OAI_USRP")
+  find_package(Boost REQUIRED)
+  include_directories(${LIBBOOST_INCLUDE_DIR})
+
+elseif (${RF_BOARD} STREQUAL "OAI_IRIS")
+    include_directories("${OPENAIR_TARGETS}/ARCH/IRIS/USERSPACE/LIB/")
+    include_directories("/usr/local/include/")
+    set(HW_SOURCE ${HW_SOURCE}
+            ${OPENAIR_TARGETS}/ARCH/IRIS/USERSPACE/LIB/iris_lib.cpp)
+    LINK_DIRECTORIES("/usr/local/lib")
+    set(option_HW_lib "-lSoapySDR -rdynamic -ldl")
+
+endif (${RF_BOARD} STREQUAL "OAI_USRP")
+
+pkg_search_module(OPENPGM openpgm-5.1 openpgm-5.2)
+if(NOT ${OPENPGM_FOUND})
+  message("PACKAGE openpgm-5.1 is required by binaries such as oaisim: will fail later if this target is built")
+else()
+  include_directories(${OPENPGM_INCLUDE_DIRS})
+endif()
+
+pkg_search_module(NETTLE nettle)
+if(NOT ${NETTLE_FOUND})
+  message( FATAL_ERROR "PACKAGE nettle not found: some targets will fail. Run build_oai -I again!")
+else()
+  include_directories(${NETTLE_INCLUDE_DIRS})
+endif()
+
+message ("NETTLE VERSION_INSTALLED  = ${NETTLE_VERSION}")
+
+string(REGEX REPLACE "([0-9]+).*" "\\1" NETTLE_VERSION_MAJOR ${NETTLE_VERSION})
+string(REGEX REPLACE "[0-9]+\\.([0-9]+).*" "\\1" NETTLE_VERSION_MINOR ${NETTLE_VERSION})
+message ("NETTLE_VERSION_MAJOR = ${NETTLE_VERSION_MAJOR}")
+message ("NETTLE_VERSION_MINOR = ${NETTLE_VERSION_MINOR}")
+
+if ("${NETTLE_VERSION_MAJOR}" STREQUAL "" OR "${NETTLE_VERSION_MINOR}" STREQUAL "")
+  message( FATAL_ERROR "The nettle version not detected properly. Try to run build_oai -I again" )
+endif()
+
+add_definitions("-DNETTLE_VERSION_MAJOR=${NETTLE_VERSION_MAJOR}")
+add_definitions("-DNETTLE_VERSION_MINOR=${NETTLE_VERSION_MINOR}")
+
+pkg_search_module(XPM xpm)
+if(NOT ${XPM_FOUND})
+  message("PACKAGE xpm not found: some targets will fail")
+else()
+  include_directories(${XPM_INCLUDE_DIRS})
+endif()
+
+# Atlas is required by some packages, but not found in pkg-config
+# So, here are some hacks here. Hope this gets fixed in future!
+if(EXISTS "/usr/include/atlas/cblas.h" OR EXISTS "/usr/include/cblas.h")
+  include_directories("/usr/include/atlas")
+  LINK_DIRECTORIES("/usr/lib/lapack")
+  LINK_DIRECTORIES("/usr/lib64")
+  LINK_DIRECTORIES("/usr/lib64/atlas") #Added because atlas libraries in CentOS 7 are here!
+
+  if(EXISTS "/usr/lib64/libblas.so" OR EXISTS "/usr/lib/libblas.so") #Case for CentOS7
+     list(APPEND ATLAS_LIBRARIES blas)
+
+  else() # Case for Ubuntu
+     list(APPEND ATLAS_LIBRARIES cblas)
+  endif()
+
+  if(EXISTS "/usr/lib/atlas/libtatlas.so" OR EXISTS "/usr/lib64/atlas/libtatlas.so") #Case for CentOS7
+     list(APPEND ATLAS_LIBRARIES tatlas)
+  else()
+     list(APPEND ATLAS_LIBRARIES atlas) #Case for Ubuntu
+  endif()
+
+  list(APPEND ATLAS_LIBRARIES lapack)
+
+# for ubuntu 17.10, directories are different
+elseif(EXISTS "/usr/include/x86_64-linux-gnu/cblas.h")
+
+  include_directories("/usr/include/x86_64-linux-gnu")
+  LINK_DIRECTORIES("/usr/lib/x86_64-linux-gnu")
+  list(APPEND ATLAS_LIBRARIES cblas)
+  list(APPEND ATLAS_LIBRARIES atlas)
+  list(APPEND ATLAS_LIBRARIES lapack)
+
+else()
+  message("No Blas/Atlas libs found, some targets will fail")
+endif()
+
 #########################################################
 # Base directories, compatible with legacy OAI building #
 #########################################################
@@ -232,8 +340,8 @@ set(CMAKE_EXE_LINKER_FLAGS  "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath -Wl,${CMAKE_CU
 #########################
 # set a flag for changes in the source code
 # these changes are related to hardcoded path to include .h files
-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS} -g3 -DMALLOC_CHECK_=3")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS} -g3 -O0 -DMALLOC_CHECK_=3")
-set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS} -g3 -DMALLOC_CHECK_=3 -O2")
+set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS} -g3 -DMALLOC_CHECK_=3 -O2 -fno-delete-null-pointer-checks")
 set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS}  -O3")
 
 set(GIT_BRANCH        "UNKNOWN")
@@ -302,7 +410,6 @@ set (OCP_ITTI ${OPENAIR_DIR}/common/utils/ocp_itti)
 add_library(ITTI
   ${OCP_ITTI}/intertask_interface.cpp
   ${OPENAIR_DIR}/common/utils/backtrace.c
-  ${OPENAIR_DIR}/common/utils/memory_pools.c
   )
 add_dependencies(ITTI rrc_flag)
   set(ITTI_LIB ITTI)
@@ -378,6 +485,7 @@ add_custom_target (
 
 add_library(NR_RRC_LIB ${nr_rrc_h} ${nr_rrc_source} 
     ${OPENAIR2_DIR}/RRC/NR/MESSAGES/asn1_msg.c
+    ${OPENAIR2_DIR}/RRC/NR/nr_ngap_gNB.c
     )
 add_dependencies(NR_RRC_LIB nr_rrc_flag)
 include_directories ("${NR_RRC_FULL_DIR}")
@@ -622,7 +730,7 @@ add_library(X2AP_ENB
   ${X2AP_DIR}/x2ap_ids.c
   ${X2AP_DIR}/x2ap_timers.c
  )
-add_dependencies(X2AP_ENB rrc_flag x2_flag)
+add_dependencies(X2AP_ENB X2AP_LIB rrc_flag x2_flag)
 
 
 # F1AP
@@ -813,7 +921,7 @@ Message("CPU_Affinity flag is ${CPU_AFFINITY}")
 add_boolean_option(NO_RRM                  True  "DO WE HAVE A RADIO RESSOURCE MANAGER: NO")
 
 add_boolean_option(OAI_NW_DRIVER_TYPE_ETHERNET False "????")
-add_boolean_option(DEADLINE_SCHEDULER True "Use the Linux scheduler SCHED_DEADLINE: kernel >= 3.14")
+add_boolean_option(DEADLINE_SCHEDULER False "Use the Linux scheduler SCHED_DEADLINE: kernel >= 3.14")
 add_boolean_option(CPU_AFFINITY False "Enable CPU Affinity of threads (only valid without deadline scheduler). It is enabled only with >2 CPUs")
 add_boolean_option(NAS_NETLINK False "useless ??? Must be True to compile nasmesh driver without rtai ????")
 add_boolean_option(OAI_NW_DRIVER_USE_NETLINK True "????")
@@ -834,9 +942,9 @@ add_boolean_option(ENB_MODE True "Swap the include directories between openair2
 ##########################
 # SCHEDULING/REAL-TIME/PERF options
 ##########################
-add_boolean_option(ENABLE_USE_CPU_EXECUTION_TIME True "Add data in vcd traces: disable it if perf issues")
+add_boolean_option(ENABLE_USE_CPU_EXECUTION_TIME False "Add data in vcd traces: disable it if perf issues")
-add_boolean_option(ENABLE_VCD              True  "always true now, time measurements of proc calls and var displays")
+add_boolean_option(ENABLE_VCD              False  "always true now, time measurements of proc calls and var displays")
-add_boolean_option(ENABLE_VCD_FIFO         True  "time measurements of proc calls and var displays sent to FIFO (one more thread)")
+add_boolean_option(ENABLE_VCD_FIFO         False  "time measurements of proc calls and var displays sent to FIFO (one more thread)")
 add_boolean_option(LINUX                   False "used in weird memcpy() in pdcp.c ???")
 add_boolean_option(LINUX_LIST              False "used only in lists.c: either use OAI implementation of lists or Linux one (should be True, but it is False")
 add_boolean_option(OPENAIR_LTE             True "Seems legacy: keep it to true")
@@ -1250,6 +1358,7 @@ set(SECU_OSA_SRC
   ${OPENAIR2_DIR}/UTIL/OSA/osa_stream_eia.c
   )
 add_library(SECU_OSA ${SECU_OSA_SRC})
+target_link_libraries(SECU_OSA ${NETTLE_LIBRARIES})
 
 set(SECU_CN_SRC
   ${OPENAIR3_DIR}/SECU/kdf.c
@@ -1263,6 +1372,8 @@ set(SECU_CN_SRC
   )
 add_library(SECU_CN ${SECU_CN_SRC})
 
+target_link_libraries(SECU_CN ${NETTLE_LIBRARIES})
+
 # Physical Channel Procedures Scheduling
 ################################"
 set(SCHED_SRC
@@ -2047,6 +2158,11 @@ set (GTPV1U_SRC
 add_library(GTPV1U ${GTPV1U_SRC})
 add_dependencies(GTPV1U rrc_flag)
 
+#add_library (GTPV1U_OCP
+#${OPENAIR3_DIR}/ocp-gtp/gtp_itf.cpp
+#)
+#include_directories(${OPENAIR3_DIR}/ocp-gtp)
+
 #NR case
 set (NR_GTPV1U_SRC
   ${NR_RRC_DIR}/rrc_gNB_GTPV1U.c
@@ -2350,6 +2466,14 @@ set (SHLIB_LOADER_SOURCES
     ${OPENAIR_DIR}/common/utils/load_module_shlib.c
 )
 
+add_library(LIB_5GNAS_GNB
+	${NAS_SRC}/COMMON/nr_common.c
+	${NAS_SRC}/gNB/network_process_nas.c
+	${NAS_SRC}/NR_UE/ue_process_nas.c
+	${OPENAIR3_DIR}//UICC/usim_interface.c
+	)
+target_link_libraries(LIB_5GNAS_GNB SECU_CN ${CRYPTO_LIBRARIES})
+
 # Make lfds as a own source code (even if it is a outside library)
 # For better intergration with compilation flags & structure of cmake
 ###################################################################
@@ -2426,114 +2550,6 @@ include_directories("${NFAPI_DIR}/nfapi/inc")
 include_directories("${NFAPI_DIR}/sim_common/inc")
 include_directories("${NFAPI_DIR}/pnf_sim/inc")
 
-
-# System packages that are required
-# We use either the cmake buildin, in ubuntu are in: /usr/share/cmake*/Modules/
-# or cmake provide a generic interface to pkg-config that widely used
-###################################
-include(FindPkgConfig)
-
-pkg_search_module(LIBXML2 libxml-2.0 REQUIRED)
-include_directories(${LIBXML2_INCLUDE_DIRS})
-
-pkg_search_module(LIBXSLT libxslt REQUIRED)
-include_directories(${LIBXSLT_INCLUDE_DIRS})
-
-pkg_search_module(OPENSSL openssl REQUIRED)
-include_directories(${OPENSSL_INCLUDE_DIRS})
-
-pkg_search_module(CONFIG libconfig REQUIRED)
-include_directories(${CONFIG_INCLUDE_DIRS})
-
-pkg_search_module(CRYPTO libcrypto REQUIRED)
-include_directories(${CRYPTO_INCLUDE_DIRS})
-
-#use native cmake method as this package is not in pkg-config
-if (${RF_BOARD} STREQUAL "OAI_USRP")
-  find_package(Boost REQUIRED)
-  include_directories(${LIBBOOST_INCLUDE_DIR})
-
-elseif (${RF_BOARD} STREQUAL "OAI_IRIS")
-    include_directories("${OPENAIR_TARGETS}/ARCH/IRIS/USERSPACE/LIB/")
-    include_directories("/usr/local/include/")
-    set(HW_SOURCE ${HW_SOURCE}
-            ${OPENAIR_TARGETS}/ARCH/IRIS/USERSPACE/LIB/iris_lib.cpp)
-    LINK_DIRECTORIES("/usr/local/lib")
-    set(option_HW_lib "-lSoapySDR -rdynamic -ldl")
-
-endif (${RF_BOARD} STREQUAL "OAI_USRP")
-
-pkg_search_module(OPENPGM openpgm-5.1 openpgm-5.2)
-if(NOT ${OPENPGM_FOUND})
-  message("PACKAGE openpgm-5.1 is required by binaries such as oaisim: will fail later if this target is built")
-else()
-  include_directories(${OPENPGM_INCLUDE_DIRS})
-endif()
-
-pkg_search_module(NETTLE nettle)
-if(NOT ${NETTLE_FOUND})
-  message( FATAL_ERROR "PACKAGE nettle not found: some targets will fail. Run build_oai -I again!")
-else()
-  include_directories(${NETTLE_INCLUDE_DIRS})
-endif()
-
-message ("NETTLE VERSION_INSTALLED  = ${NETTLE_VERSION}")
-
-string(REGEX REPLACE "([0-9]+).*" "\\1" NETTLE_VERSION_MAJOR ${NETTLE_VERSION})
-string(REGEX REPLACE "[0-9]+\\.([0-9]+).*" "\\1" NETTLE_VERSION_MINOR ${NETTLE_VERSION})
-message ("NETTLE_VERSION_MAJOR = ${NETTLE_VERSION_MAJOR}")
-message ("NETTLE_VERSION_MINOR = ${NETTLE_VERSION_MINOR}")
-
-if ("${NETTLE_VERSION_MAJOR}" STREQUAL "" OR "${NETTLE_VERSION_MINOR}" STREQUAL "")
-  message( FATAL_ERROR "The nettle version not detected properly. Try to run build_oai -I again" )
-endif()
-
-add_definitions("-DNETTLE_VERSION_MAJOR=${NETTLE_VERSION_MAJOR}")
-add_definitions("-DNETTLE_VERSION_MINOR=${NETTLE_VERSION_MINOR}")
-
-pkg_search_module(XPM xpm)
-if(NOT ${XPM_FOUND})
-  message("PACKAGE xpm not found: some targets will fail")
-else()
-  include_directories(${XPM_INCLUDE_DIRS})
-endif()
-
-# Atlas is required by some packages, but not found in pkg-config
-# So, here are some hacks here. Hope this gets fixed in future!
-if(EXISTS "/usr/include/atlas/cblas.h" OR EXISTS "/usr/include/cblas.h")
-  include_directories("/usr/include/atlas")
-  LINK_DIRECTORIES("/usr/lib/lapack")
-  LINK_DIRECTORIES("/usr/lib64")
-  LINK_DIRECTORIES("/usr/lib64/atlas") #Added because atlas libraries in CentOS 7 are here!
-
-  if(EXISTS "/usr/lib64/libblas.so" OR EXISTS "/usr/lib/libblas.so") #Case for CentOS7
-     list(APPEND ATLAS_LIBRARIES blas)
-
-  else() # Case for Ubuntu
-     list(APPEND ATLAS_LIBRARIES cblas)
-  endif()
-
-  if(EXISTS "/usr/lib/atlas/libtatlas.so" OR EXISTS "/usr/lib64/atlas/libtatlas.so") #Case for CentOS7
-     list(APPEND ATLAS_LIBRARIES tatlas)
-  else()
-     list(APPEND ATLAS_LIBRARIES atlas) #Case for Ubuntu
-  endif()
-
-  list(APPEND ATLAS_LIBRARIES lapack)
-
-# for ubuntu 17.10, directories are different
-elseif(EXISTS "/usr/include/x86_64-linux-gnu/cblas.h")
-
-  include_directories("/usr/include/x86_64-linux-gnu")
-  LINK_DIRECTORIES("/usr/lib/x86_64-linux-gnu")
-  list(APPEND ATLAS_LIBRARIES cblas)
-  list(APPEND ATLAS_LIBRARIES atlas)
-  list(APPEND ATLAS_LIBRARIES lapack)
-
-else()
-  message("No Blas/Atlas libs found, some targets will fail")
-endif()
-
 list(APPEND ATLAS_LIBRARIES lapack lapacke)
 
 include_directories ("/usr/include/X11")
@@ -2640,6 +2656,12 @@ add_executable(measurement_display
   ${OPENAIR_DIR}/common/utils/threadPool/measurement_display.c)
 target_link_libraries (measurement_display minimal_lib)
 
+add_executable(test5Gnas 
+  ${OPENAIR_DIR}/openair3/TEST/test5Gnas.c
+)
+target_link_libraries (test5Gnas LIB_5GNAS_GNB CONFIG_LIB minimal_lib )
+
+
 # lte-softmodem is both eNB and UE implementation
 ###################################################
 
@@ -2681,7 +2703,7 @@ target_link_libraries (lte-softmodem
   -Wl,--end-group z dl)
   
 target_link_libraries (lte-softmodem ${LIBXML2_LIBRARIES})
-target_link_libraries (lte-softmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES})
+target_link_libraries (lte-softmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES})
 target_link_libraries (lte-softmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (lte-softmodem ${T_LIB})
 
@@ -2720,7 +2742,7 @@ target_link_libraries (ocp-enb
   PHY_COMMON PHY PHY_RU LFDS L2 L2_LTE NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB LFDS7 SIMU_COMMON
   ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} ${FSPT_MSG_LIB} ${PROTO_AGENT_LIB}
   -Wl,--end-group z dl)
-target_link_libraries (ocp-enb ${LIBXML2_LIBRARIES} pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${LIB_LMS_LIBRARIES} ${T_LIB})
+target_link_libraries (ocp-enb ${LIBXML2_LIBRARIES} pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${LIB_LMS_LIBRARIES} ${T_LIB})
 
 add_executable(cu_test
   ${OPENAIR2_DIR}/LAYER2/PROTO_AGENT/cu_test.c
@@ -2792,7 +2814,7 @@ target_link_libraries (lte-uesoftmodem
   -Wl,--end-group z dl)
 
 target_link_libraries (lte-uesoftmodem ${LIBXML2_LIBRARIES})
-target_link_libraries (lte-uesoftmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
+target_link_libraries (lte-uesoftmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
 target_link_libraries (lte-uesoftmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (lte-uesoftmodem ${T_LIB})
 
@@ -2835,11 +2857,52 @@ target_link_libraries (nr-softmodem
   -Wl,--end-group z dl)
 
 target_link_libraries (nr-softmodem ${LIBXML2_LIBRARIES})
-target_link_libraries (nr-softmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
+target_link_libraries (nr-softmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
 target_link_libraries (nr-softmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (nr-softmodem ${T_LIB})
 
 add_dependencies( nr-softmodem ldpc_orig ldpc_optim ldpc_optim8seg ldpc )
+
+add_executable(ocp-gnb
+  ${rrc_h}
+  ${nr_rrc_h}
+  ${s1ap_h}
+#  ${OPENAIR_BIN_DIR}/messages_xml.h
+  ${OPENAIR_DIR}/executables/ocp-gnb.c
+  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
+  ${OPENAIR_DIR}/executables/softmodem-common.c
+  ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
+  ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c
+  ${OPENAIR_TARGETS}/ARCH/COMMON/record_player.c
+  ${OPENAIR2_DIR}/RRC/NAS/nas_config.c
+  ${OPENAIR2_DIR}/RRC/NAS/rb_config.c
+  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
+  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
+  ${OPENAIR_DIR}/common/utils/utils.c
+  ${OPENAIR_DIR}/common/utils/system.c
+  ${GTPU_need_ITTI}
+  ${XFORMS_SOURCE_NR}
+  ${T_SOURCE}
+  ${CONFIG_SOURCES}
+  ${SHLIB_LOADER_SOURCES}
+  ${XFORMSINTERFACE_SOURCE}
+  )
+
+target_link_libraries (ocp-gnb
+  -Wl,--start-group
+  UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB SCHED_NR_LIB PHY_NR PHY PHY_COMMON PHY_NR_COMMON PHY_RU LFDS NR_GTPV1U SECU_CN SECU_OSA
+  ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} LFDS7 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} RRC_LIB NR_RRC_LIB 
+  S1AP_LIB S1AP_ENB L2_LTE_NR L2_NR MAC_NR_COMMON NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB
+  X2AP_LIB X2AP_ENB F1AP_LIB F1AP M2AP_LIB M2AP_ENB M3AP_LIB M3AP_ENB SIMU_COMMON
+  -Wl,--end-group z dl)
+
+target_link_libraries (ocp-gnb ${LIBXML2_LIBRARIES} )
+target_link_libraries (ocp-gnb pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
+target_link_libraries (ocp-gnb ${LIB_LMS_LIBRARIES})
+target_link_libraries (ocp-gnb ${T_LIB})
+add_dependencies(ocp-gnb ldpc_orig ldpc_optim ldpc_optim8seg ldpc params_libconfig rfsimulator oai_usrpdevif rfsimulator nrscope)
+
+
 # nr-uesoftmodem is  UE implementation
 #######################################
 
@@ -2874,11 +2937,11 @@ target_link_libraries (nr-uesoftmodem
   RRC_LIB NR_RRC_LIB SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_RU_LIB SCHED_UE_LIB SCHED_NR_UE_LIB
   PHY_COMMON PHY_NR_COMMON PHY_UE PHY_NR_UE PHY_RU LFDS NR_L2_UE L2_UE_LTE_NR MAC_NR_COMMON NFAPI_COMMON_LIB NFAPI_LIB NFAPI_PNF_LIB
   NFAPI_USER_LIB S1AP_LIB S1AP_ENB
-  ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} LFDS7 ${ATLAS_LIBRARIES} 
+  ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} LFDS7 ${ATLAS_LIBRARIES} LIB_5GNAS_GNB
   -Wl,--end-group z dl)
 
 target_link_libraries (nr-uesoftmodem ${LIBXML2_LIBRARIES})
-target_link_libraries (nr-uesoftmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
+target_link_libraries (nr-uesoftmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
 target_link_libraries (nr-uesoftmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (nr-uesoftmodem ${T_LIB})
 
@@ -3045,7 +3108,7 @@ add_executable(nr_dlsim
   ${SHLIB_LOADER_SOURCES}
   )   
 target_link_libraries(nr_dlsim
-  -Wl,--start-group UTIL SIMU_COMMON SIMU PHY_COMMON PHY_NR_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_NR MAC_UE_NR MAC_NR_COMMON RRC_LIB NR_RRC_LIB CONFIG_LIB L2_NR HASHTABLE -Wl,--end-group
+  -Wl,--start-group UTIL SIMU_COMMON SIMU PHY_COMMON PHY_NR_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_NR MAC_UE_NR MAC_NR_COMMON RRC_LIB NR_RRC_LIB CONFIG_LIB L2_LTE_NR L2_NR HASHTABLE X2AP_ENB X2AP_LIB SECU_CN -Wl,--end-group
   m pthread ${ATLAS_LIBRARIES} ${T_LIB} ${ITTI_LIB} dl
   )
 target_compile_definitions(nr_dlsim PUBLIC -DPHYSICAL_SIMULATOR)
@@ -3063,7 +3126,8 @@ add_executable(nr_prachsim
   ${T_SOURCE}
   ${SHLIB_LOADER_SOURCES})
 target_link_libraries(nr_prachsim  
-   -Wl,--start-group UTIL SIMU_COMMON SIMU PHY_COMMON PHY_NR_COMMON PHY_NR PHY_RU PHY_NR_UE MAC_NR_COMMON SCHED_NR_LIB MAC_UE_NR SCHED_NR_UE_LIB RRC_LIB NR_RRC_LIB L2_NR CONFIG_LIB HASHTABLE -Wl,--end-group m pthread ${ATLAS_LIBRARIES} ${T_LIB} ${ITTI_LIB} dl)
+  -Wl,--start-group UTIL SIMU_COMMON SIMU PHY_COMMON PHY_NR_COMMON PHY_NR PHY_RU PHY_NR_UE MAC_NR_COMMON SCHED_NR_LIB SCHED_NR_UE_LIB MAC_NR MAC_UE_NR MAC_NR_COMMON RRC_LIB NR_RRC_LIB CONFIG_LIB L2_LTE_NR L2_NR HASHTABLE X2AP_ENB X2AP_LIB SECU_CN -Wl,--end-group
+  m pthread ${ATLAS_LIBRARIES} ${T_LIB} ${ITTI_LIB} dl)
 
 add_executable(nr_ulschsim
   ${OPENAIR1_DIR}/SIMULATION/NR_PHY/ulschsim.c
@@ -3095,7 +3159,7 @@ add_executable(nr_ulsim
   ${SHLIB_LOADER_SOURCES}
   )
 target_link_libraries(nr_ulsim
-  -Wl,--start-group UTIL SIMU_COMMON SIMU PHY_COMMON PHY_NR PHY_NR_COMMON PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_NR MAC_UE_NR MAC_NR_COMMON RRC_LIB NR_RRC_LIB CONFIG_LIB L2_NR HASHTABLE -Wl,--end-group
+  -Wl,--start-group UTIL SIMU_COMMON SIMU PHY_COMMON PHY_NR_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_NR MAC_UE_NR MAC_NR_COMMON RRC_LIB NR_RRC_LIB CONFIG_LIB L2_LTE_NR L2_NR HASHTABLE X2AP_ENB X2AP_LIB SECU_CN -Wl,--end-group
   m pthread ${ATLAS_LIBRARIES} ${T_LIB} ${ITTI_LIB} dl
   )
 target_compile_definitions(nr_ulsim PUBLIC -DPHYSICAL_SIMULATOR)
@@ -3130,7 +3194,7 @@ add_executable(test_epc_generate_scenario
   ${OPENAIR3_DIR}/S1AP/s1ap_eNB_defs.h
   )
 target_link_libraries (test_epc_generate_scenario
-  -Wl,--start-group RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB X2AP_ENB M2AP_LIB M2AP_ENB M3AP_LIB M3AP_ENB F1AP_LIB F1AP GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT MME_APP UDP SCHED_LIB PHY LFDS ${ITTI_LIB} ${MSC_LIB} L2 -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} ${CONFIG_LIB}
+  -Wl,--start-group RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB X2AP_ENB M2AP_LIB M2AP_ENB M3AP_LIB M3AP_ENB F1AP_LIB F1AP GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT MME_APP UDP SCHED_LIB PHY LFDS ${ITTI_LIB} ${MSC_LIB} L2 -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${CONFIG_LIB}
   )
 
 add_executable(test_epc_play_scenario
@@ -3149,7 +3213,7 @@ add_executable(test_epc_play_scenario
   )
 target_include_directories(test_epc_play_scenario PUBLIC /usr/local/share/asn1c)
 target_link_libraries (test_epc_play_scenario
-  -Wl,--start-group RRC_LIB S1AP_LIB X2AP_LIB X2AP_ENB M3AP_LIB M3AP_ENB F1AP_LIB F1AP GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT MME_APP UDP SCHED_LIB PHY_NR_COMMON PHY_COMMON PHY PHY_UE LFDS ${ITTI_LIB} ${MSC_LIB} -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} ${CONFIG_LIB}
+  -Wl,--start-group RRC_LIB S1AP_LIB X2AP_LIB X2AP_ENB M3AP_LIB M3AP_ENB F1AP_LIB F1AP GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT MME_APP UDP SCHED_LIB PHY_NR_COMMON PHY_COMMON PHY PHY_UE LFDS ${ITTI_LIB} ${MSC_LIB} -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${CONFIG_LIB}
   )
 
 
@@ -3169,7 +3233,7 @@ foreach(myExe s1ap
     ${OPENAIR3_DIR}/TEST/test_${myExe}.c
     )
   target_link_libraries (test_${myExe}
-    -Wl,--start-group SECU_CN UTIL LFDS -Wl,--end-group m rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} ${CONFIG_LIB}
+    -Wl,--start-group SECU_CN UTIL LFDS -Wl,--end-group m rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${CONFIG_LIB}
     )
 endforeach(myExe)
 

cmake_targets/build_oai

@@ -483,11 +483,6 @@ function main() {
   echo_info "Flags for Deadline scheduler: $DEADLINE_SCHEDULER_FLAG_USER"
   echo_info "Flags for CPU Affinity: $CPU_AFFINITY_FLAG_USER"
 
-  if [ -n "$UHD_IMAGES_DIR" ] && [ -z "$INSTALL_EXTERNAL" ]; then
-    echo_error "UHD images download settings will not be applied without -I present"
-    exit
-  fi
-  
   #######################################################
   # Setting and printing OAI envs, we should check here #
   #######################################################

cmake_targets/install_external_packages.ubuntu20

@@ -0,0 +1,505 @@
+#!/bin/bash
+#/*
+# * 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
+# */
+
+# brief
+# authors Laurent Thomas
+#
+#######################################
+if [ ! -f /etc/os-release ]; then
+    echo "No /etc/os-release file found. You're likely on an unsupported distro."
+    exit 1
+fi
+OS_DISTRO=$(grep "^ID=" /etc/os-release | sed "s/ID=//" | sed "s/\"//g")
+OS_RELEASE=$(grep "^VERSION_ID=" /etc/os-release | sed "s/VERSION_ID=//" | sed "s/\"//g")
+case "$OS_DISTRO" in
+    ubuntu) OS_BASEDISTRO="debian"; INSTALLER="apt"; CMAKE="cmake" ;;
+esac
+
+SUDO='sudo -E'
+
+###############################
+## echo and  family
+###############################
+black='\E[30m'
+red='\E[31m'
+green='\E[32m'
+yellow='\E[33m'
+blue='\E[1;34m'
+magenta='\E[35m'
+cyan='\E[36m'
+white='\E[37m'
+reset_color='\E[00m'
+COLORIZE=1
+
+cecho()  {
+    # Color-echo
+    # arg1 = message
+    # arg2 = color
+    local default_msg="No Message."
+    message=${1:-$default_msg}
+    color=${2:-$green}
+    [ "$COLORIZE" = "1" ] && message="$color$message$reset_color"
+    echo -e "$message"
+    return
+}
+
+echo_error()   { cecho "$* $red"          ;}
+echo_fatal()   { cecho "$* $red"; exit 1  ;}
+echo_warning() { cecho "$* $yellow"       ;}
+echo_success() { cecho "$* $green"        ;}
+echo_info()    { cecho "$* $blue"         ;}
+
+########################
+# distribution helpers #
+########################
+
+# This function return a string to identify the distribution we are running
+# Examples:
+#   ubuntu16.04
+#   debian8.5
+get_distribution_release() {
+    echo "$OS_DISTRO$OS_RELEASE"
+}
+
+check_supported_distribution() {
+    case $(get_distribution_release) in
+        "ubuntu20.04") return 0 ;;
+    esac
+    return 1
+}
+
+##################
+# Error handlers #
+##################
+
+handler_EXIT() {
+    local exit_code=$?
+    [ "$exit_code" -eq 0 ] || echo_error "build have failed"
+    exit $exit_code
+}
+
+trap handler_EXIT EXIT
+
+###########################
+# Cleaners
+###########################
+
+clean_kernel() {
+    $SUDO modprobe ip_tables
+    $SUDO modprobe x_tables
+    $SUDO iptables -P INPUT ACCEPT
+    $SUDO iptables -F INPUT
+    $SUDO iptables -P OUTPUT ACCEPT
+    $SUDO iptables -F OUTPUT
+    $SUDO iptables -P FORWARD ACCEPT
+    $SUDO iptables -F FORWARD
+    $SUDO iptables -t nat -F
+    $SUDO iptables -t mangle -F
+    $SUDO iptables -t filter -F
+    $SUDO iptables -t raw -F
+    echo_info "Flushed iptables"
+    $SUDO rmmod nasmesh > /dev/null 2>&1
+    $SUDO rmmod oai_nw_drv  > /dev/null 2>&1
+    $SUDO rmmod openair_rf > /dev/null 2>&1
+    $SUDO rmmod ue_ip > /dev/null 2>&1
+    echo_info "removed drivers from kernel"
+}
+
+clean_all_files() {
+    set_openair_env
+    rm -rf "$OPENAIR_DIR"/targets/bin/*
+    dir="$OPENAIR_DIR/cmake_targets"
+    rm -rf "$dir"/log/*
+    rm -rf "$dir"/ran_build/build
+    rm -rf "$dir"/ran_build_noLOG/build
+    rm -rf "$dir"/lte-simulators/build 
+    rm -rf "$dir"/phy_simulators/build
+    rm -rf "$dir"/nas_sim_tools/build 
+    rm -rf "$dir"/oaisim_build_oai/build
+    rm -rf "$dir"/oaisim_build_oai/CMakeLists.txt
+    rm -rf "$dir"/autotests/bin
+    rm -rf "$dir"/autotests/log
+    rm -rf "$dir"/autotests/*/build
+}
+
+############################################
+# External packages installers
+############################################
+
+install_protobuf_from_source(){
+    protobuf_install_log=$OPENAIR_DIR/cmake_targets/log/protobuf_install_log.txt
+    echo_info "\nInstalling Google Protobuf from sources. The log file for Protobuf installation is here: $protobuf_install_log "
+    (
+	cd /tmp || exit
+	echo "Downloading protobuf"
+	#rm -rf /tmp/protobuf-2.6.1.tar.gz* /tmp/protobuf-2.6.1
+	#wget https://github.com/google/protobuf/releases/download/v2.6.1/protobuf-2.6.1.tar.gz
+	#tar -xzvf protobuf-2.6.1.tar.gz --owner $USER --group $USER --no-same-owner
+	#cd protobuf-2.6.1/
+	rm -rf /tmp/protobuf-cpp-3.3.0.tar.gz* /tmp/protobuf-3.3.0
+	wget --tries=3 --retry-connrefused https://github.com/google/protobuf/releases/download/v3.3.0/protobuf-cpp-3.3.0.tar.gz
+	tar -xzvf protobuf-cpp-3.3.0.tar.gz --owner "$USER" --group "$(groups | cut -d" " -f1)" --no-same-owner
+	cd protobuf-3.3.0/ || exit
+	./configure
+	echo "Compiling protobuf"
+	make -j"$(nproc)"
+	$SUDO make install
+	$SUDO ldconfig
+    ) >& "$protobuf_install_log"
+}
+
+install_protobuf_c_from_source(){
+    protobuf_c_install_log=$OPENAIR_DIR/cmake_targets/log/protobuf_c_install_log.txt
+    echo_info "\nInstalling Google Protobuf_C from sources. The log file for Protobuf_C installation is here: $protobuf_c_install_log "
+    (
+	if [[ "$OS_DISTRO" == "rhel" ]] || [[ "$OS_DISTRO" == "centos" ]]; then
+            export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
+	fi
+	cd /tmp || exit
+	echo "Downloading protobuf-c"
+	rm -rf /tmp/protobuf-c
+	git clone https://github.com/protobuf-c/protobuf-c.git
+	cd protobuf-c || exit
+	git checkout 2a46af42784abf86804d536f6e0122d47cfeea45
+	./autogen.sh
+	./configure
+	echo "Compiling protobuf-c"
+	make -j"$(nproc)"
+	$SUDO make install
+	$SUDO ldconfig
+    ) >& "$protobuf_c_install_log"
+}
+
+install_usrp_uhd_driver_from_source(){
+    uhd_install_log=$OPENAIR_DIR/cmake_targets/log/uhd_install_log.txt
+    echo_info "\nInstalling UHD driver from sources. The log file for UHD driver installation is here: $uhd_install_log "
+    (
+	cd /tmp || exit
+	echo "Downloading UHD driver"
+	rm -rf /tmp/uhd
+	git clone https://github.com/EttusResearch/uhd.git
+	cd uhd || exit
+	git checkout tags/v3.13.0.2
+	mkdir -p host/build
+	cd host/build || exit
+	$CMAKE ../
+	echo "Compiling UHD"
+	make -j"$(nproc)"
+	make test
+	$SUDO make install
+	$SUDO ldconfig
+    ) >& "$uhd_install_log"
+}
+
+install_bladerf_driver_from_source(){
+    bladerf_install_log=$OPENAIR_DIR/cmake_targets/log/bladerf_install_log.txt
+    echo_info "\nInstalling BladeRF driver from sources. The log file for BladeRF driver installation is here: $bladerf_install_log "
+    (
+	cd /tmp || exit
+	echo "Downloading BladeRF driver"
+	rm -rf /tmp/bladeRF
+	git clone https://github.com/Nuand/bladeRF.git
+	cd bladeRF || exit
+	git checkout tags/2016.06
+	mkdir -p build
+	cd build || exit
+	$CMAKE ../
+	echo "Compiling BladeRF driver"
+	make -j"$(nproc)"
+	$SUDO make install
+	$SUDO ldconfig
+	echo "Downloading FPGA and firmware images"
+	cd /tmp/bladeRF || exit
+	wget --tries=3 --retry-connrefused https://www.nuand.com/fx3/bladeRF_fw_latest.img
+	wget --tries=3 --retry-connrefused https://www.nuand.com/fpga/hostedx40-latest.rbf
+	sudo mkdir -p /usr/share/Nuand/bladeRF
+	sudo mv bladeRF_fw_latest.img /usr/share/Nuand/bladeRF/bladeRF_fw.img
+	sudo mv hostedx40-latest.rbf /usr/share/Nuand/bladeRF/hostedx40.rbf
+    ) >& "$bladerf_install_log"
+}
+
+check_install_bladerf_driver(){
+    if [[ "$OS_DISTRO" == "ubuntu" ]]; then
+        $SUDO apt-get install -y  bladerf libbladerf-dev
+        $SUDO apt-get install -y bladerf-firmware-fx3
+        $SUDO apt-get install -y bladerf-fpga-hostedx40
+    elif [[ "$OS_BASEDISTRO" == "fedora" ]]; then
+        install_bladerf_driver_from_source
+    else
+        echo_error "BladeRF Installer for OAI does not support automatic build. Install BladeRF compiling sources manually from BladeRF website"
+    fi
+}
+
+flash_firmware_bladerf() {
+    $SUDO bladeRF-cli --flash-firmware /usr/share/Nuand/bladeRF/bladeRF_fw.img
+}
+
+install_soapy_from_source(){
+    soapy_install_log=$OPENAIR_DIR/cmake_targets/log/soapy_install_log.txt
+    echo_info "\nInstalling Soapy EcoSystem from source. The log file for Soapy installation is here: $soapy_install_log "
+    (
+	cd /tmp || exit
+	echo "Downloading SoapySDR"
+	rm -rf /tmp/soapysdr
+	git clone -b soapy-sdr-0.7.0 --single-branch https://github.com/pothosware/SoapySDR.git
+	cd SoapySDR || exit
+	#git checkout tags/release_003_010_001_001
+	mkdir -p build
+	cd build || exit
+	$CMAKE ../
+	echo "Compiling SoapySDR"
+	make -j"$(nproc)"
+	$SUDO make install
+	$SUDO ldconfig
+	cd /tmp || exit
+	echo "Downloading SoapyRemote"
+	rm -rf /tmp/soapyremote
+	git clone -b soapy-remote-0.5.0 --single-branch https://github.com/pothosware/SoapyRemote.git
+	cd SoapyRemote || exit
+	#git checkout tags/release_003_010_001_001
+	mkdir -p build
+	cd build || exit
+	cmake ../
+	echo "Compiling SoapyRemote"
+	make -j"$(nproc)"
+	$SUDO make install
+	$SUDO ldconfig
+    ) >& "$soapy_install_log"
+}
+
+install_soapy_iris_from_source(){
+    iris_install_log=$OPENAIR_DIR/cmake_targets/log/iris_install_log.txt
+    echo_info "\nInstalling Iris driver from source. The log file for Iris driver installation is here: $iris_install_log "
+    (
+	cd /tmp || exit
+	echo "Downloading SoapyIris"
+	rm -rf /tmp/sklk-soapyiris
+	git clone -b soapy-iris-2018.08.0.1 --single-branch https://github.com/skylarkwireless/sklk-soapyiris.git
+	cd sklk-soapyiris || exit
+	mkdir -p build
+	cd build ||exit
+	cmake ../
+	echo "Compiling SoapyIris"
+	make -j"$(nproc)"
+	$SUDO make install
+	$SUDO ldconfig
+    ) >& "$iris_install_log"
+}
+
+check_install_soapy () {
+    #if [[ "$OS_DISTRO" == "ubuntu" ]]; then
+    #first we remove old installation
+    $SUDO apt-get remove -y soapysdr soapysdr-server libsoapysdr-dev python-soapysdr python3-soapysdr soapysdr-module-remote || true
+    #$SUDO add-apt-repository -y ppa:myriadrf/drivers
+    #$SUDO apt-get update
+    #$SUDO apt-get install -y soapysdr soapysdr-server libsoapysdr-dev python-soapysdr python3-soapysdr soapysdr-module-remote
+
+    #elif [[ "$OS_BASEDISTRO" == "fedora" ]]; then
+    #    $SUDO $INSTALLER -y install software-properties-common python3-software-properties python-software-properties subversion git python3 python-numpy python3-numpy cmake swig python-dev
+    install_soapy_from_source
+    #fi
+    install_soapy_iris_from_source
+    
+}
+
+check_install_ubuntu_packages() {
+    $SUDO $INSTALLER update -y
+    if [[ "$OS_DISTRO" == "ubuntu" ]]; then
+	local LAPACK_LIBNAME="liblapack.so"
+	local LAPACK_TARGET="/usr/lib/atlas-base/atlas/liblapack.so"
+	$SUDO apt install -y software-properties-common
+	case "$(get_distribution_release)" in
+            "ubuntu20.04")
+		specific_packages="libtasn1-6-dev libgnutls28-dev iproute2 libconfig-dev"
+		LAPACK_LIBNAME="liblapack.so-x86_64-linux-gnu"
+		LAPACK_TARGET="/usr/lib/x86_64-linux-gnu/atlas/liblapack.so"
+		;;
+	esac
+	$SUDO $INSTALLER install -y \
+	      $specific_packages \
+	      check  \
+              dialog \
+              dkms \
+              gawk \
+              libboost-all-dev \
+              libpthread-stubs0-dev \
+              openvpn \
+              pkg-config \
+              python3-dev  \
+              python-pexpect \
+              sshfs \
+              swig  \
+              tshark \
+              uml-utilities \
+              unzip  \
+              valgrind  \
+              vlan      \
+              exuberant-ctags \
+              ntpdate \
+              iperf3 \
+              android-tools-adb \
+              wvdial \
+              python-numpy \
+              sshpass \
+              nscd \
+              bc \
+              ntp \
+              python3-scipy \
+              python3-matplotlib \
+	      bison  \
+	      build-essential \
+	      cmake \
+	      cmake-curses-gui  \
+              ninja-build \
+	      doxygen \
+	      doxygen-gui \
+	      texlive-latex-base \
+	      ethtool \
+	      flex  \
+	      gdb  \
+	      git \
+	      graphviz \
+	      gtkwave \
+	      guile-2.0-dev  \
+	      iperf \
+	      iptables \
+	      libxtables-dev \
+	      libatlas-base-dev \
+	      libblas-dev \
+	      liblapack-dev\
+	      liblapacke-dev\
+	      libffi-dev \
+	      libforms-bin \
+	      libforms-dev \
+	      libgcrypt20-dev \
+	      libgmp-dev \
+	      libgtk-3-dev \
+	      libidn2-0-dev  \
+	      libidn11-dev \
+	      libmysqlclient-dev  \
+	      libpython2.7-dev \
+	      libsctp1  \
+	      libsctp-dev  \
+	      libssl-dev  \
+	      libtool  \
+	      libusb-1.0-0-dev \
+	      libxml2 \
+	      libxml2-dev  \
+	      libxslt1-dev \
+	      mscgen  \
+	      octave-signal \
+	      openssh-client \
+	      openssh-server \
+	      openssl \
+	      python3  \
+	      subversion \
+	      xmlstarlet \
+	      python3-pip \
+	      libyaml-dev \
+	      wget \
+	      libxpm-dev \
+              libboost-all-dev \
+	      nettle-dev \
+	      nettle-bin
+    fi
+    
+    $SUDO update-alternatives --set "$LAPACK_LIBNAME" "$LAPACK_TARGET"
+    
+}
+
+install_asn1c_from_source(){
+    asn1_install_log=$OPENAIR_DIR/cmake_targets/log/asn1c_install_log.txt
+    echo_info "\nInstalling ASN1. The log file for ASN1 installation is here: $asn1_install_log "
+    (
+	$SUDO rm -rf /tmp/asn1c
+	# GIT_SSL_NO_VERIFY=true git clone https://gitlab.eurecom.fr/oai/asn1c.git /tmp/asn1c
+	git clone https://gitlab.eurecom.fr/oai/asn1c.git /tmp/asn1c
+	cd /tmp/asn1c || exit
+	# better to use a given commit than a branch in case the branch
+	# is updated and requires modifications in the source of OAI
+	#git checkout velichkov_s1ap_plus_option_group
+	git checkout f12568d617dbf48497588f8e227d70388fa217c9
+	autoreconf -iv
+	./configure
+	make -j"$(nproc)"
+	$SUDO make install
+	cd - || exit
+	$SUDO ldconfig
+    ) > "$asn1_install_log" 2>&1
+}
+
+#################################################
+# 2. compile
+################################################
+
+install_nas_tools() {
+    echo_success "generate .ue_emm.nvram .ue.nvram"
+    ./nvram --gen -c "$1" -o "$2"
+    ./usim --gen -c "$1" -o "$2"
+}
+
+
+################################
+# set_openair_env
+###############################
+set_openair_env(){
+    fullpath=$(readlink -f "${BASH_SOURCE[0]}")
+    [ -f "/.$fullpath" ] || fullpath=$(readlink -f "$PWD/$fullpath")
+    openair_path=${fullpath%/cmake_targets/*}
+    openair_path=${openair_path%/targets/*}
+    openair_path=${openair_path%/openair[123]/*}
+    export OPENAIR_DIR=$openair_path
+    export OPENAIR1_DIR=$openair_path/openair1
+    export OPENAIR2_DIR=$openair_path/openair2
+    export OPENAIR3_DIR=$openair_path/openair3
+    export OPENAIR_TARGETS=$openair_path/targets
+}
+
+if ! check_supported_distribution; then
+    echo_error "Your distribution $(get_distribution_release) is not supported by oai !"
+    exit 1
+fi
+
+echo_info "Installing packages"
+check_install_ubuntu_packages
+
+echo_info "installing ASN.1 compiler"
+install_asn1c_from_source
+
+echo_info "installing protobuf/protobuf-c for flexran agent support"
+install_protobuf_from_source
+install_protobuf_c_from_source
+
+if [ "$1" == "USRP" ] ; then
+    echo_info "installing packages for USRP support"
+    install_usrp_uhd_driver
+fi
+if [ "$1" == "BLADERF" ] ; then
+    echo_info "installing packages for BLADERF support"
+    check_install_bladerf_driver
+    flash_firmware_bladerf
+fi
+if [ "$1" == "IRIS" ] ; then
+    echo_info "installing packages for IRIS support"
+    check_install_soapy
+    #  flash_firmware_iris
+fi

common/utils/LOG/log.h

@@ -397,18 +397,21 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
 /* define variable only used in LOG macro's */
 #    define LOG_VAR(A,B) A B
 #  else /* T_TRACER: remove all debugging and tracing messages, except errors */
-#    define LOG_I(c, x...) do {logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_INFO, x) ; } while(0)/* */
-#    define LOG_W(c, x...) do {logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_WARNING, x) ; } while(0)/* */
-#    define LOG_E(c, x...) do {logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_ERR, x) ; } while(0)/* */
-#    define LOG_D(c, x...) do {logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_DEBUG, x) ; } while(0)/* */
-#    define LOG_T(c, x...) /* */
 
-#    define LOG_DUMPMSG(c, b, s, x...) /* */
+#    define LOG_E(c, x...) do { if( g_log->log_component[c].level >= OAILOG_ERR    ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_ERR, x)     ;}  while (0)
+#    define LOG_W(c, x...) do { if( g_log->log_component[c].level >= OAILOG_WARNING) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_WARNING, x) ;}  while (0)
+#    define LOG_I(c, x...) do { if( g_log->log_component[c].level >= OAILOG_INFO   ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_INFO, x)    ;}  while (0)
+#    define LOG_D(c, x...) do { if( g_log->log_component[c].level >= OAILOG_DEBUG  ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_DEBUG, x)   ;}  while (0)
+#    define LOG_T(c, x...) do { if( g_log->log_component[c].level >= OAILOG_TRACE  ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_TRACE, x)   ;}  while (0)
+#    define VLOG(c,l, f, args) do { if( g_log->log_component[c].level >= l  ) vlogRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, l, f, args)   ; } while (0)
+
 #    define nfapi_log(FILE, FNC, LN, COMP, LVL, FMT...)
-#    define LOG_DEBUGFLAG(D)  ( 0 )
+#    define LOG_DEBUGFLAG(D)  (g_log->dump_mask & D)
-#    define LOG_DUMPFLAG(D) ( 0 )
+#    define LOG_DUMPFLAG(D) (g_log->debug_mask & D)
+#    define LOG_DUMPMSG(c, f, b, s, x...) do {  if(g_log->dump_mask & f) log_dump(c, b, s, LOG_DUMP_CHAR, x)  ;}   while (0)  /* */
+
 #    define LOG_M(file, vector, data, len, dec, format) do { write_file_matlab(file, vector, data, len, dec, format);} while(0)
-#    define LOG_VAR(A,B)
+#    define LOG_VAR(A,B) A B
 #  endif /* T_TRACER */
 /* avoid warnings for variables only used in LOG macro's but set outside debug section */
 #define GCC_NOTUSED   __attribute__((unused))

common/utils/LOG/vcd_signal_dumper.c

@@ -814,6 +814,7 @@ static inline unsigned long long int vcd_get_time(void)
   return (long long unsigned int)((time.tv_nsec - g_time_start.tv_nsec)) +
          ((long long unsigned int)time.tv_sec - (long long unsigned int)g_time_start.tv_sec) * 1000000000UL;
 #endif
+  return 0;
 }
 
 void vcd_signal_dumper_create_header(void)

common/utils/LOG/vcd_signal_dumper.h

@@ -601,11 +601,19 @@ extern int ouput_vcd;
 
 #else /* T_TRACER */
 
+#if ENABLE_VCD
 #define VCD_SIGNAL_DUMPER_INIT(aRgUmEnT)                   vcd_signal_dumper_init(aRgUmEnT)
 #define VCD_SIGNAL_DUMPER_CLOSE()                          vcd_signal_dumper_close()
 #define VCD_SIGNAL_DUMPER_CREATE_HEADER()                  vcd_signal_dumper_create_header()
 #define VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(vAr1,vAr2) vcd_signal_dumper_dump_variable_by_name(vAr1,vAr2)
 #define VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(vAr1,vAr2) vcd_signal_dumper_dump_function_by_name(vAr1,vAr2)
+#else
+#define VCD_SIGNAL_DUMPER_INIT(aRgUmEnT) 
+#define VCD_SIGNAL_DUMPER_CLOSE()       
+#define VCD_SIGNAL_DUMPER_CREATE_HEADER()
+#define VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(vAr1,vAr2) 
+#define VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(vAr1,vAr2)
+#endif
 
  
 #endif /* T_TRACER */

common/utils/memory_pools.c

@@ -1,490 +0,0 @@
-/*
- * 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 "assertions.h"
-#include "memory_pools.h"
-
-#if T_TRACER
-  #include <string.h>
-  #include "T.h"
-#endif
-
-/*------------------------------------------------------------------------------*/
-const static int mp_debug = 0;
-
-# define MP_DEBUG(x, args...) do { if (mp_debug) fprintf(stdout, "[MP][D]"x, ##args); fflush (stdout); } \
-  while(0)
-
-/*------------------------------------------------------------------------------*/
-#ifndef CHARS_TO_UINT32
-  #define CHARS_TO_UINT32(c1, c2, c3, c4) (((c1) << 24) | ((c2) << 16) | ((c3) << 8) | (c4))
-#endif
-
-#define MEMORY_POOL_ITEM_INFO_NUMBER    2
-
-/*------------------------------------------------------------------------------*/
-typedef int32_t     items_group_position_t;
-typedef int32_t     items_group_index_t;
-
-typedef union items_group_positions_u {
-  uint64_t                    all;
-  struct {
-    items_group_position_t  put;
-    items_group_position_t  get;
-  } ind;
-} items_group_positions_t;
-
-typedef struct items_group_s {
-  items_group_position_t              number_plus_one;
-  volatile uint32_t                   minimum;
-  volatile items_group_positions_t    positions;
-  volatile items_group_index_t       *indexes;
-} items_group_t;
-
-/*------------------------------------------------------------------------------*/
-//static const items_group_position_t ITEMS_GROUP_POSITION_INVALID    = -1;
-static const items_group_index_t    ITEMS_GROUP_INDEX_INVALID       = -1;
-
-/*------------------------------------------------------------------------------*/
-typedef uint32_t    pool_item_start_mark_t;
-typedef uint32_t    pool_item_end_mark_t;
-
-typedef uint32_t    memory_pool_data_t;
-
-typedef uint32_t    pool_start_mark_t;
-
-typedef uint32_t    pools_start_mark_t;
-
-typedef uint8_t     pool_id_t;
-typedef uint8_t     item_status_t;
-
-typedef struct memory_pool_item_start_s {
-  pool_item_start_mark_t      start_mark;
-
-  pool_id_t                   pool_id;
-  item_status_t               item_status;
-  uint16_t                    info[MEMORY_POOL_ITEM_INFO_NUMBER];
-} memory_pool_item_start_t;
-
-typedef struct memory_pool_item_end_s {
-  pool_item_end_mark_t        end_mark;
-} memory_pool_item_end_t;
-
-typedef struct memory_pool_item_s {
-  memory_pool_item_start_t    start;
-  memory_pool_data_t          data[0];
-  memory_pool_item_end_t      end;
-} memory_pool_item_t;
-
-typedef struct memory_pool_s {
-  pool_start_mark_t           start_mark;
-
-  pool_id_t                   pool_id;
-  uint32_t                    item_data_number;
-  uint32_t                    pool_item_size;
-  items_group_t               items_group_free;
-  memory_pool_item_t         *items;
-} memory_pool_t;
-
-
-typedef struct memory_pools_s {
-  pools_start_mark_t          start_mark;
-
-  uint32_t                    pools_number;
-  uint32_t                    pools_defined;
-  memory_pool_t              *pools;
-} memory_pools_t;
-
-/*------------------------------------------------------------------------------*/
-static const uint32_t               MAX_POOLS_NUMBER =      20;
-static const uint32_t               MAX_POOL_ITEMS_NUMBER = 200 * 1000;
-static const uint32_t               MAX_POOL_ITEM_SIZE =    100 * 1000;
-
-static const pool_item_start_mark_t POOL_ITEM_START_MARK =  CHARS_TO_UINT32 ('P', 'I', 's', 't');
-static const pool_item_end_mark_t   POOL_ITEM_END_MARK =    CHARS_TO_UINT32 ('p', 'i', 'E', 'N');
-
-static const item_status_t          ITEM_STATUS_FREE =      'F';
-static const item_status_t          ITEM_STATUS_ALLOCATED = 'a';
-
-static const pool_start_mark_t      POOL_START_MARK =       CHARS_TO_UINT32 ('P', '_', 's', 't');
-
-static const pools_start_mark_t     POOLS_START_MARK =      CHARS_TO_UINT32 ('P', 'S', 's', 't');
-
-/*------------------------------------------------------------------------------*/
-static inline uint32_t items_group_number_items (items_group_t *items_group) {
-  return items_group->number_plus_one - 1;
-}
-
-static inline uint32_t items_group_free_items (items_group_t *items_group) {
-  items_group_positions_t positions;
-  uint32_t                free_items;
-  positions.all = items_group->positions.all;
-  free_items = items_group->number_plus_one + positions.ind.put - positions.ind.get;
-  free_items %= items_group->number_plus_one;
-  return free_items;
-}
-
-static inline items_group_index_t items_group_get_free_item (items_group_t *items_group) {
-  items_group_position_t  get_raw;
-  items_group_position_t  put;
-  items_group_position_t  get;
-  items_group_position_t  free_items;
-  items_group_index_t     index = ITEMS_GROUP_INDEX_INVALID;
-  /* Get current put position */
-  put = items_group->positions.ind.put % items_group->number_plus_one;
-  /* Get current get position and increase it */
-  get_raw = __sync_fetch_and_add (&items_group->positions.ind.get, 1);
-  get = get_raw % items_group->number_plus_one;
-
-  if(put == get) {
-    /* No more item free, restore previous position */
-    __sync_fetch_and_sub (&items_group->positions.ind.get, 1);
-  } else {
-    /* Get index at current get position */
-    index = items_group->indexes[get];
-
-    if (index <= ITEMS_GROUP_INDEX_INVALID) {
-      /* Index has not yet been completely freed, restore previous get position */
-      __sync_fetch_and_sub (&items_group->positions.ind.get, 1);
-    } else {
-      if (get_raw == items_group->number_plus_one) {
-        /* Wrap get position */
-        __sync_fetch_and_sub (&items_group->positions.ind.get, items_group->number_plus_one);
-      }
-
-      free_items = items_group_free_items(items_group);
-
-      /* Updates minimum free items if needed */
-      while (items_group->minimum > free_items) {
-        items_group->minimum = free_items;
-      }
-
-      /* Clear index at current get position to indicate that item is free */
-      items_group->indexes[get] = ITEMS_GROUP_INDEX_INVALID;
-    }
-  }
-
-  return (index);
-}
-
-static inline int items_group_put_free_item (items_group_t *items_group, items_group_index_t index) {
-  items_group_position_t  put_raw;
-  items_group_position_t  put;
-  /* Get current put position and increase it */
-  put_raw = __sync_fetch_and_add (&items_group->positions.ind.put, 1);
-  put = put_raw % items_group->number_plus_one;
-
-  if (put_raw == items_group->number_plus_one) {
-    /* Wrap position */
-    __sync_fetch_and_sub (&items_group->positions.ind.put, items_group->number_plus_one);
-  }
-
-  AssertError (items_group->indexes[put] <= ITEMS_GROUP_INDEX_INVALID, return (EXIT_FAILURE),
-               "Index at current put position (%d) is not marked as free (%d)!\n", put, items_group->number_plus_one);
-  /* Save freed item index at current put position */
-  items_group->indexes[put] = index;
-  return (EXIT_SUCCESS);
-}
-
-/*------------------------------------------------------------------------------*/
-static inline memory_pools_t *memory_pools_from_handler (memory_pools_handle_t memory_pools_handle) {
-  memory_pools_t *memory_pools;
-  /* Recover memory_pools */
-  memory_pools = (memory_pools_t *) memory_pools_handle;
-  /* Sanity check on passed handle */
-  AssertError (memory_pools->start_mark == POOLS_START_MARK, memory_pools = NULL,
-               "Handle %p is not a valid memory pools handle, start mark is missing!\n", memory_pools_handle);
-  return (memory_pools);
-}
-
-static inline memory_pool_item_t *memory_pool_item_from_handler (memory_pool_item_handle_t memory_pool_item_handle) {
-  void               *address;
-  memory_pool_item_t *memory_pool_item;
-  /* Recover memory_pools */
-  address = memory_pool_item_handle - sizeof(memory_pool_item_start_t);
-  memory_pool_item = (memory_pool_item_t *) address;
-  /* Sanity check on passed handle */
-  AssertError (memory_pool_item->start.start_mark == POOL_ITEM_START_MARK, memory_pool_item = NULL,
-               "Handle %p is not a valid memory pool item handle, start mark is missing!\n", memory_pool_item);
-  return (memory_pool_item);
-}
-
-static inline memory_pool_item_t *memory_pool_item_from_index (memory_pool_t *memory_pool, items_group_index_t index) {
-  void               *address;
-  address = (void *) memory_pool->items;
-  address += index * memory_pool->pool_item_size;
-  return (address);
-}
-
-/*------------------------------------------------------------------------------*/
-memory_pools_handle_t memory_pools_create (uint32_t pools_number) {
-  memory_pools_t *memory_pools;
-  pool_id_t       pool;
-  AssertFatal (pools_number <= MAX_POOLS_NUMBER, "Too many memory pools requested (%d/%d)!\n", pools_number, MAX_POOLS_NUMBER); /* Limit to a reasonable number of pools */
-  /* Allocate memory_pools */
-  memory_pools = malloc (sizeof(memory_pools_t));
-  AssertFatal (memory_pools != NULL, "Memory pools structure allocation failed!\n");
-  /* Initialize memory_pools */
-  {
-    memory_pools->start_mark    = POOLS_START_MARK;
-    memory_pools->pools_number  = pools_number;
-    memory_pools->pools_defined = 0;
-    /* Allocate pools */
-    memory_pools->pools         = calloc (pools_number, sizeof(memory_pool_t));
-    AssertFatal (memory_pools->pools != NULL, "Memory pools allocation failed!\n");
-
-    /* Initialize pools */
-    for (pool = 0; pool < pools_number; pool++) {
-      memory_pools->pools[pool].start_mark = POOL_START_MARK;
-    }
-  }
-  return ((memory_pools_handle_t) memory_pools);
-}
-
-char *memory_pools_statistics(memory_pools_handle_t memory_pools_handle) {
-  memory_pools_t     *memory_pools;
-  pool_id_t           pool;
-  char               *statistics;
-  int                 printed_chars;
-  uint32_t            allocated_pool_memory;
-  uint32_t            allocated_pools_memory = 0;
-  items_group_t      *items_group;
-  uint32_t            pool_items_size;
-  /* Recover memory_pools */
-  memory_pools = memory_pools_from_handler (memory_pools_handle);
-  AssertFatal (memory_pools != NULL, "Failed to retrieve memory pool for handle %p!\n", memory_pools_handle);
-  statistics = malloc(memory_pools->pools_defined * 200);
-  printed_chars = sprintf (&statistics[0], "Pool:   size, number, minimum,   free, address space and memory used in Kbytes\n");
-
-  for (pool = 0; pool < memory_pools->pools_defined; pool++) {
-    items_group = &memory_pools->pools[pool].items_group_free;
-    allocated_pool_memory = items_group_number_items (items_group) * memory_pools->pools[pool].pool_item_size;
-    allocated_pools_memory += allocated_pool_memory;
-    pool_items_size = memory_pools->pools[pool].item_data_number * sizeof(memory_pool_data_t);
-    printed_chars += sprintf (&statistics[printed_chars], "  %2u: %6u, %6u,  %6u, %6u, [%p-%p] %6u\n",
-                              pool, pool_items_size,
-                              items_group_number_items (items_group),
-                              items_group->minimum,
-                              items_group_free_items (items_group),
-                              memory_pools->pools[pool].items,
-                              ((void *) memory_pools->pools[pool].items) + allocated_pool_memory,
-                              allocated_pool_memory / (1024));
-  }
-
-  printed_chars = sprintf (&statistics[printed_chars], "Pools memory %u Kbytes\n", allocated_pools_memory / (1024));
-  return (statistics);
-}
-
-int memory_pools_add_pool (memory_pools_handle_t memory_pools_handle, uint32_t pool_items_number, uint32_t pool_item_size) {
-  memory_pools_t     *memory_pools;
-  memory_pool_t      *memory_pool;
-  pool_id_t           pool;
-  items_group_index_t item_index;
-  memory_pool_item_t *memory_pool_item;
-  AssertFatal (pool_items_number <= MAX_POOL_ITEMS_NUMBER, "Too many items for a memory pool (%u/%d)!\n", pool_items_number, MAX_POOL_ITEMS_NUMBER); /* Limit to a reasonable number of items */
-  AssertFatal (pool_item_size <= MAX_POOL_ITEM_SIZE, "Item size is too big for memory pool items (%u/%d)!\n", pool_item_size, MAX_POOL_ITEM_SIZE);   /* Limit to a reasonable item size */
-  /* Recover memory_pools */
-  memory_pools    = memory_pools_from_handler (memory_pools_handle);
-  AssertFatal (memory_pools != NULL, "Failed to retrieve memory pool for handle %p!\n", memory_pools_handle);
-  /* Check number of already created pools */
-  AssertFatal (memory_pools->pools_defined < memory_pools->pools_number, "Can not allocate more memory pool (%d)!\n", memory_pools->pools_number);
-  /* Select pool */
-  pool            = memory_pools->pools_defined;
-  memory_pool     = &memory_pools->pools[pool];
-  /* Initialize pool */
-  {
-    memory_pool->pool_id                            = pool;
-    /* Item size in memory_pool_data_t items by excess */
-    memory_pool->item_data_number                   = (pool_item_size + sizeof(memory_pool_data_t) - 1) / sizeof(memory_pool_data_t);
-    memory_pool->pool_item_size                     = (memory_pool->item_data_number * sizeof(memory_pool_data_t)) + sizeof(memory_pool_item_t);
-    memory_pool->items_group_free.number_plus_one   = pool_items_number + 1;
-    memory_pool->items_group_free.minimum           = pool_items_number;
-    memory_pool->items_group_free.positions.ind.put = pool_items_number;
-    memory_pool->items_group_free.positions.ind.get = 0;
-    /* Allocate free indexes */
-    memory_pool->items_group_free.indexes = malloc(memory_pool->items_group_free.number_plus_one * sizeof(items_group_index_t));
-    AssertFatal (memory_pool->items_group_free.indexes != NULL, "Memory pool indexes allocation failed!\n");
-
-    /* Initialize free indexes */
-    for (item_index = 0; item_index < pool_items_number; item_index++) {
-      memory_pool->items_group_free.indexes[item_index] = item_index;
-    }
-
-    /* Last index is not allocated */
-    memory_pool->items_group_free.indexes[item_index] = ITEMS_GROUP_INDEX_INVALID;
-    /* Allocate items */
-    memory_pool->items = calloc (pool_items_number, memory_pool->pool_item_size);
-    AssertFatal (memory_pool->items != NULL, "Memory pool items allocation failed!\n");
-
-    /* Initialize items */
-    for (item_index = 0; item_index < pool_items_number; item_index++) {
-      memory_pool_item                                      = memory_pool_item_from_index (memory_pool, item_index);
-      memory_pool_item->start.start_mark                    = POOL_ITEM_START_MARK;
-      memory_pool_item->start.pool_id                       = pool;
-      memory_pool_item->start.item_status                   = ITEM_STATUS_FREE;
-      memory_pool_item->data[memory_pool->item_data_number] = POOL_ITEM_END_MARK;
-    }
-  }
-  memory_pools->pools_defined ++;
-  return (0);
-}
-
-memory_pool_item_handle_t memory_pools_allocate (memory_pools_handle_t memory_pools_handle, uint32_t item_size, uint16_t info_0, uint16_t info_1) {
-  memory_pools_t             *memory_pools;
-  memory_pool_item_t         *memory_pool_item;
-  memory_pool_item_handle_t   memory_pool_item_handle = NULL;
-  pool_id_t                   pool;
-  items_group_index_t         item_index = ITEMS_GROUP_INDEX_INVALID;
-  /* Recover memory_pools */
-  memory_pools = memory_pools_from_handler (memory_pools_handle);
-  AssertError (memory_pools != NULL, {}, "Failed to retrieve memory pool for handle %p!\n", memory_pools_handle);
-
-  for (pool = 0; pool < memory_pools->pools_defined; pool++) {
-    if ((memory_pools->pools[pool].item_data_number * sizeof(memory_pool_data_t)) < item_size) {
-      /* This memory pool has too small items, skip it */
-      continue;
-    }
-
-    item_index = items_group_get_free_item(&memory_pools->pools[pool].items_group_free);
-
-    if (item_index <= ITEMS_GROUP_INDEX_INVALID) {
-      /* Allocation failed, skip this pool */
-      continue;
-    } else {
-      /* Allocation succeed, exit searching loop */
-      break;
-    }
-  }
-
-  if (item_index > ITEMS_GROUP_INDEX_INVALID) {
-    /* Convert item index into memory_pool_item address */
-    memory_pool_item                    = memory_pool_item_from_index (&memory_pools->pools[pool], item_index);
-    /* Sanity check on item status, must be free */
-    AssertFatal (memory_pool_item->start.item_status == ITEM_STATUS_FREE, "Item status is not set to free (%d) in pool %u, item %d!\n",
-                 memory_pool_item->start.item_status, pool, item_index);
-    memory_pool_item->start.item_status = ITEM_STATUS_ALLOCATED;
-    memory_pool_item->start.info[0]     = info_0;
-    memory_pool_item->start.info[1]     = info_1;
-    memory_pool_item_handle             = memory_pool_item->data;
-    MP_DEBUG(" Alloc [%2u][%6d]{%6d}, %3u %3u, %6u, %p, %p, %p\n",
-             pool, item_index,
-             items_group_free_items (&memory_pools->pools[pool].items_group_free),
-             info_0, info_1,
-             item_size,
-             memory_pools->pools[pool].items,
-             memory_pool_item,
-             memory_pool_item_handle);
-  } else {
-    MP_DEBUG(" Alloc [--][------]{------}, %3u %3u, %6u, failed!\n", info_0, info_1, item_size);
-  }
-
-  return memory_pool_item_handle;
-}
-
-int memory_pools_free (memory_pools_handle_t memory_pools_handle, memory_pool_item_handle_t memory_pool_item_handle, uint16_t info_0) {
-  memory_pools_t     *memory_pools;
-  memory_pool_item_t *memory_pool_item;
-  pool_id_t           pool;
-  items_group_index_t item_index;
-  uint32_t            item_size;
-  uint32_t            pool_item_size;
-  uint16_t            info_1;
-  int                 result;
-  /* Recover memory_pools */
-  memory_pools = memory_pools_from_handler (memory_pools_handle);
-  AssertError (memory_pools != NULL, return (EXIT_FAILURE), "Failed to retrieve memory pools for handle %p!\n", memory_pools_handle);
-  /* Recover memory pool item */
-  memory_pool_item = memory_pool_item_from_handler (memory_pool_item_handle);
-  AssertError (memory_pool_item != NULL, return (EXIT_FAILURE), "Failed to retrieve memory pool item for handle %p!\n", memory_pool_item_handle);
-  info_1 = memory_pool_item->start.info[1];
-  /* Recover pool index */
-  pool = memory_pool_item->start.pool_id;
-  AssertFatal (pool < memory_pools->pools_defined, "Pool index is invalid (%u/%u)!\n", pool, memory_pools->pools_defined);
-  item_size = memory_pools->pools[pool].item_data_number;
-  pool_item_size = memory_pools->pools[pool].pool_item_size;
-  item_index = (((void *) memory_pool_item) - ((void *) memory_pools->pools[pool].items)) / pool_item_size;
-  MP_DEBUG(" Free  [%2u][%6d]{%6d}, %3u %3u,         %p, %p, %p, %u\n",
-           pool, item_index,
-           items_group_free_items (&memory_pools->pools[pool].items_group_free),
-           memory_pool_item->start.info[0], info_1,
-           memory_pool_item_handle, memory_pool_item,
-           memory_pools->pools[pool].items, ((uint32_t) (item_size * sizeof(memory_pool_data_t))));
-  /* Sanity check on calculated item index */
-  AssertFatal (memory_pool_item == memory_pool_item_from_index(&memory_pools->pools[pool], item_index),
-               "Incorrect memory pool item address (%p, %p) for pool %u, item %d!\n",
-               memory_pool_item,(void *)memory_pool_item_from_index(&memory_pools->pools[pool], item_index), pool, item_index);
-  /* Sanity check on end marker, must still be present (no write overflow) */
-  AssertFatal (memory_pool_item->data[item_size] == POOL_ITEM_END_MARK,
-               "Memory pool item is corrupted, end mark is not present for pool %u, item %d!\n", pool, item_index);
-  /* Sanity check on item status, must be allocated */
-  AssertFatal (memory_pool_item->start.item_status == ITEM_STATUS_ALLOCATED,
-               "Trying to free a non allocated (%x) memory pool item (pool %u, item %d)!\n",
-               memory_pool_item->start.item_status, pool, item_index);
-  memory_pool_item->start.item_status = ITEM_STATUS_FREE;
-  result = items_group_put_free_item(&memory_pools->pools[pool].items_group_free, item_index);
-  AssertError (result == EXIT_SUCCESS, {}, "Failed to free memory pool item (pool %u, item %d)!\n", pool, item_index);
-  return (result);
-}
-
-void memory_pools_set_info (memory_pools_handle_t memory_pools_handle, memory_pool_item_handle_t memory_pool_item_handle, int index, uint16_t info) {
-  memory_pools_t     *memory_pools;
-  memory_pool_item_t *memory_pool_item;
-  pool_id_t           pool;
-  items_group_index_t item_index;
-  uint32_t            item_size;
-  uint32_t            pool_item_size;
-  AssertFatal (index < MEMORY_POOL_ITEM_INFO_NUMBER, "Incorrect info index (%d/%d)!\n", index, MEMORY_POOL_ITEM_INFO_NUMBER);
-  /* Recover memory pool item */
-  memory_pool_item = memory_pool_item_from_handler (memory_pool_item_handle);
-  AssertFatal (memory_pool_item != NULL, "Failed to retrieve memory pool item for handle %p!\n", memory_pool_item_handle);
-  /* Set info[1] */
-  memory_pool_item->start.info[index] = info;
-
-  /* Check item validity and log (not mandatory) */
-  if (1) {
-    /* Recover memory_pools */
-    memory_pools = memory_pools_from_handler (memory_pools_handle);
-    AssertFatal (memory_pools != NULL, "Failed to retrieve memory pool for handle %p!\n", memory_pools_handle);
-    /* Recover pool index */
-    pool = memory_pool_item->start.pool_id;
-    AssertFatal (pool < memory_pools->pools_defined, "Pool index is invalid (%u/%u)!\n", pool, memory_pools->pools_defined);
-    item_size = memory_pools->pools[pool].item_data_number;
-    pool_item_size = memory_pools->pools[pool].pool_item_size;
-    item_index = (((void *) memory_pool_item) - ((void *) memory_pools->pools[pool].items)) / pool_item_size;
-    MP_DEBUG(" Info  [%2u][%6d]{%6d}, %3u %3u,         %p, %p, %p, %u\n",
-             pool, item_index,
-             items_group_free_items (&memory_pools->pools[pool].items_group_free),
-             memory_pool_item->start.info[0], memory_pool_item->start.info[1],
-             memory_pool_item_handle, memory_pool_item,
-             memory_pools->pools[pool].items, ((uint32_t) (item_size * sizeof(memory_pool_data_t))));
-    /* Sanity check on calculated item index */
-    AssertFatal (memory_pool_item == memory_pool_item_from_index(&memory_pools->pools[pool], item_index),
-                 "Incorrect memory pool item address (%p, %p) for pool %u, item %d!\n",
-                 memory_pool_item, (void *)memory_pool_item_from_index(&memory_pools->pools[pool], item_index), pool, item_index);
-    /* Sanity check on end marker, must still be present (no write overflow) */
-    AssertFatal (memory_pool_item->data[item_size] == POOL_ITEM_END_MARK,
-                 "Memory pool item is corrupted, end mark is not present for pool %u, item %d!\n", pool, item_index);
-    /* Sanity check on item status, must be allocated */
-    AssertFatal (memory_pool_item->start.item_status == ITEM_STATUS_ALLOCATED,
-                 "Trying to free a non allocated (%x) memory pool item (pool %u, item %d)\n",
-                 memory_pool_item->start.item_status, pool, item_index);
-  }
-}

common/utils/threadPool/thread-pool.md

@@ -6,10 +6,9 @@ Each worker loop on pick from the same input queue jobs to do.
 
 When a job is done, the worker sends a return if a return is defined.
 
-    A selective abort allows to cancel parallel jobs (usage: a client pushed jobs, but from a response of one job, the other linked jobs becomes useless).
+A selective abort allows to cancel parallel jobs (usage: a client pushed jobs, but from a response of one job, the other linked jobs becomes useless).
 
-      All the thread pool functions are thread safe, nevertheless the working functions are implemented by the thread pool client,
+All the thread pool functions are thread safe, nevertheless the working functions are implemented by the thread pool client, so the client has to tackle the parallel execution of his functions called "processingFunc" hereafter.
-      so the client has to tackle the parallel execution of his functions called "processingFunc" hereafter.
 
 ## license
     Author:
@@ -18,65 +17,187 @@ When a job is done, the worker sends a return if a return is defined.
 
 # jobs
 
-      A job is a message (notifiedFIFO_elt_t):
+A job is a message (notifiedFIFO_elt_t):  
-    next:
-        internal FIFO chain, do not set it
-    key:
-          a long int that the client can use to identify a message or a group of messages
-    responseFifo:
-          if the client defines a response FIFO, the message will be posted back after processing
-    processingFunc:
-          any funtion (type void processingFunc(void *)) that the worker will launch
-    msgData:
-            the data passed to processingFunc. It can be added automatically, or you can set it to a buffer you are managing
-    malloced:
-    a boolean that enable internal free in these cases:
-            no return Fifo or Abort feature
 
-                      The job messages can be created with newNotifiedFIFO_elt() and delNotifiedFIFO_elt() or managed by the client.
+* next:
+  internal FIFO chain, do not set it
+* key:
+  a long int that the client can use to identify a message or a group of messages
+* ResponseFifo:
+  if the client defines a response FIFO, the message will be posted back after processing
+* processingFunc:
+  any funtion (type void processingFunc(void *)) that the worker will launch
+* msgData:
+  the data passed to processingFunc. It can be added automatically, or you can set it to a buffer you are managing
+* malloced:
+  a boolean that enable internal free in these cases:
+  no return Fifo or Abort feature
+
+The job messages can be created with newNotifiedFIFO_elt() and delNotifiedFIFO_elt() or managed by the client.
 
 # Queues of jobs
 
-              Queues are type of:
+Queues are type of:
-                      notifiedFIFO_t that must be initialized by init_notifiedFIFO()
-                      No delete function is required, the creator has only to free the data of type notifiedFIFO_t
 
-                      push_notifiedFIFO() add a job in the queue
+* notifiedFIFO_t that must be initialized by init_notifiedFIFO()
-                      pull_notifiedFIFO() is blocking, poll_notifiedFIFO() is non blocking
+* No delete function is required, the creator has only to free the data of type notifiedFIFO_t
+* push_notifiedFIFO() add a job in the queue
+* pull_notifiedFIFO() is blocking, poll_notifiedFIFO() is non blocking
+* abort_notifiedFIFO() allows the customer to delete all waiting jobs that match with the key (see key in jobs definition)
 
-                      abort_notifiedFIFO() allows the customer to delete all waiting jobs that match with the key (see key in jobs definition)
+These queues details hereafter
+
+## Common
+
+newNotifiedFIFO_elt()
+
+creates a message, that will later be used in queues/FIFO
+
+delNotifiedFIFO_elt()
+
+deletes it
+
+NotifiedFifoData()
+
+gives a pointer to the beginning of free usage memory in a message (you can put any data there, up to 'size' parameter you passed to newNotifiedFIFO_elt()
+
+These 3 calls are not mandatory, you can also use your own memory to save the malloc()/free() that are behind these calls
+iFirst level: non thread safe FIFO (or queues)
+
+# low level: fast and simple
+
+initNotifiedFIFO_nothreadSafe()
+
+to create a queue
+
+pushNotifiedFIFO_nothreadSafe()
+
+Add a element in a queue
+
+pullNotifiedFIFO_nothreadSafe()
+
+pull a element from a queue
+
+As these queues are not thread safe, there is NO blocking mechanism, neither pull() versus poll() calls
+
+There is no delete for a message queue: you only have to abandon the memory you allocated to call iinitNotifiedFIFO_nothreadSafe(notifiedFIFO_t *nf)
+
+So if you malloced the memory under 'nf' parameter you have to free it, if it is automatic variable (local variable) or global variable, nothing is to be done.
+
+
+## thread safe queues
+
+These queues are built on not thread safe queues when we need thread to thread protection
+
+initNotifiedFIFO()
+
+to create a queue
+
+pushNotifiedFIFO()
+
+Add a element in a queue
+
+pullNotifiedFIFO()
+
+pull a element from a queue, this call is blocking until a message arrived
+
+pollNotifiedFIFO()
+
+pull a element from a queue, this call is not blocking, so it returns always very shortly
+
+in 99.9% cases, pull() is better than poll()
+
+No delete() call, same principle as not thread safe queues
 
 # Thread pools
 
 ## initialization
-                      The clients can create one or more thread pools with init_tpool()
+The clients can create one or more thread pools with init_tpool()
-              the params string structure:
-                      describes a list of cores, separated by "," that run a worker thread
 
-                      If the core exists on the CPU, the thread pool initialization sets the affinity between this thread and
+the params string structure: describes a list of cores, separated by "," that run a worker thread
-                      the related code (use negative values is allowed, so the thread will never be mapped on a specific core).
 
-                      The threads are all Linux real time scheduler, their name is set automatically is "Tpool_<core id>"
+If the core exists on the CPU, the thread pool initialization sets the affinity between this thread and the related code (use negative values is allowed, so the thread will never be mapped on a specific core).
+
+The threads are all Linux real time scheduler, their name is set automatically is "Tpool_<core id>"
 
 ## adding jobs
-                      The client create their jobs messages as a notifiedFIFO_elt_t, then they push it with pushTpool() (that internally calls push_notifiedFIFO())
+The client create their jobs messages as a notifiedFIFO_elt_t, then they push it with pushTpool() (that internally calls push_notifiedFIFO())
 
-                      If they need a return, they have to create response queues with init_notifiedFIFO() and set this FIFO pointer in the notifiedFIFO_elt_t before pushing the job.
+If they need a return, they have to create response queues with init_notifiedFIFO() and set this FIFO pointer in the notifiedFIFO_elt_t before pushing the job.
 
 ## abort
 
-                      A abort service abortTpool() allows to abort all jobs that match a key (see jobs "key"). When the abort returns, it garanties no job (matching the key) response will be posted on response queues.
+A abort service abortTpool() allows to abort all jobs that match a key (see jobs "key"). When the abort returns, it garanties no job (matching the key) response will be posted on response queues.
 
-                      Nevertheless, jobs already performed before the return of abortTpool() are pushed in the response Fifo queue.
+Nevertheless, jobs already performed before the return of abortTpool() are pushed in the response Fifo queue.
+
+## API details
+Each thread pool (there can be several in the same process) should be initialized
+
+### initTpool(char *params,tpool_t *pool, bool performanceMeas) is to be called oncepool
+
+the configuration parameter is a string, elements separated by ",":
+
+* N: if a N is in the parameter list, no threads are created
+    The purpose is to keep the same API in any case
+* a CPU with a little number of cores,
+    or in debugging sessions to simplify the human work
+* a number that represent a valid CPU core on the target CPU
+    A thread is created and stick on the core (with set affinity)
+* a number that is not a valid CPU core
+    a floating thread is created (Linux is responsible of the real time core allocation)
+
+example: "-1,-1,-1"
+as there is no core number -1, the thread pool is made of 3 floating threads
+be careful with fix allocation: it is hard to be more clever than Linux kernel
+
+pool is the memory you allocated before to store the thread pool internal state (same concept as above queues)
+
+performanceMeas is a flag to enable measurements (well described in documentation)
+
+### pushTpool(tpool_t *t, notifiedFIFO_elt_t *msg)
+
+adds a job to do in the thread pool
+
+The msg data you can set are:
+
+* key:  
+    a value for you that you will find back in the response
+    it is also the key for abortTpool()
+* reponseFifo  
+    if you set it, the message will be sent back on this queue when the job is done
+    if you don't set it, no return is performed, the thread pool frees the message 'msg' when the job is done
+* processingFunc  
+    the function the job will run. the function prototype is void <func>(void *memory)
+    the data part (the pointer returned by NotifiedFifoData(msg)) is passed to the function
+    it is used to send data to the processing function and also to write back results
+    of course, writing back results will lead you to use also a return queue (the parameter reponseFifo)
+
+### pullTpool() collects job result in a return queue
+
+you collect results in one result queue: the message you gave to pushTpool(), nevertheless it has been updated by processingFunc()
+
+An example of multiple return queues, in eNB: I created one single thread pool (because it depends mainly on CPU hardware), but i use two return queues: one for turbo encode, one for turbo decode.
+
+### tryPullTpool()
+
+is the same, but not blocking (pollTpool() would have been a better name)
+
+### abortTpool()
+
+Is a facility to cancel work you pushed to a thread pool
+
+I used it once: when eNB performs turbo decode, I push all segments in the thread pool.
+
+But when I get back the decoding results, if one segment can't be decoded, I don't need the results of the other segments of the same UE.
 
 ## Performance measurements
 
-                  A performance measurement is integrated:
+A performance measurement is integrated:
-                  the pool will automacillay fill timestamps:
+the pool will automacillay fill timestamps:
-
-                  * creationTime:
-                          time the request is push to the pool;
 
+* creationTime:
+time the request is push to the pool;
 * startProcessingTime:
 time a worker start to run on the job
 * endProcessingTime:

doc/5Gnas.md

@@ -0,0 +1,107 @@
+<style type="text/css" rel="stylesheet">
+
+body {
+   font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+   font-size: 13px;
+   line-height: 18px;
+   color: #fff;
+   background-color: #110F14;
+}
+  h2 { margin-left: 20px; }
+  h3 { margin-left: 40px; }
+  h4 { margin-left: 60px; }
+
+.func2 { margin-left: 20px; }
+.func3 { margin-left: 40px; }
+.func4 { margin-left: 60px; }
+
+</style>
+
+
+This tuto for 5G gNB NAS design
+{: .text-center}
+
+# source files
+
+executables/ocp-gnb.c: a main loop to create a debuggable gNB, see document SW_archi.md
+openair2/RRC/NR/nr_ngap_gNB.c: skeleton for interface with NGAP
+openair3/NAS/COMMON/milenage.h: a simple milenage implementation, depend only on crypto library
+openair3/NAS/COMMON/NR_NAS_defs.h: messages defined for NAS implemented in C: C struct, C enums and automatic conversion to labels for debug messages
+openair3/NAS/COMMON/nr_common.c: 5G NAS common code between gNB and UE
+openair3/UICC/usim_interface.c: UICC simulation for USIM messages
+
+openair3/NAS/NR_UE/ue_process_nas.c: NAS code for UE
+
+openair3/NAS/gNB/network_process_nas.c: NAS code for gNB running without 5GC
+
+openair3/TEST/test5Gnas.c: unitary testing of NAS messages: encodes+decode a standard network entry, mixing code from UE and 5GC (or gNB in noCore)
+
+# USIM simulation
+A new USIM simulation, that parameters are in regular OAI config files
+
+## To open the USIM
+init_uicc() takes a parameter: the name of the block in the config file
+In case we run several UEs in one process, the variable section name allows to make several UEs configurations in one config file.
+
+The NAS implementation uses this possibility.
+
+# UE side
+UEprocessNAS() is the entry for all messages.
+It decodes the message type and call the specific function for each messgae
+
+## Identityrequest + IdentityResponse
+When the UE receives the request, it stores the 5GC request parameters in the UE context ( UE->uicc pointer)
+It calls "scheduleNAS", that would trigger a answer (seeing general archtecture, it will probly be a itti message to future RRC or NGAP thread).  
+
+When the scheduler wants to encode the answer, it calls identityResponse()
+The UE search for a section in the config file called "uicc"
+it encodes the NAS answer with the IMSI, as a 4G compatible authentication.
+A future release would encode 5G SUPI as native 5G UICC.
+
+## Authenticationrequest + authenticationResponse
+When the UE receives the request, it stores the 5GC request parameters in the UE context ( UE->uicc pointer)
+It calls "scheduleNAS", that would trigger a answer (seeing general archtecture, it will probly be a itti message to future RRC or NGAP thread).  
+
+When the scheduler wants to encode the answer, it calls authenticationResponse()
+The UE search for a section in the config file called "uicc"
+It uses the Milenage parameters of this section to encode a milenage response
+A future release would encode 5G new authentication cyphering functions.
+
+## SecurityModeCommand + securityModeComplete
+When the UE receives the request it will:
+Selected NAS security algorithms: store it for future encoding
+Replayed UE security capabilities: check if it is equal to UE capabilities it sent to the 5GC
+IMEISV request: to implement
+ngKSI: Key set Indicator, similator to 4G to select a ciphering keys set
+
+When the scheduler wants to encode the answer, it calls registrationComplete() 
+
+## registrationComplete
+To be defined in UE, this NAS message is done after RRC sequence completes
+
+# gNB side
+gNB NGAP thread receives the NAS message from PHY layers
+In normal mode, it send it to the core network with no decoding.
+
+Here after, the gNB mode "noCore" processing in gNB: NGAP calls the entry function: processNAS() instead of forwarding the packet to the 5GC
+
+## RRCModeComplete + Identityrequest
+When the gNB completes RRC attach, it sends a first message to NGAP thread.
+Normal processing sends NGAP initial UE message, in noCore mode, it should call: identityRequest() that encode the NAS identity request inside the gNB.  
+The gNB NGAP thread then should call the piece of code that forward the message to the UE as when it receives a NAS message from 5GC.  
+
+## All NAS coming from UE
+When NGAP thread receives a NAS message from lower layers, it encapsulates it to forward it to the 5GC. In "noCore" mode it calls processNAS(). 
+
+This function stores in the gNB the NAS data, then it should encode the next message (identity, authentication, security mode) or do nothing (registration complete).
+
+
+<div class="panel panel-info">
+**Note**
+{: .panel-heading}
+<div class="panel-body">
+
+
+</div>
+</div>
+

doc/SW_archi.md

@@ -0,0 +1,212 @@
+<style type="text/css" rel="stylesheet">
+
+body {
+   font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+   font-size: 13px;
+   line-height: 18px;
+   color: #fff;
+   background-color: #110F14;
+}
+  h2 { margin-left: 20px; }
+  h3 { margin-left: 40px; }
+  h4 { margin-left: 60px; }
+
+.func2 { margin-left: 20px; }
+.func3 { margin-left: 40px; }
+.func4 { margin-left: 60px; }
+
+</style>
+
+
+This tuto for 5G gNB design, with Open Cells main
+{: .text-center}
+
+# Top file: executables/ocp-gnb.c
+
+the function main() initializes the data from configuration file
+
+# The main thread is in ru_thread()
+The infinite loop:
+## rx_rf()
+  Collect radio signal samples from RF board  
+    all SDR processing is triggered by I/Q sample reception and it's date (timestamp)  
+    TX I/Q samples will have a date in the future, compared to RX timestamp  
+    called for each 5G NR slot  
+    it blocks until data is available  
+    the internal time comes from the RF board sampling numbers  
+    (each sample has a incremental number representing a very accurate timing)  
+raw incoming data is in buffer called "rxdata"  
+    We derivate frame number, slot number, ... from the RX timestamp
+{: .func2}
+## nr_fep_full()
+"front end processing" of uplink signal  
+performs DFT on the signal  
+same function (duplicates): phy_procedures_gNB_common_RX()  
+it computes the buffer rxdataF (for frequency) from rxdata (samples over time)  
+rxdataF is the rxdata in frequency domain, phase aligned
+{: .func3}
+## gNB_top()
+only compute frame numbre, slot number, ...
+{: .func3}
+## ocp_rxtx()
+main processing for both UL and DL  
+start by calling oai_subframe_ind() that trigger processing in pnf_p7_subframe_ind() purpose ???  
+all the context is in the passed structure UL_INFO  
+the context is not very clear: there is a mutex on it,  
+but not actual coherency (see below handle_nr_rach() assumes data is up-to-date)  
+The first part (in NR_UL_indication, uses the data computed by the lower part (phy_procedures_gNB_uespec_RX), but for the **previous** slot  
+Then, phy_procedures_gNB_uespec_RX will hereafter replace the data for the next run  
+This is very tricky and not thread safe at all.
+{: .func3}
+
+### NR_UL_indication()  
+This block processes data already decoded and stored in structures behind UL_INFO
+{: .func4}
+
+* handle_nr_rach()  
+process data from RACH primary detection  
+if the input is a UE RACH detection
+{: .func4}
+    * nr_schedule_msg2()
+{: .func4}
+* handle_nr_uci()  
+????	      
+{: .func4}
+* handle_nr_ulsch()  
+handles ulsch data prepared by nr_fill_indication()
+{: .func4}
+* gNB_dlsch_ulsch_scheduler ()  
+the **scheduler** is called here, see dedicated chapter
+{: .func4}
+* NR_Schedule_response()  
+process as per the scheduler decided
+{: .func4}
+
+### L1_nr_prach_procedures()  
+????
+{: .func4}
+### phy_procedures_gNB_uespec_RX()
+* nr_decode_pucch0()  
+actual CCH channel decoding form rxdataF (rx data in frequency domain)  
+populates UL_INFO.uci_ind, actual uci data is in gNB->pucch  
+{: .func4}
+* nr_rx_pusch()  
+{: .func4}
+    * extracts data from rxdataF (frequency transformed received data)
+{: .func4}
+    * nr_pusch_channel_estimation()
+{: .func4}
+    * nr_ulsch_extract_rbs_single()
+{: .func4}
+    * nr_ulsch_scale_channel()
+{: .func4}
+    * nr_ulsch_channel_level()
+{: .func4}
+    * nr_ulsch_channel_compensation()
+{: .func4}
+    * nr_ulsch_compute_llr()  
+this function creates the "likelyhood ratios"  
+{: .func4}
+* nr_ulsch_procedures()
+{: .func4}
+    * actual ULsch decoding
+{: .func4}
+    * nr_ulsch_unscrambling()
+ {: .func4}
+   * nr_ulsch_decoding()
+ {: .func4}
+   * nr_fill_indication()   
+populate the data for the next call to "NR_UL_indication()"  
+it would be better to call **NR_UL_indication()** now instead of before (on previous slot)
+{: .func4}
+
+### phy_procedures_gNB_TX()
+* nr_common_signal_procedures()  
+generate common signals
+{: .func4}
+* nr_generate_dci_top()
+generate DCI: the scheduling informtion for each UE in both DL and UL
+{: .func4}
+* nr_generate_pdsch()  
+generate DL shared channel (user data)
+{: .func4}
+
+### nr_feptx_prec()
+tx precoding
+{: .func3}
+### nr_feptx0
+do the inverse DFT
+{: .func3}
+### tx_rf()
+send radio signal samples to the RF board  
+the samples numbers are the future time for these samples emission on-air
+{: .func3}
+
+# Scheduler
+The scheduler is called by the chain: nr_ul_indication()=>gNB_dlsch_ulsch_scheduler()
+It calls sub functions to process each physical channel (rach, ...)  
+The scheduler uses and internal map of used RB: vrb_map and vrb_map_UL, so each specific channel scheduler can see the already filled RB in each subframe (the function gNB_dlsch_ulsch_scheduler() clears these two arrays when it starts)   
+
+The scheduler also calls "run_pdcp()", as this is not a autonomous thread, it needs to be called here to update traffic requests (DL) and to propagate waiting UL to upper layers  
+After calling run_pdcp, it updates "rlc" time data but it doesn't actually process rlc 
+it sends a iiti message to activate the thread for RRC, the answer will be asynchronous in ????  
+
+Calls schedule_nr_mib() that calls mac_rrc_nr_data_req() to fill MIB,  
+
+Calls each channel allocation: schedule SI, schedule_ul, schedule_dl, ...  
+this is a major entry for "phy-test" mode: in this mode, the allocation is fixed  
+all these channels goes to mac_rrc_nr_data_req() to get the data to transmit  
+
+nr_schedule_ue_spec() is called  
+* calls nr_simple_dlsch_preprocessor()=> mac_rlc_status_ind() mac_rlc_status_ind() locks and checks directly inside rlc data the quantity of waiting data. So, the scheduler can allocate RBs
+* calls nr_update_pucch_scheduling()  
+    * get_pdsch_to_harq_feedback() to schedule retransmission in DL
+
+Calls nr_fill_nfapi_dl_pdu() to actually populate what should be done by the lower layers to make the Tx subframe
+
+
+
+# RRC
+RRC is a regular thread with itti loop on queue: TASK_RRC_GNB
+it receives it's configuration in message NRRRC_CONFIGURATION_REQ, then real time mesages for all events: S1/NGAP events, X2AP messages and RRC_SUBFRAME_PROCESS  
+  
+RRC_SUBFRAME_PROCESS message is send each subframe  
+  
+how does it communicate to  scheduler ?  
+
+
+# RLC
+RLC code is new implementation, not using OAI mechanisms: it is implmented directly on pthreads, ignoring OAI common functions.  
+It runs a thread waiting incoming data, but it is mainly running inside calling thread.  
+It is a library, running in thread RRC (except on itti message:  F1AP_UL_RRC_MESSAGE for F1).  
+
+# NGAP
+NGAP would be a itti thread as is S1AP (+twin thread SCTP that is almost void processing)?  
+About all messages are exchanged with RRC thread  
+
+
+# GTP
+Gtp + UDP are two twin threads performing the data plane interface to the core network
+The design is hybrid: thread and inside other threads calls. It should at least be protected by a mutex.
+## GTP thread
+Gtp thread has a itti interface: queue TASK_GTPV1_U  
+The interface is about full definition: control messages (create/delet GTP tunnels) and data messages (user plane UL and DL).  
+PDCP layer push to the GTP queue (outside UDP thread that do almost nothing and work only with GTP thread) is to push a UL packet.
+
+
+## GTP thread running code from other layers
+gtp thread calls directly pdcp_data_req(), so it runs inside it's context internal pdcp structures updates
+
+## inside other threads
+gtpv1u_create_s1u_tunnel(), delete tunnel, ... functions are called inside the other threads, without mutex.
+
+
+<div class="panel panel-info">
+**Note**
+{: .panel-heading}
+<div class="panel-body">
+
+
+</div>
+</div>
+

executables/main-fs6.c

@@ -435,7 +435,7 @@ void pusch_procedures_tosplit(uint8_t *bufferZone, int bufSize, PHY_VARS_eNB *eN
     if ((ulsch) &&
         (ulsch->rnti>0) &&
         (ulsch_harq->status == ACTIVE) &&
-        ((ulsch_harq->frame == frame)	    || (ulsch_harq->repetition_number >1) ) &&
+        ((ulsch_harq->frame == frame)     || (ulsch_harq->repetition_number >1) ) &&
         ((ulsch_harq->subframe == subframe) || (ulsch_harq->repetition_number >1) ) &&
         (ulsch_harq->handled == 0)) {
       // UE has ULSCH scheduling
@@ -1520,7 +1520,7 @@ void *cu_fs6(void *arg) {
       remoteIP[i]=0;
       break;
     }
-    
+
   AssertFatal(createUDPsock(NULL, CU_PORT, remoteIP, port_def, &sockFS6), "");
   L1_rxtx_proc_t L1proc= {0};
   // We pick the global thread pool from the legacy code global vars

executables/main-ocp.c

@@ -78,9 +78,18 @@ int otg_enabled;
 uint64_t  downlink_frequency[MAX_NUM_CCs][4];
 int32_t   uplink_frequency_offset[MAX_NUM_CCs][4];
 int split73;
+int usrp_tx_thread = 0;
 char * split73_config;
 int split73;
-int usrp_tx_thread = 0;
+AGENT_RRC_xface *agent_rrc_xface[NUM_MAX_ENB]= {0};
+AGENT_MAC_xface *agent_mac_xface[NUM_MAX_ENB]= {0};
+void flexran_agent_slice_update(mid_t module_idP) {
+}
+int proto_agent_start(mod_id_t mod_id, const cudu_params_t *p){
+        return 0;
+}
+void proto_agent_stop(mod_id_t mod_id){
+}
 
 static void *ru_thread( void *param );
 void kill_RU_proc(RU_t *ru) {
@@ -101,21 +110,6 @@ void exit_function(const char *file, const char *function, const int line, const
   close_log_mem();
   oai_exit = 1;
 
-  if (RC.ru == NULL)
-    exit(-1); // likely init not completed, prevent crash or hang, exit now...
-
-  for (int ru_id=0; ru_id<RC.nb_RU; ru_id++) {
-    if (RC.ru[ru_id] && RC.ru[ru_id]->rfdevice.trx_end_func) {
-      RC.ru[ru_id]->rfdevice.trx_end_func(&RC.ru[ru_id]->rfdevice);
-      RC.ru[ru_id]->rfdevice.trx_end_func = NULL;
-    }
-
-    if (RC.ru[ru_id] && RC.ru[ru_id]->ifdevice.trx_end_func) {
-      RC.ru[ru_id]->ifdevice.trx_end_func(&RC.ru[ru_id]->ifdevice);
-      RC.ru[ru_id]->ifdevice.trx_end_func = NULL;
-    }
-  }
-
   sleep(1); //allow lte-softmodem threads to exit first
   exit(1);
 }
@@ -399,6 +393,7 @@ int setup_RU_buffers(RU_t *ru) {
   return(0);
 }
 
+#if 0
 void init_precoding_weights(PHY_VARS_eNB *eNB) {
   int layer,ru_id,aa,re,ue,tb;
   LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
@@ -431,6 +426,7 @@ void init_precoding_weights(PHY_VARS_eNB *eNB) {
     }
   }
 }
+#endif
 
 void ocp_rx_prach(PHY_VARS_eNB *eNB,
                   L1_rxtx_proc_t *proc,
@@ -804,8 +800,7 @@ int init_rf(RU_t *ru) {
   return ret;
 }
 
-void init_RU(char *rf_config_file, int send_dmrssync) {
+void ocp_init_RU(RU_t *ru, char *rf_config_file, int send_dmrssync) {
-  RU_t *ru;
   PHY_VARS_eNB *eNB0= (PHY_VARS_eNB *)NULL;
   int i;
   int CC_id;
@@ -821,11 +816,8 @@ void init_RU(char *rf_config_file, int send_dmrssync) {
 
   LOG_D(PHY,"Process RUs RC.nb_RU:%d\n",RC.nb_RU);
 
-  for (int ru_id=0; ru_id<RC.nb_RU; ru_id++) {
-    LOG_D(PHY,"Process RC.ru[%d]\n",ru_id);
-    ru               = RC.ru[ru_id];
     ru->rf_config_file = rf_config_file;
-    ru->idx          = ru_id;
+    ru->idx          = 0;
     ru->ts_offset    = 0;
 
     if (ru->is_slave == 1) {
@@ -849,8 +841,6 @@ void init_RU(char *rf_config_file, int send_dmrssync) {
     ru->wakeup_L1_sleep_cnt_max  = 3;
 
     if (ru->num_eNB > 0) {
-      LOG_D(PHY, "%s() RC.ru[%d].num_eNB:%d ru->eNB_list[0]:%p RC.eNB[0][0]:%p rf_config_file:%s\n",
-            __FUNCTION__, ru_id, ru->num_eNB, ru->eNB_list[0], RC.eNB[0][0], ru->rf_config_file);
       AssertFatal(ru->eNB_list[0], "ru->eNB_list is not initialized\n");
     } else {
       LOG_E(PHY,"Wrong data model, assigning eNB 0, carrier 0 to RU 0\n");
@@ -867,20 +857,19 @@ void init_RU(char *rf_config_file, int send_dmrssync) {
       int ruIndex=eNB0->num_RU++;
       eNB0->RU_list[ruIndex] = ru;
     }
-  } // for ru_id
 }
 
 void stop_RU(int nb_ru) {
   for (int inst = 0; inst < nb_ru; inst++) {
     LOG_I(PHY, "Stopping RU %d processing threads\n", inst);
-    kill_RU_proc(RC.ru[inst]);
+    //kill_RU_proc(RC.ru[inst]);
   }
 }
 
 /* --------------------------------------------------------*/
 /* from here function to use configuration module          */
 static int DEFBFW[] = {0x00007fff};
-void RCconfig_RU(void) {
+void ocpRCconfig_RU(RU_t* ru) {
   paramdef_t RUParams[] = RUPARAMS_DESC;
   paramlist_def_t RUParamList = {CONFIG_STRING_RU_LIST,NULL,0};
   config_getlist( &RUParamList,RUParams,sizeof(RUParams)/sizeof(paramdef_t), NULL);
@@ -891,87 +880,74 @@ void RCconfig_RU(void) {
     return;
   } // setting != NULL
 
-  if ( RC.ru != NULL ) {
+  ru->idx = 0;
-    LOG_W(PHY, "Calling RCconfig_RU twice (nb ru=%d), ignoring the second call data structure is %p\n",
+  ru->if_timing = synch_to_ext_device;
-          RUParamList.numelt,RC.ru);
+  paramdef_t *vals=RUParamList.paramarray[0];
-    return;
+
+  if (RC.nb_L1_inst >0)
+    ru->num_eNB = vals[RU_ENB_LIST_IDX].numelt;
+  else
+    ru->num_eNB = 0;
+
+  for (int i=0; i<ru->num_eNB; i++)
+    ru->eNB_list[i] = RC.eNB[vals[RU_ENB_LIST_IDX].iptr[i]][0];
+
+  if (config_isparamset(vals, RU_SDR_ADDRS)) {
+    ru->openair0_cfg.sdr_addrs = strdup(*(vals[RU_SDR_ADDRS].strptr));
   }
 
-  RC.ru = (RU_t **)malloc(RC.nb_RU*sizeof(RU_t *));
+  if (config_isparamset(vals, RU_SDR_CLK_SRC)) {
-
+    char *paramVal=*(vals[RU_SDR_CLK_SRC].strptr);
-  for (int j = 0; j < RC.nb_RU; j++) {
+    LOG_D(PHY, "RU clock source set as %s\n", paramVal);
-    RC.ru[j] = (RU_t *)calloc(sizeof(RU_t), 1);
+    
-    RC.ru[j]->idx = j;
+    if (strcmp(paramVal, "internal") == 0) {
-    LOG_I(PHY,"Creating RC.ru[%d]:%p\n", j, RC.ru[j]);
+      ru->openair0_cfg.clock_source = internal;
-    RC.ru[j]->if_timing = synch_to_ext_device;
+    } else if (strcmp(paramVal, "external") == 0) {
-    paramdef_t *vals=RUParamList.paramarray[j];
+      ru->openair0_cfg.clock_source = external;
-
+    } else if (strcmp(paramVal, "gpsdo") == 0) {
-    if (RC.nb_L1_inst >0)
+      ru->openair0_cfg.clock_source = gpsdo;
-      RC.ru[j]->num_eNB = vals[RU_ENB_LIST_IDX].numelt;
-    else
-      RC.ru[j]->num_eNB = 0;
-
-    for (int i=0; i<RC.ru[j]->num_eNB; i++)
-      RC.ru[j]->eNB_list[i] = RC.eNB[vals[RU_ENB_LIST_IDX].iptr[i]][0];
-
-    if (config_isparamset(vals, RU_SDR_ADDRS)) {
-      RC.ru[j]->openair0_cfg.sdr_addrs = strdup(*(vals[RU_SDR_ADDRS].strptr));
-    }
-
-    if (config_isparamset(vals, RU_SDR_CLK_SRC)) {
-      char *paramVal=*(vals[RU_SDR_CLK_SRC].strptr);
-      LOG_D(PHY, "RU clock source set as %s\n", paramVal);
-
-      if (strcmp(paramVal, "internal") == 0) {
-        RC.ru[j]->openair0_cfg.clock_source = internal;
-      } else if (strcmp(paramVal, "external") == 0) {
-        RC.ru[j]->openair0_cfg.clock_source = external;
-      } else if (strcmp(paramVal, "gpsdo") == 0) {
-        RC.ru[j]->openair0_cfg.clock_source = gpsdo;
-      } else {
-        LOG_E(PHY, "Erroneous RU clock source in the provided configuration file: '%s'\n", paramVal);
-      }
-    }
-
-    if (strcmp(*(vals[RU_LOCAL_RF_IDX].strptr), "yes") == 0) {
-      if ( !(config_isparamset(vals,RU_LOCAL_IF_NAME_IDX)) ) {
-        RC.ru[j]->if_south  = LOCAL_RF;
-        RC.ru[j]->function  = eNodeB_3GPP;
-        LOG_I(PHY, "Setting function for RU %d to eNodeB_3GPP\n",j);
-      } else {
-        RC.ru[j]->eth_params.local_if_name = strdup(*(vals[RU_LOCAL_IF_NAME_IDX].strptr));
-        RC.ru[j]->eth_params.my_addr       = strdup(*(vals[RU_LOCAL_ADDRESS_IDX].strptr));
-        RC.ru[j]->eth_params.remote_addr   = strdup(*(vals[RU_REMOTE_ADDRESS_IDX].strptr));
-        RC.ru[j]->eth_params.my_portc      = *(vals[RU_LOCAL_PORTC_IDX].uptr);
-        RC.ru[j]->eth_params.remote_portc  = *(vals[RU_REMOTE_PORTC_IDX].uptr);
-        RC.ru[j]->eth_params.my_portd      = *(vals[RU_LOCAL_PORTD_IDX].uptr);
-        RC.ru[j]->eth_params.remote_portd  = *(vals[RU_REMOTE_PORTD_IDX].uptr);
-      }
-
-      RC.ru[j]->max_pdschReferenceSignalPower = *(vals[RU_MAX_RS_EPRE_IDX].uptr);;
-      RC.ru[j]->max_rxgain                    = *(vals[RU_MAX_RXGAIN_IDX].uptr);
-      RC.ru[j]->num_bands                     = vals[RU_BAND_LIST_IDX].numelt;
-      /* sf_extension is in unit of samples for 30.72MHz here, has to be scaled later */
-      RC.ru[j]->sf_extension                  = *(vals[RU_SF_EXTENSION_IDX].uptr);
-      RC.ru[j]->end_of_burst_delay            = *(vals[RU_END_OF_BURST_DELAY_IDX].uptr);
-
-      for (int i=0; i<RC.ru[j]->num_bands; i++) RC.ru[j]->band[i] = vals[RU_BAND_LIST_IDX].iptr[i];
     } else {
-      LOG_I(PHY,"RU %d: Transport %s\n",j,*(vals[RU_TRANSPORT_PREFERENCE_IDX].strptr));
+      LOG_E(PHY, "Erroneous RU clock source in the provided configuration file: '%s'\n", paramVal);
-      RC.ru[j]->eth_params.local_if_name    = strdup(*(vals[RU_LOCAL_IF_NAME_IDX].strptr));
+    }
-      RC.ru[j]->eth_params.my_addr          = strdup(*(vals[RU_LOCAL_ADDRESS_IDX].strptr));
+  }
-      RC.ru[j]->eth_params.remote_addr      = strdup(*(vals[RU_REMOTE_ADDRESS_IDX].strptr));
+
-      RC.ru[j]->eth_params.my_portc         = *(vals[RU_LOCAL_PORTC_IDX].uptr);
+  if (strcmp(*(vals[RU_LOCAL_RF_IDX].strptr), "yes") == 0) {
-      RC.ru[j]->eth_params.remote_portc     = *(vals[RU_REMOTE_PORTC_IDX].uptr);
+    if ( !(config_isparamset(vals,RU_LOCAL_IF_NAME_IDX)) ) {
-      RC.ru[j]->eth_params.my_portd         = *(vals[RU_LOCAL_PORTD_IDX].uptr);
+        ru->if_south  = LOCAL_RF;
-      RC.ru[j]->eth_params.remote_portd     = *(vals[RU_REMOTE_PORTD_IDX].uptr);
+        ru->function  = eNodeB_3GPP;
+      } else {
+        ru->eth_params.local_if_name = strdup(*(vals[RU_LOCAL_IF_NAME_IDX].strptr));
+        ru->eth_params.my_addr       = strdup(*(vals[RU_LOCAL_ADDRESS_IDX].strptr));
+        ru->eth_params.remote_addr   = strdup(*(vals[RU_REMOTE_ADDRESS_IDX].strptr));
+        ru->eth_params.my_portc      = *(vals[RU_LOCAL_PORTC_IDX].uptr);
+        ru->eth_params.remote_portc  = *(vals[RU_REMOTE_PORTC_IDX].uptr);
+        ru->eth_params.my_portd      = *(vals[RU_LOCAL_PORTD_IDX].uptr);
+        ru->eth_params.remote_portd  = *(vals[RU_REMOTE_PORTD_IDX].uptr);
+      }
+
+      ru->max_pdschReferenceSignalPower = *(vals[RU_MAX_RS_EPRE_IDX].uptr);;
+      ru->max_rxgain                    = *(vals[RU_MAX_RXGAIN_IDX].uptr);
+      ru->num_bands                     = vals[RU_BAND_LIST_IDX].numelt;
+      /* sf_extension is in unit of samples for 30.72MHz here, has to be scaled later */
+      ru->sf_extension                  = *(vals[RU_SF_EXTENSION_IDX].uptr);
+      ru->end_of_burst_delay            = *(vals[RU_END_OF_BURST_DELAY_IDX].uptr);
+
+      for (int i=0; i<ru->num_bands; i++)
+	ru->band[i] = vals[RU_BAND_LIST_IDX].iptr[i];
+    } else {
+      ru->eth_params.local_if_name    = strdup(*(vals[RU_LOCAL_IF_NAME_IDX].strptr));
+      ru->eth_params.my_addr          = strdup(*(vals[RU_LOCAL_ADDRESS_IDX].strptr));
+      ru->eth_params.remote_addr      = strdup(*(vals[RU_REMOTE_ADDRESS_IDX].strptr));
+      ru->eth_params.my_portc         = *(vals[RU_LOCAL_PORTC_IDX].uptr);
+      ru->eth_params.remote_portc     = *(vals[RU_REMOTE_PORTC_IDX].uptr);
+      ru->eth_params.my_portd         = *(vals[RU_LOCAL_PORTD_IDX].uptr);
+      ru->eth_params.remote_portd     = *(vals[RU_REMOTE_PORTD_IDX].uptr);
     }  /* strcmp(local_rf, "yes") != 0 */
 
-    RC.ru[j]->nb_tx                             = *(vals[RU_NB_TX_IDX].uptr);
+    ru->nb_tx                             = *(vals[RU_NB_TX_IDX].uptr);
-    RC.ru[j]->nb_rx                             = *(vals[RU_NB_RX_IDX].uptr);
+    ru->nb_rx                             = *(vals[RU_NB_RX_IDX].uptr);
-    RC.ru[j]->att_tx                            = *(vals[RU_ATT_TX_IDX].uptr);
+    ru->att_tx                            = *(vals[RU_ATT_TX_IDX].uptr);
-    RC.ru[j]->att_rx                            = *(vals[RU_ATT_RX_IDX].uptr);
+    ru->att_rx                            = *(vals[RU_ATT_RX_IDX].uptr);
-  }// j=0..num_rus
 
   return;
 }
@@ -1055,13 +1031,13 @@ void init_pdcp(void) {
       pdcp_module_init(pdcp_initmask);
 
     if (NODE_IS_CU(RC.rrc[0]->node_type)) {
-      pdcp_set_rlc_data_req_func((send_rlc_data_req_func_t)proto_agent_send_rlc_data_req);
+      //pdcp_set_rlc_data_req_func((send_rlc_data_req_func_t)proto_agent_send_rlc_data_req);
     } else {
       pdcp_set_rlc_data_req_func((send_rlc_data_req_func_t) rlc_data_req);
       pdcp_set_pdcp_data_ind_func((pdcp_data_ind_func_t) pdcp_data_ind);
     }
   } else {
-    pdcp_set_pdcp_data_ind_func((pdcp_data_ind_func_t) proto_agent_send_pdcp_data_ind);
+    //pdcp_set_pdcp_data_ind_func((pdcp_data_ind_func_t) proto_agent_send_pdcp_data_ind);
   }
 }
 
@@ -1087,16 +1063,11 @@ void terminate_task(module_id_t mod_id, task_id_t from, task_id_t to) {
 int stop_L1L2(module_id_t enb_id) {
   LOG_W(ENB_APP, "stopping lte-softmodem\n");
 
-  if (!RC.ru) {
-    LOG_UI(ENB_APP, "no RU configured\n");
-    return -1;
-  }
-
   /* these tasks need to pick up new configuration */
   terminate_task(enb_id, TASK_ENB_APP, TASK_RRC_ENB);
   oai_exit = 1;
   LOG_I(ENB_APP, "calling kill_RU_proc() for instance %d\n", enb_id);
-  kill_RU_proc(RC.ru[enb_id]);
+  //kill_RU_proc(RC.ru[enb_id]);
   LOG_I(ENB_APP, "calling kill_eNB_proc() for instance %d\n", enb_id);
   kill_eNB_proc(enb_id);
   oai_exit = 0;
@@ -1106,7 +1077,7 @@ int stop_L1L2(module_id_t enb_id) {
     phy_free_lte_eNB(RC.eNB[enb_id][cc_id]);
   }
 
-  phy_free_RU(RC.ru[enb_id]);
+  //phy_free_RU(RC.ru[enb_id]);
   free_lte_top();
   return 0;
 }
@@ -1115,14 +1086,18 @@ int stop_L1L2(module_id_t enb_id) {
  * Restart the lte-softmodem after it has been soft-stopped with stop_L1L2()
  */
 int restart_L1L2(module_id_t enb_id) {
-  RU_t *ru = RC.ru[enb_id];
+  RU_t *ru = NULL; //RC.ru[enb_id];
   MessageDef *msg_p = NULL;
   LOG_W(ENB_APP, "restarting lte-softmodem\n");
   /* block threads */
   pthread_mutex_lock(&sync_mutex);
   sync_var = -1;
   pthread_mutex_unlock(&sync_mutex);
-  RC.ru_mask |= (1 << ru->idx);
+
+  /* copy the changed frame parameters to the RU */
+  /* TODO this should be done for all RUs associated to this eNB */
+  memcpy(&ru->frame_parms, &RC.eNB[enb_id][0]->frame_parms, sizeof(LTE_DL_FRAME_PARMS));
+
   /* reset the list of connected UEs in the MAC, since in this process with
    * loose all UEs (have to reconnect) */
   init_UE_info(&RC.mac[enb_id]->UE_info);
@@ -1135,11 +1110,6 @@ int restart_L1L2(module_id_t enb_id) {
   msg_p = itti_alloc_new_message(TASK_ENB_APP, RRC_CONFIGURATION_REQ);
   RRC_CONFIGURATION_REQ(msg_p) = RC.rrc[enb_id]->configuration;
   itti_send_msg_to_task(TASK_RRC_ENB, ENB_MODULE_ID_TO_INSTANCE(enb_id), msg_p);
-  /* TODO XForms might need to be restarted, but it is currently (09/02/18)
-   * broken, so we cannot test it */
-  init_RU_proc(ru);
-  ru->rf_map.card = 0;
-  ru->rf_map.chain = 0; /* CC_id + chain_offset;*/
   init_eNB_afterRU();
   printf("Sending sync to all threads\n");
   pthread_mutex_lock(&sync_mutex);
@@ -1187,10 +1157,16 @@ int main ( int argc, char **argv ) {
     RCconfig_L1();
   }
 
+  // RU thread and some L1 procedure aren't necessary in VNF or L2 FAPI simulator.
+  // but RU thread deals with pre_scd and this is necessary in VNF and simulator.
+  // some initialization is necessary and init_ru_vnf do this.
+  RU_t ru;
+  
+
   /* We need to read RU configuration before FlexRAN starts so it knows what
    * splits to report. Actual RU start comes later. */
-  if (RC.nb_RU > 0 && NFAPI_MODE != NFAPI_MODE_VNF) {
+  if  ( NFAPI_MODE != NFAPI_MODE_VNF) {
-    RCconfig_RU();
+    ocpRCconfig_RU(&ru);
     LOG_I(PHY,
           "number of L1 instances %d, number of RU %d, number of CPU cores %d\n",
           RC.nb_L1_inst, RC.nb_RU, get_nprocs());
@@ -1211,7 +1187,7 @@ int main ( int argc, char **argv ) {
   if (RC.nb_inst > 0) {
     /* Start the agent. If it is turned off in the configuration, it won't start */
     for (i = 0; i < RC.nb_inst; i++) {
-      flexran_agent_start(i);
+      //flexran_agent_start(i);
     }
     
     /* initializes PDCP and sets correct RLC Request/PDCP Indication callbacks
@@ -1292,20 +1268,16 @@ int main ( int argc, char **argv ) {
 
   printf("About to Init RU threads RC.nb_RU:%d\n", RC.nb_RU);
 
-  // RU thread and some L1 procedure aren't necessary in VNF or L2 FAPI simulator.
+
-  // but RU thread deals with pre_scd and this is necessary in VNF and simulator.
-  // some initialization is necessary and init_ru_vnf do this.
   if (RC.nb_RU >0 && NFAPI_MODE!=NFAPI_MODE_VNF) {
     printf("Initializing RU threads\n");
-    init_RU(get_softmodem_params()->rf_config_file,
+    ocp_init_RU(&ru,
+	    get_softmodem_params()->rf_config_file,
             get_softmodem_params()->send_dmrs_sync);
 
-    for (int ru_id=0; ru_id<RC.nb_RU; ru_id++) {
+      ru.rf_map.card=0;
-      RC.ru[ru_id]->rf_map.card=0;
+      ru.rf_map.chain=CC_id+(get_softmodem_params()->chain_offset);
-      RC.ru[ru_id]->rf_map.chain=CC_id+(get_softmodem_params()->chain_offset);
+      init_RU_proc(&ru);
-      LOG_I(PHY,"Starting ru_thread %d\n",ru_id);
-      init_RU_proc(RC.ru[ru_id]);
-    }
 
     config_sync_var=0;
 
@@ -1316,6 +1288,7 @@ int main ( int argc, char **argv ) {
     LOG_I(ENB_APP,"RC.nb_RU:%d\n", RC.nb_RU);
     // once all RUs are ready intiailize the rest of the eNBs ((dependence on final RU parameters after configuration)
     printf("ALL RUs ready - init eNBs\n");
+    sleep(1);
 
     if (NFAPI_MODE!=NFAPI_MODE_PNF && NFAPI_MODE!=NFAPI_MODE_VNF) {
       LOG_I(ENB_APP,"Not NFAPI mode - call init_eNB_afterRU()\n");
@@ -1369,10 +1342,6 @@ int main ( int argc, char **argv ) {
       }
     }
 
-    for (int inst = 0; inst < RC.nb_RU; inst++) {
-      phy_free_RU(RC.ru[inst]);
-    }
-
     free_lte_top();
     end_configmodule();
     pthread_cond_destroy(&sync_cond);
@@ -1381,17 +1350,6 @@ int main ( int argc, char **argv ) {
     pthread_mutex_destroy(&nfapi_sync_mutex);
     pthread_mutex_destroy(&ue_pf_po_mutex);
 
-    for(int ru_id=0; ru_id<RC.nb_RU; ru_id++) {
-      if (RC.ru[ru_id]->rfdevice.trx_end_func) {
-        RC.ru[ru_id]->rfdevice.trx_end_func(&RC.ru[ru_id]->rfdevice);
-        RC.ru[ru_id]->rfdevice.trx_end_func = NULL;
-      }
-
-      if (RC.ru[ru_id]->ifdevice.trx_end_func) {
-        RC.ru[ru_id]->ifdevice.trx_end_func(&RC.ru[ru_id]->ifdevice);
-        RC.ru[ru_id]->ifdevice.trx_end_func = NULL;
-      }
-    }
   }
 
   terminate_opt();

executables/nr-gnb.c

@@ -266,7 +266,7 @@ static inline int rxtx(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, int frame_t
   // run PHY TX procedures the one after the other for all CCs to avoid race conditions
   // (may be relaxed in the future for performance reasons)
   // *****************************************
-  
+
   if (tx_slot_type == NR_DOWNLINK_SLOT || tx_slot_type == NR_MIXED_SLOT) {
 
     if(get_thread_parallel_conf() != PARALLEL_RU_L1_TRX_SPLIT) {

executables/nr-softmodem.c

@@ -956,7 +956,7 @@ if(!IS_SOFTMODEM_NOS1)
   // once all RUs are ready initialize the rest of the gNBs ((dependence on final RU parameters after configuration)
   printf("ALL RUs ready - init gNBs\n");
   if(IS_SOFTMODEM_DOFORMS) {
-  	
+    sleep(1);	
     scopeParms_t p;
     p.argc=&argc;
     p.argv=argv;

nfapi/oai_integration/nfapi_pnf.c

@@ -720,9 +720,6 @@ int pnf_phy_hi_dci0_req(L1_rxtx_proc_t *proc, nfapi_pnf_p7_config_t *pnf_p7, nfa
 }
 
 int pnf_phy_dl_config_req(L1_rxtx_proc_t *proc, nfapi_pnf_p7_config_t *pnf_p7, nfapi_dl_config_request_t *req) {
-  if (RC.ru == 0) {
-    return -1;
-  }
 
   if (RC.eNB == 0) {
     return -2;
@@ -847,9 +844,6 @@ int pnf_phy_ul_config_req(L1_rxtx_proc_t *proc, nfapi_pnf_p7_config_t *pnf_p7, n
                 req->ul_config_request_body.srs_present
                );
 
-  if (RC.ru == 0) {
-    return -1;
-  }
 
   if (RC.eNB == 0) {
     return -2;

openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c

@@ -2242,16 +2242,12 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
   MIMO_mode_t mimo_mode = -1;
   uint8_t mprime=0,Ns;
   int8_t  lprime=-1;
-  int aa=0;
 
 
 #ifdef DEBUG_DLSCH_MODULATION
   uint8_t Nl0;  //= dlsch0_harq->Nl;
   uint8_t Nl1;
 #endif
-  int ru_id;
-  RU_t *ru;
-  int eNB_id;
 
 
   if ((dlsch0 != NULL) && (dlsch1 != NULL)){
@@ -2432,11 +2428,13 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
       }
 
       // mapping ue specific beamforming weights from UE specified DLSCH structure to RU beam weights for the eNB
-      for (ru_id=0;ru_id<RC.nb_RU;ru_id++) {
+      /*
+      for (int ru_id=0;ru_id<RC.nb_RU;ru_id++) {
+        RU_t *ru;
 	ru = RC.ru[ru_id];
-	for (eNB_id=0;eNB_id<ru->num_eNB;eNB_id++){
+	for (int eNB_id=0;eNB_id<ru->num_eNB;eNB_id++){
 	  if (phy_vars_eNB == ru->eNB_list[eNB_id]) {
-	    for (aa=0;aa<ru->nb_tx;aa++){
+	    for (int aa=0;aa<ru->nb_tx;aa++){
               LOG_I(PHY,"ru_id:%d eNB_id:%d aa:%d memcpy(ru->beam_weights, dlsch0->ue_spec_bf_weights[ru_id][0],)\n", ru_id, eNB_id, aa);
 	      memcpy(ru->beam_weights[eNB_id][5][aa],
 		     dlsch0->ue_spec_bf_weights[ru_id][0],
@@ -2445,6 +2443,7 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
 	  }
 	}
       }
+      */
 
     }
 

openair1/PHY/MODULATION/slot_fep_nr.c

@@ -490,6 +490,7 @@ int nr_slot_fep_ul(NR_DL_FRAME_PARMS *frame_parms,
   // clear DC carrier from OFDM symbols
   rxdataF[symbol * frame_parms->ofdm_symbol_size] = 0;
 
+
   int symb_offset = (Ns%frame_parms->slots_per_subframe)*frame_parms->symbols_per_slot;
   uint32_t rot2 = ((uint32_t*)frame_parms->symbol_rotation)[symbol+symb_offset];
   ((int16_t*)&rot2)[1]=-((int16_t*)&rot2)[1];
@@ -499,5 +500,6 @@ int nr_slot_fep_ul(NR_DL_FRAME_PARMS *frame_parms,
 		    (int16_t *)&rxdataF[frame_parms->ofdm_symbol_size*symbol],
 		    frame_parms->ofdm_symbol_size,
 		    15);
+
   return(0);
 }

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -684,14 +684,14 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     
     pdsch_vars[eNB_id]->llr_offset[symbol] = len*dlsch0_harq->Qm + llr_offset_symbol;
  
-  /*LOG_I(PHY,"compute LLRs [symbol %d] NbRB %d Qm %d LLRs-Length %d LLR-Offset %d @LLR Buff %x @LLR Buff(symb) %x\n",
+  LOG_D(PHY,"compute LLRs [symbol %d] NbRB %d Qm %d LLRs-Length %d LLR-Offset %d energy %d\n",
              symbol,
              nb_rb,dlsch0_harq->Qm,
              pdsch_vars[eNB_id]->llr_length[symbol],
              pdsch_vars[eNB_id]->llr_offset[symbol],
-             (int16_t*)pdsch_vars[eNB_id]->llr[0],
+	     signal_energy(pdsch_vars[eNB_id]->rxdataF_comp0[0], 7*2*frame_parms->N_RB_DL*12));
-             pllr_symbol_cw0);*/
+
-             
+
              /*printf("compute LLRs [symbol %d] NbRB %d Qm %d LLRs-Length %d LLR-Offset %d @LLR Buff %p @LLR Buff(symb) %p\n",
              symbol,
              nb_rb,dlsch0_harq->Qm,

openair1/PHY/TOOLS/lte_enb_scope.c

@@ -97,7 +97,7 @@ static void *scope_thread_eNB(void *arg) {
       }
     }
 
-    sleep(1);
+    usleep(100*1000);
   }
 
   //  printf("%s",stats_buffer);

openair1/PHY/TOOLS/lte_phy_scope.c

@@ -37,9 +37,12 @@ float tput_time_ue[NUMBER_OF_UE_MAX][TPUT_WINDOW_LENGTH] = {{0}};
 float tput_ue[NUMBER_OF_UE_MAX][TPUT_WINDOW_LENGTH] = {{0}};
 float tput_ue_max[NUMBER_OF_UE_MAX] = {0};
 
-static void ia_receiver_on_off( FL_OBJECT *button, long arg)
+void drawsymbol(FL_OBJECT *obj, int id,
-{
+                FL_POINT *p, int n, int w, int h) {
+  fl_points( p, n, FL_YELLOW);
+}
 
+static void ia_receiver_on_off( FL_OBJECT *button, long arg) {
   if (fl_get_button(button)) {
     fl_set_object_label(button, "IA Receiver ON");
     //    PHY_vars_UE_g[0][0]->use_ia_receiver = 1;
@@ -51,9 +54,7 @@ static void ia_receiver_on_off( FL_OBJECT *button, long arg)
   }
 }
 
-static void dl_traffic_on_off( FL_OBJECT *button, long arg)
+static void dl_traffic_on_off( FL_OBJECT *button, long arg) {
-{
-
   if (fl_get_button(button)) {
     fl_set_object_label(button, "DL Traffic ON");
     otg_enabled = 1;
@@ -65,46 +66,38 @@ static void dl_traffic_on_off( FL_OBJECT *button, long arg)
   }
 }
 
-FD_lte_phy_scope_enb *create_lte_phy_scope_enb( void )
+FD_lte_phy_scope_enb *create_lte_phy_scope_enb( void ) {
-{
-
   FL_OBJECT *obj;
   FD_lte_phy_scope_enb *fdui = fl_malloc( sizeof *fdui );
-
   // Define form
   fdui->lte_phy_scope_enb = fl_bgn_form( FL_NO_BOX, 800, 800 );
-
   // This the whole UI box
   obj = fl_add_box( FL_BORDER_BOX, 0, 0, 800, 800, "" );
   fl_set_object_color( obj, FL_BLACK, FL_BLACK );
-
   // Received signal
   fdui->rxsig_t = fl_add_xyplot( FL_NORMAL_XYPLOT, 20, 20, 370, 100, "Received Signal (Time-Domain, dB)" );
   fl_set_object_boxtype( fdui->rxsig_t, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->rxsig_t, FL_BLACK, FL_RED );
   fl_set_object_lcolor( fdui->rxsig_t, FL_WHITE ); // Label color
   fl_set_xyplot_ybounds(fdui->rxsig_t,10,70);
-
   // Time-domain channel response
   fdui->chest_t = fl_add_xyplot( FL_NORMAL_XYPLOT, 410, 20, 370, 100, "SRS Frequency Response (samples, abs)" );
   fl_set_object_boxtype( fdui->chest_t, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->chest_t, FL_BLACK, FL_RED );
   fl_set_object_lcolor( fdui->chest_t, FL_WHITE ); // Label color
-
   // Frequency-domain channel response
   fdui->chest_f = fl_add_xyplot( FL_IMPULSE_XYPLOT, 20, 140, 760, 100, "Channel Frequency  Response (RE, dB)" );
   fl_set_object_boxtype( fdui->chest_f, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->chest_f, FL_BLACK, FL_RED );
   fl_set_object_lcolor( fdui->chest_f, FL_WHITE ); // Label color
   fl_set_xyplot_ybounds( fdui->chest_f,30,70);
-
   // LLR of PUSCH
   fdui->pusch_llr = fl_add_xyplot( FL_POINTS_XYPLOT, 20, 260, 500, 200, "PUSCH Log-Likelihood Ratios (LLR, mag)" );
   fl_set_object_boxtype( fdui->pusch_llr, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->pusch_llr, FL_BLACK, FL_YELLOW );
   fl_set_object_lcolor( fdui->pusch_llr, FL_WHITE ); // Label color
   fl_set_xyplot_symbolsize( fdui->pusch_llr,2);
-
+  fl_set_xyplot_symbol(fdui->pusch_llr, 0, drawsymbol);
   // I/Q PUSCH comp
   fdui->pusch_comp = fl_add_xyplot( FL_POINTS_XYPLOT, 540, 260, 240, 200, "PUSCH I/Q of MF Output" );
   fl_set_object_boxtype( fdui->pusch_comp, FL_EMBOSSED_BOX );
@@ -112,7 +105,7 @@ FD_lte_phy_scope_enb *create_lte_phy_scope_enb( void )
   fl_set_object_lcolor( fdui->pusch_comp, FL_WHITE ); // Label color
   fl_set_xyplot_symbolsize( fdui->pusch_comp,2);
   fl_set_xyplot_xgrid( fdui->pusch_llr,FL_GRID_MAJOR);
-
+  fl_set_xyplot_symbol(fdui->pusch_comp, 0, drawsymbol);
   // I/Q PUCCH comp (format 1)
   fdui->pucch_comp1 = fl_add_xyplot( FL_POINTS_XYPLOT, 540, 480, 240, 100, "PUCCH1 Energy (SR)" );
   fl_set_object_boxtype( fdui->pucch_comp1, FL_EMBOSSED_BOX );
@@ -120,7 +113,7 @@ FD_lte_phy_scope_enb *create_lte_phy_scope_enb( void )
   fl_set_object_lcolor( fdui->pucch_comp1, FL_WHITE ); // Label color
   fl_set_xyplot_symbolsize( fdui->pucch_comp1,2);
   //  fl_set_xyplot_xgrid( fdui->pusch_llr,FL_GRID_MAJOR);
-
+  fl_set_xyplot_symbol(fdui->pucch_comp1, 0, drawsymbol);
   // I/Q PUCCH comp (fromat 1a/b)
   fdui->pucch_comp = fl_add_xyplot( FL_POINTS_XYPLOT, 540, 600, 240, 100, "PUCCH I/Q of MF Output" );
   fl_set_object_boxtype( fdui->pucch_comp, FL_EMBOSSED_BOX );
@@ -128,13 +121,12 @@ FD_lte_phy_scope_enb *create_lte_phy_scope_enb( void )
   fl_set_object_lcolor( fdui->pucch_comp, FL_WHITE ); // Label color
   fl_set_xyplot_symbolsize( fdui->pucch_comp,2);
   //  fl_set_xyplot_xgrid( fdui->pusch_llr,FL_GRID_MAJOR);
-
+  fl_set_xyplot_symbol(fdui->pucch_comp, 0, drawsymbol);
   // Throughput on PUSCH
   fdui->pusch_tput = fl_add_xyplot( FL_NORMAL_XYPLOT, 20, 480, 500, 100, "PUSCH Throughput [frame]/[kbit/s]" );
   fl_set_object_boxtype( fdui->pusch_tput, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->pusch_tput, FL_BLACK, FL_WHITE );
   fl_set_object_lcolor( fdui->pusch_tput, FL_WHITE ); // Label color
-
   // Generic eNB Button
   fdui->button_0 = fl_add_button( FL_PUSH_BUTTON, 20, 600, 240, 40, "" );
   fl_set_object_lalign(fdui->button_0, FL_ALIGN_CENTER );
@@ -143,18 +135,15 @@ FD_lte_phy_scope_enb *create_lte_phy_scope_enb( void )
   fl_set_object_label(fdui->button_0, "DL Traffic OFF");
   fl_set_object_color(fdui->button_0, FL_RED, FL_RED);
   fl_set_object_callback(fdui->button_0, dl_traffic_on_off, 0 );
-
   fl_end_form( );
   fdui->lte_phy_scope_enb->fdui = fdui;
-
   return fdui;
 }
 
 void phy_scope_eNB(FD_lte_phy_scope_enb *form,
                    PHY_VARS_eNB *phy_vars_enb,
-                   int UE_id)
+                   int UE_id) {
-{
+  LOG_D(HW,"scope for UE%d\n", UE_id);
-
   int i,i2,arx,atx,ind,k;
   LTE_DL_FRAME_PARMS *frame_parms = &phy_vars_enb->frame_parms;
   int nsymb_ce = 12*frame_parms->N_RB_UL*frame_parms->symbols_per_tti;
@@ -192,20 +181,18 @@ void phy_scope_eNB(FD_lte_phy_scope_enb *form,
   }
 
   coded_bits_per_codeword = frame_parms->N_RB_UL*12*Qm*frame_parms->symbols_per_tti;
-
+  chest_f_abs = (float *) calloc(nsymb_ce*nb_antennas_rx*nb_antennas_tx,sizeof(float));
-  chest_f_abs = (float*) calloc(nsymb_ce*nb_antennas_rx*nb_antennas_tx,sizeof(float));
+  llr = (float *) calloc(coded_bits_per_codeword,sizeof(float)); // init to zero
-  llr = (float*) calloc(coded_bits_per_codeword,sizeof(float)); // init to zero
   bit = malloc(coded_bits_per_codeword*sizeof(float));
 
   rxsig_t = (int16_t**) phy_vars_enb->RU_list[0]->common.rxdata;
-  //chest_t = (int16_t**) phy_vars_enb->pusch_vars[UE_id]->drs_ch_estimates_time[eNB_id];
+  chest_t = (int16_t **) phy_vars_enb->srs_vars[UE_id].srs_ch_estimates;
-  chest_t = (int16_t**) phy_vars_enb->srs_vars[UE_id].srs_ch_estimates;
+  chest_f = (int16_t **) phy_vars_enb->pusch_vars[UE_id]->drs_ch_estimates;
-  chest_f = (int16_t**) phy_vars_enb->pusch_vars[UE_id]->drs_ch_estimates;
+  pusch_llr = (int16_t *) phy_vars_enb->pusch_vars[UE_id]->llr;
-  pusch_llr = (int16_t*) phy_vars_enb->pusch_vars[UE_id]->llr;
+  pusch_comp = (int32_t *) phy_vars_enb->pusch_vars[UE_id]->rxdataF_comp[0];
-  pusch_comp = (int32_t*) phy_vars_enb->pusch_vars[UE_id]->rxdataF_comp[0];
+  pucch1_comp = (int32_t *) phy_vars_enb->pucch1_stats[UE_id];
-  pucch1_comp = (int32_t*) phy_vars_enb->pucch1_stats[UE_id];
+  pucch1_thres = (int32_t *) phy_vars_enb->pucch1_stats_thres[UE_id];
-  pucch1_thres = (int32_t*) phy_vars_enb->pucch1_stats_thres[UE_id];
+  pucch1ab_comp = (int32_t *) phy_vars_enb->pucch1ab_stats[UE_id];
-  pucch1ab_comp = (int32_t*) phy_vars_enb->pucch1ab_stats[UE_id];
 
   // Received signal in time domain of receive antenna 0
   if (rxsig_t != NULL) {
@@ -236,7 +223,7 @@ void phy_scope_eNB(FD_lte_phy_scope_enb *form,
     if (chest_t[0] !=NULL) {
       for (i=0; i<(frame_parms->ofdm_symbol_size); i++) {
         //i2 = (i+(frame_parms->ofdm_symbol_size>>1))%frame_parms->ofdm_symbol_size;
-	i2=i;
+        i2=i;
         //time2[i] = (float)(i-(frame_parms->ofdm_symbol_size>>1));
         time2[i] = (float)i;
         chest_t_abs[0][i] = 10*log10((float) (1+chest_t[0][2*i2]*chest_t[0][2*i2]+chest_t[0][2*i2+1]*chest_t[0][2*i2+1]));
@@ -278,7 +265,6 @@ void phy_scope_eNB(FD_lte_phy_scope_enb *form,
             freq[ind] = (float)ind;
             Re = (float)(chest_f[(atx<<1)+arx][(2*k)]);
             Im = (float)(chest_f[(atx<<1)+arx][(2*k)+1]);
-
             chest_f_abs[ind] = (short)10*log10(1.0+((double)Re*Re + (double)Im*Im));
             ind++;
           }
@@ -333,9 +319,9 @@ void phy_scope_eNB(FD_lte_phy_scope_enb *form,
              pusch_comp[(2*frame_parms->N_RB_UL*12*k)+2*i] < range  &&
              pusch_comp[(2*frame_parms->N_RB_UL*12*k)+2*i+1] > -range &&
              pusch_comp[(2*frame_parms->N_RB_UL*12*k)+2*i+1] < range ) {
-           I[ind] = pusch_comp[(2*frame_parms->N_RB_UL*12*k)+2*i];
+          I[ind] = pusch_comp[(2*frame_parms->N_RB_UL*12*k)+2*i];
-           Q[ind] = pusch_comp[(2*frame_parms->N_RB_UL*12*k)+2*i+1];
+          Q[ind] = pusch_comp[(2*frame_parms->N_RB_UL*12*k)+2*i+1];
-           ind++;
+          ind++;
         }
       }
     }
@@ -346,75 +332,62 @@ void phy_scope_eNB(FD_lte_phy_scope_enb *form,
   // PUSCH I/Q of MF Output
   if (pucch1ab_comp!=NULL) {
     for (ind=0; ind<10240; ind++) {
-
       I_pucch[ind] = (float)pucch1ab_comp[2*(ind)];
       Q_pucch[ind] = (float)pucch1ab_comp[2*(ind)+1];
       A_pucch[ind] = 10*log10(pucch1_comp[ind]);
       B_pucch[ind] = ind;
       C_pucch[ind] = (float)pucch1_thres[ind];
     }
+
     fl_set_xyplot_data(form->pucch_comp,I_pucch,Q_pucch,10240,"","","");
     fl_set_xyplot_data(form->pucch_comp1,B_pucch,A_pucch,1024,"","","");
     fl_add_xyplot_overlay(form->pucch_comp1,1,B_pucch,C_pucch,1024,FL_RED);
     fl_set_xyplot_ybounds(form->pucch_comp,-5000,5000);
     fl_set_xyplot_xbounds(form->pucch_comp,-5000,5000);
-
     fl_set_xyplot_ybounds(form->pucch_comp1,0,80);
   }
 
-
   // PUSCH Throughput
   memmove( tput_time_enb[UE_id], &tput_time_enb[UE_id][1], (TPUT_WINDOW_LENGTH-1)*sizeof(float) );
   memmove( tput_enb[UE_id], &tput_enb[UE_id][1], (TPUT_WINDOW_LENGTH-1)*sizeof(float) );
-
   tput_time_enb[UE_id][TPUT_WINDOW_LENGTH-1]  = (float) frame;
   tput_enb[UE_id][TPUT_WINDOW_LENGTH-1] = ((float) total_dlsch_bitrate)/1000.0;
-
   fl_set_xyplot_data(form->pusch_tput,tput_time_enb[UE_id],tput_enb[UE_id],TPUT_WINDOW_LENGTH,"","","");
-
   //    fl_get_xyplot_ybounds(form->pusch_tput,&ymin,&ymax);
   //    fl_set_xyplot_ybounds(form->pusch_tput,0,ymax);
-
   fl_check_forms();
-
   free(llr);
   free(bit);
   free(chest_f_abs);
 }
 
-FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void )
+FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void ) {
-{
-
   FL_OBJECT *obj;
   FD_lte_phy_scope_ue *fdui = fl_malloc( sizeof *fdui );
-
   // Define form
   fdui->lte_phy_scope_ue = fl_bgn_form( FL_NO_BOX, 800, 900 );
-
   // This the whole UI box
   obj = fl_add_box( FL_BORDER_BOX, 0, 0, 800, 900, "" );
   fl_set_object_color( obj, FL_BLACK, FL_BLACK );
-
   // Received signal
   fdui->rxsig_t = fl_add_xyplot( FL_NORMAL_XYPLOT, 20, 20, 370, 100, "Received Signal (Time-Domain, dB)" );
   fl_set_object_boxtype( fdui->rxsig_t, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->rxsig_t, FL_BLACK, FL_RED );
   fl_set_object_lcolor( fdui->rxsig_t, FL_WHITE ); // Label color
   fl_set_xyplot_ybounds(fdui->rxsig_t,10,70);
-
+  fl_set_xyplot_symbol(fdui->rxsig_t, 0, drawsymbol);
   // Time-domain channel response
   fdui->chest_t = fl_add_xyplot( FL_NORMAL_XYPLOT, 410, 20, 370, 100, "Channel Impulse Response (samples, abs)" );
   fl_set_object_boxtype( fdui->chest_t, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->chest_t, FL_BLACK, FL_RED );
   fl_set_object_lcolor( fdui->chest_t, FL_WHITE ); // Label color
-
+  fl_set_xyplot_symbol(fdui->chest_t, 0, drawsymbol);
   // Frequency-domain channel response
   fdui->chest_f = fl_add_xyplot( FL_IMPULSE_XYPLOT, 20, 140, 760, 100, "Channel Frequency Response (RE, dB)" );
   fl_set_object_boxtype( fdui->chest_f, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->chest_f, FL_BLACK, FL_RED );
   fl_set_object_lcolor( fdui->chest_f, FL_WHITE ); // Label color
   fl_set_xyplot_ybounds( fdui->chest_f,30,70);
-
   // LLR of PBCH
   fdui->pbch_llr = fl_add_xyplot( FL_POINTS_XYPLOT, 20, 260, 500, 100, "PBCH Log-Likelihood Ratios (LLR, mag)" );
   fl_set_object_boxtype( fdui->pbch_llr, FL_EMBOSSED_BOX );
@@ -423,23 +396,23 @@ FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void )
   fl_set_xyplot_symbolsize( fdui->pbch_llr,2);
   fl_set_xyplot_xgrid( fdui->pbch_llr,FL_GRID_MAJOR);
   fl_set_xyplot_xbounds( fdui->pbch_llr,0,1920);
-
+  fl_set_xyplot_symbol(fdui->pbch_llr, 0, drawsymbol);
   // I/Q PBCH comp
   fdui->pbch_comp = fl_add_xyplot( FL_POINTS_XYPLOT, 540, 260, 240, 100, "PBCH I/Q of MF Output" );
   fl_set_object_boxtype( fdui->pbch_comp, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->pbch_comp, FL_BLACK, FL_GREEN );
   fl_set_object_lcolor( fdui->pbch_comp, FL_WHITE ); // Label color
   fl_set_xyplot_symbolsize( fdui->pbch_comp,2);
+  fl_set_xyplot_symbol(fdui->pbch_comp, 0, drawsymbol);
   //  fl_set_xyplot_xbounds( fdui->pbch_comp,-100,100);
   //  fl_set_xyplot_ybounds( fdui->pbch_comp,-100,100);
-
   // LLR of PDCCH
   fdui->pdcch_llr = fl_add_xyplot( FL_POINTS_XYPLOT, 20, 380, 500, 100, "PDCCH Log-Likelihood Ratios (LLR, mag)" );
   fl_set_object_boxtype( fdui->pdcch_llr, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->pdcch_llr, FL_BLACK, FL_CYAN );
   fl_set_object_lcolor( fdui->pdcch_llr, FL_WHITE ); // Label color
   fl_set_xyplot_symbolsize( fdui->pdcch_llr,2);
-
+  fl_set_xyplot_symbol(fdui->pdcch_llr, 0, drawsymbol);
   // I/Q PDCCH comp
   fdui->pdcch_comp = fl_add_xyplot( FL_POINTS_XYPLOT, 540, 380, 240, 100, "PDCCH I/Q of MF Output" );
   fl_set_object_boxtype( fdui->pdcch_comp, FL_EMBOSSED_BOX );
@@ -447,7 +420,7 @@ FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void )
   fl_set_object_lcolor( fdui->pdcch_comp, FL_WHITE ); // Label color
   fl_set_xyplot_symbolsize( fdui->pdcch_comp,2);
   fl_set_xyplot_xgrid( fdui->pdcch_llr,FL_GRID_MAJOR);
-
+  fl_set_xyplot_symbol(fdui->pdcch_comp, 0, drawsymbol);
   // LLR of PDSCH
   fdui->pdsch_llr = fl_add_xyplot( FL_POINTS_XYPLOT, 20, 500, 500, 200, "PDSCH Log-Likelihood Ratios (LLR, mag)" );
   fl_set_object_boxtype( fdui->pdsch_llr, FL_EMBOSSED_BOX );
@@ -455,20 +428,19 @@ FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void )
   fl_set_object_lcolor( fdui->pdsch_llr, FL_WHITE ); // Label color
   fl_set_xyplot_symbolsize( fdui->pdsch_llr,2);
   fl_set_xyplot_xgrid( fdui->pdsch_llr,FL_GRID_MAJOR);
-
+  fl_set_xyplot_symbol(fdui->pdsch_llr, 0, drawsymbol);
   // I/Q PDSCH comp
   fdui->pdsch_comp = fl_add_xyplot( FL_POINTS_XYPLOT, 540, 500, 240, 200, "PDSCH I/Q of MF Output" );
   fl_set_object_boxtype( fdui->pdsch_comp, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->pdsch_comp, FL_BLACK, FL_YELLOW );
   fl_set_object_lcolor( fdui->pdsch_comp, FL_WHITE ); // Label color
   fl_set_xyplot_symbolsize( fdui->pdsch_comp,2);
-
+  fl_set_xyplot_symbol(fdui->pdsch_comp, 0, drawsymbol);
   // Throughput on PDSCH
   fdui->pdsch_tput = fl_add_xyplot( FL_NORMAL_XYPLOT, 20, 720, 500, 100, "PDSCH Throughput [frame]/[kbit/s]" );
   fl_set_object_boxtype( fdui->pdsch_tput, FL_EMBOSSED_BOX );
   fl_set_object_color( fdui->pdsch_tput, FL_BLACK, FL_WHITE );
   fl_set_object_lcolor( fdui->pdsch_tput, FL_WHITE ); // Label color
-
   // Generic UE Button
   fdui->button_0 = fl_add_button( FL_PUSH_BUTTON, 540, 720, 240, 40, "" );
   fl_set_object_lalign(fdui->button_0, FL_ALIGN_CENTER );
@@ -478,10 +450,8 @@ FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void )
   fl_set_object_color(fdui->button_0, FL_RED, FL_RED);
   fl_set_object_callback(fdui->button_0, ia_receiver_on_off, 0 );
   fl_hide_object(fdui->button_0);
-
   fl_end_form( );
   fdui->lte_phy_scope_ue->fdui = fdui;
-
   return fdui;
 }
 
@@ -489,8 +459,7 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
                   PHY_VARS_UE *phy_vars_ue,
                   int eNB_id,
                   int UE_id,
-                  uint8_t subframe)
+                  uint8_t subframe) {
-{
   int i,arx,atx,ind,k;
   LTE_DL_FRAME_PARMS *frame_parms = &phy_vars_ue->frame_parms;
   int nsymb_ce = frame_parms->ofdm_symbol_size;//*frame_parms->symbols_per_tti;
@@ -521,7 +490,6 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
   unsigned char harq_pid = 0;
   int beamforming_mode = phy_vars_ue->transmission_mode[eNB_id]>6 ? phy_vars_ue->transmission_mode[eNB_id] : 0;
 
-
   if (phy_vars_ue->dlsch[phy_vars_ue->current_thread_id[subframe]][eNB_id][0]!=NULL) {
     harq_pid = phy_vars_ue->dlsch[phy_vars_ue->current_thread_id[subframe]][eNB_id][0]->current_harq_pid;
 
@@ -556,34 +524,32 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
     coded_bits_per_codeword = 0; //frame_parms->N_RB_DL*12*get_Qm(mcs)*(frame_parms->symbols_per_tti);
   }
 
-  I = (float*) calloc(frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti*2,sizeof(float));
+  I = (float *) calloc(frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti*2,sizeof(float));
-  Q = (float*) calloc(frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti*2,sizeof(float));
+  Q = (float *) calloc(frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti*2,sizeof(float));
-  chest_t_abs = (float**) malloc(nb_antennas_rx*sizeof(float*));
+  chest_t_abs = (float **) malloc(nb_antennas_rx*sizeof(float *));
 
   for (arx=0; arx<nb_antennas_rx; arx++) {
-    chest_t_abs[arx] = (float*) calloc(frame_parms->ofdm_symbol_size,sizeof(float));
+    chest_t_abs[arx] = (float *) calloc(frame_parms->ofdm_symbol_size,sizeof(float));
   }
 
-  chest_f_abs = (float*) calloc(nsymb_ce*nb_antennas_rx*nb_antennas_tx,sizeof(float));
+  chest_f_abs = (float *) calloc(nsymb_ce*nb_antennas_rx*nb_antennas_tx,sizeof(float));
   //llr = (float*) calloc(coded_bits_per_codeword,sizeof(float)); // Cppcheck returns "invalidFunctionArg" error.
-  llr = (float*) malloc(coded_bits_per_codeword*sizeof(float));
+  llr = (float *) malloc(coded_bits_per_codeword*sizeof(float));
   memset((void *)llr, 0,coded_bits_per_codeword*sizeof(float)); // init to zero
-
   bit = malloc(coded_bits_per_codeword*sizeof(float));
-  llr_pdcch = (float*) calloc(12*frame_parms->N_RB_DL*num_pdcch_symbols*2,sizeof(float)); // init to zero
+  llr_pdcch = (float *) calloc(12*frame_parms->N_RB_DL*num_pdcch_symbols*2,sizeof(float)); // init to zero
-  bit_pdcch = (float*) calloc(12*frame_parms->N_RB_DL*num_pdcch_symbols*2,sizeof(float));
+  bit_pdcch = (float *) calloc(12*frame_parms->N_RB_DL*num_pdcch_symbols*2,sizeof(float));
-
+  rxsig_t = (int16_t **) phy_vars_ue->common_vars.rxdata;
-  rxsig_t = (int16_t**) phy_vars_ue->common_vars.rxdata;
+  chest_t = (int16_t **) phy_vars_ue->common_vars.common_vars_rx_data_per_thread[phy_vars_ue->current_thread_id[subframe]].dl_ch_estimates_time[eNB_id];
-  chest_t = (int16_t**) phy_vars_ue->common_vars.common_vars_rx_data_per_thread[phy_vars_ue->current_thread_id[subframe]].dl_ch_estimates_time[eNB_id];
+  chest_f = (int16_t **) phy_vars_ue->common_vars.common_vars_rx_data_per_thread[phy_vars_ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id];
-  chest_f = (int16_t**) phy_vars_ue->common_vars.common_vars_rx_data_per_thread[phy_vars_ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id];
+  pbch_llr = (int8_t *) phy_vars_ue->pbch_vars[eNB_id]->llr;
-  pbch_llr = (int8_t*) phy_vars_ue->pbch_vars[eNB_id]->llr;
+  pbch_comp = (int16_t *) phy_vars_ue->pbch_vars[eNB_id]->rxdataF_comp[0];
-  pbch_comp = (int16_t*) phy_vars_ue->pbch_vars[eNB_id]->rxdataF_comp[0];
+  pdcch_llr = (int8_t *) phy_vars_ue->pdcch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->llr;
-  pdcch_llr = (int8_t*) phy_vars_ue->pdcch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->llr;
+  pdcch_comp = (int16_t *) phy_vars_ue->pdcch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->rxdataF_comp[0];
-  pdcch_comp = (int16_t*) phy_vars_ue->pdcch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->rxdataF_comp[0];
+  pdsch_llr = (int16_t *) phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->llr[0]; // stream 0
-  pdsch_llr = (int16_t*) phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->llr[0]; // stream 0
   //pdsch_llr = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars_SI[eNB_id]->llr[0]; // stream 0
-  pdsch_comp = (int16_t*) phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->rxdataF_comp0[0];
+  pdsch_comp = (int16_t *) phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->rxdataF_comp0[0];
-  pdsch_mag = (int16_t*) phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->dl_ch_mag0[0];
+  pdsch_mag = (int16_t *) phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->dl_ch_mag0[0];
 
   // Received signal in time domain of receive antenna 0
   if (rxsig_t != NULL) {
@@ -652,7 +618,6 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
             freq[ind] = (float)ind;
             Re = (float)(chest_f[(atx<<1)+arx][(2*k)]);
             Im = (float)(chest_f[(atx<<1)+arx][(2*k)+1]);
-
             chest_f_abs[ind] = (short)10*log10(1.0+((double)Re*Re + (double)Im*Im));
             ind++;
           }
@@ -715,13 +680,11 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
     }
 
     fl_set_xyplot_xbounds(form->pdcch_llr,0,12*frame_parms->N_RB_DL*2*3);
-    if (frame_parms->N_RB_DL != 100)
+
-    {
+    if (frame_parms->N_RB_DL != 100) {
-        fl_set_xyplot_data(form->pdcch_llr,bit_pdcch,llr_pdcch,12*frame_parms->N_RB_DL*2*num_pdcch_symbols,"","","");
+      fl_set_xyplot_data(form->pdcch_llr,bit_pdcch,llr_pdcch,12*frame_parms->N_RB_DL*2*num_pdcch_symbols,"","","");
-    }
+    } else {
-    else
+      LOG_D(PHY,"UE PDCCH LLR plot is bugged in 20 MHz BW, to be fixed !!!\n");
-    {
-        LOG_D(PHY,"UE PDCCH LLR plot is bugged in 20 MHz BW, to be fixed !!!\n");
     }
   }
 
@@ -731,13 +694,11 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
       I[i] = pdcch_comp[2*i];
       Q[i] = pdcch_comp[2*i+1];
     }
-    if (frame_parms->N_RB_DL != 100)
+
-    {
+    if (frame_parms->N_RB_DL != 100) {
-        fl_set_xyplot_data(form->pdcch_comp,I,Q,12*frame_parms->N_RB_DL*num_pdcch_symbols,"","","");
+      fl_set_xyplot_data(form->pdcch_comp,I,Q,12*frame_parms->N_RB_DL*num_pdcch_symbols,"","","");
-    }
+    } else {
-    else
+      LOG_D(PHY,"UE PDCCH COMP plot is bugged in 20 MHz BW, to be fixed !!!\n");
-    {
-        LOG_D(PHY,"UE PDCCH COMP plot is bugged in 20 MHz BW, to be fixed !!!\n");
     }
   }
 
@@ -749,13 +710,11 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
     }
 
     fl_set_xyplot_xbounds(form->pdsch_llr,0,coded_bits_per_codeword);
-    if (frame_parms->N_RB_DL != 100)
+
-    {
+    if (frame_parms->N_RB_DL != 100) {
-        fl_set_xyplot_data(form->pdsch_llr,bit,llr,coded_bits_per_codeword,"","","");
+      fl_set_xyplot_data(form->pdsch_llr,bit,llr,coded_bits_per_codeword,"","","");
-    }
+    } else {
-    else
+      LOG_D(PHY,"UE PDSCH LLR plot is bugged in 20 MHz BW, to be fixed !!!\n");
-    {
-        LOG_D(PHY,"UE PDSCH LLR plot is bugged in 20 MHz BW, to be fixed !!!\n");
     }
   }
 
@@ -765,7 +724,7 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
 
     for (k=0; k<frame_parms->symbols_per_tti; k++) {
       for (i=0; i<12*frame_parms->N_RB_DL/2; i++) {
-    	int j = (2*frame_parms->N_RB_DL*12*k)+4*i;
+        int j = (2*frame_parms->N_RB_DL*12*k)+4*i;
         I[ind] = (pdsch_mag[j  ]!=0? 1.0/pdsch_mag[j  ]: 0.0) * pdsch_comp[j  ]*1.0;
         Q[ind] = (pdsch_mag[j+1]!=0? 1.0/pdsch_mag[j+1]: 0.0) * pdsch_comp[j+1]*1.0;
         ind++;
@@ -778,7 +737,6 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
   // PDSCH Throughput
   memmove( tput_time_ue[UE_id], &tput_time_ue[UE_id][1], (TPUT_WINDOW_LENGTH-1)*sizeof(float) );
   memmove( tput_ue[UE_id],      &tput_ue[UE_id][1],      (TPUT_WINDOW_LENGTH-1)*sizeof(float) );
-
   tput_time_ue[UE_id][TPUT_WINDOW_LENGTH-1]  = (float) frame;
   tput_ue[UE_id][TPUT_WINDOW_LENGTH-1] = ((float) total_dlsch_bitrate)/1000.0;
 
@@ -787,11 +745,8 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
   }
 
   fl_set_xyplot_data(form->pdsch_tput,tput_time_ue[UE_id],tput_ue[UE_id],TPUT_WINDOW_LENGTH,"","","");
-
   fl_set_xyplot_ybounds(form->pdsch_tput,0,tput_ue_max[UE_id]);
-
   fl_check_forms();
-
   free(I);
   free(Q);
   free(chest_f_abs);

openair1/PHY/defs_L1_NB_IoT.h

@@ -32,7 +32,9 @@
 #ifndef __PHY_DEFS_NB_IOT__H__
 #define __PHY_DEFS_NB_IOT__H__
 
+#ifndef _GNU_SOURCE
 #define _GNU_SOURCE
+#endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <malloc.h>

openair1/SIMULATION/LTE_PHY/common_sim.h

@@ -1,8 +1,4 @@
 
-static int cmpdouble(const void *p1, const void *p2) {
-  return *(double *)p1 > *(double *)p2;
-}
-
 double median(varArray_t *input) {
   return *(double *)((uint8_t *)(input+1)+(input->size/2)*input->atomSize);
 }

openair1/SIMULATION/LTE_PHY/dlsim.c

@@ -79,6 +79,9 @@ int n_tx_dropped = 0; /*!< \brief initial max process time for tx */
 int n_rx_dropped = 0; /*!< \brief initial max process time for rx */
 
 double DS_TDL = .03;
+static int cmpdouble(const void *p1, const void *p2) {
+  return *(double *)p1 > *(double *)p2;
+}
 
 int emulate_rf = 0;
 int split73=0;

openair1/SIMULATION/LTE_PHY/ulsim.c

@@ -80,6 +80,9 @@ double t_tx_min = 1000000000; /*!< \brief initial min process time for tx */
 double t_rx_min = 1000000000; /*!< \brief initial min process time for tx */
 int n_tx_dropped = 0; /*!< \brief initial max process time for tx */
 int n_rx_dropped = 0; /*!< \brief initial max process time for rx */
+static int cmpdouble(const void *p1, const void *p2) {
+  return *(double *)p1 > *(double *)p2;
+}
 
 
 int split73=0;
@@ -345,7 +348,7 @@ int main(int argc, char **argv) {
   unsigned short input_buffer_length;
   unsigned int ret;
   unsigned int coded_bits_per_codeword,nsymb;
-  unsigned int tx_lev=0,tx_lev_dB,trials,errs[4]= {0,0,0,0},round_trials[4]= {0,0,0,0};
+  unsigned int tx_lev=0,tx_lev_dB,trials,errs[5]= {0,0,0,0,0},round_trials[4]= {0,0,0,0};
   FILE *bler_fd=NULL;
   char bler_fname[512];
   FILE *time_meas_fd=NULL;

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -66,8 +66,9 @@
 #define inMicroS(a) (((double)(a))/(cpu_freq_GHz*1000.0))
 #include "SIMULATION/LTE_PHY/common_sim.h"
 
+#include <openair2/LAYER2/MAC/mac_vars.h>
+#include <openair2/RRC/LTE/rrc_vars.h>
 
-unsigned char NB_eNB_INST=0;
 LCHAN_DESC DCCH_LCHAN_DESC,DTCH_DL_LCHAN_DESC,DTCH_UL_LCHAN_DESC;
 rlc_info_t Rlc_info_um,Rlc_info_am_config;
 
@@ -81,7 +82,6 @@ double cpuf;
 int sf_ahead=4 ;
 int sl_ahead=0;
 uint8_t nfapi_mode = 0;
-uint16_t NB_UE_INST = 1;
 uint64_t downlink_frequency[MAX_NUM_CCs][4];
 
 // dummy functions
@@ -230,6 +230,7 @@ int main(int argc, char **argv)
 
   SCM_t channel_model=AWGN;//Rayleigh1_anticorr;
 
+  NB_UE_INST = 1;
   //double pbch_sinr;
   //int pbch_tx_ant;
   int N_RB_DL=106,mu=1;

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -46,6 +46,7 @@
 #include "openair1/SIMULATION/RF/rf.h"
 #include "openair1/SIMULATION/NR_PHY/nr_unitary_defs.h"
 #include "openair1/SIMULATION/NR_PHY/nr_dummy_functions.c"
+#include "openair1/PHY/MODULATION/nr_modulation.h"
 
 //#define DEBUG_NR_PBCHSIM
 

openair1/SIMULATION/NR_PHY/prachsim.c

@@ -45,11 +45,13 @@
 #include "PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h"
 #include "nr_unitary_defs.h"
 #include "OCG_vars.h"
+#include <openair2/LAYER2/MAC/mac_vars.h>
+#include <openair2/RRC/LTE/rrc_vars.h>
+
 
 #define NR_PRACH_DEBUG 1
 #define PRACH_WRITE_OUTPUT_DEBUG 1
 
-unsigned char NB_eNB_INST=0;
 LCHAN_DESC DCCH_LCHAN_DESC,DTCH_DL_LCHAN_DESC,DTCH_UL_LCHAN_DESC;
 rlc_info_t Rlc_info_um,Rlc_info_am_config;
 
@@ -59,7 +61,6 @@ RAN_CONTEXT_t RC;
 RU_t *ru;
 double cpuf;
 extern uint16_t prach_root_sequence_map0_3[838];
-uint16_t NB_UE_INST=1;
 openair0_config_t openair0_cfg[MAX_CARDS];
 uint8_t nfapi_mode=0;
 int sl_ahead = 0;
@@ -124,6 +125,7 @@ int main(int argc, char **argv){
   uint8_t config_period;
   int prachOccasion = 0;
   double DS_TDL = .03;
+  NB_UE_INST=1;
 
   //  int8_t interf1=-19,interf2=-19;
   //  uint8_t abstraction_flag=0,calibration_flag=0;

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -60,9 +60,11 @@
 #define inMicroS(a) (((double)(a))/(cpu_freq_GHz*1000.0))
 #include "SIMULATION/LTE_PHY/common_sim.h"
 
+#include <openair2/LAYER2/MAC/mac_vars.h>
+#include <openair2/RRC/LTE/rrc_vars.h>
+
 //#define DEBUG_ULSIM
 
-unsigned char NB_eNB_INST=0;
 LCHAN_DESC DCCH_LCHAN_DESC,DTCH_DL_LCHAN_DESC,DTCH_UL_LCHAN_DESC;
 rlc_info_t Rlc_info_um,Rlc_info_am_config;
 
@@ -75,7 +77,6 @@ int sf_ahead=4 ;
 int sl_ahead=0;
 double cpuf;
 uint8_t nfapi_mode = 0;
-uint16_t NB_UE_INST = 1;
 uint64_t downlink_frequency[MAX_NUM_CCs][4];
 
 
@@ -164,6 +165,7 @@ int main(int argc, char **argv)
   uint16_t N_RB_DL = 106, N_RB_UL = 106, mu = 1;
   double tx_gain=1.0;
   double N0=30;
+  NB_UE_INST = 1;
 
   //unsigned char frame_type = 0;
   NR_DL_FRAME_PARMS *frame_parms;

openair2/LAYER2/MAC/eNB_scheduler_ulsch.c

@@ -56,6 +56,8 @@
 #include "flexran.pb-c.h"
 #include "flexran_agent_mac.h"
 #include <dlfcn.h>
+#include <openair2/LAYER2/MAC/mac.h>
+
 
 #include "T.h"
 

openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c

@@ -3900,7 +3900,6 @@ void nr_ue_send_sdu(module_id_t module_idP,
   #endif
   */
 
-  /*
   #if defined(ENABLE_MAC_PAYLOAD_DEBUG)
     LOG_T(MAC, "[UE %d] First 32 bytes of DLSCH : \n", module_idP);
     for (i = 0; i < 32; i++) {
@@ -3908,7 +3907,6 @@ void nr_ue_send_sdu(module_id_t module_idP,
     }
     LOG_T(MAC, "\n");
   #endif
-  */
 
   // Processing MAC PDU
   // it parses MAC CEs subheaders, MAC CEs, SDU subheaderds and SDUs
@@ -4563,6 +4561,7 @@ void nr_ue_process_mac_pdu(module_id_t module_idP,
               LOG_D(MAC, "[UE] LCID %d, PDU length %d\n", ((NR_MAC_SUBHEADER_FIXED *)pdu_ptr)->LCID, pdu_len);
 	      //#endif
 
+        LOG_D(MAC, "[UE] LCID %d, PDU length %d\n", rx_lcid, pdu_len);
         switch(rx_lcid){
             //  MAC CE
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c

@@ -444,8 +444,10 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
     clear_nr_nfapi_information(RC.nrmac[module_idP], CC_id, frame, slot);
   }
 
+
   if ((slot == 0) && (frame & 127) == 0) dump_mac_stats(RC.nrmac[module_idP]);
 
+
   // This schedules MIB
   schedule_nr_mib(module_idP, frame, slot, slots_per_frame[*scc->ssbSubcarrierSpacing]);
 
@@ -466,24 +468,30 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
   if (get_softmodem_params()->phy_test == 0) {
     nr_schedule_RA(module_idP, frame, slot);
     nr_schedule_reception_msg3(module_idP, 0, frame, slot);
+
   }
 
   // This schedules the DCI for Uplink and subsequently PUSCH
+
   // The decision about whether to schedule is done for each UE independently
   // inside
   if (UE_info->active[UE_id] && slot < 10) {
+
     int tda = 1; // time domain assignment hardcoded for now
     schedule_fapi_ul_pdu(module_idP, frame, slot, num_slots_per_tdd, nr_ulmix_slots, tda, ulsch_in_slot_bitmap);
     nr_schedule_pusch(module_idP, UE_id, num_slots_per_tdd, nr_ulmix_slots, frame, slot);
   }
 
+
   if (UE_info->active[UE_id]
       && (is_xlsch_in_slot(dlsch_in_slot_bitmap, slot % num_slots_per_tdd))
       && slot < 10) {
+
     ue_sched_ctl->current_harq_pid = slot % num_slots_per_tdd;
     nr_schedule_ue_spec(module_idP, frame, slot, num_slots_per_tdd);
   }
 
+
   if (UE_info->active[UE_id])
     nr_schedule_pucch(module_idP, UE_id, nr_ulmix_slots, frame, slot);
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c

@@ -438,9 +438,11 @@ void nr_initiate_ra_proc(module_id_t module_idP,
       break;
     }
   }
+
   if (!pr_found) {
     LOG_E(MAC, "[gNB %d][RAPROC] FAILURE: preamble %d does not correspond to any of the ones in rach_ConfigDedicated\n",
           module_idP, preamble_index);
+
     return; // if the PRACH preamble does not correspond to any of the ones sent through RRC abort RA proc
   }
   // This should be handled differently when we use the initialBWP for RA

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_bch.c

@@ -202,8 +202,12 @@ void schedule_nr_mib(module_id_t module_idP, frame_t frameP, sub_frame_t slotP,
   }
 }
 
-void fill_ssb_vrb_map (NR_COMMON_channels_t *cc, int rbStart, int CC_id) {
 
+void schedule_nr_SI(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP) {
+//----------------------------------------  
+}
+
+void fill_ssb_vrb_map (NR_COMMON_channels_t *cc, int rbStart, int CC_id) {
   uint16_t *vrb_map = cc[CC_id].vrb_map;
   for (int rb = 0; rb < 20; rb++)
     vrb_map[rbStart + rb] = 1;

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -1830,6 +1830,7 @@ void mac_remove_nr_ue(module_id_t mod_id, rnti_t rnti)
 
     /* UE found, remove it */
     UE_id = i;
+
     UE_info->num_UEs--;
     UE_info->active[UE_id] = FALSE;
     UE_info->rnti[UE_id] = 0;

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c

@@ -214,12 +214,8 @@ void nr_process_mac_pdu(
 		int UE_id = find_nr_UE_id(module_idP, rnti);
 		RC.nrmac[module_idP]->UE_info.mac_stats[UE_id].lc_bytes_rx[rx_lcid] += mac_sdu_len;
                 #if defined(ENABLE_MAC_PAYLOAD_DEBUG)
-                    LOG_T(MAC, "[UE %d] First 32 bytes of DLSCH : \n", module_idP);
+		    log_dump(MAC, pdu_ptr + mac_subheader_len, 32, LOG_DUMP_CHAR, "\n");
 
-                    for (i = 0; i < 32; i++)
-                      LOG_T(MAC, "%x.", (pdu_ptr + mac_subheader_len)[i]);
-
-                    LOG_T(MAC, "\n");
                 #endif
                 if(IS_SOFTMODEM_NOS1){
                   mac_rlc_data_ind(module_idP,
@@ -355,6 +351,7 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
     }
 
 #if defined(ENABLE_MAC_PAYLOAD_DEBUG)
+
     LOG_I(MAC, "Printing received UL MAC payload at gNB side: %d \n");
     for (int i = 0; i < sdu_lenP ; i++) {
 	  //harq_process_ul_ue->a[i] = (unsigned char) rand();
@@ -362,6 +359,7 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
 	  printf("%02x ",(unsigned char)sduP[i]);
     }
     printf("\n");
+
 #endif
 
     if (sduP != NULL){
@@ -420,4 +418,5 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
       return;
     }
   }
+
 }

openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h

@@ -68,6 +68,9 @@
 #include "LAYER2/NR_MAC_COMMON/nr_mac_common.h"
 #include "NR_TAG.h"
 
+#include <openair3/UICC/usim_interface.h>
+
+
 /* Defs */
 #define MAX_NUM_BWP 2
 #define MAX_NUM_CORESET 2
@@ -386,7 +389,11 @@ typedef struct {
 } NR_UE_sched_ctrl_t;
 
 typedef struct {
+  boolean_t fiveG_connected;
+  uicc_t *uicc;
+} NRUEcontext_t;
 
+typedef struct {
   int lc_bytes_tx[64];
   int lc_bytes_rx[64];
   int dlsch_rounds[8];
@@ -399,6 +406,7 @@ typedef struct {
 } NR_mac_stats_t;
 
 
+
 /*! \brief UNR_E_list_t is a "list" of users within UE_info_t. Especial useful in
  * the scheduler and to keep "classes" of users. */
 typedef struct {
@@ -406,6 +414,7 @@ typedef struct {
   int next[MAX_MOBILES_PER_GNB];
 } NR_UE_list_t;
 
+
 /*! \brief UE list used by gNB to order UEs/CC for scheduling*/
 #define MAX_CSI_REPORTCONFIG 48
 typedef struct {
@@ -416,6 +425,7 @@ typedef struct {
   NR_mac_stats_t mac_stats[MAX_MOBILES_PER_GNB];
   NR_UE_list_t list;
   int num_UEs;
+
   bool active[MAX_MOBILES_PER_GNB];
   rnti_t rnti[MAX_MOBILES_PER_GNB];
   NR_CellGroupConfig_t *secondaryCellGroup[MAX_MOBILES_PER_GNB];

openair2/LAYER2/PDCP_v10.1.0/pdcp.c

@@ -1025,7 +1025,7 @@ pdcp_data_ind(
       pushNotifiedFIFO(&pdcp_sdu_list, new_sdu_p); 
 
     /* Print octets of incoming data in hexadecimal form */
-    LOG_D(PDCP, "Following content has been received from RLC (%d,%d)(PDCP header has already been removed):\n",
+      LOG_D(PDCP, "Following content has been received from RLC (%d,%d)(PDCP header has already been removed):\n",
           sdu_buffer_sizeP  - payload_offset + (int)sizeof(pdcp_data_ind_header_t),
           sdu_buffer_sizeP  - payload_offset);
     //util_print_hex_octets(PDCP, &new_sdu_p->data[sizeof (pdcp_data_ind_header_t)], sdu_buffer_sizeP - payload_offset);

openair2/LAYER2/PDCP_v10.1.0/pdcp_fifo.c

@@ -150,9 +150,9 @@ int pdcp_fifo_flush_sdus(const protocol_ctxt_t *const  ctxt_pP) {
       nas_nlh_tx->nlmsg_len = sizeToWrite;
       ret = sendmsg(nas_sock_fd[0],&nas_msg_tx,0);
     }  //  PDCP_USE_NETLINK
-
-    AssertFatal(ret >= 0,"[PDCP_FIFOS] pdcp_fifo_flush_sdus (errno: %d %s), nas_sock_fd[0]: %d\n", errno, strerror(errno), nas_sock_fd[0]);
     
+    AssertFatal(ret >= 0,"[PDCP_FIFOS] pdcp_fifo_flush_sdus (errno: %d %s), nas_sock_fd[0]: %d\n", errno, strerror(errno), nas_sock_fd[0]);
+
     if( LOG_DEBUGFLAG(DEBUG_PDCP) )
       log_dump(PDCP, pdcpData, min(sizeToWrite,30) , LOG_DUMP_CHAR,
 	       "Printing first bytes of PDCP SDU before removing it from the list: \n");
@@ -196,6 +196,7 @@ int pdcp_fifo_flush_mbms_sdus(const protocol_ctxt_t *const  ctxt_pP) {
     //}  //  PDCP_USE_NETLINK
 
     //AssertFatal(ret >= 0,"[PDCP_FIFOS] pdcp_fifo_flush_sdus (errno: %d %s)\n", errno, strerror(errno));
+
     //AssertFatal(ret >= 0,"[PDCP_FIFOS] pdcp_fifo_flush_sdus (errno: %d %s)\n", errno, strerror(errno));
     delNotifiedFIFO_elt (sdu_p);
     pdcp_nb_sdu_sent ++;

openair2/LAYER2/RLC/rlc.h

@@ -143,7 +143,7 @@ void (*rlc_rrc_data_conf)(
   const protocol_ctxt_t *const ctxtP,
   const rb_id_t         rb_idP,
   const mui_t           muiP,
-  const rlc_tx_status_t statusP);
+  const rlc_tx_status_t statusP) __attribute__ ((aligned(32)));
 
 typedef void (rrc_data_ind_cb_t)(
   const protocol_ctxt_t *const ctxtP,

openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c

@@ -19,6 +19,9 @@
  *      contact@openairinterface.org
  */
 
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
 #include "nr_pdcp_ue_manager.h"
 #include "NR_RadioBearerConfig.h"
 #include "NR_RLC-BearerConfig.h"
@@ -43,6 +46,7 @@ static uint64_t pdcp_optmask;
 /* rlc_data_req queue - begin                                               */
 /****************************************************************************/
 
+
 #include <pthread.h>
 
 /* NR PDCP and RLC both use "big locks". In some cases a thread may do
@@ -92,6 +96,7 @@ static void *rlc_data_req_thread(void *_)
 {
   int i;
 
+  pthread_setname_np(pthread_self(), "RLC queue");
   while (1) {
     if (pthread_mutex_lock(&q.m) != 0) abort();
     while (q.length == 0)
@@ -203,6 +208,7 @@ static void *enb_tun_read_thread(void *_)
   protocol_ctxt_t ctxt;
 
   int rb_id = 1;
+  pthread_setname_np( pthread_self(),"enb_tun_read");
 
   while (1) {
     len = read(nas_sock_fd[0], &rx_buf, NL_MAX_PAYLOAD);
@@ -247,7 +253,7 @@ static void *ue_tun_read_thread(void *_)
   protocol_ctxt_t ctxt;
 
   int rb_id = 1;
-
+  pthread_setname_np( pthread_self(),"ue_tun_read"); 
   while (1) {
     len = read(nas_sock_fd[0], &rx_buf, NL_MAX_PAYLOAD);
     if (len == -1) {

openair2/RRC/NR/L2_nr_interface.c

@@ -88,6 +88,12 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
   }
 
   /* TODO BCCH SIB1 SIBs */
+  if ((Srb_id & RAB_OFFSET ) == BCCH) {
+      memcpy(&buffer_pP[0],
+             RC.rrc[Mod_idP]->carrier[CC_id].SIB1_MBMS,
+             RC.rrc[Mod_idP]->carrier[CC_id].sizeof_SIB1_MBMS);
+
+  }
 
   /* CCCH */
   if( (Srb_id & RAB_OFFSET ) == CCCH) {
@@ -114,4 +120,4 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
 
   return(0);
 
-}
+}

openair2/RRC/NR/MESSAGES/asn1_msg.c

@@ -200,6 +200,10 @@ uint8_t do_MIB_NR(gNB_RRC_INST *rrc,uint32_t frame) {
   mib->message.choice.mib->spare.bits_unused = 7;  // This makes a spare of 1 bits
 
   mib->message.choice.mib->ssb_SubcarrierOffset = (carrier->ssb_SubcarrierOffset)&15;
+  /*
+   * The SIB1 will be sent in this allocation (Type0-PDCCH) : 38.213, 13-4 Table and 38.213 13-11 to 13-14 tables
+   * the reverse allocation is in nr_ue_decode_mib()
+   */
   mib->message.choice.mib->pdcch_ConfigSIB1.controlResourceSetZero = *scc->downlinkConfigCommon->initialDownlinkBWP->pdcch_ConfigCommon->choice.setup->controlResourceSetZero;
   mib->message.choice.mib->pdcch_ConfigSIB1.searchSpaceZero = *scc->downlinkConfigCommon->initialDownlinkBWP->pdcch_ConfigCommon->choice.setup->searchSpaceZero;
   AssertFatal(scc->ssbSubcarrierSpacing != NULL, "scc->ssbSubcarrierSpacing is null\n");
@@ -265,10 +269,6 @@ uint8_t do_SIB1_NR(rrc_gNB_carrier_data_t *carrier,
 	               gNB_RrcConfigurationReq *configuration
                   ) {
   asn_enc_rval_t enc_rval;
-  NR_BCCH_DL_SCH_Message_t *sib1_message ;
-  struct NR_SIB1 *sib1 ;
-  int i;
-  struct NR_PLMN_IdentityInfo nr_plmn_info;
 
   // TODO : Add support for more than one PLMN
   //int num_plmn = configuration->num_plmn;
@@ -276,31 +276,29 @@ uint8_t do_SIB1_NR(rrc_gNB_carrier_data_t *carrier,
   struct NR_PLMN_Identity nr_plmn[num_plmn];
   NR_MCC_MNC_Digit_t nr_mcc_digit[num_plmn][3];
   NR_MCC_MNC_Digit_t nr_mnc_digit[num_plmn][3];
+  memset(nr_plmn,0,sizeof(nr_plmn));
+  memset(nr_mcc_digit,0,sizeof(nr_mcc_digit));
+  memset(nr_mnc_digit,0,sizeof(nr_mnc_digit));
+  
   //  struct NR_UAC_BarringInfoSet nr_uac_BarringInfoSet;
-  sib1_message = CALLOC(1,sizeof(NR_BCCH_DL_SCH_Message_t));
+  NR_BCCH_DL_SCH_Message_t *sib1_message = CALLOC(1,sizeof(NR_BCCH_DL_SCH_Message_t));
-  memset(sib1_message,0,sizeof(NR_BCCH_DL_SCH_Message_t));
   carrier->siblock1 = sib1_message;
   sib1_message->message.present = NR_BCCH_DL_SCH_MessageType_PR_c1;
   sib1_message->message.choice.c1 = CALLOC(1,sizeof(struct NR_BCCH_DL_SCH_MessageType__c1));
-  memset(sib1_message->message.choice.c1,0,sizeof(struct NR_BCCH_DL_SCH_MessageType__c1));
   sib1_message->message.choice.c1->present = NR_BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1;
   sib1_message->message.choice.c1->choice.systemInformationBlockType1 = CALLOC(1,sizeof(struct NR_SIB1));
-  sib1 = sib1_message->message.choice.c1->choice.systemInformationBlockType1;
+  
-  memset(sib1,0,sizeof(struct NR_SIB1));
+  struct NR_SIB1 *sib1 = sib1_message->message.choice.c1->choice.systemInformationBlockType1;
   sib1->cellSelectionInfo = CALLOC(1,sizeof(struct NR_SIB1__cellSelectionInfo));
-  memset(sib1->cellSelectionInfo,0,sizeof(struct NR_SIB1__cellSelectionInfo));
   sib1->cellSelectionInfo->q_RxLevMin = -50;
-  memset(&nr_plmn_info.plmn_IdentityList,0,sizeof(struct NR_PLMN_IdentityInfo__plmn_IdentityList));
-  asn_set_empty(&nr_plmn_info.plmn_IdentityList.list);
-  memset(&nr_plmn_info,0,sizeof(struct NR_PLMN_IdentityInfo));
-  memset(nr_plmn,0,num_plmn*sizeof(struct NR_PLMN_Identity));
 
-  for (i = 0; i < num_plmn; ++i) {
+  struct NR_PLMN_IdentityInfo *nr_plmn_info=CALLOC(1,sizeof(struct NR_PLMN_IdentityInfo));
+  asn_set_empty(&nr_plmn_info->plmn_IdentityList.list);
+  for (int i = 0; i < num_plmn; ++i) {
     nr_mcc_digit[i][0] = (configuration->mcc[i]/100)%10;
     nr_mcc_digit[i][1] = (configuration->mcc[i]/10)%10;
     nr_mcc_digit[i][2] = (configuration->mcc[i])%10;
     nr_plmn[i].mcc = CALLOC(1,sizeof(struct NR_MCC));
-    memset(nr_plmn[i].mcc,0,sizeof(struct NR_MCC));
     asn_set_empty(&nr_plmn[i].mcc->list);
     ASN_SEQUENCE_ADD(&nr_plmn[i].mcc->list, &nr_mcc_digit[i][0]);
     ASN_SEQUENCE_ADD(&nr_plmn[i].mcc->list, &nr_mcc_digit[i][1]);
@@ -308,26 +306,23 @@ uint8_t do_SIB1_NR(rrc_gNB_carrier_data_t *carrier,
     nr_mnc_digit[i][0] = (configuration->mnc[i]/100)%10;
     nr_mnc_digit[i][1] = (configuration->mnc[i]/10)%10;
     nr_mnc_digit[i][2] = (configuration->mnc[i])%10;
-    memset(&nr_plmn[i].mnc,0,sizeof(NR_MNC_t));
     nr_plmn[i].mnc.list.size=0;
     nr_plmn[i].mnc.list.count=0;
     ASN_SEQUENCE_ADD(&nr_plmn[i].mnc.list, &nr_mnc_digit[i][0]);
     ASN_SEQUENCE_ADD(&nr_plmn[i].mnc.list, &nr_mnc_digit[i][1]);
     ASN_SEQUENCE_ADD(&nr_plmn[i].mnc.list, &nr_mnc_digit[i][2]);
-    ASN_SEQUENCE_ADD(&nr_plmn_info.plmn_IdentityList.list, &nr_plmn[i]);
+    ASN_SEQUENCE_ADD(&nr_plmn_info->plmn_IdentityList.list, &nr_plmn[i]);
   }//end plmn loop
 
-  nr_plmn_info.cellIdentity.buf = MALLOC(8);
+  nr_plmn_info->cellIdentity.buf = CALLOC(1,8);
-  memset(nr_plmn_info.cellIdentity.buf,0,8);
+  nr_plmn_info->cellIdentity.buf[0]= (configuration->cell_identity >> 20) & 0xff;
-  nr_plmn_info.cellIdentity.buf[0]= (configuration->cell_identity >> 20) & 0xff;
+  nr_plmn_info->cellIdentity.buf[1]= (configuration->cell_identity >> 12) & 0xff;
-  nr_plmn_info.cellIdentity.buf[1]= (configuration->cell_identity >> 12) & 0xff;
+  nr_plmn_info->cellIdentity.buf[2]= (configuration->cell_identity >> 4) & 0xff;
-  nr_plmn_info.cellIdentity.buf[2]= (configuration->cell_identity >> 4) & 0xff;
+  nr_plmn_info->cellIdentity.buf[3]= (configuration->cell_identity << 4) & 0xff;
-  nr_plmn_info.cellIdentity.buf[3]= (configuration->cell_identity << 4) & 0xff;
+  nr_plmn_info->cellIdentity.size= 4;
-  nr_plmn_info.cellIdentity.size= 4;
+  nr_plmn_info->cellIdentity.bits_unused= 4;
-  nr_plmn_info.cellIdentity.bits_unused= 4;
+  nr_plmn_info->cellReservedForOperatorUse = 0;
-  nr_plmn_info.cellReservedForOperatorUse = 0;
+  ASN_SEQUENCE_ADD(&sib1->cellAccessRelatedInfo.plmn_IdentityList.list, nr_plmn_info);
-  memset(&sib1->cellAccessRelatedInfo,0,sizeof(NR_CellAccessRelatedInfo_t));
-  ASN_SEQUENCE_ADD(&sib1->cellAccessRelatedInfo.plmn_IdentityList.list, &nr_plmn_info);
 #if 0
   sib1->uac_BarringInfo = CALLOC(1, sizeof(struct NR_SIB1__uac_BarringInfo));
   memset(sib1->uac_BarringInfo, 0, sizeof(struct NR_SIB1__uac_BarringInfo));
@@ -340,11 +335,12 @@ uint8_t do_SIB1_NR(rrc_gNB_carrier_data_t *carrier,
   ASN_SEQUENCE_ADD(&sib1->uac_BarringInfo->uac_BarringInfoSetList, &nr_uac_BarringInfoSet);
 #endif
   //encode SIB1 to data
+  carrier->SIB1=(uint8_t *) malloc16(128);
   enc_rval = uper_encode_to_buffer(&asn_DEF_NR_BCCH_DL_SCH_Message,
                                    NULL,
                                    (void *)sib1_message,
                                    carrier->SIB1,
-                                   100);
+                                   128);
   AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n",
                enc_rval.failed_type->name, enc_rval.encoded);
 
@@ -578,3 +574,8 @@ void do_SpCellConfig(gNB_RRC_INST *rrc,
   spconfig->reconfigurationWithSync = CALLOC(1,sizeof(struct NR_ReconfigurationWithSync));
 }
 
+
+int do_DLInformationTransfer_NR (void * p) {
+	return 0;
+}
+

openair2/RRC/NR/nr_ngap_gNB.c

@@ -9,6 +9,8 @@
  *
  *      http://www.openairinterface.org/?page_id=698
  *
+ * Author and copyright: Laurent Thomas, open-cells.com
+ *
  * 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.
@@ -18,25 +20,38 @@
  * For more information about the OpenAirInterface (OAI) Software Alliance:
  *      contact@openairinterface.org
  */
+#include <openair2/RRC/LTE/MESSAGES/asn1_msg.h>
+#include <openair2/RRC/NR/nr_rrc_proto.h>
 
-#ifndef MEMORY_POOLS_H_
+void rrc_gNB_process_NGAP_DOWNLINK_NAS (void ) {
-#define MEMORY_POOLS_H_
+   do_DLInformationTransfer(0,NULL,0,0,NULL);
+   // send it as DL data
+/*
+    rrc_data_req (
+      &ctxt,
+      srb_id,
+      (*rrc_eNB_mui)++,
+      SDU_CONFIRM_NO,
+      length,
+      buffer,
+      PDCP_TRANSMISSION_MODE_CONTROL);
+*/
 
-#include <stdint.h>
+}
 
-typedef void * memory_pools_handle_t;
+void rrc_gNB_send_NGAP_NAS_FIRST_REQ(void ) {
-typedef void * memory_pool_item_handle_t;
+   // We are noCore only now
+   // create message that should come from 5GC
+  
+   // send it dow
+   rrc_gNB_process_NGAP_DOWNLINK_NAS();
+}
 
-memory_pools_handle_t memory_pools_create (uint32_t pools_number);
+void nr_rrc_rx_tx() {
+  // check timers 
 
-char *memory_pools_statistics(memory_pools_handle_t memory_pools_handle);
+  // check if UEs are lost, to remove them from upper layers
 
-int memory_pools_add_pool (memory_pools_handle_t memory_pools_handle, uint32_t pool_items_number, uint32_t pool_item_size);
+  //
 
-memory_pool_item_handle_t memory_pools_allocate (memory_pools_handle_t memory_pools_handle, uint32_t item_size, uint16_t info_0, uint16_t info_1);
+}
-
-int memory_pools_free (memory_pools_handle_t memory_pools_handle, memory_pool_item_handle_t memory_pool_item_handle, uint16_t info_0);
-
-void memory_pools_set_info (memory_pools_handle_t memory_pools_handle, memory_pool_item_handle_t memory_pool_item_handle, int index, uint16_t info);
-
-#endif /* MEMORY_POOLS_H_ */

openair2/RRC/NR/nr_rrc_proto.h

@@ -93,7 +93,7 @@ int generate_CG_Config(gNB_RRC_INST *rrc,
 
 int parse_CG_ConfigInfo(gNB_RRC_INST *rrc, NR_CG_ConfigInfo_t *CG_ConfigInfo, x2ap_ENDC_sgnb_addition_req_t *m);
 
-
+void nr_rrc_rx_tx(void);
 
 /**\brief RRC eNB task.
    \param void *args_p Pointer on arguments to start the task. */

openair2/RRC/NR/rrc_gNB.c

@@ -82,7 +82,7 @@
 
 #include "executables/softmodem-common.h"
 #include <openair2/RRC/NR/rrc_gNB_UE_context.h>
-#include "x2ap_eNB.h"
+#include <openair2/X2AP/x2ap_eNB.h>
 
 //#define XER_PRINT
 
@@ -179,10 +179,11 @@ void rrc_gNB_generate_SgNBAdditionRequestAcknowledge(
 ///---------------------------------------------------------------------------------------------------------------///
 ///---------------------------------------------------------------------------------------------------------------///
 
-static void init_NR_SI(gNB_RRC_INST *rrc) {
+static void init_NR_SI(gNB_RRC_INST *rrc, gNB_RrcConfigurationReq *configuration) {
   LOG_D(RRC,"%s()\n\n\n\n",__FUNCTION__);
   rrc->carrier.MIB             = (uint8_t *) malloc16(4);
   rrc->carrier.sizeof_MIB      = do_MIB_NR(rrc,0);
+  rrc->carrier.sizeof_SIB1      = do_SIB1_NR(&rrc->carrier,configuration);
   LOG_I(NR_RRC,"Done init_NR_SI\n");
   rrc_mac_config_req_gNB(rrc->module_id,
                          rrc->carrier.ssb_SubcarrierOffset,
@@ -272,7 +273,7 @@ char openair_rrc_gNB_configuration(const module_id_t gnb_mod_idP, gNB_RrcConfigu
   rrc->carrier.pucch_TargetSNRx10 = configuration->pucch_TargetSNRx10;
   /// System Information INIT
   LOG_I(NR_RRC, PROTOCOL_NR_RRC_CTXT_FMT" Checking release \n",PROTOCOL_NR_RRC_CTXT_ARGS(&ctxt));
-  init_NR_SI(rrc);
+  init_NR_SI(rrc, configuration);
   rrc_init_nr_global_param();
   openair_nr_rrc_on(&ctxt);
   return 0;

openair2/UTIL/OPT/mac_pcap.h

@@ -6,6 +6,7 @@
 #include <arpa/inet.h>
 
 #define MAC_LTE_DLT 147
+#define DLT_IPV4 228
 /********************************************************/
 /* Definitions and descriptions come from:
     http://wiki.wireshark.org/Development/LibpcapFileFormat */
@@ -29,20 +30,4 @@ typedef struct pcaprec_hdr_s {
   unsigned int   orig_len;       /* actual length of packet */
 } pcaprec_hdr_t;
 
-/* Context information for every MAC PDU that will be logged */
-typedef struct MAC_Context_Info_t {
-  unsigned short radioType;
-  unsigned char  direction;
-  unsigned char  rntiType;
-  unsigned short rnti;
-  unsigned short ueid;
-  unsigned char  isRetx;
-  unsigned char  crcStatusOK;
-
-  unsigned short sysFrameNumber;
-  unsigned short subFrameNumber;
-
-  unsigned int   subframesSinceCaptureStart;
-} MAC_Context_Info_t;
-
 #endif

openair2/UTIL/OPT/opt.h

@@ -73,7 +73,7 @@ typedef guint8   gboolean;
 /*   optname                helpstr                 paramflags    XXXptr                  defXXXval                       type        numelt   */
 /*---------------------------------------------------------------------------------------------------------------------------------------------*/
 #define OPT_PARAMS_DESC {  \
-    {"type" ,               CONFIG_HLP_TYPEMON,     0,            strptr:&in_type,        defstrval:"none",               TYPE_STRING,    0},   \
+    {"type" ,               CONFIG_HLP_TYPEMON,     0,            strptr:(char**)&in_type,        defstrval:"none",               TYPE_STRING,    0},   \
     {"ip" ,                 CONFIG_HLP_L2MONIP,     0,            strptr:(char**)&in_ip,  defstrval:"127.0.0.1",          TYPE_STRING,    0},   \
     {"path" ,               CONFIG_HLP_L2MONPATH,   0,            strptr:(char**)&in_path,defstrval:"/tmp/oai_opt.pcap",  TYPE_STRING,    0},   \
   }

openair2/UTIL/OPT/probe.c

@@ -90,6 +90,7 @@ what about the implementation
 
 #include <pthread.h>
 #include <stdint.h>
+#include <sys/time.h>
 #include "common/config/config_userapi.h"
 #include "opt.h"
 #include "common/utils/system.h"
@@ -99,8 +100,6 @@ int opt_enabled=0;
 //static unsigned char g_PDUBuffer[1600];
 //static unsigned int g_PDUOffset;
 
-static char in_ip[128]={0};
-static char in_path[128]={0};
 FILE *file_fd = NULL;
 pcap_hdr_t file_header = {
   0xa1b2c3d4,   /* magic number */
@@ -108,10 +107,14 @@ pcap_hdr_t file_header = {
   0,            /* timezone */
   0,            /* sigfigs - apparently all tools do this */
   65535,        /* snaplen - this should be long enough */
-  MAC_LTE_DLT   /* Data Link Type (DLT).  Set as unused value 147 for now */
+  DLT_IPV4
+  //MAC_LTE_DLT   /* Data Link Type (DLT).  Set as unused value 147 for now */
 };
 
 trace_mode_t opt_type = OPT_NONE;
+static char *in_type=NULL;
+static char *in_path=NULL;
+static char *in_ip=NULL;
 static unsigned int subframesSinceCaptureStart;
 
 static int g_socksd = -1;/* UDP socket used for sending frames */
@@ -131,8 +134,80 @@ static void SendFrame(guint8 radioType, guint8 direction, guint8 rntiType,
                       guint8 oob_event, guint8 oob_event_value,
                       uint8_t *pdu_buffer, unsigned int pdu_buffer_size);
 
-static int MAC_LTE_PCAP_WritePDU(MAC_Context_Info_t *context,
+unsigned short checksum(unsigned short *ptr, int length) {
-                                 const unsigned char *PDU, unsigned int length);
+  int sum = 0;
+  u_short answer = 0;
+  unsigned short *w = ptr;
+  int nleft = length;
+
+  while(nleft > 1) {
+    sum += *w++;
+    nleft -= 2;
+  }
+
+  sum = (sum >> 16) + (sum & 0xFFFF);
+  sum += (sum >> 16);
+  answer = ~sum;
+  return(answer);
+}
+
+/* Write an individual PDU (PCAP packet header + mac-context + mac-pdu) */
+static int MAC_LTE_PCAP_WritePDU(const uint8_t *PDU,
+                                 unsigned int length) {
+  pcaprec_hdr_t packet_header;
+  // IPv4 header
+  typedef struct ip_hdr {
+    unsigned char  ip_verlen;        // 4-bit IPv4 version 4-bit header length (in 32-bit words)
+    unsigned char  ip_tos;           // IP type of service
+    unsigned short ip_totallength;   // Total length
+    unsigned short ip_id;            // Unique identifier
+    unsigned short ip_offset;        // Fragment offset field
+    unsigned char  ip_ttl;           // Time to live
+    unsigned char  ip_protocol;      // Protocol(TCP,UDP etc)
+    unsigned short ip_checksum;      // IP checksum
+    unsigned int   ip_srcaddr;       // Source address
+    unsigned int   ip_destaddr;      // Source address
+  } IPV4_HDR;
+  // Define the UDP header
+  typedef struct udp_hdr {
+    unsigned short src_portno;       // Source port no.
+    unsigned short dst_portno;       // Dest. port no.
+    unsigned short udp_length;       // Udp packet length
+    unsigned short udp_checksum;     // Udp checksum (optional)
+  } UDP_HDR;
+  IPV4_HDR IPheader= {0};
+  IPheader.ip_verlen = (4 << 4) | (sizeof(IPV4_HDR) / sizeof(uint32_t));
+  IPheader.ip_totallength = htons(sizeof(IPV4_HDR) + sizeof(UDP_HDR) + length);
+  IPheader.ip_ttl    = 8;    // Time-to-live is eight
+  IPheader.ip_protocol = IPPROTO_UDP;
+  IPheader.ip_srcaddr  = inet_addr(in_ip);
+  IPheader.ip_destaddr = inet_addr(in_ip);
+  IPheader.ip_checksum = checksum((unsigned short *)&IPheader, sizeof(IPV4_HDR));
+  // Initialize the UDP header
+  UDP_HDR UDPheader;
+  UDPheader.src_portno = htons( PACKET_MAC_LTE_DEFAULT_UDP_PORT);
+  UDPheader.dst_portno = htons( PACKET_MAC_LTE_DEFAULT_UDP_PORT);
+  UDPheader.udp_length = htons(sizeof(UDP_HDR) + length);
+  UDPheader.udp_checksum = 0;
+  /****************************************************************/
+  /* PCAP Header                                                  */
+  /* TODO: Timestamp might want to be relative to a more sensible
+     base time... */
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  packet_header.ts_sec = tv.tv_sec;
+  packet_header.ts_usec = tv.tv_usec;
+  packet_header.incl_len =sizeof(IPV4_HDR) + sizeof(UDP_HDR) + length;
+  packet_header.orig_len =sizeof(IPV4_HDR) + sizeof(UDP_HDR) + length;
+  /***************************************************************/
+  /* Now write everything to the file                            */
+  fwrite(&packet_header, sizeof(pcaprec_hdr_t), 1, file_fd);
+  fwrite(&IPheader, sizeof(IPV4_HDR), 1, file_fd);
+  fwrite(&UDPheader, sizeof(UDP_HDR), 1, file_fd);
+  fwrite(PDU, 1, length, file_fd);
+  fflush(file_fd);
+  return length;
+}
 
 static void *opt_listener_thread(void *arg) {
   ssize_t ret;
@@ -198,7 +273,6 @@ int opt_create_listener_socket(char *ip_address, uint16_t port) {
   }
 
   threadCreate(&opt_listener.thread, opt_listener_thread, NULL, "flexran", -1, OAI_PRIORITY_RT_LOW);
-
   return 0;
 }
 
@@ -321,67 +395,20 @@ static void SendFrame(guint8 radioType, guint8 direction, guint8 rntiType,
     frameOffset += pdu_buffer_size;
   }
 
-  /* Send out the data over the UDP socket */
+  if ( opt_type ==  OPT_WIRESHARK )
-  bytesSent = sendto(g_socksd, frameBuffer, frameOffset, 0,
+    /* Send out the data over the UDP socket */
-                     (const struct sockaddr *)&g_serv_addr, sizeof(g_serv_addr));
+    bytesSent = sendto(g_socksd, frameBuffer, frameOffset, 0,
+                       (const struct sockaddr *)&g_serv_addr, sizeof(g_serv_addr));
+  else
+    bytesSent = MAC_LTE_PCAP_WritePDU(frameBuffer, frameOffset);
 
   if (bytesSent != frameOffset) {
-    LOG_W(OPT, "sendto() failed (not a thread-safe func)- expected %d bytes, got %ld (errno=%d)\n",
+    LOG_W(OPT, "trace_pdu expected %d bytes, got %ld (errno=%d)\n",
           frameOffset, bytesSent, errno);
     //exit(1);
   }
 }
 
-/* Write an individual PDU (PCAP packet header + mac-context + mac-pdu) */
-static int MAC_LTE_PCAP_WritePDU(MAC_Context_Info_t *context,
-                                 const uint8_t *PDU,
-                                 unsigned int length)
-{
-  pcaprec_hdr_t packet_header;
-  uint8_t context_header[256];
-  int offset = 0;
-  unsigned short tmp16;
-  /*****************************************************************/
-  /* Context information (same as written by UDP heuristic clients */
-  context_header[offset++] = context->radioType;
-  context_header[offset++] = context->direction;
-  context_header[offset++] = context->rntiType;
-  /* RNTI */
-  context_header[offset++] = MAC_LTE_RNTI_TAG;
-  tmp16 = htons(context->rnti);
-  memcpy(context_header+offset, &tmp16, 2);
-  offset += 2;
-  /* UEId */
-  context_header[offset++] = MAC_LTE_UEID_TAG;
-  tmp16 = htons(context->ueid);
-  memcpy(context_header+offset, &tmp16, 2);
-  offset += 2;
-  /* Subframe number */
-  context_header[offset++] = MAC_LTE_FRAME_SUBFRAME_TAG;
-  tmp16 = htons(context->subFrameNumber);
-  memcpy(context_header+offset, &tmp16, 2);
-  offset += 2;
-  /* CRC Status */
-  context_header[offset++] = MAC_LTE_CRC_STATUS_TAG;
-  context_header[offset++] = context->crcStatusOK;
-  /* Data tag immediately preceding PDU */
-  context_header[offset++] = MAC_LTE_PAYLOAD_TAG;
-  /****************************************************************/
-  /* PCAP Header                                                  */
-  /* TODO: Timestamp might want to be relative to a more sensible
-     base time... */
-  packet_header.ts_sec = context->subframesSinceCaptureStart / 1000;
-  packet_header.ts_usec = (context->subframesSinceCaptureStart % 1000) * 1000;
-  packet_header.incl_len = offset + length;
-  packet_header.orig_len = offset + length;
-  /***************************************************************/
-  /* Now write everything to the file                            */
-  fwrite(&packet_header, sizeof(pcaprec_hdr_t), 1, file_fd);
-  fwrite(context_header, 1, offset, file_fd);
-  fwrite(PDU, 1, length, file_fd);
-  return 1;
-}
-
 #include <common/ran_context.h>
 extern RAN_CONTEXT_t RC;
 #include <openair1/PHY/phy_extern_ue.h>
@@ -389,7 +416,6 @@ extern RAN_CONTEXT_t RC;
 void trace_pdu_implementation(int direction, uint8_t *pdu_buffer, unsigned int pdu_buffer_size,
                               int ueid, int rntiType, int rnti, uint16_t sysFrameNumber, uint8_t subFrameNumber, int oob_event,
                               int oob_event_value) {
-  MAC_Context_Info_t pdu_context;
   int radioType=FDD_RADIO;
   LOG_D(OPT,"sending packet to wireshark: direction=%s, size: %d, ueid: %d, rnti: %x, frame/sf: %d.%d\n",
         direction?"DL":"UL", pdu_buffer_size, ueid, rnti, sysFrameNumber,subFrameNumber);
@@ -405,53 +431,41 @@ void trace_pdu_implementation(int direction, uint8_t *pdu_buffer, unsigned int p
 
   switch (opt_type) {
     case OPT_WIRESHARK :
-      if (g_socksd == -1) {
+      if (g_socksd == -1)
         return;
-      }
 
-      SendFrame( radioType,
-                 (direction == DIRECTION_DOWNLINK) ? DIRECTION_DOWNLINK : DIRECTION_UPLINK,
-                 rntiType, rnti, ueid, (sysFrameNumber<<4) + subFrameNumber,
-                 1, 0, 1,  //guint8 isPredefinedData, guint8 retx, guint8 crcStatus
-                 oob_event,oob_event_value,
-                 pdu_buffer, pdu_buffer_size);
       break;
 
     case OPT_PCAP:
-      if (file_fd == NULL) {
+      if (file_fd == NULL)
         return;
-      }
 
-      pdu_context.radioType =  radioType;
-      pdu_context.direction = (direction == DIRECTION_DOWNLINK) ? DIRECTION_DOWNLINK
-                              : DIRECTION_UPLINK;
-      pdu_context.rntiType = rntiType;
-      pdu_context.rnti = rnti;
-      pdu_context.ueid = ueid;
-      pdu_context.isRetx = 0;
-      pdu_context.crcStatusOK =1;
-      pdu_context.sysFrameNumber = sysFrameNumber;
-      pdu_context.subFrameNumber = subFrameNumber;
-      pdu_context.subframesSinceCaptureStart = subframesSinceCaptureStart++;
-      MAC_LTE_PCAP_WritePDU( &pdu_context, pdu_buffer, pdu_buffer_size);
       break;
 
     case OPT_TSHARK:
     default:
+      return;
       break;
   }
+
+  SendFrame( radioType,
+             (direction == DIRECTION_DOWNLINK) ? DIRECTION_DOWNLINK : DIRECTION_UPLINK,
+             rntiType, rnti, ueid, (sysFrameNumber<<4) + subFrameNumber,
+             1, 0, 1,  //guint8 isPredefinedData, guint8 retx, guint8 crcStatus
+             oob_event,oob_event_value,
+             pdu_buffer, pdu_buffer_size);
 }
+
 /*---------------------------------------------------*/
-int init_opt(void)
+int init_opt(void) { 
-{
+  in_type=malloc(200);
-  char *in_type=NULL;
+  in_ip=malloc(200);
+  in_path=malloc(200);
   paramdef_t opt_params[]          = OPT_PARAMS_DESC ;
   checkedparam_t opt_checkParams[] = OPTPARAMS_CHECK_DESC;
-  uint16_t in_port=0;
   config_set_checkfunctions(opt_params, opt_checkParams,
                             sizeof(opt_params)/sizeof(paramdef_t));
   config_get( opt_params,sizeof(opt_params)/sizeof(paramdef_t),OPT_CONFIGPREFIX);
-
   subframesSinceCaptureStart = 0;
   int tmptype = config_get_processedint( &(opt_params[OPTTYPE_IDX]));
 
@@ -462,25 +476,21 @@ int init_opt(void)
   } else if (tmptype == OPT_PCAP && strlen(in_path) > 0) {
     opt_type = OPT_PCAP;
     opt_enabled=1;
-    LOG_I(OPT,"Enabling OPT for PCAP  with the following file %s \n",in_path);
   } else if (tmptype == OPT_WIRESHARK && strlen(in_ip) > 0) {
     opt_enabled=1;
     opt_type = OPT_WIRESHARK;
-    LOG_I(OPT,"Enabling OPT for wireshark for local interface %s\n",in_ip);
   } else {
     LOG_E(OPT,"Invalid OPT configuration\n");
     config_printhelp(opt_params,sizeof(opt_params)/sizeof(paramdef_t),OPT_CONFIGPREFIX);
   }
 
-  in_port = PACKET_MAC_LTE_DEFAULT_UDP_PORT;
-
   // trace_mode
   switch (opt_type) {
     case OPT_WIRESHARK:
-
+      LOG_I(OPT,"mode Wireshark: ip %s port %d\n", in_ip, PACKET_MAC_LTE_DEFAULT_UDP_PORT);
       /* Create local server socket only if using localhost address */
-      if (strcmp(in_ip, "127.0.0.1") == 0) {
+      if (strncmp(in_ip, "127.0.0.1", 4) == 0) {
-        opt_create_listener_socket(in_ip, in_port);
+        opt_create_listener_socket(in_ip, PACKET_MAC_LTE_DEFAULT_UDP_PORT);
       }
 
       g_socksd = socket(AF_INET, SOCK_DGRAM, 0);
@@ -493,11 +503,12 @@ int init_opt(void)
 
       /* Get remote IP address from the function argument */
       g_serv_addr.sin_family = AF_INET;
-      g_serv_addr.sin_port = htons(in_port);
+      g_serv_addr.sin_port = htons(PACKET_MAC_LTE_DEFAULT_UDP_PORT);
       g_serv_addr.sin_addr.s_addr = inet_addr(in_ip);
       break;
 
     case OPT_PCAP:
+      LOG_I(OPT,"mode PCAB : path is %s \n",in_path);
       file_fd = fopen(in_path, "w");
 
       if (file_fd == NULL) {
@@ -516,19 +527,9 @@ int init_opt(void)
 
     default:
       opt_type = OPT_NONE;
-      LOG_W(OPT, "supported Option\n");
+       LOG_E(OPT,"Unsupported or unknown mode %d \n", opt_type);
       break;
   }
-
-  if ( opt_type == OPT_WIRESHARK )
-    LOG_E(OPT,"mode Wireshark: ip %s port %d\n", in_ip, in_port);
-  else if (opt_type == OPT_PCAP)
-    LOG_E(OPT,"mode PCAB : path is %s \n",in_path);
-  else
-    LOG_E(OPT,"Unsupported or unknown mode %d \n", opt_type);
-
-  //  mac_info = (mac_info*)malloc16(sizeof(mac_lte_info));
-  // memset(mac_info, 0, sizeof(mac_lte_info)+pdu_buffer_size + 8);
   return (1);
 }
 

openair3/NAS/COMMON/NR_NAS_defs.h

@@ -0,0 +1,391 @@
+/*
+ * 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
+ *
+ * Author and copyright: Laurent Thomas, open-cells.com
+ *
+ * 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 NR_NAS_DEFS_H
+#define NR_NAS_DEFS_H
+
+#include <common/utils/LOG/log.h>
+#include <openair3/UICC/usim_interface.h>
+#include <openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h>
+
+/* TS 24.007 possible L3 formats:
+   Table 11.1: Formats of information elements
+   Format Meaning IEI present LI present Value part present
+   T Type only yes no no
+   V Value only no no yes
+   TV Type and Value yes no yes
+   LV Length and Value no yes yes
+   TLV Type, Length and Value yes yes yes
+   LV-E Length and Value no yes yes
+   TLV-E Type, Length and Value yes yes yes
+*/
+
+/* Map task id to printable name. */
+typedef struct {
+  int id;
+  char text[256];
+} text_info_t;
+
+static inline const char * idToText(const text_info_t* table, int size, int id) {
+  for(int i=0; i<size; i++)
+    if (table[i].id==id)
+      return table[i].text;
+  LOG_E(NAS,"impossible id %x\n", id);
+  return "IMPOSSIBLE";
+}
+#define idStr(TaBle, iD) idToText(TaBle, sizeof(TaBle)/sizeof(text_info_t), iD)
+
+#define TO_TEXT(LabEl, nUmID) {nUmID, #LabEl},
+#define TO_ENUM(LabEl, nUmID ) LabEl = nUmID,
+
+//TS 24.501, chap 9.2 => TS 24.007
+typedef enum {
+  SGSsessionmanagementmessages=0x2e, //LTEbox: 0xC0 ???
+  SGSmobilitymanagementmessages=0x7e,
+} Extendedprotocoldiscriminator_t;
+
+#define FOREACH_TYPE(TYPE_DEF) \
+  TYPE_DEF(  Registrationrequest,0x41 )\
+TYPE_DEF(  Registrationaccept,0x42 )\
+TYPE_DEF(  Registrationcomplete,0x43 )\
+TYPE_DEF(  Registrationreject,0x44 )\
+TYPE_DEF(  DeregistrationrequestUEoriginating,0x45 )\
+TYPE_DEF(  DeregistrationacceptUEoriginating,0x46 )\
+TYPE_DEF(  DeregistrationrequestUEterminated,0x47 )\
+TYPE_DEF(  DeregistrationacceptUEterminated,0x48 )\
+TYPE_DEF(  Servicerequest,0x4c )\
+TYPE_DEF(  Servicereject,0x4d )\
+TYPE_DEF(  Serviceaccept,0x4e )\
+TYPE_DEF(  Controlplaneservicerequest,0x4f )\
+TYPE_DEF(  Networkslicespecificauthenticationcommand,0x50 )\
+TYPE_DEF(  Networkslicespecificauthenticationcomplete,0x51 )\
+TYPE_DEF(  Networkslicespecificauthenticationresult,0x52 )\
+TYPE_DEF(  Configurationupdatecommand,0x54 )\
+TYPE_DEF(  Configurationupdatecomplete,0x55 )\
+TYPE_DEF(  Authenticationrequest,0x56 )\
+TYPE_DEF(  Authenticationresponse,0x57 )\
+TYPE_DEF(  Authenticationreject,0x58 )\
+TYPE_DEF(  Authenticationfailure,0x59 )\
+TYPE_DEF(  Authenticationresult,0x5a )\
+TYPE_DEF(  Identityrequest,0x5b )\
+TYPE_DEF(  Identityresponse,0x5c )\
+TYPE_DEF(  Securitymodecommand,0x5d )\
+TYPE_DEF(  Securitymodecomplete,0x5e )\
+TYPE_DEF(  Securitymodereject,0x5f )\
+TYPE_DEF(  SGMMstatus,0x64 )\
+TYPE_DEF(  Notification,0x65 )\
+TYPE_DEF(  Notificationresponse,0x66 )\
+TYPE_DEF(  ULNAStransport,0x67 )\
+TYPE_DEF(  DLNAStransport,0x68 )\
+TYPE_DEF(  PDUsessionestablishmentrequest,0xc1 )\
+TYPE_DEF(  PDUsessionestablishmentaccept,0xc2 )\
+TYPE_DEF(  PDUsessionestablishmentreject,0xc3 )\
+TYPE_DEF(  PDUsessionauthenticationcommand,0xc5 )\
+TYPE_DEF(  PDUsessionauthenticationcomplete,0xc6 )\
+TYPE_DEF(  PDUsessionauthenticationresult,0xc7 )\
+TYPE_DEF(  PDUsessionmodificationrequest,0xc9 )\
+TYPE_DEF(  PDUsessionmodificationreject,0xca )\
+TYPE_DEF(  PDUsessionmodificationcommand,0xcb )\
+TYPE_DEF(  PDUsessionmodificationcomplete,0xcc )\
+TYPE_DEF(  PDUsessionmodificationcommandreject,0xcd )\
+TYPE_DEF(  PDUsessionreleaserequest,0xd1 )\
+TYPE_DEF(  PDUsessionreleasereject,0xd2 )\
+TYPE_DEF(  PDUsessionreleasecommand,0xd3 )\
+TYPE_DEF(  PDUsessionreleasecomplete,0xd4 )\
+TYPE_DEF(  SGSMstatus,0xd6 )\
+
+static const text_info_t message_text_info[] = {
+  FOREACH_TYPE(TO_TEXT)
+};
+
+//! Tasks id of each task
+typedef enum {
+  FOREACH_TYPE(TO_ENUM)
+} SGSmobilitymanagementmessages_t;
+
+// TS 24.501
+typedef enum {
+  notsecurityprotected=0,
+  Integrityprotected=1,
+  Integrityprotectedandciphered=2,
+  Integrityprotectedwithnew5GNASsecuritycontext=3,
+  Integrityprotectedandcipheredwithnew5GNASsecuritycontext=4,
+} Security_header_t;
+
+typedef enum {
+  SUCI=1,
+  SGGUTI,
+  IMEI,
+  SGSTMSI,
+  IMEISV,
+  MACaddress,
+  EUI64,
+} identitytype_t;
+
+
+// table  9.11.3.2.1
+#define FOREACH_CAUSE(CAUSE_DEF) \
+  CAUSE_DEF(Illegal_UE,0x3 )\
+  CAUSE_DEF(PEI_not_accepted,0x5 )\
+  CAUSE_DEF(Illegal_ME,0x6 )\
+  CAUSE_DEF(SGS_services_not_allowed,0x7 )\
+  CAUSE_DEF(UE_identity_cannot_be_derived_by_the_network,0x9 )\
+  CAUSE_DEF(Implicitly_de_registered,0x0a )\
+  CAUSE_DEF(PLMN_not_allowed,0x0b )\
+  CAUSE_DEF(Tracking_area_not_allowed,0x0c )\
+  CAUSE_DEF(Roaming_not_allowed_in_this_tracking_area,0x0d )\
+  CAUSE_DEF(No_suitable_cells_in_tracking_area,0x0f )\
+  CAUSE_DEF(MAC_failure,0x14 )\
+  CAUSE_DEF(Synch_failure,0x15 )\
+  CAUSE_DEF(Congestion,0x16 )\
+  CAUSE_DEF(UE_security_capabilities_mismatch,0x17 )\
+  CAUSE_DEF(Security_mode_rejected_unspecified,0x18 )\
+  CAUSE_DEF(Non_5G_authentication_unacceptable,0x1a )\
+  CAUSE_DEF(N1_mode_not_allowed,0x1b )\
+  CAUSE_DEF(Restricted_service_area,0x1c )\
+  CAUSE_DEF(Redirection_to_EPC_required,0x1f )\
+  CAUSE_DEF(LADN_not_available,0x2b )\
+  CAUSE_DEF(No_network_slices_available,0x3e )\
+  CAUSE_DEF(Maximum_number_of_PDU_sessions_reached,0x41 )\
+  CAUSE_DEF(Insufficient_resources_for_specific_slice_and_DNN,0x43 )\
+  CAUSE_DEF(Insufficient_resources_for_specific_slice,0x45 )\
+  CAUSE_DEF(ngKSI_already_in_use,0x47 )\
+  CAUSE_DEF(Non_3GPP_access_to_5GCN_not_allowed,0x48 )\
+  CAUSE_DEF(Serving_network_not_authorized,0x49 )\
+  CAUSE_DEF(Temporarily_not_authorized_for_this_SNPN,0x4A )\
+  CAUSE_DEF(Permanently_not_authorized_for_this_SNPN,0x4b )\
+  CAUSE_DEF(Not_authorized_for_this_CAG_or_authorized_for_CAG_cells_only,0x4c )\
+  CAUSE_DEF(Wireline_access_area_not_allowed,0x4d )\
+  CAUSE_DEF(Payload_was_not_forwarded,0x5a )\
+  CAUSE_DEF(DNN_not_supported_or_not_subscribed_in_the_slice,0x5b )\
+  CAUSE_DEF(Insufficient_user_plane_resources_for_the_PDU_session,0x5c )\
+  CAUSE_DEF(Semantically_incorrect_message,0x5f )\
+  CAUSE_DEF(Invalid_mandatory_information,0x60 )\
+  CAUSE_DEF(Message_type_non_existent_or_not_implemented,0x61 )\
+  CAUSE_DEF(Message_type_not_compatible_with_the_protocol_state,0x62 )\
+  CAUSE_DEF(Information_element_non_existent_or_not_implemented,0x63 )\
+  CAUSE_DEF(Conditional_IE_error,0x64 )\
+  CAUSE_DEF(Message_not_compatible_with_the_protocol_state,0x65 )\
+  CAUSE_DEF(Protocol_error_unspecified,0x67 )
+
+/* Map task id to printable name. */
+
+#define CAUSE_TEXT(LabEl, nUmID) {nUmID, #LabEl},
+
+static const text_info_t cause_text_info[] = {
+  FOREACH_CAUSE(TO_TEXT)
+};
+
+#define CAUSE_ENUM(LabEl, nUmID ) LabEl = nUmID,
+//! Tasks id of each task
+typedef enum {
+  FOREACH_CAUSE(TO_ENUM)
+} cause_id_t;
+
+//_table_9.11.4.2.1:_5GSM_cause_information_element
+#define FOREACH_CAUSE_SECU(CAUSE_SECU_DEF) \
+  CAUSE_SECU_DEF(Security_Operator_determined_barring,0x08 )\
+  CAUSE_SECU_DEF(Security_Insufficient_resources,0x1a )\
+  CAUSE_SECU_DEF(Security_Missing_or_unknown_DNN,0x1b )\
+  CAUSE_SECU_DEF(Security_Unknown_PDU_session_type,0x1c )\
+  CAUSE_SECU_DEF(Security_User_authentication_or_authorization_failed,0x1d )\
+  CAUSE_SECU_DEF(Security_Request_rejected_unspecified,0x1f )\
+  CAUSE_SECU_DEF(Security_Service_option_not_supported,0x20 )\
+  CAUSE_SECU_DEF(Security_Requested_service_option_not_subscribed,0x21 )\
+  CAUSE_SECU_DEF(Security_Service_option_temporarily_out_of_order,0x22 )\
+  CAUSE_SECU_DEF(Security_PTI_already_in_use,0x23 )\
+  CAUSE_SECU_DEF(Security_Regular_deactivation,0x24 )\
+  CAUSE_SECU_DEF(Security_Network_failure,0x26 )\
+  CAUSE_SECU_DEF(Security_Reactivation_requested,0x27 )\
+  CAUSE_SECU_DEF(Security_Semantic_error_in_the_TFT_operation,0x29 )\
+  CAUSE_SECU_DEF(Security_Syntactical_error_in_the_TFT_operation,0x2a )\
+  CAUSE_SECU_DEF(Security_Invalid_PDU_session_identity,0x2b )\
+  CAUSE_SECU_DEF(Security_Semantic_errors_in_packet_filter,0x2c )\
+  CAUSE_SECU_DEF(Security_Syntactical_error_in_packet_filter,0x2d )\
+  CAUSE_SECU_DEF(Security_Out_of_LADN_service_area,0x2e )\
+  CAUSE_SECU_DEF(Security_PTI_mismatch,0x2f )\
+  CAUSE_SECU_DEF(Security_PDU_session_type_IPv4_only_allowed,0x32 )\
+  CAUSE_SECU_DEF(Security_PDU_session_type_IPv6_only_allowed,0x33 )\
+  CAUSE_SECU_DEF(Security_PDU_session_does_not_exist,0x36 )\
+  CAUSE_SECU_DEF(Security_PDU_session_type_IPv4v6_only_allowed,0x39 )\
+  CAUSE_SECU_DEF(Security_PDU_session_type_Unstructured_only_allowed,0x3a )\
+  CAUSE_SECU_DEF(Security_PDU_session_type_Ethernet_only_allowed,0x3d )\
+  CAUSE_SECU_DEF(Security_Insufficient_resources_for_specific_slice_and_DNN,0x43 )\
+  CAUSE_SECU_DEF(Security_Not_supported_SSC_mode,0x44 )\
+  CAUSE_SECU_DEF(Security_Insufficient_resources_for_specific_slice,0x45 )\
+  CAUSE_SECU_DEF(Security_Missing_or_unknown_DNN_in_a_slice,0x46 )\
+  CAUSE_SECU_DEF(Security_Invalid_PTI_value,0x51 )\
+  CAUSE_SECU_DEF(Security_Maximum_data_rate_per_UE_for_user_plane_integrity_protection_is_too_low,0x52 )\
+  CAUSE_SECU_DEF(Security_Semantic_error_in_the_QoS_operation,0x53 )\
+  CAUSE_SECU_DEF(Security_Syntactical_error_in_the_QoS_operation,0x54 )\
+  CAUSE_SECU_DEF(Security_Invalid_mapped_EPS_bearer_identity,0x55 )\
+  CAUSE_SECU_DEF(Security_Semantically_incorrect_message,0x5f )\
+  CAUSE_SECU_DEF(Security_Invalid_mandatory_information,0x60 )\
+  CAUSE_SECU_DEF(Security_Message_type_non_existent_or_not_implemented,0x61 )\
+  CAUSE_SECU_DEF(Security_Message_type_not_compatible_with_the_protocol_state,0x62 )\
+  CAUSE_SECU_DEF(Security_Information_element_non_existent_or_not_implemented,0x63 )\
+  CAUSE_SECU_DEF(Security_Conditional_IE_error,0x64 )\
+  CAUSE_SECU_DEF(Security_Message_not_compatible_with_the_protocol_state,0x65 )\
+  CAUSE_SECU_DEF(Security_Protocol_error_unspecified,0x6f )
+
+static const text_info_t cause_secu_text_info[] = {
+  FOREACH_CAUSE_SECU(TO_TEXT)
+};
+								
+//! Tasks id of each task
+typedef enum {
+  FOREACH_CAUSE_SECU(TO_ENUM)
+} cause_secu_id_t;
+								
+// IEI (information element identifier) are spread in each message definition
+#define IEI_RAND 0x21
+#define IEI_AUTN 0x20
+#define IEI_EAP  0x78
+#define IEI_AuthenticationResponse 0x2d
+
+//TS 24.501 sub layer states for UE
+// for network side, only 5GMMderegistered, 5GMMderegistered_initiated, 5GMMregistered,  5GMMservice_request_initiated are valid
+typedef enum {
+  SGMMnull,
+  SGMMderegistered,
+  SGMMderegistered_initiated,
+  SGMMregistered,
+  SGMMregistered_initiated,
+  SGMMservice_request_initiated,
+} SGMM_UE_states;
+
+typedef struct {
+  Extendedprotocoldiscriminator_t epd:8;
+  Security_header_t sh:8;
+  SGSmobilitymanagementmessages_t mt:8;
+} SGScommonHeader_t;
+
+typedef struct {
+  Extendedprotocoldiscriminator_t epd:8;
+  Security_header_t sh:8;
+  SGSmobilitymanagementmessages_t mt:8;
+  identitytype_t it:8;
+} Identityrequest_t;
+
+// the message continues with the identity value, depending on identity type, see TS 14.501, 9.11.3.4
+typedef struct __attribute__((packed)) {
+  Extendedprotocoldiscriminator_t epd:8;
+  Security_header_t sh:8;
+  SGSmobilitymanagementmessages_t mt:8;
+  uint16_t len;
+}
+Identityresponse_t;
+
+typedef struct __attribute__((packed)) {
+  Identityresponse_t common;
+  identitytype_t mi:8;
+  unsigned int supiFormat:4;
+  unsigned int identityType:4;
+  unsigned int mcc1:4;
+  unsigned int mcc2:4;
+  unsigned int mcc3:4;
+  unsigned int mnc3:4;
+  unsigned int mnc1:4;
+  unsigned int mnc2:4;
+  unsigned int routing1:4;
+  unsigned int routing2:4;
+  unsigned int routing3:4;
+  unsigned int routing4:4;
+  unsigned int protectScheme:4;
+  unsigned int spare:4;
+  uint8_t hplmnId;
+}
+IdentityresponseIMSI_t;
+
+typedef struct  __attribute__((packed)) {
+  Extendedprotocoldiscriminator_t epd:8;
+  Security_header_t sh:8;
+  SGSmobilitymanagementmessages_t mt:8;
+  unsigned int ngKSI:4;
+  unsigned int spare:4;
+  unsigned int ABBALen:8;
+  unsigned int ABBA:16;
+  uint8_t ieiRAND;
+  uint8_t RAND[16];
+  uint8_t ieiAUTN;
+  uint8_t AUTNlen;
+  uint8_t AUTN[16];
+}
+authenticationrequestHeader_t;
+
+typedef struct  __attribute__((packed)) {
+  Extendedprotocoldiscriminator_t epd:8;
+  Security_header_t sh:8;
+  SGSmobilitymanagementmessages_t mt:8;
+  uint8_t iei;
+  uint8_t RESlen;
+  uint8_t RES[16];
+} authenticationresponse_t;
+
+//AUTHENTICATION RESULT
+
+typedef struct  __attribute__((packed)) {
+  Extendedprotocoldiscriminator_t epd:8;
+  Security_header_t sh:8;
+  SGSmobilitymanagementmessages_t mt:8;
+
+  unsigned int selectedNASsecurityalgorithms;
+  unsigned int ngKSI:4; //ngKSI NAS key set identifier 9.11.3.32
+  unsigned int spare:4;
+  // LV 3-9 bytes Replayed UE security capabilities UE security capability 9.11.3.54
+  
+  /* optional
+     TV (E-, 1 byte) Oprional IMEISV request IMEISV request 9.11.3.28
+     TV (57, 2 bytes ) Selected EPS NAS security algorithms  EPS NAS security algorithms 9.11.3.25
+     TLV (36, 3 bytes) Additional 5G security information Additional 5G security information 9.11.3.12
+     TLV-E (78,, 7-1503 bytes) EAP message EAP message 9.11.2.2
+     TLV (38, 4-n)ABBA ABBA 9.11.3.10
+     TLV (19, 4-7) Replayed S1 UE security capabilities S1 UE security capability 9.11.3.48A
+  */
+
+} securityModeCommand_t;
+
+typedef struct {
+  uicc_t *uicc;
+} nr_user_nas_t;
+
+#define STATIC_ASSERT(test_for_true) _Static_assert((test_for_true), "(" #test_for_true ") failed")
+#define myCalloc(var, type) type * var=(type*)calloc(sizeof(type),1);
+#define arrayCpy(tO, FroM)  STATIC_ASSERT(sizeof(tO) == sizeof(FroM)) ; memcpy(tO, FroM, sizeof(tO))
+int resToresStar(uint8_t *msg, uicc_t* uicc);
+
+int identityResponse(void **msg, nr_user_nas_t *UE);
+int authenticationResponse(void **msg, nr_user_nas_t *UE);
+void UEprocessNAS(void *msg,nr_user_nas_t *UE);
+void SGSabortUE(void *msg, NRUEcontext_t *UE) ;
+void SGSregistrationReq(void *msg, NRUEcontext_t *UE);
+void SGSderegistrationUEReq(void *msg, NRUEcontext_t *UE);
+void SGSauthenticationResp(void *msg, NRUEcontext_t *UE);
+void SGSidentityResp(void *msg, NRUEcontext_t *UE);
+void SGSsecurityModeComplete(void *msg, NRUEcontext_t *UE);
+void SGSregistrationComplete(void *msg, NRUEcontext_t *UE);
+void processNAS(void *msg, NRUEcontext_t *UE);
+int identityRequest(void **msg, NRUEcontext_t *UE);
+int authenticationRequest(void **msg, NRUEcontext_t *UE);
+int securityModeCommand(void **msg, NRUEcontext_t *UE);
+
+#endif

openair3/NAS/COMMON/milenage.h

@@ -0,0 +1,355 @@
+/*
+   Adaptatipn of SW from hereafter license
+   Author: laurent.thomas@open-cells.com
+   The OpenAirInterface project uses this copy under the terms of BSD
+   license.
+*/
+/*
+   3GPP AKA - Milenage algorithm (3GPP TS 35.205, .206, .207, .208)
+   Copyright (c) 2006-2007 <j@w1.fi>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License version 2 as
+   published by the Free Software Foundation.
+
+   Alternatively, this software may be distributed under the terms of BSD
+   license.
+
+   See README and COPYING for more details.
+
+   This file implements an example authentication algorithm defined for 3GPP
+   AKA. This can be used to implement a simple HLR/AuC into hlr_auc_gw to allow
+   EAP-AKA to be tested properly with real USIM cards.
+
+   This implementations assumes that the r1..r5 and c1..c5 constants defined in
+   TS 35.206 are used, i.e., r1=64, r2=0, r3=32, r4=64, r5=96, c1=00..00,
+   c2=00..01, c3=00..02, c4=00..04, c5=00..08. The block cipher is assumed to
+   be AES (Rijndael).
+*/
+
+#ifndef MILENAGE_H
+#define MILENAGE_H
+#include <openssl/aes.h>
+
+
+#define u8 uint8_t
+/**
+   milenage_f1 - Milenage f1 and f1* algorithms
+   @opc: OPc = 128-bit value derived from OP and K
+   @k: K = 128-bit subscriber key
+   @_rand: RAND = 128-bit random challenge
+   @sqn: SQN = 48-bit sequence number
+   @amf: AMF = 16-bit authentication management field
+   @mac_a: Buffer for MAC-A = 64-bit network authentication code, or %NULL
+   @mac_s: Buffer for MAC-S = 64-bit resync authentication code, or %NULL
+   Returns: true on success, false on failure
+*/
+
+void aes_128_encrypt_block(const u8* key, const u8* in, u8* out) {
+   AES_KEY k;
+  u8 tmp[16];
+  AES_set_encrypt_key(key, 128, &k);
+  AES_encrypt(in, tmp, &k); 
+  memcpy(out, tmp, sizeof(tmp));
+}
+static bool milenage_f1(const u8 *opc, const u8 *k, const u8 *_rand,
+                 const u8 *sqn, const u8 *amf, u8 *mac_a, u8 *mac_s) {
+  u8 tmp1[16], tmp2[16], tmp3[16];
+  int i;
+
+  /* tmp1 = TEMP = E_K(RAND XOR OP_C) */
+  for (i = 0; i < 16; i++)
+    tmp1[i] = _rand[i] ^ opc[i];
+
+  aes_128_encrypt_block(k, tmp1, tmp1);
+  AES_KEY kTab;
+  uint8_t cyphered[16];
+  AES_set_encrypt_key(k, 128, &kTab);
+  AES_encrypt(tmp1, cyphered, &kTab);
+  /* tmp2 = IN1 = SQN || AMF || SQN || AMF */
+  memcpy(tmp2, sqn, 6);
+  memcpy(tmp2 + 6, amf, 2);
+  memcpy(tmp2 + 8, tmp2, 8);
+
+  /* OUT1 = E_K(TEMP XOR rot(IN1 XOR OP_C, r1) XOR c1) XOR OP_C */
+
+  /* rotate (tmp2 XOR OP_C) by r1 (= 0x40 = 8 bytes) */
+  for (i = 0; i < 16; i++)
+    tmp3[(i + 8) % 16] = tmp2[i] ^ opc[i];
+
+  /* XOR with TEMP = E_K(RAND XOR OP_C) */
+  for (i = 0; i < 16; i++)
+    tmp3[i] ^= tmp1[i];
+
+  /* XOR with c1 (= ..00, i.e., NOP) */
+  /* f1 || f1* = E_K(tmp3) XOR OP_c */
+  aes_128_encrypt_block(k, tmp3, tmp1);
+
+  for (i = 0; i < 16; i++)
+    tmp1[i] ^= opc[i];
+
+  if (mac_a)
+    memcpy(mac_a, tmp1, 8); /* f1 */
+
+  if (mac_s)
+    memcpy(mac_s, tmp1 + 8, 8); /* f1* */
+
+  return true;
+}
+
+
+/**
+   milenage_f2345 - Milenage f2, f3, f4, f5, f5* algorithms
+   @opc: OPc = 128-bit value derived from OP and K
+   @k: K = 128-bit subscriber key
+   @_rand: RAND = 128-bit random challenge
+   @res: Buffer for RES = 64-bit signed response (f2), or %NULL
+   @ck: Buffer for CK = 128-bit confidentiality key (f3), or %NULL
+   @ik: Buffer for IK = 128-bit integrity key (f4), or %NULL
+   @ak: Buffer for AK = 48-bit anonymity key (f5), or %NULL
+   @akstar: Buffer for AK = 48-bit anonymity key (f5*), or %NULL
+   Returns: true on success, false on failure
+*/
+static bool milenage_f2345(const u8 *opc, const u8 *k, const u8 *_rand,
+                    u8 *res, u8 *ck, u8 *ik, u8 *ak, u8 *akstar) {
+  u8 tmp1[16], tmp2[16], tmp3[16];
+  int i;
+
+  /* tmp2 = TEMP = E_K(RAND XOR OP_C) */
+  for (i = 0; i < 16; i++)
+    tmp1[i] = _rand[i] ^ opc[i];
+
+  aes_128_encrypt_block(k, tmp1, tmp2);
+
+  /* OUT2 = E_K(rot(TEMP XOR OP_C, r2) XOR c2) XOR OP_C */
+  /* OUT3 = E_K(rot(TEMP XOR OP_C, r3) XOR c3) XOR OP_C */
+  /* OUT4 = E_K(rot(TEMP XOR OP_C, r4) XOR c4) XOR OP_C */
+  /* OUT5 = E_K(rot(TEMP XOR OP_C, r5) XOR c5) XOR OP_C */
+
+  /* f2 and f5 */
+  /* rotate by r2 (= 0, i.e., NOP) */
+  for (i = 0; i < 16; i++)
+    tmp1[i] = tmp2[i] ^ opc[i];
+
+  tmp1[15] ^= 1; /* XOR c2 (= ..01) */
+  /* f5 || f2 = E_K(tmp1) XOR OP_c */
+  aes_128_encrypt_block(k, tmp1, tmp3);
+
+  for (i = 0; i < 16; i++)
+    tmp3[i] ^= opc[i];
+
+  if (res)
+    memcpy(res, tmp3 + 8, 8); /* f2 */
+
+  if (ak)
+    memcpy(ak, tmp3, 6); /* f5 */
+
+  /* f3 */
+  if (ck) {
+    /* rotate by r3 = 0x20 = 4 bytes */
+    for (i = 0; i < 16; i++)
+      tmp1[(i + 12) % 16] = tmp2[i] ^ opc[i];
+
+    tmp1[15] ^= 2; /* XOR c3 (= ..02) */
+    aes_128_encrypt_block(k, tmp1, ck);
+
+    for (i = 0; i < 16; i++)
+      ck[i] ^= opc[i];
+  }
+
+  /* f4 */
+  if (ik) {
+    /* rotate by r4 = 0x40 = 8 bytes */
+    for (i = 0; i < 16; i++)
+      tmp1[(i + 8) % 16] = tmp2[i] ^ opc[i];
+
+    tmp1[15] ^= 4; /* XOR c4 (= ..04) */
+    aes_128_encrypt_block(k, tmp1, ik);
+
+    for (i = 0; i < 16; i++)
+      ik[i] ^= opc[i];
+  }
+
+  /* f5* */
+  if (akstar) {
+    /* rotate by r5 = 0x60 = 12 bytes */
+    for (i = 0; i < 16; i++)
+      tmp1[(i + 4) % 16] = tmp2[i] ^ opc[i];
+
+    tmp1[15] ^= 8; /* XOR c5 (= ..08) */
+    aes_128_encrypt_block(k, tmp1, tmp1);
+
+    for (i = 0; i < 6; i++)
+      akstar[i] = tmp1[i] ^ opc[i];
+  }
+
+  return true;
+}
+
+
+/**
+   milenage_generate - Generate AKA AUTN,IK,CK,RES
+   @opc: OPc = 128-bit operator variant algorithm configuration field (encr.)
+   @amf: AMF = 16-bit authentication management field
+   @k: K = 128-bit subscriber key
+   @sqn: SQN = 48-bit sequence number
+   @_rand: RAND = 128-bit random challenge
+   @autn: Buffer for AUTN = 128-bit authentication token
+   @ik: Buffer for IK = 128-bit integrity key (f4), or %NULL
+   @ck: Buffer for CK = 128-bit confidentiality key (f3), or %NULL
+   @res: Buffer for RES = 64-bit signed response (f2), or %NULL
+   @res_len: Max length for res; set to used length or 0 on failure
+*/
+static bool milenage_generate(const u8 *opc, const u8 *amf, const u8 *k,
+                       const u8 *sqn, const u8 *_rand, u8 *autn, u8 *ik,
+                       u8 *ck, u8 *res) {
+  int i;
+  u8 mac_a[8], ak[6];
+
+  if (!milenage_f1(opc, k, _rand, sqn, amf, mac_a, NULL) ||
+      !milenage_f2345(opc, k, _rand, res, ck, ik, ak, NULL))
+    return false;
+
+  /* AUTN = (SQN ^ AK) || AMF || MAC */
+  for (i = 0; i < 6; i++)
+    autn[i] = sqn[i] ^ ak[i];
+
+  memcpy(autn + 6, amf, 2);
+  memcpy(autn + 8, mac_a, 8);
+  return true;
+}
+
+
+/**
+   milenage_auts - Milenage AUTS validation
+   @opc: OPc = 128-bit operator variant algorithm configuration field (encr.)
+   @k: K = 128-bit subscriber key
+   @_rand: RAND = 128-bit random challenge
+   @auts: AUTS = 112-bit authentication token from client
+   @sqn: Buffer for SQN = 48-bit sequence number
+   Returns: 0 = success (sqn filled), -1 on failure
+*/
+#define p(a) printf("%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n", (int)((a)[0]), (int)((a)[1]), (int)((a)[2]), (int)((a)[3]),(int)((a)[4]), (int)((a)[5]));
+// valid code but put in comment as it is not used right now
+#if 0
+static bool milenage_auts(const u8 *opc, const u8 *k, const u8 *_rand, const u8 *auts,
+                   u8 *sqn) {
+  u8 amf[2] = { 0x00, 0x00 }; /* TS 33.102 v7.0.0, 6.3.3 */
+  u8 ak[6], mac_s[8];
+  int i;
+
+  if (!milenage_f2345(opc, k, _rand, NULL, NULL, NULL, NULL, ak))
+    return false;
+
+  for (i = 0; i < 6; i++)
+    sqn[i] = auts[i] ^ ak[i];
+
+  //p(sqn);
+  if (!milenage_f1(opc, k, _rand, sqn, amf, NULL, mac_s) ||
+      memcmp(mac_s, auts + 6, 8) != 0)
+    return false;
+
+  return true;
+}
+
+
+/**
+   gsm_milenage - Generate GSM-Milenage (3GPP TS 55.205) authentication triplet
+   @opc: OPc = 128-bit operator variant algorithm configuration field (encr.)
+   @k: K = 128-bit subscriber key
+   @_rand: RAND = 128-bit random challenge
+   @sres: Buffer for SRES = 32-bit SRES
+   @kc: Buffer for Kc = 64-bit Kc
+   Returns: 0 on success, -1 on failure
+*/
+static bool gsm_milenage(const u8 *opc, const u8 *k, const u8 *_rand, u8 *sres, u8 *kc) {
+  u8 res[8], ck[16], ik[16];
+  int i;
+
+  if (milenage_f2345(opc, k, _rand, res, ck, ik, NULL, NULL))
+    return false;
+
+  for (i = 0; i < 8; i++)
+    kc[i] = ck[i] ^ ck[i + 8] ^ ik[i] ^ ik[i + 8];
+
+#ifdef GSM_MILENAGE_ALT_SRES
+  memcpy(sres, res, 4);
+#else /* GSM_MILENAGE_ALT_SRES */
+
+  for (i = 0; i < 4; i++)
+    sres[i] = res[i] ^ res[i + 4];
+
+#endif /* GSM_MILENAGE_ALT_SRES */
+  return true;
+}
+
+
+/**
+   milenage_generate - Generate AKA AUTN,IK,CK,RES
+   @opc: OPc = 128-bit operator variant algorithm configuration field (encr.)
+   @k: K = 128-bit subscriber key
+   @sqn: SQN = 48-bit sequence number
+   @_rand: RAND = 128-bit random challenge
+   @autn: AUTN = 128-bit authentication token
+   @ik: Buffer for IK = 128-bit integrity key (f4), or %NULL
+   @ck: Buffer for CK = 128-bit confidentiality key (f3), or %NULL
+   @res: Buffer for RES = 64-bit signed response (f2), or %NULL
+   @res_len: Variable that will be set to RES length
+   @auts: 112-bit buffer for AUTS
+   Returns: 0 on success, -1 on failure, or -2 on synchronization failure
+*/
+static int milenage_check(const u8 *opc, const u8 *k, const u8 *sqn, const u8 *_rand,
+                   const u8 *autn, u8 *ik, u8 *ck, u8 *res, size_t *res_len,
+                   u8 *auts) {
+  int i;
+  u8 mac_a[8], ak[6], rx_sqn[6];
+  const u8 *amf;
+
+  if (milenage_f2345(opc, k, _rand, res, ck, ik, ak, NULL))
+    return -1;
+
+  *res_len = 8;
+
+  /* AUTN = (SQN ^ AK) || AMF || MAC */
+  for (i = 0; i < 6; i++)
+    rx_sqn[i] = autn[i] ^ ak[i];
+
+  if (memcmp(rx_sqn, sqn, 6) <= 0) {
+    u8 auts_amf[2] = { 0x00, 0x00 }; /* TS 33.102 v7.0.0, 6.3.3 */
+
+    if (milenage_f2345(opc, k, _rand, NULL, NULL, NULL, NULL, ak))
+      return -1;
+
+    for (i = 0; i < 6; i++)
+      auts[i] = sqn[i] ^ ak[i];
+
+    if (milenage_f1(opc, k, _rand, sqn, auts_amf, NULL, auts + 6))
+      return -1;
+
+    return -2;
+  }
+
+  amf = autn + 6;
+
+  if (milenage_f1(opc, k, _rand, rx_sqn, amf, mac_a, NULL))
+    return -1;
+
+  if (memcmp(mac_a, autn + 8, 8) != 0) {
+    printf( "Milenage: MAC mismatch\n");
+    return -1;
+  }
+
+  return 0;
+}
+
+static void milenage_opc_gen(const u8 *k, const u8 *op, u8 *opc) {
+  int i;
+  /* Encrypt OP using K */
+  aes_128_encrypt_block(k, op, opc);
+
+  /* XOR the resulting Ek(OP) with OP */
+  for (i = 0; i < 16; i++)
+    opc[i] = opc[i] ^ op[i];
+}
+#endif
+#endif

openair3/NAS/COMMON/nr_common.c

@@ -0,0 +1,66 @@
+/*
+ * 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
+ *
+ * Author and copyright: Laurent Thomas, open-cells.com
+ *
+ * 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 <openair3/NAS/COMMON/NR_NAS_defs.h>
+#include <openair3/SECU/secu_defs.h>
+
+void servingNetworkName(uint8_t *msg, char * imsiStr, int nmc_size) {
+  //SNN-network-identifier in TS 24.501
+  // TS 24.501: If the MNC of the serving PLMN has two digits, then a zero is added at the beginning.
+  const char *format="5G:mnc000.mcc000.3gppnetwork.org";
+  memcpy(msg,format, strlen(format));
+
+  if (nmc_size == 2)
+    memcpy(msg+7, imsiStr+3, 2);
+  else
+    memcpy(msg+6, imsiStr+3, 3);
+
+  memcpy(msg+13, imsiStr, 3);
+}
+
+int resToresStar(uint8_t *msg, uicc_t* uicc) {
+  // TS 33.220  annex B.2 => FC=0x6B in TS 33.501 annex A.4
+  //input S to KDF
+  uint8_t S[128]= {0};
+  S[0]=0x6B;
+  uint8_t *ptr=S+1;
+  servingNetworkName(ptr, uicc->imsiStr, uicc->nmc_size);
+  *(uint16_t *)(ptr+strlen((char *)ptr))=htons(strlen((char *)ptr));
+  ptr+=strlen((char *)ptr)+sizeof(uint16_t);
+  // add rand
+  memcpy(ptr, uicc->rand, sizeof(uicc->rand) ) ;
+  *(uint16_t *)(ptr+sizeof(uicc->rand))=htons(sizeof(uicc->rand));
+  ptr+=sizeof(uicc->rand)+sizeof(uint16_t);
+  // add res
+  memcpy(ptr, uicc->milenage_res, sizeof(uicc->milenage_res) ) ;
+  *(uint16_t *)(ptr+sizeof(uicc->milenage_res))=htons(sizeof(uicc->milenage_res));
+  ptr+=sizeof(uicc->milenage_res)+sizeof(uint16_t);
+  // S is done
+  uint8_t ckik[sizeof(uicc->ck) +sizeof(uicc->ik)];
+  memcpy(ckik, uicc->ck, sizeof(uicc->ck));
+  memcpy(ckik+sizeof(uicc->ck),uicc->ik, sizeof(uicc->ik));
+  uint8_t out[32];
+  kdf(S, ptr-S, ckik, 32, out, sizeof(out));
+  memcpy(msg, out+16, 16);
+  return 16;
+}

openair3/NAS/NR_UE/ue_process_nas.c

@@ -0,0 +1,178 @@
+/*
+ * 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
+ *
+ * Author and copyright: Laurent Thomas, open-cells.com
+ *
+ * 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 <openair3/NAS/COMMON/NR_NAS_defs.h>
+#include <openair3/SECU/secu_defs.h>
+
+
+void SGSabortNet(void *msg, nr_user_nas_t *UE) {
+}
+
+void ue_nas_schedule(void) {
+}
+
+/*
+ *Message reception
+ */
+
+void SGSauthenticationReq(void *msg, nr_user_nas_t *UE) {
+  authenticationrequestHeader_t *amsg=(authenticationrequestHeader_t *) msg;
+  arrayCpy(UE->uicc->rand,amsg->RAND);
+  arrayCpy(UE->uicc->autn,amsg->AUTN);
+  // AUTHENTICATION REQUEST message that contains a valid ngKSI, SQN and MAC is received
+  // TBD verify ngKSI (we set it as '2', see gNB code)
+  // SQN and MAC are tested in auth resp processing
+  ue_nas_schedule();
+}
+
+void SGSidentityReq(void *msg, nr_user_nas_t *UE) {
+  Identityrequest_t *idmsg=(Identityrequest_t *) msg;
+
+  if (idmsg->it == SUCI ) {
+    LOG_I(NAS,"Received Identity request, scheduling answer\n");
+    ue_nas_schedule();
+  } else
+    LOG_E(NAS,"Not developped: identity request for %d\n", idmsg->it);
+}
+
+void SGSsecurityModeCommand(void *msg, nr_user_nas_t *UE) {
+}
+
+
+void UEprocessNAS(void *msg,nr_user_nas_t *UE) {
+  SGScommonHeader_t *header=(SGScommonHeader_t *) msg;
+
+  if ( header->sh > 4 )
+    SGSabortNet(msg, UE);
+  else {
+    switch  (header->epd) {
+      case SGSmobilitymanagementmessages:
+        LOG_I(NAS,"Received message: %s\n", idStr(message_text_info, header->mt));
+
+        switch (header->mt) {
+          case Authenticationrequest:
+            SGSauthenticationReq(msg, UE);
+            break;
+
+          case Identityrequest:
+            SGSidentityReq(msg, UE);
+            break;
+
+          case Securitymodecommand:
+            SGSsecurityModeCommand(msg, UE);
+            break;
+
+          default:
+            SGSabortNet(msg, UE);
+        }
+
+        break;
+
+      case SGSsessionmanagementmessages:
+        SGSabortNet(msg, UE);
+        break;
+
+      default:
+        SGSabortNet(msg, UE);
+    }
+  }
+}
+
+/*
+ * Messages emission
+ */
+
+int identityResponse(void **msg, nr_user_nas_t *UE) {
+  if (UE->uicc == NULL)
+    // config file section hardcoded as "uicc", nevertheless it opens to manage several UEs or a multi SIM UE
+    UE->uicc=init_uicc("uicc");
+
+  // TS 24.501 9.11.3.4
+  int imsiL=strlen(UE->uicc->imsiStr);
+  int msinL=imsiL-3-UE->uicc->nmc_size;
+  int respSize=sizeof(IdentityresponseIMSI_t) + (msinL+1)/2;
+  IdentityresponseIMSI_t *resp=(IdentityresponseIMSI_t *) calloc(respSize,1);
+  resp->common.epd=SGSmobilitymanagementmessages;
+  resp->common.sh=0;
+  resp->common.mt=Identityresponse;
+  resp->common.len=htons(respSize-sizeof(Identityresponse_t));
+  resp->mi=SUCI;
+  resp->mcc1=UE->uicc->imsiStr[0]-'0';
+  resp->mcc2=UE->uicc->imsiStr[1]-'0';
+  resp->mcc3=UE->uicc->imsiStr[2]-'0';
+  resp->mnc1=UE->uicc->imsiStr[3]-'0';
+  resp->mnc2=UE->uicc->imsiStr[4]-'0';
+  resp->mnc3=UE->uicc->nmc_size==2? 0xF : UE->uicc->imsiStr[3]-'0';
+  // TBD: routing to fill (FF ?)
+  char *out=(char *)(resp+1);
+  char *ptr=UE->uicc->imsiStr + 3 + UE->uicc->nmc_size;
+
+  while ( ptr < UE->uicc->imsiStr+strlen(UE->uicc->imsiStr) ) {
+    *out=((*(ptr+1)-'0')<<4) | (*(ptr) -'0');
+    out++;
+    ptr+=2;
+  }
+
+  if (msinL%2 == 1)
+    *out=((*(ptr-1)-'0')) | 0xF0;
+
+  *msg=resp;
+  return respSize;
+}
+
+int authenticationResponse(void **msg,nr_user_nas_t *UE) {
+  if (UE->uicc == NULL)
+    // config file section hardcoded as "uicc", nevertheless it opens to manage several UEs or a multi SIM UE
+    UE->uicc=init_uicc("uicc");
+
+  myCalloc(resp, authenticationresponse_t);
+  resp->epd=SGSmobilitymanagementmessages;
+  resp->sh=0;
+  resp->mt=Authenticationresponse;
+  resp->iei=IEI_AuthenticationResponse;
+  resp->RESlen=sizeof(resp->RES); // always 16 see TS 24.501 Table 8.2.2.1.1
+  // Verify the AUTN
+  // a full implementation need to test several SQN
+  // as the last 5bits can be any value
+  // and the value can also be greater and accepted (if it is in the accepted window)
+  uint8_t AUTN[16];
+  uicc_milenage_generate(AUTN, UE->uicc);
+
+  if ( memcmp(UE->uicc->autn, AUTN, sizeof(AUTN)) == 0 ) {
+    // prepare and send good answer
+    resToresStar(resp->RES,UE->uicc);
+  } else {
+    // prepare and send autn is not compatible with our data
+    abort();
+  }
+
+  *msg=resp;
+  return sizeof(authenticationresponse_t);
+}
+
+int securityModeComplete(void **msg, nr_user_nas_t *UE) {
+  return -1;
+}
+
+int registrationComplete(void **msg, nr_user_nas_t *UE) {
+  return -1;
+}

openair3/NAS/gNB/network_process_nas.c

@@ -0,0 +1,214 @@
+/*
+ * 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
+ *
+ * Author and copyright: Laurent Thomas, open-cells.com
+ *
+ * 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 <openair3/NAS/COMMON/NR_NAS_defs.h>
+
+void SGSabortUE(void *msg, NRUEcontext_t *UE) {
+}
+void nas_schedule(void) {
+}
+/*
+ *Message reception
+ */
+
+void SGSregistrationReq(void *msg, NRUEcontext_t *UE) {
+}
+
+void SGSderegistrationUEReq(void *msg, NRUEcontext_t *UE) {
+}
+
+void SGSidentityResp(void *msg, NRUEcontext_t *UE) {
+  // use the UE SUPI to load the USIM
+  IdentityresponseIMSI_t *resp=(IdentityresponseIMSI_t *)msg;
+  char configName[100]={0};
+  char * ptr= stpcpy(configName,"uicc");
+  *ptr++=resp->mcc1+'0';
+  *ptr++=resp->mcc2+'0';
+  *ptr++=resp->mcc3+'0';
+  *ptr++=resp->mnc1+'0';
+  *ptr++=resp->mnc2+'0';
+  if ( resp->mnc3 != 0xF )
+    *ptr++=resp->mnc3 +'0';
+  int respSize=ntohs(resp->common.len);
+  int msinByteSize=respSize-sizeof(IdentityresponseIMSI_t);
+  uint8_t * msin=(uint8_t *) (resp+1);
+  for(int i=3 ; i<msinByteSize; i++) {
+    char digit1=(msin[i] >> 4) ;
+    *ptr++=(msin[i] & 0xf) +'0';
+    if (digit1 != 0xf)
+      *ptr++=digit1 +'0';
+  }
+  *ptr=0;
+  if (UE->uicc == NULL)
+    // config file section hardcoded as "uicc", nevertheless it opens to manage several UEs or a multi SIM UE
+    UE->uicc=init_uicc(configName);
+  //We schedule Authentication request
+  nas_schedule();
+}
+
+void SGSauthenticationResp(void *msg, NRUEcontext_t *UE) {
+  // Let's check the answer
+  authenticationresponse_t* resp=(authenticationresponse_t*) msg;
+  uint8_t resStarLocal[16];
+  resToresStar(resStarLocal,UE->uicc);
+  if ( memcmp(resStarLocal, resp->RES, sizeof(resStarLocal)) == 0 ) {
+    LOG_I(NAS,"UE answer to authentication resquest is correct\n");
+    // we will send securityModeCommand
+    nas_schedule();
+  } else {
+    LOG_E(NAS,"UE authentication response not good\n");
+    // To be implemented ?
+  }
+}
+
+void SGSsecurityModeComplete(void *msg, NRUEcontext_t *UE) {
+  
+}
+
+void SGSregistrationComplete(void *msg, NRUEcontext_t *UE) {
+}
+
+void processNAS(void *msg, NRUEcontext_t *UE) {
+  SGScommonHeader_t *header=(SGScommonHeader_t *) msg;
+
+  if ( header->sh > 4 )
+    SGSabortUE(msg, UE);
+  else {
+    switch  (header->epd) {
+      case SGSmobilitymanagementmessages:
+        LOG_I(NAS,"Received message: %s\n", idStr(message_text_info, header->mt));
+
+        switch (header->mt) {
+          case Registrationrequest:
+            SGSregistrationReq(msg, UE);
+            break;
+
+          case DeregistrationrequestUEoriginating:
+            SGSderegistrationUEReq(msg, UE);
+            break;
+
+          case Authenticationresponse:
+            SGSauthenticationResp(msg, UE);
+            break;
+
+          case Identityresponse:
+            SGSidentityResp(msg, UE);
+            break;
+
+          case Securitymodecomplete:
+            SGSsecurityModeComplete(msg, UE);
+            break;
+
+          case Registrationcomplete:
+            SGSregistrationComplete(msg, UE);
+            break;
+
+          default:
+            SGSabortUE(msg, UE);
+        }
+
+        break;
+
+      case SGSsessionmanagementmessages:
+        SGSabortUE(msg, UE);
+        break;
+
+      default:
+        SGSabortUE(msg, UE);
+    }
+  }
+}
+
+/*
+ * Messages emission
+ */
+
+int identityRequest(void **msg, NRUEcontext_t *UE) {
+  myCalloc(req, Identityrequest_t);
+  req->epd=SGSmobilitymanagementmessages;
+  req->sh=0;
+  req->mt=Identityrequest;
+  req->it=SUCI;
+  *msg=req;
+  return sizeof(Identityrequest_t);
+}
+
+int authenticationRequest(void **msg, NRUEcontext_t *UE) {
+
+  myCalloc(req, authenticationrequestHeader_t);
+  req->epd=SGSmobilitymanagementmessages;
+  req->sh=0;
+  req->mt=Authenticationrequest;
+  // native security context => bit 4 to 0
+  // probably from TS 33.501, table A-8.1
+  // N-NAS-int-alg (Native NAS integrity)
+  /*
+     N-NAS-enc-alg 0x01
+     N-NAS-int-alg 0x02
+     N-RRC-enc-alg 0x03
+     N-RRC-int-alg 0x04
+     N-UP-enc-alg 0x05
+     N-UP-int-alg 0x06
+  */
+  req->ngKSI=2;
+  // TS 33.501, Annex A.7.1: Initial set of security features defined for 5GS.
+  req->ABBALen=2;
+  req->ABBA=0;
+  //rand (TV)
+  req->ieiRAND=IEI_RAND;
+  FILE *h=fopen("/dev/random","r");
+
+  if ( sizeof(req->RAND) != fread(req->RAND,1,sizeof(req->RAND),h) )
+    LOG_E(NAS, "can't read /dev/random\n");
+
+  fclose(h);
+  memcpy(UE->uicc->rand, req->RAND, sizeof(UE->uicc->rand));
+  // challenge/AUTN (TLV)
+  req->ieiAUTN=IEI_AUTN;
+  req->AUTNlen=sizeof(req->AUTN);
+  uicc_milenage_generate( req->AUTN, UE->uicc);
+  // EAP message (TLV-E)
+  // not developped
+  *msg=req;
+  return sizeof(authenticationrequestHeader_t);
+}
+
+int securityModeCommand(void **msg, NRUEcontext_t *UE) {
+  *msg=NULL;
+  myCalloc(req, securityModeCommand_t);
+  req->epd=SGSmobilitymanagementmessages;
+  req->sh=0;
+  req->mt=Securitymodecommand;
+
+  // integrity algo from 5G-IA0 (null algo) to 5G-IA7 in first 4 bits
+  unsigned int ia=0;
+  // cyphering algo from 5G-EA0 (null algo) to 5G-IA7 in MSB 4 bits
+  unsigned int ea=0;
+  // trace from commercial: 5G-IA0 (0) 128-5G-IA2 (2)
+  req->selectedNASsecurityalgorithms= ea<<4 | ia;
+
+  // KSI: N-NAS-int-alg 0x02
+  req->ngKSI=2;
+  
+  *msg=req;
+  return 0;
+}

openair3/TEST/test5Gnas.c

@@ -0,0 +1,34 @@
+#include <common/config/config_userapi.h>
+#include <openair3/NAS/COMMON/NR_NAS_defs.h>
+
+volatile int oai_exit;
+
+int main(int argc, char **argv) {
+  if ( load_configmodule(argc,argv,CONFIG_ENABLECMDLINEONLY) == NULL) {
+    exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
+  }
+
+  logInit();
+  char *resp;
+  nr_user_nas_t UErrc= {0};
+  NRUEcontext_t UEnas= {0};
+  // Network generate identity request after a sucessfull radio attach
+  int size=identityRequest((void **)&resp, &UEnas);
+  log_dump(NAS, resp, size, LOG_DUMP_CHAR,"   identity Request:\n" );
+  // UE process the message that it has received from phy layer in a "DL transfer" message
+  UEprocessNAS(resp, &UErrc);
+  // UE Scheduler should later call the response
+  size=identityResponse((void **)&resp, &UErrc);
+  log_dump(NAS, resp, size, LOG_DUMP_CHAR,"   identity Response:\n" );
+  // Now the gNB process the identity response
+  processNAS(resp, &UEnas);
+  // gNB scheduler should call the next query
+  size=authenticationRequest((void **)&resp, &UEnas);
+  log_dump(NAS, resp, size, LOG_DUMP_CHAR,"   authentication request:\n" );
+  // as above
+  UEprocessNAS(resp, &UErrc);
+  size=authenticationResponse((void **)&resp, &UErrc);
+  log_dump(NAS, resp, size, LOG_DUMP_CHAR,"   authentication response:\n" );
+  processNAS(resp, &UEnas);
+  return 0;
+}

openair3/UICC/usim_interface.c

@@ -0,0 +1,92 @@
+/*
+* 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
+*
+* Author and copyright: Laurent Thomas, open-cells.com
+*
+* 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 <openair3/UICC/usim_interface.h>
+#include <openair3/NAS/COMMON/milenage.h>
+
+#define UICC_SECTION    "uicc"
+#define UICC_CONFIG_HELP_OPTIONS     " list of comma separated options to interface a simulated (real UICC to be developped). Available options: \n"\
+  "        imsi: user imsi\n"\
+  "        key:  cyphering key\n"\
+  "        opc:  cyphering OPc\n"
+/*-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+/*                                            configuration parameters for the rfsimulator device                                                                              */
+/*   optname                     helpstr                     paramflags           XXXptr                               defXXXval                          type         numelt  */
+/*-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+#define UICC_PARAMS_DESC {\
+    {"imsi",             "USIM IMSI\n",          0,         strptr:&(uicc->imsiStr),              defstrval:"",           TYPE_STRING,    0 },\
+    {"nmc_size"          "number of digits in NMC", 0,      iptr:&(uicc->nmc_size),               defintval:2,            TYPE_INT,       0 },\
+    {"key",              "USIM Ki\n",            0,         strptr:&(uicc->keyStr),               defstrval:"",           TYPE_STRING,    0 },\
+    {"opc",              "USIM OPc\n",           0,         strptr:&(uicc->opcStr),               defstrval:"",           TYPE_STRING,    0 },\
+    {"amf",              "USIM amf\n",           0,         strptr:&(uicc->amfStr),               defstrval:"8000",       TYPE_STRING,    0 },\
+    {"sqn",              "USIM sqn\n",           0,         strptr:&(uicc->sqnStr),               defstrval:"000000",     TYPE_STRING,    0 },\
+  };
+
+const char *hexTable="0123456789abcdef";
+static inline uint8_t mkDigit(unsigned char in) {
+  for (int i=0; i<16; i++)
+    if (in==hexTable[i])
+      return i;
+  LOG_E(SIM,"Impossible hexa input: %c\n",in);
+  return 0;
+}
+
+static inline void to_hex(char *in, uint8_t *out, int size) {
+  for (size_t i=0; in[i]!=0 && i < size*2 ; i+=2) {
+    *out++=(mkDigit(in[i]) << 4) | mkDigit(in[i+1]);
+  }
+}
+
+uicc_t *init_uicc(char *sectionName) {
+  uicc_t *uicc=(uicc_t *)calloc(sizeof(uicc_t),1);
+  paramdef_t uicc_params[] = UICC_PARAMS_DESC;
+  // here we call usim simulation, but calling actual usim is quite simple
+  // the code is in open-cells.com => program_uicc open source
+  // we can read the IMSI from the USIM
+  // key, OPc, sqn, amf don't need to be read from the true USIM 
+  int ret = config_get( uicc_params,sizeof(uicc_params)/sizeof(paramdef_t),sectionName);
+  AssertFatal(ret >= 0, "configuration couldn't be performed");
+  LOG_I(SIM, "UICC simulation: IMSI=%s, Ki=%s, OPc=%s\n", uicc->imsiStr, uicc->keyStr, uicc->opcStr);
+  to_hex(uicc->keyStr,uicc->key, sizeof(uicc->key) );
+  to_hex(uicc->opcStr,uicc->opc, sizeof(uicc->opc) );
+  to_hex(uicc->sqnStr,uicc->sqn, sizeof(uicc->sqn) );
+  to_hex(uicc->amfStr,uicc->amf, sizeof(uicc->amf) );
+  return uicc;
+}
+
+void uicc_milenage_generate(uint8_t *autn, uicc_t *uicc) {
+  // here we call usim simulation, but calling actual usim is quite simple
+  // the code is in open-cells.com => program_uicc open source
+  milenage_generate(uicc->opc, uicc->amf, uicc->key,
+                    uicc->sqn, uicc->rand, autn, uicc->ik, uicc->ck, uicc->milenage_res);
+  log_dump(SIM,uicc->opc,sizeof(uicc->opc), LOG_DUMP_CHAR,"opc:");
+  log_dump(SIM,uicc->amf,sizeof(uicc->amf), LOG_DUMP_CHAR,"amf:");
+  log_dump(SIM,uicc->key,sizeof(uicc->key), LOG_DUMP_CHAR,"key:");
+  log_dump(SIM,uicc->sqn,sizeof(uicc->sqn), LOG_DUMP_CHAR,"sqn:");
+  log_dump(SIM,uicc->rand,sizeof(uicc->rand), LOG_DUMP_CHAR,"rand:");
+  log_dump(SIM,uicc->ik,sizeof(uicc->ik), LOG_DUMP_CHAR,"milenage output ik:");
+  log_dump(SIM,uicc->ck,sizeof(uicc->ck), LOG_DUMP_CHAR,"milenage output ck:");
+  log_dump(SIM,uicc->milenage_res,sizeof(uicc->milenage_res), LOG_DUMP_CHAR,"milenage output res:");
+  log_dump(SIM,autn,sizeof(autn), LOG_DUMP_CHAR,"milenage output autn:");
+}
+

openair3/UICC/usim_interface.h

@@ -0,0 +1,71 @@
+/*
+* 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
+*
+* Author and copyright: Laurent Thomas, open-cells.comopenair3/UICC/usim_interface.h
+*
+* 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 USIM_INTERFACE_H
+#define USIM_INTERFACE_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <common/utils/assertions.h>
+#include <common/utils/LOG/log.h>
+#include <common/utils/load_module_shlib.h>
+#include <common/config/config_userapi.h>
+#include "common_lib.h"
+
+/* 3GPP glossary
+RES	RESponse
+XRES	eXpected RESponse
+HRES	Hash RESponse
+HXRES	Hash eXpected RESponse
+So, RES can be either milenage res, or received response, so hash of milenage res
+*/
+
+typedef struct {
+  char *imsiStr;
+  char *keyStr;
+  char *opcStr;
+  char *amfStr;
+  char *sqnStr;
+  uint8_t key[16];
+  uint8_t opc[16];
+  uint8_t amf[2];
+  uint8_t sqn[6];
+  int nmc_size;
+  uint8_t rand[16];
+  uint8_t autn[16];
+  uint8_t ak[6]; 
+  uint8_t akstar[6]; 
+  uint8_t ck[16]; 
+  uint8_t ik[16]; 
+  uint8_t milenage_res[8];
+} uicc_t;
+
+/*
+ * Read the configuration file, section name variable to be able to manage several UICC
+ */
+uicc_t *init_uicc(char *sectionName);
+void uicc_milenage_generate(uint8_t * autn, uicc_t *uicc);
+#endif

targets/ARCH/rfsimulator/simulator.c

@@ -533,24 +533,24 @@ static bool flushInput(rfsimulator_state_t *t, int timeout, int nsamps_for_initi
         b->headerMode=false;
 
         if ( t->nextTimestamp == 0 ) { // First block in UE, resync with the eNB current TS
-	  t->nextTimestamp=b->th.timestamp> nsamps_for_initial ?
+          t->nextTimestamp=b->th.timestamp> nsamps_for_initial ?
-	    b->th.timestamp -  nsamps_for_initial :
+                           b->th.timestamp -  nsamps_for_initial :
-	    0;
+                           0;
-	  b->lastReceivedTS=b->th.timestamp> nsamps_for_initial ?
+          b->lastReceivedTS=b->th.timestamp> nsamps_for_initial ?
-	    b->th.timestamp :
+                            b->th.timestamp :
-	    nsamps_for_initial;
+                            nsamps_for_initial;
-	  LOG_W(HW,"UE got first timestamp: starting at %lu\n",  t->nextTimestamp);
+          LOG_W(HW,"UE got first timestamp: starting at %lu\n",  t->nextTimestamp);
-	  b->trashingPacket=true;
+          b->trashingPacket=true;
-	} else if ( b->lastReceivedTS < b->th.timestamp) {
+        } else if ( b->lastReceivedTS < b->th.timestamp) {
           int nbAnt= b->th.nbAnt;
 
           if ( b->th.timestamp-b->lastReceivedTS < CirSize ) {
-          for (uint64_t index=b->lastReceivedTS; index < b->th.timestamp; index++ ) {
+            for (uint64_t index=b->lastReceivedTS; index < b->th.timestamp; index++ ) {
-            for (int a=0; a < nbAnt; a++) {
+              for (int a=0; a < nbAnt; a++) {
-              b->circularBuf[(index*nbAnt+a)%CirSize].r = 0;
+                b->circularBuf[(index*nbAnt+a)%CirSize].r = 0;
-              b->circularBuf[(index*nbAnt+a)%CirSize].i = 0;
+                b->circularBuf[(index*nbAnt+a)%CirSize].i = 0;
+              }
             }
-          }
           } else {
 	    memset(b->circularBuf, 0, sampleToByte(CirSize,1));
 	  }
@@ -567,7 +567,7 @@ static bool flushInput(rfsimulator_state_t *t, int timeout, int nsamps_for_initi
           // normal case
         } else {
           LOG_E(HW, "received data in past: current is %lu, new reception: %lu!\n", b->lastReceivedTS, b->th.timestamp);
-	  b->trashingPacket=true;
+          b->trashingPacket=true;
         }
 
         pthread_mutex_lock(&Sockmutex);
@@ -646,8 +646,8 @@ int rfsimulator_read(openair0_device *device, openair0_timestamp *ptimestamp, vo
         // We can never write is the past from the received time
         // So, the node perform receive but will never write these symbols
         // let's tell this to the opposite node
-	// We send timestamp for nb samples required
+        // We send timestamp for nb samples required
-	// assuming this should have been done earlier if a Tx would exist
+        // assuming this should have been done earlier if a Tx would exist
         pthread_mutex_unlock(&Sockmutex);
         struct complex16 v= {0};
         void *samplesVoid[t->tx_num_channels];
@@ -655,18 +655,18 @@ int rfsimulator_read(openair0_device *device, openair0_timestamp *ptimestamp, vo
         for ( int i=0; i < t->tx_num_channels; i++)
           samplesVoid[i]=(void *)&v;
 
-	LOG_I(HW, "No samples Tx occured, so we send 1 sample to notify it: Tx:%lu, Rx:%lu\n",
+        LOG_I(HW, "No samples Tx occured, so we send 1 sample to notify it: Tx:%lu, Rx:%lu\n",
-	      t->lastWroteTS, t->nextTimestamp);
+              t->lastWroteTS, t->nextTimestamp);
         rfsimulator_write_internal(t, t->nextTimestamp,
                                    samplesVoid, 1,
                                    t->tx_num_channels, 1, true);
       } else {
-	pthread_mutex_unlock(&Sockmutex);
+        pthread_mutex_unlock(&Sockmutex);
         LOG_W(HW, "trx_write came from another thread\n");
       }
     } else
       pthread_mutex_unlock(&Sockmutex);
-    
+
     bool have_to_wait;
 
     do {
@@ -765,7 +765,7 @@ int rfsimulator_set_freq(openair0_device *device, openair0_config_t *openair0_cf
 int rfsimulator_set_gains(openair0_device *device, openair0_config_t *openair0_cfg) {
   return 0;
 }
-int rfsimulator_write_init(openair0_device *device){
+int rfsimulator_write_init(openair0_device *device) {
   return 0;
 }
 __attribute__((__visibility__("default")))

targets/COMMON/create_nr_tasks.c

@@ -1,111 +0,0 @@
-/*
- * 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 "intertask_interface.h"
-# include "create_nr_tasks.h"
-# include "common/utils/LOG/log.h"
-
-# ifdef OPENAIR2
-#include "sctp_eNB_task.h"
-#include "s1ap_eNB.h"
-#include "nas_ue_task.h"
-#include "udp_eNB_task.h"
-#include "gtpv1u_eNB_task.h"
-#   if ENABLE_RAL
-#     include "lteRALue.h"
-#     include "lteRALenb.h"
-#   endif
-#include "RRC/NR/nr_rrc_defs.h"
-# endif
-# include "gnb_app.h"
-
-extern int emulate_rf;
-
-int create_gNB_tasks(uint32_t gnb_nb)
-{
-  LOG_D(GNB_APP, "%s(gnb_nb:%d\n", __FUNCTION__, gnb_nb);
-  
-  itti_wait_ready(1);
-  if (itti_create_task (TASK_L2L1, l2l1_task, NULL) < 0) {
-    LOG_E(PDCP, "Create task for L2L1 failed\n");
-    return -1;
-  }
-
-  if (gnb_nb > 0) {
-    // Last task to create, others task must be ready before its start
-    if (itti_create_task (TASK_GNB_APP, gNB_app_task, NULL) < 0) {
-      LOG_E(GNB_APP, "Create task for gNB APP failed\n");
-      return -1;
-    }
-  }
-
-
-  if (EPC_MODE_ENABLED) {
-      if (gnb_nb > 0) {
-        /*if (itti_create_task (TASK_SCTP, sctp_eNB_task, NULL) < 0) {
-          LOG_E(SCTP, "Create task for SCTP failed\n");
-          return -1;
-        }
-
-        if (itti_create_task (TASK_S1AP, s1ap_eNB_task, NULL) < 0) {
-          LOG_E(S1AP, "Create task for S1AP failed\n");
-          return -1;
-        }*/
-        if(!emulate_rf){
-          if (itti_create_task (TASK_UDP, udp_eNB_task, NULL) < 0) {
-            LOG_E(UDP_, "Create task for UDP failed\n");
-            return -1;
-          }
-        }
-
-        if (itti_create_task (TASK_GTPV1_U, &gtpv1u_eNB_task, NULL) < 0) {
-          LOG_E(GTPU, "Create task for GTPV1U failed\n");
-          return -1;
-        }
-      }
-
-   }
-
-  /*if (gnb_nb > 0) {
-      // Last task to create, others task must be ready before its start
-      if (itti_create_task (TASK_GNB_APP, gNB_app_task, NULL) < 0) {
-        LOG_E(GNB_APP, "Create task for gNB APP failed\n");
-        return -1;
-      }
-    }*/
-
-
-    if (gnb_nb > 0) {
-      LOG_I(NR_RRC,"Creating NR RRC gNB Task\n");
-
-      if (itti_create_task (TASK_RRC_GNB, rrc_gnb_task, NULL) < 0) {
-        LOG_E(NR_RRC, "Create task for NR RRC gNB failed\n");
-        return -1;
-      }
-    }
-
-
-  itti_wait_ready(0);
-
-  return 0;
-}
-//#endif

targets/RT/USER/lte-uesoftmodem.c

@@ -540,6 +540,12 @@ void init_pdcp(void) {
   pdcp_set_pdcp_data_ind_func((pdcp_data_ind_func_t) pdcp_data_ind);
 }
 
+// Stupid function addition because UE itti messages queues definition is common with eNB
+void *rrc_enb_process_msg(void *notUsed) {
+AssertFatal(false,"");
+	return NULL;
+}
+
 int main( int argc, char **argv ) {
   int CC_id;
   uint8_t  abstraction_flag=0;