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