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