CMakeLists.txt

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