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