CMakeLists.txt

   1 # CMakeLists.txt
   2 #
   3 # Wireshark - Network traffic analyzer
   4 # By Gerald Combs <gerald@wireshark.org>
   5 # Copyright 1998 Gerald Combs
   6 #
   7 # This program is free software; you can redistribute it and/or
   8 # modify it under the terms of the GNU General Public License
   9 # as published by the Free Software Foundation; either version 2
  10 # of the License, or (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program; if not, write to the Free Software
  19 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20 #
  21
  22 project(Wireshark C CXX)
  23
  24 message(STATUS "Generating build using CMake ${CMAKE_VERSION}")
  25 if(WIN32)
  26         # Needed for proper Qt linking. See
  27         # http://www.cmake.org/cmake/help/v3.0/policy/CMP0020.html
  28         # 3.1.3 is the currently supported version
  29         cmake_minimum_required(VERSION 3.1.3)
  30 else()
  31         cmake_minimum_required(VERSION 2.8.3)
  32 endif()
  33
  34 # Needs to be set after cmake_minimum_required or cmake_policy(VERSION)
  35 # Policy since 2.6.1
  36 cmake_policy(SET CMP0008 NEW)
  37 # Policy since 2.6.3
  38 # Backward compatibility for versions < 2.6.3
  39 cmake_policy(SET CMP0011 OLD)
  40 # Policy since 2.8.1
  41 cmake_policy(SET CMP0015 NEW)
  42
  43 #Where to find local cmake scripts
  44 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
  45
  46 # Set old behaviour for LOCATION property
  47 if (POLICY CMP0026)
  48         cmake_policy(SET CMP0026 OLD)
  49 endif()
  50
  51 # Set old behaviour for variable quoting
  52 if (POLICY CMP0054)
  53         cmake_policy(SET CMP0054 OLD)
  54 endif()
  55
  56 # Set old behaviour for MACOSX_RPATH
  57 if (POLICY CMP0042)
  58         cmake_policy(SET CMP0042 OLD)
  59 endif()
  60
  61 # If our target platform is enforced by our generator, set
  62 # WIRESHARK_TARGET_PLATFORM accordingly. Otherwise use
  63 # %WIRESHARK_TARGET_PLATFORM%.
  64
  65 if(WIN32)
  66         find_package(PowerShell REQUIRED)
  67
  68         if(${CMAKE_CL_64} OR "${CMAKE_GENERATOR}" MATCHES "Win64")
  69                 set(WIRESHARK_TARGET_PLATFORM win64)
  70         elseif("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
  71                 set(WIRESHARK_TARGET_PLATFORM win32)
  72         else()
  73                 set(WIRESHARK_TARGET_PLATFORM $ENV{WIRESHARK_TARGET_PLATFORM})
  74         endif()
  75
  76         if ("${WIRESHARK_TARGET_PLATFORM}" MATCHES "win64")
  77                 set(PROCESSOR_ARCHITECTURE amd64)
  78         else()
  79                 set(PROCESSOR_ARCHITECTURE x86)
  80         endif()
  81
  82         # Sanity check
  83         if(DEFINED ENV{PLATFORM})
  84                 string(TOLOWER $ENV{PLATFORM} _vs_platform)
  85         else()
  86                 set(_vs_platform "[undefined]") # x86
  87         endif()
  88         if(
  89                 (_vs_platform STREQUAL "x64" AND NOT WIRESHARK_TARGET_PLATFORM STREQUAL "win64")
  90                 OR
  91                 (_vs_platform STREQUAL "[undefined]" AND NOT WIRESHARK_TARGET_PLATFORM STREQUAL "win32")
  92         )
  93                 message(FATAL_ERROR "The PLATFORM environment variable (${_vs_platform})"
  94                         " doesn't match the generator platform (${WIRESHARK_TARGET_PLATFORM})")
  95         endif()
  96         message(STATUS "Building for ${WIRESHARK_TARGET_PLATFORM} using ${CMAKE_GENERATOR}")
  97
  98         # Determine where the 3rd party libraries will be
  99         if( DEFINED ENV{WIRESHARK_LIB_DIR} )
 100                 # The buildbots set WIRESHARK_LIB_DIR but not WIRESHARK_BASE_DIR.
 101                 file( TO_CMAKE_PATH "$ENV{WIRESHARK_LIB_DIR}" _PROJECT_LIB_DIR )
 102         elseif( DEFINED ENV{WIRESHARK_BASE_DIR} )
 103                 file( TO_CMAKE_PATH "$ENV{WIRESHARK_BASE_DIR}" _WS_BASE_DIR )
 104                 set( _PROJECT_LIB_DIR "${_WS_BASE_DIR}/wireshark-${WIRESHARK_TARGET_PLATFORM}-libs" )
 105         else()
 106                 # Don't know what to do
 107                 message(FATAL_ERROR "Neither WIRESHARK_BASE_DIR or WIRESHARK_LIB_DIR are defined")
 108         endif()
 109
 110         # Download third-party libraries
 111         file (TO_NATIVE_PATH ${CMAKE_SOURCE_DIR}/tools/win-setup.ps1 _win_setup)
 112         file (TO_NATIVE_PATH ${_PROJECT_LIB_DIR} _ws_lib_dir)
 113         if(MSVC14)
 114                 set(_vsversion_args "14")
 115         elseif(MSVC12)
 116                 set(_vsversion_args "12")
 117         elseif(MSVC11)
 118                 set(_vsversion_args "11")
 119         elseif(MSVC10)
 120                 set(_vsversion_args "10")
 121         else()
 122                 message(FATAL_ERROR "Unsupported compiler ${CMAKE_C_COMPILER}")
 123         endif()
 124
 125         # Is it possible to have a one-time, non-cached option in CMake? If
 126         # so, we could add a "-DFORCE_WIN_SETUP" which passes -Force to
 127         # win-setup.ps1.
 128         execute_process(
 129                 COMMAND ${POWERSHELL_COMMAND} "${_win_setup}" -Destination "${_ws_lib_dir}" -Platform ${WIRESHARK_TARGET_PLATFORM} -VSVersion ${_vsversion_args}
 130                 RESULT_VARIABLE _win_setup_failed
 131         )
 132         if (${_win_setup_failed})
 133                 message(FATAL_ERROR "Windows setup (win-setup.ps1) failed.")
 134         endif()
 135
 136         # XXX Add a dependency on ${_ws_lib_dir}/current_tag.txt?
 137
 138         # Head off any attempts to use Cygwin's Python.
 139         include(LocatePythonExecutable)
 140 endif(WIN32)
 141
 142 include(UseCustomIncludes)
 143 ADD_CUSTOM_CMAKE_INCLUDE()
 144
 145 # This cannot be implemented via option(...)
 146 if( NOT CMAKE_BUILD_TYPE )
 147         set( CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
 148                 "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
 149                 FORCE)
 150 endif()
 151 message(STATUS "Configuration types: ${CMAKE_CONFIGURATION_TYPES}")
 152
 153 # Override optimization and other flags for make based generators
 154 foreach (_BT DEBUG RELEASE RELWITHDEBINFO SIZEREL)
 155         set( CMAKE_C_FLAGS_${_BT} "${CMAKE_C_FLAGS_${_BT}} ${CMAKE_C_FLAGS}" )
 156         set( CMAKE_CXX_FLAGS_${_BT} "${CMAKE_C_FLAGS_${_BT}} ${CMAKE_C_FLAGS}" )
 157 endforeach()
 158
 159 message(STATUS "${CMAKE_BUILD_TYPE}: ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
 160
 161 # Where to put executables and libraries in the build tree
 162 # Note: Executables and libraries might end end up in a configuration
 163 # subdirectory, e.g. run/Debug or run/Release. We try to set DATAFILE_DIR
 164 # to a corresponding value below.
 165 if(NOT ARCHIVE_OUTPUT_PATH)
 166         set(ARCHIVE_OUTPUT_PATH ${Wireshark_BINARY_DIR}/run CACHE INTERNAL
 167                    "Single output directory for building all archives.")
 168 endif()
 169 if(NOT EXECUTABLE_OUTPUT_PATH)
 170         set(EXECUTABLE_OUTPUT_PATH ${Wireshark_BINARY_DIR}/run CACHE INTERNAL
 171                    "Single output directory for building all executables.")
 172 endif()
 173 if(NOT LIBRARY_OUTPUT_PATH)
 174         set(LIBRARY_OUTPUT_PATH ${Wireshark_BINARY_DIR}/run CACHE INTERNAL
 175                    "Single output directory for building all libraries.")
 176 endif()
 177
 178 # Under linux the release mode (CMAKE_BUILD_TYPE=release) defines NDEBUG
 179 #Defines CMAKE_INSTALL_BINDIR, CMAKE_INSTALL_DATADIR, etc ...
 180 include(CMakeInstallDirs)
 181
 182 # Updated by make-version.pl
 183 set(GIT_REVISION 0)
 184 set(PROJECT_MAJOR_VERSION 2)
 185 set(PROJECT_MINOR_VERSION 1)
 186 set(PROJECT_PATCH_VERSION 0)
 187 set(PROJECT_BUILD_VERSION ${GIT_REVISION})
 188 set(PROJECT_VERSION_EXTENSION "$ENV{WIRESHARK_VERSION_EXTRA}")
 189 set(PROJECT_VERSION "${PROJECT_MAJOR_VERSION}.${PROJECT_MINOR_VERSION}.${PROJECT_PATCH_VERSION}${PROJECT_VERSION_EXTENSION}")
 190
 191 # Banner shown at top right of Qt welcome screen.
 192 if(DEFINED ENV{WIRESHARK_VERSION_FLAVOR})
 193         set(VERSION_FLAVOR "$ENV{WIRESHARK_VERSION_FLAVOR}")
 194 else()
 195         set(VERSION_FLAVOR "Development Build")
 196 endif()
 197
 198 # These are required in .rc files and manifests
 199 set(VERSION_MAJOR ${PROJECT_MAJOR_VERSION})
 200 set(VERSION_MINOR ${PROJECT_MINOR_VERSION})
 201 set(VERSION_MICRO ${PROJECT_PATCH_VERSION})
 202 set(VERSION_BUILD ${PROJECT_BUILD_VERSION})
 203 set(RC_VERSION ${PROJECT_MAJOR_VERSION},${PROJECT_MINOR_VERSION},${PROJECT_PATCH_VERSION},${PROJECT_BUILD_VERSION})
 204
 205 message(STATUS "V: ${PROJECT_VERSION}, MaV: ${PROJECT_MAJOR_VERSION}, MiV: ${PROJECT_MINOR_VERSION}, PL: ${PROJECT_PATCH_VERSION}, EV: ${PROJECT_VERSION_EXTENSION}.")
 206
 207 include(UseLemon)
 208 include(UseMakeDissectorReg)
 209 include(UseMakeTapReg)
 210 include(UseAsn2Wrs)
 211
 212 include_directories(
 213         ${CMAKE_BINARY_DIR}
 214         ${CMAKE_SOURCE_DIR}
 215         ${CMAKE_SOURCE_DIR}/epan
 216         ${CMAKE_SOURCE_DIR}/tools/lemon
 217         ${CMAKE_SOURCE_DIR}/wiretap
 218 )
 219
 220 include( CMakeOptions.txt )
 221 if( DUMPCAP_INSTALL_OPTION STREQUAL "suid" )
 222         set( DUMPCAP_SETUID "SETUID" )
 223 else()
 224         set( DUMPCAP_SETUID )
 225 endif()
 226 if( NOT CMAKE_SYSTEM_NAME STREQUAL "Linux" AND
 227         DUMPCAP_INSTALL_OPTION STREQUAL "capabilities" )
 228         message( WARNING "Capabilities are only supported on Linux" )
 229         set( DUMPCAP_INSTALL_OPTION )
 230 endif()
 231
 232 # Always enable -fPIE (or -fPIC). -pie is added below for non-MSVC.
 233 # Needed when either:
 234 # - Qt5_POSITION_INDEPENDENT_CODE is set and CMake < 2.8.11
 235 # - PIE is wanted (-pie) and you want to add -fPIC/-fPIE automatically.
 236 # This option only has an effect on CMake >= 2.8.9
 237 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 238
 239 if( CMAKE_C_COMPILER_ID MATCHES "MSVC")
 240         if (MSVC10)
 241                 set(MSC_VER_REQUIRED 1600)
 242         elseif(MSVC11)
 243                 set(MSC_VER_REQUIRED 1700)
 244         elseif(MSVC12)
 245                 set(MSC_VER_REQUIRED 1800)
 246         elseif(MSVC14)
 247                 set(MSC_VER_REQUIRED 1900)
 248         else()
 249                 message(FATAL_ERROR "You are using an unsupported version of MSVC")
 250         endif()
 251
 252         add_definitions(
 253                 /DWIN32_LEAN_AND_MEAN
 254                 "/DMSC_VER_REQUIRED=${MSC_VER_REQUIRED}"
 255                 /D_CRT_SECURE_NO_DEPRECATE
 256                 /D_CRT_NONSTDC_NO_DEPRECATE
 257                 # NOMINMAX keeps windows.h from defining "min" and "max" via windef.h.
 258                 # This avoids conflicts with the C++ standard library.
 259                 /DNOMINMAX
 260                 # -DPSAPI_VERSION=1                 Programs that must run on earlier versions of Windows as well as Windows 7 and later
 261                 #                                   versions should always call this function as GetProcessMemoryInfo. To ensure correct
 262                 #                                   resolution of symbols, add Psapi.lib to the TARGETLIBS macro and compile the program
 263                 #                                   with -DPSAPI_VERSION=1.To use run-time dynamic linking, load Psapi.dll.
 264                 #                                   http://msdn.microsoft.com/en-us/library/windows/desktop/ms683219(v=vs.85).aspx
 265                 # -DBUILD_WINDOWS                   Starting from VS2013, GetVersionEx is deprecated and we are recommended to use
 266                 #                                   VerifyVersionInfo instead
 267                 #                                   http://msdn.microsoft.com/en-us/library/windows/desktop/ms724429(v=vs.85).aspx
 268                 #                                   http://msdn.microsoft.com/en-us/library/windows/desktop/ms725491(v=vs.85).aspx
 269                 #                                   To continue to use GetVersionEx, we can define BUILD_WINDOWS
 270                 # -D_ALLOW_KEYWORD_MACROS           For VS2012 onwards the, C++ STL does not permit macro redefinitions of keywords
 271                 #                                   (see http://msdn.microsoft.com/en-us/library/bb531344(v=vs.110).aspx)
 272                 #                                   This definition prevents the complaint about the redefinition of inline by WinPCap
 273                 #                                   in pcap-stdinc.h when compiling CPP files, e.g. the Qt UI
 274                 /DPSAPI_VERSION=1
 275                 /DBUILD_WINDOWS
 276                 /D_ALLOW_KEYWORD_MACROS
 277         )
 278
 279         if(NOT "${WIRESHARK_TARGET_PLATFORM}" STREQUAL "win64")
 280                 add_definitions("/D_BIND_TO_CURRENT_CRT_VERSION=1")
 281         endif()
 282
 283         # FIXME: WINPCAP_VERSION cannot be determined from source or executable.
 284         set(WINPCAP_VERSION "unknown")
 285         add_definitions("/DWINPCAP_VERSION=${WINPCAP_VERSION}")
 286
 287         set(LOCAL_CFLAGS
 288                 /MP
 289         )
 290
 291         if(MSVC12)
 292                 # /Zo                               Enhanced debugging of optimised code for VS2013 Update 3 and beyond,
 293                 #                                   Assume all VS2013 builds are at least Update 3.
 294                 #                                   See http://msdn.microsoft.com/en-us/library/dn785163.aspx
 295                 set(LOCAL_CFLAGS ${LOCAL_CFLAGS} "/Zo")
 296         elseif(MSVC14)
 297                 # /Zo                               Enhanced debugging of optimised code
 298                 #                                   VS2015(MSVC14): On by default when /Zi or /Z7 used.
 299                 set(LOCAL_CFLAGS ${LOCAL_CFLAGS} "/Zo")
 300         endif()
 301
 302         if(ENABLE_CODE_ANALYSIS)
 303                 set(LOCAL_CFLAGS ${LOCAL_CFLAGS} "/analyze:WX-")
 304         endif()
 305
 306         # Additional compiler warnings to be treated as "Level 3"
 307         #  when compiling Wireshark sources. (Selected from "level 4" warnings).
 308         ## 4295: array is too small to include a terminating null character
 309         ## 4189: local variable is initialized but not referenced
 310         set(WARNINGS_CFLAGS "/w34295 /w34189")
 311
 312         set(WIRESHARK_COMMON_FLAGS
 313                 ${LOCAL_CFLAGS}
 314                 ${WARNINGS_CFLAGS}
 315         )
 316
 317         # Set in Makefile.nmake
 318         set(WS_LINK_FLAGS "/LARGEADDRESSAWARE /MANIFEST:NO /INCREMENTAL:NO /RELEASE")
 319
 320 else()
 321         if(CMAKE_OSX_DEPLOYMENT_TARGET)
 322                 if(APPLE)
 323                         if(${CMAKE_OSX_DEPLOYMENT_TARGET} STREQUAL "10.0")
 324                                 message(FATAL_ERROR "We don't support building for OS X 10.0")
 325                         elseif(${CMAKE_OSX_DEPLOYMENT_TARGET} STREQUAL "10.1")
 326                                 message(FATAL_ERROR "We don't support building for OS X 10.1")
 327                         elseif(${CMAKE_OSX_DEPLOYMENT_TARGET} STREQUAL "10.2")
 328                                 message(FATAL_ERROR "We don't support building for OS X 10.2")
 329                         elseif(${CMAKE_OSX_DEPLOYMENT_TARGET} STREQUAL "10.4" OR ${CMAKE_OSX_DEPLOYMENT_TARGET} STREQUAL "10.5")
 330                                 #
 331                                 # Only 32-bit builds are supported.  10.5
 332                                 # (and 10.4?) had a bug that causes some BPF
 333                                 # functions not to work with 64-bit userland
 334                                 # code, so capturing won't work.
 335                                 #
 336                                 set(CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
 337                                 set(CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
 338                                 set(WS_LINK_FLAGS "-m32 ${WS_LINK_FLAGS}")
 339                         endif()
 340                         message(STATUS "Building for OS X ${CMAKE_OSX_DEPLOYMENT_TARGET}")
 341                 else()
 342                         message(FATAL_ERROR "CMAKE_OSX_DEPLOYMENT_TARGET only applies when building for OS X")
 343                 endif()
 344         endif()
 345
 346         set(WIRESHARK_COMMON_FLAGS
 347                 # The following are for C and C++
 348                 # -O<X> and -g get set by the CMAKE_BUILD_TYPE
 349                 -Wall
 350                 -W
 351                 -Wextra
 352                 -Wendif-labels
 353                 -Wpointer-arith
 354                 -Warray-bounds
 355                 -Wformat-security
 356                 -fwrapv
 357                 -fno-strict-overflow
 358                 -fno-delete-null-pointer-checks
 359                 -Wvla
 360                 -Waddress
 361                 -Wattributes
 362                 -Wdiv-by-zero
 363                 -Wignored-qualifiers
 364                 -Wpragmas
 365                 -Wno-overlength-strings
 366                 -Wwrite-strings
 367                 -Wno-long-long
 368                 -Wheader-guard
 369                 -Wunused-const-variable
 370         )
 371
 372         set(WIRESHARK_C_ONLY_FLAGS
 373                 # The following are C only, not C++
 374                 -Wc++-compat
 375                 -Wdeclaration-after-statement
 376                 -Wshadow
 377                 -Wno-pointer-sign
 378                 -Wold-style-definition
 379                 -Wstrict-prototypes
 380                 -Wlogical-op
 381                 -Wjump-misses-init
 382                 # The Qt headers generate a ton of shortening errors on 64-bit systems
 383                 # so only enable this for C for now.
 384                 -Wshorten-64-to-32
 385         )
 386
 387         set(WIRESHARK_CPP_ONLY_FLAGS
 388         )
 389
 390         set(WIRESHARK_EXTRA_COMPILER_COMMON_FLAGS
 391                 # The following are for C and C++
 392                 -Wpedantic
 393                 -Wno-variadic-macros
 394                 #
 395                 # Various code blocks this one.
 396                 #
 397                 -Woverflow
 398                 -fstrict-overflow -Wstrict-overflow=4
 399                 #
 400                 # Due to various places where APIs we don't control
 401                 # require us to cast away constness, we can probably
 402                 # never enable this one with -Werror.
 403                 #
 404                 -Wcast-qual
 405                 #
 406                 # Some generated ASN.1 dissectors block this one;
 407                 # multiple function declarations for the same
 408                 # function are being generated.
 409                 #
 410                 -Wredundant-decls
 411                 #
 412                 # Some loops are safe, but it's hard to convince the
 413                 # compiler of that.
 414                 #
 415                 -Wunsafe-loop-optimizations
 416                 #
 417                 # All the registration functions block these for now.
 418                 #
 419                 -Wmissing-prototypes
 420                 -Wmissing-declarations
 421                 #
 422                 # A bunch of "that might not work on SPARC" code blocks
 423                 # this one for now.
 424                 #
 425                 -Wcast-align
 426                 #
 427                 # Works only with Clang
 428                 #
 429                 -Wunreachable-code
 430                 #
 431                 # Works only with Clang but generates a lot of warnings
 432                 # (about glib library not using Doxygen)
 433                 #
 434                 -Wdocumentation
 435         )
 436
 437         set(WIRESHARK_EXTRA_COMPILER_C_ONLY_FLAGS
 438                 # The following are C only, not C++
 439                 #
 440                 # Due to various places where APIs we don't control
 441                 # require us to cast away constness, we can probably
 442                 # never enable this one with -Werror.
 443                 #
 444                 -Wbad-function-cast
 445         )
 446
 447         set(WIRESHARK_EXTRA_COMPILER_CPP_ONLY_FLAGS
 448         )
 449
 450         if(CMAKE_C_COMPILER_ID MATCHES "Clang")
 451                 set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS}
 452                         # avoid "argument unused during compilation" warnings
 453                         # (for example, when getting the -gsplit-dwarf option or
 454                         # when combining -fwrapv with -fno-strict-overflow)
 455                         -Qunused-arguments
 456                 )
 457
 458                 set(WIRESHARK_CPP_ONLY_FLAGS ${WIRESHARK_CPP_ONLY_FLAGS}
 459                 )
 460         else()
 461                 set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS}
 462                         -fexcess-precision=fast
 463                 )
 464
 465                 set(WIRESHARK_C_ONLY_FLAGS ${WIRESHARK_C_ONLY_FLAGS}
 466                 )
 467         endif()
 468
 469         set(WIRESHARK_ASAN_FLAGS
 470                 # With Clang >= 3.5 Leak detection is enable by default
 471                 # and no yet all leak is fixed...
 472                 # use ASAN_OPTIONS=detect_leaks=0 to disable detect_leaks
 473                 -fsanitize=address
 474                 -fsanitize=undefined # compile and runtime checks
 475                 # -fsanitize=float-divide-by-zero
 476                 # -fsanitize=float-cast-overflow
 477                 # -fno-sanitize-recover # Abort during runtime
 478         )
 479
 480         if(ENABLE_ASAN)
 481                 set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_ASAN_FLAGS})
 482         endif()
 483
 484         if(ENABLE_EXTRA_COMPILER_WARNINGS)   # This overrides -Werror
 485                 set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_EXTRA_COMPILER_COMMON_FLAGS})
 486                 set(WIRESHARK_C_ONLY_FLAGS ${WIRESHARK_C_ONLY_FLAGS} ${WIRESHARK_EXTRA_COMPILER_C_ONLY_FLAGS})
 487                 set(WIRESHARK_CPP_ONLY_FLAGS ${WIRESHARK_CPP_ONLY_FLAGS} ${WIRESHARK_EXTRA_COMPILER_CPP_ONLY_FLAGS})
 488         endif()
 489
 490         add_definitions(
 491                 -DG_DISABLE_DEPRECATED
 492                 -DG_DISABLE_SINGLE_INCLUDES
 493         )
 494 endif()
 495
 496 set( C_FLAG_TESTS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_C_ONLY_FLAGS} )
 497 set( CPP_FLAG_TESTS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_CPP_ONLY_FLAGS} )
 498
 499 # Counterhack to work around some cache magic in CHECK_C_SOURCE_COMPILES
 500 include(CheckCCompilerFlag)
 501 include(CheckCXXCompilerFlag)
 502
 503 if(ENABLE_STATIC)
 504         set(BUILD_SHARED_LIBS 0)
 505         set(LINK_MODE_LIB STATIC)
 506         set(LINK_MODE_MODULE STATIC)
 507 else()
 508         set(BUILD_SHARED_LIBS 1)
 509         set(LINK_MODE_LIB SHARED)
 510         set(LINK_MODE_MODULE MODULE)
 511 endif()
 512
 513 # Sigh: Have to use THIS_FLAG instead of ${F} for some reason
 514 foreach(THIS_FLAG ${C_FLAG_TESTS})
 515         string( REGEX REPLACE "[^a-zA-Z0-9_]+" "_" F ${THIS_FLAG} )
 516         set(${F} ${THIS_FLAG})
 517         set(V C_${F}_VALID)
 518         message(STATUS "Checking for c-compiler flag: ${THIS_FLAG}")
 519         check_c_compiler_flag("${ADDED_CMAKE_C_FLAGS} ${${F}}" ${V})
 520         if (${${V}})
 521                 set(ADDED_CMAKE_C_FLAGS "${ADDED_CMAKE_C_FLAGS} ${${F}}")
 522         endif()
 523 endforeach()
 524 set(CMAKE_C_FLAGS "${ADDED_CMAKE_C_FLAGS} ${CMAKE_C_FLAGS}")
 525
 526 foreach(THIS_FLAG ${CPP_FLAG_TESTS})
 527         string( REGEX REPLACE "[^a-zA-Z0-9_]+" "_" F ${THIS_FLAG} )
 528         set(${F} ${THIS_FLAG})
 529         set(V CPP_${F}_VALID)
 530         message(STATUS "Checking for c++-compiler flag: ${THIS_FLAG}")
 531         check_cxx_compiler_flag("${ADDED_CMAKE_CXX_FLAGS} ${${F}}" ${V})
 532         if (${${V}})
 533                 set(ADDED_CMAKE_CXX_FLAGS "${ADDED_CMAKE_CXX_FLAGS} ${${F}}")
 534         endif()
 535 endforeach()
 536 set(CMAKE_CXX_FLAGS "${ADDED_CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS}")
 537
 538 if(NOT DISABLE_WERROR AND NOT ENABLE_EXTRA_COMPILER_WARNINGS)
 539         if(CMAKE_C_COMPILER_ID MATCHES "MSVC")
 540                 set(WERROR_COMMON_FLAGS "/WX")
 541                 set(NO_ERROR_DEPRECATED_DECLARATIONS_COMPILE_FLAGS)
 542         else()
 543                 check_c_compiler_flag(-Werror WERROR)
 544                 if (WERROR)
 545                         set(WERROR_COMMON_FLAGS "-Werror")
 546                         set(NO_ERROR_DEPRECATED_DECLARATIONS_COMPILE_FLAGS "-Wno-error=deprecated-declarations")
 547                 endif()
 548         endif()
 549 else()
 550         set(WERROR_COMMON_FLAGS FALSE)
 551 endif()
 552
 553 #
 554 # Try to have the compiler default to hiding symbols, so that only
 555 # symbols explicitly exported with WS_DLL_PUBLIC will be visible
 556 # outside (shared) libraries; that way, more UN*X builds will catch
 557 # failures to export symbols, rather than having that fail only on
 558 # Windows.
 559 #
 560 # We don't need that with MSVC, as that's the default.
 561 #
 562 if( NOT CMAKE_C_COMPILER_ID MATCHES "MSVC")
 563         #
 564         # Try the GCC-and-copatible -fvisibility-hidden first.
 565         #
 566         check_c_compiler_flag(-fvisibility=hidden FVHIDDEN)
 567         if(FVHIDDEN)
 568                 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
 569         else()
 570                 #
 571                 # OK, try the Sun^WOracle C -xldscope=hidden
 572                 #
 573                 check_c_compiler_flag(-xldscope=hidden XLDSCOPEHIDDEN)
 574                 if(XLDSCOPEHIDDEN)
 575                         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -xldscope=hidden")
 576                 else()
 577                         #
 578                         # Anything else?
 579                         # If there is anything else, we might want to
 580                         # make a list of options to try, and try them
 581                         # in a loop.
 582                         #
 583                         message(WARNING "Hiding shared library symbols is not supported by the compiler."
 584                                 " All shared library symbols will be exported.")
 585                 endif()
 586         endif()
 587 endif()
 588
 589 if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang")
 590         set (C_UNUSED "__attribute__((unused))" )
 591 else()
 592         set (C_UNUSED "" )
 593 endif()
 594
 595
 596 if(NOT CMAKE_C_COMPILER_ID MATCHES "MSVC")
 597         set(WIRESHARK_LD_FLAGS
 598                 -Wl,--as-needed
 599                 # -flto
 600                 # -fwhopr
 601                 # -fwhole-program
 602         )
 603         # CMAKE_POSITION_INDEPENDENT_CODE is only supported starting with CMake
 604         # 2.8.9. Do not add -pie automatically for older versions.
 605         if(NOT CMAKE_VERSION VERSION_LESS "2.8.9")
 606                 set(WIRESHARK_LD_FLAGS ${WIRESHARK_LD_FLAGS}
 607                         -pie
 608                 )
 609         endif()
 610 endif()
 611
 612 include(CheckCLinkerFlag)
 613 set(_C 0)
 614 # Sigh: Have to use THIS_FLAG instead of ${F} for some reason
 615 foreach(THIS_FLAG ${WIRESHARK_LD_FLAGS})
 616         set(F WS_LD_FLAG_${_C})
 617         set(${F} ${THIS_FLAG})
 618         set(V WS_LD_FLAG_VALID${_C})
 619         check_c_linker_flag(${${F}} ${V})
 620         if (${${V}})
 621                 set(WS_LINK_FLAGS "${WS_LINK_FLAGS} ${${F}}")
 622         endif()
 623         math(EXPR _C "${_C} + 1")
 624 endforeach()
 625
 626 if(APPLE AND EXISTS /usr/local/opt/gettext)
 627         # GLib on OS X requires libintl. Homebrew installs gettext (and
 628         # libintl) in /usr/local/opt/gettext
 629         include_directories(/usr/local/opt/gettext/include)
 630         link_directories(/usr/local/opt/gettext/lib)
 631 endif()
 632
 633 # The packagelist is doing some magic:  If we add XXX to the packagelist, we
 634 # - may optionally set XXX_OPTIONS to pass to the find_package command
 635 # - will call FindXXX.cmake
 636 # - return found libraries in XXX_LIBRARIES
 637 # - return found include in XXX_INCLUDE_DIRS
 638 # - set HAVE_XXX
 639
 640 #The minimum package list
 641 set(PACKAGELIST Gettext M GLIB2 GMODULE2 GTHREAD2 LEX YACC Perl SED SH PythonInterp)
 642 set(LEX_REQUIRED TRUE)
 643 set(GLIB2_REQUIRED TRUE)
 644 set(GLIB2_FIND_REQUIRED TRUE)
 645 set(GLIB2_MIN_VERSION 2.14.0)
 646 set(GTHREAD2_REQUIRED TRUE)
 647 set(PythonInterp_FIND_VERSION 2)
 648 set(Python_ADDITIONAL_VERSIONS 3)
 649 set(YACC_REQUIRED TRUE)
 650
 651 if (NOT WIN32)
 652         set(M_REQUIRED TRUE)
 653 endif()
 654
 655 set(PACKAGELIST ${PACKAGELIST} HtmlViewer)
 656
 657 if(ENABLE_PCAP)
 658         set(PACKAGELIST ${PACKAGELIST} PCAP)
 659 endif()
 660
 661 if(ENABLE_AIRPCAP)
 662         set(PACKAGELIST ${PACKAGELIST} AIRPCAP)
 663 endif()
 664
 665 # Build the GTK-GUI?
 666 if(BUILD_wireshark_gtk)
 667         if(ENABLE_GTK3)
 668                 set(PACKAGELIST ${PACKAGELIST} GTK3)
 669         else()
 670                 set(PACKAGELIST ${PACKAGELIST} GTK2)
 671                 set(GTK2_OPTIONS COMPONENTS gtk)
 672                 set(GTK2_FIND_VERSION 2.12)
 673                 set(GTK2_DEBUG false)
 674         endif()
 675 endif()
 676
 677 # Build the Qt GUI?
 678 if(BUILD_wireshark)
 679         if(ENABLE_QT5)
 680                 # Untested, may not work if CMAKE_PREFIX_PATH gets overwritten
 681                 # somewhere. The if WIN32 in this place is annoying as well.
 682                 if( WIN32 )
 683                         set( QT5_BASE_PATH "$ENV{QT5_BASE_DIR}" )
 684                         set( CMAKE_PREFIX_PATH "${QT5_BASE_PATH}" )
 685                 endif()
 686                 set(PACKAGELIST ${PACKAGELIST}
 687                         Qt5Core
 688                         Qt5LinguistTools
 689                         Qt5Multimedia
 690                         Qt5PrintSupport
 691                         Qt5Widgets
 692                 )
 693                 if (APPLE)
 694                         set(PACKAGELIST ${PACKAGELIST} Qt5MacExtras)
 695                 endif()
 696                 if( WIN32 )
 697                         set(PACKAGELIST ${PACKAGELIST} Qt5WinExtras)
 698                 endif()
 699                 set(QT_VERSION 5)
 700         else()
 701                 set(PACKAGELIST ${PACKAGELIST} Qt4)
 702                 set(Qt4_OPTIONS 4.7.1 REQUIRED QtCore QtGui)
 703                 set(QT_VERSION 4)
 704         endif()
 705 endif()
 706
 707 # SMI SNMP
 708 if(ENABLE_SMI)
 709         set(PACKAGELIST ${PACKAGELIST} SMI)
 710 endif()
 711
 712 # GNU crypto
 713 if(ENABLE_GCRYPT)
 714         set(PACKAGELIST ${PACKAGELIST} GCRYPT)
 715         # Minimum version needed.
 716         set(GCRYPT_OPTIONS "1.4.2")
 717 endif()
 718
 719 # GNU SSL/TLS support
 720 if(ENABLE_GNUTLS)
 721         set(PACKAGELIST ${PACKAGELIST} GNUTLS)
 722         # Minimum version needed.
 723         set(GNUTLS_OPTIONS "2.12.0")
 724 endif()
 725
 726 # Kerberos
 727 if(ENABLE_KERBEROS)
 728         set(PACKAGELIST ${PACKAGELIST} KERBEROS)
 729 endif()
 730
 731 # Portable audio (GTK+ only)
 732 if(ENABLE_PORTAUDIO AND BUILD_wireshark_gtk)
 733         set(PACKAGELIST ${PACKAGELIST} PORTAUDIO)
 734 endif()
 735
 736
 737 # Prefer c-ares over adns
 738 if(ENABLE_CARES) # C Asynchronouse resolver
 739         set(PACKAGELIST ${PACKAGELIST} CARES)
 740 elseif(ENABLE_ADNS) # Gnu asynchronous DNS
 741         set(PACKAGELIST ${PACKAGELIST} ADNS)
 742 endif()
 743
 744 # Zlib compression
 745 if(ENABLE_ZLIB)
 746         if (WIN32)
 747                 # On Windows we build our own version of zlib, so add the paths
 748                 set(ZLIB_SRC_DIR "${_PROJECT_LIB_DIR}/zlib-1.2.8-ws")
 749                 add_subdirectory("${ZLIB_SRC_DIR}" "${CMAKE_BINARY_DIR}/zlib")
 750                 set(ZLIB_INCLUDE_DIR  "${ZLIB_SRC_DIR}" "${CMAKE_BINARY_DIR}/zlib")
 751                 set(ZLIB_LIBRARY zlib)
 752                 set(ZLIB_DLL "zlib1.dll")
 753                 set_target_properties(zlib PROPERTIES FOLDER "Libs/zlib")
 754                 # Annoyingly zlib also builds some other stuff we aren't interested in
 755                 set_target_properties(zlibstatic PROPERTIES FOLDER "Libs/zlib")
 756         endif()
 757         set(PACKAGELIST ${PACKAGELIST} ZLIB)
 758 endif()
 759
 760 # Embedded Lua interpreter
 761 if(ENABLE_LUA)
 762         set(PACKAGELIST ${PACKAGELIST} LUA)
 763 endif()
 764
 765 # GeoIP address resolving
 766 if(ENABLE_GEOIP)
 767         set(PACKAGELIST ${PACKAGELIST} GEOIP)
 768 endif()
 769
 770 if(ENABLE_NETLINK)
 771         set(PACKAGELIST ${PACKAGELIST} NL)
 772 endif()
 773
 774 if(ENABLE_SBC)
 775         set(PACKAGELIST ${PACKAGELIST} SBC)
 776 endif()
 777
 778 # Capabilities
 779 if(ENABLE_CAP)
 780         set(PACKAGELIST ${PACKAGELIST} CAP SETCAP)
 781 endif()
 782
 783 # Windows version updates
 784 if(ENABLE_WINSPARKLE)
 785         set(PACKAGELIST ${PACKAGELIST} WINSPARKLE)
 786 endif()
 787
 788 set(PACKAGELIST ${PACKAGELIST} YAPP)
 789
 790 set(PACKAGELIST ${PACKAGELIST} POD)
 791
 792 if(ENABLE_HTML_GUIDES)
 793         set(PACKAGELIST ${PACKAGELIST} DOXYGEN)
 794 endif()
 795
 796 set(PROGLIST)
 797
 798 # Sort the package list
 799 list(SORT PACKAGELIST)
 800 message(STATUS "Packagelist: ${PACKAGELIST}")
 801 # Let's loop the package list
 802 foreach(PACKAGE ${PACKAGELIST})
 803         if(${PACKAGE} STREQUAL "Qt4")
 804                 set(PACKAGE_VAR "QT")
 805         elseif(${PACKAGE} STREQUAL "PythonInterp")
 806                 set(PACKAGE_VAR "PYTHONINTERP")
 807         elseif(${PACKAGE} STREQUAL "Gettext")
 808                 set(PACKAGE_VAR "GETTEXT")
 809         elseif(${PACKAGE} STREQUAL "HtmlViewer")
 810                 set(PACKAGE_VAR "HTML_VIEWER")
 811         elseif(${PACKAGE} STREQUAL "Perl")
 812                 set(PACKAGE_VAR "PERL")
 813         else()
 814                 set(PACKAGE_VAR ${PACKAGE})
 815         endif()
 816         if(${PACKAGE}_OPTIONS)
 817                 find_package(${PACKAGE} ${${PACKAGE}_OPTIONS})
 818         elseif(${PACKAGE}_REQUIRED)
 819                 find_package(${PACKAGE} REQUIRED)
 820         else()
 821                 find_package(${PACKAGE})
 822         endif()
 823         if (${PACKAGE_VAR}_FOUND)
 824                 message(STATUS "${PACKAGE_VAR} FOUND")
 825                 set(HAVE_LIB${PACKAGE_VAR} 1)
 826                 include_directories(SYSTEM ${${PACKAGE_VAR}_INCLUDE_DIRS})
 827                 set(WS_ALL_LIBS ${WS_ALL_LIBS} ${${PACKAGE_VAR}_LIBRARIES})
 828                 message(STATUS "${PACKAGE} includes: ${${PACKAGE_VAR}_INCLUDE_DIRS}")
 829                 message(STATUS "${PACKAGE} libs: ${${PACKAGE_VAR}_LIBRARIES}")
 830                 if (${PACKAGE}_DEFINITIONS)
 831                         message(STATUS "${PACKAGE} definitions: ${${PACKAGE_VAR}_DEFINITIONS}")
 832                 endif()
 833                 if (${PACKAGE_VAR}_EXECUTABLE)
 834                         message(STATUS "${PACKAGE} executable: ${${PACKAGE_VAR}_EXECUTABLE}")
 835                 endif()
 836         else()
 837                 #
 838                 # Not finding a package is only a fatal error if the
 839                 # package is required; if it's required, then its
 840                 # XXX_REQUIRED variable is set to TRUE, and the above
 841                 # code will pass REQUIRED to find_package, and the
 842                 # configure will fail if the package isn't found.
 843                 #
 844                 # Do *NOT* report this as an error!
 845                 #
 846                 message(STATUS "${PACKAGE_VAR} NOT FOUND")
 847         endif()
 848 endforeach()
 849
 850 # Provide Windows system lib names
 851 include( UseWinLibs )
 852
 853 #packaging
 854 include(CPackConfig.txt)
 855
 856 if(HAVE_LIBAIRPCAP)
 857         set(HAVE_AIRPCAP 1)
 858 endif()
 859 if(HAVE_LIBLUA)
 860         set(HAVE_LUA_H 1)
 861         set(HAVE_LUA 1)
 862 endif()
 863 if(HAVE_LIBKERBEROS)
 864         set(HAVE_KERBEROS 1)
 865 endif()
 866 if(HAVE_LIBGEOIP)
 867         set(HAVE_GEOIP 1)
 868 endif()
 869 if(HAVE_LIBCARES)
 870         set(HAVE_C_ARES 1)
 871 endif()
 872 if(HAVE_LIBADNS)
 873         set(HAVE_GNU_ADNS 1)
 874 endif()
 875 if(HAVE_LIBNL AND HAVE_AIRPCAP)
 876         message(ERROR "Airpcap and Libnl support are mutually exclusive")
 877 endif()
 878 if(HAVE_LIBSBC)
 879         set(HAVE_SBC 1)
 880 endif()
 881 if(EXTCAP_ANDROIDDUMP_LIBPCAP)
 882         set(ANDROIDDUMP_USE_LIBPCAP 1)
 883 endif()
 884
 885 if (HAVE_LIBWINSPARKLE)
 886         set(HAVE_SOFTWARE_UPDATE 1)
 887 endif()
 888
 889 # No matter which version of GTK is present
 890 if(GTK2_FOUND OR GTK3_FOUND)
 891         set(GTK_FOUND ON)
 892 endif()
 893 # That's the name autofoo uses
 894 if(HAVE_LIBZLIB)
 895         set(HAVE_LIBZ 1)
 896         # Always include the "true" zlib includes first. This works around a
 897         # bug in the Windows setup of GTK[23] which has a faulty zconf.h.
 898         include_directories(BEFORE ${ZLIB_INCLUDE_DIRS})
 899 endif()
 900 if (Qt5Widgets_FOUND)
 901         #
 902         # Qt5CoreConfigExtras.cmake in Qt 5.5.0 sets -fPIC unconditionally.
 903         # https://bugreports.qt.io/browse/QTBUG-47942
 904         #
 905         # If it was added, we remove it, and then check whether it's
 906         # necessary the same way we do for autotools, by checking
 907         # whether we can compile and link a simple file with just
 908         #
 909         #       #include <QtCore>
 910         #       int main() {}
 911         #
 912         # (Yes, check_XXX_source_compiles() should be renamed
 913         # check_XXX_source_compiles_and_links().)
 914         #
 915         if ("${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}" MATCHES ".*-fPIC.*")
 916                 list(REMOVE_ITEM Qt5Widgets_EXECUTABLE_COMPILE_FLAGS "-fPIC")
 917                 set(CMAKE_REQUIRED_FLAGS ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS})
 918                 set(CMAKE_REQUIRED_INCLUDES ${Qt5Core_INCLUDE_DIRS})
 919                 set(CMAKE_REQUIRED_LIBS ${Qt5Core_LIBRARIES})
 920                 check_cxx_source_compiles(
 921                       "#include <QtCore>
 922                       int main() {}"
 923                     WORKS_WITHOUT_FPIC)
 924                 if (NOT WORKS_WITHOUT_FPIC)
 925                         #
 926                         # OK, it won't compile without -fPIC.  Try adding it.
 927                         #
 928                         set(CMAKE_REQUIRED_FLAGS "-fPIC")
 929                         check_cxx_source_compiles(
 930                               "#include <QtCore>
 931                               int main() {}"
 932                             WORKS_WITH_FPIC)
 933                         if (NOT WORKS_WITH_FPIC)
 934                                 #
 935                                 # It won't build with -fPIC or without -fPIC,
 936                                 # so we're hosed.
 937                                 #
 938                                 message(FATAL_ERROR "Couldn't compile Qt without -fPIC nor with -fPIC")
 939                         endif()
 940
 941                         #
 942                         # It compiles with -fPIC, so add it back.
 943                         #
 944                         list(APPEND Qt5Widgets_EXECUTABLE_COMPILE_FLAGS "-fPIC")
 945                 endif()
 946                 set(CMAKE_REQUIRED_FLAGS "")
 947                 set(CMAKE_REQUIRED_INCLUDES "")
 948                 set(CMAKE_REQUIRED_LIBS "")
 949         endif()
 950         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")
 951         set (QT_FOUND ON)
 952         set (QT_LIBRARIES ${Qt5Widgets_LIBRARIES} ${Qt5PrintSupport_LIBRARIES})
 953         if(Qt5Multimedia_FOUND)
 954                 set (QT_LIBRARIES ${QT_LIBRARIES} ${Qt5Multimedia_LIBRARIES})
 955                 # That's the name autofoo uses
 956                 set(QT_MULTIMEDIA_LIB 1)
 957         endif()
 958         if(Qt5MacExtras_FOUND)
 959                 set (QT_LIBRARIES ${QT_LIBRARIES} ${Qt5MacExtras_LIBRARIES})
 960                 # That's the name autofoo uses
 961                 set(QT_MACEXTRAS_LIB 1)
 962         endif()
 963         if(Qt5WinExtras_FOUND)
 964                 set (QT_LIBRARIES ${QT_LIBRARIES} ${Qt5WinExtras_LIBRARIES})
 965                 # set(QT_WINEXTRAS_LIB 1) # Not needed?
 966         endif()
 967 # If Qt4: QT_LIBRARIES and QT_INCLUDES are not set above. They require extra magic
 968 elseif(QT_FOUND)
 969         include(${QT_USE_FILE})
 970         include_directories(${QT_INCLUDE_DIR})
 971         message(STATUS "Qt includes: ${QT_INCLUDE_DIR}")
 972         message(STATUS "Qt libs: ${QT_LIBRARIES}")
 973         if(QT_QTMULTIMEDIA_FOUND)
 974                 include_directories(${QT_QTMULTIMEDIA_INCLUDE_DIR})
 975                 message(STATUS "QtMultimedia includes: ${QT_INCLUDE_DIR}")
 976                 set (QT_LIBRARIES ${QT_LIBRARIES} ${QT_QTMULTIMEDIA_LIBRARY})
 977                 message(STATUS "QtMultimedia libs: ${QT_QTMULTIMEDIA_LIBRARY}")
 978                 # That's the name autofoo uses
 979                 set(QT_MULTIMEDIA_LIB 1)
 980         endif()
 981 endif()
 982
 983 message(STATUS "C-Flags: ${CMAKE_C_FLAGS}")
 984 message(STATUS "CXX-Flags: ${CMAKE_CXX_FLAGS}")
 985 message(STATUS "Warnings as errors: ${WERROR_COMMON_FLAGS}")
 986
 987 if(APPLE)
 988         #
 989         # We assume that APPLE means OS X so that we have the OS X
 990         # frameworks.
 991         #
 992         set(HAVE_OS_X_FRAMEWORKS 1)
 993         FIND_LIBRARY (APPLE_APPLICATION_SERVICES_LIBRARY ApplicationServices)
 994         FIND_LIBRARY (APPLE_CORE_FOUNDATION_LIBRARY CoreFoundation)
 995         FIND_LIBRARY (APPLE_SYSTEM_CONFIGURATION_LIBRARY SystemConfiguration)
 996 endif()
 997
 998 include(ConfigureChecks.cmake)
 999
1000 #Big or little endian ?
1001 include(TestBigEndian)
1002 test_big_endian(WORDS_BIGENDIAN)
1003
1004 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
1005
1006 add_subdirectory( asn1 EXCLUDE_FROM_ALL )
1007 add_subdirectory( capchild )
1008 add_subdirectory( caputils )
1009 add_subdirectory( codecs )
1010 add_subdirectory( docbook )
1011 add_subdirectory( epan )
1012 add_subdirectory( tools/lemon )
1013 add_subdirectory( ui )
1014 add_subdirectory( wiretap )
1015 add_subdirectory( wsutil )
1016
1017 if(NOT WIN32)
1018         add_custom_target(dumpabi DEPENDS dumpabi-libwireshark dumpabi-libwiretap dumpabi-libwsutil color.h)
1019 endif()
1020
1021 if(ENABLE_ECHLD)
1022         add_subdirectory( echld )
1023 endif()
1024
1025 if(BUILD_wireshark_gtk AND GTK_FOUND)
1026         add_subdirectory( ui/gtk )
1027 endif()
1028
1029 if(BUILD_wireshark AND QT_FOUND)
1030         add_subdirectory( ui/qt )
1031 endif()
1032
1033 # Location of our data files. This should be set to a value that allows
1034 # running from the build directory on Windows, on OS X when building an
1035 # application bundle, and on UNIX if WIRESHARK_RUN_FROM_BUILD_DIRECTORY
1036 # is set.
1037 if(ENABLE_APPLICATION_BUNDLE)
1038         set(_datafile_dir "${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/Resources/share/wireshark")
1039 else()
1040         get_target_property(_libwireshark_location epan LOCATION)
1041         get_filename_component(_datafile_dir "${_libwireshark_location}" PATH)
1042 endif()
1043 set (DATAFILE_DIR ${_datafile_dir} CACHE INTERNAL "Build time data file location.")
1044
1045 if(IS_ABSOLUTE ${CMAKE_INSTALL_LIBDIR})
1046   set(ABSOLUTE_CMAKE_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
1047 else()
1048   set(ABSOLUTE_CMAKE_INSTALL_LIBDIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
1049 endif()
1050
1051 if(ENABLE_EXTCAP)
1052         set(HAVE_EXTCAP 1)
1053         set(EXTCAP_DIR "${ABSOLUTE_CMAKE_INSTALL_LIBDIR}/${CPACK_PACKAGE_NAME}/extcap/")
1054 endif()
1055
1056 # Location of our plugins. PLUGIN_DIRECTORY should allow running
1057 # from the build directory similar to DATAFILE_DIR above.
1058 if(ENABLE_PLUGINS)
1059         set(HAVE_PLUGINS 1)
1060         add_custom_target(plugins)
1061         set_target_properties(plugins PROPERTIES FOLDER "Plugins")
1062         set(PLUGIN_INSTALL_DIR "${ABSOLUTE_CMAKE_INSTALL_LIBDIR}/${CPACK_PACKAGE_NAME}/plugins/${CPACK_PACKAGE_VERSION}")
1063         set(PLUGIN_SRC_DIRS
1064                 plugins/docsis
1065                 plugins/ethercat
1066                 plugins/gryphon
1067                 plugins/irda
1068                 plugins/m2m
1069                 plugins/mate
1070                 plugins/opcua
1071                 plugins/profinet
1072                 plugins/stats_tree
1073                 plugins/unistim
1074                 plugins/wimax
1075                 plugins/wimaxasncp
1076                 plugins/wimaxmacphy
1077                 ${CUSTOM_PLUGIN_SRC_DIR}
1078         )
1079 # It seems this stuff doesn't build with autofoo either...
1080 #       if(YAPP_FOUND)
1081 #               set(PLUGIN_SRC_DIRS
1082 #                       ${PLUGIN_SRC_DIRS}
1083 #                       plugins/tpg
1084 #               )
1085 #       endif()
1086 else()
1087         set(PLUGIN_SRC_DIRS )
1088 endif()
1089
1090 if(ENABLE_APPLICATION_BUNDLE)
1091         set(_plugin_dir "${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/PlugIns/wireshark")
1092 else()
1093         get_target_property(_libwireshark_location epan LOCATION)
1094         get_filename_component(_plugin_dir "${_libwireshark_location}" PATH)
1095         set(_plugin_dir "${_plugin_dir}/plugins")
1096 endif()
1097 # XXX The NMake environment appends the version. Should we do so here?
1098 set (PLUGIN_DIR ${_plugin_dir} CACHE INTERNAL "Build time plugin location.")
1099
1100 foreach(_plugin_src_dir ${PLUGIN_SRC_DIRS})
1101         add_subdirectory( ${_plugin_src_dir} )
1102 endforeach()
1103
1104
1105 # Basedir where to install guides
1106 set(DOC_DIR "$ENV{docdir}" CACHE FILEPATH "Installation directory for ug and dg pdfs.")
1107 message(STATUS "docdir: ${DOC_DIR}")
1108
1109 if(ENABLE_PCAP_NG_DEFAULT)
1110         set(PCAP_NG_DEFAULT 1)
1111 endif()
1112
1113 # Large file support (e.g. make off_t 64 bit if supported)
1114 include(gmxTestLargeFiles)
1115 gmx_test_large_files(GMX_LARGEFILES)
1116
1117 add_definitions( -DTOP_SRCDIR=\"${CMAKE_SOURCE_DIR}\" )
1118
1119 if(WIN32)
1120         set(WS_MSVC_NORETURN "__declspec(noreturn)")
1121
1122         # Disable deprecation
1123         if(MSVC80 OR MSVC90)
1124                 add_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
1125         endif()
1126 else()
1127         set(WS_MSVC_NORETURN " ")
1128 endif()
1129
1130 set( VERSION ${PROJECT_VERSION} )
1131 execute_process(
1132         COMMAND ${PERL_EXECUTABLE}
1133                 ${CMAKE_CURRENT_SOURCE_DIR}/make-version.pl
1134                 --print-vcs
1135                 ${CMAKE_CURRENT_SOURCE_DIR}
1136         OUTPUT_VARIABLE VERSION_H_CONTENT
1137 )
1138 set( configure_input "Built with CMake ${CMAKE_VERSION}" )
1139 configure_file(${CMAKE_SOURCE_DIR}/cmakeconfig.h.in ${CMAKE_BINARY_DIR}/config.h)
1140 configure_file(${CMAKE_SOURCE_DIR}/version.h.in ${CMAKE_BINARY_DIR}/version.h)
1141 #set_target_properties(${CMAKE_BINARY_DIR}/version.h PROPERTIES FOLDER "Auxiliary")
1142
1143 set(ICON_PATH "${CMAKE_SOURCE_DIR}/image/")
1144 set( IN_FILES
1145         adns_dll.rc
1146         capchild/doxygen.cfg.in
1147         caputils/doxygen.cfg.in
1148         doxygen.cfg.in
1149         doxygen_global.cfg
1150         epan/doxygen.cfg.in
1151         image/libwireshark.rc.in
1152         image/text2pcap.rc.in
1153         image/capinfos.rc.in
1154         image/wireshark.rc.in
1155         image/mergecap.rc.in
1156         image/tshark.rc.in
1157         image/dumpcap.rc.in
1158         image/reordercap.rc.in
1159         image/rawshark.rc.in
1160         image/file_dlg_win32.rc
1161         image/tfshark.rc.in
1162         image/editcap.rc.in
1163         image/captype.rc.in
1164         image/libwsutil.rc.in
1165         image/wiretap.rc.in
1166         image/wireshark.exe.manifest.in
1167         packaging/macosx/Info.plist.in
1168         packaging/macosx/osx-dmg.sh.in
1169         packaging/macosx/Wireshark_package.pmdoc/index.xml.in
1170         ${CUSTOM_PLUGIN_IN_FILES}
1171         ui/doxygen.cfg.in
1172         ui/gtk/doxygen.cfg.in
1173         ui/qt/doxygen.cfg.in
1174         wireshark.pc.in
1175 )
1176 foreach( _in_file ${IN_FILES} )
1177         get_filename_component( _path ${_in_file} PATH )
1178         string( REGEX REPLACE "(.*)\\.in" "\\1" _outfile ${_in_file}  )
1179         configure_file( ${CMAKE_SOURCE_DIR}/${_in_file} ${CMAKE_BINARY_DIR}/${_outfile} @ONLY )
1180 endforeach()
1181
1182 include(FeatureSummary)
1183 #SET_FEATURE_INFO(NAME DESCRIPTION [URL [COMMENT] ])
1184 SET_FEATURE_INFO(SBC "SBC Codec for Bluetooth A2DP stream playing" "www: http://git.kernel.org/cgit/bluetooth/sbc.git" )
1185
1186 FEATURE_SUMMARY(WHAT ALL)
1187
1188 link_directories(
1189         ${CMAKE_BINARY_DIR}/ui
1190         ${CMAKE_BINARY_DIR}/ui/gtk
1191         ${CMAKE_BINARY_DIR}/ui/qt
1192         ${CMAKE_BINARY_DIR}/capchild
1193         ${CMAKE_BINARY_DIR}/caputils
1194         ${CMAKE_BINARY_DIR}/codecs
1195         ${CMAKE_BINARY_DIR}/epan
1196         ${CMAKE_BINARY_DIR}/wiretap
1197         ${CMAKE_BINARY_DIR}/wsutil
1198 )
1199
1200 if(WIN32)
1201         set(PLATFORM_UI_SRC
1202                 ui/win32/console_win32.c
1203                 ui/win32/file_dlg_win32.c
1204                 ui/win32/print_win32.c
1205         )
1206         set(PLATFORM_UI_RC_FILES
1207                 image/file_dlg_win32.rc
1208         )
1209 endif()
1210
1211 # sources common for wireshark, tshark, and rawshark
1212 set(SHARK_COMMON_SRC
1213         cfile.c
1214         frame_tvbuff.c
1215         sync_pipe_write.c
1216 )
1217
1218 # sources for external capture interfaces
1219 if(ENABLE_EXTCAP)
1220         set(SHARK_COMMON_SRC
1221                 ${SHARK_COMMON_SRC}
1222                 extcap.c
1223                 extcap_parser.c
1224         )
1225 endif()
1226
1227 set(TSHARK_TAP_SRC
1228         ui/cli/tap-camelsrt.c
1229         ui/cli/tap-comparestat.c
1230         ui/cli/tap-diameter-avp.c
1231         ui/cli/tap-expert.c
1232         ui/cli/tap-endpoints.c
1233         ui/cli/tap-follow.c
1234         ui/cli/tap-funnel.c
1235         ui/cli/tap-gsm_astat.c
1236         ui/cli/tap-hosts.c
1237         ui/cli/tap-httpstat.c
1238         ui/cli/tap-icmpstat.c
1239         ui/cli/tap-icmpv6stat.c
1240         ui/cli/tap-iostat.c
1241         ui/cli/tap-iousers.c
1242         ui/cli/tap-macltestat.c
1243         ui/cli/tap-protocolinfo.c
1244         ui/cli/tap-protohierstat.c
1245         ui/cli/tap-rlcltestat.c
1246         ui/cli/tap-rpcprogs.c
1247         ui/cli/tap-rtd.c
1248         ui/cli/tap-rtp.c
1249         ui/cli/tap-rtspstat.c
1250         ui/cli/tap-sctpchunkstat.c
1251         ui/cli/tap-simple_stattable.c
1252         ui/cli/tap-sipstat.c
1253         ui/cli/tap-smbsids.c
1254         ui/cli/tap-srt.c
1255         ui/cli/tap-stats_tree.c
1256         ui/cli/tap-sv.c
1257         ui/cli/tap-wspstat.c
1258 )
1259
1260 set(INSTALL_DIRS
1261         diameter
1262         dtds
1263         help
1264         radius
1265         tpncp
1266         wimaxasncp
1267 )
1268
1269 set(INSTALL_FILES
1270         ${CMAKE_BINARY_DIR}/androiddump.html
1271         ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
1272         ${CMAKE_BINARY_DIR}/capinfos.html
1273         ${CMAKE_BINARY_DIR}/captype.html
1274         cfilters
1275         colorfilters
1276         dfilters
1277         ${CMAKE_BINARY_DIR}/dftest.html
1278         ${CMAKE_BINARY_DIR}/dumpcap.html
1279         ${CMAKE_BINARY_DIR}/editcap.html
1280         ${CMAKE_BINARY_DIR}/extcap.html
1281         ${CMAKE_BINARY_DIR}/asn2deb.html
1282         ${CMAKE_BINARY_DIR}/idl2deb.html
1283         ${CMAKE_BINARY_DIR}/idl2wrs.html
1284         ipmap.html
1285         manuf
1286         ${CMAKE_BINARY_DIR}/mergecap.html
1287         pdml2html.xsl
1288         ${CMAKE_BINARY_DIR}/randpkt.html
1289         ${CMAKE_BINARY_DIR}/rawshark.html
1290         ${CMAKE_BINARY_DIR}/reordercap.html
1291         services
1292         smi_modules
1293         ${CMAKE_BINARY_DIR}/text2pcap.html
1294         ${CMAKE_BINARY_DIR}/tshark.html
1295         ${CMAKE_BINARY_DIR}/wireshark-filter.html
1296         ${CMAKE_BINARY_DIR}/wireshark.html
1297         docbook/ws.css
1298 )
1299
1300 if(WIN32)
1301         set(TEXTIFY_FILES COPYING NEWS README README.windows)
1302         foreach(_text_file ${TEXTIFY_FILES})
1303                 set(INSTALL_FILES ${CMAKE_BINARY_DIR}/${_text_file}.txt ${INSTALL_FILES})
1304         endforeach()
1305 else()
1306         set(INSTALL_FILES COPYING ${INSTALL_FILES})
1307 endif()
1308
1309 set(MAN1_FILES
1310         ${CMAKE_BINARY_DIR}/androiddump.1
1311         ${CMAKE_BINARY_DIR}/capinfos.1
1312         ${CMAKE_BINARY_DIR}/captype.1
1313         ${CMAKE_BINARY_DIR}/dftest.1
1314         ${CMAKE_BINARY_DIR}/dumpcap.1
1315         ${CMAKE_BINARY_DIR}/editcap.1
1316         ${CMAKE_BINARY_DIR}/extcap.4
1317         ${CMAKE_BINARY_DIR}/idl2wrs.1
1318         ${CMAKE_BINARY_DIR}/mergecap.1
1319         ${CMAKE_BINARY_DIR}/randpkt.1
1320         ${CMAKE_BINARY_DIR}/rawshark.1
1321         ${CMAKE_BINARY_DIR}/reordercap.1
1322         ${CMAKE_BINARY_DIR}/text2pcap.1
1323         ${CMAKE_BINARY_DIR}/tshark.1
1324         ${CMAKE_BINARY_DIR}/wireshark.1
1325 )
1326
1327 set(MAN4_FILES
1328         ${CMAKE_BINARY_DIR}/wireshark-filter.4
1329 )
1330
1331 set(LIBEPAN_LIBS
1332 #               @NSL_LIBS@      # -lnsl
1333 #               @SOCKET_LIBS@   # -lsocket
1334 #               @SSL_LIBS@      # -lcrypto
1335                 epan
1336 #               $(plugin_ldadd) # in case of static
1337                 ${AIRPCAP_LIBRARIES}
1338                 ${PCAP_LIBRARIES}
1339                 ${CARES_LIBRARIES}
1340                 ${ADNS_LIBRARIES}
1341                 ${KERBEROS_LIBRARIES}
1342                 ${LUA_LIBRARIES}
1343                 ${PYTHON_LIBRARIES}
1344                 ${GEOIP_LIBRARIES}
1345                 ${GCRYPT_LIBRARIES}
1346                 ${GNUTLS_LIBRARIES}
1347                 ${SMI_LIBRARIES}
1348                 ${ZLIB_LIBRARIES}
1349                 ${M_LIBRARIES}
1350                 ${SBC_LIBRARIES}
1351                 ${WINSPARKLE_LIBRARIES}
1352 )
1353
1354 if(WIN32)
1355         # According to http://stackoverflow.com/questions/14474659/cmake-how-to-have-a-target-for-copying-files
1356         # we can't just use "set(_dll_output_dir "$<TARGET_FILE_DIR:epan>")"
1357         # DATAFILE_DIR is set using the same property. We could probably
1358         # get away with using it here.
1359         get_target_property(_libwireshark_location epan LOCATION)
1360         get_filename_component(_dll_output_dir "${_libwireshark_location}" PATH)
1361         add_custom_target(copy_cli_dlls)
1362         set_target_properties(copy_cli_dlls PROPERTIES FOLDER "Copy Tasks")
1363         add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1364                 COMMAND ${CMAKE_COMMAND} -E make_directory "${_dll_output_dir}"
1365         )
1366
1367         # XXX Can (and should) we iterate over these similar to the way
1368         # the top-level CMakeLists.txt iterates over the package list?
1369
1370         # Required DLLs.
1371         # The cairo, freetype, gio, gnutls, png, and other OBS-generated DLLs
1372         # depend on zlib1.dll. We compile zlib locally but the Debug
1373         # configuration (the default) creates zlibd1.dll.
1374         file (TO_NATIVE_PATH "${_dll_output_dir}" _dll_output_dir_win )
1375         foreach( _dll ${GLIB2_DLLS} $<$<CONFIG:Debug>:zlib1.dll> )
1376                 add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1377                         # It would be really handy if copy, xcopy, or "cmake
1378                         # -E copy_if_different" supported multiple files
1379                         # separated by whitespace, or if robocpy had a sane
1380                         # notion of exit codes.
1381                         COMMAND if exist \"${_dll}\" xcopy ${_dll} "${_dll_output_dir_win}" /D /Y
1382                         WORKING_DIRECTORY "${GLIB2_DLL_DIR}"
1383                 )
1384         endforeach(_dll)
1385
1386
1387         # Don't overwrite an exe if it's already there. We don't want to
1388         # clobber any previous code signing.
1389         file(GLOB _gspawn_helpers
1390                 RELATIVE "${GLIB2_DLL_DIR}"
1391                 "${GLIB2_DLL_DIR}/gspawn*.exe"
1392         )
1393         foreach(_gspawn_helper ${_gspawn_helpers})
1394                 add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1395                         COMMAND if not exist \"${_dll_output_dir_win}\\${_gspawn_helper}\" xcopy ${_gspawn_helper} "${_dll_output_dir_win}" /D /Y
1396                         WORKING_DIRECTORY "${GLIB2_DLL_DIR}"
1397                 )
1398         endforeach()
1399
1400         # Optional
1401         if (AIRPCAP_FOUND)
1402                 add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1403                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1404                                 "${AIRPCAP_DLL_DIR}/${AIRPCAP_DLL}"
1405                                 "${_dll_output_dir}"
1406                 )
1407         endif(AIRPCAP_FOUND)
1408         if (CARES_FOUND)
1409                 add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1410                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1411                                 "${CARES_DLL_DIR}/${CARES_DLL}"
1412                                 "${_dll_output_dir}"
1413                 )
1414         endif(CARES_FOUND)
1415         if (GEOIP_FOUND)
1416                 add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1417                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1418                                 "${GEOIP_DLL_DIR}/${GEOIP_DLL}"
1419                                 "${_dll_output_dir}"
1420                 )
1421         endif(GEOIP_FOUND)
1422         if(GCRYPT_FOUND)
1423                 foreach( _dll ${GCRYPT_DLLS} )
1424                         add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1425                                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1426                                         "${GCRYPT_DLL_DIR}/${_dll}"
1427                                         "${_dll_output_dir}"
1428                         )
1429                 endforeach(_dll)
1430         endif(GCRYPT_FOUND)
1431         if(GNUTLS_FOUND)
1432                 foreach( _dll ${GNUTLS_DLLS} )
1433                         add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1434                                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1435                                         "${GNUTLS_DLL_DIR}/${_dll}"
1436                                         "${_dll_output_dir}"
1437                         )
1438                 endforeach(_dll)
1439         endif(GNUTLS_FOUND)
1440         if(KERBEROS_FOUND)
1441                 foreach( _dll ${KERBEROS_DLLS} )
1442                         add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1443                                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1444                                         "${KERBEROS_DLL_DIR}/${_dll}"
1445                                         "${_dll_output_dir}"
1446                         )
1447                 endforeach(_dll)
1448         endif(KERBEROS_FOUND)
1449         if (LUA_FOUND)
1450                 add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1451                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1452                                 "${LUA_DLL_DIR}/${LUA_DLL}"
1453                                 "${_dll_output_dir}"
1454                 )
1455         endif(LUA_FOUND)
1456         if (SMI_FOUND)
1457                 # Wireshark.nsi wants SMI_DIR which is the base SMI directory
1458                 get_filename_component(SMI_DIR ${SMI_DLL_DIR} DIRECTORY)
1459                 add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1460                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1461                                 "${SMI_DLL_DIR}/${SMI_DLL}"
1462                                 "${_dll_output_dir}"
1463                         COMMAND ${CMAKE_COMMAND} -E make_directory
1464                                 "${_dll_output_dir}/snmp"
1465                         COMMAND ${CMAKE_COMMAND} -E make_directory
1466                                 "${_dll_output_dir}/snmp/mibs"
1467                         COMMAND ${CMAKE_COMMAND} -E copy_directory
1468                                 "${SMI_SHARE_DIR}/${SMI_DLL}/mibs/iana"
1469                                 "${_dll_output_dir}/snmp/mibs"
1470                         COMMAND ${CMAKE_COMMAND} -E copy_directory
1471                                 "${SMI_SHARE_DIR}/${SMI_DLL}/mibs/ietf"
1472                                 "${_dll_output_dir}/snmp/mibs"
1473                         COMMAND ${CMAKE_COMMAND} -E copy_directory
1474                                 "${SMI_SHARE_DIR}/${SMI_DLL}/mibs/irtf"
1475                                 "${_dll_output_dir}/snmp/mibs"
1476                         COMMAND ${CMAKE_COMMAND} -E copy_directory
1477                                 "${SMI_SHARE_DIR}/${SMI_DLL}/mibs/site"
1478                                 "${_dll_output_dir}/snmp/mibs"
1479                         COMMAND ${CMAKE_COMMAND} -E copy_directory
1480                                 "${SMI_SHARE_DIR}/${SMI_DLL}/mibs/tubs"
1481                                 "${_dll_output_dir}/snmp/mibs"
1482                         COMMAND ${CMAKE_COMMAND} -E copy_directory
1483                                 "${SMI_SHARE_DIR}/${SMI_DLL}/pibs"
1484                                 "${_dll_output_dir}/snmp/mibs"
1485                         COMMAND ${CMAKE_COMMAND} -E copy_directory
1486                                 "${SMI_SHARE_DIR}/${SMI_DLL}/yang"
1487                                 "${_dll_output_dir}/snmp/mibs"
1488                 )
1489         endif(SMI_FOUND)
1490         if (WINSPARKLE_FOUND)
1491                 add_custom_command(TARGET copy_cli_dlls PRE_BUILD
1492                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1493                                 "${WINSPARKLE_DLL_DIR}/${WINSPARKLE_DLL}"
1494                                 "${_dll_output_dir}"
1495                 )
1496         endif(WINSPARKLE_FOUND)
1497
1498         add_dependencies(epan copy_cli_dlls)
1499
1500         # We have a lot of choices for creating zip archives:
1501         # - 7z, WinZip, etc., which require a separate download+install.
1502         # - Cygwin's zip, which requires Cygwin.
1503         # - "CMake -E tar cz", which creates a tar file.
1504         # - CPack, which requires a CPack configuration.
1505         # - PowerShell via PSCX or System.IO.Compression.FileSystem.
1506         # - Python via zipfile.
1507         # For now, just look for 7z. It's installed on the Windows builders,
1508         # which might be the only systems that use this target.
1509         find_program(ZIP_EXECUTABLE 7z
1510                 PATH "$ENV{PROGRAMFILES}/7-Zip" "$ENV{PROGRAMW6432}/7-Zip"
1511                 DOC "Path to the 7z utility."
1512         )
1513         # XXX "if(ZIP_EXECUTABLE)" doesn't work here. It looks like the
1514         # absence of "-NOTFOUND" doesn't equal "true".
1515         if (NOT "${ZIP_EXECUTABLE}" STREQUAL "ZIP_EXECUTABLE-NOTFOUND")
1516                 add_custom_target(pdb_zip_package)
1517                 set_target_properties(pdb_zip_package PROPERTIES FOLDER "Packaging")
1518                 set(_pdb_zip "${CMAKE_BINARY_DIR}/Wireshark-pdb-${WIRESHARK_TARGET_PLATFORM}-${VERSION}.zip")
1519                 file(TO_NATIVE_PATH "${_pdb_zip}" _pdb_zip_win)
1520                 add_custom_command(TARGET pdb_zip_package POST_BUILD
1521                         COMMAND ${CMAKE_COMMAND} -E remove -f "${_pdb_zip}"
1522                         COMMAND ${ZIP_EXECUTABLE} a -tzip -mmt=on "${_pdb_zip_win}" *.pdb *.lib
1523                         WORKING_DIRECTORY "${_dll_output_dir}"
1524                 )
1525                 add_dependencies(pdb_zip_package epan)
1526         endif()
1527 endif(WIN32)
1528
1529 # Copy ${INSTALL_FILES} and ${INSTALL_DIRS} to ${DATAFILE_DIR}
1530 add_custom_target(copy_data_files ALL DEPENDS ${INSTALL_FILES})
1531 set_target_properties(copy_data_files PROPERTIES FOLDER "Copy Tasks")
1532 add_dependencies(copy_data_files html_docs)
1533 if(ENABLE_APPLICATION_BUNDLE)
1534         add_custom_command(TARGET copy_data_files PRE_BUILD
1535                 COMMAND ${CMAKE_COMMAND} -E make_directory "${DATAFILE_DIR}"
1536         )
1537 endif()
1538
1539 if(WIN32)
1540         foreach(_text_file ${TEXTIFY_FILES})
1541                 add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/${_text_file}.txt
1542                         COMMAND ${POWERSHELL_COMMAND} "${CMAKE_SOURCE_DIR}/tools/textify.ps1"
1543                                 -Destination ${CMAKE_BINARY_DIR}
1544                                 ${CMAKE_SOURCE_DIR}/${_text_file}
1545                         DEPENDS
1546                                 ${CMAKE_SOURCE_DIR}/${_text_file}
1547                 )
1548         endforeach()
1549 endif()
1550
1551 foreach(_install_file ${INSTALL_FILES})
1552         get_filename_component(_install_basename "${_install_file}" NAME)
1553         add_custom_command(TARGET copy_data_files POST_BUILD
1554                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1555                         "${_install_file}"
1556                         "${DATAFILE_DIR}/${_install_basename}"
1557                 WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
1558         )
1559 endforeach()
1560
1561 if(ENABLE_EXTCAP)
1562         add_custom_command(TARGET copy_data_files PRE_BUILD
1563                 COMMAND ${CMAKE_COMMAND} -E make_directory
1564                         "${DATAFILE_DIR}/extcap"
1565         )
1566 endif()
1567 add_custom_command(TARGET copy_data_files PRE_BUILD
1568         COMMAND ${CMAKE_COMMAND} -E make_directory
1569                 "${DATAFILE_DIR}/help"
1570 )
1571 add_custom_command(TARGET copy_data_files PRE_BUILD
1572         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1573                 "${CMAKE_SOURCE_DIR}/help/toc"
1574                 "${DATAFILE_DIR}/help/toc"
1575 )
1576 if(WIN32)
1577         file(TO_NATIVE_PATH ${DATAFILE_DIR}/help _help_dest_dir)
1578         add_custom_command(TARGET copy_data_files PRE_BUILD
1579                 COMMAND ${POWERSHELL_COMMAND} "${CMAKE_SOURCE_DIR}/tools/textify.ps1"
1580                         -Destination ${_help_dest_dir}
1581                         ${CMAKE_SOURCE_DIR}/help/*.txt
1582         )
1583 else()
1584         file(GLOB _help_files
1585                 "${CMAKE_SOURCE_DIR}/help/*.txt"
1586         )
1587         foreach(_help_file ${_help_files})
1588                 add_custom_command(TARGET copy_data_files PRE_BUILD
1589                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1590                                 "${_help_file}"
1591                                 "${DATAFILE_DIR}/help/"
1592                 )
1593         endforeach()
1594 endif(WIN32)
1595 add_custom_command(TARGET copy_data_files PRE_BUILD
1596         COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/help/faq.py -b > faq.tmp.html
1597         COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tools/html2text.py
1598                 faq.tmp.html > "${DATAFILE_DIR}/help/faq.txt"
1599         COMMAND ${CMAKE_COMMAND} -E remove faq.tmp.html
1600 )
1601
1602 if(LUA_FOUND)
1603         add_custom_command(TARGET copy_data_files PRE_BUILD
1604                 COMMAND ${CMAKE_COMMAND} -E make_directory
1605                         "${DATAFILE_DIR}/lua"
1606         )
1607         add_custom_command(TARGET copy_data_files PRE_BUILD
1608                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1609                         "${CMAKE_BINARY_DIR}/epan/wslua/init.lua"
1610                         "${DATAFILE_DIR}"
1611         )
1612         add_custom_command(TARGET copy_data_files PRE_BUILD
1613                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1614                         "${CMAKE_SOURCE_DIR}/epan/wslua/console.lua"
1615                         "${DATAFILE_DIR}"
1616         )
1617         add_custom_command(TARGET copy_data_files PRE_BUILD
1618                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1619                         "${CMAKE_SOURCE_DIR}/epan/wslua/dtd_gen.lua"
1620                         "${DATAFILE_DIR}"
1621         )
1622         add_dependencies(copy_data_files wsluaauxiliary)
1623 endif(LUA_FOUND)
1624 # doc/*.html handled elsewhere.
1625 add_custom_command(TARGET copy_data_files PRE_BUILD
1626         COMMAND ${CMAKE_COMMAND} -E copy_directory
1627                 "${CMAKE_SOURCE_DIR}/dtds"
1628                 "${DATAFILE_DIR}/dtds"
1629 )
1630 # Skipping asn1 default.tt
1631 add_custom_command(TARGET copy_data_files PRE_BUILD
1632         COMMAND ${CMAKE_COMMAND} -E copy_directory
1633                 "${CMAKE_SOURCE_DIR}/radius"
1634                 "${DATAFILE_DIR}/radius"
1635 )
1636 add_custom_command(TARGET copy_data_files PRE_BUILD
1637         COMMAND ${CMAKE_COMMAND} -E make_directory
1638                 "${DATAFILE_DIR}/diameter"
1639 )
1640 file(GLOB _diameter_files
1641         "${CMAKE_SOURCE_DIR}/diameter/*.dtd"
1642         "${CMAKE_SOURCE_DIR}/diameter/*.xml"
1643 )
1644 foreach(_diameter_file ${_diameter_files})
1645         add_custom_command(TARGET copy_data_files PRE_BUILD
1646                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1647                         "${_diameter_file}"
1648                         "${DATAFILE_DIR}/diameter/"
1649         )
1650 endforeach()
1651 add_custom_command(TARGET copy_data_files PRE_BUILD
1652         COMMAND ${CMAKE_COMMAND} -E copy_directory
1653                 "${CMAKE_SOURCE_DIR}/profiles"
1654                 "${DATAFILE_DIR}/profiles"
1655 )
1656 add_custom_command(TARGET copy_data_files PRE_BUILD
1657         COMMAND ${CMAKE_COMMAND} -E make_directory
1658                 "${DATAFILE_DIR}/tpncp"
1659 )
1660 add_custom_command(TARGET copy_data_files PRE_BUILD
1661         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1662                 "${CMAKE_SOURCE_DIR}/tpncp/tpncp.dat"
1663                 "${DATAFILE_DIR}/tpncp/tpncp.dat"
1664 )
1665 add_custom_command(TARGET copy_data_files PRE_BUILD
1666         COMMAND ${CMAKE_COMMAND} -E copy_directory
1667                 "${CMAKE_SOURCE_DIR}/wimaxasncp"
1668                 "${DATAFILE_DIR}/wimaxasncp"
1669 )
1670
1671 if( (BUILD_wireshark AND QT_FOUND) OR (BUILD_wireshark_gtk AND GTK_FOUND) )
1672         set(WIRESHARK_SRC
1673                 capture_info.c
1674                 capture_opts.c
1675                 color_filters.c
1676                 file.c
1677                 fileset.c
1678                 summary.c
1679                 ${SHARK_COMMON_SRC}
1680                 ${PLATFORM_UI_SRC}
1681         )
1682         set(wireshark_FILES
1683                 ${WIRESHARK_SRC}
1684                 ${CMAKE_BINARY_DIR}/image/wireshark.rc
1685                 ${PLATFORM_UI_RC_FILES}
1686         )
1687 endif()
1688
1689 if(ENABLE_APPLICATION_BUNDLE)
1690         #
1691         # Add -Wl,-single_module to the LDFLAGS used with shared
1692         # libraries, to fix some error that show up in some cases;
1693         # some Apple documentation recommends it for most shared
1694         # libraries.
1695         #
1696         set( CMAKE_SHARED_LINKER_FLAGS "-Wl,-single_module ${CMAKE_SHARED_LINKER_FLAGS}" )
1697         #
1698         # Add -Wl,-headerpad_max_install_names to the LDFLAGS, as
1699         # code-signing issues is running out of padding space.
1700         #
1701         # Add -Wl,-search_paths_first to make sure that if we search
1702         # directories A and B, in that order, for a given library, a
1703         # non-shared version in directory A, rather than a shared
1704         # version in directory B, is chosen (so we can use
1705         # --with-pcap=/usr/local to force all programs to be linked
1706         # with a static version installed in /usr/local/lib rather than
1707         # the system version in /usr/lib).
1708         #
1709
1710         set(CMAKE_EXE_LINKER_FLAGS
1711         "-Wl,-headerpad_max_install_names -Wl,-search_paths_first ${CMAKE_EXE_LINKER_FLAGS}"
1712         )
1713
1714         # Add files to the app bundle
1715         # Wireshark.app/Contents
1716         file(WRITE ${CMAKE_BINARY_DIR}/packaging/macosx/PkgInfo "APPLWshk\n")
1717         set(BUNDLE_CONTENTS_FILES
1718                 ${CMAKE_BINARY_DIR}/packaging/macosx/PkgInfo
1719         )
1720         set_source_files_properties(${BUNDLE_CONTENTS_FILES} PROPERTIES
1721                 MACOSX_PACKAGE_LOCATION .
1722         )
1723
1724         # Wireshark.app/Contents/Resources
1725         set(BUNDLE_RESOURCE_FILES
1726                 ${CMAKE_SOURCE_DIR}/packaging/macosx/Resources/Wireshark.icns
1727                 ${CMAKE_SOURCE_DIR}/packaging/macosx/Resources/Wiresharkdoc.icns
1728         )
1729         set_source_files_properties(${BUNDLE_RESOURCE_FILES} PROPERTIES
1730                 MACOSX_PACKAGE_LOCATION Resources
1731         )
1732
1733         # Wireshark.app/Contents/Resources/share/man/man1
1734         set(BUNDLE_RESOURCE_SHARE_MAN1_FILES ${MAN1_FILES})
1735         set_source_files_properties(${BUNDLE_RESOURCE_SHARE_MAN1_FILES} PROPERTIES
1736                 MACOSX_PACKAGE_LOCATION Resources/share/man/man1
1737         )
1738
1739         # Wireshark.app/Contents/Resources/share/man/man1
1740         set(BUNDLE_RESOURCE_SHARE_MAN4_FILES ${MAN4_FILES})
1741         set_source_files_properties(${BUNDLE_RESOURCE_SHARE_MAN4_FILES} PROPERTIES
1742                 MACOSX_PACKAGE_LOCATION Resources/share/man/man4
1743         )
1744
1745         # INSTALL_FILES and INSTALL_DIRS are handled by copy_data_files
1746
1747         set(EXTRA_BUNDLE_FILES
1748                 ${BUNDLE_CONTENTS_FILES}
1749                 ${BUNDLE_RESOURCE_FILES}
1750                 ${BUNDLE_RESOURCE_SHARE_MAN1_FILES}
1751                 ${BUNDLE_RESOURCE_SHARE_MAN4_FILES}
1752         )
1753 else()
1754         set(EXTRA_BUNDLE_FILES)
1755 endif()
1756
1757 if(BUILD_wireshark AND QT_FOUND)
1758         set(wireshark_LIBS
1759                 qtui
1760                 ui
1761                 capchild
1762                 caputils
1763                 ${QT_LIBRARIES}
1764                 ${GTHREAD2_LIBRARIES}
1765                 codecs
1766                 ${LIBEPAN_LIBS}
1767                 ${APPLE_APPLICATION_SERVICES_LIBRARY}
1768                 ${APPLE_CORE_FOUNDATION_LIBRARY}
1769                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
1770                 ${NL_LIBRARIES}
1771         )
1772
1773         # Policy since 2.8.11
1774         if (POLICY CMP0020)
1775                 cmake_policy(SET CMP0020 NEW)
1776         endif()
1777
1778         add_executable(wireshark WIN32 MACOSX_BUNDLE wireshark-qt.cpp ${wireshark_FILES} ${EXTRA_BUNDLE_FILES})
1779         set(PROGLIST ${PROGLIST} wireshark)
1780         set_target_properties(wireshark PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1781         set_target_properties(wireshark PROPERTIES FOLDER "Executables")
1782         if(ENABLE_APPLICATION_BUNDLE OR WIN32)
1783                 set_target_properties(wireshark PROPERTIES OUTPUT_NAME Wireshark)
1784         endif()
1785
1786         if(ENABLE_APPLICATION_BUNDLE)
1787                 set_target_properties(
1788                         wireshark PROPERTIES
1789                                 MACOSX_BUNDLE_INFO_PLIST ${CMAKE_BINARY_DIR}/packaging/macosx/Info.plist
1790                 )
1791                 # Add a wrapper script which opens the bundle. This adds
1792                 # convenience but makes debugging more difficult.
1793                 file(REMOVE ${CMAKE_BINARY_DIR}/run/wireshark)
1794                 file(WRITE ${CMAKE_BINARY_DIR}/run/wireshark "#!/bin/sh\n")
1795                 file(APPEND ${CMAKE_BINARY_DIR}/run/wireshark "open ${CMAKE_BINARY_DIR}/run/Wireshark.app --args \"\$\@\"\n")
1796                 execute_process(COMMAND chmod a+x ${CMAKE_BINARY_DIR}/run/wireshark)
1797         endif()
1798
1799         target_link_libraries(wireshark ${wireshark_LIBS})
1800         install(
1801                 TARGETS wireshark
1802                 RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
1803                 BUNDLE DESTINATION ${CMAKE_INSTALL_BINDIR}
1804         )
1805
1806         if(NOT ENABLE_APPLICATION_BUNDLE)
1807                 # Map for endpoints dialog
1808                 ADD_CUSTOM_COMMAND(
1809                         TARGET wireshark
1810                         POST_BUILD
1811                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1812                                 "${PROJECT_SOURCE_DIR}/ipmap.html"
1813                                 $<TARGET_FILE_DIR:wireshark>
1814                 )
1815         endif()
1816
1817         if(WIN32 AND Qt5Core_FOUND)
1818                 # Use windeployqt to copy our required DLLs to the run path.
1819                 # Ideally one of the modules in ${QTDIR}/lib/cmake would expose
1820                 # the path to windeployqt. For that matter having a reliable
1821                 # path to qmake would be *amazingly convenient*. We don't have
1822                 # either of those so we try to discover the path via Qt5Core.
1823                 # http://stackoverflow.com/questions/24650936/qt5-with-cmake-how-to-find-qt-translations-dir
1824
1825                 get_target_property(_qmake_location Qt5::qmake IMPORTED_LOCATION)
1826                 get_filename_component(_qt_bin_path "${_qmake_location}" DIRECTORY)
1827                 find_program(QT_WINDEPLOYQT_EXECUTABLE windeployqt
1828                         HINTS "${_qmake_location}"
1829                         DOC "Path to the windeployqt utility."
1830                 )
1831                 if (NOT "${QT_WINDEPLOYQT_EXECUTABLE}" STREQUAL "QT_WINDEPLOYQT_EXECUTABLE-NOTFOUND")
1832                         set(QT_BIN_PATH "${_qt_bin_path}" CACHE INTERNAL
1833                                 "Path to qmake, windeployqt, and other Qt utilities."
1834                         )
1835                         add_custom_target(copy_qt_dlls ALL)
1836                         set_target_properties(copy_qt_dlls PROPERTIES FOLDER "Copy Tasks")
1837                         # Will we ever need to use --debug? Windeployqt seems to
1838                         # be smart enough to copy debug DLLs when needed.
1839                         add_custom_command(TARGET copy_qt_dlls
1840                                 POST_BUILD
1841                                 COMMAND set "PATH=%PATH%;${QT_BIN_PATH}"
1842                                 COMMAND "${QT_WINDEPLOYQT_EXECUTABLE}"
1843                                         $<$<CONFIG:Debug>:--debug>
1844                                         $<$<NOT:$<CONFIG:Debug>>:--release>
1845                                         --no-compiler-runtime
1846                                         --verbose 10
1847                                         "$<TARGET_FILE:wireshark>"
1848                         )
1849                         add_dependencies(copy_qt_dlls wireshark)
1850                 endif()
1851         endif(WIN32 AND Qt5Core_FOUND)
1852 endif()
1853
1854 # Common properties for CLI executables
1855 macro(set_extra_executable_properties _executable _folder)
1856         set_target_properties(${_executable} PROPERTIES
1857                 LINK_FLAGS "${WS_LINK_FLAGS}"
1858                 FOLDER ${_folder}
1859         )
1860
1861         set(PROGLIST ${PROGLIST} ${_executable})
1862
1863         if(ENABLE_APPLICATION_BUNDLE)
1864                 set_target_properties(${_executable} PROPERTIES
1865                         RUNTIME_OUTPUT_DIRECTORY run/Wireshark.app/Contents/MacOS
1866                 )
1867                 # Add a wrapper script which runs each executable from the
1868                 # correct location. This adds convenience but makes debugging
1869                 # more difficult.
1870                 file(REMOVE ${CMAKE_BINARY_DIR}/run/${_executable})
1871                 file(WRITE ${CMAKE_BINARY_DIR}/run/${_executable} "#!/bin/sh\n")
1872                 file(APPEND ${CMAKE_BINARY_DIR}/run/${_executable} "exec ${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/MacOS/${_executable} \"\$\@\"\n")
1873                 execute_process(COMMAND chmod a+x ${CMAKE_BINARY_DIR}/run/${_executable})
1874         endif()
1875 endmacro()
1876
1877 macro(set_extcap_executable_properties _executable)
1878         set_target_properties(androiddump PROPERTIES FOLDER "Executables/Extcaps")
1879
1880         set(PROGLIST ${PROGLIST} ${_executable})
1881
1882         if(WIN32)
1883                 set_target_properties(${_executable} PROPERTIES
1884                         LINK_FLAGS "${WS_LINK_FLAGS}"
1885                         RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/run/extcap
1886                         RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/run/Debug/extcap
1887                         RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/run/Release/extcap
1888                         RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${CMAKE_BINARY_DIR}/run/MinSizeRel/extcap
1889                         RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_BINARY_DIR}/run/RelWithDebInfo/extcap
1890                 )
1891         else()
1892                 set_target_properties(${_executable} PROPERTIES
1893                         LINK_FLAGS "${WS_LINK_FLAGS}"
1894                         RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/run/extcap
1895                 )
1896                 if(ENABLE_APPLICATION_BUNDLE)
1897                         set_target_properties(${_executable} PROPERTIES
1898                                 RUNTIME_OUTPUT_DIRECTORY run/Wireshark.app/Contents/MacOS/extcap
1899                         )
1900                         # Add a wrapper script which runs each executable from the
1901                         # correct location. This adds convenience but makes debugging
1902                         # more difficult.
1903                         file(REMOVE ${CMAKE_BINARY_DIR}/run/${_executable})
1904                         file(WRITE ${CMAKE_BINARY_DIR}/run/${_executable} "#!/bin/sh\n")
1905                         file(APPEND ${CMAKE_BINARY_DIR}/run/${_executable} "exec ${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/MacOS/extcap/${_executable} \"\$\@\"\n")
1906                         execute_process(COMMAND chmod a+x ${CMAKE_BINARY_DIR}/run/${_executable})
1907                 endif()
1908         endif()
1909 endmacro()
1910
1911 if(BUILD_wireshark_gtk AND GTK_FOUND)
1912         set(wireshark_gtk_LIBS
1913                 gtkui
1914                 ui
1915                 capchild
1916                 caputils
1917                 ${GTK2_LIBRARIES}
1918                 ${GTK3_LIBRARIES}
1919                 ${GTHREAD2_LIBRARIES}
1920                 codecs
1921                 ${PORTAUDIO_LIBRARIES}
1922                 ${LIBEPAN_LIBS}
1923                 ${APPLE_APPLICATION_SERVICES_LIBRARY}
1924                 ${APPLE_CORE_SERVICES_LIBRARY}
1925                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
1926                 ${NL_LIBRARIES}
1927                 ${WIN_COMCTL32_LIBRARY}
1928         )
1929         # wireshark and wireshark-gtk share wireshark_FILES
1930
1931         add_executable(wireshark-gtk WIN32 ${wireshark_FILES})
1932         set(PROGLIST ${PROGLIST} wireshark-gtk)
1933         set_target_properties(wireshark-gtk PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1934         set_target_properties(wireshark-gtk PROPERTIES FOLDER "Executables")
1935         target_link_libraries(wireshark-gtk ${wireshark_gtk_LIBS})
1936         install(TARGETS wireshark-gtk RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1937
1938         # Map for endpoints dialog
1939         ADD_CUSTOM_COMMAND(
1940                 TARGET wireshark-gtk
1941                 POST_BUILD
1942                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1943                         "${PROJECT_SOURCE_DIR}/ipmap.html"
1944                         $<TARGET_FILE_DIR:wireshark-gtk>
1945         )
1946
1947         if(WIN32)
1948                 get_target_property(_wsgtk_location wireshark-gtk LOCATION)
1949                 get_filename_component(_dll_output_dir "${_wsgtk_location}" PATH)
1950                 add_custom_target(copy_gtk_dlls)
1951                 set_target_properties(copy_gtk_dlls PROPERTIES FOLDER "Copy Tasks")
1952                 add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1953                         COMMAND ${CMAKE_COMMAND} -E make_directory "${_dll_output_dir}"
1954                 )
1955
1956                 if(GTK2_FOUND)
1957                         set(_gtk_dll_dir "${GTK2_DLL_DIR}")
1958                         set(_gtk_etc_dir "${GTK2_ETC_DIR}")
1959                         set(_gtk_dlls "${GTK2_DLLS}")
1960                         set(_gtk_etc_dir "${GTK2_ETC_DIR}")
1961                 else()
1962                         set(_gtk_dll_dir "${GTK3_DLL_DIR}")
1963                         set(_gtk_dlls "${GTK3_DLLS}")
1964                         set(_gtk_etc_dir "${GTK3_ETC_DIR}")
1965                 endif()
1966
1967                 foreach(_dll ${_gtk_dlls})
1968                         add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1969                                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1970                                         "${_gtk_dll_dir}/${_dll}" "${_dll_output_dir}"
1971                         )
1972                 endforeach(_dll)
1973
1974                 # /etc
1975                 add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1976                         COMMAND ${CMAKE_COMMAND} -E make_directory "${_dll_output_dir}/etc"
1977                 )
1978                 add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1979                         COMMAND ${CMAKE_COMMAND} -E copy_directory
1980                                 "${_gtk_etc_dir}" "${_dll_output_dir}/etc"
1981                 )
1982
1983                 # XXX - Omitting ${GTK2_LIB_DIR}\loaders copying from Makefile.nmake
1984                 if(GTK2_FOUND)
1985                         # Engines
1986                         set (_engines_output_dir "${_dll_output_dir}/lib/gtk-2.0/2.10.0/engines")
1987                         add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1988                                 COMMAND ${CMAKE_COMMAND} -E make_directory "${_engines_output_dir}"
1989                         )
1990                         foreach(_dll ${GTK2_ENGINES_DLLS})
1991                                 add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1992                                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1993                                                 "${GTK2_ENGINES_DLL_DIR}/${_dll}" "${_engines_output_dir}"
1994                                 )
1995                         endforeach(_dll)
1996
1997                         # Themes
1998                         add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1999                                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
2000                                         "${GTK2_THEMES_DIR}/gtkrc" "${_dll_output_dir}/etc/gtk-2.0"
2001                         )
2002
2003                         # Modules
2004                         add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
2005                                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2006                                         "${GTK2_LIB_DIR}" "${_dll_output_dir}/lib/gtk-2.0"
2007                         )
2008                 else()
2009                         add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
2010                                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2011                                         "${CMAKE_SOURCE_DIR}/ui/win32/settings.ini" "${_dll_output_dir}/etc"
2012                         )
2013                 endif()
2014
2015                 add_dependencies(wireshark-gtk copy_gtk_dlls copy_cli_dlls)
2016         endif(WIN32)
2017 endif()
2018
2019 register_tap_files(tshark-tap-register.c
2020         tshark-taps
2021         ${TSHARK_TAP_SRC}
2022 )
2023
2024 if(BUILD_tshark)
2025         set(tshark_LIBS
2026                 ui
2027                 capchild
2028                 caputils
2029                 ${LIBEPAN_LIBS}
2030                 ${APPLE_CORE_FOUNDATION_LIBRARY}
2031                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
2032         )
2033         set(tshark_FILES
2034                 capture_opts.c
2035                 tshark-tap-register.c
2036                 tshark.c
2037                 ${TSHARK_TAP_SRC}
2038                 ${SHARK_COMMON_SRC}
2039                 ${CMAKE_BINARY_DIR}/image/tshark.rc
2040         )
2041         add_executable(tshark ${tshark_FILES})
2042         set_extra_executable_properties(tshark "Executables")
2043         target_link_libraries(tshark ${tshark_LIBS})
2044         install(TARGETS tshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2045 endif()
2046
2047 if(BUILD_tfshark)
2048         set(tfshark_LIBS
2049                 ui
2050                 ${LIBEPAN_LIBS}
2051                 ${APPLE_CORE_FOUNDATION_LIBRARY}
2052                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
2053         )
2054         set(tfshark_FILES
2055                 tfshark.c
2056                 ${TSHARK_TAP_SRC}
2057                 ${SHARK_COMMON_SRC}
2058                 ${CMAKE_BINARY_DIR}/image/tfshark.rc
2059         )
2060         add_executable(tfshark ${tfshark_FILES})
2061         set_extra_executable_properties(tfshark "Executables")
2062         target_link_libraries(tfshark ${tfshark_LIBS})
2063         install(TARGETS tfshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2064 endif()
2065
2066 if(BUILD_rawshark AND PCAP_FOUND)
2067         set(rawshark_LIBS
2068                 caputils
2069                 ${LIBEPAN_LIBS}
2070                 ${APPLE_CORE_FOUNDATION_LIBRARY}
2071                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
2072         )
2073         set(rawshark_FILES
2074                 ${SHARK_COMMON_SRC}
2075                 rawshark.c
2076                 ui/util.c
2077                 ${CMAKE_BINARY_DIR}/image/rawshark.rc
2078         )
2079         add_executable(rawshark ${rawshark_FILES})
2080         set_extra_executable_properties(rawshark "Executables")
2081         target_link_libraries(rawshark ${rawshark_LIBS})
2082         install(TARGETS rawshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2083 endif()
2084
2085 if(BUILD_dftest)
2086         set(dftest_LIBS
2087                 ${LIBEPAN_LIBS}
2088         )
2089         set(dftest_FILES
2090                 dftest.c
2091                 ui/util.c
2092         )
2093         add_executable(dftest ${dftest_FILES})
2094         set_extra_executable_properties(dftest "Tests")
2095         target_link_libraries(dftest ${dftest_LIBS})
2096         install(TARGETS dftest RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2097 endif()
2098
2099 if(BUILD_randpkt)
2100         set(randpkt_LIBS
2101                 wiretap
2102                 wsutil
2103                 ${M_LIBRARIES}
2104                 ${PCAP_LIBRARIES}
2105 #               @SOCKET_LIBS@
2106 #               @NSL_LIBS@
2107                 ${CARES_LIBRARIES}
2108                 ${ADNS_LIBRARIES}
2109                 ${ZLIB_LIBRARIES}
2110         )
2111         set(randpkt_FILES
2112                 randpkt.c
2113         )
2114         add_executable(randpkt ${randpkt_FILES})
2115         set_extra_executable_properties(randpkt "Executables")
2116         target_link_libraries(randpkt ${randpkt_LIBS})
2117         install(TARGETS randpkt RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2118 endif()
2119
2120 if(BUILD_text2pcap)
2121         set(text2pcap_LIBS
2122                 wsutil
2123                 ${M_LIBRARIES}
2124                 ${ZLIB_LIBRARIES}
2125         )
2126         set(text2pcap_CLEAN_FILES
2127                 text2pcap.c
2128                 pcapio.c
2129         )
2130         set(text2pcap_FILES
2131                 ${text2pcap_CLEAN_FILES}
2132                 ${CMAKE_BINARY_DIR}/image/text2pcap.rc
2133         )
2134         add_lex_files(text2pcap_FILES
2135                 text2pcap-scanner.l
2136         )
2137         add_executable(text2pcap ${text2pcap_FILES})
2138         set_extra_executable_properties(text2pcap "Executables")
2139         target_link_libraries(text2pcap ${text2pcap_LIBS})
2140         install(TARGETS text2pcap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2141 endif()
2142
2143 if(BUILD_mergecap)
2144         set(mergecap_LIBS
2145                 wiretap
2146                 ${ZLIB_LIBRARIES}
2147                 ${CMAKE_DL_LIBS}
2148         )
2149         set(mergecap_FILES
2150                 mergecap.c
2151                 ${CMAKE_BINARY_DIR}/image/mergecap.rc
2152         )
2153         add_executable(mergecap ${mergecap_FILES})
2154         set_extra_executable_properties(mergecap "Executables")
2155         target_link_libraries(mergecap ${mergecap_LIBS})
2156         install(TARGETS mergecap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2157 endif()
2158
2159 if(BUILD_reordercap)
2160         set(reordercap_LIBS
2161                 wiretap
2162                 ${ZLIB_LIBRARIES}
2163                 ${CMAKE_DL_LIBS}
2164         )
2165         set(reordercap_FILES
2166                 reordercap.c
2167                 ${CMAKE_BINARY_DIR}/image/reordercap.rc
2168         )
2169         add_executable(reordercap ${reordercap_FILES})
2170         set_extra_executable_properties(reordercap "Executables")
2171         target_link_libraries(reordercap ${reordercap_LIBS})
2172         install(TARGETS reordercap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2173 endif()
2174
2175 if(BUILD_capinfos)
2176         set(capinfos_LIBS
2177                 wiretap
2178                 wsutil
2179                 ${ZLIB_LIBRARIES}
2180                 ${GCRYPT_LIBRARIES}
2181                 ${CMAKE_DL_LIBS}
2182         )
2183         set(capinfos_FILES
2184                 capinfos.c
2185                 ${CMAKE_BINARY_DIR}/image/capinfos.rc
2186         )
2187         add_executable(capinfos ${capinfos_FILES})
2188         set_extra_executable_properties(capinfos "Executables")
2189         target_link_libraries(capinfos ${capinfos_LIBS})
2190         install(TARGETS capinfos RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2191 endif()
2192
2193 if(BUILD_captype)
2194         set(captype_LIBS
2195                 wiretap
2196                 wsutil
2197                 ${ZLIB_LIBRARIES}
2198                 ${CMAKE_DL_LIBS}
2199         )
2200         set(captype_FILES
2201                 captype.c
2202                 ${CMAKE_BINARY_DIR}/image/captype.rc
2203         )
2204         add_executable(captype ${captype_FILES})
2205         set_extra_executable_properties(captype "Executables")
2206         target_link_libraries(captype ${captype_LIBS})
2207         install(TARGETS captype RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2208 endif()
2209
2210 if(BUILD_editcap)
2211         set(editcap_LIBS
2212                 wiretap
2213                 ${ZLIB_LIBRARIES}
2214                 ${CMAKE_DL_LIBS}
2215         )
2216         set(editcap_FILES
2217                 editcap.c
2218                 ${CMAKE_BINARY_DIR}/image/editcap.rc
2219         )
2220         add_executable(editcap ${editcap_FILES})
2221         set_extra_executable_properties(editcap "Executables")
2222         target_link_libraries(editcap ${editcap_LIBS})
2223         install(TARGETS editcap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2224 endif()
2225
2226 if(BUILD_dumpcap AND PCAP_FOUND)
2227         set(dumpcap_LIBS
2228                 wsutil
2229                 caputils
2230                 ${PCAP_LIBRARIES}
2231                 ${CAP_LIBRARIES}
2232 #               @SOCKET_LIBS@
2233 #               @NSL_LIBS@
2234                 ${GLIB2_LIBRARIES}
2235                 ${GTHREAD2_LIBRARIES}
2236                 ${ZLIB_LIBRARIES}
2237                 ${APPLE_CORE_FOUNDATION_LIBRARY}
2238                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
2239                 ${NL_LIBRARIES}
2240         )
2241         set(dumpcap_FILES
2242                 capture_opts.c
2243                 capture_stop_conditions.c
2244                 conditions.c
2245                 dumpcap.c
2246                 pcapio.c
2247                 ringbuffer.c
2248                 sync_pipe_write.c
2249                 ${CMAKE_BINARY_DIR}/image/dumpcap.rc
2250         )
2251         add_executable(dumpcap ${dumpcap_FILES})
2252         set_extra_executable_properties(dumpcap "Executables")
2253         target_link_libraries(dumpcap ${dumpcap_LIBS})
2254         install(TARGETS dumpcap
2255                         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
2256                         PERMISSIONS ${DUMPCAP_SETUID}
2257                                 OWNER_READ OWNER_WRITE OWNER_EXECUTE
2258                                 GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
2259         )
2260         if(DUMPCAP_INSTALL_OPTION STREQUAL "capabilities")
2261                 install( CODE "execute_process(
2262                         COMMAND
2263                                 ${SETCAP_EXECUTABLE}
2264                                 cap_net_raw,cap_net_admin+ep
2265                                 ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}/dumpcap${CMAKE_EXECUTABLE_SUFFIX}
2266                         RESULT_VARIABLE
2267                                 _SETCAP_RESULT
2268                         )
2269                         if( _SETCAP_RESULT )
2270                                 message( WARNING \"setcap failed (${_SETCAP_RESULT}).\")
2271                         endif()"
2272                 )
2273         endif()
2274 endif()
2275
2276 if (WIN32)
2277         # Must come after executable targets are defined.
2278         find_package( NSIS )
2279
2280         if (NOT "${MAKENSIS_EXECUTABLE}" STREQUAL "MAKENSIS_EXECUTABLE-NOTFOUND")
2281                 add_subdirectory( packaging/nsis EXCLUDE_FROM_ALL )
2282                 ADD_NSIS_UNINSTALLER_TARGET()
2283                 ADD_NSIS_PACKAGE_TARGET()
2284         endif()
2285
2286         find_package( PortableApps )
2287         if (
2288                 NOT "${PORTABLEAPPS_LAUNCHER_GENERATOR_EXECUTABLE}" STREQUAL "PORTABLEAPPS_LAUNCHER_GENERATOR_EXECUTABLE-NOTFOUND"
2289                 AND
2290                 NOT "${PORTABLEAPPS_INSTALLER_EXECUTABLE}" STREQUAL "PORTABLEAPPS_INSTALLER_EXECUTABLE-NOTFOUND"
2291         )
2292                 add_subdirectory( packaging/portableapps EXCLUDE_FROM_ALL )
2293                 ADD_PORTABLEAPPS_PACKAGE_TARGET()
2294         endif()
2295 endif()
2296
2297 if(BUILD_androiddump)
2298         if(EXTCAP_ANDROIDDUMP_LIBPCAP)
2299                 if(HAVE_LIBPCAP)
2300                         set(androiddump_LIBS
2301                                 ${GLIB2_LIBRARIES}
2302                                 ${PCAP_LIBRARIES}
2303                         )
2304                 else()
2305                         message(FATAL_ERROR "You try to build androiddump with libpcap but do not have it")
2306                 endif()
2307         else()
2308                 set(androiddump_LIBS
2309                         wiretap
2310                         ${GLIB2_LIBRARIES}
2311                         ${CMAKE_DL_LIBS}
2312                 )
2313         endif()
2314         set(androiddump_FILES
2315                 extcap/androiddump.c
2316         )
2317
2318         add_executable(androiddump WIN32 ${androiddump_FILES})
2319         # XXX Shouldn't we add wsutil to androiddump_LIBS instead?
2320         set_extcap_executable_properties(androiddump)
2321         target_link_libraries(androiddump ${androiddump_LIBS})
2322         install(TARGETS androiddump RUNTIME DESTINATION ${EXTCAP_DIR})
2323 endif()
2324
2325 ADD_CUSTOM_COMMAND(
2326         OUTPUT  ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
2327         COMMAND ${PERL_EXECUTABLE}
2328                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
2329                 ${CMAKE_SOURCE_DIR}/doc/make-authors-short.pl
2330                 < ${CMAKE_SOURCE_DIR}/AUTHORS
2331                 > ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
2332         DEPENDS
2333                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
2334                 ${CMAKE_SOURCE_DIR}/doc/make-authors-short.pl
2335                 ${CMAKE_SOURCE_DIR}/AUTHORS
2336 )
2337
2338 ADD_CUSTOM_COMMAND(
2339         OUTPUT  ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
2340         COMMAND ${PERL_EXECUTABLE}
2341                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
2342                 ${CMAKE_SOURCE_DIR}/doc/make-authors-format.pl
2343                 < ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
2344                 > ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
2345         DEPENDS
2346                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
2347                 ${CMAKE_SOURCE_DIR}/doc/make-authors-format.pl
2348                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
2349 )
2350
2351 if(WIN32)
2352 FILE(TO_NATIVE_PATH ${CMAKE_SOURCE_DIR}/doc/wireshark.pod.template WPT_WIN_PATH)
2353 FILE(TO_NATIVE_PATH ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT ASF_WIN_PATH)
2354 FILE(TO_NATIVE_PATH ${CMAKE_BINARY_DIR}/wireshark.pod WP_WIN_PATH)
2355 ADD_CUSTOM_COMMAND(
2356         OUTPUT  ${CMAKE_BINARY_DIR}/wireshark.pod
2357         COMMAND copy /B ${WPT_WIN_PATH} + ${ASF_WIN_PATH} ${WP_WIN_PATH}
2358         DEPENDS
2359                 ${CMAKE_SOURCE_DIR}/doc/wireshark.pod.template
2360                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
2361 )
2362 else()
2363
2364 ADD_CUSTOM_COMMAND(
2365         OUTPUT  ${CMAKE_BINARY_DIR}/wireshark.pod
2366         COMMAND cat
2367                 ${CMAKE_SOURCE_DIR}/doc/wireshark.pod.template
2368                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
2369                 > ${CMAKE_BINARY_DIR}/wireshark.pod
2370         DEPENDS
2371                 ${CMAKE_SOURCE_DIR}/doc/wireshark.pod.template
2372                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
2373 )
2374 endif()
2375
2376 if(ENABLE_APPLICATION_BUNDLE)
2377         add_custom_target(app_bundle)
2378         set_target_properties(app_bundle PROPERTIES FOLDER "Copy Tasks")
2379         add_custom_command(TARGET app_bundle
2380                 POST_BUILD
2381                 COMMAND "${CMAKE_SOURCE_DIR}/packaging/macosx/osx-app.sh"
2382                 WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/run"
2383         )
2384         add_dependencies(app_bundle ${PROGLIST})
2385
2386         add_custom_target(dmg_package_prep DEPENDS app_bundle)
2387
2388         ADD_CUSTOM_COMMAND(
2389                 OUTPUT ${CMAKE_BINARY_DIR}/packaging/macosx/PkgInfo
2390                 COMMAND ${CMAKE_COMMAND} -E echo APPLWshk > ${CMAKE_BINARY_DIR}/packaging/macosx/PkgInfo
2391         )
2392
2393         ADD_CUSTOM_TARGET( dmg_package
2394                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
2395                                         "${PROJECT_SOURCE_DIR}/ipmap.html"
2396                                         $<TARGET_FILE_DIR:wireshark>
2397                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2398                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/ChmodBPF
2399                                         ${CMAKE_BINARY_DIR}/run/ChmodBPF
2400                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2401                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/Resources
2402                                         ${CMAKE_BINARY_DIR}/run/Resources
2403                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2404                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/Scripts
2405                                         ${CMAKE_BINARY_DIR}/run/Scripts
2406                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2407                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/utility-launcher
2408                                         ${CMAKE_BINARY_DIR}/run/utility-launcher
2409                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
2410                                         ${CMAKE_SOURCE_DIR}/COPYING
2411                                         ${CMAKE_BINARY_DIR}/run/COPYING.txt
2412                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2413                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/Wireshark_package.pmdoc
2414                                         ${CMAKE_BINARY_DIR}/run/Wireshark_package.pmdoc
2415                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
2416                                         ${CMAKE_BINARY_DIR}/packaging/macosx/Wireshark_package.pmdoc/index.xml
2417                                         ${CMAKE_BINARY_DIR}/run/Wireshark_package.pmdoc/index.xml
2418                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
2419                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/dmg_background.png
2420                                         ${CMAKE_BINARY_DIR}/run/dmg_background.png
2421                 COMMAND bash -x ${CMAKE_BINARY_DIR}/packaging/macosx/osx-dmg.sh
2422                         --source-directory ${CMAKE_SOURCE_DIR}/packaging/macosx
2423                 # Unlike nsis_package_prep + nsis_package, we can add a direct
2424                 # dependency here.
2425                 DEPENDS dmg_package_prep
2426                 # We create Wireshark.app in "run". Do our work there.
2427                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/run
2428         )
2429
2430 endif()
2431
2432 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/androiddump 1 )
2433 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/capinfos 1 )
2434 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/captype 1 )
2435 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/dftest 1 )
2436 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/dumpcap 1 )
2437 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/editcap 1 )
2438 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/extcap 4 )
2439 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/asn2deb 1 )
2440 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/idl2deb 1 )
2441 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/idl2wrs 1 )
2442 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/mergecap 1 )
2443 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/randpkt 1 )
2444 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/rawshark 1 )
2445 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/reordercap 1 )
2446 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/text2pcap 1 )
2447 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/tshark 1 )
2448 pod2manhtml( ${CMAKE_BINARY_DIR}/wireshark 1 )
2449 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/wireshark-filter 4 )
2450
2451 add_custom_target(
2452         html_docs ALL
2453         DEPENDS
2454                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
2455                 androiddump.html
2456                 capinfos.html
2457                 captype.html
2458                 dftest.html
2459                 dumpcap.html
2460                 editcap.html
2461                 asn2deb.html
2462                 idl2deb.html
2463                 idl2wrs.html
2464                 mergecap.html
2465                 randpkt.html
2466                 rawshark.html
2467                 reordercap.html
2468                 text2pcap.html
2469                 tshark.html
2470                 wireshark.html
2471                 wireshark-filter.html
2472 )
2473 set_target_properties(html_docs PROPERTIES FOLDER "Docs")
2474
2475 set(CLEAN_FILES
2476         ${wireshark_FILES}
2477         ${tshark_FILES}
2478         ${rawshark_FILES}
2479         ${dftest_FILES}
2480         ${randpkt_FILES}
2481         ${text2pcap_CLEAN_FILES}
2482         ${mergecap_FILES}
2483         ${capinfos_FILES}
2484         ${captype_FILES}
2485         ${editcap_FILES}
2486         ${dumpcap_FILES}
2487         ${androiddump_FILES}
2488 )
2489
2490 if (WERROR_COMMON_FLAGS)
2491         set_source_files_properties(
2492                 ${CLEAN_FILES}
2493                 PROPERTIES
2494                 COMPILE_FLAGS ${WERROR_COMMON_FLAGS}
2495         )
2496 endif()
2497
2498 install(
2499         FILES
2500                 ${INSTALL_FILES}
2501         DESTINATION
2502                 ${CMAKE_INSTALL_DATADIR}/${CPACK_PACKAGE_NAME}
2503 )
2504
2505 install(
2506         FILES
2507                 ${MAN1_FILES}
2508         DESTINATION
2509                 ${CMAKE_INSTALL_MANDIR}/man1
2510 )
2511
2512 install(
2513         FILES
2514                 ${MAN4_FILES}
2515         DESTINATION
2516                 ${CMAKE_INSTALL_MANDIR}/man4
2517 )
2518
2519 install(
2520         FILES
2521                 "${CMAKE_BINARY_DIR}/wireshark.pc"
2522         DESTINATION
2523                 ${CMAKE_INSTALL_LIBDIR}/pkgconfig
2524 )
2525
2526 install(
2527         DIRECTORY
2528                 ${INSTALL_DIRS}
2529         DIRECTORY_PERMISSIONS
2530                 OWNER_EXECUTE OWNER_WRITE OWNER_READ
2531                 GROUP_EXECUTE GROUP_READ
2532                 WORLD_EXECUTE WORLD_READ
2533         DESTINATION
2534                 ${CMAKE_INSTALL_DATADIR}/${CPACK_PACKAGE_NAME}
2535         PATTERN ".git" EXCLUDE
2536         PATTERN ".svn" EXCLUDE
2537         PATTERN "Makefile.*" EXCLUDE
2538         PATTERN "faq.py" EXCLUDE
2539 )
2540
2541 include( UseCheckAPI )
2542 CHECKAPI(
2543         ${TSHARK_TAP_SRC}
2544         ${WIRESHARK_SRC}
2545 )
2546
2547 set(CMAKE_INSTALL_MODULES_DIR ${CMAKE_INSTALL_LIBDIR}/${CPACK_PACKAGE_NAME})
2548 configure_file("${CMAKE_MODULE_PATH}/WiresharkConfig.cmake.in" "${CMAKE_BINARY_DIR}/WiresharkConfig.cmake" @ONLY)
2549 configure_file("${CMAKE_MODULE_PATH}/WiresharkConfigVersion.cmake.in" "${CMAKE_BINARY_DIR}/WiresharkConfigVersion.cmake" @ONLY)
2550 install(
2551         FILES
2552                 ${CMAKE_MODULE_PATH}/FindGLIB2.cmake
2553                 ${CMAKE_MODULE_PATH}/FindWireshark.cmake
2554                 ${CMAKE_MODULE_PATH}/FindWSWinLibs.cmake
2555                 ${CMAKE_MODULE_PATH}/UseAsn2Wrs.cmake
2556                 ${CMAKE_MODULE_PATH}/LocatePythonModule.cmake
2557                 ${CMAKE_MODULE_PATH}/UseMakeDissectorReg.cmake
2558                 ${CMAKE_BINARY_DIR}/WiresharkConfig.cmake
2559                 ${CMAKE_BINARY_DIR}/WiresharkConfigVersion.cmake
2560         DESTINATION
2561                 ${CMAKE_INSTALL_MODULES_DIR}
2562 )
2563
2564 if(DOC_DIR)
2565         message(STATUS "Docdir install: ${DOC_DIR}")
2566         INSTALL(
2567                 DIRECTORY
2568                         ${CMAKE_BINARY_DIR}/docbook/
2569                 DIRECTORY_PERMISSIONS
2570                         OWNER_EXECUTE OWNER_WRITE OWNER_READ
2571                         GROUP_EXECUTE GROUP_READ
2572                         WORLD_EXECUTE WORLD_READ
2573                 DESTINATION
2574                         ${DOC_DIR}/guides
2575                 FILES_MATCHING
2576                 PATTERN "*.pdf"
2577         )
2578 endif()
2579
2580 # Test suite wrapper
2581 if(ENABLE_APPLICATION_BUNDLE)
2582         set(TEST_SH_BIN_DIR ${CMAKE_BINARY_DIR}/run)
2583 else()
2584         set(TEST_SH_BIN_DIR $<TARGET_FILE_DIR:epan>)
2585 endif()
2586
2587 add_custom_target(test-sh
2588         COMMAND ${CMAKE_COMMAND}
2589                 -DCMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}
2590                 -DTEST_SH_BIN_DIR=${TEST_SH_BIN_DIR}
2591                 -DTEST_SH_SRC_DIR=${CMAKE_SOURCE_DIR}/test
2592                 -P ${CMAKE_SOURCE_DIR}/cmake/modules/GenerateTestSh.cmake
2593         DEPENDS ${CMAKE_SOURCE_DIR}/cmake/modules/GenerateTestSh.cmake
2594 )
2595 set_target_properties(test-sh PROPERTIES FOLDER "Tests")
2596
2597 add_custom_target(test-programs
2598         DEPENDS test-sh
2599                 exntest
2600                 oids_test
2601                 reassemble_test
2602                 tvbtest
2603                 wmem_test
2604         COMMENT "Building unit test programs and wrapper"
2605 )
2606 set_target_properties(test-programs PROPERTIES FOLDER "Tests")
2607
2608 if (WIN32)
2609         file (TO_NATIVE_PATH ${CMAKE_SOURCE_DIR}/tools/Get-HardenFlags.ps1 _win_harden_flags)
2610         add_custom_target(hardening-check
2611                 COMMAND ${POWERSHELL_COMMAND} "${_win_harden_flags}" "${CMAKE_BINARY_DIR}"
2612                 DEPENDS ${PROGLIST}
2613                 COMMENT "Checking binaries for security features"
2614         )
2615         set_target_properties(hardening-check PROPERTIES FOLDER "Tests")
2616 else ()
2617         find_program(HARDENING_CHECK_EXECUTABLE hardening-check
2618                 DOC "Path to the hardening-check utility."
2619         )
2620         if (NOT "${HARDENING_CHECK_EXECUTABLE}" STREQUAL "HARDENING_CHECK_EXECUTABLE-NOTFOUND")
2621                 foreach(_prog ${PROGLIST})
2622                         get_target_property(_prog_dir ${_prog} RUNTIME_OUTPUT_DIRECTORY)
2623                         if ("${_prog_dir}" STREQUAL "_prog_dir-NOTFOUND")
2624                                 set(_prog_dir "${CMAKE_BINARY_DIR}/run")
2625                         endif()
2626                         set(_prog_paths ${_prog_paths} "${_prog_dir}/${_prog}")
2627                 endforeach()
2628                 add_custom_target(hardening-check
2629                         COMMAND ${HARDENING_CHECK_EXECUTABLE} ${_prog_paths}
2630                         DEPENDS ${PROGLIST}
2631                         COMMENT "Checking binaries for security features"
2632                 )
2633         endif()
2634 endif()
2635
2636 #
2637 # Editor modelines  -  http://www.wireshark.org/tools/modelines.html
2638 #
2639 # Local variables:
2640 # c-basic-offset: 8
2641 # tab-width: 8
2642 # indent-tabs-mode: t
2643 # End:
2644 #
2645 # vi: set shiftwidth=8 tabstop=8 noexpandtab:
2646 # :indentSize=8:tabSize=8:noTabs=false:
2647 #