CMakeLists.txt

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