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