[Global]: loading init

deps/curl/docs/libcurl/opts/CMakeLists.txt

@@ -0,0 +1,37 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  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
+#
+###########################################################################
+# Load man_MANS from shared file
+transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+
+add_manual_pages(man_MANS)
+add_custom_target(opts-man DEPENDS ${man_MANS})
+add_dependencies(man opts-man)
+if(NOT CURL_DISABLE_INSTALL)
+  unset(_src)
+  foreach(_f ${man_MANS})
+    list(APPEND _src "${CMAKE_CURRENT_BINARY_DIR}/${_f}")
+  endforeach()
+  install(FILES ${_src} DESTINATION ${CMAKE_INSTALL_MANDIR}/man3)
+endif()

deps/curl/docs/libcurl/opts/CURLINFO_ACTIVESOCKET.md

@@ -0,0 +1,77 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_ACTIVESOCKET
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_LASTSOCKET (3)
+  - CURLOPT_CONNECT_ONLY (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_ACTIVESOCKET - get the active socket
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_ACTIVESOCKET,
+                           curl_socket_t *socket);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_socket_t to receive the most recently active socket
+used for the transfer connection by this curl session. If the socket is no
+longer valid, *CURL_SOCKET_BAD* is returned. When you are finished working
+with the socket, you must call curl_easy_cleanup(3) as usual on the easy
+handle and let libcurl close the socket and cleanup other resources associated
+with the handle. This option returns the active socket only after the transfer
+is complete, and is typically used in combination with
+CURLOPT_CONNECT_ONLY(3), which skips the transfer phase.
+
+CURLINFO_ACTIVESOCKET(3) was added as a replacement for
+CURLINFO_LASTSOCKET(3) since that one is not working on all platforms.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_socket_t sockfd;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Do not do the transfer - only connect to host */
+    curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 1L);
+    res = curl_easy_perform(curl);
+
+    /* Extract the socket from the curl handle */
+    res = curl_easy_getinfo(curl, CURLINFO_ACTIVESOCKET, &sockfd);
+
+    if(res != CURLE_OK) {
+      printf("Error: %s\n", curl_easy_strerror(res));
+      return 1;
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.45.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_APPCONNECT_TIME.md

@@ -0,0 +1,71 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_APPCONNECT_TIME
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_APPCONNECT_TIME_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_APPCONNECT_TIME - get the time until the SSL/SSH handshake is completed
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_APPCONNECT_TIME,
+                           double *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the time, in seconds, it took from the
+start until the SSL/SSH connect/handshake to the remote host was completed.
+This time is most often close to the CURLINFO_PRETRANSFER_TIME(3) time,
+except for cases such as HTTP pipelining where the pretransfer time can be
+delayed due to waits in line for the pipeline and more.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    double connect;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_APPCONNECT_TIME, &connect);
+      if(CURLE_OK == res) {
+        printf("Time: %.1f", connect);
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.19.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_APPCONNECT_TIME_T.md

@@ -0,0 +1,73 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_APPCONNECT_TIME_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_APPCONNECT_TIME (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_APPCONNECT_TIME_T - time until the SSL/SSH handshake completed
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_APPCONNECT_TIME_T,
+                           curl_off_t *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_off_t to receive the time, in microseconds, it took
+from the start until the SSL/SSH connect/handshake to the remote host was
+completed. This time is most often close to the
+CURLINFO_PRETRANSFER_TIME_T(3) time, except for cases such as HTTP
+pipelining where the pretransfer time can be delayed due to waits in line for
+the pipeline and more.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_off_t connect;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_APPCONNECT_TIME_T, &connect);
+      if(CURLE_OK == res) {
+        printf("Time: %" CURL_FORMAT_CURL_OFF_T ".%06ld", connect / 1000000,
+               (long)(connect % 1000000));
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.61.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CAINFO.md

@@ -0,0 +1,66 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CAINFO
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CAPATH (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CAINFO - get the default built-in CA certificate path
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CAINFO, char **path);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a char pointer to receive the pointer to a null-terminated
+string holding the default built-in path used for the CURLOPT_CAINFO(3)
+option unless set by the user.
+
+Note that in a situation where libcurl has been built to support multiple TLS
+libraries, this option might return a string even if the specific TLS library
+currently set to be used does not support CURLOPT_CAINFO(3).
+
+This is a path identifying a single file containing CA certificates.
+
+The **path** pointer is set to NULL if there is no default path.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    char *cainfo = NULL;
+    curl_easy_getinfo(curl, CURLINFO_CAINFO, &cainfo);
+    if(cainfo) {
+      printf("default ca info path: %s\n", cainfo);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.84.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CAPATH.md

@@ -0,0 +1,66 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CAPATH
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CAINFO (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CAPATH - get the default built-in CA path string
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CAPATH, char **path);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a char pointer to receive the pointer to a null-terminated
+string holding the default built-in path used for the CURLOPT_CAPATH(3)
+option unless set by the user.
+
+Note that in a situation where libcurl has been built to support multiple TLS
+libraries, this option might return a string even if the specific TLS library
+currently set to be used does not support CURLOPT_CAPATH(3).
+
+This is a path identifying a directory.
+
+The **path** pointer is set to NULL if there is no default path.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    char *capath = NULL;
+    curl_easy_getinfo(curl, CURLINFO_CAPATH, &capath);
+    if(capath) {
+      printf("default ca path: %s\n", capath);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.84.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CERTINFO.md

@@ -0,0 +1,101 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CERTINFO
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CAPATH (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CERTINFO - get the TLS certificate chain
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CERTINFO,
+                           struct curl_certinfo **chainp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a *struct curl_certinfo ** and it is set to point to a
+struct that holds info about the server's certificate chain, assuming you had
+CURLOPT_CERTINFO(3) enabled when the request was made.
+
+~~~c
+struct curl_certinfo {
+  int num_of_certs;
+  struct curl_slist **certinfo;
+};
+~~~
+
+The *certinfo* struct member is an array of linked lists of certificate
+information. The *num_of_certs* struct member is the number of certificates
+which is the number of elements in the array. Each certificate's list has
+items with textual information in the format "name:content" such as
+"Subject:Foo", "Issuer:Bar", etc. The items in each list varies depending on
+the SSL backend and the certificate.
+
+# PROTOCOLS
+
+All TLS-based
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/");
+
+    /* connect to any HTTPS site, trusted or not */
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
+
+    curl_easy_setopt(curl, CURLOPT_CERTINFO, 1L);
+
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      int i;
+      struct curl_certinfo *ci;
+      res = curl_easy_getinfo(curl, CURLINFO_CERTINFO, &ci);
+
+      if(!res) {
+        printf("%d certs!\n", ci->num_of_certs);
+
+        for(i = 0; i < ci->num_of_certs; i++) {
+          struct curl_slist *slist;
+
+          for(slist = ci->certinfo[i]; slist; slist = slist->next)
+            printf("%s\n", slist->data);
+        }
+      }
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+See also the *certinfo.c* example.
+
+# AVAILABILITY
+
+This option is only working in libcurl built with OpenSSL, GnuTLS, Schannel or
+Secure Transport. GnuTLS support added in 7.42.0. Schannel support added in
+7.50.0. Secure Transport support added in 7.79.0.
+
+Added in 7.19.1
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CONDITION_UNMET.md

@@ -0,0 +1,80 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CONDITION_UNMET
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_TIMECONDITION (3)
+  - CURLOPT_TIMEVALUE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CONDITION_UNMET - get info on unmet time conditional or 304 HTTP response.
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONDITION_UNMET,
+                           long *unmet);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the number 1 if the condition provided in
+the previous request did not match (see CURLOPT_TIMECONDITION(3)). Alas,
+if this returns a 1 you know that the reason you did not get data in return is
+because it did not fulfill the condition. The long this argument points to
+gets a zero stored if the condition instead was met. This can also return 1 if
+the server responded with a 304 HTTP status code, for example after sending a
+custom "If-Match-*" header.
+
+# PROTOCOLS
+
+HTTP and some
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* January 1, 2020 is 1577833200 */
+    curl_easy_setopt(curl, CURLOPT_TIMEVALUE, 1577833200L);
+
+    /* If-Modified-Since the above time stamp */
+    curl_easy_setopt(curl, CURLOPT_TIMECONDITION,
+                     (long)CURL_TIMECOND_IFMODSINCE);
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* check the time condition */
+      long unmet;
+      res = curl_easy_getinfo(curl, CURLINFO_CONDITION_UNMET, &unmet);
+      if(!res) {
+        printf("The time condition was %sfulfilled\n", unmet?"NOT":"");
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.19.4
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CONNECT_TIME.md

@@ -0,0 +1,67 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CONNECT_TIME
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CONNECT_TIME_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CONNECT_TIME - get the time until connect
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONNECT_TIME, double *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the total time in seconds from the start
+until the connection to the remote host (or proxy) was completed.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    double connect;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME, &connect);
+      if(CURLE_OK == res) {
+        printf("Time: %.1f", connect);
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4.1
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CONNECT_TIME_T.md

@@ -0,0 +1,70 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CONNECT_TIME_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CONNECT_TIME (3)
+  - CURLOPT_CONNECTTIMEOUT (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CONNECT_TIME_T - get the time until connect
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONNECT_TIME_T,
+                           curl_off_t *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_off_t to receive the total time in microseconds from
+the start until the connection to the remote host (or proxy) was completed.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_off_t connect;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME_T, &connect);
+      if(CURLE_OK == res) {
+        printf("Time: %" CURL_FORMAT_CURL_OFF_T ".%06ld", connect / 1000000,
+               (long)(connect % 1000000));
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.61.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CONN_ID.md

@@ -0,0 +1,70 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CONN_ID
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_XFER_ID (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CONN_ID - get the ID of the last connection used by the handle
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONN_ID,
+                           curl_off_t *conn_id);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a *curl_off_t* to receive the connection identifier last
+used by the handle. Stores -1 if there was no connection used.
+
+The connection id is unique among all connections using the same
+connection cache. This is implicitly the case for all connections in the
+same multi handle.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      curl_off_t conn_id;
+      res = curl_easy_getinfo(curl, CURLINFO_CONN_ID, &conn_id);
+      if(!res) {
+        printf("Connection used: %" CURL_FORMAT_CURL_OFF_T "\n", conn_id);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 8.2.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CONTENT_LENGTH_DOWNLOAD.md

@@ -0,0 +1,70 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CONTENT_LENGTH_DOWNLOAD
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CONTENT_LENGTH_UPLOAD (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CONTENT_LENGTH_DOWNLOAD - get content-length of download
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONTENT_LENGTH_DOWNLOAD,
+                           double *content_length);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the content-length of the download. This
+is the value read from the Content-Length: field. Since 7.19.4, this returns
+-1 if the size is not known.
+
+CURLINFO_CONTENT_LENGTH_DOWNLOAD_T(3) is a newer replacement that returns a more
+sensible variable type.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* check the size */
+      double cl;
+      res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &cl);
+      if(!res) {
+        printf("Size: %.0f\n", cl);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.6.1. Deprecated since 7.55.0.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CONTENT_LENGTH_DOWNLOAD_T.md

@@ -0,0 +1,67 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CONTENT_LENGTH_DOWNLOAD_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CONTENT_LENGTH_UPLOAD_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CONTENT_LENGTH_DOWNLOAD_T - get content-length of download
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
+                           curl_off_t *content_length);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a *curl_off_t* to receive the content-length of the
+download. This is the value read from the Content-Length: field. Stores -1 if
+the size is not known.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* check the size */
+      curl_off_t cl;
+      res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, &cl);
+      if(!res) {
+        printf("Download size: %" CURL_FORMAT_CURL_OFF_T "\n", cl);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.55.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CONTENT_LENGTH_UPLOAD.md

@@ -0,0 +1,69 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CONTENT_LENGTH_UPLOAD
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CONTENT_LENGTH_DOWNLOAD_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CONTENT_LENGTH_UPLOAD - get the specified size of the upload
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONTENT_LENGTH_UPLOAD,
+                           double *content_length);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the specified size of the upload. Since
+7.19.4, this returns -1 if the size is not known.
+
+CURLINFO_CONTENT_LENGTH_UPLOAD_T(3) is a newer replacement that returns a
+more sensible variable type.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the upload */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* check the size */
+      double cl;
+      res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_UPLOAD, &cl);
+      if(!res) {
+        printf("Size: %.0f\n", cl);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.6.1. Deprecated since 7.55.0.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CONTENT_LENGTH_UPLOAD_T.md

@@ -0,0 +1,66 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CONTENT_LENGTH_UPLOAD_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CONTENT_LENGTH_DOWNLOAD_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CONTENT_LENGTH_UPLOAD_T - get the specified size of the upload
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONTENT_LENGTH_UPLOAD_T,
+                           curl_off_t *content_length);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a *curl_off_t* to receive the specified size of the
+upload. Stores -1 if the size is not known.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the upload */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* check the size */
+      curl_off_t cl;
+      res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_UPLOAD_T, &cl);
+      if(!res) {
+        printf("Upload size: %" CURL_FORMAT_CURL_OFF_T "\n", cl);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.55.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_CONTENT_TYPE.md

@@ -0,0 +1,75 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_CONTENT_TYPE
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_HEADERFUNCTION (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_header (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_CONTENT_TYPE - get Content-Type
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONTENT_TYPE, char **ct);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a char pointer to receive the content-type of the downloaded
+object. This is the value read from the Content-Type: field. If you get NULL,
+it means that the server did not send a valid Content-Type header or that the
+protocol used does not support this.
+
+The **ct** pointer is set to NULL or pointing to private memory. You MUST
+NOT free it - it gets freed when you call curl_easy_cleanup(3) on the
+corresponding CURL handle.
+
+The modern way to get this header from a response is to instead use the
+curl_easy_header(3) function.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* extract the content-type */
+      char *ct = NULL;
+      res = curl_easy_getinfo(curl, CURLINFO_CONTENT_TYPE, &ct);
+      if(!res && ct) {
+        printf("Content-Type: %s\n", ct);
+      }
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.9.4
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_COOKIELIST.md

@@ -0,0 +1,82 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_COOKIELIST
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_COOKIELIST (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_COOKIELIST - get all known cookies
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_COOKIELIST,
+                           struct curl_slist **cookies);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a 'struct curl_slist *' to receive a linked-list of all
+cookies curl knows (expired ones, too). Do not forget to call
+curl_slist_free_all(3) on the list after it has been used. If there are no
+cookies (cookies for the handle have not been enabled or simply none have been
+received) the 'struct curl_slist *' is made a NULL pointer.
+
+Since 7.43.0 cookies that were imported in the Set-Cookie format without a
+domain name are not exported by this option.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* enable the cookie engine */
+    curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
+
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* extract all known cookies */
+      struct curl_slist *cookies = NULL;
+      res = curl_easy_getinfo(curl, CURLINFO_COOKIELIST, &cookies);
+      if(!res && cookies) {
+        /* a linked list of cookies in cookie file format */
+        struct curl_slist *each = cookies;
+        while(each) {
+          printf("%s\n", each->data);
+          each = each->next;
+        }
+        /* we must free these cookies when we are done */
+        curl_slist_free_all(cookies);
+      }
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.14.1
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_EFFECTIVE_METHOD.md

@@ -0,0 +1,72 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_EFFECTIVE_METHOD
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_CUSTOMREQUEST (3)
+  - CURLOPT_FOLLOWLOCATION (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_EFFECTIVE_METHOD - get the last used HTTP method
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_EFFECTIVE_METHOD,
+                           char **methodp);
+~~~
+
+# DESCRIPTION
+
+Pass in a pointer to a char pointer and get the last used effective HTTP
+method.
+
+In cases when you have asked libcurl to follow redirects, the method may not be
+the same method the first request would use.
+
+The **methodp** pointer is NULL or points to private memory. You MUST NOT
+free - it gets freed when you call curl_easy_cleanup(3) on the
+corresponding CURL handle.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "data");
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      char *method = NULL;
+      curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_METHOD, &method);
+      if(method)
+        printf("Redirected to method: %s\n", method);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.72.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_EFFECTIVE_URL.md

@@ -0,0 +1,68 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_EFFECTIVE_URL
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_FOLLOWLOCATION (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_EFFECTIVE_URL - get the last used URL
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_EFFECTIVE_URL, char **urlp);
+~~~
+
+# DESCRIPTION
+
+Pass in a pointer to a char pointer and get the last used effective URL.
+
+In cases when you have asked libcurl to follow redirects, it may not be the same
+value you set with CURLOPT_URL(3).
+
+The **urlp** pointer is NULL or points to private memory. You MUST NOT free
+- it gets freed when you call curl_easy_cleanup(3) on the corresponding
+CURL handle.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      char *url = NULL;
+      curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
+      if(url)
+        printf("Redirect to: %s\n", url);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_FILETIME.md

@@ -0,0 +1,76 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_FILETIME
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_FILETIME (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_FILETIME - get the remote time of the retrieved document
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_FILETIME, long *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the remote time of the retrieved document
+in number of seconds since January 1 1970 in the GMT/UTC time zone. If you get
+-1, it can be because of many reasons (it might be unknown, the server might
+hide it or the server does not support the command that tells document time
+etc) and the time of the document is unknown.
+
+You must tell libcurl to collect this information before the transfer is made,
+by using the CURLOPT_FILETIME(3) option to curl_easy_setopt(3) or
+you this unconditionally gets a -1 back.
+
+Consider using CURLINFO_FILETIME_T(3) to be able to extract dates beyond
+the year 2038 on systems using 32 bit longs (Windows).
+
+# PROTOCOLS
+
+HTTP(S), FTP(S), SFTP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    /* Ask for filetime */
+    curl_easy_setopt(curl, CURLOPT_FILETIME, 1L);
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      long filetime = 0;
+      res = curl_easy_getinfo(curl, CURLINFO_FILETIME, &filetime);
+      if((CURLE_OK == res) && (filetime >= 0)) {
+        time_t file_time = (time_t)filetime;
+        printf("filetime: %s", ctime(&file_time));
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.5
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_FILETIME_T.md

@@ -0,0 +1,78 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_FILETIME
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_FILETIME (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_FILETIME_T - get the remote time of the retrieved document
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_FILETIME_T,
+                           curl_off_t *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_off_t to receive the remote time of the retrieved
+document in number of seconds since January 1 1970 in the GMT/UTC time
+zone. If you get -1, it can be because of many reasons (it might be unknown,
+the server might hide it or the server does not support the command that tells
+document time etc) and the time of the document is unknown.
+
+You must ask libcurl to collect this information before the transfer is made,
+by using the CURLOPT_FILETIME(3) option to curl_easy_setopt(3) or
+you unconditionally get a -1 back.
+
+This option is an alternative to CURLINFO_FILETIME(3) to allow systems
+with 32 bit long variables to extract dates outside of the 32bit timestamp
+range.
+
+# PROTOCOLS
+
+HTTP(S), FTP(S), SFTP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/");
+    /* Ask for filetime */
+    curl_easy_setopt(curl, CURLOPT_FILETIME, 1L);
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      curl_off_t filetime;
+      res = curl_easy_getinfo(curl, CURLINFO_FILETIME_T, &filetime);
+      if((CURLE_OK == res) && (filetime >= 0)) {
+        time_t file_time = (time_t)filetime;
+        printf("filetime: %s", ctime(&file_time));
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.59.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_FTP_ENTRY_PATH.md

@@ -0,0 +1,70 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_FTP_ENTRY_PATH
+Section: 3
+Source: libcurl
+See-also:
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_FTP_ENTRY_PATH - get entry path in FTP server
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_FTP_ENTRY_PATH, char **path);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a char pointer to receive a pointer to a string holding the
+path of the entry path. That is the initial path libcurl ended up in when
+logging on to the remote FTP server. This stores a NULL as pointer if
+something is wrong.
+
+The **path** pointer is NULL or points to private memory. You MUST NOT free
+- it gets freed when you call curl_easy_cleanup(3) on the corresponding
+CURL handle.
+
+# PROTOCOLS
+
+FTP(S) and SFTP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "ftp://example.com");
+
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* extract the entry path */
+      char *ep = NULL;
+      res = curl_easy_getinfo(curl, CURLINFO_FTP_ENTRY_PATH, &ep);
+      if(!res && ep) {
+        printf("Entry path was: %s\n", ep);
+      }
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.15.4. Works for SFTP since 7.21.4
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_HEADER_SIZE.md

@@ -0,0 +1,65 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_HEADER_SIZE
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_REQUEST_SIZE (3)
+  - CURLINFO_SIZE_DOWNLOAD (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_HEADER_SIZE - get size of retrieved headers
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_HEADER_SIZE, long *sizep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the total size of all the headers
+received. Measured in number of bytes.
+
+The total includes the size of any received headers suppressed by
+CURLOPT_SUPPRESS_CONNECT_HEADERS(3).
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long size;
+      res = curl_easy_getinfo(curl, CURLINFO_HEADER_SIZE, &size);
+      if(!res)
+        printf("Header size: %ld bytes\n", size);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4.1
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_HTTPAUTH_AVAIL.md

@@ -0,0 +1,77 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_HTTPAUTH_AVAIL
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_PROXYAUTH_AVAIL (3)
+  - CURLOPT_HTTPAUTH (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_HTTPAUTH_AVAIL - get available HTTP authentication methods
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_HTTPAUTH_AVAIL, long *authp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive a bitmask indicating the authentication
+method(s) available according to the previous response. The meaning of the
+bits is explained in the CURLOPT_HTTPAUTH(3) option for
+curl_easy_setopt(3).
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* extract the available authentication types */
+      long auth;
+      res = curl_easy_getinfo(curl, CURLINFO_HTTPAUTH_AVAIL, &auth);
+      if(!res) {
+        if(!auth)
+          printf("No auth available, perhaps no 401?\n");
+        else {
+          printf("%s%s%s%s\n",
+                 auth & CURLAUTH_BASIC ? "Basic ":"",
+                 auth & CURLAUTH_DIGEST ? "Digest ":"",
+                 auth & CURLAUTH_NEGOTIATE ? "Negotiate ":"",
+                 auth % CURLAUTH_NTLM ? "NTLM ":"");
+        }
+      }
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added RFC 2617 in 7.10.8
+Added RFC 7616 in 7.57.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_HTTP_CONNECTCODE.md

@@ -0,0 +1,65 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_HTTP_CONNECTCODE
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_RESPONSE_CODE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_HTTP_CONNECTCODE - get the CONNECT response code
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_HTTP_CONNECTCODE, long *p);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the last received HTTP proxy response code
+to a CONNECT request. The returned value is zero if no such response code was
+available.
+
+# PROTOCOLS
+
+HTTP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* typically CONNECT is used to do HTTPS over HTTP proxies */
+    curl_easy_setopt(curl, CURLOPT_PROXY, "http://127.0.0.1");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long code;
+      res = curl_easy_getinfo(curl, CURLINFO_HTTP_CONNECTCODE, &code);
+      if(!res && code)
+        printf("The CONNECT response code: %03ld\n", code);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.10.7
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_HTTP_VERSION.md

@@ -0,0 +1,61 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_HTTP_VERSION
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_RESPONSE_CODE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_HTTP_VERSION - get the http version used in the connection
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_HTTP_VERSION, long *p);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the version used in the last http
+connection done using this handle. The returned value is
+CURL_HTTP_VERSION_1_0, CURL_HTTP_VERSION_1_1, CURL_HTTP_VERSION_2_0,
+CURL_HTTP_VERSION_3 or 0 if the version cannot be determined.
+
+# PROTOCOLS
+
+HTTP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long http_version;
+      curl_easy_getinfo(curl, CURLINFO_HTTP_VERSION, &http_version);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.50.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_LASTSOCKET.md

@@ -0,0 +1,77 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_LASTSOCKET
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_ACTIVESOCKET (3)
+  - CURLOPT_CONNECT_ONLY (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_LASTSOCKET - get the last socket used
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_LASTSOCKET, long *socket);
+~~~
+
+# DESCRIPTION
+
+Deprecated since 7.45.0. Use CURLINFO_ACTIVESOCKET(3) instead.
+
+Pass a pointer to a long to receive the last socket used by this curl
+session. If the socket is no longer valid, -1 is returned. When you finish
+working with the socket, you must call curl_easy_cleanup(3) as usual and
+let libcurl close the socket and cleanup other resources associated with the
+handle. This is typically used in combination with
+CURLOPT_CONNECT_ONLY(3).
+
+NOTE: this API is deprecated since it is not working on win64 where the SOCKET
+type is 64 bits large while its 'long' is 32 bits. Use the
+CURLINFO_ACTIVESOCKET(3) instead, if possible.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    long sockfd; /* does not work on win64! */
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Do not do the transfer - only connect to host */
+    curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 1L);
+    res = curl_easy_perform(curl);
+
+    /* Extract the socket from the curl handle */
+    res = curl_easy_getinfo(curl, CURLINFO_LASTSOCKET, &sockfd);
+
+    if(res != CURLE_OK) {
+      printf("Error: %s\n", curl_easy_strerror(res));
+      return 1;
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.15.2
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_LOCAL_IP.md

@@ -0,0 +1,72 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_LOCAL_IP
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_LOCAL_PORT (3)
+  - CURLINFO_PRIMARY_IP (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_LOCAL_IP - get local IP address of last connection
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_LOCAL_IP, char **ip);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a char pointer to receive the pointer to a null-terminated
+string holding the IP address of the local end of most recent connection done
+with this **curl** handle. This string may be IPv6 when that is
+enabled. Note that you get a pointer to a memory area that is reused at next
+request so you need to copy the string if you want to keep the information.
+
+The **ip** pointer is NULL or points to private memory. You MUST NOT free -
+it gets freed when you call curl_easy_cleanup(3) on the corresponding
+CURL handle.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  char *ip;
+  CURLcode res;
+  CURL *curl = curl_easy_init();
+
+  curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+  /* Perform the transfer */
+  res = curl_easy_perform(curl);
+  /* Check for errors */
+  if((res == CURLE_OK) &&
+     !curl_easy_getinfo(curl, CURLINFO_LOCAL_IP, &ip) && ip) {
+    printf("Local IP: %s\n", ip);
+  }
+
+  /* always cleanup */
+  curl_easy_cleanup(curl);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.21.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_LOCAL_PORT.md

@@ -0,0 +1,68 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_LOCAL_PORT
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_LOCAL_IP (3)
+  - CURLINFO_PRIMARY_PORT (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_LOCAL_PORT - get the latest local port number
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_LOCAL_PORT, long *portp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the local port number of the most recent
+connection done with this **curl** handle.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl;
+  CURLcode res;
+
+  curl = curl_easy_init();
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/");
+    res = curl_easy_perform(curl);
+
+    if(CURLE_OK == res) {
+      long port;
+      res = curl_easy_getinfo(curl, CURLINFO_LOCAL_PORT, &port);
+
+      if(CURLE_OK == res) {
+        printf("We used local port: %ld\n", port);
+      }
+    }
+    curl_easy_cleanup(curl);
+  }
+  return 0;
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.21.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_NAMELOOKUP_TIME.md

@@ -0,0 +1,68 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_NAMELOOKUP_TIME
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_NAMELOOKUP_TIME_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_NAMELOOKUP_TIME - get the name lookup time
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_NAMELOOKUP_TIME,
+                           double *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the total time in seconds from the start
+until the name resolving was completed.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    double namelookup;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_NAMELOOKUP_TIME, &namelookup);
+      if(CURLE_OK == res) {
+        printf("Time: %.1f", namelookup);
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4.1
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_NAMELOOKUP_TIME_T.md

@@ -0,0 +1,69 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_NAMELOOKUP_TIME_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_NAMELOOKUP_TIME (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_NAMELOOKUP_TIME_T - get the name lookup time in microseconds
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_NAMELOOKUP_TIME_T,
+                           curl_off_t *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_off_t to receive the total time in microseconds
+from the start until the name resolving was completed.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_off_t namelookup;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_NAMELOOKUP_TIME_T, &namelookup);
+      if(CURLE_OK == res) {
+        printf("Time: %" CURL_FORMAT_CURL_OFF_T ".%06ld", namelookup / 1000000,
+               (long)(namelookup % 1000000));
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.61.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_NUM_CONNECTS.md

@@ -0,0 +1,65 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_NUM_CONNECTS
+Section: 3
+Source: libcurl
+See-also:
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_NUM_CONNECTS - get number of created connections
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_NUM_CONNECTS, long *nump);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive how many new connections libcurl had to
+create to achieve the previous transfer (only the successful connects are
+counted). Combined with CURLINFO_REDIRECT_COUNT(3) you are able to know how
+many times libcurl successfully reused existing connection(s) or not. See the
+connection options of curl_easy_setopt(3) to see how libcurl tries to make
+persistent connections to save time.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long connects;
+      res = curl_easy_getinfo(curl, CURLINFO_NUM_CONNECTS, &connects);
+      if(res)
+        printf("It needed %ld connects\n", connects);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.12.3
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_OS_ERRNO.md

@@ -0,0 +1,62 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_OS_ERRNO
+Section: 3
+Source: libcurl
+See-also:
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_OS_ERRNO - get errno number from last connect failure
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_OS_ERRNO, long *errnop);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the errno variable from a connect failure.
+Note that the value is only set on failure, it is not reset upon a successful
+operation. The number is OS and system specific.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res != CURLE_OK) {
+      long error;
+      res = curl_easy_getinfo(curl, CURLINFO_OS_ERRNO, &error);
+      if(res && error) {
+        printf("Errno: %ld\n", error);
+      }
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.12.2
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_PRETRANSFER_TIME.md

@@ -0,0 +1,73 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_PRETRANSFER_TIME
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CONNECT_TIME_T (3)
+  - CURLINFO_PRETRANSFER_TIME_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_PRETRANSFER_TIME - get the time until the file transfer start
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PRETRANSFER_TIME,
+                           double *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the time, in seconds, it took from the
+start until the file transfer is just about to begin.
+
+This time-stamp includes all pre-transfer commands and negotiations that are
+specific to the particular protocol(s) involved. It includes the sending of
+the protocol-specific instructions that trigger a transfer.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    double pretransfer;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_PRETRANSFER_TIME, &pretransfer);
+      if(CURLE_OK == res) {
+        printf("Time: %.1f", pretransfer);
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4.1
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_PRETRANSFER_TIME_T.md

@@ -0,0 +1,75 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_PRETRANSFER_TIME_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CONNECT_TIME (3)
+  - CURLINFO_PRETRANSFER_TIME_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_PRETRANSFER_TIME_T - get the time until the file transfer start
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PRETRANSFER_TIME_T,
+                           curl_off_t *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_off_t to receive the time, in microseconds, it took
+from the start until the file transfer is just about to begin.
+
+This time-stamp includes all pre-transfer commands and negotiations that are
+specific to the particular protocol(s) involved. It includes the sending of
+the protocol-specific instructions that trigger a transfer.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_off_t pretransfer;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_PRETRANSFER_TIME_T, &pretransfer);
+      if(CURLE_OK == res) {
+        printf("Time: %" CURL_FORMAT_CURL_OFF_T ".%06ld\n",
+               pretransfer / 1000000,
+               (long)(pretransfer % 1000000));
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.61.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_PRIMARY_IP.md

@@ -0,0 +1,73 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_PRIMARY_IP
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_LOCAL_IP (3)
+  - CURLINFO_LOCAL_PORT (3)
+  - CURLINFO_PRIMARY_PORT (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_PRIMARY_IP - get IP address of last connection
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PRIMARY_IP, char **ip);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a char pointer to receive the pointer to a null-terminated
+string holding the IP address of the most recent connection done with this
+**curl** handle. This string may be IPv6 when that is enabled. Note that you
+get a pointer to a memory area that is reused at next request so you need to
+copy the string if you want to keep the information.
+
+The **ip** pointer is NULL or points to private memory. You MUST NOT free -
+it gets freed when you call curl_easy_cleanup(3) on the corresponding
+CURL handle.
+
+# PROTOCOLS
+
+All network based ones
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  char *ip;
+  CURLcode res;
+  CURL *curl = curl_easy_init();
+
+  curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+  /* Perform the transfer */
+  res = curl_easy_perform(curl);
+  /* Check for errors */
+  if((res == CURLE_OK) &&
+     !curl_easy_getinfo(curl, CURLINFO_PRIMARY_IP, &ip) && ip) {
+    printf("IP: %s\n", ip);
+  }
+
+  /* always cleanup */
+  curl_easy_cleanup(curl);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.19.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_PRIMARY_PORT.md

@@ -0,0 +1,67 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_PRIMARY_PORT
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_LOCAL_PORT (3)
+  - CURLINFO_PRIMARY_IP (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_PRIMARY_PORT - get the latest destination port number
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PRIMARY_PORT, long *portp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the destination port of the most recent
+connection done with this **curl** handle.
+
+This is the destination port of the actual TCP or UDP connection libcurl used.
+If a proxy was used for the most recent transfer, this is the port number of
+the proxy, if no proxy was used it is the port number of the most recently
+accessed URL.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long port;
+      res = curl_easy_getinfo(curl, CURLINFO_PRIMARY_PORT, &port);
+      if(!res)
+        printf("Connected to remote port: %ld\n", port);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.21.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_PRIVATE.md

@@ -0,0 +1,68 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_PRIVATE
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_PRIVATE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_PRIVATE - get the private pointer
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PRIVATE, char **private);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a char pointer to receive the pointer to the private data
+associated with the curl handle (set with the CURLOPT_PRIVATE(3)).
+Please note that for internal reasons, the value is returned as a char
+pointer, although effectively being a 'void *'.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    void *pointer = (void *)0x2345454;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/foo.bin");
+
+    /* set the private pointer */
+    curl_easy_setopt(curl, CURLOPT_PRIVATE, pointer);
+    res = curl_easy_perform(curl);
+
+    /* extract the private pointer again */
+    res = curl_easy_getinfo(curl, CURLINFO_PRIVATE, &pointer);
+
+    if(res)
+      printf("error: %s\n", curl_easy_strerror(res));
+
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.10.3
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_PROTOCOL.md

@@ -0,0 +1,73 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_PROTOCOL
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_RESPONSE_CODE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_PROTOCOL - get the protocol used in the connection
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PROTOCOL, long *p);
+~~~
+
+# DESCRIPTION
+
+This option is deprecated. We strongly recommend using
+CURLINFO_SCHEME(3) instead, because this option cannot return all
+possible protocols!
+
+Pass a pointer to a long to receive the version used in the last http
+connection. The returned value is set to one of the CURLPROTO_* values:
+
+~~~c
+CURLPROTO_DICT, CURLPROTO_FILE, CURLPROTO_FTP, CURLPROTO_FTPS,
+CURLPROTO_GOPHER, CURLPROTO_HTTP, CURLPROTO_HTTPS, CURLPROTO_IMAP,
+CURLPROTO_IMAPS, CURLPROTO_LDAP, CURLPROTO_LDAPS, CURLPROTO_POP3,
+CURLPROTO_POP3S, CURLPROTO_RTMP, CURLPROTO_RTMPE, CURLPROTO_RTMPS,
+CURLPROTO_RTMPT, CURLPROTO_RTMPTE, CURLPROTO_RTMPTS, CURLPROTO_RTSP,
+CURLPROTO_SCP, CURLPROTO_SFTP, CURLPROTO_SMB, CURLPROTO_SMBS, CURLPROTO_SMTP,
+CURLPROTO_SMTPS, CURLPROTO_TELNET, CURLPROTO_TFTP, CURLPROTO_MQTT
+~~~
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long protocol;
+      curl_easy_getinfo(curl, CURLINFO_PROTOCOL, &protocol);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.52.0. Deprecated since 7.85.0.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_PROXYAUTH_AVAIL.md

@@ -0,0 +1,78 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_PROXYAUTH_AVAIL
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_HTTPAUTH_AVAIL (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_PROXYAUTH_AVAIL - get available HTTP proxy authentication methods
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PROXYAUTH_AVAIL,
+                           long *authp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive a bitmask indicating the authentication
+method(s) available according to the previous response. The meaning of the
+bits is explained in the CURLOPT_PROXYAUTH(3) option for
+curl_easy_setopt(3).
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    curl_easy_setopt(curl, CURLOPT_PROXY, "http://127.0.0.1:80");
+
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* extract the available proxy authentication types */
+      long auth;
+      res = curl_easy_getinfo(curl, CURLINFO_PROXYAUTH_AVAIL, &auth);
+      if(!res) {
+        if(!auth)
+          printf("No proxy auth available, perhaps no 407?\n");
+        else {
+          printf("%s%s%s%s\n",
+                 auth & CURLAUTH_BASIC ? "Basic ":"",
+                 auth & CURLAUTH_DIGEST ? "Digest ":"",
+                 auth & CURLAUTH_NEGOTIATE ? "Negotiate ":"",
+                 auth % CURLAUTH_NTLM ? "NTLM ":"");
+        }
+      }
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added RFC 2617 in 7.10.8
+Added RFC 7616 in 7.57.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_PROXY_ERROR.md

@@ -0,0 +1,105 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_PROXY_ERROR
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_RESPONSE_CODE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+  - libcurl-errors (3)
+---
+
+# NAME
+
+CURLINFO_PROXY_ERROR - get the detailed (SOCKS) proxy error
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+typedef enum {
+  CURLPX_OK,
+  CURLPX_BAD_ADDRESS_TYPE,
+  CURLPX_BAD_VERSION,
+  CURLPX_CLOSED,
+  CURLPX_GSSAPI,
+  CURLPX_GSSAPI_PERMSG,
+  CURLPX_GSSAPI_PROTECTION,
+  CURLPX_IDENTD,
+  CURLPX_IDENTD_DIFFER,
+  CURLPX_LONG_HOSTNAME,
+  CURLPX_LONG_PASSWD,
+  CURLPX_LONG_USER,
+  CURLPX_NO_AUTH,
+  CURLPX_RECV_ADDRESS,
+  CURLPX_RECV_AUTH,
+  CURLPX_RECV_CONNECT,
+  CURLPX_RECV_REQACK,
+  CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED,
+  CURLPX_REPLY_COMMAND_NOT_SUPPORTED,
+  CURLPX_REPLY_CONNECTION_REFUSED,
+  CURLPX_REPLY_GENERAL_SERVER_FAILURE,
+  CURLPX_REPLY_HOST_UNREACHABLE,
+  CURLPX_REPLY_NETWORK_UNREACHABLE,
+  CURLPX_REPLY_NOT_ALLOWED,
+  CURLPX_REPLY_TTL_EXPIRED,
+  CURLPX_REPLY_UNASSIGNED,
+  CURLPX_REQUEST_FAILED,
+  CURLPX_RESOLVE_HOST,
+  CURLPX_SEND_AUTH,
+  CURLPX_SEND_CONNECT,
+  CURLPX_SEND_REQUEST,
+  CURLPX_UNKNOWN_FAIL,
+  CURLPX_UNKNOWN_MODE,
+  CURLPX_USER_REJECTED,
+  CURLPX_LAST /* never use */
+} CURLproxycode;
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PROXY_ERROR, long *detail);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive a detailed error code when the most recent
+transfer returned a **CURLE_PROXY** error. That error code matches the
+**CURLproxycode** set.
+
+The error code is zero (**CURLPX_OK**) if no response code was available.
+
+# PROTOCOLS
+
+All that can be done over SOCKS
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    curl_easy_setopt(curl, CURLOPT_PROXY, "socks5://127.0.0.1");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_PROXY) {
+      long proxycode;
+      res = curl_easy_getinfo(curl, CURLINFO_PROXY_ERROR, &proxycode);
+      if(!res && proxycode)
+        printf("The detailed proxy error: %ld\n", proxycode);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.73.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_PROXY_SSL_VERIFYRESULT.md

@@ -0,0 +1,64 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_PROXY_SSL_VERIFYRESULT
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_SSL_VERIFYRESULT (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_PROXY_SSL_VERIFYRESULT - get the result of the proxy certificate verification
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PROXY_SSL_VERIFYRESULT,
+                           long *result);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the result of the certificate verification
+that was requested (using the CURLOPT_PROXY_SSL_VERIFYPEER(3)
+option. This is only used for HTTPS proxies.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    long verifyresult;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    curl_easy_setopt(curl, CURLOPT_PROXY, "https://proxy:443");
+    res = curl_easy_perform(curl);
+    if(res)
+      printf("error: %s\n", curl_easy_strerror(res));
+    curl_easy_getinfo(curl, CURLINFO_PROXY_SSL_VERIFYRESULT, &verifyresult);
+    printf("The peer verification said %s\n", verifyresult?
+           "fine" : "bad");
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.52.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_QUEUE_TIME_T.md

@@ -0,0 +1,70 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_QUEUE_TIME_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_STARTTRANSFER_TIME_T (3)
+  - CURLOPT_TIMEOUT (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_QUEUE_TIME_T - time this transfer was queued
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_QUEUE_TIME_T,
+                           curl_off_t *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_off_t to receive the time, in microseconds, this
+transfer was held in a waiting queue before it started "for real". A transfer
+might be put in a queue if after getting started, it cannot create a new
+connection etc due to set conditions and limits imposed by the application.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_off_t queue;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_QUEUE_TIME_T, &queue);
+      if(CURLE_OK == res) {
+        printf("Queued: %" CURL_FORMAT_CURL_OFF_T ".%06ld us", queue / 1000000,
+               (long)(queue % 1000000));
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 8.6.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_REDIRECT_COUNT.md

@@ -0,0 +1,62 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_REDIRECT_COUNT
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_REDIRECT_URL (3)
+  - CURLOPT_FOLLOWLOCATION (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_REDIRECT_COUNT - get the number of redirects
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REDIRECT_COUNT,
+                           long *countp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the total number of redirections that were
+actually followed.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long redirects;
+      curl_easy_getinfo(curl, CURLINFO_REDIRECT_COUNT, &redirects);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.9.7
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_REDIRECT_TIME.md

@@ -0,0 +1,70 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_REDIRECT_TIME
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_REDIRECT_COUNT (3)
+  - CURLINFO_REDIRECT_TIME_T (3)
+  - CURLINFO_REDIRECT_URL (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_REDIRECT_TIME - get the time for all redirection steps
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REDIRECT_TIME,
+                           double *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the total time, in seconds, it took for
+all redirection steps include name lookup, connect, pretransfer and transfer
+before final transaction was started. CURLINFO_REDIRECT_TIME(3) contains
+the complete execution time for multiple redirections.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    double redirect;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_REDIRECT_TIME, &redirect);
+      if(CURLE_OK == res) {
+        printf("Time: %.1f", redirect);
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.9.7
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_REDIRECT_TIME_T.md

@@ -0,0 +1,72 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_REDIRECT_TIME_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_REDIRECT_COUNT (3)
+  - CURLINFO_REDIRECT_TIME (3)
+  - CURLINFO_REDIRECT_URL (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_REDIRECT_TIME_T - get the time for all redirection steps
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REDIRECT_TIME_T,
+                           curl_off_t *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_off_t to receive the total time, in microseconds, it
+took for all redirection steps include name lookup, connect, pretransfer and
+transfer before final transaction was started.
+CURLINFO_REDIRECT_TIME_T(3) holds the complete execution time for
+multiple redirections.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_off_t redirect;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_REDIRECT_TIME_T, &redirect);
+      if(CURLE_OK == res) {
+        printf("Time: %" CURL_FORMAT_CURL_OFF_T ".%06ld", redirect / 1000000,
+               (long)(redirect % 1000000));
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.61.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_REDIRECT_URL.md

@@ -0,0 +1,69 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_REDIRECT_URL
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_REDIRECT_COUNT (3)
+  - CURLINFO_REDIRECT_TIME_T (3)
+  - CURLOPT_FOLLOWLOCATION (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_REDIRECT_URL - get the URL a redirect would go to
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REDIRECT_URL, char **urlp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a char pointer to receive the URL a redirect *would*
+take you to if you would enable CURLOPT_FOLLOWLOCATION(3). This can come
+handy if you think using the built-in libcurl redirect logic is not good enough
+for you but you would still prefer to avoid implementing all the magic of
+figuring out the new URL.
+
+This URL is also set if the CURLOPT_MAXREDIRS(3) limit prevented a
+redirect to happen (since 7.54.1).
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      char *url = NULL;
+      curl_easy_getinfo(curl, CURLINFO_REDIRECT_URL, &url);
+      if(url)
+        printf("Redirect to: %s\n", url);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.18.2
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_REFERER.md

@@ -0,0 +1,67 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_REFERER
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_REFERER (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_header (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_REFERER - get the used referrer request header
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REFERER, char **hdrp);
+~~~
+
+# DESCRIPTION
+
+Pass in a pointer to a char pointer and get the referrer header used in the
+most recent request.
+
+The **hdrp** pointer is NULL or points to private memory you MUST NOT free -
+it gets freed when you call curl_easy_cleanup(3) on the corresponding
+CURL handle.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    curl_easy_setopt(curl, CURLOPT_REFERER, "https://example.org/referrer");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      char *hdr = NULL;
+      curl_easy_getinfo(curl, CURLINFO_REFERER, &hdr);
+      if(hdr)
+        printf("Referrer header: %s\n", hdr);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.76.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_REQUEST_SIZE.md

@@ -0,0 +1,63 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_REQUEST_SIZE
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_HEADER_SIZE (3)
+  - CURLINFO_SIZE_DOWNLOAD_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_REQUEST_SIZE - get size of sent request
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REQUEST_SIZE, long *sizep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the total size of the issued
+requests. This is so far only for HTTP requests. Note that this may be more
+than one request if CURLOPT_FOLLOWLOCATION(3) is enabled.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long req;
+      res = curl_easy_getinfo(curl, CURLINFO_REQUEST_SIZE, &req);
+      if(!res)
+        printf("Request size: %ld bytes\n", req);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4.1
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_RESPONSE_CODE.md

@@ -0,0 +1,65 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_RESPONSE_CODE
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_HTTP_CONNECTCODE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_RESPONSE_CODE - get the last response code
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RESPONSE_CODE, long *codep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the last received HTTP, FTP, SMTP or LDAP
+(OpenLDAP only) response code. This option was previously known as
+CURLINFO_HTTP_CODE in libcurl 7.10.7 and earlier. The stored value is zero if
+no server response code has been received.
+
+Note that a proxy's CONNECT response should be read with
+CURLINFO_HTTP_CONNECTCODE(3) and not this.
+
+# PROTOCOLS
+
+HTTP, FTP, SMTP and LDAP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long response_code;
+      curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.10.8. CURLINFO_HTTP_CODE was added in 7.4.1.
+Support for SMTP responses added in 7.25.0, for OpenLDAP in 7.81.0.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_RETRY_AFTER.md

@@ -0,0 +1,71 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_RETRY_AFTER
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_HEADERFUNCTION (3)
+  - CURLOPT_STDERR (3)
+  - curl_easy_header (3)
+---
+
+# NAME
+
+CURLINFO_RETRY_AFTER - returns the Retry-After retry delay
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RETRY_AFTER,
+                           curl_off_t *retry);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_off_t variable to receive the number of seconds the
+HTTP server suggests the client should wait until the next request is
+issued. The information from the "Retry-After:" header.
+
+While the HTTP header might contain a fixed date string, the
+CURLINFO_RETRY_AFTER(3) always returns the number of seconds to wait -
+or zero if there was no header or the header could not be parsed.
+
+# DEFAULT
+
+Returns zero delay if there was no header.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      curl_off_t wait = 0;
+      curl_easy_getinfo(curl, CURLINFO_RETRY_AFTER, &wait);
+      if(wait)
+        printf("Wait for %" CURL_FORMAT_CURL_OFF_T " seconds\n", wait);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.66.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_RTSP_CLIENT_CSEQ.md

@@ -0,0 +1,61 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_RTSP_CLIENT_CSEQ
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_RTSP_CSEQ_RECV (3)
+  - CURLINFO_RTSP_SERVER_CSEQ (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_RTSP_CLIENT_CSEQ - get the next RTSP client CSeq
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RTSP_CLIENT_CSEQ,
+                           long *cseq);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the next CSeq that is expected to be used
+by the application.
+
+# PROTOCOLS
+
+RTSP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "rtsp://rtsp.example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long cseq;
+      curl_easy_getinfo(curl, CURLINFO_RTSP_CLIENT_CSEQ, &cseq);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.20.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_RTSP_CSEQ_RECV.md

@@ -0,0 +1,61 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_RTSP_CSEQ_RECV
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_RTSP_SERVER_CSEQ (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_RTSP_CSEQ_RECV - get the recently received CSeq
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RTSP_CSEQ_RECV, long *cseq);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the most recently received CSeq from the
+server. If your application encounters a *CURLE_RTSP_CSEQ_ERROR* then you
+may wish to troubleshoot and/or fix the CSeq mismatch by peeking at this
+value.
+
+# PROTOCOLS
+
+RTSP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "rtsp://rtsp.example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long cseq;
+      curl_easy_getinfo(curl, CURLINFO_RTSP_CSEQ_RECV, &cseq);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.20.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_RTSP_SERVER_CSEQ.md

@@ -0,0 +1,65 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_RTSP_SERVER_CSEQ
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_RTSP_CSEQ_RECV (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_RTSP_SERVER_CSEQ - get the next RTSP server CSeq
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RTSP_SERVER_CSEQ,
+                           long *cseq);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the next CSeq that is expected to be used
+by the application.
+
+Listening for server initiated requests is not implemented!
+
+Applications wishing to resume an RTSP session on another connection should
+retrieve this info before closing the active connection.
+
+# PROTOCOLS
+
+RTSP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "rtsp://rtsp.example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      long cseq;
+      curl_easy_getinfo(curl, CURLINFO_RTSP_SERVER_CSEQ, &cseq);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.20.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_RTSP_SESSION_ID.md

@@ -0,0 +1,66 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_RTSP_SESSION_ID
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_RTSP_CSEQ_RECV (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_RTSP_SESSION_ID - get RTSP session ID
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RTSP_SESSION_ID, char **id);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a char pointer to receive a pointer to a string holding the
+most recent RTSP Session ID.
+
+Applications wishing to resume an RTSP session on another connection should
+retrieve this info before closing the active connection.
+
+The **id** pointer is NULL or points to private memory. You MUST NOT free -
+it gets freed when you call curl_easy_cleanup(3) on the corresponding
+CURL handle.
+
+# PROTOCOLS
+
+RTSP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "rtsp://rtsp.example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      char *id;
+      curl_easy_getinfo(curl, CURLINFO_RTSP_SESSION_ID, &id);
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.20.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SCHEME.md

@@ -0,0 +1,68 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SCHEME
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_EFFECTIVE_URL (3)
+  - CURLINFO_PROTOCOL (3)
+  - CURLINFO_RESPONSE_CODE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SCHEME - get the URL scheme (sometimes called protocol) used in the connection
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SCHEME, char **scheme);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a char pointer to receive the pointer to a null-terminated
+string holding the URL scheme used for the most recent connection done with
+this CURL **handle**.
+
+The **scheme** pointer is NULL or points to private memory. You MUST NOT
+free - it gets freed when you call curl_easy_cleanup(3) on the
+corresponding CURL handle.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res == CURLE_OK) {
+      char *scheme = NULL;
+      curl_easy_getinfo(curl, CURLINFO_SCHEME, &scheme);
+      if(scheme)
+        printf("scheme: %s\n", scheme); /* scheme: HTTP */
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.52.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SIZE_DOWNLOAD.md

@@ -0,0 +1,73 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SIZE_DOWNLOAD
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_SIZE_DOWNLOAD_T (3)
+  - CURLINFO_SIZE_UPLOAD_T (3)
+  - CURLOPT_MAXFILESIZE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SIZE_DOWNLOAD - get the number of downloaded bytes
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SIZE_DOWNLOAD, double *dlp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the total amount of bytes that were
+downloaded. The amount is only for the latest transfer and gets reset again
+for each new transfer. This counts actual payload data, what's also commonly
+called body. All meta and header data is excluded and not included in this
+number.
+
+CURLINFO_SIZE_DOWNLOAD_T(3) is a newer replacement that returns a more
+sensible variable type.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* check the size */
+      double dl;
+      res = curl_easy_getinfo(curl, CURLINFO_SIZE_DOWNLOAD, &dl);
+      if(!res) {
+        printf("Downloaded %.0f bytes\n", dl);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4.1. Deprecated since 7.55.0.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SIZE_DOWNLOAD_T.md

@@ -0,0 +1,70 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SIZE_DOWNLOAD_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_SIZE_DOWNLOAD (3)
+  - CURLINFO_SIZE_UPLOAD_T (3)
+  - CURLOPT_MAXFILESIZE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SIZE_DOWNLOAD_T - get the number of downloaded bytes
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SIZE_DOWNLOAD_T,
+                           curl_off_t *dlp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a *curl_off_t* to receive the total amount of bytes that
+were downloaded. The amount is only for the latest transfer and gets reset
+again for each new transfer. This counts actual payload data, what's also
+commonly called body. All meta and header data is excluded from this amount.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* check the size */
+      curl_off_t dl;
+      res = curl_easy_getinfo(curl, CURLINFO_SIZE_DOWNLOAD_T, &dl);
+      if(!res) {
+        printf("Downloaded %" CURL_FORMAT_CURL_OFF_T " bytes\n", dl);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.55.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SIZE_UPLOAD.md

@@ -0,0 +1,69 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SIZE_UPLOAD
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_SIZE_DOWNLOAD_T (3)
+  - CURLINFO_SIZE_UPLOAD_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SIZE_UPLOAD - get the number of uploaded bytes
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SIZE_UPLOAD,
+                           double *uploadp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the total amount of bytes that were
+uploaded.
+
+CURLINFO_SIZE_UPLOAD_T(3) is a newer replacement that returns a more
+sensible variable type.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      double ul;
+      res = curl_easy_getinfo(curl, CURLINFO_SIZE_UPLOAD, &ul);
+      if(!res) {
+        printf("Uploaded %.0f bytes\n", ul);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4.1. Deprecated since 7.55.0.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SIZE_UPLOAD_T.md

@@ -0,0 +1,66 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SIZE_UPLOAD_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_SIZE_DOWNLOAD_T (3)
+  - CURLINFO_SIZE_UPLOAD (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SIZE_UPLOAD_T - get the number of uploaded bytes
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SIZE_UPLOAD_T,
+                           curl_off_t *uploadp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a *curl_off_t* to receive the total amount of bytes that
+were uploaded.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      curl_off_t ul;
+      res = curl_easy_getinfo(curl, CURLINFO_SIZE_UPLOAD_T, &ul);
+      if(!res) {
+        printf("Uploaded %" CURL_FORMAT_CURL_OFF_T " bytes\n", ul);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.55.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SPEED_DOWNLOAD.md

@@ -0,0 +1,67 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SPEED_DOWNLOAD
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_SIZE_UPLOAD_T (3)
+  - CURLINFO_SPEED_UPLOAD (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SPEED_DOWNLOAD - get download speed
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SPEED_DOWNLOAD,
+                           double *speed);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the average download speed that curl
+measured for the complete download. Measured in bytes/second.
+
+CURLINFO_SPEED_DOWNLOAD_T(3) is a newer replacement that returns a more
+sensible variable type.
+
+# PROTOCOLS
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      double speed;
+      res = curl_easy_getinfo(curl, CURLINFO_SPEED_DOWNLOAD, &speed);
+      if(!res) {
+        printf("Download speed %.0f bytes/sec\n", speed);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4.1. Deprecated since 7.55.0.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SPEED_DOWNLOAD_T.md

@@ -0,0 +1,65 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SPEED_DOWNLOAD_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_SIZE_UPLOAD_T (3)
+  - CURLINFO_SPEED_UPLOAD_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SPEED_DOWNLOAD_T - get download speed
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SPEED_DOWNLOAD_T,
+                           curl_off_t *speed);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a *curl_off_t* to receive the average download speed
+that curl measured for the complete download. Measured in bytes/second.
+
+# PROTOCOLS
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      curl_off_t speed;
+      res = curl_easy_getinfo(curl, CURLINFO_SPEED_DOWNLOAD_T, &speed);
+      if(!res) {
+        printf("Download speed %" CURL_FORMAT_CURL_OFF_T " bytes/sec\n",
+               speed);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.55.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SPEED_UPLOAD.md

@@ -0,0 +1,65 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SPEED_UPLOAD
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_SPEED_DOWNLOAD_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SPEED_UPLOAD - get upload speed
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SPEED_UPLOAD, double *speed);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the average upload speed that curl
+measured for the complete upload. Measured in bytes/second.
+
+CURLINFO_SPEED_UPLOAD_T(3) is a newer replacement that returns a more
+sensible variable type.
+
+# PROTOCOLS
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      double speed;
+      res = curl_easy_getinfo(curl, CURLINFO_SPEED_UPLOAD, &speed);
+      if(!res) {
+        printf("Upload speed %.0f bytes/sec\n", speed);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4.1. Deprecated since 7.55.0.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SPEED_UPLOAD_T.md

@@ -0,0 +1,63 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SPEED_UPLOAD_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_SPEED_DOWNLOAD_T (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SPEED_UPLOAD_T - get upload speed
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SPEED_UPLOAD_T,
+                           curl_off_t *speed);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a *curl_off_t* to receive the average upload speed that
+curl measured for the complete upload. Measured in bytes/second.
+
+# PROTOCOLS
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      curl_off_t speed;
+      res = curl_easy_getinfo(curl, CURLINFO_SPEED_UPLOAD_T, &speed);
+      if(!res) {
+        printf("Upload speed %" CURL_FORMAT_CURL_OFF_T " bytes/sec\n", speed);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.55.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SSL_ENGINES.md

@@ -0,0 +1,65 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SSL_ENGINES
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_SSLENGINE (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SSL_ENGINES - get an slist of OpenSSL crypto-engines
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SSL_ENGINES,
+                           struct curl_slist **engine_list);
+~~~
+
+# DESCRIPTION
+
+Pass the address of a 'struct curl_slist *' to receive a linked-list of
+OpenSSL crypto-engines supported. Note that engines are normally implemented
+in separate dynamic libraries. Hence not all the returned engines may be
+available at runtime. **NOTE:** you must call curl_slist_free_all(3)
+on the list pointer once you are done with it, as libcurl does not free this
+data for you.
+
+# PROTOCOLS
+
+All TLS based ones.
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    struct curl_slist *engines;
+    res = curl_easy_getinfo(curl, CURLINFO_SSL_ENGINES, &engines);
+    if((res == CURLE_OK) && engines) {
+      /* we have a list, free it when done using it */
+      curl_slist_free_all(engines);
+    }
+
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.12.3. Available in OpenSSL builds with "engine" support.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_SSL_VERIFYRESULT.md

@@ -0,0 +1,65 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_SSL_VERIFYRESULT
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_PROXY_SSL_VERIFYRESULT (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_SSL_VERIFYRESULT - get the result of the certificate verification
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SSL_VERIFYRESULT,
+                           long *result);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long to receive the result of the server SSL certificate
+verification that was requested (using the CURLOPT_SSL_VERIFYPEER(3)
+option).
+
+0 is a positive result. Non-zero is an error.
+
+# PROTOCOLS
+
+All using TLS
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    long verifyresult;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res)
+      printf("error: %s\n", curl_easy_strerror(res));
+    curl_easy_getinfo(curl, CURLINFO_SSL_VERIFYRESULT, &verifyresult);
+    printf("The peer verification said %s\n", verifyresult?
+           "BAAAD":"fine");
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.5. Only set by the OpenSSL/libressl/boringssl and GnuTLS backends.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_STARTTRANSFER_TIME.md

@@ -0,0 +1,71 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_STARTTRANSFER_TIME
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_STARTTRANSFER_TIME_T (3)
+  - CURLOPT_TIMEOUT (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_STARTTRANSFER_TIME - get the time until the first byte is received
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_STARTTRANSFER_TIME,
+                           double *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the time, in seconds, it took from the
+start until the first byte is received by libcurl. This includes
+CURLINFO_PRETRANSFER_TIME(3) and also the time the server needs to
+calculate the result.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    double start;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_STARTTRANSFER_TIME, &start);
+      if(CURLE_OK == res) {
+        printf("Time: %.1f", start);
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.9.2
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_STARTTRANSFER_TIME_T.md

@@ -0,0 +1,73 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_STARTTRANSFER_TIME_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_STARTTRANSFER_TIME (3)
+  - CURLOPT_TIMEOUT (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_STARTTRANSFER_TIME_T - get the time until the first byte is received
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_STARTTRANSFER_TIME_T,
+                           curl_off_t *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_off_t to receive the time, in microseconds,
+it took from the
+start until the first byte is received by libcurl. This includes
+CURLINFO_PRETRANSFER_TIME_T(3) and also the time the server needs to
+calculate the result.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_off_t start;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_STARTTRANSFER_TIME_T, &start);
+      if(CURLE_OK == res) {
+        printf("Time: %" CURL_FORMAT_CURL_OFF_T ".%06ld", start / 1000000,
+               (long)(start % 1000000));
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.61.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_TLS_SESSION.md

@@ -0,0 +1,75 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_TLS_SESSION
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_TLS_SSL_PTR (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_TLS_SESSION - get TLS session info
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_TLS_SESSION,
+                           struct curl_tlssessioninfo **session);
+~~~
+
+# DESCRIPTION
+
+**This option has been superseded** by CURLINFO_TLS_SSL_PTR(3) which
+was added in 7.48.0. The only reason you would use this option instead is if
+you could be using a version of libcurl earlier than 7.48.0.
+
+This option is exactly the same as CURLINFO_TLS_SSL_PTR(3) except in the
+case of OpenSSL. If the session *backend* is CURLSSLBACKEND_OPENSSL the
+session *internals* pointer varies depending on the option:
+
+CURLINFO_TLS_SESSION(3) OpenSSL session *internals* is **SSL_CTX ***.
+
+CURLINFO_TLS_SSL_PTR(3) OpenSSL session *internals* is **SSL ***.
+
+You can obtain an **SSL_CTX** pointer from an SSL pointer using OpenSSL
+function *SSL_get_SSL_CTX(3)*. Therefore unless you need compatibility
+with older versions of libcurl use CURLINFO_TLS_SSL_PTR(3). Refer to
+that document for more information.
+
+# PROTOCOLS
+
+All TLS-based
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    struct curl_tlssessioninfo *tls;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(res)
+      printf("error: %s\n", curl_easy_strerror(res));
+    curl_easy_getinfo(curl, CURLINFO_TLS_SESSION, &tls);
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.34.0. Deprecated since 7.48.0 and supported OpenSSL, GnuTLS, and
+NSS only up until this version was released.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_TLS_SSL_PTR.md

@@ -0,0 +1,174 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_TLS_SSL_PTR
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_TLS_SESSION (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_TLS_SESSION, CURLINFO_TLS_SSL_PTR - get TLS session info
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_TLS_SSL_PTR,
+                           struct curl_tlssessioninfo **session);
+
+/* if you need compatibility with libcurl < 7.48.0 use
+   CURLINFO_TLS_SESSION instead: */
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_TLS_SESSION,
+                           struct curl_tlssessioninfo **session);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a *struct curl_tlssessioninfo **. The pointer is initialized
+to refer to a *struct curl_tlssessioninfo ** that contains an enum indicating
+the SSL library used for the handshake and a pointer to the respective
+internal TLS session structure of this underlying SSL library.
+
+This option may be useful for example to extract certificate information in a
+format convenient for further processing, such as manual validation. Refer to
+the **LIMITATIONS** section.
+
+~~~c
+struct curl_tlssessioninfo {
+  curl_sslbackend backend;
+  void *internals;
+};
+~~~
+
+The *backend* struct member is one of the defines in the CURLSSLBACKEND_*
+series: CURLSSLBACKEND_NONE (when built without TLS support),
+CURLSSLBACKEND_WOLFSSL, CURLSSLBACKEND_SECURETRANSPORT, CURLSSLBACKEND_GNUTLS,
+CURLSSLBACKEND_MBEDTLS, CURLSSLBACKEND_NSS, CURLSSLBACKEND_OPENSSL,
+CURLSSLBACKEND_SCHANNEL or CURLSSLBACKEND_MESALINK. (Note that the OpenSSL
+forks are all reported as just OpenSSL here.)
+
+The *internals* struct member points to a TLS library specific pointer for
+the active ("in use") SSL connection, with the following underlying types:
+
+## GnuTLS
+
+**gnutls_session_t**
+
+## NSS
+
+**PRFileDesc ***
+
+## OpenSSL
+
+CURLINFO_TLS_SESSION(3): **SSL_CTX ***
+
+CURLINFO_TLS_SSL_PTR(3): **SSL ***
+Since 7.48.0 the *internals* member can point to these other SSL backends
+as well:
+
+## mbedTLS
+
+**mbedTLS_ssl_context ***
+
+## Secure Channel
+
+**CtxtHandle ***
+
+## Secure Transport
+
+**SSLContext ***
+
+## wolfSSL
+
+**SSL ***
+
+If the *internals* pointer is NULL then either the SSL backend is not
+supported, an SSL session has not yet been established or the connection is no
+longer associated with the easy handle (e.g. curl_easy_perform(3) has
+returned).
+
+# LIMITATIONS
+
+This option has some limitations that could make it unsafe when it comes to
+the manual verification of certificates.
+
+This option only retrieves the first in-use SSL session pointer for your easy
+handle, however your easy handle may have more than one in-use SSL session if
+using FTP over SSL. That is because the FTP protocol has a control channel and
+a data channel and one or both may be over SSL. Currently there is no way to
+retrieve a second in-use SSL session associated with an easy handle.
+
+This option has not been thoroughly tested with clear text protocols that can
+be upgraded/downgraded to/from SSL: FTP, SMTP, POP3, IMAP when used with
+CURLOPT_USE_SSL(3). Though you can to retrieve the SSL pointer, it is possible
+that before you can do that, data (including auth) may have already been sent
+over a connection after it was upgraded.
+
+Renegotiation. If unsafe renegotiation or renegotiation in a way that the
+certificate is allowed to change is allowed by your SSL library this may occur
+and the certificate may change, and data may continue to be sent or received
+after renegotiation but before you are able to get the (possibly) changed SSL
+pointer, with the (possibly) changed certificate information.
+
+Instead of using this option to poll for certificate changes use
+CURLOPT_SSL_CTX_FUNCTION(3) to set a verification callback, if supported.
+That is safer and does not suffer from any of the problems above.
+
+How are you using this option? Are you affected by any of these limitations?
+Please let us know by making a comment at
+https://github.com/curl/curl/issues/685
+
+# PROTOCOLS
+
+All TLS-based
+
+# EXAMPLE
+
+~~~c
+#include <curl/curl.h>
+#include <openssl/ssl.h>
+
+CURL *curl;
+static size_t wf(void *ptr, size_t size, size_t nmemb, void *stream)
+{
+  const struct curl_tlssessioninfo *info = NULL;
+  CURLcode res = curl_easy_getinfo(curl, CURLINFO_TLS_SSL_PTR, &info);
+  if(info && !res) {
+    if(CURLSSLBACKEND_OPENSSL == info->backend) {
+      printf("OpenSSL ver. %s\n", SSL_get_version((SSL*)info->internals));
+    }
+  }
+  return size * nmemb;
+}
+
+int main(int argc, char **argv)
+{
+  CURLcode res;
+  curl = curl_easy_init();
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, wf);
+    res = curl_easy_perform(curl);
+    curl_easy_cleanup(curl);
+  }
+  return res;
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.48.0.
+
+This option supersedes CURLINFO_TLS_SESSION(3) which was added in 7.34.0.
+This option is exactly the same as that option except in the case of OpenSSL.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_TOTAL_TIME.md

@@ -0,0 +1,69 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_TOTAL_TIME
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_TOTAL_TIME_T (3)
+  - CURLOPT_TIMEOUT (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_TOTAL_TIME - get total time of previous transfer
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_TOTAL_TIME, double *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a double to receive the total time in seconds for the
+previous transfer, including name resolving, TCP connect etc. The double
+represents the time in seconds, including fractions.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    double total;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME, &total);
+      if(CURLE_OK == res) {
+        printf("Time: %.1f", total);
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.4.1
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_TOTAL_TIME_T.md

@@ -0,0 +1,71 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_TOTAL_TIME_T
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_TOTAL_TIME (3)
+  - CURLOPT_TIMEOUT (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_TOTAL_TIME_T - get total time of previous transfer in microseconds
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_TOTAL_TIME_T,
+                           curl_off_t *timep);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a curl_off_t to receive the total time in microseconds
+for the previous transfer, including name resolving, TCP connect etc.
+The curl_off_t represents the time in microseconds.
+
+When a redirect is followed, the time from each request is added together.
+
+See also the TIMES overview in the curl_easy_getinfo(3) man page.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_off_t total;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+    res = curl_easy_perform(curl);
+    if(CURLE_OK == res) {
+      res = curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME_T, &total);
+      if(CURLE_OK == res) {
+        printf("Time: %" CURL_FORMAT_CURL_OFF_T ".%06ld", total / 1000000,
+               (long)(total % 1000000));
+      }
+    }
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.61.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_USED_PROXY.md

@@ -0,0 +1,69 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_USED_PROXY
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_NOPROXY (3)
+  - CURLOPT_PROXY (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_USED_PROXY - whether the transfer used a proxy
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_USED_PROXY,
+                           long *authp);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a long. It gets set to zero set if no proxy was used in the
+previous transfer or a non-zero value if a proxy was used.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(int argc, char *argv[])
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, argv[1]);
+    curl_easy_setopt(curl, CURLOPT_PROXY, "http://127.0.0.1:80");
+    curl_easy_setopt(curl, CURLOPT_NOPROXY, "example.com");
+
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      /* extract the available proxy authentication types */
+      long used;
+      res = curl_easy_getinfo(curl, CURLINFO_USED_PROXY, &used);
+      if(!res) {
+        printf("The proxy was %sused\n", used ? "": "NOT ");
+      }
+    }
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 8.7.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLINFO_XFER_ID.md

@@ -0,0 +1,70 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLINFO_XFER_ID
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_CONN_ID (3)
+  - curl_easy_getinfo (3)
+  - curl_easy_setopt (3)
+---
+
+# NAME
+
+CURLINFO_XFER_ID - get the ID of a transfer
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_XFER_ID,
+                           curl_off_t *xfer_id);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to a *curl_off_t* to receive the identifier of the
+current/last transfer done with the handle. Stores -1 if no transfer
+has been started yet for the handle.
+
+The transfer id is unique among all transfers performed using the same
+connection cache. This is implicitly the case for all transfers in the
+same multi handle.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* Perform the request */
+    res = curl_easy_perform(curl);
+
+    if(!res) {
+      curl_off_t xfer_id;
+      res = curl_easy_getinfo(curl, CURLINFO_XFER_ID, &xfer_id);
+      if(!res) {
+        printf("Transfer ID: %" CURL_FORMAT_CURL_OFF_T "\n", xfer_id);
+      }
+    }
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 8.2.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE.md

@@ -0,0 +1,61 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE (3)
+  - CURLMOPT_MAX_PIPELINE_LENGTH (3)
+  - CURLMOPT_PIPELINING (3)
+---
+
+# NAME
+
+CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE - chunk length threshold for pipelining
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE,
+                            long size);
+~~~
+
+# DESCRIPTION
+
+No function since pipelining was removed in 7.62.0.
+
+Pass a long with a **size** in bytes. If a transfer in a pipeline is
+currently processing a chunked (Transfer-encoding: chunked) request with a
+current chunk length larger than CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE(3),
+that pipeline is not considered for additional requests, even if it is shorter
+than CURLMOPT_MAX_PIPELINE_LENGTH(3).
+
+# DEFAULT
+
+The default value is 0, which means that the penalization is inactive.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURLM *m = curl_multi_init();
+  long maxchunk = 10000;
+  curl_multi_setopt(m, CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, maxchunk);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.30.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE.md

@@ -0,0 +1,60 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE (3)
+  - CURLMOPT_PIPELINING (3)
+---
+
+# NAME
+
+CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE - size threshold for pipelining penalty
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE,
+                            long size);
+~~~
+
+# DESCRIPTION
+
+No function since pipelining was removed in 7.62.0.
+
+Pass a long with a **size** in bytes. If a transfer in a pipeline is
+currently processing a request with a Content-Length larger than this
+CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE(3), that pipeline is not considered
+for additional requests, even if it is shorter than
+CURLMOPT_MAX_PIPELINE_LENGTH(3).
+
+# DEFAULT
+
+The default value is 0, which means that the size penalization is inactive.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURLM *m = curl_multi_init();
+  long maxlength = 10000;
+  curl_multi_setopt(m, CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, maxlength);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.30.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_MAXCONNECTS.md

@@ -0,0 +1,69 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_MAXCONNECTS
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_MAX_HOST_CONNECTIONS (3)
+  - CURLOPT_MAXCONNECTS (3)
+---
+
+# NAME
+
+CURLMOPT_MAXCONNECTS - size of connection cache
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_MAXCONNECTS, long max);
+~~~
+
+# DESCRIPTION
+
+Pass a long indicating the **max**. The set number is used as the maximum
+amount of simultaneously open connections that libcurl may keep in its
+connection cache after completed use. By default libcurl enlarges the size for
+each added easy handle to make it fit 4 times the number of added easy
+handles.
+
+By setting this option, you can prevent the cache size from growing beyond the
+limit set by you.
+
+When the cache is full, curl closes the oldest one in the cache to prevent the
+number of open connections from increasing.
+
+This option is for the multi handle's use only, when using the easy interface
+you should instead use the CURLOPT_MAXCONNECTS(3) option.
+
+See CURLMOPT_MAX_TOTAL_CONNECTIONS(3) for limiting the number of active
+connections.
+
+# DEFAULT
+
+See DESCRIPTION
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURLM *m = curl_multi_init();
+  /* only keep 10 connections in the cache */
+  curl_multi_setopt(m, CURLMOPT_MAXCONNECTS, 10L);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.16.3
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_MAX_CONCURRENT_STREAMS.md

@@ -0,0 +1,59 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_MAX_CONCURRENT_STREAMS
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_MAXCONNECTS (3)
+  - CURLOPT_MAXCONNECTS (3)
+---
+
+# NAME
+
+CURLMOPT_MAX_CONCURRENT_STREAMS - max concurrent streams for http2
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_MAX_CONCURRENT_STREAMS,
+                            long max);
+~~~
+
+# DESCRIPTION
+
+Pass a long indicating the **max**. The set number is used as the maximum
+number of concurrent streams libcurl should support on connections done using
+HTTP/2 or HTTP/3.
+
+Valid values range from 1 to 2147483647 (2^31 - 1) and defaults to 100. The
+value passed here would be honored based on other system resources properties.
+
+# DEFAULT
+
+100
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURLM *m = curl_multi_init();
+  /* max concurrent streams 200 */
+  curl_multi_setopt(m, CURLMOPT_MAX_CONCURRENT_STREAMS, 200L);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.67.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_MAX_HOST_CONNECTIONS.md

@@ -0,0 +1,72 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_MAX_HOST_CONNECTIONS
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_MAXCONNECTS (3)
+  - CURLMOPT_MAX_TOTAL_CONNECTIONS (3)
+---
+
+# NAME
+
+CURLMOPT_MAX_HOST_CONNECTIONS - max number of connections to a single host
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_MAX_HOST_CONNECTIONS,
+                            long max);
+~~~
+
+# DESCRIPTION
+
+Pass a long to indicate **max**. The set number is used as the maximum amount
+of simultaneously open connections to a single host (a host being the same as
+a hostname + port number pair). For each new session to a host, libcurl might
+open a new connection up to the limit set by
+CURLMOPT_MAX_HOST_CONNECTIONS(3). When the limit is reached, new sessions are
+kept pending until a connection becomes available.
+
+The default **max** value is 0, unlimited. This set limit is also used for
+proxy connections, and then the proxy is considered to be the host for which
+this limit counts.
+
+When more transfers are added to the multi handle than what can be performed
+due to the set limit, they are queued up waiting for their chance. When that
+happens, the CURLOPT_TIMEOUT_MS(3) timeout is inclusive of the waiting
+time, meaning that if you set a too narrow timeout in such a case the transfer
+might never even start before it times out.
+
+Even in the queued up situation, the CURLOPT_CONNECTTIMEOUT_MS(3)
+timeout is however treated as a per-connect timeout.
+
+# DEFAULT
+
+0
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURLM *m = curl_multi_init();
+  /* do no more than 2 connections per host */
+  curl_multi_setopt(m, CURLMOPT_MAX_HOST_CONNECTIONS, 2L);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.30.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_MAX_PIPELINE_LENGTH.md

@@ -0,0 +1,64 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_MAX_PIPELINE_LENGTH
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_MAX_HOST_CONNECTIONS (3)
+  - CURLMOPT_PIPELINING (3)
+---
+
+# NAME
+
+CURLMOPT_MAX_PIPELINE_LENGTH - maximum number of requests in a pipeline
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_MAX_PIPELINE_LENGTH,
+                            long max);
+~~~
+
+# DESCRIPTION
+
+No function since pipelining was removed in 7.62.0.
+
+Pass a long. The set **max** number is used as the maximum amount of
+outstanding requests in an HTTP/1.1 pipeline. This option is only used for
+HTTP/1.1 pipelining, not for HTTP/2 multiplexing.
+
+When this limit is reached, libcurl creates another connection to the same
+host (see CURLMOPT_MAX_HOST_CONNECTIONS(3)), or queue the request until one
+    of the pipelines to the host is ready to accept a request. Thus, the total
+number of requests in-flight is CURLMOPT_MAX_HOST_CONNECTIONS(3) *
+CURLMOPT_MAX_PIPELINE_LENGTH(3).
+
+# DEFAULT
+
+5
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURLM *m = curl_multi_init();
+  /* set a more conservative pipe length */
+  curl_multi_setopt(m, CURLMOPT_MAX_PIPELINE_LENGTH, 3L);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.30.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_MAX_TOTAL_CONNECTIONS.md

@@ -0,0 +1,70 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_MAX_TOTAL_CONNECTIONS
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_MAXCONNECTS (3)
+  - CURLMOPT_MAX_HOST_CONNECTIONS (3)
+---
+
+# NAME
+
+CURLMOPT_MAX_TOTAL_CONNECTIONS - max simultaneously open connections
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_MAX_TOTAL_CONNECTIONS,
+                            long amount);
+~~~
+
+# DESCRIPTION
+
+Pass a long for the **amount**. The set number is used as the maximum number
+of simultaneously open connections in total using this multi handle. For each
+new session, libcurl might open a new connection up to the limit set by
+CURLMOPT_MAX_TOTAL_CONNECTIONS(3). When the limit is reached, new
+sessions are held pending until there are available connections. If
+CURLMOPT_PIPELINING(3) is enabled, libcurl can try multiplexing if the
+host is capable of it.
+
+When more transfers are added to the multi handle than what can be performed
+due to the set limit, they get queued up waiting for their chance. When that
+happens, the CURLOPT_TIMEOUT_MS(3) timeout is counted inclusive of the
+waiting time, meaning that if you set a too narrow timeout in such a case the
+transfer might never even start before it times out.
+
+Even in the queued up situation, the CURLOPT_CONNECTTIMEOUT_MS(3)
+timeout is however treated as a per-connect timeout.
+
+# DEFAULT
+
+The default value is 0, which means that there is no limit. It is then simply
+controlled by the number of easy handles added.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURLM *m = curl_multi_init();
+  /* never do more than 15 connections */
+  curl_multi_setopt(m, CURLMOPT_MAX_TOTAL_CONNECTIONS, 15L);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.30.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_PIPELINING.md

@@ -0,0 +1,77 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_PIPELINING
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE (3)
+  - CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE (3)
+  - CURLMOPT_MAXCONNECTS (3)
+  - CURLMOPT_MAX_HOST_CONNECTIONS (3)
+  - CURLMOPT_MAX_PIPELINE_LENGTH (3)
+  - CURLMOPT_PIPELINING_SITE_BL (3)
+---
+
+# NAME
+
+CURLMOPT_PIPELINING - enable HTTP pipelining and multiplexing
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_PIPELINING, long bitmask);
+~~~
+
+# DESCRIPTION
+
+Pass in the correct value in the **bitmask** parameter to instruct libcurl
+to enable multiplexing for this multi handle.
+
+With multiplexing enabled, libcurl attempts to do multiple transfers over the
+same connection when doing parallel transfers to the same hosts.
+
+## CURLPIPE_NOTHING (0)
+
+Default, which means doing no attempts at multiplexing.
+
+## CURLPIPE_HTTP1 (1)
+
+This bit is deprecated and has no effect since version 7.62.0.
+
+## CURLPIPE_MULTIPLEX (2)
+
+If this bit is set, libcurl tries to multiplex the new transfer over an
+existing connection if possible. This requires HTTP/2 or HTTP/3.
+
+# DEFAULT
+
+Since 7.62.0, **CURLPIPE_MULTIPLEX** is enabled by default.
+
+Before that, default was **CURLPIPE_NOTHING**.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURLM *m = curl_multi_init();
+  /* try HTTP/2 multiplexing */
+  curl_multi_setopt(m, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.16.0. Multiplex support bit added in 7.43.0. HTTP/1 Pipelining
+support was disabled in 7.62.0.
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_PIPELINING_SERVER_BL.md

@@ -0,0 +1,68 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_PIPELINING_SERVER_BL
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_PIPELINING (3)
+  - CURLMOPT_PIPELINING_SITE_BL (3)
+---
+
+# NAME
+
+CURLMOPT_PIPELINING_SERVER_BL - pipelining server block list
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_PIPELINING_SERVER_BL,
+                            char **servers);
+~~~
+
+# DESCRIPTION
+
+No function since pipelining was removed in 7.62.0.
+
+Pass a **servers** array of char *, ending with a NULL entry. This is a list
+of server types prefixes (in the Server: HTTP header) that are blocked from
+pipelining, i.e server types that are known to not support HTTP
+pipelining. The array is copied by libcurl.
+
+Note that the comparison matches if the Server: header begins with the string
+in the block list, i.e "Server: Ninja 1.2.3" and "Server: Ninja 1.4.0" can
+both be blocked by having "Ninja" in the list.
+
+Pass a NULL pointer to clear the block list.
+
+# DEFAULT
+
+The default value is NULL, which means that there is no block list.
+
+# PROTOCOLS
+
+# EXAMPLE
+
+~~~c
+static char *server_block_list[] =
+{
+  "Microsoft-IIS/6.0",
+  "nginx/0.8.54",
+  NULL
+};
+int main(void)
+{
+  CURLM *m = curl_multi_init();
+  curl_multi_setopt(m, CURLMOPT_PIPELINING_SERVER_BL, server_block_list);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.30.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_PIPELINING_SITE_BL.md

@@ -0,0 +1,66 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_PIPELINING_SITE_BL
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_PIPELINING (3)
+  - CURLMOPT_PIPELINING_SERVER_BL (3)
+---
+
+# NAME
+
+CURLMOPT_PIPELINING_SITE_BL - pipelining host block list
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_PIPELINING_SITE_BL,
+                            char **hosts);
+~~~
+
+# DESCRIPTION
+
+No function since pipelining was removed in 7.62.0.
+
+Pass a **hosts** array of char *, ending with a NULL entry. This is a list
+of sites that are blocked from pipelining, i.e sites that are known to not
+support HTTP pipelining. The array is copied by libcurl.
+
+Pass a NULL pointer to clear the block list.
+
+# DEFAULT
+
+The default value is NULL, which means that there is no block list.
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+static char *site_block_list[] =
+{
+  "www.haxx.se",
+  "www.example.com:1234",
+  NULL
+};
+
+int main(void)
+{
+  CURLM *m = curl_multi_init();
+  curl_multi_setopt(m, CURLMOPT_PIPELINING_SITE_BL, site_block_list);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.30.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_PUSHDATA.md

@@ -0,0 +1,87 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_PUSHDATA
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_PIPELINING (3)
+  - CURLMOPT_PUSHFUNCTION (3)
+  - CURLOPT_PIPEWAIT (3)
+  - RFC 7540
+---
+
+# NAME
+
+CURLMOPT_PUSHDATA - pointer to pass to push callback
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_PUSHDATA, void *pointer);
+~~~
+
+# DESCRIPTION
+
+Set a *pointer* to pass as the last argument to the
+CURLMOPT_PUSHFUNCTION(3) callback. The pointer is not touched or used by
+libcurl itself, only passed on to the callback function.
+
+# DEFAULT
+
+NULL
+
+# PROTOCOLS
+
+HTTP(S)
+
+# EXAMPLE
+
+~~~c
+#include <string.h>
+
+/* only allow pushes for filenames starting with "push-" */
+int push_callback(CURL *parent,
+                  CURL *easy,
+                  size_t num_headers,
+                  struct curl_pushheaders *headers,
+                  void *clientp)
+{
+  char *headp;
+  int *transfers = (int *)clientp;
+  FILE *out;
+  headp = curl_pushheader_byname(headers, ":path");
+  if(headp && !strncmp(headp, "/push-", 6)) {
+    fprintf(stderr, "The PATH is %s\n", headp);
+
+    /* save the push here */
+    out = fopen("pushed-stream", "wb");
+
+    /* write to this file */
+    curl_easy_setopt(easy, CURLOPT_WRITEDATA, out);
+
+    (*transfers)++; /* one more */
+
+    return CURL_PUSH_OK;
+  }
+  return CURL_PUSH_DENY;
+}
+
+int main(void)
+{
+  int counter;
+  CURLM *multi = curl_multi_init();
+  curl_multi_setopt(multi, CURLMOPT_PUSHFUNCTION, push_callback);
+  curl_multi_setopt(multi, CURLMOPT_PUSHDATA, &counter);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.44.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_PUSHFUNCTION.md

@@ -0,0 +1,148 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_PUSHFUNCTION
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_PIPELINING (3)
+  - CURLMOPT_PUSHDATA (3)
+  - CURLOPT_PIPEWAIT (3)
+  - RFC 7540
+---
+
+# NAME
+
+CURLMOPT_PUSHFUNCTION - callback that approves or denies server pushes
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+int curl_push_callback(CURL *parent,
+                       CURL *easy,
+                       size_t num_headers,
+                       struct curl_pushheaders *headers,
+                       void *clientp);
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_PUSHFUNCTION,
+                            curl_push_callback func);
+~~~
+
+# DESCRIPTION
+
+This callback gets called when a new HTTP/2 stream is being pushed by the
+server (using the PUSH_PROMISE frame). If no push callback is set, all offered
+pushes are denied automatically.
+
+# CALLBACK DESCRIPTION
+
+The callback gets its arguments like this:
+
+*parent* is the handle of the stream on which this push arrives. The new
+handle has been duplicated from the parent, meaning that it has gotten all its
+options inherited. It is then up to the application to alter any options if
+desired.
+
+*easy* is a newly created handle that represents this upcoming transfer.
+
+*num_headers* is the number of name+value pairs that was received and can
+be accessed
+
+*headers* is a handle used to access push headers using the accessor
+functions described below. This only accesses and provides the PUSH_PROMISE
+headers, the normal response headers are provided in the header callback as
+usual.
+
+*clientp* is the pointer set with CURLMOPT_PUSHDATA(3)
+
+If the callback returns CURL_PUSH_OK, the new easy handle is added to the
+multi handle, the callback must not do that by itself.
+
+The callback can access PUSH_PROMISE headers with two accessor
+functions. These functions can only be used from within this callback and they
+can only access the PUSH_PROMISE headers: curl_pushheader_byname(3) and
+curl_pushheader_bynum(3). The normal response headers are passed to the
+header callback for pushed streams just as for normal streams.
+
+The header fields can also be accessed with curl_easy_header(3),
+introduced in later libcurl versions.
+
+# CALLBACK RETURN VALUE
+
+## CURL_PUSH_OK (0)
+
+The application has accepted the stream and it can now start receiving data,
+the ownership of the CURL handle has been taken over by the application.
+
+## CURL_PUSH_DENY (1)
+
+The callback denies the stream and no data reaches the application, the easy
+handle is destroyed by libcurl.
+
+## CURL_PUSH_ERROROUT (2)
+
+Returning this code rejects the pushed stream and returns an error back on the
+parent stream making it get closed with an error. (Added in 7.72.0)
+
+## *
+
+All other return codes are reserved for future use.
+
+# DEFAULT
+
+NULL, no callback
+
+# PROTOCOLS
+
+HTTP(S) (HTTP/2 only)
+
+# EXAMPLE
+
+~~~c
+#include <string.h>
+
+/* only allow pushes for filenames starting with "push-" */
+int push_callback(CURL *parent,
+                  CURL *easy,
+                  size_t num_headers,
+                  struct curl_pushheaders *headers,
+                  void *clientp)
+{
+  char *headp;
+  int *transfers = (int *)clientp;
+  FILE *out;
+  headp = curl_pushheader_byname(headers, ":path");
+  if(headp && !strncmp(headp, "/push-", 6)) {
+    fprintf(stderr, "The PATH is %s\n", headp);
+
+    /* save the push here */
+    out = fopen("pushed-stream", "wb");
+
+    /* write to this file */
+    curl_easy_setopt(easy, CURLOPT_WRITEDATA, out);
+
+    (*transfers)++; /* one more */
+
+    return CURL_PUSH_OK;
+  }
+  return CURL_PUSH_DENY;
+}
+
+int main(void)
+{
+  int counter;
+  CURLM *multi = curl_multi_init();
+  curl_multi_setopt(multi, CURLMOPT_PUSHFUNCTION, push_callback);
+  curl_multi_setopt(multi, CURLMOPT_PUSHDATA, &counter);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.44.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_SOCKETDATA.md

@@ -0,0 +1,82 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_SOCKETDATA
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_SOCKETFUNCTION (3)
+  - CURLMOPT_TIMERFUNCTION (3)
+  - curl_multi_socket_action (3)
+---
+
+# NAME
+
+CURLMOPT_SOCKETDATA - custom pointer passed to the socket callback
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_SOCKETDATA, void *pointer);
+~~~
+
+# DESCRIPTION
+
+A data *pointer* to pass to the socket callback set with the
+CURLMOPT_SOCKETFUNCTION(3) option.
+
+This pointer is not touched by libcurl but is only passed in as the socket
+callback's **clientp** argument.
+
+# DEFAULT
+
+NULL
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+struct priv {
+  void *ours;
+};
+
+static int sock_cb(CURL *e, curl_socket_t s, int what, void *cbp, void *sockp)
+{
+  struct priv *p = sockp;
+  printf("my ptr: %p\n", p->ours);
+
+  if(what == CURL_POLL_REMOVE) {
+    /* remove the socket from our collection */
+  }
+  if(what & CURL_POLL_IN) {
+    /* wait for read on this socket */
+  }
+  if(what & CURL_POLL_OUT) {
+    /* wait for write on this socket */
+  }
+
+  return 0;
+}
+
+int main(void)
+{
+  struct priv setup;
+  CURLM *multi = curl_multi_init();
+  /* ... use socket callback and custom pointer */
+  curl_multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
+  curl_multi_setopt(multi, CURLMOPT_SOCKETDATA, &setup);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.15.4
+
+# RETURN VALUE
+
+Returns CURLM_OK.

deps/curl/docs/libcurl/opts/CURLMOPT_SOCKETFUNCTION.md

@@ -0,0 +1,135 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_SOCKETFUNCTION
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_SOCKETDATA (3)
+  - CURLMOPT_TIMERFUNCTION (3)
+  - curl_multi_socket_action (3)
+---
+
+# NAME
+
+CURLMOPT_SOCKETFUNCTION - callback informed about what to wait for
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+int socket_callback(CURL *easy,      /* easy handle */
+                    curl_socket_t s, /* socket */
+                    int what,        /* describes the socket */
+                    void *clientp,   /* private callback pointer */
+                    void *socketp);  /* private socket pointer */
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_SOCKETFUNCTION, socket_callback);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to your callback function, which should match the prototype
+shown above.
+
+When the curl_multi_socket_action(3) function is called, it uses this
+callback to inform the application about updates in the socket (file
+descriptor) status by doing none, one, or multiple calls to the
+**socket_callback**. The callback function gets status updates with changes
+since the previous time the callback was called. If the given callback pointer
+is set to NULL, no callback is called.
+
+libcurl then expects the application to monitor the sockets for the specific
+activities and tell libcurl again when something happens on one of them. Tell
+libcurl by calling curl_multi_socket_action(3).
+
+# CALLBACK ARGUMENTS
+
+*easy* identifies the specific transfer for which this update is related.
+
+*s* is the specific socket this function invocation concerns. If the
+**what** argument is not CURL_POLL_REMOVE then it holds information about
+what activity on this socket the application is supposed to
+monitor. Subsequent calls to this callback might update the **what** bits
+for a socket that is already monitored.
+
+The socket callback should return 0 on success, and -1 on error. If this
+callback returns error, **all** transfers currently in progress in this
+multi handle are aborted and made to fail.
+
+**clientp** is set with CURLMOPT_SOCKETDATA(3).
+
+**socketp** is set with curl_multi_assign(3) or NULL.
+
+The **what** parameter informs the callback on the status of the given
+socket. It can hold one of these values:
+
+## CURL_POLL_IN
+
+Wait for incoming data. For the socket to become readable.
+
+## CURL_POLL_OUT
+
+Wait for outgoing data. For the socket to become writable.
+
+## CURL_POLL_INOUT
+
+Wait for incoming and outgoing data. For the socket to become readable or
+writable.
+
+## CURL_POLL_REMOVE
+
+The specified socket/file descriptor is no longer used by libcurl for any
+active transfer. It might soon be added again.
+
+# DEFAULT
+
+NULL (no callback)
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+struct priv {
+  void *ours;
+};
+
+static int sock_cb(CURL *e, curl_socket_t s, int what, void *cbp, void *sockp)
+{
+  struct priv *p = sockp;
+  printf("our ptr: %p\n", p->ours);
+
+  if(what == CURL_POLL_REMOVE) {
+    /* remove the socket from our collection */
+  }
+  if(what & CURL_POLL_IN) {
+    /* wait for read on this socket */
+  }
+  if(what & CURL_POLL_OUT) {
+    /* wait for write on this socket */
+  }
+
+  return 0;
+}
+
+int main(void)
+{
+  struct priv setup;
+  CURLM *multi = curl_multi_init();
+  /* ... use socket callback and custom pointer */
+  curl_multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
+  curl_multi_setopt(multi, CURLMOPT_SOCKETDATA, &setup);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.15.4
+
+# RETURN VALUE
+
+Returns CURLM_OK.

deps/curl/docs/libcurl/opts/CURLMOPT_TIMERDATA.md

@@ -0,0 +1,75 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_TIMERDATA
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_SOCKETFUNCTION (3)
+  - CURLMOPT_TIMERFUNCTION (3)
+---
+
+# NAME
+
+CURLMOPT_TIMERDATA - custom pointer to pass to timer callback
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_TIMERDATA, void *pointer);
+~~~
+
+# DESCRIPTION
+
+A data **pointer** to pass to the timer callback set with the
+CURLMOPT_TIMERFUNCTION(3) option.
+
+This pointer is not touched by libcurl but is only be passed in to the timer
+callback's **clientp** argument.
+
+# DEFAULT
+
+NULL
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+struct priv {
+  void *custom;
+};
+
+static int timerfunc(CURLM *multi, long timeout_ms, void *clientp)
+{
+ struct priv *mydata = clientp;
+ printf("our ptr: %p\n", mydata->custom);
+
+ if(timeout_ms) {
+   /* this is the new single timeout to wait for */
+ }
+ else {
+   /* delete the timeout, nothing to wait for now */
+ }
+}
+
+int main(void)
+{
+  struct priv mydata;
+  CURLM *multi = curl_multi_init();
+  curl_multi_setopt(multi, CURLMOPT_TIMERFUNCTION, timerfunc);
+  curl_multi_setopt(multi, CURLMOPT_TIMERDATA, &mydata);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.16.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLMOPT_TIMERFUNCTION.md

@@ -0,0 +1,103 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLMOPT_TIMERFUNCTION
+Section: 3
+Source: libcurl
+See-also:
+  - CURLMOPT_SOCKETFUNCTION (3)
+  - CURLMOPT_TIMERDATA (3)
+---
+
+# NAME
+
+CURLMOPT_TIMERFUNCTION - callback to receive timeout values
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+int timer_callback(CURLM *multi,    /* multi handle */
+                   long timeout_ms, /* timeout in number of ms */
+                   void *clientp);    /* private callback pointer */
+
+CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_TIMERFUNCTION, timer_callback);
+~~~
+
+# DESCRIPTION
+
+Pass a pointer to your callback function, which should match the prototype
+shown above.
+
+Certain features, such as timeouts and retries, require you to call libcurl
+even when there is no activity on the file descriptors.
+
+Your callback function **timer_callback** should install a non-repeating
+timer with an expire time of **timeout_ms** milliseconds. When that timer
+fires, call either curl_multi_socket_action(3) or
+curl_multi_perform(3), depending on which interface you use.
+
+A **timeout_ms** value of -1 passed to this callback means you should delete
+the timer. All other values are valid expire times in number of milliseconds.
+
+The **timer_callback** is called when the timeout expire time is changed.
+
+The **clientp** pointer is set with CURLMOPT_TIMERDATA(3).
+
+The timer callback should return 0 on success, and -1 on error. If this
+callback returns error, **all** transfers currently in progress in this
+multi handle are aborted and made to fail.
+
+This callback can be used instead of, or in addition to,
+curl_multi_timeout(3).
+
+**WARNING:** do not call libcurl directly from within the callback itself
+when the **timeout_ms** value is zero, since it risks triggering an
+unpleasant recursive behavior that immediately calls another call to the
+callback with a zero timeout...
+
+# DEFAULT
+
+NULL
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+struct priv {
+  void *custom;
+};
+
+static int timerfunc(CURLM *multi, long timeout_ms, void *clientp)
+{
+ struct priv *mydata = clientp;
+ printf("our ptr: %p\n", mydata->custom);
+
+ if(timeout_ms) {
+   /* this is the new single timeout to wait for */
+ }
+ else {
+   /* delete the timeout, nothing to wait for now */
+ }
+}
+
+int main(void)
+{
+  struct priv mydata;
+  CURLM *multi = curl_multi_init();
+  curl_multi_setopt(multi, CURLMOPT_TIMERFUNCTION, timerfunc);
+  curl_multi_setopt(multi, CURLMOPT_TIMERDATA, &mydata);
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.16.0
+
+# RETURN VALUE
+
+Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLOPT_ABSTRACT_UNIX_SOCKET.md

@@ -0,0 +1,71 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLOPT_ABSTRACT_UNIX_SOCKET
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_UNIX_SOCKET_PATH (3)
+  - unix (7)
+---
+
+# NAME
+
+CURLOPT_ABSTRACT_UNIX_SOCKET - abstract Unix domain socket
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_setopt(CURL *handle, CURLOPT_ABSTRACT_UNIX_SOCKET,
+                          char *path);
+~~~
+
+# DESCRIPTION
+
+Enables the use of an abstract Unix domain socket instead of establishing a
+TCP connection to a host. The parameter should be a char * to a
+null-terminated string holding the path of the socket. The path is set to
+*path* prefixed by a NULL byte. This is the convention for abstract
+sockets, however it should be stressed that the path passed to this function
+should not contain a leading NULL byte.
+
+On non-supporting platforms, the abstract address is interpreted as an empty
+string and fails gracefully, generating a runtime error.
+
+This option shares the same semantics as CURLOPT_UNIX_SOCKET_PATH(3) in
+which documentation more details can be found. Internally, these two options
+share the same storage and therefore only one of them can be set per handle.
+
+# DEFAULT
+
+Default is NULL.
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_ABSTRACT_UNIX_SOCKET, "/tmp/foo.sock");
+    curl_easy_setopt(curl, CURLOPT_URL, "http://localhost/");
+
+    /* Perform the request */
+    curl_easy_perform(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.53.0.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLOPT_ACCEPTTIMEOUT_MS.md

@@ -0,0 +1,61 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLOPT_ACCEPTTIMEOUT_MS
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_CONNECTTIMEOUT_MS (3)
+  - CURLOPT_DEBUGFUNCTION (3)
+  - CURLOPT_STDERR (3)
+---
+
+# NAME
+
+CURLOPT_ACCEPTTIMEOUT_MS - timeout waiting for FTP server to connect back
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_setopt(CURL *handle, CURLOPT_ACCEPTTIMEOUT_MS, long ms);
+~~~
+
+# DESCRIPTION
+
+Pass a long telling libcurl the maximum number of milliseconds to wait for a
+server to connect back to libcurl when an active FTP connection is used.
+
+# DEFAULT
+
+60000 milliseconds
+
+# PROTOCOLS
+
+FTP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_URL, "ftp://example.com/path/file");
+
+    /* wait no more than 5 seconds for FTP server responses */
+    curl_easy_setopt(curl, CURLOPT_ACCEPTTIMEOUT_MS, 5000L);
+
+    curl_easy_perform(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.24.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLOPT_ACCEPT_ENCODING.md

@@ -0,0 +1,110 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLOPT_ACCEPT_ENCODING
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_HTTPHEADER (3)
+  - CURLOPT_HTTP_CONTENT_DECODING (3)
+  - CURLOPT_TRANSFER_ENCODING (3)
+---
+
+# NAME
+
+CURLOPT_ACCEPT_ENCODING - automatic decompression of HTTP downloads
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_setopt(CURL *handle, CURLOPT_ACCEPT_ENCODING, char *enc);
+~~~
+
+# DESCRIPTION
+
+Pass a char pointer argument specifying what encoding you would like.
+
+Sets the contents of the Accept-Encoding: header sent in an HTTP request, and
+enables decoding of a response when a Content-Encoding: header is received.
+
+libcurl potentially supports several different compressed encodings depending
+on what support that has been built-in.
+
+To aid applications not having to bother about what specific algorithms this
+particular libcurl build supports, libcurl allows a zero-length string to be
+set ("") to ask for an Accept-Encoding: header to be used that contains all
+built-in supported encodings.
+
+Alternatively, you can specify exactly the encoding or list of encodings you
+want in the response. The following encodings are supported: *identity*,
+meaning non-compressed, *deflate* which requests the server to compress
+its response using the zlib algorithm, *gzip* which requests the gzip
+algorithm, (since curl 7.57.0) *br* which is brotli and (since curl
+7.72.0) *zstd* which is zstd. Provide them in the string as a
+comma-separated list of accepted encodings, like: **"br, gzip, deflate"**.
+
+Set CURLOPT_ACCEPT_ENCODING(3) to NULL to explicitly disable it, which
+makes libcurl not send an Accept-Encoding: header and not decompress received
+contents automatically.
+
+You can also opt to just include the Accept-Encoding: header in your request
+with CURLOPT_HTTPHEADER(3) but then there is no automatic decompressing
+when receiving data.
+
+This is a request, not an order; the server may or may not do it. This option
+must be set (to any non-NULL value) or else any unsolicited encoding done by
+the server is ignored.
+
+Servers might respond with Content-Encoding even without getting a
+Accept-Encoding: in the request. Servers might respond with a different
+Content-Encoding than what was asked for in the request.
+
+The Content-Length: servers send for a compressed response is supposed to
+indicate the length of the compressed content so when auto decoding is enabled
+it may not match the sum of bytes reported by the write callbacks (although,
+sending the length of the non-compressed content is a common server mistake).
+
+The application does not have to keep the string around after setting this
+option.
+
+# DEFAULT
+
+NULL
+
+# PROTOCOLS
+
+HTTP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
+
+    /* enable all supported built-in compressions */
+    curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "");
+
+    /* Perform the request */
+    curl_easy_perform(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+This option was called CURLOPT_ENCODING before 7.21.6
+
+The specific libcurl you are using must have been built with zlib to be able to
+decompress gzip and deflate responses, with the brotli library to
+decompress brotli responses and with the zstd library to decompress zstd
+responses.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, CURLE_UNKNOWN_OPTION if not, or
+CURLE_OUT_OF_MEMORY if there was insufficient heap space.

deps/curl/docs/libcurl/opts/CURLOPT_ADDRESS_SCOPE.md

@@ -0,0 +1,63 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLOPT_ADDRESS_SCOPE
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_DEBUGFUNCTION (3)
+  - CURLOPT_STDERR (3)
+---
+
+# NAME
+
+CURLOPT_ADDRESS_SCOPE - scope id for IPv6 addresses
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_setopt(CURL *handle, CURLOPT_ADDRESS_SCOPE, long scope);
+~~~
+
+# DESCRIPTION
+
+Pass a long specifying the scope id value to use when connecting to IPv6 addresses.
+
+# DEFAULT
+
+0
+
+# PROTOCOLS
+
+All, when using IPv6
+
+# EXAMPLE
+
+~~~c
+#include <net/if.h> /* for if_nametoindex() */
+
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode ret;
+    long my_scope_id;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/");
+    my_scope_id = if_nametoindex("eth0");
+    curl_easy_setopt(curl, CURLOPT_ADDRESS_SCOPE, my_scope_id);
+    ret = curl_easy_perform(curl);
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.19.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
+Returns CURLE_BAD_FUNCTION_ARGUMENT if set to a negative value.

deps/curl/docs/libcurl/opts/CURLOPT_ALTSVC.md

@@ -0,0 +1,111 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLOPT_ALTSVC
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_ALTSVC_CTRL (3)
+  - CURLOPT_CONNECT_TO (3)
+  - CURLOPT_COOKIEFILE (3)
+  - CURLOPT_RESOLVE (3)
+---
+<!-- markdown-link-check-disable -->
+# NAME
+
+CURLOPT_ALTSVC - alt-svc cache filename
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_setopt(CURL *handle, CURLOPT_ALTSVC, char *filename);
+~~~
+
+# DESCRIPTION
+
+Pass in a pointer to a *filename* to instruct libcurl to use that file as
+the Alt-Svc cache to read existing cache contents from and possibly also write
+it back to after a transfer, unless **CURLALTSVC_READONLYFILE** is set in
+CURLOPT_ALTSVC_CTRL(3).
+
+Specify a blank filename ("") to make libcurl not load from a file at all.
+
+# DEFAULT
+
+NULL. The alt-svc cache is not read nor written to file.
+
+# PROTOCOLS
+
+HTTPS
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_ALTSVC_CTRL, CURLALTSVC_H1);
+    curl_easy_setopt(curl, CURLOPT_ALTSVC, "altsvc-cache.txt");
+    curl_easy_perform(curl);
+  }
+}
+~~~
+
+# FILE FORMAT
+
+A text based file with one line per alt-svc entry and each line consists of
+nine space-separated fields.
+
+An example line could look like
+
+    h2 www.example.com 8443 h3 second.example.com 443 "20190808 06:18:37" 1 0
+
+The fields of that line are:
+
+## h2
+
+ALPN id for the source origin
+
+## www.example.comp
+
+Hostname for the source origin
+
+## 8443
+
+Port number for the source origin
+
+## h3
+
+ALPN id for the destination host
+
+## second.example.com
+
+Hostname for the destination host
+
+## 443
+
+Port number for the destination host
+
+## 2019*
+
+Expiration date and time of this entry within double quotes. The date format
+is "YYYYMMDD HH:MM:SS" and the time zone is GMT.
+
+## 1
+
+Boolean (1 or 0) if "persist" was set for this entry
+
+## 0
+
+Integer priority value (not currently used)
+
+# AVAILABILITY
+
+Added in 7.64.1
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLOPT_ALTSVC_CTRL.md

@@ -0,0 +1,97 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLOPT_ALTSVC_CTRL
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_ALTSVC (3)
+  - CURLOPT_CONNECT_TO (3)
+  - CURLOPT_RESOLVE (3)
+---
+
+# NAME
+
+CURLOPT_ALTSVC_CTRL - control alt-svc behavior
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+#define CURLALTSVC_READONLYFILE (1<<2)
+#define CURLALTSVC_H1           (1<<3)
+#define CURLALTSVC_H2           (1<<4)
+#define CURLALTSVC_H3           (1<<5)
+
+CURLcode curl_easy_setopt(CURL *handle, CURLOPT_ALTSVC_CTRL, long bitmask);
+~~~
+
+# DESCRIPTION
+
+Populate the long *bitmask* with the correct set of features to instruct
+libcurl how to handle Alt-Svc for the transfers using this handle.
+
+libcurl only accepts Alt-Svc headers over a secure transport, meaning
+HTTPS. It also only completes a request to an alternative origin if that
+origin is properly hosted over HTTPS. These requirements are there to make
+sure both the source and the destination are legitimate.
+
+Alternative services are only used when setting up new connections. If there
+exists an existing connection to the host in the connection pool, then that is
+preferred.
+
+Setting any bit enables the alt-svc engine.
+
+## CURLALTSVC_READONLYFILE
+
+Do not write the alt-svc cache back to the file specified with
+CURLOPT_ALTSVC(3) even if it gets updated. By default a file specified
+with that option is read and written to as deemed necessary.
+
+## CURLALTSVC_H1
+
+Accept alternative services offered over HTTP/1.1.
+
+## CURLALTSVC_H2
+
+Accept alternative services offered over HTTP/2. This is only used if libcurl
+was also built to actually support HTTP/2, otherwise this bit is ignored.
+
+## CURLALTSVC_H3
+
+Accept alternative services offered over HTTP/3. This is only used if libcurl
+was also built to actually support HTTP/3, otherwise this bit is ignored.
+
+# DEFAULT
+
+Alt-Svc handling is disabled by default. If CURLOPT_ALTSVC(3) is set,
+CURLOPT_ALTSVC_CTRL(3) has a default value corresponding to
+CURLALTSVC_H1 | CURLALTSVC_H2 | CURLALTSVC_H3 - the HTTP/2 and HTTP/3 bits are
+only set if libcurl was built with support for those versions.
+
+# PROTOCOLS
+
+HTTPS
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_ALTSVC_CTRL, (long)CURLALTSVC_H1);
+    curl_easy_setopt(curl, CURLOPT_ALTSVC, "altsvc-cache.txt");
+    curl_easy_perform(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.64.1
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLOPT_APPEND.md

@@ -0,0 +1,61 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLOPT_APPEND
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_DIRLISTONLY (3)
+  - CURLOPT_RESUME_FROM (3)
+  - CURLOPT_UPLOAD (3)
+---
+
+# NAME
+
+CURLOPT_APPEND - append to the remote file
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_setopt(CURL *handle, CURLOPT_APPEND, long append);
+~~~
+
+# DESCRIPTION
+
+A long parameter set to 1 tells the library to append to the remote file
+instead of overwrite it. This is only useful when uploading to an FTP site.
+
+# DEFAULT
+
+0 (disabled)
+
+# PROTOCOLS
+
+FTP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+
+    curl_easy_setopt(curl, CURLOPT_URL, "ftp://example.com/dir/to/newfile");
+    curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
+    curl_easy_setopt(curl, CURLOPT_APPEND, 1L);
+
+    curl_easy_perform(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+This option was known as CURLOPT_FTPAPPEND up to 7.16.4
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLOPT_AUTOREFERER.md

@@ -0,0 +1,77 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLOPT_AUTOREFERER
+Section: 3
+Source: libcurl
+See-also:
+  - CURLINFO_EFFECTIVE_URL (3)
+  - CURLINFO_REDIRECT_URL (3)
+  - CURLINFO_REFERER (3)
+  - CURLOPT_FOLLOWLOCATION (3)
+  - CURLOPT_REFERER (3)
+---
+
+# NAME
+
+CURLOPT_AUTOREFERER - automatically update the referer header
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_setopt(CURL *handle, CURLOPT_AUTOREFERER, long autorefer);
+~~~
+
+# DESCRIPTION
+
+Pass a long parameter set to 1 to enable this. When enabled, libcurl
+automatically sets the Referer: header field in HTTP requests to the full URL
+when it follows a Location: redirect to a new destination.
+
+The automatic referer is set to the full previous URL even when redirects are
+done cross-origin or following redirects to insecure protocols. This is
+considered a minor privacy leak by some.
+
+With CURLINFO_REFERER(3), applications can extract the actually used
+referer header after the transfer.
+
+# DEFAULT
+
+0, disabled
+
+# PROTOCOLS
+
+HTTP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/foo.bin");
+
+    /* follow redirects */
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+
+    /* set Referer: automatically when following redirects */
+    curl_easy_setopt(curl, CURLOPT_AUTOREFERER, 1L);
+
+    res = curl_easy_perform(curl);
+
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Along with HTTP
+
+# RETURN VALUE
+
+Returns CURLE_OK if HTTP is supported, and CURLE_UNKNOWN_OPTION if not.

deps/curl/docs/libcurl/opts/CURLOPT_AWS_SIGV4.md

@@ -0,0 +1,118 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLOPT_AWS_SIGV4
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_HEADEROPT (3)
+  - CURLOPT_HTTPAUTH (3)
+  - CURLOPT_HTTPHEADER (3)
+  - CURLOPT_PROXYAUTH (3)
+---
+
+# NAME
+
+CURLOPT_AWS_SIGV4 - V4 signature
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_setopt(CURL *handle, CURLOPT_AWS_SIGV4, char *param);
+~~~
+
+# DESCRIPTION
+
+Provides AWS V4 signature authentication on HTTP(S) header.
+
+Pass a char pointer that is the collection of specific arguments are used for
+creating outgoing authentication headers. The format of the *param* option
+is:
+
+## provider1[:provider2[:region[:service]]]
+
+## provider1, provider2
+
+The providers arguments are used for generating some authentication parameters
+such as "Algorithm", "date", "request type" and "signed headers".
+
+## region
+
+The argument is a geographic area of a resources collection.
+It is extracted from the hostname specified in the URL if omitted.
+
+## service
+
+The argument is a function provided by a cloud. It is extracted from the
+hostname specified in the URL if omitted.
+
+NOTE: This call set CURLOPT_HTTPAUTH(3) to CURLAUTH_AWS_SIGV4.
+Calling CURLOPT_HTTPAUTH(3) with CURLAUTH_AWS_SIGV4 is the same
+as calling this with **"aws:amz"** in parameter.
+
+Example with "Test:Try", when curl uses the algorithm, it generates
+**"TEST-HMAC-SHA256"** for "Algorithm", **"x-try-date"** and
+**"X-Try-Date"** for "date", **"test4_request"** for "request type",
+**"SignedHeaders=content-type;host;x-try-date"** for "signed headers"
+
+If you use just "test", instead of "test:try", test is used for every
+generated string.
+
+# DEFAULT
+
+By default, the value of this parameter is NULL.
+Calling CURLOPT_HTTPAUTH(3) with CURLAUTH_AWS_SIGV4 is the same
+as calling this with **"aws:amz"** in parameter.
+
+# PROTOCOLS
+
+HTTP
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_URL,
+                    "https://service.region.example.com/uri");
+    curl_easy_setopt(curl, CURLOPT_AWS_SIGV4, "provider1:provider2");
+
+    /* service and region can also be set in CURLOPT_AWS_SIGV4 */
+    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/uri");
+    curl_easy_setopt(curl, CURLOPT_AWS_SIGV4,
+                     "provider1:provider2:region:service");
+
+    curl_easy_setopt(curl, CURLOPT_USERPWD, "MY_ACCESS_KEY:MY_SECRET_KEY");
+    curl_easy_perform(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.75.0
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
+
+# NOTES
+
+This option overrides the other auth types you might have set in
+CURLOPT_HTTPAUTH(3) which should be highlighted as this makes this auth
+method special. This method cannot be combined with other auth types.
+
+A sha256 checksum of the request payload is used as input to the signature
+calculation. For POST requests, this is a checksum of the provided
+CURLOPT_POSTFIELDS(3). Otherwise, it is the checksum of an empty buffer. For
+requests like PUT, you can provide your own checksum in an HTTP header named
+**x-provider2-content-sha256**.
+
+For **aws:s3**, a **x-amz-content-sha256** header is added to every request
+if not already present. For s3 requests with unknown payload, this header takes
+the special value "UNSIGNED-PAYLOAD".

deps/curl/docs/libcurl/opts/CURLOPT_BUFFERSIZE.md

@@ -0,0 +1,84 @@
+---
+c: Copyright (C) Daniel Stenberg, <daniel.se>, et al.
+SPDX-License-Identifier: curl
+Title: CURLOPT_BUFFERSIZE
+Section: 3
+Source: libcurl
+See-also:
+  - CURLOPT_MAXFILESIZE (3)
+  - CURLOPT_MAX_RECV_SPEED_LARGE (3)
+  - CURLOPT_UPLOAD_BUFFERSIZE (3)
+  - CURLOPT_WRITEFUNCTION (3)
+---
+
+# NAME
+
+CURLOPT_BUFFERSIZE - receive buffer size
+
+# SYNOPSIS
+
+~~~c
+#include <curl/curl.h>
+
+CURLcode curl_easy_setopt(CURL *handle, CURLOPT_BUFFERSIZE, long size);
+~~~
+
+# DESCRIPTION
+
+Pass a long specifying your preferred *size* (in bytes) for the receive buffer
+in libcurl. The main point of this would be that the write callback gets
+called more often and with smaller chunks. Secondly, for some protocols, there
+is a benefit of having a larger buffer for performance.
+
+This is just treated as a request, not an order. You cannot be guaranteed to
+actually get the given size.
+
+This buffer size is by default *CURL_MAX_WRITE_SIZE* (16kB). The maximum
+buffer size allowed to be set is *CURL_MAX_READ_SIZE* (10MB). The minimum
+buffer size allowed to be set is 1024.
+
+DO NOT set this option on a handle that is currently used for an active
+transfer as that may lead to unintended consequences.
+
+The maximum size was 512kB until 7.88.0.
+
+Starting in libcurl 8.7.0, there is just a single transfer buffer allocated
+per multi handle. This buffer is used by all easy handles added to a multi
+handle no matter how many parallel transfers there are. The buffer remains
+allocated as long as there are active transfers.
+
+# DEFAULT
+
+CURL_MAX_WRITE_SIZE (16kB)
+
+# PROTOCOLS
+
+All
+
+# EXAMPLE
+
+~~~c
+int main(void)
+{
+  CURL *curl = curl_easy_init();
+  if(curl) {
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, "sftp://example.com/foo.bin");
+
+    /* ask libcurl to allocate a larger receive buffer */
+    curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, 120000L);
+
+    res = curl_easy_perform(curl);
+
+    curl_easy_cleanup(curl);
+  }
+}
+~~~
+
+# AVAILABILITY
+
+Added in 7.10. Growing the buffer was added in 7.53.0.
+
+# RETURN VALUE
+
+Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.