commit ea6a9a9a941f2b6c0b2b8a424256c931def64482 Author: stubbfel Date: Thu Jan 28 01:23:45 2016 +0100 init diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..9aa0898 --- /dev/null +++ b/Makefile @@ -0,0 +1,69 @@ +include $(TOPDIR)/rules.mk + +PKG_NAME:=121nat +PKG_VERSION:=0.5.0 +PKG_RELEASE:=1 +PKG_SOURCE_PROTO:=git +PKG_SOURCE_URL:=https://github.com/stubbfel/121nat.git +PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz +PKG_SOURCE_VERSION:=HEAD +PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION) +PKG_BUILD_DIR:=$(BUILD_DIR)/$(PKG_NAME)-$(PKG_VERSION) +PKG_LICENSE:=MIT +PKG_LICENSE_FILES:=LICENSE + +include $(INCLUDE_DIR)/package.mk + +define Package/121nat + SECTION:=net + SUBMENU:=Routing and Redirection + CATEGORY:=Network + TITLE:=Transparent One-To-One-Nat + DEPENDS:=+libstdcpp +libpthread +libpcap +endef + +define Package/121nat/description + a simple transparent one to one nat +endef + +define Build/Configure + mkdir -p $(PKG_BUILD_DIR)/build/121Nat + $(CP) ./files/jsoncpp/CMakeLists.txt $(PKG_BUILD_DIR)/lib/src/jsoncpp/ + $(CP) ./files/libtins/CMakeLists.txt $(PKG_BUILD_DIR)/lib/src/libtins/ + $(CP) ./files/libtins/src/CMakeLists.txt $(PKG_BUILD_DIR)/lib/src/libtins/src/ + $(CP) ./files/121nat/src/CMakeLists.txt $(PKG_BUILD_DIR)/src/ + $(CP) ./files/121nat/CMakeLists.txt $(PKG_BUILD_DIR)/ + + IN_OPENWRT=1 \ + AR="$(TOOLCHAIN_DIR)/bin/$(TARGET_CROSS)ar" \ + AS="$(TOOLCHAIN_DIR)/bin/$(TARGET_CC) -c $(TARGET_CFLAGS)" \ + LD="$(TOOLCHAIN_DIR)/bin/$(TARGET_CROSS)ld" \ + NM="$(TOOLCHAIN_DIR)/bin/$(TARGET_CROSS)nm" \ + CC="$(TOOLCHAIN_DIR)/bin/$(TARGET_CC)" \ + GCC="$(TOOLCHAIN_DIR)/bin/$(TARGET_CC)" \ + CXX="$(TOOLCHAIN_DIR)/bin/$(TARGET_CROSS)g++" \ + RANLIB="$(TOOLCHAIN_DIR)/bin/$(TARGET_CROSS)ranlib" \ + STRIP="$(TOOLCHAIN_DIR)/bin/$(TARGET_CROSS)strip" \ + OBJCOPY="$(TOOLCHAIN_DIR)/bin/$(TARGET_CROSS)objcopy" \ + OBJDUMP="$(TOOLCHAIN_DIR)/bin/$(TARGET_CROSS)objdump" \ + TARGET_CPPFLAGS="$(TARGET_CPPFLAGS)" \ + TARGET_CFLAGS="$(TARGET_CFLAGS)" \ + TARGET_LDFLAGS="$(TARGET_LDFLAGS)" \ + cmake -H$(PKG_BUILD_DIR)/ -B$(PKG_BUILD_DIR)/build/121Nat +endef + +define Build/Compile + $(MAKE) -C $(PKG_BUILD_DIR)/build/121Nat/ +endef + +define Package/121nat/install + $(INSTALL_DIR) $(1)/usr/lib/ + $(INSTALL_BIN) $(PKG_BUILD_DIR)/build/121Nat/lib/src/libtins/lib/libtins.so.3.3 $(1)/usr/lib/ + $(INSTALL_BIN) $(PKG_BUILD_DIR)/build/121Nat/lib/src/jsoncpp/src/lib_json/libjsoncpp.a $(1)/usr/lib/ + $(INSTALL_DIR) $(1)/usr/bin + $(INSTALL_BIN) $(PKG_BUILD_DIR)/build/121Nat/src/121Nat $(1)/usr/bin + $(INSTALL_DIR) $(1)/etc/121nat + $(INSTALL_BIN) $(PKG_BUILD_DIR)/src/config.json $(1)/etc/121nat +endef + +$(eval $(call BuildPackage,121nat)) diff --git a/files/121nat/CMakeLists.txt b/files/121nat/CMakeLists.txt new file mode 100644 index 0000000..235ef15 --- /dev/null +++ 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) + + diff --git a/files/121nat/src/CMakeLists.txt b/files/121nat/src/CMakeLists.txt new file mode 100644 index 0000000..120cace --- /dev/null +++ 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 +) + diff --git a/files/jsoncpp/CMakeLists.txt b/files/jsoncpp/CMakeLists.txt new file mode 100644 index 0000000..181519e --- /dev/null +++ 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 ) diff --git a/files/libtins/CMakeLists.txt b/files/libtins/CMakeLists.txt new file mode 100644 index 0000000..02aef97 --- /dev/null +++ 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 +) diff --git a/files/libtins/src/CMakeLists.txt b/files/libtins/src/CMakeLists.txt new file mode 100644 index 0000000..f97acaa --- /dev/null +++ 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 +)