# SPDX-License-Identifier: curl
#
###########################################################################
-find_path(BEARSSL_INCLUDE_DIRS bearssl.h)
+# Find the bearssl library
+#
+# Result Variables:
+#
+# BEARSSL_FOUND System has bearssl
+# BEARSSL_INCLUDE_DIRS The bearssl include directories
+# BEARSSL_LIBRARIES The bearssl library names
+
+find_path(BEARSSL_INCLUDE_DIRS "bearssl.h")
-find_library(BEARSSL_LIBRARY bearssl)
+find_library(BEARSSL_LIBRARY "bearssl")
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(BEARSSL DEFAULT_MSG
- BEARSSL_INCLUDE_DIRS BEARSSL_LIBRARY)
+ BEARSSL_INCLUDE_DIRS
+ BEARSSL_LIBRARY
+)
mark_as_advanced(BEARSSL_INCLUDE_DIRS BEARSSL_LIBRARY)
# SPDX-License-Identifier: curl
#
###########################################################################
+# Find the brotli library
+#
+# Result Variables:
+#
+# BROTLI_FOUND System has brotli
+# BROTLI_INCLUDE_DIRS The brotli include directories
+# BROTLI_LIBRARIES The brotli library names
+
include(FindPackageHandleStandardArgs)
find_path(BROTLI_INCLUDE_DIR "brotli/decode.h")
-find_library(BROTLICOMMON_LIBRARY NAMES brotlicommon)
-find_library(BROTLIDEC_LIBRARY NAMES brotlidec)
+find_library(BROTLICOMMON_LIBRARY NAMES "brotlicommon")
+find_library(BROTLIDEC_LIBRARY NAMES "brotlidec")
find_package_handle_standard_args(Brotli
FOUND_VAR
BROTLI_FOUND
REQUIRED_VARS
+ BROTLI_INCLUDE_DIR
BROTLIDEC_LIBRARY
BROTLICOMMON_LIBRARY
- BROTLI_INCLUDE_DIR
FAIL_MESSAGE
"Could NOT find Brotli"
)
# SPDX-License-Identifier: curl
#
###########################################################################
-# - Find c-ares
-# Find the c-ares includes and library
-# This module defines
-# CARES_INCLUDE_DIR, where to find ares.h, etc.
-# CARES_LIBRARIES, the libraries needed to use c-ares.
-# CARES_FOUND, If false, do not try to use c-ares.
-# also defined, but not for general use are
-# CARES_LIBRARY, where to find the c-ares library.
+# Find the c-ares library
+#
+# Result Variables:
+#
+# CARES_FOUND System has c-ares
+# CARES_INCLUDE_DIR The c-ares include directory
+# CARES_LIBRARY The c-ares library name
-find_path(CARES_INCLUDE_DIR ares.h)
+find_path(CARES_INCLUDE_DIR "ares.h")
-set(CARES_NAMES ${CARES_NAMES} cares)
find_library(CARES_LIBRARY
- NAMES ${CARES_NAMES}
+ NAMES ${CARES_NAMES} "cares"
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(CARES
- REQUIRED_VARS CARES_LIBRARY CARES_INCLUDE_DIR)
-
-mark_as_advanced(
- CARES_LIBRARY
- CARES_INCLUDE_DIR
+ REQUIRED_VARS
+ CARES_INCLUDE_DIR
+ CARES_LIBRARY
)
+
+mark_as_advanced(CARES_INCLUDE_DIR CARES_LIBRARY)
# SPDX-License-Identifier: curl
#
###########################################################################
-# - Try to find the GSS Kerberos library
-# Once done this defines
+# Find the GSS Kerberos library
#
-# GSS_ROOT_DIR - Set this variable to the root installation of GSS
+# Input variables:
#
-# Read-Only variables:
-# GSS_FOUND - system has the Heimdal library
-# GSS_FLAVOUR - "MIT" or "Heimdal" if anything found.
-# GSS_INCLUDE_DIR - the Heimdal include directory
-# GSS_LIBRARIES - The libraries needed to use GSS
-# GSS_LINK_DIRECTORIES - Directories to add to linker search path
-# GSS_LINKER_FLAGS - Additional linker flags
-# GSS_COMPILER_FLAGS - Additional 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"
-
-set(_MIT_MODNAME mit-krb5-gssapi)
-set(_HEIMDAL_MODNAME heimdal-gssapi)
+# GSS_ROOT_DIR Set this variable to the root installation of GSS
+#
+# Result Variables:
+#
+# GSS_FOUND System has the Heimdal library
+# GSS_FLAVOUR "MIT" or "Heimdal" if anything found
+# GSS_INCLUDE_DIR the Heimdal include directory
+# GSS_LIBRARIES The libraries needed to use GSS
+# GSS_LINK_DIRECTORIES Directories to add to linker search path
+# GSS_LINKER_FLAGS Additional linker flags
+# GSS_COMPILER_FLAGS Additional 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"
+
+set(_mit_modname "mit-krb5-gssapi")
+set(_heimdal_modname "heimdal-gssapi")
include(CheckIncludeFile)
include(CheckIncludeFiles)
include(CheckTypeSize)
-set(_GSS_ROOT_HINTS
+set(_gss_root_hints
"${GSS_ROOT_DIR}"
"$ENV{GSS_ROOT_DIR}"
)
if(NOT GSS_ROOT_DIR AND NOT "$ENV{GSS_ROOT_DIR}")
if(UNIX)
find_package(PkgConfig QUIET)
- pkg_search_module(_GSS ${_MIT_MODNAME} ${_HEIMDAL_MODNAME})
- list(APPEND _GSS_ROOT_HINTS "${_GSS_PREFIX}")
+ pkg_search_module(_GSS ${_mit_modname} ${_heimdal_modname})
+ list(APPEND _gss_root_hints "${_GSS_PREFIX}")
elseif(WIN32)
- list(APPEND _GSS_ROOT_HINTS "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MIT\\Kerberos;InstallDir]")
+ list(APPEND _gss_root_hints "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MIT\\Kerberos;InstallDir]")
endif()
endif()
if(NOT _GSS_FOUND) # Not found by pkg-config. Let us take more traditional approach.
- find_file(_GSS_CONFIGURE_SCRIPT
+ find_file(_gss_configure_script
NAMES
"krb5-config"
HINTS
- ${_GSS_ROOT_HINTS}
+ ${_gss_root_hints}
PATH_SUFFIXES
- bin
+ "bin"
NO_CMAKE_PATH
NO_CMAKE_ENVIRONMENT_PATH
)
# If not found in user-supplied directories, maybe system knows better
- find_file(_GSS_CONFIGURE_SCRIPT
+ find_file(_gss_configure_script
NAMES
"krb5-config"
PATH_SUFFIXES
- bin
+ "bin"
)
- if(_GSS_CONFIGURE_SCRIPT)
+ if(_gss_configure_script)
execute_process(
- COMMAND ${_GSS_CONFIGURE_SCRIPT} "--cflags" "gssapi"
+ COMMAND ${_gss_configure_script} "--cflags" "gssapi"
OUTPUT_VARIABLE _GSS_CFLAGS
- RESULT_VARIABLE _GSS_CONFIGURE_FAILED
+ RESULT_VARIABLE _gss_configure_failed
OUTPUT_STRIP_TRAILING_WHITESPACE
)
- message(STATUS "CFLAGS: ${_GSS_CFLAGS}")
- if(NOT _GSS_CONFIGURE_FAILED) # 0 means success
+ message(STATUS "FindGSS CFLAGS: ${_GSS_CFLAGS}")
+ if(NOT _gss_configure_failed) # 0 means success
# Should also work in an odd case when multiple directories are given
string(STRIP "${_GSS_CFLAGS}" _GSS_CFLAGS)
string(REGEX REPLACE " +-I" ";" _GSS_CFLAGS "${_GSS_CFLAGS}")
string(REGEX REPLACE " +-([^I][^ \\t;]*)" ";-\\1" _GSS_CFLAGS "${_GSS_CFLAGS}")
- foreach(_flag ${_GSS_CFLAGS})
+ foreach(_flag IN LISTS _GSS_CFLAGS)
if(_flag MATCHES "^-I.*")
string(REGEX REPLACE "^-I" "" _val "${_flag}")
list(APPEND _GSS_INCLUDE_DIRS "${_val}")
endif()
execute_process(
- COMMAND ${_GSS_CONFIGURE_SCRIPT} "--libs" "gssapi"
- OUTPUT_VARIABLE _GSS_LIB_FLAGS
- RESULT_VARIABLE _GSS_CONFIGURE_FAILED
+ COMMAND ${_gss_configure_script} "--libs" "gssapi"
+ OUTPUT_VARIABLE _gss_lib_flags
+ RESULT_VARIABLE _gss_configure_failed
OUTPUT_STRIP_TRAILING_WHITESPACE
)
- message(STATUS "LDFLAGS: ${_GSS_LIB_FLAGS}")
+ message(STATUS "FindGSS LDFLAGS: ${_gss_lib_flags}")
- if(NOT _GSS_CONFIGURE_FAILED) # 0 means success
+ if(NOT _gss_configure_failed) # 0 means success
# This script gives us libraries and link directories. Blah. We have to deal with it.
- string(STRIP "${_GSS_LIB_FLAGS}" _GSS_LIB_FLAGS)
- string(REGEX REPLACE " +-(L|l)" ";-\\1" _GSS_LIB_FLAGS "${_GSS_LIB_FLAGS}")
- string(REGEX REPLACE " +-([^Ll][^ \\t;]*)" ";-\\1" _GSS_LIB_FLAGS "${_GSS_LIB_FLAGS}")
+ string(STRIP "${_gss_lib_flags}" _gss_lib_flags)
+ string(REGEX REPLACE " +-(L|l)" ";-\\1" _gss_lib_flags "${_gss_lib_flags}")
+ string(REGEX REPLACE " +-([^Ll][^ \\t;]*)" ";-\\1" _gss_lib_flags "${_gss_lib_flags}")
- foreach(_flag ${_GSS_LIB_FLAGS})
+ foreach(_flag IN LISTS _gss_lib_flags)
if(_flag MATCHES "^-l.*")
string(REGEX REPLACE "^-l" "" _val "${_flag}")
list(APPEND _GSS_LIBRARIES "${_val}")
endif()
execute_process(
- COMMAND ${_GSS_CONFIGURE_SCRIPT} "--version"
+ COMMAND ${_gss_configure_script} "--version"
OUTPUT_VARIABLE _GSS_VERSION
- RESULT_VARIABLE _GSS_CONFIGURE_FAILED
+ RESULT_VARIABLE _gss_configure_failed
OUTPUT_STRIP_TRAILING_WHITESPACE
)
# Older versions may not have the "--version" parameter. In this case we just do not care.
- if(_GSS_CONFIGURE_FAILED)
+ if(_gss_configure_failed)
set(_GSS_VERSION 0)
endif()
execute_process(
- COMMAND ${_GSS_CONFIGURE_SCRIPT} "--vendor"
- OUTPUT_VARIABLE _GSS_VENDOR
- RESULT_VARIABLE _GSS_CONFIGURE_FAILED
+ COMMAND ${_gss_configure_script} "--vendor"
+ OUTPUT_VARIABLE _gss_vendor
+ RESULT_VARIABLE _gss_configure_failed
OUTPUT_STRIP_TRAILING_WHITESPACE
)
# Older versions may not have the "--vendor" parameter. In this case we just do not care.
- if(_GSS_CONFIGURE_FAILED)
+ if(_gss_configure_failed)
set(GSS_FLAVOUR "Heimdal") # most probably, should not really matter
else()
- if(_GSS_VENDOR MATCHES ".*H|heimdal.*")
+ if(_gss_vendor MATCHES ".*H|heimdal.*")
set(GSS_FLAVOUR "Heimdal")
else()
set(GSS_FLAVOUR "MIT")
NAMES
"gssapi/gssapi.h"
HINTS
- ${_GSS_ROOT_HINTS}
+ ${_gss_root_hints}
PATH_SUFFIXES
- include
- inc
+ "include"
+ "inc"
)
if(_GSS_INCLUDE_DIRS) # jay, we have found something
set(CMAKE_REQUIRED_INCLUDES "${_GSS_INCLUDE_DIRS}")
- check_include_files( "gssapi/gssapi_generic.h;gssapi/gssapi_krb5.h" _GSS_HAVE_MIT_HEADERS)
+ check_include_files("gssapi/gssapi_generic.h;gssapi/gssapi_krb5.h" _GSS_HAVE_MIT_HEADERS)
if(_GSS_HAVE_MIT_HEADERS)
set(GSS_FLAVOUR "MIT")
else()
# Prevent compiling the header - just check if we can include it
- list(APPEND CMAKE_REQUIRED_DEFINITIONS -D__ROKEN_H__)
- check_include_file( "roken.h" _GSS_HAVE_ROKEN_H)
+ list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D__ROKEN_H__")
+ check_include_file("roken.h" _GSS_HAVE_ROKEN_H)
- check_include_file( "heimdal/roken.h" _GSS_HAVE_HEIMDAL_ROKEN_H)
+ check_include_file("heimdal/roken.h" _GSS_HAVE_HEIMDAL_ROKEN_H)
if(_GSS_HAVE_ROKEN_H OR _GSS_HAVE_HEIMDAL_ROKEN_H)
set(GSS_FLAVOUR "Heimdal")
endif()
- list(REMOVE_ITEM CMAKE_REQUIRED_DEFINITIONS -D__ROKEN_H__)
+ list(REMOVE_ITEM CMAKE_REQUIRED_DEFINITIONS "-D__ROKEN_H__")
endif()
else()
# I am not convinced if this is the right way but this is what autotools do at the moment
NAMES
"gssapi.h"
HINTS
- ${_GSS_ROOT_HINTS}
+ ${_gss_root_hints}
PATH_SUFFIXES
- include
- inc
+ "include"
+ "inc"
)
if(_GSS_INCLUDE_DIRS)
# If we have headers, check if we can link libraries
if(GSS_FLAVOUR)
- set(_GSS_LIBDIR_SUFFIXES "")
- set(_GSS_LIBDIR_HINTS ${_GSS_ROOT_HINTS})
- get_filename_component(_GSS_CALCULATED_POTENTIAL_ROOT "${_GSS_INCLUDE_DIRS}" PATH)
- list(APPEND _GSS_LIBDIR_HINTS ${_GSS_CALCULATED_POTENTIAL_ROOT})
+ set(_gss_libdir_suffixes "")
+ set(_gss_libdir_hints ${_gss_root_hints})
+ get_filename_component(_gss_calculated_potential_root "${_GSS_INCLUDE_DIRS}" PATH)
+ list(APPEND _gss_libdir_hints ${_gss_calculated_potential_root})
if(WIN32)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
- list(APPEND _GSS_LIBDIR_SUFFIXES "lib/AMD64")
+ list(APPEND _gss_libdir_suffixes "lib/AMD64")
if(GSS_FLAVOUR STREQUAL "MIT")
- set(_GSS_LIBNAME "gssapi64")
+ set(_gss_libname "gssapi64")
else()
- set(_GSS_LIBNAME "libgssapi")
+ set(_gss_libname "libgssapi")
endif()
else()
- list(APPEND _GSS_LIBDIR_SUFFIXES "lib/i386")
+ list(APPEND _gss_libdir_suffixes "lib/i386")
if(GSS_FLAVOUR STREQUAL "MIT")
- set(_GSS_LIBNAME "gssapi32")
+ set(_gss_libname "gssapi32")
else()
- set(_GSS_LIBNAME "libgssapi")
+ set(_gss_libname "libgssapi")
endif()
endif()
else()
- list(APPEND _GSS_LIBDIR_SUFFIXES "lib;lib64") # those suffixes are not checked for HINTS
+ list(APPEND _gss_libdir_suffixes "lib;lib64") # those suffixes are not checked for HINTS
if(GSS_FLAVOUR STREQUAL "MIT")
- set(_GSS_LIBNAME "gssapi_krb5")
+ set(_gss_libname "gssapi_krb5")
else()
- set(_GSS_LIBNAME "gssapi")
+ set(_gss_libname "gssapi")
endif()
endif()
find_library(_GSS_LIBRARIES
NAMES
- ${_GSS_LIBNAME}
+ ${_gss_libname}
HINTS
- ${_GSS_LIBDIR_HINTS}
+ ${_gss_libdir_hints}
PATH_SUFFIXES
- ${_GSS_LIBDIR_SUFFIXES}
+ ${_gss_libdir_suffixes}
)
endif()
endif()
else()
- if(_GSS_MODULE_NAME STREQUAL _MIT_MODNAME OR _GSS_${_MIT_MODNAME}_VERSION) # _GSS_MODULE_NAME set since CMake 3.16
+ if(_GSS_MODULE_NAME STREQUAL _mit_modname OR _GSS_${_mit_modname}_VERSION) # _GSS_MODULE_NAME set since CMake 3.16
set(GSS_FLAVOUR "MIT")
if(NOT _GSS_VERSION) # for old CMake versions?
- set(_GSS_VERSION _GSS_${_MIT_MODNAME}_VERSION)
+ set(_GSS_VERSION _GSS_${_mit_modname}_VERSION)
endif()
else()
set(GSS_FLAVOUR "Heimdal")
if(NOT _GSS_VERSION) # for old CMake versions?
- set(_GSS_VERSION _GSS_${_HEIMDAL_MODNAME}_VERSION)
+ set(_GSS_VERSION _GSS_${_heimdal_modname}_VERSION)
endif()
endif()
endif()
if(GSS_FLAVOUR)
if(NOT GSS_VERSION AND GSS_FLAVOUR STREQUAL "Heimdal")
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
- set(HEIMDAL_MANIFEST_FILE "Heimdal.Application.amd64.manifest")
+ set(_heimdal_manifest_file "Heimdal.Application.amd64.manifest")
else()
- set(HEIMDAL_MANIFEST_FILE "Heimdal.Application.x86.manifest")
+ set(_heimdal_manifest_file "Heimdal.Application.x86.manifest")
endif()
- if(EXISTS "${GSS_INCLUDE_DIR}/${HEIMDAL_MANIFEST_FILE}")
- file(STRINGS "${GSS_INCLUDE_DIR}/${HEIMDAL_MANIFEST_FILE}" _heimdal_version_str
+ if(EXISTS "${GSS_INCLUDE_DIR}/${_heimdal_manifest_file}")
+ file(STRINGS "${GSS_INCLUDE_DIR}/${_heimdal_manifest_file}" _heimdal_version_str
REGEX "^.*version=\"[0-9]\\.[^\"]+\".*$")
- string(REGEX MATCH "[0-9]\\.[^\"]+"
- GSS_VERSION "${_heimdal_version_str}")
+ string(REGEX MATCH "[0-9]\\.[^\"]+" GSS_VERSION "${_heimdal_version_str}")
endif()
if(NOT GSS_VERSION)
set(GSS_VERSION "Heimdal Unknown")
endif()
elseif(NOT GSS_VERSION AND GSS_FLAVOUR STREQUAL "MIT")
- get_filename_component(_MIT_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MIT\\Kerberos\\SDK\\CurrentVersion;VersionString]" NAME CACHE)
- if(WIN32 AND _MIT_VERSION)
- set(GSS_VERSION "${_MIT_VERSION}")
+ get_filename_component(_mit_version "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MIT\\Kerberos\\SDK\\CurrentVersion;VersionString]" NAME CACHE)
+ if(WIN32 AND _mit_version)
+ set(GSS_VERSION "${_mit_version}")
else()
set(GSS_VERSION "MIT Unknown")
endif()
include(FindPackageHandleStandardArgs)
-set(_GSS_REQUIRED_VARS GSS_LIBRARIES GSS_FLAVOUR)
-
find_package_handle_standard_args(GSS
REQUIRED_VARS
- ${_GSS_REQUIRED_VARS}
+ GSS_LIBRARIES GSS_FLAVOUR
VERSION_VAR
GSS_VERSION
FAIL_MESSAGE
# SPDX-License-Identifier: curl
#
###########################################################################
-# - Try to find the libpsl library
-# Once done this defines
+# Find the libpsl library
#
-# LIBPSL_FOUND - system has the libpsl library
-# LIBPSL_INCLUDE_DIR - the libpsl include directory
-# LIBPSL_LIBRARY - the libpsl library name
+# Result Variables:
+#
+# LIBPSL_FOUND System has libpsl
+# LIBPSL_INCLUDE_DIR The libpsl include directory
+# LIBPSL_LIBRARY The libpsl library name
+# LIBPSL_VERSION Version of libpsl
-find_path(LIBPSL_INCLUDE_DIR libpsl.h)
+find_path(LIBPSL_INCLUDE_DIR "libpsl.h")
-find_library(LIBPSL_LIBRARY NAMES psl libpsl)
+find_library(LIBPSL_LIBRARY NAMES "psl" "libpsl")
if(LIBPSL_INCLUDE_DIR)
- file(STRINGS "${LIBPSL_INCLUDE_DIR}/libpsl.h" libpsl_version_str REGEX "^#define[\t ]+PSL_VERSION[\t ]+\"(.*)\"")
- string(REGEX REPLACE "^.*\"([^\"]+)\"" "\\1" LIBPSL_VERSION "${libpsl_version_str}")
+ file(STRINGS "${LIBPSL_INCLUDE_DIR}/libpsl.h" _libpsl_version_str REGEX "^#define[\t ]+PSL_VERSION[\t ]+\"(.*)\"")
+ string(REGEX REPLACE "^.*\"([^\"]+)\"" "\\1" LIBPSL_VERSION "${_libpsl_version_str}")
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(LibPSL
- REQUIRED_VARS LIBPSL_LIBRARY LIBPSL_INCLUDE_DIR
- VERSION_VAR LIBPSL_VERSION)
+ REQUIRED_VARS
+ LIBPSL_INCLUDE_DIR
+ LIBPSL_LIBRARY
+ VERSION_VAR
+ LIBPSL_VERSION
+)
mark_as_advanced(LIBPSL_INCLUDE_DIR LIBPSL_LIBRARY)
# SPDX-License-Identifier: curl
#
###########################################################################
-# - Try to find the libssh2 library
-# Once done this defines
+# Find the libssh2 library
#
-# LIBSSH2_FOUND - system has the libssh2 library
-# LIBSSH2_INCLUDE_DIR - the libssh2 include directory
-# LIBSSH2_LIBRARY - the libssh2 library name
+# Result Variables:
+#
+# LIBSSH2_FOUND System has libssh2
+# LIBSSH2_INCLUDE_DIR The libssh2 include directory
+# LIBSSH2_LIBRARY The libssh2 library name
+# LIBSSH2_VERSION Version of libssh2
-find_path(LIBSSH2_INCLUDE_DIR libssh2.h)
+find_path(LIBSSH2_INCLUDE_DIR "libssh2.h")
-find_library(LIBSSH2_LIBRARY NAMES ssh2 libssh2)
+find_library(LIBSSH2_LIBRARY NAMES "ssh2" "libssh2")
if(LIBSSH2_INCLUDE_DIR)
- file(STRINGS "${LIBSSH2_INCLUDE_DIR}/libssh2.h" libssh2_version_str REGEX "^#define[\t ]+LIBSSH2_VERSION[\t ]+\"(.*)\"")
- string(REGEX REPLACE "^.*\"([^\"]+)\"" "\\1" LIBSSH2_VERSION "${libssh2_version_str}")
+ file(STRINGS "${LIBSSH2_INCLUDE_DIR}/libssh2.h" _libssh2_version_str REGEX "^#define[\t ]+LIBSSH2_VERSION[\t ]+\"(.*)\"")
+ string(REGEX REPLACE "^.*\"([^\"]+)\"" "\\1" LIBSSH2_VERSION "${_libssh2_version_str}")
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(LibSSH2
- REQUIRED_VARS LIBSSH2_LIBRARY LIBSSH2_INCLUDE_DIR
- VERSION_VAR LIBSSH2_VERSION)
+ REQUIRED_VARS
+ LIBSSH2_INCLUDE_DIR
+ LIBSSH2_LIBRARY
+ VERSION_VAR
+ LIBSSH2_VERSION
+)
mark_as_advanced(LIBSSH2_INCLUDE_DIR LIBSSH2_LIBRARY)
# Find the msh3 library
#
# Result Variables:
+#
# MSH3_FOUND System has msh3
-# MSH3_INCLUDE_DIRS The msh3 include directories.
+# MSH3_INCLUDE_DIRS The msh3 include directories
# MSH3_LIBRARIES The libraries needed to use msh3
if(UNIX)
find_package(PkgConfig QUIET)
- pkg_search_module(PC_MSH3 libmsh3)
+ pkg_search_module(PC_MSH3 "libmsh3")
endif()
-find_path(MSH3_INCLUDE_DIR msh3.h
+find_path(MSH3_INCLUDE_DIR "msh3.h"
HINTS
${PC_MSH3_INCLUDEDIR}
${PC_MSH3_INCLUDE_DIRS}
)
-find_library(MSH3_LIBRARY NAMES msh3
+find_library(MSH3_LIBRARY NAMES "msh3"
HINTS
${PC_MSH3_LIBDIR}
${PC_MSH3_LIBRARY_DIRS}
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(MSH3
REQUIRED_VARS
- MSH3_LIBRARY
MSH3_INCLUDE_DIR
+ MSH3_LIBRARY
)
if(MSH3_FOUND)
- set(MSH3_LIBRARIES ${MSH3_LIBRARY})
set(MSH3_INCLUDE_DIRS ${MSH3_INCLUDE_DIR})
+ set(MSH3_LIBRARIES ${MSH3_LIBRARY})
endif()
mark_as_advanced(MSH3_INCLUDE_DIRS MSH3_LIBRARIES)
# SPDX-License-Identifier: curl
#
###########################################################################
-find_path(MBEDTLS_INCLUDE_DIRS mbedtls/ssl.h)
+# Find the mbedtls library
+#
+# Result Variables:
+#
+# MBEDTLS_FOUND System has mbedtls
+# MBEDTLS_INCLUDE_DIRS The mbedtls include directories
+# MBEDTLS_LIBRARIES The libraries needed to use mbedtls
+
+find_path(MBEDTLS_INCLUDE_DIRS "mbedtls/ssl.h")
-find_library(MBEDTLS_LIBRARY mbedtls)
-find_library(MBEDX509_LIBRARY mbedx509)
-find_library(MBEDCRYPTO_LIBRARY mbedcrypto)
+find_library(MBEDTLS_LIBRARY "mbedtls")
+find_library(MBEDX509_LIBRARY "mbedx509")
+find_library(MBEDCRYPTO_LIBRARY "mbedcrypto")
set(MBEDTLS_LIBRARIES "${MBEDTLS_LIBRARY}" "${MBEDX509_LIBRARY}" "${MBEDCRYPTO_LIBRARY}")
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(MbedTLS DEFAULT_MSG
- MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY)
+ MBEDTLS_INCLUDE_DIRS
+ MBEDTLS_LIBRARY
+ MBEDX509_LIBRARY
+ MBEDCRYPTO_LIBRARY
+)
mark_as_advanced(MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY)
# SPDX-License-Identifier: curl
#
###########################################################################
+# Find the nghttp2 library
+#
+# Result Variables:
+#
+# NGHTTP2_FOUND System has nghttp2
+# NGHTTP2_INCLUDE_DIRS The nghttp2 include directories
+# NGHTTP2_LIBRARIES The libraries needed to use nghttp2
+# NGHTTP2_VERSION Version of nghttp2
if(UNIX)
find_package(PkgConfig QUIET)
FOUND_VAR
NGHTTP2_FOUND
REQUIRED_VARS
- NGHTTP2_LIBRARY
NGHTTP2_INCLUDE_DIR
- VERSION_VAR NGHTTP2_VERSION
+ NGHTTP2_LIBRARY
+ VERSION_VAR
+ NGHTTP2_VERSION
)
if(NGHTTP2_FOUND)
# Find the nghttp3 library
#
# Result Variables:
+#
# NGHTTP3_FOUND System has nghttp3
-# NGHTTP3_INCLUDE_DIRS The nghttp3 include directories.
+# NGHTTP3_INCLUDE_DIRS The nghttp3 include directories
# NGHTTP3_LIBRARIES The libraries needed to use nghttp3
-# NGHTTP3_VERSION version of nghttp3.
+# NGHTTP3_VERSION Version of nghttp3
if(UNIX)
find_package(PkgConfig QUIET)
- pkg_search_module(PC_NGHTTP3 libnghttp3)
+ pkg_search_module(PC_NGHTTP3 "libnghttp3")
endif()
-find_path(NGHTTP3_INCLUDE_DIR nghttp3/nghttp3.h
+find_path(NGHTTP3_INCLUDE_DIR "nghttp3/nghttp3.h"
HINTS
${PC_NGHTTP3_INCLUDEDIR}
${PC_NGHTTP3_INCLUDE_DIRS}
)
-find_library(NGHTTP3_LIBRARY NAMES nghttp3
+find_library(NGHTTP3_LIBRARY NAMES "nghttp3"
HINTS
${PC_NGHTTP3_LIBDIR}
${PC_NGHTTP3_LIBRARY_DIRS}
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(NGHTTP3
REQUIRED_VARS
- NGHTTP3_LIBRARY
NGHTTP3_INCLUDE_DIR
- VERSION_VAR NGHTTP3_VERSION
+ NGHTTP3_LIBRARY
+ VERSION_VAR
+ NGHTTP3_VERSION
)
if(NGHTTP3_FOUND)
- set(NGHTTP3_LIBRARIES ${NGHTTP3_LIBRARY})
set(NGHTTP3_INCLUDE_DIRS ${NGHTTP3_INCLUDE_DIR})
+ set(NGHTTP3_LIBRARIES ${NGHTTP3_LIBRARY})
endif()
mark_as_advanced(NGHTTP3_INCLUDE_DIRS NGHTTP3_LIBRARIES)
# GnuTLS: Use libngtcp2_crypto_gnutls
#
# Result Variables:
+#
# NGTCP2_FOUND System has ngtcp2
-# NGTCP2_INCLUDE_DIRS The ngtcp2 include directories.
+# NGTCP2_INCLUDE_DIRS The ngtcp2 include directories
# NGTCP2_LIBRARIES The libraries needed to use ngtcp2
-# NGTCP2_VERSION version of ngtcp2.
+# NGTCP2_VERSION Version of ngtcp2
if(UNIX)
find_package(PkgConfig QUIET)
- pkg_search_module(PC_NGTCP2 libngtcp2)
+ pkg_search_module(PC_NGTCP2 "libngtcp2")
endif()
-find_path(NGTCP2_INCLUDE_DIR ngtcp2/ngtcp2.h
+find_path(NGTCP2_INCLUDE_DIR "ngtcp2/ngtcp2.h"
HINTS
${PC_NGTCP2_INCLUDEDIR}
${PC_NGTCP2_INCLUDE_DIRS}
)
-find_library(NGTCP2_LIBRARY NAMES ngtcp2
+find_library(NGTCP2_LIBRARY NAMES "ngtcp2"
HINTS
${PC_NGTCP2_LIBDIR}
${PC_NGTCP2_LIBRARY_DIRS}
if(NGTCP2_CRYPTO_BACKEND)
string(TOLOWER "ngtcp2_crypto_${NGTCP2_CRYPTO_BACKEND}" _crypto_library)
if(UNIX)
- pkg_search_module(PC_${_crypto_library} lib${_crypto_library})
+ pkg_search_module(PC_${_crypto_library} "lib${_crypto_library}")
endif()
find_library(${_crypto_library}_LIBRARY
NAMES
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(NGTCP2
REQUIRED_VARS
- NGTCP2_LIBRARY
NGTCP2_INCLUDE_DIR
- VERSION_VAR NGTCP2_VERSION
+ NGTCP2_LIBRARY
+ VERSION_VAR
+ NGTCP2_VERSION
HANDLE_COMPONENTS
)
if(NGTCP2_FOUND)
- 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_DIRS NGTCP2_LIBRARIES)
# SPDX-License-Identifier: curl
#
###########################################################################
-# - Try to find the nettle library
-# Once done this defines
+# Find the nettle library
#
-# NETTLE_FOUND - system has nettle
-# NETTLE_INCLUDE_DIRS - nettle include directories
-# NETTLE_LIBRARIES - nettle library names
+# Result Variables:
+#
+# NETTLE_FOUND System has nettle
+# NETTLE_INCLUDE_DIRS The nettle include directories
+# NETTLE_LIBRARIES The nettle library names
+# NETTLE_VERSION Version of nettle
if(UNIX)
find_package(PkgConfig QUIET)
- pkg_check_modules(NETTLE "nettle")
+ pkg_search_module(NETTLE "nettle")
endif()
if(NETTLE_FOUND)
REQUIRED_VARS
NETTLE_INCLUDE_DIR
NETTLE_LIBRARY
- VERSION_VAR NETTLE_VERSION)
+ VERSION_VAR
+ NETTLE_VERSION
+ )
if(NETTLE_FOUND)
set(NETTLE_INCLUDE_DIRS ${NETTLE_INCLUDE_DIR})
# Find the quiche library
#
# Result Variables:
+#
# QUICHE_FOUND System has quiche
# QUICHE_INCLUDE_DIRS The quiche include directories
# QUICHE_LIBRARIES The libraries needed to use quiche
if(UNIX)
find_package(PkgConfig QUIET)
- pkg_search_module(PC_QUICHE quiche)
+ pkg_search_module(PC_QUICHE "quiche")
endif()
-find_path(QUICHE_INCLUDE_DIR quiche.h
+find_path(QUICHE_INCLUDE_DIR "quiche.h"
HINTS
${PC_QUICHE_INCLUDEDIR}
${PC_QUICHE_INCLUDE_DIRS}
)
-find_library(QUICHE_LIBRARY NAMES quiche
+find_library(QUICHE_LIBRARY NAMES "quiche"
HINTS
${PC_QUICHE_LIBDIR}
${PC_QUICHE_LIBRARY_DIRS}
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(QUICHE
REQUIRED_VARS
- QUICHE_LIBRARY
QUICHE_INCLUDE_DIR
+ QUICHE_LIBRARY
)
if(QUICHE_FOUND)
- set(QUICHE_LIBRARIES ${QUICHE_LIBRARY})
set(QUICHE_INCLUDE_DIRS ${QUICHE_INCLUDE_DIR})
+ set(QUICHE_LIBRARIES ${QUICHE_LIBRARY})
endif()
mark_as_advanced(QUICHE_INCLUDE_DIRS QUICHE_LIBRARIES)
# SPDX-License-Identifier: curl
#
###########################################################################
+# Find the wolfssl library
+#
+# Result Variables:
+#
+# WolfSSL_FOUND System has wolfssl
+# WolfSSL_INCLUDE_DIRS The wolfssl include directories
+# WolfSSL_LIBRARIES The wolfssl library names
+# WolfSSL_VERSION Version of wolfssl
find_package(PkgConfig QUIET)
-pkg_check_modules(PC_WOLFSSL QUIET "wolfssl")
+pkg_search_module(PC_WOLFSSL QUIET "wolfssl")
find_path(WolfSSL_INCLUDE_DIR
NAMES "wolfssl/ssl.h"
REQUIRED_VARS
WolfSSL_INCLUDE_DIR
WolfSSL_LIBRARY
- VERSION_VAR WolfSSL_VERSION
+ VERSION_VAR
+ WolfSSL_VERSION
)
if(WolfSSL_FOUND)
###########################################################################
# Find the zstd library
#
-# Result Variables
+# Result Variables:
+#
# Zstd_FOUND System has zstd
-# Zstd_INCLUDE_DIRS The zstd include directories.
+# Zstd_INCLUDE_DIRS The zstd include directories
# Zstd_LIBRARIES The libraries needed to use zstd
+# Zstd_VERSION Version of zstd
if(UNIX)
find_package(PkgConfig QUIET)
- pkg_search_module(PC_Zstd libzstd)
+ pkg_search_module(PC_Zstd "libzstd")
endif()
-find_path(Zstd_INCLUDE_DIR zstd.h
+find_path(Zstd_INCLUDE_DIR "zstd.h"
HINTS
${PC_Zstd_INCLUDEDIR}
${PC_Zstd_INCLUDE_DIRS}
)
-find_library(Zstd_LIBRARY NAMES zstd
+find_library(Zstd_LIBRARY NAMES "zstd"
HINTS
${PC_Zstd_LIBDIR}
${PC_Zstd_LIBRARY_DIRS}
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Zstd
REQUIRED_VARS
- Zstd_LIBRARY
Zstd_INCLUDE_DIR
- VERSION_VAR Zstd_VERSION
+ Zstd_LIBRARY
+ VERSION_VAR
+ Zstd_VERSION
)
if(Zstd_FOUND)
- set(Zstd_LIBRARIES ${Zstd_LIBRARY})
set(Zstd_INCLUDE_DIRS ${Zstd_INCLUDE_DIR})
+ set(Zstd_LIBRARIES ${Zstd_LIBRARY})
endif()
mark_as_advanced(Zstd_INCLUDE_DIRS Zstd_LIBRARIES)
# This macro is intended to be called multiple times with a sequence of
# possibly dependent header files. Some headers depend on others to be
# compiled correctly.
-macro(check_include_file_concat file variable)
- check_include_files("${CURL_INCLUDES};${file}" ${variable})
- if(${variable})
- set(CURL_INCLUDES ${CURL_INCLUDES} ${file})
- set(CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -D${variable}")
+macro(check_include_file_concat _file _variable)
+ check_include_files("${CURL_INCLUDES};${_file}" ${_variable})
+ if(${_variable})
+ set(CURL_INCLUDES ${CURL_INCLUDES} ${_file})
+ set(CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -D${_variable}")
endif()
endmacro()
# For other curl specific tests, use this macro.
# Return result in variable: CURL_TEST_OUTPUT
-macro(curl_internal_test curl_test)
- if(NOT DEFINED "${curl_test}")
- set(MACRO_CHECK_FUNCTION_DEFINITIONS
- "-D${curl_test} ${CURL_TEST_DEFINES} ${CMAKE_REQUIRED_FLAGS}")
+macro(curl_internal_test _curl_test)
+ if(NOT DEFINED "${_curl_test}")
+ set(_macro_check_function_definitions
+ "-D${_curl_test} ${CURL_TEST_DEFINES} ${CMAKE_REQUIRED_FLAGS}")
if(CMAKE_REQUIRED_LIBRARIES)
- set(CURL_TEST_ADD_LIBRARIES
+ set(_curl_test_add_libraries
"-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
endif()
- message(STATUS "Performing Test ${curl_test}")
- try_compile(${curl_test}
+ message(STATUS "Performing Test ${_curl_test}")
+ try_compile(${_curl_test}
${CMAKE_BINARY_DIR}
- ${CMAKE_CURRENT_SOURCE_DIR}/CMake/CurlTests.c
- CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
- "${CURL_TEST_ADD_LIBRARIES}"
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/CurlTests.c"
+ CMAKE_FLAGS
+ "-DCOMPILE_DEFINITIONS:STRING=${_macro_check_function_definitions}"
+ "${_curl_test_add_libraries}"
OUTPUT_VARIABLE CURL_TEST_OUTPUT)
- if(${curl_test})
- set(${curl_test} 1 CACHE INTERNAL "Curl test")
- message(STATUS "Performing Test ${curl_test} - Success")
+ if(${_curl_test})
+ set(${_curl_test} 1 CACHE INTERNAL "Curl test")
+ message(STATUS "Performing Test ${_curl_test} - Success")
else()
- set(${curl_test} "" CACHE INTERNAL "Curl test")
- message(STATUS "Performing Test ${curl_test} - Failed")
+ set(${_curl_test} "" CACHE INTERNAL "Curl test")
+ message(STATUS "Performing Test ${_curl_test} - Failed")
endif()
endif()
endmacro()
-macro(optional_dependency dependency)
- set(CURL_${dependency} AUTO CACHE STRING "Build curl with ${dependency} support (AUTO, ON or OFF)")
- set_property(CACHE CURL_${dependency} PROPERTY STRINGS AUTO ON OFF)
+macro(optional_dependency _dependency)
+ set(CURL_${_dependency} "AUTO" CACHE STRING "Build curl with ${_dependency} support (AUTO, ON or OFF)")
+ set_property(CACHE CURL_${_dependency} PROPERTY STRINGS "AUTO" "ON" "OFF")
- if(CURL_${dependency} STREQUAL AUTO)
- find_package(${dependency})
- elseif(CURL_${dependency})
- find_package(${dependency} REQUIRED)
+ if(CURL_${_dependency} STREQUAL "AUTO")
+ find_package(${_dependency})
+ elseif(CURL_${_dependency})
+ find_package(${_dependency} REQUIRED)
endif()
endmacro()
include(CheckCSourceRuns)
include(CheckTypeSize)
-macro(add_header_include check header)
- if(${check})
+macro(add_header_include _check _header)
+ if(${_check})
set(_source_epilogue "${_source_epilogue}
- #include <${header}>")
+ #include <${_header}>")
endif()
endmacro()
endif()
check_type_size("struct sockaddr_storage" SIZEOF_STRUCT_SOCKADDR_STORAGE)
set(HAVE_STRUCT_SOCKADDR_STORAGE ${HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE})
+ set(CMAKE_EXTRA_INCLUDE_FILES "")
endif()
if(NOT WIN32)
# File containing various utilities
# Returns number of arguments that evaluate to true
-function(count_true output_count_var)
+function(count_true _output_count_var)
set(lst_len 0)
foreach(option_var IN LISTS ARGN)
if(${option_var})
math(EXPR lst_len "${lst_len} + 1")
endif()
endforeach()
- set(${output_count_var} ${lst_len} PARENT_SCOPE)
+ set(${_output_count_var} ${lst_len} PARENT_SCOPE)
endfunction()
option(ENABLE_UNICODE "Set to ON to use the Unicode version of the Windows API functions" OFF)
set(CURL_TARGET_WINDOWS_VERSION "" CACHE STRING "Minimum target Windows version as hex string")
if(CURL_TARGET_WINDOWS_VERSION)
- add_definitions(-D_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION})
- list(APPEND CMAKE_REQUIRED_DEFINITIONS -D_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION})
+ add_definitions("-D_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION}")
+ list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION}")
set(CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -D_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION}")
endif()
if(ENABLE_UNICODE)
- add_definitions(-DUNICODE -D_UNICODE)
+ add_definitions("-DUNICODE" "-D_UNICODE")
if(MINGW)
add_compile_options(-municode)
endif()
option(ENABLE_CURLDEBUG "Set to ON to build with TrackMemory feature enabled" ${ENABLE_DEBUG})
if(ENABLE_DEBUG)
- set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS DEBUGBUILD)
+ set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "DEBUGBUILD")
endif()
if(ENABLE_CURLDEBUG)
- set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS CURLDEBUG)
+ set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "CURLDEBUG")
endif()
# For debug libs and exes, add "-d" postfix
endif()
if(APPLE AND NOT ENABLE_ARES)
- set(use_core_foundation_and_core_services ON)
+ set(_use_core_foundation_and_core_services ON)
find_library(SYSTEMCONFIGURATION_FRAMEWORK "SystemConfiguration")
if(NOT SYSTEMCONFIGURATION_FRAMEWORK)
set(CURL_LIBS "socket;${CURL_LIBS}")
endif()
-check_function_exists(gethostname HAVE_GETHOSTNAME)
+check_function_exists("gethostname" HAVE_GETHOSTNAME)
if(WIN32)
list(APPEND CURL_LIBS "ws2_32" "bcrypt")
option(CURL_ENABLE_SSL "Enable SSL support" ON)
if(CURL_DEFAULT_SSL_BACKEND)
- set(valid_default_ssl_backend FALSE)
+ set(_valid_default_ssl_backend FALSE)
endif()
if(APPLE)
cmake_dependent_option(CURL_USE_OPENSSL "Enable OpenSSL for SSL/TLS" ${_openssl_default} CURL_ENABLE_SSL OFF)
option(CURL_DISABLE_OPENSSL_AUTO_LOAD_CONFIG "Disable automatic loading of OpenSSL configuration" OFF)
-count_true(enabled_ssl_options_count
+count_true(_enabled_ssl_options_count
CURL_USE_SCHANNEL
CURL_USE_SECTRANSP
CURL_USE_OPENSSL
CURL_USE_WOLFSSL
CURL_USE_GNUTLS
)
-if(enabled_ssl_options_count GREATER "1")
+if(_enabled_ssl_options_count GREATER 1)
set(CURL_WITH_MULTI_SSL ON)
endif()
set(USE_WINDOWS_SSPI ON) # CURL_USE_SCHANNEL implies CURL_WINDOWS_SSPI
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "schannel")
- set(valid_default_ssl_backend TRUE)
+ set(_valid_default_ssl_backend TRUE)
endif()
endif()
if(CURL_WINDOWS_SSPI)
endif()
if(CURL_USE_SECTRANSP)
- set(use_core_foundation_and_core_services ON)
+ set(_use_core_foundation_and_core_services ON)
find_library(SECURITY_FRAMEWORK "Security")
if(NOT SECURITY_FRAMEWORK)
list(APPEND CURL_LIBS "-framework Security")
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "secure-transport")
- set(valid_default_ssl_backend TRUE)
+ set(_valid_default_ssl_backend TRUE)
endif()
endif()
-if(use_core_foundation_and_core_services)
+if(_use_core_foundation_and_core_services)
find_library(COREFOUNDATION_FRAMEWORK "CoreFoundation")
find_library(CORESERVICES_FRAMEWORK "CoreServices")
list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "openssl")
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "openssl")
- set(valid_default_ssl_backend TRUE)
+ set(_valid_default_ssl_backend TRUE)
endif()
- set(curl_ca_bundle_supported TRUE)
+ set(_curl_ca_bundle_supported TRUE)
set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
if(NOT DEFINED HAVE_BORINGSSL)
- check_symbol_exists(OPENSSL_IS_BORINGSSL "openssl/base.h" HAVE_BORINGSSL)
+ check_symbol_exists("OPENSSL_IS_BORINGSSL" "openssl/base.h" HAVE_BORINGSSL)
endif()
if(NOT DEFINED HAVE_AWSLC)
- check_symbol_exists(OPENSSL_IS_AWSLC "openssl/base.h" HAVE_AWSLC)
+ check_symbol_exists("OPENSSL_IS_AWSLC" "openssl/base.h" HAVE_AWSLC)
endif()
endif()
include_directories(${MBEDTLS_INCLUDE_DIRS})
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "mbedtls")
- set(valid_default_ssl_backend TRUE)
+ set(_valid_default_ssl_backend TRUE)
endif()
- set(curl_ca_bundle_supported TRUE)
+ set(_curl_ca_bundle_supported TRUE)
endif()
if(CURL_USE_BEARSSL)
include_directories(${BEARSSL_INCLUDE_DIRS})
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "bearssl")
- set(valid_default_ssl_backend TRUE)
+ set(_valid_default_ssl_backend TRUE)
endif()
- set(curl_ca_bundle_supported TRUE)
+ set(_curl_ca_bundle_supported TRUE)
endif()
if(CURL_USE_WOLFSSL)
include_directories(${WolfSSL_INCLUDE_DIRS})
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "wolfssl")
- set(valid_default_ssl_backend TRUE)
+ set(_valid_default_ssl_backend TRUE)
endif()
- set(curl_ca_bundle_supported TRUE)
+ set(_curl_ca_bundle_supported TRUE)
endif()
if(CURL_USE_GNUTLS)
include_directories(${GNUTLS_INCLUDE_DIRS} ${NETTLE_INCLUDE_DIRS})
if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "gnutls")
- set(valid_default_ssl_backend TRUE)
+ set(_valid_default_ssl_backend TRUE)
endif()
- set(curl_ca_bundle_supported TRUE)
+ set(_curl_ca_bundle_supported TRUE)
if(NOT DEFINED HAVE_GNUTLS_SRP AND NOT CURL_DISABLE_SRP)
cmake_push_check_state()
set(CMAKE_REQUIRED_INCLUDES ${GNUTLS_INCLUDE_DIRS})
set(CMAKE_REQUIRED_LIBRARIES ${GNUTLS_LIBRARIES})
- check_symbol_exists(gnutls_srp_verifier "gnutls/gnutls.h" HAVE_GNUTLS_SRP)
+ check_symbol_exists("gnutls_srp_verifier" "gnutls/gnutls.h" HAVE_GNUTLS_SRP)
cmake_pop_check_state()
endif()
endif()
-if(CURL_DEFAULT_SSL_BACKEND AND NOT valid_default_ssl_backend)
+if(CURL_DEFAULT_SSL_BACKEND AND NOT _valid_default_ssl_backend)
message(FATAL_ERROR "CURL_DEFAULT_SSL_BACKEND '${CURL_DEFAULT_SSL_BACKEND}' not enabled.")
endif()
endif()
endif()
-# Check symbol in an OpenSSL-like TLS backend, or in EXTRA_LIBS depending on it.
-macro(openssl_check_symbol_exists SYMBOL FILES VARIABLE EXTRA_LIBS)
+# Check symbol in an OpenSSL-like TLS backend, or in _extra_libs depending on it.
+macro(openssl_check_symbol_exists _symbol _files _variable _extra_libs)
cmake_push_check_state()
if(USE_OPENSSL)
set(CMAKE_REQUIRED_INCLUDES "${OPENSSL_INCLUDE_DIR}")
if(WIN32)
list(APPEND CMAKE_REQUIRED_LIBRARIES "ws2_32" "crypt32")
endif()
- list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_UINTPTR_T) # to pull in stdint.h (as of wolfSSL v5.5.4)
+ list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DHAVE_UINTPTR_T") # to pull in stdint.h (as of wolfSSL v5.5.4)
endif()
- if(NOT EXTRA_LIBS STREQUAL "")
- list(APPEND CMAKE_REQUIRED_LIBRARIES "${EXTRA_LIBS}")
+ if(NOT _extra_libs STREQUAL "")
+ list(APPEND CMAKE_REQUIRED_LIBRARIES "${_extra_libs}")
endif()
- check_symbol_exists("${SYMBOL}" "${FILES}" "${VARIABLE}")
+ check_symbol_exists("${_symbol}" "${_files}" "${_variable}")
cmake_pop_check_state()
endmacro()
macro(openssl_check_quic)
if(NOT DEFINED HAVE_SSL_CTX_SET_QUIC_METHOD)
if(USE_OPENSSL)
- openssl_check_symbol_exists(SSL_CTX_set_quic_method "openssl/ssl.h" HAVE_SSL_CTX_SET_QUIC_METHOD "")
+ openssl_check_symbol_exists("SSL_CTX_set_quic_method" "openssl/ssl.h" HAVE_SSL_CTX_SET_QUIC_METHOD "")
elseif(USE_WOLFSSL)
- openssl_check_symbol_exists(wolfSSL_set_quic_method "wolfssl/options.h;wolfssl/openssl/ssl.h" HAVE_SSL_CTX_SET_QUIC_METHOD "")
+ openssl_check_symbol_exists("wolfSSL_set_quic_method" "wolfssl/options.h;wolfssl/openssl/ssl.h" HAVE_SSL_CTX_SET_QUIC_METHOD "")
endif()
endif()
if(NOT HAVE_SSL_CTX_SET_QUIC_METHOD)
endmacro()
if(USE_WOLFSSL)
- openssl_check_symbol_exists(wolfSSL_DES_ecb_encrypt "wolfssl/openssl/des.h" HAVE_WOLFSSL_DES_ECB_ENCRYPT "")
- openssl_check_symbol_exists(wolfSSL_BIO_set_shutdown "wolfssl/ssl.h" HAVE_WOLFSSL_FULL_BIO "")
+ openssl_check_symbol_exists("wolfSSL_DES_ecb_encrypt" "wolfssl/openssl/des.h" HAVE_WOLFSSL_DES_ECB_ENCRYPT "")
+ openssl_check_symbol_exists("wolfSSL_BIO_set_shutdown" "wolfssl/ssl.h" HAVE_WOLFSSL_FULL_BIO "")
endif()
if(USE_OPENSSL OR USE_WOLFSSL)
if(NOT DEFINED HAVE_SSL_SET0_WBIO)
- openssl_check_symbol_exists(SSL_set0_wbio "openssl/ssl.h" HAVE_SSL_SET0_WBIO "")
+ openssl_check_symbol_exists("SSL_set0_wbio" "openssl/ssl.h" HAVE_SSL_SET0_WBIO "")
endif()
if(NOT DEFINED HAVE_OPENSSL_SRP AND NOT CURL_DISABLE_SRP)
- openssl_check_symbol_exists(SSL_CTX_set_srp_username "openssl/ssl.h" HAVE_OPENSSL_SRP "")
+ openssl_check_symbol_exists("SSL_CTX_set_srp_username" "openssl/ssl.h" HAVE_OPENSSL_SRP "")
endif()
endif()
# Be sure that the TLS library actually supports ECH.
if(NOT DEFINED HAVE_ECH)
if(USE_OPENSSL AND HAVE_BORINGSSL)
- openssl_check_symbol_exists(SSL_set1_ech_config_list "openssl/ssl.h" HAVE_ECH "")
+ openssl_check_symbol_exists("SSL_set1_ech_config_list" "openssl/ssl.h" HAVE_ECH "")
elseif(USE_OPENSSL)
- openssl_check_symbol_exists(SSL_ech_set1_echconfig "openssl/ech.h" HAVE_ECH "")
+ openssl_check_symbol_exists("SSL_ech_set1_echconfig" "openssl/ech.h" HAVE_ECH "")
elseif(USE_WOLFSSL)
- openssl_check_symbol_exists(wolfSSL_CTX_GenerateEchConfig "wolfssl/options.h;wolfssl/ssl.h" HAVE_ECH "")
+ openssl_check_symbol_exists("wolfSSL_CTX_GenerateEchConfig" "wolfssl/options.h;wolfssl/ssl.h" HAVE_ECH "")
endif()
endif()
if(NOT HAVE_ECH)
cmake_push_check_state()
set(CMAKE_REQUIRED_INCLUDES "${QUICHE_INCLUDE_DIRS}")
set(CMAKE_REQUIRED_LIBRARIES "${QUICHE_LIBRARIES}")
- check_symbol_exists(quiche_conn_set_qlog_fd "quiche.h" HAVE_QUICHE_CONN_SET_QLOG_FD)
+ check_symbol_exists("quiche_conn_set_qlog_fd" "quiche.h" HAVE_QUICHE_CONN_SET_QLOG_FD)
cmake_pop_check_state()
endif()
endif()
set(_include_string "${_include_string}#include <${_header}>\n")
endforeach()
- list(APPEND CMAKE_REQUIRED_DEFINITIONS -DLDAP_DEPRECATED=1)
+ list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DLDAP_DEPRECATED=1")
list(APPEND CMAKE_REQUIRED_LIBRARIES ${CMAKE_LDAP_LIB})
set(CURL_LIBS "${CMAKE_LDAP_LIB};${CURL_LIBS}")
if(HAVE_LIBLBER)
set(CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -DNEED_LBER_H")
endif()
- check_function_exists(ldap_url_parse HAVE_LDAP_URL_PARSE)
- check_function_exists(ldap_init_fd HAVE_LDAP_INIT_FD)
+ check_function_exists("ldap_url_parse" HAVE_LDAP_URL_PARSE)
+ check_function_exists("ldap_init_fd" HAVE_LDAP_INIT_FD)
unset(CMAKE_REQUIRED_LIBRARIES)
endif()
if(NOT HAVE_LIBIDN2 OR NOT HAVE_IDN2_H)
find_package(PkgConfig QUIET)
- pkg_check_modules(LIBIDN2 "libidn2")
+ pkg_search_module(LIBIDN2 "libidn2")
if(LIBIDN2_FOUND)
include_directories(${LIBIDN2_INCLUDE_DIRS})
set(HAVE_LIBIDN2 ON)
list(APPEND CURL_LIBS ${LIBPSL_LIBRARY})
list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libpsl")
list(APPEND CMAKE_REQUIRED_INCLUDES "${LIBPSL_INCLUDE_DIR}")
- include_directories("${LIBPSL_INCLUDE_DIR}")
+ include_directories(${LIBPSL_INCLUDE_DIR})
set(USE_LIBPSL ON)
endif()
endif()
list(APPEND CURL_LIBS ${LIBSSH2_LIBRARY})
list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libssh2")
list(APPEND CMAKE_REQUIRED_INCLUDES "${LIBSSH2_INCLUDE_DIR}")
- include_directories("${LIBSSH2_INCLUDE_DIR}")
+ include_directories(${LIBSSH2_INCLUDE_DIR})
set(USE_LIBSSH2 ON)
endif()
endif()
message(STATUS "Found libssh ${libssh_VERSION}")
else()
find_package(PkgConfig QUIET)
- pkg_check_modules(LIBSSH "libssh")
+ pkg_search_module(LIBSSH "libssh")
if(LIBSSH_FOUND)
include_directories(${LIBSSH_INCLUDE_DIRS})
endif()
mark_as_advanced(CURL_USE_GSASL)
if(CURL_USE_GSASL)
find_package(PkgConfig REQUIRED)
- pkg_check_modules(GSASL REQUIRED libgsasl)
+ pkg_search_module(GSASL REQUIRED "libgsasl")
list(APPEND CURL_LIBS ${GSASL_LINK_LIBRARIES})
set(USE_GSASL ON)
endif()
if(NOT GSS_FLAVOUR STREQUAL "Heimdal")
# MIT
- set(_INCLUDE_LIST "")
+ set(_include_list "")
if(HAVE_GSSAPI_GSSAPI_H)
- list(APPEND _INCLUDE_LIST "gssapi/gssapi.h")
+ list(APPEND _include_list "gssapi/gssapi.h")
endif()
if(HAVE_GSSAPI_GSSAPI_GENERIC_H)
- list(APPEND _INCLUDE_LIST "gssapi/gssapi_generic.h")
+ list(APPEND _include_list "gssapi/gssapi_generic.h")
endif()
if(HAVE_GSSAPI_GSSAPI_KRB5_H)
- list(APPEND _INCLUDE_LIST "gssapi/gssapi_krb5.h")
+ list(APPEND _include_list "gssapi/gssapi_krb5.h")
endif()
- string(REPLACE ";" " " _COMPILER_FLAGS_STR "${GSS_COMPILER_FLAGS}")
- string(REPLACE ";" " " _LINKER_FLAGS_STR "${GSS_LINKER_FLAGS}")
+ string(REPLACE ";" " " _compiler_flags_str "${GSS_COMPILER_FLAGS}")
+ string(REPLACE ";" " " _linker_flags_str "${GSS_LINKER_FLAGS}")
foreach(_dir IN LISTS GSS_LINK_DIRECTORIES)
- set(_LINKER_FLAGS_STR "${_LINKER_FLAGS_STR} -L\"${_dir}\"")
+ set(_linker_flags_str "${_linker_flags_str} -L\"${_dir}\"")
endforeach()
if(NOT DEFINED HAVE_GSS_C_NT_HOSTBASED_SERVICE)
- set(CMAKE_REQUIRED_FLAGS "${_COMPILER_FLAGS_STR} ${_LINKER_FLAGS_STR}")
+ set(CMAKE_REQUIRED_FLAGS "${_compiler_flags_str} ${_linker_flags_str}")
set(CMAKE_REQUIRED_LIBRARIES ${GSS_LIBRARIES})
- check_symbol_exists("GSS_C_NT_HOSTBASED_SERVICE" ${_INCLUDE_LIST} HAVE_GSS_C_NT_HOSTBASED_SERVICE)
+ check_symbol_exists("GSS_C_NT_HOSTBASED_SERVICE" ${_include_list} HAVE_GSS_C_NT_HOSTBASED_SERVICE)
unset(CMAKE_REQUIRED_LIBRARIES)
endif()
if(NOT HAVE_GSS_C_NT_HOSTBASED_SERVICE)
#
# CA handling
#
-if(curl_ca_bundle_supported)
+if(_curl_ca_bundle_supported)
set(CURL_CA_BUNDLE "auto" CACHE STRING
"Path to the CA bundle. Set 'none' to disable or 'auto' for auto-detection. Defaults to 'auto'.")
set(CURL_CA_FALLBACK OFF CACHE BOOL
elseif(CURL_CA_BUNDLE STREQUAL "auto")
unset(CURL_CA_BUNDLE CACHE)
if(NOT CMAKE_CROSSCOMPILING AND NOT WIN32)
- set(CURL_CA_BUNDLE_AUTODETECT TRUE)
+ set(_curl_ca_bundle_autodetect TRUE)
endif()
else()
- set(CURL_CA_BUNDLE_SET TRUE)
+ set(_curl_ca_bundle_set TRUE)
endif()
if(CURL_CA_PATH STREQUAL "")
elseif(CURL_CA_PATH STREQUAL "auto")
unset(CURL_CA_PATH CACHE)
if(NOT CMAKE_CROSSCOMPILING AND NOT WIN32)
- set(CURL_CA_PATH_AUTODETECT TRUE)
+ set(_curl_ca_path_autodetect TRUE)
endif()
else()
- set(CURL_CA_PATH_SET TRUE)
+ set(_curl_ca_path_set TRUE)
endif()
- if(CURL_CA_BUNDLE_SET AND CURL_CA_PATH_AUTODETECT)
+ if(_curl_ca_bundle_set AND _curl_ca_path_autodetect)
# Skip auto-detection of unset CA path because CA bundle is set explicitly
- elseif(CURL_CA_PATH_SET AND CURL_CA_BUNDLE_AUTODETECT)
+ elseif(_curl_ca_path_set AND _curl_ca_bundle_autodetect)
# Skip auto-detection of unset CA bundle because CA path is set explicitly
- elseif(CURL_CA_BUNDLE_AUTODETECT OR CURL_CA_PATH_AUTODETECT)
+ elseif(_curl_ca_bundle_autodetect OR _curl_ca_path_autodetect)
# First try auto-detecting a CA bundle, then a CA path
- if(CURL_CA_BUNDLE_AUTODETECT)
+ if(_curl_ca_bundle_autodetect)
foreach(_search_ca_bundle_path IN ITEMS
"/etc/ssl/certs/ca-certificates.crt"
"/etc/pki/tls/certs/ca-bundle.crt"
message(STATUS "Found CA bundle: ${_search_ca_bundle_path}")
set(CURL_CA_BUNDLE "${_search_ca_bundle_path}" CACHE STRING
"Path to the CA bundle. Set 'none' to disable or 'auto' for auto-detection. Defaults to 'auto'.")
- set(CURL_CA_BUNDLE_SET TRUE CACHE BOOL "Path to the CA bundle has been set")
+ set(_curl_ca_bundle_set TRUE CACHE BOOL "Path to the CA bundle has been set")
break()
endif()
endforeach()
endif()
- if(CURL_CA_PATH_AUTODETECT AND NOT CURL_CA_PATH_SET)
+ if(_curl_ca_path_autodetect AND NOT _curl_ca_path_set)
set(_search_ca_path "/etc/ssl/certs")
file(GLOB _curl_ca_files_found "${_search_ca_path}/[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f].0")
if(_curl_ca_files_found)
message(STATUS "Found CA path: ${_search_ca_path}")
set(CURL_CA_PATH "${_search_ca_path}" CACHE STRING
"Location of default CA path. Set 'none' to disable or 'auto' for auto-detection. Defaults to 'auto'.")
- set(CURL_CA_PATH_SET TRUE CACHE BOOL "Path to the CA bundle has been set")
+ set(_curl_ca_path_set TRUE CACHE BOOL "Path to the CA bundle has been set")
endif()
endif()
endif()
check_include_file_concat("unistd.h" HAVE_UNISTD_H)
check_include_file_concat("utime.h" HAVE_UTIME_H)
-check_type_size(size_t SIZEOF_SIZE_T)
-check_type_size(ssize_t SIZEOF_SSIZE_T)
-check_type_size("long long" SIZEOF_LONG_LONG)
-check_type_size("long" SIZEOF_LONG)
-check_type_size("int" SIZEOF_INT)
-check_type_size("__int64" SIZEOF___INT64)
-check_type_size("time_t" SIZEOF_TIME_T)
-check_type_size("suseconds_t" SIZEOF_SUSECONDS_T)
+check_type_size("size_t" SIZEOF_SIZE_T)
+check_type_size("ssize_t" SIZEOF_SSIZE_T)
+check_type_size("long long" SIZEOF_LONG_LONG)
+check_type_size("long" SIZEOF_LONG)
+check_type_size("int" SIZEOF_INT)
+check_type_size("__int64" SIZEOF___INT64)
+check_type_size("time_t" SIZEOF_TIME_T)
+check_type_size("suseconds_t" SIZEOF_SUSECONDS_T)
if(NOT HAVE_SIZEOF_SSIZE_T)
if(SIZEOF_LONG EQUAL SIZEOF_SIZE_T)
- set(ssize_t long)
+ set(ssize_t "long")
endif()
if(NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T)
- set(ssize_t __int64)
+ set(ssize_t "__int64")
endif()
endif()
# off_t is sized later, after the HAVE_FILE_OFFSET_BITS test
endif()
if(NOT CMAKE_CROSSCOMPILING)
- find_file(RANDOM_FILE urandom /dev)
+ find_file(RANDOM_FILE "urandom" "/dev")
mark_as_advanced(RANDOM_FILE)
endif()
# Check for some functions that are used
if(WIN32)
- set(CMAKE_REQUIRED_LIBRARIES ws2_32)
+ set(CMAKE_REQUIRED_LIBRARIES "ws2_32")
elseif(HAVE_LIBSOCKET)
- set(CMAKE_REQUIRED_LIBRARIES socket)
-endif()
-
-check_symbol_exists(fnmatch "${CURL_INCLUDES};fnmatch.h" HAVE_FNMATCH)
-check_symbol_exists(basename "${CURL_INCLUDES};string.h" HAVE_BASENAME)
-check_symbol_exists(opendir "${CURL_INCLUDES};dirent.h" HAVE_OPENDIR)
-check_symbol_exists(socket "${CURL_INCLUDES}" HAVE_SOCKET)
-check_symbol_exists(sched_yield "${CURL_INCLUDES};sched.h" HAVE_SCHED_YIELD)
-check_symbol_exists(socketpair "${CURL_INCLUDES}" HAVE_SOCKETPAIR)
-check_symbol_exists(recv "${CURL_INCLUDES}" HAVE_RECV)
-check_symbol_exists(send "${CURL_INCLUDES}" HAVE_SEND)
-check_symbol_exists(sendmsg "${CURL_INCLUDES}" HAVE_SENDMSG)
-check_symbol_exists(select "${CURL_INCLUDES}" HAVE_SELECT)
-check_symbol_exists(strdup "${CURL_INCLUDES};string.h" HAVE_STRDUP)
-check_symbol_exists(strtok_r "${CURL_INCLUDES};string.h" HAVE_STRTOK_R)
-check_symbol_exists(strcasecmp "${CURL_INCLUDES};string.h" HAVE_STRCASECMP)
-check_symbol_exists(stricmp "${CURL_INCLUDES};string.h" HAVE_STRICMP)
-check_symbol_exists(strcmpi "${CURL_INCLUDES};string.h" HAVE_STRCMPI)
-check_symbol_exists(memrchr "${CURL_INCLUDES};string.h" HAVE_MEMRCHR)
-check_symbol_exists(alarm "${CURL_INCLUDES}" HAVE_ALARM)
-check_symbol_exists(arc4random "${CURL_INCLUDES};stdlib.h" HAVE_ARC4RANDOM)
-check_symbol_exists(fcntl "${CURL_INCLUDES}" HAVE_FCNTL)
-check_symbol_exists(getppid "${CURL_INCLUDES}" HAVE_GETPPID)
-check_symbol_exists(utimes "${CURL_INCLUDES}" HAVE_UTIMES)
-
-check_symbol_exists(gettimeofday "${CURL_INCLUDES}" HAVE_GETTIMEOFDAY)
-check_symbol_exists(closesocket "${CURL_INCLUDES}" HAVE_CLOSESOCKET)
-check_symbol_exists(sigsetjmp "${CURL_INCLUDES};setjmp.h" HAVE_SIGSETJMP)
-check_symbol_exists(getpass_r "${CURL_INCLUDES}" HAVE_GETPASS_R)
-check_symbol_exists(getpwuid "${CURL_INCLUDES}" HAVE_GETPWUID)
-check_symbol_exists(getpwuid_r "${CURL_INCLUDES}" HAVE_GETPWUID_R)
-check_symbol_exists(geteuid "${CURL_INCLUDES}" HAVE_GETEUID)
-check_symbol_exists(utime "${CURL_INCLUDES}" HAVE_UTIME)
-check_symbol_exists(gmtime_r "${CURL_INCLUDES};stdlib.h;time.h" HAVE_GMTIME_R)
-
-check_symbol_exists(gethostbyname_r "${CURL_INCLUDES}" HAVE_GETHOSTBYNAME_R)
-
-check_symbol_exists(signal "${CURL_INCLUDES};signal.h" HAVE_SIGNAL)
-check_symbol_exists(strtoll "${CURL_INCLUDES};stdlib.h" HAVE_STRTOLL)
-check_symbol_exists(strerror_r "${CURL_INCLUDES};stdlib.h;string.h" HAVE_STRERROR_R)
-check_symbol_exists(sigaction "signal.h" HAVE_SIGACTION)
-check_symbol_exists(siginterrupt "${CURL_INCLUDES};signal.h" HAVE_SIGINTERRUPT)
-check_symbol_exists(getaddrinfo "${CURL_INCLUDES};stdlib.h;string.h" HAVE_GETADDRINFO)
-check_symbol_exists(getifaddrs "${CURL_INCLUDES};stdlib.h" HAVE_GETIFADDRS)
-check_symbol_exists(freeaddrinfo "${CURL_INCLUDES}" HAVE_FREEADDRINFO)
-check_symbol_exists(pipe "${CURL_INCLUDES}" HAVE_PIPE)
-check_symbol_exists(eventfd "${CURL_INCLUDES};sys/eventfd.h" HAVE_EVENTFD)
-check_symbol_exists(ftruncate "${CURL_INCLUDES}" HAVE_FTRUNCATE)
-check_symbol_exists(_fseeki64 "${CURL_INCLUDES};stdio.h" HAVE__FSEEKI64)
-check_symbol_exists(getpeername "${CURL_INCLUDES}" HAVE_GETPEERNAME)
-check_symbol_exists(getsockname "${CURL_INCLUDES}" HAVE_GETSOCKNAME)
-check_symbol_exists(if_nametoindex "${CURL_INCLUDES}" HAVE_IF_NAMETOINDEX)
-check_symbol_exists(getrlimit "${CURL_INCLUDES}" HAVE_GETRLIMIT)
-check_symbol_exists(setlocale "${CURL_INCLUDES}" HAVE_SETLOCALE)
-check_symbol_exists(setmode "${CURL_INCLUDES}" HAVE_SETMODE)
-check_symbol_exists(setrlimit "${CURL_INCLUDES}" HAVE_SETRLIMIT)
+ set(CMAKE_REQUIRED_LIBRARIES "socket")
+endif()
+
+check_symbol_exists("fnmatch" "${CURL_INCLUDES};fnmatch.h" HAVE_FNMATCH)
+check_symbol_exists("basename" "${CURL_INCLUDES};string.h" HAVE_BASENAME)
+check_symbol_exists("opendir" "${CURL_INCLUDES};dirent.h" HAVE_OPENDIR)
+check_symbol_exists("socket" "${CURL_INCLUDES}" HAVE_SOCKET)
+check_symbol_exists("sched_yield" "${CURL_INCLUDES};sched.h" HAVE_SCHED_YIELD)
+check_symbol_exists("socketpair" "${CURL_INCLUDES}" HAVE_SOCKETPAIR)
+check_symbol_exists("recv" "${CURL_INCLUDES}" HAVE_RECV)
+check_symbol_exists("send" "${CURL_INCLUDES}" HAVE_SEND)
+check_symbol_exists("sendmsg" "${CURL_INCLUDES}" HAVE_SENDMSG)
+check_symbol_exists("select" "${CURL_INCLUDES}" HAVE_SELECT)
+check_symbol_exists("strdup" "${CURL_INCLUDES};string.h" HAVE_STRDUP)
+check_symbol_exists("strtok_r" "${CURL_INCLUDES};string.h" HAVE_STRTOK_R)
+check_symbol_exists("strcasecmp" "${CURL_INCLUDES};string.h" HAVE_STRCASECMP)
+check_symbol_exists("stricmp" "${CURL_INCLUDES};string.h" HAVE_STRICMP)
+check_symbol_exists("strcmpi" "${CURL_INCLUDES};string.h" HAVE_STRCMPI)
+check_symbol_exists("memrchr" "${CURL_INCLUDES};string.h" HAVE_MEMRCHR)
+check_symbol_exists("alarm" "${CURL_INCLUDES}" HAVE_ALARM)
+check_symbol_exists("arc4random" "${CURL_INCLUDES};stdlib.h" HAVE_ARC4RANDOM)
+check_symbol_exists("fcntl" "${CURL_INCLUDES}" HAVE_FCNTL)
+check_symbol_exists("getppid" "${CURL_INCLUDES}" HAVE_GETPPID)
+check_symbol_exists("utimes" "${CURL_INCLUDES}" HAVE_UTIMES)
+
+check_symbol_exists("gettimeofday" "${CURL_INCLUDES}" HAVE_GETTIMEOFDAY)
+check_symbol_exists("closesocket" "${CURL_INCLUDES}" HAVE_CLOSESOCKET)
+check_symbol_exists("sigsetjmp" "${CURL_INCLUDES};setjmp.h" HAVE_SIGSETJMP)
+check_symbol_exists("getpass_r" "${CURL_INCLUDES}" HAVE_GETPASS_R)
+check_symbol_exists("getpwuid" "${CURL_INCLUDES}" HAVE_GETPWUID)
+check_symbol_exists("getpwuid_r" "${CURL_INCLUDES}" HAVE_GETPWUID_R)
+check_symbol_exists("geteuid" "${CURL_INCLUDES}" HAVE_GETEUID)
+check_symbol_exists("utime" "${CURL_INCLUDES}" HAVE_UTIME)
+check_symbol_exists("gmtime_r" "${CURL_INCLUDES};stdlib.h;time.h" HAVE_GMTIME_R)
+
+check_symbol_exists("gethostbyname_r" "${CURL_INCLUDES}" HAVE_GETHOSTBYNAME_R)
+
+check_symbol_exists("signal" "${CURL_INCLUDES};signal.h" HAVE_SIGNAL)
+check_symbol_exists("strtoll" "${CURL_INCLUDES};stdlib.h" HAVE_STRTOLL)
+check_symbol_exists("strerror_r" "${CURL_INCLUDES};stdlib.h;string.h" HAVE_STRERROR_R)
+check_symbol_exists("sigaction" "signal.h" HAVE_SIGACTION)
+check_symbol_exists("siginterrupt" "${CURL_INCLUDES};signal.h" HAVE_SIGINTERRUPT)
+check_symbol_exists("getaddrinfo" "${CURL_INCLUDES};stdlib.h;string.h" HAVE_GETADDRINFO)
+check_symbol_exists("getifaddrs" "${CURL_INCLUDES};stdlib.h" HAVE_GETIFADDRS)
+check_symbol_exists("freeaddrinfo" "${CURL_INCLUDES}" HAVE_FREEADDRINFO)
+check_symbol_exists("pipe" "${CURL_INCLUDES}" HAVE_PIPE)
+check_symbol_exists("eventfd" "${CURL_INCLUDES};sys/eventfd.h" HAVE_EVENTFD)
+check_symbol_exists("ftruncate" "${CURL_INCLUDES}" HAVE_FTRUNCATE)
+check_symbol_exists("_fseeki64" "${CURL_INCLUDES};stdio.h" HAVE__FSEEKI64)
+check_symbol_exists("getpeername" "${CURL_INCLUDES}" HAVE_GETPEERNAME)
+check_symbol_exists("getsockname" "${CURL_INCLUDES}" HAVE_GETSOCKNAME)
+check_symbol_exists("if_nametoindex" "${CURL_INCLUDES}" HAVE_IF_NAMETOINDEX)
+check_symbol_exists("getrlimit" "${CURL_INCLUDES}" HAVE_GETRLIMIT)
+check_symbol_exists("setlocale" "${CURL_INCLUDES}" HAVE_SETLOCALE)
+check_symbol_exists("setmode" "${CURL_INCLUDES}" HAVE_SETMODE)
+check_symbol_exists("setrlimit" "${CURL_INCLUDES}" HAVE_SETRLIMIT)
if(NOT MSVC OR (MSVC_VERSION GREATER_EQUAL 1900))
# Earlier MSVC compilers had faulty snprintf implementations
- check_symbol_exists(snprintf "stdio.h" HAVE_SNPRINTF)
+ check_symbol_exists("snprintf" "stdio.h" HAVE_SNPRINTF)
endif()
-check_function_exists(mach_absolute_time HAVE_MACH_ABSOLUTE_TIME)
-check_symbol_exists(inet_ntop "${CURL_INCLUDES};stdlib.h;string.h" HAVE_INET_NTOP)
+check_function_exists("mach_absolute_time" HAVE_MACH_ABSOLUTE_TIME)
+check_symbol_exists("inet_ntop" "${CURL_INCLUDES};stdlib.h;string.h" HAVE_INET_NTOP)
if(MSVC AND (MSVC_VERSION LESS_EQUAL 1600))
set(HAVE_INET_NTOP OFF)
endif()
-check_symbol_exists(inet_pton "${CURL_INCLUDES};stdlib.h;string.h" HAVE_INET_PTON)
+check_symbol_exists("inet_pton" "${CURL_INCLUDES};stdlib.h;string.h" HAVE_INET_PTON)
-check_symbol_exists(fsetxattr "${CURL_INCLUDES}" HAVE_FSETXATTR)
+check_symbol_exists("fsetxattr" "${CURL_INCLUDES}" HAVE_FSETXATTR)
if(HAVE_FSETXATTR)
foreach(_curl_test IN ITEMS HAVE_FSETXATTR_5 HAVE_FSETXATTR_6)
curl_internal_test(${_curl_test})
# fseeko may not exist with _FILE_OFFSET_BITS=64 but can exist with
# _FILE_OFFSET_BITS unset or 32 (e.g. Android ARMv7 with NDK 26b and API level < 24)
# so we need to test fseeko after testing for _FILE_OFFSET_BITS
-check_symbol_exists(fseeko "${CURL_INCLUDES};stdio.h" HAVE_FSEEKO)
+check_symbol_exists("fseeko" "${CURL_INCLUDES};stdio.h" HAVE_FSEEKO)
if(HAVE_FSEEKO)
set(HAVE_DECL_FSEEKO 1)
if(CMAKE_COMPILER_IS_GNUCC AND APPLE)
include(CheckCCompilerFlag)
- check_c_compiler_flag(-Wno-long-double HAVE_C_FLAG_Wno_long_double)
+ check_c_compiler_flag("-Wno-long-double" HAVE_C_FLAG_Wno_long_double)
if(HAVE_C_FLAG_Wno_long_double)
# The Mac version of GCC warns about use of long double. Disable it.
- get_source_file_property(MPRINTF_COMPILE_FLAGS mprintf.c COMPILE_FLAGS)
- if(MPRINTF_COMPILE_FLAGS)
- set(MPRINTF_COMPILE_FLAGS "${MPRINTF_COMPILE_FLAGS} -Wno-long-double")
+ get_source_file_property(_mprintf_compile_flags "mprintf.c" COMPILE_FLAGS)
+ if(_mprintf_compile_flags)
+ set(_mprintf_compile_flags "${_mprintf_compile_flags} -Wno-long-double")
else()
- set(MPRINTF_COMPILE_FLAGS "-Wno-long-double")
+ set(_mprintf_compile_flags "-Wno-long-double")
endif()
- set_source_files_properties(mprintf.c PROPERTIES
- COMPILE_FLAGS ${MPRINTF_COMPILE_FLAGS})
+ set_source_files_properties("mprintf.c" PROPERTIES
+ COMPILE_FLAGS ${_mprintf_compile_flags})
endif()
endif()
include(CMake/OtherTests.cmake)
-add_definitions(-DHAVE_CONFIG_H)
+add_definitions("-DHAVE_CONFIG_H")
# For Windows, all compilers used by CMake should support large files
if(WIN32)
# Disable default manifest added by CMake
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
- add_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
+ add_definitions("-D_CRT_SECURE_NO_DEPRECATE" "-D_CRT_NONSTDC_NO_DEPRECATE")
if(CMAKE_C_FLAGS MATCHES "/W[0-4]")
string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
else()
# Ugly (but functional) way to include "Makefile.inc" by transforming it
# (= regenerate it).
-function(transform_makefile_inc INPUT_FILE OUTPUT_FILE)
- file(STRINGS "${INPUT_FILE}" _makefile_inc_lines)
+function(transform_makefile_inc _input_file _output_file)
+ file(STRINGS "${_input_file}" _makefile_inc_lines)
set(_makefile_inc_text "")
foreach(_line IN LISTS _makefile_inc_lines)
if(_line MATCHES "### USE SIMPLE LIST ASSIGMENTS ABOVE THIS LINE ###")
string(REGEX REPLACE "\\$\\(([a-zA-Z_][a-zA-Z0-9_]*)\\)" "\${\\1}" _makefile_inc_text ${_makefile_inc_text}) # Replace $() with ${}
string(REGEX REPLACE "@([a-zA-Z_][a-zA-Z0-9_]*)@" "\${\\1}" _makefile_inc_text ${_makefile_inc_text}) # Replace @@ with ${}, even if that may not be read by CMake scripts.
- file(WRITE ${OUTPUT_FILE} ${_makefile_inc_text})
- set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${INPUT_FILE}")
+ file(WRITE ${_output_file} ${_makefile_inc_text})
+ set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${_input_file}")
endfunction()
include(GNUInstallDirs)
-set(CURL_INSTALL_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
+set(CURL_INSTALL_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
set(_generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated")
set(_project_config "${_generated_dir}/${PROJECT_NAME}Config.cmake")
if(ENABLE_DIST_TEST)
# Get 'CMAKE_DIST' variable
transform_makefile_inc("Makefile.am" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.am.cmake")
- include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.am.cmake)
+ include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.am.cmake")
file(GLOB_RECURSE _curl_cmake_files_found RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/CMake/*.cmake"
# Helper to populate a list (_items) with a label when conditions
# (the remaining args) are satisfied
- macro(_add_if label)
+ macro(_add_if _label)
# Needs to be a macro to allow this indirection
if(${ARGN})
- set(_items ${_items} "${label}")
+ set(_items ${_items} "${_label}")
endif()
endmacro()
configure_file("${CURL_SOURCE_DIR}/libcurl.pc.in"
"${CURL_BINARY_DIR}/libcurl.pc" @ONLY)
install(FILES "${CURL_BINARY_DIR}/libcurl.pc"
- DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
# Install headers
install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/curl"
# Workaround for MSVS10 to avoid the Dialog Hell
# FIXME: This could be removed with future version of CMake.
if(MSVC_VERSION EQUAL 1600)
- set(CURL_SLN_FILENAME "${CMAKE_CURRENT_BINARY_DIR}/CURL.sln")
- if(EXISTS "${CURL_SLN_FILENAME}")
- file(APPEND "${CURL_SLN_FILENAME}" "\n# This should be regenerated!\n")
+ set(_curl_sln_filename "${CMAKE_CURRENT_BINARY_DIR}/CURL.sln")
+ if(EXISTS "${_curl_sln_filename}")
+ file(APPEND "${_curl_sln_filename}" "\n# This should be regenerated!\n")
endif()
endif()
if(NOT TARGET curl_uninstall)
configure_file(
- ${CMAKE_CURRENT_SOURCE_DIR}/CMake/cmake_uninstall.cmake.in
- ${CMAKE_CURRENT_BINARY_DIR}/CMake/cmake_uninstall.cmake
+ "${CMAKE_CURRENT_SOURCE_DIR}/CMake/cmake_uninstall.cmake.in"
+ "${CMAKE_CURRENT_BINARY_DIR}/CMake/cmake_uninstall.cmake"
IMMEDIATE @ONLY)
add_custom_target(curl_uninstall
COMMAND ${CMAKE_COMMAND} -P
- ${CMAKE_CURRENT_BINARY_DIR}/CMake/cmake_uninstall.cmake)
+ "${CMAKE_CURRENT_BINARY_DIR}/CMake/cmake_uninstall.cmake")
endif()
endif()
set(_man_target "${CURL_BINARY_DIR}/docs/${_man_misc}.1")
add_custom_command(OUTPUT "${_man_target}"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
- COMMAND "${PERL_EXECUTABLE}" ${PROJECT_SOURCE_DIR}/scripts/cd2nroff "${_man_misc}.md" > "${_man_target}"
+ COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/cd2nroff" "${_man_misc}.md" > "${_man_target}"
DEPENDS "${_man_misc}.md"
VERBATIM
)
add_custom_target("curl-generate-${_man_misc}.1" ALL DEPENDS "${_man_target}")
if(NOT CURL_DISABLE_INSTALL)
- install(FILES "${_man_target}" DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+ install(FILES "${_man_target}" DESTINATION "${CMAKE_INSTALL_MANDIR}/man1")
endif()
endforeach()
endif()
add_custom_command(OUTPUT "${MANPAGE}"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
- COMMAND "${PERL_EXECUTABLE}" ${PROJECT_SOURCE_DIR}/scripts/managen mainpage ${DPAGES} > "${MANPAGE}"
- COMMAND "${PERL_EXECUTABLE}" ${PROJECT_SOURCE_DIR}/scripts/managen ascii ${DPAGES} > "${ASCIIPAGE}"
+ COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/managen" mainpage ${DPAGES} > "${MANPAGE}"
+ COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/managen" ascii ${DPAGES} > "${ASCIIPAGE}"
VERBATIM
)
-add_custom_target(generate-curl.1 ALL DEPENDS "${MANPAGE}")
+add_custom_target("generate-curl.1" ALL DEPENDS "${MANPAGE}")
if(NOT CURL_DISABLE_INSTALL)
- install(FILES "${MANPAGE}" DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+ install(FILES "${MANPAGE}" DESTINATION "${CMAKE_INSTALL_MANDIR}/man1")
endif()
###########################################################################
# Get 'check_PROGRAMS' variable
-transform_makefile_inc("Makefile.inc"
- "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
+transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
foreach(_example IN LISTS check_PROGRAMS)
set(_example_target "curl-example-${_example}")
if(LIB_SELECTED STREQUAL LIB_STATIC AND WIN32)
set_property(TARGET ${_example_target} APPEND PROPERTY COMPILE_DEFINITIONS "CURL_STATICLIB")
endif()
- set_target_properties(${_example_target} PROPERTIES OUTPUT_NAME "${_example}" UNITY_BUILD OFF)
+ set_target_properties(${_example_target} PROPERTIES
+ OUTPUT_NAME "${_example}" UNITY_BUILD OFF)
endforeach()
if(NOT _file_count LESS ${_files_per_batch} OR _file STREQUAL "_EOL_")
add_custom_command(OUTPUT ${_rofffiles}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
- COMMAND "${PERL_EXECUTABLE}" ${PROJECT_SOURCE_DIR}/scripts/cd2nroff -k -d "${CMAKE_CURRENT_BINARY_DIR}" ${_mdfiles}
+ COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/cd2nroff" -k -d "${CMAKE_CURRENT_BINARY_DIR}" ${_mdfiles}
DEPENDS ${_mdfiles}
VERBATIM
)
endforeach()
endfunction()
-add_custom_command(OUTPUT libcurl-symbols.md
+add_custom_command(OUTPUT "libcurl-symbols.md"
COMMAND
"${PERL_EXECUTABLE}"
"${CMAKE_CURRENT_SOURCE_DIR}/mksymbolsmanpage.pl" <
- "${CMAKE_CURRENT_SOURCE_DIR}/symbols-in-versions" > libcurl-symbols.md
+ "${CMAKE_CURRENT_SOURCE_DIR}/symbols-in-versions" > "libcurl-symbols.md"
DEPENDS
"${CMAKE_CURRENT_SOURCE_DIR}/symbols-in-versions"
"${CMAKE_CURRENT_SOURCE_DIR}/mksymbolsmanpage.pl"
foreach(_f IN LISTS man_MANS)
list(APPEND _src "${CMAKE_CURRENT_BINARY_DIR}/${_f}")
endforeach()
- install(FILES ${_src} DESTINATION ${CMAKE_INSTALL_MANDIR}/man3)
+ install(FILES ${_src} DESTINATION "${CMAKE_INSTALL_MANDIR}/man3")
endif()
add_subdirectory(opts)
foreach(_f IN LISTS man_MANS)
list(APPEND _src "${CMAKE_CURRENT_BINARY_DIR}/${_f}")
endforeach()
- install(FILES ${_src} DESTINATION ${CMAKE_INSTALL_MANDIR}/man3)
+ install(FILES ${_src} DESTINATION "${CMAKE_INSTALL_MANDIR}/man3")
endif()
###########################################################################
set(LIB_NAME libcurl)
set(LIBCURL_OUTPUT_NAME libcurl CACHE STRING "Basename of the curl library")
-add_definitions(-DBUILDING_LIBCURL)
+add_definitions("-DBUILDING_LIBCURL")
-configure_file(curl_config.h.cmake
- ${CMAKE_CURRENT_BINARY_DIR}/curl_config.h)
+configure_file("curl_config.h.cmake" "${CMAKE_CURRENT_BINARY_DIR}/curl_config.h")
# Get 'CSOURCES', 'HHEADERS' variables
transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
# DllMain is added later for DLL builds only.
-list(REMOVE_ITEM CSOURCES dllmain.c)
+list(REMOVE_ITEM CSOURCES "dllmain.c")
-list(APPEND HHEADERS ${CMAKE_CURRENT_BINARY_DIR}/curl_config.h)
+list(APPEND HHEADERS "${CMAKE_CURRENT_BINARY_DIR}/curl_config.h")
# The rest of the build
EXCLUDE_FROM_ALL
${HHEADERS} ${CSOURCES}
)
- target_compile_definitions(curlu PUBLIC UNITTESTS CURL_STATICLIB)
+ target_compile_definitions(curlu PUBLIC "UNITTESTS" "CURL_STATICLIB")
target_link_libraries(curlu PRIVATE ${CURL_LIBS})
endif()
if(ENABLE_CURLDEBUG)
# We must compile these sources separately to avoid memdebug.h redefinitions
# applying to them.
- set_source_files_properties(memdebug.c curl_multibyte.c PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
+ set_source_files_properties("memdebug.c" "curl_multibyte.c" PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
endif()
## Library definition
endif()
target_include_directories(${LIB_OBJECT} INTERFACE
- $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
- $<BUILD_INTERFACE:${CURL_SOURCE_DIR}/include>)
+ "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+ "$<BUILD_INTERFACE:${CURL_SOURCE_DIR}/include>")
set(LIB_SOURCE $<TARGET_OBJECTS:${LIB_OBJECT}>)
else()
endif()
target_include_directories(${LIB_STATIC} INTERFACE
- $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
- $<BUILD_INTERFACE:${CURL_SOURCE_DIR}/include>)
+ "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+ "$<BUILD_INTERFACE:${CURL_SOURCE_DIR}/include>")
endif()
if(BUILD_SHARED_LIBS)
if(CYGWIN)
# For Cygwin always compile dllmain.c as a separate unit since it
# includes windows.h, which should not be included in other units.
- set_source_files_properties(dllmain.c PROPERTIES
+ set_source_files_properties("dllmain.c" PROPERTIES
SKIP_UNITY_BUILD_INCLUSION ON)
endif()
- set_property(TARGET ${LIB_SHARED} APPEND PROPERTY SOURCES dllmain.c)
+ set_property(TARGET ${LIB_SHARED} APPEND PROPERTY SOURCES "dllmain.c")
endif()
if(WIN32)
- set_property(TARGET ${LIB_SHARED} APPEND PROPERTY SOURCES libcurl.rc)
+ set_property(TARGET ${LIB_SHARED} APPEND PROPERTY SOURCES "libcurl.rc")
if(HIDES_CURL_PRIVATE_SYMBOLS)
set_property(TARGET ${LIB_SHARED} APPEND PROPERTY SOURCES "${CURL_SOURCE_DIR}/libcurl.def")
endif()
endif()
target_include_directories(${LIB_SHARED} INTERFACE
- $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
- $<BUILD_INTERFACE:${CURL_SOURCE_DIR}/include>)
+ "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+ "$<BUILD_INTERFACE:${CURL_SOURCE_DIR}/include>")
if(CMAKE_DLL_NAME_WITH_SOVERSION OR
CYGWIN OR
if(CURL_LIBCURL_SOVERSION OR CURL_LIBCURL_VERSIONED_SYMBOLS)
# Get 'VERSIONCHANGE', 'VERSIONADD', 'VERSIONDEL', 'VERSIONINFO' variables
transform_makefile_inc("Makefile.soname" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.soname.cmake")
- include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.soname.cmake)
+ include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.soname.cmake")
math(EXPR _cmakesoname "${VERSIONCHANGE} - ${VERSIONDEL}")
set(_cmakeversion "${_cmakesoname}.${VERSIONDEL}.${VERSIONADD}")
endif()
export(TARGETS ${libcurl_export}
- FILE ${PROJECT_BINARY_DIR}/libcurl-target.cmake
+ FILE "${PROJECT_BINARY_DIR}/libcurl-target.cmake"
NAMESPACE ${PROJECT_NAME}::
)
endif()
#
###########################################################################
set(EXE_NAME curl)
-add_definitions(-DBUILDING_CURL)
+add_definitions("-DBUILDING_CURL")
if(ENABLE_CURL_MANUAL AND HAVE_MANUAL_TOOLS)
add_definitions("-DUSE_MANUAL")
add_custom_command(
- OUTPUT tool_hugehelp.c
- COMMAND ${CMAKE_COMMAND} -E echo "#include \"tool_setup.h\"" > tool_hugehelp.c
- COMMAND ${CMAKE_COMMAND} -E echo "#ifndef HAVE_LIBZ" >> tool_hugehelp.c
- COMMAND "${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/mkhelp.pl" < "${CURL_BINARY_DIR}/docs/cmdline-opts/curl.txt" >> tool_hugehelp.c
-
- COMMAND ${CMAKE_COMMAND} -E echo "#else" >> tool_hugehelp.c
- COMMAND "${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/mkhelp.pl" -c < "${CURL_BINARY_DIR}/docs/cmdline-opts/curl.txt" >> tool_hugehelp.c
- COMMAND ${CMAKE_COMMAND} -E echo "#endif /* HAVE_LIBZ */" >> tool_hugehelp.c
+ OUTPUT "tool_hugehelp.c"
+ COMMAND ${CMAKE_COMMAND} -E echo "#include \"tool_setup.h\"" > "tool_hugehelp.c"
+ COMMAND ${CMAKE_COMMAND} -E echo "#ifndef HAVE_LIBZ" >> "tool_hugehelp.c"
+ COMMAND "${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/mkhelp.pl" < "${CURL_BINARY_DIR}/docs/cmdline-opts/curl.txt" >> "tool_hugehelp.c"
+
+ COMMAND ${CMAKE_COMMAND} -E echo "#else" >> "tool_hugehelp.c"
+ COMMAND "${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/mkhelp.pl" -c < "${CURL_BINARY_DIR}/docs/cmdline-opts/curl.txt" >> "tool_hugehelp.c"
+ COMMAND ${CMAKE_COMMAND} -E echo "#endif /* HAVE_LIBZ */" >> "tool_hugehelp.c"
DEPENDS
- generate-curl.1
+ "generate-curl.1"
"${CURL_BINARY_DIR}/docs/cmdline-opts/curl.1"
"${CMAKE_CURRENT_SOURCE_DIR}/mkhelp.pl"
"${CMAKE_CURRENT_SOURCE_DIR}/tool_hugehelp.h"
VERBATIM)
else()
add_custom_command(
- OUTPUT tool_hugehelp.c
- COMMAND ${CMAKE_COMMAND} -E echo "#include \"tool_hugehelp.h\"" > tool_hugehelp.c
+ OUTPUT "tool_hugehelp.c"
+ COMMAND ${CMAKE_COMMAND} -E echo "#include \"tool_hugehelp.h\"" > "tool_hugehelp.c"
DEPENDS
"${CMAKE_CURRENT_SOURCE_DIR}/tool_hugehelp.h"
VERBATIM)
# Get 'CURL_CFILES', 'CURLX_CFILES', 'CURL_HFILES', 'CURLTOOL_LIBCURL_CFILES' variables
transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
if(CURL_CA_EMBED_SET)
if(PERL_FOUND)
add_definitions("-DCURL_CA_EMBED")
add_custom_command(
- OUTPUT tool_ca_embed.c
- COMMAND "${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/mk-file-embed.pl" --var curl_ca_embed < "${CURL_CA_EMBED}" > tool_ca_embed.c
+ OUTPUT "tool_ca_embed.c"
+ COMMAND "${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/mk-file-embed.pl" --var curl_ca_embed < "${CURL_CA_EMBED}" > "tool_ca_embed.c"
DEPENDS
"${CURL_CA_EMBED}"
"${CMAKE_CURRENT_SOURCE_DIR}/mk-file-embed.pl"
VERBATIM)
- list(APPEND CURL_CFILES tool_ca_embed.c)
+ list(APPEND CURL_CFILES "tool_ca_embed.c")
else()
message(WARNING "Perl not found. Will not embed the CA bundle.")
endif()
endif()
if(WIN32)
- list(APPEND CURL_CFILES curl.rc)
+ list(APPEND CURL_CFILES "curl.rc")
endif()
if(BUILD_STATIC_CURL)
if(ENABLE_CURLDEBUG)
# We must compile this source separately to avoid memdebug.h redefinitions
# applying to them.
- set_source_files_properties(../lib/curl_multibyte.c PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
+ set_source_files_properties("../lib/curl_multibyte.c" PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
endif()
add_executable(
EXCLUDE_FROM_ALL
${CURL_CFILES} ${CURLTOOL_LIBCURL_CFILES} ${CURL_HFILES}
)
-target_compile_definitions(curltool PUBLIC UNITTESTS CURL_STATICLIB)
+target_compile_definitions(curltool PUBLIC "UNITTESTS" "CURL_STATICLIB")
target_link_libraries(curltool PRIVATE ${CURL_LIBS})
if(CURL_HAS_LTO)
endif()
if(ENABLE_UNICODE AND MINGW)
- target_link_libraries(${EXE_NAME} -municode)
+ target_link_libraries(${EXE_NAME} "-municode")
endif()
source_group("curlX source files" FILES ${CURLX_CFILES})
install(TARGETS ${EXE_NAME} EXPORT ${TARGETS_EXPORT_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR})
export(TARGETS ${EXE_NAME}
- FILE ${PROJECT_BINARY_DIR}/curl-target.cmake
+ FILE "${PROJECT_BINARY_DIR}/curl-target.cmake"
NAMESPACE ${PROJECT_NAME}::
)
add_subdirectory(libtest)
add_subdirectory(unit)
-function(add_runtests targetname test_flags)
+function(add_runtests _targetname _test_flags)
# Use a special '$TFLAGS' placeholder as last argument which will be
# replaced by the contents of the environment variable in runtests.pl.
# This is a workaround for CMake's limitation where commands executed by
# 'make' or 'ninja' cannot portably reference environment variables.
- string(REPLACE " " ";" _test_flags_list "${test_flags}")
- add_custom_target(${targetname}
+ string(REPLACE " " ";" _test_flags_list "${_test_flags}")
+ add_custom_target(${_targetname}
COMMAND
"${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/runtests.pl"
${_test_flags_list}
transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-foreach(_client IN LISTS check_PROGRAMS)
- set(_client_target "curl-test-client-${_client}")
- add_executable(${_client_target} "${_client}.c")
- add_dependencies(testdeps ${_client_target})
- target_include_directories(${_client_target} PRIVATE
+foreach(_test_name IN LISTS check_PROGRAMS)
+ set(_test_target "curl-test-client-${_test_name}")
+ add_executable(${_test_target} "${_test_name}.c")
+ add_dependencies(testdeps ${_test_target})
+ target_include_directories(${_test_target} PRIVATE
"${CURL_BINARY_DIR}/lib" # for "curl_config.h"
"${CURL_SOURCE_DIR}/lib" # for "curl_setup.h"
)
- target_link_libraries(${_client_target} ${LIB_SELECTED} ${CURL_LIBS})
- target_compile_definitions(${_client_target} PRIVATE "CURL_NO_OLDIES")
+ target_link_libraries(${_test_target} ${LIB_SELECTED} ${CURL_LIBS})
+ target_compile_definitions(${_test_target} PRIVATE "CURL_NO_OLDIES")
if(LIB_SELECTED STREQUAL LIB_STATIC AND WIN32)
- set_property(TARGET ${_client_target} APPEND PROPERTY COMPILE_DEFINITIONS "CURL_STATICLIB")
+ set_property(TARGET ${_test_target} APPEND PROPERTY COMPILE_DEFINITIONS "CURL_STATICLIB")
endif()
- set_target_properties(${_client_target} PROPERTIES OUTPUT_NAME "${_client}" UNITY_BUILD OFF)
+ set_target_properties(${_test_target} PROPERTIES
+ OUTPUT_NAME "${_test_name}" UNITY_BUILD OFF
+ PROJECT_LABEL "Test client ${_test_target}")
endforeach()
# SPDX-License-Identifier: curl
#
###########################################################################
-set(TARGET_LABEL_PREFIX "Test ")
-
-function(setup_test test_name) # ARGN are the files in the test
+function(setup_test _test_name) # ARGN are the files in the test
if(LIB_SELECTED STREQUAL LIB_STATIC)
# These are part of the libcurl static lib. Do not compile/link them again.
list(REMOVE_ITEM ARGN ${WARNLESS} ${MULTIBYTE} ${TIMEDIFF})
endif()
- add_executable(${test_name} EXCLUDE_FROM_ALL ${ARGN})
- add_dependencies(testdeps ${test_name})
- string(TOUPPER ${test_name} UPPER_TEST_NAME)
+ add_executable(${_test_name} EXCLUDE_FROM_ALL ${ARGN})
+ add_dependencies(testdeps ${_test_name})
+ string(TOUPPER ${_test_name} _upper_test_name)
include_directories(
"${CURL_BINARY_DIR}/lib" # for "curl_config.h"
include_directories(${CARES_INCLUDE_DIR})
endif()
- target_link_libraries(${test_name} ${LIB_SELECTED} ${CURL_LIBS})
+ target_link_libraries(${_test_name} ${LIB_SELECTED} ${CURL_LIBS})
- set_target_properties(${test_name}
- PROPERTIES COMPILE_DEFINITIONS ${UPPER_TEST_NAME})
- set_target_properties(${test_name}
- PROPERTIES PROJECT_LABEL "${TARGET_LABEL_PREFIX}${test_name}")
+ set_target_properties(${_test_name} PROPERTIES
+ COMPILE_DEFINITIONS ${_upper_test_name}
+ PROJECT_LABEL "Test ${_test_name}")
endfunction()
# Get 'noinst_PROGRAMS', '*_SOURCES' variables
transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
foreach(_test_name IN LISTS noinst_PROGRAMS)
if(DEFINED ${_test_name}_SOURCES)
# Allows for hostname override to make tests machine independent.
# TODO: this cmake build assumes a shared build, detect static linking here!
if(NOT WIN32)
- add_library(hostname MODULE EXCLUDE_FROM_ALL sethostname.c)
+ add_library(hostname MODULE EXCLUDE_FROM_ALL "sethostname.c")
add_dependencies(testdeps hostname)
# Output to .libs for compatibility with autotools, the test data expects a
# library at (tests)/libtest/.libs/libhostname.so
set_target_properties(hostname PROPERTIES
- LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/.libs)
+ LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/.libs")
if(HIDES_CURL_PRIVATE_SYMBOLS)
set_property(TARGET hostname APPEND PROPERTY COMPILE_DEFINITIONS "CURL_HIDDEN_SYMBOLS")
set_property(TARGET hostname APPEND PROPERTY COMPILE_FLAGS ${CURL_CFLAG_SYMBOLS_HIDE})
endif()
add_custom_command(
- OUTPUT lib1521.c
- COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/mk-lib1521.pl < ${CURL_SOURCE_DIR}/include/curl/curl.h > lib1521.c
+ OUTPUT "lib1521.c"
+ COMMAND ${PERL_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/mk-lib1521.pl" < "${CURL_SOURCE_DIR}/include/curl/curl.h" > "lib1521.c"
DEPENDS
"${CMAKE_CURRENT_SOURCE_DIR}/mk-lib1521.pl"
"${CURL_SOURCE_DIR}/include/curl/curl.h"
# SPDX-License-Identifier: curl
#
###########################################################################
-set(TARGET_LABEL_PREFIX "Test server ")
-
-function(setup_executable test_name) # ARGN are the files in the test
- add_executable(${test_name} EXCLUDE_FROM_ALL ${ARGN})
- add_dependencies(testdeps ${test_name})
+function(setup_executable _test_name) # ARGN are the files in the test
+ add_executable(${_test_name} EXCLUDE_FROM_ALL ${ARGN})
+ add_dependencies(testdeps ${_test_name})
include_directories(
"${CURL_BINARY_DIR}/lib" # for "curl_config.h"
include_directories(${CARES_INCLUDE_DIR})
endif()
- target_link_libraries(${test_name} ${CURL_LIBS})
+ target_link_libraries(${_test_name} ${CURL_LIBS})
# Test servers simply are standalone programs that do not use libcurl
# library. For convenience and to ease portability of these servers,
# to build the servers. In order to achieve proper linkage of these
# files on Windows targets it is necessary to build the test servers
# with CURL_STATICLIB defined, independently of how libcurl is built.
- set_target_properties(${test_name} PROPERTIES
- COMPILE_DEFINITIONS CURL_STATICLIB)
- set_target_properties(${test_name} PROPERTIES
- PROJECT_LABEL "${TARGET_LABEL_PREFIX}${test_name}")
+ set_target_properties(${_test_name} PROPERTIES
+ COMPILE_DEFINITIONS "CURL_STATICLIB"
+ PROJECT_LABEL "Test server ${_test_name}")
endfunction()
# Get 'noinst_PROGRAMS', '<target>_SOURCES' variables
-transform_makefile_inc("Makefile.inc"
- "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
+transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
foreach(_executable_name IN LISTS noinst_PROGRAMS)
setup_executable(${_executable_name} ${${_executable_name}_SOURCES})
# Get 'UNITPROGS', 'UNITFILES' variables
transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
include_directories(
"${CURL_BINARY_DIR}/lib" # for "curl_config.h"
"${CURL_SOURCE_DIR}/tests/libtest"
)
-foreach(_testfile IN LISTS UNITPROGS)
- add_executable(${_testfile} EXCLUDE_FROM_ALL ${_testfile}.c ${UNITFILES})
- add_dependencies(testdeps ${_testfile})
- target_link_libraries(${_testfile} curltool curlu)
+foreach(_test_name IN LISTS UNITPROGS)
+ add_executable(${_test_name} EXCLUDE_FROM_ALL "${_test_name}.c" ${UNITFILES})
+ add_dependencies(testdeps ${_test_name})
+ target_link_libraries(${_test_name} curltool curlu)
+ set_target_properties(${_test_name} PROPERTIES
+ PROJECT_LABEL "Test unit ${_test_name}")
endforeach()
projects / thirdparty / curl.git / commitdiff
