#***************************************************************************

# _ _ ____ _

# Project ___| | | | _ \| |

# / __| | | | |_) | |

# | (__| |_| | _ <| |___

# \___|\___/|_| \_\_____|

#

# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.

#

# This software is licensed as described in the file COPYING, which

# you should have received as part of this distribution. The terms

# are also available at https://curl.se/docs/copyright.html.

#

# You may opt to use, copy, modify, merge, publish, distribute and/or sell

# copies of the Software, and permit persons to whom the Software is

# furnished to do so, under the terms of the COPYING file.

#

# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY

# KIND, either express or implied.

#

# SPDX-License-Identifier: curl

#

###########################################################################

cmake_minimum_required(VERSION 3.18 FATAL_ERROR)

message(STATUS "Using CMake version ${CMAKE_VERSION}")

# Collect command-line arguments for buildinfo.txt.

# Must reside at the top of the script to work as expected.

set(_cmake_args "")

if(NOT "$ENV{CURL_BUILDINFO}$ENV{CURL_CI}$ENV{CI}" STREQUAL "")

get_cmake_property(_cache_vars CACHE_VARIABLES)

foreach(_cache_var IN ITEMS ${_cache_vars})

get_property(_cache_var_helpstring CACHE ${_cache_var} PROPERTY HELPSTRING)

if(_cache_var_helpstring STREQUAL "No help, variable specified on the command line.")

get_property(_cache_var_type CACHE ${_cache_var} PROPERTY TYPE)

get_property(_cache_var_value CACHE ${_cache_var} PROPERTY VALUE)

if(_cache_var_type STREQUAL "UNINITIALIZED")

set(_cache_var_type "")

else()

set(_cache_var_type ":${_cache_var_type}")

endif()

string(APPEND _cmake_args " -D${_cache_var}${_cache_var_type}=\"${_cache_var_value}\"")

endif()

endforeach()

endif()

list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake")

include(Utilities)

include(Macros)

include(CMakeDependentOption)

include(CheckCCompilerFlag)

file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/curl/curlver.h" _curl_version_h_contents REGEX "#define LIBCURL_VERSION( |_NUM )")

string(REGEX MATCH "#define LIBCURL_VERSION \"[^\"]*" _curl_version ${_curl_version_h_contents})

string(REGEX REPLACE "[^\"]+\"" "" _curl_version ${_curl_version})

string(REGEX MATCH "#define LIBCURL_VERSION_NUM 0x[0-9a-fA-F]+" _curl_version_num ${_curl_version_h_contents})

string(REGEX REPLACE "[^0]+0x" "" _curl_version_num ${_curl_version_num})

unset(_curl_version_h_contents)

message(STATUS "curl version=[${_curl_version}]")

string(REGEX REPLACE "([0-9]+\.[0-9]+\.[0-9]+).+" "\\1" _curl_version_sem "${_curl_version}")

project(CURL

VERSION "${_curl_version_sem}"

LANGUAGES C)

# CMake does not recognize some targets accurately. Touch up configuration manually as a workaround.

if(WINDOWS_STORE AND MINGW) # MinGW UWP build

# CMake (as of v3.31.2) gets confused and applies the MSVC rc.exe command-line

# template to windres. Reset it to the windres template as in 'Modules/Platform/Windows-windres.cmake':

set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -O coff <DEFINES> <INCLUDES> <FLAGS> <SOURCE> <OBJECT>")

elseif(DOS AND CMAKE_C_COMPILER_ID STREQUAL "GNU") # DJGPP

set(CMAKE_STATIC_LIBRARY_PREFIX "lib")

set(CMAKE_STATIC_LIBRARY_SUFFIX ".a")

set(CMAKE_FIND_LIBRARY_PREFIXES "lib")

set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")

endif()

# Fill platform level variable when using CMake's built-in Android configuration

if(ANDROID AND NOT DEFINED ANDROID_PLATFORM_LEVEL AND NOT CMAKE_SYSTEM_VERSION EQUAL 1)

set(ANDROID_PLATFORM_LEVEL "${CMAKE_SYSTEM_VERSION}")

endif()

set(_target_flags "")

if(APPLE)

string(APPEND _target_flags " APPLE")

endif()

if(UNIX)

string(APPEND _target_flags " UNIX")

endif()

if(BSD)

string(APPEND _target_flags " BSD")

endif()

if(ANDROID)

string(APPEND _target_flags " ANDROID-${ANDROID_PLATFORM_LEVEL}")

endif()

if(WIN32)

string(APPEND _target_flags " WIN32")

endif()

if(WINDOWS_STORE)

string(APPEND _target_flags " UWP")

endif()

if(CYGWIN)

string(APPEND _target_flags " CYGWIN")

endif()

if(DOS)

string(APPEND _target_flags " DOS")

endif()

if(AMIGA)

string(APPEND _target_flags " AMIGA")

endif()

if(CMAKE_C_COMPILER_ID STREQUAL "GNU")

string(APPEND _target_flags " GCC")

endif()

if(CMAKE_C_COMPILER_ID STREQUAL "AppleClang")

string(APPEND _target_flags " APPLE-CLANG")

elseif(CMAKE_C_COMPILER_ID STREQUAL "Clang" AND MSVC)

string(APPEND _target_flags " CLANG-CL")

elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")

string(APPEND _target_flags " LLVM-CLANG")

endif()

if(MINGW)

string(APPEND _target_flags " MINGW")

endif()

if(MSVC)

string(APPEND _target_flags " MSVC-${MSVC_VERSION}")

endif()

if(VCPKG_TOOLCHAIN)

string(APPEND _target_flags " VCPKG")

endif()

if(CMAKE_CROSSCOMPILING)

string(APPEND _target_flags " CROSS")

endif()

if(CMAKE_C_STANDARD)

string(APPEND _target_flags " C${CMAKE_C_STANDARD}")

endif()

message(STATUS "CMake platform flags:${_target_flags}")

if(CMAKE_CROSSCOMPILING)

message(STATUS "Cross-compiling: "

"${CMAKE_HOST_SYSTEM_NAME}/${CMAKE_HOST_SYSTEM_PROCESSOR} -> "

"${CMAKE_SYSTEM_NAME}/${CMAKE_SYSTEM_PROCESSOR}")

endif()

if(CMAKE_C_COMPILER_TARGET)

set(CURL_OS "\"${CMAKE_C_COMPILER_TARGET}\"")

else()

set(CURL_OS "\"${CMAKE_SYSTEM_NAME}\"")

endif()

if(CURL_PATCHSTAMP)

set(CURL_PATCHSTAMP "\"${CURL_PATCHSTAMP}\"")

endif()

set(LIB_NAME "libcurl")

set(EXE_NAME "curl")

set_property(DIRECTORY APPEND PROPERTY INCLUDE_DIRECTORIES "${PROJECT_SOURCE_DIR}/include")

if(NOT DEFINED CMAKE_UNITY_BUILD_BATCH_SIZE)

set(CMAKE_UNITY_BUILD_BATCH_SIZE 0)

endif()

# Having CMAKE_TRY_COMPILE_TARGET_TYPE set to STATIC_LIBRARY breaks certain

# 'check_function_exists()' detections (possibly more), by detecting

# non-existing features. This happens by default when using 'ios.toolchain.cmake'.

# Work it around by setting this value to `EXECUTABLE`.

if(CMAKE_TRY_COMPILE_TARGET_TYPE STREQUAL "STATIC_LIBRARY")

message(STATUS "CMAKE_TRY_COMPILE_TARGET_TYPE was found set to STATIC_LIBRARY. "

"Overriding with EXECUTABLE for feature detections to work.")

set(_cmake_try_compile_target_type_save ${CMAKE_TRY_COMPILE_TARGET_TYPE})

set(CMAKE_TRY_COMPILE_TARGET_TYPE "EXECUTABLE")

endif()

option(CURL_WERROR "Turn compiler warnings into errors" OFF)

option(PICKY_COMPILER "Enable picky compiler options" ON)

option(BUILD_CURL_EXE "Build curl executable" ON)

get_property(_has_shared GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)

option(BUILD_SHARED_LIBS "Build shared libraries" ${_has_shared})

option(BUILD_STATIC_LIBS "Build static libraries" OFF)

option(BUILD_STATIC_CURL "Build curl executable with static libcurl" OFF)

option(ENABLE_ARES "Enable c-ares support" OFF)

option(CURL_DISABLE_INSTALL "Disable installation targets" OFF)

option(CURL_BUILD_EVERYTHING "Build optional build targets (examples, tests) by default" OFF)

if(WIN32)

option(ENABLE_UNICODE "Use the Unicode version of the Windows API functions" OFF)

if(WINDOWS_STORE)

set(ENABLE_UNICODE ON)

endif()

if(ENABLE_UNICODE)

set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "UNICODE" "_UNICODE")

if(MINGW)

set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS "-municode")

endif()

endif()

# Apply to all feature checks

list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DWIN32_LEAN_AND_MEAN")

set(CURL_TARGET_WINDOWS_VERSION "" CACHE STRING "Minimum target Windows version as hex string")

if(CURL_TARGET_WINDOWS_VERSION)

if(CURL_TARGET_WINDOWS_VERSION MATCHES "^0x[0-9a-fA-F]+$")

set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION}")

list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION}") # Apply to all feature checks

else()

message(WARNING "CURL_TARGET_WINDOWS_VERSION value '${CURL_TARGET_WINDOWS_VERSION}' is not a valid hex string.")

endif()

endif()

# Detect actual value of _WIN32_WINNT and store as HAVE_WIN32_WINNT

curl_internal_test(HAVE_WIN32_WINNT)

if(HAVE_WIN32_WINNT)

string(REGEX MATCH "_WIN32_WINNT=0x[0-9a-fA-F]+" CURL_TEST_OUTPUT "${CURL_TEST_OUTPUT}")

string(REGEX REPLACE "_WIN32_WINNT=" "" CURL_TEST_OUTPUT "${CURL_TEST_OUTPUT}")

string(REGEX REPLACE "0x([0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])$" "0x0\\1" CURL_TEST_OUTPUT "${CURL_TEST_OUTPUT}") # pad to 4 digits

string(TOLOWER "${CURL_TEST_OUTPUT}" HAVE_WIN32_WINNT)

message(STATUS "Found _WIN32_WINNT=${HAVE_WIN32_WINNT}")

endif()

unset(HAVE_WIN32_WINNT CACHE) # Avoid storing in CMake cache

if(MINGW)

# Detect __MINGW64_VERSION_MAJOR, __MINGW64_VERSION_MINOR and store as MINGW64_VERSION

curl_internal_test(MINGW64_VERSION)

if(MINGW64_VERSION)

string(REGEX MATCH "MINGW64_VERSION=[0-9]+\.[0-9]+" CURL_TEST_OUTPUT "${CURL_TEST_OUTPUT}")

string(REGEX REPLACE "MINGW64_VERSION=" "" MINGW64_VERSION "${CURL_TEST_OUTPUT}")

if(MINGW64_VERSION)

message(STATUS "Found MINGW64_VERSION=${MINGW64_VERSION}")

if(MINGW64_VERSION VERSION_LESS 3.0)

message(FATAL_ERROR "mingw-w64 3.0 or upper is required")

endif()

endif()

endif()

unset(MINGW64_VERSION CACHE) # Avoid storing in CMake cache

endif()

elseif(DOS)

set(BUILD_SHARED_LIBS OFF)

set(BUILD_STATIC_LIBS ON)

endif()

option(CURL_LTO "Enable compiler Link Time Optimizations" OFF)

if(NOT DOS AND NOT AMIGA)

# if c-ares is used, default the threaded resolver to OFF

if(ENABLE_ARES)

set(_enable_threaded_resolver_default OFF)

else()

set(_enable_threaded_resolver_default ON)

endif()

option(ENABLE_THREADED_RESOLVER "Enable threaded DNS lookup" ${_enable_threaded_resolver_default})

endif()

if(CYGWIN OR CMAKE_SYSTEM_NAME STREQUAL "Linux" OR CMAKE_SYSTEM_NAME STREQUAL "GNU")

set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "_GNU_SOURCE") # Required for accept4(), pipe2(), sendmmsg()

list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_GNU_SOURCE") # Apply to all feature checks

endif()

option(ENABLE_DEBUG "Enable curl debug features (for developing curl itself)" OFF)

if(ENABLE_DEBUG)

message(WARNING "This curl build is Debug-enabled and insecure, do not use in production.")

endif()

set(CURL_DEBUG_MACROS "")

if(ENABLE_DEBUG)

list(APPEND CURL_DEBUG_MACROS "DEBUGBUILD")

endif()

option(CURL_CLANG_TIDY "Run the build through clang-tidy" OFF)

if(CURL_CLANG_TIDY)

find_program(CLANG_TIDY NAMES "clang-tidy" REQUIRED)

if(NOT CMAKE_C_COMPILER_ID MATCHES "Clang")

set(PICKY_COMPILER OFF) # Do a best effort and skip passing non-clang warning options to clang-tidy.

# This lets through warning options enabled via CURL_WERROR=ON, affecting lib and src.

endif()

set(CURL_DISABLE_TYPECHECK ON) # to improve performance (1.4x), avoid potential interference and bugprone-macro-parentheses.

set(CMAKE_C_CLANG_TIDY "${CLANG_TIDY}")

list(APPEND CMAKE_C_CLANG_TIDY "--config-file=${PROJECT_SOURCE_DIR}/.clang-tidy.yml")

if(CURL_WERROR)

list(APPEND CMAKE_C_CLANG_TIDY "--warnings-as-errors=*")

endif()

if(CURL_CLANG_TIDYFLAGS)

string(REPLACE " " ";" _tidy_flags_list "${CURL_CLANG_TIDYFLAGS}")

list(APPEND CMAKE_C_CLANG_TIDY ${_tidy_flags_list})

endif()

endif()

option(CURL_GCC_ANALYZER "Enable GCC --analyzer option" OFF)

if(CURL_GCC_ANALYZER AND CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0)

set(CURL_DISABLE_TYPECHECK ON) # to improve performance (1.1x).

# https://gcc.gnu.org/onlinedocs/gcc/Static-Analyzer-Options.html

set(CURL_ANALYZER_CFLAGS "-fanalyzer")

# disable checks causing false positives only

list(APPEND CURL_ANALYZER_CFLAGS "-Wno-analyzer-fd-leak" "-Wno-analyzer-fd-use-without-check" "-Wno-analyzer-file-leak")

list(APPEND CURL_ANALYZER_CFLAGS "-Wno-analyzer-infinite-loop")

list(APPEND CURL_ANALYZER_CFLAGS "-Wno-analyzer-malloc-leak")

list(APPEND CURL_ANALYZER_CFLAGS "-Wno-analyzer-out-of-bounds")

endif()

option(CURL_CODE_COVERAGE "Enable code coverage build options" OFF)

if(CURL_CODE_COVERAGE)

if(CMAKE_C_COMPILER_ID STREQUAL "GNU")

set(CURL_COVERAGE_MACROS "NDEBUG")

set(CURL_COVERAGE_CFLAGS "-O0" "-g" "-fprofile-arcs")

if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 4.1)

list(APPEND CURL_COVERAGE_CFLAGS "--coverage")

else()

list(APPEND CURL_COVERAGE_CFLAGS "-ftest-coverage")

endif()

set(CURL_COVERAGE_LIBS "gcov")

elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")

set(CURL_COVERAGE_MACROS "NDEBUG")

set(CURL_COVERAGE_CFLAGS "-O0" "-g" "-fprofile-instr-generate" "-fcoverage-mapping")

set(CURL_COVERAGE_LDFLAGS "-fprofile-instr-generate" "-fcoverage-mapping")

else()

set(CURL_CODE_COVERAGE OFF)

endif()

endif()

include(PickyWarnings)

set(CURL_CFLAGS "") # C flags set for libcurl and curl tool (aka public binaries) only

option(CURL_DROP_UNUSED "Drop unused code and data from built binaries" OFF)

if(CURL_DROP_UNUSED)

if(APPLE)

set_property(DIRECTORY APPEND PROPERTY LINK_OPTIONS "-Wl,-dead_strip")

elseif(MSVC) # Options below are toolchain defaults in Release configurations.

# This option does not seem to have an effect with VS2010:

set_property(DIRECTORY APPEND PROPERTY LINK_OPTIONS "-OPT:REF")

# Optional, but reduces binary size further, with the cost of larger objects/static libraries:

list(APPEND CURL_CFLAGS "-Gy")

elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang")

if(WIN32)

# To make -Wl,--gc-sections work on Windows: https://sourceware.org/bugzilla/show_bug.cgi?id=11539

set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS "-fno-asynchronous-unwind-tables")

endif()

set_property(DIRECTORY APPEND PROPERTY LINK_OPTIONS "-Wl,--gc-sections")

# Optional, but reduces binary size further, with the cost of larger objects/static libraries:

list(APPEND CURL_CFLAGS "-ffunction-sections" "-fdata-sections")

endif()

endif()

# For debug libs and exes, add "-d" postfix

if(NOT DEFINED CMAKE_DEBUG_POSTFIX)

set(CMAKE_DEBUG_POSTFIX "-d")

endif()

set(LIB_STATIC "libcurl_static")

set(LIB_SHARED "libcurl_shared")

if(NOT BUILD_SHARED_LIBS AND NOT BUILD_STATIC_LIBS)

set(BUILD_STATIC_LIBS ON)

endif()

if(NOT BUILD_STATIC_CURL AND NOT BUILD_SHARED_LIBS)

set(BUILD_STATIC_CURL ON)

elseif(BUILD_STATIC_CURL AND NOT BUILD_STATIC_LIBS)

set(BUILD_STATIC_CURL OFF)

endif()

# Lib flavour selected for curl tool

if(BUILD_STATIC_CURL)

set(LIB_SELECTED_FOR_EXE ${LIB_STATIC})

else()

set(LIB_SELECTED_FOR_EXE ${LIB_SHARED})

endif()

# Lib flavour selected for example and test programs.

if(BUILD_SHARED_LIBS)

set(LIB_SELECTED ${LIB_SHARED})

else()

set(LIB_SELECTED ${LIB_STATIC})

endif()

if(WIN32)

option(CURL_STATIC_CRT "Build libcurl with static CRT with MSVC (/MT)" OFF)

if(CURL_STATIC_CRT AND MSVC)

if(MSVC_VERSION GREATER_EQUAL 1900 OR BUILD_STATIC_CURL OR NOT BUILD_CURL_EXE)

set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")

set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS "$<$<CONFIG:Release>:-MT>")

set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS "$<$<CONFIG:Debug>:-MTd>")

else()

message(WARNING "Static CRT requires UCRT, static libcurl or no curl executable.")

endif()

endif()

endif()

# Override to force-disable or force-enable the use of CMake Configs.

if(MSVC AND NOT VCPKG_TOOLCHAIN AND NOT CMAKE_CROSSCOMPILING)

set(_curl_use_cmakeconfig_default ON)

else()

set(_curl_use_cmakeconfig_default OFF)

endif()

option(CURL_USE_CMAKECONFIG "Enable detecting dependencies via CMake Config" ${_curl_use_cmakeconfig_default})

# Override to force-disable or force-enable the use of pkg-config.

if((UNIX AND NOT ANDROID AND (NOT APPLE OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")) OR

VCPKG_TOOLCHAIN OR

(MINGW AND NOT CMAKE_CROSSCOMPILING))

set(_curl_use_pkgconfig_default ON)

else()

set(_curl_use_pkgconfig_default OFF)

endif()

option(CURL_USE_PKGCONFIG "Enable pkg-config to detect dependencies" ${_curl_use_pkgconfig_default})

# Initialize variables collecting system and dependency libs.

set(CURL_NETWORK_AND_TIME_LIBS "")

set(CURL_LIBS "")

if(ENABLE_ARES)

set(USE_ARES 1)

find_package(Cares MODULE REQUIRED)

list(APPEND CURL_LIBS CURL::cares)

endif()

include(CurlSymbolHiding)

option(CURL_ENABLE_EXPORT_TARGET "Enable CMake export target" ON)

mark_as_advanced(CURL_ENABLE_EXPORT_TARGET)

option(CURL_DISABLE_ALTSVC "Disable alt-svc support" OFF)

mark_as_advanced(CURL_DISABLE_ALTSVC)

option(CURL_DISABLE_SRP "Disable TLS-SRP support" OFF)

mark_as_advanced(CURL_DISABLE_SRP)

option(CURL_DISABLE_COOKIES "Disable cookies support" OFF)

mark_as_advanced(CURL_DISABLE_COOKIES)

option(CURL_DISABLE_BASIC_AUTH "Disable Basic authentication" OFF)

mark_as_advanced(CURL_DISABLE_BASIC_AUTH)

option(CURL_DISABLE_BEARER_AUTH "Disable Bearer authentication" OFF)

mark_as_advanced(CURL_DISABLE_BEARER_AUTH)

option(CURL_DISABLE_DIGEST_AUTH "Disable Digest authentication" OFF)

mark_as_advanced(CURL_DISABLE_DIGEST_AUTH)

option(CURL_DISABLE_KERBEROS_AUTH "Disable Kerberos authentication" OFF)

mark_as_advanced(CURL_DISABLE_KERBEROS_AUTH)

option(CURL_DISABLE_NEGOTIATE_AUTH "Disable negotiate authentication" OFF)

mark_as_advanced(CURL_DISABLE_NEGOTIATE_AUTH)

option(CURL_DISABLE_AWS "Disable aws-sigv4" OFF)

mark_as_advanced(CURL_DISABLE_AWS)

option(CURL_DISABLE_DICT "Disable DICT" OFF)

mark_as_advanced(CURL_DISABLE_DICT)

option(CURL_DISABLE_DOH "Disable DNS-over-HTTPS" OFF)

mark_as_advanced(CURL_DISABLE_DOH)

option(CURL_DISABLE_FILE "Disable FILE" OFF)

mark_as_advanced(CURL_DISABLE_FILE)

option(CURL_DISABLE_FTP "Disable FTP" OFF)

mark_as_advanced(CURL_DISABLE_FTP)

option(CURL_DISABLE_GETOPTIONS "Disable curl_easy_options API for existing options to curl_easy_setopt" OFF)

mark_as_advanced(CURL_DISABLE_GETOPTIONS)

option(CURL_DISABLE_GOPHER "Disable Gopher" OFF)

mark_as_advanced(CURL_DISABLE_GOPHER)

option(CURL_DISABLE_HEADERS_API "Disable headers-api support" OFF)

mark_as_advanced(CURL_DISABLE_HEADERS_API)

option(CURL_DISABLE_HSTS "Disable HSTS support" OFF)

mark_as_advanced(CURL_DISABLE_HSTS)

option(CURL_DISABLE_HTTP "Disable HTTP" OFF)

mark_as_advanced(CURL_DISABLE_HTTP)

option(CURL_DISABLE_HTTP_AUTH "Disable all HTTP authentication methods" OFF)

mark_as_advanced(CURL_DISABLE_HTTP_AUTH)

option(CURL_DISABLE_IMAP "Disable IMAP" OFF)

mark_as_advanced(CURL_DISABLE_IMAP)

option(CURL_DISABLE_LDAP "Disable LDAP" OFF)

mark_as_advanced(CURL_DISABLE_LDAP)

option(CURL_DISABLE_LDAPS "Disable LDAPS" ${CURL_DISABLE_LDAP})

mark_as_advanced(CURL_DISABLE_LDAPS)

option(CURL_DISABLE_LIBCURL_OPTION "Disable --libcurl option from the curl tool" OFF)

mark_as_advanced(CURL_DISABLE_LIBCURL_OPTION)

option(CURL_DISABLE_MIME "Disable MIME support" OFF)

mark_as_advanced(CURL_DISABLE_MIME)

cmake_dependent_option(CURL_DISABLE_FORM_API "Disable form-api"

OFF "NOT CURL_DISABLE_MIME"

ON)

mark_as_advanced(CURL_DISABLE_FORM_API)

option(CURL_DISABLE_MQTT "Disable MQTT" OFF)

mark_as_advanced(CURL_DISABLE_MQTT)

option(CURL_DISABLE_BINDLOCAL "Disable local binding support" OFF)

mark_as_advanced(CURL_DISABLE_BINDLOCAL)

option(CURL_DISABLE_NETRC "Disable netrc parser" OFF)

mark_as_advanced(CURL_DISABLE_NETRC)

option(CURL_ENABLE_NTLM "Enable NTLM support" OFF)

mark_as_advanced(CURL_ENABLE_NTLM)

option(CURL_DISABLE_PARSEDATE "Disable date parsing" OFF)

mark_as_advanced(CURL_DISABLE_PARSEDATE)

option(CURL_DISABLE_POP3 "Disable POP3" OFF)

mark_as_advanced(CURL_DISABLE_POP3)

option(CURL_DISABLE_PROGRESS_METER "Disable built-in progress meter" OFF)

mark_as_advanced(CURL_DISABLE_PROGRESS_METER)

option(CURL_DISABLE_PROXY "Disable proxy support" OFF)

mark_as_advanced(CURL_DISABLE_PROXY)

option(CURL_DISABLE_IPFS "Disable IPFS" OFF)

mark_as_advanced(CURL_DISABLE_IPFS)

option(CURL_DISABLE_RTSP "Disable RTSP" OFF)

mark_as_advanced(CURL_DISABLE_RTSP)

option(CURL_DISABLE_SHA512_256 "Disable SHA-512/256 hash algorithm" OFF)

mark_as_advanced(CURL_DISABLE_SHA512_256)

option(CURL_DISABLE_SHUFFLE_DNS "Disable shuffle DNS feature" OFF)

mark_as_advanced(CURL_DISABLE_SHUFFLE_DNS)

option(CURL_ENABLE_SMB "Enable SMB" OFF)

mark_as_advanced(CURL_ENABLE_SMB)

option(CURL_DISABLE_SMTP "Disable SMTP" OFF)

mark_as_advanced(CURL_DISABLE_SMTP)

option(CURL_DISABLE_SOCKETPAIR "Disable use of socketpair for curl_multi_poll()" OFF)

mark_as_advanced(CURL_DISABLE_SOCKETPAIR)

option(CURL_DISABLE_WEBSOCKETS "Disable WebSocket" OFF)

mark_as_advanced(CURL_DISABLE_WEBSOCKETS)

option(CURL_DISABLE_TELNET "Disable Telnet" OFF)

mark_as_advanced(CURL_DISABLE_TELNET)

option(CURL_DISABLE_TFTP "Disable TFTP" OFF)

mark_as_advanced(CURL_DISABLE_TFTP)

option(CURL_DISABLE_TYPECHECK "Disable curl_easy_setopt()/curl_easy_getinfo() type checking" OFF)

mark_as_advanced(CURL_DISABLE_TYPECHECK)

option(CURL_DISABLE_VERBOSE_STRINGS "Disable verbose strings" OFF)

mark_as_advanced(CURL_DISABLE_VERBOSE_STRINGS)

option(CURL_DEBUG_GLOBAL_MEM "Debug curl_global_init_mem" OFF)

mark_as_advanced(CURL_DEBUG_GLOBAL_MEM)

if(CURL_DEBUG_GLOBAL_MEM)

# Set it via the command-line to make it apply to the entire directory.

set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "CURL_DEBUG_GLOBAL_MEM")

endif()

if(CURL_DISABLE_TYPECHECK)

# Set it via the command-line to make it apply to examples also.

set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "CURL_DISABLE_TYPECHECK")

endif()

if(CURL_DISABLE_HTTP)

set(CURL_DISABLE_ALTSVC ON)

set(CURL_DISABLE_HSTS ON)

set(CURL_DISABLE_IPFS ON)

set(CURL_DISABLE_RTSP ON)

set(CURL_DISABLE_WEBSOCKETS ON)

endif()

# Corresponds to HTTP_ONLY in lib/curl_setup.h

option(HTTP_ONLY "Disable all protocols except HTTP (This overrides all CURL_DISABLE_* options)" OFF)

mark_as_advanced(HTTP_ONLY)

if(HTTP_ONLY)

set(CURL_DISABLE_DICT ON)

set(CURL_DISABLE_FILE ON)

set(CURL_DISABLE_FTP ON)

set(CURL_DISABLE_GOPHER ON)

set(CURL_DISABLE_IMAP ON)

set(CURL_DISABLE_IPFS ON)

set(CURL_DISABLE_LDAP ON)

set(CURL_DISABLE_LDAPS ON)

set(CURL_DISABLE_MQTT ON)

set(CURL_DISABLE_POP3 ON)

set(CURL_DISABLE_RTSP ON)

set(CURL_DISABLE_SMTP ON)

set(CURL_DISABLE_TELNET ON)

set(CURL_DISABLE_TFTP ON)

set(CURL_DISABLE_WEBSOCKETS ON)

endif()

if(WINDOWS_STORE)

set(CURL_DISABLE_TELNET ON) # telnet code needs fixing to compile for UWP.

endif()

option(CURL_LINT "Run lint checks while building" OFF)

find_package(Perl)

if(PERL_EXECUTABLE)

add_custom_target(curl-ca-bundle

COMMENT "Generating a fresh ca-bundle.crt" VERBATIM USES_TERMINAL

COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/mk-ca-bundle.pl" -b -l -u "lib/ca-bundle.crt"

DEPENDS "${PROJECT_SOURCE_DIR}/scripts/mk-ca-bundle.pl"

)

add_custom_target(curl-ca-firefox

COMMENT "Generating a fresh ca-bundle.crt" VERBATIM USES_TERMINAL

COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/firefox-db2pem.sh" "lib/ca-bundle.crt"

DEPENDS "${PROJECT_SOURCE_DIR}/scripts/firefox-db2pem.sh"

)

add_custom_target(curl-lint

COMMENT "Running lint checks" VERBATIM USES_TERMINAL

WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}

COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/badwords-all"

COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/checksrc-all.pl"

COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/spacecheck.pl"

DEPENDS

"${PROJECT_SOURCE_DIR}/scripts/badwords-all" "${PROJECT_SOURCE_DIR}/scripts/badwords"

"${PROJECT_SOURCE_DIR}/scripts/checksrc-all.pl" "${PROJECT_SOURCE_DIR}/scripts/checksrc.pl"

"${PROJECT_SOURCE_DIR}/scripts/spacecheck.pl"

)

if(CURL_LINT)

set_target_properties(curl-lint PROPERTIES EXCLUDE_FROM_ALL FALSE)

endif()

endif()

option(BUILD_LIBCURL_DOCS "Build libcurl man pages" ON)

option(BUILD_MISC_DOCS "Build misc man pages (e.g. curl-config and mk-ca-bundle)" ON)

option(ENABLE_CURL_MANUAL "Build the man page for curl and enable its -M/--manual option" ON)

if((ENABLE_CURL_MANUAL OR BUILD_LIBCURL_DOCS) AND NOT Perl_FOUND)

message(WARNING "Perl not found. Will not build manuals.")

endif()

# If we are on AIX, do the _ALL_SOURCE magic

if(AIX OR CMAKE_SYSTEM_NAME STREQUAL "AIX")

set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "_ALL_SOURCE")

endif()

# If we are on Haiku, make sure that the network library is brought in.

if(CMAKE_SYSTEM_NAME STREQUAL "Haiku")

list(APPEND CURL_NETWORK_AND_TIME_LIBS "network")

elseif(AMIGA)

list(APPEND CURL_NETWORK_AND_TIME_LIBS "net" "m" "atomic")

list(APPEND CMAKE_REQUIRED_LIBRARIES "net" "m" "atomic")

endif()

# Include all the necessary files for macros

include(CMakePushCheckState)

include(CheckFunctionExists)

include(CheckIncludeFile)

include(CheckIncludeFiles)

include(CheckLibraryExists)

include(CheckSymbolExists)

include(CheckTypeSize)

include(CheckCSourceCompiles)

option(_CURL_PREFILL "Fast-track known feature detection results (Windows, some Apple)" "${WIN32}")

mark_as_advanced(_CURL_PREFILL)

if(_CURL_PREFILL)

if(WIN32)

include("${CMAKE_CURRENT_SOURCE_DIR}/CMake/win32-cache.cmake")

elseif(UNIX)

include("${CMAKE_CURRENT_SOURCE_DIR}/CMake/unix-cache.cmake")

message(STATUS "Pre-filling feature detection results for UNIX")

endif()

elseif(WIN32)

message(STATUS "Pre-filling feature detection results disabled.")

elseif(APPLE)

set(HAVE_EVENTFD 0)

set(HAVE_GETPASS_R 0)

set(HAVE_WRITABLE_ARGV 1)

set(HAVE_SENDMMSG 0)

endif()

if(AMIGA)

set(HAVE_GETADDRINFO 0) # Breaks the build when detected and used.

endif()

if(DOS OR AMIGA)

set(HAVE_TIME_T_UNSIGNED 1)

endif()

if(NOT WIN32)

find_package(Threads)

if(CMAKE_USE_PTHREADS_INIT)

set(HAVE_THREADS_POSIX 1)

list(APPEND CURL_NETWORK_AND_TIME_LIBS Threads::Threads)

endif()

endif()

if(ENABLE_THREADED_RESOLVER)

if(NOT WIN32 AND NOT HAVE_THREADS_POSIX)

message(FATAL_ERROR "Threaded resolver requires POSIX Threads.")

endif()

set(USE_RESOLV_THREADED ON)

elseif(USE_ARES)

set(USE_RESOLV_ARES ON)

endif()

# Check for all needed libraries

if(DOS)

if(WATT_ROOT)

set(USE_WATT32 ON)

# FIXME upstream: must specify the full path to avoid CMake converting "watt" to "watt.lib"

list(APPEND CURL_NETWORK_AND_TIME_LIBS "${WATT_ROOT}/lib/libwatt.a")

include_directories(SYSTEM "${WATT_ROOT}/inc")

list(APPEND CMAKE_REQUIRED_INCLUDES "${WATT_ROOT}/inc")

else()

message(FATAL_ERROR "Set WATT_ROOT variable to the absolute path to the root installation of Watt-32.")

endif()

elseif(AMIGA)

if(AMISSL_INCLUDE_DIR AND AMISSL_STUBS_LIBRARY AND AMISSL_AUTO_LIBRARY)

set(USE_AMISSL ON)

list(APPEND CMAKE_REQUIRED_INCLUDES "${AMISSL_INCLUDE_DIR}")

list(APPEND CMAKE_REQUIRED_LIBRARIES "${AMISSL_STUBS_LIBRARY}" "${AMISSL_AUTO_LIBRARY}")

set(OPENSSL_INCLUDE_DIR "${AMISSL_INCLUDE_DIR}")

set(OPENSSL_SSL_LIBRARY "${AMISSL_STUBS_LIBRARY}")

set(OPENSSL_CRYPTO_LIBRARY "${AMISSL_AUTO_LIBRARY}")

set(CURL_USE_OPENSSL ON)

set(CURL_CA_FALLBACK ON CACHE BOOL "")

endif()

elseif(NOT WIN32 AND NOT APPLE)

check_library_exists("socket" "connect" "" HAVE_LIBSOCKET)

if(HAVE_LIBSOCKET)

list(PREPEND CURL_NETWORK_AND_TIME_LIBS "socket")

endif()

endif()

option(ENABLE_IPV6 "Enable IPv6 support" ON)

mark_as_advanced(ENABLE_IPV6)

if(ENABLE_IPV6)

include(CheckStructHasMember)

if(WIN32)

check_struct_has_member("struct sockaddr_in6" "sin6_scope_id" "winsock2.h;ws2tcpip.h" HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)

else()

check_struct_has_member("struct sockaddr_in6" "sin6_scope_id" "netinet/in.h" HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)

check_struct_has_member("struct sockaddr_in6" "sin6_addr" "netinet/in.h" HAVE_SOCKADDR_IN6_SIN6_ADDR)

if(NOT HAVE_SOCKADDR_IN6_SIN6_ADDR)

if(NOT DOS AND NOT AMIGA)

message(WARNING "struct sockaddr_in6 not available, disabling IPv6 support")

endif()

set(ENABLE_IPV6 OFF CACHE BOOL "Enable IPv6 support" FORCE) # Force the feature off as we use this name as guard macro

endif()

if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT ENABLE_ARES)

set(_use_core_foundation_and_core_services ON)

find_library(SYSTEMCONFIGURATION_FRAMEWORK NAMES "SystemConfiguration")

mark_as_advanced(SYSTEMCONFIGURATION_FRAMEWORK)

if(NOT SYSTEMCONFIGURATION_FRAMEWORK)

message(FATAL_ERROR "SystemConfiguration framework not found")

endif()

list(APPEND CURL_LIBS "-framework SystemConfiguration")

endif()

endif()

endif()

if(ENABLE_IPV6)

set(USE_IPV6 ON)

endif()

# Check SSL libraries

option(CURL_ENABLE_SSL "Enable SSL support" ON)

if(CURL_DEFAULT_SSL_BACKEND)

set(_valid_default_ssl_backend FALSE)

endif()

if(WIN32)

cmake_dependent_option(CURL_USE_SCHANNEL "Enable Windows native SSL/TLS (Schannel)" OFF CURL_ENABLE_SSL OFF)

option(CURL_WINDOWS_SSPI "Enable SSPI on Windows" ${CURL_USE_SCHANNEL})

else()

set(CURL_USE_SCHANNEL OFF)

set(CURL_WINDOWS_SSPI OFF)

endif()

cmake_dependent_option(CURL_USE_MBEDTLS "Enable mbedTLS for SSL/TLS" OFF CURL_ENABLE_SSL OFF)

cmake_dependent_option(CURL_USE_WOLFSSL "Enable wolfSSL for SSL/TLS" OFF CURL_ENABLE_SSL OFF)

cmake_dependent_option(CURL_USE_GNUTLS "Enable GnuTLS for SSL/TLS" OFF CURL_ENABLE_SSL OFF)

cmake_dependent_option(CURL_USE_RUSTLS "Enable Rustls for SSL/TLS" OFF CURL_ENABLE_SSL OFF)

if(WIN32 OR

CURL_USE_SCHANNEL OR

CURL_USE_MBEDTLS OR

CURL_USE_WOLFSSL OR

CURL_USE_GNUTLS OR

CURL_USE_RUSTLS)

set(_openssl_default OFF)

else()

set(_openssl_default ON)

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)

curl_count_true(_enabled_ssl_options_count

CURL_USE_SCHANNEL

CURL_USE_OPENSSL

CURL_USE_MBEDTLS

CURL_USE_WOLFSSL

CURL_USE_GNUTLS

CURL_USE_RUSTLS

)

if(_enabled_ssl_options_count GREATER 1)

set(CURL_WITH_MULTI_SSL ON)

elseif(_enabled_ssl_options_count EQUAL 0)

set(CURL_DISABLE_HSTS ON)

endif()

if(CURL_USE_SCHANNEL)

if(WINDOWS_STORE)

message(FATAL_ERROR "UWP does not support Schannel.")

endif()

set(_ssl_enabled ON)

set(USE_SCHANNEL ON) # Windows native SSL/TLS support

set(USE_WINDOWS_SSPI ON) # CURL_USE_SCHANNEL requires CURL_WINDOWS_SSPI

if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "schannel")

set(_valid_default_ssl_backend TRUE)

endif()

endif()

if(CURL_WINDOWS_SSPI AND NOT WINDOWS_STORE)

set(USE_WINDOWS_SSPI ON)

endif()

if(APPLE)

option(USE_APPLE_SECTRUST "Use Apple OS-native certificate verification" OFF)

if(USE_APPLE_SECTRUST)

if(NOT CURL_USE_OPENSSL AND NOT CURL_USE_GNUTLS)

message(FATAL_ERROR "Apple SecTrust is only supported with Openssl/GnuTLS")

endif()

find_library(SECURITY_FRAMEWORK NAMES "Security")

mark_as_advanced(SECURITY_FRAMEWORK)

if(NOT SECURITY_FRAMEWORK)

message(FATAL_ERROR "Security framework not found")

endif()

list(APPEND CURL_LIBS "-framework Security")

set(_use_core_foundation_and_core_services ON)

message(STATUS "Apple OS-native certificate verification enabled")

endif()

else()

set(USE_APPLE_SECTRUST OFF)

endif()

if(_use_core_foundation_and_core_services)

find_library(COREFOUNDATION_FRAMEWORK NAMES "CoreFoundation")

mark_as_advanced(COREFOUNDATION_FRAMEWORK)

if(NOT COREFOUNDATION_FRAMEWORK)

message(FATAL_ERROR "CoreFoundation framework not found")

endif()

list(APPEND CURL_LIBS "-framework CoreFoundation")

find_library(CORESERVICES_FRAMEWORK NAMES "CoreServices")

mark_as_advanced(CORESERVICES_FRAMEWORK)

if(NOT CORESERVICES_FRAMEWORK)

message(FATAL_ERROR "CoreServices framework not found")

endif()

list(APPEND CURL_LIBS "-framework CoreServices")

endif()

if(CURL_USE_OPENSSL)

find_package(OpenSSL REQUIRED)

set(_ssl_enabled ON)

set(USE_OPENSSL ON)

# Depend on OpenSSL via imported targets. This allows our dependents to

# get our dependencies transitively.

list(APPEND CURL_LIBS OpenSSL::SSL OpenSSL::Crypto)

if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "openssl")

set(_valid_default_ssl_backend TRUE)

endif()

set(_curl_ca_bundle_supported TRUE)

cmake_push_check_state()

list(APPEND CMAKE_REQUIRED_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)

if(NOT DEFINED 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)

endif()

if(NOT DEFINED HAVE_LIBRESSL)

check_symbol_exists("LIBRESSL_VERSION_NUMBER" "openssl/opensslv.h" HAVE_LIBRESSL)

endif()

cmake_pop_check_state()

if(HAVE_BORINGSSL OR HAVE_AWSLC)

if(NOT MSVC AND NOT ANDROID) # BoringSSL/AWS-LC MSVC builds use native Windows threads

find_package(Threads)

if(CMAKE_USE_PTHREADS_INIT)

set(HAVE_THREADS_POSIX_BORINGSSL 1)

list(APPEND CURL_NETWORK_AND_TIME_LIBS Threads::Threads)

list(APPEND CMAKE_REQUIRED_LIBRARIES Threads::Threads)

elseif(OPENSSL_USE_STATIC_LIBS)

message(WARNING "BoringSSL/AWS-LC requires POSIX Threads.")

endif()

endif()

if(OPENSSL_USE_STATIC_LIBS AND CMAKE_C_COMPILER_ID MATCHES "Clang")

list(APPEND CURL_LIBS "stdc++")

list(APPEND CMAKE_REQUIRED_LIBRARIES "stdc++")

endif()

endif()

if(HAVE_BORINGSSL)

if(BORINGSSL_VERSION)

set(CURL_BORINGSSL_VERSION "\"${BORINGSSL_VERSION}\"")

endif()

set(_openssl "BoringSSL")

elseif(HAVE_AWSLC)

set(_openssl "AWS-LC")

elseif(HAVE_LIBRESSL)

set(_openssl "LibreSSL")

elseif(USE_AMISSL)

set(_openssl "AmiSSL")

else()

set(_openssl "OpenSSL")

endif()

endif()

if(CURL_USE_MBEDTLS)

find_package(MbedTLS MODULE REQUIRED)

if(MBEDTLS_VERSION VERSION_LESS 3.2.0)

message(FATAL_ERROR "mbedTLS v3.2.0 or newer is required.")

endif()

set(_ssl_enabled ON)

set(USE_MBEDTLS ON)

list(APPEND CURL_LIBS CURL::mbedtls)

if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "mbedtls")

set(_valid_default_ssl_backend TRUE)

endif()

set(_curl_ca_bundle_supported TRUE)

if(MBEDTLS_VERSION VERSION_GREATER_EQUAL 4.0.0)

set(HAVE_MBEDTLS_DES_CRYPT_ECB 0) # pre-fill detection result

endif()

if(NOT DEFINED HAVE_MBEDTLS_DES_CRYPT_ECB)

cmake_push_check_state()

list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::mbedtls)

check_function_exists("mbedtls_des_crypt_ecb" HAVE_MBEDTLS_DES_CRYPT_ECB) # in mbedTLS <4

cmake_pop_check_state()

endif()

endif()

if(CURL_USE_WOLFSSL)

find_package(WolfSSL MODULE REQUIRED)

set(_ssl_enabled ON)

set(USE_WOLFSSL ON)

list(APPEND CURL_LIBS CURL::wolfssl)

if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "wolfssl")

set(_valid_default_ssl_backend TRUE)

endif()

set(_curl_ca_bundle_supported TRUE)

if(USE_OPENSSL AND WOLFSSL_VERSION VERSION_LESS 5.7.6)

message(FATAL_ERROR "wolfSSL 5.7.6 or newer is required to coexist with OpenSSL.")

endif()

set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "WOLFSSL_OPTIONS_IGNORE_SYS")

endif()

if(CURL_USE_GNUTLS)

find_package(GnuTLS MODULE REQUIRED)

list(APPEND CURL_LIBS CURL::gnutls)

find_package(Nettle MODULE REQUIRED)

list(APPEND CURL_LIBS CURL::nettle)

set(_ssl_enabled ON)

set(USE_GNUTLS ON)

if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "gnutls")

set(_valid_default_ssl_backend TRUE)

endif()

set(_curl_ca_bundle_supported TRUE)

if(NOT DEFINED HAVE_GNUTLS_SRP AND NOT CURL_DISABLE_SRP)

cmake_push_check_state()

list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::gnutls)

# In GnuTLS 3.8.0 (2023-02-10) and upper, this check always succeeds.

# Detecting actual TLS-SRP support needs poking the API at runtime.

check_symbol_exists("gnutls_srp_verifier" "gnutls/gnutls.h" HAVE_GNUTLS_SRP)

cmake_pop_check_state()

endif()

endif()

if(CURL_USE_RUSTLS)

find_package(Rustls MODULE REQUIRED)

set(_ssl_enabled ON)

set(USE_RUSTLS ON)

list(APPEND CURL_LIBS CURL::rustls)

if(NOT DEFINED HAVE_RUSTLS_SUPPORTED_HPKE)

if(RUSTLS_VERSION AND RUSTLS_VERSION VERSION_GREATER_EQUAL 0.15)

set(HAVE_RUSTLS_SUPPORTED_HPKE TRUE)

elseif(NOT RUSTLS_VERSION)

cmake_push_check_state()

list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::rustls)

check_symbol_exists("rustls_supported_hpke" "rustls.h" HAVE_RUSTLS_SUPPORTED_HPKE)

cmake_pop_check_state()

endif()

endif()

if(NOT HAVE_RUSTLS_SUPPORTED_HPKE)

message(FATAL_ERROR "rustls-ffi library does not provide rustls_supported_hpke function. Required version is 0.15 or newer.")

endif()

if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "rustls")

set(_valid_default_ssl_backend TRUE)

endif()

set(_curl_ca_bundle_supported TRUE)

endif()

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()

# Keep ZLIB detection after TLS detection,

# and before calling curl_openssl_check_exists().

set(HAVE_LIBZ OFF)

curl_dependency_option(CURL_ZLIB ZLIB "ZLIB")

if(ZLIB_FOUND)

set(HAVE_LIBZ ON)

# Depend on ZLIB via imported targets. This allows our dependents to

# get our dependencies transitively.

list(APPEND CURL_LIBS ZLIB::ZLIB)

endif()

set(HAVE_BROTLI OFF)

curl_dependency_option(CURL_BROTLI Brotli "brotli")

if(BROTLI_FOUND)

set(HAVE_BROTLI ON)

list(APPEND CURL_LIBS CURL::brotli)

endif()

set(HAVE_ZSTD OFF)

curl_dependency_option(CURL_ZSTD Zstd "zstd")

if(ZSTD_FOUND)

if(ZSTD_VERSION VERSION_GREATER_EQUAL 1.0.0)