luna - curl/CMakeLists.txt

   1#***************************************************************************
   2#                                  _   _ ____  _
   3#  Project                     ___| | | |  _ \| |
   4#                             / __| | | | |_) | |
   5#                            | (__| |_| |  _ <| |___
   6#                             \___|\___/|_| \_\_____|
   7#
   8# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9#
  10# This software is licensed as described in the file COPYING, which
  11# you should have received as part of this distribution. The terms
  12# are also available at https://curl.se/docs/copyright.html.
  13#
  14# You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15# copies of the Software, and permit persons to whom the Software is
  16# furnished to do so, under the terms of the COPYING file.
  17#
  18# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19# KIND, either express or implied.
  20#
  21# SPDX-License-Identifier: curl
  22#
  23###########################################################################
  24
  25cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
  26message(STATUS "Using CMake version ${CMAKE_VERSION}")
  27
  28# Collect command-line arguments for buildinfo.txt.
  29# Must reside at the top of the script to work as expected.
  30set(_cmake_args "")
  31if(NOT "$ENV{CURL_BUILDINFO}$ENV{CURL_CI}$ENV{CI}" STREQUAL "")
  32  get_cmake_property(_cache_vars CACHE_VARIABLES)
  33  foreach(_cache_var IN ITEMS ${_cache_vars})
  34    get_property(_cache_var_helpstring CACHE ${_cache_var} PROPERTY HELPSTRING)
  35    if(_cache_var_helpstring STREQUAL "No help, variable specified on the command line.")
  36      get_property(_cache_var_type CACHE ${_cache_var} PROPERTY TYPE)
  37      get_property(_cache_var_value CACHE ${_cache_var} PROPERTY VALUE)
  38      if(_cache_var_type STREQUAL "UNINITIALIZED")
  39        set(_cache_var_type "")
  40      else()
  41        set(_cache_var_type ":${_cache_var_type}")
  42      endif()
  43      string(APPEND _cmake_args " -D${_cache_var}${_cache_var_type}=\"${_cache_var_value}\"")
  44    endif()
  45  endforeach()
  46endif()
  47
  48list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake")
  49include(Utilities)
  50include(Macros)
  51include(CMakeDependentOption)
  52include(CheckCCompilerFlag)
  53
  54file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/curl/curlver.h" _curl_version_h_contents REGEX "#define LIBCURL_VERSION( |_NUM )")
  55string(REGEX MATCH "#define LIBCURL_VERSION \"[^\"]*" _curl_version ${_curl_version_h_contents})
  56string(REGEX REPLACE "[^\"]+\"" "" _curl_version ${_curl_version})
  57string(REGEX MATCH "#define LIBCURL_VERSION_NUM 0x[0-9a-fA-F]+" _curl_version_num ${_curl_version_h_contents})
  58string(REGEX REPLACE "[^0]+0x" "" _curl_version_num ${_curl_version_num})
  59unset(_curl_version_h_contents)
  60
  61message(STATUS "curl version=[${_curl_version}]")
  62
  63string(REGEX REPLACE "([0-9]+\.[0-9]+\.[0-9]+).+" "\\1" _curl_version_sem "${_curl_version}")
  64project(CURL
  65  VERSION "${_curl_version_sem}"
  66  LANGUAGES C)
  67
  68# CMake does not recognize some targets accurately. Touch up configuration manually as a workaround.
  69if(WINDOWS_STORE AND MINGW)  # MinGW UWP build
  70  # CMake (as of v3.31.2) gets confused and applies the MSVC rc.exe command-line
  71  # template to windres. Reset it to the windres template as in 'Modules/Platform/Windows-windres.cmake':
  72  set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -O coff <DEFINES> <INCLUDES> <FLAGS> <SOURCE> <OBJECT>")
  73elseif(DOS AND CMAKE_C_COMPILER_ID STREQUAL "GNU")  # DJGPP
  74  set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
  75  set(CMAKE_STATIC_LIBRARY_SUFFIX ".a")
  76  set(CMAKE_FIND_LIBRARY_PREFIXES "lib")
  77  set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
  78endif()
  79
  80# Fill platform level variable when using CMake's built-in Android configuration
  81if(ANDROID AND NOT DEFINED ANDROID_PLATFORM_LEVEL AND NOT CMAKE_SYSTEM_VERSION EQUAL 1)
  82  set(ANDROID_PLATFORM_LEVEL "${CMAKE_SYSTEM_VERSION}")
  83endif()
  84
  85set(_target_flags "")
  86if(APPLE)
  87  string(APPEND _target_flags " APPLE")
  88endif()
  89if(UNIX)
  90  string(APPEND _target_flags " UNIX")
  91endif()
  92if(BSD)
  93  string(APPEND _target_flags " BSD")
  94endif()
  95if(ANDROID)
  96  string(APPEND _target_flags " ANDROID-${ANDROID_PLATFORM_LEVEL}")
  97endif()
  98if(WIN32)
  99  string(APPEND _target_flags " WIN32")
 100endif()
 101if(WINDOWS_STORE)
 102  string(APPEND _target_flags " UWP")
 103endif()
 104if(CYGWIN)
 105  string(APPEND _target_flags " CYGWIN")
 106endif()
 107if(DOS)
 108  string(APPEND _target_flags " DOS")
 109endif()
 110if(AMIGA)
 111  string(APPEND _target_flags " AMIGA")
 112endif()
 113if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
 114  string(APPEND _target_flags " GCC")
 115endif()
 116if(CMAKE_C_COMPILER_ID STREQUAL "AppleClang")
 117  string(APPEND _target_flags " APPLE-CLANG")
 118elseif(CMAKE_C_COMPILER_ID STREQUAL "Clang" AND MSVC)
 119  string(APPEND _target_flags " CLANG-CL")
 120elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")
 121  string(APPEND _target_flags " LLVM-CLANG")
 122endif()
 123if(MINGW)
 124  string(APPEND _target_flags " MINGW")
 125endif()
 126if(MSVC)
 127  string(APPEND _target_flags " MSVC-${MSVC_VERSION}")
 128endif()
 129if(VCPKG_TOOLCHAIN)
 130  string(APPEND _target_flags " VCPKG")
 131endif()
 132if(CMAKE_CROSSCOMPILING)
 133  string(APPEND _target_flags " CROSS")
 134endif()
 135if(CMAKE_C_STANDARD)
 136  string(APPEND _target_flags " C${CMAKE_C_STANDARD}")
 137endif()
 138message(STATUS "CMake platform flags:${_target_flags}")
 139
 140if(CMAKE_CROSSCOMPILING)
 141  message(STATUS "Cross-compiling: "
 142    "${CMAKE_HOST_SYSTEM_NAME}/${CMAKE_HOST_SYSTEM_PROCESSOR} -> "
 143    "${CMAKE_SYSTEM_NAME}/${CMAKE_SYSTEM_PROCESSOR}")
 144endif()
 145
 146if(CMAKE_C_COMPILER_TARGET)
 147  set(CURL_OS "\"${CMAKE_C_COMPILER_TARGET}\"")
 148else()
 149  set(CURL_OS "\"${CMAKE_SYSTEM_NAME}\"")
 150endif()
 151
 152if(CURL_PATCHSTAMP)
 153  set(CURL_PATCHSTAMP "\"${CURL_PATCHSTAMP}\"")
 154endif()
 155
 156set(LIB_NAME "libcurl")
 157set(EXE_NAME "curl")
 158
 159set_property(DIRECTORY APPEND PROPERTY INCLUDE_DIRECTORIES "${PROJECT_SOURCE_DIR}/include")
 160
 161if(NOT DEFINED CMAKE_UNITY_BUILD_BATCH_SIZE)
 162  set(CMAKE_UNITY_BUILD_BATCH_SIZE 0)
 163endif()
 164
 165# Having CMAKE_TRY_COMPILE_TARGET_TYPE set to STATIC_LIBRARY breaks certain
 166# 'check_function_exists()' detections (possibly more), by detecting
 167# non-existing features. This happens by default when using 'ios.toolchain.cmake'.
 168# Work it around by setting this value to `EXECUTABLE`.
 169if(CMAKE_TRY_COMPILE_TARGET_TYPE STREQUAL "STATIC_LIBRARY")
 170  message(STATUS "CMAKE_TRY_COMPILE_TARGET_TYPE was found set to STATIC_LIBRARY. "
 171    "Overriding with EXECUTABLE for feature detections to work.")
 172  set(_cmake_try_compile_target_type_save ${CMAKE_TRY_COMPILE_TARGET_TYPE})
 173  set(CMAKE_TRY_COMPILE_TARGET_TYPE "EXECUTABLE")
 174endif()
 175
 176option(CURL_WERROR "Turn compiler warnings into errors" OFF)
 177option(PICKY_COMPILER "Enable picky compiler options" ON)
 178option(BUILD_CURL_EXE "Build curl executable" ON)
 179get_property(_has_shared GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
 180option(BUILD_SHARED_LIBS "Build shared libraries" ${_has_shared})
 181option(BUILD_STATIC_LIBS "Build static libraries" OFF)
 182option(BUILD_STATIC_CURL "Build curl executable with static libcurl" OFF)
 183option(ENABLE_ARES "Enable c-ares support" OFF)
 184option(CURL_DISABLE_INSTALL "Disable installation targets" OFF)
 185option(CURL_BUILD_EVERYTHING "Build optional build targets (examples, tests) by default" OFF)
 186
 187if(WIN32)
 188  option(ENABLE_UNICODE "Use the Unicode version of the Windows API functions" OFF)
 189  if(WINDOWS_STORE)
 190    set(ENABLE_UNICODE ON)
 191  endif()
 192  if(ENABLE_UNICODE)
 193    set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "UNICODE" "_UNICODE")
 194    if(MINGW)
 195      set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS "-municode")
 196    endif()
 197  endif()
 198
 199  # Apply to all feature checks
 200  list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DWIN32_LEAN_AND_MEAN")
 201
 202  set(CURL_TARGET_WINDOWS_VERSION "" CACHE STRING "Minimum target Windows version as hex string")
 203  if(CURL_TARGET_WINDOWS_VERSION)
 204    if(CURL_TARGET_WINDOWS_VERSION MATCHES "^0x[0-9a-fA-F]+$")
 205      set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION}")
 206      list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION}")  # Apply to all feature checks
 207    else()
 208      message(WARNING "CURL_TARGET_WINDOWS_VERSION value '${CURL_TARGET_WINDOWS_VERSION}' is not a valid hex string.")
 209    endif()
 210  endif()
 211
 212  # Detect actual value of _WIN32_WINNT and store as HAVE_WIN32_WINNT
 213  curl_internal_test(HAVE_WIN32_WINNT)
 214  if(HAVE_WIN32_WINNT)
 215    string(REGEX MATCH "_WIN32_WINNT=0x[0-9a-fA-F]+" CURL_TEST_OUTPUT "${CURL_TEST_OUTPUT}")
 216    string(REGEX REPLACE "_WIN32_WINNT=" "" CURL_TEST_OUTPUT "${CURL_TEST_OUTPUT}")
 217    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
 218    string(TOLOWER "${CURL_TEST_OUTPUT}" HAVE_WIN32_WINNT)
 219    message(STATUS "Found _WIN32_WINNT=${HAVE_WIN32_WINNT}")
 220  endif()
 221  unset(HAVE_WIN32_WINNT CACHE)  # Avoid storing in CMake cache
 222
 223  if(MINGW)
 224    # Detect __MINGW64_VERSION_MAJOR, __MINGW64_VERSION_MINOR and store as MINGW64_VERSION
 225    curl_internal_test(MINGW64_VERSION)
 226    if(MINGW64_VERSION)
 227      string(REGEX MATCH "MINGW64_VERSION=[0-9]+\.[0-9]+" CURL_TEST_OUTPUT "${CURL_TEST_OUTPUT}")
 228      string(REGEX REPLACE "MINGW64_VERSION=" "" MINGW64_VERSION "${CURL_TEST_OUTPUT}")
 229      if(MINGW64_VERSION)
 230        message(STATUS "Found MINGW64_VERSION=${MINGW64_VERSION}")
 231        if(MINGW64_VERSION VERSION_LESS 3.0)
 232          message(FATAL_ERROR "mingw-w64 3.0 or upper is required")
 233        endif()
 234      endif()
 235    endif()
 236    unset(MINGW64_VERSION CACHE)  # Avoid storing in CMake cache
 237  endif()
 238elseif(DOS)
 239  set(BUILD_SHARED_LIBS OFF)
 240  set(BUILD_STATIC_LIBS ON)
 241endif()
 242option(CURL_LTO "Enable compiler Link Time Optimizations" OFF)
 243
 244if(NOT DOS AND NOT AMIGA)
 245  # if c-ares is used, default the threaded resolver to OFF
 246  if(ENABLE_ARES)
 247    set(_enable_threaded_resolver_default OFF)
 248  else()
 249    set(_enable_threaded_resolver_default ON)
 250  endif()
 251  option(ENABLE_THREADED_RESOLVER "Enable threaded DNS lookup" ${_enable_threaded_resolver_default})
 252endif()
 253
 254if(CYGWIN OR CMAKE_SYSTEM_NAME STREQUAL "Linux" OR CMAKE_SYSTEM_NAME STREQUAL "GNU")
 255  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "_GNU_SOURCE")  # Required for accept4(), pipe2(), sendmmsg()
 256  list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_GNU_SOURCE")  # Apply to all feature checks
 257endif()
 258
 259option(ENABLE_DEBUG "Enable curl debug features (for developing curl itself)" OFF)
 260if(ENABLE_DEBUG)
 261  message(WARNING "This curl build is Debug-enabled and insecure, do not use in production.")
 262endif()
 263
 264set(CURL_DEBUG_MACROS "")
 265if(ENABLE_DEBUG)
 266  list(APPEND CURL_DEBUG_MACROS "DEBUGBUILD")
 267endif()
 268
 269option(CURL_CLANG_TIDY "Run the build through clang-tidy" OFF)
 270if(CURL_CLANG_TIDY)
 271  find_program(CLANG_TIDY NAMES "clang-tidy" REQUIRED)
 272  if(NOT CMAKE_C_COMPILER_ID MATCHES "Clang")
 273    set(PICKY_COMPILER OFF)  # Do a best effort and skip passing non-clang warning options to clang-tidy.
 274    # This lets through warning options enabled via CURL_WERROR=ON, affecting lib and src.
 275  endif()
 276  set(CURL_DISABLE_TYPECHECK ON)  # to improve performance (1.4x), avoid potential interference and bugprone-macro-parentheses.
 277  set(CMAKE_C_CLANG_TIDY "${CLANG_TIDY}")
 278  list(APPEND CMAKE_C_CLANG_TIDY "--config-file=${PROJECT_SOURCE_DIR}/.clang-tidy.yml")
 279  if(CURL_WERROR)
 280    list(APPEND CMAKE_C_CLANG_TIDY "--warnings-as-errors=*")
 281  endif()
 282  if(CURL_CLANG_TIDYFLAGS)
 283    string(REPLACE " " ";" _tidy_flags_list "${CURL_CLANG_TIDYFLAGS}")
 284    list(APPEND CMAKE_C_CLANG_TIDY ${_tidy_flags_list})
 285  endif()
 286endif()
 287
 288option(CURL_GCC_ANALYZER "Enable GCC --analyzer option" OFF)
 289if(CURL_GCC_ANALYZER AND CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0)
 290  set(CURL_DISABLE_TYPECHECK ON)  # to improve performance (1.1x).
 291  # https://gcc.gnu.org/onlinedocs/gcc/Static-Analyzer-Options.html
 292  set(CURL_ANALYZER_CFLAGS "-fanalyzer")
 293  # disable checks causing false positives only
 294  list(APPEND CURL_ANALYZER_CFLAGS "-Wno-analyzer-fd-leak" "-Wno-analyzer-fd-use-without-check" "-Wno-analyzer-file-leak")
 295  list(APPEND CURL_ANALYZER_CFLAGS "-Wno-analyzer-infinite-loop")
 296  list(APPEND CURL_ANALYZER_CFLAGS "-Wno-analyzer-malloc-leak")
 297  list(APPEND CURL_ANALYZER_CFLAGS "-Wno-analyzer-out-of-bounds")
 298endif()
 299
 300option(CURL_CODE_COVERAGE "Enable code coverage build options" OFF)
 301if(CURL_CODE_COVERAGE)
 302  if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
 303    set(CURL_COVERAGE_MACROS "NDEBUG")
 304    set(CURL_COVERAGE_CFLAGS "-O0" "-g" "-fprofile-arcs")
 305    if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 4.1)
 306      list(APPEND CURL_COVERAGE_CFLAGS "--coverage")
 307    else()
 308      list(APPEND CURL_COVERAGE_CFLAGS "-ftest-coverage")
 309    endif()
 310    set(CURL_COVERAGE_LIBS "gcov")
 311  elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")
 312    set(CURL_COVERAGE_MACROS "NDEBUG")
 313    set(CURL_COVERAGE_CFLAGS "-O0" "-g" "-fprofile-instr-generate" "-fcoverage-mapping")
 314    set(CURL_COVERAGE_LDFLAGS "-fprofile-instr-generate" "-fcoverage-mapping")
 315  else()
 316    set(CURL_CODE_COVERAGE OFF)
 317  endif()
 318endif()
 319
 320include(PickyWarnings)
 321
 322set(CURL_CFLAGS "")  # C flags set for libcurl and curl tool (aka public binaries) only
 323
 324option(CURL_DROP_UNUSED "Drop unused code and data from built binaries" OFF)
 325if(CURL_DROP_UNUSED)
 326  if(APPLE)
 327    set_property(DIRECTORY APPEND PROPERTY LINK_OPTIONS "-Wl,-dead_strip")
 328  elseif(MSVC)  # Options below are toolchain defaults in Release configurations.
 329    # This option does not seem to have an effect with VS2010:
 330    set_property(DIRECTORY APPEND PROPERTY LINK_OPTIONS "-OPT:REF")
 331    # Optional, but reduces binary size further, with the cost of larger objects/static libraries:
 332    list(APPEND CURL_CFLAGS "-Gy")
 333  elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang")
 334    if(WIN32)
 335      # To make -Wl,--gc-sections work on Windows: https://sourceware.org/bugzilla/show_bug.cgi?id=11539
 336      set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS "-fno-asynchronous-unwind-tables")
 337    endif()
 338    set_property(DIRECTORY APPEND PROPERTY LINK_OPTIONS "-Wl,--gc-sections")
 339    # Optional, but reduces binary size further, with the cost of larger objects/static libraries:
 340    list(APPEND CURL_CFLAGS "-ffunction-sections" "-fdata-sections")
 341  endif()
 342endif()
 343
 344# For debug libs and exes, add "-d" postfix
 345if(NOT DEFINED CMAKE_DEBUG_POSTFIX)
 346  set(CMAKE_DEBUG_POSTFIX "-d")
 347endif()
 348
 349set(LIB_STATIC "libcurl_static")
 350set(LIB_SHARED "libcurl_shared")
 351
 352if(NOT BUILD_SHARED_LIBS AND NOT BUILD_STATIC_LIBS)
 353  set(BUILD_STATIC_LIBS ON)
 354endif()
 355if(NOT BUILD_STATIC_CURL AND NOT BUILD_SHARED_LIBS)
 356  set(BUILD_STATIC_CURL ON)
 357elseif(BUILD_STATIC_CURL AND NOT BUILD_STATIC_LIBS)
 358  set(BUILD_STATIC_CURL OFF)
 359endif()
 360
 361# Lib flavour selected for curl tool
 362if(BUILD_STATIC_CURL)
 363  set(LIB_SELECTED_FOR_EXE ${LIB_STATIC})
 364else()
 365  set(LIB_SELECTED_FOR_EXE ${LIB_SHARED})
 366endif()
 367
 368# Lib flavour selected for example and test programs.
 369if(BUILD_SHARED_LIBS)
 370  set(LIB_SELECTED ${LIB_SHARED})
 371else()
 372  set(LIB_SELECTED ${LIB_STATIC})
 373endif()
 374
 375if(WIN32)
 376  option(CURL_STATIC_CRT "Build libcurl with static CRT with MSVC (/MT)" OFF)
 377  if(CURL_STATIC_CRT AND MSVC)
 378    if(MSVC_VERSION GREATER_EQUAL 1900 OR BUILD_STATIC_CURL OR NOT BUILD_CURL_EXE)
 379      set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 380      set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS "$<$<CONFIG:Release>:-MT>")
 381      set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS "$<$<CONFIG:Debug>:-MTd>")
 382    else()
 383      message(WARNING "Static CRT requires UCRT, static libcurl or no curl executable.")
 384    endif()
 385  endif()
 386endif()
 387
 388# Override to force-disable or force-enable the use of CMake Configs.
 389if(MSVC AND NOT VCPKG_TOOLCHAIN AND NOT CMAKE_CROSSCOMPILING)
 390  set(_curl_use_cmakeconfig_default ON)
 391else()
 392  set(_curl_use_cmakeconfig_default OFF)
 393endif()
 394option(CURL_USE_CMAKECONFIG "Enable detecting dependencies via CMake Config" ${_curl_use_cmakeconfig_default})
 395
 396# Override to force-disable or force-enable the use of pkg-config.
 397if((UNIX AND NOT ANDROID AND (NOT APPLE OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")) OR
 398   VCPKG_TOOLCHAIN OR
 399   (MINGW AND NOT CMAKE_CROSSCOMPILING))
 400  set(_curl_use_pkgconfig_default ON)
 401else()
 402  set(_curl_use_pkgconfig_default OFF)
 403endif()
 404option(CURL_USE_PKGCONFIG "Enable pkg-config to detect dependencies" ${_curl_use_pkgconfig_default})
 405
 406# Initialize variables collecting system and dependency libs.
 407set(CURL_NETWORK_AND_TIME_LIBS "")
 408set(CURL_LIBS "")
 409
 410if(ENABLE_ARES)
 411  set(USE_ARES 1)
 412  find_package(Cares MODULE REQUIRED)
 413  list(APPEND CURL_LIBS CURL::cares)
 414endif()
 415
 416include(CurlSymbolHiding)
 417
 418option(CURL_ENABLE_EXPORT_TARGET "Enable CMake export target" ON)
 419mark_as_advanced(CURL_ENABLE_EXPORT_TARGET)
 420
 421option(CURL_DISABLE_ALTSVC "Disable alt-svc support" OFF)
 422mark_as_advanced(CURL_DISABLE_ALTSVC)
 423option(CURL_DISABLE_SRP "Disable TLS-SRP support" OFF)
 424mark_as_advanced(CURL_DISABLE_SRP)
 425option(CURL_DISABLE_COOKIES "Disable cookies support" OFF)
 426mark_as_advanced(CURL_DISABLE_COOKIES)
 427option(CURL_DISABLE_BASIC_AUTH "Disable Basic authentication" OFF)
 428mark_as_advanced(CURL_DISABLE_BASIC_AUTH)
 429option(CURL_DISABLE_BEARER_AUTH "Disable Bearer authentication" OFF)
 430mark_as_advanced(CURL_DISABLE_BEARER_AUTH)
 431option(CURL_DISABLE_DIGEST_AUTH "Disable Digest authentication" OFF)
 432mark_as_advanced(CURL_DISABLE_DIGEST_AUTH)
 433option(CURL_DISABLE_KERBEROS_AUTH "Disable Kerberos authentication" OFF)
 434mark_as_advanced(CURL_DISABLE_KERBEROS_AUTH)
 435option(CURL_DISABLE_NEGOTIATE_AUTH "Disable negotiate authentication" OFF)
 436mark_as_advanced(CURL_DISABLE_NEGOTIATE_AUTH)
 437option(CURL_DISABLE_AWS "Disable aws-sigv4" OFF)
 438mark_as_advanced(CURL_DISABLE_AWS)
 439option(CURL_DISABLE_DICT "Disable DICT" OFF)
 440mark_as_advanced(CURL_DISABLE_DICT)
 441option(CURL_DISABLE_DOH "Disable DNS-over-HTTPS" OFF)
 442mark_as_advanced(CURL_DISABLE_DOH)
 443option(CURL_DISABLE_FILE "Disable FILE" OFF)
 444mark_as_advanced(CURL_DISABLE_FILE)
 445option(CURL_DISABLE_FTP "Disable FTP" OFF)
 446mark_as_advanced(CURL_DISABLE_FTP)
 447option(CURL_DISABLE_GETOPTIONS "Disable curl_easy_options API for existing options to curl_easy_setopt" OFF)
 448mark_as_advanced(CURL_DISABLE_GETOPTIONS)
 449option(CURL_DISABLE_GOPHER "Disable Gopher" OFF)
 450mark_as_advanced(CURL_DISABLE_GOPHER)
 451option(CURL_DISABLE_HEADERS_API "Disable headers-api support" OFF)
 452mark_as_advanced(CURL_DISABLE_HEADERS_API)
 453option(CURL_DISABLE_HSTS "Disable HSTS support" OFF)
 454mark_as_advanced(CURL_DISABLE_HSTS)
 455option(CURL_DISABLE_HTTP "Disable HTTP" OFF)
 456mark_as_advanced(CURL_DISABLE_HTTP)
 457option(CURL_DISABLE_HTTP_AUTH "Disable all HTTP authentication methods" OFF)
 458mark_as_advanced(CURL_DISABLE_HTTP_AUTH)
 459option(CURL_DISABLE_IMAP "Disable IMAP" OFF)
 460mark_as_advanced(CURL_DISABLE_IMAP)
 461option(CURL_DISABLE_LDAP "Disable LDAP" OFF)
 462mark_as_advanced(CURL_DISABLE_LDAP)
 463option(CURL_DISABLE_LDAPS "Disable LDAPS" ${CURL_DISABLE_LDAP})
 464mark_as_advanced(CURL_DISABLE_LDAPS)
 465option(CURL_DISABLE_LIBCURL_OPTION "Disable --libcurl option from the curl tool" OFF)
 466mark_as_advanced(CURL_DISABLE_LIBCURL_OPTION)
 467option(CURL_DISABLE_MIME "Disable MIME support" OFF)
 468mark_as_advanced(CURL_DISABLE_MIME)
 469cmake_dependent_option(CURL_DISABLE_FORM_API "Disable form-api"
 470  OFF "NOT CURL_DISABLE_MIME"
 471  ON)
 472mark_as_advanced(CURL_DISABLE_FORM_API)
 473option(CURL_DISABLE_MQTT "Disable MQTT" OFF)
 474mark_as_advanced(CURL_DISABLE_MQTT)
 475option(CURL_DISABLE_BINDLOCAL "Disable local binding support" OFF)
 476mark_as_advanced(CURL_DISABLE_BINDLOCAL)
 477option(CURL_DISABLE_NETRC "Disable netrc parser" OFF)
 478mark_as_advanced(CURL_DISABLE_NETRC)
 479option(CURL_ENABLE_NTLM "Enable NTLM support" OFF)
 480mark_as_advanced(CURL_ENABLE_NTLM)
 481option(CURL_DISABLE_PARSEDATE "Disable date parsing" OFF)
 482mark_as_advanced(CURL_DISABLE_PARSEDATE)
 483option(CURL_DISABLE_POP3 "Disable POP3" OFF)
 484mark_as_advanced(CURL_DISABLE_POP3)
 485option(CURL_DISABLE_PROGRESS_METER "Disable built-in progress meter" OFF)
 486mark_as_advanced(CURL_DISABLE_PROGRESS_METER)
 487option(CURL_DISABLE_PROXY "Disable proxy support" OFF)
 488mark_as_advanced(CURL_DISABLE_PROXY)
 489option(CURL_DISABLE_IPFS "Disable IPFS" OFF)
 490mark_as_advanced(CURL_DISABLE_IPFS)
 491option(CURL_DISABLE_RTSP "Disable RTSP" OFF)
 492mark_as_advanced(CURL_DISABLE_RTSP)
 493option(CURL_DISABLE_SHA512_256 "Disable SHA-512/256 hash algorithm" OFF)
 494mark_as_advanced(CURL_DISABLE_SHA512_256)
 495option(CURL_DISABLE_SHUFFLE_DNS "Disable shuffle DNS feature" OFF)
 496mark_as_advanced(CURL_DISABLE_SHUFFLE_DNS)
 497option(CURL_ENABLE_SMB "Enable SMB" OFF)
 498mark_as_advanced(CURL_ENABLE_SMB)
 499option(CURL_DISABLE_SMTP "Disable SMTP" OFF)
 500mark_as_advanced(CURL_DISABLE_SMTP)
 501option(CURL_DISABLE_SOCKETPAIR "Disable use of socketpair for curl_multi_poll()" OFF)
 502mark_as_advanced(CURL_DISABLE_SOCKETPAIR)
 503option(CURL_DISABLE_WEBSOCKETS "Disable WebSocket" OFF)
 504mark_as_advanced(CURL_DISABLE_WEBSOCKETS)
 505option(CURL_DISABLE_TELNET "Disable Telnet" OFF)
 506mark_as_advanced(CURL_DISABLE_TELNET)
 507option(CURL_DISABLE_TFTP "Disable TFTP" OFF)
 508mark_as_advanced(CURL_DISABLE_TFTP)
 509option(CURL_DISABLE_TYPECHECK "Disable curl_easy_setopt()/curl_easy_getinfo() type checking" OFF)
 510mark_as_advanced(CURL_DISABLE_TYPECHECK)
 511option(CURL_DISABLE_VERBOSE_STRINGS "Disable verbose strings" OFF)
 512mark_as_advanced(CURL_DISABLE_VERBOSE_STRINGS)
 513option(CURL_DEBUG_GLOBAL_MEM "Debug curl_global_init_mem" OFF)
 514mark_as_advanced(CURL_DEBUG_GLOBAL_MEM)
 515
 516if(CURL_DEBUG_GLOBAL_MEM)
 517  # Set it via the command-line to make it apply to the entire directory.
 518  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "CURL_DEBUG_GLOBAL_MEM")
 519endif()
 520if(CURL_DISABLE_TYPECHECK)
 521  # Set it via the command-line to make it apply to examples also.
 522  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "CURL_DISABLE_TYPECHECK")
 523endif()
 524
 525if(CURL_DISABLE_HTTP)
 526  set(CURL_DISABLE_ALTSVC ON)
 527  set(CURL_DISABLE_HSTS ON)
 528  set(CURL_DISABLE_IPFS ON)
 529  set(CURL_DISABLE_RTSP ON)
 530  set(CURL_DISABLE_WEBSOCKETS ON)
 531endif()
 532
 533# Corresponds to HTTP_ONLY in lib/curl_setup.h
 534option(HTTP_ONLY "Disable all protocols except HTTP (This overrides all CURL_DISABLE_* options)" OFF)
 535mark_as_advanced(HTTP_ONLY)
 536
 537if(HTTP_ONLY)
 538  set(CURL_DISABLE_DICT ON)
 539  set(CURL_DISABLE_FILE ON)
 540  set(CURL_DISABLE_FTP ON)
 541  set(CURL_DISABLE_GOPHER ON)
 542  set(CURL_DISABLE_IMAP ON)
 543  set(CURL_DISABLE_IPFS ON)
 544  set(CURL_DISABLE_LDAP ON)
 545  set(CURL_DISABLE_LDAPS ON)
 546  set(CURL_DISABLE_MQTT ON)
 547  set(CURL_DISABLE_POP3 ON)
 548  set(CURL_DISABLE_RTSP ON)
 549  set(CURL_DISABLE_SMTP ON)
 550  set(CURL_DISABLE_TELNET ON)
 551  set(CURL_DISABLE_TFTP ON)
 552  set(CURL_DISABLE_WEBSOCKETS ON)
 553endif()
 554
 555if(WINDOWS_STORE)
 556  set(CURL_DISABLE_TELNET ON)  # telnet code needs fixing to compile for UWP.
 557endif()
 558
 559option(CURL_LINT "Run lint checks while building" OFF)
 560
 561find_package(Perl)
 562
 563if(PERL_EXECUTABLE)
 564  add_custom_target(curl-ca-bundle
 565    COMMENT "Generating a fresh ca-bundle.crt" VERBATIM USES_TERMINAL
 566    COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/mk-ca-bundle.pl" -b -l -u "lib/ca-bundle.crt"
 567    DEPENDS "${PROJECT_SOURCE_DIR}/scripts/mk-ca-bundle.pl"
 568  )
 569  add_custom_target(curl-ca-firefox
 570    COMMENT "Generating a fresh ca-bundle.crt" VERBATIM USES_TERMINAL
 571    COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/firefox-db2pem.sh" "lib/ca-bundle.crt"
 572    DEPENDS "${PROJECT_SOURCE_DIR}/scripts/firefox-db2pem.sh"
 573  )
 574  add_custom_target(curl-lint
 575    COMMENT "Running lint checks" VERBATIM USES_TERMINAL
 576    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
 577    COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/badwords-all"
 578    COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/checksrc-all.pl"
 579    COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/spacecheck.pl"
 580    DEPENDS
 581      "${PROJECT_SOURCE_DIR}/scripts/badwords-all" "${PROJECT_SOURCE_DIR}/scripts/badwords"
 582      "${PROJECT_SOURCE_DIR}/scripts/checksrc-all.pl" "${PROJECT_SOURCE_DIR}/scripts/checksrc.pl"
 583      "${PROJECT_SOURCE_DIR}/scripts/spacecheck.pl"
 584  )
 585  if(CURL_LINT)
 586    set_target_properties(curl-lint PROPERTIES EXCLUDE_FROM_ALL FALSE)
 587  endif()
 588endif()
 589
 590option(BUILD_LIBCURL_DOCS "Build libcurl man pages" ON)
 591option(BUILD_MISC_DOCS "Build misc man pages (e.g. curl-config and mk-ca-bundle)" ON)
 592option(ENABLE_CURL_MANUAL "Build the man page for curl and enable its -M/--manual option" ON)
 593
 594if((ENABLE_CURL_MANUAL OR BUILD_LIBCURL_DOCS) AND NOT Perl_FOUND)
 595  message(WARNING "Perl not found. Cannot build manuals.")
 596endif()
 597
 598# If we are on AIX, do the _ALL_SOURCE magic
 599if(AIX OR CMAKE_SYSTEM_NAME STREQUAL "AIX")
 600  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "_ALL_SOURCE")
 601endif()
 602
 603# If we are on Haiku, make sure that the network library is brought in.
 604if(CMAKE_SYSTEM_NAME STREQUAL "Haiku")
 605  list(APPEND CURL_NETWORK_AND_TIME_LIBS "network")
 606elseif(AMIGA)
 607  list(APPEND CURL_NETWORK_AND_TIME_LIBS "net" "m" "atomic")
 608  list(APPEND CMAKE_REQUIRED_LIBRARIES "net" "m" "atomic")
 609endif()
 610
 611# Include all the necessary files for macros
 612include(CMakePushCheckState)
 613include(CheckFunctionExists)
 614include(CheckIncludeFile)
 615include(CheckIncludeFiles)
 616include(CheckLibraryExists)
 617include(CheckSymbolExists)
 618include(CheckTypeSize)
 619include(CheckCSourceCompiles)
 620
 621option(_CURL_PREFILL "Fast-track known feature detection results (Windows, some Apple)" "${WIN32}")
 622mark_as_advanced(_CURL_PREFILL)
 623if(_CURL_PREFILL)
 624  if(WIN32)
 625    include("${CMAKE_CURRENT_SOURCE_DIR}/CMake/win32-cache.cmake")
 626  elseif(UNIX)
 627    include("${CMAKE_CURRENT_SOURCE_DIR}/CMake/unix-cache.cmake")
 628    message(STATUS "Pre-filling feature detection results for UNIX")
 629  endif()
 630elseif(WIN32)
 631  message(STATUS "Pre-filling feature detection results disabled.")
 632elseif(APPLE)
 633  set(HAVE_EVENTFD 0)
 634  set(HAVE_GETPASS_R 0)
 635  set(HAVE_WRITABLE_ARGV 1)
 636  set(HAVE_SENDMMSG 0)
 637endif()
 638
 639if(AMIGA)
 640  set(HAVE_GETADDRINFO 0)  # Breaks the build when detected and used.
 641endif()
 642if(DOS OR AMIGA)
 643  set(HAVE_TIME_T_UNSIGNED 1)
 644endif()
 645
 646if(NOT WIN32)
 647  find_package(Threads)
 648  if(CMAKE_USE_PTHREADS_INIT)
 649    set(HAVE_THREADS_POSIX 1)
 650    list(APPEND CURL_NETWORK_AND_TIME_LIBS Threads::Threads)
 651  endif()
 652endif()
 653
 654if(ENABLE_THREADED_RESOLVER)
 655  if(NOT WIN32 AND NOT HAVE_THREADS_POSIX)
 656    message(FATAL_ERROR "Threaded resolver requires POSIX Threads.")
 657  endif()
 658  set(USE_RESOLV_THREADED ON)
 659elseif(USE_ARES)
 660  set(USE_RESOLV_ARES ON)
 661endif()
 662
 663# Check for all needed libraries
 664if(DOS)
 665  if(WATT_ROOT)
 666    set(USE_WATT32 ON)
 667    # FIXME upstream: must specify the full path to avoid CMake converting "watt" to "watt.lib"
 668    list(APPEND CURL_NETWORK_AND_TIME_LIBS "${WATT_ROOT}/lib/libwatt.a")
 669    include_directories(SYSTEM "${WATT_ROOT}/inc")
 670    list(APPEND CMAKE_REQUIRED_INCLUDES "${WATT_ROOT}/inc")
 671  else()
 672    message(FATAL_ERROR "Set WATT_ROOT variable to the absolute path to the root installation of Watt-32.")
 673  endif()
 674elseif(AMIGA)
 675  if(AMISSL_INCLUDE_DIR AND AMISSL_STUBS_LIBRARY AND AMISSL_AUTO_LIBRARY)
 676    set(USE_AMISSL ON)
 677    list(APPEND CMAKE_REQUIRED_INCLUDES "${AMISSL_INCLUDE_DIR}")
 678    list(APPEND CMAKE_REQUIRED_LIBRARIES "${AMISSL_STUBS_LIBRARY}" "${AMISSL_AUTO_LIBRARY}")
 679    set(OPENSSL_INCLUDE_DIR "${AMISSL_INCLUDE_DIR}")
 680    set(OPENSSL_SSL_LIBRARY "${AMISSL_STUBS_LIBRARY}")
 681    set(OPENSSL_CRYPTO_LIBRARY "${AMISSL_AUTO_LIBRARY}")
 682    set(CURL_USE_OPENSSL ON)
 683    set(CURL_CA_FALLBACK ON CACHE BOOL "")
 684  endif()
 685elseif(NOT WIN32 AND NOT APPLE)
 686  check_library_exists("socket" "connect" "" HAVE_LIBSOCKET)
 687  if(HAVE_LIBSOCKET)
 688    list(PREPEND CURL_NETWORK_AND_TIME_LIBS "socket")
 689  endif()
 690endif()
 691
 692option(ENABLE_IPV6 "Enable IPv6 support" ON)
 693mark_as_advanced(ENABLE_IPV6)
 694if(ENABLE_IPV6)
 695  include(CheckStructHasMember)
 696  if(WIN32)
 697    check_struct_has_member("struct sockaddr_in6" "sin6_scope_id" "winsock2.h;ws2tcpip.h" HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)
 698  else()
 699    check_struct_has_member("struct sockaddr_in6" "sin6_scope_id" "netinet/in.h" HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)
 700    check_struct_has_member("struct sockaddr_in6" "sin6_addr" "netinet/in.h" HAVE_SOCKADDR_IN6_SIN6_ADDR)
 701    if(NOT HAVE_SOCKADDR_IN6_SIN6_ADDR)
 702      if(NOT DOS AND NOT AMIGA)
 703        message(WARNING "struct sockaddr_in6 not available, disabling IPv6 support")
 704      endif()
 705      set(ENABLE_IPV6 OFF CACHE BOOL "Enable IPv6 support" FORCE)  # Force the feature off as we use this name as guard macro
 706    endif()
 707
 708    if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT ENABLE_ARES)
 709      set(_use_core_foundation_and_core_services ON)
 710
 711      find_library(SYSTEMCONFIGURATION_FRAMEWORK NAMES "SystemConfiguration")
 712      mark_as_advanced(SYSTEMCONFIGURATION_FRAMEWORK)
 713      if(NOT SYSTEMCONFIGURATION_FRAMEWORK)
 714        message(FATAL_ERROR "SystemConfiguration framework not found")
 715      endif()
 716      list(APPEND CURL_LIBS "-framework SystemConfiguration")
 717    endif()
 718  endif()
 719endif()
 720if(ENABLE_IPV6)
 721  set(USE_IPV6 ON)
 722endif()
 723
 724# Check SSL libraries
 725option(CURL_ENABLE_SSL "Enable SSL support" ON)
 726
 727if(CURL_DEFAULT_SSL_BACKEND)
 728  set(_valid_default_ssl_backend FALSE)
 729endif()
 730
 731if(WIN32)
 732  cmake_dependent_option(CURL_USE_SCHANNEL "Enable Windows native SSL/TLS (Schannel)" OFF CURL_ENABLE_SSL OFF)
 733  option(CURL_WINDOWS_SSPI "Enable SSPI on Windows" ${CURL_USE_SCHANNEL})
 734else()
 735  set(CURL_USE_SCHANNEL OFF)
 736  set(CURL_WINDOWS_SSPI OFF)
 737endif()
 738cmake_dependent_option(CURL_USE_MBEDTLS "Enable mbedTLS for SSL/TLS" OFF CURL_ENABLE_SSL OFF)
 739cmake_dependent_option(CURL_USE_WOLFSSL "Enable wolfSSL for SSL/TLS" OFF CURL_ENABLE_SSL OFF)
 740cmake_dependent_option(CURL_USE_GNUTLS "Enable GnuTLS for SSL/TLS" OFF CURL_ENABLE_SSL OFF)
 741cmake_dependent_option(CURL_USE_RUSTLS "Enable Rustls for SSL/TLS" OFF CURL_ENABLE_SSL OFF)
 742
 743if(WIN32 OR
 744   CURL_USE_SCHANNEL OR
 745   CURL_USE_MBEDTLS OR
 746   CURL_USE_WOLFSSL OR
 747   CURL_USE_GNUTLS OR
 748   CURL_USE_RUSTLS)
 749  set(_openssl_default OFF)
 750else()
 751  set(_openssl_default ON)
 752endif()
 753cmake_dependent_option(CURL_USE_OPENSSL "Enable OpenSSL for SSL/TLS" ${_openssl_default} CURL_ENABLE_SSL OFF)
 754option(CURL_DISABLE_OPENSSL_AUTO_LOAD_CONFIG "Disable automatic loading of OpenSSL configuration" OFF)
 755
 756curl_count_true(_enabled_ssl_options_count
 757  CURL_USE_SCHANNEL
 758  CURL_USE_OPENSSL
 759  CURL_USE_MBEDTLS
 760  CURL_USE_WOLFSSL
 761  CURL_USE_GNUTLS
 762  CURL_USE_RUSTLS
 763)
 764if(_enabled_ssl_options_count GREATER 1)
 765  set(CURL_WITH_MULTI_SSL ON)
 766elseif(_enabled_ssl_options_count EQUAL 0)
 767  set(CURL_DISABLE_HSTS ON)
 768endif()
 769
 770if(CURL_USE_SCHANNEL)
 771  if(WINDOWS_STORE)
 772    message(FATAL_ERROR "UWP does not support Schannel.")
 773  endif()
 774  set(_ssl_enabled ON)
 775  set(USE_SCHANNEL ON)  # Windows native SSL/TLS support
 776  set(USE_WINDOWS_SSPI ON)  # CURL_USE_SCHANNEL requires CURL_WINDOWS_SSPI
 777
 778  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "schannel")
 779    set(_valid_default_ssl_backend TRUE)
 780  endif()
 781endif()
 782if(CURL_WINDOWS_SSPI AND NOT WINDOWS_STORE)
 783  set(USE_WINDOWS_SSPI ON)
 784endif()
 785
 786if(APPLE)
 787  option(USE_APPLE_SECTRUST "Use Apple OS-native certificate verification" OFF)
 788  if(USE_APPLE_SECTRUST)
 789    if(NOT CURL_USE_OPENSSL AND NOT CURL_USE_GNUTLS)
 790      message(FATAL_ERROR "Apple SecTrust is only supported with Openssl/GnuTLS")
 791    endif()
 792    find_library(SECURITY_FRAMEWORK NAMES "Security")
 793    mark_as_advanced(SECURITY_FRAMEWORK)
 794    if(NOT SECURITY_FRAMEWORK)
 795      message(FATAL_ERROR "Security framework not found")
 796    endif()
 797    list(APPEND CURL_LIBS "-framework Security")
 798
 799    set(_use_core_foundation_and_core_services ON)
 800    message(STATUS "Apple OS-native certificate verification enabled")
 801  endif()
 802else()
 803  set(USE_APPLE_SECTRUST OFF)
 804endif()
 805
 806if(_use_core_foundation_and_core_services)
 807  find_library(COREFOUNDATION_FRAMEWORK NAMES "CoreFoundation")
 808  mark_as_advanced(COREFOUNDATION_FRAMEWORK)
 809  if(NOT COREFOUNDATION_FRAMEWORK)
 810    message(FATAL_ERROR "CoreFoundation framework not found")
 811  endif()
 812  list(APPEND CURL_LIBS "-framework CoreFoundation")
 813
 814  find_library(CORESERVICES_FRAMEWORK NAMES "CoreServices")
 815  mark_as_advanced(CORESERVICES_FRAMEWORK)
 816  if(NOT CORESERVICES_FRAMEWORK)
 817    message(FATAL_ERROR "CoreServices framework not found")
 818  endif()
 819  list(APPEND CURL_LIBS "-framework CoreServices")
 820endif()
 821
 822if(CURL_USE_OPENSSL)
 823  find_package(OpenSSL REQUIRED)
 824  set(_ssl_enabled ON)
 825  set(USE_OPENSSL ON)
 826
 827  # Depend on OpenSSL via imported targets. This allows our dependents to
 828  # get our dependencies transitively.
 829  list(APPEND CURL_LIBS OpenSSL::SSL OpenSSL::Crypto)
 830
 831  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "openssl")
 832    set(_valid_default_ssl_backend TRUE)
 833  endif()
 834  set(_curl_ca_bundle_supported TRUE)
 835
 836  cmake_push_check_state()
 837  list(APPEND CMAKE_REQUIRED_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
 838  if(NOT DEFINED HAVE_AWSLC)
 839    check_symbol_exists("OPENSSL_IS_AWSLC" "openssl/base.h" HAVE_AWSLC)
 840  endif()
 841  if(NOT DEFINED HAVE_BORINGSSL)
 842    check_symbol_exists("OPENSSL_IS_BORINGSSL" "openssl/base.h" HAVE_BORINGSSL)
 843  endif()
 844  if(NOT DEFINED HAVE_LIBRESSL)
 845    check_symbol_exists("LIBRESSL_VERSION_NUMBER" "openssl/opensslv.h" HAVE_LIBRESSL)
 846  endif()
 847  cmake_pop_check_state()
 848
 849  if(HAVE_AWSLC OR HAVE_BORINGSSL)
 850    if(NOT MSVC AND NOT ANDROID)  # AWS-LC/BoringSSL MSVC builds use native Windows threads
 851      find_package(Threads)
 852      if(CMAKE_USE_PTHREADS_INIT)
 853        set(HAVE_THREADS_POSIX_BORINGSSL 1)
 854        list(APPEND CURL_NETWORK_AND_TIME_LIBS Threads::Threads)
 855        list(APPEND CMAKE_REQUIRED_LIBRARIES Threads::Threads)
 856      elseif(OPENSSL_USE_STATIC_LIBS)
 857        message(WARNING "AWS-LC/BoringSSL requires POSIX Threads.")
 858      endif()
 859    endif()
 860    if(OPENSSL_USE_STATIC_LIBS AND CMAKE_C_COMPILER_ID MATCHES "Clang")
 861      list(APPEND CURL_LIBS "stdc++")
 862      list(APPEND CMAKE_REQUIRED_LIBRARIES "stdc++")
 863    endif()
 864  endif()
 865
 866  if(USE_AMISSL)
 867    set(_openssl "AmiSSL")
 868  elseif(HAVE_AWSLC)
 869    set(_openssl "AWS-LC")
 870  elseif(HAVE_BORINGSSL)
 871    if(BORINGSSL_VERSION)
 872      set(CURL_BORINGSSL_VERSION "\"${BORINGSSL_VERSION}\"")
 873    endif()
 874    set(_openssl "BoringSSL")
 875  elseif(HAVE_LIBRESSL)
 876    set(_openssl "LibreSSL")
 877  else()
 878    set(_openssl "OpenSSL")
 879  endif()
 880endif()
 881
 882if(CURL_USE_MBEDTLS)
 883  find_package(MbedTLS MODULE REQUIRED)
 884  if(MBEDTLS_VERSION VERSION_LESS 3.2.0)
 885    message(FATAL_ERROR "mbedTLS v3.2.0 or newer is required.")
 886  endif()
 887  set(_ssl_enabled ON)
 888  set(USE_MBEDTLS ON)
 889  list(APPEND CURL_LIBS CURL::mbedtls)
 890
 891  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "mbedtls")
 892    set(_valid_default_ssl_backend TRUE)
 893  endif()
 894  set(_curl_ca_bundle_supported TRUE)
 895
 896  if(MBEDTLS_VERSION VERSION_GREATER_EQUAL 4.0.0)
 897    set(HAVE_MBEDTLS_DES_CRYPT_ECB 0)  # pre-fill detection result
 898  endif()
 899  if(NOT DEFINED HAVE_MBEDTLS_DES_CRYPT_ECB)
 900    cmake_push_check_state()
 901    list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::mbedtls)
 902    check_function_exists("mbedtls_des_crypt_ecb" HAVE_MBEDTLS_DES_CRYPT_ECB)  # in mbedTLS <4
 903    cmake_pop_check_state()
 904  endif()
 905endif()
 906
 907if(CURL_USE_WOLFSSL)
 908  find_package(WolfSSL MODULE REQUIRED)
 909  set(_ssl_enabled ON)
 910  set(USE_WOLFSSL ON)
 911  list(APPEND CURL_LIBS CURL::wolfssl)
 912
 913  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "wolfssl")
 914    set(_valid_default_ssl_backend TRUE)
 915  endif()
 916  set(_curl_ca_bundle_supported TRUE)
 917
 918  if(USE_OPENSSL AND WOLFSSL_VERSION VERSION_LESS 5.7.6)
 919    message(FATAL_ERROR "wolfSSL 5.7.6 or newer is required to coexist with OpenSSL.")
 920  endif()
 921
 922  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "WOLFSSL_OPTIONS_IGNORE_SYS")
 923endif()
 924
 925if(CURL_USE_GNUTLS)
 926  find_package(GnuTLS MODULE REQUIRED)
 927  list(APPEND CURL_LIBS CURL::gnutls)
 928  find_package(Nettle MODULE REQUIRED)
 929  list(APPEND CURL_LIBS CURL::nettle)
 930  set(_ssl_enabled ON)
 931  set(USE_GNUTLS ON)
 932
 933  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "gnutls")
 934    set(_valid_default_ssl_backend TRUE)
 935  endif()
 936  set(_curl_ca_bundle_supported TRUE)
 937
 938  if(NOT DEFINED HAVE_GNUTLS_SRP AND NOT CURL_DISABLE_SRP)
 939    cmake_push_check_state()
 940    list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::gnutls)
 941    # In GnuTLS 3.8.0 (2023-02-10) and upper, this check always succeeds.
 942    # Detecting actual TLS-SRP support needs poking the API at runtime.
 943    check_symbol_exists("gnutls_srp_verifier" "gnutls/gnutls.h" HAVE_GNUTLS_SRP)
 944    cmake_pop_check_state()
 945  endif()
 946endif()
 947
 948if(CURL_USE_RUSTLS)
 949  find_package(Rustls MODULE REQUIRED)
 950  set(_ssl_enabled ON)
 951  set(USE_RUSTLS ON)
 952  list(APPEND CURL_LIBS CURL::rustls)
 953
 954  if(NOT DEFINED HAVE_RUSTLS_SUPPORTED_HPKE)
 955    if(RUSTLS_VERSION AND RUSTLS_VERSION VERSION_GREATER_EQUAL 0.15)
 956      set(HAVE_RUSTLS_SUPPORTED_HPKE TRUE)
 957    elseif(NOT RUSTLS_VERSION)
 958      cmake_push_check_state()
 959      list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::rustls)
 960      check_symbol_exists("rustls_supported_hpke" "rustls.h" HAVE_RUSTLS_SUPPORTED_HPKE)
 961      cmake_pop_check_state()
 962    endif()
 963  endif()
 964  if(NOT HAVE_RUSTLS_SUPPORTED_HPKE)
 965    message(FATAL_ERROR "rustls-ffi library does not provide rustls_supported_hpke function. Required version is 0.15 or newer.")
 966  endif()
 967
 968  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "rustls")
 969    set(_valid_default_ssl_backend TRUE)
 970  endif()
 971  set(_curl_ca_bundle_supported TRUE)
 972endif()
 973
 974if(CURL_DEFAULT_SSL_BACKEND AND NOT _valid_default_ssl_backend)
 975  message(FATAL_ERROR "CURL_DEFAULT_SSL_BACKEND '${CURL_DEFAULT_SSL_BACKEND}' not enabled.")
 976endif()
 977
 978# Keep ZLIB detection after TLS detection,
 979# and before calling curl_openssl_check_exists().
 980
 981set(HAVE_LIBZ OFF)
 982curl_dependency_option(CURL_ZLIB ZLIB "ZLIB")
 983if(ZLIB_FOUND)
 984  set(HAVE_LIBZ ON)
 985  # Depend on ZLIB via imported targets. This allows our dependents to
 986  # get our dependencies transitively.
 987  list(APPEND CURL_LIBS ZLIB::ZLIB)
 988endif()
 989
 990set(HAVE_BROTLI OFF)
 991curl_dependency_option(CURL_BROTLI Brotli "brotli")
 992if(BROTLI_FOUND)
 993  set(HAVE_BROTLI ON)
 994  list(APPEND CURL_LIBS CURL::brotli)
 995endif()
 996
 997set(HAVE_ZSTD OFF)
 998curl_dependency_option(CURL_ZSTD Zstd "zstd")
 999if(ZSTD_FOUND)
1000  if(ZSTD_VERSION VERSION_GREATER_EQUAL 1.0.0)
1001    set(HAVE_ZSTD ON)
1002    list(APPEND CURL_LIBS CURL::zstd)
1003  else()
1004    message(WARNING "zstd v1.0.0 or newer is required, disabling zstd support.")
1005  endif()
1006endif()
1007
1008# Check function in an OpenSSL-like TLS backend.
1009macro(curl_openssl_check_exists)
1010  cmake_push_check_state()
1011  if(USE_OPENSSL)
1012    list(APPEND CMAKE_REQUIRED_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
1013    list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DOPENSSL_SUPPRESS_DEPRECATED")  # for SSL_CTX_set_srp_username deprecated since 3.0.0
1014    if(HAVE_LIBZ)
1015      list(APPEND CMAKE_REQUIRED_LIBRARIES ZLIB::ZLIB)
1016    endif()
1017    if(WIN32)
1018      list(APPEND CMAKE_REQUIRED_LIBRARIES "bcrypt")  # for OpenSSL/LibreSSL BCryptGenRandom()
1019    endif()
1020  endif()
1021  if(USE_WOLFSSL)
1022    list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::wolfssl)
1023    list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DWOLFSSL_OPTIONS_IGNORE_SYS")
1024    if(HAVE_LIBZ)
1025      list(APPEND CMAKE_REQUIRED_LIBRARIES ZLIB::ZLIB)  # Public wolfSSL headers also require zlib headers
1026    endif()
1027    list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DHAVE_UINTPTR_T")  # to pull in stdint.h (as of wolfSSL v5.5.4)
1028  endif()
1029  if(WIN32)
1030    list(APPEND CMAKE_REQUIRED_LIBRARIES "ws2_32" "crypt32")  # for OpenSSL/wolfSSL
1031  endif()
1032  if(${ARGC} EQUAL 2)
1033    check_function_exists(${ARGN})
1034  else()
1035    check_symbol_exists(${ARGN})  # Uses CMAKE_REQUIRED_INCLUDES and CMAKE_REQUIRED_DEFINITIONS
1036  endif()
1037  cmake_pop_check_state()
1038endmacro()
1039
1040# Ensure that OpenSSL (or fork) or wolfSSL actually supports QUICTLS API.
1041macro(curl_openssl_check_quic)
1042  if(USE_OPENSSL)
1043    if(OPENSSL_VERSION VERSION_GREATER_EQUAL 3.5.0)
1044      if(NOT DEFINED HAVE_SSL_SET_QUIC_TLS_CBS)
1045        curl_openssl_check_exists("SSL_set_quic_tls_cbs" HAVE_SSL_SET_QUIC_TLS_CBS)
1046      endif()
1047    else()
1048      if(NOT DEFINED HAVE_SSL_SET_QUIC_USE_LEGACY_CODEPOINT)
1049        curl_openssl_check_exists("SSL_set_quic_use_legacy_codepoint" HAVE_SSL_SET_QUIC_USE_LEGACY_CODEPOINT)
1050      endif()
1051    endif()
1052  endif()
1053  if(USE_WOLFSSL AND NOT DEFINED HAVE_WOLFSSL_SET_QUIC_USE_LEGACY_CODEPOINT)
1054    curl_openssl_check_exists("wolfSSL_set_quic_use_legacy_codepoint" HAVE_WOLFSSL_SET_QUIC_USE_LEGACY_CODEPOINT)
1055  endif()
1056  if(NOT HAVE_SSL_SET_QUIC_TLS_CBS AND
1057     NOT HAVE_SSL_SET_QUIC_USE_LEGACY_CODEPOINT AND
1058     NOT HAVE_WOLFSSL_SET_QUIC_USE_LEGACY_CODEPOINT)
1059    message(FATAL_ERROR "QUICTLS API support is missing from OpenSSL/fork/wolfSSL. Try setting -DOPENSSL_ROOT_DIR")
1060  endif()
1061endmacro()
1062
1063if(USE_WOLFSSL)
1064  curl_openssl_check_exists("wolfSSL_get_peer_certificate" HAVE_WOLFSSL_GET_PEER_CERTIFICATE)
1065  curl_openssl_check_exists("wolfSSL_UseALPN" HAVE_WOLFSSL_USEALPN)
1066  curl_openssl_check_exists("wolfSSL_BIO_new" HAVE_WOLFSSL_BIO_NEW)
1067  curl_openssl_check_exists("wolfSSL_BIO_set_shutdown" HAVE_WOLFSSL_BIO_SET_SHUTDOWN)
1068  curl_openssl_check_exists("wc_Des_EcbEncrypt" HAVE_WC_DES_ECBENCRYPT)
1069endif()
1070
1071if(USE_OPENSSL)
1072  if(NOT DEFINED HAVE_DES_ECB_ENCRYPT)
1073    curl_openssl_check_exists("DES_ecb_encrypt" "openssl/des.h" HAVE_DES_ECB_ENCRYPT)
1074  endif()
1075  if(NOT DEFINED HAVE_SSL_SET0_WBIO)
1076    curl_openssl_check_exists("SSL_set0_wbio" HAVE_SSL_SET0_WBIO)
1077  endif()
1078  if(NOT DEFINED HAVE_OPENSSL_SRP AND NOT CURL_DISABLE_SRP)
1079    curl_openssl_check_exists("SSL_CTX_set_srp_username" "openssl/ssl.h" HAVE_OPENSSL_SRP)
1080  endif()
1081endif()
1082
1083option(USE_HTTPSRR "Enable HTTPS RR support" OFF)
1084option(USE_ECH "Enable ECH support" OFF)
1085if(USE_ECH)
1086  if(USE_OPENSSL OR USE_WOLFSSL OR USE_RUSTLS)
1087    # Be sure that the TLS library actually supports ECH.
1088    if(USE_WOLFSSL)
1089      curl_openssl_check_exists("wolfSSL_CTX_GenerateEchConfig" HAVE_WOLFSSL_CTX_GENERATEECHCONFIG)
1090    endif()
1091    if(USE_OPENSSL)
1092      curl_openssl_check_exists("SSL_set1_ech_config_list" HAVE_SSL_SET1_ECH_CONFIG_LIST)
1093    endif()
1094    if(HAVE_WOLFSSL_CTX_GENERATEECHCONFIG OR
1095       HAVE_SSL_SET1_ECH_CONFIG_LIST OR
1096       USE_RUSTLS)
1097      set(HAVE_ECH 1)
1098    endif()
1099    if(NOT HAVE_ECH)
1100      message(FATAL_ERROR "ECH support missing in AWS-LC/BoringSSL/OpenSSL/Rustls/wolfSSL")
1101    else()
1102      message(STATUS "ECH enabled")
1103      # ECH wants HTTPSRR
1104      set(USE_HTTPSRR ON)
1105      message(STATUS "HTTPSRR enabled")
1106    endif()
1107  else()
1108    message(FATAL_ERROR "ECH requires ECH-enabled AWS-LC, BoringSSL, OpenSSL, Rustls or wolfSSL")
1109  endif()
1110endif()
1111
1112option(USE_SSLS_EXPORT "Enable SSL session export support" OFF)
1113if(USE_SSLS_EXPORT)
1114  if(_ssl_enabled)
1115    message(STATUS "SSL export enabled.")
1116  else()
1117    message(WARNING "SSL session export requires SSL enabled")
1118  endif()
1119endif()
1120
1121option(USE_NGHTTP2 "Use nghttp2 library" ON)
1122if(USE_NGHTTP2)
1123  find_package(NGHTTP2 MODULE)
1124  if(NGHTTP2_FOUND)
1125    list(APPEND CURL_LIBS CURL::nghttp2)
1126  else()
1127    set(USE_NGHTTP2 OFF)
1128  endif()
1129endif()
1130
1131option(USE_NGTCP2 "Use ngtcp2 and nghttp3 libraries for HTTP/3 support" OFF)
1132if(USE_NGTCP2)
1133  if(CURL_WITH_MULTI_SSL)
1134    message(FATAL_ERROR "MultiSSL cannot be enabled with HTTP/3 and vice versa.")
1135  elseif(USE_OPENSSL OR USE_WOLFSSL)
1136    if(USE_WOLFSSL)
1137      find_package(NGTCP2 MODULE REQUIRED COMPONENTS "wolfSSL")
1138    elseif(HAVE_BORINGSSL OR HAVE_AWSLC)
1139      find_package(NGTCP2 MODULE REQUIRED COMPONENTS "BoringSSL")
1140    elseif(OPENSSL_VERSION VERSION_GREATER_EQUAL 3.5.0)
1141      find_package(NGTCP2 MODULE REQUIRED COMPONENTS "ossl")
1142      if(NGTCP2_VERSION VERSION_LESS 1.12.0)
1143        message(FATAL_ERROR "ngtcp2 1.12.0 or upper required for OpenSSL")
1144      endif()
1145      set(OPENSSL_QUIC_API2 1)
1146    elseif(HAVE_LIBRESSL)
1147      find_package(NGTCP2 MODULE COMPONENTS "LibreSSL")
1148      if(NOT NGTCP2_FOUND)
1149        find_package(NGTCP2 MODULE REQUIRED COMPONENTS "quictls")  # for ngtcp2 <1.15.0
1150      endif()
1151    else()
1152      find_package(NGTCP2 MODULE REQUIRED COMPONENTS "quictls")
1153      set(_openssl "quictls")
1154    endif()
1155    curl_openssl_check_quic()
1156  elseif(USE_GNUTLS)
1157    find_package(NGTCP2 MODULE REQUIRED "GnuTLS")
1158  else()
1159    message(FATAL_ERROR "ngtcp2 requires a supported TLS-backend")
1160  endif()
1161  list(APPEND CURL_LIBS CURL::ngtcp2)
1162
1163  find_package(NGHTTP3 MODULE REQUIRED)
1164  set(USE_NGHTTP3 ON)
1165  list(APPEND CURL_LIBS CURL::nghttp3)
1166endif()
1167
1168option(USE_QUICHE "Use quiche library for HTTP/3 support" OFF)
1169if(USE_QUICHE)
1170  if(USE_NGTCP2)
1171    message(FATAL_ERROR "Only one HTTP/3 backend can be selected")
1172  elseif(CURL_WITH_MULTI_SSL)
1173    message(FATAL_ERROR "MultiSSL cannot be enabled with HTTP/3 and vice versa.")
1174  endif()
1175  find_package(Quiche MODULE REQUIRED)
1176  if(NOT HAVE_BORINGSSL)
1177    message(FATAL_ERROR "quiche requires BoringSSL")
1178  endif()
1179  curl_openssl_check_quic()
1180  list(APPEND CURL_LIBS CURL::quiche)
1181  if(NOT DEFINED HAVE_QUICHE_CONN_SET_QLOG_FD)
1182    cmake_push_check_state()
1183    list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::quiche)
1184    check_symbol_exists("quiche_conn_set_qlog_fd" "quiche.h" HAVE_QUICHE_CONN_SET_QLOG_FD)
1185    cmake_pop_check_state()
1186  endif()
1187endif()
1188
1189if(NOT CURL_DISABLE_SRP AND (HAVE_GNUTLS_SRP OR HAVE_OPENSSL_SRP))
1190  set(USE_TLS_SRP 1)
1191endif()
1192
1193if(NOT CURL_DISABLE_LDAP)
1194  if(WIN32 AND NOT WINDOWS_STORE)
1195    option(USE_WIN32_LDAP "Use Windows LDAP implementation" ON)
1196    if(USE_WIN32_LDAP)
1197      list(APPEND CURL_LIBS "wldap32")
1198      if(NOT CURL_DISABLE_LDAPS)
1199        set(HAVE_LDAP_SSL ON)
1200      endif()
1201    endif()
1202  endif()
1203
1204  # Now that we know, we are not using Windows LDAP...
1205  if(NOT USE_WIN32_LDAP)
1206    # Check for LDAP
1207    cmake_push_check_state()
1208    if(USE_OPENSSL)
1209      list(APPEND CMAKE_REQUIRED_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
1210    endif()
1211    find_package(LDAP MODULE)
1212    if(LDAP_FOUND)
1213      set(HAVE_LBER_H 1)
1214      list(PREPEND CURL_LIBS CURL::ldap)
1215
1216      # LDAP feature checks
1217
1218      list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DLDAP_DEPRECATED=1")
1219      list(APPEND CMAKE_REQUIRED_LIBRARIES CURL::ldap)
1220
1221      check_function_exists("ldap_url_parse" HAVE_LDAP_URL_PARSE)
1222      check_function_exists("ldap_init_fd" HAVE_LDAP_INIT_FD)
1223
1224      check_include_file("ldap_ssl.h" HAVE_LDAP_SSL_H)
1225
1226      if(HAVE_LDAP_INIT_FD)
1227        set(USE_OPENLDAP ON)
1228      endif()
1229      if(NOT CURL_DISABLE_LDAPS)
1230        set(HAVE_LDAP_SSL ON)
1231      endif()
1232    else()
1233      message(STATUS "LDAP not found. CURL_DISABLE_LDAP set ON")
1234      set(CURL_DISABLE_LDAP ON CACHE BOOL "" FORCE)
1235    endif()
1236    cmake_pop_check_state()
1237  endif()
1238endif()
1239
1240# No ldap, no ldaps.
1241if(CURL_DISABLE_LDAP)
1242  if(NOT CURL_DISABLE_LDAPS)
1243    message(STATUS "LDAP needs to be enabled to support LDAPS")
1244    set(CURL_DISABLE_LDAPS ON CACHE BOOL "" FORCE)
1245  endif()
1246endif()
1247
1248if(WIN32)
1249  option(USE_WIN32_IDN "Use WinIDN for IDN support" OFF)
1250  if(USE_WIN32_IDN)
1251    list(APPEND CURL_LIBS "normaliz")  # for IdnToAscii(), IdnToUnicode()
1252  endif()
1253else()
1254  set(USE_WIN32_IDN OFF)
1255endif()
1256
1257if(APPLE)
1258  option(USE_APPLE_IDN "Use Apple built-in IDN support" OFF)
1259  if(USE_APPLE_IDN)
1260    cmake_push_check_state()
1261    list(APPEND CMAKE_REQUIRED_LIBRARIES "icucore")
1262    check_symbol_exists("uidna_openUTS46" "unicode/uidna.h" HAVE_APPLE_IDN)
1263    cmake_pop_check_state()
1264    if(HAVE_APPLE_IDN)
1265      list(APPEND CURL_LIBS "icucore" "iconv")
1266    else()
1267      set(USE_APPLE_IDN OFF)
1268    endif()
1269  endif()
1270else()
1271  set(USE_APPLE_IDN OFF)
1272endif()
1273
1274# Check for libidn2
1275option(USE_LIBIDN2 "Use libidn2 for IDN support" ON)
1276set(HAVE_IDN2_H OFF)
1277set(HAVE_LIBIDN2 OFF)
1278if(USE_LIBIDN2 AND NOT USE_APPLE_IDN AND NOT USE_WIN32_IDN)
1279  find_package(Libidn2 MODULE)
1280  if(LIBIDN2_FOUND)
1281    list(PREPEND CURL_LIBS CURL::libidn2)
1282    set(HAVE_IDN2_H 1)
1283    set(HAVE_LIBIDN2 1)
1284  endif()
1285endif()
1286
1287# libpsl
1288option(CURL_USE_LIBPSL "Use libpsl" ON)
1289mark_as_advanced(CURL_USE_LIBPSL)
1290set(USE_LIBPSL OFF)
1291if(CURL_USE_LIBPSL)
1292  find_package(Libpsl MODULE REQUIRED)
1293  list(APPEND CURL_LIBS CURL::libpsl)
1294  set(USE_LIBPSL ON)
1295endif()
1296
1297# libssh2
1298option(CURL_USE_LIBSSH2 "Use libssh2" ON)
1299mark_as_advanced(CURL_USE_LIBSSH2)
1300set(USE_LIBSSH2 OFF)
1301if(CURL_USE_LIBSSH2)
1302  find_package(Libssh2 MODULE)
1303  if(LIBSSH2_FOUND)
1304    list(PREPEND CURL_LIBS CURL::libssh2)  # keep it before TLS-crypto, compression
1305    set(USE_LIBSSH2 ON)
1306  endif()
1307endif()
1308
1309# libssh
1310option(CURL_USE_LIBSSH "Use libssh" OFF)
1311mark_as_advanced(CURL_USE_LIBSSH)
1312if(NOT USE_LIBSSH2 AND CURL_USE_LIBSSH)
1313  find_package(Libssh MODULE REQUIRED)
1314  list(PREPEND CURL_LIBS CURL::libssh)  # keep it before TLS-crypto, compression
1315  set(USE_LIBSSH ON)
1316endif()
1317
1318option(CURL_USE_GSASL "Use libgsasl" OFF)
1319mark_as_advanced(CURL_USE_GSASL)
1320if(CURL_USE_GSASL)
1321  find_package(Libgsasl MODULE REQUIRED)
1322  list(APPEND CURL_LIBS CURL::libgsasl)
1323  set(USE_GSASL ON)
1324endif()
1325
1326option(CURL_USE_GSSAPI "Use GSSAPI implementation" OFF)
1327mark_as_advanced(CURL_USE_GSSAPI)
1328
1329if(CURL_USE_GSSAPI)
1330  find_package(GSS MODULE)
1331
1332  set(HAVE_GSSAPI ${GSS_FOUND})
1333  if(GSS_FOUND)
1334    list(APPEND CURL_LIBS CURL::gss)
1335
1336    get_target_property(_gss_flavour CURL::gss INTERFACE_CURL_GSS_FLAVOUR)
1337    if(_gss_flavour STREQUAL "GNU")
1338      set(HAVE_GSSGNU 1)
1339    elseif(GSS_VERSION)  # MIT
1340      set(CURL_KRB5_VERSION "\"${GSS_VERSION}\"")
1341    endif()
1342  else()
1343    message(WARNING "GSSAPI has been requested, but no supporting libraries found. Skipping.")
1344  endif()
1345endif()
1346
1347# libbacktrace
1348option(CURL_USE_LIBBACKTRACE "Use libbacktrace. Requires debug-enabled build and DWARF debug information." OFF)
1349if(CURL_USE_LIBBACKTRACE)
1350  if(NOT ENABLE_DEBUG)
1351    message(FATAL_ERROR "libbacktrace requires debug-enabled build for TrackMemory")
1352  endif()
1353  if(NOT CMAKE_BUILD_TYPE MATCHES "(Debug|RelWithDebInfo)")
1354    message(FATAL_ERROR "libbacktrace requires debug information")
1355  endif()
1356  find_package(Libbacktrace MODULE REQUIRED)
1357  list(APPEND CURL_LIBS CURL::libbacktrace)
1358  set(USE_BACKTRACE ON)
1359endif()
1360
1361# libuv
1362option(CURL_USE_LIBUV "Use libuv for event-based tests" OFF)
1363if(CURL_USE_LIBUV)
1364  if(NOT ENABLE_DEBUG)
1365    message(FATAL_ERROR "Using libuv without debug support enabled is useless")
1366  endif()
1367  find_package(Libuv MODULE REQUIRED)
1368  list(APPEND CURL_LIBS CURL::libuv)
1369  set(USE_LIBUV ON)
1370  set(HAVE_UV_H ON)
1371endif()
1372
1373option(ENABLE_UNIX_SOCKETS "Enable Unix domain sockets support" ON)
1374if(ENABLE_UNIX_SOCKETS)
1375  if(WIN32 OR DOS)
1376    set(USE_UNIX_SOCKETS 1)
1377  else()
1378    include(CheckStructHasMember)
1379    check_struct_has_member("struct sockaddr_un" "sun_path" "sys/un.h" USE_UNIX_SOCKETS)
1380  endif()
1381else()
1382  set(USE_UNIX_SOCKETS 0)
1383  unset(USE_UNIX_SOCKETS CACHE)
1384endif()
1385
1386#
1387# CA handling
1388#
1389option(CURL_CA_NATIVE "Use native CA store" OFF)
1390if(CURL_CA_NATIVE)
1391  set(_curl_disable_ca_search_default ON)
1392else()
1393  set(_curl_disable_ca_search_default OFF)
1394endif()
1395
1396if(_curl_ca_bundle_supported)
1397  set(_ca_opt_desc "Set 'none' to disable or 'auto' for auto-detection. Defaults to 'auto'.")
1398
1399  set(CURL_CA_BUNDLE "auto" CACHE
1400    STRING "Absolute path to the CA bundle. ${_ca_opt_desc}")
1401  set(CURL_CA_FALLBACK OFF CACHE
1402    BOOL "Use built-in CA store of OpenSSL. Defaults to OFF")
1403  set(CURL_CA_PATH "auto" CACHE
1404    STRING "Absolute path to a directory containing CA certificates stored individually. ${_ca_opt_desc}")
1405  set(CURL_CA_EMBED "" CACHE
1406    STRING "Absolute path to the CA bundle to embed in the curl tool.")
1407
1408  if(CURL_CA_FALLBACK AND NOT CURL_USE_OPENSSL)
1409    message(FATAL_ERROR "CURL_CA_FALLBACK only works with OpenSSL.")
1410  endif()
1411
1412  if(CURL_CA_BUNDLE STREQUAL "")
1413    message(FATAL_ERROR "Invalid value of CURL_CA_BUNDLE. Use 'none', 'auto' or file path.")
1414  elseif(CURL_CA_BUNDLE STREQUAL "none")
1415    unset(CURL_CA_BUNDLE CACHE)
1416  elseif(CURL_CA_BUNDLE STREQUAL "auto")
1417    unset(CURL_CA_BUNDLE CACHE)
1418    if(NOT CMAKE_CROSSCOMPILING AND NOT WIN32 AND NOT USE_APPLE_SECTRUST AND NOT CURL_CA_NATIVE)
1419      set(_curl_ca_bundle_autodetect TRUE)
1420    endif()
1421  else()
1422    set(CURL_CA_BUNDLE_SET TRUE)
1423  endif()
1424  mark_as_advanced(CURL_CA_BUNDLE_SET)
1425
1426  if(CURL_CA_PATH STREQUAL "")
1427    message(FATAL_ERROR "Invalid value of CURL_CA_PATH. Use 'none', 'auto' or directory path.")
1428  elseif(CURL_CA_PATH STREQUAL "none")
1429    unset(CURL_CA_PATH CACHE)
1430  elseif(CURL_CA_PATH STREQUAL "auto")
1431    unset(CURL_CA_PATH CACHE)
1432    if(NOT CMAKE_CROSSCOMPILING AND NOT WIN32 AND NOT USE_APPLE_SECTRUST AND NOT CURL_CA_NATIVE)
1433      set(_curl_ca_path_autodetect TRUE)
1434    endif()
1435  else()
1436    set(CURL_CA_PATH_SET TRUE)
1437  endif()
1438  mark_as_advanced(CURL_CA_PATH_SET)
1439
1440  if(CURL_CA_BUNDLE_SET AND _curl_ca_path_autodetect)
1441    # Skip auto-detection of unset CA path because CA bundle is set explicitly
1442  elseif(CURL_CA_PATH_SET AND _curl_ca_bundle_autodetect)
1443    # Skip auto-detection of unset CA bundle because CA path is set explicitly
1444  elseif(_curl_ca_bundle_autodetect OR _curl_ca_path_autodetect)
1445    # First try auto-detecting a CA bundle, then a CA path
1446
1447    if(_curl_ca_bundle_autodetect)
1448      foreach(_search_ca_bundle_path IN ITEMS
1449          "/etc/ssl/certs/ca-certificates.crt"
1450          "/etc/pki/tls/certs/ca-bundle.crt"
1451          "/usr/share/ssl/certs/ca-bundle.crt"
1452          "/usr/local/share/certs/ca-root-nss.crt"
1453          "/etc/ssl/cert.pem")
1454        if(EXISTS "${_search_ca_bundle_path}")
1455          message(STATUS "Found CA bundle: ${_search_ca_bundle_path}")
1456          set(CURL_CA_BUNDLE "${_search_ca_bundle_path}" CACHE
1457            STRING "Absolute path to the CA bundle. ${_ca_opt_desc}")
1458          set(CURL_CA_BUNDLE_SET TRUE CACHE BOOL "Absolute path to the CA bundle has been set")
1459          break()
1460        endif()
1461      endforeach()
1462    endif()
1463
1464    if(_curl_ca_path_autodetect AND NOT CURL_CA_PATH_SET)
1465      set(_search_ca_path "/etc/ssl/certs")
1466      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")
1467      if(_curl_ca_files_found)
1468        unset(_curl_ca_files_found)
1469        message(STATUS "Found CA path: ${_search_ca_path}")
1470        set(CURL_CA_PATH "${_search_ca_path}" CACHE
1471          STRING "Absolute path to a directory containing CA certificates stored individually. ${_ca_opt_desc}")
1472        set(CURL_CA_PATH_SET TRUE CACHE BOOL "Absolute path to the CA bundle has been set")
1473      endif()
1474    endif()
1475  endif()
1476
1477  set(CURL_CA_EMBED_SET FALSE)
1478  if(BUILD_CURL_EXE AND NOT CURL_CA_EMBED STREQUAL "")
1479    if(EXISTS "${CURL_CA_EMBED}")
1480      set(CURL_CA_EMBED_SET TRUE)
1481      message(STATUS "Found CA bundle to embed: ${CURL_CA_EMBED}")
1482    else()
1483      message(FATAL_ERROR "CA bundle to embed is missing: '${CURL_CA_EMBED}'")
1484    endif()
1485  endif()
1486endif()
1487
1488if(WIN32)
1489  option(CURL_DISABLE_CA_SEARCH "Disable unsafe CA bundle search in PATH on Windows" ${_curl_disable_ca_search_default})
1490  option(CURL_CA_SEARCH_SAFE "Enable safe CA bundle search (within the curl tool directory) on Windows" OFF)
1491endif()
1492
1493set(CURL_INCLUDES "")
1494
1495# Check for header files
1496if(WIN32)
1497  list(APPEND CURL_INCLUDES "winsock2.h")
1498  list(APPEND CURL_INCLUDES "ws2tcpip.h")
1499
1500  if(HAVE_WIN32_WINNT AND HAVE_WIN32_WINNT LESS 0x0600)
1501    # Windows Vista is required for freeaddrinfo, getaddrinfo, if_nametoindex
1502    message(FATAL_ERROR "Building for Windows Vista or newer is required.")
1503  endif()
1504endif()
1505
1506if(NOT WIN32)
1507  list(APPEND CURL_INCLUDES "sys/socket.h")
1508endif()
1509if(NOT WIN32 OR MINGW)
1510  list(APPEND CURL_INCLUDES "sys/time.h")
1511endif()
1512
1513# Detect headers
1514
1515# Use check_include_file_concat_curl() for headers required by subsequent
1516# check_include_file_concat_curl() or check_symbol_exists() detections.
1517# Order for these is significant.
1518check_include_file("sys/eventfd.h"    HAVE_SYS_EVENTFD_H)
1519check_include_file("sys/filio.h"      HAVE_SYS_FILIO_H)
1520check_include_file("sys/ioctl.h"      HAVE_SYS_IOCTL_H)
1521check_include_file("sys/param.h"      HAVE_SYS_PARAM_H)
1522check_include_file("sys/poll.h"       HAVE_SYS_POLL_H)
1523check_include_file("sys/resource.h"   HAVE_SYS_RESOURCE_H)
1524check_include_file_concat_curl("sys/select.h"     HAVE_SYS_SELECT_H)
1525check_include_file("sys/sockio.h"     HAVE_SYS_SOCKIO_H)
1526check_include_file_concat_curl("sys/types.h"      HAVE_SYS_TYPES_H)
1527check_include_file("sys/un.h"         HAVE_SYS_UN_H)
1528check_include_file_concat_curl("sys/utime.h"      HAVE_SYS_UTIME_H)  # sys/types.h (AmigaOS)
1529
1530check_include_file_concat_curl("arpa/inet.h"      HAVE_ARPA_INET_H)
1531check_include_file("dirent.h"         HAVE_DIRENT_H)
1532check_include_file("fcntl.h"          HAVE_FCNTL_H)
1533check_include_file_concat_curl("ifaddrs.h"        HAVE_IFADDRS_H)
1534check_include_file("io.h"             HAVE_IO_H)
1535check_include_file_concat_curl("libgen.h"         HAVE_LIBGEN_H)
1536check_include_file("linux/tcp.h"      HAVE_LINUX_TCP_H)
1537check_include_file("locale.h"         HAVE_LOCALE_H)
1538check_include_file_concat_curl("net/if.h"         HAVE_NET_IF_H)  # sys/select.h (e.g. MS-DOS/Watt-32)
1539check_include_file_concat_curl("netdb.h"          HAVE_NETDB_H)
1540check_include_file_concat_curl("netinet/in.h"     HAVE_NETINET_IN_H)
1541check_include_file("netinet/in6.h"    HAVE_NETINET_IN6_H)
1542check_include_file_concat_curl("netinet/tcp.h"    HAVE_NETINET_TCP_H)  # sys/types.h (e.g. Cygwin) netinet/in.h
1543check_include_file_concat_curl("netinet/udp.h"    HAVE_NETINET_UDP_H)  # sys/types.h (e.g. Cygwin)
1544check_include_file("poll.h"           HAVE_POLL_H)
1545check_include_file("pwd.h"            HAVE_PWD_H)
1546check_include_file("stdatomic.h"      HAVE_STDATOMIC_H)
1547check_include_file("stdbool.h"        HAVE_STDBOOL_H)
1548check_include_file("strings.h"        HAVE_STRINGS_H)
1549check_include_file("stropts.h"        HAVE_STROPTS_H)
1550check_include_file("termio.h"         HAVE_TERMIO_H)
1551check_include_file("termios.h"        HAVE_TERMIOS_H)
1552check_include_file_concat_curl("unistd.h"         HAVE_UNISTD_H)
1553check_include_file("utime.h"          HAVE_UTIME_H)
1554
1555if(AMIGA)
1556  check_include_file_concat_curl("proto/bsdsocket.h" HAVE_PROTO_BSDSOCKET_H)
1557endif()
1558
1559# Pass these detection results to curl_internal_test() for use in CurlTests.c
1560# Add here all feature flags referenced from CurlTests.c
1561foreach(_variable IN ITEMS
1562    HAVE_STDATOMIC_H
1563    HAVE_STDBOOL_H
1564    HAVE_STROPTS_H
1565    HAVE_SYS_IOCTL_H
1566    HAVE_SYS_TYPES_H
1567    HAVE_UNISTD_H
1568)
1569  if(${_variable})
1570    list(APPEND CURL_TEST_DEFINES "-D${_variable}")
1571  endif()
1572endforeach()
1573
1574check_type_size("size_t"      SIZEOF_SIZE_T)
1575check_type_size("ssize_t"     SIZEOF_SSIZE_T)
1576check_type_size("long"        SIZEOF_LONG)
1577check_type_size("int"         SIZEOF_INT)
1578check_type_size("__int64"     SIZEOF___INT64)
1579check_type_size("time_t"      SIZEOF_TIME_T)
1580check_type_size("suseconds_t" SIZEOF_SUSECONDS_T)
1581if(NOT HAVE_SIZEOF_SSIZE_T)
1582  if(SIZEOF_LONG EQUAL SIZEOF_SIZE_T)
1583    set(ssize_t "long")
1584  endif()
1585  if(NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T)
1586    set(ssize_t "__int64")
1587  endif()
1588endif()
1589# off_t is sized later, after the HAVE_FILE_OFFSET_BITS test
1590
1591if(SIZEOF_SUSECONDS_T)
1592  set(HAVE_SUSECONDS_T 1)
1593endif()
1594
1595# Check for some functions that are used
1596
1597# Apply to all feature checks
1598if(WIN32)
1599  list(APPEND CMAKE_REQUIRED_LIBRARIES "ws2_32")
1600  if(NOT WINDOWS_STORE)
1601    list(APPEND CMAKE_REQUIRED_LIBRARIES "iphlpapi")
1602  endif()
1603elseif(HAVE_LIBSOCKET)
1604  list(APPEND CMAKE_REQUIRED_LIBRARIES "socket")
1605elseif(DOS)
1606  list(APPEND CMAKE_REQUIRED_LIBRARIES "${WATT_ROOT}/lib/libwatt.a")
1607endif()
1608
1609check_function_exists("accept4"       HAVE_ACCEPT4)
1610check_function_exists("fnmatch"       HAVE_FNMATCH)
1611check_symbol_exists("basename"        "${CURL_INCLUDES};string.h" HAVE_BASENAME)  # libgen.h unistd.h
1612check_symbol_exists("opendir"         "dirent.h" HAVE_OPENDIR)
1613check_function_exists("poll"          HAVE_POLL)  # poll.h
1614check_symbol_exists("socket"          "${CURL_INCLUDES}" HAVE_SOCKET)  # winsock2.h sys/socket.h
1615check_symbol_exists("socketpair"      "${CURL_INCLUDES}" HAVE_SOCKETPAIR)  # sys/socket.h
1616check_symbol_exists("recv"            "${CURL_INCLUDES}" HAVE_RECV)  # proto/bsdsocket.h sys/types.h sys/socket.h
1617check_symbol_exists("send"            "${CURL_INCLUDES}" HAVE_SEND)  # proto/bsdsocket.h sys/types.h sys/socket.h
1618check_function_exists("sendmsg"       HAVE_SENDMSG)
1619check_function_exists("sendmmsg"      HAVE_SENDMMSG)
1620check_symbol_exists("select"          "${CURL_INCLUDES}" HAVE_SELECT)  # proto/bsdsocket.h sys/select.h sys/socket.h
1621check_symbol_exists("memrchr"         "string.h" HAVE_MEMRCHR)
1622check_symbol_exists("alarm"           "unistd.h" HAVE_ALARM)
1623check_symbol_exists("fcntl"           "fcntl.h" HAVE_FCNTL)
1624check_function_exists("getppid"       HAVE_GETPPID)
1625check_function_exists("utimes"        HAVE_UTIMES)
1626
1627check_function_exists("gettimeofday"  HAVE_GETTIMEOFDAY)  # sys/time.h
1628check_symbol_exists("closesocket"     "${CURL_INCLUDES}" HAVE_CLOSESOCKET)  # winsock2.h
1629check_symbol_exists("sigsetjmp"       "setjmp.h" HAVE_SIGSETJMP)
1630check_function_exists("getpass_r"     HAVE_GETPASS_R)
1631check_function_exists("getpwuid"      HAVE_GETPWUID)
1632check_function_exists("getpwuid_r"    HAVE_GETPWUID_R)
1633check_function_exists("geteuid"       HAVE_GETEUID)
1634check_function_exists("utime"         HAVE_UTIME)
1635check_symbol_exists("gmtime_r"        "stdlib.h;time.h" HAVE_GMTIME_R)
1636check_symbol_exists("localtime_r"     "stdlib.h;time.h" HAVE_LOCALTIME_R)
1637
1638check_symbol_exists("gethostbyname_r" "netdb.h" HAVE_GETHOSTBYNAME_R)
1639check_symbol_exists("gethostname"     "${CURL_INCLUDES}" HAVE_GETHOSTNAME)  # winsock2.h unistd.h proto/bsdsocket.h
1640
1641check_symbol_exists("signal"          "signal.h" HAVE_SIGNAL)
1642check_symbol_exists("strerror_r"      "stdlib.h;string.h" HAVE_STRERROR_R)
1643check_symbol_exists("sigaction"       "signal.h" HAVE_SIGACTION)
1644check_symbol_exists("siginterrupt"    "signal.h" HAVE_SIGINTERRUPT)
1645check_symbol_exists("getaddrinfo"     "${CURL_INCLUDES};stdlib.h;string.h" HAVE_GETADDRINFO)  # ws2tcpip.h sys/socket.h netdb.h
1646check_symbol_exists("getifaddrs"      "${CURL_INCLUDES};stdlib.h" HAVE_GETIFADDRS)  # ifaddrs.h
1647check_symbol_exists("freeaddrinfo"    "${CURL_INCLUDES}" HAVE_FREEADDRINFO)  # ws2tcpip.h sys/socket.h netdb.h
1648check_function_exists("pipe"          HAVE_PIPE)
1649check_function_exists("eventfd"       HAVE_EVENTFD)
1650check_symbol_exists("getpeername"     "${CURL_INCLUDES}" HAVE_GETPEERNAME)  # winsock2.h unistd.h proto/bsdsocket.h
1651check_symbol_exists("getsockname"     "${CURL_INCLUDES}" HAVE_GETSOCKNAME)  # winsock2.h unistd.h proto/bsdsocket.h
1652check_function_exists("getrlimit"     HAVE_GETRLIMIT)
1653check_function_exists("setlocale"     HAVE_SETLOCALE)
1654check_function_exists("setrlimit"     HAVE_SETRLIMIT)
1655
1656if(APPLE)
1657  check_function_exists("mach_absolute_time" HAVE_MACH_ABSOLUTE_TIME)
1658else()
1659  # Apple platforms do not offer pipe2(), but the iPhone Simulator-specific
1660  # /usr/lib/system/libsystem_sim_kernel.dylib exports it. To avoid false
1661  # detection, omit this feature check for Apple targets.
1662  check_function_exists("pipe2"         HAVE_PIPE2)
1663endif()
1664
1665if(NOT WIN32)
1666  check_function_exists("if_nametoindex"  HAVE_IF_NAMETOINDEX)  # net/if.h
1667  check_function_exists("realpath"        HAVE_REALPATH)
1668  check_function_exists("sched_yield"     HAVE_SCHED_YIELD)
1669
1670  check_symbol_exists("inet_ntop"       "${CURL_INCLUDES};stdlib.h;string.h" HAVE_INET_NTOP) # arpa/inet.h netinet/in.h sys/socket.h
1671  check_symbol_exists("inet_pton"       "${CURL_INCLUDES};stdlib.h;string.h" HAVE_INET_PTON) # arpa/inet.h netinet/in.h sys/socket.h
1672  check_symbol_exists("strcasecmp"      "string.h" HAVE_STRCASECMP)
1673  check_symbol_exists("stricmp"         "string.h" HAVE_STRICMP)
1674  check_symbol_exists("strcmpi"         "string.h" HAVE_STRCMPI)
1675
1676  check_symbol_exists("memset_s" "string.h" HAVE_MEMSET_S)
1677  if(NOT HAVE_MEMSET_S)
1678    check_function_exists("memset_explicit" HAVE_MEMSET_EXPLICIT)
1679  endif()
1680endif()
1681
1682if(AMIGA)
1683  check_symbol_exists("CloseSocket" "${CURL_INCLUDES}" HAVE_CLOSESOCKET_CAMEL)  # sys/socket.h proto/bsdsocket.h
1684endif()
1685
1686if(NOT _ssl_enabled)
1687  check_symbol_exists("arc4random" "${CURL_INCLUDES};stdlib.h" HAVE_ARC4RANDOM)
1688endif()
1689
1690check_symbol_exists("fsetxattr" "sys/xattr.h" HAVE_FSETXATTR)
1691if(HAVE_FSETXATTR)
1692  curl_internal_test(HAVE_FSETXATTR_5)
1693  curl_internal_test(HAVE_FSETXATTR_6)
1694endif()
1695
1696cmake_push_check_state()
1697if(NOT WIN32)
1698  list(APPEND CMAKE_EXTRA_INCLUDE_FILES "sys/socket.h")
1699  check_type_size("sa_family_t" SIZEOF_SA_FAMILY_T)
1700  set(HAVE_SA_FAMILY_T ${HAVE_SIZEOF_SA_FAMILY_T})
1701endif()
1702cmake_pop_check_state()
1703
1704# Do curl specific tests
1705foreach(_curl_test IN ITEMS
1706    HAVE_FCNTL_O_NONBLOCK
1707    HAVE_IOCTLSOCKET
1708    HAVE_IOCTLSOCKET_CAMEL
1709    HAVE_IOCTLSOCKET_CAMEL_FIONBIO
1710    HAVE_IOCTLSOCKET_FIONBIO
1711    HAVE_IOCTL_FIONBIO
1712    HAVE_IOCTL_SIOCGIFADDR
1713    HAVE_SETSOCKOPT_SO_NONBLOCK
1714    HAVE_GETHOSTBYNAME_R_3
1715    HAVE_GETHOSTBYNAME_R_5
1716    HAVE_GETHOSTBYNAME_R_6
1717    HAVE_BOOL_T
1718    STDC_HEADERS
1719    HAVE_ATOMIC
1720)
1721  curl_internal_test(${_curl_test})
1722endforeach()
1723
1724# Check for reentrant
1725cmake_push_check_state()
1726list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_REENTRANT")
1727foreach(_curl_test IN ITEMS
1728    HAVE_GETHOSTBYNAME_R_3
1729    HAVE_GETHOSTBYNAME_R_5
1730    HAVE_GETHOSTBYNAME_R_6)
1731  curl_internal_test(${_curl_test}_REENTRANT)
1732  if(NOT ${_curl_test} AND ${_curl_test}_REENTRANT)
1733    set(NEED_REENTRANT 1)
1734  endif()
1735endforeach()
1736cmake_pop_check_state()
1737
1738if(NEED_REENTRANT)
1739  foreach(_curl_test IN ITEMS
1740      HAVE_GETHOSTBYNAME_R_3
1741      HAVE_GETHOSTBYNAME_R_5
1742      HAVE_GETHOSTBYNAME_R_6)
1743    set(${_curl_test} 0)
1744    if(${_curl_test}_REENTRANT)
1745      set(${_curl_test} 1)
1746    endif()
1747  endforeach()
1748endif()
1749
1750cmake_push_check_state()
1751list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_FILE_OFFSET_BITS=64")
1752curl_internal_test(HAVE_FILE_OFFSET_BITS)
1753cmake_pop_check_state()
1754
1755cmake_push_check_state()
1756if(HAVE_FILE_OFFSET_BITS)
1757  set(_FILE_OFFSET_BITS 64)
1758  list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_FILE_OFFSET_BITS=64")
1759endif()
1760check_type_size("off_t" SIZEOF_OFF_T)
1761
1762if(NOT WIN32)
1763  # fseeko may not exist with _FILE_OFFSET_BITS=64 but can exist with
1764  # _FILE_OFFSET_BITS unset or 32 (as in Android ARMv7 with NDK 26b and API level < 24)
1765  # so we need to test fseeko after testing for _FILE_OFFSET_BITS
1766  check_symbol_exists("fseeko" "${CURL_INCLUDES};stdio.h" HAVE_FSEEKO)
1767
1768  if(HAVE_FSEEKO)
1769    set(HAVE_DECL_FSEEKO 1)
1770  endif()
1771endif()
1772
1773# Include this header to get the type
1774cmake_push_check_state()
1775list(APPEND CMAKE_REQUIRED_INCLUDES "${PROJECT_SOURCE_DIR}/include")
1776list(APPEND CMAKE_EXTRA_INCLUDE_FILES "curl/system.h")
1777check_type_size("curl_off_t" SIZEOF_CURL_OFF_T)
1778list(APPEND CMAKE_EXTRA_INCLUDE_FILES "curl/curl.h")
1779check_type_size("curl_socket_t" SIZEOF_CURL_SOCKET_T)
1780cmake_pop_check_state()  # pop curl system headers
1781cmake_pop_check_state()  # pop -D_FILE_OFFSET_BITS=64
1782
1783if(NOT WIN32 AND NOT CMAKE_CROSSCOMPILING)
1784  # On non-Windows and not cross-compiling, check for writable argv[]
1785  include(CheckCSourceRuns)
1786  check_c_source_runs("
1787    int main(int argc, char **argv)
1788    {
1789      (void)argc;
1790      argv[0][0] = ' ';
1791      return (argv[0][0] == ' ') ? 0 : 1;
1792    }" HAVE_WRITABLE_ARGV)
1793endif()
1794
1795if(NOT CMAKE_CROSSCOMPILING)
1796  include(CheckCSourceRuns)
1797  check_c_source_runs("
1798    #include <time.h>
1799    int main(void) {
1800      time_t t = -1;
1801      return t < 0;
1802    }" HAVE_TIME_T_UNSIGNED)
1803endif()
1804
1805curl_internal_test(HAVE_GLIBC_STRERROR_R)
1806curl_internal_test(HAVE_POSIX_STRERROR_R)
1807
1808if(NOT WIN32)
1809  curl_internal_test(HAVE_CLOCK_GETTIME_MONOTONIC)  # Check clock_gettime(CLOCK_MONOTONIC, x) support
1810endif()
1811
1812if(APPLE)
1813  curl_internal_test(HAVE_BUILTIN_AVAILABLE)  # Check compiler support of __builtin_available()
1814endif()
1815
1816# Some other minor tests
1817
1818if(_cmake_try_compile_target_type_save)
1819  set(CMAKE_TRY_COMPILE_TARGET_TYPE ${_cmake_try_compile_target_type_save})
1820  unset(_cmake_try_compile_target_type_save)
1821endif()
1822
1823include(CMake/OtherTests.cmake)
1824
1825set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "HAVE_CONFIG_H")
1826
1827if(WIN32)
1828  list(APPEND CURL_NETWORK_AND_TIME_LIBS "ws2_32")
1829  if(NOT WINDOWS_STORE)
1830    list(APPEND CURL_NETWORK_AND_TIME_LIBS "iphlpapi")  # for if_nametoindex()
1831  endif()
1832  list(APPEND CURL_LIBS "bcrypt")  # for BCryptGenRandom()
1833
1834  # We use crypto functions that are not available for UWP apps
1835  if(NOT WINDOWS_STORE)
1836    set(USE_WIN32_CRYPTO ON)
1837  endif()
1838
1839  # Link required libraries for USE_WIN32_CRYPTO or USE_SCHANNEL
1840  if(USE_WIN32_CRYPTO OR USE_SCHANNEL)
1841    # for CryptAcquireContext(), CryptCreateHash(), CryptDestroyHash(), CryptGetHashParam(), CryptHashData(),
1842    #     CryptReleaseContext() in NTLM, md4, md5, sha256, Schannel
1843    # for CryptDestroyKey(), CryptEncrypt(), CryptImportKey() in NTLM
1844    list(APPEND CURL_LIBS "advapi32")
1845    # for Cert*() in openssl.c Native CA, Schannel
1846    # for CryptDecodeObjectEx(), CryptQueryObject(), CryptStringToBinary(), PFXImportCertStore() in Schannel
1847    list(APPEND CURL_LIBS "crypt32")
1848  endif()
1849  if(USE_WINDOWS_SSPI)
1850    list(APPEND CURL_LIBS "secur32")  # for InitSecurityInterface()
1851  endif()
1852endif()
1853
1854list(APPEND CURL_LIBS ${CURL_NETWORK_AND_TIME_LIBS})
1855if(CURL_CODE_COVERAGE)
1856  list(APPEND CURL_LIBS ${CURL_COVERAGE_LIBS})
1857endif()
1858
1859# Hack to add some libraries to the end of the library list to make binutils ld
1860# for GCC find symbols when linking statically. Necessary for libs detected via
1861# CMake's built-in find modules, which CMake adds to the beginning of the lib
1862# list on the linker command-line for some reason. This makes them appear
1863# before dependencies detected via curl's custom Find modules, and breaks
1864# linkers sensitive to lib order. There must be a better solution to this.
1865# Enable the workaround for all compilers, to make it available when using GCC
1866# to consume libcurl, regardless of the compiler used to build libcurl itself.
1867if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
1868  if(USE_OPENSSL AND TARGET OpenSSL::Crypto)
1869    add_library(CURL::OpenSSL_Crypto INTERFACE IMPORTED)
1870    set_target_properties(CURL::OpenSSL_Crypto PROPERTIES INTERFACE_LINK_LIBRARIES OpenSSL::Crypto)
1871    list(APPEND CURL_LIBS CURL::OpenSSL_Crypto)
1872  endif()
1873  if(HAVE_LIBZ AND TARGET ZLIB::ZLIB)
1874    add_library(CURL::ZLIB INTERFACE IMPORTED)
1875    set_target_properties(CURL::ZLIB PROPERTIES INTERFACE_LINK_LIBRARIES ZLIB::ZLIB)
1876    list(APPEND CURL_LIBS CURL::ZLIB)
1877  endif()
1878  if(WIN32)
1879    add_library(CURL::win32_winsock INTERFACE IMPORTED)
1880    set_target_properties(CURL::win32_winsock PROPERTIES INTERFACE_LINK_LIBRARIES "ws2_32")
1881    list(APPEND CURL_LIBS CURL::win32_winsock)
1882  endif()
1883endif()
1884
1885if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")  # MSVC but exclude clang-cl
1886  set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS "-MP")  # Parallel compilation
1887endif()
1888
1889if(CURL_LTO)
1890  include(CheckIPOSupported)
1891  check_ipo_supported(RESULT CURL_HAS_LTO OUTPUT _lto_error LANGUAGES C)
1892  if(CURL_HAS_LTO)
1893    message(STATUS "LTO supported and enabled")
1894  else()
1895    message(FATAL_ERROR "LTO has been requested, but the compiler does not support it\n${_lto_error}")
1896  endif()
1897endif()
1898
1899# Ugly (but functional) way to include "Makefile.inc" by transforming it
1900# (= regenerate it).
1901function(curl_transform_makefile_inc _input_file _output_file)
1902  file(READ ${_input_file} _makefile_inc_text)
1903  string(REPLACE "$(top_srcdir)"   "\${PROJECT_SOURCE_DIR}" _makefile_inc_text ${_makefile_inc_text})  # cmake-lint: disable=W0106
1904  string(REPLACE "$(top_builddir)" "\${PROJECT_BINARY_DIR}" _makefile_inc_text ${_makefile_inc_text})  # cmake-lint: disable=W0106
1905
1906  string(REGEX REPLACE "\\\\\n" "!^!^!" _makefile_inc_text ${_makefile_inc_text})
1907  string(REGEX REPLACE "([a-zA-Z_][a-zA-Z0-9_]*)[\t ]*=[\t ]*([^\n]*)" "set(\\1 \\2)" _makefile_inc_text ${_makefile_inc_text})
1908  string(REPLACE "!^!^!" "\n" _makefile_inc_text ${_makefile_inc_text})
1909
1910  # Replace $() with ${}
1911  string(REGEX REPLACE "\\$\\(([a-zA-Z_][a-zA-Z0-9_]*)\\)" "\${\\1}" _makefile_inc_text ${_makefile_inc_text})
1912  # Replace @@ with ${}, even if that may not be read by CMake scripts.
1913  string(REGEX REPLACE "@([a-zA-Z_][a-zA-Z0-9_]*)@" "\${\\1}" _makefile_inc_text ${_makefile_inc_text})
1914
1915  file(WRITE ${_output_file} ${_makefile_inc_text})
1916  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${_input_file}")
1917endfunction()
1918
1919include(GNUInstallDirs)
1920
1921set(_install_cmake_dir "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
1922set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
1923set(_generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated")
1924set(_project_config "${_generated_dir}/${PROJECT_NAME}Config.cmake")
1925set(_version_config "${_generated_dir}/${PROJECT_NAME}ConfigVersion.cmake")
1926
1927option(BUILD_TESTING "Build tests" ON)
1928if(BUILD_TESTING AND Perl_FOUND)
1929  set(CURL_BUILD_TESTING ON)
1930else()
1931  set(CURL_BUILD_TESTING OFF)
1932endif()
1933
1934if(Perl_FOUND)
1935  set(CURL_MANPAGE "${PROJECT_BINARY_DIR}/docs/cmdline-opts/curl.1")
1936  set(CURL_ASCIIPAGE "${PROJECT_BINARY_DIR}/docs/cmdline-opts/curl.txt")
1937  add_subdirectory(docs)
1938endif()
1939
1940add_subdirectory(scripts)  # for shell completions
1941
1942add_subdirectory(lib)
1943
1944if(BUILD_CURL_EXE)
1945  add_subdirectory(src)
1946endif()
1947
1948option(BUILD_EXAMPLES "Build libcurl examples" ON)
1949if(BUILD_EXAMPLES)
1950  add_subdirectory(docs/examples)
1951endif()
1952
1953if(CURL_BUILD_TESTING)
1954  add_subdirectory(tests)
1955endif()
1956
1957# Helper to populate a list (_items) with a label when conditions
1958# (the remaining args) are satisfied
1959macro(curl_add_if _label)
1960  # Needs to be a macro to allow this indirection
1961  if(${ARGN})
1962    list(APPEND _items "${_label}")
1963  endif()
1964endmacro()
1965
1966# NTLM support requires crypto functions from various SSL libs.
1967# These conditions must match those in lib/curl_setup.h.
1968if(CURL_ENABLE_NTLM AND
1969   ((USE_OPENSSL AND HAVE_DES_ECB_ENCRYPT) OR
1970    (USE_MBEDTLS AND HAVE_MBEDTLS_DES_CRYPT_ECB) OR
1971    USE_GNUTLS OR
1972    USE_WIN32_CRYPTO OR
1973    (USE_WOLFSSL AND HAVE_WC_DES_ECBENCRYPT)))
1974  set(_use_curl_ntlm_core ON)
1975endif()
1976
1977# Clear list and try to detect available protocols
1978set(_items "")
1979curl_add_if("HTTP"          NOT CURL_DISABLE_HTTP)
1980curl_add_if("HTTPS"         NOT CURL_DISABLE_HTTP AND _ssl_enabled)
1981curl_add_if("FTP"           NOT CURL_DISABLE_FTP)
1982curl_add_if("FTPS"          NOT CURL_DISABLE_FTP AND _ssl_enabled)
1983curl_add_if("FILE"          NOT CURL_DISABLE_FILE)
1984curl_add_if("TELNET"        NOT CURL_DISABLE_TELNET)
1985curl_add_if("LDAP"          NOT CURL_DISABLE_LDAP)
1986# CURL_DISABLE_LDAP implies CURL_DISABLE_LDAPS
1987curl_add_if("LDAPS"         NOT CURL_DISABLE_LDAPS AND
1988                            ((USE_OPENLDAP AND _ssl_enabled) OR
1989                            (NOT USE_OPENLDAP AND HAVE_LDAP_SSL)))
1990curl_add_if("DICT"          NOT CURL_DISABLE_DICT)
1991curl_add_if("TFTP"          NOT CURL_DISABLE_TFTP)
1992curl_add_if("GOPHER"        NOT CURL_DISABLE_GOPHER)
1993curl_add_if("GOPHERS"       NOT CURL_DISABLE_GOPHER AND _ssl_enabled)
1994curl_add_if("POP3"          NOT CURL_DISABLE_POP3)
1995curl_add_if("POP3S"         NOT CURL_DISABLE_POP3 AND _ssl_enabled)
1996curl_add_if("IMAP"          NOT CURL_DISABLE_IMAP)
1997curl_add_if("IMAPS"         NOT CURL_DISABLE_IMAP AND _ssl_enabled)
1998curl_add_if("SMB"           CURL_ENABLE_SMB AND
1999                            _use_curl_ntlm_core AND (SIZEOF_CURL_OFF_T GREATER 4))
2000curl_add_if("SMBS"          CURL_ENABLE_SMB AND _ssl_enabled AND
2001                            _use_curl_ntlm_core AND (SIZEOF_CURL_OFF_T GREATER 4))
2002curl_add_if("SMTP"          NOT CURL_DISABLE_SMTP)
2003curl_add_if("SMTPS"         NOT CURL_DISABLE_SMTP AND _ssl_enabled)
2004curl_add_if("SCP"           USE_LIBSSH2 OR USE_LIBSSH)
2005curl_add_if("SFTP"          USE_LIBSSH2 OR USE_LIBSSH)
2006curl_add_if("IPFS"          NOT CURL_DISABLE_IPFS)
2007curl_add_if("IPNS"          NOT CURL_DISABLE_IPFS)
2008curl_add_if("RTSP"          NOT CURL_DISABLE_RTSP)
2009curl_add_if("MQTT"          NOT CURL_DISABLE_MQTT)
2010curl_add_if("MQTTS"         NOT CURL_DISABLE_MQTT AND _ssl_enabled)
2011curl_add_if("WS"            NOT CURL_DISABLE_WEBSOCKETS)
2012curl_add_if("WSS"           NOT CURL_DISABLE_WEBSOCKETS AND _ssl_enabled)
2013if(_items)
2014  list(SORT _items)
2015endif()
2016set(CURL_SUPPORTED_PROTOCOLS_LIST "${_items}")
2017string(REPLACE ";" " " SUPPORT_PROTOCOLS "${_items}")
2018string(TOLOWER "${SUPPORT_PROTOCOLS}" _support_protocols_lower)
2019message(STATUS "Protocols: ${_support_protocols_lower}")
2020
2021# Clear list and try to detect available features
2022set(_items "")
2023curl_add_if("SSL"           _ssl_enabled)
2024curl_add_if("IPv6"          USE_IPV6)
2025curl_add_if("UnixSockets"   USE_UNIX_SOCKETS)
2026curl_add_if("libz"          HAVE_LIBZ)
2027curl_add_if("brotli"        HAVE_BROTLI)
2028curl_add_if("gsasl"         USE_GSASL)
2029curl_add_if("zstd"          HAVE_ZSTD)
2030curl_add_if("AsynchDNS"     USE_RESOLV_ARES OR USE_RESOLV_THREADED)
2031curl_add_if("asyn-rr"       USE_ARES AND USE_RESOLV_THREADED AND USE_HTTPSRR)
2032curl_add_if("IDN"           (HAVE_LIBIDN2 AND HAVE_IDN2_H) OR
2033                            USE_WIN32_IDN OR
2034                            USE_APPLE_IDN)
2035curl_add_if("Largefile"     (SIZEOF_CURL_OFF_T GREATER 4) AND ((SIZEOF_OFF_T GREATER 4) OR WIN32))
2036curl_add_if("SSPI"          USE_WINDOWS_SSPI)
2037curl_add_if("GSS-API"       HAVE_GSSAPI)
2038curl_add_if("alt-svc"       NOT CURL_DISABLE_ALTSVC)
2039curl_add_if("HSTS"          NOT CURL_DISABLE_HSTS)
2040curl_add_if("SPNEGO"        NOT CURL_DISABLE_NEGOTIATE_AUTH AND
2041                            (HAVE_GSSAPI OR USE_WINDOWS_SSPI))
2042curl_add_if("Kerberos"      NOT CURL_DISABLE_KERBEROS_AUTH AND
2043                            (HAVE_GSSAPI OR USE_WINDOWS_SSPI))
2044curl_add_if("NTLM"          CURL_ENABLE_NTLM AND
2045                            (_use_curl_ntlm_core OR USE_WINDOWS_SSPI))
2046curl_add_if("TLS-SRP"       USE_TLS_SRP)
2047curl_add_if("HTTP2"         USE_NGHTTP2)
2048curl_add_if("HTTP3"         USE_NGTCP2 OR USE_QUICHE)
2049curl_add_if("MultiSSL"      CURL_WITH_MULTI_SSL)
2050curl_add_if("HTTPS-proxy"   NOT CURL_DISABLE_PROXY AND _ssl_enabled AND (USE_OPENSSL OR USE_GNUTLS
2051                            OR USE_SCHANNEL OR USE_RUSTLS OR USE_MBEDTLS OR
2052                            (USE_WOLFSSL AND HAVE_WOLFSSL_BIO_NEW)))
2053curl_add_if("Unicode"       ENABLE_UNICODE)
2054curl_add_if("threadsafe"    HAVE_ATOMIC OR HAVE_THREADS_POSIX OR WIN32)
2055curl_add_if("Debug"         ENABLE_DEBUG)
2056curl_add_if("ECH"           _ssl_enabled AND HAVE_ECH)
2057curl_add_if("HTTPSRR"       _ssl_enabled AND USE_HTTPSRR)
2058curl_add_if("PSL"           USE_LIBPSL)
2059curl_add_if("CAcert"        CURL_CA_EMBED_SET)
2060curl_add_if("SSLS-EXPORT"   _ssl_enabled AND USE_SSLS_EXPORT)
2061curl_add_if("AppleSecTrust" USE_APPLE_SECTRUST AND _ssl_enabled AND (USE_OPENSSL OR USE_GNUTLS))
2062curl_add_if("NativeCA"      NOT USE_APPLE_SECTRUST AND _ssl_enabled AND CURL_CA_NATIVE)
2063if(_items)
2064  list(SORT _items CASE INSENSITIVE)
2065endif()
2066set(CURL_SUPPORTED_FEATURES_LIST "${_items}")
2067string(REPLACE ";" " " SUPPORT_FEATURES "${_items}")
2068message(STATUS "Features: ${SUPPORT_FEATURES}")
2069
2070# Clear list and collect SSL backends
2071set(_items "")
2072curl_add_if("Schannel"         _ssl_enabled AND USE_SCHANNEL)
2073curl_add_if("${_openssl}"      _ssl_enabled AND USE_OPENSSL)
2074curl_add_if("mbedTLS"          _ssl_enabled AND USE_MBEDTLS)
2075curl_add_if("wolfSSL"          _ssl_enabled AND USE_WOLFSSL)
2076curl_add_if("GnuTLS"           _ssl_enabled AND USE_GNUTLS)
2077curl_add_if("Rustls"           _ssl_enabled AND USE_RUSTLS)
2078
2079if(_items)
2080  list(SORT _items CASE INSENSITIVE)
2081endif()
2082string(REPLACE ";" " " SSL_BACKENDS "${_items}")
2083message(STATUS "Enabled SSL backends: ${SSL_BACKENDS}")
2084if(CURL_DEFAULT_SSL_BACKEND)
2085  message(STATUS "Default SSL backend: ${CURL_DEFAULT_SSL_BACKEND}")
2086endif()
2087
2088if(NOT CURL_DISABLE_INSTALL)
2089
2090  # curl-config needs the following options to be set.
2091  set(CC                      "${CMAKE_C_COMPILER}")
2092  set(CONFIGURE_OPTIONS       "")
2093  set(CURLVERSION             "${_curl_version}")
2094  set(VERSIONNUM              "${_curl_version_num}")
2095  set(prefix                  "${CMAKE_INSTALL_PREFIX}")
2096  set(exec_prefix             "\${prefix}")
2097  if(IS_ABSOLUTE ${CMAKE_INSTALL_INCLUDEDIR})
2098    set(includedir            "${CMAKE_INSTALL_INCLUDEDIR}")
2099  else()
2100    set(includedir            "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
2101  endif()
2102  if(IS_ABSOLUTE ${CMAKE_INSTALL_LIBDIR})
2103    set(libdir                "${CMAKE_INSTALL_LIBDIR}")
2104  else()
2105    set(libdir                "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
2106  endif()
2107  # "a" (Linux) or "lib" (Windows)
2108  string(REPLACE "." "" libext "${CMAKE_STATIC_LIBRARY_SUFFIX}")
2109
2110  set(_ldflags "")
2111  set(LIBCURL_PC_LIBS_PRIVATE "")
2112
2113  # Filter CMAKE_SHARED_LINKER_FLAGS for libs and libpaths
2114  string(STRIP "${CMAKE_SHARED_LINKER_FLAGS}" _custom_ldflags)
2115  string(REGEX REPLACE " +-([^ \\t;]*)" ";-\\1" _custom_ldflags "${_custom_ldflags}")
2116
2117  set(_custom_libs "")
2118  set(_custom_libdirs "")
2119  foreach(_flag IN LISTS _custom_ldflags)
2120    if(_flag MATCHES "^-l")
2121      string(REGEX REPLACE "^-l" "" _flag "${_flag}")
2122      list(APPEND _custom_libs "${_flag}")
2123    elseif(_flag MATCHES "^-framework|^-F")
2124      list(APPEND _custom_libs "${_flag}")
2125    elseif(_flag MATCHES "^-L")
2126      string(REGEX REPLACE "^-L" "" _flag "${_flag}")
2127      list(APPEND _custom_libdirs "${_flag}")
2128    elseif(_flag MATCHES "^--library-path=")
2129      string(REGEX REPLACE "^--library-path=" "" _flag "${_flag}")
2130      list(APPEND _custom_libdirs "${_flag}")
2131    endif()
2132  endforeach()
2133
2134  # Avoid getting unnecessary -L options for known system directories.
2135  set(_sys_libdirs "${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}")
2136  foreach(_libdir IN LISTS CMAKE_SYSTEM_PREFIX_PATH)
2137    if(_libdir MATCHES "/$")
2138      string(APPEND _libdir "lib")
2139    else()
2140      string(APPEND _libdir "/lib")
2141    endif()
2142    if(IS_DIRECTORY "${_libdir}")
2143      list(APPEND _sys_libdirs "${_libdir}")
2144    endif()
2145    if(DEFINED CMAKE_LIBRARY_ARCHITECTURE)
2146      string(APPEND _libdir "/${CMAKE_LIBRARY_ARCHITECTURE}")
2147      if(IS_DIRECTORY "${_libdir}")
2148        list(APPEND _sys_libdirs "${_libdir}")
2149      endif()
2150    endif()
2151  endforeach()
2152
2153  set(_implicit_libs "")
2154  if(NOT MINGW AND NOT UNIX)
2155    set(_implicit_libs "${CMAKE_C_IMPLICIT_LINK_LIBRARIES}")
2156  endif()
2157
2158  set(_explicit_libdirs "")
2159  set(LIBCURL_PC_REQUIRES_PRIVATE "")
2160  set(LIBCURL_PC_LIBS_PRIVATE_LIST "")
2161  foreach(_lib IN LISTS CURL_LIBS _custom_libs _implicit_libs)
2162    if(TARGET "${_lib}")
2163      set(_explicit_libs "")
2164      get_target_property(_imported "${_lib}" IMPORTED)
2165      if(NOT _imported)
2166        # Reading the LOCATION property on non-imported target does error out.
2167        # Assume the user does not need this information in the .pc file.
2168        continue()
2169      endif()
2170      set(_libdirs "")
2171      set(_libs "")
2172      curl_collect_target_link_options("${_lib}")  # look into the target recursively
2173      list(APPEND _explicit_libdirs ${_libdirs})
2174      list(APPEND _explicit_libs ${_libs})
2175      if(NOT _libs AND NOT _libdirs AND NOT _lib STREQUAL Threads::Threads)
2176        message(WARNING "Bad lib in library list: ${_lib}")
2177      endif()
2178      if(_lib STREQUAL OpenSSL::SSL AND NOT HAVE_BORINGSSL)  # BoringSSL does not provide openssl.pc
2179        set(_modules "openssl")
2180      elseif(_lib STREQUAL ZLIB::ZLIB)
2181        set(_modules "zlib")
2182      else()
2183        get_target_property(_modules "${_lib}" INTERFACE_LIBCURL_PC_MODULES)
2184      endif()
2185      if(_modules)
2186        list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "${_modules}")
2187      endif()
2188
2189      foreach(_lib IN LISTS _explicit_libs)
2190        if(_lib MATCHES "/")
2191          # This gets a bit more complex, because we want to specify the
2192          # directory separately, and only once per directory
2193          if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
2194            cmake_path(GET _lib PARENT_PATH _libdir)
2195            cmake_path(GET _lib STEM _libname)
2196          else()
2197            get_filename_component(_libdir "${_lib}" DIRECTORY)
2198            get_filename_component(_libname "${_lib}" NAME_WE)
2199          endif()
2200          if(_libname MATCHES "^lib")
2201            if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
2202              cmake_path(SET _libdir NORMALIZE "${_libdir}")
2203            endif()
2204            if(NOT _libdir IN_LIST _sys_libdirs)
2205              list(APPEND _ldflags "-L${_libdir}")
2206            endif()
2207            string(REGEX REPLACE "^lib" "" _libname "${_libname}")
2208            list(APPEND LIBCURL_PC_LIBS_PRIVATE "-l${_libname}")
2209            list(APPEND LIBCURL_PC_LIBS_PRIVATE_LIST "${_lib}")
2210          else()
2211            list(APPEND LIBCURL_PC_LIBS_PRIVATE "${_lib}")
2212            list(APPEND LIBCURL_PC_LIBS_PRIVATE_LIST "${_lib}")
2213          endif()
2214        else()
2215          list(APPEND LIBCURL_PC_LIBS_PRIVATE "-l${_lib}")
2216          list(APPEND LIBCURL_PC_LIBS_PRIVATE_LIST "${_lib}")
2217        endif()
2218      endforeach()
2219    elseif(_lib MATCHES "^-")  # '-framework <name>'
2220      list(APPEND _ldflags "${_lib}")
2221      list(APPEND LIBCURL_PC_LIBS_PRIVATE_LIST "${_lib}")
2222    else()
2223      list(APPEND LIBCURL_PC_LIBS_PRIVATE "-l${_lib}")
2224      list(APPEND LIBCURL_PC_LIBS_PRIVATE_LIST "${_lib}")
2225    endif()
2226  endforeach()
2227
2228  foreach(_libdir IN LISTS _custom_libdirs _explicit_libdirs)
2229    if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
2230      cmake_path(SET _libdir NORMALIZE "${_libdir}")
2231    endif()
2232    if(NOT _libdir IN_LIST _sys_libdirs)
2233      list(APPEND _ldflags "-L${_libdir}")
2234    endif()
2235  endforeach()
2236
2237  list(REMOVE_DUPLICATES _ldflags)
2238
2239  if(LIBCURL_PC_REQUIRES_PRIVATE)
2240    list(REMOVE_DUPLICATES LIBCURL_PC_REQUIRES_PRIVATE)
2241    string(REPLACE ";" "," LIBCURL_PC_REQUIRES_PRIVATE "${LIBCURL_PC_REQUIRES_PRIVATE}")
2242  endif()
2243  if(LIBCURL_PC_LIBS_PRIVATE)
2244    string(REPLACE ";" " " LIBCURL_PC_LIBS_PRIVATE "${LIBCURL_PC_LIBS_PRIVATE}")
2245  endif()
2246  if(_ldflags)
2247    list(REMOVE_DUPLICATES _ldflags)
2248    string(REPLACE ";" " " _ldflags "${_ldflags}")
2249    set(LIBCURL_PC_LDFLAGS_PRIVATE "${_ldflags}")
2250    string(STRIP "${LIBCURL_PC_LDFLAGS_PRIVATE}" LIBCURL_PC_LDFLAGS_PRIVATE)
2251  else()
2252    set(LIBCURL_PC_LDFLAGS_PRIVATE "")
2253  endif()
2254  set(LIBCURL_PC_CFLAGS_PRIVATE "-DCURL_STATICLIB")
2255
2256  # Merge pkg-config private fields into public ones when static-only
2257  if(BUILD_SHARED_LIBS)
2258    set(ENABLE_SHARED       "yes")
2259    set(LIBCURL_PC_REQUIRES "")
2260    set(LIBCURL_PC_LIBS     "")
2261    set(LIBCURL_PC_CFLAGS   "")
2262  else()
2263    set(ENABLE_SHARED       "no")
2264    set(LIBCURL_PC_REQUIRES "${LIBCURL_PC_REQUIRES_PRIVATE}")
2265    set(LIBCURL_PC_LIBS     "${LIBCURL_PC_LIBS_PRIVATE}")
2266    set(LIBCURL_PC_CFLAGS   "${LIBCURL_PC_CFLAGS_PRIVATE}")
2267  endif()
2268  if(BUILD_STATIC_LIBS)
2269    set(ENABLE_STATIC       "yes")
2270  else()
2271    set(ENABLE_STATIC       "no")
2272  endif()
2273
2274  # Generate a "curl-config" matching this config.
2275  # Consumed variables:
2276  #   CC
2277  #   CONFIGURE_OPTIONS
2278  #   CURLVERSION
2279  #   CURL_CA_BUNDLE
2280  #   ENABLE_SHARED
2281  #   ENABLE_STATIC
2282  #   exec_prefix
2283  #   includedir
2284  #   LIBCURL_PC_CFLAGS
2285  #   LIBCURL_PC_LDFLAGS_PRIVATE
2286  #   LIBCURL_PC_LIBS_PRIVATE
2287  #   libdir
2288  #   libext
2289  #   prefix
2290  #   SSL_BACKENDS
2291  #   SUPPORT_FEATURES
2292  #   SUPPORT_PROTOCOLS
2293  #   VERSIONNUM
2294  configure_file(
2295    "${PROJECT_SOURCE_DIR}/curl-config.in"
2296    "${PROJECT_BINARY_DIR}/curl-config" @ONLY)
2297  install(FILES "${PROJECT_BINARY_DIR}/curl-config"
2298    DESTINATION ${CMAKE_INSTALL_BINDIR}
2299    PERMISSIONS
2300      OWNER_READ OWNER_WRITE OWNER_EXECUTE
2301      GROUP_READ GROUP_EXECUTE
2302      WORLD_READ WORLD_EXECUTE)
2303
2304  # Generate a pkg-config file matching this config.
2305  # Consumed variables:
2306  #   CURLVERSION
2307  #   exec_prefix
2308  #   includedir
2309  #   LIBCURL_PC_CFLAGS
2310  #   LIBCURL_PC_CFLAGS_PRIVATE
2311  #   LIBCURL_PC_LDFLAGS_PRIVATE
2312  #   LIBCURL_PC_LIBS
2313  #   LIBCURL_PC_LIBS_PRIVATE
2314  #   LIBCURL_PC_REQUIRES
2315  #   LIBCURL_PC_REQUIRES_PRIVATE
2316  #   libdir
2317  #   prefix
2318  #   SUPPORT_FEATURES
2319  #   SUPPORT_PROTOCOLS
2320  # Documentation:
2321  #   https://people.freedesktop.org/~dbn/pkg-config-guide.html
2322  #   https://manpages.debian.org/unstable/pkgconf/pkg-config.1.en.html
2323  #   https://manpages.debian.org/unstable/pkg-config/pkg-config.1.en.html
2324  #   https://www.msys2.org/docs/pkgconfig/
2325  configure_file(
2326    "${PROJECT_SOURCE_DIR}/libcurl.pc.in"
2327    "${PROJECT_BINARY_DIR}/libcurl.pc" @ONLY)
2328  install(FILES "${PROJECT_BINARY_DIR}/libcurl.pc"
2329    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
2330
2331  # Install headers
2332  install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/curl"
2333    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
2334    FILES_MATCHING PATTERN "*.h")
2335
2336  include(CMakePackageConfigHelpers)
2337  write_basic_package_version_file("${_version_config}"
2338    VERSION ${_curl_version}
2339    COMPATIBILITY SameMajorVersion)
2340  file(READ "${_version_config}" _generated_version_config)
2341  file(WRITE "${_version_config}" "
2342    if(NOT PACKAGE_FIND_VERSION_RANGE AND PACKAGE_FIND_VERSION_MAJOR STREQUAL \"7\")
2343      # Version 8 satisfies version 7... requirements
2344      set(PACKAGE_FIND_VERSION_MAJOR 8)
2345      set(PACKAGE_FIND_VERSION_COUNT 1)
2346    endif()
2347    ${_generated_version_config}")
2348
2349  # Consumed custom variables:
2350  #   CMAKE_MINIMUM_REQUIRED_VERSION
2351  #   CURLVERSION
2352  #   LIBCURL_PC_LIBS_PRIVATE_LIST
2353  #   LIB_NAME
2354  #   LIB_SELECTED
2355  #   LIB_STATIC
2356  #   TARGETS_EXPORT_NAME
2357  #   CURL_SUPPORTED_FEATURES_LIST
2358  #   CURL_SUPPORTED_PROTOCOLS_LIST
2359  #   CURL_USE_CMAKECONFIG
2360  #   CURL_USE_PKGCONFIG
2361  #   HAVE_BROTLI
2362  #   HAVE_GSSAPI
2363  #   HAVE_LIBIDN2
2364  #   HAVE_LIBZ ZLIB_VERSION_MAJOR
2365  #   HAVE_THREADS_POSIX
2366  #   HAVE_THREADS_POSIX_BORINGSSL
2367  #   HAVE_ZSTD
2368  #   USE_ARES
2369  #   USE_BACKTRACE
2370  #   USE_GNUTLS
2371  #   USE_GSASL
2372  #   USE_LIBPSL
2373  #   USE_LIBSSH
2374  #   USE_LIBSSH2
2375  #   USE_LIBUV
2376  #   USE_MBEDTLS
2377  #   USE_NGHTTP2
2378  #   USE_NGHTTP3
2379  #   USE_NGTCP2 NGTCP2_CRYPTO_BACKEND
2380  #   USE_OPENSSL OPENSSL_VERSION_MAJOR
2381  #   USE_QUICHE
2382  #   USE_RUSTLS
2383  #   USE_WIN32_LDAP CURL_DISABLE_LDAP
2384  #   USE_WOLFSSL
2385  configure_package_config_file("CMake/curl-config.in.cmake"
2386    "${_project_config}"
2387    INSTALL_DESTINATION ${_install_cmake_dir}
2388    PATH_VARS CMAKE_INSTALL_INCLUDEDIR)
2389
2390  if(CURL_ENABLE_EXPORT_TARGET)
2391    install(EXPORT "${TARGETS_EXPORT_NAME}"
2392      NAMESPACE "${PROJECT_NAME}::"
2393      DESTINATION ${_install_cmake_dir})
2394  endif()
2395
2396  install(
2397    FILES
2398      ${_version_config}
2399      ${_project_config}
2400      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindBrotli.cmake"
2401      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindCares.cmake"
2402      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindGSS.cmake"
2403      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindGnuTLS.cmake"
2404      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLDAP.cmake"
2405      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibbacktrace.cmake"
2406      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibgsasl.cmake"
2407      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibidn2.cmake"
2408      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibpsl.cmake"
2409      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibssh.cmake"
2410      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibssh2.cmake"
2411      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindLibuv.cmake"
2412      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindMbedTLS.cmake"
2413      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindNGHTTP2.cmake"
2414      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindNGHTTP3.cmake"
2415      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindNGTCP2.cmake"
2416      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindNettle.cmake"
2417      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindQuiche.cmake"
2418      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindRustls.cmake"
2419      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindWolfSSL.cmake"
2420      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/FindZstd.cmake"
2421    DESTINATION ${_install_cmake_dir})
2422
2423  if(NOT TARGET curl_uninstall)
2424    configure_file(
2425      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/cmake_uninstall.in.cmake"
2426      "${CMAKE_CURRENT_BINARY_DIR}/CMake/cmake_uninstall.cmake"
2427      @ONLY)
2428
2429    add_custom_target(curl_uninstall
2430      COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_BINARY_DIR}/CMake/cmake_uninstall.cmake")
2431  endif()
2432
2433  if(BUILD_CURL_EXE)
2434    install(FILES "${PROJECT_SOURCE_DIR}/scripts/wcurl"
2435      DESTINATION ${CMAKE_INSTALL_BINDIR}
2436      PERMISSIONS
2437        OWNER_READ OWNER_WRITE OWNER_EXECUTE
2438        GROUP_READ GROUP_EXECUTE
2439        WORLD_READ WORLD_EXECUTE)
2440  endif()
2441
2442  # The `-DEV` part is important
2443  string(REGEX REPLACE "([0-9]+\.[0-9]+)\.([0-9]+.*)" "\\2" CPACK_PACKAGE_VERSION_PATCH "${_curl_version}")
2444  set(CPACK_GENERATOR "TGZ")
2445  include(CPack)
2446endif()
2447
2448# Save build info for test runner to pick up and log
2449set(_cmake_sysroot "")
2450if(CMAKE_OSX_SYSROOT)
2451  set(_cmake_sysroot ${CMAKE_OSX_SYSROOT})
2452elseif(CMAKE_SYSROOT)
2453  set(_cmake_sysroot ${CMAKE_SYSROOT})
2454endif()
2455set(_buildinfo "\
2456buildinfo.configure.tool: cmake
2457buildinfo.configure.command: ${CMAKE_COMMAND}
2458buildinfo.configure.version: ${CMAKE_VERSION}
2459buildinfo.configure.args:${_cmake_args}
2460buildinfo.configure.generator: ${CMAKE_GENERATOR}
2461buildinfo.configure.make: ${CMAKE_MAKE_PROGRAM}
2462buildinfo.host.cpu: ${CMAKE_HOST_SYSTEM_PROCESSOR}
2463buildinfo.host.os: ${CMAKE_HOST_SYSTEM_NAME}
2464buildinfo.target.cpu: ${CMAKE_SYSTEM_PROCESSOR}
2465buildinfo.target.os: ${CMAKE_SYSTEM_NAME}
2466buildinfo.target.flags:${_target_flags}
2467buildinfo.compiler: ${CMAKE_C_COMPILER_ID}
2468buildinfo.compiler.version: ${CMAKE_C_COMPILER_VERSION}
2469buildinfo.sysroot: ${_cmake_sysroot}
2470")
2471file(WRITE "${PROJECT_BINARY_DIR}/buildinfo.txt" "# This is a generated file.  Do not edit.\n${_buildinfo}")
2472if(NOT "$ENV{CURL_BUILDINFO}$ENV{CURL_CI}$ENV{CI}" STREQUAL "")
2473  message(STATUS "\n${_buildinfo}")
2474endif()