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