CMakeLists.txt

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