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 if(ENABLE_APPLICATION_BUNDLE)
1545         add_custom_command(TARGET copy_data_files PRE_BUILD
1546                 COMMAND ${CMAKE_COMMAND} -E make_directory "${DATAFILE_DIR}"
1547         )
1548 endif()
1549
1550 if(WIN32)
1551         foreach(_text_file ${TEXTIFY_FILES})
1552                 add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/${_text_file}.txt
1553                         COMMAND ${POWERSHELL_COMMAND} "${CMAKE_SOURCE_DIR}/tools/textify.ps1"
1554                                 -Destination ${CMAKE_BINARY_DIR}
1555                                 ${CMAKE_SOURCE_DIR}/${_text_file}
1556                         DEPENDS
1557                                 ${CMAKE_SOURCE_DIR}/${_text_file}
1558                 )
1559         endforeach()
1560 endif()
1561
1562 foreach(_install_file ${INSTALL_FILES})
1563         get_filename_component(_install_basename "${_install_file}" NAME)
1564         add_custom_command(TARGET copy_data_files POST_BUILD
1565                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1566                         "${_install_file}"
1567                         "${DATAFILE_DIR}/${_install_basename}"
1568                 WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
1569         )
1570 endforeach()
1571
1572 if(ENABLE_EXTCAP)
1573         add_custom_command(TARGET copy_data_files PRE_BUILD
1574                 COMMAND ${CMAKE_COMMAND} -E make_directory
1575                         "${DATAFILE_DIR}/extcap"
1576         )
1577 endif()
1578 add_custom_command(TARGET copy_data_files PRE_BUILD
1579         COMMAND ${CMAKE_COMMAND} -E make_directory
1580                 "${DATAFILE_DIR}/help"
1581 )
1582 add_custom_command(TARGET copy_data_files PRE_BUILD
1583         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1584                 "${CMAKE_SOURCE_DIR}/help/toc"
1585                 "${DATAFILE_DIR}/help/toc"
1586 )
1587 if(WIN32)
1588         file(TO_NATIVE_PATH ${DATAFILE_DIR}/help _help_dest_dir)
1589         add_custom_command(TARGET copy_data_files PRE_BUILD
1590                 COMMAND ${POWERSHELL_COMMAND} "${CMAKE_SOURCE_DIR}/tools/textify.ps1"
1591                         -Destination ${_help_dest_dir}
1592                         ${CMAKE_SOURCE_DIR}/help/*.txt
1593         )
1594 else()
1595         file(GLOB _help_files
1596                 "${CMAKE_SOURCE_DIR}/help/*.txt"
1597         )
1598         foreach(_help_file ${_help_files})
1599                 add_custom_command(TARGET copy_data_files PRE_BUILD
1600                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1601                                 "${_help_file}"
1602                                 "${DATAFILE_DIR}/help/"
1603                 )
1604         endforeach()
1605 endif(WIN32)
1606 add_custom_command(TARGET copy_data_files PRE_BUILD
1607         COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/help/faq.py -b > faq.tmp.html
1608         COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tools/html2text.py
1609                 faq.tmp.html > "${DATAFILE_DIR}/help/faq.txt"
1610         COMMAND ${CMAKE_COMMAND} -E remove faq.tmp.html
1611 )
1612
1613 if(LUA_FOUND)
1614         add_custom_command(TARGET copy_data_files PRE_BUILD
1615                 COMMAND ${CMAKE_COMMAND} -E make_directory
1616                         "${DATAFILE_DIR}/lua"
1617         )
1618         add_custom_command(TARGET copy_data_files PRE_BUILD
1619                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1620                         "${CMAKE_BINARY_DIR}/epan/wslua/init.lua"
1621                         "${DATAFILE_DIR}"
1622         )
1623         add_custom_command(TARGET copy_data_files PRE_BUILD
1624                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1625                         "${CMAKE_SOURCE_DIR}/epan/wslua/console.lua"
1626                         "${DATAFILE_DIR}"
1627         )
1628         add_custom_command(TARGET copy_data_files PRE_BUILD
1629                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1630                         "${CMAKE_SOURCE_DIR}/epan/wslua/dtd_gen.lua"
1631                         "${DATAFILE_DIR}"
1632         )
1633         add_dependencies(copy_data_files wsluaauxiliary)
1634 endif(LUA_FOUND)
1635 # doc/*.html handled elsewhere.
1636 add_custom_command(TARGET copy_data_files PRE_BUILD
1637         COMMAND ${CMAKE_COMMAND} -E copy_directory
1638                 "${CMAKE_SOURCE_DIR}/dtds"
1639                 "${DATAFILE_DIR}/dtds"
1640 )
1641 # Skipping asn1 default.tt
1642 add_custom_command(TARGET copy_data_files PRE_BUILD
1643         COMMAND ${CMAKE_COMMAND} -E copy_directory
1644                 "${CMAKE_SOURCE_DIR}/radius"
1645                 "${DATAFILE_DIR}/radius"
1646 )
1647 add_custom_command(TARGET copy_data_files PRE_BUILD
1648         COMMAND ${CMAKE_COMMAND} -E make_directory
1649                 "${DATAFILE_DIR}/diameter"
1650 )
1651 file(GLOB _diameter_files
1652         "${CMAKE_SOURCE_DIR}/diameter/*.dtd"
1653         "${CMAKE_SOURCE_DIR}/diameter/*.xml"
1654 )
1655 foreach(_diameter_file ${_diameter_files})
1656         add_custom_command(TARGET copy_data_files PRE_BUILD
1657                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1658                         "${_diameter_file}"
1659                         "${DATAFILE_DIR}/diameter/"
1660         )
1661 endforeach()
1662 add_custom_command(TARGET copy_data_files PRE_BUILD
1663         COMMAND ${CMAKE_COMMAND} -E copy_directory
1664                 "${CMAKE_SOURCE_DIR}/profiles"
1665                 "${DATAFILE_DIR}/profiles"
1666 )
1667 add_custom_command(TARGET copy_data_files PRE_BUILD
1668         COMMAND ${CMAKE_COMMAND} -E make_directory
1669                 "${DATAFILE_DIR}/tpncp"
1670 )
1671 add_custom_command(TARGET copy_data_files PRE_BUILD
1672         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1673                 "${CMAKE_SOURCE_DIR}/tpncp/tpncp.dat"
1674                 "${DATAFILE_DIR}/tpncp/tpncp.dat"
1675 )
1676 add_custom_command(TARGET copy_data_files PRE_BUILD
1677         COMMAND ${CMAKE_COMMAND} -E copy_directory
1678                 "${CMAKE_SOURCE_DIR}/wimaxasncp"
1679                 "${DATAFILE_DIR}/wimaxasncp"
1680 )
1681
1682 if( (BUILD_wireshark AND QT_FOUND) OR (BUILD_wireshark_gtk AND GTK_FOUND) )
1683         set(WIRESHARK_SRC
1684                 capture_info.c
1685                 capture_opts.c
1686                 color_filters.c
1687                 file.c
1688                 fileset.c
1689                 summary.c
1690                 ${SHARK_COMMON_SRC}
1691                 ${PLATFORM_UI_SRC}
1692         )
1693         set(wireshark_FILES
1694                 ${WIRESHARK_SRC}
1695                 ${CMAKE_BINARY_DIR}/image/wireshark.rc
1696                 ${PLATFORM_UI_RC_FILES}
1697         )
1698 endif()
1699
1700 if(ENABLE_APPLICATION_BUNDLE)
1701         #
1702         # Add -Wl,-single_module to the LDFLAGS used with shared
1703         # libraries, to fix some error that show up in some cases;
1704         # some Apple documentation recommends it for most shared
1705         # libraries.
1706         #
1707         set( CMAKE_SHARED_LINKER_FLAGS "-Wl,-single_module ${CMAKE_SHARED_LINKER_FLAGS}" )
1708         #
1709         # Add -Wl,-headerpad_max_install_names to the LDFLAGS, as
1710         # code-signing issues is running out of padding space.
1711         #
1712         # Add -Wl,-search_paths_first to make sure that if we search
1713         # directories A and B, in that order, for a given library, a
1714         # non-shared version in directory A, rather than a shared
1715         # version in directory B, is chosen (so we can use
1716         # --with-pcap=/usr/local to force all programs to be linked
1717         # with a static version installed in /usr/local/lib rather than
1718         # the system version in /usr/lib).
1719         #
1720
1721         set(CMAKE_EXE_LINKER_FLAGS
1722         "-Wl,-headerpad_max_install_names -Wl,-search_paths_first ${CMAKE_EXE_LINKER_FLAGS}"
1723         )
1724
1725         # Add files to the app bundle
1726         # Wireshark.app/Contents
1727         file(WRITE ${CMAKE_BINARY_DIR}/packaging/macosx/PkgInfo "APPLWshk\n")
1728         set(BUNDLE_CONTENTS_FILES
1729                 ${CMAKE_BINARY_DIR}/packaging/macosx/PkgInfo
1730         )
1731         set_source_files_properties(${BUNDLE_CONTENTS_FILES} PROPERTIES
1732                 MACOSX_PACKAGE_LOCATION .
1733         )
1734
1735         # Wireshark.app/Contents/Resources
1736         set(BUNDLE_RESOURCE_FILES
1737                 ${CMAKE_SOURCE_DIR}/packaging/macosx/Resources/Wireshark.icns
1738                 ${CMAKE_SOURCE_DIR}/packaging/macosx/Resources/Wiresharkdoc.icns
1739         )
1740         set_source_files_properties(${BUNDLE_RESOURCE_FILES} PROPERTIES
1741                 MACOSX_PACKAGE_LOCATION Resources
1742         )
1743
1744         # Wireshark.app/Contents/Resources/share/man/man1
1745         set(BUNDLE_RESOURCE_SHARE_MAN1_FILES ${MAN1_FILES})
1746         set_source_files_properties(${BUNDLE_RESOURCE_SHARE_MAN1_FILES} PROPERTIES
1747                 MACOSX_PACKAGE_LOCATION Resources/share/man/man1
1748         )
1749
1750         # Wireshark.app/Contents/Resources/share/man/man1
1751         set(BUNDLE_RESOURCE_SHARE_MAN4_FILES ${MAN4_FILES})
1752         set_source_files_properties(${BUNDLE_RESOURCE_SHARE_MAN4_FILES} PROPERTIES
1753                 MACOSX_PACKAGE_LOCATION Resources/share/man/man4
1754         )
1755
1756         # INSTALL_FILES and INSTALL_DIRS are handled by copy_data_files
1757
1758         set(EXTRA_BUNDLE_FILES
1759                 ${BUNDLE_CONTENTS_FILES}
1760                 ${BUNDLE_RESOURCE_FILES}
1761                 ${BUNDLE_RESOURCE_SHARE_MAN1_FILES}
1762                 ${BUNDLE_RESOURCE_SHARE_MAN4_FILES}
1763         )
1764 else()
1765         set(EXTRA_BUNDLE_FILES)
1766 endif()
1767
1768 if(BUILD_wireshark AND QT_FOUND)
1769         set(wireshark_LIBS
1770                 qtui
1771                 ui
1772                 capchild
1773                 caputils
1774                 ${QT_LIBRARIES}
1775                 ${GTHREAD2_LIBRARIES}
1776                 codecs
1777                 ${LIBEPAN_LIBS}
1778                 ${APPLE_APPLICATION_SERVICES_LIBRARY}
1779                 ${APPLE_CORE_FOUNDATION_LIBRARY}
1780                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
1781                 ${NL_LIBRARIES}
1782         )
1783
1784         # Policy since 2.8.11
1785         if (POLICY CMP0020)
1786                 cmake_policy(SET CMP0020 NEW)
1787         endif()
1788
1789         add_executable(wireshark WIN32 MACOSX_BUNDLE wireshark-qt.cpp ${wireshark_FILES} ${EXTRA_BUNDLE_FILES})
1790         set(PROGLIST ${PROGLIST} wireshark)
1791         set_target_properties(wireshark PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1792         set_target_properties(wireshark PROPERTIES FOLDER "Executables")
1793         if(ENABLE_APPLICATION_BUNDLE OR WIN32)
1794                 set_target_properties(wireshark PROPERTIES OUTPUT_NAME Wireshark)
1795         endif()
1796
1797         if(ENABLE_APPLICATION_BUNDLE)
1798                 set_target_properties(
1799                         wireshark PROPERTIES
1800                                 MACOSX_BUNDLE_INFO_PLIST ${CMAKE_BINARY_DIR}/packaging/macosx/Info.plist
1801                 )
1802                 # Add a wrapper script which opens the bundle. This adds
1803                 # convenience but makes debugging more difficult.
1804                 file(REMOVE ${CMAKE_BINARY_DIR}/run/wireshark)
1805                 file(WRITE ${CMAKE_BINARY_DIR}/run/wireshark "#!/bin/sh\n")
1806                 file(APPEND ${CMAKE_BINARY_DIR}/run/wireshark "open ${CMAKE_BINARY_DIR}/run/Wireshark.app --args \"\$\@\"\n")
1807                 execute_process(COMMAND chmod a+x ${CMAKE_BINARY_DIR}/run/wireshark)
1808         endif()
1809
1810         target_link_libraries(wireshark ${wireshark_LIBS})
1811         install(
1812                 TARGETS wireshark
1813                 RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
1814                 BUNDLE DESTINATION ${CMAKE_INSTALL_BINDIR}
1815         )
1816
1817         if(NOT ENABLE_APPLICATION_BUNDLE)
1818                 # Map for endpoints dialog
1819                 ADD_CUSTOM_COMMAND(
1820                         TARGET wireshark
1821                         POST_BUILD
1822                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
1823                                 "${PROJECT_SOURCE_DIR}/ipmap.html"
1824                                 $<TARGET_FILE_DIR:wireshark>
1825                 )
1826         endif()
1827
1828         if(WIN32 AND Qt5Core_FOUND)
1829                 # Use windeployqt to copy our required DLLs to the run path.
1830                 # Ideally one of the modules in ${QTDIR}/lib/cmake would expose
1831                 # the path to windeployqt. For that matter having a reliable
1832                 # path to qmake would be *amazingly convenient*. We don't have
1833                 # either of those so we try to discover the path via Qt5Core.
1834                 # http://stackoverflow.com/questions/24650936/qt5-with-cmake-how-to-find-qt-translations-dir
1835
1836                 get_target_property(_qmake_location Qt5::qmake IMPORTED_LOCATION)
1837                 get_filename_component(_qt_bin_path "${_qmake_location}" DIRECTORY)
1838                 find_program(QT_WINDEPLOYQT_EXECUTABLE windeployqt
1839                         HINTS "${_qmake_location}"
1840                         DOC "Path to the windeployqt utility."
1841                 )
1842                 if (NOT "${QT_WINDEPLOYQT_EXECUTABLE}" STREQUAL "QT_WINDEPLOYQT_EXECUTABLE-NOTFOUND")
1843                         set(QT_BIN_PATH "${_qt_bin_path}" CACHE INTERNAL
1844                                 "Path to qmake, windeployqt, and other Qt utilities."
1845                         )
1846                         add_custom_target(copy_qt_dlls ALL)
1847                         set_target_properties(copy_qt_dlls PROPERTIES FOLDER "Copy Tasks")
1848                         # Will we ever need to use --debug? Windeployqt seems to
1849                         # be smart enough to copy debug DLLs when needed.
1850                         add_custom_command(TARGET copy_qt_dlls
1851                                 POST_BUILD
1852                                 COMMAND set "PATH=%PATH%;${QT_BIN_PATH}"
1853                                 COMMAND "${QT_WINDEPLOYQT_EXECUTABLE}"
1854                                         $<$<CONFIG:Debug>:--debug>
1855                                         $<$<NOT:$<CONFIG:Debug>>:--release>
1856                                         --no-compiler-runtime
1857                                         --verbose 10
1858                                         "$<TARGET_FILE:wireshark>"
1859                         )
1860                         add_dependencies(copy_qt_dlls wireshark)
1861                 endif()
1862         endif(WIN32 AND Qt5Core_FOUND)
1863 endif()
1864
1865 # Common properties for CLI executables
1866 macro(set_extra_executable_properties _executable _folder)
1867         set_target_properties(${_executable} PROPERTIES
1868                 LINK_FLAGS "${WS_LINK_FLAGS}"
1869                 FOLDER ${_folder}
1870         )
1871
1872         set(PROGLIST ${PROGLIST} ${_executable})
1873
1874         if(ENABLE_APPLICATION_BUNDLE)
1875                 set_target_properties(${_executable} PROPERTIES
1876                         RUNTIME_OUTPUT_DIRECTORY run/Wireshark.app/Contents/MacOS
1877                 )
1878                 # Add a wrapper script which runs each executable from the
1879                 # correct location. This adds convenience but makes debugging
1880                 # more difficult.
1881                 file(REMOVE ${CMAKE_BINARY_DIR}/run/${_executable})
1882                 file(WRITE ${CMAKE_BINARY_DIR}/run/${_executable} "#!/bin/sh\n")
1883                 file(APPEND ${CMAKE_BINARY_DIR}/run/${_executable} "exec ${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/MacOS/${_executable} \"\$\@\"\n")
1884                 execute_process(COMMAND chmod a+x ${CMAKE_BINARY_DIR}/run/${_executable})
1885         endif()
1886 endmacro()
1887
1888 macro(set_extcap_executable_properties _executable)
1889         set_target_properties(${_executable} PROPERTIES FOLDER "Executables/Extcaps")
1890
1891         set(PROGLIST ${PROGLIST} ${_executable})
1892
1893         if(WIN32)
1894                 set_target_properties(${_executable} PROPERTIES
1895                         LINK_FLAGS "${WS_LINK_FLAGS}"
1896                         RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/run/extcap
1897                         RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/run/Debug/extcap
1898                         RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/run/Release/extcap
1899                         RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${CMAKE_BINARY_DIR}/run/MinSizeRel/extcap
1900                         RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_BINARY_DIR}/run/RelWithDebInfo/extcap
1901                 )
1902         else()
1903                 set_target_properties(${_executable} PROPERTIES
1904                         LINK_FLAGS "${WS_LINK_FLAGS}"
1905                         RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/run/extcap
1906                 )
1907                 if(ENABLE_APPLICATION_BUNDLE)
1908                         set_target_properties(${_executable} PROPERTIES
1909                                 RUNTIME_OUTPUT_DIRECTORY run/Wireshark.app/Contents/MacOS/extcap
1910                         )
1911                         # Add a wrapper script which runs each executable from the
1912                         # correct location. This adds convenience but makes debugging
1913                         # more difficult.
1914                         file(REMOVE ${CMAKE_BINARY_DIR}/run/${_executable})
1915                         file(WRITE ${CMAKE_BINARY_DIR}/run/${_executable} "#!/bin/sh\n")
1916                         file(APPEND ${CMAKE_BINARY_DIR}/run/${_executable} "exec ${CMAKE_BINARY_DIR}/run/Wireshark.app/Contents/MacOS/extcap/${_executable} \"\$\@\"\n")
1917                         execute_process(COMMAND chmod a+x ${CMAKE_BINARY_DIR}/run/${_executable})
1918                 endif()
1919         endif()
1920 endmacro()
1921
1922 if(BUILD_wireshark_gtk AND GTK_FOUND)
1923         set(wireshark_gtk_LIBS
1924                 gtkui
1925                 ui
1926                 capchild
1927                 caputils
1928                 ${GTK2_LIBRARIES}
1929                 ${GTK3_LIBRARIES}
1930                 ${GTHREAD2_LIBRARIES}
1931                 codecs
1932                 ${PORTAUDIO_LIBRARIES}
1933                 ${LIBEPAN_LIBS}
1934                 ${APPLE_APPLICATION_SERVICES_LIBRARY}
1935                 ${APPLE_CORE_SERVICES_LIBRARY}
1936                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
1937                 ${NL_LIBRARIES}
1938                 ${WIN_COMCTL32_LIBRARY}
1939         )
1940         # wireshark and wireshark-gtk share wireshark_FILES
1941
1942         add_executable(wireshark-gtk WIN32 ${wireshark_FILES})
1943         set(PROGLIST ${PROGLIST} wireshark-gtk)
1944         set_target_properties(wireshark-gtk PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1945         set_target_properties(wireshark-gtk PROPERTIES FOLDER "Executables")
1946         target_link_libraries(wireshark-gtk ${wireshark_gtk_LIBS})
1947         install(TARGETS wireshark-gtk RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1948
1949         # Map for endpoints dialog
1950         ADD_CUSTOM_COMMAND(
1951                 TARGET wireshark-gtk
1952                 POST_BUILD
1953                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1954                         "${PROJECT_SOURCE_DIR}/ipmap.html"
1955                         $<TARGET_FILE_DIR:wireshark-gtk>
1956         )
1957
1958         if(WIN32)
1959                 get_target_property(_wsgtk_location wireshark-gtk LOCATION)
1960                 get_filename_component(_dll_output_dir "${_wsgtk_location}" PATH)
1961                 add_custom_target(copy_gtk_dlls)
1962                 set_target_properties(copy_gtk_dlls PROPERTIES FOLDER "Copy Tasks")
1963                 add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1964                         COMMAND ${CMAKE_COMMAND} -E make_directory "${_dll_output_dir}"
1965                 )
1966
1967                 if(GTK2_FOUND)
1968                         set(_gtk_dll_dir "${GTK2_DLL_DIR}")
1969                         set(_gtk_etc_dir "${GTK2_ETC_DIR}")
1970                         set(_gtk_dlls "${GTK2_DLLS}")
1971                         set(_gtk_etc_dir "${GTK2_ETC_DIR}")
1972                 else()
1973                         set(_gtk_dll_dir "${GTK3_DLL_DIR}")
1974                         set(_gtk_dlls "${GTK3_DLLS}")
1975                         set(_gtk_etc_dir "${GTK3_ETC_DIR}")
1976                 endif()
1977
1978                 foreach(_dll ${_gtk_dlls})
1979                         add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1980                                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1981                                         "${_gtk_dll_dir}/${_dll}" "${_dll_output_dir}"
1982                         )
1983                 endforeach(_dll)
1984
1985                 # /etc
1986                 add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1987                         COMMAND ${CMAKE_COMMAND} -E make_directory "${_dll_output_dir}/etc"
1988                 )
1989                 add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1990                         COMMAND ${CMAKE_COMMAND} -E copy_directory
1991                                 "${_gtk_etc_dir}" "${_dll_output_dir}/etc"
1992                 )
1993
1994                 # XXX - Omitting ${GTK2_LIB_DIR}\loaders copying from Makefile.nmake
1995                 if(GTK2_FOUND)
1996                         # Engines
1997                         set (_engines_output_dir "${_dll_output_dir}/lib/gtk-2.0/2.10.0/engines")
1998                         add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
1999                                 COMMAND ${CMAKE_COMMAND} -E make_directory "${_engines_output_dir}"
2000                         )
2001                         foreach(_dll ${GTK2_ENGINES_DLLS})
2002                                 add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
2003                                         COMMAND ${CMAKE_COMMAND} -E copy_if_different
2004                                                 "${GTK2_ENGINES_DLL_DIR}/${_dll}" "${_engines_output_dir}"
2005                                 )
2006                         endforeach(_dll)
2007
2008                         # Themes
2009                         add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
2010                                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
2011                                         "${GTK2_THEMES_DIR}/gtkrc" "${_dll_output_dir}/etc/gtk-2.0"
2012                         )
2013
2014                         # Modules
2015                         add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
2016                                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2017                                         "${GTK2_LIB_DIR}" "${_dll_output_dir}/lib/gtk-2.0"
2018                         )
2019                 else()
2020                         add_custom_command(TARGET copy_gtk_dlls PRE_BUILD
2021                                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2022                                         "${CMAKE_SOURCE_DIR}/ui/win32/settings.ini" "${_dll_output_dir}/etc"
2023                         )
2024                 endif()
2025
2026                 add_dependencies(wireshark-gtk copy_gtk_dlls copy_cli_dlls)
2027         endif(WIN32)
2028 endif()
2029
2030 register_tap_files(tshark-tap-register.c
2031         tshark-taps
2032         ${TSHARK_TAP_SRC}
2033 )
2034
2035 if(BUILD_tshark)
2036         set(tshark_LIBS
2037                 ui
2038                 capchild
2039                 caputils
2040                 ${LIBEPAN_LIBS}
2041                 ${APPLE_CORE_FOUNDATION_LIBRARY}
2042                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
2043         )
2044         set(tshark_FILES
2045                 capture_opts.c
2046                 tshark-tap-register.c
2047                 tshark.c
2048                 ${TSHARK_TAP_SRC}
2049                 ${SHARK_COMMON_SRC}
2050                 ${CMAKE_BINARY_DIR}/image/tshark.rc
2051         )
2052         add_executable(tshark ${tshark_FILES})
2053         set_extra_executable_properties(tshark "Executables")
2054         target_link_libraries(tshark ${tshark_LIBS})
2055         install(TARGETS tshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2056 endif()
2057
2058 if(BUILD_tfshark)
2059         set(tfshark_LIBS
2060                 ui
2061                 ${LIBEPAN_LIBS}
2062                 ${APPLE_CORE_FOUNDATION_LIBRARY}
2063                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
2064         )
2065         set(tfshark_FILES
2066                 tfshark.c
2067                 ${TSHARK_TAP_SRC}
2068                 ${SHARK_COMMON_SRC}
2069                 ${CMAKE_BINARY_DIR}/image/tfshark.rc
2070         )
2071         add_executable(tfshark ${tfshark_FILES})
2072         set_extra_executable_properties(tfshark "Executables")
2073         target_link_libraries(tfshark ${tfshark_LIBS})
2074         install(TARGETS tfshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2075 endif()
2076
2077 if(BUILD_rawshark AND PCAP_FOUND)
2078         set(rawshark_LIBS
2079                 caputils
2080                 ${LIBEPAN_LIBS}
2081                 ${APPLE_CORE_FOUNDATION_LIBRARY}
2082                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
2083         )
2084         set(rawshark_FILES
2085                 ${SHARK_COMMON_SRC}
2086                 rawshark.c
2087                 ui/util.c
2088                 ${CMAKE_BINARY_DIR}/image/rawshark.rc
2089         )
2090         add_executable(rawshark ${rawshark_FILES})
2091         set_extra_executable_properties(rawshark "Executables")
2092         target_link_libraries(rawshark ${rawshark_LIBS})
2093         install(TARGETS rawshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2094 endif()
2095
2096 if(BUILD_dftest)
2097         set(dftest_LIBS
2098                 ${LIBEPAN_LIBS}
2099         )
2100         set(dftest_FILES
2101                 dftest.c
2102                 ui/util.c
2103         )
2104         add_executable(dftest ${dftest_FILES})
2105         set_extra_executable_properties(dftest "Tests")
2106         target_link_libraries(dftest ${dftest_LIBS})
2107         install(TARGETS dftest RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2108 endif()
2109
2110 if(BUILD_randpkt)
2111         set(randpkt_LIBS
2112                 wiretap
2113                 wsutil
2114                 ${M_LIBRARIES}
2115                 ${PCAP_LIBRARIES}
2116 #               @SOCKET_LIBS@
2117 #               @NSL_LIBS@
2118                 ${CARES_LIBRARIES}
2119                 ${ADNS_LIBRARIES}
2120                 ${ZLIB_LIBRARIES}
2121         )
2122         set(randpkt_FILES
2123                 randpkt.c
2124                 randpkt-core.c
2125         )
2126         add_executable(randpkt ${randpkt_FILES})
2127         set_extra_executable_properties(randpkt "Executables")
2128         target_link_libraries(randpkt ${randpkt_LIBS})
2129         install(TARGETS randpkt RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2130 endif()
2131
2132 if(BUILD_text2pcap)
2133         set(text2pcap_LIBS
2134                 wsutil
2135                 ${M_LIBRARIES}
2136                 ${ZLIB_LIBRARIES}
2137         )
2138         set(text2pcap_CLEAN_FILES
2139                 text2pcap.c
2140                 pcapio.c
2141         )
2142         set(text2pcap_FILES
2143                 ${text2pcap_CLEAN_FILES}
2144                 ${CMAKE_BINARY_DIR}/image/text2pcap.rc
2145         )
2146         add_lex_files(text2pcap_FILES
2147                 text2pcap-scanner.l
2148         )
2149         add_executable(text2pcap ${text2pcap_FILES})
2150         set_extra_executable_properties(text2pcap "Executables")
2151         target_link_libraries(text2pcap ${text2pcap_LIBS})
2152         install(TARGETS text2pcap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2153 endif()
2154
2155 if(BUILD_mergecap)
2156         set(mergecap_LIBS
2157                 wiretap
2158                 ${ZLIB_LIBRARIES}
2159                 ${CMAKE_DL_LIBS}
2160         )
2161         set(mergecap_FILES
2162                 mergecap.c
2163                 ${CMAKE_BINARY_DIR}/image/mergecap.rc
2164         )
2165         add_executable(mergecap ${mergecap_FILES})
2166         set_extra_executable_properties(mergecap "Executables")
2167         target_link_libraries(mergecap ${mergecap_LIBS})
2168         install(TARGETS mergecap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2169 endif()
2170
2171 if(BUILD_reordercap)
2172         set(reordercap_LIBS
2173                 wiretap
2174                 ${ZLIB_LIBRARIES}
2175                 ${CMAKE_DL_LIBS}
2176         )
2177         set(reordercap_FILES
2178                 reordercap.c
2179                 ${CMAKE_BINARY_DIR}/image/reordercap.rc
2180         )
2181         add_executable(reordercap ${reordercap_FILES})
2182         set_extra_executable_properties(reordercap "Executables")
2183         target_link_libraries(reordercap ${reordercap_LIBS})
2184         install(TARGETS reordercap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2185 endif()
2186
2187 if(BUILD_capinfos)
2188         set(capinfos_LIBS
2189                 wiretap
2190                 wsutil
2191                 ${ZLIB_LIBRARIES}
2192                 ${GCRYPT_LIBRARIES}
2193                 ${CMAKE_DL_LIBS}
2194         )
2195         set(capinfos_FILES
2196                 capinfos.c
2197                 ${CMAKE_BINARY_DIR}/image/capinfos.rc
2198         )
2199         add_executable(capinfos ${capinfos_FILES})
2200         set_extra_executable_properties(capinfos "Executables")
2201         target_link_libraries(capinfos ${capinfos_LIBS})
2202         install(TARGETS capinfos RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2203 endif()
2204
2205 if(BUILD_captype)
2206         set(captype_LIBS
2207                 wiretap
2208                 wsutil
2209                 ${ZLIB_LIBRARIES}
2210                 ${CMAKE_DL_LIBS}
2211         )
2212         set(captype_FILES
2213                 captype.c
2214                 ${CMAKE_BINARY_DIR}/image/captype.rc
2215         )
2216         add_executable(captype ${captype_FILES})
2217         set_extra_executable_properties(captype "Executables")
2218         target_link_libraries(captype ${captype_LIBS})
2219         install(TARGETS captype RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2220 endif()
2221
2222 if(BUILD_editcap)
2223         set(editcap_LIBS
2224                 wiretap
2225                 ${ZLIB_LIBRARIES}
2226                 ${CMAKE_DL_LIBS}
2227         )
2228         set(editcap_FILES
2229                 editcap.c
2230                 ${CMAKE_BINARY_DIR}/image/editcap.rc
2231         )
2232         add_executable(editcap ${editcap_FILES})
2233         set_extra_executable_properties(editcap "Executables")
2234         target_link_libraries(editcap ${editcap_LIBS})
2235         install(TARGETS editcap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
2236 endif()
2237
2238 if(BUILD_dumpcap AND PCAP_FOUND)
2239         set(dumpcap_LIBS
2240                 wsutil
2241                 caputils
2242                 ${PCAP_LIBRARIES}
2243                 ${CAP_LIBRARIES}
2244 #               @SOCKET_LIBS@
2245 #               @NSL_LIBS@
2246                 ${GLIB2_LIBRARIES}
2247                 ${GTHREAD2_LIBRARIES}
2248                 ${ZLIB_LIBRARIES}
2249                 ${APPLE_CORE_FOUNDATION_LIBRARY}
2250                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
2251                 ${NL_LIBRARIES}
2252         )
2253         set(dumpcap_FILES
2254                 capture_opts.c
2255                 capture_stop_conditions.c
2256                 conditions.c
2257                 dumpcap.c
2258                 pcapio.c
2259                 ringbuffer.c
2260                 sync_pipe_write.c
2261                 ${CMAKE_BINARY_DIR}/image/dumpcap.rc
2262         )
2263         add_executable(dumpcap ${dumpcap_FILES})
2264         set_extra_executable_properties(dumpcap "Executables")
2265         target_link_libraries(dumpcap ${dumpcap_LIBS})
2266         install(TARGETS dumpcap
2267                         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
2268                         PERMISSIONS ${DUMPCAP_SETUID}
2269                                 OWNER_READ OWNER_WRITE OWNER_EXECUTE
2270                                 GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
2271         )
2272         if(DUMPCAP_INSTALL_OPTION STREQUAL "capabilities")
2273                 install( CODE "execute_process(
2274                         COMMAND
2275                                 ${SETCAP_EXECUTABLE}
2276                                 cap_net_raw,cap_net_admin+ep
2277                                 ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}/dumpcap${CMAKE_EXECUTABLE_SUFFIX}
2278                         RESULT_VARIABLE
2279                                 _SETCAP_RESULT
2280                         )
2281                         if( _SETCAP_RESULT )
2282                                 message( WARNING \"setcap failed (${_SETCAP_RESULT}).\")
2283                         endif()"
2284                 )
2285         endif()
2286 endif()
2287
2288 if (WIN32)
2289         # Must come after executable targets are defined.
2290         find_package( NSIS )
2291
2292         if (NOT "${MAKENSIS_EXECUTABLE}" STREQUAL "MAKENSIS_EXECUTABLE-NOTFOUND")
2293                 add_subdirectory( packaging/nsis EXCLUDE_FROM_ALL )
2294                 ADD_NSIS_UNINSTALLER_TARGET()
2295                 ADD_NSIS_PACKAGE_TARGET()
2296         endif()
2297
2298         find_package( PortableApps )
2299         if (
2300                 NOT "${PORTABLEAPPS_LAUNCHER_GENERATOR_EXECUTABLE}" STREQUAL "PORTABLEAPPS_LAUNCHER_GENERATOR_EXECUTABLE-NOTFOUND"
2301                 AND
2302                 NOT "${PORTABLEAPPS_INSTALLER_EXECUTABLE}" STREQUAL "PORTABLEAPPS_INSTALLER_EXECUTABLE-NOTFOUND"
2303         )
2304                 add_subdirectory( packaging/portableapps EXCLUDE_FROM_ALL )
2305                 ADD_PORTABLEAPPS_PACKAGE_TARGET()
2306         endif()
2307 endif()
2308
2309 if(BUILD_androiddump)
2310         if(EXTCAP_ANDROIDDUMP_LIBPCAP)
2311                 if(HAVE_LIBPCAP)
2312                         set(androiddump_LIBS
2313                                 ${GLIB2_LIBRARIES}
2314                                 ${PCAP_LIBRARIES}
2315                         )
2316                 else()
2317                         message(FATAL_ERROR "You try to build androiddump with libpcap but do not have it")
2318                 endif()
2319         else()
2320                 set(androiddump_LIBS
2321                         wiretap
2322                         ${GLIB2_LIBRARIES}
2323                         ${CMAKE_DL_LIBS}
2324                 )
2325         endif()
2326         set(androiddump_FILES
2327                 extcap/androiddump.c
2328         )
2329
2330         add_executable(androiddump WIN32 ${androiddump_FILES})
2331         # XXX Shouldn't we add wsutil to androiddump_LIBS instead?
2332         set_extcap_executable_properties(androiddump)
2333         target_link_libraries(androiddump ${androiddump_LIBS})
2334         install(TARGETS androiddump RUNTIME DESTINATION ${EXTCAP_DIR})
2335 endif()
2336
2337 if(BUILD_sshdump AND LIBSSH_FOUND)
2338         set(sshdump_LIBS
2339                 ${GLIB2_LIBRARIES}
2340                 ${CMAKE_DL_LIBS}
2341                 ${LIBSSH_LIBRARIES}
2342         )
2343         if (WIN32)
2344                 set(sshdump_LIBS wsutil ${sshdump_LIBS})
2345         endif()
2346         set(sshdump_FILES
2347                 extcap/sshdump.c
2348         )
2349
2350         add_executable(sshdump WIN32 ${sshdump_FILES})
2351         set_extcap_executable_properties(sshdump)
2352         target_link_libraries(sshdump ${sshdump_LIBS})
2353         target_include_directories(sshdump PUBLIC ${LIBSSH_INCLUDE_DIR})
2354         install(TARGETS sshdump RUNTIME DESTINATION ${EXTCAP_DIR})
2355 elseif (BUILD_sshdump)
2356         #message( WARNING "Cannot find libssh, cannot build sshdump" )
2357 endif()
2358
2359 ADD_CUSTOM_COMMAND(
2360         OUTPUT  ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
2361         COMMAND ${PERL_EXECUTABLE}
2362                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
2363                 ${CMAKE_SOURCE_DIR}/doc/make-authors-short.pl
2364                 < ${CMAKE_SOURCE_DIR}/AUTHORS
2365                 > ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
2366         DEPENDS
2367                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
2368                 ${CMAKE_SOURCE_DIR}/doc/make-authors-short.pl
2369                 ${CMAKE_SOURCE_DIR}/AUTHORS
2370 )
2371
2372 ADD_CUSTOM_COMMAND(
2373         OUTPUT  ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
2374         COMMAND ${PERL_EXECUTABLE}
2375                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
2376                 ${CMAKE_SOURCE_DIR}/doc/make-authors-format.pl
2377                 < ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
2378                 > ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
2379         DEPENDS
2380                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
2381                 ${CMAKE_SOURCE_DIR}/doc/make-authors-format.pl
2382                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
2383 )
2384
2385 if(WIN32)
2386 FILE(TO_NATIVE_PATH ${CMAKE_SOURCE_DIR}/doc/wireshark.pod.template WPT_WIN_PATH)
2387 FILE(TO_NATIVE_PATH ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT ASF_WIN_PATH)
2388 FILE(TO_NATIVE_PATH ${CMAKE_BINARY_DIR}/wireshark.pod WP_WIN_PATH)
2389 ADD_CUSTOM_COMMAND(
2390         OUTPUT  ${CMAKE_BINARY_DIR}/wireshark.pod
2391         COMMAND copy /B ${WPT_WIN_PATH} + ${ASF_WIN_PATH} ${WP_WIN_PATH}
2392         DEPENDS
2393                 ${CMAKE_SOURCE_DIR}/doc/wireshark.pod.template
2394                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
2395 )
2396 else()
2397
2398 ADD_CUSTOM_COMMAND(
2399         OUTPUT  ${CMAKE_BINARY_DIR}/wireshark.pod
2400         COMMAND cat
2401                 ${CMAKE_SOURCE_DIR}/doc/wireshark.pod.template
2402                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
2403                 > ${CMAKE_BINARY_DIR}/wireshark.pod
2404         DEPENDS
2405                 ${CMAKE_SOURCE_DIR}/doc/wireshark.pod.template
2406                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
2407 )
2408 endif()
2409
2410 if(ENABLE_APPLICATION_BUNDLE)
2411         add_custom_target(app_bundle)
2412         set_target_properties(app_bundle PROPERTIES FOLDER "Copy Tasks")
2413         add_custom_command(TARGET app_bundle
2414                 POST_BUILD
2415                 COMMAND "${CMAKE_SOURCE_DIR}/packaging/macosx/osx-app.sh"
2416                 WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/run"
2417         )
2418         add_dependencies(app_bundle ${PROGLIST})
2419
2420         add_custom_target(dmg_package_prep DEPENDS app_bundle)
2421
2422         ADD_CUSTOM_COMMAND(
2423                 OUTPUT ${CMAKE_BINARY_DIR}/packaging/macosx/PkgInfo
2424                 COMMAND ${CMAKE_COMMAND} -E echo APPLWshk > ${CMAKE_BINARY_DIR}/packaging/macosx/PkgInfo
2425         )
2426
2427         ADD_CUSTOM_TARGET( dmg_package
2428                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
2429                                         "${PROJECT_SOURCE_DIR}/ipmap.html"
2430                                         $<TARGET_FILE_DIR:wireshark>
2431                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2432                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/ChmodBPF
2433                                         ${CMAKE_BINARY_DIR}/run/ChmodBPF
2434                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2435                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/Resources
2436                                         ${CMAKE_BINARY_DIR}/run/Resources
2437                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2438                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/Scripts
2439                                         ${CMAKE_BINARY_DIR}/run/Scripts
2440                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2441                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/utility-launcher
2442                                         ${CMAKE_BINARY_DIR}/run/utility-launcher
2443                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
2444                                         ${CMAKE_SOURCE_DIR}/COPYING
2445                                         ${CMAKE_BINARY_DIR}/run/COPYING.txt
2446                 COMMAND ${CMAKE_COMMAND} -E copy_directory
2447                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/Wireshark_package.pmdoc
2448                                         ${CMAKE_BINARY_DIR}/run/Wireshark_package.pmdoc
2449                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
2450                                         ${CMAKE_BINARY_DIR}/packaging/macosx/Wireshark_package.pmdoc/index.xml
2451                                         ${CMAKE_BINARY_DIR}/run/Wireshark_package.pmdoc/index.xml
2452                 COMMAND ${CMAKE_COMMAND} -E copy_if_different
2453                                         ${CMAKE_SOURCE_DIR}/packaging/macosx/dmg_background.png
2454                                         ${CMAKE_BINARY_DIR}/run/dmg_background.png
2455                 COMMAND bash -x ${CMAKE_BINARY_DIR}/packaging/macosx/osx-dmg.sh
2456                         --source-directory ${CMAKE_SOURCE_DIR}/packaging/macosx
2457                 # Unlike nsis_package_prep + nsis_package, we can add a direct
2458                 # dependency here.
2459                 DEPENDS dmg_package_prep
2460                 # We create Wireshark.app in "run". Do our work there.
2461                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/run
2462         )
2463
2464 endif()
2465
2466 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/androiddump 1 )
2467 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/capinfos 1 )
2468 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/captype 1 )
2469 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/dftest 1 )
2470 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/dumpcap 1 )
2471 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/editcap 1 )
2472 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/extcap 4 )
2473 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/asn2deb 1 )
2474 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/idl2deb 1 )
2475 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/idl2wrs 1 )
2476 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/mergecap 1 )
2477 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/randpkt 1 )
2478 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/rawshark 1 )
2479 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/reordercap 1 )
2480 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/sshdump 1 )
2481 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/text2pcap 1 )
2482 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/tshark 1 )
2483 pod2manhtml( ${CMAKE_BINARY_DIR}/wireshark 1 )
2484 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/wireshark-filter 4 )
2485
2486 add_custom_target(
2487         html_docs ALL
2488         DEPENDS
2489                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
2490                 androiddump.html
2491                 capinfos.html
2492                 captype.html
2493                 dftest.html
2494                 dumpcap.html
2495                 editcap.html
2496                 asn2deb.html
2497                 idl2deb.html
2498                 idl2wrs.html
2499                 mergecap.html
2500                 randpkt.html
2501                 rawshark.html
2502                 reordercap.html
2503                 sshdump.html
2504                 text2pcap.html
2505                 tshark.html
2506                 wireshark.html
2507                 wireshark-filter.html
2508 )
2509 set_target_properties(html_docs PROPERTIES FOLDER "Docs")
2510
2511 set(CLEAN_FILES
2512         ${wireshark_FILES}
2513         ${tshark_FILES}
2514         ${rawshark_FILES}
2515         ${dftest_FILES}
2516         ${randpkt_FILES}
2517         ${text2pcap_CLEAN_FILES}
2518         ${mergecap_FILES}
2519         ${capinfos_FILES}
2520         ${captype_FILES}
2521         ${editcap_FILES}
2522         ${dumpcap_FILES}
2523         ${androiddump_FILES}
2524         ${sshdump_FILES}
2525 )
2526
2527 if (WERROR_COMMON_FLAGS)
2528         set_source_files_properties(
2529                 ${CLEAN_FILES}
2530                 PROPERTIES
2531                 COMPILE_FLAGS ${WERROR_COMMON_FLAGS}
2532         )
2533 endif()
2534
2535 install(
2536         FILES
2537                 ${INSTALL_FILES}
2538         DESTINATION
2539                 ${CMAKE_INSTALL_DATADIR}/${CPACK_PACKAGE_NAME}
2540 )
2541
2542 install(
2543         FILES
2544                 ${MAN1_FILES}
2545         DESTINATION
2546                 ${CMAKE_INSTALL_MANDIR}/man1
2547 )
2548
2549 install(
2550         FILES
2551                 ${MAN4_FILES}
2552         DESTINATION
2553                 ${CMAKE_INSTALL_MANDIR}/man4
2554 )
2555
2556 install(
2557         FILES
2558                 "${CMAKE_BINARY_DIR}/wireshark.pc"
2559         DESTINATION
2560                 ${CMAKE_INSTALL_LIBDIR}/pkgconfig
2561 )
2562
2563 install(
2564         DIRECTORY
2565                 ${INSTALL_DIRS}
2566         DIRECTORY_PERMISSIONS
2567                 OWNER_EXECUTE OWNER_WRITE OWNER_READ
2568                 GROUP_EXECUTE GROUP_READ
2569                 WORLD_EXECUTE WORLD_READ
2570         DESTINATION
2571                 ${CMAKE_INSTALL_DATADIR}/${CPACK_PACKAGE_NAME}
2572         PATTERN ".git" EXCLUDE
2573         PATTERN ".svn" EXCLUDE
2574         PATTERN "Makefile.*" EXCLUDE
2575         PATTERN "faq.py" EXCLUDE
2576 )
2577
2578 include( UseCheckAPI )
2579 CHECKAPI(
2580         ${TSHARK_TAP_SRC}
2581         ${WIRESHARK_SRC}
2582 )
2583
2584 set(CMAKE_INSTALL_MODULES_DIR ${CMAKE_INSTALL_LIBDIR}/${CPACK_PACKAGE_NAME})
2585 configure_file("${CMAKE_MODULE_PATH}/WiresharkConfig.cmake.in" "${CMAKE_BINARY_DIR}/WiresharkConfig.cmake" @ONLY)
2586 configure_file("${CMAKE_MODULE_PATH}/WiresharkConfigVersion.cmake.in" "${CMAKE_BINARY_DIR}/WiresharkConfigVersion.cmake" @ONLY)
2587 install(
2588         FILES
2589                 ${CMAKE_MODULE_PATH}/FindGLIB2.cmake
2590                 ${CMAKE_MODULE_PATH}/FindWireshark.cmake
2591                 ${CMAKE_MODULE_PATH}/FindWSWinLibs.cmake
2592                 ${CMAKE_MODULE_PATH}/UseAsn2Wrs.cmake
2593                 ${CMAKE_MODULE_PATH}/LocatePythonModule.cmake
2594                 ${CMAKE_MODULE_PATH}/UseMakeDissectorReg.cmake
2595                 ${CMAKE_BINARY_DIR}/WiresharkConfig.cmake
2596                 ${CMAKE_BINARY_DIR}/WiresharkConfigVersion.cmake
2597         DESTINATION
2598                 ${CMAKE_INSTALL_MODULES_DIR}
2599 )
2600
2601 if(DOC_DIR)
2602         message(STATUS "Docdir install: ${DOC_DIR}")
2603         INSTALL(
2604                 DIRECTORY
2605                         ${CMAKE_BINARY_DIR}/docbook/
2606                 DIRECTORY_PERMISSIONS
2607                         OWNER_EXECUTE OWNER_WRITE OWNER_READ
2608                         GROUP_EXECUTE GROUP_READ
2609                         WORLD_EXECUTE WORLD_READ
2610                 DESTINATION
2611                         ${DOC_DIR}/guides
2612                 FILES_MATCHING
2613                 PATTERN "*.pdf"
2614         )
2615 endif()
2616
2617 # Test suite wrapper
2618 if(ENABLE_APPLICATION_BUNDLE)
2619         set(TEST_SH_BIN_DIR ${CMAKE_BINARY_DIR}/run)
2620 else()
2621         set(TEST_SH_BIN_DIR $<TARGET_FILE_DIR:epan>)
2622 endif()
2623
2624 add_custom_target(test-sh
2625         COMMAND ${CMAKE_COMMAND}
2626                 -DCMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}
2627                 -DTEST_SH_BIN_DIR=${TEST_SH_BIN_DIR}
2628                 -DTEST_SH_SRC_DIR=${CMAKE_SOURCE_DIR}/test
2629                 -P ${CMAKE_SOURCE_DIR}/cmake/modules/GenerateTestSh.cmake
2630         DEPENDS ${CMAKE_SOURCE_DIR}/cmake/modules/GenerateTestSh.cmake
2631 )
2632 set_target_properties(test-sh PROPERTIES FOLDER "Tests")
2633
2634 add_custom_target(test-programs
2635         DEPENDS test-sh
2636                 exntest
2637                 oids_test
2638                 reassemble_test
2639                 tvbtest
2640                 wmem_test
2641         COMMENT "Building unit test programs and wrapper"
2642 )
2643 set_target_properties(test-programs PROPERTIES FOLDER "Tests")
2644
2645 if (WIN32)
2646         file (TO_NATIVE_PATH ${CMAKE_SOURCE_DIR}/tools/Get-HardenFlags.ps1 _win_harden_flags)
2647         add_custom_target(hardening-check
2648                 COMMAND ${POWERSHELL_COMMAND} "${_win_harden_flags}" "${_dll_output_dir_win}"
2649                 DEPENDS ${PROGLIST}
2650                 COMMENT "Checking binaries for security features"
2651         )
2652         set_target_properties(hardening-check PROPERTIES FOLDER "Tests")
2653 else ()
2654         find_program(HARDENING_CHECK_EXECUTABLE hardening-check
2655                 DOC "Path to the hardening-check utility."
2656         )
2657         if (NOT "${HARDENING_CHECK_EXECUTABLE}" STREQUAL "HARDENING_CHECK_EXECUTABLE-NOTFOUND")
2658                 foreach(_prog ${PROGLIST})
2659                         get_target_property(_prog_dir ${_prog} RUNTIME_OUTPUT_DIRECTORY)
2660                         if (${_prog_dir} STREQUAL "_prog_dir-NOTFOUND")
2661                                 set(_prog_dir "${CMAKE_BINARY_DIR}/run")
2662                         endif()
2663                         set(_prog_paths ${_prog_paths} "${_prog_dir}/${_prog}")
2664                 endforeach()
2665                 add_custom_target(hardening-check
2666                         COMMAND ${HARDENING_CHECK_EXECUTABLE} ${_prog_paths}
2667                         DEPENDS ${PROGLIST}
2668                         COMMENT "Checking binaries for security features"
2669                 )
2670         endif()
2671 endif()
2672
2673 #
2674 # Editor modelines  -  http://www.wireshark.org/tools/modelines.html
2675 #
2676 # Local variables:
2677 # c-basic-offset: 8
2678 # tab-width: 8
2679 # indent-tabs-mode: t
2680 # End:
2681 #
2682 # vi: set shiftwidth=8 tabstop=8 noexpandtab:
2683 # :indentSize=8:tabSize=8:noTabs=false:
2684 #