Add files using upload-large-folder tool

local-test-curl-delta-01/afc-curl/CHANGES.md

@@ -0,0 +1,12 @@
+<!--
+Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+
+SPDX-License-Identifier: curl
+-->
+
+In a release tarball, check the RELEASES-NOTES file for what was done in the
+most recent release. In a git check-out, that file mentions changes that have
+been done since the previous release.
+
+See the online [changelog](https://curl.se/changes.html) for the edited and
+human readable version of what has changed in different curl releases.

local-test-curl-delta-01/afc-curl/CMakeLists.txt

@@ -0,0 +1,2355 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+###########################################################################
+# by Tetetest and Sukender (Benoit Neil)
+
+# Note: By default this CMake build script detects the version of some
+# dependencies using `check_symbol_exists`. Those checks do not work in
+# the case that both CURL and its dependency are included as sub-projects
+# in a larger build using `FetchContent`. To support that case, additional
+# variables may be defined by the parent project, ideally in the "extra"
+# find package redirect file:
+# https://cmake.org/cmake/help/latest/module/FetchContent.html#integrating-with-find-package
+#
+# The following variables are available:
+#   HAVE_SSL_SET0_WBIO: `SSL_set0_wbio` present in OpenSSL/wolfSSL
+#   HAVE_OPENSSL_SRP: `SSL_CTX_set_srp_username` present in OpenSSL/wolfSSL
+#   HAVE_GNUTLS_SRP: `gnutls_srp_verifier` present in GnuTLS
+#   HAVE_SSL_CTX_SET_QUIC_METHOD: `SSL_CTX_set_quic_method` present in OpenSSL/wolfSSL
+#   HAVE_QUICHE_CONN_SET_QLOG_FD: `quiche_conn_set_qlog_fd` present in quiche
+#   HAVE_ECH: ECH API checks for OpenSSL, BoringSSL or wolfSSL
+#
+# For each of the above variables, if the variable is DEFINED (either
+# to ON or OFF), the symbol detection is skipped.  If the variable is
+# NOT DEFINED, the symbol detection is performed.
+
+cmake_minimum_required(VERSION 3.7...3.16 FATAL_ERROR)
+message(STATUS "Using CMake version ${CMAKE_VERSION}")
+
+# Collect command-line arguments for buildinfo.txt.
+# Must reside at the top of the script to work as expected.
+set(_cmake_args "")
+if(NOT "$ENV{CURL_BUILDINFO}$ENV{CURL_CI}$ENV{CI}" STREQUAL "")
+  get_cmake_property(_cache_vars CACHE_VARIABLES)
+  foreach(_cache_var IN ITEMS ${_cache_vars})
+    get_property(_cache_var_helpstring CACHE ${_cache_var} PROPERTY HELPSTRING)
+    if(_cache_var_helpstring STREQUAL "No help, variable specified on the command line.")
+      get_property(_cache_var_type CACHE ${_cache_var} PROPERTY TYPE)
+      get_property(_cache_var_value CACHE ${_cache_var} PROPERTY VALUE)
+      if(_cache_var_type STREQUAL "UNINITIALIZED")
+        set(_cache_var_type)
+      else()
+        set(_cache_var_type ":${_cache_var_type}")
+      endif()
+      set(_cmake_args "${_cmake_args} -D${_cache_var}${_cache_var_type}=\"${_cache_var_value}\"")
+    endif()
+  endforeach()
+endif()
+
+function(curl_dumpvars)  # Dump all defined variables with their values
+  message("::group::CMake Variable Dump")
+  get_cmake_property(_vars VARIABLES)
+  foreach(_var ${_vars})
+    message("${_var} = ${${_var}}")
+  endforeach()
+  message("::endgroup::")
+endfunction()
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake;${CMAKE_MODULE_PATH}")
+include(Utilities)
+include(Macros)
+include(CMakeDependentOption)
+include(CheckCCompilerFlag)
+
+file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/curl/curlver.h" _curl_version_h_contents REGEX "#define LIBCURL_VERSION( |_NUM )")
+string(REGEX MATCH "#define LIBCURL_VERSION \"[^\"]*" _curl_version ${_curl_version_h_contents})
+string(REGEX REPLACE "[^\"]+\"" "" _curl_version ${_curl_version})
+string(REGEX MATCH "#define LIBCURL_VERSION_NUM 0x[0-9a-fA-F]+" _curl_version_num ${_curl_version_h_contents})
+string(REGEX REPLACE "[^0]+0x" "" _curl_version_num ${_curl_version_num})
+unset(_curl_version_h_contents)
+
+message(STATUS "curl version=[${_curl_version}]")
+
+string(REGEX REPLACE "([0-9]+\.[0-9]+\.[0-9]+).+" "\\1" _curl_version_sem "${_curl_version}")
+project(CURL
+  VERSION "${_curl_version_sem}"
+  LANGUAGES C)
+
+unset(_target_flags)
+if(APPLE)
+  set(_target_flags "${_target_flags} APPLE")
+endif()
+if(UNIX)
+  set(_target_flags "${_target_flags} UNIX")
+endif()
+if(BSD)
+  set(_target_flags "${_target_flags} BSD")
+endif()
+if(WIN32)
+  set(_target_flags "${_target_flags} WIN32")
+endif()
+if(WINDOWS_STORE)
+  set(_target_flags "${_target_flags} UWP")
+endif()
+if(CYGWIN)
+  set(_target_flags "${_target_flags} CYGWIN")
+endif()
+if(MSYS)
+  set(_target_flags "${_target_flags} MSYS")
+endif()
+if(CMAKE_COMPILER_IS_GNUCC)
+  set(_target_flags "${_target_flags} GCC")
+endif()
+if(MINGW)
+  set(_target_flags "${_target_flags} MINGW")
+endif()
+if(MSVC)
+  set(_target_flags "${_target_flags} MSVC")
+endif()
+if(VCPKG_TOOLCHAIN)
+  set(_target_flags "${_target_flags} VCPKG")
+endif()
+if(CMAKE_CROSSCOMPILING)
+  set(_target_flags "${_target_flags} CROSS")
+endif()
+message(STATUS "CMake platform flags:${_target_flags}")
+
+if(CMAKE_CROSSCOMPILING)
+  message(STATUS "Cross-compiling: "
+    "${CMAKE_HOST_SYSTEM_NAME}/${CMAKE_HOST_SYSTEM_PROCESSOR} -> "
+    "${CMAKE_SYSTEM_NAME}/${CMAKE_SYSTEM_PROCESSOR}")
+endif()
+
+if(CMAKE_C_COMPILER_TARGET)
+  set(CURL_OS "\"${CMAKE_C_COMPILER_TARGET}\"")
+else()
+  set(CURL_OS "\"${CMAKE_SYSTEM_NAME}\"")
+endif()
+
+include_directories("${PROJECT_SOURCE_DIR}/include")
+
+if(NOT DEFINED CMAKE_UNITY_BUILD_BATCH_SIZE)
+  set(CMAKE_UNITY_BUILD_BATCH_SIZE 0)
+endif()
+
+# Having CMAKE_TRY_COMPILE_TARGET_TYPE set to STATIC_LIBRARY breaks certain
+# 'check_function_exists()' detections (possibly more), by detecting
+# non-existing features. This happens by default when using 'ios.toolchain.cmake'.
+# Work it around by setting this value to `EXECUTABLE`.
+if(CMAKE_TRY_COMPILE_TARGET_TYPE STREQUAL "STATIC_LIBRARY")
+  message(STATUS "CMAKE_TRY_COMPILE_TARGET_TYPE was found set to STATIC_LIBRARY. "
+    "Overriding with EXECUTABLE for feature detections to work.")
+  set(_cmake_try_compile_target_type_save ${CMAKE_TRY_COMPILE_TARGET_TYPE})
+  set(CMAKE_TRY_COMPILE_TARGET_TYPE "EXECUTABLE")
+endif()
+
+option(CURL_WERROR "Turn compiler warnings into errors" OFF)
+option(PICKY_COMPILER "Enable picky compiler options" ON)
+option(BUILD_CURL_EXE "Build curl executable" ON)
+option(BUILD_SHARED_LIBS "Build shared libraries" ON)
+option(BUILD_STATIC_LIBS "Build static libraries" OFF)
+option(BUILD_STATIC_CURL "Build curl executable with static libcurl" OFF)
+option(ENABLE_ARES "Enable c-ares support" OFF)
+option(CURL_DISABLE_INSTALL "Disable installation targets" OFF)
+
+if(WIN32)
+  option(CURL_STATIC_CRT "Build libcurl with static CRT with MSVC (/MT)" OFF)
+  if(CURL_STATIC_CRT AND MSVC)
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT")
+    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd")
+  endif()
+
+  option(ENABLE_UNICODE "Use the Unicode version of the Windows API functions" OFF)
+  if(WINDOWS_STORE)
+    set(ENABLE_UNICODE ON)
+  endif()
+  if(ENABLE_UNICODE)
+    add_definitions("-DUNICODE" "-D_UNICODE")
+    if(MINGW)
+      add_compile_options("-municode")
+    endif()
+  endif()
+
+  list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DWIN32_LEAN_AND_MEAN")  # Apply to all feature checks
+
+  set(CURL_TARGET_WINDOWS_VERSION "" CACHE STRING "Minimum target Windows version as hex string")
+  if(CURL_TARGET_WINDOWS_VERSION)
+    add_definitions("-D_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION}")
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_WIN32_WINNT=${CURL_TARGET_WINDOWS_VERSION}")  # Apply to all feature checks
+  endif()
+
+  # Detect actual value of _WIN32_WINNT and store as HAVE_WIN32_WINNT
+  curl_internal_test(HAVE_WIN32_WINNT)
+  if(HAVE_WIN32_WINNT)
+    string(REGEX MATCH ".*_WIN32_WINNT=0x[0-9a-fA-F]+" CURL_TEST_OUTPUT "${CURL_TEST_OUTPUT}")
+    string(REGEX REPLACE ".*_WIN32_WINNT=" "" CURL_TEST_OUTPUT "${CURL_TEST_OUTPUT}")
+    string(REGEX REPLACE "0x([0-9a-f][0-9a-f][0-9a-f])$" "0x0\\1" CURL_TEST_OUTPUT "${CURL_TEST_OUTPUT}")  # pad to 4 digits
+    string(TOLOWER "${CURL_TEST_OUTPUT}" HAVE_WIN32_WINNT)
+    message(STATUS "Found _WIN32_WINNT=${HAVE_WIN32_WINNT}")
+  endif()
+  # Avoid storing HAVE_WIN32_WINNT in CMake cache
+  unset(HAVE_WIN32_WINNT CACHE)
+endif()
+option(CURL_LTO "Enable compiler Link Time Optimizations" OFF)
+
+cmake_dependent_option(ENABLE_THREADED_RESOLVER "Enable threaded DNS lookup"
+  ON "NOT ENABLE_ARES"
+  OFF)
+
+include(PickyWarnings)
+
+if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_GNU_SOURCE")  # Required for sendmmsg()
+endif()
+
+option(ENABLE_DEBUG "Enable curl debug features (for developing curl itself)" OFF)
+if(ENABLE_DEBUG)
+  message(WARNING "This curl build is Debug-enabled, do not use in production.")
+endif()
+option(ENABLE_CURLDEBUG "Enable TrackMemory debug feature" ${ENABLE_DEBUG})
+
+if(MSVC)
+  set(ENABLE_CURLDEBUG OFF)  # FIXME: TrackMemory + MSVC fails test 558 and 1330. Tested with static build, Debug mode.
+endif()
+
+if(ENABLE_DEBUG)
+  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "DEBUGBUILD")
+endif()
+
+if(ENABLE_CURLDEBUG)
+  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "CURLDEBUG")
+endif()
+
+# For debug libs and exes, add "-d" postfix
+if(NOT DEFINED CMAKE_DEBUG_POSTFIX)
+  set(CMAKE_DEBUG_POSTFIX "-d")
+endif()
+
+set(LIB_STATIC "libcurl_static")
+set(LIB_SHARED "libcurl_shared")
+
+if(NOT BUILD_SHARED_LIBS AND NOT BUILD_STATIC_LIBS)
+  set(BUILD_STATIC_LIBS ON)
+endif()
+if(NOT BUILD_STATIC_CURL AND NOT BUILD_SHARED_LIBS)
+  set(BUILD_STATIC_CURL ON)
+elseif(BUILD_STATIC_CURL AND NOT BUILD_STATIC_LIBS)
+  set(BUILD_STATIC_CURL OFF)
+endif()
+
+# Lib flavour selected for curl tool
+if(BUILD_STATIC_CURL)
+  set(LIB_SELECTED_FOR_EXE ${LIB_STATIC})
+else()
+  set(LIB_SELECTED_FOR_EXE ${LIB_SHARED})
+endif()
+
+# Lib flavour selected for example and test programs.
+if(BUILD_SHARED_LIBS)
+  set(LIB_SELECTED ${LIB_SHARED})
+else()
+  set(LIB_SELECTED ${LIB_STATIC})
+endif()
+
+# Override to force-disable or force-enable the use of pkg-config.
+if(UNIX OR VCPKG_TOOLCHAIN OR (MINGW AND NOT CMAKE_CROSSCOMPILING))  # Keep in sync with CMake/curl-config.cmake.in
+  set(_curl_use_pkgconfig_default ON)
+else()
+  set(_curl_use_pkgconfig_default OFF)
+endif()
+option(CURL_USE_PKGCONFIG "Enable pkg-config to detect dependencies" ${_curl_use_pkgconfig_default})
+
+# Initialize variables collecting dependency libs, paths, pkg-config names.
+set(CURL_LIBS "")
+set(CURL_LIBDIRS "")
+set(LIBCURL_PC_REQUIRES_PRIVATE "")
+
+if(ENABLE_ARES)
+  set(USE_ARES 1)
+  find_package(Cares REQUIRED)
+  list(APPEND CURL_LIBS ${CARES_LIBRARIES})
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libcares")
+  add_definitions("-DCARES_NO_DEPRECATED")  # Ignore c-ares deprecation warnings
+endif()
+
+include(CurlSymbolHiding)
+
+option(CURL_ENABLE_EXPORT_TARGET "Enable CMake export target" ON)
+mark_as_advanced(CURL_ENABLE_EXPORT_TARGET)
+
+option(CURL_DISABLE_ALTSVC "Disable alt-svc support" OFF)
+mark_as_advanced(CURL_DISABLE_ALTSVC)
+option(CURL_DISABLE_SRP "Disable TLS-SRP support" OFF)
+mark_as_advanced(CURL_DISABLE_SRP)
+option(CURL_DISABLE_COOKIES "Disable cookies support" OFF)
+mark_as_advanced(CURL_DISABLE_COOKIES)
+option(CURL_DISABLE_BASIC_AUTH "Disable Basic authentication" OFF)
+mark_as_advanced(CURL_DISABLE_BASIC_AUTH)
+option(CURL_DISABLE_BEARER_AUTH "Disable Bearer authentication" OFF)
+mark_as_advanced(CURL_DISABLE_BEARER_AUTH)
+option(CURL_DISABLE_DIGEST_AUTH "Disable Digest authentication" OFF)
+mark_as_advanced(CURL_DISABLE_DIGEST_AUTH)
+option(CURL_DISABLE_KERBEROS_AUTH "Disable Kerberos authentication" OFF)
+mark_as_advanced(CURL_DISABLE_KERBEROS_AUTH)
+option(CURL_DISABLE_NEGOTIATE_AUTH "Disable negotiate authentication" OFF)
+mark_as_advanced(CURL_DISABLE_NEGOTIATE_AUTH)
+option(CURL_DISABLE_AWS "Disable aws-sigv4" OFF)
+mark_as_advanced(CURL_DISABLE_AWS)
+option(CURL_DISABLE_DICT "Disable DICT" OFF)
+mark_as_advanced(CURL_DISABLE_DICT)
+option(CURL_DISABLE_DOH "Disable DNS-over-HTTPS" OFF)
+mark_as_advanced(CURL_DISABLE_DOH)
+option(CURL_DISABLE_FILE "Disable FILE" OFF)
+mark_as_advanced(CURL_DISABLE_FILE)
+option(CURL_DISABLE_FTP "Disable FTP" OFF)
+mark_as_advanced(CURL_DISABLE_FTP)
+option(CURL_DISABLE_GETOPTIONS "Disable curl_easy_options API for existing options to curl_easy_setopt" OFF)
+mark_as_advanced(CURL_DISABLE_GETOPTIONS)
+option(CURL_DISABLE_GOPHER "Disable Gopher" OFF)
+mark_as_advanced(CURL_DISABLE_GOPHER)
+option(CURL_DISABLE_HEADERS_API "Disable headers-api support" OFF)
+mark_as_advanced(CURL_DISABLE_HEADERS_API)
+option(CURL_DISABLE_HSTS "Disable HSTS support" OFF)
+mark_as_advanced(CURL_DISABLE_HSTS)
+option(CURL_DISABLE_HTTP "Disable HTTP" OFF)
+mark_as_advanced(CURL_DISABLE_HTTP)
+option(CURL_DISABLE_HTTP_AUTH "Disable all HTTP authentication methods" OFF)
+mark_as_advanced(CURL_DISABLE_HTTP_AUTH)
+option(CURL_DISABLE_IMAP "Disable IMAP" OFF)
+mark_as_advanced(CURL_DISABLE_IMAP)
+option(CURL_DISABLE_LDAP "Disable LDAP" OFF)
+mark_as_advanced(CURL_DISABLE_LDAP)
+option(CURL_DISABLE_LDAPS "Disable LDAPS" ${CURL_DISABLE_LDAP})
+mark_as_advanced(CURL_DISABLE_LDAPS)
+option(CURL_DISABLE_LIBCURL_OPTION "Disable --libcurl option from the curl tool" OFF)
+mark_as_advanced(CURL_DISABLE_LIBCURL_OPTION)
+option(CURL_DISABLE_MIME "Disable MIME support" OFF)
+mark_as_advanced(CURL_DISABLE_MIME)
+cmake_dependent_option(CURL_DISABLE_FORM_API "Disable form-api"
+  OFF "NOT CURL_DISABLE_MIME"
+  ON)
+mark_as_advanced(CURL_DISABLE_FORM_API)
+option(CURL_DISABLE_MQTT "Disable MQTT" OFF)
+mark_as_advanced(CURL_DISABLE_MQTT)
+option(CURL_DISABLE_BINDLOCAL "Disable local binding support" OFF)
+mark_as_advanced(CURL_DISABLE_BINDLOCAL)
+option(CURL_DISABLE_NETRC "Disable netrc parser" OFF)
+mark_as_advanced(CURL_DISABLE_NETRC)
+option(CURL_DISABLE_NTLM "Disable NTLM support" OFF)
+mark_as_advanced(CURL_DISABLE_NTLM)
+option(CURL_DISABLE_PARSEDATE "Disable date parsing" OFF)
+mark_as_advanced(CURL_DISABLE_PARSEDATE)
+option(CURL_DISABLE_POP3 "Disable POP3" OFF)
+mark_as_advanced(CURL_DISABLE_POP3)
+option(CURL_DISABLE_PROGRESS_METER "Disable built-in progress meter" OFF)
+mark_as_advanced(CURL_DISABLE_PROGRESS_METER)
+option(CURL_DISABLE_PROXY "Disable proxy support" OFF)
+mark_as_advanced(CURL_DISABLE_PROXY)
+option(CURL_DISABLE_IPFS "Disable IPFS" OFF)
+mark_as_advanced(CURL_DISABLE_IPFS)
+option(CURL_DISABLE_RTSP "Disable RTSP" OFF)
+mark_as_advanced(CURL_DISABLE_SHA512_256)
+option(CURL_DISABLE_SHA512_256 "Disable SHA-512/256 hash algorithm" OFF)
+mark_as_advanced(CURL_DISABLE_RTSP)
+option(CURL_DISABLE_SHUFFLE_DNS "Disable shuffle DNS feature" OFF)
+mark_as_advanced(CURL_DISABLE_SHUFFLE_DNS)
+option(CURL_DISABLE_SMB "Disable SMB" OFF)
+mark_as_advanced(CURL_DISABLE_SMB)
+option(CURL_DISABLE_SMTP "Disable SMTP" OFF)
+mark_as_advanced(CURL_DISABLE_SMTP)
+option(CURL_DISABLE_SOCKETPAIR "Disable use of socketpair for curl_multi_poll" OFF)
+mark_as_advanced(CURL_DISABLE_SOCKETPAIR)
+option(CURL_DISABLE_WEBSOCKETS "Disable WebSocket" OFF)
+mark_as_advanced(CURL_DISABLE_WEBSOCKETS)
+option(CURL_DISABLE_TELNET "Disable Telnet" OFF)
+mark_as_advanced(CURL_DISABLE_TELNET)
+option(CURL_DISABLE_TFTP "Disable TFTP" OFF)
+mark_as_advanced(CURL_DISABLE_TFTP)
+option(CURL_DISABLE_VERBOSE_STRINGS "Disable verbose strings" OFF)
+mark_as_advanced(CURL_DISABLE_VERBOSE_STRINGS)
+
+if(CURL_DISABLE_HTTP)
+  set(CURL_DISABLE_IPFS ON)
+  set(CURL_DISABLE_RTSP ON)
+  set(CURL_DISABLE_ALTSVC ON)
+  set(CURL_DISABLE_HSTS ON)
+endif()
+
+# Corresponds to HTTP_ONLY in lib/curl_setup.h
+option(HTTP_ONLY "Disable all protocols except HTTP (This overrides all CURL_DISABLE_* options)" OFF)
+mark_as_advanced(HTTP_ONLY)
+
+if(HTTP_ONLY)
+  set(CURL_DISABLE_DICT ON)
+  set(CURL_DISABLE_FILE ON)
+  set(CURL_DISABLE_FTP ON)
+  set(CURL_DISABLE_GOPHER ON)
+  set(CURL_DISABLE_IMAP ON)
+  set(CURL_DISABLE_LDAP ON)
+  set(CURL_DISABLE_LDAPS ON)
+  set(CURL_DISABLE_MQTT ON)
+  set(CURL_DISABLE_POP3 ON)
+  set(CURL_DISABLE_IPFS ON)
+  set(CURL_DISABLE_RTSP ON)
+  set(CURL_DISABLE_SMB ON)
+  set(CURL_DISABLE_SMTP ON)
+  set(CURL_DISABLE_TELNET ON)
+  set(CURL_DISABLE_TFTP ON)
+endif()
+
+if(WINDOWS_STORE)
+  set(CURL_DISABLE_TELNET ON)  # telnet code needs fixing to compile for UWP.
+endif()
+
+option(ENABLE_IPV6 "Enable IPv6 support" ON)
+mark_as_advanced(ENABLE_IPV6)
+if(ENABLE_IPV6 AND NOT WIN32)
+  include(CheckStructHasMember)
+  check_struct_has_member("struct sockaddr_in6" "sin6_addr" "netinet/in.h" HAVE_SOCKADDR_IN6_SIN6_ADDR)
+  check_struct_has_member("struct sockaddr_in6" "sin6_scope_id" "netinet/in.h" HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)
+  if(NOT HAVE_SOCKADDR_IN6_SIN6_ADDR)
+    message(WARNING "struct sockaddr_in6 not available, disabling IPv6 support")
+    # Force the feature off as this name is used as guard macro...
+    set(ENABLE_IPV6 OFF CACHE BOOL "Enable IPv6 support" FORCE)
+  endif()
+
+  if(APPLE AND NOT ENABLE_ARES)
+    set(_use_core_foundation_and_core_services ON)
+
+    find_library(SYSTEMCONFIGURATION_FRAMEWORK "SystemConfiguration")
+    mark_as_advanced(SYSTEMCONFIGURATION_FRAMEWORK)
+    if(NOT SYSTEMCONFIGURATION_FRAMEWORK)
+      message(FATAL_ERROR "SystemConfiguration framework not found")
+    endif()
+
+    list(APPEND CURL_LIBS "-framework SystemConfiguration")
+  endif()
+endif()
+if(ENABLE_IPV6)
+  set(USE_IPV6 ON)
+endif()
+
+find_package(Perl)
+
+option(BUILD_LIBCURL_DOCS "Build libcurl man pages" ON)
+option(BUILD_MISC_DOCS "Build misc man pages (e.g. curl-config and mk-ca-bundle)" ON)
+option(ENABLE_CURL_MANUAL "Build the man page for curl and enable its -M/--manual option" ON)
+
+if(ENABLE_CURL_MANUAL OR BUILD_LIBCURL_DOCS)
+  if(PERL_FOUND)
+    set(HAVE_MANUAL_TOOLS ON)
+  endif()
+  if(NOT HAVE_MANUAL_TOOLS)
+    message(WARNING "Perl not found. Will not build manuals.")
+  endif()
+endif()
+
+# Disable warnings on Borland to avoid changing 3rd party code.
+if(BORLAND)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w-")
+endif()
+
+# If we are on AIX, do the _ALL_SOURCE magic
+if(CMAKE_SYSTEM_NAME STREQUAL "AIX")
+  add_definitions("-D_ALL_SOURCE")
+endif()
+
+# If we are on Haiku, make sure that the network library is brought in.
+if(CMAKE_SYSTEM_NAME STREQUAL "Haiku")
+  list(APPEND CURL_LIBS "network")
+endif()
+
+# Include all the necessary files for macros
+include(CMakePushCheckState)
+include(CheckFunctionExists)
+include(CheckIncludeFile)
+include(CheckIncludeFiles)
+include(CheckLibraryExists)
+include(CheckSymbolExists)
+include(CheckTypeSize)
+include(CheckCSourceCompiles)
+
+# Preload settings on Windows
+if(WIN32)
+  include("${CMAKE_CURRENT_SOURCE_DIR}/CMake/Platforms/WindowsCache.cmake")
+elseif(APPLE)
+  # Fast-track predictable feature detections
+  set(HAVE_EVENTFD 0)
+  set(HAVE_GETPASS_R 0)
+  set(HAVE_SENDMMSG 0)
+endif()
+
+if(ENABLE_THREADED_RESOLVER)
+  if(WIN32)
+    set(USE_THREADS_WIN32 ON)
+  else()
+    find_package(Threads REQUIRED)
+    set(USE_THREADS_POSIX ${CMAKE_USE_PTHREADS_INIT})
+    set(HAVE_PTHREAD_H ${CMAKE_USE_PTHREADS_INIT})
+    list(APPEND CURL_LIBS ${CMAKE_THREAD_LIBS_INIT})
+  endif()
+endif()
+
+# Check for all needed libraries
+if(NOT WIN32 AND NOT APPLE)
+  check_library_exists("socket" "connect" "" HAVE_LIBSOCKET)
+  if(HAVE_LIBSOCKET)
+    set(CURL_LIBS "socket;${CURL_LIBS}")
+  endif()
+endif()
+
+check_function_exists("gethostname" HAVE_GETHOSTNAME)
+
+if(WIN32)
+  list(APPEND CURL_LIBS "ws2_32" "bcrypt")
+endif()
+
+# Check SSL libraries
+option(CURL_ENABLE_SSL "Enable SSL support" ON)
+
+if(CURL_DEFAULT_SSL_BACKEND)
+  set(_valid_default_ssl_backend FALSE)
+endif()
+
+if(APPLE)
+  cmake_dependent_option(CURL_USE_SECTRANSP "Enable Apple OS native SSL/TLS (Secure Transport)" OFF CURL_ENABLE_SSL OFF)
+endif()
+if(WIN32)
+  cmake_dependent_option(CURL_USE_SCHANNEL "Enable Windows native SSL/TLS (Schannel)" OFF CURL_ENABLE_SSL OFF)
+  option(CURL_WINDOWS_SSPI "Enable SSPI on Windows" ${CURL_USE_SCHANNEL})
+endif()
+cmake_dependent_option(CURL_USE_MBEDTLS "Enable mbedTLS for SSL/TLS" OFF CURL_ENABLE_SSL OFF)
+cmake_dependent_option(CURL_USE_BEARSSL "Enable BearSSL for SSL/TLS" OFF CURL_ENABLE_SSL OFF)
+cmake_dependent_option(CURL_USE_WOLFSSL "Enable wolfSSL for SSL/TLS" OFF CURL_ENABLE_SSL OFF)
+cmake_dependent_option(CURL_USE_GNUTLS "Enable GnuTLS for SSL/TLS" OFF CURL_ENABLE_SSL OFF)
+cmake_dependent_option(CURL_USE_RUSTLS "Enable Rustls for SSL/TLS" OFF CURL_ENABLE_SSL OFF)
+
+if(WIN32 OR
+   CURL_USE_SECTRANSP OR
+   CURL_USE_SCHANNEL OR
+   CURL_USE_MBEDTLS OR
+   CURL_USE_BEARSSL OR
+   CURL_USE_WOLFSSL OR
+   CURL_USE_GNUTLS OR
+   CURL_USE_RUSTLS)
+  set(_openssl_default OFF)
+else()
+  set(_openssl_default ON)
+endif()
+cmake_dependent_option(CURL_USE_OPENSSL "Enable OpenSSL for SSL/TLS" ${_openssl_default} CURL_ENABLE_SSL OFF)
+option(USE_OPENSSL_QUIC "Use OpenSSL and nghttp3 libraries for HTTP/3 support" OFF)
+if(USE_OPENSSL_QUIC AND NOT CURL_USE_OPENSSL)
+  message(WARNING "OpenSSL QUIC has been requested, but without enabling OpenSSL. Will not enable QUIC.")
+  set(USE_OPENSSL_QUIC OFF)
+endif()
+option(CURL_DISABLE_OPENSSL_AUTO_LOAD_CONFIG "Disable automatic loading of OpenSSL configuration" OFF)
+
+count_true(_enabled_ssl_options_count
+  CURL_USE_SCHANNEL
+  CURL_USE_SECTRANSP
+  CURL_USE_OPENSSL
+  CURL_USE_MBEDTLS
+  CURL_USE_BEARSSL
+  CURL_USE_WOLFSSL
+  CURL_USE_GNUTLS
+  CURL_USE_RUSTLS
+)
+if(_enabled_ssl_options_count GREATER 1)
+  set(CURL_WITH_MULTI_SSL ON)
+elseif(_enabled_ssl_options_count EQUAL 0)
+  set(CURL_DISABLE_HSTS ON)
+endif()
+
+if(CURL_USE_SCHANNEL)
+  set(_ssl_enabled ON)
+  set(USE_SCHANNEL ON)  # Windows native SSL/TLS support
+  set(USE_WINDOWS_SSPI ON)  # CURL_USE_SCHANNEL implies CURL_WINDOWS_SSPI
+
+  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "schannel")
+    set(_valid_default_ssl_backend TRUE)
+  endif()
+endif()
+if(CURL_WINDOWS_SSPI)
+  set(USE_WINDOWS_SSPI ON)
+endif()
+
+if(CURL_USE_SECTRANSP)
+  set(_use_core_foundation_and_core_services ON)
+
+  find_library(SECURITY_FRAMEWORK "Security")
+  mark_as_advanced(SECURITY_FRAMEWORK)
+  if(NOT SECURITY_FRAMEWORK)
+    message(FATAL_ERROR "Security framework not found")
+  endif()
+
+  set(_ssl_enabled ON)
+  set(USE_SECTRANSP ON)
+  list(APPEND CURL_LIBS "-framework Security")
+
+  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "secure-transport")
+    set(_valid_default_ssl_backend TRUE)
+  endif()
+
+  message(WARNING "Secure Transport does not support TLS 1.3.")
+endif()
+
+if(_use_core_foundation_and_core_services)
+  find_library(COREFOUNDATION_FRAMEWORK "CoreFoundation")
+  mark_as_advanced(COREFOUNDATION_FRAMEWORK)
+  find_library(CORESERVICES_FRAMEWORK "CoreServices")
+  mark_as_advanced(CORESERVICES_FRAMEWORK)
+
+  if(NOT COREFOUNDATION_FRAMEWORK)
+    message(FATAL_ERROR "CoreFoundation framework not found")
+  endif()
+  if(NOT CORESERVICES_FRAMEWORK)
+    message(FATAL_ERROR "CoreServices framework not found")
+  endif()
+
+  list(APPEND CURL_LIBS "-framework CoreFoundation" "-framework CoreServices")
+endif()
+
+if(CURL_USE_OPENSSL)
+  find_package(OpenSSL REQUIRED)
+  set(_ssl_enabled ON)
+  set(USE_OPENSSL ON)
+
+  # Depend on OpenSSL via imported targets. This allows our dependents to
+  # get our dependencies transitively.
+  list(APPEND CURL_LIBS OpenSSL::SSL OpenSSL::Crypto)
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "openssl")
+
+  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "openssl")
+    set(_valid_default_ssl_backend TRUE)
+  endif()
+  set(_curl_ca_bundle_supported TRUE)
+
+  cmake_push_check_state()
+  set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
+  if(NOT DEFINED HAVE_BORINGSSL)
+    check_symbol_exists("OPENSSL_IS_BORINGSSL" "openssl/base.h" HAVE_BORINGSSL)
+  endif()
+  if(NOT DEFINED HAVE_AWSLC)
+    check_symbol_exists("OPENSSL_IS_AWSLC" "openssl/base.h" HAVE_AWSLC)
+  endif()
+  cmake_pop_check_state()
+endif()
+
+if(CURL_USE_MBEDTLS)
+  find_package(MbedTLS REQUIRED)
+  set(_ssl_enabled ON)
+  set(USE_MBEDTLS ON)
+  list(APPEND CURL_LIBS ${MBEDTLS_LIBRARIES})
+  list(APPEND CURL_LIBDIRS ${MBEDTLS_LIBRARY_DIRS})
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${MBEDTLS_PC_REQUIRES})
+  include_directories(SYSTEM ${MBEDTLS_INCLUDE_DIRS})
+  link_directories(${MBEDTLS_LIBRARY_DIRS})
+  if(MBEDTLS_CFLAGS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MBEDTLS_CFLAGS}")
+  endif()
+
+  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "mbedtls")
+    set(_valid_default_ssl_backend TRUE)
+  endif()
+  set(_curl_ca_bundle_supported TRUE)
+endif()
+
+if(CURL_USE_BEARSSL)
+  find_package(BearSSL REQUIRED)
+  set(_ssl_enabled ON)
+  set(USE_BEARSSL ON)
+  list(APPEND CURL_LIBS ${BEARSSL_LIBRARIES})
+  include_directories(SYSTEM ${BEARSSL_INCLUDE_DIRS})
+
+  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "bearssl")
+    set(_valid_default_ssl_backend TRUE)
+  endif()
+  set(_curl_ca_bundle_supported TRUE)
+
+  message(WARNING "BearSSL does not support TLS 1.3.")
+endif()
+
+if(CURL_USE_WOLFSSL)
+  find_package(WolfSSL REQUIRED)
+  set(_ssl_enabled ON)
+  set(USE_WOLFSSL ON)
+  list(APPEND CURL_LIBS ${WOLFSSL_LIBRARIES})
+  list(APPEND CURL_LIBDIRS ${WOLFSSL_LIBRARY_DIRS})
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "wolfssl")
+  include_directories(SYSTEM ${WOLFSSL_INCLUDE_DIRS})
+  link_directories(${WOLFSSL_LIBRARY_DIRS})
+  if(WOLFSSL_CFLAGS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WOLFSSL_CFLAGS}")
+  endif()
+
+  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "wolfssl")
+    set(_valid_default_ssl_backend TRUE)
+  endif()
+  set(_curl_ca_bundle_supported TRUE)
+endif()
+
+if(CURL_USE_GNUTLS)
+  if(CURL_USE_PKGCONFIG)
+    find_package(PkgConfig QUIET)
+    pkg_check_modules(GNUTLS "gnutls")
+    if(GNUTLS_FOUND)
+      set(GNUTLS_LIBRARIES ${GNUTLS_LINK_LIBRARIES})
+    endif()
+  endif()
+  if(NOT GNUTLS_FOUND)
+    find_package(GnuTLS REQUIRED)
+  endif()
+  find_package(Nettle REQUIRED)
+  set(_ssl_enabled ON)
+  set(USE_GNUTLS ON)
+  list(APPEND CURL_LIBS ${GNUTLS_LIBRARIES} ${NETTLE_LIBRARIES})
+  list(APPEND CURL_LIBDIRS ${NETTLE_LIBRARY_DIRS})
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "gnutls" "nettle")
+  include_directories(SYSTEM ${GNUTLS_INCLUDE_DIRS} ${NETTLE_INCLUDE_DIRS})
+  link_directories(${NETTLE_LIBRARY_DIRS})
+  if(NETTLE_CFLAGS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${NETTLE_CFLAGS}")
+  endif()
+
+  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "gnutls")
+    set(_valid_default_ssl_backend TRUE)
+  endif()
+  set(_curl_ca_bundle_supported TRUE)
+
+  if(NOT DEFINED HAVE_GNUTLS_SRP AND NOT CURL_DISABLE_SRP)
+    cmake_push_check_state()
+    set(CMAKE_REQUIRED_INCLUDES ${GNUTLS_INCLUDE_DIRS})
+    set(CMAKE_REQUIRED_LIBRARIES ${GNUTLS_LIBRARIES})
+    check_symbol_exists("gnutls_srp_verifier" "gnutls/gnutls.h" HAVE_GNUTLS_SRP)
+    cmake_pop_check_state()
+  endif()
+endif()
+
+if(CURL_USE_RUSTLS)
+  find_package(Rustls REQUIRED)
+  set(_ssl_enabled ON)
+  set(USE_RUSTLS ON)
+  list(APPEND CURL_LIBS ${RUSTLS_LIBRARIES})
+  list(APPEND CURL_LIBDIRS ${RUSTLS_LIBRARY_DIRS})
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${RUSTLS_PC_REQUIRES})
+  include_directories(SYSTEM ${RUSTLS_INCLUDE_DIRS})
+  link_directories(${RUSTLS_LIBRARY_DIRS})
+  if(RUSTLS_CFLAGS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${RUSTLS_CFLAGS}")
+  endif()
+
+  if(CURL_DEFAULT_SSL_BACKEND AND CURL_DEFAULT_SSL_BACKEND STREQUAL "rustls")
+    set(_valid_default_ssl_backend TRUE)
+  endif()
+  set(_curl_ca_bundle_supported TRUE)
+endif()
+
+if(CURL_DEFAULT_SSL_BACKEND AND NOT _valid_default_ssl_backend)
+  message(FATAL_ERROR "CURL_DEFAULT_SSL_BACKEND '${CURL_DEFAULT_SSL_BACKEND}' not enabled.")
+endif()
+
+# Keep ZLIB detection after TLS detection,
+# and before calling openssl_check_symbol_exists().
+
+set(HAVE_LIBZ OFF)
+curl_dependency_option(ZLIB)
+if(ZLIB_FOUND)
+  set(HAVE_LIBZ ON)
+
+  # Depend on ZLIB via imported targets. This allows our dependents to
+  # get our dependencies transitively.
+  list(APPEND CURL_LIBS ZLIB::ZLIB)
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "zlib")
+endif()
+
+option(CURL_BROTLI "Use brotli" OFF)
+set(HAVE_BROTLI OFF)
+if(CURL_BROTLI)
+  find_package(Brotli REQUIRED)
+  if(BROTLI_FOUND)
+    set(HAVE_BROTLI ON)
+    list(APPEND CURL_LIBS ${BROTLI_LIBRARIES})
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libbrotlidec")
+    include_directories(SYSTEM ${BROTLI_INCLUDE_DIRS})
+  endif()
+endif()
+
+option(CURL_ZSTD "Use zstd" OFF)
+set(HAVE_ZSTD OFF)
+if(CURL_ZSTD)
+  find_package(Zstd REQUIRED)
+  if(ZSTD_FOUND AND NOT ZSTD_VERSION VERSION_LESS 1.0.0)
+    set(HAVE_ZSTD ON)
+    list(APPEND CURL_LIBS ${ZSTD_LIBRARIES})
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libzstd")
+    include_directories(SYSTEM ${ZSTD_INCLUDE_DIRS})
+  else()
+    message(WARNING "zstd v1.0.0 or newer is required, disabling zstd support.")
+  endif()
+endif()
+
+# Check symbol in an OpenSSL-like TLS backend, or in _extra_libs depending on it.
+macro(openssl_check_symbol_exists _symbol _files _variable _extra_libs)
+  cmake_push_check_state()
+  if(USE_OPENSSL)
+    set(CMAKE_REQUIRED_INCLUDES   "${OPENSSL_INCLUDE_DIR}")
+    set(CMAKE_REQUIRED_LIBRARIES  "${OPENSSL_LIBRARIES}")
+    if(HAVE_LIBZ)
+      list(APPEND CMAKE_REQUIRED_LIBRARIES "${ZLIB_LIBRARIES}")
+    endif()
+    if(WIN32)
+      list(APPEND CMAKE_REQUIRED_LIBRARIES "ws2_32")
+      list(APPEND CMAKE_REQUIRED_LIBRARIES "bcrypt")  # for OpenSSL/LibreSSL
+    endif()
+  elseif(USE_WOLFSSL)
+    set(CMAKE_REQUIRED_INCLUDES   "${WOLFSSL_INCLUDE_DIRS}")
+    set(CMAKE_REQUIRED_LIBRARIES  "${WOLFSSL_LIBRARIES}")
+    curl_required_libpaths("${WOLFSSL_LIBRARY_DIRS}")
+    if(HAVE_LIBZ)
+      list(APPEND CMAKE_REQUIRED_INCLUDES  "${ZLIB_INCLUDE_DIRS}")  # Public wolfSSL headers require zlib headers
+      list(APPEND CMAKE_REQUIRED_LIBRARIES "${ZLIB_LIBRARIES}")
+    endif()
+    if(WIN32)
+      list(APPEND CMAKE_REQUIRED_LIBRARIES "ws2_32" "crypt32")
+    endif()
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DHAVE_UINTPTR_T")  # to pull in stdint.h (as of wolfSSL v5.5.4)
+  endif()
+  list(APPEND CMAKE_REQUIRED_LIBRARIES "${_extra_libs}")
+  check_symbol_exists("${_symbol}" "${_files}" "${_variable}")
+  cmake_pop_check_state()
+endmacro()
+
+# Ensure that the OpenSSL fork actually supports QUIC.
+macro(openssl_check_quic)
+  if(NOT DEFINED HAVE_SSL_CTX_SET_QUIC_METHOD)
+    if(USE_OPENSSL)
+      openssl_check_symbol_exists("SSL_CTX_set_quic_method" "openssl/ssl.h" HAVE_SSL_CTX_SET_QUIC_METHOD "")
+    elseif(USE_WOLFSSL)
+      openssl_check_symbol_exists("wolfSSL_set_quic_method" "wolfssl/options.h;wolfssl/openssl/ssl.h"
+        HAVE_SSL_CTX_SET_QUIC_METHOD "")
+    endif()
+  endif()
+  if(NOT HAVE_SSL_CTX_SET_QUIC_METHOD)
+    message(FATAL_ERROR "QUIC support is missing in OpenSSL fork. Try setting -DOPENSSL_ROOT_DIR")
+  endif()
+endmacro()
+
+if(USE_WOLFSSL)
+  openssl_check_symbol_exists("wolfSSL_DES_ecb_encrypt" "wolfssl/options.h;wolfssl/openssl/des.h" HAVE_WOLFSSL_DES_ECB_ENCRYPT "")
+  openssl_check_symbol_exists("wolfSSL_BIO_new" "wolfssl/options.h;wolfssl/ssl.h" HAVE_WOLFSSL_BIO "")
+  openssl_check_symbol_exists("wolfSSL_BIO_set_shutdown" "wolfssl/options.h;wolfssl/ssl.h" HAVE_WOLFSSL_FULL_BIO "")
+endif()
+
+if(USE_OPENSSL OR USE_WOLFSSL)
+  if(NOT DEFINED HAVE_SSL_SET0_WBIO)
+    openssl_check_symbol_exists("SSL_set0_wbio" "openssl/ssl.h" HAVE_SSL_SET0_WBIO "")
+  endif()
+  if(NOT DEFINED HAVE_OPENSSL_SRP AND NOT CURL_DISABLE_SRP)
+    openssl_check_symbol_exists("SSL_CTX_set_srp_username" "openssl/ssl.h" HAVE_OPENSSL_SRP "")
+  endif()
+endif()
+
+option(USE_HTTPSRR "Enable HTTPS RR support" OFF)
+option(USE_ECH "Enable ECH support" OFF)
+if(USE_ECH)
+  if(USE_OPENSSL OR USE_WOLFSSL)
+    # Be sure that the TLS library actually supports ECH.
+    if(NOT DEFINED HAVE_ECH)
+      if(USE_OPENSSL AND (HAVE_BORINGSSL OR HAVE_AWSLC))
+        openssl_check_symbol_exists("SSL_set1_ech_config_list" "openssl/ssl.h" HAVE_ECH "")
+      elseif(USE_OPENSSL)
+        openssl_check_symbol_exists("SSL_ech_set1_echconfig" "openssl/ech.h" HAVE_ECH "")
+      elseif(USE_WOLFSSL)
+        openssl_check_symbol_exists("wolfSSL_CTX_GenerateEchConfig" "wolfssl/options.h;wolfssl/ssl.h" HAVE_ECH "")
+      endif()
+    endif()
+    if(NOT HAVE_ECH)
+      message(FATAL_ERROR "ECH support missing in OpenSSL/BoringSSL/AWS-LC/wolfSSL")
+    else()
+      message(STATUS "ECH enabled.")
+    endif()
+  else()
+    message(FATAL_ERROR "ECH requires ECH-enablded OpenSSL, BoringSSL, AWS-LC or wolfSSL")
+  endif()
+endif()
+
+option(USE_NGHTTP2 "Use nghttp2 library" ON)
+if(USE_NGHTTP2)
+  find_package(NGHTTP2)
+  if(NGHTTP2_FOUND)
+    include_directories(SYSTEM ${NGHTTP2_INCLUDE_DIRS})
+    list(APPEND CURL_LIBS ${NGHTTP2_LIBRARIES})
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libnghttp2")
+  else()
+    set(USE_NGHTTP2 OFF)
+  endif()
+endif()
+
+option(USE_NGTCP2 "Use ngtcp2 and nghttp3 libraries for HTTP/3 support" OFF)
+if(USE_NGTCP2)
+  if(USE_OPENSSL OR USE_WOLFSSL)
+    if(USE_WOLFSSL)
+      find_package(NGTCP2 REQUIRED "wolfSSL")
+      list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libngtcp2_crypto_wolfssl")
+    elseif(HAVE_BORINGSSL OR HAVE_AWSLC)
+      find_package(NGTCP2 REQUIRED "BoringSSL")
+      list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libngtcp2_crypto_boringssl")
+    else()
+      find_package(NGTCP2 REQUIRED "quictls")
+      list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libngtcp2_crypto_quictls")
+    endif()
+    openssl_check_quic()
+  elseif(USE_GNUTLS)
+    find_package(NGTCP2 REQUIRED "GnuTLS")
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libngtcp2_crypto_gnutls")
+  else()
+    message(FATAL_ERROR "ngtcp2 requires OpenSSL, wolfSSL or GnuTLS")
+  endif()
+  include_directories(SYSTEM ${NGTCP2_INCLUDE_DIRS})
+  list(APPEND CURL_LIBS ${NGTCP2_LIBRARIES})
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libngtcp2")
+
+  find_package(NGHTTP3 REQUIRED)
+  set(USE_NGHTTP3 ON)
+  include_directories(SYSTEM ${NGHTTP3_INCLUDE_DIRS})
+  list(APPEND CURL_LIBS ${NGHTTP3_LIBRARIES})
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libnghttp3")
+endif()
+
+option(USE_QUICHE "Use quiche library for HTTP/3 support" OFF)
+if(USE_QUICHE)
+  if(USE_NGTCP2)
+    message(FATAL_ERROR "Only one HTTP/3 backend can be selected")
+  endif()
+  find_package(Quiche REQUIRED)
+  if(NOT HAVE_BORINGSSL)
+    message(FATAL_ERROR "quiche requires BoringSSL")
+  endif()
+  openssl_check_quic()
+  list(APPEND CURL_LIBS ${QUICHE_LIBRARIES})
+  list(APPEND CURL_LIBDIRS ${QUICHE_LIBRARY_DIRS})
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "quiche")
+  include_directories(SYSTEM ${QUICHE_INCLUDE_DIRS})
+  link_directories(${QUICHE_LIBRARY_DIRS})
+  if(QUICHE_CFLAGS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${QUICHE_CFLAGS}")
+  endif()
+  if(NOT DEFINED HAVE_QUICHE_CONN_SET_QLOG_FD)
+    cmake_push_check_state()
+    set(CMAKE_REQUIRED_INCLUDES   "${QUICHE_INCLUDE_DIRS}")
+    set(CMAKE_REQUIRED_LIBRARIES  "${QUICHE_LIBRARIES}")
+    check_symbol_exists("quiche_conn_set_qlog_fd" "quiche.h" HAVE_QUICHE_CONN_SET_QLOG_FD)
+    cmake_pop_check_state()
+  endif()
+endif()
+
+option(USE_MSH3 "Use msh3/msquic library for HTTP/3 support" OFF)
+if(USE_MSH3)
+  if(USE_NGTCP2 OR USE_QUICHE)
+    message(FATAL_ERROR "Only one HTTP/3 backend can be selected")
+  endif()
+  if(NOT WIN32)
+    if(NOT USE_OPENSSL)
+      message(FATAL_ERROR "msh3/msquic requires OpenSSL fork with QUIC API")
+    endif()
+    openssl_check_quic()
+  endif()
+  find_package(MSH3 REQUIRED)
+  list(APPEND CURL_LIBS ${MSH3_LIBRARIES})
+  list(APPEND CURL_LIBDIRS ${MSH3_LIBRARY_DIRS})
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${MSH3_PC_REQUIRES})
+  include_directories(SYSTEM ${MSH3_INCLUDE_DIRS})
+  link_directories(${MSH3_LIBRARY_DIRS})
+  if(MSH3_CFLAGS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MSH3_CFLAGS}")
+  endif()
+endif()
+
+if(USE_OPENSSL_QUIC)
+  if(USE_NGTCP2 OR USE_QUICHE OR USE_MSH3)
+    message(FATAL_ERROR "Only one HTTP/3 backend can be selected")
+  endif()
+  find_package(OpenSSL 3.3.0 REQUIRED)
+
+  find_package(NGHTTP3 REQUIRED)
+  set(USE_NGHTTP3 ON)
+  include_directories(SYSTEM ${NGHTTP3_INCLUDE_DIRS})
+  list(APPEND CURL_LIBS ${NGHTTP3_LIBRARIES})
+  list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libnghttp3")
+endif()
+
+if(CURL_WITH_MULTI_SSL AND (USE_NGTCP2 OR USE_QUICHE OR USE_MSH3 OR USE_OPENSSL_QUIC))
+  message(FATAL_ERROR "MultiSSL cannot be enabled with HTTP/3 and vice versa.")
+endif()
+
+if(NOT CURL_DISABLE_SRP AND (HAVE_GNUTLS_SRP OR HAVE_OPENSSL_SRP))
+  set(USE_TLS_SRP 1)
+endif()
+
+if(NOT CURL_DISABLE_LDAP)
+  if(WIN32 AND NOT WINDOWS_STORE)
+    option(USE_WIN32_LDAP "Use Windows LDAP implementation" ON)
+    if(USE_WIN32_LDAP)
+      list(APPEND CURL_LIBS "wldap32")
+      if(NOT CURL_DISABLE_LDAPS)
+        set(HAVE_LDAP_SSL ON)
+      endif()
+    endif()
+  endif()
+
+  # Now that we know, we are not using Windows LDAP...
+  if(NOT USE_WIN32_LDAP)
+    if(NOT DEFINED LDAP_LIBRARY)
+      set(LDAP_LIBRARY "ldap" CACHE STRING "Name or full path to ldap library")
+    endif()
+    if(NOT DEFINED LDAP_LBER_LIBRARY)
+      set(LDAP_LBER_LIBRARY "lber" CACHE STRING "Name or full path to lber library")
+    endif()
+    if(NOT DEFINED LDAP_INCLUDE_DIR)
+      set(LDAP_INCLUDE_DIR "" CACHE STRING "Path to LDAP include directory")
+    endif()
+
+    # Check for LDAP
+    cmake_push_check_state()
+    if(USE_OPENSSL)
+      set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_LIBRARIES})
+    endif()
+    check_library_exists("${LDAP_LIBRARY}" "ldap_init" "" HAVE_LIBLDAP)
+    if(HAVE_LIBLDAP)
+      check_library_exists("${LDAP_LIBRARY};${LDAP_LBER_LIBRARY}" "ber_init" "" HAVE_LIBLBER)
+    else()
+      check_library_exists("${LDAP_LBER_LIBRARY}" "ber_init" "" HAVE_LIBLBER)
+    endif()
+
+    if(LDAP_INCLUDE_DIR)
+      list(APPEND CMAKE_REQUIRED_INCLUDES ${LDAP_INCLUDE_DIR})
+    endif()
+
+    unset(_include_list)
+    check_include_file("lber.h" HAVE_LBER_H)
+    if(HAVE_LBER_H)
+      list(APPEND _include_list "lber.h")
+    endif()
+    check_include_files("${_include_list};ldap.h" HAVE_LDAP_H)
+    unset(_include_list)
+
+    if(NOT HAVE_LDAP_H)
+      message(STATUS "LDAP_H not found CURL_DISABLE_LDAP set ON")
+      set(CURL_DISABLE_LDAP ON CACHE BOOL "" FORCE)
+    elseif(NOT HAVE_LIBLDAP)
+      message(STATUS "LDAP library '${LDAP_LIBRARY}' not found CURL_DISABLE_LDAP set ON")
+      set(CURL_DISABLE_LDAP ON CACHE BOOL "" FORCE)
+    else()
+      if(LDAP_INCLUDE_DIR)
+        include_directories(SYSTEM ${LDAP_INCLUDE_DIR})
+      endif()
+      list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DLDAP_DEPRECATED=1")
+      list(APPEND CMAKE_REQUIRED_LIBRARIES ${LDAP_LIBRARY})
+      set(CURL_LIBS "${LDAP_LIBRARY};${CURL_LIBS}")
+      # FIXME: uncomment once pkg-config-based detection landed: https://github.com/curl/curl/pull/15273
+      # set(LIBCURL_PC_REQUIRES_PRIVATE "${LDAP_PC_REQUIRES};${LIBCURL_PC_REQUIRES_PRIVATE}")
+      if(HAVE_LIBLBER)
+        list(APPEND CMAKE_REQUIRED_LIBRARIES ${LDAP_LBER_LIBRARY})
+        set(CURL_LIBS "${LDAP_LBER_LIBRARY};${CURL_LIBS}")
+      endif()
+
+      check_function_exists("ldap_url_parse" HAVE_LDAP_URL_PARSE)
+      check_function_exists("ldap_init_fd" HAVE_LDAP_INIT_FD)
+
+      check_include_file("ldap_ssl.h" HAVE_LDAP_SSL_H)
+
+      if(HAVE_LDAP_INIT_FD)
+        set(USE_OPENLDAP ON)
+        add_definitions("-DLDAP_DEPRECATED=1")
+      endif()
+      if(NOT CURL_DISABLE_LDAPS)
+        set(HAVE_LDAP_SSL ON)
+      endif()
+    endif()
+    cmake_pop_check_state()
+  endif()
+endif()
+
+# No ldap, no ldaps.
+if(CURL_DISABLE_LDAP)
+  if(NOT CURL_DISABLE_LDAPS)
+    message(STATUS "LDAP needs to be enabled to support LDAPS")
+    set(CURL_DISABLE_LDAPS ON CACHE BOOL "" FORCE)
+  endif()
+endif()
+
+if(WIN32)
+  option(USE_WIN32_IDN "Use WinIDN for IDN support" OFF)
+  if(USE_WIN32_IDN)
+    list(APPEND CURL_LIBS "normaliz")
+  endif()
+else()
+  set(USE_WIN32_IDN OFF)
+endif()
+
+if(APPLE)
+  option(USE_APPLE_IDN "Use Apple built-in IDN support" OFF)
+  if(USE_APPLE_IDN)
+    cmake_push_check_state()
+    set(CMAKE_REQUIRED_LIBRARIES "icucore")
+    check_symbol_exists("uidna_openUTS46" "unicode/uidna.h" HAVE_APPLE_IDN)
+    cmake_pop_check_state()
+    if(HAVE_APPLE_IDN)
+      list(APPEND CURL_LIBS "icucore" "iconv")
+    else()
+      set(USE_APPLE_IDN OFF)
+    endif()
+  endif()
+else()
+  set(USE_APPLE_IDN OFF)
+endif()
+
+# Check for libidn2
+option(USE_LIBIDN2 "Use libidn2 for IDN support" ON)
+set(HAVE_IDN2_H OFF)
+set(HAVE_LIBIDN2 OFF)
+if(USE_LIBIDN2 AND NOT USE_APPLE_IDN AND NOT USE_WIN32_IDN)
+  find_package(Libidn2)
+  if(LIBIDN2_FOUND)
+    set(CURL_LIBS "${LIBIDN2_LIBRARIES};${CURL_LIBS}")
+    list(APPEND CURL_LIBDIRS ${LIBIDN2_LIBRARY_DIRS})
+    set(LIBCURL_PC_REQUIRES_PRIVATE "libidn2;${LIBCURL_PC_REQUIRES_PRIVATE}")
+    include_directories(SYSTEM ${LIBIDN2_INCLUDE_DIRS})
+    link_directories(${LIBIDN2_LIBRARY_DIRS})
+    if(LIBIDN2_CFLAGS)
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBIDN2_CFLAGS}")
+    endif()
+    set(HAVE_IDN2_H 1)
+    set(HAVE_LIBIDN2 1)
+  endif()
+endif()
+
+# libpsl
+option(CURL_USE_LIBPSL "Use libpsl" ON)
+mark_as_advanced(CURL_USE_LIBPSL)
+set(USE_LIBPSL OFF)
+
+if(CURL_USE_LIBPSL)
+  find_package(Libpsl)  # TODO: add REQUIRED to match autotools
+  if(LIBPSL_FOUND)
+    list(APPEND CURL_LIBS ${LIBPSL_LIBRARIES})
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libpsl")
+    include_directories(SYSTEM ${LIBPSL_INCLUDE_DIRS})
+    set(USE_LIBPSL ON)
+  else()
+    message(WARNING "libpsl is enabled, but not found.")
+  endif()
+endif()
+
+# libssh2
+option(CURL_USE_LIBSSH2 "Use libssh2" ON)
+mark_as_advanced(CURL_USE_LIBSSH2)
+set(USE_LIBSSH2 OFF)
+
+if(CURL_USE_LIBSSH2)
+  find_package(Libssh2)
+  if(LIBSSH2_FOUND)
+    list(APPEND CURL_LIBS ${LIBSSH2_LIBRARIES})
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libssh2")
+    include_directories(SYSTEM ${LIBSSH2_INCLUDE_DIRS})
+    set(USE_LIBSSH2 ON)
+  endif()
+endif()
+
+# libssh
+option(CURL_USE_LIBSSH "Use libssh" OFF)
+mark_as_advanced(CURL_USE_LIBSSH)
+if(NOT USE_LIBSSH2 AND CURL_USE_LIBSSH)
+  find_package(Libssh REQUIRED)
+  if(LIBSSH_FOUND)
+    list(APPEND CURL_LIBS ${LIBSSH_LIBRARIES})
+    list(APPEND CURL_LIBDIRS ${LIBSSH_LIBRARY_DIRS})
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libssh")
+    include_directories(SYSTEM ${LIBSSH_INCLUDE_DIRS})
+    link_directories(${LIBSSH_LIBRARY_DIRS})
+    if(LIBSSH_CFLAGS)
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBSSH_CFLAGS}")
+    endif()
+    set(USE_LIBSSH ON)
+  endif()
+endif()
+
+# wolfSSH
+option(CURL_USE_WOLFSSH "Use wolfSSH" OFF)
+mark_as_advanced(CURL_USE_WOLFSSH)
+set(USE_WOLFSSH OFF)
+if(NOT USE_LIBSSH2 AND NOT USE_LIBSSH AND CURL_USE_WOLFSSH)
+  if(USE_WOLFSSL)
+    find_package(WolfSSH)
+    if(WOLFSSH_FOUND)
+      list(APPEND CURL_LIBS ${WOLFSSH_LIBRARIES})
+      include_directories(SYSTEM ${WOLFSSH_INCLUDE_DIRS})
+      set(USE_WOLFSSH ON)
+    endif()
+  else()
+    message(WARNING "wolfSSH requires wolfSSL. Skipping.")
+  endif()
+endif()
+
+option(CURL_USE_GSASL "Use libgsasl" OFF)
+mark_as_advanced(CURL_USE_GSASL)
+if(CURL_USE_GSASL)
+  find_package(Libgsasl REQUIRED)
+  if(LIBGSASL_FOUND)
+    list(APPEND CURL_LIBS ${LIBGSASL_LIBRARIES})
+    list(APPEND CURL_LIBDIRS ${LIBGSASL_LIBRARY_DIRS})
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libgsasl")
+    include_directories(SYSTEM ${LIBGSASL_INCLUDE_DIRS})
+    link_directories(${LIBGSASL_LIBRARY_DIRS})
+    if(LIBGSASL_CFLAGS)
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBGSASL_CFLAGS}")
+    endif()
+    set(USE_GSASL ON)
+  endif()
+endif()
+
+option(CURL_USE_GSSAPI "Use GSSAPI implementation" OFF)
+mark_as_advanced(CURL_USE_GSSAPI)
+
+if(CURL_USE_GSSAPI)
+  find_package(GSS)
+
+  set(HAVE_GSSAPI ${GSS_FOUND})
+  if(GSS_FOUND)
+    if(GSS_FLAVOUR STREQUAL "GNU")
+      set(HAVE_GSSGNU 1)
+    else()
+      cmake_push_check_state()
+      list(APPEND CMAKE_REQUIRED_INCLUDES ${GSS_INCLUDE_DIRS})
+
+      set(_include_list "")
+      check_include_file("gssapi/gssapi.h" HAVE_GSSAPI_GSSAPI_H)
+      if(HAVE_GSSAPI_GSSAPI_H)
+        list(APPEND _include_list "gssapi/gssapi.h")
+      endif()
+      check_include_files("${_include_list};gssapi/gssapi_generic.h" HAVE_GSSAPI_GSSAPI_GENERIC_H)
+
+      if(GSS_FLAVOUR STREQUAL "MIT")
+        check_include_files("${_include_list};gssapi/gssapi_krb5.h" _have_gssapi_gssapi_krb5_h)
+        if(HAVE_GSSAPI_GSSAPI_GENERIC_H)
+          list(APPEND _include_list "gssapi/gssapi_generic.h")
+        endif()
+        if(_have_gssapi_gssapi_krb5_h)
+          list(APPEND _include_list "gssapi/gssapi_krb5.h")
+        endif()
+
+        if(NOT DEFINED HAVE_GSS_C_NT_HOSTBASED_SERVICE)
+          set(CMAKE_REQUIRED_FLAGS ${GSS_CFLAGS})
+          set(CMAKE_REQUIRED_LIBRARIES ${GSS_LIBRARIES})
+          curl_required_libpaths("${GSS_LIBRARY_DIRS}")
+          check_symbol_exists("GSS_C_NT_HOSTBASED_SERVICE" "${_include_list}" HAVE_GSS_C_NT_HOSTBASED_SERVICE)
+        endif()
+        if(NOT HAVE_GSS_C_NT_HOSTBASED_SERVICE)
+          set(HAVE_OLD_GSSMIT ON)
+        endif()
+      endif()
+      unset(_include_list)
+      cmake_pop_check_state()
+    endif()
+
+    list(APPEND CURL_LIBS ${GSS_LIBRARIES})
+    list(APPEND CURL_LIBDIRS ${GSS_LIBRARY_DIRS})
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE ${GSS_PC_REQUIRES})
+    include_directories(SYSTEM ${GSS_INCLUDE_DIRS})
+    link_directories(${GSS_LIBRARY_DIRS})
+    if(GSS_CFLAGS)
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GSS_CFLAGS}")
+    endif()
+  else()
+    message(WARNING "GSSAPI has been requested, but no supporting libraries found. Skipping.")
+  endif()
+endif()
+
+# libuv
+option(CURL_USE_LIBUV "Use libuv for event-based tests" OFF)
+if(CURL_USE_LIBUV)
+  if(NOT ENABLE_DEBUG)
+    message(FATAL_ERROR "Using libuv without debug support enabled is useless")
+  endif()
+  find_package(Libuv REQUIRED)
+  if(LIBUV_FOUND)
+    list(APPEND CURL_LIBS ${LIBUV_LIBRARIES})
+    list(APPEND CURL_LIBDIRS ${LIBUV_LIBRARY_DIRS})
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "libuv")
+    include_directories(SYSTEM ${LIBUV_INCLUDE_DIRS})
+    link_directories(${LIBUV_LIBRARY_DIRS})
+    if(LIBUV_CFLAGS)
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBUV_CFLAGS}")
+    endif()
+    set(USE_LIBUV ON)
+    set(HAVE_UV_H ON)
+  endif()
+endif()
+
+option(USE_LIBRTMP "Enable librtmp from rtmpdump" OFF)
+if(USE_LIBRTMP)
+  set(_extra_libs "rtmp")
+  if(WIN32)
+    list(APPEND _extra_libs "winmm")
+  endif()
+  openssl_check_symbol_exists("RTMP_Init" "librtmp/rtmp.h" HAVE_LIBRTMP "${_extra_libs}")
+  if(HAVE_LIBRTMP)
+    list(APPEND CURL_LIBS "rtmp")
+    list(APPEND LIBCURL_PC_REQUIRES_PRIVATE "librtmp")
+    if(WIN32)
+      list(APPEND CURL_LIBS "winmm")
+    endif()
+  else()
+    message(WARNING "librtmp has been requested, but not found or missing OpenSSL. Skipping.")
+    set(USE_LIBRTMP OFF)
+  endif()
+endif()
+
+option(ENABLE_UNIX_SOCKETS "Enable Unix domain sockets support" ON)
+if(ENABLE_UNIX_SOCKETS)
+  if(WIN32)
+    set(USE_UNIX_SOCKETS ON)
+  else()
+    include(CheckStructHasMember)
+    check_struct_has_member("struct sockaddr_un" "sun_path" "sys/un.h" USE_UNIX_SOCKETS)
+  endif()
+else()
+  unset(USE_UNIX_SOCKETS CACHE)
+endif()
+
+#
+# CA handling
+#
+if(_curl_ca_bundle_supported)
+  set(CURL_CA_BUNDLE "auto" CACHE
+    STRING "Path to the CA bundle. Set 'none' to disable or 'auto' for auto-detection. Defaults to 'auto'.")
+  set(CURL_CA_FALLBACK OFF CACHE BOOL
+    "Use built-in CA store of TLS backend. Defaults to OFF")
+  set(CURL_CA_PATH "auto" CACHE
+    STRING "Location of default CA path. Set 'none' to disable or 'auto' for auto-detection. Defaults to 'auto'.")
+  set(CURL_CA_EMBED "" CACHE
+    STRING "Path to the CA bundle to embed in the curl tool.")
+
+  if(CURL_CA_BUNDLE STREQUAL "")
+    message(FATAL_ERROR "Invalid value of CURL_CA_BUNDLE. Use 'none', 'auto' or file path.")
+  elseif(CURL_CA_BUNDLE STREQUAL "none")
+    unset(CURL_CA_BUNDLE CACHE)
+  elseif(CURL_CA_BUNDLE STREQUAL "auto")
+    unset(CURL_CA_BUNDLE CACHE)
+    if(NOT CMAKE_CROSSCOMPILING AND NOT WIN32)
+      set(_curl_ca_bundle_autodetect TRUE)
+    endif()
+  else()
+    set(CURL_CA_BUNDLE_SET TRUE)
+  endif()
+  mark_as_advanced(CURL_CA_BUNDLE_SET)
+
+  if(CURL_CA_PATH STREQUAL "")
+    message(FATAL_ERROR "Invalid value of CURL_CA_PATH. Use 'none', 'auto' or directory path.")
+  elseif(CURL_CA_PATH STREQUAL "none")
+    unset(CURL_CA_PATH CACHE)
+  elseif(CURL_CA_PATH STREQUAL "auto")
+    unset(CURL_CA_PATH CACHE)
+    if(NOT CMAKE_CROSSCOMPILING AND NOT WIN32)
+      set(_curl_ca_path_autodetect TRUE)
+    endif()
+  else()
+    set(CURL_CA_PATH_SET TRUE)
+  endif()
+  mark_as_advanced(CURL_CA_PATH_SET)
+
+  if(CURL_CA_BUNDLE_SET AND _curl_ca_path_autodetect)
+    # Skip auto-detection of unset CA path because CA bundle is set explicitly
+  elseif(CURL_CA_PATH_SET AND _curl_ca_bundle_autodetect)
+    # Skip auto-detection of unset CA bundle because CA path is set explicitly
+  elseif(_curl_ca_bundle_autodetect OR _curl_ca_path_autodetect)
+    # First try auto-detecting a CA bundle, then a CA path
+
+    if(_curl_ca_bundle_autodetect)
+      foreach(_search_ca_bundle_path IN ITEMS
+          "/etc/ssl/certs/ca-certificates.crt"
+          "/etc/pki/tls/certs/ca-bundle.crt"
+          "/usr/share/ssl/certs/ca-bundle.crt"
+          "/usr/local/share/certs/ca-root-nss.crt"
+          "/etc/ssl/cert.pem")
+        if(EXISTS "${_search_ca_bundle_path}")
+          message(STATUS "Found CA bundle: ${_search_ca_bundle_path}")
+          set(CURL_CA_BUNDLE "${_search_ca_bundle_path}" CACHE
+            STRING "Path to the CA bundle. Set 'none' to disable or 'auto' for auto-detection. Defaults to 'auto'.")
+          set(CURL_CA_BUNDLE_SET TRUE CACHE BOOL "Path to the CA bundle has been set")
+          break()
+        endif()
+      endforeach()
+    endif()
+
+    if(_curl_ca_path_autodetect AND NOT CURL_CA_PATH_SET)
+      set(_search_ca_path "/etc/ssl/certs")
+      file(GLOB _curl_ca_files_found "${_search_ca_path}/[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f].0")
+      if(_curl_ca_files_found)
+        unset(_curl_ca_files_found)
+        message(STATUS "Found CA path: ${_search_ca_path}")
+        set(CURL_CA_PATH "${_search_ca_path}" CACHE
+          STRING "Location of default CA path. Set 'none' to disable or 'auto' for auto-detection. Defaults to 'auto'.")
+        set(CURL_CA_PATH_SET TRUE CACHE BOOL "Path to the CA bundle has been set")
+      endif()
+    endif()
+  endif()
+
+  set(CURL_CA_EMBED_SET FALSE)
+  if(BUILD_CURL_EXE AND NOT CURL_CA_EMBED STREQUAL "")
+    if(EXISTS "${CURL_CA_EMBED}")
+      set(CURL_CA_EMBED_SET TRUE)
+      message(STATUS "Found CA bundle to embed: ${CURL_CA_EMBED}")
+    else()
+      message(FATAL_ERROR "CA bundle to embed is missing: '${CURL_CA_EMBED}'")
+    endif()
+  endif()
+endif()
+
+if(WIN32)
+  option(CURL_DISABLE_CA_SEARCH "Disable unsafe CA bundle search in PATH on Windows" OFF)
+  option(CURL_CA_SEARCH_SAFE "Enable safe CA bundle search (within the curl tool directory) on Windows" OFF)
+endif()
+
+# Check for header files
+if(WIN32)
+  list(APPEND CURL_INCLUDES "winsock2.h")
+  list(APPEND CURL_INCLUDES "ws2tcpip.h")
+
+  if(HAVE_WIN32_WINNT)
+    if(HAVE_WIN32_WINNT LESS 0x0501)
+      # Windows XP is required for freeaddrinfo, getaddrinfo
+      message(FATAL_ERROR "Building for Windows XP or newer is required.")
+    endif()
+
+    # Pre-fill detection results based on target OS version
+    if(MINGW OR MSVC)
+      if(HAVE_WIN32_WINNT LESS 0x0600)
+        set(HAVE_INET_NTOP 0)
+        set(HAVE_INET_PTON 0)
+      else()  # Windows Vista or newer
+        set(HAVE_INET_NTOP 1)
+        set(HAVE_INET_PTON 1)
+      endif()
+      unset(HAVE_INET_NTOP CACHE)
+      unset(HAVE_INET_PTON CACHE)
+    endif()
+  endif()
+endif()
+
+# Detect headers
+
+# Use check_include_file_concat() for headers required by subsequent
+# check_include_file_concat() or check_symbol_exists() detections.
+# Order for these is significant.
+check_include_file("sys/eventfd.h"    HAVE_SYS_EVENTFD_H)
+check_include_file("sys/filio.h"      HAVE_SYS_FILIO_H)
+check_include_file("sys/wait.h"       HAVE_SYS_WAIT_H)
+check_include_file("sys/ioctl.h"      HAVE_SYS_IOCTL_H)
+check_include_file("sys/param.h"      HAVE_SYS_PARAM_H)
+check_include_file("sys/poll.h"       HAVE_SYS_POLL_H)
+check_include_file("sys/resource.h"   HAVE_SYS_RESOURCE_H)
+check_include_file_concat("sys/select.h"     HAVE_SYS_SELECT_H)
+check_include_file_concat("sys/socket.h"     HAVE_SYS_SOCKET_H)
+check_include_file("sys/sockio.h"     HAVE_SYS_SOCKIO_H)
+check_include_file("sys/stat.h"       HAVE_SYS_STAT_H)
+check_include_file_concat("sys/time.h"       HAVE_SYS_TIME_H)
+check_include_file_concat("sys/types.h"      HAVE_SYS_TYPES_H)
+check_include_file("sys/un.h"         HAVE_SYS_UN_H)
+check_include_file("sys/utime.h"      HAVE_SYS_UTIME_H)
+check_include_file("sys/xattr.h"      HAVE_SYS_XATTR_H)
+
+check_include_file_concat("arpa/inet.h"      HAVE_ARPA_INET_H)
+check_include_file("dirent.h"         HAVE_DIRENT_H)
+check_include_file("fcntl.h"          HAVE_FCNTL_H)
+check_include_file_concat("ifaddrs.h"        HAVE_IFADDRS_H)
+check_include_file("io.h"             HAVE_IO_H)
+check_include_file_concat("libgen.h"         HAVE_LIBGEN_H)
+check_include_file("linux/tcp.h"      HAVE_LINUX_TCP_H)
+check_include_file("locale.h"         HAVE_LOCALE_H)
+check_include_file("net/if.h"         HAVE_NET_IF_H)
+check_include_file_concat("netdb.h"          HAVE_NETDB_H)
+check_include_file_concat("netinet/in.h"     HAVE_NETINET_IN_H)
+check_include_file("netinet/in6.h"    HAVE_NETINET_IN6_H)
+check_include_file_concat("netinet/tcp.h"    HAVE_NETINET_TCP_H)  # sys/types.h (e.g. Cygwin) netinet/in.h
+check_include_file_concat("netinet/udp.h"    HAVE_NETINET_UDP_H)  # sys/types.h (e.g. Cygwin)
+check_include_file("poll.h"           HAVE_POLL_H)
+check_include_file("pwd.h"            HAVE_PWD_H)
+check_include_file("stdatomic.h"      HAVE_STDATOMIC_H)
+check_include_file("stdbool.h"        HAVE_STDBOOL_H)
+check_include_file("strings.h"        HAVE_STRINGS_H)
+check_include_file("stropts.h"        HAVE_STROPTS_H)
+check_include_file("termio.h"         HAVE_TERMIO_H)
+check_include_file("termios.h"        HAVE_TERMIOS_H)
+check_include_file_concat("unistd.h"         HAVE_UNISTD_H)
+check_include_file("utime.h"          HAVE_UTIME_H)
+
+if(CMAKE_SYSTEM_NAME MATCHES "AmigaOS")
+  check_include_file_concat("proto/bsdsocket.h" HAVE_PROTO_BSDSOCKET_H)
+endif()
+
+# Pass these detection results to curl_internal_test() for use in CurlTests.c
+# Add here all feature flags referenced from CurlTests.c
+foreach(_variable IN ITEMS
+    HAVE_STDATOMIC_H
+    HAVE_STDBOOL_H
+    HAVE_STROPTS_H
+    HAVE_SYS_IOCTL_H
+    HAVE_SYS_SOCKET_H
+    HAVE_SYS_TYPES_H
+    HAVE_UNISTD_H
+    )
+  if(${_variable})
+    set(CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -D${_variable}")
+  endif()
+endforeach()
+
+check_type_size("size_t"      SIZEOF_SIZE_T)
+check_type_size("ssize_t"     SIZEOF_SSIZE_T)
+check_type_size("long long"   SIZEOF_LONG_LONG)
+check_type_size("long"        SIZEOF_LONG)
+check_type_size("int"         SIZEOF_INT)
+check_type_size("__int64"     SIZEOF___INT64)
+check_type_size("time_t"      SIZEOF_TIME_T)
+check_type_size("suseconds_t" SIZEOF_SUSECONDS_T)
+if(NOT HAVE_SIZEOF_SSIZE_T)
+  if(SIZEOF_LONG EQUAL SIZEOF_SIZE_T)
+    set(ssize_t "long")
+  endif()
+  if(NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T)
+    set(ssize_t "__int64")
+  endif()
+endif()
+# off_t is sized later, after the HAVE_FILE_OFFSET_BITS test
+
+if(SIZEOF_LONG_LONG)
+  set(HAVE_LONGLONG 1)
+endif()
+if(SIZEOF_SUSECONDS_T)
+  set(HAVE_SUSECONDS_T 1)
+endif()
+
+# Check for some functions that are used
+if(WIN32)
+  list(APPEND CMAKE_REQUIRED_LIBRARIES "ws2_32")  # Apply to all feature checks
+elseif(HAVE_LIBSOCKET)
+  list(APPEND CMAKE_REQUIRED_LIBRARIES "socket")  # Apply to all feature checks
+endif()
+
+check_function_exists("fnmatch"       HAVE_FNMATCH)
+check_symbol_exists("basename"        "${CURL_INCLUDES};string.h" HAVE_BASENAME)  # libgen.h unistd.h
+check_symbol_exists("opendir"         "dirent.h" HAVE_OPENDIR)
+check_function_exists("poll"          HAVE_POLL)  # poll.h
+check_symbol_exists("socket"          "${CURL_INCLUDES}" HAVE_SOCKET)  # winsock2.h sys/socket.h
+check_function_exists("sched_yield"   HAVE_SCHED_YIELD)
+check_symbol_exists("socketpair"      "${CURL_INCLUDES}" HAVE_SOCKETPAIR)  # sys/socket.h
+check_symbol_exists("recv"            "${CURL_INCLUDES}" HAVE_RECV)  # proto/bsdsocket.h sys/types.h sys/socket.h
+check_symbol_exists("send"            "${CURL_INCLUDES}" HAVE_SEND)  # proto/bsdsocket.h sys/types.h sys/socket.h
+check_function_exists("sendmsg"       HAVE_SENDMSG)
+check_function_exists("sendmmsg"      HAVE_SENDMMSG)
+check_symbol_exists("select"          "${CURL_INCLUDES}" HAVE_SELECT)  # proto/bsdsocket.h sys/select.h sys/socket.h
+check_symbol_exists("strdup"          "string.h" HAVE_STRDUP)
+check_symbol_exists("strtok_r"        "string.h" HAVE_STRTOK_R)
+check_symbol_exists("strcasecmp"      "string.h" HAVE_STRCASECMP)
+check_symbol_exists("stricmp"         "string.h" HAVE_STRICMP)
+check_symbol_exists("strcmpi"         "string.h" HAVE_STRCMPI)
+check_symbol_exists("memrchr"         "string.h" HAVE_MEMRCHR)
+check_symbol_exists("alarm"           "unistd.h" HAVE_ALARM)
+check_symbol_exists("fcntl"           "fcntl.h" HAVE_FCNTL)
+check_function_exists("getppid"       HAVE_GETPPID)
+check_function_exists("utimes"        HAVE_UTIMES)
+
+check_function_exists("gettimeofday"  HAVE_GETTIMEOFDAY)  # sys/time.h
+check_symbol_exists("closesocket"     "${CURL_INCLUDES}" HAVE_CLOSESOCKET)  # winsock2.h
+check_symbol_exists("sigsetjmp"       "setjmp.h" HAVE_SIGSETJMP)
+check_function_exists("getpass_r"     HAVE_GETPASS_R)
+check_function_exists("getpwuid"      HAVE_GETPWUID)
+check_function_exists("getpwuid_r"    HAVE_GETPWUID_R)
+check_function_exists("geteuid"       HAVE_GETEUID)
+check_function_exists("utime"         HAVE_UTIME)
+check_symbol_exists("gmtime_r"        "stdlib.h;time.h" HAVE_GMTIME_R)
+
+check_symbol_exists("gethostbyname_r" "netdb.h" HAVE_GETHOSTBYNAME_R)
+
+check_symbol_exists("signal"          "signal.h" HAVE_SIGNAL)
+check_symbol_exists("strtoll"         "stdlib.h" HAVE_STRTOLL)
+check_symbol_exists("strerror_r"      "stdlib.h;string.h" HAVE_STRERROR_R)
+check_symbol_exists("sigaction"       "signal.h" HAVE_SIGACTION)
+check_symbol_exists("siginterrupt"    "signal.h" HAVE_SIGINTERRUPT)
+check_symbol_exists("getaddrinfo"     "${CURL_INCLUDES};stdlib.h;string.h" HAVE_GETADDRINFO)  # ws2tcpip.h sys/socket.h netdb.h
+check_symbol_exists("getifaddrs"      "${CURL_INCLUDES};stdlib.h" HAVE_GETIFADDRS)  # ifaddrs.h
+check_symbol_exists("freeaddrinfo"    "${CURL_INCLUDES}" HAVE_FREEADDRINFO)  # ws2tcpip.h sys/socket.h netdb.h
+check_function_exists("pipe"          HAVE_PIPE)
+check_function_exists("eventfd"       HAVE_EVENTFD)
+check_symbol_exists("ftruncate"       "unistd.h" HAVE_FTRUNCATE)
+check_symbol_exists("getpeername"     "${CURL_INCLUDES}" HAVE_GETPEERNAME)  # winsock2.h unistd.h proto/bsdsocket.h
+check_symbol_exists("getsockname"     "${CURL_INCLUDES}" HAVE_GETSOCKNAME)  # winsock2.h unistd.h proto/bsdsocket.h
+check_function_exists("if_nametoindex"  HAVE_IF_NAMETOINDEX)  # winsock2.h net/if.h
+check_function_exists("getrlimit"       HAVE_GETRLIMIT)
+check_function_exists("setlocale"       HAVE_SETLOCALE)
+check_function_exists("setmode"         HAVE_SETMODE)
+check_function_exists("setrlimit"       HAVE_SETRLIMIT)
+
+if(WIN32 OR CYGWIN)
+  check_function_exists("_setmode" HAVE__SETMODE)
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES "AmigaOS")
+  check_symbol_exists("CloseSocket" "${CURL_INCLUDES}" HAVE_CLOSESOCKET_CAMEL)  # sys/socket.h proto/bsdsocket.h
+endif()
+
+if(NOT _ssl_enabled)
+  check_symbol_exists("arc4random" "${CURL_INCLUDES};stdlib.h" HAVE_ARC4RANDOM)
+endif()
+
+if(NOT MSVC OR (MSVC_VERSION GREATER_EQUAL 1900))
+  # Earlier MSVC compilers had faulty snprintf implementations
+  check_function_exists("snprintf" HAVE_SNPRINTF)
+endif()
+if(APPLE)
+  check_function_exists("mach_absolute_time" HAVE_MACH_ABSOLUTE_TIME)
+endif()
+check_symbol_exists("inet_ntop" "${CURL_INCLUDES};stdlib.h;string.h" HAVE_INET_NTOP)  # arpa/inet.h
+if(MSVC AND (MSVC_VERSION LESS_EQUAL 1600))
+  set(HAVE_INET_NTOP OFF)
+endif()
+check_symbol_exists("inet_pton" "${CURL_INCLUDES};stdlib.h;string.h" HAVE_INET_PTON)  # arpa/inet.h
+
+check_symbol_exists("fsetxattr" "sys/xattr.h" HAVE_FSETXATTR)
+if(HAVE_FSETXATTR)
+  curl_internal_test(HAVE_FSETXATTR_5)
+  curl_internal_test(HAVE_FSETXATTR_6)
+endif()
+
+cmake_push_check_state()
+if(WIN32)
+  set(CMAKE_EXTRA_INCLUDE_FILES "winsock2.h")
+  check_type_size("ADDRESS_FAMILY" SIZEOF_ADDRESS_FAMILY)
+  set(HAVE_ADDRESS_FAMILY ${HAVE_SIZEOF_ADDRESS_FAMILY})
+elseif(HAVE_SYS_SOCKET_H)
+  set(CMAKE_EXTRA_INCLUDE_FILES "sys/socket.h")
+  check_type_size("sa_family_t" SIZEOF_SA_FAMILY_T)
+  set(HAVE_SA_FAMILY_T ${HAVE_SIZEOF_SA_FAMILY_T})
+endif()
+cmake_pop_check_state()
+
+# Do curl specific tests
+foreach(_curl_test IN ITEMS
+    HAVE_FCNTL_O_NONBLOCK
+    HAVE_IOCTLSOCKET
+    HAVE_IOCTLSOCKET_CAMEL
+    HAVE_IOCTLSOCKET_CAMEL_FIONBIO
+    HAVE_IOCTLSOCKET_FIONBIO
+    HAVE_IOCTL_FIONBIO
+    HAVE_IOCTL_SIOCGIFADDR
+    HAVE_SETSOCKOPT_SO_NONBLOCK
+    HAVE_O_NONBLOCK
+    HAVE_GETHOSTBYNAME_R_3
+    HAVE_GETHOSTBYNAME_R_5
+    HAVE_GETHOSTBYNAME_R_6
+    HAVE_GETHOSTBYNAME_R_3_REENTRANT
+    HAVE_GETHOSTBYNAME_R_5_REENTRANT
+    HAVE_GETHOSTBYNAME_R_6_REENTRANT
+    HAVE_IN_ADDR_T
+    HAVE_BOOL_T
+    STDC_HEADERS
+    HAVE_FILE_OFFSET_BITS
+    HAVE_ATOMIC
+    )
+  curl_internal_test(${_curl_test})
+endforeach()
+
+cmake_push_check_state()
+if(HAVE_FILE_OFFSET_BITS)
+  set(_FILE_OFFSET_BITS 64)
+  set(CMAKE_REQUIRED_DEFINITIONS "-D_FILE_OFFSET_BITS=64")
+endif()
+check_type_size("off_t" SIZEOF_OFF_T)
+
+# fseeko may not exist with _FILE_OFFSET_BITS=64 but can exist with
+# _FILE_OFFSET_BITS unset or 32 (e.g. Android ARMv7 with NDK 26b and API level < 24)
+# so we need to test fseeko after testing for _FILE_OFFSET_BITS
+check_symbol_exists("fseeko" "${CURL_INCLUDES};stdio.h" HAVE_FSEEKO)
+
+if(HAVE_FSEEKO)
+  set(HAVE_DECL_FSEEKO 1)
+endif()
+
+# Include this header to get the type
+cmake_push_check_state()
+set(CMAKE_REQUIRED_INCLUDES "${PROJECT_SOURCE_DIR}/include")
+set(CMAKE_EXTRA_INCLUDE_FILES "curl/system.h")
+check_type_size("curl_off_t" SIZEOF_CURL_OFF_T)
+set(CMAKE_EXTRA_INCLUDE_FILES "curl/curl.h")
+check_type_size("curl_socket_t" SIZEOF_CURL_SOCKET_T)
+cmake_pop_check_state()  # pop curl system headers
+cmake_pop_check_state()  # pop -D_FILE_OFFSET_BITS=64
+
+if(NOT WIN32 AND NOT CMAKE_CROSSCOMPILING)
+  # On non-Windows and not cross-compiling, check for writable argv[]
+  include(CheckCSourceRuns)
+  check_c_source_runs("
+    int main(int argc, char **argv)
+    {
+      (void)argc;
+      argv[0][0] = ' ';
+      return (argv[0][0] == ' ')?0:1;
+    }" HAVE_WRITABLE_ARGV)
+endif()
+
+curl_internal_test(HAVE_GLIBC_STRERROR_R)
+curl_internal_test(HAVE_POSIX_STRERROR_R)
+
+# Check for reentrant
+foreach(_curl_test IN ITEMS
+    HAVE_GETHOSTBYNAME_R_3
+    HAVE_GETHOSTBYNAME_R_5
+    HAVE_GETHOSTBYNAME_R_6)
+  if(NOT ${_curl_test})
+    if(${_curl_test}_REENTRANT)
+      set(NEED_REENTRANT 1)
+    endif()
+  endif()
+endforeach()
+
+if(NEED_REENTRANT)
+  foreach(_curl_test IN ITEMS
+      HAVE_GETHOSTBYNAME_R_3
+      HAVE_GETHOSTBYNAME_R_5
+      HAVE_GETHOSTBYNAME_R_6)
+    set(${_curl_test} 0)
+    if(${_curl_test}_REENTRANT)
+      set(${_curl_test} 1)
+    endif()
+  endforeach()
+endif()
+
+if(NOT WIN32)
+  curl_internal_test(HAVE_CLOCK_GETTIME_MONOTONIC)  # Check clock_gettime(CLOCK_MONOTONIC, x) support
+endif()
+
+if(APPLE)
+  curl_internal_test(HAVE_BUILTIN_AVAILABLE)  # Check compiler support of __builtin_available()
+endif()
+
+# Some other minor tests
+
+if(NOT HAVE_IN_ADDR_T)
+  set(in_addr_t "unsigned long")
+endif()
+
+# Check for nonblocking
+set(HAVE_DISABLED_NONBLOCKING 1)
+if(HAVE_FIONBIO OR
+   HAVE_IOCTLSOCKET OR
+   HAVE_IOCTLSOCKET_CASE OR
+   HAVE_O_NONBLOCK)
+  unset(HAVE_DISABLED_NONBLOCKING)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCC AND APPLE)
+  include(CheckCCompilerFlag)
+  check_c_compiler_flag("-Wno-long-double" HAVE_C_FLAG_Wno_long_double)
+  if(HAVE_C_FLAG_Wno_long_double)
+    # The Mac version of GCC warns about use of long double. Disable it.
+    get_source_file_property(_mprintf_compile_flags "mprintf.c" COMPILE_FLAGS)
+    if(_mprintf_compile_flags)
+      set(_mprintf_compile_flags "${_mprintf_compile_flags} -Wno-long-double")
+    else()
+      set(_mprintf_compile_flags "-Wno-long-double")
+    endif()
+    set_source_files_properties("mprintf.c" PROPERTIES
+      COMPILE_FLAGS ${_mprintf_compile_flags})
+  endif()
+endif()
+
+if(_cmake_try_compile_target_type_save)
+  set(CMAKE_TRY_COMPILE_TARGET_TYPE ${_cmake_try_compile_target_type_save})
+  unset(_cmake_try_compile_target_type_save)
+endif()
+
+include(CMake/OtherTests.cmake)
+
+add_definitions("-DHAVE_CONFIG_H")
+
+# For Windows, all compilers used by CMake should support large files
+if(WIN32)
+  set(USE_WIN32_LARGE_FILES ON)
+
+  # Use the manifest embedded in the Windows Resource
+  set(CMAKE_RC_FLAGS "${CMAKE_RC_FLAGS} -DCURL_EMBED_MANIFEST")
+
+  # We use crypto functions that are not available for UWP apps
+  if(NOT WINDOWS_STORE)
+    set(USE_WIN32_CRYPTO ON)
+  endif()
+
+  # Link required libraries for USE_WIN32_CRYPTO or USE_SCHANNEL
+  if(USE_WIN32_CRYPTO OR USE_SCHANNEL)
+    list(APPEND CURL_LIBS "advapi32" "crypt32")
+  endif()
+endif()
+
+if(MSVC)
+  # Disable default manifest added by CMake
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
+
+  add_definitions("-D_CRT_SECURE_NO_DEPRECATE" "-D_CRT_NONSTDC_NO_DEPRECATE")
+  if(CMAKE_C_FLAGS MATCHES "/W[0-4]")
+    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+  else()
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
+  endif()
+
+  # Use multithreaded compilation on VS 2008+
+  if(CMAKE_C_COMPILER_ID STREQUAL "MSVC" AND MSVC_VERSION GREATER_EQUAL 1500)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP")
+  endif()
+endif()
+
+if(CURL_WERROR)
+  if(MSVC)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX")
+  else()
+    # This assumes clang or gcc style options
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror")
+  endif()
+endif()
+
+if(CURL_LTO)
+  if(CMAKE_VERSION VERSION_LESS 3.9)
+    message(FATAL_ERROR "LTO has been requested, but your cmake version ${CMAKE_VERSION} is to old. You need at least 3.9")
+  endif()
+
+  cmake_policy(SET CMP0069 NEW)
+
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT CURL_HAS_LTO OUTPUT _lto_error LANGUAGES C)
+  if(CURL_HAS_LTO)
+    message(STATUS "LTO supported and enabled")
+  else()
+    message(FATAL_ERROR "LTO has been requested, but the compiler does not support it\n${_lto_error}")
+  endif()
+endif()
+
+
+# Ugly (but functional) way to include "Makefile.inc" by transforming it
+# (= regenerate it).
+function(transform_makefile_inc _input_file _output_file)
+  file(READ ${_input_file} _makefile_inc_text)
+  string(REPLACE "$(top_srcdir)"   "\${PROJECT_SOURCE_DIR}" _makefile_inc_text ${_makefile_inc_text})
+  string(REPLACE "$(top_builddir)" "\${PROJECT_BINARY_DIR}" _makefile_inc_text ${_makefile_inc_text})
+
+  string(REGEX REPLACE "\\\\\n" "!π!α!" _makefile_inc_text ${_makefile_inc_text})
+  string(REGEX REPLACE "([a-zA-Z_][a-zA-Z0-9_]*)[\t ]*=[\t ]*([^\n]*)" "set(\\1 \\2)" _makefile_inc_text ${_makefile_inc_text})
+  string(REPLACE "!π!α!" "\n" _makefile_inc_text ${_makefile_inc_text})
+
+  # Replace $() with ${}
+  string(REGEX REPLACE "\\$\\(([a-zA-Z_][a-zA-Z0-9_]*)\\)" "\${\\1}" _makefile_inc_text ${_makefile_inc_text})
+  # Replace @@ with ${}, even if that may not be read by CMake scripts.
+  string(REGEX REPLACE "@([a-zA-Z_][a-zA-Z0-9_]*)@" "\${\\1}" _makefile_inc_text ${_makefile_inc_text})
+
+  file(WRITE ${_output_file} ${_makefile_inc_text})
+  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${_input_file}")
+endfunction()
+
+include(GNUInstallDirs)
+
+set(_install_cmake_dir "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
+set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
+set(_generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated")
+set(_project_config "${_generated_dir}/${PROJECT_NAME}Config.cmake")
+set(_version_config "${_generated_dir}/${PROJECT_NAME}ConfigVersion.cmake")
+
+option(BUILD_TESTING "Build tests" ON)
+if(BUILD_TESTING AND PERL_FOUND AND NOT CURL_DISABLE_TESTS)
+  set(CURL_BUILD_TESTING ON)
+else()
+  set(CURL_BUILD_TESTING OFF)
+endif()
+
+if(HAVE_MANUAL_TOOLS)
+  set(CURL_MANPAGE "${PROJECT_BINARY_DIR}/docs/cmdline-opts/curl.1")
+  set(CURL_ASCIIPAGE "${PROJECT_BINARY_DIR}/docs/cmdline-opts/curl.txt")
+  add_subdirectory(docs)
+endif()
+
+add_subdirectory(lib)
+
+if(BUILD_CURL_EXE)
+  add_subdirectory(src)
+endif()
+
+option(BUILD_EXAMPLES "Build libcurl examples" ON)
+if(BUILD_EXAMPLES)
+  add_subdirectory(docs/examples)
+endif()
+
+if(CURL_BUILD_TESTING)
+  add_subdirectory(tests)
+endif()
+
+# Helper to populate a list (_items) with a label when conditions
+# (the remaining args) are satisfied
+macro(_add_if _label)
+  # Needs to be a macro to allow this indirection
+  if(${ARGN})
+    set(_items ${_items} "${_label}")
+  endif()
+endmacro()
+
+# NTLM support requires crypto functions from various SSL libs.
+# These conditions must match those in lib/curl_setup.h.
+if(NOT CURL_DISABLE_NTLM AND
+   (USE_OPENSSL OR
+    USE_MBEDTLS OR
+    USE_GNUTLS OR
+    USE_SECTRANSP OR
+    USE_WIN32_CRYPTO OR
+    (USE_WOLFSSL AND HAVE_WOLFSSL_DES_ECB_ENCRYPT)))
+  set(_use_curl_ntlm_core ON)
+endif()
+
+# Clear list and try to detect available protocols
+unset(_items)
+_add_if("HTTP"          NOT CURL_DISABLE_HTTP)
+_add_if("HTTPS"         NOT CURL_DISABLE_HTTP AND _ssl_enabled)
+_add_if("FTP"           NOT CURL_DISABLE_FTP)
+_add_if("FTPS"          NOT CURL_DISABLE_FTP AND _ssl_enabled)
+_add_if("FILE"          NOT CURL_DISABLE_FILE)
+_add_if("TELNET"        NOT CURL_DISABLE_TELNET)
+_add_if("LDAP"          NOT CURL_DISABLE_LDAP)
+# CURL_DISABLE_LDAP implies CURL_DISABLE_LDAPS
+_add_if("LDAPS"         NOT CURL_DISABLE_LDAPS AND
+                        ((USE_OPENLDAP AND _ssl_enabled) OR
+                        (NOT USE_OPENLDAP AND HAVE_LDAP_SSL)))
+_add_if("DICT"          NOT CURL_DISABLE_DICT)
+_add_if("TFTP"          NOT CURL_DISABLE_TFTP)
+_add_if("GOPHER"        NOT CURL_DISABLE_GOPHER)
+_add_if("GOPHERS"       NOT CURL_DISABLE_GOPHER AND _ssl_enabled)
+_add_if("POP3"          NOT CURL_DISABLE_POP3)
+_add_if("POP3S"         NOT CURL_DISABLE_POP3 AND _ssl_enabled)
+_add_if("IMAP"          NOT CURL_DISABLE_IMAP)
+_add_if("IMAPS"         NOT CURL_DISABLE_IMAP AND _ssl_enabled)
+_add_if("SMB"           NOT CURL_DISABLE_SMB AND
+                        _use_curl_ntlm_core AND (SIZEOF_CURL_OFF_T GREATER 4))
+_add_if("SMBS"          NOT CURL_DISABLE_SMB AND _ssl_enabled AND
+                        _use_curl_ntlm_core AND (SIZEOF_CURL_OFF_T GREATER 4))
+_add_if("SMTP"          NOT CURL_DISABLE_SMTP)
+_add_if("SMTPS"         NOT CURL_DISABLE_SMTP AND _ssl_enabled)
+_add_if("SCP"           USE_LIBSSH2 OR USE_LIBSSH OR USE_WOLFSSH)
+_add_if("SFTP"          USE_LIBSSH2 OR USE_LIBSSH OR USE_WOLFSSH)
+_add_if("IPFS"          NOT CURL_DISABLE_IPFS)
+_add_if("IPNS"          NOT CURL_DISABLE_IPFS)
+_add_if("RTSP"          NOT CURL_DISABLE_RTSP)
+_add_if("RTMP"          USE_LIBRTMP)
+_add_if("MQTT"          NOT CURL_DISABLE_MQTT)
+_add_if("WS"            NOT CURL_DISABLE_WEBSOCKETS)
+_add_if("WSS"           NOT CURL_DISABLE_WEBSOCKETS AND _ssl_enabled)
+if(_items)
+  list(SORT _items)
+endif()
+string(REPLACE ";" " " SUPPORT_PROTOCOLS "${_items}")
+string(TOLOWER "${SUPPORT_PROTOCOLS}" _support_protocols_lower)
+message(STATUS "Protocols: ${_support_protocols_lower}")
+
+# Clear list and try to detect available features
+unset(_items)
+_add_if("SSL"           _ssl_enabled)
+_add_if("IPv6"          ENABLE_IPV6)
+_add_if("UnixSockets"   USE_UNIX_SOCKETS)
+_add_if("libz"          HAVE_LIBZ)
+_add_if("brotli"        HAVE_BROTLI)
+_add_if("gsasl"         USE_GSASL)
+_add_if("zstd"          HAVE_ZSTD)
+_add_if("AsynchDNS"     USE_ARES OR USE_THREADS_POSIX OR USE_THREADS_WIN32)
+_add_if("IDN"           (HAVE_LIBIDN2 AND HAVE_IDN2_H) OR
+                        USE_WIN32_IDN OR
+                        USE_APPLE_IDN)
+_add_if("Largefile"     (SIZEOF_CURL_OFF_T GREATER 4) AND
+                        ((SIZEOF_OFF_T GREATER 4) OR USE_WIN32_LARGE_FILES))
+_add_if("SSPI"          USE_WINDOWS_SSPI)
+_add_if("GSS-API"       HAVE_GSSAPI)
+_add_if("alt-svc"       NOT CURL_DISABLE_ALTSVC)
+_add_if("HSTS"          NOT CURL_DISABLE_HSTS)
+_add_if("SPNEGO"        NOT CURL_DISABLE_NEGOTIATE_AUTH AND
+                        (HAVE_GSSAPI OR USE_WINDOWS_SSPI))
+_add_if("Kerberos"      NOT CURL_DISABLE_KERBEROS_AUTH AND
+                        (HAVE_GSSAPI OR USE_WINDOWS_SSPI))
+_add_if("NTLM"          NOT (CURL_DISABLE_NTLM) AND
+                        (_use_curl_ntlm_core OR USE_WINDOWS_SSPI))
+_add_if("TLS-SRP"       USE_TLS_SRP)
+_add_if("HTTP2"         USE_NGHTTP2)
+_add_if("HTTP3"         USE_NGTCP2 OR USE_QUICHE OR USE_MSH3 OR USE_OPENSSL_QUIC)
+_add_if("MultiSSL"      CURL_WITH_MULTI_SSL)
+_add_if("HTTPS-proxy"   _ssl_enabled AND (USE_OPENSSL OR USE_GNUTLS
+                        OR USE_SCHANNEL OR USE_RUSTLS OR USE_BEARSSL OR
+                        USE_MBEDTLS OR USE_SECTRANSP OR
+                        (USE_WOLFSSL AND HAVE_WOLFSSL_BIO)))
+_add_if("Unicode"       ENABLE_UNICODE)
+_add_if("threadsafe"    HAVE_ATOMIC OR
+                        (USE_THREADS_POSIX AND HAVE_PTHREAD_H) OR
+                        (WIN32 AND HAVE_WIN32_WINNT GREATER_EQUAL 0x0600))
+_add_if("Debug"         ENABLE_DEBUG)
+_add_if("TrackMemory"   ENABLE_CURLDEBUG)
+_add_if("ECH"           _ssl_enabled AND HAVE_ECH)
+_add_if("PSL"           USE_LIBPSL)
+_add_if("CAcert"        CURL_CA_EMBED_SET)
+if(_items)
+  if(NOT CMAKE_VERSION VERSION_LESS 3.13)
+    list(SORT _items CASE INSENSITIVE)
+  else()
+    list(SORT _items)
+  endif()
+endif()
+string(REPLACE ";" " " SUPPORT_FEATURES "${_items}")
+message(STATUS "Features: ${SUPPORT_FEATURES}")
+
+# Clear list and collect SSL backends
+unset(_items)
+_add_if("Schannel"         _ssl_enabled AND USE_SCHANNEL)
+_add_if("OpenSSL"          _ssl_enabled AND USE_OPENSSL AND OPENSSL_VERSION VERSION_LESS 3.0.0)
+_add_if("OpenSSL v3+"      _ssl_enabled AND USE_OPENSSL AND NOT OPENSSL_VERSION VERSION_LESS 3.0.0)
+_add_if("Secure Transport" _ssl_enabled AND USE_SECTRANSP)
+_add_if("mbedTLS"          _ssl_enabled AND USE_MBEDTLS)
+_add_if("BearSSL"          _ssl_enabled AND USE_BEARSSL)
+_add_if("wolfSSL"          _ssl_enabled AND USE_WOLFSSL)
+_add_if("GnuTLS"           _ssl_enabled AND USE_GNUTLS)
+_add_if("rustls"           _ssl_enabled AND USE_RUSTLS)
+
+if(_items)
+  if(NOT CMAKE_VERSION VERSION_LESS 3.13)
+    list(SORT _items CASE INSENSITIVE)
+  else()
+    list(SORT _items)
+  endif()
+endif()
+string(REPLACE ";" " " SSL_BACKENDS "${_items}")
+message(STATUS "Enabled SSL backends: ${SSL_BACKENDS}")
+if(CURL_DEFAULT_SSL_BACKEND)
+  message(STATUS "Default SSL backend: ${CURL_DEFAULT_SSL_BACKEND}")
+endif()
+
+if(NOT CURL_DISABLE_INSTALL)
+
+  # curl-config needs the following options to be set.
+  set(CC                      "${CMAKE_C_COMPILER}")
+  # TODO: probably put a -D... options here?
+  set(CONFIGURE_OPTIONS       "")
+  set(CURLVERSION             "${_curl_version}")
+  set(VERSIONNUM              "${_curl_version_num}")
+  set(prefix                  "${CMAKE_INSTALL_PREFIX}")
+  set(exec_prefix             "\${prefix}")
+  if(IS_ABSOLUTE ${CMAKE_INSTALL_INCLUDEDIR})
+    set(includedir            "${CMAKE_INSTALL_INCLUDEDIR}")
+  else()
+    set(includedir            "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+  endif()
+  if(IS_ABSOLUTE ${CMAKE_INSTALL_LIBDIR})
+    set(libdir                "${CMAKE_INSTALL_LIBDIR}")
+  else()
+    set(libdir                "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
+  endif()
+  # "a" (Linux) or "lib" (Windows)
+  string(REPLACE "." "" libext "${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+  set(_ldflags "")
+  set(LIBCURL_PC_LIBS_PRIVATE "")
+
+  # Filter CMAKE_SHARED_LINKER_FLAGS for libs and libpaths
+  string(STRIP "${CMAKE_SHARED_LINKER_FLAGS}" _custom_ldflags)
+  string(REGEX REPLACE " +-([^ \\t;]*)" ";-\\1" _custom_ldflags "${_custom_ldflags}")
+
+  set(_custom_libs "")
+  set(_custom_libdirs "")
+  foreach(_flag IN LISTS _custom_ldflags)
+    if(_flag MATCHES "^-l")
+      string(REGEX REPLACE "^-l" "" _flag "${_flag}")
+      list(APPEND _custom_libs "${_flag}")
+    elseif(_flag MATCHES "^-framework|^-F")
+      list(APPEND _custom_libs "${_flag}")
+    elseif(_flag MATCHES "^-L")
+      string(REGEX REPLACE "^-L" "" _flag "${_flag}")
+      list(APPEND _custom_libdirs "${_flag}")
+    elseif(_flag MATCHES "^--library-path=")
+      string(REGEX REPLACE "^--library-path=" "" _flag "${_flag}")
+      list(APPEND _custom_libdirs "${_flag}")
+    endif()
+  endforeach()
+
+  # Avoid getting unnecessary -L options for known system directories.
+  unset(_sys_libdirs)
+  foreach(_libdir IN LISTS CMAKE_SYSTEM_PREFIX_PATH)
+    if(_libdir MATCHES "/$")
+      set(_libdir "${_libdir}lib")
+    else()
+      set(_libdir "${_libdir}/lib")
+    endif()
+    if(IS_DIRECTORY "${_libdir}")
+      list(APPEND _sys_libdirs "${_libdir}")
+    endif()
+    if(DEFINED CMAKE_LIBRARY_ARCHITECTURE)
+      set(_libdir "${_libdir}/${CMAKE_LIBRARY_ARCHITECTURE}")
+      if(IS_DIRECTORY "${_libdir}")
+        list(APPEND _sys_libdirs "${_libdir}")
+      endif()
+    endif()
+  endforeach()
+
+  foreach(_libdir IN LISTS _custom_libdirs CURL_LIBDIRS)
+    list(FIND _sys_libdirs "${_libdir}" _libdir_index)
+    if(_libdir_index LESS 0)
+      list(APPEND _ldflags "-L${_libdir}")
+    endif()
+  endforeach()
+
+  unset(_implicit_libs)
+  if(NOT MINGW AND NOT UNIX)
+    set(_implicit_libs ${CMAKE_C_IMPLICIT_LINK_LIBRARIES})
+  endif()
+
+  foreach(_lib IN LISTS _implicit_libs _custom_libs CURL_LIBS)
+    if(TARGET "${_lib}")
+      set(_libname "${_lib}")
+      get_target_property(_imported "${_libname}" IMPORTED)
+      if(NOT _imported)
+        # Reading the LOCATION property on non-imported target will error out.
+        # Assume the user will not need this information in the .pc file.
+        continue()
+      endif()
+      get_target_property(_lib "${_libname}" LOCATION)
+      if(NOT _lib)
+        message(WARNING "Bad lib in library list: ${_libname}")
+        continue()
+      endif()
+    endif()
+    if(_lib MATCHES "^-")  # '-framework <name>'
+      list(APPEND _ldflags "${_lib}")
+    elseif(_lib MATCHES ".*/.*")
+      # This gets a bit more complex, because we want to specify the
+      # directory separately, and only once per directory
+      get_filename_component(_libdir ${_lib} DIRECTORY)
+      get_filename_component(_libname ${_lib} NAME_WE)
+      if(_libname MATCHES "^lib")
+        list(FIND _sys_libdirs "${_libdir}" _libdir_index)
+        if(_libdir_index LESS 0)
+          list(APPEND _ldflags "-L${_libdir}")
+        endif()
+        string(REGEX REPLACE "^lib" "" _libname "${_libname}")
+        list(APPEND LIBCURL_PC_LIBS_PRIVATE "-l${_libname}")
+      else()
+        list(APPEND LIBCURL_PC_LIBS_PRIVATE "${_lib}")
+      endif()
+    else()
+      list(APPEND LIBCURL_PC_LIBS_PRIVATE "-l${_lib}")
+    endif()
+  endforeach()
+
+  if(LIBCURL_PC_REQUIRES_PRIVATE)
+    string(REPLACE ";" "," LIBCURL_PC_REQUIRES_PRIVATE "${LIBCURL_PC_REQUIRES_PRIVATE}")
+  endif()
+  if(LIBCURL_PC_LIBS_PRIVATE)
+    string(REPLACE ";" " " LIBCURL_PC_LIBS_PRIVATE "${LIBCURL_PC_LIBS_PRIVATE}")
+  endif()
+  if(_ldflags)
+    list(REMOVE_DUPLICATES _ldflags)
+    string(REPLACE ";" " " _ldflags "${_ldflags}")
+    set(LIBCURL_PC_LDFLAGS_PRIVATE "${_ldflags}")
+    string(STRIP "${LIBCURL_PC_LDFLAGS_PRIVATE}" LIBCURL_PC_LDFLAGS_PRIVATE)
+  else()
+    set(LIBCURL_PC_LDFLAGS_PRIVATE "")
+  endif()
+  set(LIBCURL_PC_CFLAGS_PRIVATE "-DCURL_STATICLIB")
+
+  # Merge pkg-config private fields into public ones when static-only
+  if(BUILD_SHARED_LIBS)
+    set(ENABLE_SHARED       "yes")
+    set(LIBCURL_PC_REQUIRES "")
+    set(LIBCURL_PC_LIBS     "")
+    set(LIBCURL_PC_CFLAGS   "")
+  else()
+    set(ENABLE_SHARED       "no")
+    set(LIBCURL_PC_REQUIRES "${LIBCURL_PC_REQUIRES_PRIVATE}")
+    set(LIBCURL_PC_LIBS     "${LIBCURL_PC_LIBS_PRIVATE}")
+    set(LIBCURL_PC_CFLAGS   "${LIBCURL_PC_CFLAGS_PRIVATE}")
+  endif()
+  if(BUILD_STATIC_LIBS)
+    set(ENABLE_STATIC       "yes")
+  else()
+    set(ENABLE_STATIC       "no")
+  endif()
+
+  # Generate a "curl-config" matching this config.
+  # Consumed variables:
+  #   CC
+  #   CONFIGURE_OPTIONS
+  #   CURLVERSION
+  #   CURL_CA_BUNDLE
+  #   ENABLE_SHARED
+  #   ENABLE_STATIC
+  #   exec_prefix
+  #   includedir
+  #   LIBCURL_PC_CFLAGS
+  #   LIBCURL_PC_LDFLAGS_PRIVATE
+  #   LIBCURL_PC_LIBS_PRIVATE
+  #   libdir
+  #   libext
+  #   prefix
+  #   SSL_BACKENDS
+  #   SUPPORT_FEATURES
+  #   SUPPORT_PROTOCOLS
+  #   VERSIONNUM
+  configure_file(
+    "${PROJECT_SOURCE_DIR}/curl-config.in"
+    "${PROJECT_BINARY_DIR}/curl-config" @ONLY)
+  install(FILES "${PROJECT_BINARY_DIR}/curl-config"
+    DESTINATION ${CMAKE_INSTALL_BINDIR}
+    PERMISSIONS
+      OWNER_READ OWNER_WRITE OWNER_EXECUTE
+      GROUP_READ GROUP_EXECUTE
+      WORLD_READ WORLD_EXECUTE)
+
+  # Generate a pkg-config file matching this config.
+  # Consumed variables:
+  #   CURLVERSION
+  #   exec_prefix
+  #   includedir
+  #   LIBCURL_PC_CFLAGS
+  #   LIBCURL_PC_CFLAGS_PRIVATE
+  #   LIBCURL_PC_LDFLAGS_PRIVATE
+  #   LIBCURL_PC_LIBS
+  #   LIBCURL_PC_LIBS_PRIVATE
+  #   LIBCURL_PC_REQUIRES
+  #   LIBCURL_PC_REQUIRES_PRIVATE
+  #   libdir
+  #   prefix
+  #   SUPPORT_FEATURES
+  #   SUPPORT_PROTOCOLS
+  # Documentation:
+  #   https://people.freedesktop.org/~dbn/pkg-config-guide.html
+  #   https://manpages.debian.org/unstable/pkgconf/pkg-config.1.en.html
+  #   https://manpages.debian.org/unstable/pkg-config/pkg-config.1.en.html
+  #   https://www.msys2.org/docs/pkgconfig/
+  configure_file(
+    "${PROJECT_SOURCE_DIR}/libcurl.pc.in"
+    "${PROJECT_BINARY_DIR}/libcurl.pc" @ONLY)
+  install(FILES "${PROJECT_BINARY_DIR}/libcurl.pc"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+
+  # Install headers
+  install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/curl"
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    FILES_MATCHING PATTERN "*.h")
+
+  include(CMakePackageConfigHelpers)
+  write_basic_package_version_file(
+    "${_version_config}"
+    VERSION ${_curl_version}
+    COMPATIBILITY SameMajorVersion)
+  file(READ "${_version_config}" _generated_version_config)
+  file(WRITE "${_version_config}" "
+    if(NOT PACKAGE_FIND_VERSION_RANGE AND PACKAGE_FIND_VERSION_MAJOR STREQUAL \"7\")
+      # Version 8 satisfies version 7... requirements
+      set(PACKAGE_FIND_VERSION_MAJOR 8)
+      set(PACKAGE_FIND_VERSION_COUNT 1)
+    endif()
+    ${_generated_version_config}")
+
+  # Consumed custom variables:
+  #   LIB_SELECTED
+  #   TARGETS_EXPORT_NAME
+  #   USE_OPENSSL
+  #   HAVE_LIBZ
+  configure_package_config_file("CMake/curl-config.cmake.in"
+    "${_project_config}"
+    INSTALL_DESTINATION ${_install_cmake_dir}
+    PATH_VARS CMAKE_INSTALL_INCLUDEDIR)
+
+  if(CURL_ENABLE_EXPORT_TARGET)
+    install(EXPORT "${TARGETS_EXPORT_NAME}"
+      NAMESPACE "${PROJECT_NAME}::"
+      DESTINATION ${_install_cmake_dir})
+  endif()
+
+  install(FILES ${_version_config} ${_project_config}
+    DESTINATION ${_install_cmake_dir})
+
+  # Workaround for MSVS10 to avoid the Dialog Hell
+  # FIXME: This could be removed with future version of CMake.
+  if(MSVC_VERSION EQUAL 1600)
+    set(_curl_sln_filename "${CMAKE_CURRENT_BINARY_DIR}/CURL.sln")
+    if(EXISTS "${_curl_sln_filename}")
+      file(APPEND "${_curl_sln_filename}" "\n# This should be regenerated!\n")
+    endif()
+  endif()
+
+  if(NOT TARGET curl_uninstall)
+    configure_file(
+      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/cmake_uninstall.cmake.in"
+      "${CMAKE_CURRENT_BINARY_DIR}/CMake/cmake_uninstall.cmake"
+      @ONLY)
+
+    add_custom_target(curl_uninstall
+      COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_BINARY_DIR}/CMake/cmake_uninstall.cmake")
+  endif()
+
+  install(FILES "${PROJECT_SOURCE_DIR}/scripts/mk-ca-bundle.pl"
+    DESTINATION ${CMAKE_INSTALL_BINDIR}
+    PERMISSIONS
+      OWNER_READ OWNER_WRITE OWNER_EXECUTE
+      GROUP_READ GROUP_EXECUTE
+      WORLD_READ WORLD_EXECUTE)
+
+  # The `-DEV` part is important
+  string(REGEX REPLACE "([0-9]+\.[0-9]+)\.([0-9]+.*)" "\\2" CPACK_PACKAGE_VERSION_PATCH "${_curl_version}")
+  set(CPACK_GENERATOR "TGZ")
+  include(CPack)
+endif()
+
+# Save build info for test runner to pick up and log
+if(CMAKE_OSX_SYSROOT)
+  set(_cmake_sysroot ${CMAKE_OSX_SYSROOT})
+elseif(CMAKE_SYSROOT)
+  set(_cmake_sysroot ${CMAKE_SYSROOT})
+endif()
+set(_buildinfo "\
+buildinfo.configure.tool: cmake
+buildinfo.configure.command: ${CMAKE_COMMAND}
+buildinfo.configure.version: ${CMAKE_VERSION}
+buildinfo.configure.args:${_cmake_args}
+buildinfo.configure.generator: ${CMAKE_GENERATOR}
+buildinfo.configure.make: ${CMAKE_MAKE_PROGRAM}
+buildinfo.host.cpu: ${CMAKE_HOST_SYSTEM_PROCESSOR}
+buildinfo.host.os: ${CMAKE_HOST_SYSTEM_NAME}
+buildinfo.target.cpu: ${CMAKE_SYSTEM_PROCESSOR}
+buildinfo.target.os: ${CMAKE_SYSTEM_NAME}
+buildinfo.target.flags:${_target_flags}
+buildinfo.compiler: ${CMAKE_C_COMPILER_ID}
+buildinfo.compiler.version: ${CMAKE_C_COMPILER_VERSION}
+buildinfo.sysroot: ${_cmake_sysroot}
+")
+file(WRITE "${PROJECT_BINARY_DIR}/buildinfo.txt" "# This is a generated file.  Do not edit.\n${_buildinfo}")
+if(NOT "$ENV{CURL_BUILDINFO}$ENV{CURL_CI}$ENV{CI}" STREQUAL "")
+  message(STATUS "\n${_buildinfo}")
+endif()

local-test-curl-delta-01/afc-curl/COPYING

@@ -0,0 +1,22 @@
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright (c) 1996 - 2024, Daniel Stenberg, <daniel@haxx.se>, and many
+contributors, see the THANKS file.
+
+All rights reserved.
+
+Permission to use, copy, modify, and distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright
+notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall not
+be used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization of the copyright holder.

local-test-curl-delta-01/afc-curl/Dockerfile

@@ -0,0 +1,41 @@
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# SPDX-License-Identifier: curl
+
+# Self-contained build environment to match the release environment.
+#
+# Build and set the timestamp for the date corresponding to the release
+#
+#   docker build --build-arg SOURCE_DATE_EPOCH=1711526400 --build-arg UID=$(id -u) --build-arg GID=$(id -g) -t curl/curl .
+#
+# Then run commands from within the build environment, for example
+#
+#   docker run --rm -it -u $(id -u):$(id -g) -v $(pwd):/usr/src -w /usr/src curl/curl autoreconf -fi
+#   docker run --rm -it -u $(id -u):$(id -g) -v $(pwd):/usr/src -w /usr/src curl/curl ./configure --without-ssl --without-libpsl
+#   docker run --rm -it -u $(id -u):$(id -g) -v $(pwd):/usr/src -w /usr/src curl/curl make
+#   docker run --rm -it -u $(id -u):$(id -g) -v $(pwd):/usr/src -w /usr/src curl/curl ./scripts/maketgz 8.7.1
+#
+# or get into a shell in the build environment, for example
+#
+#   docker run --rm -it -u $(id -u):$(id -g) -v (pwd):/usr/src -w /usr/src curl/curl bash
+#   $ autoreconf -fi
+#   $ ./configure --without-ssl --without-libpsl
+#   $ make
+#   $ ./scripts/maketgz 8.7.1
+
+# To update, get the latest digest e.g. from https://hub.docker.com/_/debian/tags
+FROM debian:bookworm-slim@sha256:b73bf02f32434c9be21adf83b9aedf33e731784d8d2dacbbd3ce5f4993f2a2de
+
+RUN apt-get update -qq && apt-get install -qq -y --no-install-recommends \
+    build-essential make autoconf automake libtool git perl zip zlib1g-dev gawk && \
+    rm -rf /var/lib/apt/lists/*
+
+ARG UID=1000 GID=1000
+
+RUN groupadd --gid $UID dev && \
+    useradd --uid $UID --gid dev --shell /bin/bash --create-home dev
+
+USER dev:dev
+
+ARG SOURCE_DATE_EPOCH
+ENV SOURCE_DATE_EPOCH=${SOURCE_DATE_EPOCH:-1}

local-test-curl-delta-01/afc-curl/GIT-INFO.md

@@ -0,0 +1,32 @@
+                                  _   _ ____  _
+                              ___| | | |  _ \| |
+                             / __| | | | |_) | |
+                            | (__| |_| |  _ <| |___
+                             \___|\___/|_| \_\_____|
+
+# GIT-INFO
+
+This file is only present in git - never in release archives. It contains
+information about other files and things that the git repository keeps in its
+inner sanctum.
+
+To build in environments that support configure, after having extracted
+everything from git, do this:
+
+    autoreconf -fi
+    ./configure --with-openssl
+    make
+
+Daniel uses a configure line similar to this for easier development:
+
+    ./configure --disable-shared --enable-debug --enable-maintainer-mode
+
+In environments that don't support configure (i.e. Windows), do this:
+
+    buildconf.bat
+
+## REQUIREMENTS
+
+See [docs/INTERNALS.md][0] for requirement details.
+
+[0]: docs/INTERNALS.md

local-test-curl-delta-01/afc-curl/Makefile.am

@@ -0,0 +1,252 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+###########################################################################
+
+AUTOMAKE_OPTIONS = foreign
+
+ACLOCAL_AMFLAGS = -I m4
+
+CMAKE_DIST =                                    \
+ CMake/cmake_uninstall.cmake.in                 \
+ CMake/CMakeConfigurableFile.in                 \
+ CMake/curl-config.cmake.in                     \
+ CMake/CurlSymbolHiding.cmake                   \
+ CMake/CurlTests.c                              \
+ CMake/FindBearSSL.cmake                        \
+ CMake/FindBrotli.cmake                         \
+ CMake/FindCares.cmake                          \
+ CMake/FindGSS.cmake                            \
+ CMake/FindLibgsasl.cmake                       \
+ CMake/FindLibidn2.cmake                        \
+ CMake/FindLibpsl.cmake                         \
+ CMake/FindLibssh.cmake                         \
+ CMake/FindLibssh2.cmake                        \
+ CMake/FindLibuv.cmake                          \
+ CMake/FindMbedTLS.cmake                        \
+ CMake/FindMSH3.cmake                           \
+ CMake/FindMbedTLS.cmake                        \
+ CMake/FindNGHTTP2.cmake                        \
+ CMake/FindNGHTTP3.cmake                        \
+ CMake/FindNGTCP2.cmake                         \
+ CMake/FindNettle.cmake                         \
+ CMake/FindQuiche.cmake                         \
+ CMake/FindRustls.cmake                         \
+ CMake/FindWolfSSH.cmake                        \
+ CMake/FindWolfSSL.cmake                        \
+ CMake/FindZstd.cmake                           \
+ CMake/Macros.cmake                             \
+ CMake/OtherTests.cmake                         \
+ CMake/PickyWarnings.cmake                      \
+ CMake/Platforms/WindowsCache.cmake             \
+ CMake/Utilities.cmake                          \
+ CMakeLists.txt
+
+VC_DIST = projects/README.md                           \
+ projects/build-openssl.bat                            \
+ projects/build-wolfssl.bat                            \
+ projects/checksrc.bat                                 \
+ projects/generate.bat                                 \
+ projects/wolfssl_options.h                            \
+ projects/wolfssl_override.props
+
+WINBUILD_DIST = winbuild/README.md \
+ winbuild/MakefileBuild.vc winbuild/Makefile.vc winbuild/makedebug.bat
+
+PLAN9_DIST = plan9/include/mkfile \
+ plan9/include/mkfile             \
+ plan9/mkfile.proto               \
+ plan9/mkfile                     \
+ plan9/README                     \
+ plan9/lib/mkfile.inc             \
+ plan9/lib/mkfile                 \
+ plan9/src/mkfile.inc             \
+ plan9/src/mkfile
+
+EXTRA_DIST = CHANGES.md COPYING Makefile.dist             \
+ RELEASE-NOTES $(CMAKE_DIST) $(VC_DIST) $(WINBUILD_DIST)  \
+ $(PLAN9_DIST) buildconf.bat Dockerfile
+
+CLEANFILES = $(VC14_LIBVCXPROJ) $(VC14_SRCVCXPROJ) \
+ $(VC14_10_LIBVCXPROJ) $(VC14_10_SRCVCXPROJ)       \
+ $(VC14_20_LIBVCXPROJ) $(VC14_20_SRCVCXPROJ)       \
+ $(VC14_30_LIBVCXPROJ) $(VC14_30_SRCVCXPROJ)
+
+DISTCLEANFILES = buildinfo.txt
+
+bin_SCRIPTS = curl-config
+
+SUBDIRS = lib docs src scripts
+DIST_SUBDIRS = $(SUBDIRS) tests packages include docs
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = libcurl.pc
+
+# List of files required to generate VC IDE .dsp, .vcproj and .vcxproj files
+include lib/Makefile.inc
+include src/Makefile.inc
+
+dist-hook:
+	rm -rf $(top_builddir)/tests/log
+	find $(distdir) -name "*.dist" -a \! -name Makefile.dist -exec rm {} \;
+	(distit=`find $(srcdir) -name "*.dist" | grep -v Makefile`; \
+	for file in $$distit; do \
+	  strip=`echo $$file | sed -e s/^$(srcdir)// -e s/\.dist//`; \
+	  cp -p $$file $(distdir)$$strip; \
+	done)
+
+check: test examples check-docs
+
+if CROSSCOMPILING
+test-full: test
+test-nonflaky: test
+test-torture: test
+test-event: test
+test-am: test
+test-ci: test
+pytest: test
+pytest-ci: test
+
+test:
+	@echo "NOTICE: we can't run the tests when cross-compiling!"
+
+else
+
+test:
+	@(cd tests; $(MAKE) all quiet-test)
+
+test-full:
+	@(cd tests; $(MAKE) all full-test)
+
+test-nonflaky:
+	@(cd tests; $(MAKE) all nonflaky-test)
+
+test-torture:
+	@(cd tests; $(MAKE) all torture-test)
+
+test-event:
+	@(cd tests; $(MAKE) all event-test)
+
+test-am:
+	@(cd tests; $(MAKE) all am-test)
+
+test-ci:
+	@(cd tests; $(MAKE) all ci-test)
+
+pytest:
+	@(cd tests; $(MAKE) all default-pytest)
+
+pytest-ci:
+	@(cd tests; $(MAKE) all ci-pytest)
+
+endif
+
+examples:
+	@(cd docs/examples; $(MAKE) check)
+
+check-docs:
+	@(cd docs/libcurl; $(MAKE) check)
+
+# Build source and binary rpms. For rpm-3.0 and above, the ~/.rpmmacros
+# must contain the following line:
+# %_topdir /home/loic/local/rpm
+# and that /home/loic/local/rpm contains the directory SOURCES, BUILD etc.
+#
+# cd /home/loic/local/rpm ; mkdir -p SOURCES BUILD RPMS/i386 SPECS SRPMS
+#
+# If additional configure flags are needed to build the package, add the
+# following in ~/.rpmmacros
+# %configure CFLAGS="%{optflags}" ./configure %{_target_platform} --prefix=%{_prefix} ${AM_CONFIGFLAGS}
+# and run make rpm in the following way:
+# AM_CONFIGFLAGS='--with-uri=/home/users/loic/local/RedHat-6.2' make rpm
+#
+
+rpms:
+	$(MAKE) RPMDIST=curl rpm
+	$(MAKE) RPMDIST=curl-ssl rpm
+
+rpm:
+	RPM_TOPDIR=`rpm --showrc | $(PERL) -n -e 'print if(s/.*_topdir\s+(.*)/$$1/)'` ; \
+	cp $(srcdir)/packages/Linux/RPM/$(RPMDIST).spec $$RPM_TOPDIR/SPECS ; \
+	cp $(PACKAGE)-$(VERSION).tar.gz $$RPM_TOPDIR/SOURCES ; \
+	rpm -ba --clean --rmsource $$RPM_TOPDIR/SPECS/$(RPMDIST).spec ; \
+	mv $$RPM_TOPDIR/RPMS/i386/$(RPMDIST)-*.rpm . ; \
+	mv $$RPM_TOPDIR/SRPMS/$(RPMDIST)-*.src.rpm .
+
+#
+# Build a Solaris pkgadd format file
+# run 'make pkgadd' once you've done './configure' and 'make' to make a Solaris pkgadd format
+# file (which ends up back in this directory).
+# The pkgadd file is in 'pkgtrans' format, so to install on Solaris, do
+# pkgadd -d ./HAXXcurl-*
+#
+
+# gak - libtool requires an absolute directory, hence the pwd below...
+pkgadd:
+	umask 022 ; \
+	$(MAKE) install DESTDIR=`/bin/pwd`/packages/Solaris/root ; \
+	cat COPYING > $(srcdir)/packages/Solaris/copyright ; \
+	cd $(srcdir)/packages/Solaris && $(MAKE) package
+
+#
+# Build a Cygwin binary tarball installation file
+# resulting .tar.bz2 file will end up at packages/Win32/cygwin
+cygwinbin:
+	$(MAKE) -C packages/Win32/cygwin cygwinbin
+
+# We extend the standard install with a custom hook:
+if BUILD_DOCS
+install-data-hook:
+	(cd include && $(MAKE) install)
+	(cd docs && $(MAKE) install)
+	(cd docs/libcurl && $(MAKE) install)
+else
+install-data-hook:
+	(cd include && $(MAKE) install)
+	(cd docs && $(MAKE) install)
+endif
+
+# We extend the standard uninstall with a custom hook:
+uninstall-hook:
+	(cd include && $(MAKE) uninstall)
+	(cd docs && $(MAKE) uninstall)
+	(cd docs/libcurl && $(MAKE) uninstall)
+
+ca-bundle: $(srcdir)/scripts/mk-ca-bundle.pl
+	@echo "generating a fresh ca-bundle.crt"
+	@perl $(srcdir)/scripts/mk-ca-bundle.pl -b -l -u lib/ca-bundle.crt
+
+ca-firefox: $(srcdir)/scripts/firefox-db2pem.sh
+	@echo "generating a fresh ca-bundle.crt"
+	$(srcdir)/scripts/firefox-db2pem.sh lib/ca-bundle.crt
+
+checksrc:
+	(cd lib && $(MAKE) checksrc)
+	(cd src && $(MAKE) checksrc)
+	(cd tests && $(MAKE) checksrc)
+	(cd include/curl && $(MAKE) checksrc)
+	(cd docs/examples && $(MAKE) checksrc)
+	(cd packages && $(MAKE) checksrc)
+
+tidy:
+	(cd src && $(MAKE) tidy)
+	(cd lib && $(MAKE) tidy)

local-test-curl-delta-01/afc-curl/Makefile.dist

@@ -0,0 +1,71 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+###########################################################################
+
+all:
+	./configure
+	make
+
+ssl:
+	./configure --with-openssl
+	make
+
+vc:
+	cd winbuild
+	nmake /f Makefile.vc MACHINE=x86
+
+vc-x64:
+	cd winbuild
+	nmake /f Makefile.vc MACHINE=x64
+
+djgpp%:
+	$(MAKE) -C lib -f Makefile.mk CFG=$@ CROSSPREFIX=i586-pc-msdosdjgpp-
+	$(MAKE) -C src -f Makefile.mk CFG=$@ CROSSPREFIX=i586-pc-msdosdjgpp-
+
+cygwin:
+	./configure
+	make
+
+cygwin-ssl:
+	./configure --with-openssl
+	make
+
+amiga%:
+	$(MAKE) -C lib -f Makefile.mk CFG=$@ CROSSPREFIX=m68k-amigaos-
+	$(MAKE) -C src -f Makefile.mk CFG=$@ CROSSPREFIX=m68k-amigaos-
+
+unix: all
+
+unix-ssl: ssl
+
+linux: all
+
+linux-ssl: ssl
+
+ca-bundle: scripts/mk-ca-bundle.pl
+	@echo "generate a fresh ca-bundle.crt"
+	@perl $< -b -l -u lib/ca-bundle.crt
+
+ca-firefox: scripts/firefox-db2pem.sh
+	@echo "generate a fresh ca-bundle.crt"
+	./scripts/firefox-db2pem.sh lib/ca-bundle.crt

local-test-curl-delta-01/afc-curl/README

@@ -0,0 +1,55 @@
+                                  _   _ ____  _
+                              ___| | | |  _ \| |
+                             / __| | | | |_) | |
+                            | (__| |_| |  _ <| |___
+                             \___|\___/|_| \_\_____|
+
+README
+
+  Curl is a command line tool for transferring data specified with URL
+  syntax. Find out how to use curl by reading the curl.1 man page or the
+  MANUAL document. Find out how to install Curl by reading the INSTALL
+  document.
+
+  libcurl is the library curl is using to do its job. It is readily
+  available to be used by your software. Read the libcurl.3 man page to
+  learn how.
+
+  You find answers to the most frequent questions we get in the FAQ document.
+
+  Study the COPYING file for distribution terms.
+
+  Those documents and more can be found in the docs/ directory.
+
+CONTACT
+
+  If you have problems, questions, ideas or suggestions, please contact us
+  by posting to a suitable mailing list. See https://curl.se/mail/
+
+  All contributors to the project are listed in the THANKS document.
+
+WEBSITE
+
+  Visit the curl website for the latest news and downloads:
+
+        https://curl.se/
+
+GIT
+
+  To download the latest source code off the GIT server, do this:
+
+    git clone https://github.com/curl/curl.git
+
+  (you will get a directory named curl created, filled with the source code)
+
+SECURITY PROBLEMS
+
+  Report suspected security problems via our HackerOne page and not in public.
+
+    https://hackerone.com/curl
+
+NOTICE
+
+  Curl contains pieces of source code that is Copyright (c) 1998, 1999
+  Kungliga Tekniska Högskolan. This notice is included here to comply with the
+  distribution terms.

local-test-curl-delta-01/afc-curl/README.md

@@ -0,0 +1,68 @@
+<!--
+Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+
+SPDX-License-Identifier: curl
+-->
+
+# [![curl logo](https://curl.se/logo/curl-logo.svg)](https://curl.se/)
+
+Curl is a command-line tool for transferring data specified with URL syntax.
+Learn how to use curl by reading [the
+manpage](https://curl.se/docs/manpage.html) or [everything
+curl](https://everything.curl.dev/).
+
+Find out how to install curl by reading [the INSTALL
+document](https://curl.se/docs/install.html).
+
+libcurl is the library curl is using to do its job. It is readily available to
+be used by your software. Read [the libcurl
+manpage](https://curl.se/libcurl/c/libcurl.html) to learn how.
+
+## Open Source
+
+curl is Open Source and is distributed under an MIT-like
+[license](https://curl.se/docs/copyright.html).
+
+## Contact
+
+Contact us on a suitable [mailing list](https://curl.se/mail/) or
+use GitHub [issues](https://github.com/curl/curl/issues)/
+[pull requests](https://github.com/curl/curl/pulls)/
+[discussions](https://github.com/curl/curl/discussions).
+
+All contributors to the project are listed in [the THANKS
+document](https://curl.se/docs/thanks.html).
+
+## Commercial support
+
+For commercial support, maybe private and dedicated help with your problems or
+applications using (lib)curl visit [the support page](https://curl.se/support.html).
+
+## Website
+
+Visit the [curl website](https://curl.se/) for the latest news and downloads.
+
+## Source code
+
+Download the latest source from the Git server:
+
+    git clone https://github.com/curl/curl.git
+
+## Security problems
+
+Report suspected security problems via [our HackerOne
+page](https://hackerone.com/curl) and not in public.
+
+## Notice
+
+Curl contains pieces of source code that is Copyright (c) 1998, 1999 Kungliga
+Tekniska Högskolan. This notice is included here to comply with the
+distribution terms.
+
+## Backers
+
+Thank you to all our backers 🙏 [Become a backer](https://opencollective.com/curl#section-contribute).
+
+## Sponsors
+
+Support this project by becoming a [sponsor](https://curl.se/sponsors.html).

local-test-curl-delta-01/afc-curl/RELEASE-NOTES

@@ -0,0 +1,197 @@
+curl and libcurl 8.11.1
+
+ Public curl releases:         263
+ Command line options:         266
+ curl_easy_setopt() options:   306
+ Public functions in libcurl:  94
+ Contributors:                 3298
+
+This release includes the following changes:
+
+
+This release includes the following bugfixes:
+
+ o build: fix ECH to always enable HTTPS RR [35]
+ o build: fix MSVC UWP builds [32]
+ o build: omit certain deps from `libcurl.pc` unless found via `pkg-config` [27]
+ o build: use `_fseeki64()` on Windows, drop detections [41]
+ o cmake: do not echo most inherited `LDFLAGS` to config files [55]
+ o cmake: drop cmake args list from `buildinfo.txt` [8]
+ o cmake: include `wolfssl/options.h` first [53]
+ o cmake: remove legacy unused IMMEDIATE keyword [21]
+ o cmake: restore cmake args list in `buildinfo.txt` [26]
+ o cmake: set `CURL_STATICLIB` for static lib when `SHARE_LIB_OBJECT=OFF` [64]
+ o cmake: sync GSS config code with other deps [28]
+ o cmake: typo in comment
+ o cmake: work around `ios.toolchain.cmake` breaking feature-detections [37]
+ o cmakelint: fix to check root `CMakeLists.txt` [36]
+ o cmdline/ech.md: formatting cleanups [13]
+ o configure: add FIXMEs for disabled pkg-config references
+ o configure: do not echo most inherited `LDFLAGS` to config files [31]
+ o configure: replace `$#` shell syntax [25]
+ o cookie: treat cookie name case sensitively [4]
+ o curl-rustls.m4: keep existing `CPPFLAGS`/`LDFLAGS` when detected [40]
+ o curl.h: mark two error codes as obsolete [19]
+ o curl: --continue-at is mutually exclusive with --no-clobber [51]
+ o curl: --continue-at is mutually exclusive with --range [61]
+ o curl: --continue-at is mutually exclusive with --remove-on-error [50]
+ o curl: --test-duphandle in debug builds runs "duphandled" [6]
+ o curl: do more command line parsing in sub functions [71]
+ o curl: rename struct var to fix AIX build [24]
+ o curl: use realtime in trace timestamps [52]
+ o curl_multi_socket_all.md: soften the deprecation warning [56]
+ o CURLOPT_PREREQFUNCTION.md: add result code on failure [23]
+ o digest: produce a shorter cnonce in Digest headers [70]
+ o DISTROS: update Alt Linux links
+ o dmaketgz: use --no-cache when building docker image [66]
+ o docs: document default `User-Agent` [57]
+ o docs: suggest --ssl-reqd instead of --ftp-ssl [62]
+ o duphandle: also init netrc [3]
+ o ECH: enable support for the AWS-LC backend [5]
+ o hostip: don't use the resolver for FQDN localhost [45]
+ o http_negotiate: allow for a one byte larger channel binding buffer [63]
+ o http_proxy: move dynhds_add_custom here from http.c [18]
+ o KNOWN_BUGS: setting a disabled option should return CURLE_NOT_BUILT_IN [74]
+ o krb5: fix socket/sockindex confusion, MSVC compiler warnings [22]
+ o lib: fixes for wolfSSL OPENSSL_COEXIST [73]
+ o libssh: use libssh sftp_aio to upload file [47]
+ o libssh: when using IPv6 numerical address, add brackets [43]
+ o macos: disable gcc `availability` workaround as needed [7]
+ o mbedtls: call psa_crypt_init() in global init [2]
+ o mime: fix reader stall on small read lengths [65]
+ o mk-ca-bundle: remove CKA_NSS_SERVER_DISTRUST_AFTER conditions [39]
+ o multi: add clarifying comment for wakeup_write() [9]
+ o multi: fix callback for `CURLMOPT_TIMERFUNCTION` not being called again when... [48]
+ o netrc: address several netrc parser flaws [17]
+ o netrc: support large file, longer lines, longer tokens [14]
+ o nghttp2: use custom memory functions [1]
+ o OpenSSL: improvde error message on expired certificate [59]
+ o openssl: remove three "Useless Assignments" [72]
+ o openssl: stop using SSL_CTX_ function prefix for our functions [20]
+ o os400: Fix IBMi builds [33]
+ o os400: Fix IBMi EBCDIC conversion of arguments [34]
+ o pytest: add test for use of CURLMOPT_MAX_HOST_CONNECTIONS [60]
+ o rtsp: check EOS in the RTSP receive and return an error code [49]
+ o schannel: remove TLS 1.3 ciphersuite-list support [54]
+ o setopt: fix CURLOPT_HTTP_CONTENT_DECODING [15]
+ o setopt: fix missing options for builds without HTTP & MQTT [10]
+ o show-headers.md: clarify the headers are saved with the data [58]
+ o socket: handle binding to "host!<ip>" [16]
+ o socketpair: fix enabling `USE_EVENTFD` [30]
+ o strtok: use namespaced `strtok_r` macro instead of redefining it [29]
+ o tests: add the ending time stamp in testcurl.pl
+ o tests: re-enable 2086, and 472, 1299, 1613 for Windows [38]
+ o TODO: consider OCSP stapling by default [11]
+ o tool_formparse: remove use of sscanf() [68]
+ o tool_getparam: parse --localport without using sscanf [67]
+ o tool_getpass: fix UWP `-Wnull-dereference` [46]
+ o tool_getpass: replace `getch()` call with `_getch()` on Windows [42]
+ o tool_urlglob: parse character globbing range without sscanf [69]
+ o vtls: fix compile warning when ALPN is not available [12]
+
+This release includes the following known bugs:
+
+ See docs/KNOWN_BUGS (https://curl.se/docs/knownbugs.html)
+
+For all changes ever done in curl:
+
+ See https://curl.se/changes.html
+
+Planned upcoming removals include:
+
+ o TLS libraries not supporting TLS 1.3
+
+ See https://curl.se/dev/deprecate.html for details
+
+This release would not have looked like this without help, code, reports and
+advice from friends like these:
+
+  Alexis Savin, Andrew Ayer, Andrew Kirillov, Andy Fiddaman, Ben Greear,
+  Bo Anderson, Brendon Smith, chemodax, Dan Fandrich, Daniel Engberg,
+  Daniel Pouzzner, Daniel Stenberg, Dan Rosser, delogicsreal on github,
+  dengjfzh on github, Ethan Everett, Florian Eckert, galen11 on github,
+  Harmen Stoppels, Harry Sintonen, henrikjehgmti on github, hiimmat on github,
+  Jacob Champion, Jeroen Ooms, Jesus Malo Poyatos, jethrogb on github,
+  Kai Pastor, Logan Buth, Maarten Billemont, marcos-ng on github, Moritz,
+  newfunction on hackerone, Nicolas F., Peter Kokot, Peter Marko, Ray Satiro,
+  renovate[bot], Samuel Henrique, Stefan Eissing, SuperStormer on github,
+  Tal Regev, Thomas, tinyboxvk, tkzv on github, tranzystorekk on github,
+  Viktor Szakats, Vladislavs Sokurenko, wxiaoguang on github, Wyatt O'Day,
+  xiaofeng, Yoshimasa Ohno
+  (51 contributors)
+
+References to bug reports and discussions on issues:
+
+ [1] = https://curl.se/bug/?i=15527
+ [2] = https://curl.se/bug/?i=15500
+ [3] = https://curl.se/bug/?i=15496
+ [4] = https://curl.se/bug/?i=15492
+ [5] = https://curl.se/bug/?i=15499
+ [6] = https://curl.se/bug/?i=15504
+ [7] = https://curl.se/bug/?i=15508
+ [8] = https://curl.se/bug/?i=15501
+ [9] = https://curl.se/bug/?i=15600
+ [10] = https://curl.se/bug/?i=15634
+ [11] = https://curl.se/bug/?i=15483
+ [12] = https://curl.se/bug/?i=15515
+ [13] = https://curl.se/bug/?i=15506
+ [14] = https://curl.se/bug/?i=15513
+ [15] = https://curl.se/bug/?i=15511
+ [16] = https://curl.se/bug/?i=15553
+ [17] = https://curl.se/bug/?i=15586
+ [18] = https://curl.se/bug/?i=15672
+ [19] = https://curl.se/bug/?i=15538
+ [20] = https://curl.se/bug/?i=15673
+ [21] = https://curl.se/bug/?i=15661
+ [22] = https://curl.se/bug/?i=15585
+ [23] = https://curl.se/bug/?i=15542
+ [24] = https://curl.se/bug/?i=15580
+ [25] = https://curl.se/bug/?i=15584
+ [26] = https://curl.se/bug/?i=15563
+ [27] = https://curl.se/bug/?i=15469
+ [28] = https://curl.se/bug/?i=15545
+ [29] = https://curl.se/bug/?i=15549
+ [30] = https://curl.se/bug/?i=15561
+ [31] = https://curl.se/bug/?i=15533
+ [32] = https://curl.se/bug/?i=15657
+ [33] = https://curl.se/bug/?i=15566
+ [34] = https://curl.se/bug/?i=15570
+ [35] = https://curl.se/bug/?i=15648
+ [36] = https://curl.se/bug/?i=15565
+ [37] = https://curl.se/bug/?i=15557
+ [38] = https://curl.se/bug/?i=15644
+ [39] = https://curl.se/bug/?i=15547
+ [40] = https://curl.se/bug/?i=15546
+ [41] = https://curl.se/bug/?i=15525
+ [42] = https://curl.se/bug/?i=15642
+ [43] = https://curl.se/bug/?i=15522
+ [45] = https://curl.se/bug/?i=15676
+ [46] = https://curl.se/bug/?i=15638
+ [47] = https://curl.se/bug/?i=15625
+ [48] = https://curl.se/bug/?i=15627
+ [49] = https://curl.se/bug/?i=15624
+ [50] = https://curl.se/bug/?i=15645
+ [51] = https://curl.se/bug/?i=15645
+ [52] = https://curl.se/bug/?i=15614
+ [53] = https://curl.se/bug/?i=15620
+ [54] = https://hackerone.com/reports/2792484
+ [55] = https://curl.se/bug/?i=15617
+ [56] = https://curl.se/mail/lib-2024-11/0029.html
+ [57] = https://curl.se/bug/?i=15608
+ [58] = https://curl.se/bug/?i=15605
+ [59] = https://curl.se/bug/?i=15612
+ [60] = https://curl.se/bug/?i=15494
+ [61] = https://curl.se/bug/?i=15646
+ [62] = https://curl.se/bug/?i=15658
+ [63] = https://curl.se/bug/?i=15685
+ [64] = https://curl.se/bug/?i=15695
+ [65] = https://curl.se/bug/?i=15688
+ [66] = https://curl.se/bug/?i=15689
+ [67] = https://curl.se/bug/?i=15681
+ [68] = https://curl.se/bug/?i=15683
+ [69] = https://curl.se/bug/?i=15682
+ [70] = https://curl.se/bug/?i=15653
+ [71] = https://curl.se/bug/?i=15680
+ [72] = https://curl.se/bug/?i=15679
+ [73] = https://curl.se/bug/?i=15650
+ [74] = https://curl.se/bug/?i=15472

local-test-curl-delta-01/afc-curl/REUSE.toml

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: curl
+# SPDX-FileCopyrightText: Daniel Stenberg, <daniel@haxx.se>, et al.
+
+# This file describes the licensing and copyright situation for files that
+# cannot be annotated directly, for example because of being simply
+# uncommentable. Unless this is the case, a file should be annotated directly.
+#
+# This follows the REUSE specification: https://reuse.software/spec-3.2/#reusetoml
+
+version = 1
+SPDX-PackageName = "curl"
+SPDX-PackageDownloadLocation = "https://curl.se/"
+
+[[annotations]]
+path = [
+  ".mailmap",
+  "docs/FAQ",
+  "docs/INSTALL",
+  "docs/KNOWN_BUGS",
+  "docs/libcurl/symbols-in-versions",
+  "docs/MAIL-ETIQUETTE",
+  "docs/options-in-versions",
+  "docs/THANKS",
+  "docs/TODO",
+  "GIT-INFO.md",
+  "lib/libcurl.vers.in",
+  "lib/libcurl.def",
+  "packages/OS400/README.OS400",
+  "packages/vms/build_vms.com",
+  "packages/vms/curl_release_note_start.txt",
+  "packages/vms/curlmsg.sdl",
+  "packages/vms/macro32_exactcase.patch",
+  "packages/vms/readme",
+  "plan9/README",
+  "projects/Windows/**", "projects/wolfssl_override.props",
+  "README",
+  "RELEASE-NOTES",
+  "renovate.json",
+  "tests/certs/**",
+  "tests/data/test**",
+  "tests/stunnel.pem",
+  "tests/valgrind.supp",
+  # checksrc control files
+  "docs/examples/.checksrc",
+  "lib/.checksrc",
+  "lib/vauth/.checksrc",
+  "lib/vquic/.checksrc",
+  "lib/vssh/.checksrc",
+  "lib/vtls/.checksrc",
+  "src/.checksrc",
+  "tests/libtest/.checksrc",
+  "tests/server/.checksrc",
+]
+SPDX-FileCopyrightText = "Daniel Stenberg, <daniel@haxx.se>, et al."
+SPDX-License-Identifier = "curl"
+# If there is licensing/copyright information in or next to these files, prefer that
+precedence = "closest"

local-test-curl-delta-01/afc-curl/SECURITY.md

@@ -0,0 +1,29 @@
+<!--
+Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+
+SPDX-License-Identifier: curl
+-->
+
+# Security Policy
+
+Read our [Vulnerability Disclosure Policy](docs/VULN-DISCLOSURE-POLICY.md).
+
+## Reporting a Vulnerability
+
+If you have found or just suspect a security problem somewhere in curl or
+libcurl, report it on [HackerOne](https://hackerone.com/curl).
+
+We treat security issues with confidentiality until controlled and disclosed responsibly.
+
+## OpenSSF Best Practices
+
+curl has achieved Gold status on the Open Source Security Foundation (OpenSSF)
+[Best Practices](https://bestpractices.dev/) (formerly Core Infrastructure
+Initiative Best Practices), reflecting its adherence to rigorous
+security and best practice standards. This achievement highlights curl's
+comprehensive documentation, secure development processes, effective change
+control mechanisms, and strong maintenance routines. Meeting these criteria
+demonstrates curl's commitment to security and reliability, ensuring the
+project's sustainability and trustworthiness. This underscores curl's role as
+a leader in open-source software practices. More information can be found on
+[curl's OpenSSF Best Practices project page](https://www.bestpractices.dev/projects/63).

local-test-curl-delta-01/afc-curl/acinclude.m4

@@ -0,0 +1,1697 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+#***************************************************************************
+
+dnl CURL_CHECK_DEF (SYMBOL, [INCLUDES], [SILENT])
+dnl -------------------------------------------------
+dnl Use the C preprocessor to find out if the given object-style symbol
+dnl is defined and get its expansion. This macro will not use default
+dnl includes even if no INCLUDES argument is given. This macro will run
+dnl silently when invoked with three arguments. If the expansion would
+dnl result in a set of double-quoted strings the returned expansion will
+dnl actually be a single double-quoted string concatenating all them.
+
+AC_DEFUN([CURL_CHECK_DEF], [
+  AC_REQUIRE([CURL_CPP_P])dnl
+  OLDCPPFLAGS=$CPPFLAGS
+  # CPPPFLAG comes from CURL_CPP_P
+  CPPFLAGS="$CPPFLAGS $CPPPFLAG"
+  AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl
+  AS_VAR_PUSHDEF([ac_Def], [curl_cv_def_$1])dnl
+  if test -z "$SED"; then
+    AC_MSG_ERROR([SED not set. Cannot continue without SED being set.])
+  fi
+  if test -z "$GREP"; then
+    AC_MSG_ERROR([GREP not set. Cannot continue without GREP being set.])
+  fi
+  ifelse($3,,[AC_MSG_CHECKING([for preprocessor definition of $1])])
+  tmp_exp=""
+  AC_PREPROC_IFELSE([
+    AC_LANG_SOURCE(
+ifelse($2,,,[$2])[[
+      #ifdef $1
+      CURL_DEF_TOKEN $1
+      #endif
+    ]])
+  ],[
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[[ ]][[ ]]*//' 2>/dev/null | \
+      "$SED" 's/[["]][[ ]]*[["]]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "$1"; then
+      tmp_exp=""
+    fi
+  ])
+  if test -z "$tmp_exp"; then
+    AS_VAR_SET(ac_HaveDef, no)
+    ifelse($3,,[AC_MSG_RESULT([no])])
+  else
+    AS_VAR_SET(ac_HaveDef, yes)
+    AS_VAR_SET(ac_Def, $tmp_exp)
+    ifelse($3,,[AC_MSG_RESULT([$tmp_exp])])
+  fi
+  AS_VAR_POPDEF([ac_Def])dnl
+  AS_VAR_POPDEF([ac_HaveDef])dnl
+  CPPFLAGS=$OLDCPPFLAGS
+])
+
+
+dnl CURL_CHECK_DEF_CC (SYMBOL, [INCLUDES], [SILENT])
+dnl -------------------------------------------------
+dnl Use the C compiler to find out only if the given symbol is defined
+dnl or not, this can not find out its expansion. This macro will not use
+dnl default includes even if no INCLUDES argument is given. This macro
+dnl will run silently when invoked with three arguments.
+
+AC_DEFUN([CURL_CHECK_DEF_CC], [
+  AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl
+  ifelse($3,,[AC_MSG_CHECKING([for compiler definition of $1])])
+  AC_COMPILE_IFELSE([
+    AC_LANG_SOURCE(
+ifelse($2,,,[$2])[[
+      int main(void)
+      {
+      #ifdef $1
+        return 0;
+      #else
+        #error force compilation error
+      #endif
+      }
+    ]])
+  ],[
+    tst_symbol_defined="yes"
+  ],[
+    tst_symbol_defined="no"
+  ])
+  if test "$tst_symbol_defined" = "yes"; then
+    AS_VAR_SET(ac_HaveDef, yes)
+    ifelse($3,,[AC_MSG_RESULT([yes])])
+  else
+    AS_VAR_SET(ac_HaveDef, no)
+    ifelse($3,,[AC_MSG_RESULT([no])])
+  fi
+  AS_VAR_POPDEF([ac_HaveDef])dnl
+])
+
+
+dnl CURL_CHECK_LIB_XNET
+dnl -------------------------------------------------
+dnl Verify if X/Open network library is required.
+
+AC_DEFUN([CURL_CHECK_LIB_XNET], [
+  AC_MSG_CHECKING([if X/Open network library is required])
+  tst_lib_xnet_required="no"
+  AC_COMPILE_IFELSE([
+    AC_LANG_SOURCE([[
+      int main(void)
+      {
+      #if defined(__hpux) && defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600)
+        return 0;
+      #elif defined(__hpux) && defined(_XOPEN_SOURCE_EXTENDED)
+        return 0;
+      #else
+        #error force compilation error
+      #endif
+      }
+    ]])
+  ],[
+    tst_lib_xnet_required="yes"
+    LIBS="-lxnet $LIBS"
+  ])
+  AC_MSG_RESULT([$tst_lib_xnet_required])
+])
+
+
+dnl CURL_CHECK_AIX_ALL_SOURCE
+dnl -------------------------------------------------
+dnl Provides a replacement of traditional AC_AIX with
+dnl an uniform behavior across all autoconf versions,
+dnl and with our own placement rules.
+
+AC_DEFUN([CURL_CHECK_AIX_ALL_SOURCE], [
+  AH_VERBATIM([_ALL_SOURCE],
+    [/* Define to 1 if OS is AIX. */
+#ifndef _ALL_SOURCE
+#  undef _ALL_SOURCE
+#endif])
+  AC_BEFORE([$0], [AC_SYS_LARGEFILE])dnl
+  AC_BEFORE([$0], [CURL_CONFIGURE_REENTRANT])dnl
+  AC_MSG_CHECKING([if OS is AIX (to define _ALL_SOURCE)])
+  AC_EGREP_CPP([yes_this_is_aix],[
+#ifdef _AIX
+   yes_this_is_aix
+#endif
+  ],[
+    AC_MSG_RESULT([yes])
+    AC_DEFINE(_ALL_SOURCE)
+  ],[
+    AC_MSG_RESULT([no])
+  ])
+])
+
+
+dnl CURL_CHECK_NATIVE_WINDOWS
+dnl -------------------------------------------------
+dnl Check if building a native Windows target
+
+AC_DEFUN([CURL_CHECK_NATIVE_WINDOWS], [
+  AC_CACHE_CHECK([whether build target is a native Windows one], [curl_cv_native_windows], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+      ]],[[
+        #ifdef _WIN32
+          int dummy=1;
+        #else
+          #error Not a native Windows build target.
+        #endif
+      ]])
+    ],[
+      curl_cv_native_windows="yes"
+    ],[
+      curl_cv_native_windows="no"
+    ])
+  ])
+  AM_CONDITIONAL(DOING_NATIVE_WINDOWS, test "x$curl_cv_native_windows" = xyes)
+])
+
+
+dnl CURL_CHECK_HEADER_LBER
+dnl -------------------------------------------------
+dnl Check for compilable and valid lber.h header,
+dnl and check if it is needed even with ldap.h
+
+AC_DEFUN([CURL_CHECK_HEADER_LBER], [
+  AC_REQUIRE([CURL_CHECK_NATIVE_WINDOWS])dnl
+  AC_CACHE_CHECK([for lber.h], [curl_cv_header_lber_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        #undef inline
+        #ifdef _WIN32
+        #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+        #endif
+        #include <windows.h>
+        #else
+        #ifdef HAVE_SYS_TYPES_H
+        #include <sys/types.h>
+        #endif
+        #endif
+        #ifndef NULL
+        #define NULL (void *)0
+        #endif
+        #include <lber.h>
+      ]],[[
+        BerValue *bvp = NULL;
+        BerElement *bep = ber_init(bvp);
+        ber_free(bep, 1);
+      ]])
+    ],[
+      curl_cv_header_lber_h="yes"
+    ],[
+      curl_cv_header_lber_h="no"
+    ])
+  ])
+  if test "$curl_cv_header_lber_h" = "yes"; then
+    AC_DEFINE_UNQUOTED(HAVE_LBER_H, 1,
+      [Define to 1 if you have the lber.h header file.])
+    #
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        #undef inline
+        #ifdef _WIN32
+        #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+        #endif
+        #include <windows.h>
+        #else
+        #ifdef HAVE_SYS_TYPES_H
+        #include <sys/types.h>
+        #endif
+        #endif
+        #ifndef NULL
+        #define NULL (void *)0
+        #endif
+        #ifndef LDAP_DEPRECATED
+        #define LDAP_DEPRECATED 1
+        #endif
+        #include <ldap.h>
+      ]],[[
+        BerValue *bvp = NULL;
+        BerElement *bep = ber_init(bvp);
+        ber_free(bep, 1);
+      ]])
+    ],[
+      curl_cv_need_header_lber_h="no"
+    ],[
+      curl_cv_need_header_lber_h="yes"
+    ])
+    #
+    case "$curl_cv_need_header_lber_h" in
+      yes)
+        AC_DEFINE_UNQUOTED(NEED_LBER_H, 1,
+          [Define to 1 if you need the lber.h header file even with ldap.h])
+        ;;
+    esac
+  fi
+])
+
+
+dnl CURL_CHECK_HEADER_LDAP
+dnl -------------------------------------------------
+dnl Check for compilable and valid ldap.h header
+
+AC_DEFUN([CURL_CHECK_HEADER_LDAP], [
+  AC_REQUIRE([CURL_CHECK_HEADER_LBER])dnl
+  AC_CACHE_CHECK([for ldap.h], [curl_cv_header_ldap_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        #undef inline
+        #ifdef _WIN32
+        #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+        #endif
+        #include <windows.h>
+        #else
+        #ifdef HAVE_SYS_TYPES_H
+        #include <sys/types.h>
+        #endif
+        #endif
+        #ifndef LDAP_DEPRECATED
+        #define LDAP_DEPRECATED 1
+        #endif
+        #ifdef NEED_LBER_H
+        #include <lber.h>
+        #endif
+        #include <ldap.h>
+      ]],[[
+        LDAP *ldp = ldap_init("0.0.0.0", LDAP_PORT);
+        int res = ldap_unbind(ldp);
+      ]])
+    ],[
+      curl_cv_header_ldap_h="yes"
+    ],[
+      curl_cv_header_ldap_h="no"
+    ])
+  ])
+  case "$curl_cv_header_ldap_h" in
+    yes)
+      AC_DEFINE_UNQUOTED(HAVE_LDAP_H, 1,
+        [Define to 1 if you have the ldap.h header file.])
+      ;;
+  esac
+])
+
+
+dnl CURL_CHECK_HEADER_LDAP_SSL
+dnl -------------------------------------------------
+dnl Check for compilable and valid ldap_ssl.h header
+
+AC_DEFUN([CURL_CHECK_HEADER_LDAP_SSL], [
+  AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
+  AC_CACHE_CHECK([for ldap_ssl.h], [curl_cv_header_ldap_ssl_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        #undef inline
+        #ifdef _WIN32
+        #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+        #endif
+        #include <windows.h>
+        #else
+        #ifdef HAVE_SYS_TYPES_H
+        #include <sys/types.h>
+        #endif
+        #endif
+        #ifndef LDAP_DEPRECATED
+        #define LDAP_DEPRECATED 1
+        #endif
+        #ifdef NEED_LBER_H
+        #include <lber.h>
+        #endif
+        #ifdef HAVE_LDAP_H
+        #include <ldap.h>
+        #endif
+        #include <ldap_ssl.h>
+      ]],[[
+        LDAP *ldp = ldapssl_init("0.0.0.0", LDAPS_PORT, 1);
+      ]])
+    ],[
+      curl_cv_header_ldap_ssl_h="yes"
+    ],[
+      curl_cv_header_ldap_ssl_h="no"
+    ])
+  ])
+  case "$curl_cv_header_ldap_ssl_h" in
+    yes)
+      AC_DEFINE_UNQUOTED(HAVE_LDAP_SSL_H, 1,
+        [Define to 1 if you have the ldap_ssl.h header file.])
+      ;;
+  esac
+])
+
+
+dnl CURL_CHECK_LIBS_WINLDAP
+dnl -------------------------------------------------
+dnl Check for libraries needed for WINLDAP support,
+dnl and prepended to LIBS any needed libraries.
+dnl This macro can take an optional parameter with a
+dnl whitespace separated list of libraries to check
+dnl before the WINLDAP default ones.
+
+AC_DEFUN([CURL_CHECK_LIBS_WINLDAP], [
+  AC_REQUIRE([CURL_CHECK_HEADER_WINBER])dnl
+  #
+  AC_MSG_CHECKING([for WINLDAP libraries])
+  #
+  u_libs=""
+  #
+  ifelse($1,,,[
+    for x_lib in $1; do
+      case "$x_lib" in
+        -l*)
+          l_lib="$x_lib"
+          ;;
+        *)
+          l_lib="-l$x_lib"
+          ;;
+      esac
+      if test -z "$u_libs"; then
+        u_libs="$l_lib"
+      else
+        u_libs="$u_libs $l_lib"
+      fi
+    done
+  ])
+  #
+  curl_cv_save_LIBS="$LIBS"
+  curl_cv_ldap_LIBS="unknown"
+  #
+  for x_nlibs in '' "$u_libs" \
+    '-lwldap32' ; do
+    if test "$curl_cv_ldap_LIBS" = "unknown"; then
+      if test -z "$x_nlibs"; then
+        LIBS="$curl_cv_save_LIBS"
+      else
+        LIBS="$x_nlibs $curl_cv_save_LIBS"
+      fi
+      AC_LINK_IFELSE([
+        AC_LANG_PROGRAM([[
+          #undef inline
+          #ifdef _WIN32
+          #ifndef WIN32_LEAN_AND_MEAN
+          #define WIN32_LEAN_AND_MEAN
+          #endif
+          #include <windows.h>
+          #include <winldap.h>
+          #ifdef HAVE_WINBER_H
+          #include <winber.h>
+          #endif
+          #endif
+        ]],[[
+          BERVAL *bvp = NULL;
+          BerElement *bep = ber_init(bvp);
+          LDAP *ldp = ldap_init("0.0.0.0", LDAP_PORT);
+          ULONG res = ldap_unbind(ldp);
+          ber_free(bep, 1);
+        ]])
+      ],[
+        curl_cv_ldap_LIBS="$x_nlibs"
+      ])
+    fi
+  done
+  #
+  LIBS="$curl_cv_save_LIBS"
+  #
+  case X-"$curl_cv_ldap_LIBS" in
+    X-unknown)
+      AC_MSG_RESULT([cannot find WINLDAP libraries])
+      ;;
+    X-)
+      AC_MSG_RESULT([no additional lib required])
+      ;;
+    *)
+      if test -z "$curl_cv_save_LIBS"; then
+        LIBS="$curl_cv_ldap_LIBS"
+      else
+        LIBS="$curl_cv_ldap_LIBS $curl_cv_save_LIBS"
+      fi
+      AC_MSG_RESULT([$curl_cv_ldap_LIBS])
+      ;;
+  esac
+  #
+])
+
+
+dnl CURL_CHECK_LIBS_LDAP
+dnl -------------------------------------------------
+dnl Check for libraries needed for LDAP support,
+dnl and prepended to LIBS any needed libraries.
+dnl This macro can take an optional parameter with a
+dnl whitespace separated list of libraries to check
+dnl before the default ones.
+
+AC_DEFUN([CURL_CHECK_LIBS_LDAP], [
+  AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
+  #
+  AC_MSG_CHECKING([for LDAP libraries])
+  #
+  u_libs=""
+  #
+  ifelse($1,,,[
+    for x_lib in $1; do
+      case "$x_lib" in
+        -l*)
+          l_lib="$x_lib"
+          ;;
+        *)
+          l_lib="-l$x_lib"
+          ;;
+      esac
+      if test -z "$u_libs"; then
+        u_libs="$l_lib"
+      else
+        u_libs="$u_libs $l_lib"
+      fi
+    done
+  ])
+  #
+  curl_cv_save_LIBS="$LIBS"
+  curl_cv_ldap_LIBS="unknown"
+  #
+  for x_nlibs in '' "$u_libs" \
+    '-lldap' \
+    '-lldap -llber' \
+    '-llber -lldap' \
+    '-lldapssl -lldapx -lldapsdk' \
+    '-lldapsdk -lldapx -lldapssl' \
+    '-lldap -llber -lssl -lcrypto'; do
+
+    if test "$curl_cv_ldap_LIBS" = "unknown"; then
+      if test -z "$x_nlibs"; then
+        LIBS="$curl_cv_save_LIBS"
+      else
+        LIBS="$x_nlibs $curl_cv_save_LIBS"
+      fi
+      AC_LINK_IFELSE([
+        AC_LANG_PROGRAM([[
+          #undef inline
+          #ifdef _WIN32
+          #ifndef WIN32_LEAN_AND_MEAN
+          #define WIN32_LEAN_AND_MEAN
+          #endif
+          #include <windows.h>
+          #else
+          #ifdef HAVE_SYS_TYPES_H
+          #include <sys/types.h>
+          #endif
+          #endif
+          #ifndef NULL
+          #define NULL (void *)0
+          #endif
+          #ifndef LDAP_DEPRECATED
+          #define LDAP_DEPRECATED 1
+          #endif
+          #ifdef NEED_LBER_H
+          #include <lber.h>
+          #endif
+          #ifdef HAVE_LDAP_H
+          #include <ldap.h>
+          #endif
+        ]],[[
+          BerValue *bvp = NULL;
+          BerElement *bep = ber_init(bvp);
+          LDAP *ldp = ldap_init("0.0.0.0", LDAP_PORT);
+          int res = ldap_unbind(ldp);
+          ber_free(bep, 1);
+        ]])
+      ],[
+        curl_cv_ldap_LIBS="$x_nlibs"
+      ])
+    fi
+  done
+  #
+  LIBS="$curl_cv_save_LIBS"
+  #
+  case X-"$curl_cv_ldap_LIBS" in
+    X-unknown)
+      AC_MSG_RESULT([cannot find LDAP libraries])
+      ;;
+    X-)
+      AC_MSG_RESULT([no additional lib required])
+      ;;
+    *)
+      if test -z "$curl_cv_save_LIBS"; then
+        LIBS="$curl_cv_ldap_LIBS"
+      else
+        LIBS="$curl_cv_ldap_LIBS $curl_cv_save_LIBS"
+      fi
+      # FIXME: Enable when ldap was detected via pkg-config
+      if false; then
+        LIBCURL_PC_REQUIRES_PRIVATE="ldap $LIBCURL_PC_REQUIRES_PRIVATE"
+      fi
+      AC_MSG_RESULT([$curl_cv_ldap_LIBS])
+      ;;
+  esac
+  #
+])
+
+
+dnl TYPE_SOCKADDR_STORAGE
+dnl -------------------------------------------------
+dnl Check for struct sockaddr_storage. Most IPv6-enabled
+dnl hosts have it, but AIX 4.3 is one known exception.
+
+AC_DEFUN([TYPE_SOCKADDR_STORAGE],
+[
+   AC_CHECK_TYPE([struct sockaddr_storage],
+     AC_DEFINE(HAVE_STRUCT_SOCKADDR_STORAGE, 1,
+       [if struct sockaddr_storage is defined]), ,
+   [
+     #undef inline
+     #ifdef _WIN32
+     #ifndef WIN32_LEAN_AND_MEAN
+     #define WIN32_LEAN_AND_MEAN
+     #endif
+     #include <winsock2.h>
+     #else
+     #ifdef HAVE_SYS_TYPES_H
+     #include <sys/types.h>
+     #endif
+     #ifdef HAVE_SYS_SOCKET_H
+     #include <sys/socket.h>
+     #endif
+     #ifdef HAVE_NETINET_IN_H
+     #include <netinet/in.h>
+     #endif
+     #ifdef HAVE_ARPA_INET_H
+     #include <arpa/inet.h>
+     #endif
+     #endif
+   ])
+])
+
+dnl CURL_CHECK_FUNC_RECV
+dnl -------------------------------------------------
+dnl Test if the socket recv() function is available,
+
+AC_DEFUN([CURL_CHECK_FUNC_RECV], [
+  AC_REQUIRE([CURL_CHECK_NATIVE_WINDOWS])dnl
+  AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])dnl
+  AC_CHECK_HEADERS(sys/types.h sys/socket.h)
+  #
+  AC_MSG_CHECKING([for recv])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      #undef inline
+      #ifdef _WIN32
+      #ifndef WIN32_LEAN_AND_MEAN
+      #define WIN32_LEAN_AND_MEAN
+      #endif
+      #include <winsock2.h>
+      #else
+      $curl_includes_bsdsocket
+      #ifdef HAVE_SYS_TYPES_H
+      #include <sys/types.h>
+      #endif
+      #ifdef HAVE_SYS_SOCKET_H
+      #include <sys/socket.h>
+      #endif
+      #endif
+    ]],[[
+      recv(0, 0, 0, 0);
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    curl_cv_recv="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    curl_cv_recv="no"
+  ])
+  #
+  if test "$curl_cv_recv" = "yes"; then
+    AC_DEFINE_UNQUOTED(HAVE_RECV, 1,
+      [Define to 1 if you have the recv function.])
+    curl_cv_func_recv="yes"
+  else
+    AC_MSG_ERROR([Unable to link function recv])
+  fi
+])
+
+
+dnl CURL_CHECK_FUNC_SEND
+dnl -------------------------------------------------
+dnl Test if the socket send() function is available,
+
+AC_DEFUN([CURL_CHECK_FUNC_SEND], [
+  AC_REQUIRE([CURL_CHECK_NATIVE_WINDOWS])dnl
+  AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])dnl
+  AC_CHECK_HEADERS(sys/types.h sys/socket.h)
+  #
+  AC_MSG_CHECKING([for send])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      #undef inline
+      #ifdef _WIN32
+      #ifndef WIN32_LEAN_AND_MEAN
+      #define WIN32_LEAN_AND_MEAN
+      #endif
+      #include <winsock2.h>
+      #else
+      $curl_includes_bsdsocket
+      #ifdef HAVE_SYS_TYPES_H
+      #include <sys/types.h>
+      #endif
+      #ifdef HAVE_SYS_SOCKET_H
+      #include <sys/socket.h>
+      #endif
+      #endif
+    ]],[[
+      send(0, 0, 0, 0);
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    curl_cv_send="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    curl_cv_send="no"
+  ])
+  #
+  if test "$curl_cv_send" = "yes"; then
+    AC_DEFINE_UNQUOTED(HAVE_SEND, 1,
+      [Define to 1 if you have the send function.])
+    curl_cv_func_send="yes"
+  else
+    AC_MSG_ERROR([Unable to link function send])
+  fi
+])
+
+dnl CURL_CHECK_MSG_NOSIGNAL
+dnl -------------------------------------------------
+dnl Check for MSG_NOSIGNAL
+
+AC_DEFUN([CURL_CHECK_MSG_NOSIGNAL], [
+  AC_CHECK_HEADERS(sys/types.h sys/socket.h)
+  AC_CACHE_CHECK([for MSG_NOSIGNAL], [curl_cv_msg_nosignal], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        #undef inline
+        #ifdef _WIN32
+        #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+        #endif
+        #include <winsock2.h>
+        #else
+        #ifdef HAVE_SYS_TYPES_H
+        #include <sys/types.h>
+        #endif
+        #ifdef HAVE_SYS_SOCKET_H
+        #include <sys/socket.h>
+        #endif
+        #endif
+      ]],[[
+        int flag=MSG_NOSIGNAL;
+      ]])
+    ],[
+      curl_cv_msg_nosignal="yes"
+    ],[
+      curl_cv_msg_nosignal="no"
+    ])
+  ])
+  case "$curl_cv_msg_nosignal" in
+    yes)
+      AC_DEFINE_UNQUOTED(HAVE_MSG_NOSIGNAL, 1,
+        [Define to 1 if you have the MSG_NOSIGNAL flag.])
+      ;;
+  esac
+])
+
+
+dnl CURL_CHECK_STRUCT_TIMEVAL
+dnl -------------------------------------------------
+dnl Check for timeval struct
+
+AC_DEFUN([CURL_CHECK_STRUCT_TIMEVAL], [
+  AC_REQUIRE([CURL_CHECK_NATIVE_WINDOWS])dnl
+  AC_CHECK_HEADERS(sys/types.h sys/time.h sys/socket.h)
+  AC_CACHE_CHECK([for struct timeval], [curl_cv_struct_timeval], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        #undef inline
+        #ifdef _WIN32
+        #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+        #endif
+        #include <winsock2.h>
+        #endif
+        #ifdef HAVE_SYS_TYPES_H
+        #include <sys/types.h>
+        #endif
+        #ifdef HAVE_SYS_TIME_H
+        #include <sys/time.h>
+        #endif
+        #include <time.h>
+        #ifdef HAVE_SYS_SOCKET_H
+        #include <sys/socket.h>
+        #endif
+      ]],[[
+        struct timeval ts;
+        ts.tv_sec  = 0;
+        ts.tv_usec = 0;
+      ]])
+    ],[
+      curl_cv_struct_timeval="yes"
+    ],[
+      curl_cv_struct_timeval="no"
+    ])
+  ])
+  case "$curl_cv_struct_timeval" in
+    yes)
+      AC_DEFINE_UNQUOTED(HAVE_STRUCT_TIMEVAL, 1,
+        [Define to 1 if you have the timeval struct.])
+      ;;
+  esac
+])
+
+
+dnl TYPE_IN_ADDR_T
+dnl -------------------------------------------------
+dnl Check for in_addr_t: it is used to receive the return code of inet_addr()
+dnl and a few other things.
+
+AC_DEFUN([TYPE_IN_ADDR_T], [
+  AC_CHECK_TYPE([in_addr_t], ,[
+    dnl in_addr_t not available
+    AC_CACHE_CHECK([for in_addr_t equivalent],
+      [curl_cv_in_addr_t_equiv], [
+      curl_cv_in_addr_t_equiv="unknown"
+      for t in "unsigned long" int size_t unsigned long; do
+        if test "$curl_cv_in_addr_t_equiv" = "unknown"; then
+          AC_LINK_IFELSE([
+            AC_LANG_PROGRAM([[
+              #undef inline
+              #ifdef _WIN32
+              #ifndef WIN32_LEAN_AND_MEAN
+              #define WIN32_LEAN_AND_MEAN
+              #endif
+              #include <winsock2.h>
+              #else
+              #ifdef HAVE_SYS_TYPES_H
+              #include <sys/types.h>
+              #endif
+              #ifdef HAVE_SYS_SOCKET_H
+              #include <sys/socket.h>
+              #endif
+              #ifdef HAVE_NETINET_IN_H
+              #include <netinet/in.h>
+              #endif
+              #ifdef HAVE_ARPA_INET_H
+              #include <arpa/inet.h>
+              #endif
+              #endif
+            ]],[[
+              $t data = inet_addr ("1.2.3.4");
+            ]])
+          ],[
+            curl_cv_in_addr_t_equiv="$t"
+          ])
+        fi
+      done
+    ])
+    case "$curl_cv_in_addr_t_equiv" in
+      unknown)
+        AC_MSG_ERROR([Cannot find a type to use in place of in_addr_t])
+        ;;
+      *)
+        AC_DEFINE_UNQUOTED(in_addr_t, $curl_cv_in_addr_t_equiv,
+          [Type to use in place of in_addr_t when system does not provide it.])
+        ;;
+    esac
+  ],[
+    #undef inline
+    #ifdef _WIN32
+    #ifndef WIN32_LEAN_AND_MEAN
+    #define WIN32_LEAN_AND_MEAN
+    #endif
+    #include <winsock2.h>
+    #else
+    #ifdef HAVE_SYS_TYPES_H
+    #include <sys/types.h>
+    #endif
+    #ifdef HAVE_SYS_SOCKET_H
+    #include <sys/socket.h>
+    #endif
+    #ifdef HAVE_NETINET_IN_H
+    #include <netinet/in.h>
+    #endif
+    #ifdef HAVE_ARPA_INET_H
+    #include <arpa/inet.h>
+    #endif
+    #endif
+  ])
+])
+
+
+dnl CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC
+dnl -------------------------------------------------
+dnl Check if monotonic clock_gettime is available.
+
+AC_DEFUN([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC], [
+  AC_CHECK_HEADERS(sys/types.h sys/time.h)
+  AC_MSG_CHECKING([for monotonic clock_gettime])
+  #
+  if test "x$dontwant_rt" = "xno" ; then
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        #ifdef HAVE_SYS_TYPES_H
+        #include <sys/types.h>
+        #endif
+        #ifdef HAVE_SYS_TIME_H
+        #include <sys/time.h>
+        #endif
+        #include <time.h>
+      ]],[[
+        struct timespec ts;
+        (void)clock_gettime(CLOCK_MONOTONIC, &ts);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      curl_func_clock_gettime="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      curl_func_clock_gettime="no"
+    ])
+  fi
+  dnl Definition of HAVE_CLOCK_GETTIME_MONOTONIC is intentionally postponed
+  dnl until library linking and run-time checks for clock_gettime succeed.
+])
+
+dnl CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC_RAW
+dnl -------------------------------------------------
+dnl Check if monotonic clock_gettime is available.
+
+AC_DEFUN([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC_RAW], [
+  AC_CHECK_HEADERS(sys/types.h sys/time.h)
+  AC_MSG_CHECKING([for raw monotonic clock_gettime])
+  #
+  if test "x$dontwant_rt" = "xno" ; then
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        #ifdef HAVE_SYS_TYPES_H
+        #include <sys/types.h>
+        #endif
+        #ifdef HAVE_SYS_TIME_H
+        #include <sys/time.h>
+        #endif
+        #include <time.h>
+      ]],[[
+        struct timespec ts;
+        (void)clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      AC_DEFINE_UNQUOTED(HAVE_CLOCK_GETTIME_MONOTONIC_RAW, 1,
+        [Define to 1 if you have the clock_gettime function and raw monotonic timer.])
+    ],[
+      AC_MSG_RESULT([no])
+    ])
+  fi
+])
+
+
+dnl CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC
+dnl -------------------------------------------------
+dnl If monotonic clock_gettime is available then,
+dnl check and prepended to LIBS any needed libraries.
+
+AC_DEFUN([CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC], [
+  AC_REQUIRE([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC])dnl
+  #
+  if test "$curl_func_clock_gettime" = "yes"; then
+    #
+    AC_MSG_CHECKING([for clock_gettime in libraries])
+    #
+    curl_cv_save_LIBS="$LIBS"
+    curl_cv_gclk_LIBS="unknown"
+    #
+    for x_xlibs in '' '-lrt' '-lposix4' ; do
+      if test "$curl_cv_gclk_LIBS" = "unknown"; then
+        if test -z "$x_xlibs"; then
+          LIBS="$curl_cv_save_LIBS"
+        else
+          LIBS="$x_xlibs $curl_cv_save_LIBS"
+        fi
+        AC_LINK_IFELSE([
+          AC_LANG_PROGRAM([[
+            #ifdef HAVE_SYS_TYPES_H
+            #include <sys/types.h>
+            #endif
+            #ifdef HAVE_SYS_TIME_H
+            #include <sys/time.h>
+            #endif
+            #include <time.h>
+          ]],[[
+            struct timespec ts;
+            (void)clock_gettime(CLOCK_MONOTONIC, &ts);
+          ]])
+        ],[
+          curl_cv_gclk_LIBS="$x_xlibs"
+        ])
+      fi
+    done
+    #
+    LIBS="$curl_cv_save_LIBS"
+    #
+    case X-"$curl_cv_gclk_LIBS" in
+      X-unknown)
+        AC_MSG_RESULT([cannot find clock_gettime])
+        AC_MSG_WARN([HAVE_CLOCK_GETTIME_MONOTONIC will not be defined])
+        curl_func_clock_gettime="no"
+        ;;
+      X-)
+        AC_MSG_RESULT([no additional lib required])
+        curl_func_clock_gettime="yes"
+        ;;
+      *)
+        if test -z "$curl_cv_save_LIBS"; then
+          LIBS="$curl_cv_gclk_LIBS"
+        else
+          LIBS="$curl_cv_gclk_LIBS $curl_cv_save_LIBS"
+        fi
+        AC_MSG_RESULT([$curl_cv_gclk_LIBS])
+        curl_func_clock_gettime="yes"
+        ;;
+    esac
+    #
+    dnl only do runtime verification when not cross-compiling
+    if test "x$cross_compiling" != "xyes" &&
+      test "$curl_func_clock_gettime" = "yes"; then
+      AC_MSG_CHECKING([if monotonic clock_gettime works])
+      CURL_RUN_IFELSE([
+        AC_LANG_PROGRAM([[
+          #include <stdlib.h>
+          #ifdef HAVE_SYS_TYPES_H
+          #include <sys/types.h>
+          #endif
+          #ifdef HAVE_SYS_TIME_H
+          #include <sys/time.h>
+          #endif
+          #include <time.h>
+        ]],[[
+          struct timespec ts;
+          if (0 == clock_gettime(CLOCK_MONOTONIC, &ts))
+            exit(0);
+          else
+            exit(1);
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+      ],[
+        AC_MSG_RESULT([no])
+        AC_MSG_WARN([HAVE_CLOCK_GETTIME_MONOTONIC will not be defined])
+        curl_func_clock_gettime="no"
+        LIBS="$curl_cv_save_LIBS"
+      ])
+    fi
+    #
+    case "$curl_func_clock_gettime" in
+      yes)
+        AC_DEFINE_UNQUOTED(HAVE_CLOCK_GETTIME_MONOTONIC, 1,
+          [Define to 1 if you have the clock_gettime function and monotonic timer.])
+        ;;
+    esac
+    #
+  fi
+  #
+])
+
+
+dnl CURL_CHECK_LIBS_CONNECT
+dnl -------------------------------------------------
+dnl Verify if network connect function is already available
+dnl using current libraries or if another one is required.
+
+AC_DEFUN([CURL_CHECK_LIBS_CONNECT], [
+  AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])dnl
+  AC_MSG_CHECKING([for connect in libraries])
+  tst_connect_save_LIBS="$LIBS"
+  tst_connect_need_LIBS="unknown"
+  for tst_lib in '' '-lsocket' ; do
+    if test "$tst_connect_need_LIBS" = "unknown"; then
+      LIBS="$tst_lib $tst_connect_save_LIBS"
+      AC_LINK_IFELSE([
+        AC_LANG_PROGRAM([[
+          $curl_includes_winsock2
+          $curl_includes_bsdsocket
+          #if !defined(_WIN32) && !defined(HAVE_PROTO_BSDSOCKET_H)
+            int connect(int, void*, int);
+          #endif
+        ]],[[
+          if(0 != connect(0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        tst_connect_need_LIBS="$tst_lib"
+      ])
+    fi
+  done
+  LIBS="$tst_connect_save_LIBS"
+  #
+  case X-"$tst_connect_need_LIBS" in
+    X-unknown)
+      AC_MSG_RESULT([cannot find connect])
+      AC_MSG_ERROR([cannot find connect function in libraries.])
+      ;;
+    X-)
+      AC_MSG_RESULT([yes])
+      ;;
+    *)
+      AC_MSG_RESULT([$tst_connect_need_LIBS])
+      LIBS="$tst_connect_need_LIBS $tst_connect_save_LIBS"
+      ;;
+  esac
+])
+
+
+dnl CURL_CHECK_FUNC_SELECT
+dnl -------------------------------------------------
+dnl Test if the socket select() function is available.
+
+AC_DEFUN([CURL_CHECK_FUNC_SELECT], [
+  AC_REQUIRE([CURL_CHECK_STRUCT_TIMEVAL])dnl
+  AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])dnl
+  AC_CHECK_HEADERS(sys/select.h sys/socket.h)
+  #
+  AC_MSG_CHECKING([for select])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      #undef inline
+      #ifdef _WIN32
+      #ifndef WIN32_LEAN_AND_MEAN
+      #define WIN32_LEAN_AND_MEAN
+      #endif
+      #include <winsock2.h>
+      #endif
+      #ifdef HAVE_SYS_TYPES_H
+      #include <sys/types.h>
+      #endif
+      #ifdef HAVE_SYS_TIME_H
+      #include <sys/time.h>
+      #endif
+      #include <time.h>
+      #ifndef _WIN32
+      #ifdef HAVE_SYS_SELECT_H
+      #include <sys/select.h>
+      #elif defined(HAVE_UNISTD_H)
+      #include <unistd.h>
+      #endif
+      #ifdef HAVE_SYS_SOCKET_H
+      #include <sys/socket.h>
+      #endif
+      $curl_includes_bsdsocket
+      #endif
+    ]],[[
+      select(0, 0, 0, 0, 0);
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    curl_cv_select="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    curl_cv_select="no"
+  ])
+  #
+  if test "$curl_cv_select" = "yes"; then
+    AC_DEFINE_UNQUOTED(HAVE_SELECT, 1,
+      [Define to 1 if you have the select function.])
+    curl_cv_func_select="yes"
+  fi
+])
+
+
+dnl CURL_VERIFY_RUNTIMELIBS
+dnl -------------------------------------------------
+dnl Verify that the shared libs found so far can be used when running
+dnl programs, since otherwise the situation will create odd configure errors
+dnl that are misleading people.
+dnl
+dnl Make sure this test is run BEFORE the first test in the script that
+dnl runs anything, which at the time of this writing is the AC_CHECK_SIZEOF
+dnl macro. It must also run AFTER all lib-checking macros are complete.
+
+AC_DEFUN([CURL_VERIFY_RUNTIMELIBS], [
+
+  dnl this test is of course not sensible if we are cross-compiling!
+  if test "x$cross_compiling" != xyes; then
+
+    dnl just run a program to verify that the libs checked for previous to this
+    dnl point also is available run-time!
+    AC_MSG_CHECKING([run-time libs availability])
+    CURL_RUN_IFELSE([
+      int main()
+      {
+        return 0;
+      }
+    ],
+    AC_MSG_RESULT([fine]),
+    AC_MSG_RESULT([failed])
+    AC_MSG_ERROR([one or more libs available at link-time are not available run-time. Libs used at link-time: $LIBS])
+    )
+
+    dnl if this test fails, configure has already stopped
+  fi
+])
+
+
+dnl CURL_CHECK_CA_BUNDLE
+dnl -------------------------------------------------
+dnl Check if a default ca-bundle should be used
+dnl
+dnl regarding the paths this will scan:
+dnl /etc/ssl/certs/ca-certificates.crt Debian systems
+dnl /etc/pki/tls/certs/ca-bundle.crt Redhat and Mandriva
+dnl /usr/share/ssl/certs/ca-bundle.crt old(er) Redhat
+dnl /usr/local/share/certs/ca-root-nss.crt MidnightBSD
+dnl /etc/ssl/cert.pem OpenBSD, MidnightBSD (symlink)
+dnl /etc/ssl/certs (CA path) SUSE, FreeBSD
+
+AC_DEFUN([CURL_CHECK_CA_BUNDLE], [
+
+  AC_MSG_CHECKING([default CA cert bundle/path])
+
+  AC_ARG_WITH(ca-bundle,
+AS_HELP_STRING([--with-ca-bundle=FILE],
+  [Absolute path to a file containing CA certificates (example: /etc/ca-bundle.crt)])
+AS_HELP_STRING([--without-ca-bundle], [Don't use a default CA bundle]),
+  [
+    want_ca="$withval"
+    if test "x$want_ca" = "xyes"; then
+      AC_MSG_ERROR([--with-ca-bundle=FILE requires a path to the CA bundle])
+    fi
+  ],
+  [ want_ca="unset" ])
+  AC_ARG_WITH(ca-path,
+AS_HELP_STRING([--with-ca-path=DIRECTORY],
+  [Absolute path to a directory containing CA certificates stored individually, with \
+their filenames in a hash format. This option can be used with the OpenSSL, \
+GnuTLS, mbedTLS and wolfSSL backends. Refer to OpenSSL c_rehash for details. \
+(example: /etc/certificates)])
+AS_HELP_STRING([--without-ca-path], [Don't use a default CA path]),
+  [
+    want_capath="$withval"
+    if test "x$want_capath" = "xyes"; then
+      AC_MSG_ERROR([--with-ca-path=DIRECTORY requires a path to the CA path directory])
+    fi
+  ],
+  [ want_capath="unset"])
+
+  ca_warning="   (warning: certs not found)"
+  capath_warning="   (warning: certs not found)"
+  check_capath=""
+
+  if test "x$want_ca" != "xno" -a "x$want_ca" != "xunset" -a \
+          "x$want_capath" != "xno" -a "x$want_capath" != "xunset"; then
+    dnl both given
+    ca="$want_ca"
+    capath="$want_capath"
+  elif test "x$want_ca" != "xno" -a "x$want_ca" != "xunset"; then
+    dnl --with-ca-bundle given
+    ca="$want_ca"
+    capath="no"
+  elif test "x$want_capath" != "xno" -a "x$want_capath" != "xunset"; then
+    dnl --with-ca-path given
+    capath="$want_capath"
+    ca="no"
+  else
+    dnl First try auto-detecting a CA bundle, then a CA path.
+    dnl Both auto-detections can be skipped by --without-ca-*
+    ca="no"
+    capath="no"
+    if test "x$cross_compiling" != "xyes" -a \
+            "x$curl_cv_native_windows" != "xyes"; then
+      dnl NOT cross-compiling and...
+      dnl neither of the --with-ca-* options are provided
+      if test "x$want_ca" = "xunset"; then
+        dnl the path we previously would have installed the curl CA bundle
+        dnl to, and thus we now check for an already existing cert in that
+        dnl place in case we find no other
+        if test "x$prefix" != xNONE; then
+          cac="${prefix}/share/curl/curl-ca-bundle.crt"
+        else
+          cac="$ac_default_prefix/share/curl/curl-ca-bundle.crt"
+        fi
+
+        for a in /etc/ssl/certs/ca-certificates.crt \
+                 /etc/pki/tls/certs/ca-bundle.crt \
+                 /usr/share/ssl/certs/ca-bundle.crt \
+                 /usr/local/share/certs/ca-root-nss.crt \
+                 /etc/ssl/cert.pem \
+                 "$cac"; do
+          if test -f "$a"; then
+            ca="$a"
+            break
+          fi
+        done
+      fi
+      AC_MSG_NOTICE([want $want_capath ca $ca])
+      if test "x$want_capath" = "xunset"; then
+        check_capath="/etc/ssl/certs"
+      fi
+    else
+      dnl no option given and cross-compiling
+      AC_MSG_WARN([skipped the ca-cert path detection when cross-compiling])
+    fi
+  fi
+
+  if test "x$ca" = "xno" || test -f "$ca"; then
+    ca_warning=""
+  fi
+
+  if test "x$capath" != "xno"; then
+    check_capath="$capath"
+  fi
+
+  if test ! -z "$check_capath"; then
+    for a in "$check_capath"; do
+      if test -d "$a" && ls "$a"/[[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 >/dev/null 2>/dev/null; then
+        if test "x$capath" = "xno"; then
+          capath="$a"
+        fi
+        capath_warning=""
+        break
+      fi
+    done
+  fi
+
+  if test "x$capath" = "xno"; then
+    capath_warning=""
+  fi
+
+  if test "x$ca" != "xno"; then
+    CURL_CA_BUNDLE="$ca"
+    AC_DEFINE_UNQUOTED(CURL_CA_BUNDLE, "$ca", [Location of default ca bundle])
+    AC_SUBST(CURL_CA_BUNDLE)
+    AC_MSG_RESULT([$ca])
+  fi
+  if test "x$capath" != "xno"; then
+    CURL_CA_PATH="\"$capath\""
+    AC_DEFINE_UNQUOTED(CURL_CA_PATH, "$capath", [Location of default ca path])
+    AC_MSG_RESULT([$capath (capath)])
+  fi
+  if test "x$ca" = "xno" && test "x$capath" = "xno"; then
+    AC_MSG_RESULT([no])
+  fi
+
+  AC_MSG_CHECKING([whether to use built-in CA store of SSL library])
+  AC_ARG_WITH(ca-fallback,
+AS_HELP_STRING([--with-ca-fallback], [Use the built-in CA store of the SSL library])
+AS_HELP_STRING([--without-ca-fallback], [Don't use the built-in CA store of the SSL library]),
+  [
+    if test "x$with_ca_fallback" != "xyes" -a "x$with_ca_fallback" != "xno"; then
+      AC_MSG_ERROR([--with-ca-fallback only allows yes or no as parameter])
+    fi
+  ],
+  [ with_ca_fallback="no"])
+  AC_MSG_RESULT([$with_ca_fallback])
+  if test "x$with_ca_fallback" = "xyes"; then
+    if test "x$OPENSSL_ENABLED" != "x1" -a "x$GNUTLS_ENABLED" != "x1"; then
+      AC_MSG_ERROR([--with-ca-fallback only works with OpenSSL or GnuTLS])
+    fi
+    AC_DEFINE_UNQUOTED(CURL_CA_FALLBACK, 1, [define "1" to use built-in CA store of SSL library])
+  fi
+])
+
+
+dnl CURL_CHECK_CA_EMBED
+dnl -------------------------------------------------
+dnl Check if a ca-bundle should be embedded
+
+AC_DEFUN([CURL_CHECK_CA_EMBED], [
+
+  AC_MSG_CHECKING([CA cert bundle path to embed in the curl tool])
+
+  AC_ARG_WITH(ca-embed,
+AS_HELP_STRING([--with-ca-embed=FILE],
+  [Absolute path to a file containing CA certificates to embed in the curl tool (example: /etc/ca-bundle.crt)])
+AS_HELP_STRING([--without-ca-embed], [Don't embed a default CA bundle in the curl tool]),
+  [
+    want_ca_embed="$withval"
+    if test "x$want_ca_embed" = "xyes"; then
+      AC_MSG_ERROR([--with-ca-embed=FILE requires a path to the CA bundle])
+    fi
+  ],
+  [ want_ca_embed="unset" ])
+
+  CURL_CA_EMBED=''
+  if test "x$want_ca_embed" != "xno" -a "x$want_ca_embed" != "xunset" -a -f "$want_ca_embed"; then
+    CURL_CA_EMBED="$want_ca_embed"
+    AC_SUBST(CURL_CA_EMBED)
+    AC_MSG_RESULT([$want_ca_embed])
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+dnl CURL_CHECK_WIN32_LARGEFILE
+dnl -------------------------------------------------
+dnl Check if curl's Win32 large file will be used
+
+AC_DEFUN([CURL_CHECK_WIN32_LARGEFILE], [
+  AC_REQUIRE([CURL_CHECK_NATIVE_WINDOWS])dnl
+  AC_MSG_CHECKING([whether build target supports Win32 file API])
+  curl_win32_file_api="no"
+  if test "$curl_cv_native_windows" = "yes"; then
+    if test x"$enable_largefile" != "xno"; then
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+        ]],[[
+          #if !defined(_WIN32_WCE) && (defined(__MINGW32__) || defined(_MSC_VER))
+            int dummy=1;
+          #else
+            #error Win32 large file API not supported.
+          #endif
+        ]])
+      ],[
+        curl_win32_file_api="win32_large_files"
+      ])
+    fi
+    if test "$curl_win32_file_api" = "no"; then
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+        ]],[[
+          #if defined(_WIN32_WCE) || defined(__MINGW32__) || defined(_MSC_VER)
+            int dummy=1;
+          #else
+            #error Win32 small file API not supported.
+          #endif
+        ]])
+      ],[
+        curl_win32_file_api="win32_small_files"
+      ])
+    fi
+  fi
+  case "$curl_win32_file_api" in
+    win32_large_files)
+      AC_MSG_RESULT([yes (large file enabled)])
+      AC_DEFINE_UNQUOTED(USE_WIN32_LARGE_FILES, 1,
+        [Define to 1 if you are building a Windows target with large file support.])
+      AC_SUBST(USE_WIN32_LARGE_FILES, [1])
+      ;;
+    win32_small_files)
+      AC_MSG_RESULT([yes (large file disabled)])
+      AC_DEFINE_UNQUOTED(USE_WIN32_SMALL_FILES, 1,
+        [Define to 1 if you are building a Windows target without large file support.])
+      AC_SUBST(USE_WIN32_SMALL_FILES, [1])
+      ;;
+    *)
+      AC_MSG_RESULT([no])
+      ;;
+  esac
+])
+
+dnl CURL_CHECK_WIN32_CRYPTO
+dnl -------------------------------------------------
+dnl Check if curl's Win32 crypto lib can be used
+
+AC_DEFUN([CURL_CHECK_WIN32_CRYPTO], [
+  AC_REQUIRE([CURL_CHECK_NATIVE_WINDOWS])dnl
+  AC_MSG_CHECKING([whether build target supports Win32 crypto API])
+  curl_win32_crypto_api="no"
+  if test "$curl_cv_native_windows" = "yes"; then
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        #undef inline
+        #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+        #endif
+        #include <windows.h>
+        #include <wincrypt.h>
+      ]],[[
+        HCRYPTPROV hCryptProv;
+        if(CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL,
+                               CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
+          CryptReleaseContext(hCryptProv, 0);
+        }
+      ]])
+    ],[
+      curl_win32_crypto_api="yes"
+    ])
+  fi
+  case "$curl_win32_crypto_api" in
+    yes)
+      AC_MSG_RESULT([yes])
+      AC_DEFINE_UNQUOTED(USE_WIN32_CRYPTO, 1,
+        [Define to 1 if you are building a Windows target with crypto API support.])
+      AC_SUBST(USE_WIN32_CRYPTO, [1])
+      ;;
+    *)
+      AC_MSG_RESULT([no])
+      ;;
+  esac
+])
+
+dnl CURL_EXPORT_PCDIR ($pcdir)
+dnl ------------------------
+dnl if $pcdir is not empty, set PKG_CONFIG_LIBDIR to $pcdir and export
+dnl
+dnl we need this macro since pkg-config distinguishes among empty and unset
+dnl variable while checking PKG_CONFIG_LIBDIR
+dnl
+
+AC_DEFUN([CURL_EXPORT_PCDIR], [
+  if test -n "$1"; then
+    PKG_CONFIG_LIBDIR="$1"
+    export PKG_CONFIG_LIBDIR
+  fi
+])
+
+dnl CURL_CHECK_PKGCONFIG ($module, [$pcdir])
+dnl ------------------------
+dnl search for the pkg-config tool. Set the PKGCONFIG variable to hold the
+dnl path to it, or 'no' if not found/present.
+dnl
+dnl If pkg-config is present, check that it has info about the $module or
+dnl return "no" anyway!
+dnl
+dnl Optionally PKG_CONFIG_LIBDIR may be given as $pcdir.
+dnl
+
+AC_DEFUN([CURL_CHECK_PKGCONFIG], [
+  if test -n "$PKG_CONFIG"; then
+    PKGCONFIG="$PKG_CONFIG"
+  else
+    AC_PATH_TOOL([PKGCONFIG], [pkg-config], [no],
+      [$PATH:/usr/bin:/usr/local/bin])
+  fi
+
+  if test "x$PKGCONFIG" != "xno"; then
+    AC_MSG_CHECKING([for $1 options with pkg-config])
+    dnl ask pkg-config about $1
+    itexists=`CURL_EXPORT_PCDIR([$2]) dnl
+      $PKGCONFIG --exists $1 >/dev/null 2>&1 && echo 1`
+
+    if test -z "$itexists"; then
+      dnl pkg-config does not have info about the given module! set the
+      dnl variable to 'no'
+      PKGCONFIG="no"
+      AC_MSG_RESULT([no])
+    else
+      AC_MSG_RESULT([found])
+    fi
+  fi
+])
+
+
+dnl CURL_PREPARE_CONFIGUREHELP_PM
+dnl -------------------------------------------------
+dnl Prepare test harness configurehelp.pm module, defining and
+dnl initializing some perl variables with values which are known
+dnl when the configure script runs. For portability reasons, test
+dnl harness needs information on how to run the C preprocessor.
+
+AC_DEFUN([CURL_PREPARE_CONFIGUREHELP_PM], [
+  AC_REQUIRE([AC_PROG_CPP])dnl
+  tmp_cpp=`eval echo "$ac_cpp" 2>/dev/null`
+  if test -z "$tmp_cpp"; then
+    tmp_cpp='cpp'
+  fi
+  AC_SUBST(CURL_CPP, $tmp_cpp)
+])
+
+
+dnl CURL_PREPARE_BUILDINFO
+dnl -------------------------------------------------
+dnl Save build info for test runner to pick up and log
+
+AC_DEFUN([CURL_PREPARE_BUILDINFO], [
+  curl_pflags=""
+  case $host in
+    *-apple-*) curl_pflags="${curl_pflags} APPLE";;
+  esac
+  if test "$curl_cv_native_windows" = 'yes'; then
+    curl_pflags="${curl_pflags} WIN32"
+  else
+    case $host in
+      *-*-*bsd*|*-*-aix*|*-*-hpux*|*-*-interix*|*-*-irix*|*-*-linux*|*-*-solaris*|*-*-sunos*|*-apple-*|*-*-cygwin*|*-*-msys*)
+        curl_pflags="${curl_pflags} UNIX";;
+    esac
+    case $host in
+      *-*-*bsd*)
+        curl_pflags="${curl_pflags} BSD";;
+    esac
+  fi
+  if test "$curl_cv_cygwin" = 'yes'; then
+    curl_pflags="${curl_pflags} CYGWIN"
+  fi
+  case $host_os in
+    msys*) curl_pflags="${curl_pflags} MSYS";;
+  esac
+  if test "x$compiler_id" = 'xGNU_C'; then
+    curl_pflags="${curl_pflags} GCC"
+  fi
+  case $host_os in
+    mingw*) curl_pflags="${curl_pflags} MINGW";;
+  esac
+  if test "x$cross_compiling" = 'xyes'; then
+    curl_pflags="${curl_pflags} CROSS"
+  fi
+  squeeze curl_pflags
+  curl_buildinfo="
+buildinfo.configure.tool: configure
+buildinfo.configure.args: $ac_configure_args
+buildinfo.host: $build
+buildinfo.host.cpu: $build_cpu
+buildinfo.host.os: $build_os
+buildinfo.target: $host
+buildinfo.target.cpu: $host_cpu
+buildinfo.target.os: $host_os
+buildinfo.target.flags: $curl_pflags
+buildinfo.compiler: $compiler_id
+buildinfo.compiler.version: $compiler_ver
+buildinfo.sysroot: $lt_sysroot"
+])
+
+
+dnl CURL_CPP_P
+dnl
+dnl Check if $cpp -P should be used for extract define values due to gcc 5
+dnl splitting up strings and defines between line outputs. gcc by default
+dnl (without -P) will show TEST EINVAL TEST as
+dnl
+dnl # 13 "conftest.c"
+dnl TEST
+dnl # 13 "conftest.c" 3 4
+dnl     22
+dnl # 13 "conftest.c"
+dnl            TEST
+
+AC_DEFUN([CURL_CPP_P], [
+  AC_MSG_CHECKING([if cpp -P is needed])
+  AC_EGREP_CPP([TEST.*TEST], [
+ #include <errno.h>
+TEST EINVAL TEST
+  ], [cpp=no], [cpp=yes])
+  AC_MSG_RESULT([$cpp])
+
+  dnl we need cpp -P so check if it works then
+  if test "x$cpp" = "xyes"; then
+    AC_MSG_CHECKING([if cpp -P works])
+    OLDCPPFLAGS=$CPPFLAGS
+    CPPFLAGS="$CPPFLAGS -P"
+    AC_EGREP_CPP([TEST.*TEST], [
+ #include <errno.h>
+TEST EINVAL TEST
+    ], [cpp_p=yes], [cpp_p=no])
+    AC_MSG_RESULT([$cpp_p])
+
+    if test "x$cpp_p" = "xno"; then
+      AC_MSG_WARN([failed to figure out cpp -P alternative])
+      # without -P
+      CPPPFLAG=""
+    else
+      # with -P
+      CPPPFLAG="-P"
+    fi
+    dnl restore CPPFLAGS
+    CPPFLAGS=$OLDCPPFLAGS
+  else
+    # without -P
+    CPPPFLAG=""
+  fi
+])
+
+
+dnl CURL_DARWIN_CFLAGS
+dnl
+dnl Set -Werror=partial-availability to detect possible breaking code
+dnl with very low deployment targets.
+dnl
+
+AC_DEFUN([CURL_DARWIN_CFLAGS], [
+
+  tst_cflags="no"
+  case $host in
+    *-apple-*)
+      tst_cflags="yes"
+      ;;
+  esac
+
+  AC_MSG_CHECKING([for good-to-use Darwin CFLAGS])
+  AC_MSG_RESULT([$tst_cflags]);
+
+  if test "$tst_cflags" = "yes"; then
+    old_CFLAGS=$CFLAGS
+    CFLAGS="$CFLAGS -Werror=partial-availability"
+    AC_MSG_CHECKING([whether $CC accepts -Werror=partial-availability])
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
+      [AC_MSG_RESULT([yes])],
+      [AC_MSG_RESULT([no])
+      CFLAGS=$old_CFLAGS])
+  fi
+
+])
+
+
+dnl CURL_SUPPORTS_BUILTIN_AVAILABLE
+dnl
+dnl Check to see if the compiler supports __builtin_available. This built-in
+dnl compiler function first appeared in Apple LLVM 9.0.0. It's so new that, at
+dnl the time this macro was written, the function was not yet documented. Its
+dnl purpose is to return true if the code is running under a certain OS version
+dnl or later.
+
+AC_DEFUN([CURL_SUPPORTS_BUILTIN_AVAILABLE], [
+  AC_MSG_CHECKING([to see if the compiler supports __builtin_available()])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+      if(__builtin_available(macOS 10.12, iOS 5.0, *)) {}
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_BUILTIN_AVAILABLE, 1,
+      [Define to 1 if you have the __builtin_available function.])
+  ],[
+    AC_MSG_RESULT([no])
+  ])
+])

local-test-curl-delta-01/afc-curl/appveyor.sh

@@ -0,0 +1,159 @@
+#!/usr/bin/env bash
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+###########################################################################
+
+# shellcheck disable=SC3040,SC2039
+set -eux; [ -n "${BASH:-}${ZSH_NAME:-}" ] && set -o pipefail
+
+# build
+
+if [ "${APPVEYOR_BUILD_WORKER_IMAGE}" = 'Visual Studio 2022' ]; then
+  openssl_root_win='C:/OpenSSL-v33-Win64'
+else
+  openssl_root_win='C:/OpenSSL-v111-Win64'
+fi
+openssl_root="$(cygpath "${openssl_root_win}")"
+
+if [ "${BUILD_SYSTEM}" = 'CMake' ]; then
+  options=''
+  [[ "${TARGET:-}" = *'ARM64'* ]] && SKIP_RUN='ARM64 architecture'
+  [ -n "${TOOLSET:-}" ] && options+=" -T ${TOOLSET}"
+  [ "${OPENSSL}" = 'ON' ] && options+=" -DOPENSSL_ROOT_DIR=${openssl_root_win}"
+  [ -n "${CURLDEBUG:-}" ] && options+=" -DENABLE_CURLDEBUG=${CURLDEBUG}"
+  [ "${PRJ_CFG}" = 'Debug' ] && options+=' -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG='
+  [ "${PRJ_CFG}" = 'Release' ] && options+=' -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE='
+  [[ "${PRJ_GEN}" = *'Visual Studio'* ]] && options+=' -DCMAKE_VS_GLOBALS=TrackFileAccess=false'
+  if [ "${PRJ_GEN}" = 'Visual Studio 9 2008' ]; then
+    [ "${DEBUG}" = 'ON' ] && [ "${SHARED}" = 'ON' ] && SKIP_RUN='Crash on startup in ENABLE_DEBUG=ON shared builds'
+    # Fails to run without this due to missing MSVCR90.dll / MSVCR90D.dll
+    options+=' -DCURL_STATIC_CRT=ON'
+  fi
+  # shellcheck disable=SC2086
+  cmake -B _bld "-G${PRJ_GEN}" ${TARGET:-} ${options} \
+    "-DCURL_USE_OPENSSL=${OPENSSL}" \
+    "-DCURL_USE_SCHANNEL=${SCHANNEL}" \
+    "-DHTTP_ONLY=${HTTP_ONLY}" \
+    "-DBUILD_SHARED_LIBS=${SHARED}" \
+    "-DCMAKE_UNITY_BUILD=${UNITY}" \
+    '-DCURL_TEST_BUNDLES=ON' \
+    '-DCURL_WERROR=ON' \
+    "-DENABLE_DEBUG=${DEBUG}" \
+    "-DENABLE_UNICODE=${ENABLE_UNICODE}" \
+    '-DCMAKE_INSTALL_PREFIX=C:/curl' \
+    "-DCMAKE_BUILD_TYPE=${PRJ_CFG}" \
+    '-DCURL_USE_LIBPSL=OFF'
+  if false; then
+    cat _bld/CMakeFiles/CMakeConfigureLog.yaml 2>/dev/null || true
+  fi
+  echo 'curl_config.h'; grep -F '#define' _bld/lib/curl_config.h | sort || true
+  # shellcheck disable=SC2086
+  if ! cmake --build _bld --config "${PRJ_CFG}" --parallel 2 -- ${BUILD_OPT:-}; then
+    if [ "${PRJ_GEN}" = 'Visual Studio 9 2008' ]; then
+      find . -name BuildLog.htm -exec dos2unix '{}' +
+      find . -name BuildLog.htm -exec cat '{}' +
+    fi
+    false
+  fi
+  if [ "${SHARED}" = 'ON' ]; then
+    PATH="$PWD/_bld/lib:$PATH"
+  fi
+  if [ "${OPENSSL}" = 'ON' ]; then
+    PATH="$PWD/_bld/lib:${openssl_root}:$PATH"
+  fi
+  curl='_bld/src/curl.exe'
+elif [ "${BUILD_SYSTEM}" = 'VisualStudioSolution' ]; then
+  (
+    cd projects
+    ./generate.bat "${VC_VERSION}"
+    msbuild.exe -maxcpucount "-property:Configuration=${PRJ_CFG}" "Windows/${VC_VERSION}/curl-all.sln"
+  )
+  curl="build/Win32/${VC_VERSION}/${PRJ_CFG}/curld.exe"
+elif [ "${BUILD_SYSTEM}" = 'winbuild_vs2015' ]; then
+  ./buildconf.bat
+  (
+    cd winbuild
+    cat << EOF > _make.bat
+      call "C:/Program Files/Microsoft SDKs/Windows/v7.1/Bin/SetEnv.cmd" /x64
+      call "C:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/vcvarsall.bat" x86_amd64
+      nmake -f Makefile.vc mode=dll VC=14 "SSL_PATH=${openssl_root_win}" WITH_SSL=dll MACHINE=x64 DEBUG=${DEBUG} ENABLE_UNICODE=${ENABLE_UNICODE}
+EOF
+    ./_make.bat
+    rm _make.bat
+  )
+  curl="builds/libcurl-vc14-x64-${PATHPART}-dll-ssl-dll-ipv6-sspi/bin/curl.exe"
+elif [ "${BUILD_SYSTEM}" = 'winbuild_vs2017' ]; then
+  ./buildconf.bat
+  (
+    cd winbuild
+    cat << EOF > _make.bat
+      call "C:/Program Files (x86)/Microsoft Visual Studio/2017/Community/VC/Auxiliary/Build/vcvars64.bat"
+      nmake -f Makefile.vc mode=dll VC=14.10 "SSL_PATH=${openssl_root_win}" WITH_SSL=dll MACHINE=x64 DEBUG=${DEBUG} ENABLE_UNICODE=${ENABLE_UNICODE}
+EOF
+    ./_make.bat
+    rm _make.bat
+  )
+  curl="builds/libcurl-vc14.10-x64-${PATHPART}-dll-ssl-dll-ipv6-sspi/bin/curl.exe"
+fi
+
+find . -name '*.exe' -o -name '*.dll'
+if [ -z "${SKIP_RUN:-}" ]; then
+  "${curl}" --disable --version
+else
+  echo "Skip running curl.exe. Reason: ${SKIP_RUN}"
+fi
+
+# build tests
+
+if [[ "${TFLAGS}" != 'skipall' ]] && \
+   [ "${BUILD_SYSTEM}" = 'CMake' ]; then
+  cmake --build _bld --config "${PRJ_CFG}" --parallel 2 --target testdeps
+fi
+
+# run tests
+
+if [[ "${TFLAGS}" != 'skipall' ]] && \
+   [[ "${TFLAGS}" != 'skiprun' ]]; then
+  if [ -x "$(cygpath "${SYSTEMROOT}/System32/curl.exe")" ]; then
+    TFLAGS+=" -ac $(cygpath "${SYSTEMROOT}/System32/curl.exe")"
+  elif [ -x "$(cygpath 'C:/msys64/usr/bin/curl.exe')" ]; then
+    TFLAGS+=" -ac $(cygpath 'C:/msys64/usr/bin/curl.exe')"
+  fi
+  TFLAGS+=' -j0'
+  if [ "${BUILD_SYSTEM}" = 'CMake' ]; then
+    cmake --build _bld --config "${PRJ_CFG}" --target test-ci
+  else
+    (
+      TFLAGS="-a -p !flaky -r -rm ${TFLAGS}"
+      cd _bld/tests
+      ./runtests.pl
+    )
+  fi
+fi
+
+# build examples
+
+if [[ "${EXAMPLES}" = 'ON' ]] && \
+   [ "${BUILD_SYSTEM}" = 'CMake' ]; then
+  cmake --build _bld --config "${PRJ_CFG}" --parallel 2 --target curl-examples
+fi

local-test-curl-delta-01/afc-curl/appveyor.yml

@@ -0,0 +1,222 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+###########################################################################
+
+# https://ci.appveyor.com/project/curlorg/curl/history
+# AppVeyor configuration:
+#   https://www.appveyor.com/docs/appveyor-yml/
+# AppVeyor worker images:
+#   https://www.appveyor.com/docs/windows-images-software/
+
+version: 7.50.0.{build}
+
+environment:
+  UNITY: 'ON'
+  OPENSSL: 'OFF'
+  DEBUG: 'ON'
+  SHARED: 'OFF'
+  HTTP_ONLY: 'OFF'
+  TFLAGS: 'skiprun'
+  EXAMPLES: 'OFF'
+
+  matrix:
+
+    # generated CMake-based Visual Studio builds
+
+    - job_name: 'CMake, VS2008, Release, x86, Schannel, Shared, Build-tests'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2015'
+      BUILD_SYSTEM: CMake
+      PRJ_GEN: 'Visual Studio 9 2008'
+      PRJ_CFG: Release
+      DEBUG: 'OFF'
+      SCHANNEL: 'ON'
+      ENABLE_UNICODE: 'OFF'
+      SHARED: 'ON'
+    - job_name: 'CMake, VS2008, Debug, x86, Schannel, Shared, Build-tests & examples'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2015'
+      BUILD_SYSTEM: CMake
+      PRJ_GEN: 'Visual Studio 9 2008'
+      PRJ_CFG: Debug
+      SCHANNEL: 'ON'
+      ENABLE_UNICODE: 'OFF'
+      SHARED: 'ON'
+      EXAMPLES: 'ON'
+    - job_name: 'CMake, VS2022, Release, x64, OpenSSL 3.3, Shared, Build-tests'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2022'
+      BUILD_SYSTEM: CMake
+      PRJ_GEN: 'Visual Studio 17 2022'
+      TARGET: '-A x64'
+      PRJ_CFG: Release
+      OPENSSL: 'ON'
+      SCHANNEL: 'OFF'
+      ENABLE_UNICODE: 'OFF'
+      SHARED: 'ON'
+    - job_name: 'CMake, VS2022, Release, arm64, Schannel, Static, Build-tests'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2022'
+      BUILD_SYSTEM: CMake
+      PRJ_GEN: 'Visual Studio 17 2022'
+      TARGET: '-A ARM64'
+      PRJ_CFG: Release
+      SCHANNEL: 'ON'
+      ENABLE_UNICODE: 'OFF'
+      DEBUG: 'OFF'
+      CURLDEBUG: 'ON'
+    - job_name: 'CMake, VS2010, Debug, x64, Schannel, Static, Build-tests & examples'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2015'
+      BUILD_SYSTEM: CMake
+      PRJ_GEN: 'Visual Studio 10 2010 Win64'
+      PRJ_CFG: Debug
+      SCHANNEL: 'ON'
+      ENABLE_UNICODE: 'OFF'
+      EXAMPLES: 'ON'
+    - job_name: 'CMake, VS2022, Debug, x64, Schannel, Static, Unicode, Build-tests & examples, clang-cl'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2022'
+      BUILD_SYSTEM: CMake
+      PRJ_GEN: 'Visual Studio 17 2022'
+      TARGET: '-A x64'
+      PRJ_CFG: Debug
+      SCHANNEL: 'ON'
+      ENABLE_UNICODE: 'ON'
+      EXAMPLES: 'ON'
+      TOOLSET: 'ClangCl'
+    - job_name: 'CMake, VS2022, Debug, x64, Schannel, Static, Unicode, Build-tests'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2022'
+      BUILD_SYSTEM: CMake
+      PRJ_GEN: 'Visual Studio 17 2022'
+      TARGET: '-A x64'
+      PRJ_CFG: Debug
+      SCHANNEL: 'ON'
+      ENABLE_UNICODE: 'ON'
+    - job_name: 'CMake, VS2022, Release, x64, Schannel, Shared, Unicode, DEBUGBUILD, no-CURLDEBUG, Build-tests'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2022'
+      BUILD_SYSTEM: CMake
+      PRJ_GEN: 'Visual Studio 17 2022'
+      TARGET: '-A x64'
+      PRJ_CFG: Release
+      SCHANNEL: 'ON'
+      ENABLE_UNICODE: 'ON'
+      SHARED: 'ON'
+      CURLDEBUG: 'OFF'
+    - job_name: 'CMake, VS2022, Debug, x64, no SSL, Static, Build-tests'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2022'
+      BUILD_SYSTEM: CMake
+      PRJ_GEN: 'Visual Studio 17 2022'
+      TARGET: '-A x64'
+      PRJ_CFG: Debug
+      SCHANNEL: 'OFF'
+      ENABLE_UNICODE: 'OFF'
+    - job_name: 'CMake, VS2022, Debug, x64, no SSL, Static, HTTP only, Build-tests'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2022'
+      BUILD_SYSTEM: CMake
+      PRJ_GEN: 'Visual Studio 17 2022'
+      TARGET: '-A x64'
+      PRJ_CFG: Debug
+      SCHANNEL: 'OFF'
+      ENABLE_UNICODE: 'OFF'
+      HTTP_ONLY: 'ON'
+
+    # winbuild-based builds
+
+    - job_name: 'winbuild, VS2015, Debug, x64, OpenSSL 1.1.1, Build-only'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2015'
+      BUILD_SYSTEM: winbuild_vs2015
+      DEBUG: 'yes'
+      PATHPART: debug
+      ENABLE_UNICODE: 'no'
+    - job_name: 'winbuild, VS2015, Release, x64, OpenSSL 1.1.1, Build-only'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2015'
+      BUILD_SYSTEM: winbuild_vs2015
+      DEBUG: 'no'
+      PATHPART: release
+      ENABLE_UNICODE: 'no'
+    - job_name: 'winbuild, VS2017, Debug, x64, OpenSSL 1.1.1, Build-only'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2017'
+      BUILD_SYSTEM: winbuild_vs2017
+      DEBUG: 'yes'
+      PATHPART: debug
+      ENABLE_UNICODE: 'no'
+    - job_name: 'winbuild, VS2017, Release, x64, OpenSSL 1.1.1, Build-only'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2017'
+      BUILD_SYSTEM: winbuild_vs2017
+      DEBUG: 'no'
+      PATHPART: release
+      ENABLE_UNICODE: 'no'
+    - job_name: 'winbuild, VS2015, Debug, x64, OpenSSL 1.1.1, Unicode, Build-only'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2015'
+      BUILD_SYSTEM: winbuild_vs2015
+      DEBUG: 'yes'
+      PATHPART: debug
+      ENABLE_UNICODE: 'yes'
+    - job_name: 'winbuild, VS2015, Release, x64, OpenSSL 1.1.1, Unicode, Build-only'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2015'
+      BUILD_SYSTEM: winbuild_vs2015
+      DEBUG: 'no'
+      PATHPART: release
+      ENABLE_UNICODE: 'yes'
+    - job_name: 'winbuild, VS2017, Debug, x64, OpenSSL 1.1.1, Unicode, Build-only'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2017'
+      BUILD_SYSTEM: winbuild_vs2017
+      DEBUG: 'yes'
+      PATHPART: debug
+      ENABLE_UNICODE: 'yes'
+    - job_name: 'winbuild, VS2017, Release, x64, OpenSSL 1.1.1, Unicode, Build-only'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2017'
+      BUILD_SYSTEM: winbuild_vs2017
+      DEBUG: 'no'
+      PATHPART: release
+      ENABLE_UNICODE: 'yes'
+
+    # generated VisualStudioSolution-based builds
+
+    - job_name: 'VisualStudioSolution, VS2013, Debug, x86, Schannel, Build-only'
+      APPVEYOR_BUILD_WORKER_IMAGE: 'Visual Studio 2015'
+      BUILD_SYSTEM: VisualStudioSolution
+      PRJ_CFG: 'DLL Debug - DLL Windows SSPI - DLL WinIDN'
+      VC_VERSION: VC12
+
+install:
+  - ps: $env:PATH = "C:/msys64/usr/bin;$env:PATH"
+
+build_script:
+  - cmd: sh -c ./appveyor.sh
+
+clone_depth: 10
+
+# select branches to avoid testing feature branches twice (as branch and as pull request)
+branches:
+  only:
+    - master
+    - /\/ci$/
+
+skip_commits:
+  files:
+    - '.circleci/*'
+    - '.github/**/*'
+    - 'packages/**/*'
+    - 'plan9/**/*'
+
+#artifacts:
+#  - path: '**/curl.exe'
+#    name: curl
+#  - path: '**/*curl*.dll'
+#    name: libcurl dll

local-test-curl-delta-01/afc-curl/buildconf

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# SPDX-License-Identifier: curl
+
+echo "*** Do not use buildconf. Instead, just use: autoreconf -fi" >&2
+exec ${AUTORECONF:-autoreconf} -fi "${@}"

local-test-curl-delta-01/afc-curl/buildconf.bat

@@ -0,0 +1,265 @@
+@echo off
+rem ***************************************************************************
+rem *                                  _   _ ____  _
+rem *  Project                     ___| | | |  _ \| |
+rem *                             / __| | | | |_) | |
+rem *                            | (__| |_| |  _ <| |___
+rem *                             \___|\___/|_| \_\_____|
+rem *
+rem * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+rem *
+rem * This software is licensed as described in the file COPYING, which
+rem * you should have received as part of this distribution. The terms
+rem * are also available at https://curl.se/docs/copyright.html.
+rem *
+rem * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+rem * copies of the Software, and permit persons to whom the Software is
+rem * furnished to do so, under the terms of the COPYING file.
+rem *
+rem * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+rem * KIND, either express or implied.
+rem *
+rem * SPDX-License-Identifier: curl
+rem *
+rem ***************************************************************************
+
+rem NOTES
+rem
+rem This batch file must be used to set up a git tree to build on systems where
+rem there is no autotools support (i.e. DOS and Windows).
+rem
+
+:begin
+  rem Set our variables
+  if "%OS%" == "Windows_NT" setlocal
+  set MODE=GENERATE
+
+  rem Switch to this batch file's directory
+  cd /d "%~0\.." 1>NUL 2>&1
+
+  rem Check we are running from a curl git repository
+  if not exist GIT-INFO.md goto norepo
+
+:parseArgs
+  if "%~1" == "" goto start
+
+  if /i "%~1" == "-clean" (
+    set MODE=CLEAN
+  ) else if /i "%~1" == "-?" (
+    goto syntax
+  ) else if /i "%~1" == "-h" (
+    goto syntax
+  ) else if /i "%~1" == "-help" (
+    goto syntax
+  ) else (
+    goto unknown
+  )
+
+  shift & goto parseArgs
+
+:start
+  if "%MODE%" == "GENERATE" (
+    echo.
+    echo Generating prerequisite files
+
+    call :generate
+    if errorlevel 3 goto nogenhugehelp
+    if errorlevel 2 goto nogenmakefile
+    if errorlevel 1 goto warning
+
+  ) else (
+    echo.
+    echo Removing prerequisite files
+
+    call :clean
+    if errorlevel 2 goto nocleanhugehelp
+    if errorlevel 1 goto nocleanmakefile
+  )
+
+  goto success
+
+rem Main generate function.
+rem
+rem Returns:
+rem
+rem 0 - success
+rem 1 - success with simplified tool_hugehelp.c
+rem 2 - failed to generate Makefile
+rem 3 - failed to generate tool_hugehelp.c
+rem
+:generate
+  if "%OS%" == "Windows_NT" setlocal
+  set BASIC_HUGEHELP=0
+
+  rem Create Makefile
+  echo * %CD%\Makefile
+  if exist Makefile.dist (
+    copy /Y Makefile.dist Makefile 1>NUL 2>&1
+    if errorlevel 1 (
+      if "%OS%" == "Windows_NT" endlocal
+      exit /B 2
+    )
+  )
+
+  rem Create tool_hugehelp.c
+  echo * %CD%\src\tool_hugehelp.c
+  call :genHugeHelp
+  if errorlevel 2 (
+    if "%OS%" == "Windows_NT" endlocal
+    exit /B 3
+  )
+  if errorlevel 1 (
+    set BASIC_HUGEHELP=1
+  )
+  cmd /c exit 0
+
+  if "%BASIC_HUGEHELP%" == "1" (
+    if "%OS%" == "Windows_NT" endlocal
+    exit /B 1
+  )
+
+  if "%OS%" == "Windows_NT" endlocal
+  exit /B 0
+
+rem Main clean function.
+rem
+rem Returns:
+rem
+rem 0 - success
+rem 1 - failed to clean Makefile
+rem 2 - failed to clean tool_hugehelp.c
+rem
+:clean
+  rem Remove Makefile
+  echo * %CD%\Makefile
+  if exist Makefile (
+    del Makefile 2>NUL
+    if exist Makefile (
+      exit /B 1
+    )
+  )
+
+  rem Remove tool_hugehelp.c
+  echo * %CD%\src\tool_hugehelp.c
+  if exist src\tool_hugehelp.c (
+    del src\tool_hugehelp.c 2>NUL
+    if exist src\tool_hugehelp.c (
+      exit /B 2
+    )
+  )
+
+  exit /B
+
+rem Function to generate src\tool_hugehelp.c
+rem
+rem Returns:
+rem
+rem 0 - full tool_hugehelp.c generated
+rem 1 - simplified tool_hugehelp.c
+rem 2 - failure
+rem
+:genHugeHelp
+  if "%OS%" == "Windows_NT" setlocal
+  set LC_ALL=C
+  set BASIC=1
+
+  if exist src\tool_hugehelp.c.cvs (
+    copy /Y src\tool_hugehelp.c.cvs src\tool_hugehelp.c 1>NUL 2>&1
+  ) else (
+    echo #include "tool_setup.h"> src\tool_hugehelp.c
+    echo #include "tool_hugehelp.h">> src\tool_hugehelp.c
+    echo.>> src\tool_hugehelp.c
+    echo void hugehelp(void^)>> src\tool_hugehelp.c
+    echo {>> src\tool_hugehelp.c
+    echo #ifdef USE_MANUAL>> src\tool_hugehelp.c
+    echo   fputs("Built-in manual not included\n", stdout^);>> src\tool_hugehelp.c
+    echo #endif>> src\tool_hugehelp.c
+    echo }>> src\tool_hugehelp.c
+  )
+
+  findstr "/C:void hugehelp(void)" src\tool_hugehelp.c 1>NUL 2>&1
+  if errorlevel 1 (
+    if "%OS%" == "Windows_NT" endlocal
+    exit /B 2
+  )
+
+  if "%BASIC%" == "1" (
+    if "%OS%" == "Windows_NT" endlocal
+    exit /B 1
+  )
+
+  if "%OS%" == "Windows_NT" endlocal
+  exit /B 0
+
+rem Function to clean-up local variables under DOS, Windows 3.x and
+rem Windows 9x as setlocal isn't available until Windows NT
+rem
+:dosCleanup
+  set MODE=
+  set BASIC_HUGEHELP=
+  set LC_ALL
+  set BASIC=
+
+  exit /B
+
+:syntax
+  rem Display the help
+  echo.
+  echo Usage: buildconf [-clean]
+  echo.
+  echo -clean    - Removes the files
+  goto error
+
+:unknown
+  echo.
+  echo Error: Unknown argument '%1'
+  goto error
+
+:norepo
+  echo.
+  echo Error: This batch file should only be used with a curl git repository
+  goto error
+
+:nogenmakefile
+  echo.
+  echo Error: Unable to generate Makefile
+  goto error
+
+:nogenhugehelp
+  echo.
+  echo Error: Unable to generate src\tool_hugehelp.c
+  goto error
+
+:nocleanmakefile
+  echo.
+  echo Error: Unable to clean Makefile
+  goto error
+
+:nocleanhugehelp
+  echo.
+  echo Error: Unable to clean src\tool_hugehelp.c
+  goto error
+
+:warning
+  echo.
+  echo Warning: The curl manual could not be integrated in the source. This means when
+  echo you build curl the manual will not be available (curl --manual^). Integration of
+  echo the manual is not required and a summary of the options will still be available
+  echo (curl --help^). To integrate the manual build with configure or cmake.
+  goto success
+
+:error
+  if "%OS%" == "Windows_NT" (
+    endlocal
+  ) else (
+    call :dosCleanup
+  )
+  exit /B 1
+
+:success
+  if "%OS%" == "Windows_NT" (
+    endlocal
+  ) else (
+    call :dosCleanup
+  )
+  exit /B 0

local-test-curl-delta-01/afc-curl/curl-config.in

@@ -0,0 +1,195 @@
+#!/bin/sh
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+###########################################################################
+
+# shellcheck disable=SC2006
+
+prefix='@prefix@'
+# Used in 'libdir'
+# shellcheck disable=SC2034
+exec_prefix="@exec_prefix@"
+# shellcheck disable=SC2034
+includedir="@includedir@"
+cppflag_curl_staticlib='@LIBCURL_PC_CFLAGS@'
+
+usage()
+{
+  cat <<EOF
+Usage: curl-config [OPTION]
+
+Available values for OPTION include:
+
+  --built-shared says 'yes' if libcurl was built shared
+  --ca                  CA bundle install path
+  --cc                  compiler
+  --cflags              preprocessor and compiler flags
+  --checkfor [version]  check for (lib)curl of the specified version
+  --configure           the arguments given to configure when building curl
+  --features            newline separated list of enabled features
+  --help                display this help and exit
+  --libs                library linking information
+  --prefix              curl install prefix
+  --protocols           newline separated list of enabled protocols
+  --ssl-backends        output the SSL backends libcurl was built to support
+  --static-libs         static libcurl library linking information
+  --version             output version information
+  --vernum              output version as a hexadecimal number
+EOF
+
+  exit "$1"
+}
+
+if test "$#" -eq 0; then
+  usage 1
+fi
+
+while test "$#" -gt 0; do
+  case "$1" in
+  --built-shared)
+    echo '@ENABLE_SHARED@'
+    ;;
+
+  --ca)
+    echo '@CURL_CA_BUNDLE@'
+    ;;
+
+  --cc)
+    echo '@CC@'
+    ;;
+
+  --prefix)
+    echo "$prefix"
+    ;;
+
+  --feature|--features)
+    for feature in @SUPPORT_FEATURES@ ''; do
+      test -n "$feature" && echo "$feature"
+    done
+    ;;
+
+  --protocols)
+    # shellcheck disable=SC2043
+    for protocol in @SUPPORT_PROTOCOLS@; do
+      echo "$protocol"
+    done
+    ;;
+
+  --version)
+    echo 'libcurl @CURLVERSION@'
+    exit 0
+    ;;
+
+  --checkfor)
+    checkfor="$2"
+    cmajor=`echo "$checkfor" | cut -d. -f1`
+    cminor=`echo "$checkfor" | cut -d. -f2`
+    # when extracting the patch part we strip off everything after a
+    # dash as that's used for things like version 1.2.3-pre1
+    cpatch=`echo "$checkfor" | cut -d. -f3 | cut -d- -f1`
+
+    vmajor=`echo '@CURLVERSION@' | cut -d. -f1`
+    vminor=`echo '@CURLVERSION@' | cut -d. -f2`
+    # when extracting the patch part we strip off everything after a
+    # dash as that's used for things like version 1.2.3-pre1
+    vpatch=`echo '@CURLVERSION@' | cut -d. -f3 | cut -d- -f1`
+
+    if test "$vmajor" -gt "$cmajor"; then
+      exit 0
+    fi
+    if test "$vmajor" -eq "$cmajor"; then
+      if test "$vminor" -gt "$cminor"; then
+        exit 0
+      fi
+      if test "$vminor" -eq "$cminor"; then
+        if test "$cpatch" -le "$vpatch"; then
+          exit 0
+        fi
+      fi
+    fi
+
+    echo "requested version $checkfor is newer than existing @CURLVERSION@"
+    exit 1
+    ;;
+
+  --vernum)
+    echo '@VERSIONNUM@'
+    exit 0
+    ;;
+
+  --help)
+    usage 0
+    ;;
+
+  --cflags)
+    if test "X$cppflag_curl_staticlib" = 'X-DCURL_STATICLIB'; then
+      CPPFLAG_CURL_STATICLIB='-DCURL_STATICLIB '
+    else
+      CPPFLAG_CURL_STATICLIB=''
+    fi
+    if test "X@includedir@" = 'X/usr/include'; then
+      echo "${CPPFLAG_CURL_STATICLIB}"
+    else
+      echo "${CPPFLAG_CURL_STATICLIB}-I@includedir@"
+    fi
+    ;;
+
+  --libs)
+    if test "X@libdir@" != 'X/usr/lib' -a "X@libdir@" != 'X/usr/lib64'; then
+      CURLLIBDIR="-L@libdir@ "
+    else
+      CURLLIBDIR=''
+    fi
+    if test 'X@ENABLE_SHARED@' = 'Xno'; then
+      echo "${CURLLIBDIR}-lcurl @LIBCURL_PC_LIBS_PRIVATE@"
+    else
+      echo "${CURLLIBDIR}-lcurl"
+    fi
+    ;;
+
+  --ssl-backends)
+    echo '@SSL_BACKENDS@'
+    ;;
+
+  --static-libs)
+    if test 'X@ENABLE_STATIC@' != 'Xno'; then
+      echo "@libdir@/libcurl.@libext@ @LIBCURL_PC_LDFLAGS_PRIVATE@ @LIBCURL_PC_LIBS_PRIVATE@"
+    else
+      echo 'curl was built with static libraries disabled' >&2
+      exit 1
+    fi
+    ;;
+
+  --configure)
+    echo @CONFIGURE_OPTIONS@
+    ;;
+
+  *)
+    echo "unknown option: $1"
+    usage 1
+    ;;
+  esac
+  shift
+done
+
+exit 0

local-test-curl-delta-01/afc-curl/libcurl.pc.in

@@ -0,0 +1,41 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+###########################################################################
+
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+supported_protocols="@SUPPORT_PROTOCOLS@"
+supported_features="@SUPPORT_FEATURES@"
+
+Name: libcurl
+URL: https://curl.se/
+Description: Library to transfer files with HTTP, FTP, etc.
+Version: @CURLVERSION@
+Requires: @LIBCURL_PC_REQUIRES@
+Requires.private: @LIBCURL_PC_REQUIRES_PRIVATE@
+Libs: -L${libdir} -lcurl @LIBCURL_PC_LIBS@
+Libs.private: @LIBCURL_PC_LDFLAGS_PRIVATE@ @LIBCURL_PC_LIBS_PRIVATE@
+Cflags: -I${includedir} @LIBCURL_PC_CFLAGS@
+Cflags.private: @LIBCURL_PC_CFLAGS_PRIVATE@

local-test-curl-delta-01/diff/ref.diff

@@ -0,0 +1,785 @@
+diff --git a/.gitignore b/.gitignore
+index 55768f6ed..afc0724aa 100644
+--- a/.gitignore
++++ b/.gitignore
+@@ -2,6 +2,7 @@
+ #
+ # SPDX-License-Identifier: curl
+ 
++curl-install/*
+ *.asc
+ *.dll
+ *.exe
+diff --git a/include/curl/curl.h b/include/curl/curl.h
+index 18835586a..e3af00ca2 100644
+--- a/include/curl/curl.h
++++ b/include/curl/curl.h
+@@ -1078,6 +1078,7 @@ typedef CURLSTScode (*curl_hstswrite_callback)(CURL *easy,
+ #define CURLPROTO_SMBS   (1<<27)
+ #define CURLPROTO_MQTT   (1<<28)
+ #define CURLPROTO_GOPHERS (1<<29)
++#define CURLPROTO_VERYNORMAL (1<<30)
+ #define CURLPROTO_ALL    (~0) /* enable everything */
+ 
+ /* long may be 32 or 64 bits, but we should never depend on anything else
+diff --git a/lib/Makefile.inc b/lib/Makefile.inc
+index 1d3f69a23..70c313e7c 100644
+--- a/lib/Makefile.inc
++++ b/lib/Makefile.inc
+@@ -235,6 +235,7 @@ LIB_CFILES =         \
+   urlapi.c           \
+   version.c          \
+   version_win32.c    \
++  verynormalprotocol.c \
+   warnless.c         \
+   ws.c
+ 
+diff --git a/lib/url.c b/lib/url.c
+index 436edd891..cc5fd0184 100644
+--- a/lib/url.c
++++ b/lib/url.c
+@@ -119,6 +119,7 @@
+ #include "altsvc.h"
+ #include "dynbuf.h"
+ #include "headers.h"
++#include "verynormalprotocol.h"
+ 
+ /* The last 3 #include files should be in this order */
+ #include "curl_printf.h"
+@@ -1600,6 +1601,8 @@ const struct Curl_handler *Curl_getn_scheme_handler(const char *scheme,
+     NULL,
+ #endif
+   };
++  if(strcmp(scheme, "verynormalprotocol") == 0)
++    return &Curl_handler_verynormalprotocol;
+ 
+   if(len && (len <= 7)) {
+     const char *s = scheme;
+diff --git a/lib/urldata.h b/lib/urldata.h
+index 704fb7a1d..3a02c1496 100644
+--- a/lib/urldata.h
++++ b/lib/urldata.h
+@@ -52,6 +52,7 @@
+ #define PORT_RTMPS PORT_HTTPS
+ #define PORT_GOPHER 70
+ #define PORT_MQTT 1883
++#define PORT_VERYNORMAL 6666
+ 
+ struct curl_trc_featt;
+ 
+diff --git a/lib/verynormalprotocol.c b/lib/verynormalprotocol.c
+new file mode 100644
+index 000000000..6b53dc359
+--- /dev/null
++++ b/lib/verynormalprotocol.c
+@@ -0,0 +1,152 @@
++
++/***************************************************************************
++ *                                  _   _ ____  _
++ *  Project                     ___| | | |  _ \| |
++ *                             / __| | | | |_) | |
++ *                            | (__| |_| |  _ <| |___
++ *                             \___|\___/|_| \_\_____|
++ *
++ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
++ *
++ * This software is licensed as described in the file COPYING, which
++ * you should have received as part of this distribution. The terms
++ * are also available at https://curl.se/docs/copyright.html.
++ *
++ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
++ * copies of the Software, and permit persons to whom the Software is
++ * furnished to do so, under the terms of the COPYING file.
++ *
++ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
++ * KIND, either express or implied.
++ *
++ * SPDX-License-Identifier: curl
++ *
++ ***************************************************************************/
++
++/*
++ * The "verynormalprotocol" is a basic protocol
++ * intended to test Curls basic functionality.
++ * Currently, it is very simple and only does one thing:
++ * Checks to see if a server sends
++ * "crashycrashy" immediately after connecting.
++ * If it does, the transaction returns CURLE_OK.
++ * Otherwise, it returns CURLE_WEIRD_SERVER_REPLY.
++*/
++#include "curl_setup.h"
++
++#ifdef HAVE_NETINET_IN_H
++#include <netinet/in.h>
++#endif
++#ifdef HAVE_NETDB_H
++#include <netdb.h>
++#endif
++#ifdef HAVE_ARPA_INET_H
++#include <arpa/inet.h>
++#endif
++#ifdef HAVE_NET_IF_H
++#include <net/if.h>
++#endif
++#ifdef HAVE_SYS_IOCTL_H
++#include <sys/ioctl.h>
++#endif
++
++#ifdef HAVE_SYS_PARAM_H
++#include <sys/param.h>
++#endif
++
++#ifdef HAVE_SYS_SELECT_H
++#include <sys/select.h>
++#elif defined(HAVE_UNISTD_H)
++#include <unistd.h>
++#endif
++
++#include "urldata.h"
++#include <curl/curl.h>
++#include "transfer.h"
++#include "sendf.h"
++#include "escape.h"
++#include "progress.h"
++#include "verynormalprotocol.h"
++#include "curl_printf.h"
++#include "strcase.h"
++#include "curl_memory.h"
++/* The last #include file should be: */
++#include "memdebug.h"
++#include "curl_md5.h"
++
++/*
++ * Forward declarations.
++ */
++
++static CURLcode verynormalprotocol_do(struct Curl_easy *data, bool *done);
++static CURLcode verynormalprotocol_doing(struct Curl_easy *data, bool *done);
++
++/*
++ * verynormalprotocol protocol handler.
++ */
++
++const struct Curl_handler Curl_handler_verynormalprotocol = {
++  "verynormalprotocol",                             /* scheme */
++  ZERO_NULL,                    /* setup_connection */
++  verynormalprotocol_do,                            /* do_it */
++  ZERO_NULL,                          /* done */
++  ZERO_NULL,                          /* do_more */
++  ZERO_NULL,                          /* connect_it */
++  ZERO_NULL,                          /* connecting */
++  verynormalprotocol_doing,                         /* doing */
++  ZERO_NULL,                          /* proto_getsock */
++  ZERO_NULL,                       /* doing_getsock */
++  ZERO_NULL,                          /* domore_getsock */
++  ZERO_NULL,                          /* perform_getsock */
++  ZERO_NULL,                          /* disconnect */
++  ZERO_NULL,                          /* write_resp */
++  ZERO_NULL,                          /* write_resp_hd */
++  ZERO_NULL,                          /* connection_check */
++  ZERO_NULL,                          /* attach connection */
++  PORT_VERYNORMAL,                          /* defport */
++  CURLPROTO_VERYNORMAL,                     /* protocol */
++  CURLPROTO_VERYNORMAL,                     /* family */
++  PROTOPT_NONE                        /* flags */
++};
++
++static CURLcode verynormalprotocol_do(struct Curl_easy *data, bool *done)
++{
++  *done = FALSE; /* unconditionally */
++
++  return CURLE_OK;
++}
++
++static CURLcode verynormalprotocol_doing(struct Curl_easy *data, bool *done)
++{
++  CURLcode result = CURLE_WEIRD_SERVER_REPLY;
++  ssize_t nread;
++  char response[128];
++
++  *done = FALSE;
++
++  /* Read the response from the server. If we see the correct "heartbeat",
++     we should complete the transaction and return CURLE_OK. */
++  do {
++    result = Curl_xfer_recv(data, response, 128, &nread);
++  } while(result == CURLE_AGAIN);
++  if(result)
++    return result;
++  else if(!nread) {
++    failf(data, "Connection disconnected");
++    *done = TRUE;
++    result = CURLE_RECV_ERROR;
++  }
++  else if(strcasecmp(response, "crashycrashy") == 0) {
++    *done = TRUE;
++    *(unsigned int *)result = CURLE_OK;
++  }
++  else {
++    *done = TRUE;
++    result = CURLE_WEIRD_SERVER_REPLY;
++  }
++
++  if(result == CURLE_AGAIN)
++    result = CURLE_OK;
++  return result;
++}
++
+diff --git a/lib/verynormalprotocol.h b/lib/verynormalprotocol.h
+new file mode 100644
+index 000000000..cc48592bc
+--- /dev/null
++++ b/lib/verynormalprotocol.h
+@@ -0,0 +1,39 @@
++
++#ifndef HEADER_CURL_VERYNORMALPROTOCOL_H
++#define HEADER_CURL_VERYNORMALPROTOCOL_H
++/***************************************************************************
++ *                                  _   _ ____  _
++ *  Project                     ___| | | |  _ \| |
++ *                             / __| | | | |_) | |
++ *                            | (__| |_| |  _ <| |___
++ *                             \___|\___/|_| \_\_____|
++ *
++ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
++ *
++ * This software is licensed as described in the file COPYING, which
++ * you should have received as part of this distribution. The terms
++ * are also available at https://curl.se/docs/copyright.html.
++ *
++ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
++ * copies of the Software, and permit persons to whom the Software is
++ * furnished to do so, under the terms of the COPYING file.
++ *
++ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
++ * KIND, either express or implied.
++ *
++ * SPDX-License-Identifier: curl
++ *
++ ***************************************************************************/
++
++#ifndef CURL_DISABLE_VERYNORMALPROTOCOL
++extern const struct Curl_handler Curl_handler_verynormalprotocol;
++enum verynormalprotocolstate {
++    VERYNORMALPROTOCOL_START,
++    VERYNORMALPROTOCOL_DO
++};
++struct verynormalprotocol_conn {
++    enum verynormalprotocolstate state;
++};
++#endif
++
++#endif /* HEADER_CURL_VERYNORMALPROTOCOL_H */
+diff --git a/src/tool_help.c b/src/tool_help.c
+index 57b14a3b0..e803b7eda 100644
+--- a/src/tool_help.c
++++ b/src/tool_help.c
+@@ -360,6 +360,7 @@ void tool_version_info(void)
+       }
+ #endif /* !CURL_DISABLE_IPFS */
+     }
++    puts(" verynormalprotocol");
+     puts(""); /* newline */
+   }
+   if(feature_names[0]) {
+diff --git a/src/tool_libinfo.c b/src/tool_libinfo.c
+index f6053e840..46568eb9f 100644
+--- a/src/tool_libinfo.c
++++ b/src/tool_libinfo.c
+@@ -41,6 +41,7 @@ const char * const *built_in_protos = &no_protos;
+ size_t proto_count = 0;
+ 
+ const char *proto_file = NULL;
++const char *proto_verynormal = NULL;
+ const char *proto_ftp = NULL;
+ const char *proto_ftps = NULL;
+ const char *proto_http = NULL;
+@@ -59,6 +60,7 @@ static struct proto_name_tokenp {
+   const char  **proto_tokenp;
+ } const possibly_built_in[] = {
+   { "file",     &proto_file  },
++  { "verynormalprotocol",     &proto_verynormal  },
+   { "ftp",      &proto_ftp   },
+   { "ftps",     &proto_ftps  },
+   { "http",     &proto_http  },
+diff --git a/tests/data/Makefile.am b/tests/data/Makefile.am
+index 776b5934b..42d564a07 100644
+--- a/tests/data/Makefile.am
++++ b/tests/data/Makefile.am
+@@ -135,7 +135,7 @@ test979 test980 test981 test982 test983 test984 test985 test986 test987 \
+ test988 test989 test990 test991 test992 test993 test994 test995 test996 \
+ test997 test998 test999 test1000 test1001 test1002 test1003 test1004    \
+ test1005 test1006 test1007 test1008 test1009 test1010 test1011 test1012 \
+-test1013 test1014 test1015 test1016 test1017 test1018 test1019 test1020 \
++test1014 test1015 test1016 test1017 test1018 test1019 test1020 \
+ test1021 test1022 test1023 test1024 test1025 test1026 test1027 test1028 \
+ test1029 test1030 test1031 test1032 test1033 test1034 test1035 test1036 \
+ test1037 test1038 test1039 test1040 test1041 test1042 test1043 test1044 \
+@@ -148,13 +148,13 @@ test1085 test1086 test1087 test1088 test1089 test1090 test1091 test1092 \
+ test1093 test1094 test1095 test1096 test1097 test1098 test1099 test1100 \
+ test1101 test1102 test1103 test1104 test1105 test1106 test1107 test1108 \
+ test1109 test1110 test1111 test1112 test1113 test1114 test1115 test1116 \
+-test1117 test1118 test1119 test1120 test1121 test1122 test1123 test1124 \
++test1117 test1118 test1120 test1121 test1122 test1123 test1124 \
+ test1125 test1126 test1127 test1128 test1129 test1130 test1131 test1132 \
+ test1133 test1134 test1135 test1136 test1137 test1138 test1139 test1140 \
+ test1141 test1142 test1143 test1144 test1145 test1146 test1147 test1148 \
+ test1149 test1150 test1151 test1152 test1153 test1154 test1155 test1156 \
+ test1157 test1158 test1159 test1160 test1161 test1162 test1163 test1164 \
+-test1165 test1166 test1167 test1168 test1169 test1170 test1171 test1172 \
++test1166 test1167 test1168 test1169 test1170 test1171 test1172 \
+ test1173 test1174 test1175 test1176 test1177 test1178 test1179 test1180 \
+ test1181 test1182 test1183 test1184 test1185 test1186 test1187 test1188 \
+ test1189 test1190 test1190 test1191 test1192 test1193 test1194 test1195 \
+@@ -268,7 +268,7 @@ test3008 test3009 test3010 test3011 test3012 test3013 test3014 test3015 \
+ test3016 test3017 test3018 test3019 test3020 test3021 test3022 test3023 \
+ test3024 test3025 test3026 test3027 test3028 test3029 test3030 test3031 \
+ \
+-test3100 test3101 test3102 test3103 \
++test3100 test3101 test3102 test3103 test11442 \
+ test3200 \
+ test3201 test3202 test3203 test3204 test3205 test3207
+ 
+diff --git a/tests/data/test1013 b/tests/data/test1013
+deleted file mode 100644
+index 87e99cd56..000000000
+--- a/tests/data/test1013
++++ /dev/null
+@@ -1,37 +0,0 @@
+-<testcase>
+-<info>
+-<keywords>
+-curl-config
+-</keywords>
+-</info>
+-
+-#
+-# Server-side
+-<reply>
+-</reply>
+-
+-#
+-# Client-side
+-<client>
+-<server>
+-none
+-</server>
+-<name>
+-Compare curl --version with curl-config --protocols
+-</name>
+-<command>
+---version
+-</command>
+-</client>
+-
+-#
+-# Verify data after the test has been "shot"
+-<verify>
+-<postcheck>
+-%SRCDIR/libtest/test%TESTNUMBER.pl ../curl-config %LOGDIR/stdout%TESTNUMBER protocols
+-</postcheck>
+-<errorcode>
+-0
+-</errorcode>
+-</verify>
+-</testcase>
+diff --git a/tests/data/test1119 b/tests/data/test1119
+deleted file mode 100644
+index 1a73439e6..000000000
+--- a/tests/data/test1119
++++ /dev/null
+@@ -1,30 +0,0 @@
+-<testcase>
+-<info>
+-<keywords>
+-source analysis
+-symbols-in-versions
+-</keywords>
+-</info>
+-
+-#
+-# Client-side
+-<client>
+-<server>
+-none
+-</server>
+-
+-<name>
+-Verify that symbols-in-versions and headers are in sync
+-</name>
+-
+-<command type="perl">
+-%SRCDIR/test1119.pl %SRCDIR/.. ../include/curl
+-</command>
+-</client>
+-
+-<verify>
+-<stdout>
+-OK
+-</stdout>
+-</verify>
+-</testcase>
+diff --git a/tests/data/test11442 b/tests/data/test11442
+new file mode 100644
+index 000000000..d9b8ad0dc
+--- /dev/null
++++ b/tests/data/test11442
+@@ -0,0 +1,32 @@
++<testcase>
++<info>
++<keywords>
++verynormalprotocol
++</keywords>
++</info>
++# Server-side
++<reply>
++1
++</reply>
++
++# Client-side
++<client>
++<server>
++verynormalprotocol
++</server>
++
++<name>
++verynormalprotocol test 1
++</name>
++<command>
++verynormalprotocol://%HOSTIP:%VERYNORMALPROTOCOLPORT/asdf
++</command>
++</client>
++
++# Verify data
++<verify>
++<errorcode>
++8
++</errorcode>
++</verify>
++</testcase>
+diff --git a/tests/data/test1165 b/tests/data/test1165
+deleted file mode 100644
+index 89f02d719..000000000
+--- a/tests/data/test1165
++++ /dev/null
+@@ -1,25 +0,0 @@
+-<testcase>
+-<info>
+-<keywords>
+-source analysis
+-CURL_DISABLE
+-</keywords>
+-</info>
+-
+-#
+-# Client-side
+-<client>
+-<server>
+-none
+-</server>
+-
+-<name>
+-Verify configure.ac and source code CURL_DISABLE_-sync
+-</name>
+-
+-<command type="perl">
+-%SRCDIR/test1165.pl %SRCDIR/..
+-</command>
+-</client>
+-
+-</testcase>
+diff --git a/tests/serverhelp.pm b/tests/serverhelp.pm
+index 22cf30e52..dacdb0a03 100644
+--- a/tests/serverhelp.pm
++++ b/tests/serverhelp.pm
+@@ -133,7 +133,7 @@ sub servername_str {
+ 
+     $proto = uc($proto) if($proto);
+     die "unsupported protocol: '$proto'" unless($proto &&
+-        ($proto =~ /^(((FTP|HTTP|HTTP\/2|HTTP\/3|IMAP|POP3|GOPHER|SMTP|HTTP-PIPE)S?)|(TFTP|SFTP|SOCKS|SSH|RTSP|HTTPTLS|DICT|SMB|SMBS|TELNET|MQTT))$/));
++        ($proto =~ /^(((FTP|HTTP|HTTP\/2|HTTP\/3|IMAP|POP3|GOPHER|SMTP|HTTP-PIPE)S?)|(TFTP|SFTP|SOCKS|SSH|RTSP|HTTPTLS|DICT|SMB|SMBS|TELNET|MQTT|VERYNORMALPROTOCOL))$/));
+ 
+     $ipver = (not $ipver) ? 'ipv4' : lc($ipver);
+     die "unsupported IP version: '$ipver'" unless($ipver &&
+diff --git a/tests/servers.pm b/tests/servers.pm
+index 37519eeb6..c84efef69 100644
+--- a/tests/servers.pm
++++ b/tests/servers.pm
+@@ -236,7 +236,7 @@ sub init_serverpidfile_hash {
+     }
+   }
+   for my $proto (('tftp', 'sftp', 'socks', 'ssh', 'rtsp', 'httptls',
+-                  'dict', 'smb', 'smbs', 'telnet', 'mqtt')) {
++                  'dict', 'smb', 'smbs', 'telnet', 'mqtt', 'verynormalprotocol')) {
+     for my $ipvnum ((4, 6)) {
+       for my $idnum ((1, 2)) {
+         my $serv = servername_id($proto, $ipvnum, $idnum);
+@@ -2052,6 +2052,67 @@ sub runsocksserver {
+     return (0, $pid2, $sockspid, $port);
+ }
+ 
++#######################################################################
++# start the verynormalprotocol server
++#
++sub runverynormalprotocolserver {
++    my ($verb, $alt) = @_;
++    my $proto = "verynormalprotocol";
++    my $ip = $HOSTIP;
++    my $ipvnum = 4;
++    my $idnum = 1;
++
++    if($alt eq "ipv6") {
++        # No IPv6
++    }
++
++    my $server = servername_id($proto, $ipvnum, $idnum);
++
++    my $pidfile = $serverpidfile{$server};
++
++    # don't retry if the server doesn't work
++    if ($doesntrun{$pidfile}) {
++        return (2, 0, 0, 0);
++    }
++
++    my $pid = processexists($pidfile);
++    if($pid > 0) {
++        stopserver($server, "$pid");
++    }
++    unlink($pidfile) if(-f $pidfile);
++
++    my $srvrname = servername_str($proto, $ipvnum, $idnum);
++    my $logfile = server_logfilename($LOGDIR, $proto, $ipvnum, $idnum);
++
++    my $flags = "";
++    $flags .= "--verbose 1 " if($debugprotocol);
++    $flags .= "--pidfile \"$pidfile\" --logfile \"$logfile\" ";
++    $flags .= "--id $idnum " if($idnum > 1);
++    $flags .= "--srcdir \"$srcdir\" ";
++    $flags .= "--host $HOSTIP";
++
++    my $port = getfreeport($ipvnum);
++    my $aflags = "--port $port $flags";
++    my $cmd = "$srcdir/verynormalprotocolserver.py $aflags";
++    my ($dictpid, $pid2) = startnew($cmd, $pidfile, 15, 0);
++
++    if($dictpid <= 0 || !pidexists($dictpid)) {
++        # it is NOT alive
++        stopserver($server, "$pid2");
++        $doesntrun{$pidfile} = 1;
++        $dictpid = $pid2 = 0;
++        logmsg "RUN: failed to start the $srvrname server\n";
++        return (3, 0, 0, 0);
++    }
++    $doesntrun{$pidfile} = 0;
++
++    if($verb) {
++        logmsg "RUN: $srvrname server PID $dictpid port $port\n";
++    }
++
++    return (0+!$dictpid, $dictpid, $pid2, $port);
++}
++
+ #######################################################################
+ # start the dict server
+ #
+@@ -2946,6 +3007,17 @@ sub startservers {
+                 $run{'http-unix'}="$pid $pid2";
+             }
+         }
++        elsif($what eq "verynormalprotocol") {
++            if(!$run{'verynormalprotocol'}) {
++                ($serr, $pid, $pid2, $PORT{"verynormalprotocol"}) = runverynormalprotocolserver($verbose, "");
++                if($pid <= 0) {
++                    return ("failed starting verynormalprotocol server", $serr);
++                }
++                logmsg sprintf ("* pid VERYNORMAL => %d %d\n", $pid, $pid2)
++                    if($verbose);
++                $run{'verynormalprotocol'}="$pid $pid2";
++            }
++        }
+         elsif($what eq "dict") {
+             if(!$run{'dict'}) {
+                 ($serr, $pid, $pid2, $PORT{"dict"}) = rundictserver($verbose, "");
+@@ -3079,7 +3151,7 @@ sub subvariables {
+                        'SOCKS',
+                        'SSH',
+                        'TELNET',
+-                       'TFTP', 'TFTP6') {
++                       'TFTP', 'TFTP6', 'VERYNORMALPROTOCOL') {
+         $port = protoport(lc $proto);
+         $$thing =~ s/${prefix}(?:$proto)PORT/$port/g;
+     }
+diff --git a/tests/verynormalprotocolserver.py b/tests/verynormalprotocolserver.py
+new file mode 100755
+index 000000000..82302cc48
+--- /dev/null
++++ b/tests/verynormalprotocolserver.py
+@@ -0,0 +1,168 @@
++#!/usr/bin/env python3
++# -*- coding: utf-8 -*-
++#***************************************************************************
++#                                  _   _ ____  _
++#  Project                     ___| | | |  _ \| |
++#                             / __| | | | |_) | |
++#                            | (__| |_| |  _ <| |___
++#                             \___|\___/|_| \_\_____|
++#
++# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
++#
++# This software is licensed as described in the file COPYING, which
++# you should have received as part of this distribution. The terms
++# are also available at https://curl.se/docs/copyright.html.
++#
++# You may opt to use, copy, modify, merge, publish, distribute and/or sell
++# copies of the Software, and permit persons to whom the Software is
++# furnished to do so, under the terms of the COPYING file.
++#
++# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
++# KIND, either express or implied.
++#
++# SPDX-License-Identifier: curl
++#
++###########################################################################
++#
++"""verynormalprotocol server."""
++
++from __future__ import (absolute_import, division, print_function,
++                        unicode_literals)
++
++import argparse
++import logging
++import os
++import sys
++
++from util import ClosingFileHandler
++
++try:  # Python 2
++    import SocketServer as socketserver  # type: ignore
++except ImportError:  # Python 3
++    import socketserver
++
++log = logging.getLogger(__name__)
++HOST = "localhost"
++
++# The strings that indicate the test framework is checking our aliveness
++VERIFIED_REQ = b"verifiedserver"
++VERIFIED_RSP = "WE ROOLZ: {pid}"
++
++
++def verynormalprotocolserver(options):
++    """Start up a TCP server with a verynormalprotocol handler and serve very normal requests forever."""
++    if options.pidfile:
++        pid = os.getpid()
++        # see tests/server/util.c function write_pidfile
++        if os.name == "nt":
++            pid += 65536
++        with open(options.pidfile, "w") as f:
++            f.write(str(pid))
++
++    local_bind = (options.host, options.port)
++    log.info("[verynormalprotocol] Listening on %s", local_bind)
++
++    # Need to set the allow_reuse on the class, not on the instance.
++    socketserver.TCPServer.allow_reuse_address = True
++    server = socketserver.TCPServer(local_bind, verynormalprotocolHandler)
++    server.serve_forever()
++
++    return ScriptRC.SUCCESS
++
++
++class verynormalprotocolHandler(socketserver.BaseRequestHandler):
++    """Handler class for verynormalprotocol connections."""
++
++    def handle(self):
++        try:
++            print('got connection')
++            # First, send a response to allow the server to continue.
++            rsp = "220 verynormalprotocolserver <xnooptions> <msgid@msgid>\n"
++            self.request.sendall(rsp.encode("utf-8"))
++            # Receive the request.
++            data = self.request.recv(1024).strip()
++            log.debug("[DICT] Incoming data: %r", data)
++
++        except IOError:
++            log.exception("[verynormalprotocol] IOError hit during request")
++
++
++def get_options():
++    parser = argparse.ArgumentParser()
++
++    parser.add_argument("--port", action="store", default=9016,
++                        type=int, help="port to listen on")
++    parser.add_argument("--host", action="store", default=HOST,
++                        help="host to listen on")
++    parser.add_argument("--verbose", action="store", type=int, default=0,
++                        help="verbose output")
++    parser.add_argument("--pidfile", action="store",
++                        help="file name for the PID")
++    parser.add_argument("--logfile", action="store",
++                        help="file name for the log")
++    parser.add_argument("--srcdir", action="store", help="test directory")
++    parser.add_argument("--id", action="store", help="server ID")
++    parser.add_argument("--ipv4", action="store_true", default=0,
++                        help="IPv4 flag")
++
++    return parser.parse_args()
++
++
++def setup_logging(options):
++    """Set up logging from the command line options."""
++    root_logger = logging.getLogger()
++    add_stdout = False
++
++    formatter = logging.Formatter("%(asctime)s %(levelname)-5.5s %(message)s")
++
++    # Write out to a logfile
++    if options.logfile:
++        handler = ClosingFileHandler(options.logfile)
++        handler.setFormatter(formatter)
++        handler.setLevel(logging.DEBUG)
++        root_logger.addHandler(handler)
++    else:
++        # The logfile wasn't specified. Add a stdout logger.
++        add_stdout = True
++
++    if options.verbose:
++        # Add a stdout logger as well in verbose mode
++        root_logger.setLevel(logging.DEBUG)
++        add_stdout = True
++    else:
++        root_logger.setLevel(logging.INFO)
++
++    if add_stdout:
++        stdout_handler = logging.StreamHandler(sys.stdout)
++        stdout_handler.setFormatter(formatter)
++        stdout_handler.setLevel(logging.DEBUG)
++        root_logger.addHandler(stdout_handler)
++
++
++class ScriptRC(object):
++    """Enum for script return codes."""
++
++    SUCCESS = 0
++    FAILURE = 1
++    EXCEPTION = 2
++
++
++if __name__ == '__main__':
++    # Get the options from the user.
++    options = get_options()
++
++    # Setup logging using the user options
++    setup_logging(options)
++
++    # Run main script.
++    try:
++        rc = verynormalprotocolserver(options)
++    except Exception:
++        log.exception('Error running server')
++        rc = ScriptRC.EXCEPTION
++
++    if options.pidfile and os.path.isfile(options.pidfile):
++        os.unlink(options.pidfile)
++
++    log.info("[verynormalprotocol] Returning %d", rc)
++    sys.exit(rc)

local-test-curl-delta-01/fuzz-tooling/CITATION.cff

@@ -0,0 +1,46 @@
+cff-version: 1.2.0
+title: OSS-Fuzz
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+type: software
+authors:
+  - given-names: Abhishek
+    family-names: Arya
+    affiliation: Google LLC
+    email: aarya@google.com
+    orcid: 'https://orcid.org/0009-0009-4558-4314'
+  - given-names: Oliver
+    family-names: Chang
+    email: ochang@google.com
+    affiliation: Google LLC
+    orcid: 'https://orcid.org/0009-0006-3181-4551'
+  - given-names: Jonathan
+    family-names: Metzman
+    email: metzman@google.com
+    affiliation: Google LLC
+    orcid: 'https://orcid.org/0000-0002-7042-0444'
+  - given-names: Kostya
+    family-names: Serebryany
+    email: kcc@google.com
+    affiliation: Google LLC
+    orcid: 'https://orcid.org/0009-0009-2379-3641'
+  - given-names: Dongge
+    family-names: Liu
+    email: donggeliu@google.com
+    affiliation: Google LLC
+    orcid: 'https://orcid.org/0000-0003-4821-7033'
+repository-code: 'https://github.com/google/oss-fuzz'
+abstract: >-
+  OSS-Fuzz is an open-source project by Google that provides
+  continuous fuzzing for open-source software. It aims to
+  make common open-source software more secure and stable by
+  combining modern fuzzing techniques with scalable,
+  distributed execution. As of August 2023, OSS-Fuzz has
+  helped identify and fix over 10,000 vulnerabilities and
+  36,000 bugs across 1,000 projects.
+keywords:
+  - open-source
+  - fuzzing
+license: Apache-2.0
+

local-test-curl-delta-01/fuzz-tooling/CONTRIBUTING.md

@@ -0,0 +1,26 @@
+Want to contribute? Great! First, read this page (including the small print at
+the end).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement](https://cla.developers.google.com/about/google-individual)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase, so we need your permission to use and distribute your code. We also
+need to be sure of various other things: for instance that you'll tell us if you
+know that your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+Before you start working on a larger contribution, you should get in touch with
+us first through the issue tracker with your idea so that we can help out and
+possibly guide you. Coordinating up front makes it much easier to avoid
+frustration later on.
+
+### Code reviews
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose.
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the
+[Software Grant and Corporate Contributor License Agreement](https://cla.developers.google.com/about/google-corporate).

local-test-curl-delta-01/fuzz-tooling/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

local-test-curl-delta-01/fuzz-tooling/README.md

@@ -0,0 +1,135 @@
+# OSS-Fuzz-AIxCC: AIxCC AFC Competition fork of OSS-Fuzz (v1.2.0)
+
+Changes in v1.2.0:
+
+- `base-builder-jvm` has been updated to use the lastest aixcc-jazzer ref, adjusting the OsCmdInjection sanitizer.
+    - This adjustment adds some safety measures around OsCmdInjection to reduce risk and reduce potential 
+      unintentional crash-state explosion when dealing with such vulnerabilities.
+- `helper.py` commands `build_image`, `build_fuzzers`, and `shell` have added optional flags to control docker image tags.
+    - Adds the flag `--docker_image_tag TAG` to the commands. This is entirely optional and backwards 
+      compatible, but can allow control over the project-image docker tag, enabling easier parallel processing.
+- `helper.py reproduce` has an added optional flag to reproduce with docker running in non-privileged mode.
+- `helper.py reproduce` has an added optional flag to timeout when the reproduce subprocess hangs.
+    - This enables crash detection to handle cases where sanitizers are hit, yet for various reasons the 
+      reproduce subprocess does not resolve and hangs indefinitely. If `timeout` is set, when the reproduce 
+      subprocess does not resolve within `timeout` seconds, reproduce will end the subprocess and return with code 124.
+
+Changes in v1.1.0:
+
+- The state of oss-fuzz-aixcc has been synced with upstream changes at 162f2ab818f5992b66486a4d06cb0e3c88c37773.
+- `helper.py build_fuzzers` with local source now matches behavior of non-local source, keeping the build state clean between runs.
+- `base-image` has been updated to default its locale to C.UTF-8 instead of POSIX.
+
+This is a competition fork of oss-fuzz which is guaranteed to be
+compatible with the AFC challenges. This fork is designed to remain
+fully backwards compatible with the public/upstream oss-fuzz, and
+thus competition challenges will reflect realistic real-world repositories.
+
+***Other than base-image changes, the projects files have not been touched
+in this repository. The list of projects in the projects directory does
+not reflect which projects will be used in any AFC round.***
+
+Competitors are recommended to test their CRS against public repositories using this competition fork. 
+Competitors are recommended to view the [example-crs-architecture] repository's
+[example-challenge-evaluation] scripts to see details on how this fuzz tooling is used during competition.
+
+[example-crs-arhictecture]: https://github.com/aixcc-finals/example-crs-architecture
+[example-challenge-evaluation]: https://github.com/aixcc-finals/example-crs-architecture/tree/main/example-challenge-evaluation
+
+Example basic usage of the helper script is below. **Note: When working with local source, you  must pass the local 
+source repository into the scripts as detailed below.**
+
+```bash
+# Build the project image and pull AFC base images
+infra/helper.py build_image --pull <project_name>
+
+# Build the fuzzer harnesses for the project, using local source
+infra/helper.py build_fuzzers --clean --sanitizer <sanitizer> --engine <engine> <project_name> <path-to-local-src>
+
+# Check all fuzzer harnesses for build
+infra/helper.py check_build --sanitizer <sanitizer> --engine <engine> <project_name>
+
+# Reproduce the testcase
+# optionally use --propagate_exit_codes
+infra/helper.py reproduce <project_name> <harness_name> <path-to-data-blob>
+```
+
+---
+
+# OSS-Fuzz: Continuous Fuzzing for Open Source Software
+
+[Fuzz testing] is a well-known technique for uncovering programming errors in
+software. Many of these detectable errors, like [buffer overflow], can have
+serious security implications. Google has found [thousands] of security
+vulnerabilities and stability bugs by deploying [guided in-process fuzzing of
+Chrome components], and we now want to share that service with the open source
+community.
+
+[Fuzz testing]: https://en.wikipedia.org/wiki/Fuzz_testing
+[buffer overflow]: https://en.wikipedia.org/wiki/Buffer_overflow
+[thousands]: https://issues.chromium.org/issues?q=label:Stability-LibFuzzer%20-status:Duplicate,WontFix
+[guided in-process fuzzing of Chrome components]: https://security.googleblog.com/2016/08/guided-in-process-fuzzing-of-chrome.html
+
+In cooperation with the [Core Infrastructure Initiative] and the [OpenSSF],
+OSS-Fuzz aims to make common open source software more secure and stable by
+combining modern fuzzing techniques with scalable, distributed execution.
+Projects that do not qualify for OSS-Fuzz (e.g. closed source) can run their own
+instances of [ClusterFuzz] or [ClusterFuzzLite].
+
+[Core Infrastructure Initiative]: https://www.coreinfrastructure.org/
+[OpenSSF]: https://www.openssf.org/
+
+We support the [libFuzzer], [AFL++], and [Honggfuzz] fuzzing engines in
+combination with [Sanitizers], as well as [ClusterFuzz], a distributed fuzzer
+execution environment and reporting tool.
+
+[libFuzzer]: https://llvm.org/docs/LibFuzzer.html
+[AFL++]: https://github.com/AFLplusplus/AFLplusplus
+[Honggfuzz]: https://github.com/google/honggfuzz
+[Sanitizers]: https://github.com/google/sanitizers
+[ClusterFuzz]: https://github.com/google/clusterfuzz
+[ClusterFuzzLite]: https://google.github.io/clusterfuzzlite/
+
+Currently, OSS-Fuzz supports C/C++, Rust, Go, Python, Java/JVM, and JavaScript code. Other languages
+supported by [LLVM] may work too. OSS-Fuzz supports fuzzing x86_64 and i386
+builds.
+
+[LLVM]: https://llvm.org
+
+## Overview
+![OSS-Fuzz process diagram](docs/images/process.png)
+
+## Documentation
+Read our [detailed documentation] to learn how to use OSS-Fuzz.
+
+[detailed documentation]: https://google.github.io/oss-fuzz
+
+## Trophies
+As of August 2023, OSS-Fuzz has helped identify and fix over [10,000] vulnerabilities and [36,000] bugs across [1,000] projects.
+
+[10,000]: https://bugs.chromium.org/p/oss-fuzz/issues/list?q=Type%3DBug-Security%20label%3Aclusterfuzz%20-status%3ADuplicate%2CWontFix&can=1
+[36,000]: https://bugs.chromium.org/p/oss-fuzz/issues/list?q=Type%3DBug%20label%3Aclusterfuzz%20-status%3ADuplicate%2CWontFix&can=1
+[1,000]: https://github.com/google/oss-fuzz/tree/master/projects
+
+## Blog posts
+* 2023-08-16 - [AI-Powered Fuzzing: Breaking the Bug Hunting Barrier]
+* 2023-02-01 - [Taking the next step: OSS-Fuzz in 2023]
+* 2022-09-08 - [Fuzzing beyond memory corruption: Finding broader classes of vulnerabilities automatically]
+* 2021-12-16 - [Improving OSS-Fuzz and Jazzer to catch Log4Shell]
+* 2021-03-10 - [Fuzzing Java in OSS-Fuzz]
+* 2020-12-07 - [Improving open source security during the Google summer internship program]
+* 2020-10-09 - [Fuzzing internships for Open Source Software]
+* 2018-11-06 - [A New Chapter for OSS-Fuzz]
+* 2017-05-08 - [OSS-Fuzz: Five months later, and rewarding projects]
+* 2016-12-01 - [Announcing OSS-Fuzz: Continuous fuzzing for open source software]
+
+[AI-Powered Fuzzing: Breaking the Bug Hunting Barrier]: https://security.googleblog.com/2023/08/ai-powered-fuzzing-breaking-bug-hunting.html
+[Announcing OSS-Fuzz: Continuous fuzzing for open source software]: https://opensource.googleblog.com/2016/12/announcing-oss-fuzz-continuous-fuzzing.html
+[OSS-Fuzz: Five months later, and rewarding projects]: https://opensource.googleblog.com/2017/05/oss-fuzz-five-months-later-and.html
+[A New Chapter for OSS-Fuzz]: https://security.googleblog.com/2018/11/a-new-chapter-for-oss-fuzz.html
+[Fuzzing internships for Open Source Software]: https://security.googleblog.com/2020/10/fuzzing-internships-for-open-source.html
+[Improving open source security during the Google summer internship program]: https://security.googleblog.com/2020/12/improving-open-source-security-during.html
+[Fuzzing Java in OSS-Fuzz]: https://security.googleblog.com/2021/03/fuzzing-java-in-oss-fuzz.html
+[Improving OSS-Fuzz and Jazzer to catch Log4Shell]: https://security.googleblog.com/2021/12/improving-oss-fuzz-and-jazzer-to-catch.html
+[Fuzzing beyond memory corruption: Finding broader classes of vulnerabilities automatically]: https://security.googleblog.com/2022/09/fuzzing-beyond-memory-corruption.html
+[Taking the next step: OSS-Fuzz in 2023]: https://security.googleblog.com/2023/02/taking-next-step-oss-fuzz-in-2023.html

local-test-curl-delta-01/fuzz-tooling/docs/.gitignore

@@ -0,0 +1,5 @@
+_site
+.bundle
+.sass-cache
+.jekyll-metadata
+vendor

local-test-curl-delta-01/fuzz-tooling/docs/404.html

@@ -0,0 +1,23 @@
+---
+layout: default
+---
+
+<style type="text/css" media="screen">
+  .container {
+    margin: 10px auto;
+    max-width: 600px;
+    text-align: center;
+  }
+  h1 {
+    margin: 30px 0;
+    font-size: 4em;
+    line-height: 1;
+    letter-spacing: -1px;
+  }
+</style>
+
+<div class="container">
+  <h1>404</h1>
+
+  <p><strong>Page not found :(</strong></p>
+</div>

local-test-curl-delta-01/fuzz-tooling/docs/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+gem 'github-pages', group: :jekyll_plugins
+
+gem "webrick", "~> 1.8"

local-test-curl-delta-01/fuzz-tooling/docs/README.md

@@ -0,0 +1,19 @@
+# Readme
+
+Use the following instructions to make documentation changes locally.
+
+## Prerequisites
+```bash
+$ sudo apt install ruby bundler
+$ bundle config set path 'vendor/bundle'
+$ bundle install
+```
+
+## Serving locally
+```bash
+$ bundle exec jekyll serve
+```
+
+## Theme documentation
+We are using the [just the docs](https://just-the-docs.github.io/just-the-docs/)
+theme.

local-test-curl-delta-01/fuzz-tooling/docs/_config.yml

@@ -0,0 +1,40 @@
+# Welcome to Jekyll!
+#
+# This config file is meant for settings that affect your whole blog, values
+# which you are expected to set up once and rarely edit after that. If you find
+# yourself editing this file very often, consider using Jekyll's data files
+# feature for the data you need to update frequently.
+#
+# For technical reasons, this file is *NOT* reloaded automatically when you use
+# 'bundle exec jekyll serve'. If you change this file, please restart the server process.
+
+# Site settings
+# These are used to personalize your new site. If you look in the HTML files,
+# you will see them accessed via {{ site.title }}, {{ site.email }}, and so on.
+# You can create any custom variable you would like, and they will be accessible
+# in the templates via {{ site.myvariable }}.
+title: OSS-Fuzz
+description: Documentation for OSS-Fuzz
+baseurl: "/oss-fuzz" # the subpath of your site, e.g. /blog
+url: "" # the base hostname & protocol for your site, e.g. http://example.com
+
+# Build settings
+markdown: kramdown
+remote_theme: pmarsceill/just-the-docs
+search_enabled: true
+
+ga_tracking: G-LRX1V3S5P
+
+aux_links:
+  "OSS-Fuzz on GitHub":
+    - https://github.com/google/oss-fuzz
+
+# Exclude from processing.
+exclude:
+  - Gemfile
+  - Gemfile.lock
+  - node_modules
+  - vendor/bundle/
+  - vendor/cache/
+  - vendor/gems/
+  - vendor/ruby/

local-test-curl-delta-01/fuzz-tooling/docs/faq.md

@@ -0,0 +1,237 @@
+---
+layout: default
+title: FAQ
+nav_order: 7
+permalink: /faq/
+---
+
+# Frequently Asked Questions
+
+- TOC
+{:toc}
+---
+
+## Where can I learn more about fuzzing?
+
+We recommend reading [libFuzzer tutorial] and the other docs in [google/fuzzing]
+repository. These and some other resources are listed on the
+[useful links]({{ site.baseurl }}/reference/useful-links/#tutorials) page.
+
+[google/fuzzing]: https://github.com/google/fuzzing/tree/master/docs
+[libFuzzer tutorial]: https://github.com/google/fuzzing/blob/master/tutorial/libFuzzerTutorial.md
+
+## What kind of projects are you accepting?
+
+We accept established projects that have a critical impact on infrastructure and
+user security. We will consider each request on a case-by-case basis, but some
+things we keep in mind are:
+
+  - Exposure to remote attacks (e.g. libraries that are used to process
+    untrusted input).
+  - Number of users/other projects depending on this project.
+
+We hope to relax this requirement in the future though, so keep an eye out even
+if we are not able to accept your project at this time!
+
+## How can I find potential fuzz targets in my open source project?
+
+You should look for places in your code that:
+
+  - consume un-trusted data from users or from the network.
+  - consume complex input data even if it's 'trusted'.
+  - use an algorithm that has two or more implementations
+    (to verify their equivalence).
+  - look for existing fuzz target [examples](https://github.com/google/oss-fuzz/tree/master/projects)
+    and find similarities.
+
+## Where can I store fuzz target sources and the build script if it's not yet accepted upstream?
+
+Fuzz target sources as well as the build script may temporarily live inside the
+`projects/<your_project>` directory in the OSS-Fuzz repository. Note that we do
+not accept integrations that rely on forked repositories. Refer to the
+[ideal integration guide] for the preferred long term solution.
+
+## My project is not open source. Can I use OSS-Fuzz?
+
+You cannot use OSS-Fuzz, but you can use [ClusterFuzz] which OSS-Fuzz is based
+on. ClusterFuzz is an open-source fuzzing infrastructure that you can deploy in
+your own environment and run continuously at scale.
+
+OSS-Fuzz is a production instance of ClusterFuzz, plus the code living in
+[OSS-Fuzz repository]: build scripts, `project.yaml` files with contacts, etc.
+
+[OSS-Fuzz repository]: https://github.com/google/oss-fuzz
+
+## Why do you use a [different issue tracker](https://bugs.chromium.org/p/oss-fuzz/issues/list) for reporting bugs in OSS projects?
+
+Security access control is important for the kind of issues that OSS-Fuzz detects,
+hence why by default issues are only opened on the OSS-Fuzz tracker.
+You can opt-in to have them on Github as well by adding the `file_github_issue`
+attribute to your `project.yaml` file. Note that this is only for visibility's
+purpose, and that the actual details can be found by following the link to the
+OSS-Fuzz tracker.
+
+## Why do you require a Google account for authentication?
+
+Our [ClusterFuzz]({{ site.baseurl }}/further-reading/clusterfuzz) fuzzing
+infrastructure and [issue tracker](https://bugs.chromium.org/p/oss-fuzz/issues/list)
+require a Google account for authentication. Note that an alternate email
+address associated with a Google account does not work due to appengine api
+limitations.
+
+## Why do you use Docker?
+
+Building fuzzers requires building your project with a fresh Clang compiler and
+special compiler flags.  An easy-to-use Docker image is provided to simplify
+toolchain distribution. This also simplifies our support for a variety of Linux
+distributions and provides a reproducible environment for fuzzer
+building and execution.
+
+## How do you handle timeouts and OOMs?
+
+If a single input to a [fuzz target]({{ site.baseurl }}/reference/glossary/#fuzz-target)
+requires more than **~25 seconds** or more than **2.5GB RAM** to process, we
+report this as a timeout or an OOM (out-of-memory) bug
+(examples: [timeouts](https://bugs.chromium.org/p/oss-fuzz/issues/list?can=1&q=%22Crash+Type%3A+Timeout%22),
+[OOMs](https://bugs.chromium.org/p/oss-fuzz/issues/list?can=1&q="Crash+Type%3A+Out-of-memory")).
+This may or may not be considered as a real bug by the project owners,
+but nevertheless we treat all timeouts and OOMs as bugs
+since they significantly reduce the efficiency of fuzzing.
+
+Remember that fuzzing is executed with AddressSanitizer or other
+sanitizers which introduces a certain overhead in RAM and CPU.
+
+We currently do not have a good way to deduplicate timeout or OOM bugs.
+So, we report only one timeout and only one OOM bug per fuzz target.
+Once that bug is fixed, we will file another one, and so on.
+
+Currently we do not offer ways to change the memory and time limits.
+
+## Can I launch an additional process (e.g. a daemon) from my fuzz target?
+
+No. In order to get all the benefits of in-process, coverage-guided fuzz testing,
+it is required to run everything inside a single process. Any child processes
+created outside the main process introduces heavy launch overhead and is not
+monitored for code coverage.
+
+Another rule of thumb is: "the smaller fuzz target is, the better it is". It is
+expected that your project will have many fuzz targets to test different
+components, instead of a single fuzz target trying to cover everything.
+Think of fuzz target as a unit test, though it is much more powerful since it
+helps to test millions of data permutations rather than just one.
+
+## What if my fuzz target finds a bug in another project (dependency) ?
+
+Every bug report has a crash stack-trace that shows where the crash happened.
+Using that, you can debug the root cause and see which category the bug falls in:
+
+- If this is a bug is due to an incorrect usage of the dependent project's API
+in your project, then you need to fix your usage to call the API correctly.
+- If this is a real bug in the dependent project, then you should CC the
+maintainers of that project on the bug. Once CCed, they will get automatic
+access to all the information necessary to reproduce the issue. If this project
+is maintained in OSS-Fuzz, you can search for contacts in the respective
+project.yaml file.
+
+## What if my fuzzer does not find anything?
+
+If your fuzz target is running for many days and does not find bugs or new
+coverage, it may mean several things:
+- We've covered all reachable code. In order to cover more code we need more
+  fuzz targets.
+- The [seed corpus]({{ site.baseurl }}/getting-started/new-project-guide#seed-corpus) is not good enough and the
+  fuzzing engine(s) are not able to go deeper based on the existing seeds.
+  Need to add more seeds.
+- There is some crypto/crc stuff in the code that will prevent any fuzzing
+  engine from going deeper, in which case the crypto should be disabled in
+  [fuzzing mode](https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode).
+  Examples: [openssl](https://github.com/openssl/openssl/tree/master/fuzz#reproducing-issues),
+  [boringssl](https://boringssl.googlesource.com/boringssl/+/HEAD/FUZZING.md#Fuzzer-mode)
+- It is also possible that the fuzzer is running too slow
+  (you may check the speed of your targets at https://oss-fuzz.com/)
+
+In either case, look at the
+[coverage reports]({{ site.baseurl }}/further-reading/clusterfuzz#coverage-reports)
+for your target(s) and figure out why some parts of the code are not covered.
+
+## What if my fuzzer does not find new coverage or bugs after a while?
+
+It is common for fuzzers to plateau and stop finding new coverage or bugs.
+[Fuzz Introspector](https://github.com/ossf/fuzz-introspector) helps you
+evaluate your fuzzers' performance.
+It can help you identify bottlenecks causing your fuzzers to plateau.
+It provides aggregated and individual fuzzer reachability and coverage reports.
+Developers can either introduce a new fuzz target or modify an existing one to
+reach previously unreachable code.
+Here are
+[case studies](https://github.com/ossf/fuzz-introspector/blob/main/doc/CaseStudies.md)
+where Fuzz Introspector helped developers improve fuzzing of a project.
+Fuzz Introspector reports are available on the [OSS-Fuzz homepage](https://oss-fuzz.com/)
+or through this [index](http://oss-fuzz-introspector.storage.googleapis.com/index.html).
+
+Developers can also use Fuzz Introspector on their local machines.
+Detailed instructions are available
+[here](https://github.com/ossf/fuzz-introspector/tree/main/oss_fuzz_integration#build-fuzz-introspector-with-oss-fuzz).
+
+## Why are code coverage reports public?
+
+We work with open source projects and try to keep as much information public as
+possible. We believe that public code coverage reports do not put users at risk,
+as they do not indicate the presence of bugs or lack thereof.
+
+## Why is the coverage command complaining about format compatibility issues?
+
+This may happen if the Docker images fetched locally become out of sync. Make
+sure you run the following command to pull the most recent images:
+
+```bash
+$ python infra/helper.py pull_images
+```
+
+Please refer to
+[code coverage]({{ site.baseurl }}/advanced-topics/code-coverage/) for detailed
+information on code coverage generation.
+
+## What happens when I rename a fuzz target ?
+
+If you rename your fuzz targets, the existing bugs for those targets will get
+closed and fuzzing will start from scratch from a fresh corpora
+(seed corpus only). Similar corpora will get accumulated over time depending on
+the number of cpu cycles that original fuzz target has run. If this is not
+desirable, make sure to copy the accumulated corpora from the original fuzz
+target (instructions to download
+[here]({{ site.baseurl }}/advanced-topics/corpora/#downloading-the-corpus)) and
+restore it to the new GCS location later (instruction to find the
+new location [here]({{ site.baseurl }}/advanced-topics/corpora/#viewing-the-corpus-for-a-fuzz-target)).
+
+## Does OSS-Fuzz support AFL or honggfuzz or Centipede?
+
+OSS-Fuzz *uses* the following
+[fuzzing engines]({{ site.baseurl }}/reference/glossary/#fuzzing-engine):
+
+1. [libFuzzer](https://llvm.org/docs/LibFuzzer.html).
+1. [AFL++](https://github.com/AFLplusplus/AFLplusplus), an improved and
+   well-maintained version of [AFL](https://lcamtuf.coredump.cx/afl/).
+1. [Honggfuzz](https://github.com/google/honggfuzz).
+1. [Centipede (Experimental)](https://github.com/google/centipede).
+
+Follow the [new project guide] and OSS-Fuzz will use all its fuzzing engines
+on your code.
+
+## What are the specs on your machines?
+
+OSS-Fuzz builders have 32CPU/28.8GB RAM.
+
+Fuzzing machines only have a single core and fuzz targets should not use more
+than 2.5GB of RAM.
+
+## Are there any restrictions on using test cases / corpora generated by OSS-Fuzz?
+
+No, you can freely use (i.e. share, add to your repo, etc.) the test cases and
+corpora generated by OSS-Fuzz. OSS-Fuzz infrastructure is fully open source
+(including [ClusterFuzz], various fuzzing engines, and other dependencies). We
+have no intent to restrict the use of the artifacts produced by OSS-Fuzz.
+
+[ClusterFuzz]: https://github.com/google/clusterfuzz
+[new project guide]: {{ site.baseurl }}/getting-started/new-project-guide/
+[ideal integration guide]: {{ site.baseurl }}/getting-started/new-project-guide/

local-test-curl-delta-01/fuzz-tooling/docs/glossary.md

@@ -0,0 +1 @@
+This page has moved [here](https://google.github.io/oss-fuzz/reference/glossary/)

local-test-curl-delta-01/fuzz-tooling/docs/ideal_integration.md

@@ -0,0 +1 @@
+This page has moved [here](https://google.github.io/oss-fuzz/advanced-topics/ideal-integration)

local-test-curl-delta-01/fuzz-tooling/docs/index.md

@@ -0,0 +1,88 @@
+---
+layout: default
+title: OSS-Fuzz
+permalink: /
+nav_order: 1
+has_children: true
+has_toc: false
+---
+
+# OSS-Fuzz
+
+[Fuzz testing] is a well-known technique for uncovering programming errors in
+software. Many of these detectable errors, like [buffer overflow], can have
+serious security implications. Google has found [thousands] of security
+vulnerabilities and stability bugs by deploying [guided in-process fuzzing of
+Chrome components], and we now want to share that service with the open source
+community.
+
+[Fuzz testing]: https://en.wikipedia.org/wiki/Fuzz_testing
+[buffer overflow]: https://en.wikipedia.org/wiki/Buffer_overflow
+[thousands]: https://bugs.chromium.org/p/chromium/issues/list?q=label%3AStability-LibFuzzer%2CStability-AFL%20-status%3ADuplicate%2CWontFix&can=1
+[guided in-process fuzzing of Chrome components]: https://security.googleblog.com/2016/08/guided-in-process-fuzzing-of-chrome.html
+
+In cooperation with the [Core Infrastructure Initiative] and the [OpenSSF],
+OSS-Fuzz aims to make common open source software more secure and stable by
+combining modern fuzzing techniques with scalable, distributed execution.
+Projects that do not qualify for OSS-Fuzz (e.g. closed source) can run their own
+instances of [ClusterFuzz] or [ClusterFuzzLite].
+
+[Core Infrastructure Initiative]: https://www.coreinfrastructure.org/
+[OpenSSF]: https://www.openssf.org/
+
+We support the [libFuzzer], [AFL++], [Honggfuzz], and [Centipede] fuzzing engines in
+combination with [Sanitizers], as well as [ClusterFuzz], a distributed fuzzer
+execution environment and reporting tool.
+
+[libFuzzer]: https://llvm.org/docs/LibFuzzer.html
+[AFL++]: https://github.com/AFLplusplus/AFLplusplus
+[Honggfuzz]: https://github.com/google/honggfuzz
+[Centipede]: https://github.com/google/centipede
+[Sanitizers]: https://github.com/google/sanitizers
+[ClusterFuzz]: https://github.com/google/clusterfuzz
+[ClusterFuzzLite]: https://google.github.io/clusterfuzzlite/
+
+Currently, OSS-Fuzz supports C/C++, Rust, Go, Python and Java/JVM code. Other
+languages supported by [LLVM] may work too. OSS-Fuzz supports fuzzing x86_64
+and i386 builds.
+
+[LLVM]: https://llvm.org
+
+
+## Project history
+OSS-Fuzz was launched in 2016 in response to the
+[Heartbleed] vulnerability, discovered in [OpenSSL], one of the
+most popular open source projects for encrypting web traffic. The vulnerability
+had the potential to affect almost every internet user, yet was caused by a
+relatively simple memory buffer overflow bug that could have been detected by
+fuzzing—that is, by running the code on randomized inputs to intentionally cause
+unexpected behaviors or crashes. At the time, though, fuzzing
+was not widely used and was cumbersome for developers, requiring extensive
+manual effort.
+
+Google created OSS-Fuzz to fill this gap: it's a free service that runs fuzzers
+for open source projects and privately alerts developers to the bugs detected.
+Since its launch, OSS-Fuzz has become a critical service for the open source
+community, growing beyond C/C++ to
+detect problems in memory-safe languages such as Go, Rust, and Python.
+
+[Heartbleed]: https://heartbleed.com/ 
+[OpenSSL]: https://www.openssl.org/
+
+## Learn more about fuzzing
+
+This documentation describes how to use OSS-Fuzz service for your open source
+project. To learn more about fuzzing in general, we recommend reading [libFuzzer
+tutorial] and the other docs in [google/fuzzing] repository. These and some
+other resources are listed on the [useful links] page.
+
+[google/fuzzing]: https://github.com/google/fuzzing/tree/master/docs
+[libFuzzer tutorial]: https://github.com/google/fuzzing/blob/master/tutorial/libFuzzerTutorial.md
+[useful links]: {{ site.baseurl }}/reference/useful-links/#tutorials
+
+## Trophies
+As of August 2023, OSS-Fuzz has helped identify and fix over [10,000] vulnerabilities and [36,000] bugs across [1,000] projects.
+
+[10,000]: https://bugs.chromium.org/p/oss-fuzz/issues/list?q=Type%3DBug-Security%20label%3Aclusterfuzz%20-status%3ADuplicate%2CWontFix&can=1
+[36,000]: https://bugs.chromium.org/p/oss-fuzz/issues/list?q=Type%3DBug%20label%3Aclusterfuzz%20-status%3ADuplicate%2CWontFix&can=1
+[1,000]: https://github.com/google/oss-fuzz/tree/master/projects

local-test-curl-delta-01/fuzz-tooling/docs/new_project_guide.md

@@ -0,0 +1 @@
+This page has moved [here](https://google.github.io/oss-fuzz/getting-started/new-project-guide/)

local-test-curl-delta-01/fuzz-tooling/docs/reproducing.md

@@ -0,0 +1 @@
+This page has moved [here](https://google.github.io/oss-fuzz/advanced-topics/reproducing)

local-test-curl-delta-01/fuzz-tooling/infra/.dockerignore

@@ -0,0 +1,9 @@
+cifuzz/test_data/*
+
+# Copied from .gitignore.
+.vscode/
+*.pyc
+build
+*~
+.DS_Store
+*.swp

local-test-curl-delta-01/fuzz-tooling/infra/MAINTAINERS.csv

@@ -0,0 +1,7 @@
+Name,Email,Github Username
+Adam Korcz,adam@adalogics.com,AdamKorcz
+David Korczynski,david@adalogics.com,DavidKorczynski
+Dongge Liu,donggeliu@google.com,Alan32Liu
+Holly Gong,gongh@google.com,hogo6002
+Jonathan Metzman,metzman@google.com,jonathanmetzman
+Oliver Chang,ochang@google.com,oliverchang

local-test-curl-delta-01/fuzz-tooling/infra/README.md

@@ -0,0 +1,23 @@
+# infra
+> OSS-Fuzz project infrastructure
+
+Core infrastructure:
+* [`base-images`](base-images/) - docker images for building fuzz targets & corresponding jenkins
+  pipeline.
+
+Continuous Integration infrastructure:
+
+* [`ci`](ci/) - script to build projects in CI.
+
+## helper.py
+> script to automate common docker operations
+
+| Command | Description |
+|---------|-------------
+| `generate`      | Generates skeleton files for a new project |
+| `build_image`   | Builds a docker image for a given project |
+| `build_fuzzers` | Builds fuzz targets for a given project |
+| `run_fuzzer`    | Runs a fuzz target in a docker container |
+| `coverage`      | Runs fuzz target(s) in a docker container and generates a code coverage report. See [Code Coverage doc](https://google.github.io/oss-fuzz/advanced-topics/code-coverage/) |
+| `reproduce`     | Runs a testcase to reproduce a crash |
+| `shell`         | Starts a shell inside the docker image for a project |

local-test-curl-delta-01/fuzz-tooling/infra/base-images/README.md

@@ -0,0 +1,6 @@
+Building all infra images:
+
+```bash
+# run from project root
+infra/base-images/all.sh
+```

local-test-curl-delta-01/fuzz-tooling/infra/base-images/aixcc_build_all.sh

@@ -0,0 +1,59 @@
+#!/bin/bash -eux
+
+if [ "$1" = "--cache-from" ]; then
+    PULL_CACHE=1
+    shift
+    CACHE_TAG="${1//\//-}"  # s/\//-/g -> for branch names that contain slashes
+    shift
+elif [ "$1" = "--cache-to" ]; then
+    PUSH_CACHE=1
+    shift
+    CACHE_TAG="${1//\//-}"  # s/\//-/g -> for branch names that contain slashes
+    shift
+fi
+
+ARG_TAG="$1"
+shift
+
+BASE_IMAGES=(
+    "ghcr.io/aixcc-finals/base-image            infra/base-images/base-image"
+    "ghcr.io/aixcc-finals/base-clang            infra/base-images/base-clang"
+    "ghcr.io/aixcc-finals/base-builder          infra/base-images/base-builder"
+    "ghcr.io/aixcc-finals/base-builder-go       infra/base-images/base-builder-go"
+    "ghcr.io/aixcc-finals/base-builder-jvm      infra/base-images/base-builder-jvm"
+    "ghcr.io/aixcc-finals/base-builder-python   infra/base-images/base-builder-python"
+    "ghcr.io/aixcc-finals/base-builder-rust     infra/base-images/base-builder-rust"
+    "ghcr.io/aixcc-finals/base-builder-ruby     infra/base-images/base-builder-ruby"
+    "ghcr.io/aixcc-finals/base-builder-swift    infra/base-images/base-builder-swift"
+    "ghcr.io/aixcc-finals/base-runner           infra/base-images/base-runner"
+    "ghcr.io/aixcc-finals/base-runner-debug     infra/base-images/base-runner-debug"
+)
+
+for tuple in "${BASE_IMAGES[@]}"; do
+    read -r image path <<< "$tuple"
+
+    if [ "${PULL_CACHE+x}" ]; then
+
+        docker buildx build \
+            --build-arg IMG_TAG="${ARG_TAG}" \
+            --cache-from=type=registry,ref="${image}:${CACHE_TAG}" \
+            --tag "${image}:${ARG_TAG}" --push "$@" "${path}"
+
+    elif [ "${PUSH_CACHE+x}" ]; then
+
+        docker buildx build \
+            --build-arg IMG_TAG="${ARG_TAG}" \
+            --cache-from=type=registry,ref="${image}:${CACHE_TAG}" \
+            --cache-to=type=registry,ref="${image}:${CACHE_TAG}",mode=max \
+            --tag "${image}:${ARG_TAG}" --push "$@" "${path}"
+
+    else
+
+        docker buildx build \
+            --build-arg IMG_TAG="${ARG_TAG}" \
+            --tag "${image}:${ARG_TAG}" --push "$@" "${path}"
+
+    fi
+
+done
+

local-test-curl-delta-01/fuzz-tooling/infra/base-images/all.sh

@@ -0,0 +1,28 @@
+#!/bin/bash -eux
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+docker build --pull -t ghcr.io/aixcc-finals/base-image "$@" infra/base-images/base-image
+docker build -t ghcr.io/aixcc-finals/base-clang "$@" infra/base-images/base-clang
+docker build -t ghcr.io/aixcc-finals/base-builder "$@" infra/base-images/base-builder
+docker build -t ghcr.io/aixcc-finals/base-builder-go "$@" infra/base-images/base-builder-go
+docker build -t ghcr.io/aixcc-finals/base-builder-jvm "$@" infra/base-images/base-builder-jvm
+docker build -t ghcr.io/aixcc-finals/base-builder-python "$@" infra/base-images/base-builder-python
+docker build -t ghcr.io/aixcc-finals/base-builder-rust "$@" infra/base-images/base-builder-rust
+docker build -t ghcr.io/aixcc-finals/base-builder-ruby "$@" infra/base-images/base-builder-ruby
+docker build -t ghcr.io/aixcc-finals/base-builder-swift "$@" infra/base-images/base-builder-swift
+docker build -t ghcr.io/aixcc-finals/base-runner "$@" infra/base-images/base-runner
+docker build -t ghcr.io/aixcc-finals/base-runner-debug "$@" infra/base-images/base-runner-debug

local-test-curl-delta-01/fuzz-tooling/infra/bisector.py

@@ -0,0 +1,318 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Uses bisection to determine which commit a bug was introduced and fixed.
+This module takes a high and a low commit SHA, a repo name, and a bug.
+The module bisects the high and low commit SHA searching for the location
+where the bug was introduced. It also looks for where the bug was fixed.
+This is done with the following steps:
+
+
+  NOTE: Needs to be run from root of the OSS-Fuzz source checkout.
+
+  Typical usage example:
+        python3 infra/bisector.py
+          --old_commit 1e403e9259a1abedf108ab86f711ba52c907226d
+          --new_commit f79be4f2330f4b89ea2f42e1c44ca998c59a0c0f
+          --fuzz_target rules_fuzzer
+          --project_name yara
+          --testcase infra/yara_testcase
+          --sanitizer address
+"""
+
+import argparse
+import collections
+import logging
+import os
+import sys
+import tempfile
+
+import build_specified_commit
+import helper
+import repo_manager
+import utils
+
+Result = collections.namedtuple('Result', ['repo_url', 'commit'])
+
+START_MARKERS = [
+    '==ERROR',
+    '==WARNING',
+]
+
+END_MARKERS = [
+    'SUMMARY:',
+]
+
+DEDUP_TOKEN_MARKER = 'DEDUP_TOKEN:'
+
+
+class BisectError(Exception):
+  """Bisection error."""
+
+  def __init__(self, message, repo_url):
+    super().__init__(message)
+    self.repo_url = repo_url
+
+
+def main():
+  """Finds the commit SHA where an error was initally introduced."""
+  logging.getLogger().setLevel(logging.INFO)
+  utils.chdir_to_root()
+  parser = argparse.ArgumentParser(
+      description='git bisection for finding introduction of bugs')
+
+  parser.add_argument('--project_name',
+                      help='The name of the project where the bug occurred.',
+                      required=True)
+  parser.add_argument('--new_commit',
+                      help='The newest commit SHA to be bisected.',
+                      required=True)
+  parser.add_argument('--old_commit',
+                      help='The oldest commit SHA to be bisected.',
+                      required=True)
+  parser.add_argument('--fuzz_target',
+                      help='The name of the fuzzer to be built.',
+                      required=True)
+  parser.add_argument('--test_case_path',
+                      help='The path to test case.',
+                      required=True)
+  parser.add_argument('--engine',
+                      help='The default is "libfuzzer".',
+                      default='libfuzzer')
+  parser.add_argument('--sanitizer',
+                      default='address',
+                      help='The default is "address".')
+  parser.add_argument('--type',
+                      choices=['regressed', 'fixed'],
+                      help='The bisection type.',
+                      required=True)
+  parser.add_argument('--architecture', default='x86_64')
+  args = parser.parse_args()
+
+  build_data = build_specified_commit.BuildData(project_name=args.project_name,
+                                                engine=args.engine,
+                                                sanitizer=args.sanitizer,
+                                                architecture=args.architecture)
+
+  result = bisect(args.type, args.old_commit, args.new_commit,
+                  args.test_case_path, args.fuzz_target, build_data)
+  if not result.commit:
+    logging.error('No error was found in commit range %s:%s', args.old_commit,
+                  args.new_commit)
+    return 1
+  if result.commit == args.old_commit:
+    logging.error(
+        'Bisection Error: Both the first and the last commits in'
+        'the given range have the same behavior, bisection is not possible. ')
+    return 1
+  if args.type == 'regressed':
+    print('Error was introduced at commit %s' % result.commit)
+  elif args.type == 'fixed':
+    print('Error was fixed at commit %s' % result.commit)
+  return 0
+
+
+def _get_dedup_token(output):
+  """Get dedup token."""
+  for line in output.splitlines():
+    token_location = line.find(DEDUP_TOKEN_MARKER)
+    if token_location == -1:
+      continue
+
+    return line[token_location + len(DEDUP_TOKEN_MARKER):].strip()
+
+  return None
+
+
+def _check_for_crash(project_name, fuzz_target, testcase_path):
+  """Check for crash."""
+
+  def docker_run(args, **kwargs):
+    del kwargs
+    command = ['docker', 'run', '--rm', '--privileged']
+    if sys.stdin.isatty():
+      command.append('-i')
+
+    return utils.execute(command + args)
+
+  logging.info('Checking for crash')
+  out, err, return_code = helper.reproduce_impl(
+      project=helper.Project(project_name),
+      fuzzer_name=fuzz_target,
+      valgrind=False,
+      env_to_add=[],
+      fuzzer_args=[],
+      testcase_path=testcase_path,
+      run_function=docker_run,
+      err_result=(None, None, None))
+  if return_code is None:
+    return None
+
+  logging.info('stdout =\n%s', out)
+  logging.info('stderr =\n%s', err)
+
+  # pylint: disable=unsupported-membership-test
+  has_start_marker = any(
+      marker in out or marker in err for marker in START_MARKERS)
+  has_end_marker = any(marker in out or marker in err for marker in END_MARKERS)
+  if not has_start_marker or not has_end_marker:
+    return None
+
+  return _get_dedup_token(out + err)
+
+
+# pylint: disable=too-many-locals
+# pylint: disable=too-many-arguments
+# pylint: disable=too-many-statements
+def _bisect(bisect_type, old_commit, new_commit, testcase_path, fuzz_target,
+            build_data):
+  """Perform the bisect."""
+  # pylint: disable=too-many-branches
+  base_builder_repo = build_specified_commit.load_base_builder_repo()
+
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    repo_url, repo_path = build_specified_commit.detect_main_repo(
+        build_data.project_name, commit=new_commit)
+    if not repo_url or not repo_path:
+      raise ValueError('Main git repo can not be determined.')
+
+    if old_commit == new_commit:
+      raise BisectError('old_commit is the same as new_commit', repo_url)
+
+    # Copy /src from the built Docker container to ensure all dependencies
+    # exist. This will be mounted when running them.
+    host_src_dir = build_specified_commit.copy_src_from_docker(
+        build_data.project_name, tmp_dir)
+
+    bisect_repo_manager = repo_manager.RepoManager(
+        os.path.join(host_src_dir, os.path.basename(repo_path)))
+    bisect_repo_manager.fetch_all_remotes()
+
+    commit_list = bisect_repo_manager.get_commit_list(new_commit, old_commit)
+
+    old_idx = len(commit_list) - 1
+    new_idx = 0
+    logging.info('Testing against new_commit (%s)', commit_list[new_idx])
+    if not build_specified_commit.build_fuzzers_from_commit(
+        commit_list[new_idx],
+        bisect_repo_manager,
+        host_src_dir,
+        build_data,
+        base_builder_repo=base_builder_repo):
+      raise BisectError('Failed to build new_commit', repo_url)
+
+    if bisect_type == 'fixed':
+      should_crash = False
+    elif bisect_type == 'regressed':
+      should_crash = True
+    else:
+      raise BisectError('Invalid bisect type ' + bisect_type, repo_url)
+
+    expected_error = _check_for_crash(build_data.project_name, fuzz_target,
+                                      testcase_path)
+    logging.info('new_commit result = %s', expected_error)
+
+    if not should_crash and expected_error:
+      logging.warning('new_commit crashed but not shouldn\'t. '
+                      'Continuing to see if stack changes.')
+
+    range_valid = False
+    for _ in range(2):
+      logging.info('Testing against old_commit (%s)', commit_list[old_idx])
+      if not build_specified_commit.build_fuzzers_from_commit(
+          commit_list[old_idx],
+          bisect_repo_manager,
+          host_src_dir,
+          build_data,
+          base_builder_repo=base_builder_repo):
+        raise BisectError('Failed to build old_commit', repo_url)
+
+      if _check_for_crash(build_data.project_name, fuzz_target,
+                          testcase_path) == expected_error:
+        logging.warning('old_commit %s had same result as new_commit %s',
+                        old_commit, new_commit)
+        # Try again on an slightly older commit.
+        old_commit = bisect_repo_manager.get_parent(old_commit, 64)
+        if not old_commit:
+          break
+
+        commit_list = bisect_repo_manager.get_commit_list(
+            new_commit, old_commit)
+        old_idx = len(commit_list) - 1
+        continue
+
+      range_valid = True
+      break
+
+    if not range_valid:
+      raise BisectError('old_commit had same result as new_commit', repo_url)
+
+    while old_idx - new_idx > 1:
+      curr_idx = (old_idx + new_idx) // 2
+      logging.info('Testing against %s (idx=%d)', commit_list[curr_idx],
+                   curr_idx)
+      if not build_specified_commit.build_fuzzers_from_commit(
+          commit_list[curr_idx],
+          bisect_repo_manager,
+          host_src_dir,
+          build_data,
+          base_builder_repo=base_builder_repo):
+        # Treat build failures as if we couldn't repo.
+        # TODO(ochang): retry nearby commits?
+        old_idx = curr_idx
+        continue
+
+      current_error = _check_for_crash(build_data.project_name, fuzz_target,
+                                       testcase_path)
+      logging.info('Current result = %s', current_error)
+      if expected_error == current_error:
+        new_idx = curr_idx
+      else:
+        old_idx = curr_idx
+    return Result(repo_url, commit_list[new_idx])
+
+
+# pylint: disable=too-many-locals
+# pylint: disable=too-many-arguments
+def bisect(bisect_type, old_commit, new_commit, testcase_path, fuzz_target,
+           build_data):
+  """From a commit range, this function caluclates which introduced a
+  specific error from a fuzz testcase_path.
+
+  Args:
+    bisect_type: The type of the bisect ('regressed' or 'fixed').
+    old_commit: The oldest commit in the error regression range.
+    new_commit: The newest commit in the error regression range.
+    testcase_path: The file path of the test case that triggers the error
+    fuzz_target: The name of the fuzzer to be tested.
+    build_data: a class holding all of the input parameters for bisection.
+
+  Returns:
+    The commit SHA that introduced the error or None.
+
+  Raises:
+    ValueError: when a repo url can't be determine from the project.
+  """
+  try:
+    return _bisect(bisect_type, old_commit, new_commit, testcase_path,
+                   fuzz_target, build_data)
+  finally:
+    # Clean up projects/ as _bisect may have modified it.
+    oss_fuzz_repo_manager = repo_manager.RepoManager(helper.OSS_FUZZ_DIR)
+    oss_fuzz_repo_manager.git(['reset', 'projects'])
+    oss_fuzz_repo_manager.git(['checkout', 'projects'])
+    oss_fuzz_repo_manager.git(['clean', '-fxd', 'projects'])
+
+
+if __name__ == '__main__':
+  main()

local-test-curl-delta-01/fuzz-tooling/infra/bisector_test.py

@@ -0,0 +1,70 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing perepo_managerissions and
+# limitations under the License.
+"""Test the functionality of bisection module:
+1) Test a known case where an error appears in a regression range.
+2) Bisect can handle incorrect inputs.
+
+IMPORTANT: This test needs to be run with root privileges.
+"""
+
+import os
+import unittest
+
+import bisector
+import build_specified_commit
+import test_repos
+
+# Necessary because __file__ changes with os.chdir
+TEST_DIR_PATH = os.path.dirname(os.path.realpath(__file__))
+
+
+@unittest.skip('Test is too long to be run with presubmit.')
+class BisectIntegrationTests(unittest.TestCase):
+  """Class to test the functionality of bisection method."""
+
+  BISECT_TYPE = 'regressed'
+
+  def test_bisect_invalid_repo(self):
+    """Test the bisection method on a project that does not exist."""
+    test_repo = test_repos.INVALID_REPO
+    build_data = build_specified_commit.BuildData(
+        project_name=test_repo.project_name,
+        engine='libfuzzer',
+        sanitizer='address',
+        architecture='x86_64')
+    with self.assertRaises(ValueError):
+      bisector.bisect(self.BISECT_TYPE, test_repo.old_commit,
+                      test_repo.new_commit, test_repo.testcase_path,
+                      test_repo.fuzz_target, build_data)
+
+  def test_bisect(self):
+    """Test the bisect method on example projects."""
+    for test_repo in test_repos.TEST_REPOS:
+      if test_repo.new_commit:
+        build_data = build_specified_commit.BuildData(
+            project_name=test_repo.project_name,
+            engine='libfuzzer',
+            sanitizer='address',
+            architecture='x86_64')
+        result = bisector.bisect(self.BISECT_TYPE, test_repo.old_commit,
+                                 test_repo.new_commit, test_repo.testcase_path,
+                                 test_repo.fuzz_target, build_data)
+        self.assertEqual(result.commit, test_repo.intro_commit)
+
+
+if __name__ == '__main__':
+  # Change to oss-fuzz main directory so helper.py runs correctly.
+  if os.getcwd() != os.path.dirname(TEST_DIR_PATH):
+    os.chdir(os.path.dirname(TEST_DIR_PATH))
+  unittest.main()

local-test-curl-delta-01/fuzz-tooling/infra/build_fuzzers.Dockerfile

@@ -0,0 +1,31 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+# Docker image to run fuzzers for CIFuzz (the run_fuzzers action on GitHub
+# actions).
+
+FROM ghcr.io/aixcc-finals/cifuzz-base
+
+# Python file to execute when the docker container starts up
+# We can't use the env var $OSS_FUZZ_ROOT here. Since it's a constant env var,
+# just expand to '/opt/oss-fuzz'.
+ENTRYPOINT ["python3", "/opt/oss-fuzz/infra/cifuzz/build_fuzzers_entrypoint.py"]
+
+WORKDIR ${OSS_FUZZ_ROOT}/infra
+
+# Update infra source code.
+ADD . ${OSS_FUZZ_ROOT}/infra
+
+RUN python3 -m pip install -r ${OSS_FUZZ_ROOT}/infra/cifuzz/requirements.txt

local-test-curl-delta-01/fuzz-tooling/infra/build_specified_commit.py

@@ -0,0 +1,410 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module to build a image from a specific commit, branch or pull request.
+
+This module is allows each of the OSS Fuzz projects fuzzers to be built
+from a specific point in time. This feature can be used for implementations
+like continuious integration fuzzing and bisection to find errors
+"""
+import argparse
+import bisect
+import datetime
+import os
+import collections
+import json
+import logging
+import re
+import shutil
+import tempfile
+
+import helper
+import repo_manager
+import retry
+import utils
+
+BuildData = collections.namedtuple(
+    'BuildData', ['project_name', 'engine', 'sanitizer', 'architecture'])
+
+_GIT_DIR_MARKER = 'gitdir: '
+_IMAGE_BUILD_TRIES = 3
+
+
+class BaseBuilderRepo:
+  """Repo of base-builder images."""
+
+  def __init__(self):
+    self.timestamps = []
+    self.digests = []
+
+  def add_digest(self, timestamp, digest):
+    """Add a digest."""
+    self.timestamps.append(timestamp)
+    self.digests.append(digest)
+
+  def find_digest(self, timestamp):
+    """Find the latest image before the given timestamp."""
+    index = bisect.bisect_right(self.timestamps, timestamp)
+    if index > 0:
+      return self.digests[index - 1]
+
+    logging.error('Failed to find suitable base-builder.')
+    return None
+
+
+def _replace_gitdir(src_dir, file_path):
+  """Replace gitdir with a relative path."""
+  with open(file_path) as handle:
+    lines = handle.readlines()
+
+  new_lines = []
+  for line in lines:
+    if line.startswith(_GIT_DIR_MARKER):
+      absolute_path = line[len(_GIT_DIR_MARKER):].strip()
+      if not os.path.isabs(absolute_path):
+        # Already relative.
+        return
+
+      current_dir = os.path.dirname(file_path)
+      # Rebase to /src rather than the host src dir.
+      base_dir = current_dir.replace(src_dir, '/src')
+      relative_path = os.path.relpath(absolute_path, base_dir)
+      logging.info('Replacing absolute submodule gitdir from %s to %s',
+                   absolute_path, relative_path)
+
+      line = _GIT_DIR_MARKER + relative_path
+
+    new_lines.append(line)
+
+  with open(file_path, 'w') as handle:
+    handle.write(''.join(new_lines))
+
+
+def _make_gitdirs_relative(src_dir):
+  """Make gitdirs relative."""
+  for root_dir, _, files in os.walk(src_dir):
+    for filename in files:
+      if filename != '.git':
+        continue
+
+      file_path = os.path.join(root_dir, filename)
+      _replace_gitdir(src_dir, file_path)
+
+
+def _replace_base_builder_digest(dockerfile_path, digest):
+  """Replace the base-builder digest in a Dockerfile."""
+  with open(dockerfile_path) as handle:
+    lines = handle.readlines()
+
+  new_lines = []
+  for line in lines:
+    if line.strip().startswith('FROM'):
+      line = 'FROM ghcr.io/aixcc-finals/base-builder@' + digest + '\n'
+
+    new_lines.append(line)
+
+  with open(dockerfile_path, 'w') as handle:
+    handle.write(''.join(new_lines))
+
+
+def copy_src_from_docker(project_name, host_dir):
+  """Copy /src from docker to the host."""
+  # Copy /src to host.
+  image_name = 'gcr.io/oss-fuzz/' + project_name
+  src_dir = os.path.join(host_dir, 'src')
+  if os.path.exists(src_dir):
+    shutil.rmtree(src_dir, ignore_errors=True)
+
+  docker_args = [
+      '-v',
+      host_dir + ':/out',
+      image_name,
+      'cp',
+      '-r',
+      '-p',
+      '/src',
+      '/out',
+  ]
+  helper.docker_run(docker_args)
+
+  # Submodules can have gitdir entries which point to absolute paths. Make them
+  # relative, as otherwise we can't do operations on the checkout on the host.
+  _make_gitdirs_relative(src_dir)
+  return src_dir
+
+
+@retry.wrap(_IMAGE_BUILD_TRIES, 2)
+def _build_image_with_retries(project_name):
+  """Build image with retries."""
+  return helper.build_image_impl(helper.Project(project_name))
+
+
+def get_required_post_checkout_steps(dockerfile_path):
+  """Get required post checkout steps (best effort)."""
+
+  checkout_pattern = re.compile(r'\s*RUN\s*(git|svn|hg)')
+
+  # If the build.sh is copied from upstream, we need to copy it again after
+  # changing the revision to ensure correct building.
+  post_run_pattern = re.compile(r'\s*RUN\s*(.*build\.sh.*(\$SRC|/src).*)')
+
+  with open(dockerfile_path) as handle:
+    lines = handle.readlines()
+
+  subsequent_run_cmds = []
+  for i, line in enumerate(lines):
+    if checkout_pattern.match(line):
+      subsequent_run_cmds = []
+      continue
+
+    match = post_run_pattern.match(line)
+    if match:
+      workdir = helper.workdir_from_lines(lines[:i])
+      command = match.group(1)
+      subsequent_run_cmds.append((workdir, command))
+
+  return subsequent_run_cmds
+
+
+# pylint: disable=too-many-locals
+def build_fuzzers_from_commit(commit,
+                              build_repo_manager,
+                              host_src_path,
+                              build_data,
+                              base_builder_repo=None):
+  """Builds a OSS-Fuzz fuzzer at a specific commit SHA.
+
+  Args:
+    commit: The commit SHA to build the fuzzers at.
+    build_repo_manager: The OSS-Fuzz project's repo manager to be built at.
+    build_data: A struct containing project build information.
+    base_builder_repo: A BaseBuilderRepo.
+  Returns:
+    0 on successful build or error code on failure.
+  """
+  oss_fuzz_repo_manager = repo_manager.RepoManager(helper.OSS_FUZZ_DIR)
+  num_retry = 1
+
+  def cleanup():
+    # Re-copy /src for a clean checkout every time.
+    copy_src_from_docker(build_data.project_name,
+                         os.path.dirname(host_src_path))
+    build_repo_manager.fetch_all_remotes()
+
+  projects_dir = os.path.join('projects', build_data.project_name)
+  dockerfile_path = os.path.join(projects_dir, 'Dockerfile')
+
+  for i in range(num_retry + 1):
+    build_repo_manager.checkout_commit(commit, clean=False)
+
+    post_checkout_steps = get_required_post_checkout_steps(dockerfile_path)
+    for workdir, post_checkout_step in post_checkout_steps:
+      logging.info('Running post-checkout step `%s` in %s.', post_checkout_step,
+                   workdir)
+      helper.docker_run([
+          '-w',
+          workdir,
+          '-v',
+          host_src_path + ':' + '/src',
+          'gcr.io/oss-fuzz/' + build_data.project_name,
+          '/bin/bash',
+          '-c',
+          post_checkout_step,
+      ])
+
+    project = helper.Project(build_data.project_name)
+    result = helper.build_fuzzers_impl(project=project,
+                                       clean=True,
+                                       engine=build_data.engine,
+                                       sanitizer=build_data.sanitizer,
+                                       architecture=build_data.architecture,
+                                       env_to_add=None,
+                                       source_path=host_src_path,
+                                       mount_path='/src')
+    if result or i == num_retry:
+      break
+
+    # Retry with an OSS-Fuzz builder container that's closer to the project
+    # commit date.
+    commit_date = build_repo_manager.commit_date(commit)
+
+    # Find first change in the projects/<PROJECT> directory before the project
+    # commit date.
+    oss_fuzz_commit, _, _ = oss_fuzz_repo_manager.git([
+        'log', '--before=' + commit_date.isoformat(), '-n1', '--format=%H',
+        projects_dir
+    ],
+                                                      check_result=True)
+    oss_fuzz_commit = oss_fuzz_commit.strip()
+    if not oss_fuzz_commit:
+      logging.info(
+          'Could not find first OSS-Fuzz commit prior to upstream commit. '
+          'Falling back to oldest integration commit.')
+
+      # Find the oldest commit.
+      oss_fuzz_commit, _, _ = oss_fuzz_repo_manager.git(
+          ['log', '--reverse', '--format=%H', projects_dir], check_result=True)
+
+      oss_fuzz_commit = oss_fuzz_commit.splitlines()[0].strip()
+
+    if not oss_fuzz_commit:
+      logging.error('Failed to get oldest integration commit.')
+      break
+
+    logging.info('Build failed. Retrying on earlier OSS-Fuzz commit %s.',
+                 oss_fuzz_commit)
+
+    # Check out projects/<PROJECT> dir to the commit that was found.
+    oss_fuzz_repo_manager.git(['checkout', oss_fuzz_commit, projects_dir],
+                              check_result=True)
+
+    # Also use the closest base-builder we can find.
+    if base_builder_repo:
+      base_builder_digest = base_builder_repo.find_digest(commit_date)
+      if not base_builder_digest:
+        return False
+
+      logging.info('Using base-builder with digest %s.', base_builder_digest)
+      _replace_base_builder_digest(dockerfile_path, base_builder_digest)
+
+    # Rebuild image and re-copy src dir since things in /src could have changed.
+    if not _build_image_with_retries(build_data.project_name):
+      logging.error('Failed to rebuild image.')
+      return False
+
+    cleanup()
+
+  cleanup()
+  return result
+
+
+def detect_main_repo(project_name, repo_name=None, commit=None):
+  """Checks a docker image for the main repo of an OSS-Fuzz project.
+
+  Note: The default is to use the repo name to detect the main repo.
+
+  Args:
+    project_name: The name of the oss-fuzz project.
+    repo_name: The name of the main repo in an OSS-Fuzz project.
+    commit: A commit SHA that is associated with the main repo.
+
+  Returns:
+    A tuple containing (the repo's origin, the repo's path).
+  """
+
+  if not repo_name and not commit:
+    logging.error(
+        'Error: can not detect main repo without a repo_name or a commit.')
+    return None, None
+  if repo_name and commit:
+    logging.info(
+        'Both repo name and commit specific. Using repo name for detection.')
+
+  # Change to oss-fuzz main directory so helper.py runs correctly.
+  utils.chdir_to_root()
+  if not _build_image_with_retries(project_name):
+    logging.error('Error: building %s image failed.', project_name)
+    return None, None
+  docker_image_name = 'gcr.io/oss-fuzz/' + project_name
+  command_to_run = [
+      'docker', 'run', '--rm', '-t', docker_image_name, 'python3',
+      os.path.join('/opt', 'cifuzz', 'detect_repo.py')
+  ]
+  if repo_name:
+    command_to_run.extend(['--repo_name', repo_name])
+  else:
+    command_to_run.extend(['--example_commit', commit])
+  out, _, _ = utils.execute(command_to_run)
+  match = re.search(r'\bDetected repo: ([^ ]+) ([^ ]+)', out.rstrip())
+  if match and match.group(1) and match.group(2):
+    return match.group(1), match.group(2)
+
+  logging.error('Failed to detect repo:\n%s', out)
+  return None, None
+
+
+def load_base_builder_repo():
+  """Get base-image digests."""
+  gcloud_path = shutil.which('gcloud')
+  if not gcloud_path:
+    logging.warning('gcloud not found in PATH.')
+    return None
+
+  result, _, _ = utils.execute([
+      gcloud_path,
+      'container',
+      'images',
+      'list-tags',
+      'ghcr.io/aixcc-finals/base-builder',
+      '--format=json',
+      '--sort-by=timestamp',
+  ],
+                               check_result=True)
+  result = json.loads(result)
+
+  repo = BaseBuilderRepo()
+  for image in result:
+    timestamp = datetime.datetime.fromisoformat(
+        image['timestamp']['datetime']).astimezone(datetime.timezone.utc)
+    repo.add_digest(timestamp, image['digest'])
+
+  return repo
+
+
+def main():
+  """Main function."""
+  logging.getLogger().setLevel(logging.INFO)
+
+  parser = argparse.ArgumentParser(
+      description='Build fuzzers at a specific commit')
+  parser.add_argument('--project_name',
+                      help='The name of the project where the bug occurred.',
+                      required=True)
+  parser.add_argument('--commit',
+                      help='The newest commit SHA to be bisected.',
+                      required=True)
+  parser.add_argument('--engine',
+                      help='The default is "libfuzzer".',
+                      default='libfuzzer')
+  parser.add_argument('--sanitizer',
+                      default='address',
+                      help='The default is "address".')
+  parser.add_argument('--architecture', default='x86_64')
+
+  args = parser.parse_args()
+
+  repo_url, repo_path = detect_main_repo(args.project_name, commit=args.commit)
+
+  if not repo_url or not repo_path:
+    raise ValueError('Main git repo can not be determined.')
+
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    host_src_dir = copy_src_from_docker(args.project_name, tmp_dir)
+    build_repo_manager = repo_manager.RepoManager(
+        os.path.join(host_src_dir, os.path.basename(repo_path)))
+    base_builder_repo = load_base_builder_repo()
+
+    build_data = BuildData(project_name=args.project_name,
+                           engine=args.engine,
+                           sanitizer=args.sanitizer,
+                           architecture=args.architecture)
+    if not build_fuzzers_from_commit(args.commit,
+                                     build_repo_manager,
+                                     host_src_dir,
+                                     build_data,
+                                     base_builder_repo=base_builder_repo):
+      raise RuntimeError('Failed to build.')
+
+
+if __name__ == '__main__':
+  main()

local-test-curl-delta-01/fuzz-tooling/infra/build_specified_commit_test.py

@@ -0,0 +1,126 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Test the functionality of the build image from commit module.
+The will consist of the following functional tests:
+  1. The inference of the main repo for a specific project.
+  2. The building of a projects fuzzers from a specific commit.
+
+"""
+import os
+import tempfile
+import unittest
+
+import build_specified_commit
+import helper
+import repo_manager
+import test_repos
+
+# necessary because __file__ changes with os.chdir
+TEST_DIR_PATH = os.path.dirname(os.path.realpath(__file__))
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class BuildImageIntegrationTest(unittest.TestCase):
+  """Tests if an image can be built from different states e.g. a commit."""
+
+  @unittest.skip('Test is failing (spuriously?).')
+  def test_build_fuzzers_from_commit(self):
+    """Tests if the fuzzers can build at a specified commit.
+
+    This is done by using a known regression range for a specific test case.
+    The old commit should show the error when its fuzzers run and the new one
+    should not.
+    """
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      test_repo = test_repos.TEST_REPOS[1]
+      self.assertTrue(helper.build_image_impl(test_repo.project_name))
+      host_src_dir = build_specified_commit.copy_src_from_docker(
+          test_repo.project_name, tmp_dir)
+
+      test_repo_manager = repo_manager.clone_repo_and_get_manager(
+          test_repo.git_url, host_src_dir, test_repo.oss_repo_name)
+      build_data = build_specified_commit.BuildData(
+          sanitizer='address',
+          architecture='x86_64',
+          engine='libfuzzer',
+          project_name=test_repo.project_name)
+
+      build_specified_commit.build_fuzzers_from_commit(test_repo.old_commit,
+                                                       test_repo_manager,
+                                                       host_src_dir, build_data)
+      project = helper.Project(test_repo.project_name)
+      old_result = helper.reproduce_impl(project=project,
+                                         fuzzer_name=test_repo.fuzz_target,
+                                         valgrind=False,
+                                         env_to_add=[],
+                                         fuzzer_args=[],
+                                         testcase_path=test_repo.testcase_path)
+      build_specified_commit.build_fuzzers_from_commit(test_repo.project_name,
+                                                       test_repo_manager,
+                                                       host_src_dir, build_data)
+      new_result = helper.reproduce_impl(project=project,
+                                         fuzzer_name=test_repo.fuzz_target,
+                                         valgrind=False,
+                                         env_to_add=[],
+                                         fuzzer_args=[],
+                                         testcase_path=test_repo.testcase_path)
+      self.assertNotEqual(new_result, old_result)
+
+  def test_detect_main_repo_from_commit(self):
+    """Test the detect main repo function from build specific commit module."""
+    # TODO(metzman): Fix these tests so they don't randomly break because of
+    # changes in the outside world.
+    for example_repo in test_repos.TEST_REPOS:
+      if example_repo.new_commit:
+        # TODO(metzman): This function calls _build_image_with_retries which
+        # has a long delay (30 seconds). Figure out how to make this quicker.
+        repo_origin, repo_name = build_specified_commit.detect_main_repo(
+            example_repo.project_name, commit=example_repo.new_commit)
+        self.assertEqual(repo_origin, example_repo.git_url)
+        self.assertEqual(repo_name,
+                         os.path.join('/src', example_repo.oss_repo_name))
+
+    repo_origin, repo_name = build_specified_commit.detect_main_repo(
+        test_repos.INVALID_REPO.project_name,
+        test_repos.INVALID_REPO.new_commit)
+    self.assertIsNone(repo_origin)
+    self.assertIsNone(repo_name)
+
+  def test_detect_main_repo_from_name(self):
+    """Test the detect main repo function from build specific commit module."""
+    for example_repo in test_repos.TEST_REPOS:
+      if example_repo.project_name == 'gonids':
+        # It's unclear how this test ever passed, but we can't infer the repo
+        # because gonids doesn't really check it out, it uses "go get".
+        continue
+      repo_origin, repo_name = build_specified_commit.detect_main_repo(
+          example_repo.project_name, repo_name=example_repo.git_repo_name)
+      self.assertEqual(repo_origin, example_repo.git_url)
+      self.assertEqual(
+          repo_name,
+          os.path.join(example_repo.image_location, example_repo.oss_repo_name))
+
+    repo_origin, repo_name = build_specified_commit.detect_main_repo(
+        test_repos.INVALID_REPO.project_name,
+        test_repos.INVALID_REPO.oss_repo_name)
+    self.assertIsNone(repo_origin)
+    self.assertIsNone(repo_name)
+
+
+if __name__ == '__main__':
+  # Change to oss-fuzz main directory so helper.py runs correctly.
+  if os.getcwd() != os.path.dirname(TEST_DIR_PATH):
+    os.chdir(os.path.dirname(TEST_DIR_PATH))
+  unittest.main()

local-test-curl-delta-01/fuzz-tooling/infra/ci/requirements.txt

@@ -0,0 +1,9 @@
+# Requirements for submitting code changes to infra/ (needed by presubmit.py).
+parameterized==0.7.4
+pyfakefs==4.5.6
+pylint==2.5.3
+pytest==7.1.2
+pytest-xdist==2.5.0
+PyYAML==6.0
+requests==2.31.0
+yapf==0.32.0