CMakeLists.txt

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