cmake: define dependencies as `IMPORTED` interface targets
Rework the way curl's custom Find modules advertise their properties.
Before this patch, Find modules returned detected dependency properties
(header dirs, libs, libdirs, C flags, etc.) via global variables. curl's
main `CMakeLists.txt` copied their values into global lists, which it
later applied to targets. This solution worked internally, but it was
unsuited for the public, distributed `CURLConfig.cmake` and publishing
curl's Find modules with it, due to polluting the namespace of consumer
projects. It's also impractical to apply the many individual variables
to every targets depending on libcurl.
To allow using Find modules in consumer projects, this patch makes them
define as imported interface targets, named `CURL::<dependency>`. Then
store dependency information as target properties. It avoids namespace
pollution and makes the dependency information apply automatically
to all targets using `CURL::libcurl_static`.
Find modules continue to return `*_FOUND` and `*_VERSION` variables.
For dependencies detected via `pkg-config`, CMake 3.16+ is recommended.
Older CMake versions have a varying degree of support for
propagating/handling library directories. This may cause issues in envs
where dependencies reside in non-system locations and detected via
`pkg-config` (e.g. macOS + Homebrew). Use `CURL_USE_PKGCONFIG=OFF`
to fix these issues. Or upgrade to newer CMake, or link libcurl
dynamically.
Also:
- re-enable `pkg-config` for old cmake `find_library()` integration
tests.
- make `curlinfo` build after these changes.
- distribute local Find modules.
- export the raw list of lib dependencies via `CURL_LIBRARIES_PRIVATE`.
- `CURLconfig.cmake`: use curl's Find modules to detect dependencies in
the consumer env.
- add custom property to target property debug function.
- the curl build process no longer modifies `CMAKE_C_FLAGS`.
Follow-up to e86542038dda88dadf8959584e803895f979310c #17047
Ref: #14930
Ref: https://github.com/libssh2/libssh2/pull/1535
Ref: https://github.com/libssh2/libssh2/pull/1571
Ref: https://github.com/libssh2/libssh2/pull/1581
Ref: https://github.com/libssh2/libssh2/pull/1623
Closes #16973
diff --git a/CMake/FindBrotli.cmake b/CMake/FindBrotli.cmake
index d2b50d9..981b30c 100644
--- a/CMake/FindBrotli.cmake
+++ b/CMake/FindBrotli.cmake
@@ -29,31 +29,27 @@
# - `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")
@@ -68,9 +64,25 @@
)
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()
diff --git a/CMake/FindCares.cmake b/CMake/FindCares.cmake
index ae2db52..4a20bc0 100644
--- a/CMake/FindCares.cmake
+++ b/CMake/FindCares.cmake
@@ -25,32 +25,29 @@
#
# 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")
@@ -85,13 +82,29 @@
)
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()
diff --git a/CMake/FindGSS.cmake b/CMake/FindGSS.cmake
index 89545aa..106c4c4 100644
--- a/CMake/FindGSS.cmake
+++ b/CMake/FindGSS.cmake
@@ -25,19 +25,15 @@
#
# 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")
@@ -140,7 +136,7 @@
# 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?)
@@ -156,7 +152,7 @@
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")
@@ -174,14 +170,14 @@
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)
@@ -193,34 +189,28 @@
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")
@@ -234,9 +224,9 @@
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)
@@ -248,8 +238,8 @@
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(GSS
REQUIRED_VARS
- GSS_FLAVOUR
- GSS_LIBRARIES
+ _gss_flavour
+ _gss_LIBRARIES
VERSION_VAR
GSS_VERSION
FAIL_MESSAGE
@@ -266,3 +256,20 @@
_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()
diff --git a/CMake/FindGnuTLS.cmake b/CMake/FindGnuTLS.cmake
index 4de4f82..fff57b2 100644
--- a/CMake/FindGnuTLS.cmake
+++ b/CMake/FindGnuTLS.cmake
@@ -25,32 +25,29 @@
#
# 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")
@@ -75,9 +72,25 @@
)
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()
diff --git a/CMake/FindLDAP.cmake b/CMake/FindLDAP.cmake
index 0a897aa..2f5cc71 100644
--- a/CMake/FindLDAP.cmake
+++ b/CMake/FindLDAP.cmake
@@ -29,32 +29,28 @@
# - `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
@@ -99,9 +95,25 @@
)
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()
diff --git a/CMake/FindLibbacktrace.cmake b/CMake/FindLibbacktrace.cmake
index 444c5f9..c6f7b70 100644
--- a/CMake/FindLibbacktrace.cmake
+++ b/CMake/FindLibbacktrace.cmake
@@ -25,14 +25,13 @@
#
# 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")
@@ -45,8 +44,22 @@
)
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)
diff --git a/CMake/FindLibgsasl.cmake b/CMake/FindLibgsasl.cmake
index e584f75..5ddf957 100644
--- a/CMake/FindLibgsasl.cmake
+++ b/CMake/FindLibgsasl.cmake
@@ -25,32 +25,28 @@
#
# 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")
@@ -75,9 +71,25 @@
)
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()
diff --git a/CMake/FindLibidn2.cmake b/CMake/FindLibidn2.cmake
index 9112428..336a7f7 100644
--- a/CMake/FindLibidn2.cmake
+++ b/CMake/FindLibidn2.cmake
@@ -25,32 +25,29 @@
#
# 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")
@@ -75,9 +72,25 @@
)
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()
diff --git a/CMake/FindLibpsl.cmake b/CMake/FindLibpsl.cmake
index 13740fa..9b1a0cd 100644
--- a/CMake/FindLibpsl.cmake
+++ b/CMake/FindLibpsl.cmake
@@ -25,32 +25,29 @@
#
# 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")
@@ -75,9 +72,25 @@
)
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()
diff --git a/CMake/FindLibrtmp.cmake b/CMake/FindLibrtmp.cmake
index be97579..0705385 100644
--- a/CMake/FindLibrtmp.cmake
+++ b/CMake/FindLibrtmp.cmake
@@ -25,32 +25,29 @@
#
# 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")
@@ -85,8 +82,8 @@
)
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)
@@ -94,10 +91,26 @@
# 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()
diff --git a/CMake/FindLibssh.cmake b/CMake/FindLibssh.cmake
index cb895aa..ad1248f 100644
--- a/CMake/FindLibssh.cmake
+++ b/CMake/FindLibssh.cmake
@@ -25,32 +25,29 @@
#
# 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")
@@ -85,13 +82,29 @@
)
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()
diff --git a/CMake/FindLibssh2.cmake b/CMake/FindLibssh2.cmake
index 0841553..330611b 100644
--- a/CMake/FindLibssh2.cmake
+++ b/CMake/FindLibssh2.cmake
@@ -25,32 +25,29 @@
#
# 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")
@@ -75,9 +72,25 @@
)
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()
diff --git a/CMake/FindLibuv.cmake b/CMake/FindLibuv.cmake
index 2565ba3..f9d614b 100644
--- a/CMake/FindLibuv.cmake
+++ b/CMake/FindLibuv.cmake
@@ -25,32 +25,29 @@
#
# 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")
@@ -85,9 +82,25 @@
)
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()
diff --git a/CMake/FindMbedTLS.cmake b/CMake/FindMbedTLS.cmake
index 11b4f07..97201ab 100644
--- a/CMake/FindMbedTLS.cmake
+++ b/CMake/FindMbedTLS.cmake
@@ -25,20 +25,16 @@
#
# 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.")
@@ -46,7 +42,7 @@
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
@@ -54,16 +50,16 @@
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")
@@ -92,9 +88,25 @@
)
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()
diff --git a/CMake/FindNGHTTP2.cmake b/CMake/FindNGHTTP2.cmake
index 1ccf641..8304345 100644
--- a/CMake/FindNGHTTP2.cmake
+++ b/CMake/FindNGHTTP2.cmake
@@ -25,31 +25,28 @@
#
# 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")
@@ -74,9 +71,25 @@
)
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()
diff --git a/CMake/FindNGHTTP3.cmake b/CMake/FindNGHTTP3.cmake
index fba2c57..37ebfe1 100644
--- a/CMake/FindNGHTTP3.cmake
+++ b/CMake/FindNGHTTP3.cmake
@@ -25,31 +25,28 @@
#
# 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")
@@ -74,9 +71,25 @@
)
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()
diff --git a/CMake/FindNGTCP2.cmake b/CMake/FindNGTCP2.cmake
index cda3b0e..416ea45 100644
--- a/CMake/FindNGTCP2.cmake
+++ b/CMake/FindNGTCP2.cmake
@@ -44,15 +44,11 @@
# - `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 "")
@@ -71,9 +67,9 @@
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)
@@ -81,14 +77,14 @@
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")
@@ -128,8 +124,8 @@
)
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)
@@ -139,3 +135,19 @@
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()
diff --git a/CMake/FindNettle.cmake b/CMake/FindNettle.cmake
index 7f2f69c..d22865f 100644
--- a/CMake/FindNettle.cmake
+++ b/CMake/FindNettle.cmake
@@ -25,32 +25,29 @@
#
# 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")
@@ -80,9 +77,25 @@
)
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()
diff --git a/CMake/FindQuiche.cmake b/CMake/FindQuiche.cmake
index 934cf9f..22482d7 100644
--- a/CMake/FindQuiche.cmake
+++ b/CMake/FindQuiche.cmake
@@ -25,32 +25,29 @@
#
# 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")
@@ -63,9 +60,25 @@
)
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()
diff --git a/CMake/FindRustls.cmake b/CMake/FindRustls.cmake
index a29ce5f..37b99be 100644
--- a/CMake/FindRustls.cmake
+++ b/CMake/FindRustls.cmake
@@ -25,34 +25,31 @@
#
# 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")
@@ -65,8 +62,8 @@
)
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)
@@ -79,31 +76,47 @@
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()
diff --git a/CMake/FindWolfSSL.cmake b/CMake/FindWolfSSL.cmake
index 4d172c0..3a3c05f 100644
--- a/CMake/FindWolfSSL.cmake
+++ b/CMake/FindWolfSSL.cmake
@@ -25,18 +25,14 @@
#
# 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.")
@@ -47,19 +43,20 @@
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")
@@ -84,8 +81,8 @@
)
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)
@@ -98,19 +95,35 @@
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()
diff --git a/CMake/FindZstd.cmake b/CMake/FindZstd.cmake
index 655f0cc..954a827 100644
--- a/CMake/FindZstd.cmake
+++ b/CMake/FindZstd.cmake
@@ -25,18 +25,14 @@
#
# 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.")
@@ -47,19 +43,20 @@
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")
@@ -94,9 +91,25 @@
)
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()
diff --git a/CMake/Utilities.cmake b/CMake/Utilities.cmake
index 335713c..efa28b7 100644
--- a/CMake/Utilities.cmake
+++ b/CMake/Utilities.cmake
@@ -59,6 +59,7 @@
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")
diff --git a/CMake/curl-config.cmake.in b/CMake/curl-config.cmake.in
index d1582b8..9994919 100644
--- a/CMake/curl-config.cmake.in
+++ b/CMake/curl-config.cmake.in
@@ -23,7 +23,12 @@
###########################################################################
@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@")
@@ -34,6 +39,97 @@
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")
@@ -45,9 +141,31 @@
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@")
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5d6e7ca..2af1679 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -358,23 +358,14 @@
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)
@@ -762,7 +753,7 @@
# 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)
@@ -809,14 +800,7 @@
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)
@@ -828,9 +812,7 @@
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()
@@ -840,14 +822,7 @@
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)
@@ -857,26 +832,11 @@
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)
@@ -885,9 +845,7 @@
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)
@@ -899,23 +857,14 @@
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()
@@ -944,21 +893,14 @@
# 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)
@@ -966,14 +908,7 @@
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()
@@ -993,9 +928,7 @@
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()
@@ -1097,14 +1030,7 @@
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()
@@ -1140,25 +1066,11 @@
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)
@@ -1173,18 +1085,10 @@
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()
@@ -1200,14 +1104,7 @@
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))
@@ -1235,22 +1132,12 @@
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)
@@ -1312,14 +1199,7 @@
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()
@@ -1329,17 +1209,9 @@
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()
@@ -1347,18 +1219,10 @@
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()
@@ -1368,14 +1232,7 @@
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()
@@ -1383,14 +1240,7 @@
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()
@@ -1402,16 +1252,10 @@
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}\"")
@@ -1431,8 +1275,7 @@
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()
@@ -1443,14 +1286,7 @@
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()
@@ -1458,14 +1294,7 @@
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)
@@ -1964,6 +1793,28 @@
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()
@@ -2028,8 +1879,6 @@
add_subdirectory(scripts) # for shell completions
-list(REMOVE_DUPLICATES CURL_LIBDIRS)
-
add_subdirectory(lib)
if(BUILD_CURL_EXE)
@@ -2252,7 +2101,91 @@
endif()
endforeach()
- foreach(_libdir IN LISTS _custom_libdirs CURL_LIBDIRS)
+ set(_implicit_libs "")
+ if(NOT MINGW AND NOT UNIX)
+ set(_implicit_libs "${CMAKE_C_IMPLICIT_LINK_LIBRARIES}")
+ endif()
+
+ 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(_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()
+ 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_target_property(_libname "${_lib}" LOCATION)
+ endif()
+ if(_libname)
+ list(APPEND _explicit_libs "${_libname}")
+ else()
+ get_target_property(_libs "${_lib}" INTERFACE_LINK_LIBRARIES)
+ if(_libs)
+ list(APPEND _explicit_libs "${_libs}")
+ endif()
+ get_target_property(_libdirs "${_lib}" INTERFACE_LINK_DIRECTORIES)
+ if(_libdirs)
+ list(APPEND _explicit_libdirs "${_libdirs}")
+ endif()
+ 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()
@@ -2262,57 +2195,10 @@
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)
- if(TARGET "${_lib}")
- set(_libname "${_lib}")
- get_target_property(_imported "${_libname}" 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)
- 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}")
- else()
- list(APPEND LIBCURL_PC_LIBS_PRIVATE "${_lib}")
- endif()
- else()
- list(APPEND LIBCURL_PC_LIBS_PRIVATE "-l${_lib}")
- 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)
@@ -2424,13 +2310,37 @@
# 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}
@@ -2442,7 +2352,32 @@
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)
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index b468eec..5ce288a 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -44,7 +44,7 @@
# 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 "")
@@ -151,8 +151,7 @@
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")
@@ -174,6 +173,27 @@
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)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 33f288b..7d28434 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -109,12 +109,13 @@
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)
diff --git a/tests/cmake/test.sh b/tests/cmake/test.sh
index 4512354..a871372 100755
--- a/tests/cmake/test.sh
+++ b/tests/cmake/test.sh
@@ -114,7 +114,7 @@
"${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}"
