-cmake_minimum_required (VERSION 2.8.11)
+cmake_minimum_required (VERSION 3.4.3)
project (snort CXX C)
set (VERSION_MAJOR 3)
set (VERSION_MINOR 0)
-set (VERSION_BUILD 0)
-set (VERSION
- "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_BUILD}")
+set (VERSION_PATCH 0)
+set (VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
-set (INCLUDE_SUFFIX "${CMAKE_PROJECT_NAME}")
-set (INCLUDE_INSTALL_PATH "include/${INCLUDE_SUFFIX}")
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
-set (CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+set (CMAKE_C_STANDARD 99)
+set (CMAKE_C_STANDARD_REQUIRED ON)
+set (CMAKE_C_EXTENSIONS ON)
-include (cmake/macros.cmake)
-include (cmake/create_options.cmake)
-include (cmake/include_libraries.cmake)
-include (cmake/platforms.cmake)
-include (cmake/configure_options.cmake)
-include (cmake/CheckCXX11Features.cmake)
-#include (cmake/compiler_features.cmake)
-include (cmake/sanity_checks.cmake)
+set (CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
+# Pull in definitions of various install directories
+include (GNUInstallDirs)
+include (${CMAKE_MODULE_PATH}/macros.cmake)
+include (${CMAKE_MODULE_PATH}/create_options.cmake)
+include (${CMAKE_MODULE_PATH}/include_libraries.cmake)
+include (${CMAKE_MODULE_PATH}/platforms.cmake)
+include (${CMAKE_MODULE_PATH}/configure_options.cmake)
+#include (${CMAKE_MODULE_PATH}/compiler_features.cmake)
+include (${CMAKE_MODULE_PATH}/sanity_checks.cmake)
+
+set (INSTALL_SUFFIX "${CMAKE_PROJECT_NAME}")
+set (INCLUDE_INSTALL_PATH "${CMAKE_INSTALL_INCLUDEDIR}/${INSTALL_SUFFIX}")
+set (PLUGIN_INSTALL_PATH "${CMAKE_INSTALL_LIBDIR}/${INSTALL_SUFFIX}")
configure_file (
"${PROJECT_SOURCE_DIR}/config.cmake.h.in"
"${PROJECT_BINARY_DIR}/config.h"
- )
+)
add_definitions( -DHAVE_CONFIG_H )
-# CMAKE_CXX_* properties aren't supported in 2.x :(
-# set (CMAKE_CXX_STANDARD 11)
-# set (CMAKE_CXX_STANDARD_REQUIRED ON)
-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX11_COMPILER_FLAGS}")
-
-# FIXIT - there is probably a better way to do this
-set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99")
-
-# Apply sanitizer compiler and linker flags
-set ( CMAKE_C_FLAGS "${SANITIZER_CXXFLAGS} ${CMAKE_C_FLAGS}" )
-set ( CMAKE_CXX_FLAGS "${SANITIZER_CXXFLAGS} ${CMAKE_CXX_FLAGS}" )
+# Set these after all tests are done but *before* any subdirectories are included
+# or other targets declared.
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${EXTRA_LINKER_FLAGS}")
+set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${EXTRA_LINKER_FLAGS}")
+foreach (EXTRA_LIBRARY IN LISTS EXTRA_LIBRARIES)
+ link_libraries(${EXTRA_LIBRARY})
+endforeach (EXTRA_LIBRARY)
include_directories (${PROJECT_BINARY_DIR})
include_directories (${PROJECT_SOURCE_DIR})
if (ENABLE_UNIT_TESTS)
include(CTest)
add_custom_target (check COMMAND ${CMAKE_CTEST_COMMAND})
- add_dependencies (check snort)
- #add_test (catch_tests ${CMAKE_CURRENT_BINARY_DIR}/src/snort --catch-test all)
endif (ENABLE_UNIT_TESTS)
add_subdirectory (src)
add_subdirectory (doc)
add_subdirectory (daqs)
-# Miscellaneous stuff. Does NOT directly effect snort's building environment
-include (cmake/packaging_data.cmake)
-include (cmake/create_pkg_config.cmake)
+# Miscellaneous stuff. Does NOT directly affect Snort's build environment.
+include (${CMAKE_MODULE_PATH}/packaging_data.cmake)
+include (${CMAKE_MODULE_PATH}/create_pkg_config.cmake)
# uninstall target
configure_file(
add_custom_target(uninstall
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+
+message("
+-------------------------------------------------------
+${CMAKE_PROJECT_NAME} version ${VERSION}
+
+Install options:
+ prefix: ${CMAKE_INSTALL_PREFIX}
+ includes: ${CMAKE_INSTALL_FULL_INCLUDEDIR}/${INSTALL_SUFFIX}
+ plugins: ${CMAKE_INSTALL_FULL_LIBDIR}/${INSTALL_SUFFIX}
+
+Compiler options:
+ CC: ${CMAKE_C_COMPILER}
+ CXX: ${CMAKE_CXX_COMPILER}
+ CFLAGS: ${CMAKE_C_FLAGS}
+ CXXFLAGS: ${CMAKE_CXX_FLAGS}
+ EXE_LDFLAGS: ${CMAKE_EXE_LINKER_FLAGS}
+ MODULE_LDFLAGS: ${CMAKE_MODULE_LINKER_FLAGS}
+
+Feature options:\
+")
+
+if (HAVE_FLATBUFFERS)
+ message("\
+ Flatbuffers: ON")
+else ()
+ message("\
+ Flatbuffers: OFF")
+endif ()
+
+if (HAVE_HYPERSCAN)
+ message("\
+ Hyperscan: ON")
+else ()
+ message("\
+ Hyperscan: OFF")
+endif ()
+
+if (HAVE_ICONV)
+ message("\
+ ICONV: ON")
+else ()
+ message("\
+ ICONV: OFF")
+endif ()
+
+if (HAVE_LZMA)
+ message("\
+ LZMA: ON")
+else ()
+ message("\
+ LZMA: OFF")
+endif ()
+
+if (HAVE_SAFEC AND SAFEC_ENABLED)
+ message("\
+ SafeC: ON")
+else ()
+ message("\
+ SafeC: OFF")
+endif ()
+
+if (HAVE_UUID)
+ message("\
+ UUID: ON")
+else ()
+ message("\
+ UUID: OFF")
+endif ()
+
+message("-------------------------------------------------------\n")
+++ /dev/null
-# - Check which parts of the C++11 standard the compiler supports
-#
-# When found it will set the following variables
-#
-# CXX11_COMPILER_FLAGS - the compiler flags needed to get C++11 features
-#
-# HAS_CXX11_AUTO - auto keyword
-# HAS_CXX11_AUTO_RET_TYPE - function declaration with deduced return types
-# HAS_CXX11_CLASS_OVERRIDE - override and final keywords for classes and methods
-# HAS_CXX11_CONSTEXPR - constexpr keyword
-# HAS_CXX11_CSTDINT_H - cstdint header
-# HAS_CXX11_DECLTYPE - decltype keyword
-# HAS_CXX11_FUNC - __func__ preprocessor constant
-# HAS_CXX11_INITIALIZER_LIST - initializer list
-# HAS_CXX11_LONG_LONG - long long signed & unsigned types
-# HAS_CXX11_NULLPTR - nullptr
-# HAS_CXX11_RVALUE_REFERENCES - rvalue references
-# HAS_CXX11_SIZEOF_MEMBER - sizeof() non-static members
-# HAS_CXX11_STATIC_ASSERT - static_assert()
-
-#=============================================================================
-# Copyright 2011,2012 Rolf Eike Beer <eike@sf-mail.de>
-# Copyright 2012 Andreas Weis
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-# License text for the above reference.)
-
-if (NOT CMAKE_CXX_COMPILER_LOADED)
- message(FATAL_ERROR "CheckCXX11Features modules only works if language CXX is enabled")
-endif ()
-
-cmake_minimum_required(VERSION 2.8.3)
-
-#
-### Check for needed compiler flags
-#
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-std=c++11" _HAS_CXX11_FLAG)
-if (NOT _HAS_CXX11_FLAG)
- check_cxx_compiler_flag("-std=c++0x" _HAS_CXX0X_FLAG)
-endif ()
-
-if (_HAS_CXX11_FLAG)
- set(CXX11_COMPILER_FLAGS "-std=c++11")
-elseif (_HAS_CXX0X_FLAG)
- set(CXX11_COMPILER_FLAGS "-std=c++0x")
-endif ()
-
-function(cxx11_check_feature FEATURE_NAME RESULT_VAR)
- if (NOT DEFINED ${RESULT_VAR})
- set(_bindir "${CMAKE_CURRENT_BINARY_DIR}/cxx11_${FEATURE_NAME}")
-
- set(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/CheckCXX11Features/cxx11-test-${FEATURE_NAME})
- set(_LOG_NAME "\"${FEATURE_NAME}\"")
- message(STATUS "Checking C++11 support for ${_LOG_NAME}")
-
- set(_SRCFILE "${_SRCFILE_BASE}.cpp")
- set(_SRCFILE_FAIL "${_SRCFILE_BASE}_fail.cpp")
- set(_SRCFILE_FAIL_COMPILE "${_SRCFILE_BASE}_fail_compile.cpp")
-
- if (CROSS_COMPILING)
- try_compile(${RESULT_VAR} "${_bindir}" "${_SRCFILE}"
- COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
- if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
- try_compile(${RESULT_VAR} "${_bindir}_fail" "${_SRCFILE_FAIL}"
- COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
- endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
- else (CROSS_COMPILING)
- try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
- "${_bindir}" "${_SRCFILE}"
- COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
- if (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
- set(${RESULT_VAR} TRUE)
- else (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
- set(${RESULT_VAR} FALSE)
- endif (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
- if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
- try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
- "${_bindir}_fail" "${_SRCFILE_FAIL}"
- COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
- if (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
- set(${RESULT_VAR} TRUE)
- else (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
- set(${RESULT_VAR} FALSE)
- endif (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
- endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
- endif (CROSS_COMPILING)
- if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
- try_compile(_TMP_RESULT "${_bindir}_fail_compile" "${_SRCFILE_FAIL_COMPILE}"
- COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
- if (_TMP_RESULT)
- set(${RESULT_VAR} FALSE)
- else (_TMP_RESULT)
- set(${RESULT_VAR} TRUE)
- endif (_TMP_RESULT)
- endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
-
- if (${RESULT_VAR})
- message(STATUS "Checking C++11 support for ${_LOG_NAME}: works")
- else (${RESULT_VAR})
- message(STATUS "Checking C++11 support for ${_LOG_NAME}: not supported")
- endif (${RESULT_VAR})
- set(${RESULT_VAR} ${${RESULT_VAR}} CACHE INTERNAL "C++11 support for ${_LOG_NAME}")
- endif (NOT DEFINED ${RESULT_VAR})
-endfunction(cxx11_check_feature)
-
-cxx11_check_feature("__func__" HAS_CXX11_FUNC)
-cxx11_check_feature("auto" HAS_CXX11_AUTO)
-cxx11_check_feature("auto_ret_type" HAS_CXX11_AUTO_RET_TYPE)
-cxx11_check_feature("class_override_final" HAS_CXX11_CLASS_OVERRIDE)
-cxx11_check_feature("constexpr" HAS_CXX11_CONSTEXPR)
-cxx11_check_feature("cstdint" HAS_CXX11_CSTDINT_H)
-cxx11_check_feature("decltype" HAS_CXX11_DECLTYPE)
-cxx11_check_feature("initializer_list" HAS_CXX11_INITIALIZER_LIST)
-cxx11_check_feature("long_long" HAS_CXX11_LONG_LONG)
-cxx11_check_feature("nullptr" HAS_CXX11_NULLPTR)
-cxx11_check_feature("rvalue-references" HAS_CXX11_RVALUE_REFERENCES)
-cxx11_check_feature("sizeof_member" HAS_CXX11_SIZEOF_MEMBER)
-cxx11_check_feature("static_assert" HAS_CXX11_STATIC_ASSERT)
+++ /dev/null
-int main(void)
-{
- if (!__func__)
- return 1;
- if (!(*__func__))
- return 1;
- return 0;
-}
+++ /dev/null
-
-int main()
-{
- auto i = 5;
- auto f = 3.14159f;
- auto d = 3.14159;
- bool ret = (
- (sizeof(f) < sizeof(d)) &&
- (sizeof(i) == sizeof(int))
- );
- return ret ? 0 : 1;
-}
+++ /dev/null
-int main(void)
-{
- // must fail because there is no initializer
- auto i;
-
- return 0;
-}
+++ /dev/null
-auto foo(int i) -> int {
- return i - 1;
-}
-
-int main()
-{
- return foo(1);
-}
+++ /dev/null
-class base {
-public:
- virtual int foo(int a)
- { return 4 + a; }
- int bar(int a) final
- { return a - 2; }
-};
-
-class sub final : public base {
-public:
- virtual int foo(int a) override
- { return 8 + 2 * a; };
-};
-
-int main(void)
-{
- base b;
- sub s;
-
- return (b.foo(2) * 2 == s.foo(2)) ? 0 : 1;
-}
+++ /dev/null
-class base {
-public:
- virtual int foo(int a)
- { return 4 + a; }
- virtual int bar(int a) final
- { return a - 2; }
-};
-
-class sub final : public base {
-public:
- virtual int foo(int a) override
- { return 8 + 2 * a; };
- virtual int bar(int a)
- { return a; }
-};
-
-class impossible : public sub { };
-
-int main(void)
-{
- base b;
- sub s;
-
- return 1;
-}
+++ /dev/null
-constexpr int square(int x)
-{
- return x*x;
-}
-
-constexpr int the_answer()
-{
- return 42;
-}
-
-int main()
-{
- int test_arr[square(3)];
- bool ret = (
- (square(the_answer()) == 1764) &&
- (sizeof(test_arr)/sizeof(test_arr[0]) == 9)
- );
- return ret ? 0 : 1;
-}
+++ /dev/null
-#include <cstdint>
-
-int main()
-{
- bool test =
- (sizeof(int8_t) == 1) &&
- (sizeof(int16_t) == 2) &&
- (sizeof(int32_t) == 4) &&
- (sizeof(int64_t) == 8);
- return test ? 0 : 1;
-}
+++ /dev/null
-bool check_size(int i)
-{
- return sizeof(int) == sizeof(decltype(i));
-}
-
-int main()
-{
- bool ret = check_size(42);
- return ret ? 0 : 1;
-}
+++ /dev/null
-#include <vector>
-
-class seq {
-public:
- seq(std::initializer_list<int> list);
-
- int length() const;
-private:
- std::vector<int> m_v;
-};
-
-seq::seq(std::initializer_list<int> list)
- : m_v(list)
-{
-}
-
-int seq::length() const
-{
- return m_v.size();
-}
-
-int main(void)
-{
- seq a = {18, 20, 2, 0, 4, 7};
-
- return (a.length() == 6) ? 0 : 1;
-}
+++ /dev/null
-int main(void)
-{
- long long l;
- unsigned long long ul;
-
- return ((sizeof(l) >= 8) && (sizeof(ul) >= 8)) ? 0 : 1;
-}
+++ /dev/null
-int main(void)
-{
- void *v = nullptr;
-
- return v ? 1 : 0;
-}
+++ /dev/null
-int main(void)
-{
- int i = nullptr;
-
- return 1;
-}
+++ /dev/null
-#include <cassert>
-
-class rvmove {
-public:
- void *ptr;
- char *array;
-
- rvmove()
- : ptr(0),
- array(new char[10])
- {
- ptr = this;
- }
-
- rvmove(rvmove &&other)
- : ptr(other.ptr),
- array(other.array)
- {
- other.array = 0;
- other.ptr = 0;
- }
-
- ~rvmove()
- {
- assert(((ptr != 0) && (array != 0)) || ((ptr == 0) && (array == 0)));
- delete[] array;
- }
-
- rvmove &operator=(rvmove &&other)
- {
- delete[] array;
- ptr = other.ptr;
- array = other.array;
- other.array = 0;
- other.ptr = 0;
- return *this;
- }
-
- static rvmove create()
- {
- return rvmove();
- }
-private:
- rvmove(const rvmove &);
- rvmove &operator=(const rvmove &);
-};
-
-int main()
-{
- rvmove mine;
- if (mine.ptr != &mine)
- return 1;
- mine = rvmove::create();
- if (mine.ptr == &mine)
- return 1;
- return 0;
-}
+++ /dev/null
-struct foo {
- char bar;
- int baz;
-};
-
-int main(void)
-{
- bool ret = (
- (sizeof(foo::bar) == 1) &&
- (sizeof(foo::baz) >= sizeof(foo::bar)) &&
- (sizeof(foo) >= sizeof(foo::bar) + sizeof(foo::baz))
- );
- return ret ? 0 : 1;
-}
+++ /dev/null
-struct foo {
- int baz;
- double bar;
-};
-
-int main(void)
-{
- return (sizeof(foo::bar) == 4) ? 0 : 1;
-}
+++ /dev/null
-int main(void)
-{
- static_assert(0 < 1, "your ordering of integers is screwed");
- return 0;
-}
+++ /dev/null
-int main(void)
-{
- static_assert(1 < 0, "your ordering of integers is screwed");
- return 0;
-}
--- /dev/null
+#
+# Loosely based on:
+# https://raw.githubusercontent.com/peti/autoconf-archive/master/m4/ax_code_coverage.m4
+# - and -
+# https://raw.githubusercontent.com/bilke/cmake-modules/master/CodeCoverage.cmake
+#
+
+find_program( GCOV_PATH gcov )
+
+if(NOT GCOV_PATH)
+ message(FATAL_ERROR "gcov not found! Aborting...")
+endif()
+
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+ if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+ message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+ endif()
+elseif(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+ message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+endif()
+
+set(COVERAGE_COMPILER_FLAGS "-O0 -g -fprofile-arcs -ftest-coverage")
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
+ set(COVERAGE_LINKER_FLAGS "")
+ set(COVERAGE_LIBRARIES "gcov")
+else()
+ set(COVERAGE_LINKER_FLAGS "--coverage")
+ set(COVERAGE_LIBRARIES "")
+endif()
+
+mark_as_advanced(
+ COVERAGE_COMPILER_FLAGS
+ COVERAGE_LINKER_FLAGS
+ COVERAGE_LIBRARIES
+)
check_cxx_compiler_flag ( "-Wdate-time" HAS_WDATE_TIME_CPPFLAG )
if ( HAS_WDATE_TIME_CPPFLAG )
- set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wdate-time" )
+ set ( HARDENED_CXX_FLAGS "${HARDENED_CXX_FLAGS} -Wdate-time" )
endif ()
check_cxx_compiler_flag ( "-D_FORTIFY_SOURCE=2" HAS_FORTIFY_SOURCE_2_CPPFLAG )
if ( HAS_FORTIFY_SOURCE_2_CPPFLAG )
- set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_FORTIFY_SOURCE=2" )
+ set ( HARDENED_CXX_FLAGS "${HARDENED_CXX_FLAGS} -D_FORTIFY_SOURCE=2" )
endif ()
check_cxx_compiler_flag ( "-fstack-protector-strong" HAS_FSTACK_PROTECTOR_STRONG_CXXFLAG )
if ( HAS_FSTACK_PROTECTOR_STRONG_CXXFLAG )
- set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-strong" )
+ set ( HARDENED_CXX_FLAGS "${HARDENED_CXX_FLAGS} -fstack-protector-strong" )
endif ()
check_cxx_compiler_flag ( "-Wformat" HAS_WFORMAT_CXXFLAG )
if ( HAS_WFORMAT_CXXFLAG )
- set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat" )
+ set ( HARDENED_CXX_FLAGS "${HARDENED_CXX_FLAGS} -Wformat" )
endif ()
check_cxx_compiler_flag ( "-Werror=format-security" HAS_WERROR_FORMAT_SECURITY_CXXFLAG )
if ( HAS_WERROR_FORMAT_SECURITY_CXXFLAG )
- set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=format-security" )
+ set ( HARDENED_CXX_FLAGS "${HARDENED_CXX_FLAGS} -Werror=format-security" )
endif ()
set ( CMAKE_REQUIRED_FLAGS "-Wl,-z,relro" )
check_cxx_compiler_flag ( "" HAS_ZRELRO_LDFLAG )
if ( HAS_ZRELRO_LDFLAG )
- set ( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-z,relro" )
- set ( CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-z,relro" )
+ set ( HARDENED_LINKER_FLAGS "${HARDENED_LINKER_FLAGS} -Wl,-z,relro" )
endif ()
unset ( CMAKE_REQUIRED_FLAGS )
set ( CMAKE_REQUIRED_FLAGS "-Wl,-z,now" )
check_cxx_compiler_flag ( "-Wl,-z,now" HAS_ZNOW_LDFLAG )
if ( HAS_ZNOW_LDFLAG )
- set ( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-z,now" )
- set ( CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-z,now" )
+ set ( HARDENED_LINKER_FLAGS "${HARDENED_LINKER_FLAGS} -Wl,-z,now" )
endif ()
unset ( CMAKE_REQUIRED_FLAGS )
if ( ENABLE_PIE )
check_cxx_compiler_flag ( "-fPIE -pie" HAS_PIE_SUPPORT )
if ( HAS_PIE_SUPPORT )
- set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIE" )
- set ( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fPIE -pie" )
- set ( CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -fPIE -pie" )
+ set ( HARDENED_CXX_FLAGS "${HARDENED_CXX_FLAGS} -fPIE" )
+ set ( HARDENED_LINKER_FLAGS "${HARDENED_LINKER_FLAGS} -fPIE -pie" )
endif ()
endif ( ENABLE_PIE )
set ( DEBUG ${ENABLE_DEBUG} )
if ( ENABLE_DEBUG )
- set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g" )
+ set ( DEBUGGING_C_FLAGS "${DEBUGGING_C_FLAGS} -g -DDEBUG" )
endif ( ENABLE_DEBUG )
if ( ENABLE_GDB )
- set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -ggdb" )
+ set ( DEBUGGING_C_FLAGS "${DEBUGGING_C_FLAGS} -g -ggdb" )
endif ( ENABLE_GDB )
if ( ENABLE_PROFILE AND CMAKE_COMPILER_IS_GNUCXX )
- set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pg" )
+ set ( DEBUGGING_C_FLAGS "${DEBUGGING_C_FLAGS} -pg" )
endif ( ENABLE_PROFILE AND CMAKE_COMPILER_IS_GNUCXX )
if ( ENABLE_ADDRESS_SANITIZER )
- set ( SANITIZER_FLAGS "-fsanitize=address -fno-omit-frame-pointer" )
+ set ( SANITIZER_CXX_FLAGS "-fsanitize=address -fno-omit-frame-pointer" )
- set ( CMAKE_REQUIRED_FLAGS "${SANITIZER_LDFLAGS} -fsanitize=address" )
- check_cxx_compiler_flag ( "${SANITIZER_FLAGS}" HAS_SANITIZE_ADDRESS_LDFLAG )
+ set ( CMAKE_REQUIRED_FLAGS "${SANITIZER_LINKER_FLAGS} -fsanitize=address" )
+ check_cxx_compiler_flag ( "${SANITIZER_CXX_FLAGS}" HAS_SANITIZE_ADDRESS_LDFLAG )
if ( HAS_SANITIZE_ADDRESS_LDFLAG )
- set ( SANITIZER_LDFLAGS "${SANITIZER_LDFLAGS} -fsanitize=address" )
- endif ()
- unset ( CMAKE_REQUIRED_FLAGS )
-
- set ( CMAKE_REQUIRED_FLAGS "${SANITIZER_LDFLAGS} -static-libasan" )
- check_cxx_compiler_flag ( "${SANITIZER_FLAGS}" HAS_STATIC_LIBASAN_LDFLAG )
- if ( HAS_STATIC_LIBASAN_LDFLAG )
- set ( SANITIZER_LDFLAGS "${SANITIZER_LDFLAGS} -static-libasan" )
+ set ( SANITIZER_LINKER_FLAGS "${SANITIZER_LINKER_FLAGS} -fsanitize=address" )
endif ()
unset ( CMAKE_REQUIRED_FLAGS )
endif ( ENABLE_ADDRESS_SANITIZER )
if ( ENABLE_THREAD_SANITIZER )
- set ( SANITIZER_CXXFLAGS "-fsanitize=thread -fno-omit-frame-pointer" )
+ set ( SANITIZER_CXX_FLAGS "-fsanitize=thread -fno-omit-frame-pointer" )
- set ( CMAKE_REQUIRED_FLAGS "${SANITIZER_LDFLAGS} -fsanitize=thread" )
- check_cxx_compiler_flag ( "${SANITIZER_CXXFLAGS}" HAS_SANITIZE_THREAD_LDFLAG )
+ set ( CMAKE_REQUIRED_FLAGS "${SANITIZER_LINKER_FLAGS} -fsanitize=thread" )
+ check_cxx_compiler_flag ( "${SANITIZER_CXX_FLAGS}" HAS_SANITIZE_THREAD_LDFLAG )
if ( HAS_SANITIZE_THREAD_LDFLAG )
- set ( SANITIZER_LDFLAGS "${SANITIZER_LDFLAGS} -fsanitize=thread" )
- endif ()
- unset ( CMAKE_REQUIRED_FLAGS )
-
- set ( CMAKE_REQUIRED_FLAGS "${SANITIZER_LDFLAGS} -static-libtsan" )
- check_cxx_compiler_flag ( "${SANITIZER_CXXFLAGS}" HAS_STATIC_LIBTSAN_LDFLAG )
- if ( HAS_STATIC_LIBTSAN_LDFLAG )
- set ( SANITIZER_LDFLAGS "${SANITIZER_LDFLAGS} -static-libtsan" )
+ set ( SANITIZER_LINKER_FLAGS "${SANITIZER_LINKER_FLAGS} -fsanitize=thread" )
endif ()
unset ( CMAKE_REQUIRED_FLAGS )
endif ( ENABLE_THREAD_SANITIZER )
if ( ENABLE_CODE_COVERAGE )
- set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g -fprofile-arcs -ftest-coverage" )
- set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -fprofile-arcs -ftest-coverage" )
-
- if ( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" )
- set ( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lgcov" )
- endif ()
+ include(${CMAKE_MODULE_PATH}/CodeCoverage.cmake)
endif ( ENABLE_CODE_COVERAGE )
+
+# Accumulate extra flags and libraries
+#[[
+message("
+ HARDENED_CXX_FLAGS = ${HARDENED_CXX_FLAGS}
+ HARDENED_LINKER_FLAGS = ${HARDENED_LINKER_FLAGS}
+ DEBUGGING_C_FLAGS = ${DEBUGGING_C_FLAGS}
+ SANITIZER_CXX_FLAGS = ${SANITIZER_CXX_FLAGS}
+ SANITIZER_LINKER_FLAGS = ${SANITIZER_LINKER_FLAGS}
+ COVERAGE_COMPILER_FLAGS = ${COVERAGE_COMPILER_FLAGS}
+ COVERAGE_LINKER_FLAGS = ${COVERAGE_LINKER_FLAGS}
+ COVERAGE_LIBRARIES = ${COVERAGE_LIBRARIES}
+")
+]]
+set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} ${HARDENED_CXX_FLAGS} ${DEBUGGING_C_FLAGS} ${SANITIZER_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" )
+set ( EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} ${HARDENED_CXX_FLAGS} ${DEBUGGING_C_FLAGS} ${SANITIZER_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" )
+set ( EXTRA_LINKER_FLAGS "${EXTRA_LINKER_FLAGS} ${HARDENED_LINKER_FLAGS} ${SANITIZER_LINKER_FLAGS} ${COVERAGE_LINKER_FLAGS}" )
+foreach (EXTRA_LIBRARY IN LISTS COVERAGE_LIBRARIES)
+ list ( APPEND EXTRA_LIBRARIES ${EXTRA_LIBRARY} )
+endforeach ()
SIGNAL_SNORT_READ_ATTR_TBL "SIGURG"
CACHE STRING "set the SNORT_READ_ATTR_TBL signal (must be a valid integer or signal name)"
)
-
-#Setting default directories...appended to INSTALL_PREFIX unless a full path is provided
-set ( SNORT_DATA_DIR share/doc/${CMAKE_PROJECT_NAME} )
-
set(prefix "${CMAKE_INSTALL_PREFIX}")
set(exec_prefix "\${prefix}")
set(bindir "\${exec_prefix}/bin")
-set(libdir "\${exec_prefix}/lib")
+set(libdir "\${prefix}/${CMAKE_INSTALL_LIBDIR}")
set(includedir "\${prefix}/include")
set(datarootdir "\${prefix}/share")
set(datadir "\${datarootdir}")
)
install (FILES ${CMAKE_BINARY_DIR}/snort.pc
- DESTINATION "lib/pkgconfig/"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig/"
)
install (
TARGETS ${libname}
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/${install_path}"
+ DESTINATION "${PLUGIN_INSTALL_PATH}/${install_path}"
)
endmacro (add_dynamic_module)
-#anything following testname is assumed to be a link dependency
-macro (add_cpputest testname)
+function (add_cpputest testname)
if ( ENABLE_UNIT_TESTS )
- add_executable (${testname} EXCLUDE_FROM_ALL ${testname}.cc)
- target_include_directories (${testname} PRIVATE ${CPPUTEST_INCLUDE_DIR})
- target_link_libraries (${testname} ${CPPUTEST_LIBRARIES} ${ARGN})
- add_test (${testname} ${testname})
- add_dependencies ( check ${testname} )
+ set(multiValueArgs SOURCES LIBS)
+ cmake_parse_arguments(CppUTest "" "" "${multiValueArgs}" ${ARGN})
+ add_executable(${testname} EXCLUDE_FROM_ALL ${testname}.cc ${CppUTest_SOURCES})
+ target_include_directories(${testname} PRIVATE ${CPPUTEST_INCLUDE_DIR})
+ target_link_libraries(${testname} ${CPPUTEST_LIBRARIES} ${CppUTest_LIBS})
+ add_test(${testname} ${testname})
+ add_dependencies(check ${testname})
endif ( ENABLE_UNIT_TESTS )
-endmacro (add_cpputest)
+endfunction (add_cpputest)
set (CPACK_PACKAGE_VENDOR "Cisco")
set (CPACK_PACKAGE_VERSION_MAJOR "${VERSION_MAJOR}")
set (CPACK_PACKAGE_VERSION_MINOR "${VERSION_MINOR}")
-set (CPACK_PACKAGE_VERSION_PATCH "${VERSION_BUILD}-${VERSION_RELEASE}")
+set (CPACK_PACKAGE_VERSION_PATCH "${VERSION_PATCH}")
set (CPACK_PACKAGE_ICON "${CMAKE_SOURCE_DIR}/doc/images/snort.png")
set (CPACK_PACKAGE_INSTALL_DIRECTORY "snort")
set (CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
set (CMAKE_SKIP_RPATH ON)
-
-if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
- if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.8")
- message(FATAL_ERROR "G++ version 4.8 or greater required")
+if (${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
+ set(GNUCXX_MINVER "4.8.1")
+ message(STATUS "g++ version ${CMAKE_CXX_COMPILER_VERSION}")
+ if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS GNUCXX_MINVER)
+ message(FATAL_ERROR "A minimum of g++ ${GNUCXX_MINVER} is required for C++11 support")
endif()
endif()
-# the Clang compiler on MacOS X may need the c++ library explicityly specified
+# the Clang compiler on MacOS X may need the c++ library explicitly specified
if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
endif()
endif()
-
+include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
-set (CMAKE_REQUIRED_FLAGS "-fvisibility=hidden")
-check_cxx_compiler_flag (${CMAKE_REQUIRED_FLAGS} HAVE_VISIBILITY)
-if (HAVE_VISIBILITY)
- set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_REQUIRED_FLAGS}")
-endif ()
-unset(CMAKE_REQUIRED_FLAGS)
+CHECK_C_COMPILER_FLAG(-fvisibility=hidden HAS_C_HIDDEN)
+if (HAS_C_HIDDEN)
+ set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fvisibility=hidden")
+ set(HAVE_VISIBILITY 1)
+endif()
+
+CHECK_CXX_COMPILER_FLAG(-fvisibility=hidden HAS_CXX_HIDDEN)
+if (HAS_CXX_HIDDEN)
+ set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -fvisibility=hidden")
+ set(HAVE_VISIBILITY 1)
+endif()
+
include(CheckCXXSourceCompiles)
-#UNCONVERTED AUTOTOOL OPTION
-
-#AC_FUNC_ALLOCA
-
-
include (TestBigEndian)
test_big_endian(WORDS_BIGENDIAN)
-#check include files
-check_include_file_cxx("arpa/inet.h" HAVE_ARPA_INET_H)
-check_include_file_cxx("fcntl.h" HAVE_FCNTL_H)
-check_include_file_cxx("inttypes.h" HAVE_INTTYPES_H)
-check_include_file_cxx("libintl.h" HAVE_LIBINTL_H)
-check_include_file_cxx("limits.h" HAVE_LIMITS_H)
-check_include_file_cxx("malloc.h" HAVE_MALLOC_H)
-check_include_file_cxx("netdb.h" HAVE_NETDB_H)
-check_include_file_cxx("netinet/in.h" HAVE_NETINET_IN_H)
-check_include_file_cxx("stddef.h" HAVE_STDDEF_H)
-check_include_file_cxx("stdint.h" HAVE_STDINT_H)
-check_include_file_cxx("stdlib.h" HAVE_STDLIB_H)
-check_include_file_cxx("string.h" HAVE_STRING_H)
-check_include_file_cxx("strings.h" HAVE_STRINGS_H)
-check_include_file_cxx("sys/socket.h" HAVE_SYS_SOCKET_H)
-check_include_file_cxx("sys/time.h" HAVE_SYS_TIME_H)
-check_include_file_cxx("syslog.h" HAVE_SYSLOG_H)
-check_include_file_cxx("unistd.h" HAVE_UNISTD_H)
-check_include_file_cxx("wchar.h" HAVE_WCHAR_H)
-
-
-
-# UNCONVERTED AUTOTOOL OPTIONS
-
-#AC_FUNC_MALLOC
-#AC_FUNC_REALLOC
-#AC_FUNC_STRERROR_R
-#AC_FUNC_STRTOD
-
-
-set (CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES} unistd.h")
-check_function_exists(chown HAVE_CHOWN)
-check_function_exists(fork HAVE_WORKING_FORK)
-check_function_exists(vfork HAVE_WORKING_VFORK)
-check_function_exists(malloc HAVE_FORK)
-
-
-check_function_exists(endgrent HAVE_ENDGRENT)
-check_function_exists(endpwent HAVE_ENDPWENT)
-check_function_exists(ftruncate HAVE_FTRUNCATE)
-check_function_exists(getcwd HAVE_GETCWD)
-check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
-check_function_exists(inet_ntoa HAVE_INET_NTOA)
-check_function_exists(isascii HAVE_ISASCII)
-check_function_exists(localtime_r HAVE_LOCALTIME_R)
-check_function_exists(memchr HAVE_MEMCHR)
-check_function_exists(memmove HAVE_MEMMOVE)
-check_function_exists(memset HAVE_MEMSET)
-check_function_exists(mkdir HAVE_MKDIR)
-check_function_exists(select HAVE_SELECT)
-check_function_exists(socket HAVE_SOCKET)
-check_function_exists(strcasecmp HAVE_STRCASECMP)
-check_function_exists(strchr HAVE_STRCHR)
-check_function_exists(strerror HAVE_STRERROR)
-check_function_exists(strncasecmp HAVE_STRNCASECMP)
-check_function_exists(strrchr HAVE_STRRCHR)
-check_function_exists(strstr HAVE_STRSTR)
-check_function_exists(strtol HAVE_STRTOL)
-check_function_exists(strtoul HAVE_STRTOUL)
-
-set (CMAKE_REQUIRED_INCLUDES)
-
-
-
-
#--------------------------------------------------------------------------
# Checks for typedefs, structures, and compiler characteristics.
#--------------------------------------------------------------------------
-check_type_size(int8_t INT8_T)
-check_type_size(int16_t INT16_T)
-check_type_size(int32_t INT32_T)
-check_type_size(int64_t INT64_T)
-check_type_size(uint8_t UINT8_T)
-check_type_size(uint16_t UINT16_T)
-check_type_size(uint32_t UINT32_T)
-check_type_size(uint64_t UINT64_T)
-check_type_size("char" SIZEOF_CHAR)
-check_type_size("short" SIZEOF_SHORT)
-check_type_size("int" SIZEOF_INT)
-check_type_size("unsigned int" SIZEOF_UNSIGNED_INT)
check_type_size("long int" SIZEOF_LONG_INT)
check_type_size("unsigned long int" SIZEOF_UNSIGNED_LONG_INT)
-check_type_size("long long int" SIZEOF_LONG_LONG_INT)
-check_type_size("unsigned long long int" SIZEOF_UNSIGNED_LONG_LONG_INT)
-
-check_type_size("uid_t" UID_T)
-check_type_size("pid_t" PID_T)
-check_type_size("size_t" SIZE_T)
-check_type_size("ssize_t" SSIZE_T)
-check_type_size("mode_t" MODE_T)
# vvvvvvvvv INLINE TEST vvvvvvvvv
/* enalbe debug messages */
#cmakedefine DEBUG_MSGS 1
-/* enable debug build */
-#cmakedefine DEBUG 1
-
-/* disable assertions */
-#cmakedefine NDEBUG 1
-
/* enable profiling */
#cmakedefine PROFILE 1
/* Print available system types and their sizes */
-/* Define to 1 if the system has the type `int16_t'. */
-#cmakedefine HAVE_INT16_T 1
-
-/* Define to 1 if the system has the type `int32_t'. */
-#cmakedefine HAVE_INT32_T 1
-
-/* Define to 1 if the system has the type `int64_t'. */
-#cmakedefine HAVE_INT64_T 1
-
-/* Define to 1 if the system has the type `int8_t'. */
-#cmakedefine HAVE_INT8_T 1
-
-/* Define to 1 if the system has the type `uint16_t'. */
-#cmakedefine HAVE_UINT16_T 1
-
-/* Define to 1 if the system has the type `uint32_t'. */
-#cmakedefine HAVE_UINT32_T 1
-
-/* Define to 1 if the system has the type `uint64_t'. */
-#cmakedefine HAVE_UINT64_T 1
-
-/* Define to 1 if the system has the type `uint8_t'. */
-#cmakedefine HAVE_UINT8_T 1
-
-/* The size of `char', as computed by sizeof. */
-#cmakedefine SIZEOF_CHAR @SIZEOF_CHAR@
-
-/* The size of `int', as computed by sizeof. */
-#cmakedefine SIZEOF_INT @SIZEOF_INT@
-
/* The size of `long int', as computed by sizeof. */
#cmakedefine SIZEOF_LONG_INT @SIZEOF_LONG_INT@
-/* The size of `long long int', as computed by sizeof. */
-#cmakedefine SIZEOF_LONG_LONG_INT @SIZEOF_LONG_LONG_INT@
-
-/* The size of `short', as computed by sizeof. */
-#cmakedefine SIZEOF_SHORT @SIZEOF_SHORT@
-
-/* The size of `unsigned int', as computed by sizeof. */
-#cmakedefine SIZEOF_UNSIGNED_INT @SIZEOF_UNSIGNED_INT@
-
/* The size of `unsigned long int', as computed by sizeof. */
#cmakedefine SIZEOF_UNSIGNED_LONG_INT @SIZEOF_UNSIGNED_LONG_INT@
-/* The size of `unsigned long long int', as computed by sizeof. */
-#cmakedefine SIZEOF_UNSIGNED_LONG_LONG_INT @SIZEOF_UNSIGNED_LONG_LONG_INT@
-
-/* Define to `unsigned int' if uid_t is undefined in the system */
-#cmakedefine uid_t unsigned int
-
-/* Define to `unsigned int' if pid_t is undefined in the system */
-#cmakedefine pid_t unsigned int
-
-/* Define to `unsigned int' if size_t is undefined in the system */
-#cmakedefine size_t unsigned int
-
-/* Define to `unsigned int' if ssize_t is undefined in the system */
-#cmakedefine ssize_t int
-
-/* Define to `int' if mode_t is undefined in the system */
-#cmakedefine mode_t int
-
/* Define if words are big endian */
#cmakedefine WORDS_BIGENDIAN 1
/* Header file definitions */
-/* Define to 1 if you have the <arpa/inet.h> header file. */
-#cmakedefine HAVE_ARPA_INET_H 1
-
-/* Define to 1 if you have the <fcntl.h> header file. */
-#cmakedefine HAVE_FCNTL_H 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#cmakedefine HAVE_INTTYPES_H 1
-
-/* Define to 1 if you have the <libintl.h> header file. */
-#cmakedefine HAVE_LIBINTL_H 1
-
-/* Define to 1 if you have the <limits.h> header file. */
-#cmakedefine HAVE_LIMITS_H 1
-
-/* Define to 1 if you have the <malloc.h> header file. */
-#cmakedefine HAVE_MALLOC_H 1
-
-/* Define to 1 if you have the <netdb.h> header file. */
-#cmakedefine HAVE_NETDB_H 1
-
-/* Define to 1 if you have the <netinet/in.h> header file. */
-#cmakedefine HAVE_NETINET_IN_H 1
-
-/* Define to 1 if you have the <stddef.h> header file. */
-#cmakedefine HAVE_STDDEF_H 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#cmakedefine HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#cmakedefine HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#cmakedefine HAVE_STRING_H 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#cmakedefine HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <syslog.h> header file. */
-#cmakedefine HAVE_SYSLOG_H 1
-
-/* Define to 1 if you have the <sys/socket.h> header file. */
-#cmakedefine HAVE_SYS_SOCKET_H 1
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#cmakedefine HAVE_SYS_TIME_H 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#cmakedefine HAVE_UNISTD_H 1
-
-/* Define to 1 if you have the <wchar.h> header file. */
-#cmakedefine HAVE_WCHAR_H 1
-
/* Define to 1 if you have the <dumbnet.h> header file. */
#cmakedefine HAVE_DUMBNET_H 1
macro ( add_daq_module libname )
add_dynamic_module ( ${libname} daqs ${ARGN} )
- set_target_properties (
- ${libname}
- PROPERTIES
- C_STANDARD 99
- )
endmacro ( add_daq_module )
-set ( DAQS_INCLUDES daq_user.h )
+set ( DAQS_HEADERS daq_user.h )
set(
EXTERNAL_INCLUDES
${DAQ_INCLUDE_DIR}
add_daq_module ( daq_file daq_file.c )
add_daq_module ( daq_hext daq_hext.c )
-install (FILES ${DAQS_INCLUDES}
+install (FILES ${DAQS_HEADERS}
DESTINATION "${INCLUDE_INSTALL_PATH}/daqs"
)
-include ( help.cmake )
add_custom_target ( snort_manuals ALL )
set (
wizard.txt
)
+function ( add_help_command generator_script output_file )
+ add_custom_command (
+ OUTPUT ${output_file}
+ COMMAND ${generator_script} $<TARGET_FILE:snort> ${output_file} $ENV{SNORT_PLUGIN_PATH}
+ DEPENDS snort
+ COMMENT "Documents: building ${output_file} with $ENV{SNORT_PLUGIN_PATH}"
+ )
+endfunction ( add_help_command )
+
foreach ( output_file ${HELP_SOURCES} )
add_help_command (
"${CMAKE_CURRENT_LIST_DIR}/scripts/generate_help.sh"
list (
APPEND
EXTRA_CLEAN
- "${CMAKE_CURRENT_BINARY_DIR}/snort_manual.html"
"${CMAKE_CURRENT_BINARY_DIR}/snort_manual.chunked"
"${CMAKE_CURRENT_BINARY_DIR}/snort_manual.tgz"
)
COMMAND rm -rf ${TEXT_DOC_TMP}
DEPENDS snort_manual.text
)
-
- list (
- APPEND
- EXTRA_CLEAN
- "${CMAKE_CURRENT_BINARY_DIR}/snort_manual.text"
- )
endif ( MAKE_TEXT_DOC )
if ( MAKE_PDF_DOC )
COMMAND rm -rf ${PDF_DOC_TMP}
DEPENDS snort_manual.pdf
)
-
- list (
- APPEND
- EXTRA_CLEAN
- "${CMAKE_CURRENT_BINARY_DIR}/snort_manual.pdf"
- )
endif ( MAKE_PDF_DOC )
install (
${BUILT_DIST}
${UNBUILT_SOURCES}
DESTINATION
- ${SNORT_DATA_DIR}
+ ${CMAKE_INSTALL_DOCDIR}
)
set (
EXTRA_CLEAN
${EXTRA_CLEAN}
${BINARY_DIR_BUILT_SOURCES}
- ${BINARY_DIR_UNBUILT_SOURCES}
)
+if ( NOT CMAKE_CURRENT_LIST_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR )
+ list (
+ APPEND
+ EXTRA_CLEAN
+ ${BINARY_DIR_UNBUILT_SOURCES}
+ )
+endif ()
+
if ( EXTRA_CLEAN )
set_property (
DIRECTORY
+++ /dev/null
-function ( add_help_command generator_script output_file )
-
- add_custom_command (
- OUTPUT ${output_file}
- COMMAND ${generator_script} $<TARGET_FILE:snort> ${output_file} $ENV{SNORT_PLUGIN_PATH}
- DEPENDS snort
- COMMENT "Documents: building ${output_file} with $ENV{SNORT_PLUGIN_PATH}"
- )
-
-endfunction ( add_help_command )
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project( snort_extra CXX C )
set (EXTRA_VERSION_MAJOR 1)
set (EXTRA_VERSION_MINOR 0)
set (EXTRA_VERSION_BUILD 0-a4)
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
+set (CMAKE_C_STANDARD 99)
+set (CMAKE_C_STANDARD_REQUIRED ON)
+set (CMAKE_C_EXTENSIONS ON)
+
+# Pull in definitions of various install directories
+include (GNUInstallDirs)
+
set (AUTOTOOL_FILES "autom4te.cache;m4;configure.ac;Makefile.am")
set (CPACK_GENERATOR TGZ)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_eapol CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_eapol PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_eapol
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_linux_sll CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_linux_sll PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_linux_sll
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_null CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_null PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_null
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_pbb CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_pbb PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_pbb
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_pflog CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_pflog PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_pflog
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_ppp CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_ppp PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_ppp
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_raw4 CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_raw4 PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_raw4
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_raw6 CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_raw6 PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_raw6
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_slip CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_slip PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_slip
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_token_ring CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_token_ring PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_token_ring
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( cd_wlan CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
cd_wlan PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS cd_wlan
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/codecs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/codecs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( daq_regtest C )
+set (CMAKE_C_STANDARD 99)
+set (CMAKE_C_STANDARD_REQUIRED ON)
+set (CMAKE_C_EXTENSIONS ON)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99" )
-
target_include_directories (
daq_regtest PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS daq_regtest
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/daqs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/daqs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( daq_socket C )
+set (CMAKE_C_STANDARD 99)
+set (CMAKE_C_STANDARD_REQUIRED ON)
+set (CMAKE_C_EXTENSIONS ON)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99" )
-
target_include_directories (
daq_socket PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS daq_socket
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/daqs"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/daqs"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( data_log CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
data_log PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS data_log
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/inspectors"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/inspectors"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( dpx CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
dpx PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS dpx
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/inspectors"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/inspectors"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( reg_test CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
reg_test PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS reg_test
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/inspectors"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/inspectors"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( find )
install (
FILES find.lua
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/ips_options"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/ips_options"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( ips_mss CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
ips_mss PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS ips_mss
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/ips_options"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/ips_options"
)
AM_CXXFLAGS = @SNORT3_CFLAGS@ -std=c++11
ips_msslib_LTLIBRARIES = ips_mss.la
+ips_mss_la_CXXFLAGS = $(AM_CXXFLAGS)
ips_mss_la_LDFLAGS = -module -export-dynamic -avoid-version -shared
ips_mss_la_SOURCES = ips_mss.cc
if ( strcmp(s_name, ips.get_name()) )
return false;
- TcpMssOption& rhs = (TcpMssOption&)ips;
+ const TcpMssOption& rhs = (const TcpMssOption&)ips;
return ( config == rhs.config );
}
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( ips_pkt_num CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
ips_pkt_num PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS ips_pkt_num
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/ips_options"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/ips_options"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( ips_urg CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
ips_urg PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS ips_urg
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/ips_options"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/ips_options"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( ips_wscale CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
ips_wscale PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS ips_wscale
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/ips_options"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/ips_options"
)
AM_CXXFLAGS = @SNORT3_CFLAGS@ -std=c++11
ips_wscalelib_LTLIBRARIES = ips_wscale.la
+ips_wscale_la_CXXFLAGS = $(AM_CXXFLAGS)
ips_wscale_la_LDFLAGS = -module -export-dynamic -avoid-version -shared
ips_wscale_la_SOURCES = ips_wscale.cc
if ( strcmp(s_name, ips.get_name()) )
return false;
- TcpWscaleOption& rhs = (TcpWscaleOption&)ips;
+ const TcpWscaleOption& rhs = (const TcpWscaleOption&)ips;
return ( config == rhs.config );
}
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( alert_ex CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
alert_ex PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS alert_ex
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/loggers"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/loggers"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( alert_json CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
alert_json PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS alert_json
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/loggers"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/loggers"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( alert_lua )
install (
FILES alert.lua
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/loggers"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/loggers"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( alert_unixsock CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
alert_unixsock PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS alert_unixsock
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/loggers"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/loggers"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( log_null CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
log_null PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS log_null
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/loggers"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/loggers"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( lowmem CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
lowmem PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS lowmem
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/search_engines"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/search_engines"
)
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( sid_18758 CXX )
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-
target_include_directories (
sid_18758 PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS sid_18758
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/so_rules"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/so_rules"
)
%if @generate.project_boilerplate
-cmake_minimum_required ( VERSION 2.8.11 )
+cmake_minimum_required ( VERSION 3.4.3 )
project ( <%= @project.name %><% if @project.language == "CXX" %> CXX<% elsif @project.language == "C" %> C<% end %> )
%end
%if !@project.sources.empty?
%if @generate.platform_boilerplate
+%if @project.language == "CXX"
+set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+%elsif @project.language == "C"
+set (CMAKE_C_STANDARD 99)
+set (CMAKE_C_STANDARD_REQUIRED ON)
+set (CMAKE_C_EXTENSIONS ON)
+%end
+
if ( APPLE )
set ( CMAKE_MACOSX_RPATH OFF )
endif ( APPLE )
PREFIX ""
)
-%if @project.language == "CXX"
-set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-%elsif @project.language == "C"
-set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99" )
-%end
-
target_include_directories (
<%= @project.libname %> PUBLIC
${SNORT3_INCLUDE_DIRS}
install (
TARGETS <%= @project.libname %>
LIBRARY
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/<%= @project.dirname %>"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/<%= @project.dirname %>"
)
%end
%if !@project.scripts.empty?
install (
FILES<% for script in @project.scripts %> <%= script %><% end %>
- DESTINATION "lib/${CMAKE_PROJECT_NAME}/<%= @project.dirname %>"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/${CMAKE_PROJECT_NAME}/<%= @project.dirname %>"
)
%end
)
install (FILES ${LUA_SCRIPTS}
- DESTINATION "etc/snort"
+ DESTINATION "${CMAKE_INSTALL_SYSCONFDIR}/snort"
)
${ZLIB_INCLUDE_DIRS}
)
+if ( FLATBUFFERS_FOUND )
+ LIST(APPEND EXTERNAL_LIBRARIES ${FLATBUFFERS_LIBRARIES})
+endif()
+
if ( HS_FOUND )
LIST(APPEND EXTERNAL_LIBRARIES ${HS_LIBRARIES})
LIST(APPEND EXTERNAL_INCLUDES ${HS_INCLUDE_DIRS})
include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR})
include_directories(BEFORE network_inspectors)
-if (STATIC_CODECS)
- set (STATIC_CODEC_LIBRARIES
- link_codecs
- root_codecs
- )
-endif()
-
if (ENABLE_UNIT_TESTS)
enable_testing()
- set( UNIT_TESTS_LIBRARIES catch_tests)
+ set( UNIT_TESTS_LIBRARIES $<TARGET_OBJECTS:catch_tests>)
add_subdirectory(catch)
endif (ENABLE_UNIT_TESTS)
if ( ENABLE_PIGLET )
- set ( PIGLET_LIBRARIES piglet piglet_plugins )
+ set ( PIGLET_LIBRARIES $<TARGET_OBJECTS:piglet> $<TARGET_OBJECTS:piglet_plugins> )
add_subdirectory ( piglet )
add_subdirectory ( piglet_plugins )
endif ( ENABLE_PIGLET )
-# The main Snort executableRA
-add_executable( snort
- main.h
- main.cc
-)
-
-# order libs to avoid undefined symbols
-# from gnu linker
-target_link_libraries( snort
- ${UNIT_TESTS_LIBRARIES}
- managers
- main
- codecs
- loggers
- ip_codecs
- misc_codecs
- ${STATIC_CODEC_LIBRARIES}
- network_inspectors
- service_inspectors
-# include only those with otherwise unresolved dependencies
- appid
- http_inspect
- http2_inspect
- sip
- reputation
- stream
- stream_base
- stream_ip
- stream_icmp
- stream_tcp
- stream_libtcp
- stream_udp
- stream_user
- stream_file
- stream_paf
- mime
- ips_options
- search_engines
- target_based
- ${PIGLET_LIBRARIES}
- codec_module
- memory
- host_tracker
- pub_sub
- parser
- flow
- side_channel
- connectors
- file_connector
- control
- filter
- detection
- framework
- file_api
- latency
- profiler
- time
- ips_actions
- events
- hash
- log
- packet_io
- helpers
- lua
- decompress
- sfip
- sfrt
- protocols
- ports
- utils
- ${EXTERNAL_LIBRARIES}
-)
-
add_subdirectory(actions)
add_subdirectory(codecs)
add_subdirectory(control)
add_subdirectory(connectors)
+# FIXIT-L Delegate building out the target objects list to subdirectories
+
+# The main Snort executable
+add_executable( snort
+ main.h
+ main.cc
+ $<TARGET_OBJECTS:codecs>
+ $<TARGET_OBJECTS:connectors>
+ $<TARGET_OBJECTS:control>
+ $<TARGET_OBJECTS:decompress>
+ $<TARGET_OBJECTS:detection>
+ $<TARGET_OBJECTS:events>
+ $<TARGET_OBJECTS:file_api>
+ $<TARGET_OBJECTS:file_connector>
+ $<TARGET_OBJECTS:filter>
+ $<TARGET_OBJECTS:flow>
+ $<TARGET_OBJECTS:framework>
+ $<TARGET_OBJECTS:hash>
+ $<TARGET_OBJECTS:helpers>
+ $<TARGET_OBJECTS:host_tracker>
+ $<TARGET_OBJECTS:ips_actions>
+ $<TARGET_OBJECTS:ips_options>
+ $<TARGET_OBJECTS:latency>
+ $<TARGET_OBJECTS:log>
+ $<TARGET_OBJECTS:loggers>
+ $<TARGET_OBJECTS:lua>
+ $<TARGET_OBJECTS:main>
+ $<TARGET_OBJECTS:managers>
+ $<TARGET_OBJECTS:memory>
+ $<TARGET_OBJECTS:mime>
+ $<TARGET_OBJECTS:network_inspectors>
+ $<TARGET_OBJECTS:packet_io>
+ $<TARGET_OBJECTS:parser>
+ $<TARGET_OBJECTS:ports>
+ $<TARGET_OBJECTS:profiler>
+ $<TARGET_OBJECTS:protocols>
+ $<TARGET_OBJECTS:pub_sub>
+ $<TARGET_OBJECTS:search_engines>
+ $<TARGET_OBJECTS:service_inspectors>
+ $<TARGET_OBJECTS:sfip>
+ $<TARGET_OBJECTS:sfrt>
+ $<TARGET_OBJECTS:side_channel>
+ $<TARGET_OBJECTS:stream>
+ $<TARGET_OBJECTS:stream_base>
+ $<TARGET_OBJECTS:stream_ip>
+ $<TARGET_OBJECTS:stream_icmp>
+ $<TARGET_OBJECTS:stream_libtcp>
+ $<TARGET_OBJECTS:stream_tcp>
+ $<TARGET_OBJECTS:stream_udp>
+ $<TARGET_OBJECTS:stream_user>
+ $<TARGET_OBJECTS:stream_file>
+ $<TARGET_OBJECTS:stream_paf>
+ $<TARGET_OBJECTS:target_based>
+ $<TARGET_OBJECTS:tcp_connector>
+ $<TARGET_OBJECTS:time>
+ $<TARGET_OBJECTS:utils>
+ ${PIGLET_LIBRARIES}
+ ${STATIC_CODEC_PLUGINS}
+ ${STATIC_NETWORK_INSPECTOR_PLUGINS}
+ ${STATIC_SERVICE_INSPECTOR_PLUGINS}
+ ${UNIT_TESTS_LIBRARIES}
+)
+
+#[[
+message("
+ STATIC_CODEC_PLUGINS = ${STATIC_CODEC_PLUGINS}
+ STATIC_NETWORK_INSPECTOR_PLUGINS = ${STATIC_NETWORK_INSPECTOR_PLUGINS}
+ STATIC_SERVICE_INSPECTOR_PLUGINS = ${STATIC_SERVICE_INSPECTOR_PLUGINS}
+")
+]]
+
+target_link_libraries( snort
+ ${EXTERNAL_LIBRARIES}
+)
+
# setting export properties
set_property(TARGET snort APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES
${LUAJIT_INCLUDE_DIR}
set_property(TARGET snort APPEND PROPERTY INTERFACE_COMPILE_OPTIONS "${CMAKE_CXX_FLAGS}")
-set_target_properties(
- snort
- PROPERTIES
- LINK_FLAGS "${SANITIZER_LDFLAGS}"
-)
+set_property(TARGET snort PROPERTY ENABLE_EXPORTS 1)
install (TARGETS snort
- EXPORT snortexe
- RUNTIME DESTINATION bin
+ # EXPORT snortexe
+ RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
-install (EXPORT snortexe
- DESTINATION lib/snort
- FILE snort.cmake
-)
+# FIXIT-L Restore CMake export information
+#install (EXPORT snortexe
+# DESTINATION ${CMAKE_INSTALL_LIBDIR}/snort
+# FILE snort.cmake
+#)
)
if (STATIC_IPS_ACTIONS)
- add_library ( ips_actions STATIC
+ add_library ( ips_actions OBJECT
${IPS_ACTION_SOURCES}
${PLUGIN_LIST}
)
else (STATIC_IPS_ACTIONS)
- add_library ( ips_actions STATIC
+ add_library ( ips_actions OBJECT
${IPS_ACTION_SOURCES}
)
if ( ENABLE_UNIT_TESTS )
-set (CATCH_INCLUDES
- catch.hpp
- snort_catch.h
-)
+ set (CATCH_INCLUDES
+ catch.hpp
+ snort_catch.h
+ )
-install (FILES ${CATCH_INCLUDES}
- DESTINATION "${INCLUDE_INSTALL_PATH}/catch"
-)
+ install (FILES ${CATCH_INCLUDES}
+ DESTINATION "${INCLUDE_INSTALL_PATH}/catch"
+ )
-add_library(catch_tests STATIC
- ${CATCH_INCLUDES}
- unit_test.cc
- unit_test.h
-)
-
-target_link_libraries(catch_tests)
+ add_library(catch_tests OBJECT
+ ${CATCH_INCLUDES}
+ unit_test.cc
+ unit_test.h
+ )
endif()
catch.hpp is from https://github.com/philsquared/Catch.
-If a source file contains only Catch unit tests, the linker must be tricked
-into not excluding the seemingly unneeded object file. To do this, include
-unit_test.h in the source file and add this directive to the beginning of the
-source code:
- SNORT_FORCED_INCLUSION_DEFINITION(source_file_name_less_extension)
-Additionally, edit unit_test_main.h to add the external definition with:
- SNORT_FORCED_INCLUSION_EXTERN(source_file_name_less_extension)
-As well as the reference to it in catch_extern_tests[] with:
- SNORT_FORCED_INCLUSION_SYMBOL(source_file_name_less_extension)
+++ /dev/null
-//--------------------------------------------------------------------------
-// Copyright (C) 2014-2018 Cisco and/or its affiliates. All rights reserved.
-//
-// 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. You may not use, modify or distribute
-// this program under any other version of the GNU General Public License.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with this program; if not, write to the Free Software Foundation, Inc.,
-// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-//--------------------------------------------------------------------------
-// unit_test_main.h author Michael Altizer <mialtize@cisco.com>
-
-#ifndef UNIT_TEST_MAIN_H
-#define UNIT_TEST_MAIN_H
-
-// Unit test framework to be included *only* by the main source file to handle
-// forcing the linking of objects file containing only Catch test cases.
-
-#include "catch/unit_test.h"
-
-// Unresolved external symbol declarations and references.
-SNORT_FORCED_INCLUSION_EXTERN(bitop_test);
-SNORT_FORCED_INCLUSION_EXTERN(lua_stack_test);
-SNORT_FORCED_INCLUSION_EXTERN(sfdaq_module_test);
-SNORT_FORCED_INCLUSION_EXTERN(sfip_test);
-SNORT_FORCED_INCLUSION_EXTERN(sfrf_test);
-SNORT_FORCED_INCLUSION_EXTERN(sfrt_test);
-SNORT_FORCED_INCLUSION_EXTERN(sfthd_test);
-SNORT_FORCED_INCLUSION_EXTERN(stopwatch_test);
-
-bool catch_extern_tests[] =
-{
- SNORT_FORCED_INCLUSION_SYMBOL(bitop_test),
- SNORT_FORCED_INCLUSION_SYMBOL(lua_stack_test),
- SNORT_FORCED_INCLUSION_SYMBOL(sfdaq_module_test),
- SNORT_FORCED_INCLUSION_SYMBOL(sfip_test),
- SNORT_FORCED_INCLUSION_SYMBOL(sfrf_test),
- SNORT_FORCED_INCLUSION_SYMBOL(sfrt_test),
- SNORT_FORCED_INCLUSION_SYMBOL(sfthd_test),
- SNORT_FORCED_INCLUSION_SYMBOL(stopwatch_test),
-};
-
-#endif
-
codec_module.h
)
-add_library (codecs STATIC
+add_library (codecs OBJECT
${CODEC_INCLUDES}
codec_api.h
codec_api.cc
-)
-
-add_library (codec_module STATIC
codec_module.cc
)
if (STATIC_CODECS)
- set (CODEC_PLUGIN_LIBRARIES
- link_codecs
- root_codecs
+ set (STATIC_CODEC_PLUGINS
+ $<TARGET_OBJECTS:ip_codecs>
+ $<TARGET_OBJECTS:link_codecs>
+ $<TARGET_OBJECTS:misc_codecs>
+ $<TARGET_OBJECTS:root_codecs>
+ CACHE INTERNAL "STATIC_CODEC_PLUGINS"
+ )
+else()
+ set (STATIC_CODEC_PLUGINS
+ $<TARGET_OBJECTS:ip_codecs>
+ $<TARGET_OBJECTS:misc_codecs>
+ CACHE INTERNAL "STATIC_CODEC_PLUGINS"
)
endif(STATIC_CODECS)
-target_link_libraries (codecs
- ${CODEC_PLUGIN_LIBRARIES}
- ip_codecs
- misc_codecs
- protocols
- sfip
- framework
- main
-)
-
-
install (FILES ${CODEC_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/codecs"
)
endif()
-add_library( ip_codecs STATIC
+add_library( ip_codecs OBJECT
cd_ipv4.cc # Static due to its dependence on fpdetect
cd_hop_opts.cc # Ensured the symbols CheckIPV6HopOptions && CheckIPv6ExtensionOrder are in the binary.
cd_tcp.cc # Only file to use some functions. Must be included in binary.
${PLUGIN_SOURCES}
)
-target_link_libraries( ip_codecs
- protocols
- framework
- events
- main
- managers
- codec_module
-)
endif(STATIC_CODECS)
-
-
# NOTE: if any static libraries need to built, this extra if()
# MUST be removed. It is here because cmake sends out
# a warning if no files exist in the link codecs library
if(STATIC_CODECS)
- add_library( link_codecs STATIC
+ add_library( link_codecs OBJECT
${PLUGIN_SOURCES}
)
-
-
- target_link_libraries( link_codecs
- events
- managers
- codec_module
- )
-
endif(STATIC_CODECS)
endif(STATIC_CODECS)
-add_library( misc_codecs STATIC
+add_library( misc_codecs OBJECT
cd_default.cc
${PLUGIN_LIST}
)
-target_link_libraries( misc_codecs
- protocols
- codec_module
-)
if (STATIC_CODECS)
- add_library(root_codecs STATIC
+ add_library(root_codecs OBJECT
${PLUGIN_LIST}
${PCAP_INCLUDE_DIR}/pcap.h # rebuild if a new libpcap is installed
)
-
- target_link_libraries( root_codecs
- codec_module
- )
-
endif (STATIC_CODECS)
add_subdirectory(file_connector)
add_subdirectory(tcp_connector)
-add_library( connectors STATIC
+add_library( connectors OBJECT
connectors.cc
connectors.h
)
-target_link_libraries(connectors file_connector tcp_connector)
-
-add_library( file_connector STATIC
+add_library( file_connector OBJECT
file_connector.cc
file_connector.h
file_connector_config.h
file_connector_module.h
)
-target_link_libraries(file_connector)
+add_subdirectory(test)
-add_cpputest(file_connector_test file_connector))
-add_cpputest(file_connector_module_test file_connector_module))
+add_cpputest( file_connector_test
+ SOURCES
+ ../file_connector.cc
+ ../../../framework/module.cc
+)
+
+add_cpputest( file_connector_module_test
+ SOURCES
+ ../file_connector_module.cc
+ ../../../framework/module.cc
+ ../../../framework/value.cc
+ ../../../sfip/sf_ip.cc
+ $<TARGET_OBJECTS:catch_tests>
+)
-add_library( tcp_connector STATIC
+add_library( tcp_connector OBJECT
tcp_connector.cc
tcp_connector.h
tcp_connector_config.h
tcp_connector_module.h
)
-target_link_libraries(tcp_connector)
+add_subdirectory(test)
-add_cpputest(tcp_connector_test tcp_connector))
-add_cpputest(tcp_connector_module_test tcp_connector_module))
+
+add_cpputest( tcp_connector_test
+ SOURCES
+ ../tcp_connector.cc
+ ../../../framework/module.cc
+ LIBS
+ ${CMAKE_THREAD_LIBS_INIT}
+)
+
+add_cpputest( tcp_connector_module_test
+ SOURCES
+ ../tcp_connector_module.cc
+ ../../../framework/module.cc
+ ../../../framework/parameter.cc
+ ../../../framework/value.cc
+ ../../../sfip/sf_ip.cc
+ $<TARGET_OBJECTS:catch_tests>
+ LIBS
+ ${DNET_LIBRARIES}
+)
-add_library ( control STATIC
+add_library ( control OBJECT
idle_processing.h
idle_processing.cc
)
file_decomp.h
)
-add_library (decompress STATIC
+add_library (decompress OBJECT
${DECOMPRESS_INCLUDES}
file_decomp.cc
file_decomp_pdf.cc
file_decomp_swf.h
)
-target_link_libraries(decompress
- log
- utils
-)
-
install (FILES ${DECOMPRESS_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/decompress"
)
#include <cassert>
#include "detection/detection_util.h"
-#include "main/snort_types.h"
#include "utils/util.h"
#include "file_decomp_pdf.h"
#include "catch/snort_catch.h"
#endif
-SNORT_FORCED_INCLUSION_DEFINITION(file_decomp);
-
static const char PDF_Sig[5] = { '%', 'P', 'D', 'F', '-' };
static const char SWF_ZLIB_Sig[3] = { 'C', 'W', 'S' };
#ifdef HAVE_LZMA
treenodes.h
)
-add_library (detection STATIC
+add_library (detection OBJECT
${DETECTION_INCLUDES}
context_switcher.cc
context_switcher.h
tag.h
)
-target_link_libraries( detection
- framework
- managers
-)
-
install(FILES ${DETECTION_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/detection"
)
event_queue.h
)
-add_library (events STATIC
+add_library (events OBJECT
event.cc
event_queue.cc
sfeventq.cc
file_service.h
)
-add_library ( file_api STATIC
+add_library ( file_api OBJECT
${FILE_API_INCLUDES}
circular_buffer.cc
circular_buffer.h
file_stats.h
)
-target_link_libraries(file_api mime)
-
install (FILES ${FILE_API_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/file_api"
)
{
public:
- FilePolicy() { }
- ~FilePolicy() { }
+ FilePolicy() = default;
+ ~FilePolicy() override = default;
void policy_check(Flow* flow, FileInfo* file) override;
)
endif()
-add_library (filter STATIC
+add_library (filter OBJECT
detection_filter.cc
detection_filter.h
rate_filter.cc
#endif
#include "catch/snort_catch.h"
-#include "main/snort_types.h"
#include "parser/parse_ip.h"
#include "sfip/sf_ip.h"
//---------------------------------------------------------------
-SNORT_FORCED_INCLUSION_DEFINITION(sfrf_test);
-
#define IP_ANY nullptr // used to get "unset"
#define IP4_SRC "1.2.3.4"
#include "catch/snort_catch.h"
#include "hash/xhash.h"
-#include "main/snort_types.h"
#include "parser/parse_ip.h"
#include "sfip/sf_ip.h"
//---------------------------------------------------------------
-SNORT_FORCED_INCLUSION_DEFINITION(sfthd_test);
-
#define IP_ANY nullptr // used to get "unset"
#define IP4_SRC "1.2.3.4"
flow_key.h
)
-add_library (flow STATIC
+add_library (flow OBJECT
${FLOW_INCLUDES}
expect_cache.cc
flow.cc
session.h
)
-target_link_libraries(flow
- protocols
-)
-
install(FILES ${FLOW_INCLUDES}
DESTINATION ${INCLUDE_INSTALL_PATH}/flow
)
+
+add_subdirectory(test)
-add_cpputest(ha_test ha)
-add_cpputest(ha_module_ha ha_module)
+add_cpputest( ha_test
+ SOURCES ../ha.cc
+)
+add_cpputest( ha_module_test
+ SOURCES
+ ../ha_module.cc
+ ../../framework/module.cc
+ ../../framework/value.cc
+ ../../sfip/sf_ip.cc
+ $<TARGET_OBJECTS:catch_tests>
+)
connector.h
)
-add_library ( framework STATIC
+add_library ( framework OBJECT
${FRAMEWORK_INCLUDES}
codec.cc
cursor.cc
DESTINATION "${INCLUDE_INSTALL_PATH}/framework"
)
-if ( ENABLE_UNIT_TESTS )
- target_link_libraries ( framework catch_tests )
-endif ( ENABLE_UNIT_TESTS )
-
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/api_options.h
COMMAND grep API_OPTIONS ${CMAKE_BINARY_DIR}/config.h > ${CMAKE_CURRENT_BINARY_DIR}/api_options.h
hashfcn.h
)
-set (HASH_SOURCES )
-
-add_library( hash STATIC
+add_library( hash OBJECT
${HASH_INCLUDES}
- ${HASH_SOURCES}
hashes.cc
lru_cache_shared.h
lru_cache_shared.cc
-add_cpputest(lru_cache_shared_test hash)
-add_cpputest(ghash_test hash)
+add_cpputest( lru_cache_shared_test
+ SOURCES ../lru_cache_shared.cc
+)
+
+add_cpputest( ghash_test
+ SOURCES
+ ../ghash.cc
+ ../hashfcn.cc
+ ../primetable.cc
+)
base64_encoder.h
)
-add_library (helpers STATIC
+add_library (helpers OBJECT
${HELPERS_INCLUDES}
base64_encoder.cc
chunk.cc
ring_logic.h
)
-target_link_libraries(helpers
- log
- utils
-)
-
install (FILES ${HELPERS_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/helpers"
)
#include "catch/snort_catch.h"
#endif
-SNORT_FORCED_INCLUSION_DEFINITION(base64_encoder);
-
static inline char b64(uint8_t idx)
{
static const char* encoding =
-add_library( host_tracker STATIC
+add_library( host_tracker OBJECT
host_cache.cc
host_cache.h
host_cache_module.cc
-set (
- HOST_TRACKER_MODULE_LIBS
- framework
- sfip
- ${DNET_LIBRARIES}
+
+add_cpputest( host_cache_test
+ SOURCES
+ ../host_cache.cc
+ ../host_tracker.cc
+ ../../sfip/sf_ip.cc
+)
+
+add_cpputest( host_cache_module_test
+ SOURCES
+ ../host_cache_module.cc
+ ../host_cache.cc
+ ../host_tracker.cc
+ ../../framework/module.cc
+ ../../framework/value.cc
+ ../../hash/lru_cache_shared.cc
+ ../../sfip/sf_ip.cc
+ $<TARGET_OBJECTS:catch_tests>
+)
+
+add_cpputest( host_tracker_test
+ SOURCES
+ ../host_tracker.cc
+ ../../sfip/sf_ip.cc
+)
+
+add_cpputest( host_tracker_module_test
+ SOURCES
+ ../host_cache.cc
+ ../host_tracker.cc
+ ../host_tracker_module.cc
+ ../../framework/module.cc
+ ../../framework/parameter.cc
+ ../../framework/value.cc
+ ../../sfip/sf_ip.cc
+ $<TARGET_OBJECTS:catch_tests>
+ LIBS
+ ${DNET_LIBRARIES}
)
-add_cpputest(host_cache_test host_tracker sfip)
-add_cpputest(host_cache_module_test host_tracker ${HOST_TRACKER_MODULE_LIBS} hash)
-add_cpputest(host_tracker_module_test host_tracker ${HOST_TRACKER_MODULE_LIBS})
-add_cpputest(host_tracker_test host_tracker sfip)
if (STATIC_IPS_OPTIONS)
- add_library ( ips_options STATIC
+ add_library ( ips_options OBJECT
${IPS_SOURCES}
${OPTION_LIST}
${PLUGIN_LIST}
else (STATIC_IPS_OPTIONS)
- add_library ( ips_options STATIC
+ add_library ( ips_options OBJECT
${IPS_SOURCES}
${OPTION_LIST}
)
endif (STATIC_IPS_OPTIONS)
-target_link_libraries(ips_options
- framework
- helpers
- hash
-)
+add_subdirectory(test)
-# see Makefile.am for why this is temporarily disabled
-#if ( HAVE_HYPERSCAN )
-# add_cpputest(ips_regex_test ips_options
-# ips_options
-# framework
-# sfip
-# catch_tests
-# )
-#
-# target_link_libraries(ips_regex_test ${HS_LIBRARIES})
-# target_include_directories(ips_regex_test PUBLIC ${LUAJIT_INCLUDE_DIR})
-#endif()
+if ( HAVE_HYPERSCAN )
+ add_cpputest( ips_regex_test
+ SOURCES
+ ../ips_regex.cc
+ ../../framework/module.cc
+ ../../framework/ips_option.cc
+ ../../framework/value.cc
+ ../../sfip/sf_ip.cc
+ $<TARGET_OBJECTS:catch_tests>
+ LIBS
+ ${HS_LIBRARIES}
+ )
+endif()
rule_latency_state.h
rule_latency.h
rule_latency.cc
- )
+)
-add_library ( latency STATIC ${LATENCY_SOURCES} )
+add_library ( latency OBJECT ${LATENCY_SOURCES} )
u2_packet.h
)
-add_library ( log STATIC
+add_library ( log OBJECT
${LOG_INCLUDES}
log.cc
log_text.cc
DESTINATION "${INCLUDE_INSTALL_PATH}/log"
)
-target_link_libraries(log
- utils
- protocols
-)
-
add_subdirectory ( test )
-add_cpputest(obfuscator_test log)
+add_cpputest( obfuscator_test
+ SOURCES ../obfuscator.cc
+)
#include "protocols/protocol_ids.h"
#include "utils/util.h"
-SNORT_FORCED_INCLUSION_DEFINITION(u2_pseudo_header);
-
static const uint8_t u2_ttl = 64;
//--------------------------------------------------------------------------
)
if (STATIC_LOGGERS)
- add_library ( loggers STATIC
+ add_library ( loggers OBJECT
${LOGGER_SOURCES}
${PLUGIN_LIST}
)
else (STATIC_LOGGERS)
- add_library ( loggers STATIC
+ add_library ( loggers OBJECT
${LOGGER_SOURCES}
)
set(TEST_FILES lua_stack_test.cc)
endif()
-add_library (lua STATIC
+add_library (lua OBJECT
lua.cc
lua.h
lua_ref.cc
#include <string>
#include "catch/snort_catch.h"
-#include "main/snort_types.h"
#include "lua_test_common.h"
#include "lua/lua_stack.h"
-SNORT_FORCED_INCLUSION_DEFINITION(lua_stack_test);
-
static lua_State* L = nullptr;
static void test_signed()
#include "lua/lua.h"
#include "main/analyzer.h"
#include "main/analyzer_command.h"
-#include "main/inclusion.h"
#include "main/request.h"
#include "main/shell.h"
#include "main/snort.h"
#include "utils/safec.h"
#ifdef UNIT_TEST
-#include "catch/unit_test_main.h"
+#include "catch/unit_test.h"
#endif
#ifdef PIGLET
set ( SHELL_SOURCES control.cc control.h control_mgmt.cc control_mgmt.h )
endif ( ENABLE_SHELL )
-add_library (main STATIC
+add_library (main OBJECT
analyzer.cc
analyzer.h
analyzer_command.cc
${SHELL_SOURCES}
)
-
-target_link_libraries(main
- time
- codecs
- detection
- packet_io
-)
-
install (FILES ${INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/main"
)
+++ /dev/null
-//--------------------------------------------------------------------------
-// Copyright (C) 2014-2018 Cisco and/or its affiliates. All rights reserved.
-// Copyright (C) 2007-2013 Sourcefire, Inc.
-//
-// 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. You may not use, modify or distribute
-// this program under any other version of the GNU General Public License.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with this program; if not, write to the Free Software Foundation, Inc.,
-// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-//--------------------------------------------------------------------------
-
-#ifndef SNORT_INCLUSION_H
-#define SNORT_INCLUSION_H
-
-SNORT_FORCED_INCLUSION_EXTERN(base64_encoder);
-SNORT_FORCED_INCLUSION_EXTERN(jsnorm);
-SNORT_FORCED_INCLUSION_EXTERN(kmap);
-SNORT_FORCED_INCLUSION_EXTERN(utf);
-SNORT_FORCED_INCLUSION_EXTERN(u2_pseudo_header);
-
-bool extern_symbols[] =
-{
- SNORT_FORCED_INCLUSION_SYMBOL(base64_encoder),
- SNORT_FORCED_INCLUSION_SYMBOL(jsnorm),
- SNORT_FORCED_INCLUSION_SYMBOL(kmap),
- SNORT_FORCED_INCLUSION_SYMBOL(utf),
- SNORT_FORCED_INCLUSION_SYMBOL(u2_pseudo_header)
-};
-
-#endif
#define __attribute__(x) /* delete __attribute__ if non-gcc or gcc1 */
#endif
-#define SNORT_FORCED_INCLUSION_SYMBOL( name ) \
- __snort_include_##name
-
-#define SNORT_FORCED_INCLUSION_DEFINITION( name ) \
- bool SNORT_FORCED_INCLUSION_SYMBOL( name )
-
-#define SNORT_FORCED_INCLUSION_EXTERN( name ) \
- extern SNORT_FORCED_INCLUSION_DEFINITION( name )
-
#endif
inspector_manager.h
)
-add_library( managers STATIC
+add_library( managers OBJECT
${MANAGERS_INCLUDES}
action_manager.h
action_manager.cc
connector_manager.h
)
-target_link_libraries(managers
- framework
- helpers
- loggers
- ips_options
- network_inspectors
- service_inspectors
- search_engines
- parser
- codecs
- ips_actions
-)
-
install (FILES ${MANAGERS_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/managers"
)
memory_manager.cc
prune_handler.cc
prune_handler.h
- )
+)
-add_library ( memory STATIC
+add_library ( memory OBJECT
${MEMORY_SOURCES}
)
void operator delete[](void* p, const std::nothrow_t&) noexcept
{ ::operator delete[](p); }
+// C++14 delete operators are a special case and must be explicitly exported
+// since we're compiling as C++11 but must capture these for external libraries
+void operator delete(void* p, size_t) noexcept;
+SO_PUBLIC void operator delete(void* p, size_t) noexcept
+{ ::operator delete(p); }
+
+void operator delete[](void* p, size_t) noexcept;
+SO_PUBLIC void operator delete[](void* p, size_t) noexcept
+{ ::operator delete[](p); }
+
// -----------------------------------------------------------------------------
// unit tests
// -----------------------------------------------------------------------------
file_mime_process.h
)
-add_library ( mime STATIC
+add_library ( mime OBJECT
${MIME_INCLUDES}
file_mime_config.cc
file_mime_decode.cc
decode_uu.h
)
-target_link_libraries(mime file_api)
-
install (FILES ${MIME_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/mime"
)
add_subdirectory(reputation)
if(STATIC_INSPECTORS)
- set(STATIC_INSPECTOR_LIBS
- arp_spoof
- packet_capture
+ set(STATIC_INSPECTOR_OBJS
+ $<TARGET_OBJECTS:arp_spoof>
+ $<TARGET_OBJECTS:packet_capture>
)
endif()
-add_library( network_inspectors STATIC
+set(STATIC_NETWORK_INSPECTOR_PLUGINS
+ $<TARGET_OBJECTS:appid>
+ $<TARGET_OBJECTS:binder>
+ $<TARGET_OBJECTS:normalize>
+ $<TARGET_OBJECTS:perf_monitor>
+ $<TARGET_OBJECTS:port_scan>
+ $<TARGET_OBJECTS:reputation>
+ ${STATIC_INSPECTOR_OBJS}
+ CACHE INTERNAL "STATIC_NETWORK_INSPECTOR_PLUGINS"
+)
+
+add_library( network_inspectors OBJECT
network_inspectors.cc
network_inspectors.h
)
-target_link_libraries( network_inspectors
- ${STATIC_INSPECTOR_LIBS}
- binder
- normalize
- perf_monitor
- port_scan
- reputation
-)
-set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing" )
set (APPID_INCLUDES
appid_api.h
#if (STATIC_INSPECTORS)
- add_library(appid STATIC
+add_library(appid OBJECT
${APPID_SOURCES}
${CP_APPID_SOURCES}
${DP_APPID_SOURCES}
-set (
- SMTP_TEST_LIBS
- utils
-)
-
-add_cpputest(detector_smtp_test ${SMTP_TEST_LIBS})
-
-add_cpputest(http_url_patterns_test)
include_directories ( appid PRIVATE ${APPID_INCLUDE_DIR} )
+add_cpputest( detector_smtp_test )
+
+add_cpputest( http_url_patterns_test )
-add_cpputest(service_rsync_test)
-
include_directories ( appid PRIVATE ${APPID_INCLUDE_DIR} )
+add_cpputest( service_rsync_test )
-add_library(appid_test_depends_on_lib ../appid_peg_counts.cc ../../../sfip/sf_ip.cc ../../../utils/util_cstring.cc)
+add_library(appid_cpputest_deps OBJECT ../appid_peg_counts.cc ../../../sfip/sf_ip.cc ../../../utils/util_cstring.cc)
+include_directories ( appid PRIVATE ${APPID_INCLUDE_DIR} )
-add_cpputest(appid_http_event_test appid_test_depends_on_lib)
-add_cpputest(appid_api_test appid_test_depends_on_lib)
-#add_cpputest(app_info_table_test appid_test_depends_on_lib)
-add_cpputest(appid_detector_test appid_test_depends_on_lib)
-add_cpputest(appid_expected_flags_test appid_test_depends_on_lib)
+# add_cpputest( app_info_table_test
+# SOURCES $<TARGET_OBJECTS:appid_cpputest_deps>
+# )
-include_directories ( appid PRIVATE ${APPID_INCLUDE_DIR} )
+add_cpputest( appid_api_test
+ SOURCES $<TARGET_OBJECTS:appid_cpputest_deps>
+)
+
+add_cpputest( appid_detector_test
+ SOURCES $<TARGET_OBJECTS:appid_cpputest_deps>
+)
+
+add_cpputest( appid_expected_flags_test
+ SOURCES $<TARGET_OBJECTS:appid_cpputest_deps>
+)
+add_cpputest( appid_http_event_test
+ SOURCES $<TARGET_OBJECTS:appid_cpputest_deps>
+)
)
if (STATIC_INSPECTORS)
- add_library(arp_spoof STATIC
+ add_library(arp_spoof OBJECT
${FILE_LIST}
)
)
#if (STATIC_INSPECTORS)
- add_library(binder STATIC ${FILE_LIST})
+add_library(binder OBJECT ${FILE_LIST})
#else (STATIC_INSPECTORS)
# add_dynamic_module(binder inspectors ${FILE_LIST})
-add_library( normalize STATIC
+add_library( normalize OBJECT
normalize.cc
normalize.h
norm_module.cc
)
if (STATIC_INSPECTORS)
- add_library(packet_capture STATIC ${FILE_LIST})
- target_link_libraries(packet_capture utils)
+ add_library(packet_capture OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(packet_capture inspectors ${FILE_LIST})
set( FLATBUFFERS_SOURCE fbs_formatter.h fbs_formatter.cc )
endif()
-add_library ( perf_monitor STATIC
+add_library ( perf_monitor OBJECT
base_tracker.cc
base_tracker.h
csv_formatter.cc
if ( FLATBUFFERS_FOUND )
target_include_directories( perf_monitor PRIVATE ${FLATBUFFERS_INCLUDE_DIR} )
- target_link_libraries( perf_monitor ${FLATBUFFERS_LIBRARIES} )
endif()
-add_library( port_scan STATIC
+add_library( port_scan OBJECT
port_scan.cc
ps_detect.cc
ps_detect.h
ipobj.h
)
-target_link_libraries( port_scan
- events
-)
-add_library( reputation STATIC
+add_library( reputation OBJECT
reputation_config.h
reputation_inspect.h
reputation_inspect.cc
)
endif (ENABLE_UNIT_TESTS)
-add_library (packet_io STATIC
+add_library (packet_io OBJECT
active.cc
active.h
intf.cc
#include "catch/snort_catch.h"
#include "main/snort_config.h"
-#include "main/snort_types.h"
#include "packet_io/sfdaq_config.h"
#include "packet_io/sfdaq_module.h"
-SNORT_FORCED_INCLUSION_DEFINITION(sfdaq_module_test);
-
TEST_CASE("Kitchen Sink", "[SFDAQModule]")
{
SFDAQModule sfdm;
-add_library (parser STATIC
+add_library (parser OBJECT
arg_list.cc
arg_list.h
parser.cc
vars.h
)
-target_link_libraries(parser
- protocols
- time
- stream
- codecs
-)
-add_library (
- piglet STATIC
-
+add_library ( piglet OBJECT
piglet.cc
piglet_manager.cc
piglet_output.cc
${PP_TEST_SOURCES}
)
-add_library (
- piglet_plugins STATIC
+add_library ( piglet_plugins OBJECT
${PP_SOURCES}
)
-ADD_LIBRARY( ports STATIC
+ADD_LIBRARY( ports OBJECT
port_group.cc
port_group.h
port_item.cc
rule_port_tables.h
)
-target_link_libraries(ports
- log
-)
-
-list(APPEND PACKAGED_DIST "readme.txt")
-
time_profiler.h
)
-add_library ( profiler STATIC
+add_library ( profiler OBJECT
${PROFILER_SOURCES}
${PROFILER_INCLUDES}
)
vlan.h
)
-add_library (protocols STATIC
+add_library (protocols OBJECT
${PROTOCOL_HEADERS}
layer.cc
packet.cc
sip_events.h
)
-add_library( pub_sub STATIC
+add_library( pub_sub OBJECT
${PUB_SUB_INCLUDES}
http_events.cc
sip_events.cc
)
if ( STATIC_SEARCH_ENGINES )
- add_library(search_engines STATIC
+ add_library(search_engines OBJECT
${ACSMX_SOURCES}
${ACSMX2_SOURCES}
${INTEL_SOURCES}
)
else ( STATIC_SEARCH_ENGINES)
- add_library(search_engines STATIC
+ add_library(search_engines OBJECT
${SEARCH_ENGINE_SOURCES}
${SEARCH_ENGINE_INCLUDES}
)
install(FILES ${SEARCH_ENGINE_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/search_engines"
)
+
+add_subdirectory(test)
-# see Makefile.am for why this is temporarily disabled
-#if ( HAVE_HYPERSCAN )
-# add_cpputest(hyperscan_test search_engines
-# framework
-# catch_tests
-# )
-#
-# target_link_libraries(hyperscan_test ${HS_LIBRARIES})
-#endif()
+add_cpputest( search_tool_test
+ SOURCES
+ ../ac_bnfa.cc
+ ../bnfa_search.cc
+ ../search_tool.cc
+)
+
+if ( HAVE_HYPERSCAN )
+ add_cpputest( hyperscan_test
+ SOURCES ../hyperscan.cc
+ LIBS ${HS_LIBRARIES}
+ )
+endif()
{
}
-void FatalError(const char*,...)
+[[noreturn]] void FatalError(const char*,...)
{
exit(1);
}
add_subdirectory(wizard)
if (STATIC_INSPECTORS)
- set (STATIC_INSPECTOR_LIBS
- back_orifice
- dce_rpc
- dnp3
- dns
- ftp_telnet
- gtp_inspect
- modbus
- rpc_decode
- ssh
- wizard
+ set (STATIC_INSPECTOR_OBJS
+ $<TARGET_OBJECTS:back_orifice>
+ $<TARGET_OBJECTS:dce_rpc>
+ $<TARGET_OBJECTS:dnp3>
+ $<TARGET_OBJECTS:dns>
+ $<TARGET_OBJECTS:ftp_telnet>
+ $<TARGET_OBJECTS:gtp_inspect>
+ $<TARGET_OBJECTS:modbus>
+ $<TARGET_OBJECTS:rpc_decode>
+ $<TARGET_OBJECTS:ssh>
+ $<TARGET_OBJECTS:wizard>
)
endif()
-add_library( service_inspectors STATIC
- service_inspectors.cc
- service_inspectors.h
+set(STATIC_SERVICE_INSPECTOR_PLUGINS
+ $<TARGET_OBJECTS:http_inspect>
+ $<TARGET_OBJECTS:http2_inspect>
+ $<TARGET_OBJECTS:imap>
+ $<TARGET_OBJECTS:pop>
+ $<TARGET_OBJECTS:sip>
+ $<TARGET_OBJECTS:smtp>
+ $<TARGET_OBJECTS:ssl>
+ ${STATIC_INSPECTOR_OBJS}
+ CACHE INTERNAL "STATIC_SERVICE_INSPECTOR_PLUGINS"
)
-target_link_libraries( service_inspectors
- ${STATIC_INSPECTOR_LIBS}
- imap
- pop
- smtp
- ssl
+add_library( service_inspectors OBJECT
+ service_inspectors.cc
+ service_inspectors.h
)
)
if (STATIC_INSPECTORS)
- add_library( back_orifice STATIC ${FILE_LIST})
+ add_library( back_orifice OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(back_orifice inspectors ${FILE_LIST})
if (STATIC_INSPECTORS)
- add_library(dce_rpc STATIC ${FILE_LIST})
+ add_library(dce_rpc OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(dce_rpc inspectors ${FILE_LIST})
)
if (STATIC_INSPECTORS)
- add_library(dnp3 STATIC ${FILE_LIST})
+ add_library(dnp3 OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(dnp3 inspectors ${FILE_LIST})
)
if (STATIC_INSPECTORS)
- add_library( dns STATIC ${FILE_LIST})
+ add_library( dns OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(dns inspectors ${FILE_LIST})
)
if (STATIC_INSPECTORS)
- add_library(ftp_telnet STATIC ${FILE_LIST})
- target_link_libraries(ftp_telnet utils)
+ add_library(ftp_telnet OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(ftp_telnet inspectors ${FILE_LIST})
)
if (STATIC_INSPECTORS)
- add_library(gtp_inspect STATIC ${FILE_LIST})
+ add_library(gtp_inspect OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(gtp_inspect inspectors ${FILE_LIST})
)
#if (STATIC_INSPECTORS)
- add_library(http2_inspect STATIC ${FILE_LIST})
+ add_library(http2_inspect OBJECT ${FILE_LIST})
#else(STATIC_INSPECTORS)
#add_dynamic_module(http2_inspect inspectors ${FILE_LIST})
-add_cpputest(http2_inspect_impl_test http2_inspect framework)
-add_cpputest(http2_stream_splitter_impl_test http2_inspect framework)
+add_cpputest( http2_inspect_impl_test
+ SOURCES
+ ../http2_flow_data.cc
+ ../http2_inspect_impl.cc
+ ../http2_module.cc
+ ../http2_tables.cc
+ ../../../framework/module.cc
+)
+add_cpputest( http2_stream_splitter_impl_test
+ SOURCES
+ ../http2_flow_data.cc
+ ../http2_stream_splitter_impl.cc
+ ../http2_module.cc
+ ../http2_tables.cc
+ ../../../framework/module.cc
+)
// Stubs whose sole purpose is to make the test code link
FlowData::FlowData(unsigned u, Inspector* ph) : next(nullptr), prev(nullptr), handler(ph), id(u) {}
FlowData::~FlowData() {}
+unsigned FlowData::flow_data_id = 0;
void show_stats(PegCount*, const PegInfo*, unsigned, const char*) { }
void show_stats(PegCount*, const PegInfo*, IndexVec&, const char*, FILE*) { }
void show_stats(SimpleStats*, const char*) { }
)
#if (STATIC_INSPECTORS)
- add_library(http_inspect STATIC ${FILE_LIST})
+ add_library(http_inspect OBJECT ${FILE_LIST})
#else(STATIC_INSPECTORS)
#add_dynamic_module(http_inspect inspectors ${FILE_LIST})
-add_cpputest(http_uri_norm_test http_inspect framework)
-add_cpputest(http_normalizers_test http_inspect framework)
-add_cpputest(http_module_test http_inspect framework)
-add_cpputest(http_msg_head_shared_util_test http_inspect framework)
+add_cpputest( http_module_test
+ SOURCES
+ ../http_module.cc
+ ../http_tables.cc
+ ../http_normalizers.cc
+ ../http_uri_norm.cc
+ ../http_field.cc
+ ../../../framework/module.cc
+)
-# FIXIT-M this doesn't link properly under cmake. Autotools version is working.
-# add_library(depends_on_lib_transaction ../http_transaction.cc ../http_flow_data.cc ../http_test_manager.cc ../http_test_input.cc)
-# add_cpputest(http_transaction_test depends_on_lib_transaction framework -lz)
+add_cpputest( http_msg_head_shared_util_test
+ SOURCES
+ ../http_msg_head_shared_util.cc
+ ../http_field.cc
+ ../http_str_to_code.cc
+)
+add_cpputest( http_normalizers_test
+ SOURCES
+ ../http_normalizers.cc
+ ../http_field.cc
+)
+
+add_cpputest( http_transaction_test
+ SOURCES
+ ../http_transaction.cc
+ ../http_flow_data.cc
+ ../http_test_manager.cc
+ ../http_test_input.cc
+ LIBS ${ZLIB_LIBRARIES}
+)
+
+add_cpputest( http_uri_norm_test
+ SOURCES
+ ../http_uri_norm.cc
+ ../http_module.cc
+ ../http_test_manager.cc
+ ../http_test_input.cc
+ ../http_normalizers.cc
+ ../http_str_to_code.cc
+ ../http_field.cc
+ ../http_tables.cc
+ ../../../framework/module.cc
+)
# can't be be linked dynamically yet
#if (STATIC_INSPECTORS)
- add_library( imap STATIC ${FILE_LIST})
+ add_library( imap OBJECT ${FILE_LIST})
#else (STATIC_INSPECTORS)
#add_dynamic_module(imap inspectors ${FILE_LIST})
)
if (STATIC_INSPECTORS)
- add_library(modbus STATIC ${FILE_LIST})
+ add_library(modbus OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(modbus inspectors ${FILE_LIST})
# can't be be linked dynamically yet
#if (STATIC_INSPECTORS)
- add_library( pop STATIC ${FILE_LIST})
+ add_library( pop OBJECT ${FILE_LIST})
#else (STATIC_INSPECTORS)
#add_dynamic_module(pop inspectors ${FILE_LIST})
)
if (STATIC_INSPECTORS)
- add_library( rpc_decode STATIC ${FILE_LIST})
+ add_library( rpc_decode OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(rpc_decode inspectors ${FILE_LIST})
#FIXIT-M fix dependency loops
#if (STATIC_INSPECTORS)
- add_library( sip STATIC ${FILE_LIST})
+ add_library( sip OBJECT ${FILE_LIST})
#else (STATIC_INSPECTORS)
# add_dynamic_module(sip inspectors ${FILE_LIST})
# can't be be linked dynamically yet
#if (STATIC_INSPECTORS)
- add_library( smtp STATIC ${FILE_LIST})
+ add_library( smtp OBJECT ${FILE_LIST})
#else (STATIC_INSPECTORS)
#add_dynamic_module(smtp inspectors ${FILE_LIST})
)
if (STATIC_INSPECTORS)
- add_library( ssh STATIC ${FILE_LIST})
+ add_library( ssh OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(ssh inspectors ${FILE_LIST})
# can't be be linked dynamically yet
#if (STATIC_INSPECTORS)
- add_library( ssl STATIC ${FILE_LIST})
+ add_library( ssl OBJECT ${FILE_LIST})
#else (STATIC_INSPECTORS)
#add_dynamic_module(ssl inspectors ${FILE_LIST})
)
if (STATIC_INSPECTORS)
- add_library(wizard STATIC ${FILE_LIST})
+ add_library(wizard OBJECT ${FILE_LIST})
else (STATIC_INSPECTORS)
add_dynamic_module(wizard inspectors ${FILE_LIST})
set(TEST_FILES sfip_test.cc)
endif()
-add_library ( sfip STATIC
+add_library ( sfip OBJECT
${SFIP_INCLUDES}
${TEST_FILES}
sf_cidr.cc
#include <cstring>
#include "catch/snort_catch.h"
-#include "main/snort_types.h"
#include "sf_cidr.h"
//---------------------------------------------------------------
-SNORT_FORCED_INCLUSION_DEFINITION(sfip_test);
-
static int s_debug = 0;
static const char* const codes[] =
set(TEST_FILES sfrt_test.cc)
endif()
-add_library ( sfrt STATIC
+add_library ( sfrt OBJECT
sfrt.cc
sfrt.h
sfrt_dir.cc
#endif
#include "catch/snort_catch.h"
-#include "main/snort_types.h"
#include "sfip/sf_cidr.h"
#include "utils/util.h"
#define NUM_IPS 32
#define NUM_DATA 4
-SNORT_FORCED_INCLUSION_DEFINITION(sfrt_test);
-
typedef struct
{
const char* ip_str;
-add_library( side_channel STATIC
+add_library( side_channel OBJECT
side_channel.cc
side_channel.h
side_channel_module.cc
side_channel_module.h
)
-target_link_libraries(side_channel)
+add_subdirectory(test)
-add_cpputest(side_channel_test side_channel)
-add_cpputest(side_channel_module_test side_channel_module)
+add_cpputest( side_channel_test
+ SOURCES ../side_channel.cc
+)
+
+add_cpputest( side_channel_module_test
+ SOURCES
+ ../side_channel_module.cc
+ ../../framework/module.cc
+ ../../framework/value.cc
+ ../../sfip/sf_ip.cc
+ $<TARGET_OBJECTS:catch_tests>
+)
stream_splitter.h
)
-add_library( stream STATIC
+add_library( stream OBJECT
stream.cc
stream_inspectors.cc
stream_inspectors.h
stream_splitter.cc
)
-add_library( stream_paf STATIC
+add_library( stream_paf OBJECT
flush_bucket.cc
flush_bucket.h
paf.cc
)
-target_link_libraries( stream
- stream_base
- stream_ip
- stream_icmp
- stream_libtcp
- stream_tcp
- stream_udp
- stream_user
- stream_file
- protocols
-)
-
install (FILES ${STREAM_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/stream"
)
-add_library( stream_base STATIC
+add_library( stream_base OBJECT
stream_base.cc
stream_ha.cc
stream_ha.h
-add_library( stream_file STATIC
+add_library( stream_file OBJECT
file_module.cc
file_module.h
file_session.cc
-add_library( stream_icmp STATIC
+add_library( stream_icmp OBJECT
icmp_ha.cc
icmp_ha.h
icmp_module.cc
stream_icmp.h
)
-target_link_libraries( stream_icmp
- protocols
-)
-add_library( stream_ip STATIC
+add_library( stream_ip OBJECT
ip_defrag.cc
ip_defrag.h
ip_ha.cc
endif()
-add_library( stream_libtcp STATIC
+add_library( stream_libtcp OBJECT
tcp_segment_descriptor.cc
tcp_state_handler.cc
tcp_state_machine.cc
-add_library( stream_tcp STATIC
+add_library( stream_tcp OBJECT
ips_stream_reassemble.cc
ips_stream_size.cc
segment_overlap_editor.h
-include_directories( ../../../network_inspectors ${LUAJIT_INCLUDE_DIR} )
-
-set (
- STREAM_TCP_TEST_SOURCES
- ../tcp_normalizer.cc
- ../tcp_normalizers.cc
- ../../../protocols/tcp_options.cc
-)
-
-if ( ENABLE_DEBUG_MSGS )
- list (
- APPEND STREAM_TCP_TEST_SOURCES
- ../../../main/snort_debug.cc
- )
-endif ( ENABLE_DEBUG_MSGS )
-
-add_library ( stream_tcp_test ${STREAM_TCP_TEST_SOURCES} )
-
# this test is broken, uncomment below when fixed
-# add_cpputest( tcp_normalizer_test stream_tcp_test )
+# add_cpputest( tcp_normalizer_test
+# SOURCES
+# ../tcp_normalizer.cc
+# ../tcp_normalizers.cc
+# ../../../protocols/tcp_options.cc
+# ../../../main/snort_debug.cc
+# )
-# can't find the .o and don't want parent lib
-#add_cpputest(stream_splitter_test ../stream_splitter.o)
-
+add_cpputest( stream_splitter_test
+ SOURCES ../stream_splitter.cc
+)
-add_library( stream_udp STATIC
+add_library( stream_udp OBJECT
stream_udp.cc
stream_udp.h
udp_ha.cc
-add_library( stream_user STATIC
+add_library( stream_user OBJECT
user_module.cc
user_module.h
user_session.cc
-add_library( target_based STATIC
+add_library( target_based OBJECT
sftarget_reader.cc
sftarget_reader.h
sftarget_hostentry.cc
set ( TARGET_BASED_INCLUDES
snort_protocols.h
- )
+)
install (FILES ${TARGET_BASED_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/target_based"
periodic.h
timersub.h
tsc_clock.cc
- )
+)
if ( ENABLE_UNIT_TESTS )
list ( APPEND TIME_INTERNAL_SOURCES stopwatch_test.cc )
packet_time.h
stopwatch.h
tsc_clock.h
- )
+)
-add_library ( time STATIC
+add_library ( time OBJECT
${TIME_INTERNAL_SOURCES}
${TIME_INCLUDES}
- )
+)
install (FILES ${TIME_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/time"
#endif
#include "catch/snort_catch.h"
-#include "main/snort_types.h"
#include "clock_defs.h"
#include "stopwatch.h"
-SNORT_FORCED_INCLUSION_DEFINITION(stopwatch_test);
-
namespace t_stopwatch
{
set(TEST_FILES bitop_test.cc)
endif()
-ADD_LIBRARY( utils STATIC
+add_library ( utils OBJECT
${UTIL_INCLUDES}
${SNPRINTF_SOURCES}
boyer_moore.cc
target_include_directories( utils PRIVATE ${FLATBUFFERS_INCLUDE_DIR} )
endif()
-target_link_libraries(utils
- log
-)
-
install (FILES ${UTIL_INCLUDES}
DESTINATION "${INCLUDE_INSTALL_PATH}/utils"
)
#endif
#include "catch/snort_catch.h"
-#include "main/snort_types.h"
#include "bitop.h"
-SNORT_FORCED_INCLUSION_DEFINITION(bitop_test);
-
static bool t_bitop_buffer_zero(BitOp& bitop)
{
for ( size_t i = 0; i < bitop.get_buf_size(); ++i )
#include <limits>
#include <string>
-#include "main/snort_types.h"
-
#include "util.h"
-SNORT_FORCED_INCLUSION_DEFINITION(kmap);
-
KMAP* KMapNew(KMapUserFreeFunc userfree)
{
KMAP* km = (KMAP*)snort_calloc(sizeof(KMAP));
#include <cstdlib>
#include <cstring>
-#include "main/snort_types.h"
#include "main/thread.h"
#define INVALID_HEX_VAL (-1)
#define ANY '\0'
-SNORT_FORCED_INCLUSION_DEFINITION(jsnorm);
-
typedef enum
{
PNORM_ACT_DQUOTES,
#include <iconv.h>
#endif
-#include "main/snort_types.h"
-
#define DSTATE_FIRST 0
#define DSTATE_SECOND 1
#define DSTATE_THIRD 2
#define DSTATE_FOURTH 3
-SNORT_FORCED_INCLUSION_DEFINITION(utf);
-
UtfDecodeSession::UtfDecodeSession()
{
init_decode_utf_state();
)
install (TARGETS fbstreamer
- RUNTIME DESTINATION bin
+ RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
endif()
include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
+add_subdirectory(config_states)
add_subdirectory(data)
+add_subdirectory(helpers)
add_subdirectory(keyword_states)
-add_subdirectory(preprocessor_states)
add_subdirectory(output_states)
-add_subdirectory(config_states)
+add_subdirectory(preprocessor_states)
add_subdirectory(rule_states)
-add_subdirectory(helpers)
if (ENABLE_UNIT_TESTS)
if (0)
init_state.h
snort2lua.cc
init_state.cc
-)
-
-target_link_libraries( snort2lua
- conversion_data
- snort2lua_helpers
- keyword_states
- output_states
- preprocessor_states
- rule_states
+ $<TARGET_OBJECTS:config_states>
+ $<TARGET_OBJECTS:conversion_data>
+ $<TARGET_OBJECTS:data_types>
+ $<TARGET_OBJECTS:keyword_states>
+ $<TARGET_OBJECTS:output_states>
+ $<TARGET_OBJECTS:preprocessor_states>
+ $<TARGET_OBJECTS:rule_states>
+ $<TARGET_OBJECTS:snort2lua_helpers>
)
install (TARGETS snort2lua
- RUNTIME DESTINATION bin
+ RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
-add_library( config_states STATIC
+add_library( config_states OBJECT
config_alertfile.cc
config_binding.cc
config_checksums.cc
config_api.cc
)
-target_link_libraries( config_states
- snort2lua_helpers
- conversion_data
-)
add_subdirectory (data_types)
-add_library( conversion_data STATIC
+add_library( conversion_data OBJECT
dt_data.h
dt_data.cc
dt_table_api.h
dt_rule_api.cc
)
-target_link_libraries( conversion_data
- data_types
-)
-add_library( data_types STATIC
+add_library( data_types OBJECT
dt_comment.h
dt_comment.cc
dt_include.h
-add_library( snort2lua_helpers STATIC
+add_library( snort2lua_helpers OBJECT
converter.h
converter.cc
s2l_util.h
s2l_markup.cc
)
-target_link_libraries( snort2lua_helpers
- conversion_data
-)
-add_library( keyword_states STATIC
+add_library( keyword_states OBJECT
kws_attribute_table.cc
kws_config.cc
kws_deleted.cc
keywords_api.cc
)
-target_link_libraries( keyword_states
- snort2lua_helpers
- conversion_data
- output_states
- preprocessor_states
- config_states
- rule_states
-)
-add_library(output_states STATIC
+add_library(output_states OBJECT
out_csv.cc
out_deleted.cc
out_fast.cc
output_api.cc
)
-target_link_libraries( output_states
- snort2lua_helpers
- conversion_data
-)
-add_library(preprocessor_states STATIC
+add_library(preprocessor_states OBJECT
pps_appid.cc
pps_arpspoof.cc
pps_bo.cc
preprocessor_api.cc
)
-target_link_libraries( preprocessor_states
- snort2lua_helpers
- conversion_data
-)
-add_library( rule_states STATIC
+add_library( rule_states OBJECT
rule_base64_decode.cc
rule_content.cc
rule_convert_comma_list.cc
rule_api.h
)
-target_link_libraries( rule_states
- snort2lua_helpers
- conversion_data
-)
)
install (TARGETS u2boat
- RUNTIME DESTINATION bin
+ RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
install(FILES README.u2boat
- DESTINATION "${SNORT_DATA_DIR}"
+ DESTINATION "${CMAKE_INSTALL_DOCDIR}"
)
)
install (TARGETS u2spewfoo
- RUNTIME DESTINATION bin
+ RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
projects / thirdparty / snort3.git / commitdiff
