init

2016-01-28 01:23:45 +01:00
commit ea6a9a9a94
6 changed files with 525 additions and 0 deletions
--- a/files/121nat/CMakeLists.txt
+++ b/files/121nat/CMakeLists.txt
@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.3.2)
+project (121Nat)
+link_directories("$ENV{STAGING_DIR}/usr/lib")
+ADD_SUBDIRECTORY(lib/src/jsoncpp)
+ADD_SUBDIRECTORY(lib/src/libtins)
+ADD_SUBDIRECTORY(src)
+
+
--- a/files/121nat/src/CMakeLists.txt
+++ b/files/121nat/src/CMakeLists.txt
@@ -0,0 +1,11 @@
+file(GLOB_RECURSE 121Nat_Src_Files "*.h" "*.cpp")
+INCLUDE_DIRECTORIES(../lib/src/libtins/include)
+INCLUDE_DIRECTORIES(../lib/src/jsoncpp/include)
+add_executable(121Nat ${121Nat_Src_Files})
+target_link_libraries (121Nat pthread tins jsoncpp_lib_static "$ENV{TARGET_LDFLAGS}" )
+set_property(TARGET 121Nat PROPERTY CXX_STANDARD 11)
+set_property(TARGET 121Nat PROPERTY CXX_STANDARD_REQUIRED ON)
+install(TARGETS 121Nat
+        RUNTIME DESTINATION bin
+)
+
--- a/files/jsoncpp/CMakeLists.txt
+++ b/files/jsoncpp/CMakeLists.txt
@@ -0,0 +1,146 @@
+# vim: et ts=4 sts=4 sw=4 tw=0
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.5)
+PROJECT(jsoncpp)
+#ENABLE_TESTING()
+
+OPTION(JSONCPP_WITH_TESTS "Compile and (for jsoncpp_check) run JsonCpp test executables" OFF)
+OPTION(JSONCPP_WITH_POST_BUILD_UNITTEST "Automatically run unit-tests as a post build step" OFF)
+OPTION(JSONCPP_WITH_WARNING_AS_ERROR "Force compilation to fail if a warning occurs" OFF)
+OPTION(JSONCPP_WITH_STRICT_ISO "Issue all the warnings demanded by strict ISO C and ISO C++" ON)
+OPTION(JSONCPP_WITH_PKGCONFIG_SUPPORT "Generate and install .pc files" ON)
+OPTION(JSONCPP_WITH_CMAKE_PACKAGE "Generate and install cmake package files" OFF)
+OPTION(BUILD_SHARED_LIBS "Build jsoncpp_lib as a shared library." Off)
+OPTION(BUILD_STATIC_LIBS "Build jsoncpp_lib static library." On)
+
+# Ensures that CMAKE_BUILD_TYPE is visible in cmake-gui on Unix
+IF(NOT WIN32)
+    IF(NOT CMAKE_BUILD_TYPE)
+        SET(CMAKE_BUILD_TYPE Release CACHE STRING
+            "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel Coverage."
+            FORCE)
+    ENDIF()
+ENDIF()
+
+SET(DEBUG_LIBNAME_SUFFIX "" CACHE STRING "Optional suffix to append to the library name for a debug build")
+SET(LIB_SUFFIX "" CACHE STRING "Optional arch-dependent suffix for the library installation directory")
+
+SET(RUNTIME_INSTALL_DIR bin
+    CACHE PATH "Install dir for executables and dlls")
+SET(ARCHIVE_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}
+    CACHE PATH "Install dir for static libraries")
+SET(LIBRARY_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}
+    CACHE PATH "Install dir for shared libraries")
+SET(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/include
+    CACHE PATH "Install dir for headers")
+SET(PACKAGE_INSTALL_DIR lib${LIB_SUFFIX}/cmake
+    CACHE PATH "Install dir for cmake package config files")
+MARK_AS_ADVANCED( RUNTIME_INSTALL_DIR ARCHIVE_INSTALL_DIR INCLUDE_INSTALL_DIR PACKAGE_INSTALL_DIR )
+
+# Set variable named ${VAR_NAME} to value ${VALUE}
+FUNCTION(set_using_dynamic_name VAR_NAME VALUE)
+    SET( "${VAR_NAME}" "${VALUE}" PARENT_SCOPE)
+ENDFUNCTION()
+
+# Extract major, minor, patch from version text
+# Parse a version string "X.Y.Z" and outputs
+# version parts in ${OUPUT_PREFIX}_MAJOR, _MINOR, _PATCH.
+# If parse succeeds then ${OUPUT_PREFIX}_FOUND is TRUE.
+MACRO(jsoncpp_parse_version VERSION_TEXT OUPUT_PREFIX)
+    SET(VERSION_REGEX "[0-9]+\\.[0-9]+\\.[0-9]+(-[a-zA-Z0-9_]+)?")
+    IF( ${VERSION_TEXT} MATCHES ${VERSION_REGEX} )
+        STRING(REGEX MATCHALL "[0-9]+|-([A-Za-z0-9_]+)" VERSION_PARTS ${VERSION_TEXT})
+        LIST(GET VERSION_PARTS 0 ${OUPUT_PREFIX}_MAJOR)
+        LIST(GET VERSION_PARTS 1 ${OUPUT_PREFIX}_MINOR)
+        LIST(GET VERSION_PARTS 2 ${OUPUT_PREFIX}_PATCH)
+        set_using_dynamic_name( "${OUPUT_PREFIX}_FOUND" TRUE )
+    ELSE( ${VERSION_TEXT} MATCHES ${VERSION_REGEX} )
+        set_using_dynamic_name( "${OUPUT_PREFIX}_FOUND" FALSE )
+    ENDIF()
+ENDMACRO()
+
+# Read out version from "version" file
+#FILE(STRINGS "version" JSONCPP_VERSION)
+#SET( JSONCPP_VERSION_MAJOR X )
+#SET( JSONCPP_VERSION_MINOR Y )
+#SET( JSONCPP_VERSION_PATCH Z )
+SET( JSONCPP_VERSION 1.6.5 )
+jsoncpp_parse_version( ${JSONCPP_VERSION} JSONCPP_VERSION )
+#IF(NOT JSONCPP_VERSION_FOUND)
+#    MESSAGE(FATAL_ERROR "Failed to parse version string properly. Expect X.Y.Z")
+#ENDIF(NOT JSONCPP_VERSION_FOUND)
+
+MESSAGE(STATUS "JsonCpp Version: ${JSONCPP_VERSION_MAJOR}.${JSONCPP_VERSION_MINOR}.${JSONCPP_VERSION_PATCH}")
+# File version.h is only regenerated on CMake configure step
+CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/src/lib_json/version.h.in"
+                "${PROJECT_SOURCE_DIR}/include/json/version.h"
+                NEWLINE_STYLE UNIX )
+CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/version.in"
+                "${PROJECT_SOURCE_DIR}/version"
+                NEWLINE_STYLE UNIX )
+
+macro(UseCompilationWarningAsError)
+	if ( MSVC )
+        # Only enabled in debug because some old versions of VS STL generate
+        # warnings when compiled in release configuration.
+		set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /WX ")
+  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+    if (JSONCPP_WITH_STRICT_ISO)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic-errors")
+    endif ()
+	endif()
+endmacro()
+
+# Include our configuration header
+INCLUDE_DIRECTORIES( ${jsoncpp_SOURCE_DIR}/include )
+
+if ( MSVC )
+    # Only enabled in debug because some old versions of VS STL generate
+    # unreachable code warning when compiled in release configuration.
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /W4 ")
+endif()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  # using regular Clang or AppleClang
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Wconversion -Wshadow -Wno-sign-conversion")
+elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  # using GCC
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Wconversion -Wshadow -Wextra")
+  # not yet ready for -Wsign-conversion
+
+  if (JSONCPP_WITH_STRICT_ISO AND NOT JSONCPP_WITH_WARNING_AS_ERROR)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
+  endif ()
+endif()
+
+find_program(CCACHE_FOUND ccache)
+if(CCACHE_FOUND)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+endif(CCACHE_FOUND)
+
+IF(JSONCPP_WITH_WARNING_AS_ERROR)
+    UseCompilationWarningAsError()
+ENDIF()
+
+IF(JSONCPP_WITH_PKGCONFIG_SUPPORT)
+	CONFIGURE_FILE(
+		"pkg-config/jsoncpp.pc.in"
+		"pkg-config/jsoncpp.pc"
+		@ONLY)
+	INSTALL(FILES "${CMAKE_BINARY_DIR}/pkg-config/jsoncpp.pc"
+		DESTINATION "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/pkgconfig")
+ENDIF()
+
+IF(JSONCPP_WITH_CMAKE_PACKAGE)
+        INSTALL(EXPORT jsoncpp
+                DESTINATION ${PACKAGE_INSTALL_DIR}/jsoncpp
+                FILE        jsoncppConfig.cmake)
+ENDIF()
+
+# Build the different applications
+ADD_SUBDIRECTORY( src )
+
+#install the includes
+ADD_SUBDIRECTORY( include )
--- a/files/libtins/CMakeLists.txt
+++ b/files/libtins/CMakeLists.txt
@@ -0,0 +1,211 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.1)
+PROJECT(libtins)
+#INCLUDE_DIRECTORIES("$ENV{TARGET_LDFLAGS}" "$ENV{TARGET_CPPFLAGS}" "$ENV{TARGET_CFLAGS}")
+# Compile in release mode by default
+IF(NOT CMAKE_BUILD_TYPE)
+    MESSAGE(STATUS "Setting build type to 'RelWithDebInfo' as none was specified.")
+    SET(CMAKE_BUILD_TYPE RelWithDebInfo) 
+ELSE(NOT CMAKE_BUILD_TYPE)
+    MESSAGE(STATUS "Using specified '${CMAKE_BUILD_TYPE}' build type.")
+ENDIF(NOT CMAKE_BUILD_TYPE)
+
+# Compilation flags.
+IF(MSVC)
+    # Don't always use Wall, since VC's /Wall is ridiculously verbose.
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3")
+    # Disable VC secure checks, since these are not really issues.
+    ADD_DEFINITIONS("-D_CRT_SECURE_NO_WARNINGS=1")
+    ADD_DEFINITIONS("-D_SCL_SECURE_NO_WARNINGS=1")
+ELSE()
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+    # Fix for Clang on OSX
+    ADD_DEFINITIONS("-DGTEST_HAS_TR1_TUPLE=0")
+ENDIF()
+
+# Build output checks
+OPTION(LIBTINS_BUILD_SHARED "Build libtins as a shared library." ON)
+IF(LIBTINS_BUILD_SHARED)
+    MESSAGE(
+        STATUS 
+        "Build will generate a shared library. "
+        "Use LIBTINS_BUILD_SHARED=0 to perform a static build"
+    )
+    SET(LIBTINS_TYPE SHARED)
+ELSE(LIBTINS_BUILD_SHARED)
+    MESSAGE(STATUS "Build will generate a static library.")
+    SET(LIBTINS_TYPE STATIC)
+ENDIF(LIBTINS_BUILD_SHARED)
+
+# The version number.
+SET(LIBTINS_VERSION_MAJOR 3)
+SET(LIBTINS_VERSION_MINOR 3)
+SET(LIBTINS_VERSION "${LIBTINS_VERSION_MAJOR}.${LIBTINS_VERSION_MINOR}")
+
+# Required Packages
+SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/lib/src/libtins/cmake/Modules/")
+
+# Look for libpcap
+#FIND_PACKAGE(PCAP REQUIRED)
+
+# Set some Windows specific flags
+IF(WIN32)
+    # We need to link against these libs
+    SET(LIBTINS_OS_LIBS Ws2_32.lib Iphlpapi.lib)
+
+    # Add the NOMINMAX macro to avoid Windows' min and max macros.
+    ADD_DEFINITIONS(-DNOMINMAX)
+ENDIF(WIN32)
+
+# *******************
+# Compilation options
+# *******************
+
+# C++11 support
+
+#OPTION(LIBTINS_ENABLE_CXX11 "Compile libtins with c++11 features" On)
+#IF(LIBTINS_ENABLE_CXX11)
+#    SET(HAVE_CXX11 ON)
+#    INCLUDE(CheckCXX11Features)
+#    IF(HAS_CXX11_NULLPTR AND HAS_CXX11_RVALUE_REFERENCES)
+#        MESSAGE(STATUS "Enabling C++11 features")
+#        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX11_COMPILER_FLAGS}")
+#    ELSE(HAS_CXX11_NULLPTR AND HAS_CXX11_RVALUE_REFERENCES)
+#        MESSAGE(FATAL_ERROR "C++11 features requested but the compiler does not support them.")
+#    ENDIF(HAS_CXX11_NULLPTR AND HAS_CXX11_RVALUE_REFERENCES)
+#ELSE(LIBTINS_ENABLE_CXX11)
+#    MESSAGE(
+#        WARNING 
+#        "Disabling C++11 features. Use LIBTINS_ENABLE_CXX11=1 to enable them. "
+#        "Unless you are using an old compiler, you should enable this option, "
+#        "as it increases the library's performance")
+#ENDIF(LIBTINS_ENABLE_CXX11)
+
+# IEEE 802.11 and WPA2 decryption support
+OPTION(LIBTINS_ENABLE_DOT11 "Compile libtins with IEEE 802.11 support" Off)
+OPTION(LIBTINS_ENABLE_WPA2 "Compile libtins with WPA2 decryption features (requires OpenSSL)" Off)
+IF(LIBTINS_ENABLE_DOT11)
+    SET(HAVE_DOT11 ON)
+    MESSAGE(STATUS "Enabling IEEE 802.11 support.")
+    IF(LIBTINS_ENABLE_WPA2)
+        FIND_PACKAGE(OpenSSL REQUIRED)
+        SET(HAVE_WPA2_DECRYPTION ON)
+        MESSAGE(STATUS "Enabling WPA2 decryption support.")
+    ELSE(LIBTINS_ENABLE_WPA2)
+        MESSAGE(STATUS "Disabling WPA2 decryption support.")
+    ENDIF(LIBTINS_ENABLE_WPA2)
+ENDIF(LIBTINS_ENABLE_DOT11)
+
+# Use pcap_sendpacket to send l2 packets rather than raw sockets
+IF(WIN32)
+    SET(USE_PCAP_SENDPACKET_DEFAULT ON)
+ELSE(WIN32)
+    SET(USE_PCAP_SENDPACKET_DEFAULT OFF)
+ENDIF(WIN32)
+
+OPTION(LIBTINS_USE_PCAP_SENDPACKET "Use pcap_sendpacket to send l2 packets"
+        ${USE_PCAP_SENDPACKET_DEFAULT})
+IF(LIBTINS_USE_PCAP_SENDPACKET)
+    SET(HAVE_PACKET_SENDER_PCAP_SENDPACKET ON)
+    MESSAGE(STATUS "Using pcap_sendpacket to send l2 packets.")
+ENDIF(LIBTINS_USE_PCAP_SENDPACKET)
+
+# Add a target to generate API documentation using Doxygen
+FIND_PACKAGE(Doxygen QUIET)
+IF(DOXYGEN_FOUND)
+    CONFIGURE_FILE(
+        ${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile.in 
+        ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile 
+        @ONLY
+    )
+    ADD_CUSTOM_TARGET(
+        docs
+        ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Generating API documentation with Doxygen" VERBATIM
+    )
+ENDIF(DOXYGEN_FOUND)
+
+# The library output directory
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
+
+# Configuration file
+CONFIGURE_FILE(
+  "${PROJECT_SOURCE_DIR}/include/tins/config.h.in"
+  "${PROJECT_SOURCE_DIR}/include/tins/config.h"
+)
+
+# Support for pkg-config
+SET(CMAKE_INSTALL_LIBDIR lib)
+SET(pkgconfig_prefix      ${CMAKE_INSTALL_PREFIX})
+SET(pkgconfig_exec_prefix ${CMAKE_INSTALL_PREFIX})
+SET(pkgconfig_libdir      ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
+SET(pkgconfig_version     ${LIBTINS_VERSION})
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/libtins.pc.in
+                ${CMAKE_CURRENT_BINARY_DIR}/libtins.pc @ONLY)
+
+INSTALL(
+    FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/libtins.pc
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
+)
+
+# ******************
+# Add subdirectories
+# ******************
+ADD_SUBDIRECTORY(include)
+ADD_SUBDIRECTORY(src)
+#ADD_SUBDIRECTORY(examples)
+
+# Only include googletest if the git submodule has been fetched
+#IF(EXISTS "${CMAKE_SOURCE_DIR}/googletest/CMakeLists.txt")
+    # Enable tests and add the test directory
+#    MESSAGE(STATUS "Tests have been enabled")
+#    SET(gtest_force_shared_crt ON CACHE BOOL "Always use /MD")
+#    ENABLE_TESTING()
+#    ADD_SUBDIRECTORY(googletest)
+#    ADD_SUBDIRECTORY(tests)
+#ELSE()
+#    MESSAGE(STATUS "googletest git submodule is absent. Run `git submodule init && git submodule update` to get it")
+#ENDIF()
+
+# **********************************
+# CMake project configuration export
+# **********************************
+
+# Add all targets to the build-tree export set
+EXPORT(
+    TARGETS tins
+    FILE "${PROJECT_BINARY_DIR}/libtinsTargets.cmake"
+)
+
+# Export the package for use from the build-tree
+# (this registers the build-tree with a global CMake-registry)
+EXPORT(PACKAGE libtins)
+
+# Create the libtinsConfig.cmake and libtinsConfigVersion.cmake files
+# for the build tree
+SET(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/include")
+CONFIGURE_FILE(
+    cmake/libtinsConfig.cmake.in
+    "${PROJECT_BINARY_DIR}/libtinsConfig.cmake" @ONLY
+)
+CONFIGURE_FILE(
+    cmake/libtinsConfigVersion.cmake.in
+    "${PROJECT_BINARY_DIR}/libtinsConfigVersion.cmake" @ONLY
+)
+# Install the libtinsConfig.cmake and libtinsConfigVersion.cmake
+INSTALL(
+    FILES
+    "${PROJECT_BINARY_DIR}/libtinsConfig.cmake"
+    "${PROJECT_BINARY_DIR}/libtinsConfigVersion.cmake"
+    DESTINATION CMake
+    COMPONENT dev
+)
+
+# Install the export set for use with the install-tree
+INSTALL(
+    EXPORT libtinsTargets
+    DESTINATION CMake
+    COMPONENT dev
+)
--- a/files/libtins/src/CMakeLists.txt
+++ b/files/libtins/src/CMakeLists.txt
@@ -0,0 +1,80 @@
+SET(LIBTINS_INCLUDE_DIR ../include/tins/)
+
+#IF(HAVE_PCAP_IMMEDIATE_MODE)
+    ADD_DEFINITIONS("-DHAVE_PCAP_IMMEDIATE_MODE=1")
+#ENDIF()
+
+INCLUDE_DIRECTORIES(
+    ${LIBTINS_INCLUDE_DIR}
+    ${OPENSSL_INCLUDE_DIR}
+    "$ENV{STAGING_DIR}/usr/include"
+)
+
+ADD_LIBRARY( 
+    tins ${LIBTINS_TYPE}
+    arp.cpp
+    bootp.cpp
+    handshake_capturer.cpp
+    stp.cpp
+    pppoe.cpp
+    crypto.cpp
+    dhcp.cpp
+    dhcpv6.cpp
+    dns.cpp
+    dot3.cpp
+    dot1q.cpp
+    eapol.cpp
+    ethernetII.cpp
+    icmp.cpp
+    icmpv6.cpp
+    internals.cpp
+    ip_reassembler.cpp
+    ip.cpp
+    ip_address.cpp
+    ipv6.cpp
+    ipv6_address.cpp
+    ipsec.cpp
+    llc.cpp
+    loopback.cpp
+    network_interface.cpp
+    offline_packet_filter.cpp
+    packet_sender.cpp
+    packet_writer.cpp
+    ppi.cpp
+    pdu.cpp
+    pktap.cpp
+    radiotap.cpp
+    address_range.cpp
+    rawpdu.cpp
+    rsn_information.cpp
+    sll.cpp
+    snap.cpp
+    sniffer.cpp
+    tcp.cpp
+    tcp_stream.cpp
+    udp.cpp
+    utils.cpp
+    dot11/dot11_base.cpp
+    dot11/dot11_data.cpp
+    dot11/dot11_mgmt.cpp
+    dot11/dot11_beacon.cpp
+    dot11/dot11_assoc.cpp
+    dot11/dot11_auth.cpp
+    dot11/dot11_probe.cpp
+    dot11/dot11_control.cpp
+)
+
+TARGET_LINK_LIBRARIES(tins "$ENV{STAGING_DIR}/usr/lib/libpcap.so" ${OPENSSL_LIBRARIES} ${LIBTINS_OS_LIBS} "$ENV{TARGET_LDFLAGS}")
+
+SET_TARGET_PROPERTIES(tins PROPERTIES OUTPUT_NAME tins )
+SET_TARGET_PROPERTIES(tins PROPERTIES VERSION ${LIBTINS_VERSION} SOVERSION ${LIBTINS_VERSION} )
+set_property(TARGET tins PROPERTY CXX_STANDARD 11)
+set_property(TARGET tins PROPERTY CXX_STANDARD_REQUIRED ON)
+# Install instructions for this target
+INSTALL( 
+    TARGETS tins
+    EXPORT libtinsTargets
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib
+    COMPONENT dev
+)