CMakeLists.txt

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