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