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