"Fossies" - the Fresh Open Source Software Archive

Member "tcpdump-4.99.1/./cmake/Modules/FindPCAP.cmake" (7 Jun 2021, 14714 Bytes) of package /linux/misc/tcpdump-4.99.1.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) CMake source code syntax highlighting (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file. See also the latest Fossies "Diffs" side-by-side code changes report for "FindPCAP.cmake": 4.99.0_vs_4.99.1.

    1 #
    2 # Try to find libpcap.
    3 #
    4 # To tell this module where to look, a user may set the environment variable
    5 # PCAP_ROOT to point cmake to the *root* of a directory with include and
    6 # lib subdirectories for pcap.dll (e.g WpdPack or npcap-sdk).
    7 # Alternatively, PCAP_ROOT may also be set from cmake command line or GUI
    8 # (e.g cmake -DPCAP_ROOT=C:\path\to\pcap [...])
    9 #
   10 
   11 if(WIN32)
   12   #
   13   # Building for Windows.
   14   #
   15   # libpcap isn't set up to install .pc files or pcap-config on Windows,
   16   # and it's not clear that either of them would work without a lot
   17   # of additional effort.  WinPcap doesn't supply them, and neither
   18   # does Npcap.
   19   #
   20   # So just search for them directly.  Look for both pcap and wpcap.
   21   # Don't bother looking for static libraries; unlike most UN*Xes
   22   # (with the exception of AIX), where different extensions are used
   23   # for shared and static, Windows uses .lib both for import libraries
   24   # for DLLs and for static libraries.
   25   #
   26   # We don't directly set PCAP_INCLUDE_DIRS or PCAP_LIBRARIES, as
   27   # they're not supposed to be cache entries, and find_path() and
   28   # find_library() set cache entries.
   29   #
   30   find_path(PCAP_INCLUDE_DIR pcap.h)
   31 
   32   # The 64-bit Packet.lib is located under /x64
   33   if(CMAKE_SIZEOF_VOID_P EQUAL 8)
   34     #
   35     # For the WinPcap and Npcap SDKs, the Lib subdirectory of the top-level
   36     # directory contains 32-bit libraries; the 64-bit libraries are in the
   37     # Lib/x64 directory.
   38     #
   39     # The only way to *FORCE* CMake to look in the Lib/x64 directory
   40     # without searching in the Lib directory first appears to be to set
   41     # CMAKE_LIBRARY_ARCHITECTURE to "x64".
   42     #
   43     set(CMAKE_LIBRARY_ARCHITECTURE "x64")
   44   endif()
   45   find_library(PCAP_LIBRARY NAMES pcap wpcap)
   46 
   47   #
   48   # Do the standard arg processing, including failing if it's a
   49   # required package.
   50   #
   51   include(FindPackageHandleStandardArgs)
   52   find_package_handle_standard_args(PCAP
   53     DEFAULT_MSG
   54     PCAP_INCLUDE_DIR
   55     PCAP_LIBRARY
   56   )
   57   mark_as_advanced(
   58     PCAP_INCLUDE_DIR
   59     PCAP_LIBRARY
   60   )
   61   if(PCAP_FOUND)
   62     set(PCAP_LIBRARIES ${PCAP_LIBRARY})
   63     set(PCAP_INCLUDE_DIRS ${PCAP_INCLUDE_DIR})
   64   endif()
   65 else(WIN32)
   66   #
   67   # Building for UN*X.
   68   #
   69   # See whether we were handed a QUIET argument, so we can pass it on
   70   # to pkg_search_module.  Do *NOT* pass on the REQUIRED argument,
   71   # because, if pkg-config isn't found, or it is but it has no .pc
   72   # files for libpcap, that is *not* necessarily an indication that
   73   # libpcap isn't available - not all systems ship pkg-config, and
   74   # libpcap didn't have .pc files until libpcap 1.9.0.
   75   #
   76   if(PCAP_FIND_QUIETLY)
   77     set(_quiet "QUIET")
   78   endif()
   79 
   80   #
   81   # First, try pkg-config.
   82   # Before doing so, set the PKG_CONFIG_PATH environment variable
   83   # to include all the directories in CMAKE_PREFIX_PATH.
   84   #
   85   # *If* we were to require CMake 3.1 or later on UN*X,
   86   # pkg_search_module() would do this for us, but, for now,
   87   # we're not doing that, in case somebody's building with
   88   # CMake on some "long-term support" version, predating
   89   # CMake 3.1, of an OS that that supplies an earlier
   90   # version as a package.
   91   #
   92   # If we ever set a minimum of 3.1 or later on UN*X, we should
   93   # remove the environment variable changes.
   94   #
   95   # This is based on code in the CMake 3.12.4 FindPkgConfig.cmake,
   96   # which is "Distributed under the OSI-approved BSD 3-Clause License."
   97   #
   98   find_package(PkgConfig)
   99 
  100   #
  101   # Get the current PKG_CONFIG_PATH setting.
  102   #
  103   set(_pkg_config_path "$ENV{PKG_CONFIG_PATH}")
  104 
  105   #
  106   # Save it, so we can restore it after we run pkg-config.
  107   #
  108   set(_saved_pkg_config_path "${_pkg_config_path}")
  109 
  110   if(NOT "${CMAKE_PREFIX_PATH}" STREQUAL "")
  111     #
  112     # Convert it to a CMake-style path, before we add additional
  113     # values to it.
  114     #
  115     if(NOT "${_pkg_config_path}" STREQUAL "")
  116       file(TO_CMAKE_PATH "${_pkg_config_path}" _pkg_config_path)
  117     endif()
  118 
  119     #
  120     # Turn CMAKE_PREFIX_PATH into a list of extra paths to add
  121     # to _pkg_config_path.
  122     #
  123     set(_extra_paths "")
  124     list(APPEND _extra_paths ${CMAKE_PREFIX_PATH})
  125 
  126     # Create a list of the possible pkgconfig subfolder (depending on
  127     # the system
  128     set(_lib_dirs)
  129     if(NOT DEFINED CMAKE_SYSTEM_NAME
  130         OR (CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU)$"
  131             AND NOT CMAKE_CROSSCOMPILING))
  132       if(EXISTS "/etc/debian_version") # is this a debian system ?
  133         if(CMAKE_LIBRARY_ARCHITECTURE)
  134           list(APPEND _lib_dirs "lib/${CMAKE_LIBRARY_ARCHITECTURE}/pkgconfig")
  135         endif()
  136       else()
  137         # not debian, check the FIND_LIBRARY_USE_LIB32_PATHS and FIND_LIBRARY_USE_LIB64_PATHS properties
  138         get_property(uselib32 GLOBAL PROPERTY FIND_LIBRARY_USE_LIB32_PATHS)
  139         if(uselib32 AND CMAKE_SIZEOF_VOID_P EQUAL 4)
  140           list(APPEND _lib_dirs "lib32/pkgconfig")
  141         endif()
  142         get_property(uselib64 GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS)
  143         if(uselib64 AND CMAKE_SIZEOF_VOID_P EQUAL 8)
  144           list(APPEND _lib_dirs "lib64/pkgconfig")
  145         endif()
  146         get_property(uselibx32 GLOBAL PROPERTY FIND_LIBRARY_USE_LIBX32_PATHS)
  147         if(uselibx32 AND CMAKE_INTERNAL_PLATFORM_ABI STREQUAL "ELF X32")
  148           list(APPEND _lib_dirs "libx32/pkgconfig")
  149         endif()
  150       endif()
  151     endif()
  152     if(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD" AND NOT CMAKE_CROSSCOMPILING)
  153       list(APPEND _lib_dirs "libdata/pkgconfig")
  154     endif()
  155     list(APPEND _lib_dirs "lib/pkgconfig")
  156     list(APPEND _lib_dirs "share/pkgconfig")
  157 
  158     # Check if directories exist and eventually append them to the
  159     # pkgconfig path list
  160     foreach(_prefix_dir ${_extra_paths})
  161       foreach(_lib_dir ${_lib_dirs})
  162         if(EXISTS "${_prefix_dir}/${_lib_dir}")
  163           list(APPEND _pkg_config_path "${_prefix_dir}/${_lib_dir}")
  164           list(REMOVE_DUPLICATES _pkg_config_path)
  165         endif()
  166       endforeach()
  167     endforeach()
  168 
  169     if(NOT "${_pkg_config_path}" STREQUAL "")
  170       # remove empty values from the list
  171       list(REMOVE_ITEM _pkg_config_path "")
  172       file(TO_NATIVE_PATH "${_pkg_config_path}" _pkg_config_path)
  173       if(UNIX)
  174         string(REPLACE ";" ":" _pkg_config_path "${_pkg_config_path}")
  175         string(REPLACE "\\ " " " _pkg_config_path "${_pkg_config_path}")
  176       endif()
  177       set(ENV{PKG_CONFIG_PATH} "${_pkg_config_path}")
  178     endif()
  179   endif()
  180   pkg_search_module(CONFIG_PCAP ${_quiet} libpcap)
  181   set(ENV{PKG_CONFIG_PATH} "${_saved_pkg_config_path}")
  182 
  183   if(NOT CONFIG_PCAP_FOUND)
  184     #
  185     # That didn't work.  Try pcap-config.
  186     #
  187     find_program(PCAP_CONFIG pcap-config)
  188     if(PCAP_CONFIG)
  189       #
  190       # We have pcap-config; use it.
  191       #
  192       if(NOT "${_quiet}" STREQUAL "QUIET")
  193         message(STATUS "Found pcap-config")
  194       endif()
  195 
  196       #
  197       # if this is macOS or some other Darwin-based OS, check whether
  198       # it's the system-supplied one.
  199       #
  200       if(APPLE AND "${PCAP_CONFIG}" STREQUAL /usr/bin/pcap-config)
  201         #
  202         # It is - remember that, so that if it provides -I/usr/local/include
  203         # with --cflags, or -L/usr/local/lib with --libs, we ignore it;
  204         # the macOS pcap-config does that even though the headers aren't
  205         # under /usr/local/include and the library isn't in /usr/local/lib.
  206         #
  207         set(_broken_apple_pcap_config TRUE)
  208       endif()
  209 
  210       #
  211       # Now get the include directories.
  212       #
  213       execute_process(COMMAND "${PCAP_CONFIG}" "--cflags"
  214         RESULT_VARIABLE PCAP_CONFIG_RESULT
  215         OUTPUT_VARIABLE PCAP_CONFIG_OUTPUT
  216         OUTPUT_STRIP_TRAILING_WHITESPACE
  217       )
  218       if(NOT PCAP_CONFIG_RESULT EQUAL 0)
  219         message(FATAL_ERROR "pcap-config --cflags failed")
  220       endif()
  221       separate_arguments(CFLAGS_LIST UNIX_COMMAND ${PCAP_CONFIG_OUTPUT})
  222       set(CONFIG_PCAP_INCLUDE_DIRS "")
  223       foreach(_arg IN LISTS CFLAGS_LIST)
  224         if(_arg MATCHES "^-I")
  225           #
  226           # Extract the directory by removing the -I.
  227           #
  228           string(REGEX REPLACE "-I" "" _dir ${_arg})
  229           #
  230           # Work around macOS (and probably other Darwin) brokenness,
  231           # by not adding /usr/local/include if it's from the broken
  232           # Apple pcap-config.
  233           #
  234           if(NOT _broken_apple_pcap_config OR
  235              NOT "${_dir}" STREQUAL /usr/local/include)
  236             # Add it to CONFIG_PCAP_INCLUDE_DIRS
  237             list(APPEND CONFIG_PCAP_INCLUDE_DIRS ${_dir})
  238           endif()
  239         endif()
  240       endforeach()
  241 
  242       #
  243       # Now, get the library directories and libraries for dynamic linking.
  244       #
  245       execute_process(COMMAND "${PCAP_CONFIG}" "--libs"
  246         RESULT_VARIABLE PCAP_CONFIG_RESULT
  247         OUTPUT_VARIABLE PCAP_CONFIG_OUTPUT
  248         OUTPUT_STRIP_TRAILING_WHITESPACE
  249       )
  250       if(NOT PCAP_CONFIG_RESULT EQUAL 0)
  251         message(FATAL_ERROR "pcap-config --libs failed")
  252       endif()
  253       separate_arguments(LIBS_LIST UNIX_COMMAND ${PCAP_CONFIG_OUTPUT})
  254       set(CONFIG_PCAP_LIBRARY_DIRS "")
  255       set(CONFIG_PCAP_LIBRARIES "")
  256       foreach(_arg IN LISTS LIBS_LIST)
  257         if(_arg MATCHES "^-L")
  258           #
  259           # Extract the directory by removing the -L.
  260           #
  261           string(REGEX REPLACE "-L" "" _dir ${_arg})
  262           #
  263           # Work around macOS (and probably other Darwin) brokenness,
  264           # by not adding /usr/local/lib if it's from the broken
  265           # Apple pcap-config.
  266           #
  267           if(NOT _broken_apple_pcap_config OR
  268              NOT "${_dir}" STREQUAL /usr/local/lib)
  269             # Add this directory to CONFIG_PCAP_LIBRARY_DIRS
  270             list(APPEND CONFIG_PCAP_LIBRARY_DIRS ${_dir})
  271           endif()
  272         elseif(_arg MATCHES "^-l")
  273           string(REGEX REPLACE "-l" "" _lib ${_arg})
  274           list(APPEND CONFIG_PCAP_LIBRARIES ${_lib})
  275         endif()
  276       endforeach()
  277 
  278       #
  279       # Now, get the library directories and libraries for static linking.
  280       #
  281       execute_process(COMMAND "${PCAP_CONFIG}" "--libs" "--static"
  282         RESULT_VARIABLE PCAP_CONFIG_RESULT
  283         OUTPUT_VARIABLE PCAP_CONFIG_OUTPUT
  284       )
  285       if(NOT PCAP_CONFIG_RESULT EQUAL 0)
  286         message(FATAL_ERROR "pcap-config --libs --static failed")
  287       endif()
  288       separate_arguments(LIBS_LIST UNIX_COMMAND ${PCAP_CONFIG_OUTPUT})
  289       set(CONFIG_PCAP_STATIC_LIBRARY_DIRS "")
  290       set(CONFIG_PCAP_STATIC_LIBRARIES "")
  291       foreach(_arg IN LISTS LIBS_LIST)
  292         if(_arg MATCHES "^-L")
  293           #
  294           # Extract the directory by removing the -L.
  295           #
  296           string(REGEX REPLACE "-L" "" _dir ${_arg})
  297           #
  298           # Work around macOS (and probably other Darwin) brokenness,
  299           # by not adding /usr/local/lib if it's from the broken
  300           # Apple pcap-config.
  301           #
  302           if(NOT _broken_apple_pcap_config OR
  303              NOT "${_dir}" STREQUAL /usr/local/lib)
  304             # Add this directory to CONFIG_PCAP_STATIC_LIBRARY_DIRS
  305             list(APPEND CONFIG_PCAP_STATIC_LIBRARY_DIRS ${_dir})
  306           endif()
  307         elseif(_arg MATCHES "^-l")
  308           string(REGEX REPLACE "-l" "" _lib ${_arg})
  309           #
  310           # Try to find that library, so we get its full path, as
  311           # we do with dynamic libraries.
  312           #
  313           list(APPEND CONFIG_PCAP_STATIC_LIBRARIES ${_lib})
  314         endif()
  315       endforeach()
  316 
  317       #
  318       # We've set CONFIG_PCAP_INCLUDE_DIRS, CONFIG_PCAP_LIBRARIES, and
  319       # CONFIG_PCAP_STATIC_LIBRARIES above; set CONFIG_PCAP_FOUND.
  320       #
  321       set(CONFIG_PCAP_FOUND YES)
  322     endif()
  323   endif()
  324 
  325   #
  326   # If CONFIG_PCAP_FOUND is set, we have information from pkg-config and
  327   # pcap-config; we need to convert library names to library full paths.
  328   #
  329   # If it's not set, we have to look for the libpcap headers and library
  330   # ourselves.
  331   #
  332   if(CONFIG_PCAP_FOUND)
  333     #
  334     # Use CONFIG_PCAP_INCLUDE_DIRS as the value for PCAP_INCLUDE_DIRS.
  335     #
  336     set(PCAP_INCLUDE_DIRS "${CONFIG_PCAP_INCLUDE_DIRS}")
  337 
  338     #
  339     # CMake *really* doesn't like the notion of specifying
  340     # "here are the directories in which to look for libraries"
  341     # except in find_library() calls; it *really* prefers using
  342     # full paths to library files, rather than library names.
  343     #
  344     foreach(_lib IN LISTS CONFIG_PCAP_LIBRARIES)
  345       find_library(_libfullpath ${_lib} HINTS ${CONFIG_PCAP_LIBRARY_DIRS})
  346       list(APPEND PCAP_LIBRARIES ${_libfullpath})
  347       #
  348       # Remove that from the cache; we're using it as a local variable,
  349       # but find_library insists on making it a cache variable.
  350       #
  351       unset(_libfullpath CACHE)
  352    endforeach()
  353 
  354     #
  355     # Now do the same for the static libraries.
  356     #
  357     set(SAVED_CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_FIND_LIBRARY_SUFFIXES}")
  358     set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
  359     foreach(_lib IN LISTS CONFIG_PCAP_STATIC_LIBRARIES)
  360       find_library(_libfullpath ${_lib} HINTS ${CONFIG_PCAP_LIBRARY_DIRS})
  361       list(APPEND PCAP_STATIC_LIBRARIES ${_libfullpath})
  362       #
  363       # Remove that from the cache; we're using it as a local variable,
  364       # but find_library insists on making it a cache variable.
  365       #
  366       unset(_libfullpath CACHE)
  367     endforeach()
  368     set(CMAKE_FIND_LIBRARY_SUFFIXES "${SAVED_CMAKE_FIND_LIBRARY_SUFFIXES}")
  369 
  370     #
  371     # We found libpcap using pkg-config or pcap-config.
  372     #
  373     set(PCAP_FOUND YES)
  374   else(CONFIG_PCAP_FOUND)
  375     #
  376     # We didn't have pkg-config, or we did but it didn't have .pc files
  377     # for libpcap, and we don't have pkg-config, so we have to look for
  378     # the headers and libraries ourself.
  379     #
  380     # We don't directly set PCAP_INCLUDE_DIRS or PCAP_LIBRARIES, as
  381     # they're not supposed to be cache entries, and find_path() and
  382     # find_library() set cache entries.
  383     #
  384     # Try to find the header file.
  385     #
  386     find_path(PCAP_INCLUDE_DIR pcap.h)
  387 
  388     #
  389     # Try to find the library
  390     #
  391     find_library(PCAP_LIBRARY pcap)
  392 
  393     # Try to find the static library (XXX - what about AIX?)
  394     set(SAVED_CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_FIND_LIBRARY_SUFFIXES}")
  395     set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
  396     find_library(PCAP_STATIC_LIBRARY pcap)
  397     set(CMAKE_FIND_LIBRARY_SUFFIXES "${SAVED_CMAKE_FIND_LIBRARY_SUFFIXES}")
  398 
  399     #
  400     # This will fail if REQUIRED is set and PCAP_INCLUDE_DIR or
  401     # PCAP_LIBRARY aren't set.
  402     #
  403     include(FindPackageHandleStandardArgs)
  404     find_package_handle_standard_args(PCAP
  405       DEFAULT_MSG
  406       PCAP_INCLUDE_DIR
  407       PCAP_LIBRARY
  408     )
  409 
  410     mark_as_advanced(
  411       PCAP_INCLUDE_DIR
  412       PCAP_LIBRARY
  413       PCAP_STATIC_LIBRARY
  414     )
  415 
  416     if(PCAP_FOUND)
  417       set(PCAP_INCLUDE_DIRS ${PCAP_INCLUDE_DIR})
  418       set(PCAP_LIBRARIES ${PCAP_LIBRARY})
  419       set(PCAP_STATIC_LIBRARIES ${PCAP_STATIC_LIBRARY})
  420     endif(PCAP_FOUND)
  421   endif(CONFIG_PCAP_FOUND)
  422 endif(WIN32)