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