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