luo980/curl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cmake: more syntax tidy-up

Browse Source 
- quote string literals.
  In the hope it improves syntax-highlighting and readability.

- use lowercase, underscore-prefixed local var names.
  As a hint for scope, to help readability.

- prefer `pkg_search_module` (over `pkg_check_modules`).
  They are the same, but `pkg_search_module` stops searching
  at the first hit.

- more `IN LISTS` in `foreach()`.

- OtherTests.cmake: clear `CMAKE_EXTRA_INCLUDE_FILES` after use.

- add `PROJECT_LABEL` for http/client and unit test targets.

- sync `Find*` module comments and formatting.

- drop a few local variables.

- drop bogus `CARES_LIBRARIES` from comment.

- unquote numeric literal.

Follow-up to acbc6b703f #14197
Closes #14388
This commit is contained in:
Viktor Szakats 2024-08-04 20:35:13 +02:00
parent 63e9e06794
commit c2889a7b41
No known key found for this signature in database
GPG Key ID: B5ABD165E2AEF201
31 changed files with 551 additions and 483 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
CMake/FindBearSSL.cmake
View File

@ -21,12 +21,22 @@
# 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_library(BEARSSL_LIBRARY bearssl)
find_path(BEARSSL_INCLUDE_DIRS "bearssl.h")
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)

14
CMake/FindBrotli.cmake
View File

@ -21,20 +21,28 @@
# 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"
)

30
CMake/FindCARES.cmake
View File

@ -21,27 +21,25 @@
# 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)

177
CMake/FindGSS.cmake
View File

@ -21,30 +21,32 @@
# 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"
# 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)
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}"
)
@ -53,48 +55,48 @@ set(_GSS_ROOT_HINTS
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}")
@ -105,20 +107,20 @@ if(NOT _GSS_FOUND) # Not found by pkg-config. Let us take more traditional appr
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}")
@ -132,29 +134,29 @@ if(NOT _GSS_FOUND) # Not found by pkg-config. Let us take more traditional appr
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")
@ -167,28 +169,28 @@ if(NOT _GSS_FOUND) # Not found by pkg-config. Let us take more traditional appr
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
@ -196,10 +198,10 @@ if(NOT _GSS_FOUND) # Not found by pkg-config. Let us take more traditional appr
NAMES
"gssapi.h"
HINTS
${_GSS_ROOT_HINTS}
${_gss_root_hints}
PATH_SUFFIXES
include
inc
"include"
"inc"
)
if(_GSS_INCLUDE_DIRS)
@ -209,56 +211,56 @@ if(NOT _GSS_FOUND) # Not found by pkg-config. Let us take more traditional appr
# 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()
@ -273,26 +275,25 @@ set(GSS_VERSION ${_GSS_VERSION})
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()
@ -301,11 +302,9 @@ 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

28
CMake/FindLibPSL.cmake
View File

@ -21,25 +21,31 @@
# 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)

28
CMake/FindLibSSH2.cmake
View File

@ -21,25 +21,31 @@
# 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)

13
CMake/FindMSH3.cmake
View File

@ -24,22 +24,23 @@
# 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}
@ -48,13 +49,13 @@ find_library(MSH3_LIBRARY NAMES msh3
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)

22
CMake/FindMbedTLS.cmake
View File

@ -21,16 +21,28 @@
# 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_library(MBEDTLS_LIBRARY mbedtls)
find_library(MBEDX509_LIBRARY mbedx509)
find_library(MBEDCRYPTO_LIBRARY mbedcrypto)
find_path(MBEDTLS_INCLUDE_DIRS "mbedtls/ssl.h")
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)

13
CMake/FindNGHTTP2.cmake
View File

@ -21,6 +21,14 @@
# 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)
@ -48,9 +56,10 @@ find_package_handle_standard_args(NGHTTP2
FOUND_VAR
NGHTTP2_FOUND
REQUIRED_VARS
NGHTTP2_LIBRARY
NGHTTP2_INCLUDE_DIR
VERSION_VAR NGHTTP2_VERSION
NGHTTP2_LIBRARY
VERSION_VAR
NGHTTP2_VERSION
)
if(NGHTTP2_FOUND)

18
CMake/FindNGHTTP3.cmake
View File

@ -24,23 +24,24 @@
# 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}
@ -53,14 +54,15 @@ endif()
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)

20
CMake/FindNGTCP2.cmake
View File

@ -32,23 +32,24 @@
# 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}
@ -72,7 +73,7 @@ if(NGTCP2_FIND_COMPONENTS)
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
@ -91,15 +92,16 @@ endif()
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)

18
CMake/FindNettle.cmake
View File

@ -21,16 +21,18 @@
# 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)
@ -64,7 +66,9 @@ else()
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})

11
CMake/FindQUICHE.cmake
View File

@ -24,22 +24,23 @@
# 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}
@ -48,13 +49,13 @@ find_library(QUICHE_LIBRARY NAMES quiche
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)

13
CMake/FindWolfSSL.cmake
View File

@ -21,9 +21,17 @@
# 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"
@ -49,7 +57,8 @@ find_package_handle_standard_args(WolfSSL
REQUIRED_VARS
WolfSSL_INCLUDE_DIR
WolfSSL_LIBRARY
VERSION_VAR WolfSSL_VERSION
VERSION_VAR
WolfSSL_VERSION
)
if(WolfSSL_FOUND)

19
CMake/FindZstd.cmake
View File

@ -23,23 +23,25 @@
###########################################################################
# 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}
@ -54,14 +56,15 @@ endif()
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)

55
CMake/Macros.cmake
View File

@ -27,49 +27,50 @@
# 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()

7
CMake/OtherTests.cmake
View File

@ -25,10 +25,10 @@ include(CheckCSourceCompiles)
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()
@ -45,6 +45,7 @@ if(NOT DEFINED HAVE_STRUCT_SOCKADDR_STORAGE)
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)

4
CMake/Utilities.cmake
View File

@ -24,12 +24,12 @@
# 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()

332
CMakeLists.txt
View File

@ -123,12 +123,12 @@ if(WIN32)
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()
@ -146,11 +146,11 @@ option(ENABLE_DEBUG "Set to ON to enable curl debug features" OFF)
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
@ -326,7 +326,7 @@ if(ENABLE_IPV6 AND NOT WIN32)
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)
@ -408,7 +408,7 @@ if(HAVE_LIBSOCKET)
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")
@ -418,7 +418,7 @@ endif()
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)
@ -440,7 +440,7 @@ endif()
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
@ -449,7 +449,7 @@ count_true(enabled_ssl_options_count
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()
@ -459,7 +459,7 @@ if(CURL_USE_SCHANNEL)
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)
@ -467,7 +467,7 @@ 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)
@ -479,11 +479,11 @@ if(CURL_USE_SECTRANSP)
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")
@ -514,16 +514,16 @@ if(CURL_USE_OPENSSL)
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()
@ -536,9 +536,9 @@ if(CURL_USE_MBEDTLS)
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)
@ -549,9 +549,9 @@ 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)
@ -563,9 +563,9 @@ 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)
@ -578,20 +578,20 @@ 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()
@ -645,8 +645,8 @@ if(CURL_ZSTD)
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}")
@ -668,12 +668,12 @@ macro(openssl_check_symbol_exists SYMBOL FILES VARIABLE EXTRA_LIBS)
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()
@ -681,9 +681,9 @@ 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)
@ -692,16 +692,16 @@ macro(openssl_check_quic)
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()
@ -712,11 +712,11 @@ if(USE_ECH)
# 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)
@ -794,7 +794,7 @@ if(USE_QUICHE)
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()
@ -898,7 +898,7 @@ if(NOT CURL_DISABLE_LDAP)
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)
@ -921,8 +921,8 @@ if(NOT CURL_DISABLE_LDAP)
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)
@ -957,7 +957,7 @@ if(USE_LIBIDN2)
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)
@ -1005,7 +1005,7 @@ if(CURL_USE_LIBPSL)
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()
@ -1021,7 +1021,7 @@ if(CURL_USE_LIBSSH2)
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()
@ -1035,7 +1035,7 @@ if(NOT USE_LIBSSH2 AND CURL_USE_LIBSSH)
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()
@ -1054,7 +1054,7 @@ option(CURL_USE_GSASL "Use GSASL implementation" OFF)
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()
@ -1077,28 +1077,28 @@ if(CURL_USE_GSSAPI)
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)
@ -1174,7 +1174,7 @@ endif()
#
# 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
@ -1191,10 +1191,10 @@ if(curl_ca_bundle_supported)
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 "")
@ -1204,20 +1204,20 @@ if(curl_ca_bundle_supported)
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"
@ -1228,13 +1228,13 @@ if(curl_ca_bundle_supported)
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)
@ -1242,7 +1242,7 @@ if(curl_ca_bundle_supported)
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()
@ -1339,20 +1339,20 @@ check_include_file_concat("termios.h" HAVE_TERMIOS_H)
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
@ -1365,83 +1365,83 @@ if(SIZEOF_SUSECONDS_T)
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)
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("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("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("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)
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})
@ -1495,7 +1495,7 @@ check_type_size("off_t" SIZEOF_OFF_T)
# 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)
@ -1591,23 +1591,23 @@ endif()
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)
@ -1631,7 +1631,7 @@ if(MSVC)
# 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()
@ -1672,8 +1672,8 @@ endif()
# 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 ###")
@ -1691,13 +1691,13 @@ function(transform_makefile_inc INPUT_FILE OUTPUT_FILE)
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")
@ -1730,7 +1730,7 @@ endif()
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"
@ -1754,10 +1754,10 @@ if(NOT CURL_DISABLE_INSTALL)
# 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()
@ -2012,7 +2012,7 @@ if(NOT CURL_DISABLE_INSTALL)
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"
@ -2053,20 +2053,20 @@ if(NOT CURL_DISABLE_INSTALL)
# 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()

4
docs/CMakeLists.txt
View File

@ -34,13 +34,13 @@ if(BUILD_MISC_DOCS)
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()

8
docs/cmdline-opts/CMakeLists.txt
View File

@ -30,11 +30,11 @@ include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
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()

8
docs/examples/CMakeLists.txt
View File

@ -23,9 +23,8 @@
###########################################################################
# 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}")
@ -35,5 +34,6 @@ foreach(_example IN LISTS check_PROGRAMS)
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()

8
docs/libcurl/CMakeLists.txt
View File

@ -41,7 +41,7 @@ function(add_manual_pages _listname)
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
)
@ -61,11 +61,11 @@ function(add_manual_pages _listname)
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"
@ -79,7 +79,7 @@ if(NOT CURL_DISABLE_INSTALL)
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)

2
docs/libcurl/opts/CMakeLists.txt
View File

@ -33,5 +33,5 @@ if(NOT CURL_DISABLE_INSTALL)
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()

37
lib/CMakeLists.txt
View File

@ -23,19 +23,18 @@
###########################################################################
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
@ -54,14 +53,14 @@ if(BUILD_TESTING)
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
@ -113,8 +112,8 @@ if(SHARE_LIB_OBJECT)
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()
@ -147,8 +146,8 @@ if(BUILD_STATIC_LIBS)
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)
@ -159,13 +158,13 @@ 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()
@ -187,8 +186,8 @@ if(BUILD_SHARED_LIBS)
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
@ -213,7 +212,7 @@ if(BUILD_SHARED_LIBS)
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}")
@ -285,7 +284,7 @@ if(CURL_ENABLE_EXPORT_TARGET)
endif()
export(TARGETS ${libcurl_export}
FILE ${PROJECT_BINARY_DIR}/libcurl-target.cmake
FILE "${PROJECT_BINARY_DIR}/libcurl-target.cmake"
NAMESPACE ${PROJECT_NAME}::
)
endif()

40
src/CMakeLists.txt
View File

@ -22,29 +22,29 @@
#
###########################################################################
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
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
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)
@ -52,26 +52,26 @@ endif()
# 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)
@ -81,7 +81,7 @@ endif()
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(
@ -100,7 +100,7 @@ add_library(
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)
@ -110,7 +110,7 @@ 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})
@ -131,6 +131,6 @@ target_link_libraries(${EXE_NAME} ${LIB_SELECTED_FOR_EXE} ${CURL_LIBS})
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}::
)

6
tests/CMakeLists.txt
View File

@ -37,13 +37,13 @@ add_subdirectory(server)
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}

20
tests/http/clients/CMakeLists.txt
View File

@ -26,18 +26,20 @@
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()

29
tests/libtest/CMakeLists.txt
View File

@ -21,18 +21,16 @@
# 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"
@ -43,17 +41,16 @@ function(setup_test test_name) # ARGN are the files in the test
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)
@ -66,12 +63,12 @@ endforeach()
# 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})
@ -79,8 +76,8 @@ if(NOT WIN32)
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"

22
tests/server/CMakeLists.txt
View File

@ -21,11 +21,9 @@
# 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"
@ -36,7 +34,7 @@ function(setup_executable test_name) # ARGN are the files in the test
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,
@ -44,16 +42,14 @@ function(setup_executable test_name) # ARGN are the files in the test
# 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})

12
tests/unit/CMakeLists.txt
View File

@ -24,7 +24,7 @@
# 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"
@ -33,8 +33,10 @@ include_directories(
"${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()