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