JackLee/XSteam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

update libcurl libgit2

Browse Source
This commit is contained in:
JackLee_CN 2024-10-11 19:49:24 +08:00
parent c1b80be038
commit e119abfd22
612 changed files with 62380 additions and 24429 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
3rdparty/ValveFileVDF/include/vdf_parser.hpp → 3rdparty/ValveFileVDF/vdf_parser.hpp vendored
View File

20
3rdparty/curl/bin/curl-config vendored
View File

@ -25,13 +25,13 @@
# shellcheck disable=SC2006
prefix='F:\SourceCode\curl\build\curl'
prefix='F:/SourceCode/XSteam/3rdparty/curl'
# Used in 'libdir'
# shellcheck disable=SC2034
exec_prefix="${prefix}"
# shellcheck disable=SC2034
includedir="${prefix}/include"
cppflag_curl_staticlib='-DCURL_STATICLIB'
cppflag_curl_staticlib=''
usage()
{
@ -67,7 +67,7 @@ fi
while test "$#" -gt 0; do
case "$1" in
--built-shared)
echo 'no'
echo 'yes'
;;
--ca)
@ -75,7 +75,7 @@ while test "$#" -gt 0; do
;;
--cc)
echo 'D:/Dev/msys64/mingw64/bin/cc.exe'
echo 'D:/Dev/Qt/Tools/mingw1120_64/bin/gcc.exe'
;;
--prefix)
@ -83,14 +83,14 @@ while test "$#" -gt 0; do
;;
--feature|--features)
for feature in alt-svc AsynchDNS HSTS HTTP2 HTTP3 HTTPS-proxy IDN IPv6 Largefile libz NTLM PSL SSL threadsafe TLS-SRP UnixSockets zstd ''; do
for feature in alt-svc AsynchDNS HTTP2 IDN IPv6 Largefile NTLM PSL threadsafe UnixSockets ''; do
test -n "$feature" && echo "$feature"
done
;;
--protocols)
# shellcheck disable=SC2043
for protocol in DICT FILE FTP FTPS GOPHER GOPHERS HTTP HTTPS IMAP IMAPS IPFS IPNS LDAP LDAPS MQTT POP3 POP3S RTSP SCP SFTP SMB SMBS SMTP SMTPS TELNET TFTP; do
for protocol in DICT FILE FTP GOPHER HTTP IMAP IPFS IPNS LDAP LDAPS MQTT POP3 RTSP SCP SFTP SMB SMTP TELNET TFTP; do
echo "$protocol"
done
;;
@ -160,20 +160,20 @@ while test "$#" -gt 0; do
else
CURLLIBDIR=''
fi
if test 'Xno' = 'Xno'; then
echo "${CURLLIBDIR}-lcurl -lidn2 -lws2_32 -lbcrypt -lssl -lcrypto -lz -lzstd -lnghttp2 -lnghttp3 -lwldap32 -lpsl -lssh2 -ladvapi32 -lcrypt32"
if test 'Xyes' = 'Xno'; then
echo "${CURLLIBDIR}-lcurl -lidn2 -lws2_32 -lbcrypt -lnghttp2 -lwldap32 -lpsl -lssh2 -ladvapi32 -lcrypt32"
else
echo "${CURLLIBDIR}-lcurl"
fi
;;
--ssl-backends)
echo 'OpenSSL v3+'
echo ''
;;
--static-libs)
if test 'Xyes' != 'Xno'; then
echo "${exec_prefix}/lib/libcurl.a -LD:/Dev/msys64/mingw64/bin/../lib -LD:/Dev/msys64/mingw64/lib -lidn2 -lws2_32 -lbcrypt -lssl -lcrypto -lz -lzstd -lnghttp2 -lnghttp3 -lwldap32 -lpsl -lssh2 -ladvapi32 -lcrypt32"
echo "${exec_prefix}/lib/libcurl.a -LD:/Dev/msys64/mingw64/bin/../lib -LD:/Dev/msys64/mingw64/lib -lidn2 -lws2_32 -lbcrypt -lnghttp2 -lwldap32 -lpsl -lssh2 -ladvapi32 -lcrypt32"
else
echo 'curl was built with static libraries disabled' >&2
exit 1

BIN
3rdparty/curl/bin/curl.exe vendored
View File

Binary file not shown.

BIN
3rdparty/curl/bin/libcurl.dll vendored Normal file
View File

Binary file not shown.

10
3rdparty/curl/lib/cmake/CURL/CURLConfig.cmake vendored
View File

@ -55,11 +55,11 @@ endif()
option(CURL_USE_PKGCONFIG "Enable pkg-config to detect CURL dependencies" ${_curl_use_pkgconfig_default})
include(CMakeFindDependencyMacro)
if("ON")
find_dependency(OpenSSL "3")
if("")
find_dependency(OpenSSL "")
endif()
if("ON")
find_dependency(ZLIB "1")
if("OFF")
find_dependency(ZLIB "")
endif()
include("${CMAKE_CURRENT_LIST_DIR}/CURLTargets.cmake")
@ -67,7 +67,7 @@ check_required_components("CURL")
# Alias for either shared or static library
if(NOT TARGET CURL::libcurl)
add_library(CURL::libcurl ALIAS CURL::libcurl_static)
add_library(CURL::libcurl ALIAS CURL::libcurl_shared)
endif()
# For compatibility with CMake's FindCURL.cmake

5
3rdparty/curl/lib/cmake/CURL/CURLConfigVersion.cmake vendored
View File

@ -58,11 +58,6 @@ else()
endif()
# if the installed project requested no architecture check, don't perform the check
if("FALSE")
return()
endif()
# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
return()

10
3rdparty/curl/lib/cmake/CURL/CURLTargets-release.cmake vendored
View File

@ -15,6 +15,16 @@ set_target_properties(CURL::libcurl_static PROPERTIES
list(APPEND _cmake_import_check_targets CURL::libcurl_static )
list(APPEND _cmake_import_check_files_for_CURL::libcurl_static "${_IMPORT_PREFIX}/lib/libcurl.a" )
# Import target "CURL::libcurl_shared" for configuration "Release"
set_property(TARGET CURL::libcurl_shared APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(CURL::libcurl_shared PROPERTIES
IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/lib/libcurl.dll.a"
IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/libcurl.dll"
)
list(APPEND _cmake_import_check_targets CURL::libcurl_shared )
list(APPEND _cmake_import_check_files_for_CURL::libcurl_shared "${_IMPORT_PREFIX}/lib/libcurl.dll.a" "${_IMPORT_PREFIX}/bin/libcurl.dll" )
# Import target "CURL::curl" for configuration "Release"
set_property(TARGET CURL::curl APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(CURL::curl PROPERTIES

35
3rdparty/curl/lib/cmake/CURL/CURLTargets.cmake vendored
View File

@ -3,11 +3,11 @@
if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
message(FATAL_ERROR "CMake >= 2.8.0 required")
endif()
if(CMAKE_VERSION VERSION_LESS "2.8.3")
message(FATAL_ERROR "CMake >= 2.8.3 required")
if(CMAKE_VERSION VERSION_LESS "2.8.12")
message(FATAL_ERROR "CMake >= 2.8.12 required")
endif()
cmake_policy(PUSH)
cmake_policy(VERSION 2.8.3...3.22)
cmake_policy(VERSION 2.8.12...3.28)
#----------------------------------------------------------------
# Generated CMake target import file.
#----------------------------------------------------------------
@ -19,7 +19,7 @@ set(CMAKE_IMPORT_FILE_VERSION 1)
set(_cmake_targets_defined "")
set(_cmake_targets_not_defined "")
set(_cmake_expected_targets "")
foreach(_cmake_expected_target IN ITEMS CURL::libcurl_static CURL::curl)
foreach(_cmake_expected_target IN ITEMS CURL::libcurl_static CURL::libcurl_shared CURL::curl)
list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
if(TARGET "${_cmake_expected_target}")
list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
@ -61,16 +61,19 @@ add_library(CURL::libcurl_static STATIC IMPORTED)
set_target_properties(CURL::libcurl_static PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CURL_STATICLIB"
INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
INTERFACE_LINK_LIBRARIES "\$<LINK_ONLY:idn2>;\$<LINK_ONLY:ws2_32>;\$<LINK_ONLY:bcrypt>;\$<LINK_ONLY:OpenSSL::SSL>;\$<LINK_ONLY:OpenSSL::Crypto>;\$<LINK_ONLY:ZLIB::ZLIB>;D:/Dev/msys64/mingw64/lib/libzstd.dll.a;D:/Dev/msys64/mingw64/lib/libnghttp2.dll.a;D:/Dev/msys64/mingw64/lib/libnghttp3.dll.a;\$<LINK_ONLY:wldap32>;D:/Dev/msys64/mingw64/lib/libpsl.dll.a;D:/Dev/msys64/mingw64/lib/libssh2.dll.a;\$<LINK_ONLY:advapi32>;\$<LINK_ONLY:crypt32>"
INTERFACE_LINK_LIBRARIES "\$<LINK_ONLY:idn2>;\$<LINK_ONLY:ws2_32>;\$<LINK_ONLY:bcrypt>;D:/Dev/msys64/mingw64/lib/libnghttp2.dll.a;\$<LINK_ONLY:wldap32>;D:/Dev/msys64/mingw64/lib/libpsl.dll.a;D:/Dev/msys64/mingw64/lib/libssh2.dll.a;\$<LINK_ONLY:advapi32>;\$<LINK_ONLY:crypt32>"
)
# Create imported target CURL::libcurl_shared
add_library(CURL::libcurl_shared SHARED IMPORTED)
set_target_properties(CURL::libcurl_shared PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
)
# Create imported target CURL::curl
add_executable(CURL::curl IMPORTED)
if(CMAKE_VERSION VERSION_LESS 2.8.12)
message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.")
endif()
# Load information for each installed configuration.
file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/CURLTargets-*.cmake")
foreach(_cmake_config_file IN LISTS _cmake_config_files)
@ -84,9 +87,12 @@ set(_IMPORT_PREFIX)
# Loop over all imported files and verify that they actually exist
foreach(_cmake_target IN LISTS _cmake_import_check_targets)
foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
if(NOT EXISTS "${_cmake_file}")
message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
if(CMAKE_VERSION VERSION_LESS "3.28"
OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
if(NOT EXISTS "${_cmake_file}")
message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
\"${_cmake_file}\"
but this file does not exist. Possible reasons include:
* The file was deleted, renamed, or moved to another location.
@ -95,8 +101,9 @@ but this file does not exist. Possible reasons include:
\"${CMAKE_CURRENT_LIST_FILE}\"
but not all the files it references.
")
endif()
endforeach()
endif()
endforeach()
endif()
unset(_cmake_file)
unset("_cmake_import_check_files_for_${_cmake_target}")
endforeach()

BIN
3rdparty/curl/lib/libcurl.a vendored
View File

Binary file not shown.

BIN
3rdparty/curl/lib/libcurl.dll.a vendored Normal file
View File

Binary file not shown.

16
3rdparty/curl/lib/pkgconfig/libcurl.pc vendored
View File

@ -22,20 +22,20 @@
#
###########################################################################
prefix=F:\SourceCode\curl\build\curl
prefix=F:/SourceCode/XSteam/3rdparty/curl
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include
supported_protocols="DICT FILE FTP FTPS GOPHER GOPHERS HTTP HTTPS IMAP IMAPS IPFS IPNS LDAP LDAPS MQTT POP3 POP3S RTSP SCP SFTP SMB SMBS SMTP SMTPS TELNET TFTP"
supported_features="alt-svc AsynchDNS HSTS HTTP2 HTTP3 HTTPS-proxy IDN IPv6 Largefile libz NTLM PSL SSL threadsafe TLS-SRP UnixSockets zstd"
supported_protocols="DICT FILE FTP GOPHER HTTP IMAP IPFS IPNS LDAP LDAPS MQTT POP3 RTSP SCP SFTP SMB SMTP TELNET TFTP"
supported_features="alt-svc AsynchDNS HTTP2 IDN IPv6 Largefile NTLM PSL threadsafe UnixSockets"
Name: libcurl
URL: https://curl.se/
Description: Library to transfer files with HTTP, FTP, etc.
Version: 8.11.0-DEV
Requires: libidn2,openssl,zlib,libzstd,libnghttp2,libnghttp3,libpsl,libssh2
Requires.private: libidn2,openssl,zlib,libzstd,libnghttp2,libnghttp3,libpsl,libssh2
Libs: -L${libdir} -lcurl -lidn2 -lws2_32 -lbcrypt -lssl -lcrypto -lz -lzstd -lnghttp2 -lnghttp3 -lwldap32 -lpsl -lssh2 -ladvapi32 -lcrypt32
Libs.private: -LD:/Dev/msys64/mingw64/bin/../lib -LD:/Dev/msys64/mingw64/lib -lidn2 -lws2_32 -lbcrypt -lssl -lcrypto -lz -lzstd -lnghttp2 -lnghttp3 -lwldap32 -lpsl -lssh2 -ladvapi32 -lcrypt32
Cflags: -I${includedir} -DCURL_STATICLIB
Requires:
Requires.private: libidn2,libnghttp2,libpsl,libssh2
Libs: -L${libdir} -lcurl
Libs.private: -LD:/Dev/msys64/mingw64/bin/../lib -LD:/Dev/msys64/mingw64/lib -lidn2 -lws2_32 -lbcrypt -lnghttp2 -lwldap32 -lpsl -lssh2 -ladvapi32 -lcrypt32
Cflags: -I${includedir}
Cflags.private: -DCURL_STATICLIB

82
3rdparty/curl/share/man/man1/curl-config.1 vendored Normal file
View File

@ -0,0 +1,82 @@
.\" generated by cd2nroff 0.1 from curl-config.md
.TH curl-config 1 "2024-10-11" curl-config
.SH NAME
curl\-config \- Get information about a libcurl installation
.SH SYNOPSIS
\fBcurl\-config [options]\fP
.SH DESCRIPTION
\fBcurl\-config\fP
displays information about the curl and libcurl installation.
.SH OPTIONS
.IP --ca
Displays the built\-in path to the CA cert bundle this libcurl uses.
.IP --cc
Displays the compiler used to build libcurl.
.IP --cflags
Set of compiler options (CFLAGS) to use when compiling files that use
libcurl. Currently that is only the include path to the curl include files.
.IP "--checkfor [version]"
Specify the oldest possible libcurl version string you want, and this script
returns 0 if the current installation is new enough or it returns 1 and
outputs a text saying that the current version is not new enough. (Added in
7.15.4)
.IP --configure
Displays the arguments given to configure when building curl.
.IP --feature
Lists what particular main features the installed libcurl was built with. At
the time of writing, this list may include SSL, KRB4 or IPv6. Do not assume
any particular order. The keywords are separated by newlines. There may be
none, one, or several keywords in the list.
.IP --help
Displays the available options.
.IP --libs
Shows the complete set of libs and other linker options you need in order to
link your application with libcurl.
.IP --prefix
This is the prefix used when libcurl was installed. Libcurl is then installed
in $prefix/lib and its header files are installed in $prefix/include and so
on. The prefix is set with "configure \--prefix".
.IP --protocols
Lists what particular protocols the installed libcurl was built to support. At
the time of writing, this list may include HTTP, HTTPS, FTP, FTPS, FILE,
TELNET, LDAP, DICT and many more. Do not assume any particular order. The
protocols are listed using uppercase and are separated by newlines. There may
be none, one, or several protocols in the list. (Added in 7.13.0)
.IP --ssl-backends
Lists the SSL backends that were enabled when libcurl was built. It might be
no, one or several names. If more than one name, they appear comma\-separated.
(Added in 7.58.0)
.IP --static-libs
Shows the complete set of libs and other linker options you need in order to
link your application with libcurl statically. (Added in 7.17.1)
.IP --version
Outputs version information about the installed libcurl.
.IP --vernum
Outputs version information about the installed libcurl, in numerical mode.
This shows the version number, in hexadecimal, using 8 bits for each part:
major, minor, and patch numbers. This makes libcurl 7.7.4 appear as 070704 and
libcurl 12.13.14 appear as 0c0d0e... Note that the initial zero might be
omitted. (This option was broken in the 7.15.0 release.)
.SH EXAMPLES
What linker options do I need when I link with libcurl?
.nf
$ curl-config --libs
.fi
What compiler options do I need when I compile using libcurl functions?
.nf
$ curl-config --cflags
.fi
How do I know if libcurl was built with SSL support?
.nf
$ curl-config --feature | grep SSL
.fi
What\(aqs the installed libcurl version?
.nf
$ curl-config --version
.fi
How do I build a single file with a one\-line command?
.nf
$ `curl-config --cc --cflags` -o example source.c `curl-config --libs`
.fi
.SH SEE ALSO
.BR curl (1)

2
3rdparty/curl/share/man/man1/curl.1 vendored
View File

@ -24,7 +24,7 @@
.\"
.\" DO NOT EDIT. Generated by the curl project managen manpage generator.
.\"
.TH curl 1 "2024-09-25" "curl 8.11.0" "curl Manual"
.TH curl 1 "2024-10-11" "curl 8.11.0" "curl Manual"
.SH NAME
curl \- transfer a URL
.SH SYNOPSIS

81
3rdparty/curl/share/man/man1/mk-ca-bundle.1 vendored Normal file
View File

@ -0,0 +1,81 @@
.\" generated by cd2nroff 0.1 from mk-ca-bundle.md
.TH mk-ca-bundle 1 "2024-10-11" mk-ca-bundle
.SH NAME
mk\-ca\-bundle \- convert Mozilla\(aqs certificate bundle to PEM format
.SH SYNOPSIS
mk\-ca\-bundle [options] [output]
.SH DESCRIPTION
This tool downloads the \fIcertdata.txt\fP file from Mozilla\(aqs source tree over
HTTPS, then parses it and extracts the included certificates into PEM format.
By default, only CA root certificates trusted to issue SSL server
authentication certificates are extracted. These are then processed with the
OpenSSL command line tool to produce the final ca\-bundle output file.
The default \fIoutput\fP name is \fBca\-bundle.crt\fP. By setting it to \(aq\-\(aq (a single
dash) you get the output sent to STDOUT instead of a file.
The PEM format this scripts uses for output makes the result readily available
for use by just about all OpenSSL or GnuTLS powered applications, such as curl
and others.
.SH OPTIONS
The following options are supported:
.IP -b
backup an existing version of \fIoutput\fP
.IP "-d [name]"
specify which Mozilla tree to pull \fIcertdata.txt\fP from (or a custom URL).
Valid names are: \fBaurora\fP, \fBbeta\fP, \fBcentral\fP, \fBMozilla\fP, \fBnss\fP,
\fBrelease\fP (default). They are shortcuts for which source tree to get the
certificate data from.
.IP -f
force rebuild even if \fIcertdata.txt\fP is current (Added in version 1.17)
.IP -i
print version info about used modules
.IP -k
Allow insecure data transfer. By default (since 1.27) this command fails if
the HTTPS transfer fails. This overrides that decision (and opens for
man\-in\-the\-middle attacks).
.IP -l
print license info about \fIcertdata.txt\fP
.IP -m
(Added in 1.26) Include meta data comments in the output. The meta data is
specific information about each certificate that is stored in the original
file as comments and using this option makes those comments get passed on to
the output file. The meta data is not parsed in any way by mk\-ca\-bundle.
.IP -n
Do not download \fIcertdata.txt\fP \- use the existing.
.IP "-p [purposes]:[levels]"
list of Mozilla trust purposes and levels for certificates to include in
output. Takes the form of a comma separated list of purposes, a colon, and a
comma separated list of levels. The default is to include all certificates
trusted to issue SSL Server certificates (\fISERVER_AUTH:TRUSTED_DELEGATOR\fP).
Valid purposes are: \fBALL\fP, \fBDIGITAL_SIGNATURE\fP, \fBNON_REPUDIATION\fP,
\fBKEY_ENCIPHERMENT\fP, \fBDATA_ENCIPHERMENT\fP, \fBKEY_AGREEMENT\fP,
\fBKEY_CERT_SIGN\fP, \fBCRL_SIGN\fP, \fBSERVER_AUTH\fP (default), \fBCLIENT_AUTH\fP,
\fBCODE_SIGNING\fP, \fBEMAIL_PROTECTION\fP, \fBIPSEC_END_SYSTEM\fP,
\fBIPSEC_TUNNEL\fP, \fBIPSEC_USER\fP, \fBTIME_STAMPING\fP, \fBSTEP_UP_APPROVED\fP
Valid trust levels are: \fBALL\fP, \fBTRUSTED_DELEGATOR\fP (default), \fBNOT_TRUSTED\fP,
\fBMUST_VERIFY_TRUST\fP, \fBTRUSTED\fP
.IP -q
be really quiet (no progress output at all)
.IP -t
include plain text listing of certificates
.IP "-s [algorithms]"
A comma separated list of signature algorithms with which to hash/fingerprint
each certificate and output when run in plain text mode.
Valid algorithms are:
ALL, NONE, MD5 (default), SHA1, SHA256, SHA384, SHA512
.IP -u
unlink (remove) \fIcertdata.txt\fP after processing
.IP -v
be verbose and print out processed certificate authorities
.SH EXIT STATUS
Returns 0 on success. Returns 1 if it fails to download data.
.SH FILE FORMAT
The file format used by Mozilla for this trust information is documented here:
https://p11\-glue.freedesktop.org/doc/storing\-trust\-policy/storing\-trust\-existing.html
.SH SEE ALSO
.BR curl (1)

63
3rdparty/curl/share/man/man3/CURLINFO_ACTIVESOCKET.3 vendored Normal file
View File

@ -0,0 +1,63 @@
.\" generated by cd2nroff 0.1 from CURLINFO_ACTIVESOCKET.md
.TH CURLINFO_ACTIVESOCKET 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_ACTIVESOCKET \- get the active socket
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_ACTIVESOCKET,
curl_socket_t *socket);
.fi
.SH 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, \fICURL_SOCKET_BAD\fP is returned. When you are finished working
with the socket, you must call \fIcurl_easy_cleanup(3)\fP 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
\fICURLOPT_CONNECT_ONLY(3)\fP, which skips the transfer phase.
\fICURLINFO_ACTIVESOCKET(3)\fP was added as a replacement for
\fICURLINFO_LASTSOCKET(3)\fP since that one is not working on all platforms.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
if(res != CURLE_OK) {
printf("Error: %s\\n", curl_easy_strerror(res));
curl_easy_cleanup(curl);
return 1;
}
/* Extract the socket from the curl handle */
res = curl_easy_getinfo(curl, CURLINFO_ACTIVESOCKET, &sockfd);
if(!res && sockfd != CURL_SOCKET_BAD) {
/* operate on sockfd */
}
curl_easy_cleanup(curl);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.45.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_LASTSOCKET (3),
.BR CURLOPT_CONNECT_ONLY (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

52
3rdparty/curl/share/man/man3/CURLINFO_APPCONNECT_TIME.3 vendored Normal file
View File

@ -0,0 +1,52 @@
.\" generated by cd2nroff 0.1 from CURLINFO_APPCONNECT_TIME.md
.TH CURLINFO_APPCONNECT_TIME 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_APPCONNECT_TIME \- get the time until the SSL/SSH handshake is completed
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_APPCONNECT_TIME,
double *timep);
.fi
.SH 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 \fICURLINFO_PRETRANSFER_TIME(3)\fP time, except
for cases such as HTTP multiplexing where the pretransfer time can be delayed
due to waits in line for the stream and more.
When a redirect is followed, the time from each request is added together.
See also the TIMES overview in the \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.19.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_APPCONNECT_TIME_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

53
3rdparty/curl/share/man/man3/CURLINFO_APPCONNECT_TIME_T.3 vendored Normal file
View File

@ -0,0 +1,53 @@
.\" generated by cd2nroff 0.1 from CURLINFO_APPCONNECT_TIME_T.md
.TH CURLINFO_APPCONNECT_TIME_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_APPCONNECT_TIME_T \- time until the SSL/SSH handshake completed
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_APPCONNECT_TIME_T,
curl_off_t *timep);
.fi
.SH 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 \fICURLINFO_PRETRANSFER_TIME_T(3)\fP
time, except for cases such as HTTP multiplexing where the pretransfer time
can be delayed due to waits in line for the stream and more.
When a redirect is followed, the time from each request is added together.
See also the TIMES overview in the \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.61.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_APPCONNECT_TIME (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

49
3rdparty/curl/share/man/man3/CURLINFO_CAINFO.3 vendored Normal file
View File

@ -0,0 +1,49 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CAINFO.md
.TH CURLINFO_CAINFO 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CAINFO \- get the default built\-in CA certificate path
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CAINFO, char **path);
.fi
.SH 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 \fICURLOPT_CAINFO(3)\fP
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 \fICURLOPT_CAINFO(3)\fP.
This is a path identifying a single file containing CA certificates.
The \fBpath\fP pointer is set to NULL if there is no default path.
.SH PROTOCOLS
This functionality affects all TLS based protocols: HTTPS, FTPS, IMAPS, POP3S, SMTPS etc.
All TLS backends support this option.
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.84.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CAPATH (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

50
3rdparty/curl/share/man/man3/CURLINFO_CAPATH.3 vendored Normal file
View File

@ -0,0 +1,50 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CAPATH.md
.TH CURLINFO_CAPATH 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CAPATH \- get the default built\-in CA path string
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CAPATH, char **path);
.fi
.SH 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 \fICURLOPT_CAPATH(3)\fP
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 \fICURLOPT_CAPATH(3)\fP.
This is a path identifying a directory.
The \fBpath\fP pointer is set to NULL if there is no default path.
.SH PROTOCOLS
This functionality affects all TLS based protocols: HTTPS, FTPS, IMAPS, POP3S, SMTPS etc.
This option works only with the following TLS backends:
GnuTLS, OpenSSL, mbedTLS and wolfSSL
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.84.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CAINFO (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

84
3rdparty/curl/share/man/man3/CURLINFO_CERTINFO.3 vendored Normal file
View File

@ -0,0 +1,84 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CERTINFO.md
.TH CURLINFO_CERTINFO 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CERTINFO \- get the TLS certificate chain
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CERTINFO,
struct curl_certinfo **chainp);
.fi
.SH DESCRIPTION
Pass a pointer to a \fIstruct curl_certinfo \fP* and it is set to point to a
struct that holds info about the server\(aqs certificate chain, assuming you had
\fICURLOPT_CERTINFO(3)\fP enabled when the request was made.
.nf
struct curl_certinfo {
int num_of_certs;
struct curl_slist **certinfo;
};
.fi
The \fIcertinfo\fP struct member is an array of linked lists of certificate
information. The \fInum_of_certs\fP struct member is the number of certificates
which is the number of elements in the array. Each certificate\(aqs 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.
.SH PROTOCOLS
This functionality affects all TLS based protocols: HTTPS, FTPS, IMAPS, POP3S, SMTPS etc.
This option works only with the following TLS backends:
GnuTLS, OpenSSL, Schannel and Secure Transport
.SH EXAMPLE
.nf
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);
}
}
.fi
See also the \fIcertinfo.c\fP example.
.SH HISTORY
GnuTLS support added in 7.42.0. Schannel support added in 7.50.0. Secure
Transport support added in 7.79.0. mbedTLS support added in 8.9.0.
.SH AVAILABILITY
Added in curl 7.19.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CAPATH (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

61
3rdparty/curl/share/man/man3/CURLINFO_CONDITION_UNMET.3 vendored Normal file
View File

@ -0,0 +1,61 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CONDITION_UNMET.md
.TH CURLINFO_CONDITION_UNMET 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CONDITION_UNMET \- get info on unmet time conditional or 304 HTTP response.
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONDITION_UNMET,
long *unmet);
.fi
.SH DESCRIPTION
Pass a pointer to a long to receive the number 1 if the condition provided in
the previous request did not match (see \fICURLOPT_TIMECONDITION(3)\fP). 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.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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":"");
}
}
}
}
.fi
.SH AVAILABILITY
Added in curl 7.19.4
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_TIMECONDITION (3),
.BR CURLOPT_TIMEVALUE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

48
3rdparty/curl/share/man/man3/CURLINFO_CONNECT_TIME.3 vendored Normal file
View File

@ -0,0 +1,48 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CONNECT_TIME.md
.TH CURLINFO_CONNECT_TIME 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CONNECT_TIME \- get the time until connect
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONNECT_TIME, double *timep);
.fi
.SH 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.4.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CONNECT_TIME_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

51
3rdparty/curl/share/man/man3/CURLINFO_CONNECT_TIME_T.3 vendored Normal file
View File

@ -0,0 +1,51 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CONNECT_TIME_T.md
.TH CURLINFO_CONNECT_TIME_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CONNECT_TIME_T \- get the time until connect
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONNECT_TIME_T,
curl_off_t *timep);
.fi
.SH 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.61.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CONNECT_TIME (3),
.BR CURLOPT_CONNECTTIMEOUT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

51
3rdparty/curl/share/man/man3/CURLINFO_CONN_ID.3 vendored Normal file
View File

@ -0,0 +1,51 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CONN_ID.md
.TH CURLINFO_CONN_ID 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CONN_ID \- get the ID of the last connection used by the handle
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONN_ID,
curl_off_t *conn_id);
.fi
.SH DESCRIPTION
Pass a pointer to a \fIcurl_off_t\fP 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.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH AVAILABILITY
Added in curl 8.2.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_XFER_ID (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

53
3rdparty/curl/share/man/man3/CURLINFO_CONTENT_LENGTH_DOWNLOAD.3 vendored Normal file
View File

@ -0,0 +1,53 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CONTENT_LENGTH_DOWNLOAD.md
.TH CURLINFO_CONTENT_LENGTH_DOWNLOAD 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CONTENT_LENGTH_DOWNLOAD \- get content\-length of download
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONTENT_LENGTH_DOWNLOAD,
double *content_length);
.fi
.SH 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.
\fICURLINFO_CONTENT_LENGTH_DOWNLOAD_T(3)\fP is a newer replacement that returns a more
sensible variable type.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH DEPRECATED
Deprecated since 7.55.0.
.SH AVAILABILITY
Added in curl 7.6.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CONTENT_LENGTH_UPLOAD (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

48
3rdparty/curl/share/man/man3/CURLINFO_CONTENT_LENGTH_DOWNLOAD_T.3 vendored Normal file
View File

@ -0,0 +1,48 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CONTENT_LENGTH_DOWNLOAD_T.md
.TH CURLINFO_CONTENT_LENGTH_DOWNLOAD_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CONTENT_LENGTH_DOWNLOAD_T \- get content\-length of download
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
curl_off_t *content_length);
.fi
.SH DESCRIPTION
Pass a pointer to a \fIcurl_off_t\fP 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.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH AVAILABILITY
Added in curl 7.55.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CONTENT_LENGTH_UPLOAD_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

52
3rdparty/curl/share/man/man3/CURLINFO_CONTENT_LENGTH_UPLOAD.3 vendored Normal file
View File

@ -0,0 +1,52 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CONTENT_LENGTH_UPLOAD.md
.TH CURLINFO_CONTENT_LENGTH_UPLOAD 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CONTENT_LENGTH_UPLOAD \- get the specified size of the upload
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONTENT_LENGTH_UPLOAD,
double *content_length);
.fi
.SH 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.
\fICURLINFO_CONTENT_LENGTH_UPLOAD_T(3)\fP is a newer replacement that returns a
more sensible variable type.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH DEPRECATED
Deprecated since 7.55.0.
.SH AVAILABILITY
Added in curl 7.6.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CONTENT_LENGTH_DOWNLOAD_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

47
3rdparty/curl/share/man/man3/CURLINFO_CONTENT_LENGTH_UPLOAD_T.3 vendored Normal file
View File

@ -0,0 +1,47 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CONTENT_LENGTH_UPLOAD_T.md
.TH CURLINFO_CONTENT_LENGTH_UPLOAD_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CONTENT_LENGTH_UPLOAD_T \- get the specified size of the upload
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONTENT_LENGTH_UPLOAD_T,
curl_off_t *content_length);
.fi
.SH DESCRIPTION
Pass a pointer to a \fIcurl_off_t\fP to receive the specified size of the
upload. Stores \-1 if the size is not known.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH AVAILABILITY
Added in curl 7.55.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CONTENT_LENGTH_DOWNLOAD_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

56
3rdparty/curl/share/man/man3/CURLINFO_CONTENT_TYPE.3 vendored Normal file
View File

@ -0,0 +1,56 @@
.\" generated by cd2nroff 0.1 from CURLINFO_CONTENT_TYPE.md
.TH CURLINFO_CONTENT_TYPE 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_CONTENT_TYPE \- get Content\-Type
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_CONTENT_TYPE, char **ct);
.fi
.SH 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 \fBct\fP pointer is set to NULL or pointing to private memory. You MUST
NOT free it \- it gets freed when you call \fIcurl_easy_cleanup(3)\fP on the
corresponding CURL handle.
The modern way to get this header from a response is to instead use the
\fIcurl_easy_header(3)\fP function.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.9.4
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_HEADERFUNCTION (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_header (3),
.BR curl_easy_setopt (3)

63
3rdparty/curl/share/man/man3/CURLINFO_COOKIELIST.3 vendored Normal file
View File

@ -0,0 +1,63 @@
.\" generated by cd2nroff 0.1 from CURLINFO_COOKIELIST.md
.TH CURLINFO_COOKIELIST 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_COOKIELIST \- get all known cookies
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_COOKIELIST,
struct curl_slist **cookies);
.fi
.SH DESCRIPTION
Pass a pointer to a \(aqstruct curl_slist *\(aq to receive a linked\-list of all
cookies curl knows (expired ones, too). Do not forget to call
\fIcurl_slist_free_all(3)\fP 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 \(aqstruct curl_slist *\(aq 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.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.14.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_COOKIELIST (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

53
3rdparty/curl/share/man/man3/CURLINFO_EFFECTIVE_METHOD.3 vendored Normal file
View File

@ -0,0 +1,53 @@
.\" generated by cd2nroff 0.1 from CURLINFO_EFFECTIVE_METHOD.md
.TH CURLINFO_EFFECTIVE_METHOD 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_EFFECTIVE_METHOD \- get the last used HTTP method
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_EFFECTIVE_METHOD,
char **methodp);
.fi
.SH 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 \fBmethodp\fP pointer is NULL or points to private memory. You MUST NOT
free \- it gets freed when you call \fIcurl_easy_cleanup(3)\fP on the
corresponding CURL handle.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.72.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_CUSTOMREQUEST (3),
.BR CURLOPT_FOLLOWLOCATION (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

49
3rdparty/curl/share/man/man3/CURLINFO_EFFECTIVE_URL.3 vendored Normal file
View File

@ -0,0 +1,49 @@
.\" generated by cd2nroff 0.1 from CURLINFO_EFFECTIVE_URL.md
.TH CURLINFO_EFFECTIVE_URL 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_EFFECTIVE_URL \- get the last used URL
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_EFFECTIVE_URL, char **urlp);
.fi
.SH 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 \fICURLOPT_URL(3)\fP.
The \fBurlp\fP pointer is NULL or points to private memory. You MUST NOT free
- it gets freed when you call \fIcurl_easy_cleanup(3)\fP on the corresponding
CURL handle.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.4
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_FOLLOWLOCATION (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

56
3rdparty/curl/share/man/man3/CURLINFO_FILETIME.3 vendored Normal file
View File

@ -0,0 +1,56 @@
.\" generated by cd2nroff 0.1 from CURLINFO_FILETIME.md
.TH CURLINFO_FILETIME 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_FILETIME \- get the remote time of the retrieved document
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_FILETIME, long *timep);
.fi
.SH 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 ask libcurl to collect this information before the transfer is made,
by using the \fICURLOPT_FILETIME(3)\fP option or you unconditionally get a \-1 back.
Consider \fICURLINFO_FILETIME_T(3)\fP instead to be able to extract dates beyond the
year 2038 on systems using 32\-bit longs (Windows).
.SH PROTOCOLS
This functionality affects ftp, http and sftp
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.5
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_FILETIME (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

57
3rdparty/curl/share/man/man3/CURLINFO_FILETIME_T.3 vendored Normal file
View File

@ -0,0 +1,57 @@
.\" generated by cd2nroff 0.1 from CURLINFO_FILETIME_T.md
.TH CURLINFO_FILETIME_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_FILETIME_T \- get the remote time of the retrieved document
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_FILETIME_T,
curl_off_t *timep);
.fi
.SH 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 \fICURLOPT_FILETIME(3)\fP option or you unconditionally get a \-1 back.
This option is an alternative to \fICURLINFO_FILETIME(3)\fP to allow systems with 32
bit long variables to extract dates outside of the 32\-bit timestamp range.
.SH PROTOCOLS
This functionality affects ftp, http and sftp
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.59.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_FILETIME (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

53
3rdparty/curl/share/man/man3/CURLINFO_FTP_ENTRY_PATH.3 vendored Normal file
View File

@ -0,0 +1,53 @@
.\" generated by cd2nroff 0.1 from CURLINFO_FTP_ENTRY_PATH.md
.TH CURLINFO_FTP_ENTRY_PATH 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_FTP_ENTRY_PATH \- get entry path in FTP server
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_FTP_ENTRY_PATH, char **path);
.fi
.SH 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 \fBpath\fP pointer is NULL or points to private memory. You MUST NOT free
- it gets freed when you call \fIcurl_easy_cleanup(3)\fP on the corresponding
CURL handle.
.SH PROTOCOLS
This functionality affects ftp only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH HISTORY
Works for SFTP since 7.21.4
.SH AVAILABILITY
Added in curl 7.15.4
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

46
3rdparty/curl/share/man/man3/CURLINFO_HEADER_SIZE.3 vendored Normal file
View File

@ -0,0 +1,46 @@
.\" generated by cd2nroff 0.1 from CURLINFO_HEADER_SIZE.md
.TH CURLINFO_HEADER_SIZE 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_HEADER_SIZE \- get size of retrieved headers
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_HEADER_SIZE, long *sizep);
.fi
.SH 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
\fICURLOPT_SUPPRESS_CONNECT_HEADERS(3)\fP.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.4.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_REQUEST_SIZE (3),
.BR CURLINFO_SIZE_DOWNLOAD (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

56
3rdparty/curl/share/man/man3/CURLINFO_HTTPAUTH_AVAIL.3 vendored Normal file
View File

@ -0,0 +1,56 @@
.\" generated by cd2nroff 0.1 from CURLINFO_HTTPAUTH_AVAIL.md
.TH CURLINFO_HTTPAUTH_AVAIL 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_HTTPAUTH_AVAIL \- get available HTTP authentication methods
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_HTTPAUTH_AVAIL, long *authp);
.fi
.SH 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 \fICURLOPT_HTTPAUTH(3)\fP option for \fIcurl_easy_setopt(3)\fP.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.10.8
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_PROXYAUTH_AVAIL (3),
.BR CURLOPT_HTTPAUTH (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

46
3rdparty/curl/share/man/man3/CURLINFO_HTTP_CONNECTCODE.3 vendored Normal file
View File

@ -0,0 +1,46 @@
.\" generated by cd2nroff 0.1 from CURLINFO_HTTP_CONNECTCODE.md
.TH CURLINFO_HTTP_CONNECTCODE 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_HTTP_CONNECTCODE \- get the CONNECT response code
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_HTTP_CONNECTCODE, long *p);
.fi
.SH 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.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.10.7
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_RESPONSE_CODE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

42
3rdparty/curl/share/man/man3/CURLINFO_HTTP_VERSION.3 vendored Normal file
View File

@ -0,0 +1,42 @@
.\" generated by cd2nroff 0.1 from CURLINFO_HTTP_VERSION.md
.TH CURLINFO_HTTP_VERSION 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_HTTP_VERSION \- get the http version used in the connection
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_HTTP_VERSION, long *p);
.fi
.SH 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.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.50.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_RESPONSE_CODE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

63
3rdparty/curl/share/man/man3/CURLINFO_LASTSOCKET.3 vendored Normal file
View File

@ -0,0 +1,63 @@
.\" generated by cd2nroff 0.1 from CURLINFO_LASTSOCKET.md
.TH CURLINFO_LASTSOCKET 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_LASTSOCKET \- get the last socket used
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_LASTSOCKET, long *socket);
.fi
.SH DESCRIPTION
Deprecated since 7.45.0. Use \fICURLINFO_ACTIVESOCKET(3)\fP 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 \fIcurl_easy_cleanup(3)\fP as usual and
let libcurl close the socket and cleanup other resources associated with the
handle. This is typically used in combination with
\fICURLOPT_CONNECT_ONLY(3)\fP.
NOTE: this API is deprecated since it is not working on win64 where the SOCKET
type is 64 bits large while its \(aqlong\(aq is 32 bits. Use the
\fICURLINFO_ACTIVESOCKET(3)\fP instead, if possible.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
if(res != CURLE_OK) {
printf("Error: %s\\n", curl_easy_strerror(res));
curl_easy_cleanup(curl);
return 1;
}
/* Extract the socket from the curl handle */
res = curl_easy_getinfo(curl, CURLINFO_LASTSOCKET, &sockfd);
if(!res && sockfd != -1) {
/* operate on sockfd */
}
curl_easy_cleanup(curl);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.15.2
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_ACTIVESOCKET (3),
.BR CURLOPT_CONNECT_ONLY (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

53
3rdparty/curl/share/man/man3/CURLINFO_LOCAL_IP.3 vendored Normal file
View File

@ -0,0 +1,53 @@
.\" generated by cd2nroff 0.1 from CURLINFO_LOCAL_IP.md
.TH CURLINFO_LOCAL_IP 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_LOCAL_IP \- get local IP address of last connection
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_LOCAL_IP, char **ip);
.fi
.SH 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 \fBcurl\fP 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 \fBip\fP pointer is NULL or points to private memory. You MUST NOT free \- it
gets freed when you call \fIcurl_easy_cleanup(3)\fP on the corresponding CURL
handle.
.SH PROTOCOLS
This functionality affects quic and tcp
.SH EXAMPLE
.nf
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);
}
.fi
.SH AVAILABILITY
Added in curl 7.21.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_LOCAL_PORT (3),
.BR CURLINFO_PRIMARY_IP (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

52
3rdparty/curl/share/man/man3/CURLINFO_LOCAL_PORT.3 vendored Normal file
View File

@ -0,0 +1,52 @@
.\" generated by cd2nroff 0.1 from CURLINFO_LOCAL_PORT.md
.TH CURLINFO_LOCAL_PORT 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_LOCAL_PORT \- get the latest local port number
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_LOCAL_PORT, long *portp);
.fi
.SH DESCRIPTION
Pass a pointer to a long to receive the local port number of the most recent
connection done with this \fBcurl\fP handle.
If the connection was done using QUIC, the port number is a UDP port number,
otherwise it is a TCP port number.
.SH PROTOCOLS
This functionality affects quic and tcp
.SH EXAMPLE
.nf
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;
}
.fi
.SH AVAILABILITY
Added in curl 7.21.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_LOCAL_IP (3),
.BR CURLINFO_PRIMARY_PORT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

49
3rdparty/curl/share/man/man3/CURLINFO_NAMELOOKUP_TIME.3 vendored Normal file
View File

@ -0,0 +1,49 @@
.\" generated by cd2nroff 0.1 from CURLINFO_NAMELOOKUP_TIME.md
.TH CURLINFO_NAMELOOKUP_TIME 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_NAMELOOKUP_TIME \- get the name lookup time
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_NAMELOOKUP_TIME,
double *timep);
.fi
.SH 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.4.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_NAMELOOKUP_TIME_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

50
3rdparty/curl/share/man/man3/CURLINFO_NAMELOOKUP_TIME_T.3 vendored Normal file
View File

@ -0,0 +1,50 @@
.\" generated by cd2nroff 0.1 from CURLINFO_NAMELOOKUP_TIME_T.md
.TH CURLINFO_NAMELOOKUP_TIME_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_NAMELOOKUP_TIME_T \- get the name lookup time in microseconds
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_NAMELOOKUP_TIME_T,
curl_off_t *timep);
.fi
.SH 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.61.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_NAMELOOKUP_TIME (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

46
3rdparty/curl/share/man/man3/CURLINFO_NUM_CONNECTS.3 vendored Normal file
View File

@ -0,0 +1,46 @@
.\" generated by cd2nroff 0.1 from CURLINFO_NUM_CONNECTS.md
.TH CURLINFO_NUM_CONNECTS 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_NUM_CONNECTS \- get number of created connections
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_NUM_CONNECTS, long *nump);
.fi
.SH 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 \fICURLINFO_REDIRECT_COUNT(3)\fP you are able to know how
many times libcurl successfully reused existing connection(s) or not. See the
connection options of \fIcurl_easy_setopt(3)\fP to see how libcurl tries to make
persistent connections to save time.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.12.3
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

51
3rdparty/curl/share/man/man3/CURLINFO_OS_ERRNO.3 vendored Normal file
View File

@ -0,0 +1,51 @@
.\" generated by cd2nroff 0.1 from CURLINFO_OS_ERRNO.md
.TH CURLINFO_OS_ERRNO 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_OS_ERRNO \- get errno number from last connect failure
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_OS_ERRNO, long *errnop);
.fi
.SH 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.
libcurl network\-related errors that may have a saved errno are:
CURLE_COULDNT_CONNECT, CURLE_FAILED_INIT, CURLE_INTERFACE_FAILED,
CURLE_OPERATION_TIMEDOUT, CURLE_RECV_ERROR, CURLE_SEND_ERROR.
Since 8.8.0 libcurl clears the easy handle\(aqs saved errno before performing the
transfer. Prior versions did not clear the saved errno, which means if a saved
errno is retrieved it could be from a previous transfer on the same handle.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.12.2
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

52
3rdparty/curl/share/man/man3/CURLINFO_POSTTRANSFER_TIME_T.3 vendored Normal file
View File

@ -0,0 +1,52 @@
.\" generated by cd2nroff 0.1 from CURLINFO_POSTTRANSFER_TIME_T.md
.TH CURLINFO_POSTTRANSFER_TIME_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_POSTTRANSFER_TIME_T \- get the time until the last byte is sent
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_POSTTRANSFER_TIME_T,
curl_off_t *timep);
.fi
.SH DESCRIPTION
Pass a pointer to a curl_off_t to receive the time, in microseconds,
it took from the start until the last byte is sent by libcurl.
When a redirect is followed, the time from each request is added together.
See also the TIMES overview in the \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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(CURLE_OK == res) {
curl_off_t posttransfer;
res = curl_easy_getinfo(curl, CURLINFO_POSTTRANSFER_TIME_T,
&posttransfer);
if(CURLE_OK == res) {
printf("Request sent after: %" CURL_FORMAT_CURL_OFF_T ".%06ld us",
posttransfer / 1000000, (long)(posttransfer % 1000000));
}
}
/* always cleanup */
curl_easy_cleanup(curl);
}
}
.fi
.SH AVAILABILITY
Added in curl 8.10.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_PRETRANSFER_TIME_T (3),
.BR CURLOPT_TIMEOUT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

54
3rdparty/curl/share/man/man3/CURLINFO_PRETRANSFER_TIME.3 vendored Normal file
View File

@ -0,0 +1,54 @@
.\" generated by cd2nroff 0.1 from CURLINFO_PRETRANSFER_TIME.md
.TH CURLINFO_PRETRANSFER_TIME 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_PRETRANSFER_TIME \- get the time until the file transfer start
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PRETRANSFER_TIME,
double *timep);
.fi
.SH 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.4.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CONNECT_TIME_T (3),
.BR CURLINFO_PRETRANSFER_TIME_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

56
3rdparty/curl/share/man/man3/CURLINFO_PRETRANSFER_TIME_T.3 vendored Normal file
View File

@ -0,0 +1,56 @@
.\" generated by cd2nroff 0.1 from CURLINFO_PRETRANSFER_TIME_T.md
.TH CURLINFO_PRETRANSFER_TIME_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_PRETRANSFER_TIME_T \- get the time until the file transfer start
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PRETRANSFER_TIME_T,
curl_off_t *timep);
.fi
.SH 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.61.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CONNECT_TIME (3),
.BR CURLINFO_PRETRANSFER_TIME_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

54
3rdparty/curl/share/man/man3/CURLINFO_PRIMARY_IP.3 vendored Normal file
View File

@ -0,0 +1,54 @@
.\" generated by cd2nroff 0.1 from CURLINFO_PRIMARY_IP.md
.TH CURLINFO_PRIMARY_IP 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_PRIMARY_IP \- get IP address of last connection
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PRIMARY_IP, char **ip);
.fi
.SH 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
\fBcurl\fP 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 \fBip\fP pointer is NULL or points to private memory. You MUST NOT free \-
it gets freed when you call \fIcurl_easy_cleanup(3)\fP on the corresponding
CURL handle.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
.fi
.SH AVAILABILITY
Added in curl 7.19.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_LOCAL_IP (3),
.BR CURLINFO_LOCAL_PORT (3),
.BR CURLINFO_PRIMARY_PORT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

48
3rdparty/curl/share/man/man3/CURLINFO_PRIMARY_PORT.3 vendored Normal file
View File

@ -0,0 +1,48 @@
.\" generated by cd2nroff 0.1 from CURLINFO_PRIMARY_PORT.md
.TH CURLINFO_PRIMARY_PORT 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_PRIMARY_PORT \- get the latest destination port number
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PRIMARY_PORT, long *portp);
.fi
.SH DESCRIPTION
Pass a pointer to a long to receive the destination port of the most recent
connection done with this \fBcurl\fP 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.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.21.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_LOCAL_PORT (3),
.BR CURLINFO_PRIMARY_IP (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

49
3rdparty/curl/share/man/man3/CURLINFO_PRIVATE.3 vendored Normal file
View File

@ -0,0 +1,49 @@
.\" generated by cd2nroff 0.1 from CURLINFO_PRIVATE.md
.TH CURLINFO_PRIVATE 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_PRIVATE \- get the private pointer
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PRIVATE, char **private);
.fi
.SH DESCRIPTION
Pass a pointer to a char pointer to receive the pointer to the private data
associated with the curl handle (set with the \fICURLOPT_PRIVATE(3)\fP).
Please note that for internal reasons, the value is returned as a char
pointer, although effectively being a \(aqvoid *\(aq.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.10.3
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_PRIVATE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

56
3rdparty/curl/share/man/man3/CURLINFO_PROTOCOL.3 vendored Normal file
View File

@ -0,0 +1,56 @@
.\" generated by cd2nroff 0.1 from CURLINFO_PROTOCOL.md
.TH CURLINFO_PROTOCOL 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_PROTOCOL \- get the protocol used in the connection
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PROTOCOL, long *p);
.fi
.SH DESCRIPTION
This option is deprecated. We strongly recommend using
\fICURLINFO_SCHEME(3)\fP 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:
.nf
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
.fi
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH DEPRECATED
Deprecated since 7.85.0.
.SH AVAILABILITY
Added in curl 7.52.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_RESPONSE_CODE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

57
3rdparty/curl/share/man/man3/CURLINFO_PROXYAUTH_AVAIL.3 vendored Normal file
View File

@ -0,0 +1,57 @@
.\" generated by cd2nroff 0.1 from CURLINFO_PROXYAUTH_AVAIL.md
.TH CURLINFO_PROXYAUTH_AVAIL 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_PROXYAUTH_AVAIL \- get available HTTP proxy authentication methods
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PROXYAUTH_AVAIL,
long *authp);
.fi
.SH 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 \fICURLOPT_PROXYAUTH(3)\fP option for \fIcurl_easy_setopt(3)\fP.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.10.8
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_HTTPAUTH_AVAIL (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

86
3rdparty/curl/share/man/man3/CURLINFO_PROXY_ERROR.3 vendored Normal file
View File

@ -0,0 +1,86 @@
.\" generated by cd2nroff 0.1 from CURLINFO_PROXY_ERROR.md
.TH CURLINFO_PROXY_ERROR 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_PROXY_ERROR \- get the detailed (SOCKS) proxy error
.SH SYNOPSIS
.nf
#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);
.fi
.SH DESCRIPTION
Pass a pointer to a long to receive a detailed error code when the most recent
transfer returned a \fBCURLE_PROXY\fP error. That error code matches the
\fBCURLproxycode\fP set.
The error code is zero (\fBCURLPX_OK\fP) if no response code was available.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.73.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_RESPONSE_CODE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3),
.BR libcurl-errors (3)

59
3rdparty/curl/share/man/man3/CURLINFO_PROXY_SSL_VERIFYRESULT.3 vendored Normal file
View File

@ -0,0 +1,59 @@
.\" generated by cd2nroff 0.1 from CURLINFO_PROXY_SSL_VERIFYRESULT.md
.TH CURLINFO_PROXY_SSL_VERIFYRESULT 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_PROXY_SSL_VERIFYRESULT \- get the result of the proxy certificate verification
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_PROXY_SSL_VERIFYRESULT,
long *result);
.fi
.SH DESCRIPTION
Pass a pointer to a long to receive the result of the certificate verification
that was requested (using the \fICURLOPT_PROXY_SSL_VERIFYPEER(3)\fP
option. This is only used for HTTPS proxies.
0 is a positive result. Non\-zero is an error.
.SH PROTOCOLS
This functionality affects all TLS based protocols: HTTPS, FTPS, IMAPS, POP3S, SMTPS etc.
This option works only with the following TLS backends:
GnuTLS and OpenSSL
.SH EXAMPLE
.nf
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_cleanup(curl);
return 1;
}
res = curl_easy_getinfo(curl, CURLINFO_PROXY_SSL_VERIFYRESULT,
&verifyresult);
if(!res) {
printf("The peer verification said %s\\n",
(verifyresult ? "bad" : "fine"));
}
curl_easy_cleanup(curl);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.52.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_SSL_VERIFYRESULT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

51
3rdparty/curl/share/man/man3/CURLINFO_QUEUE_TIME_T.3 vendored Normal file
View File

@ -0,0 +1,51 @@
.\" generated by cd2nroff 0.1 from CURLINFO_QUEUE_TIME_T.md
.TH CURLINFO_QUEUE_TIME_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_QUEUE_TIME_T \- time this transfer was queued
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_QUEUE_TIME_T,
curl_off_t *timep);
.fi
.SH 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 8.6.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_STARTTRANSFER_TIME_T (3),
.BR CURLOPT_TIMEOUT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

43
3rdparty/curl/share/man/man3/CURLINFO_REDIRECT_COUNT.3 vendored Normal file
View File

@ -0,0 +1,43 @@
.\" generated by cd2nroff 0.1 from CURLINFO_REDIRECT_COUNT.md
.TH CURLINFO_REDIRECT_COUNT 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_REDIRECT_COUNT \- get the number of redirects
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REDIRECT_COUNT,
long *countp);
.fi
.SH DESCRIPTION
Pass a pointer to a long to receive the total number of redirections that were
actually followed.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.9.7
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_REDIRECT_URL (3),
.BR CURLOPT_FOLLOWLOCATION (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

51
3rdparty/curl/share/man/man3/CURLINFO_REDIRECT_TIME.3 vendored Normal file
View File

@ -0,0 +1,51 @@
.\" generated by cd2nroff 0.1 from CURLINFO_REDIRECT_TIME.md
.TH CURLINFO_REDIRECT_TIME 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_REDIRECT_TIME \- get the time for all redirection steps
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REDIRECT_TIME,
double *timep);
.fi
.SH 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. \fICURLINFO_REDIRECT_TIME(3)\fP contains
the complete execution time for multiple redirections.
See also the TIMES overview in the \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.9.7
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_REDIRECT_COUNT (3),
.BR CURLINFO_REDIRECT_TIME_T (3),
.BR CURLINFO_REDIRECT_URL (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

53
3rdparty/curl/share/man/man3/CURLINFO_REDIRECT_TIME_T.3 vendored Normal file
View File

@ -0,0 +1,53 @@
.\" generated by cd2nroff 0.1 from CURLINFO_REDIRECT_TIME_T.md
.TH CURLINFO_REDIRECT_TIME_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_REDIRECT_TIME_T \- get the time for all redirection steps
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REDIRECT_TIME_T,
curl_off_t *timep);
.fi
.SH 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.
\fICURLINFO_REDIRECT_TIME_T(3)\fP holds the complete execution time for
multiple redirections.
See also the TIMES overview in the \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.61.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_REDIRECT_COUNT (3),
.BR CURLINFO_REDIRECT_TIME (3),
.BR CURLINFO_REDIRECT_URL (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

50
3rdparty/curl/share/man/man3/CURLINFO_REDIRECT_URL.3 vendored Normal file
View File

@ -0,0 +1,50 @@
.\" generated by cd2nroff 0.1 from CURLINFO_REDIRECT_URL.md
.TH CURLINFO_REDIRECT_URL 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_REDIRECT_URL \- get the URL a redirect would go to
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REDIRECT_URL, char **urlp);
.fi
.SH DESCRIPTION
Pass a pointer to a char pointer to receive the URL a redirect \fIwould\fP take
you to if you would enable \fICURLOPT_FOLLOWLOCATION(3)\fP. 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 \fICURLOPT_MAXREDIRS(3)\fP limit prevented a redirect to
happen (since 7.54.1).
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.18.2
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_REDIRECT_COUNT (3),
.BR CURLINFO_REDIRECT_TIME_T (3),
.BR CURLOPT_FOLLOWLOCATION (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

48
3rdparty/curl/share/man/man3/CURLINFO_REFERER.3 vendored Normal file
View File

@ -0,0 +1,48 @@
.\" generated by cd2nroff 0.1 from CURLINFO_REFERER.md
.TH CURLINFO_REFERER 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_REFERER \- get the used referrer request header
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REFERER, char **hdrp);
.fi
.SH DESCRIPTION
Pass in a pointer to a char pointer and get the referrer header used in the
most recent request.
The \fBhdrp\fP pointer is NULL or points to private memory you MUST NOT free \-
it gets freed when you call \fIcurl_easy_cleanup(3)\fP on the corresponding
CURL handle.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.76.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_REFERER (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_header (3),
.BR curl_easy_setopt (3)

44
3rdparty/curl/share/man/man3/CURLINFO_REQUEST_SIZE.3 vendored Normal file
View File

@ -0,0 +1,44 @@
.\" generated by cd2nroff 0.1 from CURLINFO_REQUEST_SIZE.md
.TH CURLINFO_REQUEST_SIZE 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_REQUEST_SIZE \- get size of sent request
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_REQUEST_SIZE, long *sizep);
.fi
.SH 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 \fICURLOPT_FOLLOWLOCATION(3)\fP is enabled.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.4.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_HEADER_SIZE (3),
.BR CURLINFO_SIZE_DOWNLOAD_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

48
3rdparty/curl/share/man/man3/CURLINFO_RESPONSE_CODE.3 vendored Normal file
View File

@ -0,0 +1,48 @@
.\" generated by cd2nroff 0.1 from CURLINFO_RESPONSE_CODE.md
.TH CURLINFO_RESPONSE_CODE 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_RESPONSE_CODE \- get the last response code
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RESPONSE_CODE, long *codep);
.fi
.SH 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\(aqs CONNECT response should be read with
\fICURLINFO_HTTP_CONNECTCODE(3)\fP and not this.
.SH PROTOCOLS
This functionality affects ftp, http, ldap and smtp
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH NOTES
The former name, CURLINFO_HTTP_CODE, was added in 7.4.1. Support for SMTP
responses added in 7.25.0, for OpenLDAP in 7.81.0.
.SH AVAILABILITY
Added in curl 7.10.8
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_HTTP_CONNECTCODE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

50
3rdparty/curl/share/man/man3/CURLINFO_RETRY_AFTER.3 vendored Normal file
View File

@ -0,0 +1,50 @@
.\" generated by cd2nroff 0.1 from CURLINFO_RETRY_AFTER.md
.TH CURLINFO_RETRY_AFTER 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_RETRY_AFTER \- returns the Retry\-After retry delay
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RETRY_AFTER,
curl_off_t *retry);
.fi
.SH 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
\fICURLINFO_RETRY_AFTER(3)\fP always returns the number of seconds to wait \-
or zero if there was no header or the header could not be parsed.
.SH DEFAULT
Zero if there was no header.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.66.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_HEADERFUNCTION (3),
.BR CURLOPT_STDERR (3),
.BR curl_easy_header (3)

42
3rdparty/curl/share/man/man3/CURLINFO_RTSP_CLIENT_CSEQ.3 vendored Normal file
View File

@ -0,0 +1,42 @@
.\" generated by cd2nroff 0.1 from CURLINFO_RTSP_CLIENT_CSEQ.md
.TH CURLINFO_RTSP_CLIENT_CSEQ 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_RTSP_CLIENT_CSEQ \- get the next RTSP client CSeq
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RTSP_CLIENT_CSEQ,
long *cseq);
.fi
.SH DESCRIPTION
Pass a pointer to a long to receive the next CSeq that is expected to be used
by the application.
.SH PROTOCOLS
This functionality affects rtsp only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.20.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_RTSP_CSEQ_RECV (3),
.BR CURLINFO_RTSP_SERVER_CSEQ (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

42
3rdparty/curl/share/man/man3/CURLINFO_RTSP_CSEQ_RECV.3 vendored Normal file
View File

@ -0,0 +1,42 @@
.\" generated by cd2nroff 0.1 from CURLINFO_RTSP_CSEQ_RECV.md
.TH CURLINFO_RTSP_CSEQ_RECV 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_RTSP_CSEQ_RECV \- get the recently received CSeq
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RTSP_CSEQ_RECV, long *cseq);
.fi
.SH DESCRIPTION
Pass a pointer to a long to receive the most recently received CSeq from the
server. If your application encounters a \fICURLE_RTSP_CSEQ_ERROR\fP then you
may wish to troubleshoot and/or fix the CSeq mismatch by peeking at this
value.
.SH PROTOCOLS
This functionality affects rtsp only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.20.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_RTSP_SERVER_CSEQ (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

46
3rdparty/curl/share/man/man3/CURLINFO_RTSP_SERVER_CSEQ.3 vendored Normal file
View File

@ -0,0 +1,46 @@
.\" generated by cd2nroff 0.1 from CURLINFO_RTSP_SERVER_CSEQ.md
.TH CURLINFO_RTSP_SERVER_CSEQ 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_RTSP_SERVER_CSEQ \- get the next RTSP server CSeq
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RTSP_SERVER_CSEQ,
long *cseq);
.fi
.SH 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.
.SH PROTOCOLS
This functionality affects rtsp only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.20.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_RTSP_CSEQ_RECV (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

47
3rdparty/curl/share/man/man3/CURLINFO_RTSP_SESSION_ID.3 vendored Normal file
View File

@ -0,0 +1,47 @@
.\" generated by cd2nroff 0.1 from CURLINFO_RTSP_SESSION_ID.md
.TH CURLINFO_RTSP_SESSION_ID 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_RTSP_SESSION_ID \- get RTSP session ID
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_RTSP_SESSION_ID, char **id);
.fi
.SH 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 \fBid\fP pointer is NULL or points to private memory. You MUST NOT free \-
it gets freed when you call \fIcurl_easy_cleanup(3)\fP on the corresponding
CURL handle.
.SH PROTOCOLS
This functionality affects rtsp only
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.20.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_RTSP_CSEQ_RECV (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

52
3rdparty/curl/share/man/man3/CURLINFO_SCHEME.3 vendored Normal file
View File

@ -0,0 +1,52 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SCHEME.md
.TH CURLINFO_SCHEME 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SCHEME \- get the URL scheme (sometimes called protocol) used in the connection
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SCHEME, char **scheme);
.fi
.SH 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 \fBhandle\fP.
The \fBscheme\fP pointer is NULL or points to private memory. You MUST NOT
free \- it gets freed when you call \fIcurl_easy_cleanup(3)\fP on the corresponding
CURL handle.
The returned scheme might be upper or lowercase. Do comparisons case
insensitively.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.52.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_EFFECTIVE_URL (3),
.BR CURLINFO_PROTOCOL (3),
.BR CURLINFO_RESPONSE_CODE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

56
3rdparty/curl/share/man/man3/CURLINFO_SIZE_DOWNLOAD.3 vendored Normal file
View File

@ -0,0 +1,56 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SIZE_DOWNLOAD.md
.TH CURLINFO_SIZE_DOWNLOAD 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SIZE_DOWNLOAD \- get the number of downloaded bytes
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SIZE_DOWNLOAD, double *dlp);
.fi
.SH 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\(aqs also commonly
called body. All meta and header data is excluded and not included in this
number.
\fICURLINFO_SIZE_DOWNLOAD_T(3)\fP is a newer replacement that returns a more
sensible variable type.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH DEPRECATED
Deprecated since 7.55.0.
.SH AVAILABILITY
Added in curl 7.4.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_SIZE_DOWNLOAD_T (3),
.BR CURLINFO_SIZE_UPLOAD_T (3),
.BR CURLOPT_MAXFILESIZE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

51
3rdparty/curl/share/man/man3/CURLINFO_SIZE_DOWNLOAD_T.3 vendored Normal file
View File

@ -0,0 +1,51 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SIZE_DOWNLOAD_T.md
.TH CURLINFO_SIZE_DOWNLOAD_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SIZE_DOWNLOAD_T \- get the number of downloaded bytes
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SIZE_DOWNLOAD_T,
curl_off_t *dlp);
.fi
.SH DESCRIPTION
Pass a pointer to a \fIcurl_off_t\fP 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\(aqs also
commonly called body. All meta and header data is excluded from this amount.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH AVAILABILITY
Added in curl 7.55.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_SIZE_DOWNLOAD (3),
.BR CURLINFO_SIZE_UPLOAD_T (3),
.BR CURLOPT_MAXFILESIZE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

52
3rdparty/curl/share/man/man3/CURLINFO_SIZE_UPLOAD.3 vendored Normal file
View File

@ -0,0 +1,52 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SIZE_UPLOAD.md
.TH CURLINFO_SIZE_UPLOAD 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SIZE_UPLOAD \- get the number of uploaded bytes
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SIZE_UPLOAD,
double *uploadp);
.fi
.SH DESCRIPTION
Pass a pointer to a double to receive the total amount of bytes that were
uploaded.
\fICURLINFO_SIZE_UPLOAD_T(3)\fP is a newer replacement that returns a more
sensible variable type.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH DEPRECATED
Deprecated since 7.55.0.
.SH AVAILABILITY
Added in curl 7.4.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_SIZE_DOWNLOAD_T (3),
.BR CURLINFO_SIZE_UPLOAD_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

47
3rdparty/curl/share/man/man3/CURLINFO_SIZE_UPLOAD_T.3 vendored Normal file
View File

@ -0,0 +1,47 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SIZE_UPLOAD_T.md
.TH CURLINFO_SIZE_UPLOAD_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SIZE_UPLOAD_T \- get the number of uploaded bytes
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SIZE_UPLOAD_T,
curl_off_t *uploadp);
.fi
.SH DESCRIPTION
Pass a pointer to a \fIcurl_off_t\fP to receive the total amount of bytes that
were uploaded.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH AVAILABILITY
Added in curl 7.55.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_SIZE_DOWNLOAD_T (3),
.BR CURLINFO_SIZE_UPLOAD (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

52
3rdparty/curl/share/man/man3/CURLINFO_SPEED_DOWNLOAD.3 vendored Normal file
View File

@ -0,0 +1,52 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SPEED_DOWNLOAD.md
.TH CURLINFO_SPEED_DOWNLOAD 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SPEED_DOWNLOAD \- get download speed
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SPEED_DOWNLOAD,
double *speed);
.fi
.SH DESCRIPTION
Pass a pointer to a double to receive the average download speed that curl
measured for the complete download. Measured in bytes/second.
\fICURLINFO_SPEED_DOWNLOAD_T(3)\fP is a newer replacement that returns a more
sensible variable type.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH DEPRECATED
Deprecated since 7.55.0.
.SH AVAILABILITY
Added in curl 7.4.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_SIZE_UPLOAD_T (3),
.BR CURLINFO_SPEED_UPLOAD (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

48
3rdparty/curl/share/man/man3/CURLINFO_SPEED_DOWNLOAD_T.3 vendored Normal file
View File

@ -0,0 +1,48 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SPEED_DOWNLOAD_T.md
.TH CURLINFO_SPEED_DOWNLOAD_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SPEED_DOWNLOAD_T \- get download speed
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SPEED_DOWNLOAD_T,
curl_off_t *speed);
.fi
.SH DESCRIPTION
Pass a pointer to a \fIcurl_off_t\fP to receive the average download speed
that curl measured for the complete download. Measured in bytes/second.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH AVAILABILITY
Added in curl 7.55.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_SIZE_UPLOAD_T (3),
.BR CURLINFO_SPEED_UPLOAD_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

50
3rdparty/curl/share/man/man3/CURLINFO_SPEED_UPLOAD.3 vendored Normal file
View File

@ -0,0 +1,50 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SPEED_UPLOAD.md
.TH CURLINFO_SPEED_UPLOAD 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SPEED_UPLOAD \- get upload speed
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SPEED_UPLOAD, double *speed);
.fi
.SH DESCRIPTION
Pass a pointer to a double to receive the average upload speed that curl
measured for the complete upload. Measured in bytes/second.
\fICURLINFO_SPEED_UPLOAD_T(3)\fP is a newer replacement that returns a more
sensible variable type.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH DEPRECATED
Deprecated since 7.55.0.
.SH AVAILABILITY
Added in curl 7.4.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_SPEED_DOWNLOAD_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

46
3rdparty/curl/share/man/man3/CURLINFO_SPEED_UPLOAD_T.3 vendored Normal file
View File

@ -0,0 +1,46 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SPEED_UPLOAD_T.md
.TH CURLINFO_SPEED_UPLOAD_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SPEED_UPLOAD_T \- get upload speed
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SPEED_UPLOAD_T,
curl_off_t *speed);
.fi
.SH DESCRIPTION
Pass a pointer to a \fIcurl_off_t\fP to receive the average upload speed that
curl measured for the complete upload. Measured in bytes/second.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH AVAILABILITY
Added in curl 7.55.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_SPEED_DOWNLOAD_T (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

49
3rdparty/curl/share/man/man3/CURLINFO_SSL_ENGINES.3 vendored Normal file
View File

@ -0,0 +1,49 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SSL_ENGINES.md
.TH CURLINFO_SSL_ENGINES 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SSL_ENGINES \- get an slist of OpenSSL crypto\-engines
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SSL_ENGINES,
struct curl_slist **engine_list);
.fi
.SH DESCRIPTION
Pass the address of a \(aqstruct curl_slist *\(aq 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. \fBNOTE:\fP you must call \fIcurl_slist_free_all(3)\fP
on the list pointer once you are done with it, as libcurl does not free this
data for you.
.SH PROTOCOLS
This functionality affects all TLS based protocols: HTTPS, FTPS, IMAPS, POP3S, SMTPS etc.
This option works only with the following TLS backends:
OpenSSL
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.12.3
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_SSLENGINE (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

58
3rdparty/curl/share/man/man3/CURLINFO_SSL_VERIFYRESULT.3 vendored Normal file
View File

@ -0,0 +1,58 @@
.\" generated by cd2nroff 0.1 from CURLINFO_SSL_VERIFYRESULT.md
.TH CURLINFO_SSL_VERIFYRESULT 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_SSL_VERIFYRESULT \- get the result of the certificate verification
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_SSL_VERIFYRESULT,
long *result);
.fi
.SH DESCRIPTION
Pass a pointer to a long to receive the result of the server SSL certificate
verification that was requested (using the \fICURLOPT_SSL_VERIFYPEER(3)\fP
option).
0 is a positive result. Non\-zero is an error.
.SH PROTOCOLS
This functionality affects all TLS based protocols: HTTPS, FTPS, IMAPS, POP3S, SMTPS etc.
This option works only with the following TLS backends:
GnuTLS and OpenSSL
.SH EXAMPLE
.nf
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_cleanup(curl);
return 1;
}
res = curl_easy_getinfo(curl, CURLINFO_SSL_VERIFYRESULT,
&verifyresult);
if(!res) {
printf("The peer verification said %s\\n",
(verifyresult ? "bad" : "fine"));
}
curl_easy_cleanup(curl);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.5
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_PROXY_SSL_VERIFYRESULT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

52
3rdparty/curl/share/man/man3/CURLINFO_STARTTRANSFER_TIME.3 vendored Normal file
View File

@ -0,0 +1,52 @@
.\" generated by cd2nroff 0.1 from CURLINFO_STARTTRANSFER_TIME.md
.TH CURLINFO_STARTTRANSFER_TIME 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_STARTTRANSFER_TIME \- get the time until the first byte is received
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_STARTTRANSFER_TIME,
double *timep);
.fi
.SH 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
\fICURLINFO_PRETRANSFER_TIME(3)\fP 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.9.2
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_STARTTRANSFER_TIME_T (3),
.BR CURLOPT_TIMEOUT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

54
3rdparty/curl/share/man/man3/CURLINFO_STARTTRANSFER_TIME_T.3 vendored Normal file
View File

@ -0,0 +1,54 @@
.\" generated by cd2nroff 0.1 from CURLINFO_STARTTRANSFER_TIME_T.md
.TH CURLINFO_STARTTRANSFER_TIME_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_STARTTRANSFER_TIME_T \- get the time until the first byte is received
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_STARTTRANSFER_TIME_T,
curl_off_t *timep);
.fi
.SH 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
\fICURLINFO_PRETRANSFER_TIME_T(3)\fP 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.61.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_STARTTRANSFER_TIME (3),
.BR CURLOPT_TIMEOUT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

60
3rdparty/curl/share/man/man3/CURLINFO_TLS_SESSION.3 vendored Normal file
View File

@ -0,0 +1,60 @@
.\" generated by cd2nroff 0.1 from CURLINFO_TLS_SESSION.md
.TH CURLINFO_TLS_SESSION 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_TLS_SESSION \- get TLS session info
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_TLS_SESSION,
struct curl_tlssessioninfo **session);
.fi
.SH DESCRIPTION
\fBThis option has been superseded\fP by \fICURLINFO_TLS_SSL_PTR(3)\fP 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 \fICURLINFO_TLS_SSL_PTR(3)\fP except in the
case of OpenSSL. If the session \fIbackend\fP is CURLSSLBACKEND_OPENSSL the
session \fIinternals\fP pointer varies depending on the option:
\fICURLINFO_TLS_SESSION(3)\fP OpenSSL session \fIinternals\fP is \fBSSL_CTX \fP*.
\fICURLINFO_TLS_SSL_PTR(3)\fP OpenSSL session \fIinternals\fP is \fBSSL \fP*.
You can obtain an \fBSSL_CTX\fP pointer from an SSL pointer using OpenSSL
function \fISSL_get_SSL_CTX(3)\fP. Therefore unless you need compatibility
with older versions of libcurl use \fICURLINFO_TLS_SSL_PTR(3)\fP. Refer to
that document for more information.
.SH PROTOCOLS
This functionality affects all TLS based protocols: HTTPS, FTPS, IMAPS, POP3S, SMTPS etc.
This option works only with the following TLS backends:
GnuTLS and OpenSSL
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH DEPRECATED
Deprecated since 7.48.0
.SH AVAILABILITY
Added in curl 7.34.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_TLS_SSL_PTR (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

140
3rdparty/curl/share/man/man3/CURLINFO_TLS_SSL_PTR.3 vendored Normal file
View File

@ -0,0 +1,140 @@
.\" generated by cd2nroff 0.1 from CURLINFO_TLS_SSL_PTR.md
.TH CURLINFO_TLS_SSL_PTR 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_TLS_SESSION, CURLINFO_TLS_SSL_PTR \- get TLS session info
.SH SYNOPSIS
.nf
#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);
.fi
.SH DESCRIPTION
Pass a pointer to a \fIstruct curl_tlssessioninfo \fP*. The pointer is initialized
to refer to a \fIstruct curl_tlssessioninfo \fP* 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 \fBLIMITATIONS\fP section.
.nf
struct curl_tlssessioninfo {
curl_sslbackend backend;
void *internals;
};
.fi
The \fIbackend\fP 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 or
CURLSSLBACKEND_SCHANNEL. (Note that the OpenSSL
forks are all reported as just OpenSSL here.)
The \fIinternals\fP struct member points to a TLS library specific pointer for
the active ("in use") SSL connection, with the following underlying types:
.IP GnuTLS
\fBgnutls_session_t\fP
.IP OpenSSL
\fICURLINFO_TLS_SESSION(3)\fP: \fBSSL_CTX \fP*
\fICURLINFO_TLS_SSL_PTR(3)\fP: \fBSSL \fP*
Since 7.48.0 the \fIinternals\fP member can point to these other SSL backends
as well:
.IP mbedTLS
\fBmbedTLS_ssl_context \fP*
.IP "Secure Channel"
\fBCtxtHandle \fP*
.IP "Secure Transport"
\fBSSLContext \fP*
.IP wolfSSL
\fBSSL \fP*
.PP
If the \fIinternals\fP 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. \fIcurl_easy_perform(3)\fP has
returned).
.SH 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
\fICURLOPT_USE_SSL(3)\fP. 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
\fICURLOPT_SSL_CTX_FUNCTION(3)\fP 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
.SH PROTOCOLS
This functionality affects all TLS based protocols: HTTPS, FTPS, IMAPS, POP3S, SMTPS etc.
This option works only with the following TLS backends:
BearSSL, GnuTLS, OpenSSL, Schannel, Secure Transport, mbedTLS and wolfSSL
.SH EXAMPLE
.nf
#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;
}
.fi
.SH HISTORY
This option supersedes \fICURLINFO_TLS_SESSION(3)\fP which was added in 7.34.0.
This option is exactly the same as that option except in the case of OpenSSL.
.SH AVAILABILITY
Added in curl 7.48.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_TLS_SESSION (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

50
3rdparty/curl/share/man/man3/CURLINFO_TOTAL_TIME.3 vendored Normal file
View File

@ -0,0 +1,50 @@
.\" generated by cd2nroff 0.1 from CURLINFO_TOTAL_TIME.md
.TH CURLINFO_TOTAL_TIME 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_TOTAL_TIME \- get total time of previous transfer
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_TOTAL_TIME, double *timep);
.fi
.SH 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.4.1
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_TOTAL_TIME_T (3),
.BR CURLOPT_TIMEOUT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

52
3rdparty/curl/share/man/man3/CURLINFO_TOTAL_TIME_T.3 vendored Normal file
View File

@ -0,0 +1,52 @@
.\" generated by cd2nroff 0.1 from CURLINFO_TOTAL_TIME_T.md
.TH CURLINFO_TOTAL_TIME_T 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_TOTAL_TIME_T \- get total time of previous transfer in microseconds
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_TOTAL_TIME_T,
curl_off_t *timep);
.fi
.SH 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 \fIcurl_easy_getinfo(3)\fP man page.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 7.61.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_TOTAL_TIME (3),
.BR CURLOPT_TIMEOUT (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

50
3rdparty/curl/share/man/man3/CURLINFO_USED_PROXY.3 vendored Normal file
View File

@ -0,0 +1,50 @@
.\" generated by cd2nroff 0.1 from CURLINFO_USED_PROXY.md
.TH CURLINFO_USED_PROXY 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_USED_PROXY \- whether the transfer used a proxy
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_USED_PROXY,
long *authp);
.fi
.SH 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.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
.fi
.SH AVAILABILITY
Added in curl 8.7.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLOPT_NOPROXY (3),
.BR CURLOPT_PROXY (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

51
3rdparty/curl/share/man/man3/CURLINFO_XFER_ID.3 vendored Normal file
View File

@ -0,0 +1,51 @@
.\" generated by cd2nroff 0.1 from CURLINFO_XFER_ID.md
.TH CURLINFO_XFER_ID 3 "2024-10-11" libcurl
.SH NAME
CURLINFO_XFER_ID \- get the ID of a transfer
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLcode curl_easy_getinfo(CURL *handle, CURLINFO_XFER_ID,
curl_off_t *xfer_id);
.fi
.SH DESCRIPTION
Pass a pointer to a \fIcurl_off_t\fP 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.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
}
}
}
.fi
.SH AVAILABILITY
Added in curl 8.2.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLINFO_CONN_ID (3),
.BR curl_easy_getinfo (3),
.BR curl_easy_setopt (3)

40
3rdparty/curl/share/man/man3/CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE.3 vendored Normal file
View File

@ -0,0 +1,40 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE.md
.TH CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE \- chunk length threshold for pipelining
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE,
long size);
.fi
.SH DESCRIPTION
No function since pipelining was removed in 7.62.0.
Pass a long with a \fBsize\fP in bytes. If a transfer in a pipeline is
currently processing a chunked (Transfer\-encoding: chunked) request with a
current chunk length larger than \fICURLMOPT_CHUNK_LENGTH_PENALTY_SIZE(3)\fP,
that pipeline is not considered for additional requests, even if it is shorter
than \fICURLMOPT_MAX_PIPELINE_LENGTH(3)\fP.
.SH DEFAULT
0, which means that penalization is inactive.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
int main(void)
{
CURLM *m = curl_multi_init();
long maxchunk = 10000;
curl_multi_setopt(m, CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, maxchunk);
}
.fi
.SH AVAILABILITY
Added in curl 7.30.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE (3),
.BR CURLMOPT_MAX_PIPELINE_LENGTH (3),
.BR CURLMOPT_PIPELINING (3)

39
3rdparty/curl/share/man/man3/CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE.3 vendored Normal file
View File

@ -0,0 +1,39 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE.md
.TH CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE \- size threshold for pipelining penalty
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE,
long size);
.fi
.SH DESCRIPTION
No function since pipelining was removed in 7.62.0.
Pass a long with a \fBsize\fP in bytes. If a transfer in a pipeline is
currently processing a request with a Content\-Length larger than this
\fICURLMOPT_CONTENT_LENGTH_PENALTY_SIZE(3)\fP, that pipeline is not considered
for additional requests, even if it is shorter than
\fICURLMOPT_MAX_PIPELINE_LENGTH(3)\fP.
.SH DEFAULT
0, which means that the size penalization is inactive.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
int main(void)
{
CURLM *m = curl_multi_init();
long maxlength = 10000;
curl_multi_setopt(m, CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, maxlength);
}
.fi
.SH AVAILABILITY
Added in curl 7.30.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE (3),
.BR CURLMOPT_PIPELINING (3)

53
3rdparty/curl/share/man/man3/CURLMOPT_MAXCONNECTS.3 vendored Normal file
View File

@ -0,0 +1,53 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_MAXCONNECTS.md
.TH CURLMOPT_MAXCONNECTS 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_MAXCONNECTS \- size of connection cache
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_MAXCONNECTS, long max);
.fi
.SH DESCRIPTION
Pass a long indicating the \fBmax\fP. 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\(aqs use only, when using the easy interface
you should instead use the \fICURLOPT_MAXCONNECTS(3)\fP option.
See \fICURLMOPT_MAX_TOTAL_CONNECTIONS(3)\fP for limiting the number of active
connections.
Changing this value when there are transfers in progress is possible, and the
new value is then used the next time checks are performed. Lowering the value
does however not close down any active transfers, it simply does not allow new
ones to get made.
.SH DEFAULT
See DESCRIPTION
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
int main(void)
{
CURLM *m = curl_multi_init();
/* only keep 10 connections in the cache */
curl_multi_setopt(m, CURLMOPT_MAXCONNECTS, 10L);
}
.fi
.SH AVAILABILITY
Added in curl 7.16.3
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_MAX_HOST_CONNECTIONS (3),
.BR CURLOPT_MAXCONNECTS (3)

38
3rdparty/curl/share/man/man3/CURLMOPT_MAX_CONCURRENT_STREAMS.3 vendored Normal file
View File

@ -0,0 +1,38 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_MAX_CONCURRENT_STREAMS.md
.TH CURLMOPT_MAX_CONCURRENT_STREAMS 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_MAX_CONCURRENT_STREAMS \- max concurrent streams for http2
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_MAX_CONCURRENT_STREAMS,
long max);
.fi
.SH DESCRIPTION
Pass a long indicating the \fBmax\fP. 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.
.SH DEFAULT
100
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
int main(void)
{
CURLM *m = curl_multi_init();
/* max concurrent streams 200 */
curl_multi_setopt(m, CURLMOPT_MAX_CONCURRENT_STREAMS, 200L);
}
.fi
.SH AVAILABILITY
Added in curl 7.67.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_MAXCONNECTS (3),
.BR CURLOPT_MAXCONNECTS (3)

56
3rdparty/curl/share/man/man3/CURLMOPT_MAX_HOST_CONNECTIONS.3 vendored Normal file
View File

@ -0,0 +1,56 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_MAX_HOST_CONNECTIONS.md
.TH CURLMOPT_MAX_HOST_CONNECTIONS 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_MAX_HOST_CONNECTIONS \- max number of connections to a single host
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_MAX_HOST_CONNECTIONS,
long max);
.fi
.SH DESCRIPTION
Pass a long to indicate \fBmax\fP. 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 \fICURLMOPT_MAX_HOST_CONNECTIONS(3)\fP.
When the limit is reached, new sessions are kept pending until a connection
becomes available.
The default \fBmax\fP 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 \fICURLOPT_TIMEOUT_MS(3)\fP 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 \fICURLOPT_CONNECTTIMEOUT_MS(3)\fP timeout is
however treated as a per\-connect timeout.
Changing this value when there are transfers in progress is possible, and the
new value is then used the next time checks are performed. Lowering the value
does however not close down any active transfers, it simply does not allow new
ones to get made.
.SH DEFAULT
0
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
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);
}
.fi
.SH AVAILABILITY
Added in curl 7.30.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_MAXCONNECTS (3),
.BR CURLMOPT_MAX_TOTAL_CONNECTIONS (3)

44
3rdparty/curl/share/man/man3/CURLMOPT_MAX_PIPELINE_LENGTH.3 vendored Normal file
View File

@ -0,0 +1,44 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_MAX_PIPELINE_LENGTH.md
.TH CURLMOPT_MAX_PIPELINE_LENGTH 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_MAX_PIPELINE_LENGTH \- maximum number of requests in a pipeline
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_MAX_PIPELINE_LENGTH,
long max);
.fi
.SH DESCRIPTION
No function since pipelining was removed in 7.62.0.
Pass a long. The set \fBmax\fP 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 \fICURLMOPT_MAX_HOST_CONNECTIONS(3)\fP), or queue the request until one
.nf
of the pipelines to the host is ready to accept a request. Thus, the total
.fi
\fICURLMOPT_MAX_PIPELINE_LENGTH(3)\fP.
.SH DEFAULT
5
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
int main(void)
{
CURLM *m = curl_multi_init();
/* set a more conservative pipe length */
curl_multi_setopt(m, CURLMOPT_MAX_PIPELINE_LENGTH, 3L);
}
.fi
.SH AVAILABILITY
Added in curl 7.30.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_MAX_HOST_CONNECTIONS (3),
.BR CURLMOPT_PIPELINING (3)

49
3rdparty/curl/share/man/man3/CURLMOPT_MAX_TOTAL_CONNECTIONS.3 vendored Normal file
View File

@ -0,0 +1,49 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_MAX_TOTAL_CONNECTIONS.md
.TH CURLMOPT_MAX_TOTAL_CONNECTIONS 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_MAX_TOTAL_CONNECTIONS \- max simultaneously open connections
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_MAX_TOTAL_CONNECTIONS,
long amount);
.fi
.SH DESCRIPTION
Pass a long for the \fBamount\fP. 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
\fICURLMOPT_MAX_TOTAL_CONNECTIONS(3)\fP. When the limit is reached, new
sessions are held pending until there are available connections. If
\fICURLMOPT_PIPELINING(3)\fP 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 \fICURLOPT_TIMEOUT_MS(3)\fP 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 \fICURLOPT_CONNECTTIMEOUT_MS(3)\fP
timeout is however treated as a per\-connect timeout.
.SH DEFAULT
0, which means that there is no limit. It is then simply controlled by the
number of easy handles added.
.SH PROTOCOLS
This functionality affects all supported protocols
.SH EXAMPLE
.nf
int main(void)
{
CURLM *m = curl_multi_init();
/* never do more than 15 connections */
curl_multi_setopt(m, CURLMOPT_MAX_TOTAL_CONNECTIONS, 15L);
}
.fi
.SH AVAILABILITY
Added in curl 7.30.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_MAXCONNECTS (3),
.BR CURLMOPT_MAX_HOST_CONNECTIONS (3)

54
3rdparty/curl/share/man/man3/CURLMOPT_PIPELINING.3 vendored Normal file
View File

@ -0,0 +1,54 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_PIPELINING.md
.TH CURLMOPT_PIPELINING 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_PIPELINING \- enable HTTP multiplexing
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_PIPELINING, long bitmask);
.fi
.SH DESCRIPTION
Pass in the correct value in the \fBbitmask\fP 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.
.IP "CURLPIPE_NOTHING (0)"
Make no attempts at multiplexing.
.IP "CURLPIPE_HTTP1 (1)"
This bit is deprecated and has no effect since version 7.62.0.
.IP "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.
.SH DEFAULT
\fBCURLPIPE_MULTIPLEX\fP
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
int main(void)
{
CURLM *m = curl_multi_init();
/* try HTTP/2 multiplexing */
curl_multi_setopt(m, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
}
.fi
.SH HISTORY
The multiplex support bit was added in 7.43.0. HTTP/1 Pipelining support was
disabled in 7.62.0.
Since 7.62.0, \fBCURLPIPE_MULTIPLEX\fP is enabled by default.
Before that, default was \fBCURLPIPE_NOTHING\fP.
.SH AVAILABILITY
Added in curl 7.16.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE (3),
.BR CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE (3),
.BR CURLMOPT_MAXCONNECTS (3),
.BR CURLMOPT_MAX_HOST_CONNECTIONS (3),
.BR CURLMOPT_MAX_PIPELINE_LENGTH (3),
.BR CURLMOPT_PIPELINING_SITE_BL (3)

49
3rdparty/curl/share/man/man3/CURLMOPT_PIPELINING_SERVER_BL.3 vendored Normal file
View File

@ -0,0 +1,49 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_PIPELINING_SERVER_BL.md
.TH CURLMOPT_PIPELINING_SERVER_BL 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_PIPELINING_SERVER_BL \- pipelining server block list
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_PIPELINING_SERVER_BL,
char **servers);
.fi
.SH DESCRIPTION
No function since pipelining was removed in 7.62.0.
Pass a \fBservers\fP 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.
.SH DEFAULT
NULL, which means that there is no block list.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
.fi
.SH AVAILABILITY
Added in curl 7.30.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_PIPELINING (3),
.BR CURLMOPT_PIPELINING_SITE_BL (3)

45
3rdparty/curl/share/man/man3/CURLMOPT_PIPELINING_SITE_BL.3 vendored Normal file
View File

@ -0,0 +1,45 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_PIPELINING_SITE_BL.md
.TH CURLMOPT_PIPELINING_SITE_BL 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_PIPELINING_SITE_BL \- pipelining host block list
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_PIPELINING_SITE_BL,
char **hosts);
.fi
.SH DESCRIPTION
No function since pipelining was removed in 7.62.0.
Pass a \fBhosts\fP 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.
.SH DEFAULT
NULL, which means that there is no block list.
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
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);
}
.fi
.SH AVAILABILITY
Added in curl 7.30.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_PIPELINING (3),
.BR CURLMOPT_PIPELINING_SERVER_BL (3)

66
3rdparty/curl/share/man/man3/CURLMOPT_PUSHDATA.3 vendored Normal file
View File

@ -0,0 +1,66 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_PUSHDATA.md
.TH CURLMOPT_PUSHDATA 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_PUSHDATA \- pointer to pass to push callback
.SH SYNOPSIS
.nf
#include <curl/curl.h>
CURLMcode curl_multi_setopt(CURLM *handle, CURLMOPT_PUSHDATA, void *pointer);
.fi
.SH DESCRIPTION
Set a \fIpointer\fP to pass as the last argument to the
\fICURLMOPT_PUSHFUNCTION(3)\fP callback. The pointer is not touched or used by
libcurl itself, only passed on to the callback function.
.SH DEFAULT
NULL
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
#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);
}
.fi
.SH AVAILABILITY
Added in curl 7.44.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_PIPELINING (3),
.BR CURLMOPT_PUSHFUNCTION (3),
.BR CURLOPT_PIPEWAIT (3),
.BR RFC 7540

116
3rdparty/curl/share/man/man3/CURLMOPT_PUSHFUNCTION.3 vendored Normal file
View File

@ -0,0 +1,116 @@
.\" generated by cd2nroff 0.1 from CURLMOPT_PUSHFUNCTION.md
.TH CURLMOPT_PUSHFUNCTION 3 "2024-10-11" libcurl
.SH NAME
CURLMOPT_PUSHFUNCTION \- callback that approves or denies server pushes
.SH SYNOPSIS
.nf
#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);
.fi
.SH 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.
.SH CALLBACK DESCRIPTION
The callback gets its arguments like this:
\fIparent\fP 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.
\fIeasy\fP is a newly created handle that represents this upcoming transfer.
\fInum_headers\fP is the number of name+value pairs that was received and can
be accessed
\fIheaders\fP 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.
\fIclientp\fP is the pointer set with \fICURLMOPT_PUSHDATA(3)\fP
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: \fIcurl_pushheader_byname(3)\fP and
\fIcurl_pushheader_bynum(3)\fP. 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 \fIcurl_easy_header(3)\fP,
introduced in later libcurl versions.
.SH CALLBACK RETURN VALUE
.IP "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.
.IP "CURL_PUSH_DENY (1)"
The callback denies the stream and no data reaches the application, the easy
handle is destroyed by libcurl.
.IP "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)
.IP *
All other return codes are reserved for future use.
.SH DEFAULT
NULL, no callback
.SH PROTOCOLS
This functionality affects http only
.SH EXAMPLE
.nf
#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);
}
.fi
.SH AVAILABILITY
Added in curl 7.44.0
.SH RETURN VALUE
Returns CURLM_OK if the option is supported, and CURLM_UNKNOWN_OPTION if not.
.SH SEE ALSO
.BR CURLMOPT_PIPELINING (3),
.BR CURLMOPT_PUSHDATA (3),
.BR CURLOPT_PIPEWAIT (3),
.BR RFC 7540

Some files were not shown because too many files have changed in this diff Show More