# - `BROTLICOMMON_LIBRARY`: Absolute path to `brotlicommon` library.
# - `BROTLIDEC_LIBRARY`: Absolute path to `brotlidec` library.
#
-# Result variables:
+# Defines:
#
# - `BROTLI_FOUND`: System has brotli.
-# - `BROTLI_INCLUDE_DIRS`: The brotli include directories.
-# - `BROTLI_LIBRARIES`: The brotli library names.
-# - `BROTLI_LIBRARY_DIRS`: The brotli library directories.
-# - `BROTLI_PC_REQUIRES`: The brotli pkg-config packages.
-# - `BROTLI_CFLAGS`: Required compiler flags.
# - `BROTLI_VERSION`: Version of brotli.
+# - `CURL::brotli`: brotli library target.
-set(BROTLI_PC_REQUIRES "libbrotlidec" "libbrotlicommon") # order is significant: brotlidec then brotlicommon
+set(_brotli_pc_requires "libbrotlidec" "libbrotlicommon") # order is significant: brotlidec then brotlicommon
if(CURL_USE_PKGCONFIG AND
NOT DEFINED BROTLI_INCLUDE_DIR AND
NOT DEFINED BROTLICOMMON_LIBRARY AND
NOT DEFINED BROTLIDEC_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(BROTLI ${BROTLI_PC_REQUIRES})
+ pkg_check_modules(_brotli ${_brotli_pc_requires})
endif()
-if(BROTLI_FOUND)
+if(_brotli_FOUND)
set(Brotli_FOUND TRUE)
- set(BROTLI_VERSION ${BROTLI_libbrotlicommon_VERSION})
- string(REPLACE ";" " " BROTLI_CFLAGS "${BROTLI_CFLAGS}")
- message(STATUS "Found Brotli (via pkg-config): ${BROTLI_INCLUDE_DIRS} (found version \"${BROTLI_VERSION}\")")
+ set(BROTLI_FOUND TRUE)
+ set(BROTLI_VERSION ${_brotli_libbrotlicommon_VERSION})
+ message(STATUS "Found Brotli (via pkg-config): ${_brotli_INCLUDE_DIRS} (found version \"${BROTLI_VERSION}\")")
else()
find_path(BROTLI_INCLUDE_DIR "brotli/decode.h")
find_library(BROTLICOMMON_LIBRARY NAMES "brotlicommon")
)
if(BROTLI_FOUND)
- set(BROTLI_INCLUDE_DIRS ${BROTLI_INCLUDE_DIR})
- set(BROTLI_LIBRARIES ${BROTLIDEC_LIBRARY} ${BROTLICOMMON_LIBRARY})
+ set(_brotli_INCLUDE_DIRS ${BROTLI_INCLUDE_DIR})
+ set(_brotli_LIBRARIES ${BROTLIDEC_LIBRARY} ${BROTLICOMMON_LIBRARY})
endif()
mark_as_advanced(BROTLI_INCLUDE_DIR BROTLIDEC_LIBRARY BROTLICOMMON_LIBRARY)
endif()
+
+if(BROTLI_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_brotli_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::brotli)
+ add_library(CURL::brotli INTERFACE IMPORTED)
+ set_target_properties(CURL::brotli PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_brotli_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_brotli_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_brotli_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_brotli_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_brotli_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `CARES_INCLUDE_DIR`: Absolute path to c-ares include directory.
-# - `CARES_LIBRARY`: Absolute path to `cares` library.
+# - `CARES_INCLUDE_DIR`: Absolute path to c-ares include directory.
+# - `CARES_LIBRARY`: Absolute path to `cares` library.
#
-# Result variables:
+# Defines:
#
-# - `CARES_FOUND`: System has c-ares.
-# - `CARES_INCLUDE_DIRS`: The c-ares include directories.
-# - `CARES_LIBRARIES`: The c-ares library names.
-# - `CARES_LIBRARY_DIRS`: The c-ares library directories.
-# - `CARES_PC_REQUIRES`: The c-ares pkg-config packages.
-# - `CARES_CFLAGS`: Required compiler flags.
-# - `CARES_VERSION`: Version of c-ares.
+# - `CARES_FOUND`: System has c-ares.
+# - `CARES_VERSION`: Version of c-ares.
+# - `CURL::cares`: c-ares library target.
-set(CARES_PC_REQUIRES "libcares")
+set(_cares_pc_requires "libcares")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED CARES_INCLUDE_DIR AND
NOT DEFINED CARES_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(CARES ${CARES_PC_REQUIRES})
+ pkg_check_modules(_cares ${_cares_pc_requires})
endif()
-if(CARES_FOUND)
+if(_cares_FOUND)
set(Cares_FOUND TRUE)
- string(REPLACE ";" " " CARES_CFLAGS "${CARES_CFLAGS}")
- message(STATUS "Found Cares (via pkg-config): ${CARES_INCLUDE_DIRS} (found version \"${CARES_VERSION}\")")
+ set(CARES_FOUND TRUE)
+ set(CARES_VERSION ${_cares_VERSION})
+ message(STATUS "Found Cares (via pkg-config): ${_cares_INCLUDE_DIRS} (found version \"${CARES_VERSION}\")")
else()
find_path(CARES_INCLUDE_DIR NAMES "ares.h")
find_library(CARES_LIBRARY NAMES ${CARES_NAMES} "cares")
)
if(CARES_FOUND)
- set(CARES_INCLUDE_DIRS ${CARES_INCLUDE_DIR})
- set(CARES_LIBRARIES ${CARES_LIBRARY})
+ set(_cares_INCLUDE_DIRS ${CARES_INCLUDE_DIR})
+ set(_cares_LIBRARIES ${CARES_LIBRARY})
endif()
mark_as_advanced(CARES_INCLUDE_DIR CARES_LIBRARY)
endif()
-if(CARES_FOUND AND WIN32)
- list(APPEND CARES_LIBRARIES "iphlpapi") # for if_indextoname and others
+if(CARES_FOUND)
+ if(WIN32)
+ list(APPEND _cares_LIBRARIES "iphlpapi") # for if_indextoname and others
+ endif()
+
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_cares_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::cares)
+ add_library(CURL::cares INTERFACE IMPORTED)
+ set_target_properties(CURL::cares PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_cares_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_cares_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_cares_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_cares_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_cares_LIBRARIES}")
+ endif()
endif()
#
# Input variables:
#
-# - `GSS_ROOT_DIR`: Absolute path to the root installation of GSS. (also supported as environment)
+# - `GSS_ROOT_DIR`: Absolute path to the root installation of GSS. (also supported as environment)
#
-# Result variables:
+# Defines:
#
-# - `GSS_FOUND`: System has a GSS library.
-# - `GSS_FLAVOUR`: "GNU" or "MIT" if anything found.
-# - `GSS_INCLUDE_DIRS`: The GSS include directories.
-# - `GSS_LIBRARIES`: The GSS library names.
-# - `GSS_LIBRARY_DIRS`: The GSS library directories.
-# - `GSS_PC_REQUIRES`: The GSS pkg-config packages.
-# - `GSS_CFLAGS`: Required compiler flags.
-# - `GSS_VERSION`: This is set to version advertised by pkg-config or read from manifest.
-# In case the library is found but no version info available it is set to "unknown"
+# - `GSS_FOUND`: System has a GSS library.
+# - `GSS_VERSION`: This is set to version advertised by pkg-config or read from manifest.
+# In case the library is found but no version info available it is set to "unknown"
+# - `CURL::gss`: GSS library target.
+# - CURL_GSS_FLAVOUR`: Custom property. "GNU" or "MIT" if detected.
set(_gnu_modname "gss")
set(_mit_modname "mit-krb5-gssapi")
# Older versions may not have the "--vendor" parameter. In this case we just do not care.
if(NOT _gss_configure_failed AND NOT _gss_vendor MATCHES "Heimdal|heimdal")
- set(GSS_FLAVOUR "MIT") # assume a default, should not really matter
+ set(_gss_flavour "MIT") # assume a default, should not really matter
endif()
else() # Either there is no config script or we are on a platform that does not provide one (Windows?)
cmake_pop_check_state()
if(_gss_have_mit_headers)
- set(GSS_FLAVOUR "MIT")
+ set(_gss_flavour "MIT")
if(WIN32)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
list(APPEND _gss_libdir_suffixes "lib/AMD64")
find_path(_gss_INCLUDE_DIRS NAMES "gss.h" HINTS ${_gss_root_hints} PATH_SUFFIXES "include")
if(_gss_INCLUDE_DIRS)
- set(GSS_FLAVOUR "GNU")
- set(GSS_PC_REQUIRES ${_gnu_modname})
+ set(_gss_flavour "GNU")
+ set(_gss_pc_requires ${_gnu_modname})
set(_gss_libname "gss")
endif()
endif()
# If we have headers, look up libraries
- if(GSS_FLAVOUR)
+ if(_gss_flavour)
set(_gss_libdir_hints ${_gss_root_hints})
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
cmake_path(GET _gss_INCLUDE_DIRS PARENT_PATH _gss_calculated_potential_root)
find_library(_gss_LIBRARIES NAMES ${_gss_libname} HINTS ${_gss_libdir_hints} PATH_SUFFIXES ${_gss_libdir_suffixes})
endif()
endif()
- if(NOT GSS_FLAVOUR)
+ if(NOT _gss_flavour)
message(FATAL_ERROR "GNU or MIT GSS is required")
endif()
else()
# _gss_MODULE_NAME set since CMake 3.16.
# _pkg_check_modules_pkg_name is undocumented and used as a fallback for CMake <3.16 versions.
if(_gss_MODULE_NAME STREQUAL _gnu_modname OR _pkg_check_modules_pkg_name STREQUAL _gnu_modname)
- set(GSS_FLAVOUR "GNU")
- set(GSS_PC_REQUIRES ${_gnu_modname})
+ set(_gss_flavour "GNU")
+ set(_gss_pc_requires ${_gnu_modname})
elseif(_gss_MODULE_NAME STREQUAL _mit_modname OR _pkg_check_modules_pkg_name STREQUAL _mit_modname)
- set(GSS_FLAVOUR "MIT")
- set(GSS_PC_REQUIRES ${_mit_modname})
+ set(_gss_flavour "MIT")
+ set(_gss_pc_requires ${_mit_modname})
else()
message(FATAL_ERROR "GNU or MIT GSS is required")
endif()
- message(STATUS "Found GSS/${GSS_FLAVOUR} (via pkg-config): ${_gss_INCLUDE_DIRS} (found version \"${_gss_version}\")")
+ message(STATUS "Found GSS/${_gss_flavour} (via pkg-config): ${_gss_INCLUDE_DIRS} (found version \"${_gss_version}\")")
endif()
-string(REPLACE ";" " " _gss_CFLAGS "${_gss_CFLAGS}")
-
-set(GSS_INCLUDE_DIRS ${_gss_INCLUDE_DIRS})
-set(GSS_LIBRARIES ${_gss_LIBRARIES})
-set(GSS_LIBRARY_DIRS ${_gss_LIBRARY_DIRS})
-set(GSS_CFLAGS ${_gss_CFLAGS})
set(GSS_VERSION ${_gss_version})
if(NOT GSS_VERSION)
- if(GSS_FLAVOUR STREQUAL "MIT")
+ if(_gss_flavour STREQUAL "MIT")
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.24)
cmake_host_system_information(RESULT _mit_version QUERY WINDOWS_REGISTRY
"HKLM/SOFTWARE/MIT/Kerberos/SDK/CurrentVersion" VALUE "VersionString")
set(GSS_VERSION "MIT Unknown")
endif()
else() # GNU
- if(GSS_INCLUDE_DIRS AND EXISTS "${GSS_INCLUDE_DIRS}/gss.h")
+ if(_gss_INCLUDE_DIRS AND EXISTS "${_gss_INCLUDE_DIRS}/gss.h")
set(_version_regex "#[\t ]*define[\t ]+GSS_VERSION[\t ]+\"([^\"]*)\"")
- file(STRINGS "${GSS_INCLUDE_DIRS}/gss.h" _version_str REGEX "${_version_regex}")
+ file(STRINGS "${_gss_INCLUDE_DIRS}/gss.h" _version_str REGEX "${_version_regex}")
string(REGEX REPLACE "${_version_regex}" "\\1" _version_str "${_version_str}")
set(GSS_VERSION "${_version_str}")
unset(_version_regex)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(GSS
REQUIRED_VARS
- GSS_FLAVOUR
- GSS_LIBRARIES
+ _gss_flavour
+ _gss_LIBRARIES
VERSION_VAR
GSS_VERSION
FAIL_MESSAGE
_gss_PREFIX
_gss_version
)
+
+if(GSS_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_gss_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::gss)
+ add_library(CURL::gss INTERFACE IMPORTED)
+ set_target_properties(CURL::gss PROPERTIES
+ INTERFACE_CURL_GSS_FLAVOUR "${_gss_flavour}"
+ INTERFACE_LIBCURL_PC_MODULES "${_gss_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_gss_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_gss_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_gss_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_gss_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `GNUTLS_INCLUDE_DIR`: Absolute path to GnuTLS include directory.
-# - `GNUTLS_LIBRARY`: Absolute path to `gnutls` library.
+# - `GNUTLS_INCLUDE_DIR`: Absolute path to GnuTLS include directory.
+# - `GNUTLS_LIBRARY`: Absolute path to `gnutls` library.
#
-# Result variables:
+# Defines:
#
-# - `GNUTLS_FOUND`: System has GnuTLS.
-# - `GNUTLS_INCLUDE_DIRS`: The GnuTLS include directories.
-# - `GNUTLS_LIBRARIES`: The GnuTLS library names.
-# - `GNUTLS_LIBRARY_DIRS`: The GnuTLS library directories.
-# - `GNUTLS_PC_REQUIRES`: The GnuTLS pkg-config packages.
-# - `GNUTLS_CFLAGS`: Required compiler flags.
-# - `GNUTLS_VERSION`: Version of GnuTLS.
+# - `GNUTLS_FOUND`: System has GnuTLS.
+# - `GNUTLS_VERSION`: Version of GnuTLS.
+# - `CURL::gnutls`: GnuTLS library target.
-set(GNUTLS_PC_REQUIRES "gnutls")
+set(_gnutls_pc_requires "gnutls")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED GNUTLS_INCLUDE_DIR AND
NOT DEFINED GNUTLS_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(GNUTLS ${GNUTLS_PC_REQUIRES})
+ pkg_check_modules(_gnutls ${_gnutls_pc_requires})
endif()
-if(GNUTLS_FOUND)
+if(_gnutls_FOUND)
set(GnuTLS_FOUND TRUE)
- string(REPLACE ";" " " GNUTLS_CFLAGS "${GNUTLS_CFLAGS}")
- message(STATUS "Found GnuTLS (via pkg-config): ${GNUTLS_INCLUDE_DIRS} (found version \"${GNUTLS_VERSION}\")")
+ set(GNUTLS_FOUND TRUE)
+ set(GNUTLS_VERSION ${_gnutls_VERSION})
+ message(STATUS "Found GnuTLS (via pkg-config): ${_gnutls_INCLUDE_DIRS} (found version \"${GNUTLS_VERSION}\")")
else()
find_path(GNUTLS_INCLUDE_DIR NAMES "gnutls/gnutls.h")
find_library(GNUTLS_LIBRARY NAMES "gnutls" "libgnutls")
)
if(GNUTLS_FOUND)
- set(GNUTLS_INCLUDE_DIRS ${GNUTLS_INCLUDE_DIR})
- set(GNUTLS_LIBRARIES ${GNUTLS_LIBRARY})
+ set(_gnutls_INCLUDE_DIRS ${GNUTLS_INCLUDE_DIR})
+ set(_gnutls_LIBRARIES ${GNUTLS_LIBRARY})
endif()
mark_as_advanced(GNUTLS_INCLUDE_DIR GNUTLS_LIBRARY)
endif()
+
+if(GNUTLS_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_gnutls_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::gnutls)
+ add_library(CURL::gnutls INTERFACE IMPORTED)
+ set_target_properties(CURL::gnutls PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_gnutls_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_gnutls_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_gnutls_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_gnutls_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_gnutls_LIBRARIES}")
+ endif()
+endif()
# - `LDAP_LIBRARY`: Absolute path to `ldap` library.
# - `LDAP_LBER_LIBRARY`: Absolute path to `lber` library.
#
-# Result variables:
+# Defines:
#
# - `LDAP_FOUND`: System has ldap.
-# - `LDAP_INCLUDE_DIRS`: The ldap include directories.
-# - `LDAP_LIBRARIES`: The ldap library names.
-# - `LDAP_LIBRARY_DIRS`: The ldap library directories.
-# - `LDAP_PC_REQUIRES`: The ldap pkg-config packages.
-# - `LDAP_CFLAGS`: Required compiler flags.
# - `LDAP_VERSION`: Version of ldap.
+# - `CURL::ldap`: ldap library target.
-set(LDAP_PC_REQUIRES "ldap" "lber")
+set(_ldap_pc_requires "ldap" "lber")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED LDAP_INCLUDE_DIR AND
NOT DEFINED LDAP_LIBRARY AND
NOT DEFINED LDAP_LBER_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(LDAP ${LDAP_PC_REQUIRES})
+ pkg_check_modules(_ldap ${_ldap_pc_requires})
endif()
-if(LDAP_FOUND)
- set(LDAP_VERSION ${LDAP_ldap_VERSION})
- string(REPLACE ";" " " LDAP_CFLAGS "${LDAP_CFLAGS}")
- message(STATUS "Found LDAP (via pkg-config): ${LDAP_INCLUDE_DIRS} (found version \"${LDAP_VERSION}\")")
+if(_ldap_FOUND)
+ set(LDAP_FOUND TRUE)
+ set(LDAP_VERSION ${_ldap_ldap_VERSION})
+ message(STATUS "Found LDAP (via pkg-config): ${_ldap_INCLUDE_DIRS} (found version \"${LDAP_VERSION}\")")
else()
- set(LDAP_PC_REQUIRES "") # Depend on pkg-config only when found via pkg-config
+ set(_ldap_pc_requires "") # Depend on pkg-config only when found via pkg-config
# On Apple the SDK LDAP gets picked up from
# 'MacOSX.sdk/System/Library/Frameworks/LDAP.framework/Headers', which contains
)
if(LDAP_FOUND)
- set(LDAP_INCLUDE_DIRS ${LDAP_INCLUDE_DIR})
- set(LDAP_LIBRARIES ${LDAP_LIBRARY} ${LDAP_LBER_LIBRARY})
+ set(_ldap_INCLUDE_DIRS ${LDAP_INCLUDE_DIR})
+ set(_ldap_LIBRARIES ${LDAP_LIBRARY} ${LDAP_LBER_LIBRARY})
endif()
mark_as_advanced(LDAP_INCLUDE_DIR LDAP_LIBRARY LDAP_LBER_LIBRARY)
endif()
+
+if(LDAP_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_ldap_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::ldap)
+ add_library(CURL::ldap INTERFACE IMPORTED)
+ set_target_properties(CURL::ldap PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_ldap_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_ldap_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_ldap_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_ldap_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_ldap_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `LIBBACKTRACE_INCLUDE_DIR`: Absolute path to libbacktrace include directory.
-# - `LIBBACKTRACE_LIBRARY`: Absolute path to `libbacktrace` library.
+# - `LIBBACKTRACE_INCLUDE_DIR`: Absolute path to libbacktrace include directory.
+# - `LIBBACKTRACE_LIBRARY`: Absolute path to `libbacktrace` library.
#
-# Result variables:
+# Defines:
#
-# - `LIBBACKTRACE_FOUND`: System has libbacktrace.
-# - `LIBBACKTRACE_INCLUDE_DIRS`: The libbacktrace include directories.
-# - `LIBBACKTRACE_LIBRARIES`: The libbacktrace library names.
+# - `LIBBACKTRACE_FOUND`: System has libbacktrace.
+# - `CURL::libbacktrace`: libbacktrace library target.
find_path(LIBBACKTRACE_INCLUDE_DIR NAMES "backtrace.h")
find_library(LIBBACKTRACE_LIBRARY NAMES "backtrace" "libbacktrace")
)
if(LIBBACKTRACE_FOUND)
- set(LIBBACKTRACE_INCLUDE_DIRS ${LIBBACKTRACE_INCLUDE_DIR})
- set(LIBBACKTRACE_LIBRARIES ${LIBBACKTRACE_LIBRARY})
+ set(_libbacktrace_INCLUDE_DIRS ${LIBBACKTRACE_INCLUDE_DIR})
+ set(_libbacktrace_LIBRARIES ${LIBBACKTRACE_LIBRARY})
+
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_libbacktrace_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::libbacktrace)
+ add_library(CURL::libbacktrace INTERFACE IMPORTED)
+ set_target_properties(CURL::libbacktrace PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_libbacktrace_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_libbacktrace_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_libbacktrace_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_libbacktrace_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_libbacktrace_LIBRARIES}")
+ endif()
endif()
mark_as_advanced(LIBBACKTRACE_INCLUDE_DIR LIBBACKTRACE_LIBRARY)
#
# Input variables:
#
-# - `LIBGSASL_INCLUDE_DIR`: Absolute path to libgsasl include directory.
-# - `LIBGSASL_LIBRARY`: Absolute path to `libgsasl` library.
+# - `LIBGSASL_INCLUDE_DIR`: Absolute path to libgsasl include directory.
+# - `LIBGSASL_LIBRARY`: Absolute path to `libgsasl` library.
#
-# Result variables:
+# Defines:
#
-# - `LIBGSASL_FOUND`: System has libgsasl.
-# - `LIBGSASL_INCLUDE_DIRS`: The libgsasl include directories.
-# - `LIBGSASL_LIBRARIES`: The libgsasl library names.
-# - `LIBGSASL_LIBRARY_DIRS`: The libgsasl library directories.
-# - `LIBGSASL_PC_REQUIRES`: The libgsasl pkg-config packages.
-# - `LIBGSASL_CFLAGS`: Required compiler flags.
-# - `LIBGSASL_VERSION`: Version of libgsasl.
+# - `LIBGSASL_FOUND`: System has libgsasl.
+# - `LIBGSASL_VERSION`: Version of libgsasl.
+# - `CURL::libgsasl`: libgsasl library target.
-set(LIBGSASL_PC_REQUIRES "libgsasl")
+set(_libgsasl_pc_requires "libgsasl")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED LIBGSASL_INCLUDE_DIR AND
NOT DEFINED LIBGSASL_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(LIBGSASL ${LIBGSASL_PC_REQUIRES})
+ pkg_check_modules(_libgsasl ${_libgsasl_pc_requires})
endif()
-if(LIBGSASL_FOUND)
+if(_libgsasl_FOUND)
set(Libgsasl_FOUND TRUE)
- string(REPLACE ";" " " LIBGSASL_CFLAGS "${LIBGSASL_CFLAGS}")
- message(STATUS "Found Libgsasl (via pkg-config): ${LIBGSASL_INCLUDE_DIRS} (found version \"${LIBGSASL_VERSION}\")")
+ set(LIBGSASL_FOUND TRUE)
+ message(STATUS "Found Libgsasl (via pkg-config): ${_libgsasl_INCLUDE_DIRS} (found version \"${LIBGSASL_VERSION}\")")
else()
find_path(LIBGSASL_INCLUDE_DIR NAMES "gsasl.h")
find_library(LIBGSASL_LIBRARY NAMES "gsasl" "libgsasl")
)
if(LIBGSASL_FOUND)
- set(LIBGSASL_INCLUDE_DIRS ${LIBGSASL_INCLUDE_DIR})
- set(LIBGSASL_LIBRARIES ${LIBGSASL_LIBRARY})
+ set(_libgsasl_INCLUDE_DIRS ${LIBGSASL_INCLUDE_DIR})
+ set(_libgsasl_LIBRARIES ${LIBGSASL_LIBRARY})
endif()
mark_as_advanced(LIBGSASL_INCLUDE_DIR LIBGSASL_LIBRARY)
endif()
+
+if(LIBGSASL_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_libgsasl_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::libgsasl)
+ add_library(CURL::libgsasl INTERFACE IMPORTED)
+ set_target_properties(CURL::libgsasl PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_libgsasl_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_libgsasl_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_libgsasl_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_libgsasl_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_libgsasl_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `LIBIDN2_INCLUDE_DIR`: Absolute path to libidn2 include directory.
-# - `LIBIDN2_LIBRARY`: Absolute path to `libidn2` library.
+# - `LIBIDN2_INCLUDE_DIR`: Absolute path to libidn2 include directory.
+# - `LIBIDN2_LIBRARY`: Absolute path to `libidn2` library.
#
-# Result variables:
+# Defines:
#
-# - `LIBIDN2_FOUND`: System has libidn2.
-# - `LIBIDN2_INCLUDE_DIRS`: The libidn2 include directories.
-# - `LIBIDN2_LIBRARIES`: The libidn2 library names.
-# - `LIBIDN2_LIBRARY_DIRS`: The libidn2 library directories.
-# - `LIBIDN2_PC_REQUIRES`: The libidn2 pkg-config packages.
-# - `LIBIDN2_CFLAGS`: Required compiler flags.
-# - `LIBIDN2_VERSION`: Version of libidn2.
+# - `LIBIDN2_FOUND`: System has libidn2.
+# - `LIBIDN2_VERSION`: Version of libidn2.
+# - `CURL::libidn2`: libidn2 library target.
-set(LIBIDN2_PC_REQUIRES "libidn2")
+set(_libidn2_pc_requires "libidn2")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED LIBIDN2_INCLUDE_DIR AND
NOT DEFINED LIBIDN2_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(LIBIDN2 ${LIBIDN2_PC_REQUIRES})
+ pkg_check_modules(_libidn2 ${_libidn2_pc_requires})
endif()
-if(LIBIDN2_FOUND)
+if(_libidn2_FOUND)
set(Libidn2_FOUND TRUE)
- string(REPLACE ";" " " LIBIDN2_CFLAGS "${LIBIDN2_CFLAGS}")
- message(STATUS "Found Libidn2 (via pkg-config): ${LIBIDN2_INCLUDE_DIRS} (found version \"${LIBIDN2_VERSION}\")")
+ set(LIBIDN2_FOUND TRUE)
+ set(LIBIDN2_VERSION ${_libidn2_VERSION})
+ message(STATUS "Found Libidn2 (via pkg-config): ${_libidn2_INCLUDE_DIRS} (found version \"${LIBIDN2_VERSION}\")")
else()
find_path(LIBIDN2_INCLUDE_DIR NAMES "idn2.h")
find_library(LIBIDN2_LIBRARY NAMES "idn2" "libidn2")
)
if(LIBIDN2_FOUND)
- set(LIBIDN2_INCLUDE_DIRS ${LIBIDN2_INCLUDE_DIR})
- set(LIBIDN2_LIBRARIES ${LIBIDN2_LIBRARY})
+ set(_libidn2_INCLUDE_DIRS ${LIBIDN2_INCLUDE_DIR})
+ set(_libidn2_LIBRARIES ${LIBIDN2_LIBRARY})
endif()
mark_as_advanced(LIBIDN2_INCLUDE_DIR LIBIDN2_LIBRARY)
endif()
+
+if(LIBIDN2_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_libidn2_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::libidn2)
+ add_library(CURL::libidn2 INTERFACE IMPORTED)
+ set_target_properties(CURL::libidn2 PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_libidn2_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_libidn2_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_libidn2_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_libidn2_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_libidn2_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `LIBPSL_INCLUDE_DIR`: Absolute path to libpsl include directory.
-# - `LIBPSL_LIBRARY`: Absolute path to `libpsl` library.
+# - `LIBPSL_INCLUDE_DIR`: Absolute path to libpsl include directory.
+# - `LIBPSL_LIBRARY`: Absolute path to `libpsl` library.
#
-# Result variables:
+# Defines:
#
-# - `LIBPSL_FOUND`: System has libpsl.
-# - `LIBPSL_INCLUDE_DIRS`: The libpsl include directories.
-# - `LIBPSL_LIBRARIES`: The libpsl library names.
-# - `LIBPSL_LIBRARY_DIRS`: The libpsl library directories.
-# - `LIBPSL_PC_REQUIRES`: The libpsl pkg-config packages.
-# - `LIBPSL_CFLAGS`: Required compiler flags.
-# - `LIBPSL_VERSION`: Version of libpsl.
+# - `LIBPSL_FOUND`: System has libpsl.
+# - `LIBPSL_VERSION`: Version of libpsl.
+# - `CURL::libpsl`: libpsl library target.
-set(LIBPSL_PC_REQUIRES "libpsl")
+set(_libpsl_pc_requires "libpsl")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED LIBPSL_INCLUDE_DIR AND
NOT DEFINED LIBPSL_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(LIBPSL ${LIBPSL_PC_REQUIRES})
+ pkg_check_modules(_libpsl ${_libpsl_pc_requires})
endif()
-if(LIBPSL_FOUND AND LIBPSL_INCLUDE_DIRS)
+if(_libpsl_FOUND AND _libpsl_INCLUDE_DIRS)
set(Libpsl_FOUND TRUE)
- string(REPLACE ";" " " LIBPSL_CFLAGS "${LIBPSL_CFLAGS}")
- message(STATUS "Found Libpsl (via pkg-config): ${LIBPSL_INCLUDE_DIRS} (found version \"${LIBPSL_VERSION}\")")
+ set(LIBPSL_FOUND TRUE)
+ set(LIBPSL_VERSION ${_libpsl_VERSION})
+ message(STATUS "Found Libpsl (via pkg-config): ${_libpsl_INCLUDE_DIRS} (found version \"${LIBPSL_VERSION}\")")
else()
find_path(LIBPSL_INCLUDE_DIR NAMES "libpsl.h")
find_library(LIBPSL_LIBRARY NAMES "psl" "libpsl")
)
if(LIBPSL_FOUND)
- set(LIBPSL_INCLUDE_DIRS ${LIBPSL_INCLUDE_DIR})
- set(LIBPSL_LIBRARIES ${LIBPSL_LIBRARY})
+ set(_libpsl_INCLUDE_DIRS ${LIBPSL_INCLUDE_DIR})
+ set(_libpsl_LIBRARIES ${LIBPSL_LIBRARY})
endif()
mark_as_advanced(LIBPSL_INCLUDE_DIR LIBPSL_LIBRARY)
endif()
+
+if(LIBPSL_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_libpsl_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::libpsl)
+ add_library(CURL::libpsl INTERFACE IMPORTED)
+ set_target_properties(CURL::libpsl PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_libpsl_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_libpsl_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_libpsl_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_libpsl_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_libpsl_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `LIBRTMP_INCLUDE_DIR`: Absolute path to librtmp include directory.
-# - `LIBRTMP_LIBRARY`: Absolute path to `librtmp` library.
+# - `LIBRTMP_INCLUDE_DIR`: Absolute path to librtmp include directory.
+# - `LIBRTMP_LIBRARY`: Absolute path to `librtmp` library.
#
-# Result variables:
+# Defines:
#
-# - `LIBRTMP_FOUND`: System has librtmp.
-# - `LIBRTMP_INCLUDE_DIRS`: The librtmp include directories.
-# - `LIBRTMP_LIBRARIES`: The librtmp library names.
-# - `LIBRTMP_LIBRARY_DIRS`: The librtmp library directories.
-# - `LIBRTMP_PC_REQUIRES`: The librtmp pkg-config packages.
-# - `LIBRTMP_CFLAGS`: Required compiler flags.
-# - `LIBRTMP_VERSION`: Version of librtmp.
+# - `LIBRTMP_FOUND`: System has librtmp.
+# - `LIBRTMP_VERSION`: Version of librtmp.
+# - `CURL::librtmp`: librtmp library target.
-set(LIBRTMP_PC_REQUIRES "librtmp")
+set(_librtmp_pc_requires "librtmp")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED LIBRTMP_INCLUDE_DIR AND
NOT DEFINED LIBRTMP_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(LIBRTMP ${LIBRTMP_PC_REQUIRES})
+ pkg_check_modules(_librtmp ${_librtmp_pc_requires})
endif()
-if(LIBRTMP_FOUND AND LIBRTMP_INCLUDE_DIRS)
+if(_librtmp_FOUND AND _librtmp_INCLUDE_DIRS)
set(Librtmp_FOUND TRUE)
- string(REPLACE ";" " " LIBRTMP_CFLAGS "${LIBRTMP_CFLAGS}")
- message(STATUS "Found Librtmp (via pkg-config): ${LIBRTMP_INCLUDE_DIRS} (found version \"${LIBRTMP_VERSION}\")")
+ set(LIBRTMP_FOUND TRUE)
+ set(LIBRTMP_VERSION ${_librtmp_VERSION})
+ message(STATUS "Found Librtmp (via pkg-config): ${_librtmp_INCLUDE_DIRS} (found version \"${LIBRTMP_VERSION}\")")
else()
find_path(LIBRTMP_INCLUDE_DIR NAMES "librtmp/rtmp.h")
find_library(LIBRTMP_LIBRARY NAMES "rtmp")
)
if(LIBRTMP_FOUND)
- set(LIBRTMP_INCLUDE_DIRS ${LIBRTMP_INCLUDE_DIR})
- set(LIBRTMP_LIBRARIES ${LIBRTMP_LIBRARY})
+ set(_librtmp_INCLUDE_DIRS ${LIBRTMP_INCLUDE_DIR})
+ set(_librtmp_LIBRARIES ${LIBRTMP_LIBRARY})
endif()
mark_as_advanced(LIBRTMP_INCLUDE_DIR LIBRTMP_LIBRARY)
# Necessary when linking a static librtmp
find_package(OpenSSL)
if(OPENSSL_FOUND)
- list(APPEND LIBRTMP_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
+ list(APPEND _librtmp_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
endif()
endif()
-if(LIBRTMP_FOUND AND WIN32)
- list(APPEND LIBRTMP_LIBRARIES "winmm")
+if(LIBRTMP_FOUND)
+ if(WIN32)
+ list(APPEND _librtmp_LIBRARIES "winmm")
+ endif()
+
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_librtmp_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::librtmp)
+ add_library(CURL::librtmp INTERFACE IMPORTED)
+ set_target_properties(CURL::librtmp PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_librtmp_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_librtmp_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_librtmp_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_librtmp_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_librtmp_LIBRARIES}")
+ endif()
endif()
#
# Input variables:
#
-# - `LIBSSH_INCLUDE_DIR`: Absolute path to libssh include directory.
-# - `LIBSSH_LIBRARY`: Absolute path to `libssh` library.
+# - `LIBSSH_INCLUDE_DIR`: Absolute path to libssh include directory.
+# - `LIBSSH_LIBRARY`: Absolute path to `libssh` library.
#
-# Result variables:
+# Defines:
#
-# - `LIBSSH_FOUND`: System has libssh.
-# - `LIBSSH_INCLUDE_DIRS`: The libssh include directories.
-# - `LIBSSH_LIBRARIES`: The libssh library names.
-# - `LIBSSH_LIBRARY_DIRS`: The libssh library directories.
-# - `LIBSSH_PC_REQUIRES`: The libssh pkg-config packages.
-# - `LIBSSH_CFLAGS`: Required compiler flags.
-# - `LIBSSH_VERSION`: Version of libssh.
+# - `LIBSSH_FOUND`: System has libssh.
+# - `LIBSSH_VERSION`: Version of libssh.
+# - `CURL::libssh`: libssh library target.
-set(LIBSSH_PC_REQUIRES "libssh")
+set(_libssh_pc_requires "libssh")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED LIBSSH_INCLUDE_DIR AND
NOT DEFINED LIBSSH_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(LIBSSH ${LIBSSH_PC_REQUIRES})
+ pkg_check_modules(_libssh ${_libssh_pc_requires})
endif()
-if(LIBSSH_FOUND)
+if(_libssh_FOUND)
set(Libssh_FOUND TRUE)
- string(REPLACE ";" " " LIBSSH_CFLAGS "${LIBSSH_CFLAGS}")
- message(STATUS "Found Libssh (via pkg-config): ${LIBSSH_INCLUDE_DIRS} (found version \"${LIBSSH_VERSION}\")")
+ set(LIBSSH_FOUND TRUE)
+ set(LIBSSH_VERSION ${_libssh_VERSION})
+ message(STATUS "Found Libssh (via pkg-config): ${_libssh_INCLUDE_DIRS} (found version \"${LIBSSH_VERSION}\")")
else()
find_path(LIBSSH_INCLUDE_DIR NAMES "libssh/libssh.h")
find_library(LIBSSH_LIBRARY NAMES "ssh" "libssh")
)
if(LIBSSH_FOUND)
- set(LIBSSH_INCLUDE_DIRS ${LIBSSH_INCLUDE_DIR})
- set(LIBSSH_LIBRARIES ${LIBSSH_LIBRARY})
+ set(_libssh_INCLUDE_DIRS ${LIBSSH_INCLUDE_DIR})
+ set(_libssh_LIBRARIES ${LIBSSH_LIBRARY})
endif()
mark_as_advanced(LIBSSH_INCLUDE_DIR LIBSSH_LIBRARY)
endif()
-if(LIBSSH_FOUND AND WIN32)
- list(APPEND LIBSSH_LIBRARIES "iphlpapi") # for if_nametoindex
+if(LIBSSH_FOUND)
+ if(WIN32)
+ list(APPEND _libssh_LIBRARIES "iphlpapi") # for if_nametoindex
+ endif()
+
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_libssh_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::libssh)
+ add_library(CURL::libssh INTERFACE IMPORTED)
+ set_target_properties(CURL::libssh PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_libssh_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_libssh_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_libssh_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_libssh_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_libssh_LIBRARIES}")
+ endif()
endif()
#
# Input variables:
#
-# - `LIBSSH2_INCLUDE_DIR`: Absolute path to libssh2 include directory.
-# - `LIBSSH2_LIBRARY`: Absolute path to `libssh2` library.
+# - `LIBSSH2_INCLUDE_DIR`: Absolute path to libssh2 include directory.
+# - `LIBSSH2_LIBRARY`: Absolute path to `libssh2` library.
#
-# Result variables:
+# Defines:
#
-# - `LIBSSH2_FOUND`: System has libssh2.
-# - `LIBSSH2_INCLUDE_DIRS`: The libssh2 include directories.
-# - `LIBSSH2_LIBRARIES`: The libssh2 library names.
-# - `LIBSSH2_LIBRARY_DIRS`: The libssh2 library directories.
-# - `LIBSSH2_PC_REQUIRES`: The libssh2 pkg-config packages.
-# - `LIBSSH2_CFLAGS`: Required compiler flags.
-# - `LIBSSH2_VERSION`: Version of libssh2.
+# - `LIBSSH2_FOUND`: System has libssh2.
+# - `LIBSSH2_VERSION`: Version of libssh2.
+# - `CURL::libssh2`: libssh2 library target.
-set(LIBSSH2_PC_REQUIRES "libssh2")
+set(_libssh2_pc_requires "libssh2")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED LIBSSH2_INCLUDE_DIR AND
NOT DEFINED LIBSSH2_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(LIBSSH2 ${LIBSSH2_PC_REQUIRES})
+ pkg_check_modules(_libssh2 ${_libssh2_pc_requires})
endif()
-if(LIBSSH2_FOUND AND LIBSSH2_INCLUDE_DIRS)
+if(_libssh2_FOUND AND _libssh2_INCLUDE_DIRS)
set(Libssh2_FOUND TRUE)
- string(REPLACE ";" " " LIBSSH2_CFLAGS "${LIBSSH2_CFLAGS}")
- message(STATUS "Found Libssh2 (via pkg-config): ${LIBSSH2_INCLUDE_DIRS} (found version \"${LIBSSH2_VERSION}\")")
+ set(LIBSSH2_FOUND TRUE)
+ set(LIBSSH2_VERSION ${_libssh2_VERSION})
+ message(STATUS "Found Libssh2 (via pkg-config): ${_libssh2_INCLUDE_DIRS} (found version \"${LIBSSH2_VERSION}\")")
else()
find_path(LIBSSH2_INCLUDE_DIR NAMES "libssh2.h")
find_library(LIBSSH2_LIBRARY NAMES "ssh2" "libssh2")
)
if(LIBSSH2_FOUND)
- set(LIBSSH2_INCLUDE_DIRS ${LIBSSH2_INCLUDE_DIR})
- set(LIBSSH2_LIBRARIES ${LIBSSH2_LIBRARY})
+ set(_libssh2_INCLUDE_DIRS ${LIBSSH2_INCLUDE_DIR})
+ set(_libssh2_LIBRARIES ${LIBSSH2_LIBRARY})
endif()
mark_as_advanced(LIBSSH2_INCLUDE_DIR LIBSSH2_LIBRARY)
endif()
+
+if(LIBSSH2_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_libssh2_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::libssh2)
+ add_library(CURL::libssh2 INTERFACE IMPORTED)
+ set_target_properties(CURL::libssh2 PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_libssh2_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_libssh2_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_libssh2_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_libssh2_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_libssh2_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `LIBUV_INCLUDE_DIR`: Absolute path to libuv include directory.
-# - `LIBUV_LIBRARY`: Absolute path to `libuv` library.
+# - `LIBUV_INCLUDE_DIR`: Absolute path to libuv include directory.
+# - `LIBUV_LIBRARY`: Absolute path to `libuv` library.
#
-# Result variables:
+# Defines:
#
-# - `LIBUV_FOUND`: System has libuv.
-# - `LIBUV_INCLUDE_DIRS`: The libuv include directories.
-# - `LIBUV_LIBRARIES`: The libuv library names.
-# - `LIBUV_LIBRARY_DIRS`: The libuv library directories.
-# - `LIBUV_PC_REQUIRES`: The libuv pkg-config packages.
-# - `LIBUV_CFLAGS`: Required compiler flags.
-# - `LIBUV_VERSION`: Version of libuv.
+# - `LIBUV_FOUND`: System has libuv.
+# - `LIBUV_VERSION`: Version of libuv.
+# - `CURL::libuv`: libuv library target.
-set(LIBUV_PC_REQUIRES "libuv")
+set(_libuv_pc_requires "libuv")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED LIBUV_INCLUDE_DIR AND
NOT DEFINED LIBUV_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(LIBUV ${LIBUV_PC_REQUIRES})
+ pkg_check_modules(_libuv ${_libuv_pc_requires})
endif()
-if(LIBUV_FOUND)
+if(_libuv_FOUND)
set(Libuv_FOUND TRUE)
- string(REPLACE ";" " " LIBUV_CFLAGS "${LIBUV_CFLAGS}")
- message(STATUS "Found Libuv (via pkg-config): ${LIBUV_INCLUDE_DIRS} (found version \"${LIBUV_VERSION}\")")
+ set(LIBUV_FOUND TRUE)
+ set(LIBUV_VERSION ${_libuv_VERSION})
+ message(STATUS "Found Libuv (via pkg-config): ${_libuv_INCLUDE_DIRS} (found version \"${LIBUV_VERSION}\")")
else()
find_path(LIBUV_INCLUDE_DIR NAMES "uv.h")
find_library(LIBUV_LIBRARY NAMES "uv" "libuv")
)
if(LIBUV_FOUND)
- set(LIBUV_INCLUDE_DIRS ${LIBUV_INCLUDE_DIR})
- set(LIBUV_LIBRARIES ${LIBUV_LIBRARY})
+ set(_libuv_INCLUDE_DIRS ${LIBUV_INCLUDE_DIR})
+ set(_libuv_LIBRARIES ${LIBUV_LIBRARY})
endif()
mark_as_advanced(LIBUV_INCLUDE_DIR LIBUV_LIBRARY)
endif()
+
+if(LIBUV_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_libuv_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::libuv)
+ add_library(CURL::libuv INTERFACE IMPORTED)
+ set_target_properties(CURL::libuv PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_libuv_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_libuv_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_libuv_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_libuv_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_libuv_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `MBEDTLS_INCLUDE_DIR`: Absolute path to mbedTLS include directory.
-# - `MBEDTLS_LIBRARY`: Absolute path to `mbedtls` library.
-# - `MBEDX509_LIBRARY`: Absolute path to `mbedx509` library.
-# - `MBEDCRYPTO_LIBRARY`: Absolute path to `mbedcrypto` library.
+# - `MBEDTLS_INCLUDE_DIR`: Absolute path to mbedTLS include directory.
+# - `MBEDTLS_LIBRARY`: Absolute path to `mbedtls` library.
+# - `MBEDX509_LIBRARY`: Absolute path to `mbedx509` library.
+# - `MBEDCRYPTO_LIBRARY`: Absolute path to `mbedcrypto` library.
#
-# Result variables:
+# Defines:
#
-# - `MBEDTLS_FOUND`: System has mbedTLS.
-# - `MBEDTLS_INCLUDE_DIRS`: The mbedTLS include directories.
-# - `MBEDTLS_LIBRARIES`: The mbedTLS library names.
-# - `MBEDTLS_LIBRARY_DIRS`: The mbedTLS library directories.
-# - `MBEDTLS_PC_REQUIRES`: The mbedTLS pkg-config packages.
-# - `MBEDTLS_CFLAGS`: Required compiler flags.
-# - `MBEDTLS_VERSION`: Version of mbedTLS.
+# - `MBEDTLS_FOUND`: System has mbedTLS.
+# - `MBEDTLS_VERSION`: Version of mbedTLS.
+# - `CURL::mbedtls`: mbedTLS library target.
if(DEFINED MBEDTLS_INCLUDE_DIRS AND NOT DEFINED MBEDTLS_INCLUDE_DIR)
message(WARNING "MBEDTLS_INCLUDE_DIRS is deprecated, use MBEDTLS_INCLUDE_DIR instead.")
unset(MBEDTLS_INCLUDE_DIRS)
endif()
-set(MBEDTLS_PC_REQUIRES "mbedtls" "mbedx509" "mbedcrypto")
+set(_mbedtls_pc_requires "mbedtls" "mbedx509" "mbedcrypto")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED MBEDTLS_INCLUDE_DIR AND
NOT DEFINED MBEDX509_LIBRARY AND
NOT DEFINED MBEDCRYPTO_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(MBEDTLS ${MBEDTLS_PC_REQUIRES})
+ pkg_check_modules(_mbedtls ${_mbedtls_pc_requires})
endif()
-if(MBEDTLS_FOUND)
+if(_mbedtls_FOUND)
set(MbedTLS_FOUND TRUE)
- set(MBEDTLS_VERSION ${MBEDTLS_mbedtls_VERSION})
- string(REPLACE ";" " " MBEDTLS_CFLAGS "${MBEDTLS_CFLAGS}")
- message(STATUS "Found MbedTLS (via pkg-config): ${MBEDTLS_INCLUDE_DIRS} (found version \"${MBEDTLS_VERSION}\")")
+ set(MBEDTLS_FOUND TRUE)
+ set(MBEDTLS_VERSION ${_mbedtls_mbedtls_VERSION})
+ message(STATUS "Found MbedTLS (via pkg-config): ${_mbedtls_INCLUDE_DIRS} (found version \"${MBEDTLS_VERSION}\")")
else()
- set(MBEDTLS_PC_REQUIRES "") # Depend on pkg-config only when found via pkg-config
+ set(_mbedtls_pc_requires "") # Depend on pkg-config only when found via pkg-config
find_path(MBEDTLS_INCLUDE_DIR NAMES "mbedtls/ssl.h")
find_library(MBEDTLS_LIBRARY NAMES "mbedtls" "libmbedtls")
)
if(MBEDTLS_FOUND)
- set(MBEDTLS_INCLUDE_DIRS ${MBEDTLS_INCLUDE_DIR})
- set(MBEDTLS_LIBRARIES ${MBEDTLS_LIBRARY} ${MBEDX509_LIBRARY} ${MBEDCRYPTO_LIBRARY})
+ set(_mbedtls_INCLUDE_DIRS ${MBEDTLS_INCLUDE_DIR})
+ set(_mbedtls_LIBRARIES ${MBEDTLS_LIBRARY} ${MBEDX509_LIBRARY} ${MBEDCRYPTO_LIBRARY})
endif()
mark_as_advanced(MBEDTLS_INCLUDE_DIR MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY)
endif()
+
+if(MBEDTLS_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_mbedtls_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::mbedtls)
+ add_library(CURL::mbedtls INTERFACE IMPORTED)
+ set_target_properties(CURL::mbedtls PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_mbedtls_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_mbedtls_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_mbedtls_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_mbedtls_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_mbedtls_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `NGHTTP2_INCLUDE_DIR`: Absolute path to nghttp2 include directory.
-# - `NGHTTP2_LIBRARY`: Absolute path to `nghttp2` library.
+# - `NGHTTP2_INCLUDE_DIR`: Absolute path to nghttp2 include directory.
+# - `NGHTTP2_LIBRARY`: Absolute path to `nghttp2` library.
#
-# Result variables:
+# Defines:
#
-# - `NGHTTP2_FOUND`: System has nghttp2.
-# - `NGHTTP2_INCLUDE_DIRS`: The nghttp2 include directories.
-# - `NGHTTP2_LIBRARIES`: The nghttp2 library names.
-# - `NGHTTP2_LIBRARY_DIRS`: The nghttp2 library directories.
-# - `NGHTTP2_PC_REQUIRES`: The nghttp2 pkg-config packages.
-# - `NGHTTP2_CFLAGS`: Required compiler flags.
-# - `NGHTTP2_VERSION`: Version of nghttp2.
+# - `NGHTTP2_FOUND`: System has nghttp2.
+# - `NGHTTP2_VERSION`: Version of nghttp2.
+# - `CURL::nghttp2`: nghttp2 library target.
-set(NGHTTP2_PC_REQUIRES "libnghttp2")
+set(_nghttp2_pc_requires "libnghttp2")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED NGHTTP2_INCLUDE_DIR AND
NOT DEFINED NGHTTP2_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(NGHTTP2 ${NGHTTP2_PC_REQUIRES})
+ pkg_check_modules(_nghttp2 ${_nghttp2_pc_requires})
endif()
-if(NGHTTP2_FOUND)
- string(REPLACE ";" " " NGHTTP2_CFLAGS "${NGHTTP2_CFLAGS}")
- message(STATUS "Found NGHTTP2 (via pkg-config): ${NGHTTP2_INCLUDE_DIRS} (found version \"${NGHTTP2_VERSION}\")")
+if(_nghttp2_FOUND)
+ set(NGHTTP2_FOUND TRUE)
+ set(NGHTTP2_VERSION ${_nghttp2_VERSION})
+ message(STATUS "Found NGHTTP2 (via pkg-config): ${_nghttp2_INCLUDE_DIRS} (found version \"${NGHTTP2_VERSION}\")")
else()
find_path(NGHTTP2_INCLUDE_DIR NAMES "nghttp2/nghttp2.h")
find_library(NGHTTP2_LIBRARY NAMES "nghttp2" "nghttp2_static")
)
if(NGHTTP2_FOUND)
- set(NGHTTP2_INCLUDE_DIRS ${NGHTTP2_INCLUDE_DIR})
- set(NGHTTP2_LIBRARIES ${NGHTTP2_LIBRARY})
+ set(_nghttp2_INCLUDE_DIRS ${NGHTTP2_INCLUDE_DIR})
+ set(_nghttp2_LIBRARIES ${NGHTTP2_LIBRARY})
endif()
mark_as_advanced(NGHTTP2_INCLUDE_DIR NGHTTP2_LIBRARY)
endif()
+
+if(NGHTTP2_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_nghttp2_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::nghttp2)
+ add_library(CURL::nghttp2 INTERFACE IMPORTED)
+ set_target_properties(CURL::nghttp2 PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_nghttp2_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_nghttp2_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_nghttp2_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_nghttp2_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_nghttp2_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `NGHTTP3_INCLUDE_DIR`: Absolute path to nghttp3 include directory.
-# - `NGHTTP3_LIBRARY`: Absolute path to `nghttp3` library.
+# - `NGHTTP3_INCLUDE_DIR`: Absolute path to nghttp3 include directory.
+# - `NGHTTP3_LIBRARY`: Absolute path to `nghttp3` library.
#
-# Result variables:
+# Defines:
#
-# - `NGHTTP3_FOUND`: System has nghttp3.
-# - `NGHTTP3_INCLUDE_DIRS`: The nghttp3 include directories.
-# - `NGHTTP3_LIBRARIES`: The nghttp3 library names.
-# - `NGHTTP3_LIBRARY_DIRS`: The nghttp3 library directories.
-# - `NGHTTP3_PC_REQUIRES`: The nghttp3 pkg-config packages.
-# - `NGHTTP3_CFLAGS`: Required compiler flags.
-# - `NGHTTP3_VERSION`: Version of nghttp3.
+# - `NGHTTP3_FOUND`: System has nghttp3.
+# - `NGHTTP3_VERSION`: Version of nghttp3.
+# - `CURL::nghttp3`: nghttp3 library target.
-set(NGHTTP3_PC_REQUIRES "libnghttp3")
+set(_nghttp3_pc_requires "libnghttp3")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED NGHTTP3_INCLUDE_DIR AND
NOT DEFINED NGHTTP3_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(NGHTTP3 ${NGHTTP3_PC_REQUIRES})
+ pkg_check_modules(_nghttp3 ${_nghttp3_pc_requires})
endif()
-if(NGHTTP3_FOUND)
- string(REPLACE ";" " " NGHTTP3_CFLAGS "${NGHTTP3_CFLAGS}")
- message(STATUS "Found NGHTTP3 (via pkg-config): ${NGHTTP3_INCLUDE_DIRS} (found version \"${NGHTTP3_VERSION}\")")
+if(_nghttp3_FOUND)
+ set(NGHTTP3_FOUND TRUE)
+ set(NGHTTP3_VERSION ${_nghttp3_VERSION})
+ message(STATUS "Found NGHTTP3 (via pkg-config): ${_nghttp3_INCLUDE_DIRS} (found version \"${NGHTTP3_VERSION}\")")
else()
find_path(NGHTTP3_INCLUDE_DIR NAMES "nghttp3/nghttp3.h")
find_library(NGHTTP3_LIBRARY NAMES "nghttp3")
)
if(NGHTTP3_FOUND)
- set(NGHTTP3_INCLUDE_DIRS ${NGHTTP3_INCLUDE_DIR})
- set(NGHTTP3_LIBRARIES ${NGHTTP3_LIBRARY})
+ set(_nghttp3_INCLUDE_DIRS ${NGHTTP3_INCLUDE_DIR})
+ set(_nghttp3_LIBRARIES ${NGHTTP3_LIBRARY})
endif()
mark_as_advanced(NGHTTP3_INCLUDE_DIR NGHTTP3_LIBRARY)
endif()
+
+if(NGHTTP3_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_nghttp3_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::nghttp3)
+ add_library(CURL::nghttp3 INTERFACE IMPORTED)
+ set_target_properties(CURL::nghttp3 PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_nghttp3_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_nghttp3_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_nghttp3_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_nghttp3_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_nghttp3_LIBRARIES}")
+ endif()
+endif()
# - `NGTCP2_CRYPTO_QUICTLS_LIBRARY`: Absolute path to `ngtcp2_crypto_quictls` library.
# - `NGTCP2_CRYPTO_WOLFSSL_LIBRARY`: Absolute path to `ngtcp2_crypto_wolfssl` library.
#
-# Result variables:
+# Defines:
#
# - `NGTCP2_FOUND`: System has ngtcp2.
-# - `NGTCP2_INCLUDE_DIRS`: The ngtcp2 include directories.
-# - `NGTCP2_LIBRARIES`: The ngtcp2 library names.
-# - `NGTCP2_LIBRARY_DIRS`: The ngtcp2 library directories.
-# - `NGTCP2_PC_REQUIRES`: The ngtcp2 pkg-config packages.
-# - `NGTCP2_CFLAGS`: Required compiler flags.
# - `NGTCP2_VERSION`: Version of ngtcp2.
+# - `CURL::ngtcp2`: ngtcp2 library target.
if(NGTCP2_FIND_COMPONENTS)
set(_ngtcp2_crypto_backend "")
endif()
endif()
-set(NGTCP2_PC_REQUIRES "libngtcp2")
+set(_ngtcp2_pc_requires "libngtcp2")
if(_ngtcp2_crypto_backend)
- list(APPEND NGTCP2_PC_REQUIRES "lib${_crypto_library_lower}")
+ list(APPEND _ngtcp2_pc_requires "lib${_crypto_library_lower}")
endif()
set(_tried_pkgconfig FALSE)
NOT DEFINED NGTCP2_INCLUDE_DIR AND
NOT DEFINED NGTCP2_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(NGTCP2 ${NGTCP2_PC_REQUIRES})
+ pkg_check_modules(_ngtcp2 ${_ngtcp2_pc_requires})
set(_tried_pkgconfig TRUE)
endif()
-if(NGTCP2_FOUND)
- set(NGTCP2_VERSION ${NGTCP2_libngtcp2_VERSION})
- string(REPLACE ";" " " NGTCP2_CFLAGS "${NGTCP2_CFLAGS}")
- message(STATUS "Found NGTCP2 (via pkg-config): ${NGTCP2_INCLUDE_DIRS} (found version \"${NGTCP2_VERSION}\")")
+if(_ngtcp2_FOUND)
+ set(NGTCP2_FOUND TRUE)
+ set(NGTCP2_VERSION ${_ngtcp2_libngtcp2_VERSION})
+ message(STATUS "Found NGTCP2 (via pkg-config): ${_ngtcp2_INCLUDE_DIRS} (found version \"${NGTCP2_VERSION}\")")
else()
find_path(NGTCP2_INCLUDE_DIR NAMES "ngtcp2/ngtcp2.h")
find_library(NGTCP2_LIBRARY NAMES "ngtcp2")
)
if(NGTCP2_FOUND)
- set(NGTCP2_INCLUDE_DIRS ${NGTCP2_INCLUDE_DIR})
- set(NGTCP2_LIBRARIES ${NGTCP2_LIBRARY} ${NGTCP2_CRYPTO_LIBRARY})
+ set(_ngtcp2_INCLUDE_DIRS ${NGTCP2_INCLUDE_DIR})
+ set(_ngtcp2_LIBRARIES ${NGTCP2_LIBRARY} ${NGTCP2_CRYPTO_LIBRARY})
endif()
mark_as_advanced(NGTCP2_INCLUDE_DIR NGTCP2_LIBRARY NGTCP2_CRYPTO_LIBRARY)
unset(NGTCP2_LIBRARY CACHE)
endif()
endif()
+
+if(NGTCP2_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_ngtcp2_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::ngtcp2)
+ add_library(CURL::ngtcp2 INTERFACE IMPORTED)
+ set_target_properties(CURL::ngtcp2 PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_ngtcp2_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_ngtcp2_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_ngtcp2_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_ngtcp2_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_ngtcp2_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `NETTLE_INCLUDE_DIR`: Absolute path to nettle include directory.
-# - `NETTLE_LIBRARY`: Absolute path to `nettle` library.
+# - `NETTLE_INCLUDE_DIR`: Absolute path to nettle include directory.
+# - `NETTLE_LIBRARY`: Absolute path to `nettle` library.
#
-# Result variables:
+# Defines:
#
-# - `NETTLE_FOUND`: System has nettle.
-# - `NETTLE_INCLUDE_DIRS`: The nettle include directories.
-# - `NETTLE_LIBRARIES`: The nettle library names.
-# - `NETTLE_LIBRARY_DIRS`: The nettle library directories.
-# - `NETTLE_PC_REQUIRES`: The nettle pkg-config packages.
-# - `NETTLE_CFLAGS`: Required compiler flags.
-# - `NETTLE_VERSION`: Version of nettle.
+# - `NETTLE_FOUND`: System has nettle.
+# - `NETTLE_VERSION`: Version of nettle.
+# - `CURL::nettle`: nettle library target.
-set(NETTLE_PC_REQUIRES "nettle")
+set(_nettle_pc_requires "nettle")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED NETTLE_INCLUDE_DIR AND
NOT DEFINED NETTLE_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(NETTLE ${NETTLE_PC_REQUIRES})
+ pkg_check_modules(_nettle ${_nettle_pc_requires})
endif()
-if(NETTLE_FOUND)
+if(_nettle_FOUND)
set(Nettle_FOUND TRUE)
- string(REPLACE ";" " " NETTLE_CFLAGS "${NETTLE_CFLAGS}")
- message(STATUS "Found Nettle (via pkg-config): ${NETTLE_INCLUDE_DIRS} (found version \"${NETTLE_VERSION}\")")
+ set(NETTLE_FOUND TRUE)
+ set(NETTLE_VERSION ${_nettle_VERSION})
+ message(STATUS "Found Nettle (via pkg-config): ${_nettle_INCLUDE_DIRS} (found version \"${NETTLE_VERSION}\")")
else()
find_path(NETTLE_INCLUDE_DIR NAMES "nettle/sha2.h")
find_library(NETTLE_LIBRARY NAMES "nettle")
)
if(NETTLE_FOUND)
- set(NETTLE_INCLUDE_DIRS ${NETTLE_INCLUDE_DIR})
- set(NETTLE_LIBRARIES ${NETTLE_LIBRARY})
+ set(_nettle_INCLUDE_DIRS ${NETTLE_INCLUDE_DIR})
+ set(_nettle_LIBRARIES ${NETTLE_LIBRARY})
endif()
mark_as_advanced(NETTLE_INCLUDE_DIR NETTLE_LIBRARY)
endif()
+
+if(NETTLE_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_nettle_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::nettle)
+ add_library(CURL::nettle INTERFACE IMPORTED)
+ set_target_properties(CURL::nettle PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_nettle_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_nettle_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_nettle_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_nettle_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_nettle_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `QUICHE_INCLUDE_DIR`: Absolute path to quiche include directory.
-# - `QUICHE_LIBRARY`: Absolute path to `quiche` library.
+# - `QUICHE_INCLUDE_DIR`: Absolute path to quiche include directory.
+# - `QUICHE_LIBRARY`: Absolute path to `quiche` library.
#
-# Result variables:
+# Defines:
#
-# - `QUICHE_FOUND`: System has quiche.
-# - `QUICHE_INCLUDE_DIRS`: The quiche include directories.
-# - `QUICHE_LIBRARIES`: The quiche library names.
-# - `QUICHE_LIBRARY_DIRS`: The quiche library directories.
-# - `QUICHE_PC_REQUIRES`: The quiche pkg-config packages.
-# - `QUICHE_CFLAGS`: Required compiler flags.
-# - `QUICHE_VERSION`: Version of quiche.
+# - `QUICHE_FOUND`: System has quiche.
+# - `QUICHE_VERSION`: Version of quiche.
+# - `CURL::quiche`: quiche library target.
-set(QUICHE_PC_REQUIRES "quiche")
+set(_quiche_pc_requires "quiche")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED QUICHE_INCLUDE_DIR AND
NOT DEFINED QUICHE_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(QUICHE ${QUICHE_PC_REQUIRES})
+ pkg_check_modules(_quiche ${_quiche_pc_requires})
endif()
-if(QUICHE_FOUND)
+if(_quiche_FOUND)
set(Quiche_FOUND TRUE)
- string(REPLACE ";" " " QUICHE_CFLAGS "${QUICHE_CFLAGS}")
- message(STATUS "Found Quiche (via pkg-config): ${QUICHE_INCLUDE_DIRS} (found version \"${QUICHE_VERSION}\")")
+ set(QUICHE_FOUND TRUE)
+ set(QUICHE_VERSION ${_quiche_VERSION})
+ message(STATUS "Found Quiche (via pkg-config): ${_quiche_INCLUDE_DIRS} (found version \"${QUICHE_VERSION}\")")
else()
find_path(QUICHE_INCLUDE_DIR NAMES "quiche.h")
find_library(QUICHE_LIBRARY NAMES "quiche")
)
if(QUICHE_FOUND)
- set(QUICHE_INCLUDE_DIRS ${QUICHE_INCLUDE_DIR})
- set(QUICHE_LIBRARIES ${QUICHE_LIBRARY})
+ set(_quiche_INCLUDE_DIRS ${QUICHE_INCLUDE_DIR})
+ set(_quiche_LIBRARIES ${QUICHE_LIBRARY})
endif()
mark_as_advanced(QUICHE_INCLUDE_DIR QUICHE_LIBRARY)
endif()
+
+if(QUICHE_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_quiche_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::quiche)
+ add_library(CURL::quiche INTERFACE IMPORTED)
+ set_target_properties(CURL::quiche PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_quiche_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_quiche_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_quiche_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_quiche_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_quiche_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `RUSTLS_INCLUDE_DIR`: Absolute path to Rustls include directory.
-# - `RUSTLS_LIBRARY`: Absolute path to `rustls` library.
+# - `RUSTLS_INCLUDE_DIR`: Absolute path to Rustls include directory.
+# - `RUSTLS_LIBRARY`: Absolute path to `rustls` library.
#
-# Result variables:
+# Defines:
#
-# - `RUSTLS_FOUND`: System has Rustls.
-# - `RUSTLS_INCLUDE_DIRS`: The Rustls include directories.
-# - `RUSTLS_LIBRARIES`: The Rustls library names.
-# - `RUSTLS_LIBRARY_DIRS`: The Rustls library directories.
-# - `RUSTLS_PC_REQUIRES`: The Rustls pkg-config packages.
-# - `RUSTLS_CFLAGS`: Required compiler flags.
-# - `RUSTLS_VERSION`: Version of Rustls.
+# - `RUSTLS_FOUND`: System has Rustls.
+# - `RUSTLS_VERSION`: Version of Rustls.
+# - `CURL::rustls`: Rustls library target.
-set(RUSTLS_PC_REQUIRES "rustls")
+set(_rustls_pc_requires "rustls")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED RUSTLS_INCLUDE_DIR AND
NOT DEFINED RUSTLS_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(RUSTLS ${RUSTLS_PC_REQUIRES})
+ pkg_check_modules(_rustls ${_rustls_pc_requires})
endif()
-if(RUSTLS_FOUND)
+if(_rustls_FOUND)
set(Rustls_FOUND TRUE)
- string(REPLACE ";" " " RUSTLS_CFLAGS "${RUSTLS_CFLAGS}")
- message(STATUS "Found Rustls (via pkg-config): ${RUSTLS_INCLUDE_DIRS} (found version \"${RUSTLS_VERSION}\")")
+ set(RUSTLS_FOUND TRUE)
+ set(RUSTLS_VERSION ${_rustls_VERSION})
+ message(STATUS "Found Rustls (via pkg-config): ${_rustls_INCLUDE_DIRS} (found version \"${RUSTLS_VERSION}\")")
else()
- set(RUSTLS_PC_REQUIRES "") # Depend on pkg-config only when found via pkg-config
+ set(_rustls_pc_requires "") # Depend on pkg-config only when found via pkg-config
find_path(RUSTLS_INCLUDE_DIR NAMES "rustls.h")
find_library(RUSTLS_LIBRARY NAMES "rustls")
)
if(RUSTLS_FOUND)
- set(RUSTLS_INCLUDE_DIRS ${RUSTLS_INCLUDE_DIR})
- set(RUSTLS_LIBRARIES ${RUSTLS_LIBRARY})
+ set(_rustls_INCLUDE_DIRS ${RUSTLS_INCLUDE_DIR})
+ set(_rustls_LIBRARIES ${RUSTLS_LIBRARY})
endif()
mark_as_advanced(RUSTLS_INCLUDE_DIR RUSTLS_LIBRARY)
if(NOT SECURITY_FRAMEWORK)
message(FATAL_ERROR "Security framework not found")
endif()
- list(APPEND RUSTLS_LIBRARIES "-framework Security")
+ list(APPEND _rustls_LIBRARIES "-framework Security")
find_library(FOUNDATION_FRAMEWORK NAMES "Foundation")
mark_as_advanced(FOUNDATION_FRAMEWORK)
if(NOT FOUNDATION_FRAMEWORK)
message(FATAL_ERROR "Foundation framework not found")
endif()
- list(APPEND RUSTLS_LIBRARIES "-framework Foundation")
+ list(APPEND _rustls_LIBRARIES "-framework Foundation")
elseif(NOT WIN32)
find_library(PTHREAD_LIBRARY NAMES "pthread")
if(PTHREAD_LIBRARY)
- list(APPEND RUSTLS_LIBRARIES ${PTHREAD_LIBRARY})
+ list(APPEND _rustls_LIBRARIES ${PTHREAD_LIBRARY})
endif()
mark_as_advanced(PTHREAD_LIBRARY)
find_library(DL_LIBRARY NAMES "dl")
if(DL_LIBRARY)
- list(APPEND RUSTLS_LIBRARIES ${DL_LIBRARY})
+ list(APPEND _rustls_LIBRARIES ${DL_LIBRARY})
endif()
mark_as_advanced(DL_LIBRARY)
find_library(MATH_LIBRARY NAMES "m")
if(MATH_LIBRARY)
- list(APPEND RUSTLS_LIBRARIES ${MATH_LIBRARY})
+ list(APPEND _rustls_LIBRARIES ${MATH_LIBRARY})
endif()
mark_as_advanced(MATH_LIBRARY)
endif()
endif()
+
+if(RUSTLS_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_rustls_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::rustls)
+ add_library(CURL::rustls INTERFACE IMPORTED)
+ set_target_properties(CURL::rustls PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_rustls_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_rustls_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_rustls_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_rustls_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_rustls_LIBRARIES}")
+ endif()
+endif()
#
# Input variables:
#
-# - `WOLFSSL_INCLUDE_DIR`: Absolute path to wolfSSL include directory.
-# - `WOLFSSL_LIBRARY`: Absolute path to `wolfssl` library.
+# - `WOLFSSL_INCLUDE_DIR`: Absolute path to wolfSSL include directory.
+# - `WOLFSSL_LIBRARY`: Absolute path to `wolfssl` library.
#
-# Result variables:
+# Defines:
#
-# - `WOLFSSL_FOUND`: System has wolfSSL.
-# - `WOLFSSL_INCLUDE_DIRS`: The wolfSSL include directories.
-# - `WOLFSSL_LIBRARIES`: The wolfSSL library names.
-# - `WOLFSSL_LIBRARY_DIRS`: The wolfSSL library directories.
-# - `WOLFSSL_PC_REQUIRES`: The wolfSSL pkg-config packages.
-# - `WOLFSSL_CFLAGS`: Required compiler flags.
-# - `WOLFSSL_VERSION`: Version of wolfSSL.
+# - `WOLFSSL_FOUND`: System has wolfSSL.
+# - `WOLFSSL_VERSION`: Version of wolfSSL.
+# - `CURL::wolfssl`: wolfSSL library target.
if(DEFINED WolfSSL_INCLUDE_DIR AND NOT DEFINED WOLFSSL_INCLUDE_DIR)
message(WARNING "WolfSSL_INCLUDE_DIR is deprecated, use WOLFSSL_INCLUDE_DIR instead.")
set(WOLFSSL_LIBRARY "${WolfSSL_LIBRARY}")
endif()
-set(WOLFSSL_PC_REQUIRES "wolfssl")
+set(_wolfssl_pc_requires "wolfssl")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED WOLFSSL_INCLUDE_DIR AND
NOT DEFINED WOLFSSL_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(WOLFSSL ${WOLFSSL_PC_REQUIRES})
+ pkg_check_modules(_wolfssl ${_wolfssl_pc_requires})
endif()
-if(WOLFSSL_FOUND)
+if(_wolfssl_FOUND)
set(WolfSSL_FOUND TRUE)
- string(REPLACE ";" " " WOLFSSL_CFLAGS "${WOLFSSL_CFLAGS}")
- message(STATUS "Found WolfSSL (via pkg-config): ${WOLFSSL_INCLUDE_DIRS} (found version \"${WOLFSSL_VERSION}\")")
+ set(WOLFSSL_FOUND TRUE)
+ set(WOLFSSL_VERSION ${_wolfssl_VERSION})
+ message(STATUS "Found WolfSSL (via pkg-config): ${_wolfssl_INCLUDE_DIRS} (found version \"${WOLFSSL_VERSION}\")")
else()
find_path(WOLFSSL_INCLUDE_DIR NAMES "wolfssl/ssl.h")
find_library(WOLFSSL_LIBRARY NAMES "wolfssl")
)
if(WOLFSSL_FOUND)
- set(WOLFSSL_INCLUDE_DIRS ${WOLFSSL_INCLUDE_DIR})
- set(WOLFSSL_LIBRARIES ${WOLFSSL_LIBRARY})
+ set(_wolfssl_INCLUDE_DIRS ${WOLFSSL_INCLUDE_DIR})
+ set(_wolfssl_LIBRARIES ${WOLFSSL_LIBRARY})
endif()
mark_as_advanced(WOLFSSL_INCLUDE_DIR WOLFSSL_LIBRARY)
if(NOT SECURITY_FRAMEWORK)
message(FATAL_ERROR "Security framework not found")
endif()
- list(APPEND WOLFSSL_LIBRARIES "-framework Security")
+ list(APPEND _wolfssl_LIBRARIES "-framework Security")
find_library(COREFOUNDATION_FRAMEWORK NAMES "CoreFoundation")
mark_as_advanced(COREFOUNDATION_FRAMEWORK)
if(NOT COREFOUNDATION_FRAMEWORK)
message(FATAL_ERROR "CoreFoundation framework not found")
endif()
- list(APPEND WOLFSSL_LIBRARIES "-framework CoreFoundation")
- elseif(NOT WIN32)
+ list(APPEND _wolfssl_LIBRARIES "-framework CoreFoundation")
+ elseif(WIN32)
+ list(APPEND _wolfssl_LIBRARIES "crypt32")
+ else()
find_library(MATH_LIBRARY NAMES "m")
if(MATH_LIBRARY)
- list(APPEND WOLFSSL_LIBRARIES ${MATH_LIBRARY}) # for log and pow
+ list(APPEND _wolfssl_LIBRARIES ${MATH_LIBRARY}) # for log and pow
endif()
mark_as_advanced(MATH_LIBRARY)
endif()
+
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_wolfssl_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::wolfssl)
+ add_library(CURL::wolfssl INTERFACE IMPORTED)
+ set_target_properties(CURL::wolfssl PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_wolfssl_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_wolfssl_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_wolfssl_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_wolfssl_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_wolfssl_LIBRARIES}")
+ endif()
endif()
#
# Input variables:
#
-# - `ZSTD_INCLUDE_DIR`: Absolute path to zstd include directory.
-# - `ZSTD_LIBRARY`: Absolute path to `zstd` library.
+# - `ZSTD_INCLUDE_DIR`: Absolute path to zstd include directory.
+# - `ZSTD_LIBRARY`: Absolute path to `zstd` library.
#
-# Result variables:
+# Defines:
#
-# - `ZSTD_FOUND`: System has zstd.
-# - `ZSTD_INCLUDE_DIRS`: The zstd include directories.
-# - `ZSTD_LIBRARIES`: The zstd library names.
-# - `ZSTD_LIBRARY_DIRS`: The zstd library directories.
-# - `ZSTD_PC_REQUIRES`: The zstd pkg-config packages.
-# - `ZSTD_CFLAGS`: Required compiler flags.
-# - `ZSTD_VERSION`: Version of zstd.
+# - `ZSTD_FOUND`: System has zstd.
+# - `ZSTD_VERSION`: Version of zstd.
+# - `CURL::zstd`: zstd library target.
if(DEFINED Zstd_INCLUDE_DIR AND NOT DEFINED ZSTD_INCLUDE_DIR)
message(WARNING "Zstd_INCLUDE_DIR is deprecated, use ZSTD_INCLUDE_DIR instead.")
set(ZSTD_LIBRARY "${Zstd_LIBRARY}")
endif()
-set(ZSTD_PC_REQUIRES "libzstd")
+set(_zstd_pc_requires "libzstd")
if(CURL_USE_PKGCONFIG AND
NOT DEFINED ZSTD_INCLUDE_DIR AND
NOT DEFINED ZSTD_LIBRARY)
find_package(PkgConfig QUIET)
- pkg_check_modules(ZSTD ${ZSTD_PC_REQUIRES})
+ pkg_check_modules(_zstd ${_zstd_pc_requires})
endif()
-if(ZSTD_FOUND)
+if(_zstd_FOUND)
set(Zstd_FOUND TRUE)
- string(REPLACE ";" " " ZSTD_CFLAGS "${ZSTD_CFLAGS}")
- message(STATUS "Found Zstd (via pkg-config): ${ZSTD_INCLUDE_DIRS} (found version \"${ZSTD_VERSION}\")")
+ set(ZSTD_FOUND TRUE)
+ set(ZSTD_VERSION ${_zstd_VERSION})
+ message(STATUS "Found Zstd (via pkg-config): ${_zstd_INCLUDE_DIRS} (found version \"${ZSTD_VERSION}\")")
else()
find_path(ZSTD_INCLUDE_DIR NAMES "zstd.h")
find_library(ZSTD_LIBRARY NAMES "zstd")
)
if(ZSTD_FOUND)
- set(ZSTD_INCLUDE_DIRS ${ZSTD_INCLUDE_DIR})
- set(ZSTD_LIBRARIES ${ZSTD_LIBRARY})
+ set(_zstd_INCLUDE_DIRS ${ZSTD_INCLUDE_DIR})
+ set(_zstd_LIBRARIES ${ZSTD_LIBRARY})
endif()
mark_as_advanced(ZSTD_INCLUDE_DIR ZSTD_LIBRARY)
endif()
+
+if(ZSTD_FOUND)
+ if(CMAKE_VERSION VERSION_LESS 3.13)
+ link_directories(${_zstd_LIBRARY_DIRS})
+ endif()
+
+ if(NOT TARGET CURL::zstd)
+ add_library(CURL::zstd INTERFACE IMPORTED)
+ set_target_properties(CURL::zstd PROPERTIES
+ INTERFACE_LIBCURL_PC_MODULES "${_zstd_pc_requires}"
+ INTERFACE_COMPILE_OPTIONS "${_zstd_CFLAGS}"
+ INTERFACE_INCLUDE_DIRECTORIES "${_zstd_INCLUDE_DIRS}"
+ INTERFACE_LINK_DIRECTORIES "${_zstd_LIBRARY_DIRS}"
+ INTERFACE_LINK_LIBRARIES "${_zstd_LIBRARIES}")
+ endif()
+endif()
string(REPLACE "\n" ";" _cmake_property_list "${_cmake_property_list}")
list(REMOVE_DUPLICATES _cmake_property_list)
list(REMOVE_ITEM _cmake_property_list "")
+ list(APPEND _cmake_property_list "INTERFACE_LIBCURL_PC_MODULES")
foreach(_prop IN LISTS _cmake_property_list)
if(_prop MATCHES "<CONFIG>")
foreach(_config IN ITEMS "DEBUG" "RELEASE" "MINSIZEREL" "RELWITHDEBINFO")
###########################################################################
@PACKAGE_INIT@
+option(CURL_USE_PKGCONFIG "Enable pkg-config to detect @PROJECT_NAME@ dependencies. Default: @CURL_USE_PKGCONFIG@" "@CURL_USE_PKGCONFIG@")
+
include(CMakeFindDependencyMacro)
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR} ${CMAKE_MODULE_PATH})
+
+set(_libs "")
if("@USE_OPENSSL@")
if("@OPENSSL_VERSION_MAJOR@")
find_dependency(OpenSSL "@OPENSSL_VERSION_MAJOR@")
if("@HAVE_LIBZ@")
find_dependency(ZLIB "@ZLIB_VERSION_MAJOR@")
endif()
+if("@HAVE_BROTLI@")
+ find_dependency(Brotli)
+ list(APPEND _libs CURL::brotli)
+endif()
+if("@USE_ARES@")
+ find_dependency(Cares)
+ list(APPEND _libs CURL::cares)
+endif()
+if("@HAVE_GSSAPI@")
+ find_dependency(GSS)
+ list(APPEND _libs CURL::gss)
+endif()
+if("@USE_BACKTRACE@")
+ find_dependency(Libbacktrace)
+ list(APPEND _libs CURL::libbacktrace)
+endif()
+if("@USE_GSASL@")
+ find_dependency(Libgsasl)
+ list(APPEND _libs CURL::libgsasl)
+endif()
+if(NOT "@USE_WIN32_LDAP@" AND NOT "@CURL_DISABLE_LDAP@")
+ find_dependency(LDAP)
+ list(APPEND _libs CURL::ldap)
+endif()
+if("@HAVE_LIBIDN2@")
+ find_dependency(Libidn2)
+ list(APPEND _libs CURL::libidn2)
+endif()
+if("@USE_LIBPSL@")
+ find_dependency(Libpsl)
+ list(APPEND _libs CURL::libpsl)
+endif()
+if("@USE_LIBRTMP@")
+ find_dependency(Librtmp)
+ list(APPEND _libs CURL::librtmp)
+endif()
+if("@USE_LIBSSH@")
+ find_dependency(Libssh)
+ list(APPEND _libs CURL::libssh)
+endif()
+if("@USE_LIBSSH2@")
+ find_dependency(Libssh2)
+ list(APPEND _libs CURL::libssh2)
+endif()
+if("@USE_LIBUV@")
+ find_dependency(Libuv)
+ list(APPEND _libs CURL::libuv)
+endif()
+if("@USE_MBEDTLS@")
+ find_dependency(MbedTLS)
+ list(APPEND _libs CURL::mbedtls)
+endif()
+if("@USE_NGHTTP2@")
+ find_dependency(NGHTTP2)
+ list(APPEND _libs CURL::nghttp2)
+endif()
+if("@USE_NGHTTP3@")
+ find_dependency(NGHTTP3)
+ list(APPEND _libs CURL::nghttp3)
+endif()
+if("@USE_NGTCP2@")
+ find_dependency(NGTCP2)
+ list(APPEND _libs CURL::ngtcp2)
+endif()
+if("@USE_GNUTLS@")
+ find_dependency(GnuTLS)
+ list(APPEND _libs CURL::gnutls)
+ find_dependency(Nettle)
+ list(APPEND _libs CURL::nettle)
+endif()
+if("@USE_QUICHE@")
+ find_dependency(Quiche)
+ list(APPEND _libs CURL::quiche)
+endif()
+if("@USE_RUSTLS@")
+ find_dependency(Rustls)
+ list(APPEND _libs CURL::rustls)
+endif()
+if("@USE_WOLFSSL@")
+ find_dependency(WolfSSL)
+ list(APPEND _libs CURL::wolfssl)
+endif()
+if("@HAVE_ZSTD@")
+ find_dependency(Zstd)
+ list(APPEND _libs CURL::zstd)
+endif()
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND WIN32 AND NOT TARGET CURL::win32_winsock)
+ add_library(CURL::win32_winsock INTERFACE IMPORTED)
+ set_target_properties(CURL::win32_winsock PROPERTIES INTERFACE_LINK_LIBRARIES "@_win32_winsock@")
+endif()
include("${CMAKE_CURRENT_LIST_DIR}/@TARGETS_EXPORT_NAME@.cmake")
add_library(@PROJECT_NAME@::@LIB_NAME@ ALIAS @PROJECT_NAME@::@LIB_SELECTED@)
endif()
+if(TARGET @PROJECT_NAME@::@LIB_STATIC@)
+ # CMake before CMP0099 (CMake 3.17 2020-03-20) did not propagate libdirs to
+ # targets. It expected libs to have an absolute filename. As a workaround,
+ # manually apply dependency libdirs, for CMake consumers without this policy.
+ if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.17)
+ cmake_policy(GET CMP0099 _has_CMP0099) # https://cmake.org/cmake/help/latest/policy/CMP0099.html
+ endif()
+ if(NOT _has_CMP0099 AND CMAKE_VERSION VERSION_GREATER_EQUAL 3.13 AND _libs)
+ set(_libdirs "")
+ foreach(_lib IN LISTS _libs)
+ get_target_property(_libdir "${_lib}" INTERFACE_LINK_DIRECTORIES)
+ if(_libdir)
+ list(APPEND _libdirs "${_libdir}")
+ endif()
+ endforeach()
+ if(_libdirs)
+ target_link_directories(@PROJECT_NAME@::@LIB_STATIC@ INTERFACE ${_libdirs})
+ endif()
+ endif()
+endif()
+
# For compatibility with CMake's FindCURL.cmake
set(CURL_VERSION_STRING "@CURLVERSION@")
set(CURL_LIBRARIES @PROJECT_NAME@::@LIB_NAME@)
+set(CURL_LIBRARIES_PRIVATE "@LIBCURL_PC_LIBS_PRIVATE_LIST@")
set_and_check(CURL_INCLUDE_DIRS "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@")
set(CURL_SUPPORTED_PROTOCOLS "@CURL_SUPPORTED_PROTOCOLS_LIST@")
endif()
option(CURL_USE_PKGCONFIG "Enable pkg-config to detect dependencies" ${_curl_use_pkgconfig_default})
-# Initialize variables collecting dependency libs, paths, pkg-config names.
+# Initialize variables collecting system and dependency libs.
set(CURL_NETWORK_AND_TIME_LIBS "")
set(CURL_LIBS "")
-set(CURL_LIBDIRS "")
-set(LIBCURL_PC_REQUIRES_PRIVATE "")
if(ENABLE_ARES)
set(USE_ARES 1)
find_package(Cares REQUIRED)
- list(APPEND CURL_LIBS ${CARES_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${CARES_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${CARES_PC_REQUIRES})
- include_directories(SYSTEM ${CARES_INCLUDE_DIRS})
- link_directories(${CARES_LIBRARY_DIRS})
- if(CARES_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${CARES_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::cares)
endif()
include(CurlSymbolHiding)
# Depend on OpenSSL via imported targets. This allows our dependents to
# get our dependencies transitively.
list(APPEND CURL_LIBS OpenSSL::SSL OpenSSL::Crypto)
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "openssl")
+ set_target_properties(OpenSSL::SSL PROPERTIES INTERFACE_LIBCURL_PC_MODULES "openssl")
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "openssl")
set(_valid_default_ssl_backend TRUE)
endif()
set(_ssl_enabled ON)
set(USE_MBEDTLS ON)
- list(APPEND CURL_LIBS ${MBEDTLS_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${MBEDTLS_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${MBEDTLS_PC_REQUIRES})
- include_directories(SYSTEM ${MBEDTLS_INCLUDE_DIRS})
- link_directories(${MBEDTLS_LIBRARY_DIRS})
- if(MBEDTLS_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${MBEDTLS_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::mbedtls)
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "mbedtls")
set(_valid_default_ssl_backend TRUE)
endif()
if(NOT DEFINED HAVE_MBEDTLS_DES_CRYPT_ECB)
cmake_push_check_state()
- list(APPEND CMAKE_REQUIRED_INCLUDES "${MBEDTLS_INCLUDE_DIRS}")
- list(APPEND CMAKE_REQUIRED_LIBRARIES "${MBEDTLS_LIBRARIES}")
- curl_required_libpaths("${MBEDTLS_LIBRARY_DIRS}")
+ list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::mbedtls)
check_function_exists("mbedtls_des_crypt_ecb" HAVE_MBEDTLS_DES_CRYPT_ECB) # in mbedTLS <4
cmake_pop_check_state()
endif()
find_package(WolfSSL REQUIRED)
set(_ssl_enabled ON)
set(USE_WOLFSSL ON)
- list(APPEND CURL_LIBS ${WOLFSSL_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${WOLFSSL_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${WOLFSSL_PC_REQUIRES})
- include_directories(SYSTEM ${WOLFSSL_INCLUDE_DIRS})
- link_directories(${WOLFSSL_LIBRARY_DIRS})
- if(WOLFSSL_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${WOLFSSL_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::wolfssl)
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "wolfssl")
set(_valid_default_ssl_backend TRUE)
if(CURL_USE_GNUTLS)
find_package(GnuTLS REQUIRED)
- list(APPEND CURL_LIBS ${GNUTLS_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${GNUTLS_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${GNUTLS_PC_REQUIRES})
- include_directories(SYSTEM ${GNUTLS_INCLUDE_DIRS})
- link_directories(${GNUTLS_LIBRARY_DIRS})
- if(GNUTLS_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${GNUTLS_CFLAGS}")
- endif()
-
+ list(APPEND CURL_LIBS CURL::gnutls)
find_package(Nettle REQUIRED)
+ list(APPEND CURL_LIBS CURL::nettle)
set(_ssl_enabled ON)
set(USE_GNUTLS ON)
- list(APPEND CURL_LIBS ${NETTLE_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${NETTLE_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${NETTLE_PC_REQUIRES})
- include_directories(SYSTEM ${NETTLE_INCLUDE_DIRS})
- link_directories(${NETTLE_LIBRARY_DIRS})
- if(NETTLE_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${NETTLE_CFLAGS}")
- endif()
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "gnutls")
set(_valid_default_ssl_backend TRUE)
if(NOT DEFINED HAVE_GNUTLS_SRP AND NOT CURL_DISABLE_SRP)
cmake_push_check_state()
- list(APPEND CMAKE_REQUIRED_INCLUDES "${GNUTLS_INCLUDE_DIRS}")
- list(APPEND CMAKE_REQUIRED_LIBRARIES "${GNUTLS_LIBRARIES}")
- curl_required_libpaths("${GNUTLS_LIBRARY_DIRS}")
+ list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::gnutls)
# In GnuTLS 3.8.0 (2023-02-10) and upper, this check always succeeds.
# Detecting actual TLS-SRP support needs poking the API at runtime.
check_symbol_exists("gnutls_srp_verifier" "gnutls/gnutls.h" HAVE_GNUTLS_SRP)
find_package(Rustls REQUIRED)
set(_ssl_enabled ON)
set(USE_RUSTLS ON)
- list(APPEND CURL_LIBS ${RUSTLS_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${RUSTLS_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${RUSTLS_PC_REQUIRES})
- include_directories(SYSTEM ${RUSTLS_INCLUDE_DIRS})
- link_directories(${RUSTLS_LIBRARY_DIRS})
- if(RUSTLS_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${RUSTLS_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::rustls)
if(NOT DEFINED HAVE_RUSTLS_SUPPORTED_HPKE)
if(RUSTLS_VERSION AND RUSTLS_VERSION VERSION_GREATER_EQUAL 0.15)
set(HAVE_RUSTLS_SUPPORTED_HPKE TRUE)
elseif(NOT RUSTLS_VERSION)
cmake_push_check_state()
- list(APPEND CMAKE_REQUIRED_INCLUDES "${RUSTLS_INCLUDE_DIRS}")
- list(APPEND CMAKE_REQUIRED_LIBRARIES "${RUSTLS_LIBRARIES}")
- curl_required_libpaths("${RUSTLS_LIBRARY_DIRS}")
+ list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::rustls)
check_symbol_exists("rustls_supported_hpke" "rustls.h" HAVE_RUSTLS_SUPPORTED_HPKE)
cmake_pop_check_state()
endif()
# Depend on ZLIB via imported targets. This allows our dependents to
# get our dependencies transitively.
list(APPEND CURL_LIBS ZLIB::ZLIB)
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "zlib")
+ set_target_properties(ZLIB::ZLIB PROPERTIES INTERFACE_LIBCURL_PC_MODULES "zlib")
endif()
set(HAVE_BROTLI OFF)
curl_dependency_option(CURL_BROTLI Brotli "brotli")
if(BROTLI_FOUND)
set(HAVE_BROTLI ON)
- list(APPEND CURL_LIBS ${BROTLI_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${BROTLI_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${BROTLI_PC_REQUIRES})
- include_directories(SYSTEM ${BROTLI_INCLUDE_DIRS})
- link_directories(${BROTLI_LIBRARY_DIRS})
- if(BROTLI_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${BROTLI_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::brotli)
endif()
set(HAVE_ZSTD OFF)
if(ZSTD_FOUND)
if(ZSTD_VERSION VERSION_GREATER_EQUAL 1.0.0)
set(HAVE_ZSTD ON)
- list(APPEND CURL_LIBS ${ZSTD_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${ZSTD_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${ZSTD_PC_REQUIRES})
- include_directories(SYSTEM ${ZSTD_INCLUDE_DIRS})
- link_directories(${ZSTD_LIBRARY_DIRS})
- if(ZSTD_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${ZSTD_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::zstd)
else()
message(WARNING "zstd v1.0.0 or newer is required, disabling zstd support.")
endif()
endif()
endif()
if(USE_WOLFSSL)
- list(APPEND CMAKE_REQUIRED_INCLUDES "${WOLFSSL_INCLUDE_DIRS}")
- list(APPEND CMAKE_REQUIRED_LIBRARIES "${WOLFSSL_LIBRARIES}")
- curl_required_libpaths("${WOLFSSL_LIBRARY_DIRS}")
+ list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::wolfssl)
if(HAVE_LIBZ)
list(APPEND CMAKE_REQUIRED_LIBRARIES ZLIB::ZLIB) # Public wolfSSL headers also require zlib headers
endif()
if(USE_NGHTTP2)
find_package(NGHTTP2)
if(NGHTTP2_FOUND)
- list(APPEND CURL_LIBS ${NGHTTP2_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${NGHTTP2_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${NGHTTP2_PC_REQUIRES})
- include_directories(SYSTEM ${NGHTTP2_INCLUDE_DIRS})
- link_directories(${NGHTTP2_LIBRARY_DIRS})
- if(NGHTTP2_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${NGHTTP2_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::nghttp2)
else()
set(USE_NGHTTP2 OFF)
endif()
else()
message(FATAL_ERROR "ngtcp2 requires a supported TLS-backend")
endif()
- list(APPEND CURL_LIBS ${NGTCP2_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${NGTCP2_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${NGTCP2_PC_REQUIRES})
- include_directories(SYSTEM ${NGTCP2_INCLUDE_DIRS})
- link_directories(${NGTCP2_LIBRARY_DIRS})
- if(NGTCP2_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${NGTCP2_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::ngtcp2)
find_package(NGHTTP3 REQUIRED)
set(USE_NGHTTP3 ON)
- list(APPEND CURL_LIBS ${NGHTTP3_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${NGHTTP3_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${NGHTTP3_PC_REQUIRES})
- include_directories(SYSTEM ${NGHTTP3_INCLUDE_DIRS})
- link_directories(${NGHTTP3_LIBRARY_DIRS})
- if(NGHTTP3_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${NGHTTP3_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::nghttp3)
endif()
option(USE_QUICHE "Use quiche library for HTTP/3 support" OFF)
message(FATAL_ERROR "quiche requires BoringSSL")
endif()
curl_openssl_check_quic()
- list(APPEND CURL_LIBS ${QUICHE_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${QUICHE_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${QUICHE_PC_REQUIRES})
- include_directories(SYSTEM ${QUICHE_INCLUDE_DIRS})
- link_directories(${QUICHE_LIBRARY_DIRS})
- if(QUICHE_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${QUICHE_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::quiche)
if(NOT DEFINED HAVE_QUICHE_CONN_SET_QLOG_FD)
cmake_push_check_state()
- list(APPEND CMAKE_REQUIRED_INCLUDES "${QUICHE_INCLUDE_DIRS}")
- list(APPEND CMAKE_REQUIRED_LIBRARIES "${QUICHE_LIBRARIES}")
+ list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::quiche)
check_symbol_exists("quiche_conn_set_qlog_fd" "quiche.h" HAVE_QUICHE_CONN_SET_QLOG_FD)
cmake_pop_check_state()
endif()
find_package(NGHTTP3 REQUIRED)
set(USE_NGHTTP3 ON)
- list(APPEND CURL_LIBS ${NGHTTP3_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${NGHTTP3_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${NGHTTP3_PC_REQUIRES})
- include_directories(SYSTEM ${NGHTTP3_INCLUDE_DIRS})
- link_directories(${NGHTTP3_LIBRARY_DIRS})
- if(NGHTTP3_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${NGHTTP3_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::nghttp3)
endif()
if(NOT CURL_DISABLE_SRP AND (HAVE_GNUTLS_SRP OR HAVE_OPENSSL_SRP))
find_package(LDAP)
if(LDAP_FOUND)
set(HAVE_LBER_H 1)
- set(CURL_LIBS ${LDAP_LIBRARIES} ${CURL_LIBS})
- list(APPEND CURL_LIBDIRS ${LDAP_LIBRARY_DIRS})
- if(LDAP_PC_REQUIRES)
- set(LIBCURL_PC_REQUIRES_PRIVATE ${LDAP_PC_REQUIRES} ${LIBCURL_PC_REQUIRES_PRIVATE})
- endif()
- include_directories(SYSTEM ${LDAP_INCLUDE_DIRS})
- link_directories(${LDAP_LIBRARY_DIRS})
- if(LDAP_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${LDAP_CFLAGS}")
- endif()
+ set(CURL_LIBS CURL::ldap ${CURL_LIBS})
# LDAP feature checks
list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DLDAP_DEPRECATED=1")
- list(APPEND CMAKE_REQUIRED_LIBRARIES "${LDAP_LIBRARIES}")
- curl_required_libpaths("${LDAP_LIBRARY_DIRS}")
+ list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::ldap)
check_function_exists("ldap_url_parse" HAVE_LDAP_URL_PARSE)
check_function_exists("ldap_init_fd" HAVE_LDAP_INIT_FD)
if(USE_LIBIDN2 AND NOT USE_APPLE_IDN AND NOT USE_WIN32_IDN)
find_package(Libidn2)
if(LIBIDN2_FOUND)
- set(CURL_LIBS ${LIBIDN2_LIBRARIES} ${CURL_LIBS})
- list(APPEND CURL_LIBDIRS ${LIBIDN2_LIBRARY_DIRS})
- set(LIBCURL_PC_REQUIRES_PRIVATE ${LIBIDN2_PC_REQUIRES} ${LIBCURL_PC_REQUIRES_PRIVATE})
- include_directories(SYSTEM ${LIBIDN2_INCLUDE_DIRS})
- link_directories(${LIBIDN2_LIBRARY_DIRS})
- if(LIBIDN2_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${LIBIDN2_CFLAGS}")
- endif()
+ set(CURL_LIBS CURL::libidn2 ${CURL_LIBS})
set(HAVE_IDN2_H 1)
set(HAVE_LIBIDN2 1)
endif()
option(CURL_USE_LIBPSL "Use libpsl" ON)
mark_as_advanced(CURL_USE_LIBPSL)
set(USE_LIBPSL OFF)
-
if(CURL_USE_LIBPSL)
find_package(Libpsl REQUIRED)
- list(APPEND CURL_LIBS ${LIBPSL_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${LIBPSL_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${LIBPSL_PC_REQUIRES})
- include_directories(SYSTEM ${LIBPSL_INCLUDE_DIRS})
- link_directories(${LIBPSL_LIBRARY_DIRS})
- if(LIBPSL_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${LIBPSL_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::libpsl)
set(USE_LIBPSL ON)
endif()
option(CURL_USE_LIBSSH2 "Use libssh2" ON)
mark_as_advanced(CURL_USE_LIBSSH2)
set(USE_LIBSSH2 OFF)
-
if(CURL_USE_LIBSSH2)
find_package(Libssh2)
if(LIBSSH2_FOUND)
- set(CURL_LIBS ${LIBSSH2_LIBRARIES} ${CURL_LIBS}) # keep it before TLS-crypto, compression
- list(APPEND CURL_LIBDIRS ${LIBSSH2_LIBRARY_DIRS})
- set(LIBCURL_PC_REQUIRES_PRIVATE ${LIBSSH2_PC_REQUIRES} ${LIBCURL_PC_REQUIRES_PRIVATE})
- include_directories(SYSTEM ${LIBSSH2_INCLUDE_DIRS})
- link_directories(${LIBSSH2_LIBRARY_DIRS})
- if(LIBSSH2_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${LIBSSH2_CFLAGS}")
- endif()
+ set(CURL_LIBS CURL::libssh2 ${CURL_LIBS}) # keep it before TLS-crypto, compression
set(USE_LIBSSH2 ON)
endif()
endif()
mark_as_advanced(CURL_USE_LIBSSH)
if(NOT USE_LIBSSH2 AND CURL_USE_LIBSSH)
find_package(Libssh REQUIRED)
- set(CURL_LIBS ${LIBSSH_LIBRARIES} ${CURL_LIBS}) # keep it before TLS-crypto, compression
- list(APPEND CURL_LIBDIRS ${LIBSSH_LIBRARY_DIRS})
- set(LIBCURL_PC_REQUIRES_PRIVATE ${LIBSSH_PC_REQUIRES} ${LIBCURL_PC_REQUIRES_PRIVATE})
- include_directories(SYSTEM ${LIBSSH_INCLUDE_DIRS})
- link_directories(${LIBSSH_LIBRARY_DIRS})
- if(LIBSSH_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${LIBSSH_CFLAGS}")
- endif()
+ set(CURL_LIBS CURL::libssh ${CURL_LIBS}) # keep it before TLS-crypto, compression
set(USE_LIBSSH ON)
endif()
mark_as_advanced(CURL_USE_GSASL)
if(CURL_USE_GSASL)
find_package(Libgsasl REQUIRED)
- list(APPEND CURL_LIBS ${LIBGSASL_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${LIBGSASL_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${LIBGSASL_PC_REQUIRES})
- include_directories(SYSTEM ${LIBGSASL_INCLUDE_DIRS})
- link_directories(${LIBGSASL_LIBRARY_DIRS})
- if(LIBGSASL_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${LIBGSASL_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::libgsasl)
set(USE_GSASL ON)
endif()
set(HAVE_GSSAPI ${GSS_FOUND})
if(GSS_FOUND)
- list(APPEND CURL_LIBS ${GSS_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${GSS_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${GSS_PC_REQUIRES})
- include_directories(SYSTEM ${GSS_INCLUDE_DIRS})
- link_directories(${GSS_LIBRARY_DIRS})
- if(GSS_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${GSS_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::gss)
- if(GSS_FLAVOUR STREQUAL "GNU")
+ get_target_property(_gss_flavour CURL::gss INTERFACE_CURL_GSS_FLAVOUR)
+ if(_gss_flavour STREQUAL "GNU")
set(HAVE_GSSGNU 1)
elseif(GSS_VERSION) # MIT
set(CURL_KRB5_VERSION "\"${GSS_VERSION}\"")
message(FATAL_ERROR "libbacktrace requires debug information")
endif()
find_package(Libbacktrace REQUIRED)
- list(APPEND CURL_LIBS ${LIBBACKTRACE_LIBRARIES})
- include_directories(SYSTEM ${LIBBACKTRACE_INCLUDE_DIRS})
+ list(APPEND CURL_LIBS CURL::libbacktrace)
set(USE_BACKTRACE ON)
endif()
message(FATAL_ERROR "Using libuv without debug support enabled is useless")
endif()
find_package(Libuv REQUIRED)
- list(APPEND CURL_LIBS ${LIBUV_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${LIBUV_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${LIBUV_PC_REQUIRES})
- include_directories(SYSTEM ${LIBUV_INCLUDE_DIRS})
- link_directories(${LIBUV_LIBRARY_DIRS})
- if(LIBUV_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${LIBUV_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::libuv)
set(USE_LIBUV ON)
set(HAVE_UV_H ON)
endif()
option(USE_LIBRTMP "Enable librtmp from rtmpdump" OFF)
if(USE_LIBRTMP)
find_package(Librtmp REQUIRED)
- list(APPEND CURL_LIBS ${LIBRTMP_LIBRARIES})
- list(APPEND CURL_LIBDIRS ${LIBRTMP_LIBRARY_DIRS})
- list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${LIBRTMP_PC_REQUIRES})
- include_directories(SYSTEM ${LIBRTMP_INCLUDE_DIRS})
- link_directories(${LIBRTMP_LIBRARY_DIRS})
- if(LIBRTMP_CFLAGS)
- string(APPEND CMAKE_C_FLAGS " ${LIBRTMP_CFLAGS}")
- endif()
+ list(APPEND CURL_LIBS CURL::librtmp)
endif()
option(ENABLE_UNIX_SOCKETS "Enable Unix domain sockets support" ON)
list(APPEND CURL_LIBS ${CURL_COVERAGE_LIBS})
endif()
+# Hack to add some libraries to the end of the library list to make binutils ld
+# for GCC find symbols when linking statically. Necessary for libs detected via
+# CMake's built-in find modules, which CMake adds to the beginning of the lib
+# list on the linker command-line for some reason. This makes them appear
+# before dependencies detected via curl's custom Find modules, and breaks
+# linkers sensitive to lib order. There must be a better solution to this.
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
+ foreach(_lib IN ITEMS OpenSSL::Crypto ZLIB::ZLIB)
+ if(TARGET "${_lib}")
+ add_library(CURL::${_lib} INTERFACE IMPORTED)
+ get_target_property(_libname "${_lib}" LOCATION)
+ set_target_properties(${_lib} PROPERTIES INTERFACE_LINK_LIBRARIES "${_libname}")
+ list(APPEND CURL_LIBS ${_lib})
+ endif()
+ endforeach()
+ if(WIN32)
+ add_library(CURL::win32_winsock INTERFACE IMPORTED)
+ set_target_properties(CURL::win32_winsock PROPERTIES INTERFACE_LINK_LIBRARIES "ws2_32")
+ list(APPEND CURL_LIBS CURL::win32_winsock)
+ endif()
+endif()
+
if(CMAKE_C_COMPILER_ID STREQUAL "MSVC") # MSVC but exclude clang-cl
set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS "-MP") # Parallel compilation
endif()
add_subdirectory(scripts) # for shell completions
-list(REMOVE_DUPLICATES CURL_LIBDIRS)
-
add_subdirectory(lib)
if(BUILD_CURL_EXE)
endif()
endforeach()
- foreach(_libdir IN LISTS _custom_libdirs CURL_LIBDIRS)
- if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
- cmake_path(SET _libdir NORMALIZE "${_libdir}")
- endif()
- list(FIND _sys_libdirs "${_libdir}" _libdir_index)
- if(_libdir_index LESS 0)
- list(APPEND _ldflags "-L${_libdir}")
- endif()
- endforeach()
-
set(_implicit_libs "")
if(NOT MINGW AND NOT UNIX)
set(_implicit_libs "${CMAKE_C_IMPLICIT_LINK_LIBRARIES}")
endif()
- foreach(_lib IN LISTS _implicit_libs _custom_libs CURL_LIBS)
+ set(_explicit_libdirs "")
+ set(LIBCURL_PC_REQUIRES_PRIVATE "")
+ set(LIBCURL_PC_LIBS_PRIVATE_LIST "")
+ foreach(_lib IN LISTS CURL_LIBS _custom_libs _implicit_libs)
if(TARGET "${_lib}")
- set(_libname "${_lib}")
- get_target_property(_imported "${_libname}" IMPORTED)
+ set(_explicit_libs "")
+ get_target_property(_imported "${_lib}" IMPORTED)
if(NOT _imported)
# Reading the LOCATION property on non-imported target will error out.
# Assume the user will not need this information in the .pc file.
continue()
endif()
- get_target_property(_lib "${_libname}" LOCATION)
- if(NOT _lib)
- message(WARNING "Bad lib in library list: ${_libname}")
- continue()
- endif()
- endif()
- if(_lib MATCHES "^-") # '-framework <name>'
- list(APPEND _ldflags "${_lib}")
- elseif(_lib MATCHES "/")
- # This gets a bit more complex, because we want to specify the
- # directory separately, and only once per directory
- if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
- cmake_path(GET _lib PARENT_PATH _libdir)
- cmake_path(GET _lib STEM _libname)
+ if(_lib MATCHES "CURL::")
+ # This is empty for 'CURL::*' targets and safe to ignore.
+ # Explicitly skip this query to avoid CMake v3.18 and older erroring out.
+ set(_libname "")
else()
- get_filename_component(_libdir "${_lib}" DIRECTORY)
- get_filename_component(_libname "${_lib}" NAME_WE)
+ get_target_property(_libname "${_lib}" LOCATION)
endif()
- if(_libname MATCHES "^lib")
- if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
- cmake_path(SET _libdir NORMALIZE "${_libdir}")
+ if(_libname)
+ list(APPEND _explicit_libs "${_libname}")
+ else()
+ get_target_property(_libs "${_lib}" INTERFACE_LINK_LIBRARIES)
+ if(_libs)
+ list(APPEND _explicit_libs "${_libs}")
endif()
- list(FIND _sys_libdirs "${_libdir}" _libdir_index)
- if(_libdir_index LESS 0)
- list(APPEND _ldflags "-L${_libdir}")
+ get_target_property(_libdirs "${_lib}" INTERFACE_LINK_DIRECTORIES)
+ if(_libdirs)
+ list(APPEND _explicit_libdirs "${_libdirs}")
endif()
- string(REGEX REPLACE "^lib" "" _libname "${_libname}")
- list(APPEND LIBCURL_PC_LIBS_PRIVATE "-l${_libname}")
- else()
- list(APPEND LIBCURL_PC_LIBS_PRIVATE "${_lib}")
endif()
+ if(NOT _libname AND NOT _libs AND NOT _libdirs)
+ message(WARNING "Bad lib in library list: ${_lib}")
+ endif()
+ get_target_property(_modules "${_lib}" INTERFACE_LIBCURL_PC_MODULES)
+ if(_modules)
+ list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "${_modules}")
+ endif()
+
+ foreach(_lib IN LISTS _explicit_libs)
+ if(_lib MATCHES "/")
+ # This gets a bit more complex, because we want to specify the
+ # directory separately, and only once per directory
+ if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
+ cmake_path(GET _lib PARENT_PATH _libdir)
+ cmake_path(GET _lib STEM _libname)
+ else()
+ get_filename_component(_libdir "${_lib}" DIRECTORY)
+ get_filename_component(_libname "${_lib}" NAME_WE)
+ endif()
+ if(_libname MATCHES "^lib")
+ if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
+ cmake_path(SET _libdir NORMALIZE "${_libdir}")
+ endif()
+ list(FIND _sys_libdirs "${_libdir}" _libdir_index)
+ if(_libdir_index LESS 0)
+ list(APPEND _ldflags "-L${_libdir}")
+ endif()
+ string(REGEX REPLACE "^lib" "" _libname "${_libname}")
+ list(APPEND LIBCURL_PC_LIBS_PRIVATE "-l${_libname}")
+ list(APPEND LIBCURL_PC_LIBS_PRIVATE_LIST "${_lib}")
+ else()
+ list(APPEND LIBCURL_PC_LIBS_PRIVATE "${_lib}")
+ list(APPEND LIBCURL_PC_LIBS_PRIVATE_LIST "${_lib}")
+ endif()
+ else()
+ list(APPEND LIBCURL_PC_LIBS_PRIVATE "-l${_lib}")
+ list(APPEND LIBCURL_PC_LIBS_PRIVATE_LIST "${_lib}")
+ endif()
+ endforeach()
+ elseif(_lib MATCHES "^-") # '-framework <name>'
+ list(APPEND _ldflags "${_lib}")
+ list(APPEND LIBCURL_PC_LIBS_PRIVATE_LIST "${_lib}")
else()
list(APPEND LIBCURL_PC_LIBS_PRIVATE "-l${_lib}")
+ list(APPEND LIBCURL_PC_LIBS_PRIVATE_LIST "${_lib}")
endif()
endforeach()
+ foreach(_libdir IN LISTS _custom_libdirs _explicit_libdirs)
+ if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
+ cmake_path(SET _libdir NORMALIZE "${_libdir}")
+ endif()
+ list(FIND _sys_libdirs "${_libdir}" _libdir_index)
+ if(_libdir_index LESS 0)
+ list(APPEND _ldflags "-L${_libdir}")
+ endif()
+ endforeach()
+
+ list(REMOVE_DUPLICATES _ldflags)
+
if(LIBCURL_PC_REQUIRES_PRIVATE)
+ list(REMOVE_DUPLICATES LIBCURL_PC_REQUIRES_PRIVATE)
string(REPLACE ";" "," LIBCURL_PC_REQUIRES_PRIVATE "${LIBCURL_PC_REQUIRES_PRIVATE}")
endif()
if(LIBCURL_PC_LIBS_PRIVATE)
# Consumed custom variables:
# CURLVERSION
+ # LIBCURL_PC_LIBS_PRIVATE_LIST
# LIB_NAME
# LIB_SELECTED
+ # LIB_STATIC
# TARGETS_EXPORT_NAME
- # USE_OPENSSL OPENSSL_VERSION_MAJOR
- # HAVE_LIBZ ZLIB_VERSION_MAJOR
# CURL_SUPPORTED_FEATURES_LIST
# CURL_SUPPORTED_PROTOCOLS_LIST
+ # HAVE_BROTLI
+ # HAVE_GSSAPI
+ # HAVE_LIBIDN2
+ # HAVE_LIBZ ZLIB_VERSION_MAJOR
+ # HAVE_ZSTD
+ # USE_ARES
+ # USE_BACKTRACE
+ # USE_GNUTLS
+ # USE_GSASL
+ # USE_LIBPSL
+ # USE_LIBRTMP
+ # USE_LIBSSH
+ # USE_LIBSSH2
+ # USE_LIBUV
+ # USE_MBEDTLS
+ # USE_NGHTTP2
+ # USE_NGHTTP3
+ # USE_NGTCP2
+ # USE_OPENSSL OPENSSL_VERSION_MAJOR
+ # USE_QUICHE
+ # USE_RUSTLS
+ # USE_WIN32_LDAP CURL_DISABLE_LDAP
+ # USE_WOLFSSL
+ # _win32_winsock
configure_package_config_file("CMake/curl-config.cmake.in"
"${_project_config}"
INSTALL_DESTINATION ${_install_cmake_dir}
DESTINATION ${_install_cmake_dir})
endif()
- install(FILES ${_version_config} ${_project_config}
+ install(
+ FILES
+ ${_version_config}
+ ${_project_config}
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindBrotli.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindCares.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindGSS.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindGnuTLS.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLDAP.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibbacktrace.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibgsasl.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibidn2.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibpsl.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibrtmp.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibssh.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibssh2.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibuv.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindMbedTLS.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindNGHTTP2.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindNGHTTP3.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindNGTCP2.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindNettle.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindQuiche.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindRustls.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindWolfSSL.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindZstd.cmake"
DESTINATION ${_install_cmake_dir})
if(NOT TARGET curl_uninstall)
# special libcurlu library just for unittests
add_library(curlu STATIC EXCLUDE_FROM_ALL ${HHEADERS} ${CSOURCES})
target_compile_definitions(curlu PUBLIC "CURL_STATICLIB" "UNITTESTS")
- target_link_libraries(curlu PRIVATE ${CURL_LIBS})
+ target_link_libraries(curlu PUBLIC ${CURL_LIBS})
# There is plenty of parallelism when building the testdeps target.
# Override the curlu batch size with the maximum to optimize performance.
set_target_properties(curlu PROPERTIES UNITY_BUILD_BATCH_SIZE 0 C_CLANG_TIDY "")
set_target_properties(${LIB_STATIC} PROPERTIES
PREFIX "" OUTPUT_NAME "${LIBCURL_OUTPUT_NAME}"
SUFFIX "${STATIC_LIB_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}"
- INTERFACE_COMPILE_DEFINITIONS "CURL_STATICLIB"
- INTERFACE_LINK_DIRECTORIES "${CURL_LIBDIRS}")
+ INTERFACE_COMPILE_DEFINITIONS "CURL_STATICLIB")
if(CURL_HIDES_PRIVATE_SYMBOLS)
set_property(TARGET ${LIB_STATIC} APPEND PROPERTY COMPILE_OPTIONS "${CURL_CFLAG_SYMBOLS_HIDE}")
set_property(TARGET ${LIB_STATIC} APPEND PROPERTY COMPILE_DEFINITIONS "CURL_HIDDEN_SYMBOLS")
target_include_directories(${LIB_STATIC} INTERFACE
"$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
"$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>")
+
+ # CMake before CMP0099 (CMake 3.17 2020-03-20) did not propagate libdirs to
+ # targets. It expected libs to have an absolute filename. As a workaround,
+ # manually apply dependency libdirs, for CMake consumers without this policy.
+ if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.17)
+ cmake_policy(GET CMP0099 _has_CMP0099) # https://cmake.org/cmake/help/latest/policy/CMP0099.html
+ endif()
+ if(NOT _has_CMP0099 AND CMAKE_VERSION VERSION_GREATER_EQUAL 3.13 AND CURL_LIBS)
+ set(_libdirs "")
+ foreach(_lib IN LISTS CURL_LIBS)
+ if(TARGET "${_lib}")
+ get_target_property(_libdir "${_lib}" INTERFACE_LINK_DIRECTORIES)
+ if(_libdir)
+ list(APPEND _libdirs "${_libdir}")
+ endif()
+ endif()
+ endforeach()
+ if(_libdirs)
+ target_link_directories(${LIB_STATIC} INTERFACE ${_libdirs})
+ endif()
+ endif()
endif()
if(BUILD_SHARED_LIBS)
add_executable(${PROJECT_NAME}::${EXE_NAME} ALIAS ${EXE_NAME})
add_executable(curlinfo EXCLUDE_FROM_ALL "curlinfo.c")
+target_link_libraries(curlinfo PRIVATE ${CURL_LIBS})
set_target_properties(curlinfo PROPERTIES UNITY_BUILD OFF)
# special libcurltool library just for unittests
add_library(curltool STATIC EXCLUDE_FROM_ALL ${CURL_CFILES} ${CURL_HFILES} ${_curlx_cfiles_lib} ${_curlx_hfiles_lib})
target_compile_definitions(curltool PUBLIC "CURL_STATICLIB" "UNITTESTS")
-target_link_libraries(curltool PRIVATE ${CURL_LIBS})
+target_link_libraries(curltool PUBLIC ${CURL_LIBS})
set_target_properties(curltool PROPERTIES C_CLANG_TIDY "")
if(CURL_HAS_LTO)
"${cmake_provider}" --install "${bldp}"
else
mkdir "${bldp}"; cd "${bldp}"
- "${cmake_provider}" "${src}" -G "${gen}" ${cmake_opts} -DCURL_USE_PKGCONFIG=OFF ${TEST_CMAKE_FLAGS:-} "$@" \
+ "${cmake_provider}" "${src}" -G "${gen}" ${cmake_opts} ${TEST_CMAKE_FLAGS:-} "$@" \
-DBUILD_SHARED_LIBS=ON \
-DBUILD_STATIC_LIBS=ON \
-DCMAKE_INSTALL_PREFIX="${prefix}"
projects / thirdparty / curl.git / commitdiff
