# Needed for GREATER_EQUAL operator
cmake_minimum_required(VERSION 3.7)
else()
- cmake_minimum_required(VERSION 2.8.12)
+ cmake_minimum_required(VERSION 3.5)
endif()
#Where to find local cmake scripts
set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
-# Set old behaviour for MACOSX_RPATH (since 3.0)
-if (POLICY CMP0042)
- cmake_policy(SET CMP0042 OLD)
-endif()
-
-# Set old behaviour for variable quoting (since 3.1)
-if (POLICY CMP0054)
- cmake_policy(SET CMP0054 OLD)
-endif()
-
# If our target platform is enforced by our generator, set
# WIRESHARK_TARGET_PLATFORM accordingly. Otherwise use
# %WIRESHARK_TARGET_PLATFORM%.
if(WIN32)
find_package(PowerShell REQUIRED)
- if(${CMAKE_CL_64} OR "${CMAKE_GENERATOR}" MATCHES "Win64")
+ if(CMAKE_CL_64 OR CMAKE_GENERATOR MATCHES "Win64")
set(WIRESHARK_TARGET_PLATFORM win64)
- elseif("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
+ elseif(CMAKE_GENERATOR MATCHES "Visual Studio")
set(WIRESHARK_TARGET_PLATFORM win32)
else()
set(WIRESHARK_TARGET_PLATFORM $ENV{WIRESHARK_TARGET_PLATFORM})
endif()
- if ("${WIRESHARK_TARGET_PLATFORM}" MATCHES "win64")
+ if(WIRESHARK_TARGET_PLATFORM MATCHES "win64")
set(WIRESHARK_TARGET_PROCESSOR_ARCHITECTURE amd64)
else()
set(WIRESHARK_TARGET_PROCESSOR_ARCHITECTURE x86)
# Download third-party libraries
file (TO_NATIVE_PATH ${CMAKE_SOURCE_DIR}/tools/win-setup.ps1 _win_setup)
file (TO_NATIVE_PATH ${_PROJECT_LIB_DIR} _ws_lib_dir)
- if(MSVC14)
- set(_vsversion_args "14")
- elseif(MSVC12)
- set(_vsversion_args "12")
- elseif(MSVC11)
- set(_vsversion_args "11")
- elseif(MSVC10)
- set(_vsversion_args "10")
- else()
- message(FATAL_ERROR "Unsupported compiler ${CMAKE_C_COMPILER}")
- endif()
# Is it possible to have a one-time, non-cached option in CMake? If
# so, we could add a "-DFORCE_WIN_SETUP" which passes -Force to
# win-setup.ps1.
execute_process(
- COMMAND ${POWERSHELL_COMMAND} "\"${_win_setup}\"" -Destination "${_ws_lib_dir}" -Platform ${WIRESHARK_TARGET_PLATFORM} -VSVersion ${_vsversion_args}
+ COMMAND ${POWERSHELL_COMMAND} "\"${_win_setup}\"" -Destination "${_ws_lib_dir}" -Platform ${WIRESHARK_TARGET_PLATFORM}
RESULT_VARIABLE _win_setup_failed
)
- if (${_win_setup_failed})
+ if(_win_setup_failed)
message(FATAL_ERROR "Windows setup (win-setup.ps1) failed.")
endif()
# Head off any attempts to use Cygwin's Python.
include(LocatePythonExecutable)
+
+ # Prepopulate some ConfigureChecks values. Compilation checks
+ # on Windows can be slow.
+ set(HAVE_FCNTL_H TRUE)
+ set(HAVE_FLOORL TRUE)
+ set(HAVE_LRINT TRUE)
+
+ # It looks like we call check_type_size somewhere, which checks
+ # for these.
+ set(HAVE_SYS_TYPES_H TRUE)
+ set(HAVE_STDINT_H TRUE)
+ set(HAVE_STDDEF_H TRUE)
endif(WIN32)
include(UseCustomIncludes)
# https://cmake.org/Wiki/CMake_RPATH_handling
if(NOT CMAKE_INSTALL_RPATH AND NOT (WIN32 OR APPLE))
LIST(FIND CMAKE_C_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_FULL_LIBDIR}" IS_SYSTEM_DIR)
- if("${IS_SYSTEM_DIR}" STREQUAL "-1")
+ if(IS_SYSTEM_DIR STREQUAL "-1")
SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_FULL_LIBDIR}")
SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
- endif("${IS_SYSTEM_DIR}" STREQUAL "-1")
+ endif()
endif()
+if(WIN32)
+ # Linking with wsetargv.obj enables "wildcard expansion" of
+ # command-line arguments.
+ set(WILDCARD_OBJ wsetargv.obj)
+endif(WIN32)
+
# Banner shown at top right of Qt welcome screen.
if(DEFINED ENV{WIRESHARK_VERSION_FLAVOR})
set(VERSION_FLAVOR "$ENV{WIRESHARK_VERSION_FLAVOR}")
include(UseLemon)
include(UseMakePluginReg)
include(UseMakeTaps)
+include(UseExecutableResources)
include(UseAsn2Wrs)
# The following snippet has been taken from
# lookup tables for the epan libraries
# Check if CXX flags have been set to c++11 -> Setup Eclipse Indexer correctly!
# Also setup the project slightly different
-if (${CMAKE_EXTRA_GENERATOR} MATCHES "Eclipse CDT4" )
+if(CMAKE_EXTRA_GENERATOR MATCHES "Eclipse CDT4")
SET(CXX_ENABLED 0)
LIST(LENGTH CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS LIST_LEN)
- if ( ${LIST_LEN} GREATER 0 )
+ if(LIST_LEN GREATER 0)
SET(CXX_ENABLED 1)
endif()
SET(C_ENABLED 0)
LIST(LENGTH CMAKE_EXTRA_GENERATOR_C_SYSTEM_DEFINED_MACROS LIST_LEN)
- if ( ${LIST_LEN} GREATER 0)
+ if(LIST_LEN GREATER 0)
SET(C_ENABLED 1)
endif()
- if (${C_ENABLED} EQUAL 1 AND ${CXX_ENABLED} EQUAL 1)
+ if(C_ENABLED EQUAL 1 AND CXX_ENABLED EQUAL 1)
# Combined project (C and CXX). This will confuse the indexer. For that reason
# we unsert set the __cplusplus variable for the indexer
list(FIND CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS "__cplusplus" GEN_MACRO_INDEX)
- if( ${GEN_MACRO_INDEX} GREATER -1 )
+ if(GEN_MACRO_INDEX GREATER -1)
list(REMOVE_AT CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS ${GEN_MACRO_INDEX})
list(REMOVE_AT CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS ${GEN_MACRO_INDEX})
endif()
SET(CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS ${CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS} CACHE INTERNAL "")
- elseif ( (${CXX_ENABLED} EQUAL 1) AND (${CMAKE_CXX_FLAGS} MATCHES ".*-std=c\\+\\+11.*"))
+ elseif((CXX_ENABLED EQUAL 1) AND (CMAKE_CXX_FLAGS MATCHES ".*-std=c\\+\\+11.*"))
#add_definitions (-D__cplusplus=201103L)
# CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS
list(FIND CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS "199711L" GEN_MACRO_INDEX)
- if( ${GEN_MACRO_INDEX} GREATER -1 )
+ if(GEN_MACRO_INDEX GREATER -1)
list(REMOVE_AT CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS ${GEN_MACRO_INDEX})
list(INSERT CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS ${GEN_MACRO_INDEX} "201103L")
SET(CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS ${CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS} CACHE INTERNAL "")
endif()
if(APPLE AND EXISTS /usr/local/opt/qt5)
- # Homebrew installs Qt5 (up to at least 5.9.1) in
- # /usr/local/qt5, ensure it can be found by CMake since
- # it is not in the default /usr/local prefix.
- list(APPEND CMAKE_PREFIX_PATH "/usr/local/opt/qt5")
+ # Homebrew installs Qt5 (up to at least 5.11.0) in
+ # /usr/local/qt5. Ensure that it can be found by CMake
+ # since it is not in the default /usr/local prefix.
+ # Add it to PATHS so that it doesn't override the
+ # CMAKE_PREFIX_PATH environment variable.
+ # QT_FIND_PACKAGE_OPTIONS should be passed to find_package,
+ # e.g. find_package(Qt5Core ${QT_FIND_PACKAGE_OPTIONS})
+ set (QT_FIND_PACKAGE_OPTIONS PATHS /usr/local/opt/qt5)
endif()
# Always enable position-independent code when compiling, even for
# This option only has an effect on CMake >= 2.8.9
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+# Path to our generated executables (or wrapper scripts)
+if(WIN32)
+ set(WS_PROGRAM_PATH ./run/$<CONFIG>)
+else()
+ set(WS_PROGRAM_PATH ./run)
+endif()
+
if( CMAKE_C_COMPILER_ID MATCHES "MSVC")
if ((MSVC_VERSION LESS "1900") OR (MSVC_VERSION GREATER_EQUAL "2000"))
message(FATAL_ERROR "You are using an unsupported version of MSVC")
# resolution of symbols, add Psapi.lib to the TARGETLIBS macro and compile the program
# with -DPSAPI_VERSION=1.To use run-time dynamic linking, load Psapi.dll.
# http://msdn.microsoft.com/en-us/library/windows/desktop/ms683219(v=vs.85).aspx
- # -DBUILD_WINDOWS Starting from VS2013, GetVersionEx is deprecated and we are recommended to use
- # VerifyVersionInfo instead
- # http://msdn.microsoft.com/en-us/library/windows/desktop/ms724429(v=vs.85).aspx
- # http://msdn.microsoft.com/en-us/library/windows/desktop/ms725491(v=vs.85).aspx
- # To continue to use GetVersionEx, we can define BUILD_WINDOWS
# -D_ALLOW_KEYWORD_MACROS For VS2012 onwards the, C++ STL does not permit macro redefinitions of keywords
# (see http://msdn.microsoft.com/en-us/library/bb531344(v=vs.110).aspx)
# This definition prevents the complaint about the redefinition of inline by WinPCap
# in pcap-stdinc.h when compiling C++ files, e.g. the Qt UI
/DPSAPI_VERSION=1
- /DBUILD_WINDOWS
/D_ALLOW_KEYWORD_MACROS
)
- if(NOT "${WIRESHARK_TARGET_PLATFORM}" STREQUAL "win64")
+ if(NOT WIRESHARK_TARGET_PLATFORM STREQUAL "win64")
add_definitions("/D_BIND_TO_CURRENT_CRT_VERSION=1")
endif()
set(WS_LINK_FLAGS "/LARGEADDRESSAWARE /MANIFEST:NO /INCREMENTAL:NO /RELEASE")
- if(MSVC12)
- # /Zo Enhanced debugging of optimised code for VS2013 Update 3 and beyond,
- # Assume all VS2013 builds are at least Update 3.
- # See http://msdn.microsoft.com/en-us/library/dn785163.aspx
- list(APPEND LOCAL_CFLAGS /Zo)
- elseif(MSVC14)
- # To do: Add /external:... See https://blogs.msdn.microsoft.com/vcblog/2017/12/13/broken-warnings-theory/
- #
- # /Zo Enhanced debugging of optimised code
- # /utf-8 Set Source and Executable character sets to UTF-8
- # VS2015(MSVC14): On by default when /Zi or /Z7 used.
- # /guard:cf Control Flow Guard (compile and link).
- # See https://msdn.microsoft.com/en-us/library/windows/desktop/mt637065.aspx
- # Note: This requires CMake 3.9.0 or newer.
- # https://gitlab.kitware.com/cmake/cmake/commit/f973d49ab9d4c59b93f6dac812a94bb130200836
- # /Qspectre Speculative execution attack mitigation
- # See https://blogs.msdn.microsoft.com/vcblog/2018/01/15/spectre-mitigations-in-msvc/
- list(APPEND LOCAL_CFLAGS /Zo /utf-8 /guard:cf /Qspectre)
- set(WS_LINK_FLAGS "${WS_LINK_FLAGS} /guard:cf")
- endif()
+ # To do: Add /external:... See https://blogs.msdn.microsoft.com/vcblog/2017/12/13/broken-warnings-theory/
+ #
+ # /Zo Enhanced debugging of optimised code
+ # /utf-8 Set Source and Executable character sets to UTF-8
+ # VS2015(MSVC14): On by default when /Zi or /Z7 used.
+ # /guard:cf Control Flow Guard (compile and link).
+ # See https://msdn.microsoft.com/en-us/library/windows/desktop/mt637065.aspx
+ # Note: This requires CMake 3.9.0 or newer.
+ # https://gitlab.kitware.com/cmake/cmake/commit/f973d49ab9d4c59b93f6dac812a94bb130200836
+ # /Qspectre Speculative execution attack mitigation
+ # See https://blogs.msdn.microsoft.com/vcblog/2018/01/15/spectre-mitigations-in-msvc/
+ list(APPEND LOCAL_CFLAGS /Zo /utf-8 /guard:cf)
+ set(WS_LINK_FLAGS "${WS_LINK_FLAGS} /guard:cf")
+ # /Qspectre is not available for VS2015 or older VS2017. Test for its availability.
+ set(WIRESHARK_COMMON_FLAGS /Qspectre)
if(ENABLE_CODE_ANALYSIS)
list(APPEND LOCAL_CFLAGS /analyze:WX-)
else() # ! MSVC
if(CMAKE_OSX_DEPLOYMENT_TARGET)
if(APPLE)
- if(${CMAKE_OSX_DEPLOYMENT_TARGET} STREQUAL "10.0")
+ if(CMAKE_OSX_DEPLOYMENT_TARGET STREQUAL "10.0")
message(FATAL_ERROR "We don't support building for Mac OS X 10.0")
- elseif(${CMAKE_OSX_DEPLOYMENT_TARGET} STREQUAL "10.1")
+ elseif(CMAKE_OSX_DEPLOYMENT_TARGET STREQUAL "10.1")
message(FATAL_ERROR "We don't support building for Mac OS X 10.1")
- elseif(${CMAKE_OSX_DEPLOYMENT_TARGET} STREQUAL "10.2")
+ elseif(CMAKE_OSX_DEPLOYMENT_TARGET STREQUAL "10.2")
message(FATAL_ERROR "We don't support building for Mac OS X 10.2")
- elseif(${CMAKE_OSX_DEPLOYMENT_TARGET} STREQUAL "10.4" OR ${CMAKE_OSX_DEPLOYMENT_TARGET} STREQUAL "10.5")
+ elseif(CMAKE_OSX_DEPLOYMENT_TARGET STREQUAL "10.4" OR CMAKE_OSX_DEPLOYMENT_TARGET STREQUAL "10.5")
#
# Only 32-bit builds are supported. 10.5
# (and 10.4?) had a bug that causes some BPF
# compilers for which CMake supports it, we may still have
# to do it ourselves on other compilers.
#
+ # In addition, CMake 3.5.2 seems to think that GCC versions
+ # less than 4.4 don't support -std=gnu99, which we need in
+ # order to get support for "for (int i = 0; i < n; i++) ;",
+ # which is another reason not to rely on CMake's CMAKE_C_STANDARD
+ # support.
+ #
# See the CMake documentation for the CMAKE_<LANG>_COMPILER_ID
# variables for a list of compiler IDs.
#
)
endif()
- set(COMMON_WARN_FLAGS
+ list(APPEND WIRESHARK_COMMON_FLAGS
# The following are for C and C++
# -O<X> and -g get set by the CMAKE_BUILD_TYPE
-Wall
-Wextra
+ -Wextra-semi
-Wendif-labels
-Wpointer-arith
-Wformat-security
-Wno-overlength-strings
-Wno-long-long
-Wheader-guard
+ -Wcomma
+ -Wshorten-64-to-32
)
#
# the stack usage - we only care about stack
# usage in normal operation.
#
- set(COMMON_WARN_FLAGS ${COMMON_WARN_FLAGS}
- -Wframe-larger-than=16384
+ set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS}
+ -Wframe-larger-than=32768
)
endif()
- set(C_WARN_FLAGS
+ list(APPEND WIRESHARK_C_ONLY_FLAGS
# The following are C only, not C++
-Wc++-compat
-Wunused-const-variable
# least some Xcode versions that come with Mac OS X
# 10.5, complain about variables in function and
# function pointer *declarations* shadowing other
- # variables. The autoconf script checks for that; we
+ # variables. The autoconf script checked for that; we
# don't.
-Wshadow
-Wno-pointer-sign
#
# Some versions of GCC, such as 4.3.2 and 4.4.5,
# generate logical-op warnings when strchr() is given a
- # constant string. The autoconf script checks for that;
+ # constant string. The autoconf script checked for that;
# we don't.
#
-Wlogical-op
-Wjump-misses-init
#
- # The Qt headers generate a ton of shortening warnings
- # on 64-bit systems, so we only enable this for C for
- # now.
- #
- -Wshorten-64-to-32
- #
# Implicit function declarations are an error in C++ and most
# likely a programming error in C. Turn -Wimplicit-int and
# -Wimplicit-function-declaration into an error by default.
#
-Werror=implicit
- #
- # The Qt headers in version 5.10 introduced a lot of
- # "Possible misuse of comma operator here" warnings.
- #
- -Wcomma
)
- set(CXX_WARN_FLAGS
+ list(APPEND WIRESHARK_CXX_ONLY_FLAGS
)
- find_package(Qt5Core) # Needed to check for Qt version
- if (Qt5Core_VERSION VERSION_GREATER 5.8)
- # The Qt headers in version 5.8 and older generate a ton of shortening
- # errors on 64-bit systems so only enable this for version 5.9 and greater.
- set(CXX_WARN_FLAGS ${CXX_WARN_FLAGS}
- -Wshorten-64-to-32
- )
- endif()
- if (Qt5Core_VERSION VERSION_LESS 5.10)
- # The Qt headers in version 5.10 introduced a lot of
- # "Possible misuse of comma operator here" warnings.
- set(CXX_WARN_FLAGS ${CXX_WARN_FLAGS}
- -Wcomma
- )
- endif()
-
#
# These are not enabled by default, because the warnings they
# produce are very hard or impossible to eliminate.
#
- set(COMMON_EXTRA_WARN_FLAGS
- # The following are for C and C++
- -Wpedantic
- #
- # As we use variadic macros, we don't want warnings
- # about them, even with -Wpedantic.
- #
- -Wno-variadic-macros
- #
- # Various code blocks this one.
- #
- -Woverflow
- -fstrict-overflow -Wstrict-overflow=4
- #
- # Due to various places where APIs we don't control
- # require us to cast away constness, we can probably
- # never enable this one with -Werror.
- #
- -Wcast-qual
- #
- # Some generated ASN.1 dissectors block this one;
- # multiple function declarations for the same
- # function are being generated.
- #
- -Wredundant-decls
- #
- # Some loops are safe, but it's hard to convince the
- # compiler of that.
- #
- -Wunsafe-loop-optimizations
- #
- # All the registration functions block these for now.
- #
- -Wmissing-prototypes
- -Wmissing-declarations
- #
- # A bunch of "that might not work on SPARC" code blocks
- # this one for now; some of it is code that *will* work
- # on SPARC, such as casts of "struct sockaddr *" to
- # "struct sockaddr_in *", which are required by some
- # APIs such as getifaddrs().
- #
- -Wcast-align
- #
- # Works only with Clang
- #
- -Wunreachable-code
- #
- # Works only with Clang but generates a lot of warnings
- # (about glib library not using Doxygen)
- #
- -Wdocumentation
- #
- # Works only with GCC 7
- #
- -Wduplicated-branches
- #
- # No longer supported by El Capitan clang on C++
- # XXX - is this one of those where CMake's check
- # doesn't fail, so it won't reject this?
- #
- -fno-delete-null-pointer-checks
- )
-
- set(C_EXTRA_WARN_FLAGS
- # The following are C only, not C++
- #
- # Due to various places where APIs we don't control
- # require us to cast away constness, we can probably
- # never enable this one with -Werror.
- #
- -Wbad-function-cast
- )
+ if(ENABLE_EXTRA_COMPILER_WARNINGS) # This overrides -Werror
+ list(APPEND WIRESHARK_COMMON_FLAGS
+ # The following are for C and C++
+ -Wpedantic
+ #
+ # As we use variadic macros, we don't want warnings
+ # about them, even with -Wpedantic.
+ #
+ -Wno-variadic-macros
+ #
+ # Various code blocks this one.
+ #
+ -Woverflow
+ -fstrict-overflow -Wstrict-overflow=4
+ #
+ # Due to various places where APIs we don't control
+ # require us to cast away constness, we can probably
+ # never enable this one with -Werror.
+ #
+ -Wcast-qual
+ #
+ # Some generated ASN.1 dissectors block this one;
+ # multiple function declarations for the same
+ # function are being generated.
+ #
+ -Wredundant-decls
+ #
+ # Some loops are safe, but it's hard to convince the
+ # compiler of that.
+ #
+ -Wunsafe-loop-optimizations
+ #
+ # All the registration functions block these for now.
+ #
+ -Wmissing-prototypes
+ -Wmissing-declarations
+ #
+ # A bunch of "that might not work on SPARC" code blocks
+ # this one for now; some of it is code that *will* work
+ # on SPARC, such as casts of "struct sockaddr *" to
+ # "struct sockaddr_in *", which are required by some
+ # APIs such as getifaddrs().
+ #
+ -Wcast-align
+ #
+ # Works only with Clang
+ #
+ -Wunreachable-code
+ #
+ # Works only with Clang but generates a lot of warnings
+ # (about glib library not using Doxygen)
+ #
+ -Wdocumentation
+ #
+ # Works only with GCC 7
+ #
+ -Wduplicated-branches
+ #
+ # No longer supported by El Capitan clang on C++
+ # XXX - is this one of those where CMake's check
+ # doesn't fail, so it won't reject this?
+ #
+ -fno-delete-null-pointer-checks
+ )
- set(CXX_EXTRA_WARN_FLAGS
- )
+ list(APPEND WIRESHARK_C_ONLY_FLAGS
+ # The following are C only, not C++
+ #
+ # Due to various places where APIs we don't control
+ # require us to cast away constness, we can probably
+ # never enable this one with -Werror.
+ #
+ -Wbad-function-cast
+ )
- if(ENABLE_EXTRA_COMPILER_WARNINGS) # This overrides -Werror
- set(COMMON_WARN_FLAGS ${COMMON_WARN_FLAGS} ${COMMON_EXTRA_WARN_FLAGS})
- set(C_WARN_FLAGS ${C_WARN_FLAGS} ${C_EXTRA_WARN_FLAGS})
- set(CXX_WARN_FLAGS ${CXX_WARN_FLAGS} ${CXX_EXTRA_WARN_FLAGS})
+ list(APPEND WIRESHARK_CXX_ONLY_FLAGS
+ )
endif()
add_definitions(
)
set(WIRESHARK_LD_FLAGS
+ # See also CheckCLinkerFlag.cmake
-Wl,--as-needed
# -flto
# -fwhopr
# -fwhole-program
+ # XXX: This is applicable only when linking executables.
+ -pie
)
- # CMAKE_POSITION_INDEPENDENT_CODE is only supported starting with CMake
- # 2.8.9. Do not add -pie automatically for older versions.
- #
- # XXX - are there other compilers that don't support -pie? It's
- # not as if the only platforms we support are Windows and Linux....
- #
- if(NOT CMAKE_VERSION VERSION_LESS "2.8.9")
- set(WIRESHARK_LD_FLAGS ${WIRESHARK_LD_FLAGS}
- -pie
- )
- endif()
endif() # ! MSVC
-set( C_FLAG_TESTS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_C_ONLY_FLAGS} )
-set( CXX_FLAG_TESTS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_CXX_ONLY_FLAGS} )
-
-set( C_WARN_TESTS ${COMMON_WARN_FLAGS} ${C_WARN_FLAGS} )
-set( CXX_WARN_TESTS ${COMMON_WARN_FLAGS} ${CXX_WARN_FLAGS} )
-
# Counterhack to work around some cache magic in CHECK_C_SOURCE_COMPILES
include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
set(BUILD_SHARED_LIBS 1)
endif()
-# Sigh: Have to use THIS_FLAG instead of ${F} for some reason
-foreach(THIS_FLAG ${C_FLAG_TESTS})
- string( REGEX REPLACE "[^a-zA-Z0-9_]+" "_" F ${THIS_FLAG} )
- set(${F} ${THIS_FLAG})
- set(V C_${F}_VALID)
- message(STATUS "Checking for c-compiler flag: ${THIS_FLAG}")
- check_c_compiler_flag("${ADDED_CMAKE_C_FLAGS} ${${F}}" ${V})
- if (${${V}})
- set(ADDED_CMAKE_C_FLAGS "${ADDED_CMAKE_C_FLAGS} ${${F}}")
+function(test_compiler_flag _lang _this_flag _valid_flags_var)
+ string(MAKE_C_IDENTIFIER "${_lang}${_this_flag}_VALID" _flag_var)
+ set(_test_flags "${${_valid_flags_var}} ${_this_flag}")
+ if(_lang STREQUAL "C")
+ check_c_compiler_flag("${_test_flags}" ${_flag_var})
+ elseif(_lang STREQUAL "CXX")
+ check_cxx_compiler_flag("${_test_flags}" ${_flag_var})
+ else()
+ message(FATAL_ERROR "Language must be C or CXX")
endif()
-endforeach()
-set(CMAKE_C_FLAGS "${ADDED_CMAKE_C_FLAGS} ${CMAKE_C_FLAGS}")
-
-foreach(THIS_FLAG ${CXX_FLAG_TESTS})
- string( REGEX REPLACE "[^a-zA-Z0-9_]+" "_" F ${THIS_FLAG} )
- set(${F} ${THIS_FLAG})
- set(V CXX_${F}_VALID)
- message(STATUS "Checking for c++-compiler flag: ${THIS_FLAG}")
- check_cxx_compiler_flag("${ADDED_CMAKE_CXX_FLAGS} ${${F}}" ${V})
- if (${${V}})
- set(ADDED_CMAKE_CXX_FLAGS "${ADDED_CMAKE_CXX_FLAGS} ${${F}}")
+ if (${_flag_var})
+ set(${_valid_flags_var} "${_test_flags}" PARENT_SCOPE)
endif()
-endforeach()
-set(CMAKE_CXX_FLAGS "${ADDED_CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS}")
+endfunction()
-foreach(THIS_FLAG ${C_WARN_TESTS})
- string( REGEX REPLACE "[^a-zA-Z0-9_]+" "_" F ${THIS_FLAG} )
- set(${F} ${THIS_FLAG})
- set(V C_${F}_VALID)
- message(STATUS "Checking for c-compiler flag: ${THIS_FLAG}")
- check_c_compiler_flag("${C_FLAG_TESTS} ${${F}}" ${V})
- if (${${V}})
- set(ADDED_WARN_C_FLAGS "${ADDED_WARN_C_FLAGS} ${${F}}")
- endif()
+foreach(THIS_FLAG ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_C_ONLY_FLAGS})
+ test_compiler_flag(C ${THIS_FLAG} ADDED_CMAKE_C_FLAGS)
endforeach()
-set(CMAKE_C_FLAGS "${ADDED_WARN_C_FLAGS} ${CMAKE_C_FLAGS}")
+set(CMAKE_C_FLAGS "${ADDED_CMAKE_C_FLAGS} ${CMAKE_C_FLAGS}")
-foreach(THIS_FLAG ${CXX_WARN_TESTS})
- string( REGEX REPLACE "[^a-zA-Z0-9_]+" "_" F ${THIS_FLAG} )
- set(${F} ${THIS_FLAG})
- set(V CXX_${F}_VALID)
- message(STATUS "Checking for c++-compiler flag: ${THIS_FLAG}")
- check_cxx_compiler_flag("${CXX_FLAG_TESTS} ${${F}}" ${V})
- if (${${V}})
- set(ADDED_WARN_CXX_FLAGS "${ADDED_WARN_CXX_FLAGS} ${${F}}")
- endif()
+foreach(THIS_FLAG ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_CXX_ONLY_FLAGS})
+ test_compiler_flag(CXX ${THIS_FLAG} ADDED_CMAKE_CXX_FLAGS)
endforeach()
-set(CMAKE_CXX_FLAGS "${ADDED_WARN_CXX_FLAGS} ${CMAKE_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS "${ADDED_CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS}")
include(CMakePushCheckState)
endif()
set(WERROR_COMMON_FLAGS "")
-set(NO_ERROR_DEPRECATED_DECLARATIONS_COMPILE_FLAGS "")
if(NOT DISABLE_WERROR AND NOT ENABLE_EXTRA_COMPILER_WARNINGS)
if(CMAKE_C_COMPILER_ID MATCHES "MSVC")
set(WERROR_COMMON_FLAGS "/WX")
else()
- check_c_compiler_flag(-Werror WERROR)
- if (WERROR)
- set(WERROR_COMMON_FLAGS "-Werror")
- set(NO_ERROR_DEPRECATED_DECLARATIONS_COMPILE_FLAGS "-Wno-error=deprecated-declarations")
+ #
+ # If a warning has been enabled by -Wall or -W,
+ # and have specified -Werror, there appears to be
+ # no way, in Apple's llvm-gcc, to prevent that
+ # particular warning from giving an error - not
+ # with a pragma, not with -Wno-{warning}, and not
+ # with -Wno-error={warning}.
+ #
+ # Therefore, with that compiler, we just disable
+ # -Werror.
+ #
+ if ((NOT APPLE) OR CMAKE_C_COMPILER_ID MATCHES "Clang")
+ check_c_compiler_flag(-Werror WERROR)
+ if (WERROR)
+ set(WERROR_COMMON_FLAGS "-Werror")
+ endif()
endif()
endif()
endif()
endif()
include(CheckCLinkerFlag)
-set(_C 0)
-# Sigh: Have to use THIS_FLAG instead of ${F} for some reason
+
foreach(THIS_FLAG ${WIRESHARK_LD_FLAGS})
- set(F WS_LD_FLAG_${_C})
- set(${F} ${THIS_FLAG})
- set(V WS_LD_FLAG_VALID${_C})
- check_c_linker_flag(${${F}} ${V})
- if (${${V}})
- set(WS_LINK_FLAGS "${WS_LINK_FLAGS} ${${F}}")
- endif()
- math(EXPR _C "${_C} + 1")
+ string(MAKE_C_IDENTIFIER "LINK${THIS_FLAG}_VALID" _flag_var)
+ check_c_linker_flag(${THIS_FLAG} ${_flag_var})
+ if (${_flag_var})
+ set(WS_LINK_FLAGS "${WS_LINK_FLAGS} ${THIS_FLAG}")
+ endif()
endforeach()
+message(STATUS "Linker flags: ${WS_LINK_FLAGS}")
if(APPLE AND EXISTS /usr/local/opt/gettext)
# GLib on macOS requires libintl. Homebrew installs gettext (and
set(GLIB2_MIN_VERSION 2.32.0)
set(GTHREAD2_OPTIONS REQUIRED)
set(GCRYPT_OPTIONS "1.4.2" REQUIRED)
+set(Perl_OPTIONS REQUIRED)
set(PythonInterp_FIND_VERSION 2)
set(Python_ADDITIONAL_VERSIONS 3)
set(YACC_OPTIONS REQUIRED)
set(PACKAGELIST ${PACKAGELIST} LIBSSH)
set(LIBSSH_OPTIONS "0.6")
+set(PACKAGELIST ${PACKAGELIST} JSONGLIB)
+
if(ENABLE_PCAP)
set(PACKAGELIST ${PACKAGELIST} PCAP)
endif()
set(PACKAGELIST ${PACKAGELIST} AIRPCAP)
endif()
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+ set(PACKAGELIST ${PACKAGELIST} Systemd)
+endif()
+
# Build the Qt GUI?
if(BUILD_wireshark)
# Untested, may not work if CMAKE_PREFIX_PATH gets overwritten
set( QT5_BASE_PATH "$ENV{QT5_BASE_DIR}" )
set( CMAKE_PREFIX_PATH "${QT5_BASE_PATH}" )
endif()
+ list (INSERT QT_FIND_PACKAGE_OPTIONS 0 REQUIRED)
set(PACKAGELIST ${PACKAGELIST}
Qt5Core
Qt5LinguistTools
Qt5Svg
Qt5Widgets
)
- set(Qt5Core_OPTIONS REQUIRED)
- set(Qt5LinguistTools_OPTIONS REQUIRED)
- set(Qt5Multimedia_OPTIONS REQUIRED)
- set(Qt5PrintSupport_OPTIONS REQUIRED)
- set(Qt5Svg_OPTIONS REQUIRED)
- set(Qt5Widgets_OPTIONS REQUIRED)
+ set(Qt5Core_OPTIONS ${QT_FIND_PACKAGE_OPTIONS})
+ set(Qt5LinguistTools_OPTIONS ${QT_FIND_PACKAGE_OPTIONS})
+ set(Qt5Multimedia_OPTIONS ${QT_FIND_PACKAGE_OPTIONS})
+ set(Qt5PrintSupport_OPTIONS ${QT_FIND_PACKAGE_OPTIONS})
+ set(Qt5Svg_OPTIONS ${QT_FIND_PACKAGE_OPTIONS})
+ set(Qt5Widgets_OPTIONS ${QT_FIND_PACKAGE_OPTIONS})
if (APPLE)
set(PACKAGELIST ${PACKAGELIST} Qt5MacExtras)
- set(Qt5MacExtras_OPTIONS REQUIRED)
+ set(Qt5MacExtras_OPTIONS ${QT_FIND_PACKAGE_OPTIONS})
endif()
if( WIN32 )
set(PACKAGELIST ${PACKAGELIST} Qt5WinExtras)
- set(Qt5WinExtras_OPTIONS REQUIRED)
+ set(Qt5WinExtras_OPTIONS ${QT_FIND_PACKAGE_OPTIONS})
endif()
endif()
# Embedded Lua interpreter
if(ENABLE_LUA)
set(PACKAGELIST ${PACKAGELIST} LUA)
+ set(LUA_OPTIONS "5.1")
endif()
if(ENABLE_NETLINK)
message(STATUS "Package List: ${_package_list}")
# Let's loop the package list
foreach(PACKAGE ${PACKAGELIST})
- if(${PACKAGE} STREQUAL "Qt4")
- set(PACKAGE_VAR "QT")
- elseif(${PACKAGE} STREQUAL "PythonInterp")
- set(PACKAGE_VAR "PYTHONINTERP")
- elseif(${PACKAGE} STREQUAL "Gettext")
- set(PACKAGE_VAR "GETTEXT")
- elseif(${PACKAGE} STREQUAL "Perl")
- set(PACKAGE_VAR "PERL")
- elseif(${PACKAGE} STREQUAL "LibXml2")
- set(PACKAGE_VAR "LIBXML2")
+ # Most packages export uppercase variables, but there are exceptions.
+ if(PACKAGE MATCHES "^(Qt5)")
+ set(PACKAGE_VAR "${PACKAGE}")
else()
- set(PACKAGE_VAR ${PACKAGE})
+ string(TOUPPER "${PACKAGE}" PACKAGE_VAR)
endif()
if(${PACKAGE}_OPTIONS)
find_package(${PACKAGE} ${${PACKAGE}_OPTIONS})
else()
find_package(${PACKAGE})
endif()
- # FindPackageHandleStandardArgs before CMake 3.2 always uses uppercase
- # for the FOUND variables (e.g. GIT_FOUND is set, but not Git_FOUND).
- string(TOUPPER "${PACKAGE_VAR}" PACKAGE_VAR_UPPER)
- if (${PACKAGE_VAR}_FOUND OR ${PACKAGE_VAR_UPPER}_FOUND)
+ if (${PACKAGE_VAR}_FOUND)
message(STATUS "${PACKAGE_VAR} FOUND")
set(HAVE_LIB${PACKAGE_VAR} 1)
if (NOT DEFINED ${PACKAGE_VAR}_INCLUDE_DIRS AND ${PACKAGE_VAR}_INCLUDE_DIR)
message(STATUS "${PACKAGE} includes: ${${PACKAGE_VAR}_INCLUDE_DIRS}")
endif()
if (${PACKAGE_VAR}_LIBRARIES)
- list(APPEND WS_ALL_LIBS ${${PACKAGE_VAR}_LIBRARIES})
message(STATUS "${PACKAGE} libs: ${${PACKAGE_VAR}_LIBRARIES}")
endif()
if (${PACKAGE_VAR}_DEFINITIONS)
message(STATUS "${PACKAGE} definitions: ${${PACKAGE_VAR}_DEFINITIONS}")
+ string(REPLACE ";" " " _definitions "${${PACKAGE_VAR}_DEFINITIONS}")
+ set(CMAKE_C_FLAGS "${_definitions} ${CMAKE_C_FLAGS}")
+ set(CMAKE_CXX_FLAGS "${_definitions} ${CMAKE_CXX_FLAGS}")
+ endif()
+ if (${PACKAGE_VAR}_LINK_FLAGS)
+ string(REPLACE ";" " " _link_flags "${${PACKAGE_VAR}_LINK_FLAGS}")
+ set(WS_LINK_FLAGS "${_link_flags} ${WS_LINK_FLAGS}")
+ message(STATUS "${PACKAGE} other link flags: ${_link_flags}")
endif()
if (${PACKAGE_VAR}_EXECUTABLE)
message(STATUS "${PACKAGE} executable: ${${PACKAGE_VAR}_EXECUTABLE}")
endif()
endforeach()
-# Provide Windows system lib names
-include( UseWinLibs )
-
# dist target that prepares source dir
+# XXX Duplicated in the RPM section below.
add_custom_target(dist
- COMMAND "${CMAKE_COMMAND}"
- -DPROJECT_SOURCE_DIR="${PROJECT_SOURCE_DIR}"
- -DGIT_EXECUTABLE="${GIT_EXECUTABLE}"
- -DWS_SOURCE_DIR="${WS_SOURCE_DIR}"
- -P "${CMAKE_SOURCE_DIR}/cmake/modules/Dist.cmake"
- COMMAND "${CMAKE_MAKE_PROGRAM}" package_source
+ COMMAND ./tools/git-export-release.sh -d "${CMAKE_BINARY_DIR}"
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
)
-
if(HAVE_LIBAIRPCAP)
set(HAVE_AIRPCAP 1)
endif()
if(LIBSSH_FOUND)
set(HAVE_LIBSSH 1)
endif()
+if(JSONGLIB_FOUND)
+ set(HAVE_JSONGLIB 1)
+endif()
if(NGHTTP2_FOUND)
set(HAVE_NGHTTP2 1)
endif()
# non-empty value, be sure to clear it when not found.
set(LIBXML2_LIBRARIES "")
endif()
-if(EXTCAP_ANDROIDDUMP_LIBPCAP)
- set(ANDROIDDUMP_USE_LIBPCAP 1)
-endif()
if (HAVE_LIBWINSPARKLE)
set(HAVE_SOFTWARE_UPDATE 1)
set(HAVE_SNAPPY 1)
endif()
if (Qt5Widgets_FOUND)
+ if (Qt5Widgets_VERSION VERSION_LESS 5.2)
+ message(FATAL_ERROR "Qt 5.2 or later is required.")
+ endif()
if (Qt5Widgets_VERSION VERSION_GREATER 5.6
AND (CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang"))
- # Qt 5.7 and later require C++ 11. If our minmimu required CMake version
- # is ever >= 3.1 we can use CXX_STANDARD + CXX_STANDARD_REQUIRED.
- message(STATUS "Checking for C++ 11 support (Required by Qt 5.7 and later)")
- check_cxx_compiler_flag(-std=c++11 CXX__std_c__11_VALID)
- if(NOT CXX__std_c__11_VALID)
- message(FATAL_ERROR "Qt ${Qt5Widgets_VERSION} requires C++ 11")
- endif()
- set(CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
+ # Qt 5.7 and later require C++ 11.
+ set(CMAKE_CXX_STANDARD 11)
+ set(CMAKE_CXX_STANDARD_REQUIRED ON)
endif()
set (QT_FOUND ON)
set (QT_LIBRARIES ${Qt5Widgets_LIBRARIES} ${Qt5PrintSupport_LIBRARIES})
if(Qt5Multimedia_FOUND)
set (QT_LIBRARIES ${QT_LIBRARIES} ${Qt5Multimedia_LIBRARIES})
- # That's the name autofoo uses
+ # That's the name autotools used
set(QT_MULTIMEDIA_LIB 1)
endif()
if(Qt5Svg_FOUND)
set (QT_LIBRARIES ${QT_LIBRARIES} ${Qt5Svg_LIBRARIES})
- # That's the name autofoo uses
+ # That's the name autotools used
set(QT_SVG_LIB 1)
endif()
if(Qt5MacExtras_FOUND)
set (QT_LIBRARIES ${QT_LIBRARIES} ${Qt5MacExtras_LIBRARIES})
- # That's the name autofoo uses
+ # That's the name autotools used
set(QT_MACEXTRAS_LIB 1)
endif()
if(Qt5WinExtras_FOUND)
# Squelch moc verbose "nothing to do" output
set(MOC_OPTIONS -nn)
endif()
-# If Qt4: QT_LIBRARIES and QT_INCLUDES are not set above. They require extra magic
-elseif(QT4_FOUND)
- include(${QT_USE_FILE})
- include_directories(${QT_INCLUDE_DIR})
- message(STATUS "Qt includes: ${QT_INCLUDE_DIR}")
- message(STATUS "Qt libs: ${QT_LIBRARIES}")
- if(QT_QTMULTIMEDIA_FOUND)
- include_directories(${QT_QTMULTIMEDIA_INCLUDE_DIR})
- message(STATUS "QtMultimedia includes: ${QT_INCLUDE_DIR}")
- set (QT_LIBRARIES ${QT_LIBRARIES} ${QT_QTMULTIMEDIA_LIBRARY})
- message(STATUS "QtMultimedia libs: ${QT_QTMULTIMEDIA_LIBRARY}")
- # That's the name autofoo uses
- set(QT_MULTIMEDIA_LIB 1)
- endif()
- if(WIN32 OR APPLE)
- message(FATAL_ERROR "Windows and macOS builds should use Qt5.")
+
+ # CMake uses qmake to find Qt4. It relies on Qt's CMake modules
+ # to find Qt5. This means that we can't assume that the qmake
+ # in our PATH is the correct one. We can fetch qmake's location
+ # from Qt5::qmake, which is is defined in Qt5CoreConfigExtras.cmake.
+ get_target_property(QT_QMAKE_EXECUTABLE Qt5::qmake IMPORTED_LOCATION)
+ get_filename_component(_qt_bin_path "${QT_QMAKE_EXECUTABLE}" DIRECTORY)
+ set(QT_BIN_PATH "${_qt_bin_path}" CACHE INTERNAL
+ "Path to qmake, macdeployqt, windeployqt, and other Qt utilities."
+ )
+ # Use qmake to find windeployqt and macdeployqt. Ideally one of
+ # the modules in ${QTDIR}/lib/cmake would do this for us.
+ if(WIN32)
+ find_program(QT_WINDEPLOYQT_EXECUTABLE windeployqt
+ HINTS "${QT_BIN_PATH}"
+ DOC "Path to the windeployqt utility."
+ )
+ elseif(APPLE)
+ find_program(QT_MACDEPLOYQT_EXECUTABLE macdeployqt
+ HINTS "${QT_BIN_PATH}"
+ DOC "Path to the macdeployqt utility."
+ )
endif()
+
endif()
if(ENABLE_CHECKHF_CONFLICT)
set(ENABLE_CHECK_FILTER 1)
endif()
+#
+# Platform-specific additional libraries.
+#
+if(WIN32)
+ set(WIN_PSAPI_LIBRARY psapi.lib)
+ set(WIN_WSOCK32_LIBRARY wsock32.lib)
+ set(WIN_COMCTL32_LIBRARY comctl32.lib )
+ set(WIN_VERSION_LIBRARY version.lib)
+endif()
+
if(APPLE)
#
# We assume that APPLE means macOS so that we have the macOS
#
set(HAVE_MACOS_FRAMEWORKS 1)
FIND_LIBRARY (APPLE_APPLICATION_SERVICES_LIBRARY ApplicationServices)
+ FIND_LIBRARY (APPLE_APPKIT_LIBRARY AppKit)
FIND_LIBRARY (APPLE_CORE_FOUNDATION_LIBRARY CoreFoundation)
FIND_LIBRARY (APPLE_SYSTEM_CONFIGURATION_LIBRARY SystemConfiguration)
endif()
EXCLUDE_FROM_DEFAULT_BUILD True
)
+include( UseCheckAPI )
+
+# Target platform locations
+# UN*X in general, including macOS if not building an app bundle:
+# $DESTDIR/lib/wireshark/extcap
+# Windows: $DESTDIR/extcap
+# macOS app bundle: Wireshark.app/Contents/Resources/share/wireshark/extcap
+if (WIN32)
+ set(EXTCAP_INSTALL_LIBDIR "extcap" CACHE INTERNAL "The extcap dir")
+else ()
+ set(EXTCAP_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}/${CPACK_PACKAGE_NAME}/extcap" CACHE INTERNAL "The extcap dir")
+endif()
+
+# Directory where plugins and Lua dissectors can be found.
+if(WIN32)
+ set(PLUGIN_INSTALL_LIBDIR "plugins" CACHE INTERNAL "The plugin dir")
+else()
+ set(PLUGIN_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}/${CPACK_PACKAGE_NAME}/plugins" CACHE INTERNAL "The plugin dir")
+endif()
+set(PLUGIN_INSTALL_VERSION_LIBDIR "${PLUGIN_INSTALL_LIBDIR}/${PROJECT_RELEASE_VERSION}")
+set(PLUGIN_VERSION_DIR "plugins/${PROJECT_RELEASE_VERSION}")
+
add_subdirectory( capchild )
add_subdirectory( caputils )
add_subdirectory( codecs )
add_subdirectory( doc )
add_subdirectory( docbook EXCLUDE_FROM_ALL )
add_subdirectory( epan )
+add_subdirectory( extcap )
add_subdirectory( randpkt_core )
add_subdirectory( tools/lemon )
add_subdirectory( ui )
# application bundle, and on UNIX in general if
# WIRESHARK_RUN_FROM_BUILD_DIRECTORY is set.
if(ENABLE_APPLICATION_BUNDLE)
- set(_datafile_dir "${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/Resources/share/wireshark")
+ if(CMAKE_CFG_INTDIR STREQUAL ".")
+ set(_datafile_dir "${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/Resources/share/wireshark")
+ else()
+ # Xcode
+ set(_datafile_dir "${CMAKE_BINARY_DIR}/run/${CMAKE_CFG_INTDIR}/Wireshark.app/Contents/Resources/share/wireshark")
+ endif()
elseif(NOT CMAKE_CFG_INTDIR STREQUAL ".")
# Visual Studio, Xcode, etc.
set(_datafile_dir "${CMAKE_BINARY_DIR}/run/${CMAKE_CFG_INTDIR}")
add_subdirectory( ui/qt )
endif()
-# Target platform locations
-# UN*X in general, including macOS if not building an app bundle:
-# $DESTDIR/lib/wireshark/extcap
-# Windows: $DESTDIR/extcap
-# macOS app bundle: Wireshark.app/Contents/Resources/share/wireshark/extcap
-if (WIN32)
- set(EXTCAP_DIR "extcap")
-else ()
- set(EXTCAP_DIR "${CMAKE_INSTALL_FULL_LIBDIR}/${CPACK_PACKAGE_NAME}/extcap")
-endif()
-
-if(LIBSSH_FOUND)
- SET(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${LIBSSH_LIBRARIES})
- CHECK_FUNCTION_EXISTS(ssh_userauth_agent LIBSSH_USERAUTH_AGENT_FOUND)
- if(LIBSSH_USERAUTH_AGENT_FOUND)
- set(HAVE_SSH_USERAUTH_AGENT 1)
- endif()
-endif()
-
-# Directory where plugins and Lua dissectors can be found.
-set(PLUGIN_VERSION_DIR "plugins/${PROJECT_RELEASE_VERSION}")
-set(PLUGIN_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}/${CPACK_PACKAGE_NAME}/${PLUGIN_VERSION_DIR}")
-# Used by the WiresharkConfig.cmake.in module
-if (WIN32)
- set(PLUGIN_INSTALL_DIR "${PLUGIN_VERSION_DIR}")
-else ()
- set(PLUGIN_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/${PLUGIN_INSTALL_LIBDIR}")
-endif()
-
# Location of our plugins. PLUGIN_DIR should allow running
# from the build directory similar to DATAFILE_DIR above.
if(ENABLE_PLUGINS)
# Target platform locations
# UN*X in general, including macOS if not building an app bundle:
# $DESTDIR/lib/wireshark/plugins/$VERSION
- # Windows: $DESTDIR/wireshark/plubins/$VERSION
+ # Windows: $DESTDIR/wireshark/plugins/$VERSION
# macOS app bundle: Wireshark.app/Contents/PlugIns/wireshark
set(HAVE_PLUGINS 1)
add_custom_target(plugins)
endif()
if(ENABLE_APPLICATION_BUNDLE)
- set(_plugin_dir "${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/PlugIns/wireshark/${PROJECT_RELEASE_VERSION}")
+ if(CMAKE_CFG_INTDIR STREQUAL ".")
+ set(_plugin_dir "${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/PlugIns/wireshark/${PROJECT_RELEASE_VERSION}")
+ else()
+ # Xcode
+ set(_plugin_dir "${CMAKE_BINARY_DIR}/run/$<CONFIG>/Wireshark.app/Contents/PlugIns/wireshark/${PROJECT_RELEASE_VERSION}")
+ endif()
+elseif(WIN32 AND NOT CMAKE_CFG_INTDIR STREQUAL ".")
+ set(_plugin_dir "${CMAKE_BINARY_DIR}/run/$<CONFIG>/${PLUGIN_VERSION_DIR}")
else()
set(_plugin_dir "${DATAFILE_DIR}/${PLUGIN_VERSION_DIR}")
endif()
include(gmxTestLargeFiles)
gmx_test_large_files(GMX_LARGEFILES)
-add_definitions( -DTOP_SRCDIR=\"${CMAKE_SOURCE_DIR}\" )
-
-if (${GIT_EXECUTABLE})
- set(GIT_BIN_PARAM "--git-bin ${GIT_EXECUTABLE}")
-endif()
set( VERSION ${PROJECT_VERSION} )
-if(NOT CMAKE_VERSION VERSION_LESS "3.2.1")
- # Prevents unnecessary rebuilds by ensuring that dependents are not
- # built before make-version.pl finishes (which may touch version.h).
- set(version_byproducts BYPRODUCTS version.h)
-else()
- set(version_byproducts "")
-endif()
add_custom_target(version
- ${version_byproducts}
+ BYPRODUCTS version.h
COMMAND ${PERL_EXECUTABLE}
${CMAKE_SOURCE_DIR}/make-version.pl
- --set-vcs ${GIT_BIN_PARAM}
${CMAKE_SOURCE_DIR}
)
set_target_properties(version PROPERTIES FOLDER "Auxiliary")
set( configure_input "Built with CMake ${CMAKE_VERSION}" )
configure_file(${CMAKE_SOURCE_DIR}/cmakeconfig.h.in ${CMAKE_BINARY_DIR}/config.h)
+configure_file(${CMAKE_SOURCE_DIR}/ws_version.h.in ${CMAKE_BINARY_DIR}/ws_version.h)
+
set( prefix "${CMAKE_INSTALL_PREFIX}" )
set( exec_prefix "\${prefix}" )
set( libdir "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}" )
set( includedir "\${prefix}/include" )
set( plugindir "\${libdir}/wireshark/${PLUGIN_VERSION_DIR}" )
-set(ICON_PATH "${CMAKE_SOURCE_DIR}/image/")
-set( IN_FILES
- capchild/doxygen.cfg.in
- caputils/doxygen.cfg.in
- doxygen.cfg.in
- doxygen_global.cfg
- epan/doxygen.cfg.in
- image/libwireshark.rc.in
- image/text2pcap.rc.in
- image/capinfos.rc.in
- image/wireshark.rc.in
- image/mergecap.rc.in
- image/tshark.rc.in
- image/dumpcap.rc.in
- image/reordercap.rc.in
- image/rawshark.rc.in
- image/file_dlg_win32.rc
- image/tfshark.rc.in
- image/editcap.rc.in
- image/captype.rc.in
- image/libwscodecs.rc.in
- image/libwsutil.rc.in
- image/wiretap.rc.in
- image/wireshark.exe.manifest.in
- packaging/macosx/Info.plist.in
- packaging/macosx/osx-app.sh.in
- packaging/macosx/osx-dmg.sh.in
- packaging/macosx/Wireshark_package.pmdoc/index.xml.in
- randpkt_core/doxygen.cfg.in
- ui/doxygen.cfg.in
- ui/qt/doxygen.cfg.in
- wireshark.pc.in
- writecap/doxygen.cfg.in
+# Doxygen variables
+file(GLOB TOP_LEVEL_SOURCE_LIST *.c *.cpp *.h)
+string (REPLACE ";" " " DOXYGEN_TOP_LEVEL_SOURCES "${TOP_LEVEL_SOURCE_LIST}")
+set(DOXYGEN_INPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
+set(DOXYGEN_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+
+set(CFG_OUT_FILES
+ doxygen.cfg
+ image/libwireshark.rc
+ image/wireshark.rc
+ image/dumpcap.rc
+ image/libwscodecs.rc
+ image/libwsutil.rc
+ image/wiretap.rc
+ image/wireshark.exe.manifest
+ packaging/macosx/Info.plist
+ packaging/macosx/osx-app.sh
+ packaging/macosx/osx-dmg.sh
+ packaging/macosx/Wireshark_package.pmdoc/index.xml
+ wireshark.pc
)
-foreach( _in_file ${IN_FILES} )
- get_filename_component( _path ${_in_file} PATH )
- string( REGEX REPLACE "(.*)\\.in" "\\1" _outfile ${_in_file} )
- configure_file( ${CMAKE_SOURCE_DIR}/${_in_file} ${CMAKE_BINARY_DIR}/${_outfile} @ONLY )
+foreach( _cfg_file ${CFG_OUT_FILES} )
+ configure_file( ${CMAKE_SOURCE_DIR}/${_cfg_file}.in ${CMAKE_BINARY_DIR}/${_cfg_file} @ONLY )
endforeach()
include(FeatureSummary)
set(PLATFORM_UI_SRC
ui/win32/console_win32.c
ui/win32/file_dlg_win32.c
- ui/win32/print_win32.c
)
set(PLATFORM_UI_RC_FILES
image/file_dlg_win32.rc
)
+elseif(APPLE)
+ set(PLATFORM_UI_SRC
+ ui/macosx/cocoa_bridge.mm
+ )
endif()
# sources common for wireshark, tshark, rawshark and sharkd
set(TSHARK_TAP_SRC
${CMAKE_SOURCE_DIR}/ui/cli/tap-camelsrt.c
- ${CMAKE_SOURCE_DIR}/ui/cli/tap-comparestat.c
${CMAKE_SOURCE_DIR}/ui/cli/tap-diameter-avp.c
${CMAKE_SOURCE_DIR}/ui/cli/tap-expert.c
${CMAKE_SOURCE_DIR}/ui/cli/tap-exportobject.c
# the top-level CMakeLists.txt iterates over the package list?
# Required DLLs.
- # The cairo, freetype, gio, gnutls, png, and other OBS-generated DLLs
- # depend on zlib1.dll. We compile zlib locally but the Debug
- # configuration (the default) creates zlibd1.dll.
- # Note: Passing multiple files to copy_if_different requires
- # CMake 3.5 or later.
+ # The gio, gnutls, png, and other OBS-generated DLLs depend on
+ # zlib1.dll. We compile zlib locally but the Debug configuration
+ # (the default) creates zlibd1.dll.
add_custom_command(TARGET copy_cli_dlls PRE_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different
${GLIB2_DLLS} $<$<CONFIG:Debug>:zlib1.dll>
if (LIBSSH_FOUND)
list (APPEND OPTIONAL_DLLS "${LIBSSH_DLL_DIR}/${LIBSSH_DLL}")
endif(LIBSSH_FOUND)
+ if (JSONGLIB_FOUND)
+ list (APPEND OPTIONAL_DLLS "${JSONGLIB_DLL_DIR}/${JSONGLIB_DLL}")
+ endif(JSONGLIB_FOUND)
foreach( _dll ${GCRYPT_DLLS} )
list (APPEND OPTIONAL_DLLS "${GCRYPT_DLL_DIR}/${_dll}")
endforeach(_dll)
)
endif(OPTIONAL_DLLS)
- # This might not be needed since make-dissectors has the same dependency.
add_dependencies(epan copy_cli_dlls)
# We have a lot of choices for creating zip archives:
PATH "$ENV{PROGRAMFILES}/7-Zip" "$ENV{PROGRAMW6432}/7-Zip"
DOC "Path to the 7z utility."
)
- # XXX "if(ZIP_EXECUTABLE)" doesn't work here. It looks like the
- # absence of "-NOTFOUND" doesn't equal "true".
- if (NOT "${ZIP_EXECUTABLE}" STREQUAL "ZIP_EXECUTABLE-NOTFOUND")
- add_custom_target(pdb_zip_package)
+ if(ZIP_EXECUTABLE)
+ add_custom_target(pdb_zip_package COMMENT "This packages .PDBs but will not create them.")
set_target_properties(pdb_zip_package PROPERTIES FOLDER "Packaging")
set(_pdb_zip "${CMAKE_BINARY_DIR}/Wireshark-pdb-${WIRESHARK_TARGET_PLATFORM}-${VERSION}.zip")
file(TO_NATIVE_PATH "${_pdb_zip}" _pdb_zip_win)
${PLUGIN_VERSION_DIR}/wiretap/*.pdb
WORKING_DIRECTORY "${_dll_output_dir}"
)
- add_dependencies(pdb_zip_package epan)
endif()
endif(WIN32)
list(APPEND copy_data_files_depends "${_output_file}")
endforeach()
-# Ensure "run/extcap" exists
-add_custom_command(OUTPUT "${DATAFILE_DIR}/extcap"
- COMMAND ${CMAKE_COMMAND} -E make_directory
- "${DATAFILE_DIR}/extcap"
-)
-list(APPEND copy_data_files_depends "${DATAFILE_DIR}/extcap")
-
# faq.txt is handled separately below.
set(_help_source_files
help/capture_filters.txt
# Copy all paths from the source tree to the data directory. Directories are
# automatically created if missing as the filename is given.
-# TODO Switch to cmake -E copy_if_different when our minimum CMake version
-# is >= 3.5 everywhere.
file(GLOB _data_files RELATIVE "${CMAKE_SOURCE_DIR}" ${DATA_FILES_SRC})
foreach(_data_file ${_data_files})
add_custom_command(OUTPUT "${DATAFILE_DIR}/${_data_file}"
list(APPEND copy_data_files_depends "${DATAFILE_DIR}/${_data_file}")
endforeach()
-if(CMAKE_VERSION VERSION_LESS 3.5)
- # To bad -u / --update is a GNU extension.
- set (MULTI_COPY_COMMAND cp)
-else()
- set (MULTI_COPY_COMMAND ${CMAKE_COMMAND} -E copy_if_different)
-endif()
-
-add_custom_command(
- OUTPUT "${DATAFILE_DIR}/dtds" "${DATAFILE_DIR}/diameter" "${DATAFILE_DIR}/radius"
- COMMAND ${CMAKE_COMMAND} -E make_directory "${DATAFILE_DIR}/dtds"
- COMMAND ${CMAKE_COMMAND} -E make_directory "${DATAFILE_DIR}/diameter"
- COMMAND ${CMAKE_COMMAND} -E make_directory "${DATAFILE_DIR}/radius"
-)
-
file(GLOB _dtds_src_files RELATIVE "${CMAKE_SOURCE_DIR}" "dtds/*.dtd")
set (_dtds_data_files)
add_custom_command(
OUTPUT ${_dtds_data_files}
- COMMAND ${MULTI_COPY_COMMAND}
+ COMMAND ${CMAKE_COMMAND} -E make_directory "${DATAFILE_DIR}/dtds"
+ COMMAND ${CMAKE_COMMAND} -E copy_if_different
${_dtds_src_files}
"${DATAFILE_DIR}/dtds"
VERBATIM
- DEPENDS "${DATAFILE_DIR}/dtds"
+ DEPENDS ${_dtds_src_files}
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
)
add_custom_command(
OUTPUT ${_diameter_data_files}
- COMMAND ${MULTI_COPY_COMMAND}
+ COMMAND ${CMAKE_COMMAND} -E make_directory "${DATAFILE_DIR}/diameter"
+ COMMAND ${CMAKE_COMMAND} -E copy_if_different
${_diameter_src_files}
"${DATAFILE_DIR}/diameter"
VERBATIM
- DEPENDS "${DATAFILE_DIR}/diameter"
+ DEPENDS ${_diameter_src_files}
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
)
add_custom_command(
OUTPUT ${_radius_data_files}
- COMMAND ${MULTI_COPY_COMMAND}
+ COMMAND ${CMAKE_COMMAND} -E make_directory "${DATAFILE_DIR}/radius"
+ COMMAND ${CMAKE_COMMAND} -E copy_if_different
${_radius_src_files}
"${DATAFILE_DIR}/radius"
VERBATIM
- DEPENDS "${DATAFILE_DIR}/radius"
+ DEPENDS ${_radius_src_files}
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
)
)
set(wireshark_FILES
${WIRESHARK_SRC}
- ${CMAKE_BINARY_DIR}/image/wireshark.rc
${PLATFORM_UI_RC_FILES}
)
+ set_executable_resources(wireshark "Wireshark" UNIQUE_RC)
endif()
if(ENABLE_APPLICATION_BUNDLE)
ui
capchild
caputils
+ wiretap
${QT_LIBRARIES}
${GTHREAD2_LIBRARIES}
wscodecs
${LIBEPAN_LIBS}
${APPLE_APPLICATION_SERVICES_LIBRARY}
+ ${APPLE_APPKIT_LIBRARY}
${APPLE_CORE_FOUNDATION_LIBRARY}
${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
${NL_LIBRARIES}
${WIN_VERSION_LIBRARY}
)
- add_executable(wireshark WIN32 MACOSX_BUNDLE wireshark-qt.cpp ${wireshark_FILES} ${EXTRA_BUNDLE_FILES})
+ add_executable(wireshark WIN32 MACOSX_BUNDLE ${wireshark_FILES} ${EXTRA_BUNDLE_FILES})
add_dependencies(wireshark version)
set(PROGLIST ${PROGLIST} wireshark)
if(CMAKE_VERSION VERSION_LESS "2.8.12"
wireshark PROPERTIES
MACOSX_BUNDLE_INFO_PLIST ${CMAKE_BINARY_DIR}/packaging/macosx/Info.plist
)
- # Add a wrapper script which opens the bundle. This adds
- # convenience but makes debugging more difficult.
- file(REMOVE ${CMAKE_BINARY_DIR}/run/wireshark)
- file(WRITE ${CMAKE_BINARY_DIR}/run/wireshark "#!/bin/sh\n")
- file(APPEND ${CMAKE_BINARY_DIR}/run/wireshark "# Generated by ${CMAKE_CURRENT_LIST_FILE}\n")
- file(APPEND ${CMAKE_BINARY_DIR}/run/wireshark "exec ${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/MacOS/Wireshark \"\$\@\"\n")
- execute_process(COMMAND chmod a+x ${CMAKE_BINARY_DIR}/run/wireshark)
+ if(CMAKE_CFG_INTDIR STREQUAL ".")
+ # Add a wrapper script which opens the bundle. This adds
+ # convenience but makes debugging more difficult.
+ # It is not created if using Xcode
+ file(REMOVE ${CMAKE_BINARY_DIR}/run/wireshark)
+ file(WRITE ${CMAKE_BINARY_DIR}/run/wireshark "#!/bin/sh\n")
+ file(APPEND ${CMAKE_BINARY_DIR}/run/wireshark "# Generated by ${CMAKE_CURRENT_LIST_FILE}\n")
+ file(APPEND ${CMAKE_BINARY_DIR}/run/wireshark "exec ${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/MacOS/Wireshark \"\$\@\"\n")
+ execute_process(COMMAND chmod a+x ${CMAKE_BINARY_DIR}/run/wireshark)
+ endif()
endif()
target_link_libraries(wireshark ${wireshark_LIBS})
BUNDLE DESTINATION ${CMAKE_INSTALL_BINDIR}
)
- if(WIN32 AND Qt5Core_FOUND)
- # Use windeployqt to copy our required DLLs to the run path.
- # Ideally one of the modules in ${QTDIR}/lib/cmake would expose
- # the path to windeployqt. For that matter having a reliable
- # path to qmake would be *amazingly convenient*. We don't have
- # either of those so we try to discover the path via Qt5Core.
- # http://stackoverflow.com/questions/24650936/qt5-with-cmake-how-to-find-qt-translations-dir
-
- get_target_property(_qmake_location Qt5::qmake IMPORTED_LOCATION)
- get_filename_component(_qt_bin_path "${_qmake_location}" DIRECTORY)
- find_program(QT_WINDEPLOYQT_EXECUTABLE windeployqt
- HINTS "${_qmake_location}"
- DOC "Path to the windeployqt utility."
+ if(QT_WINDEPLOYQT_EXECUTABLE)
+ add_custom_target(copy_qt_dlls ALL)
+ set_target_properties(copy_qt_dlls PROPERTIES FOLDER "Copy Tasks")
+ # Will we ever need to use --debug? Windeployqt seems to
+ # be smart enough to copy debug DLLs when needed.
+ add_custom_command(TARGET copy_qt_dlls
+ POST_BUILD
+ COMMAND set "PATH=${QT_BIN_PATH};%PATH%"
+ COMMAND "${QT_WINDEPLOYQT_EXECUTABLE}"
+ $<$<CONFIG:Debug>:--debug>
+ $<$<NOT:$<CONFIG:Debug>>:--release>
+ --no-compiler-runtime
+ --verbose 10
+ "$<TARGET_FILE:wireshark>"
)
- if (NOT "${QT_WINDEPLOYQT_EXECUTABLE}" STREQUAL "QT_WINDEPLOYQT_EXECUTABLE-NOTFOUND")
- set(QT_BIN_PATH "${_qt_bin_path}" CACHE INTERNAL
- "Path to qmake, windeployqt, and other Qt utilities."
- )
- add_custom_target(copy_qt_dlls ALL)
- set_target_properties(copy_qt_dlls PROPERTIES FOLDER "Copy Tasks")
- # Will we ever need to use --debug? Windeployqt seems to
- # be smart enough to copy debug DLLs when needed.
- add_custom_command(TARGET copy_qt_dlls
- POST_BUILD
- COMMAND set "PATH=${QT_BIN_PATH};%PATH%"
- COMMAND "${QT_WINDEPLOYQT_EXECUTABLE}"
- $<$<CONFIG:Debug>:--debug>
- $<$<NOT:$<CONFIG:Debug>>:--release>
- --no-compiler-runtime
- --verbose 10
- "$<TARGET_FILE:wireshark>"
- )
- add_dependencies(copy_qt_dlls wireshark)
- endif()
- endif(WIN32 AND Qt5Core_FOUND)
+ add_dependencies(copy_qt_dlls wireshark)
+ endif(QT_WINDEPLOYQT_EXECUTABLE)
endif()
# Common properties for CLI executables
macro(set_extra_executable_properties _executable _folder)
set_target_properties(${_executable} PROPERTIES
- LINK_FLAGS "${WS_LINK_FLAGS}"
+ LINK_FLAGS "${WILDCARD_OBJ} ${WS_LINK_FLAGS}"
FOLDER ${_folder}
)
set(PROGLIST ${PROGLIST} ${_executable})
if(ENABLE_APPLICATION_BUNDLE)
- set_target_properties(${_executable} PROPERTIES
- RUNTIME_OUTPUT_DIRECTORY run/Wireshark.app/Contents/MacOS
- )
- # Add a wrapper script which runs each executable from the
- # correct location. This adds convenience but makes debugging
- # more difficult.
- file(REMOVE ${CMAKE_BINARY_DIR}/run/${_executable})
- file(WRITE ${CMAKE_BINARY_DIR}/run/${_executable} "#!/bin/sh\n")
- file(APPEND ${CMAKE_BINARY_DIR}/run/${_executable} "exec ${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/MacOS/${_executable} \"\$\@\"\n")
- execute_process(COMMAND chmod a+x ${CMAKE_BINARY_DIR}/run/${_executable})
- endif()
-endmacro()
-
-macro(set_extcap_executable_properties _executable)
- set_target_properties(${_executable} PROPERTIES FOLDER "Executables/Extcaps")
-
- set(PROGLIST ${PROGLIST} ${_executable})
-
- if(WIN32)
- set_target_properties(${_executable} PROPERTIES
- LINK_FLAGS "${WS_LINK_FLAGS}"
- RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/run/extcap
- RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/run/Debug/extcap
- RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/run/Release/extcap
- RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${CMAKE_BINARY_DIR}/run/MinSizeRel/extcap
- RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_BINARY_DIR}/run/RelWithDebInfo/extcap
- )
- else()
- set_target_properties(${_executable} PROPERTIES
- LINK_FLAGS "${WS_LINK_FLAGS}"
- RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/run/extcap
- )
- if(ENABLE_APPLICATION_BUNDLE)
+ if(NOT CMAKE_CFG_INTDIR STREQUAL ".")
+ # Xcode
+ set_target_properties(${_executable} PROPERTIES
+ RUNTIME_OUTPUT_DIRECTORY run/$<CONFIG>/Wireshark.app/Contents/MacOS
+ )
+ else ()
set_target_properties(${_executable} PROPERTIES
- RUNTIME_OUTPUT_DIRECTORY run/Wireshark.app/Contents/MacOS/extcap
+ RUNTIME_OUTPUT_DIRECTORY run/Wireshark.app/Contents/MacOS
)
# Add a wrapper script which runs each executable from the
# correct location. This adds convenience but makes debugging
# more difficult.
file(REMOVE ${CMAKE_BINARY_DIR}/run/${_executable})
file(WRITE ${CMAKE_BINARY_DIR}/run/${_executable} "#!/bin/sh\n")
- file(APPEND ${CMAKE_BINARY_DIR}/run/${_executable} "exec ${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/MacOS/extcap/${_executable} \"\$\@\"\n")
+ file(APPEND ${CMAKE_BINARY_DIR}/run/${_executable} "exec ${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/MacOS/${_executable} \"\$\@\"\n")
execute_process(COMMAND chmod a+x ${CMAKE_BINARY_DIR}/run/${_executable})
endif()
endif()
ui
capchild
caputils
+ wiretap
${LIBEPAN_LIBS}
${APPLE_CORE_FOUNDATION_LIBRARY}
${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
tshark.c
${TSHARK_TAP_SRC}
${SHARK_COMMON_SRC}
- ${CMAKE_BINARY_DIR}/image/tshark.rc
)
+
+ set_executable_resources(tshark "TShark" UNIQUE_RC)
add_executable(tshark ${tshark_FILES})
add_dependencies(tshark version)
set_extra_executable_properties(tshark "Executables")
if(BUILD_tfshark)
set(tfshark_LIBS
ui
+ wiretap
${LIBEPAN_LIBS}
${APPLE_CORE_FOUNDATION_LIBRARY}
${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
tfshark.c
${TSHARK_TAP_SRC}
${SHARK_COMMON_SRC}
- ${CMAKE_BINARY_DIR}/image/tfshark.rc
)
+ set_executable_resources(tfshark "TFShark")
add_executable(tfshark ${tfshark_FILES})
add_dependencies(tfshark version)
set_extra_executable_properties(tfshark "Executables")
set(rawshark_LIBS
caputils
ui
+ wiretap
${LIBEPAN_LIBS}
${APPLE_CORE_FOUNDATION_LIBRARY}
${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
set(rawshark_FILES
${SHARK_COMMON_SRC}
rawshark.c
- ${CMAKE_BINARY_DIR}/image/rawshark.rc
)
+ set_executable_resources(rawshark "Rawshark")
add_executable(rawshark ${rawshark_FILES})
add_dependencies(rawshark version)
set_extra_executable_properties(rawshark "Executables")
set(sharkd_LIBS
ui
wscodecs
+ wiretap
${LIBEPAN_LIBS}
${APPLE_CORE_FOUNDATION_LIBRARY}
${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
sharkd_session.c
${SHARK_COMMON_SRC}
)
+ set_executable_resources(sharkd "SharkD")
add_executable(sharkd ${sharkd_FILES})
add_dependencies(sharkd version)
set_extra_executable_properties(sharkd "Executables")
if(BUILD_dftest)
set(dftest_LIBS
ui
+ wiretap
${LIBEPAN_LIBS}
)
set(dftest_FILES
if(BUILD_fuzzshark)
set(fuzzshark_LIBS
+ wiretap
${LIBEPAN_LIBS}
)
set(fuzzshark_FILES
add_lex_files(text2pcap_LEX_FILES text2pcap_FILES
text2pcap-scanner.l
)
- add_executable(text2pcap ${text2pcap_FILES}
- ${CMAKE_BINARY_DIR}/image/text2pcap.rc)
+ set_executable_resources(text2pcap "Text2pcap"
+ COPYRIGHT_INFO "2001 Ashok Narayanan <ashokn@cisco.com>")
+ add_executable(text2pcap ${text2pcap_FILES})
add_dependencies(text2pcap version)
set_extra_executable_properties(text2pcap "Executables")
target_link_libraries(text2pcap ${text2pcap_LIBS})
set(mergecap_FILES
mergecap.c
version_info.c
- ${CMAKE_BINARY_DIR}/image/mergecap.rc
)
+ set_executable_resources(mergecap "Mergecap")
add_executable(mergecap ${mergecap_FILES})
add_dependencies(mergecap version)
set_extra_executable_properties(mergecap "Executables")
set(reordercap_FILES
reordercap.c
version_info.c
- ${CMAKE_BINARY_DIR}/image/reordercap.rc
)
+ set_executable_resources(reordercap "Reordercap")
add_executable(reordercap ${reordercap_FILES})
add_dependencies(reordercap version)
set_extra_executable_properties(reordercap "Executables")
set(capinfos_FILES
capinfos.c
version_info.c
- ${CMAKE_BINARY_DIR}/image/capinfos.rc
)
+ set_executable_resources(capinfos "Capinfos")
add_executable(capinfos ${capinfos_FILES})
add_dependencies(capinfos version)
set_extra_executable_properties(capinfos "Executables")
set(captype_FILES
captype.c
version_info.c
- ${CMAKE_BINARY_DIR}/image/captype.rc
)
+ set_executable_resources(captype "Captype")
add_executable(captype ${captype_FILES})
add_dependencies(captype version)
set_extra_executable_properties(captype "Executables")
set(editcap_FILES
editcap.c
version_info.c
- ${CMAKE_BINARY_DIR}/image/editcap.rc
)
+ set_executable_resources(editcap "Editcap")
add_executable(editcap ${editcap_FILES})
add_dependencies(editcap version)
set_extra_executable_properties(editcap "Executables")
ringbuffer.c
sync_pipe_write.c
version_info.c
- ${CMAKE_BINARY_DIR}/image/dumpcap.rc
)
+ set_executable_resources(dumpcap "Dumpcap" UNIQUE_RC)
add_executable(dumpcap ${dumpcap_FILES})
add_dependencies(dumpcap version)
set_extra_executable_properties(dumpcap "Executables")
OWNER_READ OWNER_WRITE OWNER_EXECUTE
GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
+ if(ENABLE_DUMPCAP_GROUP)
+ install(CODE "execute_process(COMMAND chgrp ${DUMPCAP_INSTALL_GROUP} ${CMAKE_INSTALL_FULL_BINDIR}/dumpcap)")
+ install(CODE "execute_process(COMMAND chmod o-x ${CMAKE_INSTALL_FULL_BINDIR}/dumpcap)")
+ endif()
if(DUMPCAP_INSTALL_OPTION STREQUAL "capabilities")
install( CODE "execute_process(
COMMAND
# Must come after executable targets are defined.
find_package( NSIS )
- if (NOT "${MAKENSIS_EXECUTABLE}" STREQUAL "MAKENSIS_EXECUTABLE-NOTFOUND")
+ if(MAKENSIS_EXECUTABLE)
add_subdirectory( packaging/nsis EXCLUDE_FROM_ALL )
ADD_NSIS_UNINSTALLER_TARGET()
ADD_NSIS_PACKAGE_TARGET()
find_package( WiX )
- if (NOT "${WIX_CANDLE_EXECUTABLE}" STREQUAL "WIX_CANDLE_EXECUTABLE-NOTFOUND")
+ if(WIX_CANDLE_EXECUTABLE)
add_subdirectory( packaging/wix EXCLUDE_FROM_ALL )
ADD_WIX_PACKAGE_TARGET()
endif()
find_package( PortableApps )
- if (
- NOT "${PORTABLEAPPS_LAUNCHER_GENERATOR_EXECUTABLE}" STREQUAL "PORTABLEAPPS_LAUNCHER_GENERATOR_EXECUTABLE-NOTFOUND"
- AND
- NOT "${PORTABLEAPPS_INSTALLER_EXECUTABLE}" STREQUAL "PORTABLEAPPS_INSTALLER_EXECUTABLE-NOTFOUND"
- )
+ if(PORTABLEAPPS_LAUNCHER_GENERATOR_EXECUTABLE AND PORTABLEAPPS_INSTALLER_EXECUTABLE)
add_subdirectory( packaging/portableapps EXCLUDE_FROM_ALL )
ADD_PORTABLEAPPS_PACKAGE_TARGET()
endif()
endif()
-add_custom_target(extcaps)
-
-if(BUILD_androiddump)
- if(EXTCAP_ANDROIDDUMP_LIBPCAP)
- if(HAVE_LIBPCAP)
- set(androiddump_LIBS
- ui
- ${GLIB2_LIBRARIES}
- ${PCAP_LIBRARIES}
- )
- else()
- message(FATAL_ERROR "You are trying to build androiddump with libpcap but do not have it")
- endif()
- else()
- set(androiddump_LIBS
- ui
- wiretap
- ${GLIB2_LIBRARIES}
- ${ZLIB_LIBRARIES}
- ${CMAKE_DL_LIBS}
- )
- endif()
- set(androiddump_FILES
- extcap/androiddump.c
- extcap/extcap-base.c
- )
-
- add_executable(androiddump WIN32 ${androiddump_FILES})
- # XXX Shouldn't we add wsutil to androiddump_LIBS instead?
- set_extcap_executable_properties(androiddump)
- target_link_libraries(androiddump ${androiddump_LIBS})
- install(TARGETS androiddump RUNTIME DESTINATION ${EXTCAP_DIR})
- add_dependencies(extcaps androiddump)
-endif()
-
-if(BUILD_sshdump AND LIBSSH_FOUND)
- set(sshdump_LIBS
- wsutil
- ${GLIB2_LIBRARIES}
- ${CMAKE_DL_LIBS}
- ${LIBSSH_LIBRARIES}
- )
- set(sshdump_FILES
- extcap/sshdump.c
- extcap/extcap-base.c
- extcap/ssh-base.c
- )
-
- add_executable(sshdump WIN32 ${sshdump_FILES})
- set_extcap_executable_properties(sshdump)
- target_link_libraries(sshdump ${sshdump_LIBS})
- target_include_directories(sshdump PUBLIC ${LIBSSH_INCLUDE_DIR})
- install(TARGETS sshdump RUNTIME DESTINATION ${EXTCAP_DIR})
- add_dependencies(extcaps sshdump)
-elseif (BUILD_sshdump)
- #message( WARNING "Cannot find libssh, cannot build sshdump" )
-endif()
-
-if(BUILD_ciscodump AND LIBSSH_FOUND)
- set(ciscodump_LIBS
- writecap
- wsutil
- ${GLIB2_LIBRARIES}
- ${CMAKE_DL_LIBS}
- ${LIBSSH_LIBRARIES}
- )
- set(ciscodump_FILES
- extcap/ciscodump.c
- extcap/extcap-base.c
- extcap/ssh-base.c
- )
-
- add_executable(ciscodump WIN32 ${ciscodump_FILES})
- set_extcap_executable_properties(ciscodump)
- target_link_libraries(ciscodump ${ciscodump_LIBS})
- target_include_directories(ciscodump PUBLIC ${LIBSSH_INCLUDE_DIR})
- install(TARGETS ciscodump RUNTIME DESTINATION ${EXTCAP_DIR})
- add_dependencies(extcaps ciscodump)
-elseif (BUILD_ciscodump)
- #message( WARNING "Cannot find libssh, cannot build ciscodump" )
-endif()
-
-if(BUILD_udpdump)
- set(udpdump_LIBS
- ${GLIB2_LIBRARIES}
- ${CMAKE_DL_LIBS}
- wsutil
- writecap
- )
- set(udpdump_FILES
- extcap/udpdump.c
- extcap/extcap-base.c
- )
-
- add_executable(udpdump WIN32 ${udpdump_FILES})
- set_extcap_executable_properties(udpdump)
- target_link_libraries(udpdump ${udpdump_LIBS})
- install(TARGETS udpdump RUNTIME DESTINATION ${EXTCAP_DIR})
- add_dependencies(extcaps udpdump)
-endif()
-
-if(BUILD_randpktdump)
- set(randpktdump_LIBS
- randpkt_core
- ui
- wiretap
- ${GLIB2_LIBRARIES}
- ${ZLIB_LIBRARIES}
- ${CMAKE_DL_LIBS}
- )
- set(randpktdump_FILES
- extcap/extcap-base.c
- extcap/randpktdump.c
- )
-
- add_executable(randpktdump WIN32 ${randpktdump_FILES})
- # XXX Shouldn't we add wsutil to randpktdump_LIBS instead?
- set_extcap_executable_properties(randpktdump)
- target_link_libraries(randpktdump ${randpktdump_LIBS})
- install(TARGETS randpktdump RUNTIME DESTINATION ${EXTCAP_DIR})
- add_dependencies(extcaps randpktdump)
-endif()
-
if (MAXMINDDB_FOUND)
set(mmdbresolve_LIBS
# Note: libmaxminddb is not GPL-2 compatible.
COMMAND ${CMAKE_COMMAND} -E copy_directory
${CMAKE_SOURCE_DIR}/packaging/macosx/ChmodBPF
${CMAKE_BINARY_DIR}/run/ChmodBPF
- COMMAND ${CMAKE_COMMAND} -E copy_directory
- ${CMAKE_SOURCE_DIR}/packaging/macosx/Resources
- ${CMAKE_BINARY_DIR}/run/Resources
COMMAND ${CMAKE_COMMAND} -E copy_directory
${CMAKE_SOURCE_DIR}/packaging/macosx/Scripts
${CMAKE_BINARY_DIR}/run/Scripts
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
find_program(RPMBUILD_EXECUTABLE rpmbuild)
+ find_program(DPKG_BUILDPACKAGE_EXECUTABLE dpkg-buildpackage)
find_program(GIT_EXECUTABLE git)
endif()
-# This will fail if we're not building from a git checkout.
-if(RPMBUILD_EXECUTABLE AND GIT_EXECUTABLE)
+function(_SET_GITVERSION_CMAKE_VARIABLE OUTPUT_VARIABLE)
+ # Load version string and write it to a cmake variable so it can be accessed from cmake.
+ FILE(READ "${CMAKE_CURRENT_BINARY_DIR}/version.h" VERSION_H_FILE_CONTENT)
+ string(REPLACE "\n" "" VERSION_H_FILE_CONTENT ${VERSION_H_FILE_CONTENT})
+ #define VCSVERSION "v2.9.0rc0-305-gb8e8aa87"
+ string(SUBSTRING "${VERSION_H_FILE_CONTENT}" 21 -1 VERSION_STRING)
+ STRING(REGEX REPLACE "\"" "" VERSION_STRING "${VERSION_STRING}")
+ MESSAGE(STATUS "Version string created from version.h: ${VERSION_STRING}")
+ SET(${OUTPUT_VARIABLE} "${VERSION_STRING}" CACHE INTERNAL "${OUTPUT_VARIABLE}")
+endfunction(_SET_GITVERSION_CMAKE_VARIABLE)
+
+
+if(RPMBUILD_EXECUTABLE)
foreach(_rpm_dir BUILD RPMS SOURCES SPECS SRPMS)
file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/packaging/rpm/${_rpm_dir}")
endforeach()
if(CMAKE_GENERATOR STREQUAL "Ninja")
list(APPEND _rpmbuild_with_args --with ninja)
endif()
+ if(CCACHE_EXECUTABLE)
+ list(APPEND _rpmbuild_with_args --with ccache)
+ endif()
if (BUILD_wireshark)
list(APPEND _rpmbuild_with_args --with qt5)
endif()
- if (BUILD_mmdbresolve)
+ if (MAXMINDDB_FOUND)
list(APPEND _rpmbuild_with_args --with mmdbresolve)
endif()
if (LUA_FOUND)
if (NGHTTP2_FOUND)
list(APPEND _rpmbuild_with_args --with nghttp2)
endif()
+ if (SYSTEMD_FOUND)
+ list(APPEND _rpmbuild_with_args --with sdjournal)
+ endif()
execute_process(
- COMMAND git describe --abbrev=8 --match v[1-9]*
- OUTPUT_VARIABLE _git_description
- OUTPUT_STRIP_TRAILING_WHITESPACE
- WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+ COMMAND ${PERL_EXECUTABLE}
+ ${CMAKE_SOURCE_DIR}/make-version.pl
+ ${CMAKE_SOURCE_DIR}
)
- string(SUBSTRING "${_git_description}" 1 -1 RPM_TARBALL_VERSION)
- string(REPLACE "-" "_" RPM_VERSION "${RPM_TARBALL_VERSION}")
+
+ _SET_GITVERSION_CMAKE_VARIABLE(_git_description)
+
+ if (NOT _git_description)
+ # We're building the rpm outside the source. Guess the version from the dirname.
+ get_filename_component(CMAKE_SOURCE_DIR_NAME ${CMAKE_SOURCE_DIR} NAME)
+ # XXX this assumes the directory to start with "wireshark-"
+ string(SUBSTRING "${CMAKE_SOURCE_DIR_NAME}" 10 -1 _git_description)
+ endif()
+ string(REPLACE "-" "_" RPM_VERSION "${_git_description}")
configure_file(packaging/rpm/wireshark.spec.in ${CMAKE_BINARY_DIR}/packaging/rpm/SPECS/wireshark.spec)
- set(_export_tarball "${CPACK_PACKAGE_NAME}-${RPM_TARBALL_VERSION}.tar.xz")
+ # XXX Replace with the "dist" target?
+ set(_export_tarball "${CPACK_PACKAGE_NAME}-${_git_description}.tar.xz")
add_custom_command(
- OUTPUT "${CMAKE_SOURCE_DIR}/${_export_tarball}"
- COMMAND ./tools/git-export-release.sh "${_git_description}"
+ OUTPUT "${CMAKE_BINARY_DIR}/packaging/rpm/SOURCES/${_export_tarball}"
+ COMMAND ./tools/git-export-release.sh
+ -d "${CMAKE_BINARY_DIR}/packaging/rpm/SOURCES"
+ "${_git_description}"
# XXX Add an option to git-export-release.sh to write to a
# specific directory so that we can get rid of `ln` below.
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
)
add_custom_target(rpm-package
- COMMAND ${CMAKE_COMMAND} -E create_symlink
- "${CMAKE_SOURCE_DIR}/${_export_tarball}"
- "SOURCES/${_export_tarball}"
COMMAND ${RPMBUILD_EXECUTABLE}
--define "_topdir ${CMAKE_BINARY_DIR}/packaging/rpm"
--define "_prefix ${CMAKE_INSTALL_PREFIX}"
${_rpmbuild_with_args}
--clean -ba SPECS/wireshark.spec
- DEPENDS "${CMAKE_SOURCE_DIR}/${_export_tarball}"
+ DEPENDS "${CMAKE_BINARY_DIR}/packaging/rpm/SOURCES/${_export_tarball}"
WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/packaging/rpm"
COMMENT "Create a tarball from the current git commit."
)
endif()
+if(DPKG_BUILDPACKAGE_EXECUTABLE)
+ add_custom_target(deb-package
+ COMMAND ${DPKG_BUILDPACKAGE_EXECUTABLE} -us -uc
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+ )
+endif()
+
set(CLEAN_C_FILES
+ ${dumpcap_FILES}
${wireshark_FILES}
${tshark_FILES}
${rawshark_FILES}
${captype_FILES}
${editcap_FILES}
${idl2wrs_FILES}
- ${dumpcap_FILES}
- ${androiddump_FILES}
- ${sshdump_FILES}
- ${ciscodump_FILES}
${mmdbresolve_FILES}
)
ws_compiler_tests.h
ws_diag_control.h
ws_symbol_export.h
+ version_info.h
+ ${CMAKE_BINARY_DIR}/ws_version.h
)
if(NOT WIN32)
PATTERN "Makefile.*" EXCLUDE
)
-set(CMAKE_INSTALL_MODULES_DIR ${CMAKE_INSTALL_LIBDIR}/${CPACK_PACKAGE_NAME})
-configure_file("${CMAKE_MODULE_PATH}/WiresharkConfig.cmake.in" "${CMAKE_BINARY_DIR}/WiresharkConfig.cmake" @ONLY)
-configure_file("${CMAKE_MODULE_PATH}/WiresharkConfigVersion.cmake.in" "${CMAKE_BINARY_DIR}/WiresharkConfigVersion.cmake" @ONLY)
+set(CMAKE_INSTALL_MODULES_DIR "${CMAKE_INSTALL_LIBDIR}/${CPACK_PACKAGE_NAME}/cmake")
install(
FILES
${CMAKE_MODULE_PATH}/FindGLIB2.cmake
- ${CMAKE_MODULE_PATH}/FindWireshark.cmake
${CMAKE_MODULE_PATH}/FindWSWinLibs.cmake
${CMAKE_MODULE_PATH}/UseAsn2Wrs.cmake
${CMAKE_MODULE_PATH}/LocatePythonModule.cmake
${CMAKE_MODULE_PATH}/UseMakePluginReg.cmake
- ${CMAKE_BINARY_DIR}/WiresharkConfig.cmake
- ${CMAKE_BINARY_DIR}/WiresharkConfigVersion.cmake
DESTINATION
${CMAKE_INSTALL_MODULES_DIR}
)
-# Test suite wrapper
-if(ENABLE_APPLICATION_BUNDLE)
- set(TEST_SH_BIN_DIR ${CMAKE_BINARY_DIR}/run)
-else()
- set(TEST_SH_BIN_DIR $<TARGET_FILE_DIR:epan>)
-endif()
+include(CMakePackageConfigHelpers)
-add_custom_target(test-sh
- COMMAND ${CMAKE_COMMAND}
- -DCMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}
- -DTEST_SH_BIN_DIR=${TEST_SH_BIN_DIR}
- -DTEST_SH_SRC_DIR=${CMAKE_SOURCE_DIR}/test
- -P ${CMAKE_SOURCE_DIR}/cmake/modules/GenerateTestSh.cmake
- DEPENDS ${CMAKE_SOURCE_DIR}/cmake/modules/GenerateTestSh.cmake
+configure_package_config_file(WiresharkConfig.cmake.in
+ ${CMAKE_BINARY_DIR}/WiresharkConfig.cmake
+ INSTALL_DESTINATION ${CMAKE_INSTALL_MODULES_DIR}
+ PATH_VARS
+ CMAKE_INSTALL_LIBDIR
+ CMAKE_INSTALL_INCLUDEDIR
+ PLUGIN_INSTALL_VERSION_LIBDIR
+ EXTCAP_INSTALL_LIBDIR
)
-set_target_properties(test-sh PROPERTIES
- FOLDER "Tests"
- EXCLUDE_FROM_DEFAULT_BUILD True
+
+write_basic_package_version_file(
+ ${CMAKE_BINARY_DIR}/WiresharkConfigVersion.cmake
+ COMPATIBILITY AnyNewerVersion
)
+# XXX On Windows wsutil depends on a CMake zlib target for which there are no
+# exports.
+if(NOT WIN32)
+ install(
+ FILES
+ ${CMAKE_BINARY_DIR}/WiresharkConfig.cmake
+ ${CMAKE_BINARY_DIR}/WiresharkConfigVersion.cmake
+ DESTINATION
+ ${CMAKE_INSTALL_MODULES_DIR}
+ )
+
+ install(EXPORT WiresharkTargets
+ DESTINATION ${CMAKE_INSTALL_MODULES_DIR}
+ )
+endif()
+
+if (DOXYGEN_EXECUTABLE)
+ # API reference
+ # We don't have a good way of tracking dependencies, so we simply
+ # recreate the whole thing from scratch each time.
+ add_custom_target(wsar_html
+ COMMAND ${CMAKE_COMMAND} -E remove_directory wsar_html
+ COMMAND ${DOXYGEN_EXECUTABLE} doxygen.cfg
+ )
+
+ add_custom_target(wsar_html_zip
+ COMMAND ${CMAKE_COMMAND} -E tar "cfv" "wsar_html.zip" --format=zip wsar_html
+ DEPENDS wsar_html
+ )
+ set_target_properties(wsar_html wsar_html_zip PROPERTIES
+ FOLDER "Docs"
+ EXCLUDE_FROM_DEFAULT_BUILD True
+ )
+endif(DOXYGEN_EXECUTABLE)
+
add_custom_target(test-programs
- DEPENDS test-sh
- exntest
+ DEPENDS exntest
oids_test
reassemble_test
tvbtest
EXCLUDE_FROM_DEFAULT_BUILD True
)
+# Test suites
+enable_testing()
+# We could try to build this list dynamically, but given that we tend to
+# go years between adding suites just run
+# test/test.py --list-groups | sort
+# and paste the output here.
+set(_test_group_list
+ suite_capture
+ suite_clopts
+ suite_decryption
+ suite_dfilter.group_bytes_ether
+ suite_dfilter.group_bytes_ipv6
+ suite_dfilter.group_bytes_type
+ suite_dfilter.group_double
+ suite_dfilter.group_integer
+ suite_dfilter.group_integer_1byte
+ suite_dfilter.group_ipv4
+ suite_dfilter.group_membership
+ suite_dfilter.group_range_method
+ suite_dfilter.group_scanner
+ suite_dfilter.group_string_type
+ suite_dfilter.group_stringz
+ suite_dfilter.group_time_relative
+ suite_dfilter.group_time_type
+ suite_dfilter.group_tvb
+ suite_dfilter.group_uint64
+ suite_dissection
+ suite_fileformats
+ suite_follow
+ suite_io
+ suite_mergecap
+ suite_nameres
+ suite_text2pcap
+ suite_sharkd
+ suite_unittests
+ suite_wslua
+)
+
+# We don't currently handle spaces in arguments. On Windows this
+# means that you will probably have to pass in an interface index
+# instead of a name.
+set(TEST_EXTRA_ARGS "" CACHE STRING "Extra arguments to pass to test/test.py")
+separate_arguments(TEST_EXTRA_ARGS)
+
+foreach(_group_name ${_test_group_list})
+ add_test(
+ NAME ${_group_name}
+ COMMAND ${CMAKE_COMMAND} -E env PYTHONIOENCODING=UTF-8
+ ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/test/test.py
+ --verbose
+ --program-path ${WS_PROGRAM_PATH}
+ ${TEST_EXTRA_ARGS}
+ ${_group_name}
+ )
+ set_tests_properties(${_group_name} PROPERTIES TIMEOUT 600)
+endforeach()
+
if (GIT_EXECUTABLE)
# Update AUTHORS file with entries from git shortlog
add_custom_target(
find_program(HARDENING_CHECK_EXECUTABLE hardening-check
DOC "Path to the hardening-check utility."
)
- if (NOT "${HARDENING_CHECK_EXECUTABLE}" STREQUAL "HARDENING_CHECK_EXECUTABLE-NOTFOUND")
+ if(HARDENING_CHECK_EXECUTABLE)
foreach(_prog ${PROGLIST})
get_target_property(_prog_dir ${_prog} RUNTIME_OUTPUT_DIRECTORY)
- if ("${_prog_dir}" STREQUAL "_prog_dir-NOTFOUND")
+ if(NOT _prog_dir)
set(_prog_dir "${CMAKE_BINARY_DIR}/run")
endif()
set(_prog_paths ${_prog_paths} "${_prog_dir}/${_prog}")
endif()
endif()
-include( UseCheckAPI )
CHECKAPI(
NAME
main
find_program(SHELLCHECK_EXECUTABLE shellcheck
DOC "Path to the shellcheck utility."
)
-if (NOT "${SHELLCHECK_EXECUTABLE}" STREQUAL "SHELLCHECK_EXECUTABLE-NOTFOUND")
+if(SHELLCHECK_EXECUTABLE)
add_custom_target(shellcheck)
set_target_properties(shellcheck PROPERTIES FOLDER "Tests")
# --external-sources requires 0.4.0 or later.
add_custom_command(TARGET shellcheck POST_BUILD
COMMAND shellcheck --external-sources
+ image/stock_icons/svg-to-png.sh
+ packaging/macosx/osx-app.sh.in
+ packaging/macosx/osx-dmg.sh.in
+ tools/compress-pngs.sh
+ tools/debian-setup.sh
+ tools/git-export-release.sh
tools/fuzz-test.sh
+ tools/gen-bugnote
+ tools/pre-commit
tools/randpkt-test.sh
+ tools/release-update-debian-soversions.sh
tools/test-captures.sh
+ tools/update-tx
tools/valgrind-wireshark.sh
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
)