xref: /freebsd/contrib/libpcap/CMakeLists.txt (revision a03411e84728e9b267056fd31c7d1d9d1dc1b01e)
1if(WIN32)
2    #
3    # We need 3.12 or later, so that we can set policy CMP0074; see
4    # below.
5    cmake_minimum_required(VERSION 3.12)
6else(WIN32)
7    cmake_minimum_required(VERSION 2.8.6)
8endif(WIN32)
9
10#
11# Apple doesn't build with an install_name starting with @rpath, and
12# neither do we with autotools; don't do so with CMake, either, and
13# suppress warnings about that.
14#
15if(POLICY CMP0042)
16    cmake_policy(SET CMP0042 OLD)
17endif()
18
19#
20# Squelch noise about quoted strings in if() statements.
21# WE KNOW WHAT WE'RE DOING, WE'RE DOING EVERYTHING THE WAY THAT NEWER
22# VERSIONS OF CMAKE EXPECT BY DEFAULT, DON'T WASTE OUR TIME WITH NOISE.
23#
24if(POLICY CMP0054)
25    cmake_policy(SET CMP0054 NEW)
26endif()
27
28#
29# We want find_file() and find_library() to honor {packagename}_ROOT,
30# as that appears to be the only way, with the Visual Studio 2019 IDE
31# and its CMake support, to tell CMake where to look for the Npcap
32# or WinPcap SDK.
33#
34if(POLICY CMP0074)
35    cmake_policy(SET CMP0074 NEW)
36endif()
37
38#
39# We want check_include_file() to honor CMAKE_REQUIRED_LIBRARIES; see
40# the big comment before the check_include_file() test for
41# infiniband/verbs.h for the reason.
42#
43if(POLICY CMP0075)
44    cmake_policy(SET CMP0075 NEW)
45endif()
46
47set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules)
48
49#
50# We only need a C++ compiler for Haiku; all code except for its
51# pcap module is in C.
52#
53# We do that by specifying just C in the project() call and, after
54# that finishes, checking for Haiku and, if we're building for
55# Haiku, use enable_language() to check for C++.  This means that
56# we don't require a C++ compiler on platforms other than Haiku.
57#
58# CMAKE_SYSTEM_NAME is set by project(), so we can't do this by
59# testing CMAKE_SYSTEM_NAME and then passing different language
60# lists to project() based on the system.
61#
62project(pcap C)
63
64#
65# For getting raw lists of --libs and --libs --static information from a
66# pkg-config module.
67#
68# In CMake up to 2.8.12, pkg_check_modules() sets:
69#
70#    <XPREFIX>_LIBRARIES, which is a list of library names to which, on
71#      a UN*X, -l can be prefixed - i.e., names, without extensions,
72#      rather than full paths to the file.
73#    <XPREFIX>_LIBRARY_DIRS, which is a list of paths to directories
74#      containing the libraries, to which, on a UN*X, -L can be
75#      prefixed.
76#    <XPREFIX>_LDFLAGS, which is a list of *all* required linker flags
77#    <XPREFIX>_LDFLAGS_OTHER, which is a list of all linker flags other
78#      than -l and -L flags
79#
80# In 3.0 (at least as of 3.0.2), it also sets:
81#
82#    <XPREFIX>_LINK_LIBRARIES, which is a list of full paths to the
83#      library files.
84#
85# but if <XPREFIX> is <PREFIX>_STATIC, <XPREFIX>_LINK_LIBRARIES is
86# currently not set by CMake.
87#
88# Unfortunately, pkg_check_modules() sets the
89# PKG_CONFIG_ALLOW_SYSTEM_LIBS environment variable when running
90# pkg-config, so the output of --libs, etc. may include a -L for the
91# system library, which we do *NOT* want to put in our libpcap.pc and
92# pcap-config files.
93#
94# So we just run pkg-config ourselves, so that we get its output
95# directly without any processing by CMake.
96#
97macro(pkg_get_link_info _prefix _package)
98  if (PKG_CONFIG_EXECUTABLE)
99    #
100    # Get the --libs information.
101    #
102    # We force PKG_CONFIG_ALLOW_SYSTEM_LIBS to be undefined, as
103    # at least some versions of CMake appear to define it in
104    # pkg_check_modules() before running pkg-config and *not* undefine
105    # it after running it.
106    #
107    unset(ENV{PKG_CONFIG_ALLOW_SYSTEM_LIBS})
108    set(_pkg_config_result "")
109    execute_process(
110      COMMAND ${PKG_CONFIG_EXECUTABLE} "--libs" ${_package}
111      OUTPUT_VARIABLE _pkg_config_result
112      RESULT_VARIABLE _pkg_config_failed
113      OUTPUT_STRIP_TRAILING_WHITESPACE)
114
115    if (_pkg_config_failed)
116      #
117      # pkg-config failed; assume that means that there is no such
118      # package for it to find.  XXX - what do we do here?
119      #
120      set(${_prefix}_FOUND_WITH_PKG_CONFIG FALSE)
121    else()
122      #
123      # pkg-config succeeded; replace CR and LF with spaces.
124      #
125      string(REGEX REPLACE "[\r\n]" " " ${_prefix}_LIBS "${_pkg_config_result}")
126
127      #
128      # Now get the --libs --static information.
129      #
130      set(_pkg_config_result "")
131      execute_process(
132        COMMAND ${PKG_CONFIG_EXECUTABLE} "--libs" "--static" ${_package}
133        OUTPUT_VARIABLE _pkg_config_result
134        RESULT_VARIABLE _pkg_config_failed
135        OUTPUT_STRIP_TRAILING_WHITESPACE)
136
137      if (_pkg_config_failed)
138        #
139        # pkg-config failed; assume that means that there is no such
140        # package for it to find.  XXX - what do we do here?
141        #
142        set(${_prefix}_FOUND_WITH_PKG_CONFIG FALSE)
143      else()
144        #
145        # pkg-config succeeded; replace CR and LF with spaces.
146        #
147        string(REGEX REPLACE "[\r\n]" " " ${_prefix}_LIBS_STATIC "${_pkg_config_result}")
148
149        #
150        # List this package in its PACKAGE_NAME variable.
151        #
152        set(${_prefix}_PACKAGE_NAME "${_package}")
153
154        #
155        # It worked.
156        #
157        set(${_prefix}_FOUND_WITH_PKG_CONFIG TRUE)
158      endif()
159    endif()
160  endif()
161endmacro()
162
163macro(get_link_info_from_library_path  _library_prefix _library_name)
164  if(NOT ${_library_prefix}_LIBRARY STREQUAL "${_library_prefix}_LIBRARY-NOTFOUND")
165    get_filename_component(_lib_directory "${${_library_prefix}_LIBRARY}}" DIRECTORY)
166
167    #
168    # The closest thing to a list of "system library directories" in
169    # which the linker will, by default, search for libraries appears to
170    # be CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES, so that's what we use
171    # when we're trying to construct a -L argument, for insertion into
172    # pcap-config and libpcap.pc, for a library upon which we depend.
173    #
174    # In some versions of CMake it appears to have duplicate entries,
175    # but that shouldn't affect a search for a directory in that list.
176    #
177    list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${_lib_directory}" _lib_index)
178    if(_lib_index EQUAL -1)
179      #
180      # No, so add a -L flag to get the linker to search in that
181      # directory.
182      #
183      set(${_library_prefix}_LIBS "-L${_lib_directory}")
184      set(${_library_prefix}_LIBS_STATIC "-L${_lib_directory}")
185      set(${_libraryprefix}_LIBS_PRIVATE "-L${_lib_directory}")
186    endif()
187    set(${_library_prefix}_LIBS "${${_library_prefix}_LIBS} -l${_library_name}")
188    set(${_library_prefix}_LIBS_STATIC "${${_library_prefix}_LIBS} -l${_library_name}")
189    set(${_library_prefix}_LIBS_PRIVATE "${${_library_prefix}_LIBS} -l${_library_name}")
190  endif()
191endmacro()
192
193if(CMAKE_SYSTEM_NAME STREQUAL "Haiku")
194    enable_language(CXX)
195
196    #
197    # OK, this is a royal pain.
198    #
199    # CMake will try to determine the sizes of some data types, including
200    # void *, early in the process of configuration; apparently, it's done
201    # as part of processing the project() command.
202    #
203    # At least as of CMake 2.8.6, it does so by checking the size of
204    # "void *" in C, setting CMAKE_C_SIZEOF_DATA_PTR based on that,
205    # setting CMAKE_SIZEOF_VOID_P to that, and then checking the size
206    # of "void *" in C++, setting CMAKE_CXX_SIZEOF_DATA_PTR based on
207    # that, and then setting CMAKE_SIZEOF_VOID_P to *that*.
208    #
209    # The compile tests include whatever C flags may have been provided
210    # to CMake in the CFLAGS and CXXFLAGS environment variables.
211    #
212    # If you set an architecture flag such as -m32 or -m64 in CFLAGS
213    # but *not* in CXXFLAGS, the size for C++ will win, and hilarity
214    # will ensue.
215    #
216    # Or if, at least on Solaris, you have a newer version of GCC
217    # installed, but *not* a newer version of G++, and you have Oracle
218    # Studio installed, it will find GCC, which will default to building
219    # 64-bit, and Oracle Studio's C++ compiler, which will default to
220    # building 32-bit, the size for C++ will win, and, again, hilarity
221    # will ensue.
222    #
223    # So we make sure both languages have the same pointer sizes with
224    # the flags they're given; if they don't, it means that the
225    # compilers for the languages will, with those flags, not produce
226    # code that can be linked together.
227    #
228    # This is unlikely to happen on Haiku, but it *has* happened on
229    # Solaris; we do this for future-proofing, in case we ever need
230    # C++ on a platform where that can happen.
231    #
232    if(NOT ${CMAKE_C_SIZEOF_DATA_PTR} EQUAL ${CMAKE_CXX_SIZEOF_DATA_PTR})
233         message(FATAL_ERROR
234"C compiler ${CMAKE_C_COMPILER} produces code with \
235${CMAKE_C_SIZEOF_DATA_PTR}-byte pointers while C++ compiler \
236${CMAKE_CXX_COMPILER} produces code with \
237${CMAKE_CXX_SIZEOF_DATA_PTR}-byte pointers. \
238This prevents code in these languages from being combined.")
239    endif()
240endif()
241
242#
243# Show the bit width for which we're compiling.
244# This can help debug problems if you're dealing with a compiler that
245# defaults to generating 32-bit code even when running on a 64-bit
246# platform, and where that platform may provide only 64-bit versions of
247# libraries that we might use (looking at *you*, Oracle Studio!).
248#
249if(CMAKE_SIZEOF_VOID_P EQUAL 4)
250  message(STATUS "Building 32-bit")
251elseif(CMAKE_SIZEOF_VOID_P EQUAL 8)
252  message(STATUS "Building 64-bit")
253endif()
254
255#
256# Solaris pkg-config is annoying.  For at least one package (D-Bus, I'm
257# looking at *you*!), there are separate include files for 32-bit and
258# 64-bit builds (I guess using "unsigned long long" as a 64-bit integer
259# type on a 64-bit build is like crossing the beams or soething), and
260# there are two separate .pc files, so if we're doing a 32-bit build we
261# should make sure we look in /usr/lib/pkgconfig for .pc files and if
262# we're doing a 64-bit build we should make sure we look in
263# /usr/lib/amd64/pkgconfig for .pc files.
264#
265if(CMAKE_SYSTEM_NAME STREQUAL "SunOS" AND CMAKE_SYSTEM_VERSION MATCHES "5[.][0-9.]*")
266    #
267    # Note: string(REPLACE) does not appear to support using ENV{...}
268    # as an argument, so we set a variable and then use set() to set
269    # the environment variable.
270    #
271    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
272        #
273        # 64-bit build.  If /usr/lib/pkgconfig appears in the path,
274        # prepend /usr/lib/amd64/pkgconfig to it; otherwise,
275        # put /usr/lib/amd64 at the end.
276        #
277        if((NOT DEFINED ENV{PKG_CONFIG_PATH}) OR "$ENV{PKG_CONFIG_PATH}" EQUAL "")
278            #
279            # Not set, or empty.  Set it to /usr/lib/amd64/pkgconfig.
280            #
281            set(fixed_path "/usr/lib/amd64/pkgconfig")
282        elseif("$ENV{PKG_CONFIG_PATH}" MATCHES "/usr/lib/pkgconfig")
283            #
284            # It contains /usr/lib/pkgconfig.  Prepend
285            # /usr/lib/amd64/pkgconfig to /usr/lib/pkgconfig.
286            #
287            string(REPLACE "/usr/lib/pkgconfig"
288                "/usr/lib/amd64/pkgconfig:/usr/lib/pkgconfig"
289                fixed_path "$ENV{PKG_CONFIG_PATH}")
290        else()
291            #
292            # Not empty, but doesn't contain /usr/lib/pkgconfig.
293            # Append /usr/lib/amd64/pkgconfig to it.
294            #
295            set(fixed_path "$ENV{PKG_CONFIG_PATH}:/usr/lib/amd64/pkgconfig")
296        endif()
297        set(ENV{PKG_CONFIG_PATH} "${fixed_path}")
298    elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
299        #
300        # 32-bit build.  If /usr/amd64/lib/pkgconfig appears in the path,
301        # prepend /usr/lib/pkgconfig to it.
302        #
303        if("$ENV{PKG_CONFIG_PATH}" MATCHES "/usr/lib/amd64/pkgconfig")
304            #
305            # It contains /usr/lib/amd64/pkgconfig.  Prepend
306            # /usr/lib/pkgconfig to /usr/lib/amd64/pkgconfig.
307            #
308            string(REPLACE "/usr/lib/amd64/pkgconfig"
309                "/usr/lib/pkgconfig:/usr/lib/amd64/pkgconfig"
310                fixed_path "$ENV{PKG_CONFIG_PATH}")
311            set(ENV{PKG_CONFIG_PATH} "${fixed_path}")
312        endif()
313    endif()
314endif()
315
316include(CheckCCompilerFlag)
317
318#
319# For checking if a compiler flag works and adding it if it does.
320#
321macro(check_and_add_compiler_option _option)
322    message(STATUS "Checking C compiler flag ${_option}")
323    string(REPLACE "=" "-" _temp_option_variable ${_option})
324    string(REGEX REPLACE "^-" "" _option_variable ${_temp_option_variable})
325    check_c_compiler_flag("${_option}" ${_option_variable})
326    if(${${_option_variable}})
327        set(C_ADDITIONAL_FLAGS "${C_ADDITIONAL_FLAGS} ${_option}")
328    endif()
329endmacro()
330
331#
332# If we're building with Visual Studio, we require Visual Studio 2015,
333# in order to get sufficient C99 compatibility.  Check for that.
334#
335# If not, try the appropriate flag for the compiler to enable C99
336# features.
337#
338set(C_ADDITIONAL_FLAGS "")
339if(MSVC)
340    if(MSVC_VERSION LESS 1900)
341        message(FATAL_ERROR "Visual Studio 2015 or later is required")
342    endif()
343
344    #
345    # Treat source files as being in UTF-8 with MSVC if it's not using
346    # the Clang front end.
347    # We assume that UTF-8 source is OK with other compilers and with
348    # MSVC if it's using the Clang front end.
349    #
350    if(NOT ${CMAKE_C_COMPILER} MATCHES "clang*")
351        set(C_ADDITIONAL_FLAGS "${C_ADDITIONAL_FLAGS} /utf-8")
352    endif(NOT ${CMAKE_C_COMPILER} MATCHES "clang*")
353else(MSVC)
354    #
355    # For checking if a compiler flag works, failing if it doesn't,
356    # and adding it otherwise.
357    #
358    macro(require_and_add_compiler_option _option)
359        message(STATUS "Checking C compiler flag ${_option}")
360        string(REPLACE "=" "-" _temp_option_variable ${_option})
361        string(REGEX REPLACE "^-" "" _option_variable ${_temp_option_variable})
362        check_c_compiler_flag("${_option}" ${_option_variable})
363        if(${${_option_variable}})
364            set(C_ADDITIONAL_FLAGS "${C_ADDITIONAL_FLAGS} ${_option}")
365        else()
366            message(FATAL_ERROR "C99 support is required, but the compiler doesn't support a compiler flag to enable it")
367        endif()
368    endmacro()
369
370    #
371    # Try to enable as many C99 features as we can.
372    # At minimum, we want C++/C99-style // comments.
373    #
374    # Newer versions of compilers might default to supporting C99, but
375    # older versions may require a special flag.
376    #
377    # Prior to CMake 3.1, setting CMAKE_C_STANDARD will not have any effect,
378    # so, unless and until we require CMake 3.1 or later, we have to do it
379    # ourselves on pre-3.1 CMake, so we just do it ourselves on all versions
380    # of CMake.
381    #
382    # Note: with CMake 3.1 through 3.5, the only compilers for which CMake
383    # handles CMAKE_C_STANDARD are GCC and Clang.  3.6 adds support only
384    # for Intel C; 3.9 adds support for PGI C, Sun C, and IBM XL C, and
385    # 3.10 adds support for Cray C and IAR C, but no version of CMake has
386    # support for HP C.  Therefore, even if we use CMAKE_C_STANDARD with
387    # compilers for which CMake supports it, we may still have to do it
388    # ourselves on other compilers.
389    #
390    # See the CMake documentation for the CMAKE_<LANG>_COMPILER_ID variables
391    # for a list of compiler IDs.
392    #
393    # XXX - this just tests whether the option works, fails if it doesn't,
394    # and adds it if it does.  We don't test whether it's necessary in order
395    # to get the C99 features that we use, or whether, if it's used, it
396    # enables all the features that we require.
397    #
398    if(CMAKE_C_COMPILER_ID MATCHES "GNU" OR
399       CMAKE_C_COMPILER_ID MATCHES "Clang")
400        require_and_add_compiler_option("-std=gnu99")
401    elseif(CMAKE_C_COMPILER_ID MATCHES "XL")
402        #
403        # We want support for extensions picked up for GNU C compatibility,
404        # so we use -qlanglvl=extc99.
405        #
406        require_and_add_compiler_option("-qlanglvl=extc99")
407    elseif(CMAKE_C_COMPILER_ID MATCHES "HP")
408        require_and_add_compiler_option("-AC99")
409    elseif(CMAKE_C_COMPILER_ID MATCHES "Sun")
410        require_and_add_compiler_option("-xc99")
411    elseif(CMAKE_C_COMPILER_ID MATCHES "Intel")
412        require_and_add_compiler_option("-c99")
413    endif()
414endif(MSVC)
415
416#
417# If we're building with MinGW, we need to specify _WIN32_WINNT as
418# 0x0600 ("NT 6.0", a/k/a Vista/Windows Server 2008) or higher
419# in order to get the full IPv6 API, including inet_ntop(), and we
420# need to specify it as 0x0601 ("NT 6.1", a/k/a Windows 7) or higher
421# in order to get NdisMediumIP.
422#
423# NOTE: pcap does *NOT* work with msvcrt.dll; it must link with
424# a newer version of the C library, i.e. Visual Studio 2015 or
425# later, as it depends on C99 features introduced in VS 2015.
426#
427if(MINGW)
428    add_definitions(-D_WIN32_WINNT=0x0601)
429endif(MINGW)
430
431#
432# Build all runtimes in the top-level binary directory; that way,
433# on Windows, the executables will be in the same directory as
434# the DLLs, so the system will find pcap.dll when any of the
435# executables are run.
436#
437set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/run)
438
439###################################################################
440#   Parameters
441###################################################################
442
443if(WIN32)
444    #
445    # On Windows, allow the library name to be overridden, for the
446    # benefit of projects that combine libpcap with their own
447    # kernel-mode code to support capturing.
448    #
449    set(LIBRARY_NAME pcap CACHE STRING "Library name")
450else()
451    #
452    # On UN*X, it's always been libpcap.
453    #
454    set(LIBRARY_NAME pcap)
455endif()
456
457option(INET6 "Enable IPv6" ON)
458if(WIN32)
459    option(USE_STATIC_RT "Use static Runtime" ON)
460endif(WIN32)
461option(BUILD_SHARED_LIBS "Build shared libraries" ON)
462set(dpdk_ROOT "" CACHE PATH "Path to directory with include and lib subdirectories for DPDK")
463if(WIN32)
464    set(Packet_ROOT "" CACHE PATH "Path to directory with include and lib subdirectories for packet.dll")
465    set(AirPcap_ROOT "" CACHE PATH "Path to directory with include and lib subdirectories for airpcap.dll")
466endif(WIN32)
467
468option(ENABLE_PROFILING "Enable code profiling" OFF)
469
470# To pacify those who hate the protochain instruction
471option(NO_PROTOCHAIN "Disable protochain instruction" OFF)
472
473#
474# Start out with the capture mechanism type unspecified; the user
475# can explicitly specify it and, if they don't, we'll pick an
476# appropriate one.
477#
478set(PCAP_TYPE "" CACHE STRING "Packet capture type")
479
480#
481# Default to having remote capture support on Windows and, for now, to
482# not having it on UN*X.
483#
484if(WIN32)
485    option(ENABLE_REMOTE "Enable remote capture" ON)
486else()
487    option(ENABLE_REMOTE "Enable remote capture" OFF)
488endif(WIN32)
489
490if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
491    option(BUILD_WITH_LIBNL "Build with libnl" ON)
492endif()
493
494#
495# Additional capture modules.
496#
497if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
498    option(DISABLE_LINUX_USBMON "Disable Linux usbmon USB sniffing support" OFF)
499endif()
500option(DISABLE_BLUETOOTH "Disable Bluetooth sniffing support" OFF)
501option(DISABLE_NETMAP "Disable netmap support" OFF)
502option(DISABLE_DPDK "Disable DPDK support" OFF)
503
504#
505# We don't support D-Bus sniffing on macOS; see
506#
507# https://bugs.freedesktop.org/show_bug.cgi?id=74029
508#
509if(APPLE)
510    option(DISABLE_DBUS "Disable D-Bus sniffing support" ON)
511else(APPLE)
512    option(DISABLE_DBUS "Disable D-Bus sniffing support" OFF)
513endif(APPLE)
514option(DISABLE_RDMA "Disable RDMA sniffing support" OFF)
515
516option(DISABLE_DAG "Disable Endace DAG card support" OFF)
517
518option(DISABLE_SEPTEL "Disable Septel card support" OFF)
519set(SEPTEL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../septel" CACHE PATH "Path to directory with include and lib subdirectories for Septel API")
520
521option(DISABLE_SNF "Disable Myricom SNF support" OFF)
522
523option(DISABLE_TC "Disable Riverbed TurboCap support" OFF)
524
525#
526# Debugging options.
527#
528option(BDEBUG "Build optimizer debugging code" OFF)
529option(YYDEBUG "Build parser debugging code" OFF)
530
531###################################################################
532#   Versioning
533###################################################################
534
535# Get, parse, format and set pcap's version string from [pcap_root]/VERSION
536# for later use.
537
538# Get MAJOR, MINOR, PATCH & SUFFIX
539file(STRINGS ${pcap_SOURCE_DIR}/VERSION
540    PACKAGE_VERSION
541    LIMIT_COUNT 1 # Read only the first line
542)
543
544# Get "just" MAJOR
545string(REGEX MATCH "^([0-9]+)" PACKAGE_VERSION_MAJOR "${PACKAGE_VERSION}")
546
547# Get MAJOR, MINOR & PATCH
548string(REGEX MATCH "^([0-9]+.)?([0-9]+.)?([0-9]+)" PACKAGE_VERSION_NOSUFFIX "${PACKAGE_VERSION}")
549
550if(WIN32)
551    # Convert PCAP_VERSION_NOSUFFIX to Windows preferred version format
552    string(REPLACE "." "," PACKAGE_VERSION_PREDLL ${PACKAGE_VERSION_NOSUFFIX})
553
554    # Append NANO (used for Windows internal versioning) to PCAP_VERSION_PREDLL
555    # 0 means unused.
556    set(PACKAGE_VERSION_DLL ${PACKAGE_VERSION_PREDLL},0)
557endif(WIN32)
558
559set(PACKAGE_NAME "${LIBRARY_NAME}")
560set(PACKAGE_STRING "${LIBRARY_NAME} ${PACKAGE_VERSION}")
561
562######################################
563# Project settings
564######################################
565
566add_definitions(-DHAVE_CONFIG_H)
567
568include_directories(
569    ${CMAKE_CURRENT_BINARY_DIR}
570    ${pcap_SOURCE_DIR}
571)
572
573include(CheckFunctionExists)
574include(CMakePushCheckState)
575include(CheckSymbolExists)
576
577if(WIN32)
578
579    if(IS_DIRECTORY ${CMAKE_HOME_DIRECTORY}/../../Common)
580        include_directories(${CMAKE_HOME_DIRECTORY}/../../Common)
581    endif(IS_DIRECTORY ${CMAKE_HOME_DIRECTORY}/../../Common)
582
583    find_package(Packet)
584    if(Packet_FOUND)
585        set(HAVE_PACKET32 TRUE)
586        include_directories(${Packet_INCLUDE_DIRS})
587        #
588        # Check whether we have the NPcap PacketIsLoopbackAdapter()
589        # function.
590        #
591        cmake_push_check_state()
592        set(CMAKE_REQUIRED_LIBRARIES ${Packet_LIBRARIES})
593        check_function_exists(PacketIsLoopbackAdapter HAVE_PACKET_IS_LOOPBACK_ADAPTER)
594        check_function_exists(PacketGetTimestampModes HAVE_PACKET_GET_TIMESTAMP_MODES)
595        cmake_pop_check_state()
596    endif(Packet_FOUND)
597
598    message(STATUS "checking for Npcap's version.h")
599    check_symbol_exists(WINPCAP_PRODUCT_NAME "${CMAKE_SOURCE_DIR}/../../version.h" HAVE_VERSION_H)
600    if(HAVE_VERSION_H)
601        message(STATUS "HAVE version.h")
602    else(HAVE_VERSION_H)
603        message(STATUS "MISSING version.h")
604    endif(HAVE_VERSION_H)
605
606endif(WIN32)
607
608if(MSVC)
609    add_definitions(-D__STDC__)
610    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
611endif(MSVC)
612
613if(USE_STATIC_RT)
614    message(STATUS "Use STATIC runtime")
615        if(MSVC)
616            foreach(RT_FLAG
617                CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
618                CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
619                CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
620                CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
621                string(REGEX REPLACE "/MD" "/MT" ${RT_FLAG} "${${RT_FLAG}}")
622            endforeach(RT_FLAG)
623        elseif(MINGW)
624            set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-libgcc")
625        endif()
626else (USE_STATIC_RT)
627    message(STATUS "Use DYNAMIC runtime")
628endif(USE_STATIC_RT)
629
630###################################################################
631#   Detect available platform features
632###################################################################
633
634include(CheckIncludeFile)
635include(CheckIncludeFiles)
636include(CheckStructHasMember)
637include(CheckTypeSize)
638
639#
640# Tests are a bit expensive with Visual Studio on Windows, so, on
641# Windows, we skip tests for UN*X-only headers and functions.
642#
643
644#
645# Header files.
646#
647check_include_file(inttypes.h HAVE_INTTYPES_H)
648check_include_file(stdint.h HAVE_STDINT_H)
649check_include_file(unistd.h HAVE_UNISTD_H)
650if(NOT HAVE_UNISTD_H)
651    add_definitions(-DYY_NO_UNISTD_H)
652endif(NOT HAVE_UNISTD_H)
653check_include_file(bitypes.h HAVE_SYS_BITYPES_H)
654if(NOT WIN32)
655    check_include_file(sys/ioccom.h HAVE_SYS_IOCCOM_H)
656    check_include_file(sys/sockio.h HAVE_SYS_SOCKIO_H)
657    check_include_file(sys/select.h HAVE_SYS_SELECT_H)
658
659    check_include_file(netpacket/packet.h HAVE_NETPACKET_PACKET_H)
660    check_include_file(netinet/if_ether.h HAVE_NETINET_IF_ETHER_H)
661endif(NOT WIN32)
662
663#
664# Functions.
665#
666# First, check for the __atomic_load_n() and __atomic_store_n()
667# builtins.
668#
669# We can't use check_function_exists(), as it tries to declare
670# the function, and attempting to declare a compiler builtin
671# can produce an error.
672#
673# We don't use check_symbol_exists(), as it expects a header
674# file to be specified to declare the function, but there isn't
675# such a header file.
676#
677# So we use check_c_source_compiles().
678#
679check_c_source_compiles(
680"int
681main(void)
682{
683	int i = 17;
684	return __atomic_load_n(&i, __ATOMIC_RELAXED);
685}
686"
687            HAVE___ATOMIC_LOAD_N)
688check_c_source_compiles(
689"int
690main(void)
691{
692	int i;
693	__atomic_store_n(&i, 17, __ATOMIC_RELAXED);
694	return 0;
695}
696"
697            HAVE___ATOMIC_STORE_N)
698
699#
700# Now check for various system functions.
701#
702check_function_exists(strerror HAVE_STRERROR)
703check_function_exists(strerror_r HAVE_STRERROR_R)
704if(HAVE_STRERROR_R)
705    #
706    # We have strerror_r; if we define _GNU_SOURCE, is it a
707    # POSIX-compliant strerror_r() or a GNU strerror_r()?
708    #
709    check_c_source_compiles(
710"#define _GNU_SOURCE
711#include <string.h>
712
713/* Define it GNU-style; that will cause an error if it's not GNU-style */
714extern char *strerror_r(int, char *, size_t);
715
716int
717main(void)
718{
719	return 0;
720}
721"
722            HAVE_GNU_STRERROR_R)
723    if(NOT HAVE_GNU_STRERROR_R)
724        set(HAVE_POSIX_STRERROR_R YES)
725    endif(NOT HAVE_GNU_STRERROR_R)
726else(HAVE_STRERROR_R)
727    #
728    # We don't have strerror_r; do we have _wcserror_s?
729    #
730    check_function_exists(_wcserror_s HAVE__WCSERROR_S)
731endif(HAVE_STRERROR_R)
732
733#
734# Make sure we have vsnprintf() and snprintf(); we require them.
735# We use check_symbol_exists(), as they aren't necessarily external
736# functions - in Visual Studio, for example, they're inline functions
737# calling a common external function.
738#
739check_symbol_exists(vsnprintf "stdio.h" HAVE_VSNPRINTF)
740if(NOT HAVE_VSNPRINTF)
741    message(FATAL_ERROR "vsnprintf() is required but wasn't found")
742endif(NOT HAVE_VSNPRINTF)
743check_symbol_exists(snprintf "stdio.h" HAVE_SNPRINTF)
744if(NOT HAVE_SNPRINTF)
745    message(FATAL_ERROR "snprintf() is required but wasn't found")
746endif()
747
748check_function_exists(strlcpy HAVE_STRLCPY)
749check_function_exists(strlcat HAVE_STRLCAT)
750check_function_exists(asprintf HAVE_ASPRINTF)
751check_function_exists(vasprintf HAVE_VASPRINTF)
752check_function_exists(strtok_r HAVE_STRTOK_R)
753if(NOT WIN32)
754    check_function_exists(vsyslog HAVE_VSYSLOG)
755endif()
756
757#
758# These tests are for network applications that need socket functions
759# and getaddrinfo()/getnameinfo()-ish functions.  We now require
760# getaddrinfo() and getnameinfo().  On UN*X systems, we also prefer
761# versions of recvmsg() that conform to the Single UNIX Specification,
762# so that we can check whether a datagram received with recvmsg() was
763# truncated when received due to the buffer being too small.
764#
765# On Windows, getaddrinfo() is in the ws2_32 library.
766
767# On most UN*X systems, they're available in the system library.
768#
769# Under Solaris, we need to link with libsocket and libnsl to get
770# getaddrinfo() and getnameinfo() and, if we have libxnet, we need to
771# link with libxnet before libsocket to get a version of recvmsg()
772# that conforms to the Single UNIX Specification.
773#
774# We use getaddrinfo() because we want a portable thread-safe way
775# of getting information for a host name or port; there exist _r
776# versions of gethostbyname() and getservbyname() on some platforms,
777# but not on all platforms.
778#
779# NOTE: if you hand check_library_exists as its last argument a variable
780# that's been set, it skips the test, so we need different variables.
781#
782set(PCAP_LINK_LIBRARIES "")
783set(LIBS "")
784set(LIBS_STATIC "")
785set(REQUIRES_PRIVATE "")
786set(LIBS_PRIVATE "")
787include(CheckLibraryExists)
788if(WIN32)
789    #
790    # We need winsock2.h and ws2tcpip.h.
791    #
792    cmake_push_check_state()
793    set(CMAKE_REQUIRED_LIBRARIES ws2_32)
794    check_symbol_exists(getaddrinfo "winsock2.h;ws2tcpip.h" LIBWS2_32_HAS_GETADDRINFO)
795    cmake_pop_check_state()
796    if(LIBWS2_32_HAS_GETADDRINFO)
797        set(PCAP_LINK_LIBRARIES ws2_32 ${PCAP_LINK_LIBRARIES})
798    else(LIBWS2_32_HAS_GETADDRINFO)
799        message(FATAL_ERROR "getaddrinfo is required, but wasn't found")
800    endif(LIBWS2_32_HAS_GETADDRINFO)
801else(WIN32)
802    #
803    # UN*X.  First try the system libraries, then try the libraries
804    # for Solaris and possibly other systems that picked up the
805    # System V library split.
806    #
807    check_function_exists(getaddrinfo STDLIBS_HAVE_GETADDRINFO)
808    if(NOT STDLIBS_HAVE_GETADDRINFO)
809        #
810        # Not found in the standard system libraries.
811        # Try libsocket, which requires libnsl.
812        #
813        cmake_push_check_state()
814        set(CMAKE_REQUIRED_LIBRARIES nsl)
815        check_library_exists(socket getaddrinfo "" LIBSOCKET_HAS_GETADDRINFO)
816        cmake_pop_check_state()
817        if(LIBSOCKET_HAS_GETADDRINFO)
818            #
819            # OK, we found it in libsocket.
820            #
821            set(PCAP_LINK_LIBRARIES socket nsl ${PCAP_LINK_LIBRARIES})
822            set(LIBS "-lsocket -lnsl ${LIBS}")
823            set(LIBS_STATIC "-lsocket -lnsl ${LIBS_STATIC}")
824            set(LIBS_PRIVATE "-lsocket -lnsl ${LIBS_PRIVATE}")
825        else(LIBSOCKET_HAS_GETADDRINFO)
826            check_library_exists(network getaddrinfo "" LIBNETWORK_HAS_GETADDRINFO)
827            if(LIBNETWORK_HAS_GETADDRINFO)
828                #
829                # OK, we found it in libnetwork (Haiku).
830                #
831                set(PCAP_LINK_LIBRARIES network ${PCAP_LINK_LIBRARIES})
832                set(LIBS "-lnetwork ${LIBS}")
833                set(LIBS_STATIC "-lnetwork ${LIBS_STATIC}")
834                set(LIBS_PRIVATE "-lnetwork ${LIBS_PRIVATE}")
835            else(LIBNETWORK_HAS_GETADDRINFO)
836                #
837                # We didn't find it.
838                #
839                message(FATAL_ERROR "getaddrinfo is required, but wasn't found")
840            endif(LIBNETWORK_HAS_GETADDRINFO)
841        endif(LIBSOCKET_HAS_GETADDRINFO)
842
843        #
844        # OK, do we have recvmsg() in libxnet?
845        # We also link with libsocket and libnsl.
846        #
847        cmake_push_check_state()
848        set(CMAKE_REQUIRED_LIBRARIES socket nsl)
849        check_library_exists(xnet recvmsg "" LIBXNET_HAS_RECVMSG)
850        cmake_pop_check_state()
851        if(LIBXNET_HAS_RECVMSG)
852            #
853            # Yes - link with it as well.
854            #
855            set(PCAP_LINK_LIBRARIES xnet ${PCAP_LINK_LIBRARIES})
856            set(LIBSC "-lxnet ${LIBS_LIBS}")
857            set(LIBS_STATIC "-lxnet ${LIBS_STATIC}")
858            set(LIBS_PRIVATE "-lxnet ${LIBS_PRIVATE}")
859        endif(LIBXNET_HAS_RECVMSG)
860    endif(NOT STDLIBS_HAVE_GETADDRINFO)
861
862    # DLPI needs putmsg under HPUX so test for -lstr while we're at it
863    check_function_exists(putmsg STDLIBS_HAVE_PUTMSG)
864    if(NOT STDLIBS_HAVE_PUTMSG)
865        check_library_exists(str putmsg "" LIBSTR_HAS_PUTMSG)
866        if(LIBSTR_HAS_PUTMSG)
867            set(PCAP_LINK_LIBRARIES str ${PCAP_LINK_LIBRARIES})
868            set(LIBS "-lstr ${LIBS}")
869            set(LIBS_STATIC "-lstr ${LIBS_STATIC}")
870            set(LIBS_PRIVATE "-lstr ${LIBS_PRIVATE}")
871        endif(LIBSTR_HAS_PUTMSG)
872    endif(NOT STDLIBS_HAVE_PUTMSG)
873
874    # Haiku has getpass in libbsd
875    check_function_exists(getpass STDLIBS_HAVE_GETPASS)
876    if(NOT STDLIBS_HAVE_GETPASS)
877        check_library_exists(bsd getpass "" LIBBSD_HAS_GETPASS)
878        if(LIBBSD_HAS_GETPASS)
879            set(PCAP_LINK_LIBRARIES bsd ${PCAP_LINK_LIBRARIES})
880        endif(LIBBSD_HAS_GETPASS)
881    endif(NOT STDLIBS_HAVE_GETPASS)
882endif(WIN32)
883
884#
885# Check for reentrant versions of getnetbyname_r(), as provided by
886# Linux (glibc), Solaris/IRIX, and AIX (with three different APIs!).
887# If we don't find one, we just use getnetbyname(), which uses
888# thread-specific data on many platforms, but doesn't use it on
889# NetBSD or OpenBSD, and may not use it on older versions of other
890# platforms.
891#
892# Only do the check if we have a declaration of getnetbyname_r();
893# without it, we can't check which API it has.  (We assume that
894# if there's a declaration, it has a prototype, so that the API
895# can be checked.)
896#
897cmake_push_check_state()
898set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LINK_LIBRARIES})
899check_symbol_exists(getnetbyname_r netdb.h NETDB_H_DECLARES_GETNETBYNAME_R)
900if(NETDB_H_DECLARES_GETNETBYNAME_R)
901    check_c_source_compiles(
902"#include <netdb.h>
903
904int
905main(void)
906{
907    struct netent netent_buf;
908    char buf[1024];
909    struct netent *resultp;
910    int h_errnoval;
911
912    return getnetbyname_r((const char *)0, &netent_buf, buf, sizeof buf, &resultp, &h_errnoval);
913}
914"
915        HAVE_LINUX_GETNETBYNAME_R)
916    if(NOT HAVE_LINUX_GETNETBYNAME_R)
917        check_c_source_compiles(
918"#include <netdb.h>
919
920int
921main(void)
922{
923    struct netent netent_buf;
924    char buf[1024];
925
926    return getnetbyname_r((const char *)0, &netent_buf, buf, (int)sizeof buf) != NULL;
927}
928"
929            HAVE_SOLARIS_IRIX_GETNETBYNAME_R)
930        if(NOT HAVE_SOLARIS_IRIX_GETNETBYNAME_R)
931            check_c_source_compiles(
932"#include <netdb.h>
933
934int
935main(void)
936{
937    struct netent netent_buf;
938    struct netent_data net_data;
939
940    return getnetbyname_r((const char *)0, &netent_buf, &net_data);
941}
942"
943                HAVE_AIX_GETNETBYNAME_R)
944        endif(NOT HAVE_SOLARIS_IRIX_GETNETBYNAME_R)
945    endif(NOT HAVE_LINUX_GETNETBYNAME_R)
946endif(NETDB_H_DECLARES_GETNETBYNAME_R)
947cmake_pop_check_state()
948
949#
950# Check for reentrant versions of getprotobyname_r(), as provided by
951# Linux (glibc), Solaris/IRIX, and AIX (with three different APIs!).
952# If we don't find one, we just use getprotobyname(), which uses
953# thread-specific data on many platforms, but doesn't use it on
954# NetBSD or OpenBSD, and may not use it on older versions of other
955# platforms.
956#
957# Only do the check if we have a declaration of getprotobyname_r();
958# without it, we can't check which API it has.  (We assume that
959# if there's a declaration, it has a prototype, so that the API
960# can be checked.)
961#
962cmake_push_check_state()
963set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LINK_LIBRARIES})
964check_symbol_exists(getprotobyname_r netdb.h NETDB_H_DECLARES_GETPROTOBYNAME_R)
965if(NETDB_H_DECLARES_GETPROTOBYNAME_R)
966    check_c_source_compiles(
967"#include <netdb.h>
968
969int
970main(void)
971{
972    struct protoent protoent_buf;
973    char buf[1024];
974    struct protoent *resultp;
975
976    return getprotobyname_r((const char *)0, &protoent_buf, buf, sizeof buf, &resultp);
977}
978"
979        HAVE_LINUX_GETPROTOBYNAME_R)
980    if(NOT HAVE_LINUX_GETPROTOBYNAME_R)
981        check_c_source_compiles(
982"#include <netdb.h>
983
984int
985main(void)
986{
987    struct protoent protoent_buf;
988    char buf[1024];
989
990    return getprotobyname_r((const char *)0, &protoent_buf, buf, (int)sizeof buf) != NULL;
991}
992"
993            HAVE_SOLARIS_IRIX_GETPROTOBYNAME_R)
994        if(NOT HAVE_SOLARIS_IRIX_GETPROTOBYNAME_R)
995            check_c_source_compiles(
996"#include <netdb.h>
997
998int
999main(void)
1000{
1001    struct protoent protoent_buf;
1002    struct protoent_data proto_data;
1003
1004    return getprotobyname_r((const char *)0, &protoent_buf, &proto_data);
1005}
1006"
1007                HAVE_AIX_GETPROTOBYNAME_R)
1008        endif(NOT HAVE_SOLARIS_IRIX_GETPROTOBYNAME_R)
1009    endif(NOT HAVE_LINUX_GETPROTOBYNAME_R)
1010endif(NETDB_H_DECLARES_GETPROTOBYNAME_R)
1011cmake_pop_check_state()
1012
1013#
1014# Data types.
1015#
1016# XXX - there's no check_type() macro that's like check_type_size()
1017# except that it only checks for the existence of the structure type,
1018# so we use check_type_size() and ignore the size.
1019#
1020cmake_push_check_state()
1021if(WIN32)
1022    set(CMAKE_EXTRA_INCLUDE_FILES winsock2.h)
1023else(WIN32)
1024    set(CMAKE_EXTRA_INCLUDE_FILES unistd.h sys/socket.h)
1025endif(WIN32)
1026check_type_size("struct sockaddr_storage" STRUCT_SOCKADDR_STORAGE)
1027check_type_size("socklen_t" SOCKLEN_T)
1028cmake_pop_check_state()
1029
1030#
1031# Structure fields.
1032#
1033if(WIN32)
1034    check_struct_has_member("struct sockaddr" sa_len winsock2.h HAVE_STRUCT_SOCKADDR_SA_LEN)
1035else(WIN32)
1036    check_struct_has_member("struct sockaddr" sa_len sys/socket.h HAVE_STRUCT_SOCKADDR_SA_LEN)
1037endif(WIN32)
1038
1039#
1040# Do we have ffs(), and is it declared in <strings.h>?
1041#
1042check_function_exists(ffs HAVE_FFS)
1043if(HAVE_FFS)
1044    #
1045    # OK, we have ffs().  Is it declared in <strings.h>?
1046    #
1047    # This test fails if we don't have <strings.h> or if we do
1048    # but it doesn't declare ffs().
1049    #
1050    check_symbol_exists(ffs strings.h STRINGS_H_DECLARES_FFS)
1051endif()
1052
1053#
1054# This requires the libraries that we require, as ether_hostton might be
1055# in one of those libraries.  That means we have to do this after
1056# we check for those libraries.
1057#
1058# You are in a twisty little maze of UN*Xes, all different.
1059# Some might not have ether_hostton().
1060# Some might have it and declare it in <net/ethernet.h>.
1061# Some might have it and declare it in <netinet/ether.h>
1062# Some might have it and declare it in <sys/ethernet.h>.
1063# Some might have it and declare it in <arpa/inet.h>.
1064# Some might have it and declare it in <netinet/if_ether.h>.
1065# Some might have it and not declare it in any header file.
1066#
1067# Before you is a C compiler.
1068#
1069cmake_push_check_state()
1070set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LINK_LIBRARIES})
1071check_function_exists(ether_hostton HAVE_ETHER_HOSTTON)
1072if(HAVE_ETHER_HOSTTON)
1073    #
1074    # OK, we have ether_hostton().  Is it declared in <net/ethernet.h>?
1075    #
1076    # This test fails if we don't have <net/ethernet.h> or if we do
1077    # but it doesn't declare ether_hostton().
1078    #
1079    check_symbol_exists(ether_hostton net/ethernet.h NET_ETHERNET_H_DECLARES_ETHER_HOSTTON)
1080    if(NET_ETHERNET_H_DECLARES_ETHER_HOSTTON)
1081        #
1082        # Yes - we have it declared.
1083        #
1084        set(HAVE_DECL_ETHER_HOSTTON TRUE)
1085    endif()
1086    #
1087    # Did that succeed?
1088    #
1089    if(NOT HAVE_DECL_ETHER_HOSTTON)
1090        #
1091        # No - how about <netinet/ether.h>, as on Linux?
1092        #
1093        # This test fails if we don't have <netinet/ether.h>
1094        # or if we do but it doesn't declare ether_hostton().
1095        #
1096        check_symbol_exists(ether_hostton netinet/ether.h NETINET_ETHER_H_DECLARES_ETHER_HOSTTON)
1097        if(NETINET_ETHER_H_DECLARES_ETHER_HOSTTON)
1098            #
1099            # Yes - we have it declared.
1100            #
1101            set(HAVE_DECL_ETHER_HOSTTON TRUE)
1102        endif()
1103    endif()
1104    #
1105    # Did that succeed?
1106    #
1107    if(NOT HAVE_DECL_ETHER_HOSTTON)
1108        #
1109        # No - how about <sys/ethernet.h>, as on Solaris 10 and later?
1110        #
1111        # This test fails if we don't have <sys/ethernet.h>
1112        # or if we do but it doesn't declare ether_hostton().
1113        #
1114        check_symbol_exists(ether_hostton sys/ethernet.h SYS_ETHERNET_H_DECLARES_ETHER_HOSTTON)
1115        if(SYS_ETHERNET_H_DECLARES_ETHER_HOSTTON)
1116            #
1117            # Yes - we have it declared.
1118            #
1119            set(HAVE_DECL_ETHER_HOSTTON TRUE)
1120        endif()
1121    endif()
1122    #
1123    # Did that succeed?
1124    #
1125    if(NOT HAVE_DECL_ETHER_HOSTTON)
1126        #
1127        # No, how about <arpa/inet.h>, as on AIX?
1128        #
1129        # This test fails if we don't have <arpa/inet.h>
1130        # or if we do but it doesn't declare ether_hostton().
1131        #
1132        check_symbol_exists(ether_hostton arpa/inet.h ARPA_INET_H_DECLARES_ETHER_HOSTTON)
1133        if(ARPA_INET_H_DECLARES_ETHER_HOSTTON)
1134            #
1135            # Yes - we have it declared.
1136            #
1137            set(HAVE_DECL_ETHER_HOSTTON TRUE)
1138        endif()
1139    endif()
1140    #
1141    # Did that succeed?
1142    #
1143    if(NOT HAVE_DECL_ETHER_HOSTTON)
1144        #
1145        # No, how about <netinet/if_ether.h>?
1146        # On some platforms, it requires <net/if.h> and
1147        # <netinet/in.h>, and we always include it with
1148        # both of them, so test it with both of them.
1149        #
1150        # This test fails if we don't have <netinet/if_ether.h>
1151        # and the headers we include before it, or if we do but
1152        # <netinet/if_ether.h> doesn't declare ether_hostton().
1153        #
1154        check_symbol_exists(ether_hostton "sys/types.h;sys/socket.h;net/if.h;netinet/in.h;netinet/if_ether.h" NETINET_IF_ETHER_H_DECLARES_ETHER_HOSTTON)
1155        if(NETINET_IF_ETHER_H_DECLARES_ETHER_HOSTTON)
1156            #
1157            # Yes - we have it declared.
1158            #
1159            set(HAVE_DECL_ETHER_HOSTTON TRUE)
1160        endif()
1161    endif()
1162    #
1163    # After all that, is ether_hostton() declared?
1164    #
1165    if(NOT HAVE_DECL_ETHER_HOSTTON)
1166        #
1167        # No, we'll have to declare it ourselves.
1168        # Do we have "struct ether_addr" if we include <netinet/if_ether.h>?
1169        #
1170        # XXX - there's no check_type() macro that's like check_type_size()
1171        # except that it only checks for the existence of the structure type,
1172        # so we use check_type_size() and ignore the size.
1173        #
1174        cmake_push_check_state()
1175        set(CMAKE_EXTRA_INCLUDE_FILES sys/types.h sys/socket.h net/if.h netinet/in.h netinet/if_ether.h)
1176        check_type_size("struct ether_addr" STRUCT_ETHER_ADDR)
1177        cmake_pop_check_state()
1178    endif()
1179endif()
1180cmake_pop_check_state()
1181
1182#
1183# Large file support on UN*X, a/k/a LFS.
1184#
1185if(NOT WIN32)
1186  include(FindLFS)
1187  if(LFS_FOUND)
1188    #
1189    # Add the required #defines.
1190    #
1191    add_definitions(${LFS_DEFINITIONS})
1192  endif()
1193
1194  #
1195  # Check for fseeko as well.
1196  #
1197  include(FindFseeko)
1198  if(FSEEKO_FOUND)
1199    set(HAVE_FSEEKO ON)
1200
1201    #
1202    # Add the required #defines.
1203    #
1204    add_definitions(${FSEEKO_DEFINITIONS})
1205  endif()
1206endif()
1207
1208if(INET6)
1209    message(STATUS "Support IPv6")
1210endif(INET6)
1211
1212#
1213# Pthreads.
1214# We might need them, because some libraries we use might use them,
1215# but we don't necessarily need them.
1216# That's only on UN*X; on Windows, if they use threads, we assume
1217# they're native Windows threads.
1218#
1219if(NOT WIN32)
1220  set(CMAKE_THREAD_PREFER_PTHREAD ON)
1221  find_package(Threads)
1222  if(NOT CMAKE_USE_PTHREADS_INIT)
1223    #
1224    # If it's not pthreads, we won't use it; we use it for libraries
1225    # that require it.
1226    #
1227    set(CMAKE_THREAD_LIBS_INIT "")
1228  endif(NOT CMAKE_USE_PTHREADS_INIT)
1229endif(NOT WIN32)
1230
1231if(ENABLE_PROFILING)
1232    if(NOT MSVC)
1233        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pg")
1234        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pg")
1235    endif()
1236endif()
1237
1238#
1239# Based on
1240#
1241#    https://github.com/commonmark/cmark/blob/master/FindAsan.cmake
1242#
1243# The MIT License (MIT)
1244#
1245# Copyright (c) 2013 Matthew Arsenault
1246#
1247# Permission is hereby granted, free of charge, to any person obtaining a copy
1248# of this software and associated documentation files (the "Software"), to deal
1249# in the Software without restriction, including without limitation the rights
1250# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
1251# copies of the Software, and to permit persons to whom the Software is
1252# furnished to do so, subject to the following conditions:
1253#
1254# The above copyright notice and this permission notice shall be included in
1255# all copies or substantial portions of the Software.
1256#
1257# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1258# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1259# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1260# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
1261# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
1262# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
1263# THE SOFTWARE.
1264#
1265# Test if the each of the sanitizers in the ENABLE_SANITIZERS list are
1266# supported by the compiler, and, if so, adds the appropriate flags to
1267# CMAKE_C_FLAGS, CMAKE_CXX_FLAGS, and SANITIZER_FLAGS.  If not, it fails.
1268#
1269# Do this last, in the hope that it will prevent configuration on Linux
1270# from somehow deciding it doesn't need -lpthread when building rpcapd
1271# (it does require it, but somehow, in some mysterious fashion that no
1272# obvious CMake debugging flag reveals, it doesn't realize that if we
1273# turn sanitizer stuff on).
1274#
1275set(SANITIZER_FLAGS "")
1276foreach(sanitizer IN LISTS ENABLE_SANITIZERS)
1277    # Set -Werror to catch "argument unused during compilation" warnings
1278
1279    message(STATUS "Checking sanitizer ${sanitizer}")
1280    set(sanitizer_variable "sanitize_${sanitizer}")
1281    set(CMAKE_REQUIRED_FLAGS "-Werror -fsanitize=${sanitizer}")
1282    check_c_compiler_flag("-fsanitize=${sanitizer}" ${sanitizer_variable})
1283    if(${${sanitizer_variable}})
1284        set(SANITIZER_FLAGS "${SANITIZER_FLAGS} -fsanitize=${sanitizer}")
1285        message(STATUS "${sanitizer} sanitizer supported using -fsanitizer=${sanitizer}")
1286    else()
1287        #
1288        # Try the versions supported prior to Clang 3.2.
1289        # If the sanitizer is "address", try -fsanitize-address.
1290        # If it's "undefined", try -fcatch-undefined-behavior.
1291        # Otherwise, give up.
1292        #
1293        set(sanitizer_variable "OLD_${sanitizer_variable}")
1294        if ("${sanitizer}" STREQUAL "address")
1295            set(CMAKE_REQUIRED_FLAGS "-Werror -fsanitize-address")
1296            check_c_compiler_flag("-fsanitize-address" ${sanitizer_variable})
1297            if(${${sanitizer_variable}})
1298                set(SANITIZER_FLAGS "${SANITIZER_FLAGS} -fsanitize-address")
1299                message(STATUS "${sanitizer} sanitizer supported using -fsanitize-address")
1300            else()
1301                message(FATAL_ERROR "${sanitizer} isn't a supported sanitizer")
1302            endif()
1303        elseif("${sanitizer}" STREQUAL "undefined")
1304            set(CMAKE_REQUIRED_FLAGS "-Werror -fcatch-undefined-behavior")
1305            check_c_compiler_flag("-fcatch-undefined-behavior" ${sanitizer_variable})
1306            if(${${sanitizer_variable}})
1307                set(SANITIZER_FLAGS "${SANITIZER_FLAGS} -fcatch-undefined-behavior")
1308                message(STATUS "${sanitizer} sanitizer supported using catch-undefined-behavior")
1309            else()
1310                message(FATAL_ERROR "${sanitizer} isn't a supported sanitizer")
1311            endif()
1312        else()
1313            message(FATAL_ERROR "${sanitizer} isn't a supported sanitizer")
1314        endif()
1315    endif()
1316
1317    unset(CMAKE_REQUIRED_FLAGS)
1318endforeach()
1319
1320if(NOT "${SANITIZER_FLAGS}" STREQUAL "")
1321  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O1 -g ${SANITIZER_FLAGS} -fno-omit-frame-pointer -fno-optimize-sibling-calls")
1322  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O1 -g ${SANITIZER_FLAGS} -fno-omit-frame-pointer -fno-optimize-sibling-calls")
1323endif()
1324
1325#
1326# OpenSSL/libressl.
1327#
1328find_package(OpenSSL)
1329if(OPENSSL_FOUND)
1330  #
1331  # We have OpenSSL.
1332  #
1333  include_directories(SYSTEM ${OPENSSL_INCLUDE_DIR})
1334  set(PCAP_LINK_LIBRARIES ${PCAP_LINK_LIBRARIES} ${OPENSSL_LIBRARIES})
1335
1336  #
1337  # The find_package() module CMake provides for OpenSSL uses does not
1338  # give us a defined indication of whether it found OpenSSL with
1339  # pkg-config or not.  We need to know that as, if it was found with
1340  # pkg-config, we should set the Requires.private value in libpcap.pc
1341  # to include its package name, openssl, otherwise we should add the
1342  # names for the static libraries to Libs.private.
1343  #
1344  # On UN*X, FindOpenSSL happens to use pkg-config to find OpenSSL, but
1345  # it doesn't appear to be documented as doing so; therefore, we don't
1346  # assume that, if we got here, we have pkg-config.
1347  #
1348  # So we use pkg_get_link_info() to run pkg-config ourselves, both
1349  # because FindOpenSSL doesn't set the OPENSSL_LDFLAGS or
1350  # OPENSSL_STATIC_LDFLAGS variables and because, for reasons explained
1351  # in the comment before the pkg_get_link_info() macro, even if it did,
1352  # it wouldn't be what we want anyway.
1353  #
1354  if (PKG_CONFIG_EXECUTABLE)
1355    pkg_get_link_info(OPENSSL openssl)
1356    if (OPENSSL_FOUND_WITH_PKG_CONFIG)
1357      #
1358      # pkg-config failed; assume that means that there is no openssl
1359      # package for it to find.  Just add OPENSSL_LIBRARIES to
1360      # LIBS_PRIVATE AND LIBS_STATIC, as that's the
1361      # best we can do. XXX - need list of -l and -L flags to add....
1362      #
1363      set(LIBS "${LIBS} ${OPENSSL_LIBS}")
1364      set(LIBS_STATIC "${LIBS_STATIC} ${OPENSSL_LIBS_STATIC}")
1365      set(REQUIRES_PRIVATE "${REQUIRES_PRIVATE} ${OPENSSL_PACKAGE_NAME}")
1366    endif()
1367  else()
1368    # Get it from OPENSSL_LIBRARIES
1369    foreach(_lib IN LISTS OPENSSL_LIBRARIES)
1370      #
1371      # Get the directory in which the library resides.
1372      #
1373      get_filename_component(_lib_directory "${_lib}" DIRECTORY)
1374
1375      #
1376      # Is the library directory in CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES?
1377      # (See comment above on why we use that.)
1378      #
1379      list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${_lib_directory}" _lib_index)
1380      if(_lib_index EQUAL -1)
1381        #
1382        # No, so add a -L flag to get the linker to search in that
1383        # directory.
1384        #
1385        set(LIBS "${LIBS} -L${_lib_directory}")
1386        set(LIBS_STATIC "${LIBS_STATIC} -L${_lib_directory}")
1387        set(LIBS_PRIVATE "${LIBS_PRIVATE} -L${_lib_directory}")
1388      endif()
1389
1390      #
1391      # Get the file name of the library, without the extension.
1392      #
1393      get_filename_component(_lib_filename "${_lib}" NAME_WE)
1394
1395      #
1396      # Strip off the "lib" prefix to get the library name, and
1397      # add a -l flag based on that.
1398      #
1399      string(REGEX REPLACE "^lib" "" _library_name "${_lib_filename}")
1400      set(LIBS "${LIBS} -l${_library_name}")
1401      set(LIBS_STATIC "${LIBS_STATIC} -l${_library_name}")
1402      set(LIBS_PRIVATE "${LIBS_PRIVATE} -l${_library_name}")
1403    endforeach()
1404  endif()
1405  set(HAVE_OPENSSL YES)
1406endif(OPENSSL_FOUND)
1407
1408#
1409# Additional linker flags.
1410#
1411set(LINKER_FLAGS "${SANITIZER_FLAGS}")
1412if(ENABLE_PROFILING)
1413    if(MSVC)
1414        set(LINKER_FLAGS " /PROFILE")
1415    else()
1416        set(LINKER_FLAGS " -pg")
1417    endif()
1418endif()
1419
1420######################################
1421# Input files
1422######################################
1423
1424set(PROJECT_SOURCE_LIST_C
1425    bpf_dump.c
1426    bpf_filter.c
1427    bpf_image.c
1428    etherent.c
1429    fmtutils.c
1430    gencode.c
1431    nametoaddr.c
1432    optimize.c
1433    pcap-common.c
1434    pcap-usb-linux-common.c
1435    pcap-util.c
1436    pcap.c
1437    savefile.c
1438    sf-pcapng.c
1439    sf-pcap.c
1440)
1441
1442if(WIN32)
1443    #
1444    # We add the character set conversion routines; they're Windows-only
1445    # for now.
1446    #
1447    # We assume we don't have asprintf(), and provide an implementation
1448    # that uses _vscprintf() to determine how big the string needs to be.
1449    #
1450    set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C}
1451        charconv.c missing/win_asprintf.c)
1452else()
1453    if(NOT HAVE_ASPRINTF)
1454        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} missing/asprintf.c)
1455    endif()
1456    if(NOT HAVE_STRLCAT)
1457        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} missing/strlcat.c)
1458    endif(NOT HAVE_STRLCAT)
1459    if(NOT HAVE_STRLCPY)
1460        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} missing/strlcpy.c)
1461    endif(NOT HAVE_STRLCPY)
1462    if(NOT HAVE_STRTOK_R)
1463        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} missing/strtok_r.c)
1464    endif(NOT HAVE_STRTOK_R)
1465endif(WIN32)
1466
1467#
1468# Determine the main pcap-XXX.c file to use, and the libraries with
1469# which we need to link libpcap, if any.
1470#
1471if(WIN32)
1472    #
1473    # Windows.
1474    #
1475    # Has the user explicitly specified a capture type?
1476    #
1477    if(PCAP_TYPE STREQUAL "")
1478        #
1479        # The user didn't explicitly specify a capture mechanism.
1480        # Check whether we have packet.dll.
1481        #
1482        if(HAVE_PACKET32)
1483            #
1484            # We have packet.dll.
1485            # Set the capture type to NPF.
1486            #
1487            set(PCAP_TYPE npf)
1488        else()
1489            #
1490            # We don't have any capture type we know about, so just use
1491            # the null capture type, and only support reading (and writing)
1492            # capture files.
1493            #
1494            set(PCAP_TYPE null)
1495        endif()
1496    endif()
1497else()
1498    #
1499    # UN*X.
1500    #
1501    # Figure out what type of packet capture mechanism we have, and
1502    # what libraries we'd need to link libpcap with, if any.
1503    #
1504
1505    #
1506    # Has the user explicitly specified a capture type?
1507    #
1508    if(PCAP_TYPE STREQUAL "")
1509        #
1510        # Check for a bunch of headers for various packet capture mechanisms.
1511        #
1512        check_include_files("sys/types.h;net/bpf.h" HAVE_NET_BPF_H)
1513        if(HAVE_NET_BPF_H)
1514            #
1515            # Does it define BIOCSETIF?
1516            # I.e., is it a header for an LBL/BSD-style capture
1517            # mechanism, or is it just a header for a BPF filter
1518            # engine?  Some versions of Arch Linux, for example,
1519            # have a net/bpf.h that doesn't define BIOCSETIF;
1520            # as it's a Linux, it should use packet sockets,
1521            # instead.
1522            #
1523            # We need:
1524            #
1525            #  sys/types.h, because FreeBSD 10's net/bpf.h
1526            #  requires that various BSD-style integer types
1527            #  be defined;
1528            #
1529            #  sys/time.h, because AIX 5.2 and 5.3's net/bpf.h
1530            #  doesn't include it but does use struct timeval
1531            #  in ioctl definitions;
1532            #
1533            #  sys/ioctl.h and, if we have it, sys/ioccom.h,
1534            #  because net/bpf.h defines ioctls;
1535            #
1536            #  net/if.h, because it defines some structures
1537            #  used in ioctls defined by net/bpf.h;
1538            #
1539            #  sys/socket.h, because OpenBSD 5.9's net/bpf.h
1540            #  defines some structure fields as being
1541            #  struct sockaddrs;
1542            #
1543            # and net/bpf.h doesn't necessarily include all
1544            # of those headers itself.
1545            #
1546            if(HAVE_SYS_IOCCOM_H)
1547                check_symbol_exists(BIOCSETIF "sys/types.h;sys/time.h;sys/ioctl.h;sys/socket.h;sys/ioccom.h;net/bpf.h;net/if.h" BPF_H_DEFINES_BIOCSETIF)
1548            else(HAVE_SYS_IOCCOM_H)
1549                check_symbol_exists(BIOCSETIF "sys/types.h;sys/time.h;sys/ioctl.h;sys/socket.h;net/bpf.h;net/if.h" BPF_H_DEFINES_BIOCSETIF)
1550            endif(HAVE_SYS_IOCCOM_H)
1551        endif(HAVE_NET_BPF_H)
1552        check_include_file(net/pfilt.h HAVE_NET_PFILT_H)
1553        check_include_file(net/enet.h HAVE_NET_ENET_H)
1554        check_include_file(net/nit.h HAVE_NET_NIT_H)
1555        check_include_file(sys/net/nit.h HAVE_SYS_NET_NIT_H)
1556        check_include_file(linux/socket.h HAVE_LINUX_SOCKET_H)
1557        check_include_file(net/raw.h HAVE_NET_RAW_H)
1558        check_include_file(sys/dlpi.h HAVE_SYS_DLPI_H)
1559        check_include_file(config/HaikuConfig.h HAVE_CONFIG_HAIKUCONFIG_H)
1560
1561        if(BPF_H_DEFINES_BIOCSETIF)
1562            #
1563            # BPF.
1564            # Check this before DLPI, so that we pick BPF on
1565            # Solaris 11 and later.
1566            #
1567            set(PCAP_TYPE bpf)
1568        elseif(HAVE_LINUX_SOCKET_H)
1569            #
1570            # No prizes for guessing this one.
1571            #
1572            set(PCAP_TYPE linux)
1573        elseif(HAVE_NET_PFILT_H)
1574            #
1575            # DEC OSF/1, Digital UNIX, Tru64 UNIX
1576            #
1577            set(PCAP_TYPE pf)
1578        elseif(HAVE_NET_ENET_H)
1579            #
1580            # Stanford Enetfilter.
1581            #
1582            set(PCAP_TYPE enet)
1583        elseif(HAVE_NET_NIT_H)
1584            #
1585            # SunOS 4.x STREAMS NIT.
1586            #
1587            set(PCAP_TYPE snit)
1588        elseif(HAVE_SYS_NET_NIT_H)
1589            #
1590            # Pre-SunOS 4.x non-STREAMS NIT.
1591            #
1592            set(PCAP_TYPE nit)
1593        elseif(HAVE_NET_RAW_H)
1594            #
1595            # IRIX snoop.
1596            #
1597            set(PCAP_TYPE snoop)
1598        elseif(HAVE_SYS_DLPI_H)
1599            #
1600            # DLPI on pre-Solaris 11 SunOS 5, HP-UX, possibly others.
1601            #
1602            set(PCAP_TYPE dlpi)
1603        elseif(HAVE_CONFIG_HAIKUCONFIG_H)
1604            #
1605            # Haiku.
1606            #
1607            set(PCAP_TYPE haiku)
1608        else()
1609            #
1610            # Nothing we support.
1611            #
1612            set(PCAP_TYPE null)
1613            message(WARNING
1614"cannot determine packet capture interface
1615(see the INSTALL.md file for more info)")
1616        endif()
1617    endif()
1618endif(WIN32)
1619message(STATUS "Packet capture mechanism type: ${PCAP_TYPE}")
1620
1621find_package(PkgConfig QUIET)
1622
1623#
1624# Do capture-mechanism-dependent tests.
1625#
1626if(WIN32)
1627    if(PCAP_TYPE STREQUAL "npf")
1628        #
1629        # Link with packet.dll before Winsock2.
1630        #
1631        set(PCAP_LINK_LIBRARIES ${Packet_LIBRARIES} ${PCAP_LINK_LIBRARIES})
1632    elseif(PCAP_TYPE STREQUAL "null")
1633    else()
1634        message(FATAL_ERROR "${PCAP_TYPE} is not a valid pcap type")
1635    endif()
1636else(WIN32)
1637    if(PCAP_TYPE STREQUAL "dlpi")
1638        #
1639        # Needed for common functions used by pcap-[dlpi,libdlpi].c
1640        #
1641        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} dlpisubs.c)
1642
1643        #
1644        # Checks for some header files.
1645        #
1646        check_include_file(sys/bufmod.h HAVE_SYS_BUFMOD_H)
1647        check_include_file(sys/dlpi_ext.h HAVE_SYS_DLPI_EXT_H)
1648
1649        #
1650        # Checks to see if Solaris has the public libdlpi(3LIB) library.
1651        # Note: The existence of /usr/include/libdlpi.h does not mean it is the
1652        # public libdlpi(3LIB) version. Before libdlpi was made public, a
1653        # private version also existed, which did not have the same APIs.
1654        # Due to a gcc bug, the default search path for 32-bit libraries does
1655        # not include /lib, we add it explicitly here.
1656        # [http://bugs.opensolaris.org/view_bug.do?bug_id=6619485].
1657        # Also, due to the bug above applications that link to libpcap with
1658        # libdlpi will have to add "-L/lib" option to "configure".
1659        #
1660        cmake_push_check_state()
1661        set(CMAKE_REQUIRED_FLAGS "-L/lib")
1662        set(CMAKE_REQUIRED_LIBRARIES dlpi)
1663        check_function_exists(dlpi_walk HAVE_LIBDLPI)
1664        cmake_pop_check_state()
1665        if(HAVE_LIBDLPI)
1666            #
1667            # XXX - add -L/lib
1668            #
1669            set(PCAP_LINK_LIBRARIES ${PCAP_LINK_LIBRARIES} dlpi)
1670            set(LIBS "${LIBS} -ldlpi")
1671            set(LIBS_STATIC "${LIBS_STATIC} -ldlpi")
1672            set(LIBS_PRIVATE "${LIBS_PRIVATE} -ldlpi")
1673            set(PCAP_TYPE libdlpi)
1674        endif()
1675
1676        #
1677        # This check is for Solaris with DLPI support for passive modes.
1678        # See dlpi(7P) for more details.
1679        #
1680        # XXX - there's no check_type() macro that's like check_type_size()
1681        # except that it only checks for the existence of the structure type,
1682        # so we use check_type_size() and ignore the size.
1683        #
1684        cmake_push_check_state()
1685        set(CMAKE_EXTRA_INCLUDE_FILES sys/types.h sys/dlpi.h)
1686        check_type_size(dl_passive_req_t DL_PASSIVE_REQ_T)
1687        cmake_pop_check_state()
1688    elseif(PCAP_TYPE STREQUAL "linux")
1689        #
1690        # Do we have the wireless extensions?
1691        # linux/wireless.h requires sys/socket.h.
1692        #
1693        check_include_files("sys/socket.h;linux/wireless.h" HAVE_LINUX_WIRELESS_H)
1694
1695        #
1696        # Do we have libnl?
1697        # We only want version 3.  Version 2 was, apparently,
1698        # short-lived, and version 1 is source and binary
1699        # incompatible with version 3, and it appears that,
1700        # these days, everybody's using version 3.  We're
1701        # not supporting older versions of the Linux kernel;
1702        # let's drop support for older versions of libnl, too.
1703        #
1704        if(BUILD_WITH_LIBNL)
1705            pkg_check_modules(LIBNL libnl-genl-3.0)
1706            if(LIBNL_FOUND)
1707                set(PCAP_LINK_LIBRARIES ${LIBNL_LIBRARIES} ${PCAP_LINK_LIBRARIES})
1708
1709                #
1710                # Get raw link flags from pkg-config.
1711                #
1712                pkg_get_link_info(LIBNL libnl-genl-3.0)
1713                set(LIBS "${LIBNL_LIBS} ${LIBS}")
1714                set(LIBS_STATIC "${LIBNL_LIBS_STATIC} ${LIBS_STATIC}")
1715                set(REQUIRES_PRIVATE "${LIBNL_PACKAGE_NAME} ${REQUIRES_PRIVATE}")
1716            else()
1717                cmake_push_check_state()
1718                set(CMAKE_REQUIRED_LIBRARIES nl-3)
1719                check_function_exists(nl_socket_alloc HAVE_LIBNL)
1720                cmake_pop_check_state()
1721                if(HAVE_LIBNL)
1722                    #
1723                    # Yes, we have libnl 3.x.
1724                    #
1725                    set(PCAP_LINK_LIBRARIES nl-genl-3 nl-3 ${PCAP_LINK_LIBRARIES})
1726                    include_directories("/usr/include/libnl3")
1727                    set(LIBS "-lnl-genl-3 -lnl-3 ${LIBS}")
1728                    set(LIBS_STATIC "-lnl-genl-3 -lnl-3 ${LIBS_STATIC}")
1729                    set(LIBS_PRIVATE "-lnl-genl-3 -lnl-3 ${LIBS_PRIVATE}")
1730                endif()
1731            endif()
1732        else()
1733            unset(HAVE_LIBNL CACHE) # check_function_exists stores results in cache
1734        endif()
1735
1736        check_struct_has_member("struct tpacket_auxdata" tp_vlan_tci linux/if_packet.h HAVE_STRUCT_TPACKET_AUXDATA_TP_VLAN_TCI)
1737    elseif(PCAP_TYPE STREQUAL "bpf")
1738        #
1739        # Check whether we have the *BSD-style ioctls.
1740        #
1741        check_include_files("sys/types.h;net/if_media.h" HAVE_NET_IF_MEDIA_H)
1742
1743        #
1744        # Check whether we have struct BPF_TIMEVAL.
1745        #
1746        # XXX - there's no check_type() macro that's like check_type_size()
1747        # except that it only checks for the existence of the structure type,
1748        # so we use check_type_size() and ignore the size.
1749        #
1750        cmake_push_check_state()
1751        if(HAVE_SYS_IOCCOM_H)
1752            set(CMAKE_EXTRA_INCLUDE_FILES sys/types.h sys/ioccom.h net/bpf.h)
1753            check_type_size("struct BPF_TIMEVAL" STRUCT_BPF_TIMEVAL)
1754        else()
1755            set(CMAKE_EXTRA_INCLUDE_FILES  sys/types.h net/bpf.h)
1756            check_type_size("struct BPF_TIMEVAL" STRUCT_BPF_TIMEVAL)
1757        endif()
1758        cmake_pop_check_state()
1759    elseif(PCAP_TYPE STREQUAL "haiku")
1760        #
1761        # Check for some headers just in case.
1762        #
1763        check_include_files("net/if.h;net/if_dl.h;net/if_types.h" HAVE_NET_IF_TYPES_H)
1764        set(PCAP_SRC pcap-${PCAP_TYPE}.cpp)
1765    elseif(PCAP_TYPE STREQUAL "null")
1766    else()
1767        message(FATAL_ERROR "${PCAP_TYPE} is not a valid pcap type")
1768    endif()
1769endif(WIN32)
1770
1771if(NOT DEFINED PCAP_SRC)
1772set(PCAP_SRC pcap-${PCAP_TYPE}.c)
1773endif()
1774
1775set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} ${PCAP_SRC})
1776
1777#
1778# Now figure out how we get a list of interfaces and addresses,
1779# if we support capturing.  Don't bother if we don't support
1780# capturing.
1781#
1782if(NOT WIN32)
1783    #
1784    # UN*X - figure out what type of interface list mechanism we
1785    # have.
1786    #
1787    # If the capture type is null, that means we can't capture,
1788    # so we can't open any capture devices, so we won't return
1789    # any interfaces.
1790    #
1791    if(NOT PCAP_TYPE STREQUAL "null")
1792        cmake_push_check_state()
1793        set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LINK_LIBRARIES})
1794        check_function_exists(getifaddrs HAVE_GETIFADDRS)
1795        cmake_pop_check_state()
1796        if(NOT HAVE_GETIFADDRS)
1797            #
1798            # It's not in the libraries that, at this point, we've
1799            # found we need to link libpcap with.
1800            #
1801            # It's in libsocket on Solaris and possibly other OSes;
1802            # as long as we're not linking with libxnet, check there.
1803            #
1804            # NOTE: if you hand check_library_exists as its last
1805            # argument a variable that's been set, it skips the test,
1806            # so we need different variables.
1807            #
1808            if(NOT LIBXNET_HAS_GETHOSTBYNAME)
1809                check_library_exists(socket getifaddrs "" SOCKET_HAS_GETIFADDRS)
1810                if(SOCKET_HAS_GETIFADDRS)
1811                    set(PCAP_LINK_LIBRARIES socket ${PCAP_LINK_LIBRARIES})
1812                    set(LIBS "-lsocket ${LIBS}")
1813                    set(LIBS_STATIC "-lsocket ${LIBS_STATIC}")
1814                    set(LIBS_PRIVATE "-lsocket ${LIBS_PRIVATE}")
1815                    set(HAVE_GETIFADDRS TRUE)
1816                endif()
1817            endif()
1818        endif()
1819        if(HAVE_GETIFADDRS)
1820            #
1821            # We have "getifaddrs()"; make sure we have <ifaddrs.h>
1822            # as well, just in case some platform is really weird.
1823            # It may require that sys/types.h be included first,
1824            # so include it first.
1825            #
1826            check_include_files("sys/types.h;ifaddrs.h" HAVE_IFADDRS_H)
1827            if(HAVE_IFADDRS_H)
1828                #
1829                # We have the header, so we use "getifaddrs()" to
1830                # get the list of interfaces.
1831                #
1832                set(FINDALLDEVS_TYPE getad)
1833            else()
1834                #
1835                # We don't have the header - give up.
1836                # XXX - we could also fall back on some other
1837                # mechanism, but, for now, this'll catch this
1838                # problem so that we can at least try to figure
1839                # out something to do on systems with "getifaddrs()"
1840                # but without "ifaddrs.h", if there is something
1841                # we can do on those systems.
1842                #
1843                message(FATAL_ERROR "Your system has getifaddrs() but doesn't have a usable <ifaddrs.h>.")
1844            endif()
1845        else()
1846            #
1847            # Well, we don't have "getifaddrs()", at least not with the
1848            # libraries with which we've decided we need to link
1849            # libpcap with, so we have to use some other mechanism.
1850            #
1851            # Note that this may happen on Solaris, which has
1852            # getifaddrs(), but in -lsocket, not in -lxnet, so we
1853            # won't find it if we link with -lxnet, which we want
1854            # to do for other reasons.
1855            #
1856            # For now, we use either the SIOCGIFCONF ioctl or the
1857            # SIOCGLIFCONF ioctl, preferring the latter if we have
1858            # it; the latter is a Solarisism that first appeared
1859            # in Solaris 8.  (Solaris's getifaddrs() appears to
1860            # be built atop SIOCGLIFCONF; using it directly
1861            # avoids a not-all-that-useful middleman.)
1862            #
1863            try_compile(HAVE_SIOCGLIFCONF ${CMAKE_CURRENT_BINARY_DIR} "${pcap_SOURCE_DIR}/cmake/have_siocglifconf.c" )
1864            if(HAVE_SIOCGLIFCONF)
1865                set(FINDALLDEVS_TYPE glifc)
1866            else()
1867                set(FINDALLDEVS_TYPE gifc)
1868            endif()
1869        endif()
1870        message(STATUS "Find-interfaces mechanism type: ${FINDALLDEVS_TYPE}")
1871        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} fad-${FINDALLDEVS_TYPE}.c)
1872    endif()
1873endif()
1874
1875# Check for hardware timestamp support.
1876if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
1877    check_include_file(linux/net_tstamp.h HAVE_LINUX_NET_TSTAMP_H)
1878endif()
1879
1880#
1881# Check for additional native sniffing capabilities.
1882#
1883
1884#
1885# Various Linux-specific mechanisms.
1886#
1887if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
1888    # Check for usbmon USB sniffing support.
1889    if(NOT DISABLE_LINUX_USBMON)
1890        set(PCAP_SUPPORT_LINUX_USBMON TRUE)
1891        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-usb-linux.c)
1892        #
1893        # Do we have a version of <linux/compiler.h> available?
1894        # If so, we might need it for <linux/usbdevice_fs.h>.
1895        #
1896        check_include_files("linux/compiler.h" HAVE_LINUX_COMPILER_H)
1897        if(HAVE_LINUX_COMPILER_H)
1898            #
1899            # Yes - include it when testing for <linux/usbdevice_fs.h>.
1900            #
1901            check_include_files("linux/compiler.h;linux/usbdevice_fs.h" HAVE_LINUX_USBDEVICE_FS_H)
1902        else(HAVE_LINUX_COMPILER_H)
1903            check_include_files("linux/usbdevice_fs.h" HAVE_LINUX_USBDEVICE_FS_H)
1904        endif(HAVE_LINUX_COMPILER_H)
1905        if(HAVE_LINUX_USBDEVICE_FS_H)
1906            #
1907            # OK, does it define bRequestType?  Older versions of the kernel
1908            # define fields with names like "requesttype, "request", and
1909            # "value", rather than "bRequestType", "bRequest", and
1910            # "wValue".
1911            #
1912            if(HAVE_LINUX_COMPILER_H)
1913                check_struct_has_member("struct usbdevfs_ctrltransfer" bRequestType "linux/compiler.h;linux/usbdevice_fs.h" HAVE_STRUCT_USBDEVFS_CTRLTRANSFER_BREQUESTTYPE)
1914            else(HAVE_LINUX_COMPILER_H)
1915                check_struct_has_member("struct usbdevfs_ctrltransfer" bRequestType "linux/usbdevice_fs.h" HAVE_STRUCT_USBDEVFS_CTRLTRANSFER_BREQUESTTYPE)
1916            endif(HAVE_LINUX_COMPILER_H)
1917        endif()
1918    endif()
1919
1920    #
1921    # Check for netfilter sniffing support.
1922    #
1923    # Life's too short to deal with trying to get this to compile
1924    # if you don't get the right types defined with
1925    # __KERNEL_STRICT_NAMES getting defined by some other include.
1926    #
1927    # Check whether the includes Just Work.  If not, don't turn on
1928    # netfilter support.
1929    #
1930    check_c_source_compiles(
1931"#include <sys/socket.h>
1932#include <netinet/in.h>
1933#include <linux/types.h>
1934
1935#include <linux/netlink.h>
1936#include <linux/netfilter.h>
1937#include <linux/netfilter/nfnetlink.h>
1938#include <linux/netfilter/nfnetlink_log.h>
1939#include <linux/netfilter/nfnetlink_queue.h>
1940
1941int
1942main(void)
1943{
1944    return 0;
1945}
1946"
1947        PCAP_SUPPORT_NETFILTER)
1948    if(PCAP_SUPPORT_NETFILTER)
1949        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-netfilter-linux.c)
1950    endif(PCAP_SUPPORT_NETFILTER)
1951endif()
1952
1953# Check for netmap sniffing support.
1954if(NOT DISABLE_NETMAP)
1955    #
1956    # Check whether net/netmap_user.h is usable if NETMAP_WITH_LIBS is
1957    # defined; it's not usable on DragonFly BSD 4.6 if NETMAP_WITH_LIBS
1958    # is defined, for example, as it includes a non-existent malloc.h
1959    # header.
1960    #
1961    check_c_source_compiles(
1962"#define NETMAP_WITH_LIBS
1963#include <net/netmap_user.h>
1964
1965int
1966main(void)
1967{
1968    return 0;
1969}
1970"
1971        PCAP_SUPPORT_NETMAP)
1972    if(PCAP_SUPPORT_NETMAP)
1973        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-netmap.c)
1974    endif(PCAP_SUPPORT_NETMAP)
1975endif()
1976
1977# Check for DPDK sniffing support
1978if(NOT DISABLE_DPDK)
1979    find_package(dpdk)
1980    if(dpdk_FOUND)
1981        #
1982        # We call rte_eth_dev_count_avail(), and older versions of DPDK
1983        # didn't have it, so check for it.
1984        #
1985        cmake_push_check_state()
1986        set(CMAKE_REQUIRED_INCLUDES ${dpdk_INCLUDE_DIRS})
1987        set(CMAKE_REQUIRED_LIBRARIES ${dpdk_LIBRARIES})
1988        check_function_exists(rte_eth_dev_count_avail HAVE_RTE_ETH_DEV_COUNT_AVAIL)
1989        cmake_pop_check_state()
1990        if(HAVE_RTE_ETH_DEV_COUNT_AVAIL)
1991            set(DPDK_C_FLAGS "-march=native")
1992            set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} ${DPDK_C_FLAGS})
1993            include_directories(AFTER ${dpdk_INCLUDE_DIRS})
1994            link_directories(AFTER ${dpdk_LIBRARIES})
1995            set(PCAP_LINK_LIBRARIES ${PCAP_LINK_LIBRARIES} ${dpdk_LIBRARIES})
1996            set(LIBS "${LIBS} ${dpdk_LIBS}")
1997            set(LIBS_STATIC "${LIBS_STATIC} ${dpdk_LIBS_STATIC}")
1998            set(REQUIRES_PRIVATE "${REQUIRES_PRIVATE} ${dpdk_PACKAGE_NAME}")
1999            set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-dpdk.c)
2000            set(PCAP_SUPPORT_DPDK TRUE)
2001
2002            #
2003            # Check whether the rte_ether.h file defines
2004            # struct ether_addr or struct rte_ether_addr.
2005            #
2006            # ("API compatibility?  That's for losers!")
2007            #
2008            cmake_push_check_state()
2009            set(CMAKE_REQUIRED_INCLUDES ${dpdk_INCLUDE_DIRS})
2010            set(CMAKE_EXTRA_INCLUDE_FILES rte_ether.h)
2011            check_type_size("struct rte_ether_addr" STRUCT_RTE_ETHER_ADDR)
2012            cmake_pop_check_state()
2013        endif()
2014    else()
2015      message(WARNING,
2016"We couldn't find DPDK with pkg-config.  If you want DPDK support,
2017make sure that pkg-config is installed, that DPDK 18.02.2 or later is
2018installed, and that DPDK provides a .pc file.")
2019    endif()
2020endif()
2021
2022# Check for Bluetooth sniffing support
2023if(NOT DISABLE_BLUETOOTH)
2024    if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
2025        check_include_file(bluetooth/bluetooth.h HAVE_BLUETOOTH_BLUETOOTH_H)
2026        if(HAVE_BLUETOOTH_BLUETOOTH_H)
2027            set(PCAP_SUPPORT_BT TRUE)
2028            set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-bt-linux.c)
2029            #
2030            # OK, does struct sockaddr_hci have an hci_channel
2031            # member?
2032            #
2033            check_struct_has_member("struct sockaddr_hci" hci_channel "bluetooth/bluetooth.h;bluetooth/hci.h" HAVE_STRUCT_SOCKADDR_HCI_HCI_CHANNEL)
2034            if(HAVE_STRUCT_SOCKADDR_HCI_HCI_CHANNEL)
2035                #
2036                # OK, is HCI_CHANNEL_MONITOR defined?
2037                #
2038               check_c_source_compiles(
2039"#include <bluetooth/bluetooth.h>
2040#include <bluetooth/hci.h>
2041
2042int
2043main(void)
2044{
2045    u_int i = HCI_CHANNEL_MONITOR;
2046    return 0;
2047}
2048"
2049                   PCAP_SUPPORT_BT_MONITOR)
2050               if(PCAP_SUPPORT_BT_MONITOR)
2051                   #
2052                   # Yes, so we can also support Bluetooth monitor
2053                   # sniffing.
2054                   #
2055                   set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-bt-monitor-linux.c)
2056               endif(PCAP_SUPPORT_BT_MONITOR)
2057            endif(HAVE_STRUCT_SOCKADDR_HCI_HCI_CHANNEL)
2058        endif(HAVE_BLUETOOTH_BLUETOOTH_H)
2059    endif()
2060else()
2061    unset(PCAP_SUPPORT_BT_MONITOR CACHE)
2062endif()
2063
2064# Check for D-Bus sniffing support
2065if(NOT DISABLE_DBUS)
2066    #
2067    # We don't support D-Bus sniffing on macOS; see
2068    #
2069    # https://bugs.freedesktop.org/show_bug.cgi?id=74029
2070    #
2071    if(APPLE)
2072        message(FATAL_ERROR "Due to freedesktop.org bug 74029, D-Bus capture support is not available on macOS")
2073    endif(APPLE)
2074    pkg_check_modules(DBUS dbus-1)
2075    if(DBUS_FOUND)
2076        set(PCAP_SUPPORT_DBUS TRUE)
2077        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-dbus.c)
2078        include_directories(${DBUS_INCLUDE_DIRS})
2079
2080        #
2081        # This "helpfully" supplies DBUS_LIBRARIES as a bunch of
2082        # library names - not paths - and DBUS_LIBRARY_DIRS as
2083        # a bunch of directories.
2084        #
2085        # CMake *really* doesn't like the notion of specifying "here are
2086        # the directories in which to look for libraries" except in
2087        # find_library() calls; it *really* prefers using full paths to
2088        # library files, rather than library names.
2089        #
2090        # Find the libraries and add their full paths.
2091        #
2092        set(DBUS_LIBRARY_FULLPATHS)
2093        foreach(_lib IN LISTS DBUS_LIBRARIES)
2094            #
2095            # Try to find this library, so we get its full path.
2096            #
2097            find_library(_libfullpath ${_lib} HINTS ${DBUS_LIBRARY_DIRS})
2098            list(APPEND DBUS_LIBRARY_FULLPATHS ${_libfullpath})
2099        endforeach()
2100        set(PCAP_LINK_LIBRARIES ${PCAP_LINK_LIBRARIES} ${DBUS_LIBRARY_FULLPATHS})
2101
2102        #
2103        # Get library information for DPDK.
2104        #
2105        pkg_get_link_info(DBUS dbus-1)
2106        set(LIBS "${LIBS} ${DBUS_LIBS}")
2107        set(LIBS_STATIC "${LIBS_STATIC} ${DBUS_LIBS_STATIC}")
2108        set(REQUIRES_PRIVATE "${REQUIRES_PRIVATE} ${DBUS_PACKAGE_NAME}")
2109    endif(DBUS_FOUND)
2110endif(NOT DISABLE_DBUS)
2111
2112# Check for RDMA sniffing support
2113if(NOT DISABLE_RDMA)
2114    pkg_check_modules(LIBIBVERBS libibverbs)
2115    if(LIBIBVERBS_FOUND)
2116        #
2117        # pkg-config found it; remember its pkg-config name.
2118        #
2119        set(LIBIBVERBS_REQUIRES_PRIVATE ${LIBIBVERBS_PACKAGE_NAME})
2120
2121        #
2122        # Get static linking information for it.
2123        #
2124        pkg_get_link_info(LIBIBVERBS libibverbs)
2125    else()
2126        #
2127        # pkg-config didn't find it; try to look for it ourselves
2128        #
2129        check_library_exists(ibverbs ibv_get_device_list "" LIBIBVERBS_HAS_IBV_GET_DEVICE_LIST)
2130        if(LIBIBVERBS_HAS_IBV_GET_DEVICE_LIST)
2131            set(LIBIBVERBS_FOUND TRUE)
2132            set(LIBIBVERBS_LIBRARIES ibverbs)
2133            # XXX - at least on Ubuntu 20.04, there are many more
2134            # libraries needed; is there any platform where
2135            # libibverbs is available but where pkg-config
2136            # isn't available or libibverbs doesn't use it?
2137            # If not, we should only use pkg-config for it.
2138            set(LIBIBVERBS_STATIC_LIBRARIES ibverbs)
2139            set(LIBIBVERBS_LIBS -libverbs)
2140            set(LIBIBVERBS_LIBS_STATIC -libverbs)
2141            set(LIBIBVERBS_LIBS_PRIVATE -libverbs)
2142        endif()
2143    endif()
2144    if(LIBIBVERBS_FOUND)
2145        #
2146        # For unknown reasons, check_include_file() doesn't just attempt
2147        # to compile a test program that includes the header in
2148        # question, it also attempts to link it.
2149        #
2150        # For unknown reasons, at least some of the static inline
2151        # functions defined in infiniband/verbs.h are not inlined by the
2152        # Sun^WOracle Studio C compiler, so the compiler generates code
2153        # for them as part of the object code resulting from compiling
2154        # the test program. At lest some of those functions call
2155        # routines in -libverbs, so, in order to keep the compile and
2156        # link from failing, even though the header file exists and is
2157        # usable, we need to link with -libverbs.
2158        #
2159        cmake_push_check_state()
2160        set(CMAKE_REQUIRED_LIBRARIES ${LIBIBVERBS_LIBRARIES})
2161        check_include_file(infiniband/verbs.h HAVE_INFINIBAND_VERBS_H)
2162        if(HAVE_INFINIBAND_VERBS_H)
2163            check_symbol_exists(ibv_create_flow infiniband/verbs.h PCAP_SUPPORT_RDMASNIFF)
2164            if(PCAP_SUPPORT_RDMASNIFF)
2165                set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-rdmasniff.c)
2166                set(PCAP_LINK_LIBRARIES ${LIBIBVERBS_LIBRARIES} ${PCAP_LINK_LIBRARIES})
2167                set(LIBS "${LIBIBVERBS_LIBS} ${LIBS}")
2168                set(LIBS_STATIC "${LIBIBVERBS_LIBS_STATIC} ${LIBS_STATIC}")
2169                set(LIBS_PRIVATE "${LIBIBVERBS_LIBS_PRIVATE} ${LIBS_PRIVATE}")
2170                set(REQUIRES_PRIVATE "${REQUIRES_PRIVATE} ${LIBIBVERBS_PACKAGE_NAME}")
2171            endif(PCAP_SUPPORT_RDMASNIFF)
2172        endif(HAVE_INFINIBAND_VERBS_H)
2173        cmake_pop_check_state()
2174    endif(LIBIBVERBS_FOUND)
2175endif(NOT DISABLE_RDMA)
2176
2177#
2178# Check for sniffing capabilities using third-party APIs.
2179#
2180
2181# Check for Endace DAG card support.
2182if(NOT DISABLE_DAG)
2183    #
2184    # Try to find the DAG header file and library.
2185    #
2186    find_package(DAG)
2187
2188    #
2189    # Did we succeed?
2190    #
2191    if(DAG_FOUND)
2192        #
2193        # Yes.
2194        # Check for various DAG API functions.
2195        #
2196        cmake_push_check_state()
2197        set(CMAKE_REQUIRED_INCLUDES ${DAG_INCLUDE_DIRS})
2198        set(CMAKE_REQUIRED_LIBRARIES ${DAG_LIBRARIES})
2199        check_function_exists(dag_attach_stream HAVE_DAG_STREAMS_API)
2200        if(NOT HAVE_DAG_STREAMS_API)
2201            message(FATAL_ERROR "DAG library lacks streams support")
2202        endif()
2203        check_function_exists(dag_attach_stream64 HAVE_DAG_LARGE_STREAMS_API)
2204        check_function_exists(dag_get_erf_types HAVE_DAG_GET_ERF_TYPES)
2205        check_function_exists(dag_get_stream_erf_types HAVE_DAG_GET_STREAM_ERF_TYPES)
2206        cmake_pop_check_state()
2207
2208        include_directories(AFTER ${DAG_INCLUDE_DIRS})
2209        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-dag.c)
2210        set(HAVE_DAG_API TRUE)
2211        set(PCAP_LINK_LIBRARIES ${PCAP_LINK_LIBRARIES} ${DAG_LIBRARIES})
2212        set(LIBS "${LIBS} ${DAG_LIBS}")
2213        set(LIBS_STATIC "${LIBS_STATIC} ${DAG_LIBS_STATIC}")
2214        set(LIBS_PRIVATE "${LIBS_PRIVATE} ${DAG_LIBS_PRIVATE}")
2215
2216        if(HAVE_DAG_LARGE_STREAMS_API)
2217            get_filename_component(DAG_LIBRARY_DIR ${DAG_LIBRARY} PATH)
2218            check_library_exists(vdag vdag_set_device_info ${DAG_LIBRARY_DIR} HAVE_DAG_VDAG)
2219            if(HAVE_DAG_VDAG)
2220                set(PCAP_LINK_LIBRARIES ${PCAP_LINK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
2221                set(LIBS "${LIBS} ${CMAKE_THREAD_LIBS_INIT}")
2222                set(LIBS_STATIC "${LIBS_STATIC} ${CMAKE_THREAD_LIBS_INIT}")
2223                set(LIBS_PRIVATE "${LIBS_PRIVATE} ${CMAKE_THREAD_LIBS_INIT}")
2224            endif()
2225        endif()
2226    endif()
2227endif()
2228
2229# Check for Septel card support.
2230set(PROJECT_EXTERNAL_OBJECT_LIST "")
2231if(NOT DISABLE_SEPTEL)
2232    #
2233    # Do we have the msg.h header?
2234    #
2235    set(SEPTEL_INCLUDE_DIRS "${SEPTEL_ROOT}/INC")
2236    cmake_push_check_state()
2237    set(CMAKE_REQUIRED_INCLUDES ${SEPTEL_INCLUDE_DIRS})
2238    check_include_file(msg.h HAVE_INC_MSG_H)
2239    cmake_pop_check_state()
2240    if(HAVE_INC_MSG_H)
2241        #
2242        # Yes.
2243        #
2244        include_directories(AFTER ${SEPTEL_INCLUDE_DIRS})
2245        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-septel.c)
2246        set(PROJECT_EXTERNAL_OBJECT_LIST ${PROJECT_EXTERNAL_OBJECT_LIST} "${SEPTEL_ROOT}/asciibin.o ${SEPTEL_ROOT}/bit2byte.o ${SEPTEL_ROOT}/confirm.o ${SEPTEL_ROOT}/fmtmsg.o ${SEPTEL_ROOT}/gct_unix.o ${SEPTEL_ROOT}/hqueue.o ${SEPTEL_ROOT}/ident.o ${SEPTEL_ROOT}/mem.o ${SEPTEL_ROOT}/pack.o ${SEPTEL_ROOT}/parse.o ${SEPTEL_ROOT}/pool.o ${SEPTEL_ROOT}/sdlsig.o ${SEPTEL_ROOT}/strtonum.o ${SEPTEL_ROOT}/timer.o ${SEPTEL_ROOT}/trace.o")
2247        set(HAVE_SEPTEL_API TRUE)
2248    endif()
2249endif()
2250
2251# Check for Myricom SNF support.
2252if(NOT DISABLE_SNF)
2253    #
2254    # Try to find the SNF header file and library.
2255    #
2256    find_package(SNF)
2257
2258    #
2259    # Did we succeed?
2260    #
2261    if(SNF_FOUND)
2262        #
2263        # Yes.
2264        #
2265        include_directories(AFTER ${SNF_INCLUDE_DIRS})
2266        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-snf.c)
2267        set(HAVE_SNF_API TRUE)
2268        set(PCAP_LINK_LIBRARIES ${PCAP_LINK_LIBRARIES} ${SNF_LIBRARIES})
2269        set(LIBS "${LIBS_STATIC} ${SNF_LIBS}")
2270        set(LIBS_STATIC "${LIBS_STATIC} ${SNF_LIBS_STATIC}")
2271        set(LIBS_PRIVATE "${LIBS_PRIVATE} ${SNF_LIBS_PRIVATE}")
2272    endif()
2273endif()
2274
2275# Check for Riverbed AirPcap support.
2276if(NOT DISABLE_AIRPCAP)
2277    #
2278    # Try to find the AirPcap header file and library.
2279    #
2280    find_package(AirPcap)
2281
2282    #
2283    # Did we succeed?
2284    #
2285    if(AirPcap_FOUND)
2286        #
2287        # Yes.
2288        #
2289        include_directories(AFTER ${AirPcap_INCLUDE_DIRS})
2290        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-airpcap.c)
2291        set(HAVE_AIRPCAP_API TRUE)
2292        set(PCAP_LINK_LIBRARIES ${PCAP_LINK_LIBRARIES} ${AirPcap_LIBRARIES})
2293    endif()
2294endif()
2295
2296# Check for Riverbed TurboCap support.
2297if(NOT DISABLE_TC)
2298    #
2299    # Try to find the TurboCap header file and library.
2300    #
2301    find_package(TC)
2302
2303    #
2304    # Did we succeed?
2305    #
2306    if(TC_FOUND)
2307        #
2308        # Yes.
2309        #
2310        include_directories(AFTER ${TC_INCLUDE_DIRS})
2311        set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} pcap-tc.c)
2312        set(HAVE_TC_API TRUE)
2313        set(PCAP_LINK_LIBRARIES ${PCAP_LINK_LIBRARIES} ${TC_LIBRARIES} ${CMAKE_USE_PTHREADS_INIT} stdc++)
2314    endif()
2315endif()
2316
2317#
2318# Remote capture support.
2319#
2320
2321if(ENABLE_REMOTE)
2322    #
2323    # Check for various members of struct msghdr.
2324    # We need to include ftmacros.h on some platforms, to make sure we
2325    # get the POSIX/Single USER Specification version of struct msghdr,
2326    # which has those members, rather than the backwards-compatible
2327    # version, which doesn't.  That's not a system header file, and
2328    # at least some versions of CMake include it as <ftmacros.h>, which
2329    # won't check the current directory, so we add the top-level
2330    # source directory to the list of include directories when we do
2331    # the check.
2332    #
2333    cmake_push_check_state()
2334    set(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR})
2335    check_struct_has_member("struct msghdr" msg_control "ftmacros.h;sys/socket.h" HAVE_STRUCT_MSGHDR_MSG_CONTROL)
2336    check_struct_has_member("struct msghdr" msg_flags "ftmacros.h;sys/socket.h" HAVE_STRUCT_MSGHDR_MSG_FLAGS)
2337    cmake_pop_check_state()
2338    set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C}
2339        pcap-new.c pcap-rpcap.c rpcap-protocol.c sockutils.c sslutils.c)
2340endif(ENABLE_REMOTE)
2341
2342###################################################################
2343#   Warning options
2344###################################################################
2345
2346#
2347# Check and add warning options if we have a .devel file.
2348#
2349if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.devel OR EXISTS ${CMAKE_BINARY_DIR}/.devel)
2350    #
2351    # Warning options.
2352    #
2353    if(MSVC AND NOT ${CMAKE_C_COMPILER} MATCHES "clang*")
2354        #
2355        # MSVC, with Microsoft's front end and code generator.
2356        # "MSVC" is also set for Microsoft's compiler with a Clang
2357        # front end and their code generator ("Clang/C2"), so we
2358        # check for clang.exe and treat that differently.
2359        #
2360        check_and_add_compiler_option(-Wall)
2361        #
2362        # Disable some pointless warnings that /Wall turns on.
2363        #
2364        # Unfortunately, MSVC does not appear to have an equivalent
2365        # to "__attribute__((unused))" to mark a particular function
2366        # parameter as being known to be unused, so that the compiler
2367        # won't warn about it (for example, the function might have
2368        # that parameter because a pointer to it is being used, and
2369        # the signature of that function includes that parameter).
2370        # C++ lets you give a parameter a type but no name, but C
2371        # doesn't have that.
2372        #
2373        check_and_add_compiler_option(-wd4100)
2374        #
2375        # In theory, we care whether somebody uses f() rather than
2376        # f(void) to declare a function with no arguments, but, in
2377        # practice, there are places in the Windows header files
2378        # that appear to do that, so we squelch that warning.
2379        #
2380        check_and_add_compiler_option(-wd4255)
2381        #
2382        # Windows FD_SET() generates this, so we suppress it.
2383        #
2384        check_and_add_compiler_option(-wd4548)
2385        #
2386        # Perhaps testing something #defined to be 0 with #ifdef is an
2387        # error, and it should be tested with #if, but perhaps it's
2388        # not, and Microsoft does that in its headers, so we squelch
2389        # that warning.
2390        #
2391        check_and_add_compiler_option(-wd4574)
2392        #
2393        # The Windows headers also test not-defined values in #if, so
2394        # we don't want warnings about that, either.
2395        #
2396        check_and_add_compiler_option(-wd4668)
2397        #
2398        # We do *not* care whether some function is, or isn't, going to be
2399        # expanded inline.
2400        #
2401        check_and_add_compiler_option(-wd4710)
2402        check_and_add_compiler_option(-wd4711)
2403        #
2404        # We do *not* care whether we're adding padding bytes after
2405        # structure members.
2406        #
2407        check_and_add_compiler_option(-wd4820)
2408        #
2409        # We do *not* care about every single place the compiler would
2410        # have inserted Spectre mitigation if only we had told it to
2411        # do so with /Qspectre.  Maybe it's worth it, as that's in
2412        # Bison-generated code that we don't control.
2413        #
2414        # XXX - add /Qspectre if that is really worth doing.
2415        #
2416        check_and_add_compiler_option(-wd5045)
2417
2418        #
2419        # Treat all (remaining) warnings as errors.
2420        #
2421        check_and_add_compiler_option(-WX)
2422    else()
2423        #
2424        # Other compilers, including MSVC with a Clang front end and
2425        # Microsoft's code generator.  We currently treat them as if
2426        # they might support GCC-style -W options.
2427        #
2428        check_and_add_compiler_option(-Wall)
2429        check_and_add_compiler_option(-Wcomma)
2430        # Warns about safeguards added in case the enums are extended
2431        # check_and_add_compiler_option(-Wcovered-switch-default)
2432        check_and_add_compiler_option(-Wdocumentation)
2433        check_and_add_compiler_option(-Wformat-nonliteral)
2434        check_and_add_compiler_option(-Wmissing-noreturn)
2435        check_and_add_compiler_option(-Wmissing-prototypes)
2436        check_and_add_compiler_option(-Wmissing-variable-declarations)
2437        check_and_add_compiler_option(-Wpointer-arith)
2438        check_and_add_compiler_option(-Wpointer-sign)
2439        check_and_add_compiler_option(-Wshadow)
2440        check_and_add_compiler_option(-Wsign-compare)
2441        check_and_add_compiler_option(-Wshorten-64-to-32)
2442        check_and_add_compiler_option(-Wstrict-prototypes)
2443        check_and_add_compiler_option(-Wunreachable-code)
2444        check_and_add_compiler_option(-Wunused-parameter)
2445        check_and_add_compiler_option(-Wused-but-marked-unused)
2446    endif()
2447endif()
2448
2449#
2450# Suppress some warnings we get with MSVC even without /Wall.
2451#
2452if(MSVC AND NOT ${CMAKE_C_COMPILER} MATCHES "clang*")
2453    #
2454    # Yes, we have some functions that never return but that
2455    # have a non-void return type.  That's because, on some
2456    # platforms, they *do* return values but, on other
2457    # platforms, including Windows, they just fail and
2458    # longjmp out by calling bpf_error().
2459    #
2460    check_and_add_compiler_option(-wd4646)
2461endif()
2462
2463file(GLOB PROJECT_SOURCE_LIST_H
2464    *.h
2465    pcap/*.h
2466)
2467
2468#
2469# Try to have the compiler default to hiding symbols, so that only
2470# symbols explicitly exported with PCAP_API will be visible outside
2471# (shared) libraries.
2472#
2473# Not necessary with MSVC, as that's the default.
2474#
2475# XXX - we don't use ADD_COMPILER_EXPORT_FLAGS, because, as of CMake
2476# 2.8.12.2, it doesn't know about Sun C/Oracle Studio, and, as of
2477# CMake 2.8.6, it only sets the C++ compiler flags, rather than
2478# allowing an arbitrary variable to be set with the "hide symbols
2479# not explicitly exported" flag.
2480#
2481if(NOT MSVC)
2482    if(CMAKE_C_COMPILER_ID MATCHES "SunPro")
2483        #
2484        # Sun C/Oracle Studio.
2485        #
2486        check_and_add_compiler_option(-xldscope=hidden)
2487    else()
2488        #
2489        # Try this for all other compilers; it's what GCC uses,
2490        # and a number of other compilers, such as Clang and Intel C,
2491        # use it as well.
2492        #
2493        check_and_add_compiler_option(-fvisibility=hidden)
2494    endif()
2495endif(NOT MSVC)
2496
2497#
2498# Extra compiler options for the build matrix scripts to request -Werror or
2499# its equivalent if required.  The CMake variable name cannot be CFLAGS
2500# because that is already used for a different purpose in CMake.  Example
2501# usage: cmake -DEXTRA_CFLAGS='-Wall -Wextra -Werror' ...
2502#
2503if(NOT "${EXTRA_CFLAGS}" STREQUAL "")
2504    foreach(_extra_cflag ${EXTRA_CFLAGS})
2505        check_and_add_compiler_option("${_extra_cflag}")
2506    endforeach(_extra_cflag)
2507    message(STATUS "Added extra compile options (${EXTRA_CFLAGS})")
2508endif()
2509
2510#
2511# Flex/Lex and YACC/Berkeley YACC/Bison.
2512# From a mail message to the CMake mailing list by Andy Cedilnik of
2513# Kitware.
2514#
2515
2516#
2517# Try to find Flex, a Windows version of Flex, or Lex.
2518#
2519find_program(LEX_EXECUTABLE NAMES flex win_flex lex)
2520if(LEX_EXECUTABLE STREQUAL "LEX_EXECUTABLE-NOTFOUND")
2521    message(FATAL_ERROR "Neither flex nor win_flex nor lex was found.")
2522endif()
2523message(STATUS "Lexical analyzer generator: ${LEX_EXECUTABLE}")
2524
2525#
2526# Make sure {f}lex supports the -P, --header-file, and --nounput flags
2527# and supports processing our scanner.l.
2528#
2529if(WIN32)
2530    set(NULL_DEVICE "NUL:")
2531else()
2532    set(NULL_DEVICE "/dev/null")
2533endif()
2534execute_process(COMMAND ${LEX_EXECUTABLE} -P pcap_ --header-file=${NULL_DEVICE} --nounput -t ${pcap_SOURCE_DIR}/scanner.l
2535    OUTPUT_QUIET RESULT_VARIABLE EXIT_STATUS)
2536if(NOT EXIT_STATUS EQUAL 0)
2537    message(FATAL_ERROR "${LEX_EXECUTABLE} is insufficient to compile libpcap.
2538libpcap requires Flex 2.5.31 or later, or a compatible version of lex.
2539If a suitable version of Lex/Flex is available as a non-standard command
2540and/or not in the PATH, you can specify it using the LEX environment
2541variable. That said, on some systems the error can mean that Flex/Lex is
2542actually acceptable, but m4 is not. Likewise, if a suitable version of
2543m4 (such as GNU M4) is available but has not been detected, you can
2544specify it using the M4 environment variable.")
2545endif()
2546
2547add_custom_command(
2548    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/scanner.c ${CMAKE_CURRENT_BINARY_DIR}/scanner.h
2549    SOURCE ${pcap_SOURCE_DIR}/scanner.l
2550    COMMAND ${LEX_EXECUTABLE} -P pcap_ --header-file=scanner.h --nounput -o${CMAKE_CURRENT_BINARY_DIR}/scanner.c ${pcap_SOURCE_DIR}/scanner.l
2551    DEPENDS ${pcap_SOURCE_DIR}/scanner.l
2552)
2553
2554#
2555# Since scanner.c does not exist yet when cmake is run, mark
2556# it as generated.
2557#
2558# Since scanner.c includes grammar.h, mark that as a dependency.
2559#
2560set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/scanner.c PROPERTIES
2561    GENERATED TRUE
2562    OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/grammar.h
2563)
2564
2565#
2566# Add scanner.c to the list of sources.
2567#
2568#set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} ${CMAKE_CURRENT_BINARY_DIR}/scanner.c)
2569
2570#
2571# Try to find YACC or Bison.
2572#
2573find_program(YACC_EXECUTABLE NAMES bison win_bison byacc yacc)
2574if(YACC_EXECUTABLE STREQUAL "YACC_EXECUTABLE-NOTFOUND")
2575    message(FATAL_ERROR "Neither bison nor win_bison nor byacc nor yacc was found.")
2576endif()
2577
2578if(YACC_EXECUTABLE MATCHES "byacc" OR YACC_EXECUTABLE MATCHES "yacc")
2579    #
2580    # Make sure this is Berkeley YACC, not AT&T YACC;
2581    # the latter doesn't support reentrant parsers.
2582    # Run it with "-V"; that succeeds and reports the
2583    # version number with Berkeley YACC, but will
2584    # (probably) fail with various vendor flavors
2585    # of AT&T YACC.
2586    #
2587    # Hopefully this also eliminates any versions
2588    # of Berkeley YACC that don't support reentrant
2589    # parsers, if there are any.
2590    #
2591    execute_process(COMMAND ${YACC_EXECUTABLE} -V OUTPUT_QUIET
2592        RESULT_VARIABLE EXIT_STATUS)
2593    if(NOT EXIT_STATUS EQUAL 0)
2594        message(FATAL_ERROR "${YACC_EXECUTABLE} is insufficient to compile libpcap.
2595libpcap requires Bison, a newer version of Berkeley YACC with support
2596for reentrant parsers, or another YACC compatible with them.")
2597    endif()
2598    #
2599    # Berkeley YACC doesn't support "%define api.pure", so use
2600    # "%pure-parser".
2601    #
2602    set(REENTRANT_PARSER "%pure-parser")
2603else()
2604    #
2605    # Bison prior to 2.4(.1) doesn't support "%define api.pure", so use
2606    # "%pure-parser".
2607    #
2608    execute_process(COMMAND ${YACC_EXECUTABLE} -V OUTPUT_VARIABLE bison_full_version)
2609    string(REGEX MATCH "[1-9][0-9]*[.][0-9]+" bison_major_minor ${bison_full_version})
2610    if (bison_major_minor VERSION_LESS "2.4")
2611        set(REENTRANT_PARSER "%pure-parser")
2612    else()
2613        set(REENTRANT_PARSER "%define api.pure")
2614    endif()
2615endif()
2616
2617message(STATUS "Parser generator: ${YACC_EXECUTABLE}")
2618
2619#
2620# Create custom command for the scanner.
2621#
2622add_custom_command(
2623    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/grammar.c ${CMAKE_CURRENT_BINARY_DIR}/grammar.h
2624    SOURCE ${pcap_BINARY_DIR}/grammar.y
2625    COMMAND ${YACC_EXECUTABLE} -p pcap_ -o ${CMAKE_CURRENT_BINARY_DIR}/grammar.c -d ${pcap_BINARY_DIR}/grammar.y
2626    DEPENDS ${pcap_BINARY_DIR}/grammar.y
2627)
2628
2629#
2630# Since grammar.c does not exists yet when cmake is run, mark
2631# it as generated.
2632#
2633set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/grammar.c PROPERTIES
2634    GENERATED TRUE
2635    OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/scanner.h
2636)
2637
2638#
2639# Add grammar.c to the list of sources.
2640#
2641#set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} ${CMAKE_CURRENT_BINARY_DIR}/grammar.c)
2642
2643#
2644# Assume, by default, no support for shared libraries and V7/BSD
2645# convention for man pages (devices in section 4, file formats in
2646# section 5, miscellaneous info in section 7, administrative commands
2647# and daemons in section 8).  Individual cases can override this.
2648# Individual cases can override this.
2649#
2650set(MAN_DEVICES 4)
2651set(MAN_FILE_FORMATS 5)
2652set(MAN_MISC_INFO 7)
2653set(MAN_ADMIN_COMMANDS 8)
2654if(CMAKE_SYSTEM_NAME STREQUAL "AIX")
2655    # Workaround to enable certain features
2656    set(_SUN TRUE)
2657    if(PCAP_TYPE STREQUAL "bpf")
2658        #
2659        # If we're using BPF, we need libodm and libcfg, as
2660        # we use them to load the BPF module.
2661        #
2662        set(PCAP_LINK_LIBRARIES ${PCAP_LINK_LIBRARIES} odm cfg)
2663        set(LIBS "${LIBS} -lodm -lcfg")
2664        set(LIBS_STATIC "${LIBS_STATIC} -lodm -lcfg")
2665        set(LIBS_PRIVATE "${LIBS_PRIVATE} -lodm -lcfg")
2666    endif()
2667elseif(CMAKE_SYSTEM_NAME STREQUAL "HP-UX")
2668    if(CMAKE_SYSTEM_VERSION MATCHES "[A-Z.]*9\.[0-9]*")
2669        #
2670        # HP-UX 9.x.
2671        #
2672        set(HAVE_HPUX9 TRUE)
2673    elseif(CMAKE_SYSTEM_VERSION MATCHES "[A-Z.]*10\.0")
2674        #
2675        # HP-UX 10.0.
2676        #
2677    elseif(CMAKE_SYSTEM_VERSION MATCHES "[A-Z.]*10\.1")
2678        #
2679        # HP-UX 10.1.
2680        #
2681    else()
2682        #
2683        # HP-UX 10.20 and later.
2684        #
2685        set(HAVE_HPUX10_20_OR_LATER TRUE)
2686    endif()
2687
2688    #
2689    # Use System V conventions for man pages.
2690    #
2691    set(MAN_ADMIN_COMMANDS 1m)
2692    set(MAN_FILE_FORMATS 4)
2693    set(MAN_MISC_INFO 5)
2694elseif(CMAKE_SYSTEM_NAME STREQUAL "IRIX" OR CMAKE_SYSTEM_NAME STREQUAL "IRIX64")
2695    #
2696    # Use IRIX conventions for man pages; they're the same as the
2697    # System V conventions, except that they use section 8 for
2698    # administrative commands and daemons.
2699    #
2700    set(MAN_FILE_FORMATS 4)
2701    set(MAN_MISC_INFO 5)
2702elseif(CMAKE_SYSTEM_NAME STREQUAL "OSF1")
2703    #
2704    # DEC OSF/1, a/k/a Digital UNIX, a/k/a Tru64 UNIX.
2705    # Use Tru64 UNIX conventions for man pages; they're the same as the
2706    # System V conventions except that they use section 8 for
2707    # administrative commands and daemons.
2708    #
2709    set(MAN_FILE_FORMATS 4)
2710    set(MAN_MISC_INFO 5)
2711    set(MAN_DEVICES 7)
2712elseif(CMAKE_SYSTEM_NAME STREQUAL "SunOS" AND CMAKE_SYSTEM_VERSION MATCHES "5[.][0-9.]*")
2713    #
2714    # SunOS 5.x.
2715    #
2716    set(HAVE_SOLARIS TRUE)
2717    #
2718    # Make sure errno is thread-safe, in case we're called in
2719    # a multithreaded program.  We don't guarantee that two
2720    # threads can use the *same* pcap_t safely, but the
2721    # current version does guarantee that you can use different
2722    # pcap_t's in different threads, and even that pcap_compile()
2723    # is thread-safe (it wasn't thread-safe in some older versions).
2724    #
2725    add_definitions(-D_TS_ERRNO)
2726
2727    if(CMAKE_SYSTEM_VERSION STREQUAL "5.12")
2728    else()
2729        #
2730        # Use System V conventions for man pages.
2731        #
2732        set(MAN_ADMIN_COMMANDS 1m)
2733        set(MAN_FILE_FORMATS 4)
2734        set(MAN_MISC_INFO 5)
2735        set(MAN_DEVICES 7D)
2736    endif()
2737elseif(CMAKE_SYSTEM_NAME STREQUAL "Haiku")
2738    #
2739    # Haiku needs _BSD_SOURCE for the _IO* macros because it doesn't use them.
2740    #
2741    add_definitions(-D_BSD_SOURCE)
2742endif()
2743
2744source_group("Source Files" FILES ${PROJECT_SOURCE_LIST_C})
2745source_group("Header Files" FILES ${PROJECT_SOURCE_LIST_H})
2746
2747if(WIN32)
2748    #
2749    # Add pcap-dll.rc to the list of sources.
2750    #
2751    set(PROJECT_SOURCE_LIST_C ${PROJECT_SOURCE_LIST_C} ${pcap_SOURCE_DIR}/pcap-dll.rc)
2752endif(WIN32)
2753
2754#
2755# Add subdirectories after we've set various variables, so they pick up
2756# pick up those variables.
2757#
2758if(ENABLE_REMOTE)
2759    add_subdirectory(rpcapd)
2760endif(ENABLE_REMOTE)
2761add_subdirectory(testprogs)
2762
2763######################################
2764# Register targets
2765######################################
2766
2767#
2768# Special target to serialize the building of the generated source.
2769#
2770# See
2771#
2772#  https://public.kitware.com/pipermail/cmake/2013-August/055510.html
2773#
2774add_custom_target(SerializeTarget
2775    DEPENDS
2776    ${CMAKE_CURRENT_BINARY_DIR}/grammar.c
2777    ${CMAKE_CURRENT_BINARY_DIR}/scanner.c
2778)
2779
2780set_source_files_properties(${PROJECT_EXTERNAL_OBJECT_LIST} PROPERTIES
2781    EXTERNAL_OBJECT TRUE)
2782
2783if(BUILD_SHARED_LIBS)
2784    add_library(${LIBRARY_NAME} SHARED
2785        ${PROJECT_SOURCE_LIST_C}
2786        ${CMAKE_CURRENT_BINARY_DIR}/grammar.c
2787        ${CMAKE_CURRENT_BINARY_DIR}/scanner.c
2788        ${PROJECT_EXTERNAL_OBJECT_LIST}
2789    )
2790    add_dependencies(${LIBRARY_NAME} SerializeTarget)
2791    set_target_properties(${LIBRARY_NAME} PROPERTIES
2792        COMPILE_DEFINITIONS BUILDING_PCAP)
2793    #
2794    # No matter what the library is called - it might be called "wpcap"
2795    # in a Windows build - the symbol to define to indicate that we're
2796    # building the library, rather than a program using the library,
2797    # and thus that we're exporting functions defined in our public
2798    # header files, rather than importing those functions, is
2799    # pcap_EXPORTS.
2800    #
2801    set_target_properties(${LIBRARY_NAME} PROPERTIES
2802        DEFINE_SYMBOL pcap_EXPORTS)
2803    if(NOT "${LINKER_FLAGS}" STREQUAL "")
2804        set_target_properties(${LIBRARY_NAME} PROPERTIES
2805            LINK_FLAGS "${LINKER_FLAGS}")
2806    endif()
2807endif(BUILD_SHARED_LIBS)
2808
2809add_library(${LIBRARY_NAME}_static STATIC
2810    ${PROJECT_SOURCE_LIST_C}
2811    ${CMAKE_CURRENT_BINARY_DIR}/grammar.c
2812    ${CMAKE_CURRENT_BINARY_DIR}/scanner.c
2813    ${PROJECT_EXTERNAL_OBJECT_LIST}
2814)
2815add_dependencies(${LIBRARY_NAME}_static SerializeTarget)
2816set_target_properties(${LIBRARY_NAME}_static PROPERTIES
2817    COMPILE_DEFINITIONS BUILDING_PCAP)
2818
2819if(WIN32)
2820    if(BUILD_SHARED_LIBS)
2821        set_target_properties(${LIBRARY_NAME} PROPERTIES
2822            VERSION ${PACKAGE_VERSION_NOSUFFIX} # only MAJOR and MINOR are needed
2823        )
2824    endif(BUILD_SHARED_LIBS)
2825    if(MSVC)
2826        # XXX For DLLs, the TARGET_PDB_FILE generator expression can be used to locate
2827        # its PDB file's output directory for installation.
2828        # cmake doesn't offer a generator expression for PDB files generated by the
2829        # compiler (static libraries).
2830        # So instead of considering any possible output there is (there are many),
2831        # this will search for the PDB file in the compiler's initial output directory,
2832        # which is always ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles\wpcap_static.dir
2833        # regardless of architecture, build generator etc.
2834        # Quite hackish indeed.
2835        set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY $<TARGET_FILE_DIR:${LIBRARY_NAME}_static>)
2836        set_target_properties(${LIBRARY_NAME}_static PROPERTIES
2837            COMPILE_PDB_NAME ${LIBRARY_NAME}_static
2838            OUTPUT_NAME "${LIBRARY_NAME}_static"
2839        )
2840    elseif(MINGW)
2841        #
2842        # For compatibility, build the shared library without the "lib" prefix on
2843        # MinGW as well.
2844        #
2845        set_target_properties(${LIBRARY_NAME} PROPERTIES
2846            PREFIX ""
2847            OUTPUT_NAME "${LIBRARY_NAME}"
2848        )
2849        set_target_properties(${LIBRARY_NAME}_static PROPERTIES
2850            OUTPUT_NAME "${LIBRARY_NAME}"
2851        )
2852    endif()
2853else(WIN32) # UN*X
2854    if(BUILD_SHARED_LIBS)
2855        if(APPLE)
2856            set_target_properties(${LIBRARY_NAME} PROPERTIES
2857                VERSION ${PACKAGE_VERSION}
2858                SOVERSION A
2859            )
2860        else(APPLE)
2861            set_target_properties(${LIBRARY_NAME} PROPERTIES
2862                VERSION ${PACKAGE_VERSION}
2863                SOVERSION ${PACKAGE_VERSION_MAJOR}
2864            )
2865        endif(APPLE)
2866    endif(BUILD_SHARED_LIBS)
2867    set_target_properties(${LIBRARY_NAME}_static PROPERTIES
2868        OUTPUT_NAME "${LIBRARY_NAME}"
2869    )
2870endif(WIN32)
2871
2872if(BUILD_SHARED_LIBS)
2873    if(NOT C_ADDITIONAL_FLAGS STREQUAL "")
2874        set_target_properties(${LIBRARY_NAME} PROPERTIES COMPILE_FLAGS ${C_ADDITIONAL_FLAGS})
2875    endif()
2876    target_link_libraries(${LIBRARY_NAME} ${PCAP_LINK_LIBRARIES})
2877endif(BUILD_SHARED_LIBS)
2878
2879if(NOT C_ADDITIONAL_FLAGS STREQUAL "")
2880    set_target_properties(${LIBRARY_NAME}_static PROPERTIES COMPILE_FLAGS ${C_ADDITIONAL_FLAGS})
2881endif()
2882
2883#
2884# On macOS, build libpcap for the appropriate architectures, if
2885# CMAKE_OSX_ARCHITECTURES isn't set (if it is, let that control
2886# the architectures for which to build it).
2887#
2888if(APPLE AND "${CMAKE_OSX_ARCHITECTURES}" STREQUAL "")
2889    #
2890    # Get the major version of Darwin.
2891    #
2892    string(REGEX MATCH "^([0-9]+)" SYSTEM_VERSION_MAJOR "${CMAKE_SYSTEM_VERSION}")
2893
2894    if(SYSTEM_VERSION_MAJOR LESS 8)
2895        #
2896        # Pre-Tiger.  Build only for 32-bit PowerPC.
2897        #
2898        set(OSX_LIBRARY_ARCHITECTURES "ppc")
2899    elseif(SYSTEM_VERSION_MAJOR EQUAL 8)
2900        #
2901        # Tiger.  Is this prior to, or with, Intel support?
2902        #
2903        # Get the minor version of Darwin.
2904        #
2905        string(REPLACE "${SYSTEM_VERSION_MAJOR}." "" SYSTEM_MINOR_AND_PATCH_VERSION ${CMAKE_SYSTEM_VERSION})
2906        string(REGEX MATCH "^([0-9]+)" SYSTEM_VERSION_MINOR "${SYSTEM_MINOR_AND_PATCH_VERSION}")
2907        if(SYSTEM_VERSION_MINOR LESS 4)
2908            #
2909            # Prior to Intel support.  Build for 32-bit
2910            # PowerPC and 64-bit PowerPC, with 32-bit PowerPC
2911            # first.  (I'm guessing that's what Apple does.)
2912            #
2913            set(OSX_LIBRARY_ARCHITECTURES "ppc;ppc64")
2914        elseif(SYSTEM_VERSION_MINOR LESS 7)
2915            #
2916            # With Intel support but prior to x86-64 support.
2917            # Build for 32-bit PowerPC, 64-bit PowerPC, and 32-bit x86,
2918            # with 32-bit PowerPC first.
2919            # (I'm guessing that's what Apple does.)
2920            #
2921            set(OSX_LIBRARY_ARCHITECTURES "ppc;ppc64;i386")
2922        else()
2923            #
2924            # With Intel support including x86-64 support.
2925            # Build for 32-bit PowerPC, 64-bit PowerPC, 32-bit x86,
2926            # and x86-64, with 32-bit PowerPC first.
2927            # (I'm guessing that's what Apple does.)
2928            #
2929            set(OSX_LIBRARY_ARCHITECTURES "ppc;ppc64;i386;x86_64")
2930        endif()
2931    elseif(SYSTEM_VERSION_MAJOR EQUAL 9)
2932        #
2933        # Leopard.  Build for 32-bit PowerPC, 64-bit
2934        # PowerPC, 32-bit x86, and x86-64, with 32-bit PowerPC
2935        # first.  (That's what Apple does.)
2936        #
2937        set(OSX_LIBRARY_ARCHITECTURES "ppc;ppc64;i386;x86_64")
2938    elseif(SYSTEM_VERSION_MAJOR EQUAL 10)
2939        #
2940        # Snow Leopard.  Build for x86-64, 32-bit x86, and
2941        # 32-bit PowerPC, with x86-64 first.  (That's
2942        # what Apple does, even though Snow Leopard
2943        # doesn't run on PPC, so PPC libpcap runs under
2944        # Rosetta, and Rosetta doesn't support BPF
2945        # ioctls, so PPC programs can't do live
2946        # captures.)
2947        #
2948        set(OSX_LIBRARY_ARCHITECTURES "x86_64;i386;ppc")
2949    elseif(SYSTEM_VERSION_MAJOR GREATER 10 AND SYSTEM_VERSION_MAJOR LESS 19)
2950        #
2951        # Post-Snow Leopard, pre-Catalina.  Build for x86-64
2952        # and 32-bit x86, with x86-64 first.  (That's what Apple does)
2953        #
2954        # First, check whether we're building with OpenSSL.
2955        # If so, don't bother trying to build fat.
2956        #
2957        if(HAVE_OPENSSL)
2958          set(X86_32_BIT_SUPPORTED NO)
2959          set(OSX_LIBRARY_ARCHITECTURES "x86_64")
2960          message(WARNING "We're assuming the OpenSSL libraries are 64-bit only, so we're not compiling for 32-bit x86")
2961        else()
2962          #
2963          # Now, check whether we *can* build for i386.
2964          #
2965          cmake_push_check_state()
2966          set(CMAKE_REQUIRED_FLAGS "-arch i386")
2967          check_c_source_compiles(
2968"int
2969main(void)
2970{
2971    return 0;
2972}
2973"
2974                   X86_32_BIT_SUPPORTED)
2975          cmake_pop_check_state()
2976          if(X86_32_BIT_SUPPORTED)
2977              set(OSX_LIBRARY_ARCHITECTURES "x86_64;i386")
2978          else()
2979              set(OSX_LIBRARY_ARCHITECTURES "x86_64")
2980              #
2981              # We can't build fat; suggest that the user install the
2982              # /usr/include headers if they want to build fat.
2983              #
2984              if(SYSTEM_VERSION_MAJOR LESS 18)
2985                  #
2986                  # Pre-Mojave; the command-line tools should be sufficient to
2987                  # enable 32-bit x86 builds.
2988                  #
2989                  message(WARNING "Compiling for 32-bit x86 gives an error; try installing the command-line tools")
2990              else()
2991                  message(WARNING "Compiling for 32-bit x86 gives an error; try installing the command-line tools and, after that, installing the /usr/include headers from the /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg package")
2992              endif()
2993          endif()
2994        endif()
2995    elseif(SYSTEM_VERSION_MAJOR EQUAL 19)
2996        #
2997        # Catalina.  Build libraries and executables
2998        # only for x86-64.  (That's what Apple does;
2999        # 32-bit x86 binaries are not supported on
3000        # Catalina.)
3001        #
3002        set(OSX_LIBRARY_ARCHITECTURES "x86_64")
3003    else()
3004        #
3005        # Post-Catalina.  Build libraries and
3006        # executables for x86-64 and ARM64.
3007        # (That's what Apple does, except they
3008        # build for arm64e, which may include
3009        # some of the pointer-checking extensions.)
3010        #
3011        # If we're building with libssl, make sure
3012        # we can build fat with it (i.e., that it
3013        # was built fat); if we can't, don't set
3014        # the target architectures, and just
3015        # build for the host we're on.
3016        #
3017        # Otherwise, just add both of them.
3018        #
3019        if(HAVE_OPENSSL)
3020          cmake_push_check_state()
3021          set(CMAKE_REQUIRED_FLAGS "-arch x86_64 -arch arm64")
3022          set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
3023          set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_LIBRARIES})
3024          #
3025          # We must test whether this compiles and links, so
3026          # check_symbol_exists() isn't sufficient.
3027          #
3028          # SSL_library_init() may be a macro that's #defined
3029          # to be the real function to call, so we have to
3030          # include <openssl/ssl.h>, and check_function_exists()
3031          # isn't sufficient.
3032          #
3033          check_c_source_compiles(
3034"#include <openssl/ssl.h>
3035int
3036main(void)
3037{
3038    SSL_library_init();
3039    return 0;
3040}
3041"
3042              FAT_SSL_BUILDS_SUPPORTED)
3043          cmake_pop_check_state()
3044          if(FAT_SSL_BUILDS_SUPPORTED)
3045              set(OSX_LIBRARY_ARCHITECTURES "x86_64;arm64")
3046          endif()
3047        else()
3048            set(OSX_LIBRARY_ARCHITECTURES "x86_64;arm64")
3049        endif()
3050    endif()
3051    if(BUILD_SHARED_LIBS)
3052        set_target_properties(${LIBRARY_NAME} PROPERTIES
3053            OSX_ARCHITECTURES "${OSX_LIBRARY_ARCHITECTURES}")
3054    endif(BUILD_SHARED_LIBS)
3055    set_target_properties(${LIBRARY_NAME}_static PROPERTIES
3056        OSX_ARCHITECTURES "${OSX_LIBRARY_ARCHITECTURES}")
3057endif()
3058
3059######################################
3060# Write out the config.h file
3061######################################
3062
3063configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmakeconfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)
3064
3065######################################
3066# Write out the grammar.y file
3067######################################
3068
3069configure_file(${CMAKE_CURRENT_SOURCE_DIR}/grammar.y.in ${CMAKE_CURRENT_BINARY_DIR}/grammar.y @ONLY)
3070
3071######################################
3072# Install pcap library, include files, and man pages
3073######################################
3074
3075#
3076# "Define GNU standard installation directories", which actually
3077# are also defined, to some degree, by autotools, and at least
3078# some of which are general UN*X conventions.
3079#
3080include(GNUInstallDirs)
3081
3082set(LIBRARY_NAME_STATIC ${LIBRARY_NAME}_static)
3083
3084function(install_manpage_symlink SOURCE TARGET MANDIR)
3085    if(MINGW)
3086        #
3087        # If we haven't found an ln executable with MinGW, we don't try
3088        # generating and installing the man pages, so if we get here,
3089        # we've found that executable.
3090        set(LINK_COMMAND "\"${LINK_EXECUTABLE}\" \"-s\" \"${SOURCE}\" \"${TARGET}\"")
3091    else(MINGW)
3092        set(LINK_COMMAND "\"${CMAKE_COMMAND}\" \"-E\" \"create_symlink\" \"${SOURCE}\" \"${TARGET}\"")
3093    endif(MINGW)
3094
3095    install(CODE
3096        "message(STATUS \"Symlinking: \$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/${MANDIR}/${SOURCE} to ${TARGET}\")
3097         execute_process(
3098            COMMAND \"${CMAKE_COMMAND}\" \"-E\" \"remove\" \"${TARGET}\"
3099            WORKING_DIRECTORY \$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/${MANDIR}
3100          )
3101         execute_process(
3102            COMMAND ${LINK_COMMAND}
3103            WORKING_DIRECTORY \$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/${MANDIR}
3104            RESULT_VARIABLE EXIT_STATUS
3105          )
3106          if(NOT EXIT_STATUS EQUAL 0)
3107              message(FATAL_ERROR \"Could not create symbolic link from ${CMAKE_INSTALL_PREFIX}/${MANDIR}/${SOURCE} to ${TARGET}\")
3108          endif()
3109          set(CMAKE_INSTALL_MANIFEST_FILES \${CMAKE_INSTALL_MANIFEST_FILES} ${CMAKE_INSTALL_PREFIX}/${MANDIR}/${TARGET})")
3110endfunction(install_manpage_symlink)
3111
3112set(MAN1_NOEXPAND pcap-config.1)
3113set(MAN3PCAP_EXPAND
3114    pcap.3pcap.in
3115    pcap_compile.3pcap.in
3116    pcap_datalink.3pcap.in
3117    pcap_dump_open.3pcap.in
3118    pcap_get_tstamp_precision.3pcap.in
3119    pcap_list_datalinks.3pcap.in
3120    pcap_list_tstamp_types.3pcap.in
3121    pcap_open_dead.3pcap.in
3122    pcap_open_offline.3pcap.in
3123    pcap_set_immediate_mode.3pcap.in
3124    pcap_set_tstamp_precision.3pcap.in
3125    pcap_set_tstamp_type.3pcap.in
3126)
3127set(MAN3PCAP_NOEXPAND
3128    pcap_activate.3pcap
3129    pcap_breakloop.3pcap
3130    pcap_can_set_rfmon.3pcap
3131    pcap_close.3pcap
3132    pcap_create.3pcap
3133    pcap_datalink_name_to_val.3pcap
3134    pcap_datalink_val_to_name.3pcap
3135    pcap_dump.3pcap
3136    pcap_dump_close.3pcap
3137    pcap_dump_file.3pcap
3138    pcap_dump_flush.3pcap
3139    pcap_dump_ftell.3pcap
3140    pcap_file.3pcap
3141    pcap_fileno.3pcap
3142    pcap_findalldevs.3pcap
3143    pcap_freecode.3pcap
3144    pcap_get_required_select_timeout.3pcap
3145    pcap_get_selectable_fd.3pcap
3146    pcap_geterr.3pcap
3147    pcap_init.3pcap
3148    pcap_inject.3pcap
3149    pcap_is_swapped.3pcap
3150    pcap_lib_version.3pcap
3151    pcap_lookupdev.3pcap
3152    pcap_lookupnet.3pcap
3153    pcap_loop.3pcap
3154    pcap_major_version.3pcap
3155    pcap_next_ex.3pcap
3156    pcap_offline_filter.3pcap
3157    pcap_open_live.3pcap
3158    pcap_set_buffer_size.3pcap
3159    pcap_set_datalink.3pcap
3160    pcap_set_promisc.3pcap
3161    pcap_set_protocol_linux.3pcap
3162    pcap_set_rfmon.3pcap
3163    pcap_set_snaplen.3pcap
3164    pcap_set_timeout.3pcap
3165    pcap_setdirection.3pcap
3166    pcap_setfilter.3pcap
3167    pcap_setnonblock.3pcap
3168    pcap_snapshot.3pcap
3169    pcap_stats.3pcap
3170    pcap_statustostr.3pcap
3171    pcap_strerror.3pcap
3172    pcap_tstamp_type_name_to_val.3pcap
3173    pcap_tstamp_type_val_to_name.3pcap
3174)
3175set(MANFILE_EXPAND
3176    pcap-savefile.manfile.in
3177)
3178set(MANMISC_EXPAND
3179    pcap-filter.manmisc.in
3180    pcap-linktype.manmisc.in
3181    pcap-tstamp.manmisc.in
3182)
3183
3184if(BUILD_SHARED_LIBS)
3185    set(LIBRARIES_TO_INSTALL "${LIBRARY_NAME}" "${LIBRARY_NAME_STATIC}")
3186else(BUILD_SHARED_LIBS)
3187    set(LIBRARIES_TO_INSTALL "${LIBRARY_NAME_STATIC}")
3188endif(BUILD_SHARED_LIBS)
3189
3190if(WIN32 OR CYGWIN OR MSYS)
3191    #
3192    # XXX - according to the CMake documentation, WIN32 is set if
3193    # the target is Windows; would there ever be a case where
3194    # CYGWIN or MSYS are set but WIN32 *isn't* set?
3195    #
3196    if(MSVC AND CMAKE_SIZEOF_VOID_P EQUAL 8)
3197        #
3198        # Install 64-bit code built with MSVC in the x64 subdirectories,
3199        # as that's where it expects it to be.
3200        #
3201        install(TARGETS ${LIBRARIES_TO_INSTALL}
3202                RUNTIME DESTINATION bin/x64
3203                LIBRARY DESTINATION lib/x64
3204                ARCHIVE DESTINATION lib/x64)
3205        if(NOT MINGW)
3206            install(FILES $<TARGET_FILE_DIR:${LIBRARY_NAME_STATIC}>/${LIBRARY_NAME_STATIC}.pdb
3207                    DESTINATION bin/x64 OPTIONAL)
3208            if(BUILD_SHARED_LIBS)
3209                install(FILES $<TARGET_PDB_FILE:${LIBRARY_NAME}>
3210                        DESTINATION bin/x64 OPTIONAL)
3211            endif(BUILD_SHARED_LIBS)
3212        endif(NOT MINGW)
3213    else(MSVC AND CMAKE_SIZEOF_VOID_P EQUAL 8)
3214        #
3215        # Install 32-bit code, and 64-bit code not built with MSVC
3216        # in the top-level directories, as those are where they
3217        # expect it to be.
3218        #
3219        install(TARGETS ${LIBRARIES_TO_INSTALL}
3220                RUNTIME DESTINATION bin
3221                LIBRARY DESTINATION lib
3222                ARCHIVE DESTINATION lib)
3223        if(MSVC)
3224            install(FILES $<TARGET_FILE_DIR:${LIBRARY_NAME_STATIC}>/${LIBRARY_NAME_STATIC}.pdb
3225                    DESTINATION bin OPTIONAL)
3226            if(BUILD_SHARED_LIBS)
3227                install(FILES $<TARGET_PDB_FILE:${LIBRARY_NAME}>
3228                        DESTINATION bin OPTIONAL)
3229            endif(BUILD_SHARED_LIBS)
3230        endif(MSVC)
3231    endif(MSVC AND CMAKE_SIZEOF_VOID_P EQUAL 8)
3232else(WIN32 OR CYGWIN OR MSYS)
3233    install(TARGETS ${LIBRARIES_TO_INSTALL} DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR})
3234endif(WIN32 OR CYGWIN OR MSYS)
3235
3236install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/pcap/ DESTINATION include/pcap)
3237install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/pcap.h DESTINATION include)
3238install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/pcap-bpf.h DESTINATION include)
3239install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/pcap-namedb.h DESTINATION include)
3240
3241# On UN*X, and on Windows when not using MSVC, generate libpcap.pc and
3242# pcap-config and process man pages and arrange that they be installed.
3243if(NOT MSVC)
3244    set(prefix ${CMAKE_INSTALL_PREFIX})
3245    set(exec_prefix "\${prefix}")
3246    set(includedir "\${prefix}/include")
3247    set(libdir "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
3248
3249    #
3250    # If this is a platform where we need to have the .pc file and
3251    # pcap-config script supply an rpath option to specify the directory
3252    # in which the libpcap shared library is installed, and the install
3253    # prefix /usr (meaning we're not installing a system library),
3254    # provide the rpath option.
3255    #
3256    # (We must check CMAKE_INSTALL_PREFIX, as the library directory
3257    # isn't  necessarily /usr/lib in this case - for example, Linux
3258    # distributions for 64-bit platforms that also provide support for
3259    # binaries for a 32-bit version of the platform may put the 64-bit
3260    # libraries, the 32-bit libraries, or both in directories other than
3261    # /usr/lib.)
3262    #
3263    # In AIX, do we have to do this?
3264    #
3265    # In Darwin-based OSes, the full paths of the shared libraries with
3266    # which the program was linked are stored in the executable, so we
3267    # don't need to provide an rpath option.
3268    #
3269    # With the HP-UX linker, directories specified with -L are, by
3270    # default, added to the run-time search path, so we don't need to
3271    # supply them.
3272    #
3273    # For Tru64 UNIX, "-rpath" works with DEC's^WCompaq's^WHP's C
3274    # compiler for Alpha, but isn't documented as working with GCC, and
3275    # no GCC-compatible option is documented as working with the DEC
3276    # compiler.  If anybody needs this on Tru64/Alpha, they're welcome
3277    # to figure out a way to make it work.
3278    #
3279    # This must *not* depend on the compiler, as, on platforms where
3280    # there's a GCC-compatible compiler and a vendor compiler, we need
3281    # to work with both.
3282    #
3283    if(NOT CMAKE_INSTALL_PREFIX STREQUAL "/usr")
3284        if(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD" OR
3285           CMAKE_SYSTEM_NAME STREQUAL "NetBSD" OR
3286           CMAKE_SYSTEM_NAME STREQUAL "OpenBSD" OR
3287           CMAKE_SYSTEM_NAME STREQUAL "DragonFly BSD" OR
3288           CMAKE_SYSTEM_NAME STREQUAL "Linux")
3289            #
3290            # Platforms where the "native" C compiler is GCC or accepts
3291            # compatible command-line arguments, and the "native" linker
3292            # is the GNU linker or accepts compatible command-line
3293            # arguments.
3294            #
3295            set(RPATH "-Wl,-rpath,\${libdir}")
3296        elseif(CMAKE_SYSTEM_NAME STREQUAL "SunOS" AND CMAKE_SYSTEM_VERSION MATCHES "5[.][0-9.]*")
3297            #
3298            # SunOS 5.x.
3299            #
3300            # Sun/Oracle's linker, the GNU linker, and GNU-compatible
3301            # linkers all support -R.
3302            #
3303            set(RPATH "-Wl,-R,\${libdir}")
3304        else()
3305            #
3306            # No option needed to set the RPATH.
3307            #
3308            set(RPATH "")
3309        endif()
3310    endif()
3311    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/pcap-config.in ${CMAKE_CURRENT_BINARY_DIR}/pcap-config @ONLY)
3312    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpcap.pc.in ${CMAKE_CURRENT_BINARY_DIR}/libpcap.pc @ONLY)
3313    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/pcap-config DESTINATION bin)
3314    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpcap.pc DESTINATION lib/pkgconfig)
3315
3316    #
3317    # Man pages.
3318    #
3319    # For each section of the manual for which we have man pages
3320    # that require macro expansion, do the expansion.
3321    #
3322    # If this is MinGW, maybe we have a UN*X-style ln command and
3323    # maybe we don't.  (No, we do *NOT* require MSYS!)  If we don't
3324    # have it, don't do the man pages.
3325    #
3326    if(MINGW)
3327        find_program(LINK_EXECUTABLE ln)
3328    endif(MINGW)
3329    if(UNIX OR (MINGW AND LINK_EXECUTABLE))
3330        set(MAN1 "")
3331        foreach(MANPAGE ${MAN1_NOEXPAND})
3332            set(MAN1 ${MAN1} ${CMAKE_CURRENT_SOURCE_DIR}/${MANPAGE})
3333        endforeach(MANPAGE)
3334        install(FILES ${MAN1} DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
3335
3336        set(MAN3PCAP "")
3337        foreach(MANPAGE ${MAN3PCAP_NOEXPAND})
3338            set(MAN3PCAP ${MAN3PCAP} ${CMAKE_CURRENT_SOURCE_DIR}/${MANPAGE})
3339        endforeach(MANPAGE)
3340        foreach(TEMPLATE_MANPAGE ${MAN3PCAP_EXPAND})
3341            string(REPLACE ".in" "" MANPAGE ${TEMPLATE_MANPAGE})
3342            configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${TEMPLATE_MANPAGE} ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE} @ONLY)
3343            set(MAN3PCAP ${MAN3PCAP} ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE})
3344        endforeach(TEMPLATE_MANPAGE)
3345        install(FILES ${MAN3PCAP} DESTINATION ${CMAKE_INSTALL_MANDIR}/man3)
3346        install_manpage_symlink(pcap_datalink_val_to_name.3pcap pcap_datalink_val_to_description.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3347        install_manpage_symlink(pcap_datalink_val_to_name.3pcap pcap_datalink_val_to_description_or_dlt.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3348        install_manpage_symlink(pcap_dump_open.3pcap pcap_dump_fopen.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3349        install_manpage_symlink(pcap_findalldevs.3pcap pcap_freealldevs.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3350        install_manpage_symlink(pcap_geterr.3pcap pcap_perror.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3351        install_manpage_symlink(pcap_inject.3pcap pcap_sendpacket.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3352        install_manpage_symlink(pcap_list_datalinks.3pcap pcap_free_datalinks.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3353        install_manpage_symlink(pcap_list_tstamp_types.3pcap pcap_free_tstamp_types.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3354        install_manpage_symlink(pcap_loop.3pcap pcap_dispatch.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3355        install_manpage_symlink(pcap_major_version.3pcap pcap_minor_version.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3356        install_manpage_symlink(pcap_next_ex.3pcap pcap_next.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3357        install_manpage_symlink(pcap_open_dead.3pcap pcap_open_dead_with_tstamp_precision.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3358        install_manpage_symlink(pcap_open_offline.3pcap pcap_open_offline_with_tstamp_precision.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3359        install_manpage_symlink(pcap_open_offline.3pcap pcap_fopen_offline.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3360        install_manpage_symlink(pcap_open_offline.3pcap pcap_fopen_offline_with_tstamp_precision.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3361        install_manpage_symlink(pcap_tstamp_type_val_to_name.3pcap pcap_tstamp_type_val_to_description.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3362        install_manpage_symlink(pcap_setnonblock.3pcap pcap_getnonblock.3pcap ${CMAKE_INSTALL_MANDIR}/man3)
3363
3364        set(MANFILE "")
3365        foreach(TEMPLATE_MANPAGE ${MANFILE_EXPAND})
3366            string(REPLACE ".manfile.in" ".${MAN_FILE_FORMATS}" MANPAGE ${TEMPLATE_MANPAGE})
3367            configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${TEMPLATE_MANPAGE} ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE} @ONLY)
3368            set(MANFILE ${MANFILE} ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE})
3369        endforeach(TEMPLATE_MANPAGE)
3370        install(FILES ${MANFILE} DESTINATION ${CMAKE_INSTALL_MANDIR}/man${MAN_FILE_FORMATS})
3371
3372        set(MANMISC "")
3373        foreach(TEMPLATE_MANPAGE ${MANMISC_EXPAND})
3374            string(REPLACE ".manmisc.in" ".${MAN_MISC_INFO}" MANPAGE ${TEMPLATE_MANPAGE})
3375            configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${TEMPLATE_MANPAGE} ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE} @ONLY)
3376            set(MANMISC ${MANMISC} ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE})
3377        endforeach(TEMPLATE_MANPAGE)
3378        install(FILES ${MANMISC} DESTINATION ${CMAKE_INSTALL_MANDIR}/man${MAN_MISC_INFO})
3379    endif(UNIX OR (MINGW AND LINK_EXECUTABLE))
3380endif(NOT MSVC)
3381
3382# uninstall target
3383configure_file(
3384    "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
3385    "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
3386    IMMEDIATE @ONLY)
3387
3388add_custom_target(uninstall
3389    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
3390