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 # Policy since 2.8.11
  35 if (POLICY CMP0020)
  36         cmake_policy(SET CMP0020 OLD)
  37 endif()
  38
  39 #Where to find local cmake scripts
  40 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
  41
  42 # This cannot be implemented via option(...)
  43 if( NOT CMAKE_BUILD_TYPE )
  44         set( CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
  45                 "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
  46                 FORCE)
  47 endif()
  48 message(STATUS "Configuration types: ${CMAKE_CONFIGURATION_TYPES}")
  49 message(STATUS "${CMAKE_BUILD_TYPE}: ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
  50 #Where to put executables and libraries in the build tree
  51 if(NOT ARCHIVE_OUTPUT_PATH)
  52         set(ARCHIVE_OUTPUT_PATH ${Wireshark_BINARY_DIR}/run CACHE INTERNAL
  53                    "Single output directory for building all archives.")
  54 endif()
  55 if(NOT EXECUTABLE_OUTPUT_PATH)
  56         set(EXECUTABLE_OUTPUT_PATH ${Wireshark_BINARY_DIR}/run CACHE INTERNAL
  57                    "Single output directory for building all executables.")
  58 endif()
  59 if(NOT LIBRARY_OUTPUT_PATH)
  60         set(LIBRARY_OUTPUT_PATH ${Wireshark_BINARY_DIR}/run CACHE INTERNAL
  61                    "Single output directory for building all libraries.")
  62 endif()
  63 # Under linux the release mode (CMAKE_BUILD_TYPE=release) defines NDEBUG
  64 #Defines CMAKE_INSTALL_BINDIR, CMAKE_INSTALL_DATADIR, etc ...
  65 include(CMakeInstallDirs)
  66
  67 # set(PROJECT_MAJOR_VERSION 1)
  68 # set(PROJECT_MINOR_VERSION 9)
  69 # set(PROJECT_PATCH_VERSION 0)
  70 # set(PROJECT_VERSION_EXTENSION "-rc5")
  71 # If not set, copy over Wireshark version from configure.ac
  72 if(NOT PROJECT_MAJOR_VERSION)
  73         file(STRINGS
  74                 ${CMAKE_SOURCE_DIR}/configure.ac
  75                 PROJECT_MAJOR_VERSION_TMP
  76                 REGEX "^m4_define\\(\\[?version_major\\]?, *\\[?[0-9]+\\]?\\)"
  77         )
  78         file(STRINGS
  79                 ${CMAKE_SOURCE_DIR}/configure.ac
  80                 PROJECT_MINOR_VERSION_TMP
  81                 REGEX "^m4_define\\(\\[?version_minor\\]?, *\\[?[0-9]+\\]?\\)"
  82         )
  83         file(STRINGS
  84                 ${CMAKE_SOURCE_DIR}/configure.ac
  85                 PROJECT_PATCH_VERSION_TMP
  86                 REGEX "^m4_define\\(\\[?version_micro\\]?, *\\[?[0-9]+\\]?\\)"
  87         )
  88         # XXX pull VERSION_EXTENSION out of configure.ac ?
  89
  90         string(REGEX REPLACE "m4_define\\(\\[?version_major\\]?, *\\[?([0-9]+)\\]?\\)"
  91                 "\\1"
  92                 PROJECT_MAJOR_VERSION
  93                 ${PROJECT_MAJOR_VERSION_TMP}
  94         )
  95         string(REGEX REPLACE "m4_define\\(\\[?version_minor\\]?, *\\[?([0-9]+)\\]?\\)"
  96                 "\\1"
  97                 PROJECT_MINOR_VERSION
  98                 ${PROJECT_MINOR_VERSION_TMP}
  99         )
 100         string(REGEX REPLACE "m4_define\\(\\[?version_micro\\]?, *\\[?([0-9]+)\\]?\\)"
 101                 "\\1"
 102                 PROJECT_PATCH_VERSION
 103                 ${PROJECT_PATCH_VERSION_TMP}
 104         )
 105 endif()
 106
 107 if(PROJECT_VERSION_EXTENSION)
 108         set(PROJECT_VERSION ${PROJECT_MAJOR_VERSION}.${PROJECT_MINOR_VERSION}.${PROJECT_PATCH_VERSION}${PROJECT_VERSION_EXTENSION})
 109 else()
 110         set(PROJECT_VERSION ${PROJECT_MAJOR_VERSION}.${PROJECT_MINOR_VERSION}.${PROJECT_PATCH_VERSION})
 111 endif()
 112
 113 message(STATUS "V: ${PROJECT_VERSION}, MaV: ${PROJECT_MAJOR_VERSION}, MiV: ${PROJECT_MINOR_VERSION}, PL: ${PROJECT_PATCH_VERSION}, EV: ${PROJECT_VERSION_EXTENSION}.")
 114
 115 include(UseLemon)
 116 include(UseMakeDissectorReg)
 117 include(UseMakeTapReg)
 118 include(UseAsn2Wrs)
 119
 120 include_directories(
 121         ${CMAKE_BINARY_DIR}
 122         ${CMAKE_SOURCE_DIR}
 123         ${CMAKE_SOURCE_DIR}/epan
 124         ${CMAKE_SOURCE_DIR}/filetap
 125         ${CMAKE_SOURCE_DIR}/tools/lemon
 126         ${CMAKE_SOURCE_DIR}/wiretap
 127 )
 128
 129 include( CMakeOptions.txt )
 130 if( DUMPCAP_INSTALL_OPTION STREQUAL "suid" )
 131         set( DUMPCAP_SETUID "SETUID" )
 132 else()
 133         set( DUMPCAP_SETUID )
 134 endif()
 135 if( NOT CMAKE_SYSTEM_NAME STREQUAL "Linux" AND
 136         DUMPCAP_INSTALL_OPTION STREQUAL "capabilities" )
 137         message( WARNING "Capabilities are only supported on Linux" )
 138         set( DUMPCAP_INSTALL_OPTION )
 139 endif()
 140
 141 if( CMAKE_C_COMPILER_ID MATCHES "MSVC")
 142         if (MSVC10)
 143                 set(MSC_VER_REQUIRED 1600)
 144         elseif(MSVC11)
 145                 set(MSC_VER_REQUIRED 1700)
 146         elseif(MSVC12)
 147                 set(MSC_VER_REQUIRED 1800)
 148         else()
 149                 message(FATAL_ERROR "You are using an unsupported version of MSVC")
 150         endif()
 151         set(LOCAL_CFLAGS
 152                 /Zi
 153                 /W3
 154                 /MDd
 155                 /DWIN32_LEAN_AND_MEAN
 156                 "/DMSC_VER_REQUIRED=${MSC_VER_REQUIRED}"
 157                 /D_CRT_SECURE_NO_DEPRECATE
 158                 /D_CRT_NONSTDC_NO_DEPRECATE
 159                 /MP
 160                 # NOMINMAX keeps windows.h from defining "min" and "max" via windef.h.
 161                 # This avoids conflicts with the C++ standard library.
 162                 /DNOMINMAX
 163                 # -DPSAPI_VERSION=1                 Programs that must run on earlier versions of Windows as well as Windows 7 and later
 164                 #                                   versions should always call this function as GetProcessMemoryInfo. To ensure correct
 165                 #                                   resolution of symbols, add Psapi.lib to the TARGETLIBS macro and compile the program
 166                 #                                   with -DPSAPI_VERSION=1.To use run-time dynamic linking, load Psapi.dll.
 167                 #                                   http://msdn.microsoft.com/en-us/library/windows/desktop/ms683219(v=vs.85).aspx
 168                 # -DBUILD_WINDOWS                   Starting from VS2013, GetVersionEx is deprecated and we are recommended to use
 169                 #                                   VerifyVersionInfo instead
 170                 #                                   http://msdn.microsoft.com/en-us/library/windows/desktop/ms724429(v=vs.85).aspx
 171                 #                                   http://msdn.microsoft.com/en-us/library/windows/desktop/ms725491(v=vs.85).aspx
 172                 #                                   To continue to use GetVersionEx, we can define BUILD_WINDOWS
 173                 # -D_ALLOW_KEYWORD_MACROS           For VS2012 onwards the, C++ STL does not permit macro redefinitions of keywords
 174                 #                                   (see http://msdn.microsoft.com/en-us/library/bb531344(v=vs.110).aspx)
 175                 #                                   This definition prevents the complaint about the redefinition of inline by WinPCap
 176                 #                                   in pcap-stdinc.h when compiling CPP files, e.g. the QT UI
 177                 /DPSAPI_VERSION=1
 178                 /DBUILD_WINDOWS
 179                 /D_ALLOW_KEYWORD_MACROS
 180         )
 181
 182         if(NOT WIN64)
 183                 set(LOCAL_CFLAGS ${LOCAL_CFLAGS} "/D_BIND_TO_CURRENT_CRT_VERSION=1")
 184         endif()
 185
 186         # Additional compiler warnings to be treated as "Level 3"
 187         #  when compiling Wireshark sources. (Selected from "level 4" warnings).
 188         ## 4295: array is too small to include a terminating null character
 189         set(WARNINGS_CFLAGS "/w34295")
 190
 191         # FIXME: WINPCAP_VERSION cannot be determined from source or executable.
 192         set(WINPCAP_VERSION "unknown")
 193         set(WIRESHARK_COMMON_FLAGS
 194                 "/DWINPCAP_VERSION=${WINPCAP_VERSION}"
 195                 ${LOCAL_CFLAGS}
 196                 ${WARNINGS_CFLAGS}
 197         )
 198 else()
 199         set(WIRESHARK_COMMON_FLAGS
 200                 # -O<X> and -g get set by the CMAKE_BUILD_TYPE
 201                 -Wall
 202                 -W
 203                 -Wextra
 204                 -Wendif-labels
 205                 -Wpointer-arith
 206                 -Warray-bounds
 207                 -Wformat-security
 208                 -Wvla
 209                 -Waddress
 210                 -Wattributes
 211                 -Wdiv-by-zero
 212                 -Wignored-qualifiers
 213                 -Wpragmas
 214                 -Wno-overlength-strings
 215                 -Wwrite-strings
 216                 -Wno-long-long
 217                 -Wheader-guard
 218         )
 219
 220         set(WIRESHARK_C_ONLY_FLAGS
 221                 # The following are C only, not C++
 222                 -Wc++-compat
 223                 -Wdeclaration-after-statement
 224                 -Wshadow
 225                 -Wno-pointer-sign
 226                 -Wold-style-definition
 227                 -Wstrict-prototypes
 228                 -Wlogical-op
 229                 -Wjump-misses-init
 230                 # The Qt headers generate a ton of shortening errors on 64-bit systems
 231                 # so only enable this for C for now.
 232                 -Wshorten-64-to-32
 233         )
 234
 235         set(WIRESHARK_CPP_ONLY_FLAGS
 236         )
 237
 238         set(WIRESHARK_EXTRA_COMPILER_COMMON_FLAGS
 239                 -pedantic
 240                 -Woverflow
 241                 #
 242                 # Various code blocks this one.
 243                 #
 244                 -fstrict-overflow -Wstrict-overflow=4
 245                 #
 246                 # Due to various places where APIs we don't control
 247                 # require us to cast away constness, we can probably
 248                 # never enable this one with -Werror.
 249                 #
 250                 -Wcast-qual
 251                 #
 252                 # Some generated ASN.1 dissectors block this one;
 253                 # multiple function declarations for the same
 254                 # function are being generated.
 255                 #
 256                 -Wredundant-decls
 257                 #
 258                 # Some loops are safe, but it's hard to convince the
 259                 # compiler of that.
 260                 #
 261                 -Wunsafe-loop-optimizations
 262                 #
 263                 # All the registration functions block this for now.
 264                 #
 265                 -Wmissing-declarations
 266                 #
 267                 # A bunch of "that might not work on SPARC" code blocks
 268                 # this one for now.
 269                 #
 270                 -Wcast-align
 271                 #
 272                 # Works only with Clang
 273                 #
 274                 -Wunreachable-code
 275                 #
 276                 # Works only with Clang but generates a lot of warnings
 277                 # (about glib library not using Doxygen)
 278                 #
 279                 -Wdocumentation
 280                 -fwrapv
 281                 -fno-strict-overflow
 282                 -fno-delete-null-pointer-checks
 283         )
 284
 285         set(WIRESHARK_EXTRA_COMPILER_C_ONLY_FLAGS
 286                 # The following are C only, not C++
 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                 -Wbad-function-cast
 293                 #
 294                 # All the registration functions block this for now.
 295                 #
 296                 -Wmissing-prototypes
 297         )
 298
 299         set(WIRESHARK_EXTRA_COMPILER_CPP_ONLY_FLAGS
 300         )
 301
 302         if(CMAKE_C_COMPILER_ID MATCHES "Clang")
 303                 set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS}
 304                         #-fcolor-diagnostics
 305         )
 306         else()
 307                 set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS}
 308                         -fexcess-precision=fast
 309                 )
 310
 311                 set(WIRESHARK_C_ONLY_FLAGS ${WIRESHARK_C_ONLY_FLAGS}
 312                 )
 313         endif()
 314
 315         if(ENABLE_EXTRA_COMPILER_WARNINGS)   # This overrides -Werror
 316                 set(WIRESHARK_COMMON_FLAGS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_EXTRA_COMPILER_COMMON_FLAGS})
 317                 set(WIRESHARK_C_ONLY_FLAGS ${WIRESHARK_C_ONLY_FLAGS} ${WIRESHARK_EXTRA_COMPILER_C_ONLY_FLAGS})
 318                 set(WIRESHARK_CPP_ONLY_FLAGS ${WIRESHARK_CPP_ONLY_FLAGS} ${WIRESHARK_EXTRA_COMPILER_CPP_ONLY_FLAGS})
 319         endif()
 320
 321         add_definitions(
 322                 -DG_DISABLE_DEPRECATED
 323                 -DG_DISABLE_SINGLE_INCLUDES
 324         )
 325 endif()
 326
 327 set( C_FLAG_TESTS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_C_ONLY_FLAGS} )
 328 set( CPP_FLAG_TESTS ${WIRESHARK_COMMON_FLAGS} ${WIRESHARK_CPP_ONLY_FLAGS} )
 329
 330 # Counterhack to work around some cache magic in CHECK_C_SOURCE_COMPILES
 331 include(CheckCCompilerFlag)
 332 include(CheckCXXCompilerFlag)
 333
 334 if(NOT DISABLE_WERROR AND NOT ENABLE_EXTRA_COMPILER_WARNINGS)
 335         check_c_compiler_flag(-Werror WERROR)
 336 else()
 337         set(WERROR FALSE)
 338 endif()
 339
 340 # Sigh: Have to use THIS_FLAG instead of ${F} for some reason
 341 foreach(THIS_FLAG ${C_FLAG_TESTS})
 342         string( REGEX REPLACE "[^a-zA-Z0-9_]+" "_" F ${THIS_FLAG} )
 343         set(${F} ${THIS_FLAG})
 344         set(V C_${F}_VALID)
 345         message(STATUS "Checking for c-compiler flag: ${THIS_FLAG}")
 346         check_c_compiler_flag(${${F}} ${V})
 347         if (${${V}})
 348                 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${${F}}")
 349         endif()
 350 endforeach()
 351 foreach(THIS_FLAG ${CPP_FLAG_TESTS})
 352         string( REGEX REPLACE "[^a-zA-Z0-9_]+" "_" F ${THIS_FLAG} )
 353         set(${F} ${THIS_FLAG})
 354         set(V CPP_${F}_VALID)
 355         message(STATUS "Checking for c++-compiler flag: ${THIS_FLAG}")
 356         check_cxx_compiler_flag(${${F}} ${V})
 357         if (${${V}})
 358                 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${${F}}")
 359         endif()
 360 endforeach()
 361 message(STATUS "C-Flags: ${CMAKE_C_FLAGS}")
 362 message(STATUS "CXX-Flags: ${CMAKE_CXX_FLAGS}")
 363
 364 #
 365 # XXX - we're assuming MSVC supports the SSE 4.2 intrinsics and
 366 # that other C compilers support them iff they support the
 367 # -msse4.2 flag.
 368 #
 369 # Perhaps we should check whether we can compile something
 370 # that uses them, instead, and do something else to figure
 371 # out what compiler flag, if any, we need to pass to the
 372 # compiler to compile code that uses them.
 373 #
 374 if(CMAKE_C_COMPILER_ID MATCHES "MSVC")
 375         set(HAVE_SSE4_2 TRUE)
 376 else()
 377         message(STATUS "Checking for c-compiler flag: -msse4.2")
 378         check_c_compiler_flag(-msse4.2 HAVE_SSE4_2)
 379 endif()
 380
 381 check_c_compiler_flag(-fvisibility=hidden FVHIDDEN)
 382 if(FVHIDDEN)
 383         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
 384 else() # TODO add alternate compiler flags for hiding symbols
 385         if( NOT CMAKE_C_COMPILER_ID MATCHES "MSVC")
 386                 message(WARNING "Hiding shared library symbols is not supported by the compiler."
 387                         " All shared library symbols will be exported.")
 388         endif()
 389 endif()
 390
 391 if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang")
 392         set (C_UNUSED "__attribute__((unused))" )
 393 else()
 394         set (C_UNUSED "" )
 395 endif()
 396
 397
 398 if( CMAKE_C_COMPILER_ID MATCHES "MSVC")
 399         # Set in Makefile.nmake
 400         set(WIRESHARK_LD_FLAGS
 401                 "/LARGEADDRESSAWARE /MANIFEST:NO"
 402         )
 403 else()
 404         set(WIRESHARK_LD_FLAGS
 405                 -Wl,--as-needed
 406                 # -flto
 407                 # -fwhopr
 408                 # -fwhole-program
 409         )
 410 endif()
 411
 412 include(CheckCLinkerFlag)
 413 set(C 0)
 414 # Sigh: Have to use THIS_FLAG instead of ${F} for some reason
 415 foreach(THIS_FLAG ${WIRESHARK_LD_FLAGS})
 416         set(F WS_LD_FLAG_${C})
 417         set(${F} ${THIS_FLAG})
 418         set(V WS_LD_FLAG_VALID${C})
 419         check_c_linker_flag(${${F}} ${V})
 420         if (${${V}})
 421                 set(WS_LINK_FLAGS ${WS_LINK_FLAGS} ${${F}})
 422         endif()
 423         math(EXPR C "${C} + 1")
 424 endforeach()
 425
 426 if(ENABLE_STATIC)
 427         set(LINK_MODE_LIB STATIC)
 428         set(LINK_MODE_MODULE STATIC)
 429 else()
 430         set(LINK_MODE_LIB SHARED)
 431         set(LINK_MODE_MODULE MODULE)
 432 endif()
 433
 434 if(APPLE AND EXISTS /usr/local/opt/gettext)
 435         # GLib on OS X requires libintl. Homebrew installs gettext (and
 436         # libintl) in /usr/local/opt/gettext
 437         include_directories(/usr/local/opt/gettext/include)
 438         link_directories(/usr/local/opt/gettext/lib)
 439 endif()
 440
 441 # The packagelist is doing some magic:  If we add XXX to the packagelist, we
 442 # - may optionally set XXX_OPTIONS to pass to the find_package command
 443 # - will call FindXXX.cmake
 444 # - return found libraries in XXX_LIBRARIES
 445 # - return found include in XXX_INCLUDE_DIRS
 446 # - set HAVE_XXX
 447
 448 #The minimum package list
 449 set(PACKAGELIST Gettext M GLIB2 GMODULE2 GTHREAD2 LEX YACC Perl SED SH PythonInterp)
 450 set(GLIB2_REQUIRED TRUE)
 451 set(GLIB2_FIND_REQUIRED TRUE)
 452 set(GLIB2_MIN_VERSION 2.14.0)
 453 set(GTHREAD2_REQUIRED TRUE)
 454 set(PythonInterp_FIND_VERSION 2)
 455 set(Python_ADDITIONAL_VERSIONS 3)
 456 if (NOT WIN32)
 457         set(M_REQUIRED TRUE)
 458 endif()
 459
 460 set(PACKAGELIST ${PACKAGELIST} HtmlViewer)
 461
 462 if(ENABLE_PCAP)
 463         set(PACKAGELIST ${PACKAGELIST} PCAP)
 464 endif()
 465
 466 if(ENABLE_AIRPCAP)
 467         set(PACKAGELIST ${PACKAGELIST} AIRPCAP)
 468 endif()
 469
 470 # Build the GTK-GUI?
 471 if(BUILD_wireshark)
 472         if(ENABLE_GTK3)
 473                 set(PACKAGELIST ${PACKAGELIST} GTK3)
 474         else()
 475                 set(PACKAGELIST ${PACKAGELIST} GTK2)
 476                 set(GTK2_OPTIONS COMPONENTS gtk)
 477                 set(GTK2_FIND_VERSION 2.12)
 478                 set(GTK2_DEBUG false)
 479         endif()
 480 endif()
 481
 482 # Build the Qt GUI?
 483 if(BUILD_qtshark)
 484         if(ENABLE_QT5)
 485                 # Untested, may not work if CMAKE_PREFIX_PATH gets overwritten
 486                 # somewhere. The if WIN32 in this place is annoying as well.
 487                 if( WIN32 )
 488                         set( QT5_BASE_PATH "$ENV{QT5_BASE_DIR}" )
 489                         set( CMAKE_PREFIX_PATH "${QT5_BASE_PATH}" )
 490                         # Used for the creation of setpath.bat
 491                         set( QT5_DLL_PATH "${QT5_BASE_PATH}/bin" )
 492                         set( WS_ALL_LIBS ${WS_ALL_LIBS} ${QT5_DLL_PATH} )
 493                 endif()
 494                 set(PACKAGELIST ${PACKAGELIST} Qt5Widgets Qt5PrintSupport Qt5LinguistTools)
 495                 if (APPLE)
 496                         set(PACKAGELIST ${PACKAGELIST} Qt5MacExtras)
 497                 endif()
 498                 set(QT_VERSION 5)
 499         else()
 500                 set(PACKAGELIST ${PACKAGELIST} Qt4)
 501                 # set(Qt4_OPTIONS 4.7.1 REQUIRED QtCore QtGui)
 502                 set(QT_VERSION 4)
 503         endif()
 504 endif()
 505
 506 # SMI SNMP
 507 if(ENABLE_SMI)
 508         set(PACKAGELIST ${PACKAGELIST} SMI)
 509 endif()
 510
 511 # GNU crypto
 512 if(ENABLE_GCRYPT)
 513         set(PACKAGELIST ${PACKAGELIST} GCRYPT)
 514 endif()
 515
 516 # GNU SSL/TLS support
 517 if(ENABLE_GNUTLS)
 518         set(PACKAGELIST ${PACKAGELIST} GNUTLS)
 519 endif()
 520
 521 # Kerberos
 522 if(ENABLE_KERBEROS)
 523         set(PACKAGELIST ${PACKAGELIST} KERBEROS)
 524 endif()
 525
 526 # Portable audio
 527 if(ENABLE_PORTAUDIO AND BUILD_wireshark)
 528         set(PACKAGELIST ${PACKAGELIST} PORTAUDIO)
 529 endif()
 530
 531
 532 # Prefer c-ares over adns
 533 if(ENABLE_CARES) # C Asynchronouse resolver
 534         set(PACKAGELIST ${PACKAGELIST} CARES)
 535 elseif(ENABLE_ADNS) # Gnu asynchronous DNS
 536         set(PACKAGELIST ${PACKAGELIST} ADNS)
 537 endif()
 538
 539 # Zlib compression
 540 if(ENABLE_ZLIB)
 541         set(PACKAGELIST ${PACKAGELIST} ZLIB)
 542 endif()
 543
 544 # Lua 5.1 dissectors
 545 if(ENABLE_LUA)
 546         set(PACKAGELIST ${PACKAGELIST} LUA)
 547 endif()
 548
 549 # GeoIP address resolving
 550 if(ENABLE_GEOIP)
 551         set(PACKAGELIST ${PACKAGELIST} GEOIP)
 552 endif()
 553
 554 if(ENABLE_NETLINK)
 555         set(PACKAGELIST ${PACKAGELIST} NL)
 556 endif()
 557
 558 if(ENABLE_SBC)
 559         set(PACKAGELIST ${PACKAGELIST} SBC)
 560 endif()
 561
 562 # Capabilities
 563 if(ENABLE_CAP)
 564         set(PACKAGELIST ${PACKAGELIST} CAP SETCAP)
 565 endif()
 566
 567 set(PACKAGELIST ${PACKAGELIST} YAPP)
 568
 569 set(PACKAGELIST ${PACKAGELIST} POD)
 570
 571 if(ENABLE_GUIDES)
 572         set(PACKAGELIST ${PACKAGELIST} DOXYGEN)
 573 endif()
 574
 575 set(PROGLIST text2pcap mergecap capinfos captype editcap reordercap dumpcap)
 576
 577 #Sort the package list
 578 list(SORT PACKAGELIST)
 579 message(STATUS "Packagelist: ${PACKAGELIST}")
 580 #Let's loop the package list
 581 foreach(PACKAGE ${PACKAGELIST})
 582         if(${PACKAGE} STREQUAL "Qt4")
 583                 set(PACKAGE_VAR "QT")
 584         elseif(${PACKAGE} STREQUAL "PythonInterp")
 585                 set(PACKAGE_VAR "PYTHONINTERP")
 586         elseif(${PACKAGE} STREQUAL "Gettext")
 587                 set(PACKAGE_VAR "GETTEXT")
 588         elseif(${PACKAGE} STREQUAL "HtmlViewer")
 589                 set(PACKAGE_VAR "HTMLVIEWER")
 590         elseif(${PACKAGE} STREQUAL "Perl")
 591                 set(PACKAGE_VAR "PERL")
 592         else()
 593                 set(PACKAGE_VAR ${PACKAGE})
 594         endif()
 595         if(${PACKAGE}_OPTIONS)
 596                 find_package(${PACKAGE} ${${PACKAGE}_OPTIONS})
 597         elseif(${PACKAGE}_REQUIRED)
 598                 find_package(${PACKAGE} REQUIRED)
 599         else()
 600                 find_package(${PACKAGE})
 601         endif()
 602         if (${PACKAGE_VAR}_FOUND)
 603                 message("${PACKAGE_VAR} FOUND")
 604                 set(HAVE_LIB${PACKAGE_VAR} 1)
 605                 include_directories(${${PACKAGE_VAR}_INCLUDE_DIRS})
 606                 set(WS_ALL_LIBS ${WS_ALL_LIBS} ${${PACKAGE_VAR}_LIBRARIES})
 607                 message(STATUS "${PACKAGE} includes: ${${PACKAGE_VAR}_INCLUDE_DIRS}")
 608                 message(STATUS "${PACKAGE} libs: ${${PACKAGE_VAR}_LIBRARIES}")
 609                 if (${PACKAGE}_DEFINITIONS)
 610                         message(STATUS "${PACKAGE} definitions: ${${PACKAGE_VAR}_DEFINITIONS}")
 611                 endif()
 612                 if (${PACKAGE_VAR}_EXECUTABLE)
 613                         message(STATUS "${PACKAGE} executable: ${${PACKAGE_VAR}_EXECUTABLE}")
 614                 endif()
 615         else()
 616                 #
 617                 # Not finding a package is only a fatal error if the
 618                 # package is required; if it's required, then its
 619                 # XXX_REQUIRED variable is set to TRUE, and the above
 620                 # code will pass REQUIRED to find_package, and the
 621                 # configure will fail if the package isn't found.
 622                 #
 623                 # Do *NOT* report this as an error!
 624                 #
 625                 message("${PACKAGE_VAR} NOT FOUND")
 626         endif()
 627 endforeach()
 628
 629 # Provide Windows system lib names
 630 include( UseWinLibs )
 631
 632 # Create file to set paths to run binaries from build dir
 633 WSExtendPath( "${WS_ALL_LIBS}" "${CMAKE_BINARY_DIR}/setpath.bat" )
 634
 635 #packaging
 636 include(CPackConfig.txt)
 637
 638 if(HAVE_LIBLUA)
 639         set(HAVE_LUA_H 1)
 640         set(HAVE_LUA 1)
 641 endif()
 642 if(HAVE_LIBKERBEROS)
 643         set(HAVE_KERBEROS 1)
 644         # HAVE_HEIMDAL_KERBEROS
 645         set(HAVE_MIT_KERBEROS 1)
 646         set(HAVE_KEYTYPE_ARCFOUR_56 1)
 647 endif()
 648 if(HAVE_LIBGEOIP)
 649         set(HAVE_GEOIP 1)
 650 endif()
 651 if(HAVE_LIBCARES)
 652         set(HAVE_C_ARES 1)
 653 endif()
 654 if(HAVE_LIBADNS)
 655         set(HAVE_GNU_ADNS 1)
 656 endif()
 657 if(HAVE_LIBNL AND HAVE_AIRPCAP)
 658         message(ERROR "Airpcap and Libnl support are mutually exclusive")
 659 endif()
 660 if(HAVE_LIBSBC)
 661         set(HAVE_SBC 1)
 662 endif()
 663 # No matter which version of GTK is present
 664 if(GTK2_FOUND OR GTK3_FOUND)
 665         set(GTK_FOUND ON)
 666 endif()
 667 # That's the name autofoo uses
 668 if(HAVE_LIBZLIB)
 669         set(HAVE_LIBZ 1)
 670         # Always include the "true" zlib includes first. This works around a
 671         # bug in the Windows setup of GTK[23] which has a faulty zconf.h.
 672         include_directories(BEFORE ${ZLIB_INCLUDE_DIRS})
 673 endif()
 674 if (Qt5Widgets_FOUND)
 675         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")
 676         if (Qt5_POSITION_INDEPENDENT_CODE)
 677                 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 678         endif()
 679         set (QT_FOUND ON)
 680         set (QT_LIBRARIES ${Qt5Widgets_LIBRARIES} ${Qt5PrintSupport_LIBRARIES})
 681         if(Qt5MacExtras_FOUND)
 682                 set (QT_LIBRARIES ${QT_LIBRARIES} ${Qt5MacExtras_LIBRARIES})
 683                 # That's the name autofoo uses
 684                 set(QT_MACEXTRAS_LIB 1)
 685         endif()
 686 # If Qt4: QT_LIBRARIES and QT_INCLUDES are not set above. They require extra magic
 687 elseif(QT_FOUND)
 688         include(${QT_USE_FILE})
 689         include_directories(${QT_INCLUDE_DIR})
 690         message(STATUS "QT includes: ${QT_INCLUDE_DIR}")
 691         message(STATUS "QT libs: ${QT_LIBRARIES}")
 692 endif()
 693 include(ConfigureChecks.cmake)
 694
 695 #Big or little endian ?
 696 include(TestBigEndian)
 697 test_big_endian(WORDS_BIGENDIAN)
 698
 699 set(DATAFILE_DIR "${CMAKE_INSTALL_PREFIX}/share/${CPACK_PACKAGE_NAME}")
 700
 701 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 702
 703 if(ENABLE_PLUGINS)
 704         set(HAVE_PLUGINS 1)
 705         set(PLUGIN_DIR "${DATAFILE_DIR}/plugins/${CPACK_PACKAGE_VERSION}")
 706         set(PLUGIN_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}/@CPACK_PACKAGE_NAME@/plugins/${CPACK_PACKAGE_VERSION}")
 707         set(PLUGIN_SRC_DIRS
 708                 plugins/docsis
 709                 plugins/ethercat
 710                 plugins/gryphon
 711                 plugins/irda
 712                 plugins/m2m
 713                 plugins/mate
 714                 plugins/opcua
 715                 plugins/profinet
 716                 plugins/stats_tree
 717                 plugins/unistim
 718                 plugins/wimax
 719                 plugins/wimaxasncp
 720                 plugins/wimaxmacphy
 721         )
 722 # It seems this stuff doesn't build with autofoo either...
 723 #       if(YAPP_FOUND)
 724 #               set(PLUGIN_SRC_DIRS
 725 #                       ${PLUGIN_SRC_DIRS}
 726 #                       plugins/tpg
 727 #               )
 728 #       endif()
 729 else()
 730         set(PLUGIN_SRC_DIRS )
 731 endif()
 732
 733 foreach(PLUGIN_DIR ${PLUGIN_SRC_DIRS})
 734         add_subdirectory( ${PLUGIN_DIR} )
 735 endforeach()
 736
 737 add_subdirectory( asn1 EXCLUDE_FROM_ALL )
 738 add_subdirectory( capchild )
 739 add_subdirectory( codecs )
 740 add_subdirectory( epan )
 741 add_subdirectory( filetap )
 742 add_subdirectory( tools/lemon )
 743 add_subdirectory( ui )
 744 add_subdirectory( wiretap )
 745 add_subdirectory( wsutil )
 746
 747 if(NOT WIN32)
 748         add_custom_target(dumpabi DEPENDS dumpabi-libwireshark dumpabi-libfiletap dumpabi-libwiretap dumpabi-libwsutil color.h)
 749 endif()
 750
 751 if(ENABLE_ECHLD)
 752         add_subdirectory( echld )
 753 endif()
 754
 755 if(BUILD_wireshark AND GTK_FOUND)
 756         add_subdirectory( ui/gtk )
 757 endif()
 758
 759 if(BUILD_qtshark AND QT_FOUND)
 760         add_subdirectory( ui/qt )
 761 endif()
 762
 763
 764 # Basedir where to install guides
 765 set(DOC_DIR "$ENV{docdir}" CACHE FILEPATH "Installation directory for ug and dg pdfs.")
 766 message(STATUS "docdir: ${DOC_DIR}")
 767
 768 if(ENABLE_GUIDES)
 769         add_subdirectory( docbook )
 770 endif()
 771
 772 if(ENABLE_PCAP_NG_DEFAULT)
 773         set(PCAP_NG_DEFAULT 1)
 774 endif()
 775
 776 # Large file support (e.g. make off_t 64 bit if supported)
 777 include(gmxTestLargeFiles)
 778 gmx_test_large_files(GMX_LARGEFILES)
 779
 780 add_definitions( -DTOP_SRCDIR=\"${CMAKE_SOURCE_DIR}\" )
 781
 782 if(APPLE)
 783         #
 784         # We assume that APPLE means OS X so that we have the OS X
 785         # frameworks.
 786         #
 787         set(HAVE_OS_X_FRAMEWORKS 1)
 788         FIND_LIBRARY (APPLE_APPLICATION_SERVICES_LIBRARY ApplicationServices)
 789         FIND_LIBRARY (APPLE_CORE_FOUNDATION_LIBRARY CoreFoundation)
 790         FIND_LIBRARY (APPLE_SYSTEM_CONFIGURATION_LIBRARY SystemConfiguration)
 791 endif()
 792
 793 if(WIN32)
 794         set(WS_MSVC_NORETURN "__declspec(noreturn)")
 795
 796         # Disable deprecation
 797         if(MSVC80 OR MSVC90)
 798                 add_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
 799         endif()
 800 else()
 801         set(WS_MSVC_NORETURN " ")
 802 endif()
 803
 804 set( VERSION ${PROJECT_VERSION} )
 805 set( configure_input "Built with CMake ${CMAKE_VERSION}" )
 806 configure_file(${CMAKE_SOURCE_DIR}/cmakeconfig.h.in ${CMAKE_BINARY_DIR}/config.h)
 807 set( IN_FILES
 808         adns_dll.rc
 809         capchild/doxygen.cfg.in
 810         doxygen.cfg.in
 811         doxygen_global.cfg
 812         epan/doxygen.cfg.in
 813         image/libwireshark.rc.in
 814         image/text2pcap.rc.in
 815         image/capinfos.rc.in
 816         image/wireshark.rc.in
 817         image/mergecap.rc.in
 818         image/tshark.rc.in
 819         image/dumpcap.rc.in
 820         image/reordercap.rc.in
 821         image/rawshark.rc.in
 822         image/file_dlg_win32.rc
 823         image/tfshark.rc.in
 824         image/editcap.rc.in
 825         image/captype.rc.in
 826         image/libwsutil.rc.in
 827         image/filetap.rc.in
 828         image/wiretap.rc.in
 829         packaging/macosx/Info.plist.in
 830         plugins/ethercat/plugin.rc.in
 831         plugins/unistim/plugin.rc.in
 832         plugins/opcua/plugin.rc.in
 833         plugins/asn1/plugin.rc.in
 834         plugins/wimax/plugin.rc.in
 835         plugins/gryphon/plugin.rc.in
 836         plugins/profinet/plugin.rc.in
 837         plugins/m2m/plugin.rc.in
 838         plugins/stats_tree/plugin.rc.in
 839         plugins/wimaxasncp/plugin.rc.in
 840         plugins/mate/plugin.rc.in
 841         plugins/wimaxmacphy/plugin.rc.in
 842         plugins/irda/plugin.rc.in
 843         plugins/docsis/plugin.rc.in
 844         plugins/easy_codec/plugin.rc.in
 845         ui/doxygen.cfg.in
 846         ui/gtk/doxygen.cfg.in
 847         ui/qt/doxygen.cfg.in
 848         wireshark.pc.in
 849 )
 850 foreach( _in_file ${IN_FILES} )
 851         get_filename_component( _path ${_in_file} PATH )
 852         string( REGEX REPLACE "(.*)\\.in" "\\1" _outfile ${_in_file}  )
 853         configure_file( ${CMAKE_SOURCE_DIR}/${_in_file} ${CMAKE_BINARY_DIR}/${_outfile} @ONLY )
 854 endforeach()
 855
 856 include(FeatureSummary)
 857 #SET_FEATURE_INFO(NAME DESCRIPTION [URL [COMMENT] ]
 858 SET_FEATURE_INFO(SBC "SBC Codec for Bluetooth A2DP stream playing" "www: http://git.kernel.org/cgit/bluetooth/sbc.git" )
 859
 860 FEATURE_SUMMARY(WHAT ALL)
 861
 862 link_directories(
 863         ${CMAKE_BINARY_DIR}/ui
 864         ${CMAKE_BINARY_DIR}/ui/gtk
 865         ${CMAKE_BINARY_DIR}/ui/qt
 866         ${CMAKE_BINARY_DIR}/capchild
 867         ${CMAKE_BINARY_DIR}/codecs
 868         ${CMAKE_BINARY_DIR}/epan
 869         ${CMAKE_BINARY_DIR}/filetap
 870         ${CMAKE_BINARY_DIR}/wiretap
 871         ${CMAKE_BINARY_DIR}/wsutil
 872 )
 873
 874 ADD_CUSTOM_TARGET(
 875         gitversion ALL
 876         COMMAND ${PERL_EXECUTABLE}
 877                 ${CMAKE_CURRENT_SOURCE_DIR}/make-version.pl
 878                 ${CMAKE_CURRENT_SOURCE_DIR}
 879         DEPENDS
 880                 ${CMAKE_CURRENT_SOURCE_DIR}/make-version.pl
 881 )
 882 set_target_properties(gitversion PROPERTIES FOLDER "Auxiliary")
 883
 884 ADD_CUSTOM_COMMAND(
 885         OUTPUT  version.h
 886         COMMAND ${PERL_EXECUTABLE}
 887                 ${CMAKE_CURRENT_SOURCE_DIR}/make-version.pl
 888                 ${CMAKE_CURRENT_SOURCE_DIR}
 889         DEPENDS
 890                 ${CMAKE_CURRENT_SOURCE_DIR}/make-version.pl
 891 )
 892
 893 if(UNIX)
 894         set(PLATFORM_PCAP_SRC
 895                 capture-pcap-util-unix.c
 896         )
 897 endif()
 898
 899 if(WIN32)
 900         set(PLATFORM_PCAP_SRC
 901                 capture_win_ifnames.c
 902                 capture-wpcap.c
 903                 capture_wpcap_packet.c
 904         )
 905         set(PLATFORM_UI_SRC
 906                 ui/win32/console_win32.c
 907                 ui/win32/file_dlg_win32.c
 908                 ui/win32/print_win32.c
 909                 image/file_dlg_win32.rc
 910         )
 911 endif()
 912
 913 # sources common for wireshark, tshark, and rawshark
 914 set(SHARK_COMMON_SRC
 915         ${PLATFORM_PCAP_SRC}
 916         capture-pcap-util.c
 917         cfile.c
 918         frame_tvbuff.c
 919         version.h
 920         sync_pipe_write.c
 921         version_info.c
 922 )
 923
 924 # sources common for wireshark and tshark, but not rawshark;
 925 # these are for programs that capture traffic by running dumpcap
 926 set(SHARK_COMMON_CAPTURE_SRC
 927 )
 928
 929 set(TSHARK_TAP_SRC
 930         ui/cli/tap-afpstat.c
 931         ui/cli/tap-ansi_astat.c
 932         ui/cli/tap-bootpstat.c
 933         ui/cli/tap-camelcounter.c
 934         ui/cli/tap-camelsrt.c
 935         ui/cli/tap-comparestat.c
 936         ui/cli/tap-dcerpcstat.c
 937         ui/cli/tap-diameter-avp.c
 938         ui/cli/tap-expert.c
 939         ui/cli/tap-follow.c
 940         ui/cli/tap-funnel.c
 941         ui/cli/tap-gsm_astat.c
 942         ui/cli/tap-h225counter.c
 943         ui/cli/tap-h225rassrt.c
 944         ui/cli/tap-hosts.c
 945         ui/cli/tap-httpstat.c
 946         ui/cli/tap-icmpstat.c
 947         ui/cli/tap-icmpv6stat.c
 948         ui/cli/tap-iostat.c
 949         ui/cli/tap-iousers.c
 950         ui/cli/tap-macltestat.c
 951         ui/cli/tap-mgcpstat.c
 952         ui/cli/tap-megacostat.c
 953         ui/cli/tap-protocolinfo.c
 954         ui/cli/tap-protohierstat.c
 955         ui/cli/tap-radiusstat.c
 956         ui/cli/tap-rlcltestat.c
 957         ui/cli/tap-rpcstat.c
 958         ui/cli/tap-rpcprogs.c
 959         ui/cli/tap-rtp.c
 960         ui/cli/tap-rtspstat.c
 961         ui/cli/tap-scsistat.c
 962         ui/cli/tap-sctpchunkstat.c
 963         ui/cli/tap-sipstat.c
 964         ui/cli/tap-smbsids.c
 965         ui/cli/tap-smbstat.c
 966         ui/cli/tap-stats_tree.c
 967         ui/cli/tap-sv.c
 968         ui/cli/tap-wspstat.c
 969 )
 970
 971 set(INSTALL_DIRS
 972         diameter
 973         dtds
 974         help
 975         radius
 976         tpncp
 977         wimaxasncp
 978 )
 979
 980 set(INSTALL_FILES
 981         ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
 982         COPYING
 983         ${CMAKE_BINARY_DIR}/capinfos.html
 984         ${CMAKE_BINARY_DIR}/captype.html
 985         cfilters
 986         colorfilters
 987         dfilters
 988         ${CMAKE_BINARY_DIR}/dftest.html
 989         ${CMAKE_BINARY_DIR}/dumpcap.html
 990         ${CMAKE_BINARY_DIR}/editcap.html
 991         ${CMAKE_BINARY_DIR}/asn2deb.html
 992         ${CMAKE_BINARY_DIR}/idl2deb.html
 993         ${CMAKE_BINARY_DIR}/idl2wrs.html
 994         ipmap.html
 995         manuf
 996         ${CMAKE_BINARY_DIR}/mergecap.html
 997         pdml2html.xsl
 998         ${CMAKE_BINARY_DIR}/randpkt.html
 999         ${CMAKE_BINARY_DIR}/rawshark.html
1000         ${CMAKE_BINARY_DIR}/reordercap.html
1001         services
1002         smi_modules
1003         ${CMAKE_BINARY_DIR}/text2pcap.html
1004         ${CMAKE_BINARY_DIR}/tshark.html
1005         ${CMAKE_BINARY_DIR}/wireshark-filter.html
1006         ${CMAKE_BINARY_DIR}/wireshark.html
1007         docbook/ws.css
1008 )
1009
1010 set(LIBEPAN_LIBS
1011 #               @NSL_LIBS@      # -lnsl
1012 #               @SOCKET_LIBS@   # -lsocket
1013 #               @SSL_LIBS@      # -lcrypto
1014                 epan
1015 #               $(plugin_ldadd) # in case of static
1016                 ${AIRPCAP_LIBRARIES}
1017                 ${PCAP_LIBRARIES}
1018                 ${CARES_LIBRARIES}
1019                 ${ADNS_LIBRARIES}
1020                 ${KERBEROS_LIBRARIES}
1021                 ${LUA_LIBRARIES}
1022                 ${PYTHON_LIBRARIES}
1023                 ${GEOIP_LIBRARIES}
1024                 ${GCRYPT_LIBRARIES}
1025                 ${GNUTLS_LIBRARIES}
1026                 ${SMI_LIBRARIES}
1027                 ${ZLIB_LIBRARIES}
1028                 ${M_LIBRARIES}
1029                 ${SBC_LIBRARIES}
1030 )
1031
1032 if( (BUILD_wireshark AND GTK_FOUND) OR (BUILD_qtshark AND QT_FOUND) )
1033         set(wireshark_FILES
1034                 airpcap_loader.c
1035                 capture_info.c
1036                 capture_opts.c
1037                 color_filters.c
1038                 file.c
1039                 fileset.c
1040                 iface_monitor.c
1041                 summary.c
1042                 ws80211_utils.c
1043                 ${SHARK_COMMON_CAPTURE_SRC}
1044                 ${SHARK_COMMON_SRC}
1045                 ${PLATFORM_UI_SRC}
1046                 image/wireshark.rc
1047         )
1048 endif()
1049
1050 if(BUILD_wireshark AND GTK_FOUND)
1051         set(wireshark_LIBS
1052                 gtkui
1053                 ui
1054                 capchild
1055                 ${GTK2_LIBRARIES}
1056                 ${GTK3_LIBRARIES}
1057                 ${GTHREAD2_LIBRARIES}
1058                 codecs
1059                 ${PORTAUDIO_LIBRARIES}
1060                 ${LIBEPAN_LIBS}
1061                 ${APPLE_APPLICATION_SERVICES_LIBRARY}
1062                 ${APPLE_CORE_SERVICES_LIBRARY}
1063                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
1064                 ${NL_LIBRARIES}
1065                 ${WIN_COMCTL32_LIBRARY}
1066         )
1067         # qtshark and wireshark share wireshark_FILES
1068
1069         add_executable(wireshark ${wireshark_FILES})
1070         add_dependencies(wireshark gitversion)
1071         set_target_properties(wireshark PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1072         set_target_properties(wireshark PROPERTIES FOLDER "Executables")
1073         target_link_libraries(wireshark ${wireshark_LIBS})
1074         install(TARGETS wireshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1075 endif()
1076
1077 if(BUILD_qtshark AND QT_FOUND)
1078         set(qtshark_LIBS
1079                 qtui
1080                 ui
1081                 capchild
1082                 ${QT_LIBRARIES}
1083                 ${GTHREAD2_LIBRARIES}
1084                 codecs
1085                 ${LIBEPAN_LIBS}
1086                 ${APPLE_APPLICATION_SERVICES_LIBRARY}
1087                 ${APPLE_CORE_FOUNDATION_LIBRARY}
1088                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
1089                 ${NL_LIBRARIES}
1090         )
1091         # qtshark and wireshark share wireshark_FILES
1092
1093         add_executable(qtshark ${wireshark_FILES})
1094         add_dependencies(qtshark gitversion)
1095         set_target_properties(qtshark PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1096         set_target_properties(qtshark PROPERTIES FOLDER "Executables")
1097         target_link_libraries(qtshark ${qtshark_LIBS})
1098         install(TARGETS qtshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1099 endif()
1100
1101 register_tap_files(tshark-tap-register.c
1102                 tshark-taps
1103         ${TSHARK_TAP_SRC}
1104 )
1105
1106 if(BUILD_tshark)
1107         set(tshark_LIBS
1108                 ui
1109                 capchild
1110                 ${LIBEPAN_LIBS}
1111                 ${APPLE_CORE_FOUNDATION_LIBRARY}
1112                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
1113         )
1114         set(tshark_FILES
1115                 capture_opts.c
1116                 tshark-tap-register.c
1117                 tshark.c
1118                 ${TSHARK_TAP_SRC}
1119                 ${SHARK_COMMON_CAPTURE_SRC}
1120                 ${SHARK_COMMON_SRC}
1121                 image/tshark.rc
1122         )
1123         add_executable(tshark ${tshark_FILES})
1124         add_dependencies(tshark gitversion)
1125         set_target_properties(tshark PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1126         set_target_properties(tshark PROPERTIES FOLDER "Executables")
1127         target_link_libraries(tshark ${tshark_LIBS})
1128         install(TARGETS tshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1129 endif()
1130
1131 if(BUILD_tfshark)
1132         set(tfshark_LIBS
1133                 filetap
1134                 ui
1135                 ${LIBEPAN_LIBS}
1136                 ${APPLE_CORE_FOUNDATION_LIBRARY}
1137                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
1138         )
1139         set(tfshark_FILES
1140                 tfshark.c
1141                 ${TSHARK_TAP_SRC}
1142                 ${SHARK_COMMON_SRC}
1143                 image/tfshark.rc
1144         )
1145         add_executable(tfshark ${tfshark_FILES})
1146         add_dependencies(tfshark gitversion)
1147         set_target_properties(tfshark PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1148         set_target_properties(tfshark PROPERTIES FOLDER "Executables")
1149         target_link_libraries(tfshark ${tfshark_LIBS})
1150         install(TARGETS tfshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1151 endif()
1152
1153 if(BUILD_rawshark AND PCAP_FOUND)
1154         set(rawshark_LIBS
1155                 ${LIBEPAN_LIBS}
1156                 ${APPLE_CORE_FOUNDATION_LIBRARY}
1157                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
1158         )
1159         set(rawshark_FILES
1160                 ${SHARK_COMMON_SRC}
1161                 rawshark.c
1162                 ui/util.c
1163                 image/rawshark.rc
1164         )
1165         add_executable(rawshark ${rawshark_FILES})
1166         add_dependencies(rawshark gitversion)
1167         set_target_properties(rawshark PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1168         set_target_properties(rawshark PROPERTIES FOLDER "Executables")
1169         target_link_libraries(rawshark ${rawshark_LIBS})
1170         install(TARGETS rawshark RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1171 endif()
1172
1173 if(BUILD_dftest)
1174         set(dftest_LIBS
1175                 ${LIBEPAN_LIBS}
1176         )
1177         set(dftest_FILES
1178                 dftest.c
1179                 ui/util.c
1180         )
1181         add_executable(dftest ${dftest_FILES})
1182         set_target_properties(dftest PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1183         set_target_properties(dftest PROPERTIES FOLDER "Tests")
1184         target_link_libraries(dftest ${dftest_LIBS})
1185         install(TARGETS dftest RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1186 endif()
1187
1188 if(BUILD_randpkt)
1189         set(randpkt_LIBS
1190                 wiretap
1191                 wsutil
1192                 ${M_LIBRARIES}
1193                 ${PCAP_LIBRARIES}
1194 #               @SOCKET_LIBS@
1195 #               @NSL_LIBS@
1196                 ${CARES_LIBRARIES}
1197                 ${ADNS_LIBRARIES}
1198                 ${ZLIB_LIBRARIES}
1199         )
1200         set(randpkt_FILES
1201                 randpkt.c
1202         )
1203         add_executable(randpkt ${randpkt_FILES})
1204         set_target_properties(randpkt PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1205         set_target_properties(randpkt PROPERTIES FOLDER "Executables")
1206         target_link_libraries(randpkt ${randpkt_LIBS})
1207         install(TARGETS randpkt RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1208 endif()
1209
1210 if(BUILD_text2pcap)
1211         set(text2pcap_LIBS
1212                 wsutil
1213                 ${M_LIBRARIES}
1214                 ${ZLIB_LIBRARIES}
1215         )
1216         set(text2pcap_CLEAN_FILES
1217                 text2pcap.c
1218                 pcapio.c
1219         )
1220         set(text2pcap_FILES
1221                 ${text2pcap_CLEAN_FILES}
1222                 image/text2pcap.rc
1223         )
1224         add_lex_files(text2pcap_FILES
1225                 text2pcap-scanner.l
1226         )
1227         add_executable(text2pcap ${text2pcap_FILES})
1228         add_dependencies(text2pcap gitversion)
1229         set_target_properties(text2pcap PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1230         set_target_properties(text2pcap PROPERTIES FOLDER "Executables")
1231         target_link_libraries(text2pcap ${text2pcap_LIBS})
1232         install(TARGETS text2pcap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1233 endif()
1234
1235 if(BUILD_mergecap)
1236         set(mergecap_LIBS
1237                 wiretap
1238                 ${ZLIB_LIBRARIES}
1239                 ${CMAKE_DL_LIBS}
1240         )
1241         set(mergecap_FILES
1242                 mergecap.c
1243                 version.h
1244                 image/mergecap.rc
1245         )
1246         add_executable(mergecap ${mergecap_FILES})
1247         add_dependencies(mergecap gitversion)
1248         set_target_properties(mergecap PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1249         set_target_properties(mergecap PROPERTIES FOLDER "Executables")
1250         target_link_libraries(mergecap ${mergecap_LIBS})
1251         install(TARGETS mergecap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1252 endif()
1253
1254 if(BUILD_reordercap)
1255         set(reordercap_LIBS
1256                 wiretap
1257                 ${ZLIB_LIBRARIES}
1258                 ${CMAKE_DL_LIBS}
1259         )
1260         set(reordercap_FILES
1261                 reordercap.c
1262                 version.h
1263                 image/reordercap.rc
1264         )
1265         add_executable(reordercap ${reordercap_FILES})
1266         add_dependencies(reordercap gitversion)
1267         set_target_properties(reordercap PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1268         set_target_properties(reordercap PROPERTIES FOLDER "Executables")
1269         target_link_libraries(reordercap ${reordercap_LIBS})
1270         install(TARGETS reordercap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1271 endif()
1272
1273 if(BUILD_capinfos)
1274         set(capinfos_LIBS
1275                 wiretap
1276                 wsutil
1277                 ${ZLIB_LIBRARIES}
1278                 ${GCRYPT_LIBRARIES}
1279                 ${CMAKE_DL_LIBS}
1280         )
1281         set(capinfos_FILES
1282                 capinfos.c
1283                 image/capinfos.rc
1284         )
1285         add_executable(capinfos ${capinfos_FILES})
1286         add_dependencies(capinfos gitversion)
1287         set_target_properties(capinfos PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1288         set_target_properties(capinfos PROPERTIES FOLDER "Executables")
1289         target_link_libraries(capinfos ${capinfos_LIBS})
1290         install(TARGETS capinfos RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1291 endif()
1292
1293 if(BUILD_captype)
1294         set(captype_LIBS
1295                 wiretap
1296                 wsutil
1297                 ${ZLIB_LIBRARIES}
1298                 ${CMAKE_DL_LIBS}
1299         )
1300         set(captype_FILES
1301                 captype.c
1302                 image/captype.rc
1303         )
1304         add_executable(captype ${captype_FILES})
1305         add_dependencies(captype gitversion)
1306         set_target_properties(captype PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1307         set_target_properties(captype PROPERTIES FOLDER "Executables")
1308         target_link_libraries(captype ${captype_LIBS})
1309         install(TARGETS captype RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1310 endif()
1311
1312 if(BUILD_editcap)
1313         set(editcap_LIBS
1314                 wiretap
1315                 ${ZLIB_LIBRARIES}
1316                 ${CMAKE_DL_LIBS}
1317         )
1318         set(editcap_FILES
1319                 editcap.c
1320                 image/editcap.rc
1321         )
1322         add_executable(editcap ${editcap_FILES})
1323         add_dependencies(editcap gitversion)
1324         set_target_properties(editcap PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1325         set_target_properties(editcap PROPERTIES FOLDER "Executables")
1326         target_link_libraries(editcap ${editcap_LIBS})
1327         install(TARGETS editcap RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
1328 endif()
1329
1330 if(BUILD_dumpcap AND PCAP_FOUND)
1331         set(dumpcap_LIBS
1332                 wsutil
1333                 ${PCAP_LIBRARIES}
1334                 ${CAP_LIBRARIES}
1335 #               @SOCKET_LIBS@
1336 #               @NSL_LIBS@
1337                 ${GLIB2_LIBRARIES}
1338                 ${GTHREAD2_LIBRARIES}
1339                 ${ZLIB_LIBRARIES}
1340                 ${APPLE_CORE_FOUNDATION_LIBRARY}
1341                 ${APPLE_SYSTEM_CONFIGURATION_LIBRARY}
1342                 ${NL_LIBRARIES}
1343         )
1344         set(dumpcap_FILES
1345                 version.h
1346                 capture_opts.c
1347                 capture-pcap-util.c
1348                 capture_stop_conditions.c
1349                 conditions.c
1350                 dumpcap.c
1351                 pcapio.c
1352                 ringbuffer.c
1353                 sync_pipe_write.c
1354                 version_info.c
1355                 ws80211_utils.c
1356                 ${PLATFORM_PCAP_SRC}
1357                 image/dumpcap.rc
1358         )
1359         add_executable(dumpcap ${dumpcap_FILES})
1360         add_dependencies(dumpcap gitversion)
1361         set_target_properties(dumpcap PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
1362         set_target_properties(dumpcap PROPERTIES FOLDER "Executables")
1363         target_link_libraries(dumpcap ${dumpcap_LIBS})
1364         install(TARGETS dumpcap
1365                         RUNTIME
1366                         DESTINATION ${CMAKE_INSTALL_BINDIR}
1367                         PERMISSIONS ${DUMPCAP_SETUID}
1368                                 OWNER_READ OWNER_WRITE OWNER_EXECUTE
1369                                 GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
1370         )
1371         if(DUMPCAP_INSTALL_OPTION STREQUAL "capabilities")
1372                 install( CODE "execute_process(
1373                         COMMAND
1374                                 ${SETCAP_EXECUTABLE}
1375                                 cap_net_raw,cap_net_admin+ep
1376                                 ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}/dumpcap${CMAKE_EXECUTABLE_SUFFIX}
1377                         RESULT_VARIABLE
1378                                 _SETCAP_RESULT
1379                         )
1380                         if( _SETCAP_RESULT )
1381                                 message( WARNING \"setcap failed (${_SETCAP_RESULT}).\")
1382                         endif()"
1383                 )
1384         endif()
1385 endif()
1386
1387 ADD_CUSTOM_COMMAND(
1388         OUTPUT  ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
1389         COMMAND ${PERL_EXECUTABLE}
1390                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
1391                 ${CMAKE_SOURCE_DIR}/doc/make-authors-short.pl
1392                 < ${CMAKE_SOURCE_DIR}/AUTHORS
1393                 > ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
1394         DEPENDS
1395                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
1396                 ${CMAKE_SOURCE_DIR}/doc/make-authors-short.pl
1397                 ${CMAKE_SOURCE_DIR}/AUTHORS
1398 )
1399
1400 ADD_CUSTOM_COMMAND(
1401         OUTPUT  ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
1402                 ${CMAKE_BINARY_DIR}/wireshark.pod
1403         COMMAND ${PERL_EXECUTABLE}
1404                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
1405                 ${CMAKE_SOURCE_DIR}/doc/make-authors-format.pl
1406                 < ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
1407                 > ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
1408         COMMAND cat
1409                 ${CMAKE_SOURCE_DIR}/doc/wireshark.pod.template
1410                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT-FORMAT
1411                 > ${CMAKE_BINARY_DIR}/wireshark.pod
1412         DEPENDS
1413                 ${CMAKE_SOURCE_DIR}/doc/perlnoutf.pl
1414                 ${CMAKE_SOURCE_DIR}/doc/make-authors-format.pl
1415                 ${CMAKE_BINARY_DIR}/AUTHORS-SHORT
1416                 ${CMAKE_SOURCE_DIR}/doc/wireshark.pod.template
1417 )
1418
1419 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/capinfos 1 )
1420 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/captype 1 )
1421 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/dftest 1 )
1422 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/dumpcap 1 )
1423 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/editcap 1 )
1424 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/asn2deb 1 )
1425 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/idl2deb 1 )
1426 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/idl2wrs 1 )
1427 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/mergecap 1 )
1428 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/randpkt 1 )
1429 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/rawshark 1 )
1430 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/reordercap 1 )
1431 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/text2pcap 1 )
1432 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/tshark 1 )
1433 pod2manhtml( ${CMAKE_BINARY_DIR}/wireshark 1 )
1434 pod2manhtml( ${CMAKE_SOURCE_DIR}/doc/wireshark-filter 4 )
1435
1436 add_custom_target(
1437         auxiliary ALL
1438         DEPENDS
1439                 AUTHORS-SHORT
1440                 capinfos.html
1441                 captype.html
1442                 dftest.html
1443                 dumpcap.html
1444                 editcap.html
1445                 asn2deb.html
1446                 idl2deb.html
1447                 idl2wrs.html
1448                 mergecap.html
1449                 randpkt.html
1450                 rawshark.html
1451                 reordercap.html
1452                 text2pcap.html
1453                 tshark.html
1454                 wireshark.html
1455                 wireshark-filter.html
1456 )
1457 set_target_properties(auxiliary PROPERTIES FOLDER "Docs")
1458
1459 set(MAN1_FILES
1460         ${CMAKE_BINARY_DIR}/capinfos.1
1461         ${CMAKE_BINARY_DIR}/captype.1
1462         ${CMAKE_BINARY_DIR}/dftest.1
1463         ${CMAKE_BINARY_DIR}/dumpcap.1
1464         ${CMAKE_BINARY_DIR}/editcap.1
1465         ${CMAKE_BINARY_DIR}/idl2wrs.1
1466         ${CMAKE_BINARY_DIR}/mergecap.1
1467         ${CMAKE_BINARY_DIR}/randpkt.1
1468         ${CMAKE_BINARY_DIR}/rawshark.1
1469         ${CMAKE_BINARY_DIR}/reordercap.1
1470         ${CMAKE_BINARY_DIR}/text2pcap.1
1471         ${CMAKE_BINARY_DIR}/tshark.1
1472         ${CMAKE_BINARY_DIR}/wireshark.1
1473 )
1474
1475 set(MAN4_FILES
1476         ${CMAKE_BINARY_DIR}/wireshark-filter.4
1477 )
1478
1479 set(CLEAN_FILES
1480         ${wireshark_FILES}
1481         ${tshark_FILES}
1482         ${rawshark_FILES}
1483         ${dftest_FILES}
1484         ${randpkt_FILES}
1485         ${text2pcap_CLEAN_FILES}
1486         ${mergecap_FILES}
1487         ${capinfos_FILES}
1488         ${captype_FILES}
1489         ${editcap_FILES}
1490         ${dumpcap_FILES}
1491 )
1492
1493 if (WERROR)
1494         set_source_files_properties(
1495                 ${CLEAN_FILES}
1496                 PROPERTIES
1497                 COMPILE_FLAGS -Werror
1498         )
1499 endif()
1500
1501 install(
1502         FILES
1503                 ${INSTALL_FILES}
1504         DESTINATION
1505                 ${CMAKE_INSTALL_DATADIR}/${CPACK_PACKAGE_NAME}
1506 )
1507
1508 install(
1509         FILES
1510                 ${MAN1_FILES}
1511         DESTINATION
1512                 ${CMAKE_INSTALL_MANDIR}/man1
1513 )
1514
1515 install(
1516         FILES
1517                 ${MAN4_FILES}
1518         DESTINATION
1519                 ${CMAKE_INSTALL_MANDIR}/man4
1520 )
1521
1522 install(
1523         FILES
1524                 "${CMAKE_BINARY_DIR}/wireshark.pc"
1525         DESTINATION
1526                 ${CMAKE_INSTALL_LIBDIR}/pkgconfig
1527 )
1528
1529 install(
1530         DIRECTORY
1531                 ${INSTALL_DIRS}
1532         DIRECTORY_PERMISSIONS
1533                 OWNER_EXECUTE OWNER_WRITE OWNER_READ
1534                 GROUP_EXECUTE GROUP_READ
1535                 WORLD_EXECUTE WORLD_READ
1536         DESTINATION
1537                 ${CMAKE_INSTALL_DATADIR}/${CPACK_PACKAGE_NAME}
1538         PATTERN ".git" EXCLUDE
1539         PATTERN ".svn" EXCLUDE
1540         PATTERN "Makefile.*" EXCLUDE
1541         PATTERN "faq.py" EXCLUDE
1542 )
1543
1544 include( UseCheckAPI )
1545 CHECKAPI(
1546         ${TSHARK_TAP_SRC}
1547         ${wireshark_FILES}
1548 )
1549
1550 if(DOC_DIR)
1551         message(STATUS "Docdir install: ${DOC_DIR}")
1552         INSTALL(
1553                 DIRECTORY
1554                         ${CMAKE_BINARY_DIR}/docbook/
1555                 DIRECTORY_PERMISSIONS
1556                         OWNER_EXECUTE OWNER_WRITE OWNER_READ
1557                         GROUP_EXECUTE GROUP_READ
1558                         WORLD_EXECUTE WORLD_READ
1559                 DESTINATION
1560                         ${DOC_DIR}/guides
1561                 FILES_MATCHING
1562                 PATTERN "*.pdf"
1563         )
1564 endif()