CMakeLists.txt

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