project(Wireshark C CXX)
+# Updated by make-version.pl
+set(GIT_REVISION 0)
+set(PROJECT_MAJOR_VERSION 2)
+set(PROJECT_MINOR_VERSION 3)
+set(PROJECT_PATCH_VERSION 0)
+set(PROJECT_BUILD_VERSION ${GIT_REVISION})
+set(PROJECT_VERSION_EXTENSION "")
+
+if(DEFINED ENV{WIRESHARK_VERSION_EXTRA})
+ set(PROJECT_VERSION_EXTENSION "$ENV{WIRESHARK_VERSION_EXTRA}")
+endif()
+
+set(PROJECT_VERSION "${PROJECT_MAJOR_VERSION}.${PROJECT_MINOR_VERSION}.${PROJECT_PATCH_VERSION}${PROJECT_VERSION_EXTENSION}")
+
message(STATUS "Generating build using CMake ${CMAKE_VERSION}")
if(WIN32)
# Needed for proper Qt linking. See
#Defines CMAKE_INSTALL_BINDIR, CMAKE_INSTALL_DATADIR, etc ...
include(CMakeInstallDirs)
-# Updated by make-version.pl
-set(GIT_REVISION 0)
-set(PROJECT_MAJOR_VERSION 2)
-set(PROJECT_MINOR_VERSION 1)
-set(PROJECT_PATCH_VERSION 0)
-set(PROJECT_BUILD_VERSION ${GIT_REVISION})
-# Updated by make-version.pl
-set(PROJECT_VERSION_EXTENSION)
-if(NOT DEFINED PROJECT_VERSION_EXTENSION)
- if (DEFINED ENV{WIRESHARK_VERSION_EXTRA})
- set(PROJECT_VERSION_EXTENSION "$ENV{WIRESHARK_VERSION_EXTRA}")
- else()
- set(PROJECT_VERSION_EXTENSION "-git")
- endif()
-endif()
-
-set(PROJECT_VERSION "${PROJECT_MAJOR_VERSION}.${PROJECT_MINOR_VERSION}.${PROJECT_PATCH_VERSION}${PROJECT_VERSION_EXTENSION}")
-
# Banner shown at top right of Qt welcome screen.
if(DEFINED ENV{WIRESHARK_VERSION_FLAVOR})
set(VERSION_FLAVOR "$ENV{WIRESHARK_VERSION_FLAVOR}")
set(LOCAL_CFLAGS ${LOCAL_CFLAGS} "/Zo")
elseif(MSVC14)
# /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.
- set(LOCAL_CFLAGS ${LOCAL_CFLAGS} "/Zo")
+ set(LOCAL_CFLAGS ${LOCAL_CFLAGS} "/Zo" "/utf-8")
endif()
if(ENABLE_CODE_ANALYSIS)
# when compiling Wireshark sources. (Selected from "level 4" warnings).
## 4295: array is too small to include a terminating null character
## 4189: local variable is initialized but not referenced
- set(WARNINGS_CFLAGS "/w34295 /w34189")
+ # Disable warnings about about use of flexible array members:
+ ## 4200: nonstandard extension used : zero-sized array in struct/union
+ set(WARNINGS_CFLAGS "/w34295 /w34189 /wd4200")
set(WIRESHARK_COMMON_FLAGS
${LOCAL_CFLAGS}
${WARNINGS_CFLAGS}
)
- # Set in Makefile.nmake
set(WS_LINK_FLAGS "/LARGEADDRESSAWARE /MANIFEST:NO /INCREMENTAL:NO /RELEASE")
else()
endif()
endif()
- set(WIRESHARK_COMMON_FLAGS
+ if(CMAKE_VERSION VERSION_LESS "3.1")
+ # Many modern compilers use c99 by default, but for older ones
+ # (like GCC 4.4.7), -std=gnu99 is required to avoid errors about
+ # use constructs like "for (int i = 0; i < n; i++) ;"
+ #
+ # Older versions of IBM XL C may require -qlanglvl=extc99.
+ # With V7.0, the "xlc" command defaults to C89; with 10.1,
+ # it defaults to C99 (both with IBM syntax extensions).
+ #
+ # HP's manual for HP C/HP-UX B.11.11.04 (the tenth
+ # edition of the manual), for PA-RISC, "documents
+ # new HP C features that support C99 industry standards".
+ # The manual for Version A.06.25 for Itanium mentions an
+ # -AC99 flag to support C99, but says it's the default;
+ # some older versions might require -AC99.
+ #
+ # As of Sun Studio 8, the compiler appears to default
+ # to supporting some C99 language features, but not
+ # C99 library differences from C89; -xc99 will give
+ # you both. The earlier Sun Forte Developer 6 update 2
+ # might or might not support thosee C99 language features
+ # by default, and doesn't speak of library differences;
+ # if it doesn't support the language features by default,
+ # -xc99 will support them.
+ #
+ if(CMAKE_C_COMPILER_ID MATCHES "GNU")
+ set(CMAKE_C_FLAGS "-std=gnu99 ${CMAKE_C_FLAGS}")
+ endif()
+ else()
+ #
+ # Current versions of CMake do not support options to
+ # request C99 for XL C, HP C, or Oracle C. (They may
+ # not be necessary for current versions.)
+ #
+ set(CMAKE_C_STANDARD 99)
+ endif()
+
+ if(CMAKE_C_COMPILER_ID MATCHES "Clang")
+ set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS}
+ # avoid "argument unused during compilation" warnings
+ # (for example, when getting the -gsplit-dwarf option or
+ # when combining -fwrapv with -fno-strict-overflow)
+ -Qunused-arguments
+ )
+ else()
+ set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS}
+ -fexcess-precision=fast
+ )
+ endif()
+
+ set(COMMON_WARN_FLAGS
# The following are for C and C++
# -O<X> and -g get set by the CMAKE_BUILD_TYPE
-Wall
-Wheader-guard
)
- set(WIRESHARK_C_ONLY_FLAGS
+ set(C_WARN_FLAGS
# The following are C only, not C++
-Wc++-compat
- -Wdeclaration-after-statement
-Wshadow
-Wno-pointer-sign
-Wold-style-definition
# The Qt headers generate a ton of shortening errors on 64-bit systems
# so only enable this for C for now.
-Wshorten-64-to-32
- # Clang only
- -Wc99-extensions
)
- set(WIRESHARK_CXX_ONLY_FLAGS
+ set(CXX_WARN_FLAGS
)
- set(WIRESHARK_EXTRA_COMPILER_COMMON_FLAGS
+ set(COMMON_EXTRA_WARN_FLAGS
# The following are for C and C++
-Wpedantic
#
-fno-delete-null-pointer-checks
)
- set(WIRESHARK_EXTRA_COMPILER_C_ONLY_FLAGS
+ set(C_EXTRA_WARN_FLAGS
# The following are C only, not C++
#
# Due to various places where APIs we don't control
-Wbad-function-cast
)
- set(WIRESHARK_EXTRA_COMPILER_CXX_ONLY_FLAGS
+ set(CXX_EXTRA_WARN_FLAGS
)
- if(CMAKE_C_COMPILER_ID MATCHES "Clang")
- set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS}
- # avoid "argument unused during compilation" warnings
- # (for example, when getting the -gsplit-dwarf option or
- # when combining -fwrapv with -fno-strict-overflow)
- -Qunused-arguments
- )
-
- set(WIRESHARK_CXX_ONLY_FLAGS ${WIRESHARK_CXX_ONLY_FLAGS}
- )
- else()
- set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS}
- -fexcess-precision=fast
- )
-
- set(WIRESHARK_C_ONLY_FLAGS ${WIRESHARK_C_ONLY_FLAGS}
- )
- endif()
-
- set(WIRESHARK_ASAN_FLAGS
- # With Clang >= 3.5 Leak detection is enable by default
- # and no yet all leak is fixed...
- # use ASAN_OPTIONS=detect_leaks=0 to disable detect_leaks
- -fsanitize=address
- -fsanitize=undefined # compile and runtime checks
- # -fsanitize=float-divide-by-zero
- # -fsanitize=float-cast-overflow
- # -fno-sanitize-recover # Abort during runtime
- )
-
- if(ENABLE_ASAN)
- set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_ASAN_FLAGS})
- endif()
-
if(ENABLE_EXTRA_COMPILER_WARNINGS) # This overrides -Werror
- set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_EXTRA_COMPILER_COMMON_FLAGS})
- set(WIRESHARK_C_ONLY_FLAGS ${WIRESHARK_C_ONLY_FLAGS} ${WIRESHARK_EXTRA_COMPILER_C_ONLY_FLAGS})
- set(WIRESHARK_CXX_ONLY_FLAGS ${WIRESHARK_CXX_ONLY_FLAGS} ${WIRESHARK_EXTRA_COMPILER_CXX_ONLY_FLAGS})
+ 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})
endif()
add_definitions(
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)
endforeach()
set(CMAKE_CXX_FLAGS "${ADDED_CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS}")
+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()
+endforeach()
+set(WS_WARNINGS_C_FLAGS ${ADDED_WARN_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()
+endforeach()
+set(WS_WARNINGS_CXX_FLAGS ${ADDED_WARN_CXX_FLAGS})
+
+if(ENABLE_ASAN)
+ set(CMAKE_REQUIRED_LIBRARIES "-fsanitize=address")
+ check_c_compiler_flag(-fsanitize=address C__fsanitize_address_VALID)
+ check_cxx_compiler_flag(-fsanitize=address CXX__fsanitize_address_VALID)
+ set(CMAKE_REQUIRED_LIBRARIES "")
+ if(NOT C__fsanitize_address_VALID OR NOT CXX__fsanitize_address_VALID)
+ message(FATAL_ERROR "ENABLE_ASAN was requested, but not supported!")
+ endif()
+ set(CMAKE_C_FLAGS "-fsanitize=address ${CMAKE_C_FLAGS}")
+ set(CMAKE_CXX_FLAGS "-fsanitize=address ${CMAKE_CXX_FLAGS}")
+ # Disable ASAN for build-time tools, e.g. lemon
+ check_c_compiler_flag(-fno-sanitize=all C__fno_sanitize_all_VALID)
+ if(C__fno_sanitize_all_VALID)
+ set(NO_SANITIZE_CFLAGS "-fno-sanitize=all")
+ set(NO_SANITIZE_LDFLAGS "-fno-sanitize=all")
+ endif()
+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")
- set(NO_ERROR_DEPRECATED_DECLARATIONS_COMPILE_FLAGS)
else()
check_c_compiler_flag(-Werror WERROR)
if (WERROR)
set(NO_ERROR_DEPRECATED_DECLARATIONS_COMPILE_FLAGS "-Wno-error=deprecated-declarations")
endif()
endif()
-else()
- set(WERROR_COMMON_FLAGS FALSE)
endif()
#
set(LEX_REQUIRED TRUE)
set(GLIB2_REQUIRED TRUE)
set(GLIB2_FIND_REQUIRED TRUE)
-set(GLIB2_MIN_VERSION 2.14.0)
+set(GLIB2_MIN_VERSION 2.22.0)
set(GTHREAD2_REQUIRED TRUE)
set(PythonInterp_FIND_VERSION 2)
set(Python_ADDITIONAL_VERSIONS 3)
#
list(REMOVE_ITEM Qt5Widgets_EXECUTABLE_COMPILE_FLAGS "-fPIC")
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 "${CMAKE_CXX_FLAGS} -std=c++11")
+ endif()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")
set (QT_FOUND ON)
set (QT_LIBRARIES ${Qt5Widgets_LIBRARIES} ${Qt5PrintSupport_LIBRARIES})
set(ENABLE_CHECK_FILTER 1)
endif()
-message(STATUS "C-Flags: ${CMAKE_C_FLAGS}")
-message(STATUS "CXX-Flags: ${CMAKE_CXX_FLAGS}")
+string(REPLACE ";" " " _warnings_c_flags "${WS_WARNINGS_C_FLAGS}")
+message(STATUS "C-Flags: ${CMAKE_C_FLAGS} ${_warnings_c_flags}")
+string(REPLACE ";" " " _warnings_cxx_flags "${WS_WARNINGS_CXX_FLAGS}")
+message(STATUS "CXX-Flags: ${CMAKE_CXX_FLAGS} ${_warnings_cxx_flags}")
message(STATUS "Warnings as errors: ${WERROR_COMMON_FLAGS}")
if(APPLE)
${SHARK_COMMON_SRC}
extcap.c
extcap_parser.c
+ extcap_spawn.c
)
endif()
${CMAKE_BINARY_DIR}/doc/AUTHORS-SHORT
${CMAKE_BINARY_DIR}/doc/asn2deb.html
${CMAKE_BINARY_DIR}/doc/androiddump.html
+ ${CMAKE_BINARY_DIR}/doc/udpdump.html
${CMAKE_BINARY_DIR}/doc/capinfos.html
${CMAKE_BINARY_DIR}/doc/captype.html
${CMAKE_BINARY_DIR}/doc/ciscodump.html
)
endforeach(_dll)
-
- # Don't overwrite an exe if it's already there. We don't want to
- # clobber any previous code signing.
- file(GLOB _gspawn_helpers
- RELATIVE "${GLIB2_DLL_DIR}"
- "${GLIB2_DLL_DIR}/gspawn*.exe"
- )
- foreach(_gspawn_helper ${_gspawn_helpers})
- add_custom_command(TARGET copy_cli_dlls PRE_BUILD
- COMMAND if not exist \"${_dll_output_dir_win}\\${_gspawn_helper}\" xcopy ${_gspawn_helper} "${_dll_output_dir_win}" /D /Y
- WORKING_DIRECTORY "${GLIB2_DLL_DIR}"
- )
- endforeach()
-
# Optional
if (AIRPCAP_FOUND)
add_custom_command(TARGET copy_cli_dlls PRE_BUILD
)
# Wireshark.app/Contents/Resources/share/man/man1
- set(BUNDLE_RESOURCE_SHARE_MAN1_FILES ${MAN1_FILES})
set_source_files_properties(${BUNDLE_RESOURCE_SHARE_MAN1_FILES} PROPERTIES
MACOSX_PACKAGE_LOCATION Resources/share/man/man1
)
# Wireshark.app/Contents/Resources/share/man/man1
- set(BUNDLE_RESOURCE_SHARE_MAN4_FILES ${MAN4_FILES})
set_source_files_properties(${BUNDLE_RESOURCE_SHARE_MAN4_FILES} PROPERTIES
MACOSX_PACKAGE_LOCATION Resources/share/man/man4
)
add_executable(wireshark WIN32 MACOSX_BUNDLE wireshark-qt.cpp ${wireshark_FILES} ${EXTRA_BUNDLE_FILES})
add_dependencies(wireshark version)
set(PROGLIST ${PROGLIST} wireshark)
+ set_target_properties(wireshark PROPERTIES COMPILE_OPTIONS "${WS_WARNINGS_CXX_FLAGS}")
set_target_properties(wireshark PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
set_target_properties(wireshark PROPERTIES FOLDER "Executables")
if(ENABLE_APPLICATION_BUNDLE OR WIN32)
# 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 "open ${CMAKE_BINARY_DIR}/run/Wireshark.app --args \"\$\@\"\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()
# Common properties for CLI executables
macro(set_extra_executable_properties _executable _folder)
set_target_properties(${_executable} PROPERTIES
+ COMPILE_OPTIONS "${WS_WARNINGS_C_FLAGS}"
LINK_FLAGS "${WS_LINK_FLAGS}"
FOLDER ${_folder}
)
if(WIN32)
set_target_properties(${_executable} PROPERTIES
+ COMPILE_OPTIONS "${WS_WARNINGS_C_FLAGS}"
LINK_FLAGS "${WS_LINK_FLAGS}"
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/run/extcap
RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/run/Debug/extcap
)
else()
set_target_properties(${_executable} PROPERTIES
+ COMPILE_OPTIONS "${WS_WARNINGS_C_FLAGS}"
LINK_FLAGS "${WS_LINK_FLAGS}"
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/run/extcap
)
add_executable(wireshark-gtk WIN32 ${wireshark_FILES})
add_dependencies(wireshark-gtk version)
set(PROGLIST ${PROGLIST} wireshark-gtk)
+ set_target_properties(wireshark-gtk PROPERTIES COMPILE_OPTIONS "${WS_WARNINGS_C_FLAGS}")
set_target_properties(wireshark-gtk PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
set_target_properties(wireshark-gtk PROPERTIES FOLDER "Executables")
target_link_libraries(wireshark-gtk ${wireshark_gtk_LIBS})
#message( WARNING "Cannot find libssh, cannot build ciscodump" )
endif()
+if(ENABLE_EXTCAP AND BUILD_udpdump)
+ set(udpdump_LIBS
+ ${GLIB2_LIBRARIES}
+ ${CMAKE_DL_LIBS}
+ ${LIBEPAN_LIBS}
+ 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})
+endif()
+
if(ENABLE_EXTCAP AND BUILD_randpktdump)
set(randpktdump_LIBS
randpkt_core
${dftest_FILES}
${randpkt_FILES}
${randpktdump_FILES}
+ ${udpdump_FILES}
${text2pcap_CLEAN_FILES}
${mergecap_FILES}
${capinfos_FILES}
${androiddump_FILES}
${sshdump_FILES}
${ciscodump_FILES}
+ ${udpdump_FILES}
)
-if (WERROR_COMMON_FLAGS)
- set_source_files_properties(
- ${CLEAN_FILES}
- PROPERTIES
- COMPILE_FLAGS ${WERROR_COMMON_FLAGS}
- )
-endif()
+set_source_files_properties(
+ ${CLEAN_FILES}
+ PROPERTIES
+ COMPILE_FLAGS "${WERROR_COMMON_FLAGS}"
+)
install(
FILES
${TSHARK_TAP_SRC}
)
+find_program(SHELLCHECK_EXECUTABLE shellcheck
+ DOC "Path to the shellcheck utility."
+)
+if (NOT "${SHELLCHECK_EXECUTABLE}" STREQUAL "SHELLCHECK_EXECUTABLE-NOTFOUND")
+ 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
+ tools/fuzz-test.sh
+ tools/randpkt-test.sh
+ tools/runa2x.sh
+ tools/test-captures.sh
+ tools/valgrind-wireshark.sh
+ WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+ )
+endif()
+
+
#
# Editor modelines - http://www.wireshark.org/tools/modelines.html
#