add common/app

build/nrf/CMakeLists.txt

@@ -32,3 +32,5 @@ set (BUILD_TOP_DIR   ${OPENAIRCN_DIR}/build)
 set (SRC_TOP_DIR     $ENV{OPENAIRCN_DIR}/src)
 
 include(${CMAKE_CURRENT_SOURCE_DIR}/../../src/oai-nrf/CMakeLists.txt)
+
+ADD_SUBDIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src/nrf_app ${CMAKE_CURRENT_BINARY_DIR}/nrf_app)

src/common/CMakeLists.txt

+################################################################################
+# 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_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/msg)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/nas)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ngap)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/common/utils)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+include_directories(${SRC_TOP_DIR}/../build/ext/spdlog/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+
+add_library(3GPP_COMMON_TYPES STATIC
+  ${CMAKE_CURRENT_SOURCE_DIR}/logger.cpp
+)
+
+

src/common/common_defs.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file common_defs.h
+ \brief
+ \author Sebastien ROUX, Lionel Gauthier
+ \company Eurecom
+ \email: lionel.gauthier@eurecom.fr
+ */
+
+#ifndef FILE_COMMON_DEFS_SEEN
+#define FILE_COMMON_DEFS_SEEN
+
+#include <arpa/inet.h>
+#include <stdint.h>
+
+#define RETURNclear       (int)2
+#define RETURNerror       (int)1
+#define RETURNok          (int)0
+
+typedef enum {
+  /* Fatal errors - received message should not be processed */
+  TLV_MAC_MISMATCH = -14,
+  TLV_BUFFER_NULL = -13,
+  TLV_BUFFER_TOO_SHORT = -12,
+  TLV_PROTOCOL_NOT_SUPPORTED = -11,
+  TLV_WRONG_MESSAGE_TYPE = -10,
+  TLV_OCTET_STRING_TOO_LONG_FOR_IEI = -9,
+
+  TLV_VALUE_DOESNT_MATCH = -4,
+  TLV_MANDATORY_FIELD_NOT_PRESENT = -3,
+  TLV_UNEXPECTED_IEI = -2,
+
+//  RETURNerror                             = -1,
+//  RETURNok                                = 0,
+
+  TLV_ERROR_OK = RETURNok,
+  /* Defines error code limit below which received message should be discarded
+   * because it cannot be further processed */
+  TLV_FATAL_ERROR = TLV_VALUE_DOESNT_MATCH
+
+} error_code_e;
+//------------------------------------------------------------------------------
+#define DECODE_U8(bUFFER, vALUE, sIZE)    \
+    vALUE = *(uint8_t*)(bUFFER);    \
+    sIZE += sizeof(uint8_t)
+
+#define DECODE_U16(bUFFER, vALUE, sIZE)   \
+    vALUE = ntohs(*(uint16_t*)(bUFFER));  \
+    sIZE += sizeof(uint16_t)
+
+#define DECODE_U24(bUFFER, vALUE, sIZE)   \
+    vALUE = ntohl(*(uint32_t*)(bUFFER)) >> 8; \
+    sIZE += sizeof(uint8_t) + sizeof(uint16_t)
+
+#define DECODE_U32(bUFFER, vALUE, sIZE)   \
+    vALUE = ntohl(*(uint32_t*)(bUFFER));  \
+    sIZE += sizeof(uint32_t)
+
+#if (BYTE_ORDER == LITTLE_ENDIAN)
+# define DECODE_LENGTH_U16(bUFFER, vALUE, sIZE)          \
+    vALUE = ((*(bUFFER)) << 8) | (*((bUFFER) + 1));      \
+    sIZE += sizeof(uint16_t)
+#else
+# define DECODE_LENGTH_U16(bUFFER, vALUE, sIZE)          \
+    vALUE = (*(bUFFER)) | (*((bUFFER) + 1) << 8);        \
+    sIZE += sizeof(uint16_t)
+#endif
+
+#define ENCODE_U8(buffer, value, size)    \
+    *(uint8_t*)(buffer) = value;    \
+    size += sizeof(uint8_t)
+
+#define ENCODE_U16(buffer, value, size)   \
+    *(uint16_t*)(buffer) = htons(value);  \
+   size += sizeof(uint16_t)
+
+#define ENCODE_U24(buffer, value, size)   \
+    *(uint32_t*)(buffer) = htonl(value);  \
+    size += sizeof(uint8_t) + sizeof(uint16_t)
+
+#define ENCODE_U32(buffer, value, size)   \
+    *(uint32_t*)(buffer) = htonl(value);  \
+    size += sizeof(uint32_t)
+
+#define IPV4_STR_ADDR_TO_INT_NWBO(AdDr_StR,NwBo,MeSsAgE ) do {\
+            struct in_addr inp;\
+            if ( inet_aton(AdDr_StR, &inp ) < 0 ) {\
+                AssertFatal (0, MeSsAgE);\
+            } else {\
+                NwBo = inp.s_addr;\
+            }\
+        } while (0)
+
+#define NIPADDR(addr) \
+  (uint8_t)(addr & 0x000000FF), \
+  (uint8_t)((addr & 0x0000FF00) >> 8), \
+  (uint8_t)((addr & 0x00FF0000) >> 16), \
+  (uint8_t)((addr & 0xFF000000) >> 24)
+
+#define HIPADDR(addr) \
+  (uint8_t)((addr & 0xFF000000) >> 24),\
+  (uint8_t)((addr & 0x00FF0000) >> 16),\
+  (uint8_t)((addr & 0x0000FF00) >> 8), \
+  (uint8_t)(addr & 0x000000FF)
+
+#define NIP6ADDR(addr) \
+  ntohs((addr)->s6_addr16[0]), \
+  ntohs((addr)->s6_addr16[1]), \
+  ntohs((addr)->s6_addr16[2]), \
+  ntohs((addr)->s6_addr16[3]), \
+  ntohs((addr)->s6_addr16[4]), \
+  ntohs((addr)->s6_addr16[5]), \
+  ntohs((addr)->s6_addr16[6]), \
+  ntohs((addr)->s6_addr16[7])
+
+#define IN6_ARE_ADDR_MASKED_EQUAL(a,b,m) \
+  (((((__const uint32_t *) (a))[0] & (((__const uint32_t *) (m))[0])) == (((__const uint32_t *) (b))[0] & (((__const uint32_t *) (m))[0])))  \
+   && ((((__const uint32_t *) (a))[1] & (((__const uint32_t *) (m))[1])) == (((__const uint32_t *) (b))[1] & (((__const uint32_t *) (m))[1])))  \
+   && ((((__const uint32_t *) (a))[2] & (((__const uint32_t *) (m))[2])) == (((__const uint32_t *) (b))[2] & (((__const uint32_t *) (m))[2])))  \
+   && ((((__const uint32_t *) (a))[3] & (((__const uint32_t *) (m))[3])) == (((__const uint32_t *) (b))[3] & (((__const uint32_t *) (m))[3]))))
+
+////////////
+#define IPV4_STR_ADDR_TO_INADDR(AdDr_StR,InAdDr,MeSsAgE ) do {\
+            if ( inet_aton(AdDr_StR, &InAdDr ) <= 0 ) {\
+              throw (MeSsAgE);\
+            }\
+        } while (0)
+
+#ifndef UNUSED
+#define UNUSED(x) (void)(x)
+#endif
+
+#endif /* FILE_COMMON_DEFS_SEEN */

src/common/dynamic_memory_check.c

+/*
+ * Copyright (c) 2015, EURECOM (www.eurecom.fr)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those
+ * of the authors and should not be interpreted as representing official policies,
+ * either expressed or implied, of the FreeBSD Project.
+ */
+
+#include <stdlib.h>
+#include "dynamic_memory_check.h"
+#include "assertions.h"
+
+//------------------------------------------------------------------------------
+void free_wrapper(void **ptr)
+{
+  // for debug only
+  AssertFatal(ptr, "Trying to free NULL ptr");
+  if (ptr) {
+    free(*ptr);
+    *ptr = NULL;
+  }
+}
+
+//------------------------------------------------------------------------------
+void bdestroy_wrapper(bstring *b)
+{
+  if ((b) && (*b)) {
+    bdestroy(*b);
+    *b = NULL;
+  }
+}
+

src/common/dynamic_memory_check.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file dynamic_memory_check.h
+ \brief
+ \author Lionel Gauthier
+ \company Eurecom
+ \email: lionel.gauthier@eurecom.fr
+ */
+
+#ifndef FILE_DYNAMIC_MEMORY_CHECK_SEEN
+#define FILE_DYNAMIC_MEMORY_CHECK_SEEN
+# include "bstrlib.h"
+
+void free_wrapper(void **ptr) __attribute__ ((hot));
+void bdestroy_wrapper(bstring *b);
+
+#endif /* FILE_DYNAMIC_MEMORY_CHECK_SEEN */

src/common/logger.cpp

+/*
+ * Copyright (c) 2017 Sprint
+ *
+ * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+
+#include "logger.hpp"
+#include "spdlog/sinks/syslog_sink.h"
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <memory>
+
+Logger *Logger::m_singleton = NULL;
+
+void Logger::_init(const char *app, const bool log_stdout,
+                   bool const log_rot_file) {
+  int num_sinks = 0;
+  spdlog::set_async_mode(2048);
+#if TRACE_IS_ON
+   spdlog::level::level_enum llevel = spdlog::level::trace;
+#elif DEBUG_IS_ON
+   spdlog::level::level_enum llevel = spdlog::level::debug;
+#elif INFO_IS_ON
+   spdlog::level::level_enum llevel = spdlog::level::info;
+#else
+  spdlog::level::level_enum llevel = spdlog::level::warn;
+#endif
+  if (log_stdout) {
+    std::string filename = fmt::format("./{}.log", app);
+    m_sinks.push_back(
+        std::make_shared<spdlog::sinks::ansicolor_stdout_sink_mt>());
+    m_sinks[num_sinks++].get()->set_level(llevel);
+  }
+  if (log_rot_file) {
+    std::string filename = fmt::format("./{}.log", app);
+    m_sinks.push_back(
+        std::make_shared<spdlog::sinks::rotating_file_sink_mt>(filename,
+                                                               5 * 1024 * 1024,
+                                                               3));
+    m_sinks[num_sinks++].get()->set_level(llevel);
+  }
+
+  std::stringstream ss;
+  ss << "[%Y-%m-%dT%H:%M:%S.%f] [" << app << "] [%n] [%l] %v";
+
+  m_async_cmd = new _Logger("async_c", m_sinks, ss.str().c_str());
+  m_itti = new _Logger("itti   ", m_sinks, ss.str().c_str());
+  m_smf_app = new _Logger("smf_app", m_sinks, ss.str().c_str());
+  m_system = new _Logger("system ", m_sinks, ss.str().c_str());
+  m_udp = new _Logger("udp    ", m_sinks, ss.str().c_str());
+  m_pfcp = new _Logger("pfcp   ", m_sinks, ss.str().c_str());
+  m_pfcp_switch = new _Logger("pfcp_sw ", m_sinks, ss.str().c_str());
+  m_smf_n1 = new _Logger("smf_n1 ", m_sinks, ss.str().c_str());
+  m_smf_n2 = new _Logger("smf_n2 ", m_sinks, ss.str().c_str());
+  m_smf_n4 = new _Logger("smf_n4 ", m_sinks, ss.str().c_str());
+  m_smf_n10 = new _Logger("smf_n10", m_sinks, ss.str().c_str());
+  m_smf_n11 = new _Logger("smf_n11", m_sinks, ss.str().c_str());
+  m_smf_api_server = new _Logger("sbi_srv", m_sinks, ss.str().c_str());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+_Logger::_Logger(const char *category, std::vector<spdlog::sink_ptr> &sinks,
+                 const char *pattern)
+    :
+    m_log(category, sinks.begin(), sinks.end()) {
+  m_log.set_pattern(pattern);
+#if TRACE_IS_ON
+   m_log.set_level( spdlog::level::trace );
+#elif DEBUG_IS_ON
+   m_log.set_level( spdlog::level::debug );
+#elif INFO_IS_ON
+   m_log.set_level( spdlog::level::info );
+#else
+  m_log.set_level(spdlog::level::warn);
+#endif
+}
+
+void _Logger::trace(const char *format, ...) {
+#if TRACE_IS_ON
+   va_list args;
+   va_start( args, format );
+   log( _ltTrace, format, args );
+   va_end( args );
+#endif
+}
+
+void _Logger::debug(const char *format, ...) {
+#if DEBUG_IS_ON
+   va_list args;
+   va_start( args, format );
+   log( _ltDebug, format, args );
+   va_end( args );
+#endif
+}
+
+void _Logger::info(const char *format, ...) {
+#if INFO_IS_ON
+   va_list args;
+   va_start( args, format );
+   log( _ltInfo, format, args );
+   va_end( args );
+#endif
+}
+
+void _Logger::startup(const char *format, ...) {
+  va_list args;
+  va_start(args, format);
+  log(_ltStartup, format, args);
+  va_end(args);
+}
+
+void _Logger::warn(const char *format, ...) {
+  va_list args;
+  va_start(args, format);
+  log(_ltWarn, format, args);
+  va_end(args);
+}
+
+void _Logger::error(const char *format, ...) {
+  va_list args;
+  va_start(args, format);
+  log(_ltError, format, args);
+  va_end(args);
+}
+
+void _Logger::log(_LogType lt, const char *format, va_list &args) {
+  char buffer[2048];
+
+  vsnprintf(buffer, sizeof(buffer), format, args);
+
+  switch (lt) {
+    case _ltTrace:
+      m_log.trace(buffer);
+      break;
+    case _ltDebug:
+      m_log.debug(buffer);
+      break;
+    case _ltInfo:
+      m_log.info(buffer);
+      break;
+    case _ltStartup:
+      m_log.warn(buffer);
+      break;
+    case _ltWarn:
+      m_log.error(buffer);
+      break;
+    case _ltError:
+      m_log.critical(buffer);
+      break;
+  }
+}

src/common/logger.hpp

+/*
+ * Copyright (c) 2017 Sprint
+ *
+ * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+
+#ifndef __LOGGER_H
+#define __LOGGER_H
+
+#include <cstdarg>
+#include <stdexcept>
+#include <vector>
+
+//#define SPDLOG_LEVEL_NAMES { "trace", "debug", "info",  "warning", "error", "critical", "off" };
+#define SPDLOG_LEVEL_NAMES { "trace", "debug", "info ",  "start", "warn ", "error", "off  " };
+
+#define SPDLOG_ENABLE_SYSLOG
+#include "spdlog/spdlog.h"
+
+class LoggerException : public std::runtime_error {
+ public:
+  explicit LoggerException(const char *m)
+      :
+      std::runtime_error(m) {
+  }
+  explicit LoggerException(const std::string &m)
+      :
+      std::runtime_error(m) {
+  }
+};
+
+class _Logger {
+ public:
+  _Logger(const char *category, std::vector<spdlog::sink_ptr> &sinks,
+          const char *pattern);
+
+  void trace(const char *format, ...);
+  void trace(const std::string &format, ...);
+  void debug(const char *format, ...);
+  void debug(const std::string &format, ...);
+  void info(const char *format, ...);
+  void info(const std::string &format, ...);
+  void startup(const char *format, ...);
+  void startup(const std::string &format, ...);
+  void warn(const char *format, ...);
+  void warn(const std::string &format, ...);
+  void error(const char *format, ...);
+  void error(const std::string &format, ...);
+
+ private:
+  _Logger();
+
+  enum _LogType {
+    _ltTrace,
+    _ltDebug,
+    _ltInfo,
+    _ltStartup,
+    _ltWarn,
+    _ltError
+  };
+
+  void log(_LogType lt, const char *format, va_list &args);
+
+  spdlog::logger m_log;
+};
+
+class Logger {
+ public:
+
+  static void init(const char *app, const bool log_stdout,
+                   const bool log_rot_file) {
+    singleton()._init(app, log_stdout, log_rot_file);
+  }
+  static void init(const std::string &app, const bool log_stdout,
+                   const bool log_rot_file) {
+    init(app.c_str(), log_stdout, log_rot_file);
+  }
+
+  static _Logger& async_cmd() {
+    return *singleton().m_async_cmd;
+  }
+  static _Logger& itti() {
+    return *singleton().m_itti;
+  }
+  static _Logger& smf_app() {
+    return *singleton().m_smf_app;
+  }
+  static _Logger& system() {
+    return *singleton().m_system;
+  }
+  static _Logger& udp() {
+    return *singleton().m_udp;
+  }
+  static _Logger& pfcp() {
+    return *singleton().m_pfcp;
+  }
+  static _Logger& pfcp_switch() {
+    return *singleton().m_pfcp_switch;
+  }
+
+  static _Logger& smf_n1() {
+    return *singleton().m_smf_n1;
+  }
+  static _Logger& smf_n2() {
+    return *singleton().m_smf_n2;
+  }
+  static _Logger& smf_n4() {
+    return *singleton().m_smf_n4;
+  }
+  static _Logger& smf_n10() {
+    return *singleton().m_smf_n10;
+  }
+  static _Logger& smf_n11() {
+    return *singleton().m_smf_n11;
+  }
+  static _Logger& smf_api_server() {
+    return *singleton().m_smf_api_server;
+  }
+
+ private:
+  static Logger *m_singleton;
+  static Logger& singleton() {
+    if (!m_singleton)
+      m_singleton = new Logger();
+    return *m_singleton;
+  }
+
+  Logger() {
+  }
+  ~Logger() {
+  }
+
+  void _init(const char *app, const bool log_stdout, const bool log_rot_file);
+
+  std::vector<spdlog::sink_ptr> m_sinks;
+
+  std::string m_pattern;
+
+  _Logger *m_async_cmd;
+  _Logger *m_itti;
+  _Logger *m_smf_app;
+  _Logger *m_system;
+  _Logger *m_udp;
+  _Logger *m_pfcp;
+  _Logger *m_pfcp_switch;
+  _Logger *m_smf_n1;
+  _Logger *m_smf_n2;
+  _Logger *m_smf_n4;
+  _Logger *m_smf_n10;
+  _Logger *m_smf_n11;
+  _Logger *m_smf_api_server;
+};
+
+#endif // __LOGGER_H

src/common/utils/CMakeLists.txt

+################################################################################
+# Licensed to the OpenAirInterface (OAI) Software Alliance under one or more