From 82852ba4ee09940e0b12b55ab01073a944181974 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Fri, 6 Mar 2026 10:15:11 +1100 Subject: [PATCH 01/31] deps/libcurl --- deps/libcurl/include/curl/curl.h | 3312 +++++++++++++++++++++ deps/libcurl/include/curl/curlver.h | 79 + deps/libcurl/include/curl/easy.h | 125 + deps/libcurl/include/curl/header.h | 74 + deps/libcurl/include/curl/mprintf.h | 85 + deps/libcurl/include/curl/multi.h | 481 +++ deps/libcurl/include/curl/options.h | 70 + deps/libcurl/include/curl/stdcheaders.h | 35 + deps/libcurl/include/curl/system.h | 440 +++ deps/libcurl/include/curl/typecheck-gcc.h | 718 +++++ deps/libcurl/include/curl/urlapi.h | 155 + deps/libcurl/include/curl/websockets.h | 84 + deps/libcurl/lib/libcurl.a | Bin 0 -> 1123738 bytes 13 files changed, 5658 insertions(+) create mode 100644 deps/libcurl/include/curl/curl.h create mode 100644 deps/libcurl/include/curl/curlver.h create mode 100644 deps/libcurl/include/curl/easy.h create mode 100644 deps/libcurl/include/curl/header.h create mode 100644 deps/libcurl/include/curl/mprintf.h create mode 100644 deps/libcurl/include/curl/multi.h create mode 100644 deps/libcurl/include/curl/options.h create mode 100644 deps/libcurl/include/curl/stdcheaders.h create mode 100644 deps/libcurl/include/curl/system.h create mode 100644 deps/libcurl/include/curl/typecheck-gcc.h create mode 100644 deps/libcurl/include/curl/urlapi.h create mode 100644 deps/libcurl/include/curl/websockets.h create mode 100644 deps/libcurl/lib/libcurl.a diff --git a/deps/libcurl/include/curl/curl.h b/deps/libcurl/include/curl/curl.h new file mode 100644 index 0000000000..84cf5f2f52 --- /dev/null +++ b/deps/libcurl/include/curl/curl.h @@ -0,0 +1,3312 @@ +#ifndef CURLINC_CURL_H +#define CURLINC_CURL_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ + +/* + * If you have libcurl problems, all docs and details are found here: + * https://curl.se/libcurl/ + */ + +#ifdef CURL_NO_OLDIES +#define CURL_STRICTER /* not used since 8.11.0 */ +#endif + +/* Compile-time deprecation macros. */ +#if (defined(__GNUC__) && \ + ((__GNUC__ > 12) || ((__GNUC__ == 12) && (__GNUC_MINOR__ >= 1))) || \ + (defined(__clang__) && __clang_major__ >= 3) || \ + defined(__IAR_SYSTEMS_ICC__)) && \ + !defined(__INTEL_COMPILER) && \ + !defined(CURL_DISABLE_DEPRECATION) && !defined(BUILDING_LIBCURL) +#define CURL_DEPRECATED(version, message) \ + __attribute__((deprecated("since " # version ". " message))) +#if defined(__IAR_SYSTEMS_ICC__) +#define CURL_IGNORE_DEPRECATION(statements) \ + _Pragma("diag_suppress=Pe1444") \ + statements \ + _Pragma("diag_default=Pe1444") +#else +#define CURL_IGNORE_DEPRECATION(statements) \ + _Pragma("GCC diagnostic push") \ + _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \ + statements \ + _Pragma("GCC diagnostic pop") +#endif +#else +#define CURL_DEPRECATED(version, message) +#define CURL_IGNORE_DEPRECATION(statements) statements +#endif + +#include "curlver.h" /* libcurl version defines */ +#include "system.h" /* determine things runtime */ + +#include +#include + +#if defined(__FreeBSD__) || defined(__MidnightBSD__) +/* Needed for __FreeBSD_version or __MidnightBSD_version symbol definition */ +#include +#endif + +/* The include stuff here below is mainly for time_t! */ +#include +#include + +#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__) +#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || \ + defined(__LWIP_OPT_H__) || defined(LWIP_HDR_OPT_H)) +/* The check above prevents the winsock2.h inclusion if winsock.h already was + included, since they cannot co-exist without problems */ +#include +#include +#endif +#endif + +/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish + libc5-based Linux systems. Only include it on systems that are known to + require it! */ +#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \ + defined(__minix) || defined(__INTEGRITY) || \ + defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \ + defined(__CYGWIN__) || defined(AMIGA) || defined(__NuttX__) || \ + (defined(__FreeBSD_version) && (__FreeBSD_version < 800000)) || \ + (defined(__MidnightBSD_version) && (__MidnightBSD_version < 100000)) || \ + defined(__sun__) || defined(__serenity__) || defined(__vxworks__) +#include +#endif + +#if !defined(_WIN32) && !defined(_WIN32_WCE) +#include +#endif + +#if !defined(_WIN32) +#include +#endif + +/* Compatibility for non-Clang compilers */ +#ifndef __has_declspec_attribute +# define __has_declspec_attribute(x) 0 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void CURL; +typedef void CURLSH; + +/* + * libcurl external API function linkage decorations. + */ + +#ifdef CURL_STATICLIB +# define CURL_EXTERN +#elif defined(_WIN32) || \ + (__has_declspec_attribute(dllexport) && \ + __has_declspec_attribute(dllimport)) +# if defined(BUILDING_LIBCURL) +# define CURL_EXTERN __declspec(dllexport) +# else +# define CURL_EXTERN __declspec(dllimport) +# endif +#elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS) +# define CURL_EXTERN CURL_EXTERN_SYMBOL +#else +# define CURL_EXTERN +#endif + +#ifndef curl_socket_typedef +/* socket typedef */ +#if defined(_WIN32) && !defined(__LWIP_OPT_H__) && !defined(LWIP_HDR_OPT_H) +typedef SOCKET curl_socket_t; +#define CURL_SOCKET_BAD INVALID_SOCKET +#else +typedef int curl_socket_t; +#define CURL_SOCKET_BAD -1 +#endif +#define curl_socket_typedef +#endif /* curl_socket_typedef */ + +/* enum for the different supported SSL backends */ +typedef enum { + CURLSSLBACKEND_NONE = 0, + CURLSSLBACKEND_OPENSSL = 1, + CURLSSLBACKEND_GNUTLS = 2, + CURLSSLBACKEND_NSS CURL_DEPRECATED(8.3.0, "") = 3, + CURLSSLBACKEND_OBSOLETE4 = 4, /* Was QSOSSL. */ + CURLSSLBACKEND_GSKIT CURL_DEPRECATED(8.3.0, "") = 5, + CURLSSLBACKEND_POLARSSL CURL_DEPRECATED(7.69.0, "") = 6, + CURLSSLBACKEND_WOLFSSL = 7, + CURLSSLBACKEND_SCHANNEL = 8, + CURLSSLBACKEND_SECURETRANSPORT = 9, + CURLSSLBACKEND_AXTLS CURL_DEPRECATED(7.61.0, "") = 10, + CURLSSLBACKEND_MBEDTLS = 11, + CURLSSLBACKEND_MESALINK CURL_DEPRECATED(7.82.0, "") = 12, + CURLSSLBACKEND_BEARSSL = 13, + CURLSSLBACKEND_RUSTLS = 14 +} curl_sslbackend; + +/* aliases for library clones and renames */ +#define CURLSSLBACKEND_AWSLC CURLSSLBACKEND_OPENSSL +#define CURLSSLBACKEND_BORINGSSL CURLSSLBACKEND_OPENSSL +#define CURLSSLBACKEND_LIBRESSL CURLSSLBACKEND_OPENSSL + +/* deprecated names: */ +#define CURLSSLBACKEND_CYASSL CURLSSLBACKEND_WOLFSSL +#define CURLSSLBACKEND_DARWINSSL CURLSSLBACKEND_SECURETRANSPORT + +struct curl_httppost { + struct curl_httppost *next; /* next entry in the list */ + char *name; /* pointer to allocated name */ + long namelength; /* length of name length */ + char *contents; /* pointer to allocated data contents */ + long contentslength; /* length of contents field, see also + CURL_HTTPPOST_LARGE */ + char *buffer; /* pointer to allocated buffer contents */ + long bufferlength; /* length of buffer field */ + char *contenttype; /* Content-Type */ + struct curl_slist *contentheader; /* list of extra headers for this form */ + struct curl_httppost *more; /* if one field name has more than one + file, this link should link to following + files */ + long flags; /* as defined below */ + +/* specified content is a filename */ +#define CURL_HTTPPOST_FILENAME (1<<0) +/* specified content is a filename */ +#define CURL_HTTPPOST_READFILE (1<<1) +/* name is only stored pointer do not free in formfree */ +#define CURL_HTTPPOST_PTRNAME (1<<2) +/* contents is only stored pointer do not free in formfree */ +#define CURL_HTTPPOST_PTRCONTENTS (1<<3) +/* upload file from buffer */ +#define CURL_HTTPPOST_BUFFER (1<<4) +/* upload file from pointer contents */ +#define CURL_HTTPPOST_PTRBUFFER (1<<5) +/* upload file contents by using the regular read callback to get the data and + pass the given pointer as custom pointer */ +#define CURL_HTTPPOST_CALLBACK (1<<6) +/* use size in 'contentlen', added in 7.46.0 */ +#define CURL_HTTPPOST_LARGE (1<<7) + + char *showfilename; /* The filename to show. If not set, the + actual filename will be used (if this + is a file part) */ + void *userp; /* custom pointer used for + HTTPPOST_CALLBACK posts */ + curl_off_t contentlen; /* alternative length of contents + field. Used if CURL_HTTPPOST_LARGE is + set. Added in 7.46.0 */ +}; + + +/* This is a return code for the progress callback that, when returned, will + signal libcurl to continue executing the default progress function */ +#define CURL_PROGRESSFUNC_CONTINUE 0x10000001 + +/* This is the CURLOPT_PROGRESSFUNCTION callback prototype. It is now + considered deprecated but was the only choice up until 7.31.0 */ +typedef int (*curl_progress_callback)(void *clientp, + double dltotal, + double dlnow, + double ultotal, + double ulnow); + +/* This is the CURLOPT_XFERINFOFUNCTION callback prototype. It was introduced + in 7.32.0, avoids the use of floating point numbers and provides more + detailed information. */ +typedef int (*curl_xferinfo_callback)(void *clientp, + curl_off_t dltotal, + curl_off_t dlnow, + curl_off_t ultotal, + curl_off_t ulnow); + +#ifndef CURL_MAX_READ_SIZE + /* The maximum receive buffer size configurable via CURLOPT_BUFFERSIZE. */ +#define CURL_MAX_READ_SIZE (10*1024*1024) +#endif + +#ifndef CURL_MAX_WRITE_SIZE + /* Tests have proven that 20K is a bad buffer size for uploads on Windows, + while 16K for some odd reason performed a lot better. We do the ifndef + check to allow this value to easier be changed at build time for those + who feel adventurous. The practical minimum is about 400 bytes since + libcurl uses a buffer of this size as a scratch area (unrelated to + network send operations). */ +#define CURL_MAX_WRITE_SIZE 16384 +#endif + +#ifndef CURL_MAX_HTTP_HEADER +/* The only reason to have a max limit for this is to avoid the risk of a bad + server feeding libcurl with a never-ending header that will cause reallocs + infinitely */ +#define CURL_MAX_HTTP_HEADER (100*1024) +#endif + +/* This is a magic return code for the write callback that, when returned, + will signal libcurl to pause receiving on the current transfer. */ +#define CURL_WRITEFUNC_PAUSE 0x10000001 + +/* This is a magic return code for the write callback that, when returned, + will signal an error from the callback. */ +#define CURL_WRITEFUNC_ERROR 0xFFFFFFFF + +typedef size_t (*curl_write_callback)(char *buffer, + size_t size, + size_t nitems, + void *outstream); + +/* This callback will be called when a new resolver request is made */ +typedef int (*curl_resolver_start_callback)(void *resolver_state, + void *reserved, void *userdata); + +/* enumeration of file types */ +typedef enum { + CURLFILETYPE_FILE = 0, + CURLFILETYPE_DIRECTORY, + CURLFILETYPE_SYMLINK, + CURLFILETYPE_DEVICE_BLOCK, + CURLFILETYPE_DEVICE_CHAR, + CURLFILETYPE_NAMEDPIPE, + CURLFILETYPE_SOCKET, + CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */ + + CURLFILETYPE_UNKNOWN /* should never occur */ +} curlfiletype; + +#define CURLFINFOFLAG_KNOWN_FILENAME (1<<0) +#define CURLFINFOFLAG_KNOWN_FILETYPE (1<<1) +#define CURLFINFOFLAG_KNOWN_TIME (1<<2) +#define CURLFINFOFLAG_KNOWN_PERM (1<<3) +#define CURLFINFOFLAG_KNOWN_UID (1<<4) +#define CURLFINFOFLAG_KNOWN_GID (1<<5) +#define CURLFINFOFLAG_KNOWN_SIZE (1<<6) +#define CURLFINFOFLAG_KNOWN_HLINKCOUNT (1<<7) + +/* Information about a single file, used when doing FTP wildcard matching */ +struct curl_fileinfo { + char *filename; + curlfiletype filetype; + time_t time; /* always zero! */ + unsigned int perm; + int uid; + int gid; + curl_off_t size; + long int hardlinks; + + struct { + /* If some of these fields is not NULL, it is a pointer to b_data. */ + char *time; + char *perm; + char *user; + char *group; + char *target; /* pointer to the target filename of a symlink */ + } strings; + + unsigned int flags; + + /* These are libcurl private struct fields. Previously used by libcurl, so + they must never be interfered with. */ + char *b_data; + size_t b_size; + size_t b_used; +}; + +/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */ +#define CURL_CHUNK_BGN_FUNC_OK 0 +#define CURL_CHUNK_BGN_FUNC_FAIL 1 /* tell the lib to end the task */ +#define CURL_CHUNK_BGN_FUNC_SKIP 2 /* skip this chunk over */ + +/* if splitting of data transfer is enabled, this callback is called before + download of an individual chunk started. Note that parameter "remains" works + only for FTP wildcard downloading (for now), otherwise is not used */ +typedef long (*curl_chunk_bgn_callback)(const void *transfer_info, + void *ptr, + int remains); + +/* return codes for CURLOPT_CHUNK_END_FUNCTION */ +#define CURL_CHUNK_END_FUNC_OK 0 +#define CURL_CHUNK_END_FUNC_FAIL 1 /* tell the lib to end the task */ + +/* If splitting of data transfer is enabled this callback is called after + download of an individual chunk finished. + Note! After this callback was set then it have to be called FOR ALL chunks. + Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC. + This is the reason why we do not need "transfer_info" parameter in this + callback and we are not interested in "remains" parameter too. */ +typedef long (*curl_chunk_end_callback)(void *ptr); + +/* return codes for FNMATCHFUNCTION */ +#define CURL_FNMATCHFUNC_MATCH 0 /* string corresponds to the pattern */ +#define CURL_FNMATCHFUNC_NOMATCH 1 /* pattern does not match the string */ +#define CURL_FNMATCHFUNC_FAIL 2 /* an error occurred */ + +/* callback type for wildcard downloading pattern matching. If the + string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */ +typedef int (*curl_fnmatch_callback)(void *ptr, + const char *pattern, + const char *string); + +/* These are the return codes for the seek callbacks */ +#define CURL_SEEKFUNC_OK 0 +#define CURL_SEEKFUNC_FAIL 1 /* fail the entire transfer */ +#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking cannot be done, so + libcurl might try other means instead */ +typedef int (*curl_seek_callback)(void *instream, + curl_off_t offset, + int origin); /* 'whence' */ + +/* This is a return code for the read callback that, when returned, will + signal libcurl to immediately abort the current transfer. */ +#define CURL_READFUNC_ABORT 0x10000000 +/* This is a return code for the read callback that, when returned, will + signal libcurl to pause sending data on the current transfer. */ +#define CURL_READFUNC_PAUSE 0x10000001 + +/* Return code for when the trailing headers' callback has terminated + without any errors */ +#define CURL_TRAILERFUNC_OK 0 +/* Return code for when was an error in the trailing header's list and we + want to abort the request */ +#define CURL_TRAILERFUNC_ABORT 1 + +typedef size_t (*curl_read_callback)(char *buffer, + size_t size, + size_t nitems, + void *instream); + +typedef int (*curl_trailer_callback)(struct curl_slist **list, + void *userdata); + +typedef enum { + CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */ + CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */ + CURLSOCKTYPE_LAST /* never use */ +} curlsocktype; + +/* The return code from the sockopt_callback can signal information back + to libcurl: */ +#define CURL_SOCKOPT_OK 0 +#define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return + CURLE_ABORTED_BY_CALLBACK */ +#define CURL_SOCKOPT_ALREADY_CONNECTED 2 + +typedef int (*curl_sockopt_callback)(void *clientp, + curl_socket_t curlfd, + curlsocktype purpose); + +struct curl_sockaddr { + int family; + int socktype; + int protocol; + unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it + turned really ugly and painful on the systems that + lack this type */ + struct sockaddr addr; +}; + +typedef curl_socket_t +(*curl_opensocket_callback)(void *clientp, + curlsocktype purpose, + struct curl_sockaddr *address); + +typedef int +(*curl_closesocket_callback)(void *clientp, curl_socket_t item); + +typedef enum { + CURLIOE_OK, /* I/O operation successful */ + CURLIOE_UNKNOWNCMD, /* command was unknown to callback */ + CURLIOE_FAILRESTART, /* failed to restart the read */ + CURLIOE_LAST /* never use */ +} curlioerr; + +typedef enum { + CURLIOCMD_NOP, /* no operation */ + CURLIOCMD_RESTARTREAD, /* restart the read stream from start */ + CURLIOCMD_LAST /* never use */ +} curliocmd; + +typedef curlioerr (*curl_ioctl_callback)(CURL *handle, + int cmd, + void *clientp); + +#ifndef CURL_DID_MEMORY_FUNC_TYPEDEFS +/* + * The following typedef's are signatures of malloc, free, realloc, strdup and + * calloc respectively. Function pointers of these types can be passed to the + * curl_global_init_mem() function to set user defined memory management + * callback routines. + */ +typedef void *(*curl_malloc_callback)(size_t size); +typedef void (*curl_free_callback)(void *ptr); +typedef void *(*curl_realloc_callback)(void *ptr, size_t size); +typedef char *(*curl_strdup_callback)(const char *str); +typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size); + +#define CURL_DID_MEMORY_FUNC_TYPEDEFS +#endif + +/* the kind of data that is passed to information_callback */ +typedef enum { + CURLINFO_TEXT = 0, + CURLINFO_HEADER_IN, /* 1 */ + CURLINFO_HEADER_OUT, /* 2 */ + CURLINFO_DATA_IN, /* 3 */ + CURLINFO_DATA_OUT, /* 4 */ + CURLINFO_SSL_DATA_IN, /* 5 */ + CURLINFO_SSL_DATA_OUT, /* 6 */ + CURLINFO_END +} curl_infotype; + +typedef int (*curl_debug_callback) + (CURL *handle, /* the handle/transfer this concerns */ + curl_infotype type, /* what kind of data */ + char *data, /* points to the data */ + size_t size, /* size of the data pointed to */ + void *userptr); /* whatever the user please */ + +/* This is the CURLOPT_PREREQFUNCTION callback prototype. */ +typedef int (*curl_prereq_callback)(void *clientp, + char *conn_primary_ip, + char *conn_local_ip, + int conn_primary_port, + int conn_local_port); + +/* Return code for when the pre-request callback has terminated without + any errors */ +#define CURL_PREREQFUNC_OK 0 +/* Return code for when the pre-request callback wants to abort the + request */ +#define CURL_PREREQFUNC_ABORT 1 + +/* All possible error codes from all sorts of curl functions. Future versions + may return other values, stay prepared. + + Always add new return codes last. Never *EVER* remove any. The return + codes must remain the same! + */ + +typedef enum { + CURLE_OK = 0, + CURLE_UNSUPPORTED_PROTOCOL, /* 1 */ + CURLE_FAILED_INIT, /* 2 */ + CURLE_URL_MALFORMAT, /* 3 */ + CURLE_NOT_BUILT_IN, /* 4 - [was obsoleted in August 2007 for + 7.17.0, reused in April 2011 for 7.21.5] */ + CURLE_COULDNT_RESOLVE_PROXY, /* 5 */ + CURLE_COULDNT_RESOLVE_HOST, /* 6 */ + CURLE_COULDNT_CONNECT, /* 7 */ + CURLE_WEIRD_SERVER_REPLY, /* 8 */ + CURLE_REMOTE_ACCESS_DENIED, /* 9 a service was denied by the server + due to lack of access - when login fails + this is not returned. */ + CURLE_FTP_ACCEPT_FAILED, /* 10 - [was obsoleted in April 2006 for + 7.15.4, reused in Dec 2011 for 7.24.0]*/ + CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */ + CURLE_FTP_ACCEPT_TIMEOUT, /* 12 - timeout occurred accepting server + [was obsoleted in August 2007 for 7.17.0, + reused in Dec 2011 for 7.24.0]*/ + CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */ + CURLE_FTP_WEIRD_227_FORMAT, /* 14 */ + CURLE_FTP_CANT_GET_HOST, /* 15 */ + CURLE_HTTP2, /* 16 - A problem in the http2 framing layer. + [was obsoleted in August 2007 for 7.17.0, + reused in July 2014 for 7.38.0] */ + CURLE_FTP_COULDNT_SET_TYPE, /* 17 */ + CURLE_PARTIAL_FILE, /* 18 */ + CURLE_FTP_COULDNT_RETR_FILE, /* 19 */ + CURLE_OBSOLETE20, /* 20 - NOT USED */ + CURLE_QUOTE_ERROR, /* 21 - quote command failure */ + CURLE_HTTP_RETURNED_ERROR, /* 22 */ + CURLE_WRITE_ERROR, /* 23 */ + CURLE_OBSOLETE24, /* 24 - NOT USED */ + CURLE_UPLOAD_FAILED, /* 25 - failed upload "command" */ + CURLE_READ_ERROR, /* 26 - could not open/read from file */ + CURLE_OUT_OF_MEMORY, /* 27 */ + CURLE_OPERATION_TIMEDOUT, /* 28 - the timeout time was reached */ + CURLE_OBSOLETE29, /* 29 - NOT USED */ + CURLE_FTP_PORT_FAILED, /* 30 - FTP PORT operation failed */ + CURLE_FTP_COULDNT_USE_REST, /* 31 - the REST command failed */ + CURLE_OBSOLETE32, /* 32 - NOT USED */ + CURLE_RANGE_ERROR, /* 33 - RANGE "command" did not work */ + CURLE_OBSOLETE34, /* 34 */ + CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */ + CURLE_BAD_DOWNLOAD_RESUME, /* 36 - could not resume download */ + CURLE_FILE_COULDNT_READ_FILE, /* 37 */ + CURLE_LDAP_CANNOT_BIND, /* 38 */ + CURLE_LDAP_SEARCH_FAILED, /* 39 */ + CURLE_OBSOLETE40, /* 40 - NOT USED */ + CURLE_OBSOLETE41, /* 41 - NOT USED starting with 7.53.0 */ + CURLE_ABORTED_BY_CALLBACK, /* 42 */ + CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */ + CURLE_OBSOLETE44, /* 44 - NOT USED */ + CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */ + CURLE_OBSOLETE46, /* 46 - NOT USED */ + CURLE_TOO_MANY_REDIRECTS, /* 47 - catch endless re-direct loops */ + CURLE_UNKNOWN_OPTION, /* 48 - User specified an unknown option */ + CURLE_SETOPT_OPTION_SYNTAX, /* 49 - Malformed setopt option */ + CURLE_OBSOLETE50, /* 50 - NOT USED */ + CURLE_OBSOLETE51, /* 51 - NOT USED */ + CURLE_GOT_NOTHING, /* 52 - when this is a specific error */ + CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */ + CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as + default */ + CURLE_SEND_ERROR, /* 55 - failed sending network data */ + CURLE_RECV_ERROR, /* 56 - failure in receiving network data */ + CURLE_OBSOLETE57, /* 57 - NOT IN USE */ + CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */ + CURLE_SSL_CIPHER, /* 59 - could not use specified cipher */ + CURLE_PEER_FAILED_VERIFICATION, /* 60 - peer's certificate or fingerprint + was not verified fine */ + CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */ + CURLE_OBSOLETE62, /* 62 - NOT IN USE since 7.82.0 */ + CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */ + CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */ + CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind + that failed */ + CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */ + CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not + accepted and we failed to login */ + CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */ + CURLE_TFTP_PERM, /* 69 - permission problem on server */ + CURLE_REMOTE_DISK_FULL, /* 70 - out of disk space on server */ + CURLE_TFTP_ILLEGAL, /* 71 - Illegal TFTP operation */ + CURLE_TFTP_UNKNOWNID, /* 72 - Unknown transfer ID */ + CURLE_REMOTE_FILE_EXISTS, /* 73 - File already exists */ + CURLE_TFTP_NOSUCHUSER, /* 74 - No such user */ + CURLE_OBSOLETE75, /* 75 - NOT IN USE since 7.82.0 */ + CURLE_OBSOLETE76, /* 76 - NOT IN USE since 7.82.0 */ + CURLE_SSL_CACERT_BADFILE, /* 77 - could not load CACERT file, missing + or wrong format */ + CURLE_REMOTE_FILE_NOT_FOUND, /* 78 - remote file not found */ + CURLE_SSH, /* 79 - error from the SSH layer, somewhat + generic so the error message will be of + interest when this has happened */ + + CURLE_SSL_SHUTDOWN_FAILED, /* 80 - Failed to shut down the SSL + connection */ + CURLE_AGAIN, /* 81 - socket is not ready for send/recv, + wait till it is ready and try again (Added + in 7.18.2) */ + CURLE_SSL_CRL_BADFILE, /* 82 - could not load CRL file, missing or + wrong format (Added in 7.19.0) */ + CURLE_SSL_ISSUER_ERROR, /* 83 - Issuer check failed. (Added in + 7.19.0) */ + CURLE_FTP_PRET_FAILED, /* 84 - a PRET command failed */ + CURLE_RTSP_CSEQ_ERROR, /* 85 - mismatch of RTSP CSeq numbers */ + CURLE_RTSP_SESSION_ERROR, /* 86 - mismatch of RTSP Session Ids */ + CURLE_FTP_BAD_FILE_LIST, /* 87 - unable to parse FTP file list */ + CURLE_CHUNK_FAILED, /* 88 - chunk callback reported error */ + CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the + session will be queued */ + CURLE_SSL_PINNEDPUBKEYNOTMATCH, /* 90 - specified pinned public key did not + match */ + CURLE_SSL_INVALIDCERTSTATUS, /* 91 - invalid certificate status */ + CURLE_HTTP2_STREAM, /* 92 - stream error in HTTP/2 framing layer + */ + CURLE_RECURSIVE_API_CALL, /* 93 - an api function was called from + inside a callback */ + CURLE_AUTH_ERROR, /* 94 - an authentication function returned an + error */ + CURLE_HTTP3, /* 95 - An HTTP/3 layer problem */ + CURLE_QUIC_CONNECT_ERROR, /* 96 - QUIC connection error */ + CURLE_PROXY, /* 97 - proxy handshake error */ + CURLE_SSL_CLIENTCERT, /* 98 - client-side certificate required */ + CURLE_UNRECOVERABLE_POLL, /* 99 - poll/select returned fatal error */ + CURLE_TOO_LARGE, /* 100 - a value/data met its maximum */ + CURLE_ECH_REQUIRED, /* 101 - ECH tried but failed */ + CURL_LAST /* never use! */ +} CURLcode; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* removed in 7.53.0 */ +#define CURLE_FUNCTION_NOT_FOUND CURLE_OBSOLETE41 + +/* removed in 7.56.0 */ +#define CURLE_HTTP_POST_ERROR CURLE_OBSOLETE34 + +/* Previously obsolete error code reused in 7.38.0 */ +#define CURLE_OBSOLETE16 CURLE_HTTP2 + +/* Previously obsolete error codes reused in 7.24.0 */ +#define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED +#define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT + +/* compatibility with older names */ +#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING +#define CURLE_FTP_WEIRD_SERVER_REPLY CURLE_WEIRD_SERVER_REPLY + +/* The following were added in 7.62.0 */ +#define CURLE_SSL_CACERT CURLE_PEER_FAILED_VERIFICATION + +/* The following were added in 7.21.5, April 2011 */ +#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION + +/* Added for 7.78.0 */ +#define CURLE_TELNET_OPTION_SYNTAX CURLE_SETOPT_OPTION_SYNTAX + +/* The following were added in 7.17.1 */ +/* These are scheduled to disappear by 2009 */ +#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION + +/* The following were added in 7.17.0 */ +/* These are scheduled to disappear by 2009 */ +#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */ +#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46 +#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44 +#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10 +#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16 +#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32 +#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29 +#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12 +#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20 +#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40 +#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24 +#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57 +#define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN + +#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED +#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE +#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR +#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL +#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS +#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR +#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED + +/* The following were added earlier */ + +#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT +#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR +#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED +#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED +#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE +#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME +#define CURLE_LDAP_INVALID_URL CURLE_OBSOLETE62 +#define CURLE_CONV_REQD CURLE_OBSOLETE76 +#define CURLE_CONV_FAILED CURLE_OBSOLETE75 + +/* This was the error code 50 in 7.7.3 and a few earlier versions, this + is no longer used by libcurl but is instead #defined here only to not + make programs break */ +#define CURLE_ALREADY_COMPLETE 99999 + +/* Provide defines for really old option names */ +#define CURLOPT_FILE CURLOPT_WRITEDATA /* name changed in 7.9.7 */ +#define CURLOPT_INFILE CURLOPT_READDATA /* name changed in 7.9.7 */ +#define CURLOPT_WRITEHEADER CURLOPT_HEADERDATA + +/* Since long deprecated options with no code in the lib that does anything + with them. */ +#define CURLOPT_WRITEINFO CURLOPT_OBSOLETE40 +#define CURLOPT_CLOSEPOLICY CURLOPT_OBSOLETE72 +#define CURLOPT_OBSOLETE72 9999 +#define CURLOPT_OBSOLETE40 9999 + +#endif /* !CURL_NO_OLDIES */ + +/* + * Proxy error codes. Returned in CURLINFO_PROXY_ERROR if CURLE_PROXY was + * return for the transfers. + */ +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; + +/* This prototype applies to all conversion callbacks */ +typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length); + +typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */ + void *ssl_ctx, /* actually an OpenSSL + or wolfSSL SSL_CTX, + or an mbedTLS + mbedtls_ssl_config */ + void *userptr); + +typedef enum { + CURLPROXY_HTTP = 0, /* added in 7.10, new in 7.19.4 default is to use + CONNECT HTTP/1.1 */ + CURLPROXY_HTTP_1_0 = 1, /* added in 7.19.4, force to use CONNECT + HTTP/1.0 */ + CURLPROXY_HTTPS = 2, /* HTTPS but stick to HTTP/1 added in 7.52.0 */ + CURLPROXY_HTTPS2 = 3, /* HTTPS and attempt HTTP/2 added in 8.2.0 */ + CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already + in 7.10 */ + CURLPROXY_SOCKS5 = 5, /* added in 7.10 */ + CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */ + CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the + hostname rather than the IP address. added + in 7.18.0 */ +} curl_proxytype; /* this enum was added in 7.10 */ + +/* + * Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options: + * + * CURLAUTH_NONE - No HTTP authentication + * CURLAUTH_BASIC - HTTP Basic authentication (default) + * CURLAUTH_DIGEST - HTTP Digest authentication + * CURLAUTH_NEGOTIATE - HTTP Negotiate (SPNEGO) authentication + * CURLAUTH_GSSNEGOTIATE - Alias for CURLAUTH_NEGOTIATE (deprecated) + * CURLAUTH_NTLM - HTTP NTLM authentication + * CURLAUTH_DIGEST_IE - HTTP Digest authentication with IE flavour + * CURLAUTH_NTLM_WB - HTTP NTLM authentication delegated to winbind helper + * CURLAUTH_BEARER - HTTP Bearer token authentication + * CURLAUTH_ONLY - Use together with a single other type to force no + * authentication or just that single type + * CURLAUTH_ANY - All fine types set + * CURLAUTH_ANYSAFE - All fine types except Basic + */ + +#define CURLAUTH_NONE ((unsigned long)0) +#define CURLAUTH_BASIC (((unsigned long)1)<<0) +#define CURLAUTH_DIGEST (((unsigned long)1)<<1) +#define CURLAUTH_NEGOTIATE (((unsigned long)1)<<2) +/* Deprecated since the advent of CURLAUTH_NEGOTIATE */ +#define CURLAUTH_GSSNEGOTIATE CURLAUTH_NEGOTIATE +/* Used for CURLOPT_SOCKS5_AUTH to stay terminologically correct */ +#define CURLAUTH_GSSAPI CURLAUTH_NEGOTIATE +#define CURLAUTH_NTLM (((unsigned long)1)<<3) +#define CURLAUTH_DIGEST_IE (((unsigned long)1)<<4) +#ifndef CURL_NO_OLDIES + /* functionality removed since 8.8.0 */ +#define CURLAUTH_NTLM_WB (((unsigned long)1)<<5) +#endif +#define CURLAUTH_BEARER (((unsigned long)1)<<6) +#define CURLAUTH_AWS_SIGV4 (((unsigned long)1)<<7) +#define CURLAUTH_ONLY (((unsigned long)1)<<31) +#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE) +#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE)) + +#define CURLSSH_AUTH_ANY ~0 /* all types supported by the server */ +#define CURLSSH_AUTH_NONE 0 /* none allowed, silly but complete */ +#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */ +#define CURLSSH_AUTH_PASSWORD (1<<1) /* password */ +#define CURLSSH_AUTH_HOST (1<<2) /* host key files */ +#define CURLSSH_AUTH_KEYBOARD (1<<3) /* keyboard interactive */ +#define CURLSSH_AUTH_AGENT (1<<4) /* agent (ssh-agent, pageant...) */ +#define CURLSSH_AUTH_GSSAPI (1<<5) /* gssapi (kerberos, ...) */ +#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY + +#define CURLGSSAPI_DELEGATION_NONE 0 /* no delegation (default) */ +#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */ +#define CURLGSSAPI_DELEGATION_FLAG (1<<1) /* delegate always */ + +#define CURL_ERROR_SIZE 256 + +enum curl_khtype { + CURLKHTYPE_UNKNOWN, + CURLKHTYPE_RSA1, + CURLKHTYPE_RSA, + CURLKHTYPE_DSS, + CURLKHTYPE_ECDSA, + CURLKHTYPE_ED25519 +}; + +struct curl_khkey { + const char *key; /* points to a null-terminated string encoded with base64 + if len is zero, otherwise to the "raw" data */ + size_t len; + enum curl_khtype keytype; +}; + +/* this is the set of return values expected from the curl_sshkeycallback + callback */ +enum curl_khstat { + CURLKHSTAT_FINE_ADD_TO_FILE, + CURLKHSTAT_FINE, + CURLKHSTAT_REJECT, /* reject the connection, return an error */ + CURLKHSTAT_DEFER, /* do not accept it, but we cannot answer right now. + Causes a CURLE_PEER_FAILED_VERIFICATION error but the + connection will be left intact etc */ + CURLKHSTAT_FINE_REPLACE, /* accept and replace the wrong key */ + CURLKHSTAT_LAST /* not for use, only a marker for last-in-list */ +}; + +/* this is the set of status codes pass in to the callback */ +enum curl_khmatch { + CURLKHMATCH_OK, /* match */ + CURLKHMATCH_MISMATCH, /* host found, key mismatch! */ + CURLKHMATCH_MISSING, /* no matching host/key found */ + CURLKHMATCH_LAST /* not for use, only a marker for last-in-list */ +}; + +typedef int + (*curl_sshkeycallback) (CURL *easy, /* easy handle */ + const struct curl_khkey *knownkey, /* known */ + const struct curl_khkey *foundkey, /* found */ + enum curl_khmatch, /* libcurl's view on the keys */ + void *clientp); /* custom pointer passed with */ + /* CURLOPT_SSH_KEYDATA */ + +typedef int + (*curl_sshhostkeycallback) (void *clientp,/* custom pointer passed */ + /* with CURLOPT_SSH_HOSTKEYDATA */ + int keytype, /* CURLKHTYPE */ + const char *key, /* hostkey to check */ + size_t keylen); /* length of the key */ + /* return CURLE_OK to accept */ + /* or something else to refuse */ + + +/* parameter for the CURLOPT_USE_SSL option */ +typedef enum { + CURLUSESSL_NONE, /* do not attempt to use SSL */ + CURLUSESSL_TRY, /* try using SSL, proceed anyway otherwise */ + CURLUSESSL_CONTROL, /* SSL for the control connection or fail */ + CURLUSESSL_ALL, /* SSL for all communication or fail */ + CURLUSESSL_LAST /* not an option, never use */ +} curl_usessl; + +/* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */ + +/* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the + name of improving interoperability with older servers. Some SSL libraries + have introduced work-arounds for this flaw but those work-arounds sometimes + make the SSL communication fail. To regain functionality with those broken + servers, a user can this way allow the vulnerability back. */ +#define CURLSSLOPT_ALLOW_BEAST (1<<0) + +/* - NO_REVOKE tells libcurl to disable certificate revocation checks for those + SSL backends where such behavior is present. */ +#define CURLSSLOPT_NO_REVOKE (1<<1) + +/* - NO_PARTIALCHAIN tells libcurl to *NOT* accept a partial certificate chain + if possible. The OpenSSL backend has this ability. */ +#define CURLSSLOPT_NO_PARTIALCHAIN (1<<2) + +/* - REVOKE_BEST_EFFORT tells libcurl to ignore certificate revocation offline + checks and ignore missing revocation list for those SSL backends where such + behavior is present. */ +#define CURLSSLOPT_REVOKE_BEST_EFFORT (1<<3) + +/* - CURLSSLOPT_NATIVE_CA tells libcurl to use standard certificate store of + operating system. Currently implemented under MS-Windows. */ +#define CURLSSLOPT_NATIVE_CA (1<<4) + +/* - CURLSSLOPT_AUTO_CLIENT_CERT tells libcurl to automatically locate and use + a client certificate for authentication. (Schannel) */ +#define CURLSSLOPT_AUTO_CLIENT_CERT (1<<5) + +/* If possible, send data using TLS 1.3 early data */ +#define CURLSSLOPT_EARLYDATA (1<<6) + +/* The default connection attempt delay in milliseconds for happy eyeballs. + CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS.3 and happy-eyeballs-timeout-ms.d document + this value, keep them in sync. */ +#define CURL_HET_DEFAULT 200L + +/* The default connection upkeep interval in milliseconds. */ +#define CURL_UPKEEP_INTERVAL_DEFAULT 60000L + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Backwards compatibility with older names */ +/* These are scheduled to disappear by 2009 */ + +#define CURLFTPSSL_NONE CURLUSESSL_NONE +#define CURLFTPSSL_TRY CURLUSESSL_TRY +#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL +#define CURLFTPSSL_ALL CURLUSESSL_ALL +#define CURLFTPSSL_LAST CURLUSESSL_LAST +#define curl_ftpssl curl_usessl +#endif /* !CURL_NO_OLDIES */ + +/* parameter for the CURLOPT_FTP_SSL_CCC option */ +typedef enum { + CURLFTPSSL_CCC_NONE, /* do not send CCC */ + CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */ + CURLFTPSSL_CCC_ACTIVE, /* Initiate the shutdown */ + CURLFTPSSL_CCC_LAST /* not an option, never use */ +} curl_ftpccc; + +/* parameter for the CURLOPT_FTPSSLAUTH option */ +typedef enum { + CURLFTPAUTH_DEFAULT, /* let libcurl decide */ + CURLFTPAUTH_SSL, /* use "AUTH SSL" */ + CURLFTPAUTH_TLS, /* use "AUTH TLS" */ + CURLFTPAUTH_LAST /* not an option, never use */ +} curl_ftpauth; + +/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */ +typedef enum { + CURLFTP_CREATE_DIR_NONE, /* do NOT create missing dirs! */ + CURLFTP_CREATE_DIR, /* (FTP/SFTP) if CWD fails, try MKD and then CWD + again if MKD succeeded, for SFTP this does + similar magic */ + CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD + again even if MKD failed! */ + CURLFTP_CREATE_DIR_LAST /* not an option, never use */ +} curl_ftpcreatedir; + +/* parameter for the CURLOPT_FTP_FILEMETHOD option */ +typedef enum { + CURLFTPMETHOD_DEFAULT, /* let libcurl pick */ + CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */ + CURLFTPMETHOD_NOCWD, /* no CWD at all */ + CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */ + CURLFTPMETHOD_LAST /* not an option, never use */ +} curl_ftpmethod; + +/* bitmask defines for CURLOPT_HEADEROPT */ +#define CURLHEADER_UNIFIED 0 +#define CURLHEADER_SEPARATE (1<<0) + +/* CURLALTSVC_* are bits for the CURLOPT_ALTSVC_CTRL option */ +#define CURLALTSVC_READONLYFILE (1<<2) +#define CURLALTSVC_H1 (1<<3) +#define CURLALTSVC_H2 (1<<4) +#define CURLALTSVC_H3 (1<<5) + + +struct curl_hstsentry { + char *name; + size_t namelen; + unsigned int includeSubDomains:1; + char expire[18]; /* YYYYMMDD HH:MM:SS [null-terminated] */ +}; + +struct curl_index { + size_t index; /* the provided entry's "index" or count */ + size_t total; /* total number of entries to save */ +}; + +typedef enum { + CURLSTS_OK, + CURLSTS_DONE, + CURLSTS_FAIL +} CURLSTScode; + +typedef CURLSTScode (*curl_hstsread_callback)(CURL *easy, + struct curl_hstsentry *e, + void *userp); +typedef CURLSTScode (*curl_hstswrite_callback)(CURL *easy, + struct curl_hstsentry *e, + struct curl_index *i, + void *userp); + +/* CURLHSTS_* are bits for the CURLOPT_HSTS option */ +#define CURLHSTS_ENABLE (long)(1<<0) +#define CURLHSTS_READONLYFILE (long)(1<<1) + +/* The CURLPROTO_ defines below are for the **deprecated** CURLOPT_*PROTOCOLS + options. Do not use. */ +#define CURLPROTO_HTTP (1<<0) +#define CURLPROTO_HTTPS (1<<1) +#define CURLPROTO_FTP (1<<2) +#define CURLPROTO_FTPS (1<<3) +#define CURLPROTO_SCP (1<<4) +#define CURLPROTO_SFTP (1<<5) +#define CURLPROTO_TELNET (1<<6) +#define CURLPROTO_LDAP (1<<7) +#define CURLPROTO_LDAPS (1<<8) +#define CURLPROTO_DICT (1<<9) +#define CURLPROTO_FILE (1<<10) +#define CURLPROTO_TFTP (1<<11) +#define CURLPROTO_IMAP (1<<12) +#define CURLPROTO_IMAPS (1<<13) +#define CURLPROTO_POP3 (1<<14) +#define CURLPROTO_POP3S (1<<15) +#define CURLPROTO_SMTP (1<<16) +#define CURLPROTO_SMTPS (1<<17) +#define CURLPROTO_RTSP (1<<18) +#define CURLPROTO_RTMP (1<<19) +#define CURLPROTO_RTMPT (1<<20) +#define CURLPROTO_RTMPE (1<<21) +#define CURLPROTO_RTMPTE (1<<22) +#define CURLPROTO_RTMPS (1<<23) +#define CURLPROTO_RTMPTS (1<<24) +#define CURLPROTO_GOPHER (1<<25) +#define CURLPROTO_SMB (1<<26) +#define CURLPROTO_SMBS (1<<27) +#define CURLPROTO_MQTT (1<<28) +#define CURLPROTO_GOPHERS (1<<29) +#define CURLPROTO_ALL (~0) /* enable everything */ + +/* long may be 32 or 64 bits, but we should never depend on anything else + but 32 */ +#define CURLOPTTYPE_LONG 0 +#define CURLOPTTYPE_OBJECTPOINT 10000 +#define CURLOPTTYPE_FUNCTIONPOINT 20000 +#define CURLOPTTYPE_OFF_T 30000 +#define CURLOPTTYPE_BLOB 40000 + +/* *STRINGPOINT is an alias for OBJECTPOINT to allow tools to extract the + string options from the header file */ + + +#define CURLOPT(na,t,nu) na = t + nu +#define CURLOPTDEPRECATED(na,t,nu,v,m) na CURL_DEPRECATED(v,m) = t + nu + +/* CURLOPT aliases that make no runtime difference */ + +/* 'char *' argument to a string with a trailing zero */ +#define CURLOPTTYPE_STRINGPOINT CURLOPTTYPE_OBJECTPOINT + +/* 'struct curl_slist *' argument */ +#define CURLOPTTYPE_SLISTPOINT CURLOPTTYPE_OBJECTPOINT + +/* 'void *' argument passed untouched to callback */ +#define CURLOPTTYPE_CBPOINT CURLOPTTYPE_OBJECTPOINT + +/* 'long' argument with a set of values/bitmask */ +#define CURLOPTTYPE_VALUES CURLOPTTYPE_LONG + +/* + * All CURLOPT_* values. + */ + +typedef enum { + /* This is the FILE * or void * the regular output should be written to. */ + CURLOPT(CURLOPT_WRITEDATA, CURLOPTTYPE_CBPOINT, 1), + + /* The full URL to get/put */ + CURLOPT(CURLOPT_URL, CURLOPTTYPE_STRINGPOINT, 2), + + /* Port number to connect to, if other than default. */ + CURLOPT(CURLOPT_PORT, CURLOPTTYPE_LONG, 3), + + /* Name of proxy to use. */ + CURLOPT(CURLOPT_PROXY, CURLOPTTYPE_STRINGPOINT, 4), + + /* "user:password;options" to use when fetching. */ + CURLOPT(CURLOPT_USERPWD, CURLOPTTYPE_STRINGPOINT, 5), + + /* "user:password" to use with proxy. */ + CURLOPT(CURLOPT_PROXYUSERPWD, CURLOPTTYPE_STRINGPOINT, 6), + + /* Range to get, specified as an ASCII string. */ + CURLOPT(CURLOPT_RANGE, CURLOPTTYPE_STRINGPOINT, 7), + + /* not used */ + + /* Specified file stream to upload from (use as input): */ + CURLOPT(CURLOPT_READDATA, CURLOPTTYPE_CBPOINT, 9), + + /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE + * bytes big. */ + CURLOPT(CURLOPT_ERRORBUFFER, CURLOPTTYPE_OBJECTPOINT, 10), + + /* Function that will be called to store the output (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CURLOPT(CURLOPT_WRITEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 11), + + /* Function that will be called to read the input (instead of fread). The + * parameters will use fread() syntax, make sure to follow them. */ + CURLOPT(CURLOPT_READFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 12), + + /* Time-out the read operation after this amount of seconds */ + CURLOPT(CURLOPT_TIMEOUT, CURLOPTTYPE_LONG, 13), + + /* If CURLOPT_READDATA is used, this can be used to inform libcurl about + * how large the file being sent really is. That allows better error + * checking and better verifies that the upload was successful. -1 means + * unknown size. + * + * For large file support, there is also a _LARGE version of the key + * which takes an off_t type, allowing platforms with larger off_t + * sizes to handle larger files. See below for INFILESIZE_LARGE. + */ + CURLOPT(CURLOPT_INFILESIZE, CURLOPTTYPE_LONG, 14), + + /* POST static input fields. */ + CURLOPT(CURLOPT_POSTFIELDS, CURLOPTTYPE_OBJECTPOINT, 15), + + /* Set the referrer page (needed by some CGIs) */ + CURLOPT(CURLOPT_REFERER, CURLOPTTYPE_STRINGPOINT, 16), + + /* Set the FTP PORT string (interface name, named or numerical IP address) + Use i.e '-' to use default address. */ + CURLOPT(CURLOPT_FTPPORT, CURLOPTTYPE_STRINGPOINT, 17), + + /* Set the User-Agent string (examined by some CGIs) */ + CURLOPT(CURLOPT_USERAGENT, CURLOPTTYPE_STRINGPOINT, 18), + + /* If the download receives less than "low speed limit" bytes/second + * during "low speed time" seconds, the operations is aborted. + * You could i.e if you have a pretty high speed connection, abort if + * it is less than 2000 bytes/sec during 20 seconds. + */ + + /* Set the "low speed limit" */ + CURLOPT(CURLOPT_LOW_SPEED_LIMIT, CURLOPTTYPE_LONG, 19), + + /* Set the "low speed time" */ + CURLOPT(CURLOPT_LOW_SPEED_TIME, CURLOPTTYPE_LONG, 20), + + /* Set the continuation offset. + * + * Note there is also a _LARGE version of this key which uses + * off_t types, allowing for large file offsets on platforms which + * use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE. + */ + CURLOPT(CURLOPT_RESUME_FROM, CURLOPTTYPE_LONG, 21), + + /* Set cookie in request: */ + CURLOPT(CURLOPT_COOKIE, CURLOPTTYPE_STRINGPOINT, 22), + + /* This points to a linked list of headers, struct curl_slist kind. This + list is also used for RTSP (in spite of its name) */ + CURLOPT(CURLOPT_HTTPHEADER, CURLOPTTYPE_SLISTPOINT, 23), + + /* This points to a linked list of post entries, struct curl_httppost */ + CURLOPTDEPRECATED(CURLOPT_HTTPPOST, CURLOPTTYPE_OBJECTPOINT, 24, + 7.56.0, "Use CURLOPT_MIMEPOST"), + + /* name of the file keeping your private SSL-certificate */ + CURLOPT(CURLOPT_SSLCERT, CURLOPTTYPE_STRINGPOINT, 25), + + /* password for the SSL or SSH private key */ + CURLOPT(CURLOPT_KEYPASSWD, CURLOPTTYPE_STRINGPOINT, 26), + + /* send TYPE parameter? */ + CURLOPT(CURLOPT_CRLF, CURLOPTTYPE_LONG, 27), + + /* send linked-list of QUOTE commands */ + CURLOPT(CURLOPT_QUOTE, CURLOPTTYPE_SLISTPOINT, 28), + + /* send FILE * or void * to store headers to, if you use a callback it + is simply passed to the callback unmodified */ + CURLOPT(CURLOPT_HEADERDATA, CURLOPTTYPE_CBPOINT, 29), + + /* point to a file to read the initial cookies from, also enables + "cookie awareness" */ + CURLOPT(CURLOPT_COOKIEFILE, CURLOPTTYPE_STRINGPOINT, 31), + + /* What version to specifically try to use. + See CURL_SSLVERSION defines below. */ + CURLOPT(CURLOPT_SSLVERSION, CURLOPTTYPE_VALUES, 32), + + /* What kind of HTTP time condition to use, see defines */ + CURLOPT(CURLOPT_TIMECONDITION, CURLOPTTYPE_VALUES, 33), + + /* Time to use with the above condition. Specified in number of seconds + since 1 Jan 1970 */ + CURLOPT(CURLOPT_TIMEVALUE, CURLOPTTYPE_LONG, 34), + + /* 35 = OBSOLETE */ + + /* Custom request, for customizing the get command like + HTTP: DELETE, TRACE and others + FTP: to use a different list command + */ + CURLOPT(CURLOPT_CUSTOMREQUEST, CURLOPTTYPE_STRINGPOINT, 36), + + /* FILE handle to use instead of stderr */ + CURLOPT(CURLOPT_STDERR, CURLOPTTYPE_OBJECTPOINT, 37), + + /* 38 is not used */ + + /* send linked-list of post-transfer QUOTE commands */ + CURLOPT(CURLOPT_POSTQUOTE, CURLOPTTYPE_SLISTPOINT, 39), + + /* 40 is not used */ + + /* talk a lot */ + CURLOPT(CURLOPT_VERBOSE, CURLOPTTYPE_LONG, 41), + + /* throw the header out too */ + CURLOPT(CURLOPT_HEADER, CURLOPTTYPE_LONG, 42), + + /* shut off the progress meter */ + CURLOPT(CURLOPT_NOPROGRESS, CURLOPTTYPE_LONG, 43), + + /* use HEAD to get http document */ + CURLOPT(CURLOPT_NOBODY, CURLOPTTYPE_LONG, 44), + + /* no output on http error codes >= 400 */ + CURLOPT(CURLOPT_FAILONERROR, CURLOPTTYPE_LONG, 45), + + /* this is an upload */ + CURLOPT(CURLOPT_UPLOAD, CURLOPTTYPE_LONG, 46), + + /* HTTP POST method */ + CURLOPT(CURLOPT_POST, CURLOPTTYPE_LONG, 47), + + /* bare names when listing directories */ + CURLOPT(CURLOPT_DIRLISTONLY, CURLOPTTYPE_LONG, 48), + + /* Append instead of overwrite on upload! */ + CURLOPT(CURLOPT_APPEND, CURLOPTTYPE_LONG, 50), + + /* Specify whether to read the user+password from the .netrc or the URL. + * This must be one of the CURL_NETRC_* enums below. */ + CURLOPT(CURLOPT_NETRC, CURLOPTTYPE_VALUES, 51), + + /* use Location: Luke! */ + CURLOPT(CURLOPT_FOLLOWLOCATION, CURLOPTTYPE_LONG, 52), + + /* transfer data in text/ASCII format */ + CURLOPT(CURLOPT_TRANSFERTEXT, CURLOPTTYPE_LONG, 53), + + /* HTTP PUT */ + CURLOPTDEPRECATED(CURLOPT_PUT, CURLOPTTYPE_LONG, 54, + 7.12.1, "Use CURLOPT_UPLOAD"), + + /* 55 = OBSOLETE */ + + /* DEPRECATED + * Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_progress_callback + * prototype defines. */ + CURLOPTDEPRECATED(CURLOPT_PROGRESSFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 56, + 7.32.0, "Use CURLOPT_XFERINFOFUNCTION"), + + /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION + callbacks */ + CURLOPT(CURLOPT_XFERINFODATA, CURLOPTTYPE_CBPOINT, 57), +#define CURLOPT_PROGRESSDATA CURLOPT_XFERINFODATA + + /* We want the referrer field set automatically when following locations */ + CURLOPT(CURLOPT_AUTOREFERER, CURLOPTTYPE_LONG, 58), + + /* Port of the proxy, can be set in the proxy string as well with: + "[host]:[port]" */ + CURLOPT(CURLOPT_PROXYPORT, CURLOPTTYPE_LONG, 59), + + /* size of the POST input data, if strlen() is not good to use */ + CURLOPT(CURLOPT_POSTFIELDSIZE, CURLOPTTYPE_LONG, 60), + + /* tunnel non-http operations through an HTTP proxy */ + CURLOPT(CURLOPT_HTTPPROXYTUNNEL, CURLOPTTYPE_LONG, 61), + + /* Set the interface string to use as outgoing network interface */ + CURLOPT(CURLOPT_INTERFACE, CURLOPTTYPE_STRINGPOINT, 62), + + /* Set the krb4/5 security level, this also enables krb4/5 awareness. This + * is a string, 'clear', 'safe', 'confidential' or 'private'. If the string + * is set but does not match one of these, 'private' will be used. */ + CURLOPT(CURLOPT_KRBLEVEL, CURLOPTTYPE_STRINGPOINT, 63), + + /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ + CURLOPT(CURLOPT_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 64), + + /* The CApath or CAfile used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_CAINFO, CURLOPTTYPE_STRINGPOINT, 65), + + /* 66 = OBSOLETE */ + /* 67 = OBSOLETE */ + + /* Maximum number of http redirects to follow */ + CURLOPT(CURLOPT_MAXREDIRS, CURLOPTTYPE_LONG, 68), + + /* Pass a long set to 1 to get the date of the requested document (if + possible)! Pass a zero to shut it off. */ + CURLOPT(CURLOPT_FILETIME, CURLOPTTYPE_LONG, 69), + + /* This points to a linked list of telnet options */ + CURLOPT(CURLOPT_TELNETOPTIONS, CURLOPTTYPE_SLISTPOINT, 70), + + /* Max amount of cached alive connections */ + CURLOPT(CURLOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 71), + + /* 72 = OBSOLETE */ + /* 73 = OBSOLETE */ + + /* Set to explicitly use a new connection for the upcoming transfer. + Do not use this unless you are absolutely sure of this, as it makes the + operation slower and is less friendly for the network. */ + CURLOPT(CURLOPT_FRESH_CONNECT, CURLOPTTYPE_LONG, 74), + + /* Set to explicitly forbid the upcoming transfer's connection to be reused + when done. Do not use this unless you are absolutely sure of this, as it + makes the operation slower and is less friendly for the network. */ + CURLOPT(CURLOPT_FORBID_REUSE, CURLOPTTYPE_LONG, 75), + + /* Set to a filename that contains random data for libcurl to use to + seed the random engine when doing SSL connects. */ + CURLOPTDEPRECATED(CURLOPT_RANDOM_FILE, CURLOPTTYPE_STRINGPOINT, 76, + 7.84.0, "Serves no purpose anymore"), + + /* Set to the Entropy Gathering Daemon socket pathname */ + CURLOPTDEPRECATED(CURLOPT_EGDSOCKET, CURLOPTTYPE_STRINGPOINT, 77, + 7.84.0, "Serves no purpose anymore"), + + /* Time-out connect operations after this amount of seconds, if connects are + OK within this time, then fine... This only aborts the connect phase. */ + CURLOPT(CURLOPT_CONNECTTIMEOUT, CURLOPTTYPE_LONG, 78), + + /* Function that will be called to store headers (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CURLOPT(CURLOPT_HEADERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 79), + + /* Set this to force the HTTP request to get back to GET. Only really usable + if POST, PUT or a custom request have been used first. + */ + CURLOPT(CURLOPT_HTTPGET, CURLOPTTYPE_LONG, 80), + + /* Set if we should verify the Common name from the peer certificate in ssl + * handshake, set 1 to check existence, 2 to ensure that it matches the + * provided hostname. */ + CURLOPT(CURLOPT_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 81), + + /* Specify which filename to write all known cookies in after completed + operation. Set filename to "-" (dash) to make it go to stdout. */ + CURLOPT(CURLOPT_COOKIEJAR, CURLOPTTYPE_STRINGPOINT, 82), + + /* Specify which TLS 1.2 (1.1, 1.0) ciphers to use */ + CURLOPT(CURLOPT_SSL_CIPHER_LIST, CURLOPTTYPE_STRINGPOINT, 83), + + /* Specify which HTTP version to use! This must be set to one of the + CURL_HTTP_VERSION* enums set below. */ + CURLOPT(CURLOPT_HTTP_VERSION, CURLOPTTYPE_VALUES, 84), + + /* Specifically switch on or off the FTP engine's use of the EPSV command. By + default, that one will always be attempted before the more traditional + PASV command. */ + CURLOPT(CURLOPT_FTP_USE_EPSV, CURLOPTTYPE_LONG, 85), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ + CURLOPT(CURLOPT_SSLCERTTYPE, CURLOPTTYPE_STRINGPOINT, 86), + + /* name of the file keeping your private SSL-key */ + CURLOPT(CURLOPT_SSLKEY, CURLOPTTYPE_STRINGPOINT, 87), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ + CURLOPT(CURLOPT_SSLKEYTYPE, CURLOPTTYPE_STRINGPOINT, 88), + + /* crypto engine for the SSL-sub system */ + CURLOPT(CURLOPT_SSLENGINE, CURLOPTTYPE_STRINGPOINT, 89), + + /* set the crypto engine for the SSL-sub system as default + the param has no meaning... + */ + CURLOPT(CURLOPT_SSLENGINE_DEFAULT, CURLOPTTYPE_LONG, 90), + + /* Non-zero value means to use the global dns cache */ + /* DEPRECATED, do not use! */ + CURLOPTDEPRECATED(CURLOPT_DNS_USE_GLOBAL_CACHE, CURLOPTTYPE_LONG, 91, + 7.11.1, "Use CURLOPT_SHARE"), + + /* DNS cache timeout */ + CURLOPT(CURLOPT_DNS_CACHE_TIMEOUT, CURLOPTTYPE_LONG, 92), + + /* send linked-list of pre-transfer QUOTE commands */ + CURLOPT(CURLOPT_PREQUOTE, CURLOPTTYPE_SLISTPOINT, 93), + + /* set the debug function */ + CURLOPT(CURLOPT_DEBUGFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 94), + + /* set the data for the debug function */ + CURLOPT(CURLOPT_DEBUGDATA, CURLOPTTYPE_CBPOINT, 95), + + /* mark this as start of a cookie session */ + CURLOPT(CURLOPT_COOKIESESSION, CURLOPTTYPE_LONG, 96), + + /* The CApath directory used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_CAPATH, CURLOPTTYPE_STRINGPOINT, 97), + + /* Instruct libcurl to use a smaller receive buffer */ + CURLOPT(CURLOPT_BUFFERSIZE, CURLOPTTYPE_LONG, 98), + + /* Instruct libcurl to not use any signal/alarm handlers, even when using + timeouts. This option is useful for multi-threaded applications. + See libcurl-the-guide for more background information. */ + CURLOPT(CURLOPT_NOSIGNAL, CURLOPTTYPE_LONG, 99), + + /* Provide a CURLShare for mutexing non-ts data */ + CURLOPT(CURLOPT_SHARE, CURLOPTTYPE_OBJECTPOINT, 100), + + /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), + CURLPROXY_HTTPS, CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and + CURLPROXY_SOCKS5. */ + CURLOPT(CURLOPT_PROXYTYPE, CURLOPTTYPE_VALUES, 101), + + /* Set the Accept-Encoding string. Use this to tell a server you would like + the response to be compressed. Before 7.21.6, this was known as + CURLOPT_ENCODING */ + CURLOPT(CURLOPT_ACCEPT_ENCODING, CURLOPTTYPE_STRINGPOINT, 102), + + /* Set pointer to private data */ + CURLOPT(CURLOPT_PRIVATE, CURLOPTTYPE_OBJECTPOINT, 103), + + /* Set aliases for HTTP 200 in the HTTP Response header */ + CURLOPT(CURLOPT_HTTP200ALIASES, CURLOPTTYPE_SLISTPOINT, 104), + + /* Continue to send authentication (user+password) when following locations, + even when hostname changed. This can potentially send off the name + and password to whatever host the server decides. */ + CURLOPT(CURLOPT_UNRESTRICTED_AUTH, CURLOPTTYPE_LONG, 105), + + /* Specifically switch on or off the FTP engine's use of the EPRT command ( + it also disables the LPRT attempt). By default, those ones will always be + attempted before the good old traditional PORT command. */ + CURLOPT(CURLOPT_FTP_USE_EPRT, CURLOPTTYPE_LONG, 106), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_USERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CURLOPT(CURLOPT_HTTPAUTH, CURLOPTTYPE_VALUES, 107), + + /* Set the ssl context callback function, currently only for OpenSSL or + wolfSSL ssl_ctx, or mbedTLS mbedtls_ssl_config in the second argument. + The function must match the curl_ssl_ctx_callback prototype. */ + CURLOPT(CURLOPT_SSL_CTX_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 108), + + /* Set the userdata for the ssl context callback function's third + argument */ + CURLOPT(CURLOPT_SSL_CTX_DATA, CURLOPTTYPE_CBPOINT, 109), + + /* FTP Option that causes missing dirs to be created on the remote server. + In 7.19.4 we introduced the convenience enums for this option using the + CURLFTP_CREATE_DIR prefix. + */ + CURLOPT(CURLOPT_FTP_CREATE_MISSING_DIRS, CURLOPTTYPE_LONG, 110), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_PROXYUSERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CURLOPT(CURLOPT_PROXYAUTH, CURLOPTTYPE_VALUES, 111), + + /* Option that changes the timeout, in seconds, associated with getting a + response. This is different from transfer timeout time and essentially + places a demand on the server to acknowledge commands in a timely + manner. For FTP, SMTP, IMAP and POP3. */ + CURLOPT(CURLOPT_SERVER_RESPONSE_TIMEOUT, CURLOPTTYPE_LONG, 112), + + /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to + tell libcurl to use those IP versions only. This only has effect on + systems with support for more than one, i.e IPv4 _and_ IPv6. */ + CURLOPT(CURLOPT_IPRESOLVE, CURLOPTTYPE_VALUES, 113), + + /* Set this option to limit the size of a file that will be downloaded from + an HTTP or FTP server. + + Note there is also _LARGE version which adds large file support for + platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */ + CURLOPT(CURLOPT_MAXFILESIZE, CURLOPTTYPE_LONG, 114), + + /* See the comment for INFILESIZE above, but in short, specifies + * the size of the file being uploaded. -1 means unknown. + */ + CURLOPT(CURLOPT_INFILESIZE_LARGE, CURLOPTTYPE_OFF_T, 115), + + /* Sets the continuation offset. There is also a CURLOPTTYPE_LONG version + * of this; look above for RESUME_FROM. + */ + CURLOPT(CURLOPT_RESUME_FROM_LARGE, CURLOPTTYPE_OFF_T, 116), + + /* Sets the maximum size of data that will be downloaded from + * an HTTP or FTP server. See MAXFILESIZE above for the LONG version. + */ + CURLOPT(CURLOPT_MAXFILESIZE_LARGE, CURLOPTTYPE_OFF_T, 117), + + /* Set this option to the filename of your .netrc file you want libcurl + to parse (using the CURLOPT_NETRC option). If not set, libcurl will do + a poor attempt to find the user's home directory and check for a .netrc + file in there. */ + CURLOPT(CURLOPT_NETRC_FILE, CURLOPTTYPE_STRINGPOINT, 118), + + /* Enable SSL/TLS for FTP, pick one of: + CURLUSESSL_TRY - try using SSL, proceed anyway otherwise + CURLUSESSL_CONTROL - SSL for the control connection or fail + CURLUSESSL_ALL - SSL for all communication or fail + */ + CURLOPT(CURLOPT_USE_SSL, CURLOPTTYPE_VALUES, 119), + + /* The _LARGE version of the standard POSTFIELDSIZE option */ + CURLOPT(CURLOPT_POSTFIELDSIZE_LARGE, CURLOPTTYPE_OFF_T, 120), + + /* Enable/disable the TCP Nagle algorithm */ + CURLOPT(CURLOPT_TCP_NODELAY, CURLOPTTYPE_LONG, 121), + + /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 123 OBSOLETE. Gone in 7.16.0 */ + /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 127 OBSOLETE. Gone in 7.16.0 */ + /* 128 OBSOLETE. Gone in 7.16.0 */ + + /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option + can be used to change libcurl's default action which is to first try + "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK + response has been received. + + Available parameters are: + CURLFTPAUTH_DEFAULT - let libcurl decide + CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS + CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL + */ + CURLOPT(CURLOPT_FTPSSLAUTH, CURLOPTTYPE_VALUES, 129), + + CURLOPTDEPRECATED(CURLOPT_IOCTLFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 130, + 7.18.0, "Use CURLOPT_SEEKFUNCTION"), + CURLOPTDEPRECATED(CURLOPT_IOCTLDATA, CURLOPTTYPE_CBPOINT, 131, + 7.18.0, "Use CURLOPT_SEEKDATA"), + + /* 132 OBSOLETE. Gone in 7.16.0 */ + /* 133 OBSOLETE. Gone in 7.16.0 */ + + /* null-terminated string for pass on to the FTP server when asked for + "account" info */ + CURLOPT(CURLOPT_FTP_ACCOUNT, CURLOPTTYPE_STRINGPOINT, 134), + + /* feed cookie into cookie engine */ + CURLOPT(CURLOPT_COOKIELIST, CURLOPTTYPE_STRINGPOINT, 135), + + /* ignore Content-Length */ + CURLOPT(CURLOPT_IGNORE_CONTENT_LENGTH, CURLOPTTYPE_LONG, 136), + + /* Set to non-zero to skip the IP address received in a 227 PASV FTP server + response. Typically used for FTP-SSL purposes but is not restricted to + that. libcurl will then instead use the same IP address it used for the + control connection. */ + CURLOPT(CURLOPT_FTP_SKIP_PASV_IP, CURLOPTTYPE_LONG, 137), + + /* Select "file method" to use when doing FTP, see the curl_ftpmethod + above. */ + CURLOPT(CURLOPT_FTP_FILEMETHOD, CURLOPTTYPE_VALUES, 138), + + /* Local port number to bind the socket to */ + CURLOPT(CURLOPT_LOCALPORT, CURLOPTTYPE_LONG, 139), + + /* Number of ports to try, including the first one set with LOCALPORT. + Thus, setting it to 1 will make no additional attempts but the first. + */ + CURLOPT(CURLOPT_LOCALPORTRANGE, CURLOPTTYPE_LONG, 140), + + /* no transfer, set up connection and let application use the socket by + extracting it with CURLINFO_LASTSOCKET */ + CURLOPT(CURLOPT_CONNECT_ONLY, CURLOPTTYPE_LONG, 141), + + /* Function that will be called to convert from the + network encoding (instead of using the iconv calls in libcurl) */ + CURLOPTDEPRECATED(CURLOPT_CONV_FROM_NETWORK_FUNCTION, + CURLOPTTYPE_FUNCTIONPOINT, 142, + 7.82.0, "Serves no purpose anymore"), + + /* Function that will be called to convert to the + network encoding (instead of using the iconv calls in libcurl) */ + CURLOPTDEPRECATED(CURLOPT_CONV_TO_NETWORK_FUNCTION, + CURLOPTTYPE_FUNCTIONPOINT, 143, + 7.82.0, "Serves no purpose anymore"), + + /* Function that will be called to convert from UTF8 + (instead of using the iconv calls in libcurl) + Note that this is used only for SSL certificate processing */ + CURLOPTDEPRECATED(CURLOPT_CONV_FROM_UTF8_FUNCTION, + CURLOPTTYPE_FUNCTIONPOINT, 144, + 7.82.0, "Serves no purpose anymore"), + + /* if the connection proceeds too quickly then need to slow it down */ + /* limit-rate: maximum number of bytes per second to send or receive */ + CURLOPT(CURLOPT_MAX_SEND_SPEED_LARGE, CURLOPTTYPE_OFF_T, 145), + CURLOPT(CURLOPT_MAX_RECV_SPEED_LARGE, CURLOPTTYPE_OFF_T, 146), + + /* Pointer to command string to send if USER/PASS fails. */ + CURLOPT(CURLOPT_FTP_ALTERNATIVE_TO_USER, CURLOPTTYPE_STRINGPOINT, 147), + + /* callback function for setting socket options */ + CURLOPT(CURLOPT_SOCKOPTFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 148), + CURLOPT(CURLOPT_SOCKOPTDATA, CURLOPTTYPE_CBPOINT, 149), + + /* set to 0 to disable session ID reuse for this transfer, default is + enabled (== 1) */ + CURLOPT(CURLOPT_SSL_SESSIONID_CACHE, CURLOPTTYPE_LONG, 150), + + /* allowed SSH authentication methods */ + CURLOPT(CURLOPT_SSH_AUTH_TYPES, CURLOPTTYPE_VALUES, 151), + + /* Used by scp/sftp to do public/private key authentication */ + CURLOPT(CURLOPT_SSH_PUBLIC_KEYFILE, CURLOPTTYPE_STRINGPOINT, 152), + CURLOPT(CURLOPT_SSH_PRIVATE_KEYFILE, CURLOPTTYPE_STRINGPOINT, 153), + + /* Send CCC (Clear Command Channel) after authentication */ + CURLOPT(CURLOPT_FTP_SSL_CCC, CURLOPTTYPE_LONG, 154), + + /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ + CURLOPT(CURLOPT_TIMEOUT_MS, CURLOPTTYPE_LONG, 155), + CURLOPT(CURLOPT_CONNECTTIMEOUT_MS, CURLOPTTYPE_LONG, 156), + + /* set to zero to disable the libcurl's decoding and thus pass the raw body + data to the application even when it is encoded/compressed */ + CURLOPT(CURLOPT_HTTP_TRANSFER_DECODING, CURLOPTTYPE_LONG, 157), + CURLOPT(CURLOPT_HTTP_CONTENT_DECODING, CURLOPTTYPE_LONG, 158), + + /* Permission used when creating new files and directories on the remote + server for protocols that support it, SFTP/SCP/FILE */ + CURLOPT(CURLOPT_NEW_FILE_PERMS, CURLOPTTYPE_LONG, 159), + CURLOPT(CURLOPT_NEW_DIRECTORY_PERMS, CURLOPTTYPE_LONG, 160), + + /* Set the behavior of POST when redirecting. Values must be set to one + of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */ + CURLOPT(CURLOPT_POSTREDIR, CURLOPTTYPE_VALUES, 161), + + /* used by scp/sftp to verify the host's public key */ + CURLOPT(CURLOPT_SSH_HOST_PUBLIC_KEY_MD5, CURLOPTTYPE_STRINGPOINT, 162), + + /* Callback function for opening socket (instead of socket(2)). Optionally, + callback is able change the address or refuse to connect returning + CURL_SOCKET_BAD. The callback should have type + curl_opensocket_callback */ + CURLOPT(CURLOPT_OPENSOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 163), + CURLOPT(CURLOPT_OPENSOCKETDATA, CURLOPTTYPE_CBPOINT, 164), + + /* POST volatile input fields. */ + CURLOPT(CURLOPT_COPYPOSTFIELDS, CURLOPTTYPE_OBJECTPOINT, 165), + + /* set transfer mode (;type=) when doing FTP via an HTTP proxy */ + CURLOPT(CURLOPT_PROXY_TRANSFER_MODE, CURLOPTTYPE_LONG, 166), + + /* Callback function for seeking in the input stream */ + CURLOPT(CURLOPT_SEEKFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 167), + CURLOPT(CURLOPT_SEEKDATA, CURLOPTTYPE_CBPOINT, 168), + + /* CRL file */ + CURLOPT(CURLOPT_CRLFILE, CURLOPTTYPE_STRINGPOINT, 169), + + /* Issuer certificate */ + CURLOPT(CURLOPT_ISSUERCERT, CURLOPTTYPE_STRINGPOINT, 170), + + /* (IPv6) Address scope */ + CURLOPT(CURLOPT_ADDRESS_SCOPE, CURLOPTTYPE_LONG, 171), + + /* Collect certificate chain info and allow it to get retrievable with + CURLINFO_CERTINFO after the transfer is complete. */ + CURLOPT(CURLOPT_CERTINFO, CURLOPTTYPE_LONG, 172), + + /* "name" and "pwd" to use when fetching. */ + CURLOPT(CURLOPT_USERNAME, CURLOPTTYPE_STRINGPOINT, 173), + CURLOPT(CURLOPT_PASSWORD, CURLOPTTYPE_STRINGPOINT, 174), + + /* "name" and "pwd" to use with Proxy when fetching. */ + CURLOPT(CURLOPT_PROXYUSERNAME, CURLOPTTYPE_STRINGPOINT, 175), + CURLOPT(CURLOPT_PROXYPASSWORD, CURLOPTTYPE_STRINGPOINT, 176), + + /* Comma separated list of hostnames defining no-proxy zones. These should + match both hostnames directly, and hostnames within a domain. For + example, local.com will match local.com and www.local.com, but NOT + notlocal.com or www.notlocal.com. For compatibility with other + implementations of this, .local.com will be considered to be the same as + local.com. A single * is the only valid wildcard, and effectively + disables the use of proxy. */ + CURLOPT(CURLOPT_NOPROXY, CURLOPTTYPE_STRINGPOINT, 177), + + /* block size for TFTP transfers */ + CURLOPT(CURLOPT_TFTP_BLKSIZE, CURLOPTTYPE_LONG, 178), + + /* Socks Service */ + /* DEPRECATED, do not use! */ + CURLOPTDEPRECATED(CURLOPT_SOCKS5_GSSAPI_SERVICE, + CURLOPTTYPE_STRINGPOINT, 179, + 7.49.0, "Use CURLOPT_PROXY_SERVICE_NAME"), + + /* Socks Service */ + CURLOPT(CURLOPT_SOCKS5_GSSAPI_NEC, CURLOPTTYPE_LONG, 180), + + /* set the bitmask for the protocols that are allowed to be used for the + transfer, which thus helps the app which takes URLs from users or other + external inputs and want to restrict what protocol(s) to deal + with. Defaults to CURLPROTO_ALL. */ + CURLOPTDEPRECATED(CURLOPT_PROTOCOLS, CURLOPTTYPE_LONG, 181, + 7.85.0, "Use CURLOPT_PROTOCOLS_STR"), + + /* set the bitmask for the protocols that libcurl is allowed to follow to, + as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs + to be set in both bitmasks to be allowed to get redirected to. */ + CURLOPTDEPRECATED(CURLOPT_REDIR_PROTOCOLS, CURLOPTTYPE_LONG, 182, + 7.85.0, "Use CURLOPT_REDIR_PROTOCOLS_STR"), + + /* set the SSH knownhost filename to use */ + CURLOPT(CURLOPT_SSH_KNOWNHOSTS, CURLOPTTYPE_STRINGPOINT, 183), + + /* set the SSH host key callback, must point to a curl_sshkeycallback + function */ + CURLOPT(CURLOPT_SSH_KEYFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 184), + + /* set the SSH host key callback custom pointer */ + CURLOPT(CURLOPT_SSH_KEYDATA, CURLOPTTYPE_CBPOINT, 185), + + /* set the SMTP mail originator */ + CURLOPT(CURLOPT_MAIL_FROM, CURLOPTTYPE_STRINGPOINT, 186), + + /* set the list of SMTP mail receiver(s) */ + CURLOPT(CURLOPT_MAIL_RCPT, CURLOPTTYPE_SLISTPOINT, 187), + + /* FTP: send PRET before PASV */ + CURLOPT(CURLOPT_FTP_USE_PRET, CURLOPTTYPE_LONG, 188), + + /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */ + CURLOPT(CURLOPT_RTSP_REQUEST, CURLOPTTYPE_VALUES, 189), + + /* The RTSP session identifier */ + CURLOPT(CURLOPT_RTSP_SESSION_ID, CURLOPTTYPE_STRINGPOINT, 190), + + /* The RTSP stream URI */ + CURLOPT(CURLOPT_RTSP_STREAM_URI, CURLOPTTYPE_STRINGPOINT, 191), + + /* The Transport: header to use in RTSP requests */ + CURLOPT(CURLOPT_RTSP_TRANSPORT, CURLOPTTYPE_STRINGPOINT, 192), + + /* Manually initialize the client RTSP CSeq for this handle */ + CURLOPT(CURLOPT_RTSP_CLIENT_CSEQ, CURLOPTTYPE_LONG, 193), + + /* Manually initialize the server RTSP CSeq for this handle */ + CURLOPT(CURLOPT_RTSP_SERVER_CSEQ, CURLOPTTYPE_LONG, 194), + + /* The stream to pass to INTERLEAVEFUNCTION. */ + CURLOPT(CURLOPT_INTERLEAVEDATA, CURLOPTTYPE_CBPOINT, 195), + + /* Let the application define a custom write method for RTP data */ + CURLOPT(CURLOPT_INTERLEAVEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 196), + + /* Turn on wildcard matching */ + CURLOPT(CURLOPT_WILDCARDMATCH, CURLOPTTYPE_LONG, 197), + + /* Directory matching callback called before downloading of an + individual file (chunk) started */ + CURLOPT(CURLOPT_CHUNK_BGN_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 198), + + /* Directory matching callback called after the file (chunk) + was downloaded, or skipped */ + CURLOPT(CURLOPT_CHUNK_END_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 199), + + /* Change match (fnmatch-like) callback for wildcard matching */ + CURLOPT(CURLOPT_FNMATCH_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 200), + + /* Let the application define custom chunk data pointer */ + CURLOPT(CURLOPT_CHUNK_DATA, CURLOPTTYPE_CBPOINT, 201), + + /* FNMATCH_FUNCTION user pointer */ + CURLOPT(CURLOPT_FNMATCH_DATA, CURLOPTTYPE_CBPOINT, 202), + + /* send linked-list of name:port:address sets */ + CURLOPT(CURLOPT_RESOLVE, CURLOPTTYPE_SLISTPOINT, 203), + + /* Set a username for authenticated TLS */ + CURLOPT(CURLOPT_TLSAUTH_USERNAME, CURLOPTTYPE_STRINGPOINT, 204), + + /* Set a password for authenticated TLS */ + CURLOPT(CURLOPT_TLSAUTH_PASSWORD, CURLOPTTYPE_STRINGPOINT, 205), + + /* Set authentication type for authenticated TLS */ + CURLOPT(CURLOPT_TLSAUTH_TYPE, CURLOPTTYPE_STRINGPOINT, 206), + + /* Set to 1 to enable the "TE:" header in HTTP requests to ask for + compressed transfer-encoded responses. Set to 0 to disable the use of TE: + in outgoing requests. The current default is 0, but it might change in a + future libcurl release. + + libcurl will ask for the compressed methods it knows of, and if that + is not any, it will not ask for transfer-encoding at all even if this + option is set to 1. + + */ + CURLOPT(CURLOPT_TRANSFER_ENCODING, CURLOPTTYPE_LONG, 207), + + /* Callback function for closing socket (instead of close(2)). The callback + should have type curl_closesocket_callback */ + CURLOPT(CURLOPT_CLOSESOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 208), + CURLOPT(CURLOPT_CLOSESOCKETDATA, CURLOPTTYPE_CBPOINT, 209), + + /* allow GSSAPI credential delegation */ + CURLOPT(CURLOPT_GSSAPI_DELEGATION, CURLOPTTYPE_VALUES, 210), + + /* Set the name servers to use for DNS resolution. + * Only supported by the c-ares DNS backend */ + CURLOPT(CURLOPT_DNS_SERVERS, CURLOPTTYPE_STRINGPOINT, 211), + + /* Time-out accept operations (currently for FTP only) after this amount + of milliseconds. */ + CURLOPT(CURLOPT_ACCEPTTIMEOUT_MS, CURLOPTTYPE_LONG, 212), + + /* Set TCP keepalive */ + CURLOPT(CURLOPT_TCP_KEEPALIVE, CURLOPTTYPE_LONG, 213), + + /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */ + CURLOPT(CURLOPT_TCP_KEEPIDLE, CURLOPTTYPE_LONG, 214), + CURLOPT(CURLOPT_TCP_KEEPINTVL, CURLOPTTYPE_LONG, 215), + + /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */ + CURLOPT(CURLOPT_SSL_OPTIONS, CURLOPTTYPE_VALUES, 216), + + /* Set the SMTP auth originator */ + CURLOPT(CURLOPT_MAIL_AUTH, CURLOPTTYPE_STRINGPOINT, 217), + + /* Enable/disable SASL initial response */ + CURLOPT(CURLOPT_SASL_IR, CURLOPTTYPE_LONG, 218), + + /* Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_xferinfo_callback + * prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */ + CURLOPT(CURLOPT_XFERINFOFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 219), + + /* The XOAUTH2 bearer token */ + CURLOPT(CURLOPT_XOAUTH2_BEARER, CURLOPTTYPE_STRINGPOINT, 220), + + /* Set the interface string to use as outgoing network + * interface for DNS requests. + * Only supported by the c-ares DNS backend */ + CURLOPT(CURLOPT_DNS_INTERFACE, CURLOPTTYPE_STRINGPOINT, 221), + + /* Set the local IPv4 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CURLOPT(CURLOPT_DNS_LOCAL_IP4, CURLOPTTYPE_STRINGPOINT, 222), + + /* Set the local IPv6 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CURLOPT(CURLOPT_DNS_LOCAL_IP6, CURLOPTTYPE_STRINGPOINT, 223), + + /* Set authentication options directly */ + CURLOPT(CURLOPT_LOGIN_OPTIONS, CURLOPTTYPE_STRINGPOINT, 224), + + /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */ + CURLOPTDEPRECATED(CURLOPT_SSL_ENABLE_NPN, CURLOPTTYPE_LONG, 225, + 7.86.0, "Has no function"), + + /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */ + CURLOPT(CURLOPT_SSL_ENABLE_ALPN, CURLOPTTYPE_LONG, 226), + + /* Time to wait for a response to an HTTP request containing an + * Expect: 100-continue header before sending the data anyway. */ + CURLOPT(CURLOPT_EXPECT_100_TIMEOUT_MS, CURLOPTTYPE_LONG, 227), + + /* This points to a linked list of headers used for proxy requests only, + struct curl_slist kind */ + CURLOPT(CURLOPT_PROXYHEADER, CURLOPTTYPE_SLISTPOINT, 228), + + /* Pass in a bitmask of "header options" */ + CURLOPT(CURLOPT_HEADEROPT, CURLOPTTYPE_VALUES, 229), + + /* The public key in DER form used to validate the peer public key + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PINNEDPUBLICKEY, CURLOPTTYPE_STRINGPOINT, 230), + + /* Path to Unix domain socket */ + CURLOPT(CURLOPT_UNIX_SOCKET_PATH, CURLOPTTYPE_STRINGPOINT, 231), + + /* Set if we should verify the certificate status. */ + CURLOPT(CURLOPT_SSL_VERIFYSTATUS, CURLOPTTYPE_LONG, 232), + + /* Set if we should enable TLS false start. */ + CURLOPT(CURLOPT_SSL_FALSESTART, CURLOPTTYPE_LONG, 233), + + /* Do not squash dot-dot sequences */ + CURLOPT(CURLOPT_PATH_AS_IS, CURLOPTTYPE_LONG, 234), + + /* Proxy Service Name */ + CURLOPT(CURLOPT_PROXY_SERVICE_NAME, CURLOPTTYPE_STRINGPOINT, 235), + + /* Service Name */ + CURLOPT(CURLOPT_SERVICE_NAME, CURLOPTTYPE_STRINGPOINT, 236), + + /* Wait/do not wait for pipe/mutex to clarify */ + CURLOPT(CURLOPT_PIPEWAIT, CURLOPTTYPE_LONG, 237), + + /* Set the protocol used when curl is given a URL without a protocol */ + CURLOPT(CURLOPT_DEFAULT_PROTOCOL, CURLOPTTYPE_STRINGPOINT, 238), + + /* Set stream weight, 1 - 256 (default is 16) */ + CURLOPT(CURLOPT_STREAM_WEIGHT, CURLOPTTYPE_LONG, 239), + + /* Set stream dependency on another curl handle */ + CURLOPT(CURLOPT_STREAM_DEPENDS, CURLOPTTYPE_OBJECTPOINT, 240), + + /* Set E-xclusive stream dependency on another curl handle */ + CURLOPT(CURLOPT_STREAM_DEPENDS_E, CURLOPTTYPE_OBJECTPOINT, 241), + + /* Do not send any tftp option requests to the server */ + CURLOPT(CURLOPT_TFTP_NO_OPTIONS, CURLOPTTYPE_LONG, 242), + + /* Linked-list of host:port:connect-to-host:connect-to-port, + overrides the URL's host:port (only for the network layer) */ + CURLOPT(CURLOPT_CONNECT_TO, CURLOPTTYPE_SLISTPOINT, 243), + + /* Set TCP Fast Open */ + CURLOPT(CURLOPT_TCP_FASTOPEN, CURLOPTTYPE_LONG, 244), + + /* Continue to send data if the server responds early with an + * HTTP status code >= 300 */ + CURLOPT(CURLOPT_KEEP_SENDING_ON_ERROR, CURLOPTTYPE_LONG, 245), + + /* The CApath or CAfile used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_CAINFO, CURLOPTTYPE_STRINGPOINT, 246), + + /* The CApath directory used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_CAPATH, CURLOPTTYPE_STRINGPOINT, 247), + + /* Set if we should verify the proxy in ssl handshake, + set 1 to verify. */ + CURLOPT(CURLOPT_PROXY_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 248), + + /* Set if we should verify the Common name from the proxy certificate in ssl + * handshake, set 1 to check existence, 2 to ensure that it matches + * the provided hostname. */ + CURLOPT(CURLOPT_PROXY_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 249), + + /* What version to specifically try to use for proxy. + See CURL_SSLVERSION defines below. */ + CURLOPT(CURLOPT_PROXY_SSLVERSION, CURLOPTTYPE_VALUES, 250), + + /* Set a username for authenticated TLS for proxy */ + CURLOPT(CURLOPT_PROXY_TLSAUTH_USERNAME, CURLOPTTYPE_STRINGPOINT, 251), + + /* Set a password for authenticated TLS for proxy */ + CURLOPT(CURLOPT_PROXY_TLSAUTH_PASSWORD, CURLOPTTYPE_STRINGPOINT, 252), + + /* Set authentication type for authenticated TLS for proxy */ + CURLOPT(CURLOPT_PROXY_TLSAUTH_TYPE, CURLOPTTYPE_STRINGPOINT, 253), + + /* name of the file keeping your private SSL-certificate for proxy */ + CURLOPT(CURLOPT_PROXY_SSLCERT, CURLOPTTYPE_STRINGPOINT, 254), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") for + proxy */ + CURLOPT(CURLOPT_PROXY_SSLCERTTYPE, CURLOPTTYPE_STRINGPOINT, 255), + + /* name of the file keeping your private SSL-key for proxy */ + CURLOPT(CURLOPT_PROXY_SSLKEY, CURLOPTTYPE_STRINGPOINT, 256), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") for + proxy */ + CURLOPT(CURLOPT_PROXY_SSLKEYTYPE, CURLOPTTYPE_STRINGPOINT, 257), + + /* password for the SSL private key for proxy */ + CURLOPT(CURLOPT_PROXY_KEYPASSWD, CURLOPTTYPE_STRINGPOINT, 258), + + /* Specify which TLS 1.2 (1.1, 1.0) ciphers to use for proxy */ + CURLOPT(CURLOPT_PROXY_SSL_CIPHER_LIST, CURLOPTTYPE_STRINGPOINT, 259), + + /* CRL file for proxy */ + CURLOPT(CURLOPT_PROXY_CRLFILE, CURLOPTTYPE_STRINGPOINT, 260), + + /* Enable/disable specific SSL features with a bitmask for proxy, see + CURLSSLOPT_* */ + CURLOPT(CURLOPT_PROXY_SSL_OPTIONS, CURLOPTTYPE_LONG, 261), + + /* Name of pre proxy to use. */ + CURLOPT(CURLOPT_PRE_PROXY, CURLOPTTYPE_STRINGPOINT, 262), + + /* The public key in DER form used to validate the proxy public key + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_PINNEDPUBLICKEY, CURLOPTTYPE_STRINGPOINT, 263), + + /* Path to an abstract Unix domain socket */ + CURLOPT(CURLOPT_ABSTRACT_UNIX_SOCKET, CURLOPTTYPE_STRINGPOINT, 264), + + /* Suppress proxy CONNECT response headers from user callbacks */ + CURLOPT(CURLOPT_SUPPRESS_CONNECT_HEADERS, CURLOPTTYPE_LONG, 265), + + /* The request target, instead of extracted from the URL */ + CURLOPT(CURLOPT_REQUEST_TARGET, CURLOPTTYPE_STRINGPOINT, 266), + + /* bitmask of allowed auth methods for connections to SOCKS5 proxies */ + CURLOPT(CURLOPT_SOCKS5_AUTH, CURLOPTTYPE_LONG, 267), + + /* Enable/disable SSH compression */ + CURLOPT(CURLOPT_SSH_COMPRESSION, CURLOPTTYPE_LONG, 268), + + /* Post MIME data. */ + CURLOPT(CURLOPT_MIMEPOST, CURLOPTTYPE_OBJECTPOINT, 269), + + /* Time to use with the CURLOPT_TIMECONDITION. Specified in number of + seconds since 1 Jan 1970. */ + CURLOPT(CURLOPT_TIMEVALUE_LARGE, CURLOPTTYPE_OFF_T, 270), + + /* Head start in milliseconds to give happy eyeballs. */ + CURLOPT(CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS, CURLOPTTYPE_LONG, 271), + + /* Function that will be called before a resolver request is made */ + CURLOPT(CURLOPT_RESOLVER_START_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 272), + + /* User data to pass to the resolver start callback. */ + CURLOPT(CURLOPT_RESOLVER_START_DATA, CURLOPTTYPE_CBPOINT, 273), + + /* send HAProxy PROXY protocol header? */ + CURLOPT(CURLOPT_HAPROXYPROTOCOL, CURLOPTTYPE_LONG, 274), + + /* shuffle addresses before use when DNS returns multiple */ + CURLOPT(CURLOPT_DNS_SHUFFLE_ADDRESSES, CURLOPTTYPE_LONG, 275), + + /* Specify which TLS 1.3 ciphers suites to use */ + CURLOPT(CURLOPT_TLS13_CIPHERS, CURLOPTTYPE_STRINGPOINT, 276), + CURLOPT(CURLOPT_PROXY_TLS13_CIPHERS, CURLOPTTYPE_STRINGPOINT, 277), + + /* Disallow specifying username/login in URL. */ + CURLOPT(CURLOPT_DISALLOW_USERNAME_IN_URL, CURLOPTTYPE_LONG, 278), + + /* DNS-over-HTTPS URL */ + CURLOPT(CURLOPT_DOH_URL, CURLOPTTYPE_STRINGPOINT, 279), + + /* Preferred buffer size to use for uploads */ + CURLOPT(CURLOPT_UPLOAD_BUFFERSIZE, CURLOPTTYPE_LONG, 280), + + /* Time in ms between connection upkeep calls for long-lived connections. */ + CURLOPT(CURLOPT_UPKEEP_INTERVAL_MS, CURLOPTTYPE_LONG, 281), + + /* Specify URL using CURL URL API. */ + CURLOPT(CURLOPT_CURLU, CURLOPTTYPE_OBJECTPOINT, 282), + + /* add trailing data just after no more data is available */ + CURLOPT(CURLOPT_TRAILERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 283), + + /* pointer to be passed to HTTP_TRAILER_FUNCTION */ + CURLOPT(CURLOPT_TRAILERDATA, CURLOPTTYPE_CBPOINT, 284), + + /* set this to 1L to allow HTTP/0.9 responses or 0L to disallow */ + CURLOPT(CURLOPT_HTTP09_ALLOWED, CURLOPTTYPE_LONG, 285), + + /* alt-svc control bitmask */ + CURLOPT(CURLOPT_ALTSVC_CTRL, CURLOPTTYPE_LONG, 286), + + /* alt-svc cache filename to possibly read from/write to */ + CURLOPT(CURLOPT_ALTSVC, CURLOPTTYPE_STRINGPOINT, 287), + + /* maximum age (idle time) of a connection to consider it for reuse + * (in seconds) */ + CURLOPT(CURLOPT_MAXAGE_CONN, CURLOPTTYPE_LONG, 288), + + /* SASL authorization identity */ + CURLOPT(CURLOPT_SASL_AUTHZID, CURLOPTTYPE_STRINGPOINT, 289), + + /* allow RCPT TO command to fail for some recipients */ + CURLOPT(CURLOPT_MAIL_RCPT_ALLOWFAILS, CURLOPTTYPE_LONG, 290), + + /* the private SSL-certificate as a "blob" */ + CURLOPT(CURLOPT_SSLCERT_BLOB, CURLOPTTYPE_BLOB, 291), + CURLOPT(CURLOPT_SSLKEY_BLOB, CURLOPTTYPE_BLOB, 292), + CURLOPT(CURLOPT_PROXY_SSLCERT_BLOB, CURLOPTTYPE_BLOB, 293), + CURLOPT(CURLOPT_PROXY_SSLKEY_BLOB, CURLOPTTYPE_BLOB, 294), + CURLOPT(CURLOPT_ISSUERCERT_BLOB, CURLOPTTYPE_BLOB, 295), + + /* Issuer certificate for proxy */ + CURLOPT(CURLOPT_PROXY_ISSUERCERT, CURLOPTTYPE_STRINGPOINT, 296), + CURLOPT(CURLOPT_PROXY_ISSUERCERT_BLOB, CURLOPTTYPE_BLOB, 297), + + /* the EC curves requested by the TLS client (RFC 8422, 5.1); + * OpenSSL support via 'set_groups'/'set_curves': + * https://docs.openssl.org/master/man3/SSL_CTX_set1_curves/ + */ + CURLOPT(CURLOPT_SSL_EC_CURVES, CURLOPTTYPE_STRINGPOINT, 298), + + /* HSTS bitmask */ + CURLOPT(CURLOPT_HSTS_CTRL, CURLOPTTYPE_LONG, 299), + /* HSTS filename */ + CURLOPT(CURLOPT_HSTS, CURLOPTTYPE_STRINGPOINT, 300), + + /* HSTS read callback */ + CURLOPT(CURLOPT_HSTSREADFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 301), + CURLOPT(CURLOPT_HSTSREADDATA, CURLOPTTYPE_CBPOINT, 302), + + /* HSTS write callback */ + CURLOPT(CURLOPT_HSTSWRITEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 303), + CURLOPT(CURLOPT_HSTSWRITEDATA, CURLOPTTYPE_CBPOINT, 304), + + /* Parameters for V4 signature */ + CURLOPT(CURLOPT_AWS_SIGV4, CURLOPTTYPE_STRINGPOINT, 305), + + /* Same as CURLOPT_SSL_VERIFYPEER but for DoH (DNS-over-HTTPS) servers. */ + CURLOPT(CURLOPT_DOH_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 306), + + /* Same as CURLOPT_SSL_VERIFYHOST but for DoH (DNS-over-HTTPS) servers. */ + CURLOPT(CURLOPT_DOH_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 307), + + /* Same as CURLOPT_SSL_VERIFYSTATUS but for DoH (DNS-over-HTTPS) servers. */ + CURLOPT(CURLOPT_DOH_SSL_VERIFYSTATUS, CURLOPTTYPE_LONG, 308), + + /* The CA certificates as "blob" used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_CAINFO_BLOB, CURLOPTTYPE_BLOB, 309), + + /* The CA certificates as "blob" used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_CAINFO_BLOB, CURLOPTTYPE_BLOB, 310), + + /* used by scp/sftp to verify the host's public key */ + CURLOPT(CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256, CURLOPTTYPE_STRINGPOINT, 311), + + /* Function that will be called immediately before the initial request + is made on a connection (after any protocol negotiation step). */ + CURLOPT(CURLOPT_PREREQFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 312), + + /* Data passed to the CURLOPT_PREREQFUNCTION callback */ + CURLOPT(CURLOPT_PREREQDATA, CURLOPTTYPE_CBPOINT, 313), + + /* maximum age (since creation) of a connection to consider it for reuse + * (in seconds) */ + CURLOPT(CURLOPT_MAXLIFETIME_CONN, CURLOPTTYPE_LONG, 314), + + /* Set MIME option flags. */ + CURLOPT(CURLOPT_MIME_OPTIONS, CURLOPTTYPE_LONG, 315), + + /* set the SSH host key callback, must point to a curl_sshkeycallback + function */ + CURLOPT(CURLOPT_SSH_HOSTKEYFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 316), + + /* set the SSH host key callback custom pointer */ + CURLOPT(CURLOPT_SSH_HOSTKEYDATA, CURLOPTTYPE_CBPOINT, 317), + + /* specify which protocols that are allowed to be used for the transfer, + which thus helps the app which takes URLs from users or other external + inputs and want to restrict what protocol(s) to deal with. Defaults to + all built-in protocols. */ + CURLOPT(CURLOPT_PROTOCOLS_STR, CURLOPTTYPE_STRINGPOINT, 318), + + /* specify which protocols that libcurl is allowed to follow directs to */ + CURLOPT(CURLOPT_REDIR_PROTOCOLS_STR, CURLOPTTYPE_STRINGPOINT, 319), + + /* WebSockets options */ + CURLOPT(CURLOPT_WS_OPTIONS, CURLOPTTYPE_LONG, 320), + + /* CA cache timeout */ + CURLOPT(CURLOPT_CA_CACHE_TIMEOUT, CURLOPTTYPE_LONG, 321), + + /* Can leak things, gonna exit() soon */ + CURLOPT(CURLOPT_QUICK_EXIT, CURLOPTTYPE_LONG, 322), + + /* set a specific client IP for HAProxy PROXY protocol header? */ + CURLOPT(CURLOPT_HAPROXY_CLIENT_IP, CURLOPTTYPE_STRINGPOINT, 323), + + /* millisecond version */ + CURLOPT(CURLOPT_SERVER_RESPONSE_TIMEOUT_MS, CURLOPTTYPE_LONG, 324), + + /* set ECH configuration */ + CURLOPT(CURLOPT_ECH, CURLOPTTYPE_STRINGPOINT, 325), + + /* maximum number of keepalive probes (Linux, *BSD, macOS, etc.) */ + CURLOPT(CURLOPT_TCP_KEEPCNT, CURLOPTTYPE_LONG, 326), + + CURLOPT_LASTENTRY /* the last unused */ +} CURLoption; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Backwards compatibility with older names */ +/* These are scheduled to disappear by 2011 */ + +/* This was added in version 7.19.1 */ +#define CURLOPT_POST301 CURLOPT_POSTREDIR + +/* These are scheduled to disappear by 2009 */ + +/* The following were added in 7.17.0 */ +#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD +#define CURLOPT_FTPAPPEND CURLOPT_APPEND +#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY +#define CURLOPT_FTP_SSL CURLOPT_USE_SSL + +/* The following were added earlier */ + +#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD +#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL + +/* */ +#define CURLOPT_FTP_RESPONSE_TIMEOUT CURLOPT_SERVER_RESPONSE_TIMEOUT + +/* Added in 8.2.0 */ +#define CURLOPT_MAIL_RCPT_ALLLOWFAILS CURLOPT_MAIL_RCPT_ALLOWFAILS + +#else +/* This is set if CURL_NO_OLDIES is defined at compile-time */ +#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */ +#endif + + + /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host + name resolves addresses using more than one IP protocol version, this + option might be handy to force libcurl to use a specific IP version. */ +#define CURL_IPRESOLVE_WHATEVER 0 /* default, uses addresses to all IP + versions that your system allows */ +#define CURL_IPRESOLVE_V4 1 /* uses only IPv4 addresses/connections */ +#define CURL_IPRESOLVE_V6 2 /* uses only IPv6 addresses/connections */ + + /* Convenient "aliases" */ +#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER + + /* These enums are for use with the CURLOPT_HTTP_VERSION option. */ +enum { + CURL_HTTP_VERSION_NONE, /* setting this means we do not care, and that we + would like the library to choose the best + possible for us! */ + CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */ + CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */ + CURL_HTTP_VERSION_2_0, /* please use HTTP 2 in the request */ + CURL_HTTP_VERSION_2TLS, /* use version 2 for HTTPS, version 1.1 for HTTP */ + CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE, /* please use HTTP 2 without HTTP/1.1 + Upgrade */ + CURL_HTTP_VERSION_3 = 30, /* Use HTTP/3, fallback to HTTP/2 or HTTP/1 if + needed. For HTTPS only. For HTTP, this option + makes libcurl return error. */ + CURL_HTTP_VERSION_3ONLY = 31, /* Use HTTP/3 without fallback. For HTTPS + only. For HTTP, this makes libcurl + return error. */ + + CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */ +}; + +/* Convenience definition simple because the name of the version is HTTP/2 and + not 2.0. The 2_0 version of the enum name was set while the version was + still planned to be 2.0 and we stick to it for compatibility. */ +#define CURL_HTTP_VERSION_2 CURL_HTTP_VERSION_2_0 + +/* + * Public API enums for RTSP requests + */ +enum { + CURL_RTSPREQ_NONE, /* first in list */ + CURL_RTSPREQ_OPTIONS, + CURL_RTSPREQ_DESCRIBE, + CURL_RTSPREQ_ANNOUNCE, + CURL_RTSPREQ_SETUP, + CURL_RTSPREQ_PLAY, + CURL_RTSPREQ_PAUSE, + CURL_RTSPREQ_TEARDOWN, + CURL_RTSPREQ_GET_PARAMETER, + CURL_RTSPREQ_SET_PARAMETER, + CURL_RTSPREQ_RECORD, + CURL_RTSPREQ_RECEIVE, + CURL_RTSPREQ_LAST /* last in list */ +}; + + /* These enums are for use with the CURLOPT_NETRC option. */ +enum CURL_NETRC_OPTION { + CURL_NETRC_IGNORED, /* The .netrc will never be read. + * This is the default. */ + CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred + * to one in the .netrc. */ + CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored. + * Unless one is set programmatically, the .netrc + * will be queried. */ + CURL_NETRC_LAST +}; + +#define CURL_SSLVERSION_DEFAULT 0 +#define CURL_SSLVERSION_TLSv1 1 /* TLS 1.x */ +#define CURL_SSLVERSION_SSLv2 2 +#define CURL_SSLVERSION_SSLv3 3 +#define CURL_SSLVERSION_TLSv1_0 4 +#define CURL_SSLVERSION_TLSv1_1 5 +#define CURL_SSLVERSION_TLSv1_2 6 +#define CURL_SSLVERSION_TLSv1_3 7 + +#define CURL_SSLVERSION_LAST 8 /* never use, keep last */ + +#define CURL_SSLVERSION_MAX_NONE 0 +#define CURL_SSLVERSION_MAX_DEFAULT (CURL_SSLVERSION_TLSv1 << 16) +#define CURL_SSLVERSION_MAX_TLSv1_0 (CURL_SSLVERSION_TLSv1_0 << 16) +#define CURL_SSLVERSION_MAX_TLSv1_1 (CURL_SSLVERSION_TLSv1_1 << 16) +#define CURL_SSLVERSION_MAX_TLSv1_2 (CURL_SSLVERSION_TLSv1_2 << 16) +#define CURL_SSLVERSION_MAX_TLSv1_3 (CURL_SSLVERSION_TLSv1_3 << 16) + + /* never use, keep last */ +#define CURL_SSLVERSION_MAX_LAST (CURL_SSLVERSION_LAST << 16) + +enum CURL_TLSAUTH { + CURL_TLSAUTH_NONE, + CURL_TLSAUTH_SRP, + CURL_TLSAUTH_LAST /* never use, keep last */ +}; + +/* symbols to use with CURLOPT_POSTREDIR. + CURL_REDIR_POST_301, CURL_REDIR_POST_302 and CURL_REDIR_POST_303 + can be bitwise ORed so that CURL_REDIR_POST_301 | CURL_REDIR_POST_302 + | CURL_REDIR_POST_303 == CURL_REDIR_POST_ALL */ + +#define CURL_REDIR_GET_ALL 0 +#define CURL_REDIR_POST_301 1 +#define CURL_REDIR_POST_302 2 +#define CURL_REDIR_POST_303 4 +#define CURL_REDIR_POST_ALL \ + (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303) + +typedef enum { + CURL_TIMECOND_NONE, + + CURL_TIMECOND_IFMODSINCE, + CURL_TIMECOND_IFUNMODSINCE, + CURL_TIMECOND_LASTMOD, + + CURL_TIMECOND_LAST +} curl_TimeCond; + +/* Special size_t value signaling a null-terminated string. */ +#define CURL_ZERO_TERMINATED ((size_t) -1) + +/* curl_strequal() and curl_strnequal() are subject for removal in a future + release */ +CURL_EXTERN int curl_strequal(const char *s1, const char *s2); +CURL_EXTERN int curl_strnequal(const char *s1, const char *s2, size_t n); + +/* Mime/form handling support. */ +typedef struct curl_mime curl_mime; /* Mime context. */ +typedef struct curl_mimepart curl_mimepart; /* Mime part context. */ + +/* CURLMIMEOPT_ defines are for the CURLOPT_MIME_OPTIONS option. */ +#define CURLMIMEOPT_FORMESCAPE (1<<0) /* Use backslash-escaping for forms. */ + +/* + * NAME curl_mime_init() + * + * DESCRIPTION + * + * Create a mime context and return its handle. The easy parameter is the + * target handle. + */ +CURL_EXTERN curl_mime *curl_mime_init(CURL *easy); + +/* + * NAME curl_mime_free() + * + * DESCRIPTION + * + * release a mime handle and its substructures. + */ +CURL_EXTERN void curl_mime_free(curl_mime *mime); + +/* + * NAME curl_mime_addpart() + * + * DESCRIPTION + * + * Append a new empty part to the given mime context and return a handle to + * the created part. + */ +CURL_EXTERN curl_mimepart *curl_mime_addpart(curl_mime *mime); + +/* + * NAME curl_mime_name() + * + * DESCRIPTION + * + * Set mime/form part name. + */ +CURL_EXTERN CURLcode curl_mime_name(curl_mimepart *part, const char *name); + +/* + * NAME curl_mime_filename() + * + * DESCRIPTION + * + * Set mime part remote filename. + */ +CURL_EXTERN CURLcode curl_mime_filename(curl_mimepart *part, + const char *filename); + +/* + * NAME curl_mime_type() + * + * DESCRIPTION + * + * Set mime part type. + */ +CURL_EXTERN CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype); + +/* + * NAME curl_mime_encoder() + * + * DESCRIPTION + * + * Set mime data transfer encoder. + */ +CURL_EXTERN CURLcode curl_mime_encoder(curl_mimepart *part, + const char *encoding); + +/* + * NAME curl_mime_data() + * + * DESCRIPTION + * + * Set mime part data source from memory data, + */ +CURL_EXTERN CURLcode curl_mime_data(curl_mimepart *part, + const char *data, size_t datasize); + +/* + * NAME curl_mime_filedata() + * + * DESCRIPTION + * + * Set mime part data source from named file. + */ +CURL_EXTERN CURLcode curl_mime_filedata(curl_mimepart *part, + const char *filename); + +/* + * NAME curl_mime_data_cb() + * + * DESCRIPTION + * + * Set mime part data source from callback function. + */ +CURL_EXTERN CURLcode curl_mime_data_cb(curl_mimepart *part, + curl_off_t datasize, + curl_read_callback readfunc, + curl_seek_callback seekfunc, + curl_free_callback freefunc, + void *arg); + +/* + * NAME curl_mime_subparts() + * + * DESCRIPTION + * + * Set mime part data source from subparts. + */ +CURL_EXTERN CURLcode curl_mime_subparts(curl_mimepart *part, + curl_mime *subparts); +/* + * NAME curl_mime_headers() + * + * DESCRIPTION + * + * Set mime part headers. + */ +CURL_EXTERN CURLcode curl_mime_headers(curl_mimepart *part, + struct curl_slist *headers, + int take_ownership); + +typedef enum { + /********* the first one is unused ************/ + CURLFORM_NOTHING CURL_DEPRECATED(7.56.0, ""), + CURLFORM_COPYNAME CURL_DEPRECATED(7.56.0, "Use curl_mime_name()"), + CURLFORM_PTRNAME CURL_DEPRECATED(7.56.0, "Use curl_mime_name()"), + CURLFORM_NAMELENGTH CURL_DEPRECATED(7.56.0, ""), + CURLFORM_COPYCONTENTS CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), + CURLFORM_PTRCONTENTS CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), + CURLFORM_CONTENTSLENGTH CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), + CURLFORM_FILECONTENT CURL_DEPRECATED(7.56.0, "Use curl_mime_data_cb()"), + CURLFORM_ARRAY CURL_DEPRECATED(7.56.0, ""), + CURLFORM_OBSOLETE, + CURLFORM_FILE CURL_DEPRECATED(7.56.0, "Use curl_mime_filedata()"), + + CURLFORM_BUFFER CURL_DEPRECATED(7.56.0, "Use curl_mime_filename()"), + CURLFORM_BUFFERPTR CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), + CURLFORM_BUFFERLENGTH CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), + + CURLFORM_CONTENTTYPE CURL_DEPRECATED(7.56.0, "Use curl_mime_type()"), + CURLFORM_CONTENTHEADER CURL_DEPRECATED(7.56.0, "Use curl_mime_headers()"), + CURLFORM_FILENAME CURL_DEPRECATED(7.56.0, "Use curl_mime_filename()"), + CURLFORM_END, + CURLFORM_OBSOLETE2, + + CURLFORM_STREAM CURL_DEPRECATED(7.56.0, "Use curl_mime_data_cb()"), + CURLFORM_CONTENTLEN /* added in 7.46.0, provide a curl_off_t length */ + CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), + + CURLFORM_LASTENTRY /* the last unused */ +} CURLformoption; + +/* structure to be used as parameter for CURLFORM_ARRAY */ +struct curl_forms { + CURLformoption option; + const char *value; +}; + +/* use this for multipart formpost building */ +/* Returns code for curl_formadd() + * + * Returns: + * CURL_FORMADD_OK on success + * CURL_FORMADD_MEMORY if the FormInfo allocation fails + * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form + * CURL_FORMADD_NULL if a null pointer was given for a char + * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed + * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used + * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error) + * CURL_FORMADD_MEMORY if a curl_httppost struct cannot be allocated + * CURL_FORMADD_MEMORY if some allocation for string copying failed. + * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array + * + ***************************************************************************/ +typedef enum { + CURL_FORMADD_OK CURL_DEPRECATED(7.56.0, ""), /* 1st, no error */ + + CURL_FORMADD_MEMORY CURL_DEPRECATED(7.56.0, ""), + CURL_FORMADD_OPTION_TWICE CURL_DEPRECATED(7.56.0, ""), + CURL_FORMADD_NULL CURL_DEPRECATED(7.56.0, ""), + CURL_FORMADD_UNKNOWN_OPTION CURL_DEPRECATED(7.56.0, ""), + CURL_FORMADD_INCOMPLETE CURL_DEPRECATED(7.56.0, ""), + CURL_FORMADD_ILLEGAL_ARRAY CURL_DEPRECATED(7.56.0, ""), + /* libcurl was built with form api disabled */ + CURL_FORMADD_DISABLED CURL_DEPRECATED(7.56.0, ""), + + CURL_FORMADD_LAST /* last */ +} CURLFORMcode; + +/* + * NAME curl_formadd() + * + * DESCRIPTION + * + * Pretty advanced function for building multi-part formposts. Each invoke + * adds one part that together construct a full post. Then use + * CURLOPT_HTTPPOST to send it off to libcurl. + */ +CURL_EXTERN CURLFORMcode CURL_DEPRECATED(7.56.0, "Use curl_mime_init()") +curl_formadd(struct curl_httppost **httppost, + struct curl_httppost **last_post, + ...); + +/* + * callback function for curl_formget() + * The void *arg pointer will be the one passed as second argument to + * curl_formget(). + * The character buffer passed to it must not be freed. + * Should return the buffer length passed to it as the argument "len" on + * success. + */ +typedef size_t (*curl_formget_callback)(void *arg, const char *buf, + size_t len); + +/* + * NAME curl_formget() + * + * DESCRIPTION + * + * Serialize a curl_httppost struct built with curl_formadd(). + * Accepts a void pointer as second argument which will be passed to + * the curl_formget_callback function. + * Returns 0 on success. + */ +CURL_EXTERN int CURL_DEPRECATED(7.56.0, "") +curl_formget(struct curl_httppost *form, void *arg, + curl_formget_callback append); +/* + * NAME curl_formfree() + * + * DESCRIPTION + * + * Free a multipart formpost previously built with curl_formadd(). + */ +CURL_EXTERN void CURL_DEPRECATED(7.56.0, "Use curl_mime_free()") +curl_formfree(struct curl_httppost *form); + +/* + * NAME curl_getenv() + * + * DESCRIPTION + * + * Returns a malloc()'ed string that MUST be curl_free()ed after usage is + * complete. DEPRECATED - see lib/README.curlx + */ +CURL_EXTERN char *curl_getenv(const char *variable); + +/* + * NAME curl_version() + * + * DESCRIPTION + * + * Returns a static ASCII string of the libcurl version. + */ +CURL_EXTERN char *curl_version(void); + +/* + * NAME curl_easy_escape() + * + * DESCRIPTION + * + * Escapes URL strings (converts all letters consider illegal in URLs to their + * %XX versions). This function returns a new allocated string or NULL if an + * error occurred. + */ +CURL_EXTERN char *curl_easy_escape(CURL *handle, + const char *string, + int length); + +/* the previous version: */ +CURL_EXTERN char *curl_escape(const char *string, + int length); + + +/* + * NAME curl_easy_unescape() + * + * DESCRIPTION + * + * Unescapes URL encoding in strings (converts all %XX codes to their 8bit + * versions). This function returns a new allocated string or NULL if an error + * occurred. + * Conversion Note: On non-ASCII platforms the ASCII %XX codes are + * converted into the host encoding. + */ +CURL_EXTERN char *curl_easy_unescape(CURL *handle, + const char *string, + int length, + int *outlength); + +/* the previous version */ +CURL_EXTERN char *curl_unescape(const char *string, + int length); + +/* + * NAME curl_free() + * + * DESCRIPTION + * + * Provided for de-allocation in the same translation unit that did the + * allocation. Added in libcurl 7.10 + */ +CURL_EXTERN void curl_free(void *p); + +/* + * NAME curl_global_init() + * + * DESCRIPTION + * + * curl_global_init() should be invoked exactly once for each application that + * uses libcurl and before any call of other libcurl functions. + + * This function is thread-safe if CURL_VERSION_THREADSAFE is set in the + * curl_version_info_data.features flag (fetch by curl_version_info()). + + */ +CURL_EXTERN CURLcode curl_global_init(long flags); + +/* + * NAME curl_global_init_mem() + * + * DESCRIPTION + * + * curl_global_init() or curl_global_init_mem() should be invoked exactly once + * for each application that uses libcurl. This function can be used to + * initialize libcurl and set user defined memory management callback + * functions. Users can implement memory management routines to check for + * memory leaks, check for mis-use of the curl library etc. User registered + * callback routines will be invoked by this library instead of the system + * memory management routines like malloc, free etc. + */ +CURL_EXTERN CURLcode curl_global_init_mem(long flags, + curl_malloc_callback m, + curl_free_callback f, + curl_realloc_callback r, + curl_strdup_callback s, + curl_calloc_callback c); + +/* + * NAME curl_global_cleanup() + * + * DESCRIPTION + * + * curl_global_cleanup() should be invoked exactly once for each application + * that uses libcurl + */ +CURL_EXTERN void curl_global_cleanup(void); + +/* + * NAME curl_global_trace() + * + * DESCRIPTION + * + * curl_global_trace() can be invoked at application start to + * configure which components in curl should participate in tracing. + + * This function is thread-safe if CURL_VERSION_THREADSAFE is set in the + * curl_version_info_data.features flag (fetch by curl_version_info()). + + */ +CURL_EXTERN CURLcode curl_global_trace(const char *config); + +/* linked-list structure for the CURLOPT_QUOTE option (and other) */ +struct curl_slist { + char *data; + struct curl_slist *next; +}; + +/* + * NAME curl_global_sslset() + * + * DESCRIPTION + * + * When built with multiple SSL backends, curl_global_sslset() allows to + * choose one. This function can only be called once, and it must be called + * *before* curl_global_init(). + * + * The backend can be identified by the id (e.g. CURLSSLBACKEND_OPENSSL). The + * backend can also be specified via the name parameter (passing -1 as id). + * If both id and name are specified, the name will be ignored. If neither id + * nor name are specified, the function will fail with + * CURLSSLSET_UNKNOWN_BACKEND and set the "avail" pointer to the + * NULL-terminated list of available backends. + * + * Upon success, the function returns CURLSSLSET_OK. + * + * If the specified SSL backend is not available, the function returns + * CURLSSLSET_UNKNOWN_BACKEND and sets the "avail" pointer to a NULL-terminated + * list of available SSL backends. + * + * The SSL backend can be set only once. If it has already been set, a + * subsequent attempt to change it will result in a CURLSSLSET_TOO_LATE. + */ + +struct curl_ssl_backend { + curl_sslbackend id; + const char *name; +}; +typedef struct curl_ssl_backend curl_ssl_backend; + +typedef enum { + CURLSSLSET_OK = 0, + CURLSSLSET_UNKNOWN_BACKEND, + CURLSSLSET_TOO_LATE, + CURLSSLSET_NO_BACKENDS /* libcurl was built without any SSL support */ +} CURLsslset; + +CURL_EXTERN CURLsslset curl_global_sslset(curl_sslbackend id, const char *name, + const curl_ssl_backend ***avail); + +/* + * NAME curl_slist_append() + * + * DESCRIPTION + * + * Appends a string to a linked list. If no list exists, it will be created + * first. Returns the new list, after appending. + */ +CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *list, + const char *data); + +/* + * NAME curl_slist_free_all() + * + * DESCRIPTION + * + * free a previously built curl_slist. + */ +CURL_EXTERN void curl_slist_free_all(struct curl_slist *list); + +/* + * NAME curl_getdate() + * + * DESCRIPTION + * + * Returns the time, in seconds since 1 Jan 1970 of the time string given in + * the first argument. The time argument in the second parameter is unused + * and should be set to NULL. + */ +CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused); + +/* info about the certificate chain, for SSL backends that support it. Asked + for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */ +struct curl_certinfo { + int num_of_certs; /* number of certificates with information */ + struct curl_slist **certinfo; /* for each index in this array, there is a + linked list with textual information for a + certificate in the format "name:content". + eg "Subject:foo", "Issuer:bar", etc. */ +}; + +/* Information about the SSL library used and the respective internal SSL + handle, which can be used to obtain further information regarding the + connection. Asked for with CURLINFO_TLS_SSL_PTR or CURLINFO_TLS_SESSION. */ +struct curl_tlssessioninfo { + curl_sslbackend backend; + void *internals; +}; + +#define CURLINFO_STRING 0x100000 +#define CURLINFO_LONG 0x200000 +#define CURLINFO_DOUBLE 0x300000 +#define CURLINFO_SLIST 0x400000 +#define CURLINFO_PTR 0x400000 /* same as SLIST */ +#define CURLINFO_SOCKET 0x500000 +#define CURLINFO_OFF_T 0x600000 +#define CURLINFO_MASK 0x0fffff +#define CURLINFO_TYPEMASK 0xf00000 + +typedef enum { + CURLINFO_NONE, /* first, never use this */ + CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1, + CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2, + CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3, + CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4, + CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5, + CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6, + CURLINFO_SIZE_UPLOAD CURL_DEPRECATED(7.55.0, "Use CURLINFO_SIZE_UPLOAD_T") + = CURLINFO_DOUBLE + 7, + CURLINFO_SIZE_UPLOAD_T = CURLINFO_OFF_T + 7, + CURLINFO_SIZE_DOWNLOAD + CURL_DEPRECATED(7.55.0, "Use CURLINFO_SIZE_DOWNLOAD_T") + = CURLINFO_DOUBLE + 8, + CURLINFO_SIZE_DOWNLOAD_T = CURLINFO_OFF_T + 8, + CURLINFO_SPEED_DOWNLOAD + CURL_DEPRECATED(7.55.0, "Use CURLINFO_SPEED_DOWNLOAD_T") + = CURLINFO_DOUBLE + 9, + CURLINFO_SPEED_DOWNLOAD_T = CURLINFO_OFF_T + 9, + CURLINFO_SPEED_UPLOAD + CURL_DEPRECATED(7.55.0, "Use CURLINFO_SPEED_UPLOAD_T") + = CURLINFO_DOUBLE + 10, + CURLINFO_SPEED_UPLOAD_T = CURLINFO_OFF_T + 10, + CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11, + CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12, + CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13, + CURLINFO_FILETIME = CURLINFO_LONG + 14, + CURLINFO_FILETIME_T = CURLINFO_OFF_T + 14, + CURLINFO_CONTENT_LENGTH_DOWNLOAD + CURL_DEPRECATED(7.55.0, + "Use CURLINFO_CONTENT_LENGTH_DOWNLOAD_T") + = CURLINFO_DOUBLE + 15, + CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = CURLINFO_OFF_T + 15, + CURLINFO_CONTENT_LENGTH_UPLOAD + CURL_DEPRECATED(7.55.0, + "Use CURLINFO_CONTENT_LENGTH_UPLOAD_T") + = CURLINFO_DOUBLE + 16, + CURLINFO_CONTENT_LENGTH_UPLOAD_T = CURLINFO_OFF_T + 16, + CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17, + CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18, + CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19, + CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20, + CURLINFO_PRIVATE = CURLINFO_STRING + 21, + CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22, + CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23, + CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24, + CURLINFO_OS_ERRNO = CURLINFO_LONG + 25, + CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26, + CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27, + CURLINFO_COOKIELIST = CURLINFO_SLIST + 28, + CURLINFO_LASTSOCKET CURL_DEPRECATED(7.45.0, "Use CURLINFO_ACTIVESOCKET") + = CURLINFO_LONG + 29, + CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30, + CURLINFO_REDIRECT_URL = CURLINFO_STRING + 31, + CURLINFO_PRIMARY_IP = CURLINFO_STRING + 32, + CURLINFO_APPCONNECT_TIME = CURLINFO_DOUBLE + 33, + CURLINFO_CERTINFO = CURLINFO_PTR + 34, + CURLINFO_CONDITION_UNMET = CURLINFO_LONG + 35, + CURLINFO_RTSP_SESSION_ID = CURLINFO_STRING + 36, + CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG + 37, + CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG + 38, + CURLINFO_RTSP_CSEQ_RECV = CURLINFO_LONG + 39, + CURLINFO_PRIMARY_PORT = CURLINFO_LONG + 40, + CURLINFO_LOCAL_IP = CURLINFO_STRING + 41, + CURLINFO_LOCAL_PORT = CURLINFO_LONG + 42, + CURLINFO_TLS_SESSION CURL_DEPRECATED(7.48.0, "Use CURLINFO_TLS_SSL_PTR") + = CURLINFO_PTR + 43, + CURLINFO_ACTIVESOCKET = CURLINFO_SOCKET + 44, + CURLINFO_TLS_SSL_PTR = CURLINFO_PTR + 45, + CURLINFO_HTTP_VERSION = CURLINFO_LONG + 46, + CURLINFO_PROXY_SSL_VERIFYRESULT = CURLINFO_LONG + 47, + CURLINFO_PROTOCOL CURL_DEPRECATED(7.85.0, "Use CURLINFO_SCHEME") + = CURLINFO_LONG + 48, + CURLINFO_SCHEME = CURLINFO_STRING + 49, + CURLINFO_TOTAL_TIME_T = CURLINFO_OFF_T + 50, + CURLINFO_NAMELOOKUP_TIME_T = CURLINFO_OFF_T + 51, + CURLINFO_CONNECT_TIME_T = CURLINFO_OFF_T + 52, + CURLINFO_PRETRANSFER_TIME_T = CURLINFO_OFF_T + 53, + CURLINFO_STARTTRANSFER_TIME_T = CURLINFO_OFF_T + 54, + CURLINFO_REDIRECT_TIME_T = CURLINFO_OFF_T + 55, + CURLINFO_APPCONNECT_TIME_T = CURLINFO_OFF_T + 56, + CURLINFO_RETRY_AFTER = CURLINFO_OFF_T + 57, + CURLINFO_EFFECTIVE_METHOD = CURLINFO_STRING + 58, + CURLINFO_PROXY_ERROR = CURLINFO_LONG + 59, + CURLINFO_REFERER = CURLINFO_STRING + 60, + CURLINFO_CAINFO = CURLINFO_STRING + 61, + CURLINFO_CAPATH = CURLINFO_STRING + 62, + CURLINFO_XFER_ID = CURLINFO_OFF_T + 63, + CURLINFO_CONN_ID = CURLINFO_OFF_T + 64, + CURLINFO_QUEUE_TIME_T = CURLINFO_OFF_T + 65, + CURLINFO_USED_PROXY = CURLINFO_LONG + 66, + CURLINFO_POSTTRANSFER_TIME_T = CURLINFO_OFF_T + 67, + CURLINFO_EARLYDATA_SENT_T = CURLINFO_OFF_T + 68, + CURLINFO_HTTPAUTH_USED = CURLINFO_LONG + 69, + CURLINFO_PROXYAUTH_USED = CURLINFO_LONG + 70, + CURLINFO_LASTONE = 70 +} CURLINFO; + +/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as + CURLINFO_HTTP_CODE */ +#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE + +typedef enum { + CURLCLOSEPOLICY_NONE, /* first, never use this */ + + CURLCLOSEPOLICY_OLDEST, + CURLCLOSEPOLICY_LEAST_RECENTLY_USED, + CURLCLOSEPOLICY_LEAST_TRAFFIC, + CURLCLOSEPOLICY_SLOWEST, + CURLCLOSEPOLICY_CALLBACK, + + CURLCLOSEPOLICY_LAST /* last, never use this */ +} curl_closepolicy; + +#define CURL_GLOBAL_SSL (1<<0) /* no purpose since 7.57.0 */ +#define CURL_GLOBAL_WIN32 (1<<1) +#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32) +#define CURL_GLOBAL_NOTHING 0 +#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL +#define CURL_GLOBAL_ACK_EINTR (1<<2) + + +/***************************************************************************** + * Setup defines, protos etc for the sharing stuff. + */ + +/* Different data locks for a single share */ +typedef enum { + CURL_LOCK_DATA_NONE = 0, + /* CURL_LOCK_DATA_SHARE is used internally to say that + * the locking is just made to change the internal state of the share + * itself. + */ + CURL_LOCK_DATA_SHARE, + CURL_LOCK_DATA_COOKIE, + CURL_LOCK_DATA_DNS, + CURL_LOCK_DATA_SSL_SESSION, + CURL_LOCK_DATA_CONNECT, + CURL_LOCK_DATA_PSL, + CURL_LOCK_DATA_HSTS, + CURL_LOCK_DATA_LAST +} curl_lock_data; + +/* Different lock access types */ +typedef enum { + CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */ + CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */ + CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */ + CURL_LOCK_ACCESS_LAST /* never use */ +} curl_lock_access; + +typedef void (*curl_lock_function)(CURL *handle, + curl_lock_data data, + curl_lock_access locktype, + void *userptr); +typedef void (*curl_unlock_function)(CURL *handle, + curl_lock_data data, + void *userptr); + + +typedef enum { + CURLSHE_OK, /* all is fine */ + CURLSHE_BAD_OPTION, /* 1 */ + CURLSHE_IN_USE, /* 2 */ + CURLSHE_INVALID, /* 3 */ + CURLSHE_NOMEM, /* 4 out of memory */ + CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */ + CURLSHE_LAST /* never use */ +} CURLSHcode; + +typedef enum { + CURLSHOPT_NONE, /* do not use */ + CURLSHOPT_SHARE, /* specify a data type to share */ + CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */ + CURLSHOPT_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */ + CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */ + CURLSHOPT_USERDATA, /* pass in a user data pointer used in the lock/unlock + callback functions */ + CURLSHOPT_LAST /* never use */ +} CURLSHoption; + +CURL_EXTERN CURLSH *curl_share_init(void); +CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *share, CURLSHoption option, + ...); +CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *share); + +/**************************************************************************** + * Structures for querying information about the curl library at runtime. + */ + +typedef enum { + CURLVERSION_FIRST, /* 7.10 */ + CURLVERSION_SECOND, /* 7.11.1 */ + CURLVERSION_THIRD, /* 7.12.0 */ + CURLVERSION_FOURTH, /* 7.16.1 */ + CURLVERSION_FIFTH, /* 7.57.0 */ + CURLVERSION_SIXTH, /* 7.66.0 */ + CURLVERSION_SEVENTH, /* 7.70.0 */ + CURLVERSION_EIGHTH, /* 7.72.0 */ + CURLVERSION_NINTH, /* 7.75.0 */ + CURLVERSION_TENTH, /* 7.77.0 */ + CURLVERSION_ELEVENTH, /* 7.87.0 */ + CURLVERSION_TWELFTH, /* 8.8.0 */ + CURLVERSION_LAST /* never actually use this */ +} CURLversion; + +/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by + basically all programs ever that want to get version information. It is + meant to be a built-in version number for what kind of struct the caller + expects. If the struct ever changes, we redefine the NOW to another enum + from above. */ +#define CURLVERSION_NOW CURLVERSION_TWELFTH + +struct curl_version_info_data { + CURLversion age; /* age of the returned struct */ + const char *version; /* LIBCURL_VERSION */ + unsigned int version_num; /* LIBCURL_VERSION_NUM */ + const char *host; /* OS/host/cpu/machine when configured */ + int features; /* bitmask, see defines below */ + const char *ssl_version; /* human readable string */ + long ssl_version_num; /* not used anymore, always 0 */ + const char *libz_version; /* human readable string */ + /* protocols is terminated by an entry with a NULL protoname */ + const char * const *protocols; + + /* The fields below this were added in CURLVERSION_SECOND */ + const char *ares; + int ares_num; + + /* This field was added in CURLVERSION_THIRD */ + const char *libidn; + + /* These field were added in CURLVERSION_FOURTH */ + + /* Same as '_libiconv_version' if built with HAVE_ICONV */ + int iconv_ver_num; + + const char *libssh_version; /* human readable string */ + + /* These fields were added in CURLVERSION_FIFTH */ + unsigned int brotli_ver_num; /* Numeric Brotli version + (MAJOR << 24) | (MINOR << 12) | PATCH */ + const char *brotli_version; /* human readable string. */ + + /* These fields were added in CURLVERSION_SIXTH */ + unsigned int nghttp2_ver_num; /* Numeric nghttp2 version + (MAJOR << 16) | (MINOR << 8) | PATCH */ + const char *nghttp2_version; /* human readable string. */ + const char *quic_version; /* human readable quic (+ HTTP/3) library + + version or NULL */ + + /* These fields were added in CURLVERSION_SEVENTH */ + const char *cainfo; /* the built-in default CURLOPT_CAINFO, might + be NULL */ + const char *capath; /* the built-in default CURLOPT_CAPATH, might + be NULL */ + + /* These fields were added in CURLVERSION_EIGHTH */ + unsigned int zstd_ver_num; /* Numeric Zstd version + (MAJOR << 24) | (MINOR << 12) | PATCH */ + const char *zstd_version; /* human readable string. */ + + /* These fields were added in CURLVERSION_NINTH */ + const char *hyper_version; /* human readable string. */ + + /* These fields were added in CURLVERSION_TENTH */ + const char *gsasl_version; /* human readable string. */ + + /* These fields were added in CURLVERSION_ELEVENTH */ + /* feature_names is terminated by an entry with a NULL feature name */ + const char * const *feature_names; + + /* These fields were added in CURLVERSION_TWELFTH */ + const char *rtmp_version; /* human readable string. */ +}; +typedef struct curl_version_info_data curl_version_info_data; + +#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */ +#define CURL_VERSION_KERBEROS4 (1<<1) /* Kerberos V4 auth is supported + (deprecated) */ +#define CURL_VERSION_SSL (1<<2) /* SSL options are present */ +#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */ +#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */ +#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth is supported + (deprecated) */ +#define CURL_VERSION_DEBUG (1<<6) /* Built with debug capabilities */ +#define CURL_VERSION_ASYNCHDNS (1<<7) /* Asynchronous DNS resolves */ +#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth is supported */ +#define CURL_VERSION_LARGEFILE (1<<9) /* Supports files larger than 2GB */ +#define CURL_VERSION_IDN (1<<10) /* Internationized Domain Names are + supported */ +#define CURL_VERSION_SSPI (1<<11) /* Built against Windows SSPI */ +#define CURL_VERSION_CONV (1<<12) /* Character conversions supported */ +#define CURL_VERSION_CURLDEBUG (1<<13) /* Debug memory tracking supported */ +#define CURL_VERSION_TLSAUTH_SRP (1<<14) /* TLS-SRP auth is supported */ +#define CURL_VERSION_NTLM_WB (1<<15) /* NTLM delegation to winbind helper + is supported */ +#define CURL_VERSION_HTTP2 (1<<16) /* HTTP2 support built-in */ +#define CURL_VERSION_GSSAPI (1<<17) /* Built against a GSS-API library */ +#define CURL_VERSION_KERBEROS5 (1<<18) /* Kerberos V5 auth is supported */ +#define CURL_VERSION_UNIX_SOCKETS (1<<19) /* Unix domain sockets support */ +#define CURL_VERSION_PSL (1<<20) /* Mozilla's Public Suffix List, used + for cookie domain verification */ +#define CURL_VERSION_HTTPS_PROXY (1<<21) /* HTTPS-proxy support built-in */ +#define CURL_VERSION_MULTI_SSL (1<<22) /* Multiple SSL backends available */ +#define CURL_VERSION_BROTLI (1<<23) /* Brotli features are present. */ +#define CURL_VERSION_ALTSVC (1<<24) /* Alt-Svc handling built-in */ +#define CURL_VERSION_HTTP3 (1<<25) /* HTTP3 support built-in */ +#define CURL_VERSION_ZSTD (1<<26) /* zstd features are present */ +#define CURL_VERSION_UNICODE (1<<27) /* Unicode support on Windows */ +#define CURL_VERSION_HSTS (1<<28) /* HSTS is supported */ +#define CURL_VERSION_GSASL (1<<29) /* libgsasl is supported */ +#define CURL_VERSION_THREADSAFE (1<<30) /* libcurl API is thread-safe */ + +/* + * NAME curl_version_info() + * + * DESCRIPTION + * + * This function returns a pointer to a static copy of the version info + * struct. See above. + */ +CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion); + +/* + * NAME curl_easy_strerror() + * + * DESCRIPTION + * + * The curl_easy_strerror function may be used to turn a CURLcode value + * into the equivalent human readable error string. This is useful + * for printing meaningful error messages. + */ +CURL_EXTERN const char *curl_easy_strerror(CURLcode); + +/* + * NAME curl_share_strerror() + * + * DESCRIPTION + * + * The curl_share_strerror function may be used to turn a CURLSHcode value + * into the equivalent human readable error string. This is useful + * for printing meaningful error messages. + */ +CURL_EXTERN const char *curl_share_strerror(CURLSHcode); + +/* + * NAME curl_easy_pause() + * + * DESCRIPTION + * + * The curl_easy_pause function pauses or unpauses transfers. Select the new + * state by setting the bitmask, use the convenience defines below. + * + */ +CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask); + +#define CURLPAUSE_RECV (1<<0) +#define CURLPAUSE_RECV_CONT (0) + +#define CURLPAUSE_SEND (1<<2) +#define CURLPAUSE_SEND_CONT (0) + +#define CURLPAUSE_ALL (CURLPAUSE_RECV|CURLPAUSE_SEND) +#define CURLPAUSE_CONT (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT) + +/* + * NAME curl_easy_ssls_import() + * + * DESCRIPTION + * + * The curl_easy_ssls_import function adds a previously exported SSL session + * to the SSL session cache of the easy handle (or the underlying share). + */ +CURL_EXTERN CURLcode curl_easy_ssls_import(CURL *handle, + const char *session_key, + const unsigned char *shmac, + size_t shmac_len, + const unsigned char *sdata, + size_t sdata_len); + +/* This is the curl_ssls_export_cb callback prototype. It + * is passed to curl_easy_ssls_export() to extract SSL sessions/tickets. */ +typedef CURLcode curl_ssls_export_cb(CURL *handle, + void *userptr, + const char *session_key, + const unsigned char *shmac, + size_t shmac_len, + const unsigned char *sdata, + size_t sdata_len, + curl_off_t valid_until, + int ietf_tls_id, + const char *alpn, + size_t earlydata_max); + +/* + * NAME curl_easy_ssls_export() + * + * DESCRIPTION + * + * The curl_easy_ssls_export function iterates over all SSL sessions stored + * in the easy handle (or underlying share) and invokes the passed + * callback. + * + */ +CURL_EXTERN CURLcode curl_easy_ssls_export(CURL *handle, + curl_ssls_export_cb *export_fn, + void *userptr); + + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +/* unfortunately, the easy.h and multi.h include files need options and info + stuff before they can be included! */ +#include "easy.h" /* nothing in curl is fun without the easy stuff */ +#include "multi.h" +#include "urlapi.h" +#include "options.h" +#include "header.h" +#include "websockets.h" +#ifndef CURL_SKIP_INCLUDE_MPRINTF +#include "mprintf.h" +#endif + +/* the typechecker does not work in C++ (yet) */ +#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \ + ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \ + !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK) +#include "typecheck-gcc.h" +#else +#if defined(__STDC__) && (__STDC__ >= 1) +/* This preprocessor magic that replaces a call with the exact same call is + only done to make sure application authors pass exactly three arguments + to these functions. */ +#define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param) +#define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg) +#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param) +#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) +#endif /* __STDC__ >= 1 */ +#endif /* gcc >= 4.3 && !__cplusplus && !CURL_DISABLE_TYPECHECK */ + +#endif /* CURLINC_CURL_H */ diff --git a/deps/libcurl/include/curl/curlver.h b/deps/libcurl/include/curl/curlver.h new file mode 100644 index 0000000000..fc8ba4cd4b --- /dev/null +++ b/deps/libcurl/include/curl/curlver.h @@ -0,0 +1,79 @@ +#ifndef CURLINC_CURLVER_H +#define CURLINC_CURLVER_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ + +/* This header file contains nothing but libcurl version info, generated by + a script at release-time. This was made its own header file in 7.11.2 */ + +/* This is the global package copyright */ +#define LIBCURL_COPYRIGHT "Daniel Stenberg, ." + +/* This is the version number of the libcurl package from which this header + file origins: */ +#define LIBCURL_VERSION "8.12.1" + +/* The numeric version number is also available "in parts" by using these + defines: */ +#define LIBCURL_VERSION_MAJOR 8 +#define LIBCURL_VERSION_MINOR 12 +#define LIBCURL_VERSION_PATCH 1 + +/* This is the numeric version of the libcurl version number, meant for easier + parsing and comparisons by programs. The LIBCURL_VERSION_NUM define will + always follow this syntax: + + 0xXXYYZZ + + Where XX, YY and ZZ are the main version, release and patch numbers in + hexadecimal (using 8 bits each). All three numbers are always represented + using two digits. 1.2 would appear as "0x010200" while version 9.11.7 + appears as "0x090b07". + + This 6-digit (24 bits) hexadecimal number does not show pre-release number, + and it is always a greater number in a more recent release. It makes + comparisons with greater than and less than work. + + Note: This define is the full hex number and _does not_ use the + CURL_VERSION_BITS() macro since curl's own configure script greps for it + and needs it to contain the full number. +*/ +#define LIBCURL_VERSION_NUM 0x080c01 + +/* + * This is the date and time when the full source package was created. The + * timestamp is not stored in git, as the timestamp is properly set in the + * tarballs by the maketgz script. + * + * The format of the date follows this template: + * + * "2007-11-23" + */ +#define LIBCURL_TIMESTAMP "2025-02-13" + +#define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|(z)) +#define CURL_AT_LEAST_VERSION(x,y,z) \ + (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z)) + +#endif /* CURLINC_CURLVER_H */ diff --git a/deps/libcurl/include/curl/easy.h b/deps/libcurl/include/curl/easy.h new file mode 100644 index 0000000000..56f8060e04 --- /dev/null +++ b/deps/libcurl/include/curl/easy.h @@ -0,0 +1,125 @@ +#ifndef CURLINC_EASY_H +#define CURLINC_EASY_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ +#ifdef __cplusplus +extern "C" { +#endif + +/* Flag bits in the curl_blob struct: */ +#define CURL_BLOB_COPY 1 /* tell libcurl to copy the data */ +#define CURL_BLOB_NOCOPY 0 /* tell libcurl to NOT copy the data */ + +struct curl_blob { + void *data; + size_t len; + unsigned int flags; /* bit 0 is defined, the rest are reserved and should be + left zeroes */ +}; + +CURL_EXTERN CURL *curl_easy_init(void); +CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...); +CURL_EXTERN CURLcode curl_easy_perform(CURL *curl); +CURL_EXTERN void curl_easy_cleanup(CURL *curl); + +/* + * NAME curl_easy_getinfo() + * + * DESCRIPTION + * + * Request internal information from the curl session with this function. + * The third argument MUST be pointing to the specific type of the used option + * which is documented in each manpage of the option. The data pointed to + * will be filled in accordingly and can be relied upon only if the function + * returns CURLE_OK. This function is intended to get used *AFTER* a performed + * transfer, all results from this function are undefined until the transfer + * is completed. + */ +CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...); + + +/* + * NAME curl_easy_duphandle() + * + * DESCRIPTION + * + * Creates a new curl session handle with the same options set for the handle + * passed in. Duplicating a handle could only be a matter of cloning data and + * options, internal state info and things like persistent connections cannot + * be transferred. It is useful in multithreaded applications when you can run + * curl_easy_duphandle() for each new thread to avoid a series of identical + * curl_easy_setopt() invokes in every thread. + */ +CURL_EXTERN CURL *curl_easy_duphandle(CURL *curl); + +/* + * NAME curl_easy_reset() + * + * DESCRIPTION + * + * Re-initializes a curl handle to the default values. This puts back the + * handle to the same state as it was in when it was just created. + * + * It does keep: live connections, the Session ID cache, the DNS cache and the + * cookies. + */ +CURL_EXTERN void curl_easy_reset(CURL *curl); + +/* + * NAME curl_easy_recv() + * + * DESCRIPTION + * + * Receives data from the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen, + size_t *n); + +/* + * NAME curl_easy_send() + * + * DESCRIPTION + * + * Sends data over the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer, + size_t buflen, size_t *n); + + +/* + * NAME curl_easy_upkeep() + * + * DESCRIPTION + * + * Performs connection upkeep for the given session handle. + */ +CURL_EXTERN CURLcode curl_easy_upkeep(CURL *curl); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/deps/libcurl/include/curl/header.h b/deps/libcurl/include/curl/header.h new file mode 100644 index 0000000000..8df11e1e42 --- /dev/null +++ b/deps/libcurl/include/curl/header.h @@ -0,0 +1,74 @@ +#ifndef CURLINC_HEADER_H +#define CURLINC_HEADER_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +struct curl_header { + char *name; /* this might not use the same case */ + char *value; + size_t amount; /* number of headers using this name */ + size_t index; /* ... of this instance, 0 or higher */ + unsigned int origin; /* see bits below */ + void *anchor; /* handle privately used by libcurl */ +}; + +/* 'origin' bits */ +#define CURLH_HEADER (1<<0) /* plain server header */ +#define CURLH_TRAILER (1<<1) /* trailers */ +#define CURLH_CONNECT (1<<2) /* CONNECT headers */ +#define CURLH_1XX (1<<3) /* 1xx headers */ +#define CURLH_PSEUDO (1<<4) /* pseudo headers */ + +typedef enum { + CURLHE_OK, + CURLHE_BADINDEX, /* header exists but not with this index */ + CURLHE_MISSING, /* no such header exists */ + CURLHE_NOHEADERS, /* no headers at all exist (yet) */ + CURLHE_NOREQUEST, /* no request with this number was used */ + CURLHE_OUT_OF_MEMORY, /* out of memory while processing */ + CURLHE_BAD_ARGUMENT, /* a function argument was not okay */ + CURLHE_NOT_BUILT_IN /* if API was disabled in the build */ +} CURLHcode; + +CURL_EXTERN CURLHcode curl_easy_header(CURL *easy, + const char *name, + size_t index, + unsigned int origin, + int request, + struct curl_header **hout); + +CURL_EXTERN struct curl_header *curl_easy_nextheader(CURL *easy, + unsigned int origin, + int request, + struct curl_header *prev); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif /* CURLINC_HEADER_H */ diff --git a/deps/libcurl/include/curl/mprintf.h b/deps/libcurl/include/curl/mprintf.h new file mode 100644 index 0000000000..88059c851f --- /dev/null +++ b/deps/libcurl/include/curl/mprintf.h @@ -0,0 +1,85 @@ +#ifndef CURLINC_MPRINTF_H +#define CURLINC_MPRINTF_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ + +#include +#include /* needed for FILE */ +#include "curl.h" /* for CURL_EXTERN */ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef CURL_TEMP_PRINTF +#if (defined(__GNUC__) || defined(__clang__) || \ + defined(__IAR_SYSTEMS_ICC__)) && \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !defined(CURL_NO_FMT_CHECKS) +#if defined(__MINGW32__) && !defined(__clang__) +#if defined(__MINGW_PRINTF_FORMAT) /* mingw-w64 3.0.0+. Needs stdio.h. */ +#define CURL_TEMP_PRINTF(fmt, arg) \ + __attribute__((format(__MINGW_PRINTF_FORMAT, fmt, arg))) +#else +#define CURL_TEMP_PRINTF(fmt, arg) +#endif +#else +#define CURL_TEMP_PRINTF(fmt, arg) \ + __attribute__((format(printf, fmt, arg))) +#endif +#else +#define CURL_TEMP_PRINTF(fmt, arg) +#endif +#endif + +CURL_EXTERN int curl_mprintf(const char *format, ...) + CURL_TEMP_PRINTF(1, 2); +CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...) + CURL_TEMP_PRINTF(2, 3); +CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...) + CURL_TEMP_PRINTF(2, 3); +CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength, + const char *format, ...) + CURL_TEMP_PRINTF(3, 4); +CURL_EXTERN int curl_mvprintf(const char *format, va_list args) + CURL_TEMP_PRINTF(1, 0); +CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args) + CURL_TEMP_PRINTF(2, 0); +CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args) + CURL_TEMP_PRINTF(2, 0); +CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength, + const char *format, va_list args) + CURL_TEMP_PRINTF(3, 0); +CURL_EXTERN char *curl_maprintf(const char *format, ...) + CURL_TEMP_PRINTF(1, 2); +CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args) + CURL_TEMP_PRINTF(1, 0); + +#undef CURL_TEMP_PRINTF + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif /* CURLINC_MPRINTF_H */ diff --git a/deps/libcurl/include/curl/multi.h b/deps/libcurl/include/curl/multi.h new file mode 100644 index 0000000000..42469bb565 --- /dev/null +++ b/deps/libcurl/include/curl/multi.h @@ -0,0 +1,481 @@ +#ifndef CURLINC_MULTI_H +#define CURLINC_MULTI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ +/* + This is an "external" header file. Do not give away any internals here! + + GOALS + + o Enable a "pull" interface. The application that uses libcurl decides where + and when to ask libcurl to get/send data. + + o Enable multiple simultaneous transfers in the same thread without making it + complicated for the application. + + o Enable the application to select() on its own file descriptors and curl's + file descriptors simultaneous easily. + +*/ + +/* + * This header file should not really need to include "curl.h" since curl.h + * itself includes this file and we expect user applications to do #include + * without the need for especially including multi.h. + * + * For some reason we added this include here at one point, and rather than to + * break existing (wrongly written) libcurl applications, we leave it as-is + * but with this warning attached. + */ +#include "curl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void CURLM; + +typedef enum { + CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or + curl_multi_socket*() soon */ + CURLM_OK, + CURLM_BAD_HANDLE, /* the passed-in handle is not a valid CURLM handle */ + CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */ + CURLM_OUT_OF_MEMORY, /* if you ever get this, you are in deep sh*t */ + CURLM_INTERNAL_ERROR, /* this is a libcurl bug */ + CURLM_BAD_SOCKET, /* the passed in socket argument did not match */ + CURLM_UNKNOWN_OPTION, /* curl_multi_setopt() with unsupported option */ + CURLM_ADDED_ALREADY, /* an easy handle already added to a multi handle was + attempted to get added - again */ + CURLM_RECURSIVE_API_CALL, /* an api function was called from inside a + callback */ + CURLM_WAKEUP_FAILURE, /* wakeup is unavailable or failed */ + CURLM_BAD_FUNCTION_ARGUMENT, /* function called with a bad parameter */ + CURLM_ABORTED_BY_CALLBACK, + CURLM_UNRECOVERABLE_POLL, + CURLM_LAST +} CURLMcode; + +/* just to make code nicer when using curl_multi_socket() you can now check + for CURLM_CALL_MULTI_SOCKET too in the same style it works for + curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */ +#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM + +/* bitmask bits for CURLMOPT_PIPELINING */ +#define CURLPIPE_NOTHING 0L +#define CURLPIPE_HTTP1 1L +#define CURLPIPE_MULTIPLEX 2L + +typedef enum { + CURLMSG_NONE, /* first, not used */ + CURLMSG_DONE, /* This easy handle has completed. 'result' contains + the CURLcode of the transfer */ + CURLMSG_LAST /* last, not used */ +} CURLMSG; + +struct CURLMsg { + CURLMSG msg; /* what this message means */ + CURL *easy_handle; /* the handle it concerns */ + union { + void *whatever; /* message-specific data */ + CURLcode result; /* return code for transfer */ + } data; +}; +typedef struct CURLMsg CURLMsg; + +/* Based on poll(2) structure and values. + * We do not use pollfd and POLL* constants explicitly + * to cover platforms without poll(). */ +#define CURL_WAIT_POLLIN 0x0001 +#define CURL_WAIT_POLLPRI 0x0002 +#define CURL_WAIT_POLLOUT 0x0004 + +struct curl_waitfd { + curl_socket_t fd; + short events; + short revents; +}; + +/* + * Name: curl_multi_init() + * + * Desc: initialize multi-style curl usage + * + * Returns: a new CURLM handle to use in all 'curl_multi' functions. + */ +CURL_EXTERN CURLM *curl_multi_init(void); + +/* + * Name: curl_multi_add_handle() + * + * Desc: add a standard curl handle to the multi stack + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle, + CURL *curl_handle); + + /* + * Name: curl_multi_remove_handle() + * + * Desc: removes a curl handle from the multi stack again + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle, + CURL *curl_handle); + + /* + * Name: curl_multi_fdset() + * + * Desc: Ask curl for its fd_set sets. The app can use these to select() or + * poll() on. We want curl_multi_perform() called as soon as one of + * them are ready. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle, + fd_set *read_fd_set, + fd_set *write_fd_set, + fd_set *exc_fd_set, + int *max_fd); + +/* + * Name: curl_multi_wait() + * + * Desc: Poll on all fds within a CURLM set as well as any + * additional fds passed to the function. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle, + struct curl_waitfd extra_fds[], + unsigned int extra_nfds, + int timeout_ms, + int *ret); + +/* + * Name: curl_multi_poll() + * + * Desc: Poll on all fds within a CURLM set as well as any + * additional fds passed to the function. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_poll(CURLM *multi_handle, + struct curl_waitfd extra_fds[], + unsigned int extra_nfds, + int timeout_ms, + int *ret); + +/* + * Name: curl_multi_wakeup() + * + * Desc: wakes up a sleeping curl_multi_poll call. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_wakeup(CURLM *multi_handle); + + /* + * Name: curl_multi_perform() + * + * Desc: When the app thinks there is data available for curl it calls this + * function to read/write whatever there is right now. This returns + * as soon as the reads and writes are done. This function does not + * require that there actually is data available for reading or that + * data can be written, it can be called just in case. It returns + * the number of handles that still transfer data in the second + * argument's integer-pointer. + * + * Returns: CURLMcode type, general multi error code. *NOTE* that this only + * returns errors etc regarding the whole multi stack. There might + * still have occurred problems on individual transfers even when + * this returns OK. + */ +CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle, + int *running_handles); + + /* + * Name: curl_multi_cleanup() + * + * Desc: Cleans up and removes a whole multi stack. It does not free or + * touch any individual easy handles in any way. We need to define + * in what state those handles will be if this function is called + * in the middle of a transfer. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle); + +/* + * Name: curl_multi_info_read() + * + * Desc: Ask the multi handle if there is any messages/informationals from + * the individual transfers. Messages include informationals such as + * error code from the transfer or just the fact that a transfer is + * completed. More details on these should be written down as well. + * + * Repeated calls to this function will return a new struct each + * time, until a special "end of msgs" struct is returned as a signal + * that there is no more to get at this point. + * + * The data the returned pointer points to will not survive calling + * curl_multi_cleanup(). + * + * The 'CURLMsg' struct is meant to be simple and only contain basic + * information. If more involved information is wanted, we will + * provide the particular "transfer handle" in that struct and that + * should/could/would be used in subsequent curl_easy_getinfo() calls + * (or similar). The point being that we must never expose complex + * structs to applications, as then we will undoubtably get backwards + * compatibility problems in the future. + * + * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out + * of structs. It also writes the number of messages left in the + * queue (after this read) in the integer the second argument points + * to. + */ +CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle, + int *msgs_in_queue); + +/* + * Name: curl_multi_strerror() + * + * Desc: The curl_multi_strerror function may be used to turn a CURLMcode + * value into the equivalent human readable error string. This is + * useful for printing meaningful error messages. + * + * Returns: A pointer to a null-terminated error message. + */ +CURL_EXTERN const char *curl_multi_strerror(CURLMcode); + +/* + * Name: curl_multi_socket() and + * curl_multi_socket_all() + * + * Desc: An alternative version of curl_multi_perform() that allows the + * application to pass in one of the file descriptors that have been + * detected to have "action" on them and let libcurl perform. + * See manpage for details. + */ +#define CURL_POLL_NONE 0 +#define CURL_POLL_IN 1 +#define CURL_POLL_OUT 2 +#define CURL_POLL_INOUT 3 +#define CURL_POLL_REMOVE 4 + +#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD + +#define CURL_CSELECT_IN 0x01 +#define CURL_CSELECT_OUT 0x02 +#define CURL_CSELECT_ERR 0x04 + +typedef int (*curl_socket_callback)(CURL *easy, /* easy handle */ + curl_socket_t s, /* socket */ + int what, /* see above */ + void *userp, /* private callback + pointer */ + void *socketp); /* private socket + pointer */ +/* + * Name: curl_multi_timer_callback + * + * Desc: Called by libcurl whenever the library detects a change in the + * maximum number of milliseconds the app is allowed to wait before + * curl_multi_socket() or curl_multi_perform() must be called + * (to allow libcurl's timed events to take place). + * + * Returns: The callback should return zero. + */ +typedef int (*curl_multi_timer_callback)(CURLM *multi, /* multi handle */ + long timeout_ms, /* see above */ + void *userp); /* private callback + pointer */ + +CURL_EXTERN CURLMcode CURL_DEPRECATED(7.19.5, "Use curl_multi_socket_action()") +curl_multi_socket(CURLM *multi_handle, curl_socket_t s, int *running_handles); + +CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle, + curl_socket_t s, + int ev_bitmask, + int *running_handles); + +CURL_EXTERN CURLMcode CURL_DEPRECATED(7.19.5, "Use curl_multi_socket_action()") +curl_multi_socket_all(CURLM *multi_handle, int *running_handles); + +#ifndef CURL_ALLOW_OLD_MULTI_SOCKET +/* This macro below was added in 7.16.3 to push users who recompile to use + the new curl_multi_socket_action() instead of the old curl_multi_socket() +*/ +#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z) +#endif + +/* + * Name: curl_multi_timeout() + * + * Desc: Returns the maximum number of milliseconds the app is allowed to + * wait before curl_multi_socket() or curl_multi_perform() must be + * called (to allow libcurl's timed events to take place). + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle, + long *milliseconds); + +typedef enum { + /* This is the socket callback function pointer */ + CURLOPT(CURLMOPT_SOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 1), + + /* This is the argument passed to the socket callback */ + CURLOPT(CURLMOPT_SOCKETDATA, CURLOPTTYPE_OBJECTPOINT, 2), + + /* set to 1 to enable pipelining for this multi handle */ + CURLOPT(CURLMOPT_PIPELINING, CURLOPTTYPE_LONG, 3), + + /* This is the timer callback function pointer */ + CURLOPT(CURLMOPT_TIMERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 4), + + /* This is the argument passed to the timer callback */ + CURLOPT(CURLMOPT_TIMERDATA, CURLOPTTYPE_OBJECTPOINT, 5), + + /* maximum number of entries in the connection cache */ + CURLOPT(CURLMOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 6), + + /* maximum number of (pipelining) connections to one host */ + CURLOPT(CURLMOPT_MAX_HOST_CONNECTIONS, CURLOPTTYPE_LONG, 7), + + /* maximum number of requests in a pipeline */ + CURLOPT(CURLMOPT_MAX_PIPELINE_LENGTH, CURLOPTTYPE_LONG, 8), + + /* a connection with a content-length longer than this + will not be considered for pipelining */ + CURLOPT(CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 9), + + /* a connection with a chunk length longer than this + will not be considered for pipelining */ + CURLOPT(CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 10), + + /* a list of site names(+port) that are blocked from pipelining */ + CURLOPT(CURLMOPT_PIPELINING_SITE_BL, CURLOPTTYPE_OBJECTPOINT, 11), + + /* a list of server types that are blocked from pipelining */ + CURLOPT(CURLMOPT_PIPELINING_SERVER_BL, CURLOPTTYPE_OBJECTPOINT, 12), + + /* maximum number of open connections in total */ + CURLOPT(CURLMOPT_MAX_TOTAL_CONNECTIONS, CURLOPTTYPE_LONG, 13), + + /* This is the server push callback function pointer */ + CURLOPT(CURLMOPT_PUSHFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 14), + + /* This is the argument passed to the server push callback */ + CURLOPT(CURLMOPT_PUSHDATA, CURLOPTTYPE_OBJECTPOINT, 15), + + /* maximum number of concurrent streams to support on a connection */ + CURLOPT(CURLMOPT_MAX_CONCURRENT_STREAMS, CURLOPTTYPE_LONG, 16), + + CURLMOPT_LASTENTRY /* the last unused */ +} CURLMoption; + + +/* + * Name: curl_multi_setopt() + * + * Desc: Sets options for the multi handle. + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle, + CURLMoption option, ...); + + +/* + * Name: curl_multi_assign() + * + * Desc: This function sets an association in the multi handle between the + * given socket and a private pointer of the application. This is + * (only) useful for curl_multi_socket uses. + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle, + curl_socket_t sockfd, void *sockp); + +/* + * Name: curl_multi_get_handles() + * + * Desc: Returns an allocated array holding all handles currently added to + * the multi handle. Marks the final entry with a NULL pointer. If + * there is no easy handle added to the multi handle, this function + * returns an array with the first entry as a NULL pointer. + * + * Returns: NULL on failure, otherwise a CURL **array pointer + */ +CURL_EXTERN CURL **curl_multi_get_handles(CURLM *multi_handle); + +/* + * Name: curl_push_callback + * + * Desc: This callback gets called when a new stream is being pushed by the + * server. It approves or denies the new stream. It can also decide + * to completely fail the connection. + * + * Returns: CURL_PUSH_OK, CURL_PUSH_DENY or CURL_PUSH_ERROROUT + */ +#define CURL_PUSH_OK 0 +#define CURL_PUSH_DENY 1 +#define CURL_PUSH_ERROROUT 2 /* added in 7.72.0 */ + +struct curl_pushheaders; /* forward declaration only */ + +CURL_EXTERN char *curl_pushheader_bynum(struct curl_pushheaders *h, + size_t num); +CURL_EXTERN char *curl_pushheader_byname(struct curl_pushheaders *h, + const char *name); + +typedef int (*curl_push_callback)(CURL *parent, + CURL *easy, + size_t num_headers, + struct curl_pushheaders *headers, + void *userp); + +/* + * Name: curl_multi_waitfds() + * + * Desc: Ask curl for fds for polling. The app can use these to poll on. + * We want curl_multi_perform() called as soon as one of them are + * ready. Passing zero size allows to get just a number of fds. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_waitfds(CURLM *multi, + struct curl_waitfd *ufds, + unsigned int size, + unsigned int *fd_count); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/deps/libcurl/include/curl/options.h b/deps/libcurl/include/curl/options.h new file mode 100644 index 0000000000..1ed76a95c6 --- /dev/null +++ b/deps/libcurl/include/curl/options.h @@ -0,0 +1,70 @@ +#ifndef CURLINC_OPTIONS_H +#define CURLINC_OPTIONS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + CURLOT_LONG, /* long (a range of values) */ + CURLOT_VALUES, /* (a defined set or bitmask) */ + CURLOT_OFF_T, /* curl_off_t (a range of values) */ + CURLOT_OBJECT, /* pointer (void *) */ + CURLOT_STRING, /* (char * to null-terminated buffer) */ + CURLOT_SLIST, /* (struct curl_slist *) */ + CURLOT_CBPTR, /* (void * passed as-is to a callback) */ + CURLOT_BLOB, /* blob (struct curl_blob *) */ + CURLOT_FUNCTION /* function pointer */ +} curl_easytype; + +/* Flag bits */ + +/* "alias" means it is provided for old programs to remain functional, + we prefer another name */ +#define CURLOT_FLAG_ALIAS (1<<0) + +/* The CURLOPTTYPE_* id ranges can still be used to figure out what type/size + to use for curl_easy_setopt() for the given id */ +struct curl_easyoption { + const char *name; + CURLoption id; + curl_easytype type; + unsigned int flags; +}; + +CURL_EXTERN const struct curl_easyoption * +curl_easy_option_by_name(const char *name); + +CURL_EXTERN const struct curl_easyoption * +curl_easy_option_by_id(CURLoption id); + +CURL_EXTERN const struct curl_easyoption * +curl_easy_option_next(const struct curl_easyoption *prev); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif +#endif /* CURLINC_OPTIONS_H */ diff --git a/deps/libcurl/include/curl/stdcheaders.h b/deps/libcurl/include/curl/stdcheaders.h new file mode 100644 index 0000000000..7451aa3052 --- /dev/null +++ b/deps/libcurl/include/curl/stdcheaders.h @@ -0,0 +1,35 @@ +#ifndef CURLINC_STDCHEADERS_H +#define CURLINC_STDCHEADERS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ + +#include + +size_t fread(void *, size_t, size_t, FILE *); +size_t fwrite(const void *, size_t, size_t, FILE *); + +int strcasecmp(const char *, const char *); +int strncasecmp(const char *, const char *, size_t); + +#endif /* CURLINC_STDCHEADERS_H */ diff --git a/deps/libcurl/include/curl/system.h b/deps/libcurl/include/curl/system.h new file mode 100644 index 0000000000..820fe96b39 --- /dev/null +++ b/deps/libcurl/include/curl/system.h @@ -0,0 +1,440 @@ +#ifndef CURLINC_SYSTEM_H +#define CURLINC_SYSTEM_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ + +/* + * Try to keep one section per platform, compiler and architecture, otherwise, + * if an existing section is reused for a different one and later on the + * original is adjusted, probably the piggybacking one can be adversely + * changed. + * + * In order to differentiate between platforms/compilers/architectures use + * only compiler built-in predefined preprocessor symbols. + * + * curl_off_t + * ---------- + * + * For any given platform/compiler curl_off_t must be typedef'ed to a 64-bit + * wide signed integral data type. The width of this data type must remain + * constant and independent of any possible large file support settings. + * + * As an exception to the above, curl_off_t shall be typedef'ed to a 32-bit + * wide signed integral data type if there is no 64-bit type. + * + * As a general rule, curl_off_t shall not be mapped to off_t. This rule shall + * only be violated if off_t is the only 64-bit data type available and the + * size of off_t is independent of large file support settings. Keep your + * build on the safe side avoiding an off_t gating. If you have a 64-bit + * off_t then take for sure that another 64-bit data type exists, dig deeper + * and you will find it. + * + */ + +#if defined(__DJGPP__) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__BORLANDC__) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__POCC__) +# if defined(_MSC_VER) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__LCC__) +# if defined(__MCST__) /* MCST eLbrus Compiler Collection */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# else /* Local (or Little) C Compiler */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# endif + +#elif defined(macintosh) +# include +# if TYPE_LONGLONG +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int + +#elif defined(__TANDEM) +# if !defined(__LP64) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int +# endif + +#elif defined(_WIN32_WCE) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__MINGW32__) +# include +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T PRId64 +# define CURL_FORMAT_CURL_OFF_TU PRIu64 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_PULL_SYS_TYPES_H 1 + +#elif defined(__VMS) +# if defined(__VAX) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int + +#elif defined(__OS400__) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#elif defined(__MVS__) +# if defined(_LONG_LONG) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else /* _LP64 and default */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#elif defined(__370__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_LONG_LONG) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else /* _LP64 and default */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(TPF) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__TINYC__) /* also known as tcc */ +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) /* Oracle Solaris Studio */ +# if !defined(__LP64) && (defined(__ILP32) || \ + defined(__i386) || \ + defined(__sparcv8) || \ + defined(__sparcv8plus)) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__LP64) || \ + defined(__amd64) || defined(__sparcv9) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#elif defined(__xlc__) /* IBM xlc compiler */ +# if !defined(_LP64) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#elif defined(__hpux) /* HP aCC compiler */ +# if !defined(_LP64) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +/* ===================================== */ +/* KEEP MSVC THE PENULTIMATE ENTRY */ +/* ===================================== */ + +#elif defined(_MSC_VER) +# if (_MSC_VER >= 1800) +# include +# define CURL_FORMAT_CURL_OFF_T PRId64 +# define CURL_FORMAT_CURL_OFF_TU PRIu64 +# else +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# endif +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +/* ===================================== */ +/* KEEP GENERIC GCC THE LAST ENTRY */ +/* ===================================== */ + +#elif defined(__GNUC__) && !defined(_SCO_DS) +# if !defined(__LP64__) && \ + (defined(__ILP32__) || defined(__i386__) || defined(__hppa__) || \ + defined(__ppc__) || defined(__powerpc__) || defined(__arm__) || \ + defined(__sparc__) || defined(__mips__) || defined(__sh__) || \ + defined(__XTENSA__) || \ + (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 4) || \ + (defined(__LONG_MAX__) && __LONG_MAX__ == 2147483647L)) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__LP64__) || \ + defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__) || \ + defined(__e2k__) || \ + (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 8) || \ + (defined(__LONG_MAX__) && __LONG_MAX__ == 9223372036854775807L) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#else +/* generic "safe guess" on old 32-bit style */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +#endif + +#ifdef _AIX +/* AIX needs */ +#define CURL_PULL_SYS_POLL_H +#endif + +/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file */ +/* sys/types.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_TYPES_H +# include +#endif + +/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file */ +/* sys/socket.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_SOCKET_H +# include +#endif + +/* CURL_PULL_SYS_POLL_H is defined above when inclusion of header file */ +/* sys/poll.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_POLL_H +# include +#endif + +/* Data type definition of curl_socklen_t. */ +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T + typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; +#endif + +/* Data type definition of curl_off_t. */ + +#ifdef CURL_TYPEOF_CURL_OFF_T + typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; +#endif + +/* + * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow + * these to be visible and exported by the external libcurl interface API, + * while also making them visible to the library internals, simply including + * curl_setup.h, without actually needing to include curl.h internally. + * If some day this section would grow big enough, all this should be moved + * to its own header file. + */ + +/* + * Figure out if we can use the ## preprocessor operator, which is supported + * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__ + * or __cplusplus so we need to carefully check for them too. + */ + +#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ + defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \ + defined(__POCC__) || defined(__HIGHC__) || \ + defined(__ILEC400__) + /* This compiler is believed to have an ISO compatible preprocessor */ +#define CURL_ISOCPP +#else + /* This compiler is believed NOT to have an ISO compatible preprocessor */ +#undef CURL_ISOCPP +#endif + +/* + * Macros for minimum-width signed and unsigned curl_off_t integer constants. + */ + +#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551) +# define CURLINC_OFF_T_C_HLPR2(x) x +# define CURLINC_OFF_T_C_HLPR1(x) CURLINC_OFF_T_C_HLPR2(x) +# define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ + CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ + CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) +#else +# ifdef CURL_ISOCPP +# define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix +# else +# define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix +# endif +# define CURLINC_OFF_T_C_HLPR1(Val,Suffix) CURLINC_OFF_T_C_HLPR2(Val,Suffix) +# define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) +#endif + +#endif /* CURLINC_SYSTEM_H */ diff --git a/deps/libcurl/include/curl/typecheck-gcc.h b/deps/libcurl/include/curl/typecheck-gcc.h new file mode 100644 index 0000000000..e532e6997d --- /dev/null +++ b/deps/libcurl/include/curl/typecheck-gcc.h @@ -0,0 +1,718 @@ +#ifndef CURLINC_TYPECHECK_GCC_H +#define CURLINC_TYPECHECK_GCC_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ + +/* wraps curl_easy_setopt() with typechecking */ + +/* To add a new kind of warning, add an + * if(curlcheck_sometype_option(_curl_opt)) + * if(!curlcheck_sometype(value)) + * _curl_easy_setopt_err_sometype(); + * block and define curlcheck_sometype_option, curlcheck_sometype and + * _curl_easy_setopt_err_sometype below + * + * NOTE: We use two nested 'if' statements here instead of the && operator, in + * order to work around gcc bug #32061. It affects only gcc 4.3.x/4.4.x + * when compiling with -Wlogical-op. + * + * To add an option that uses the same type as an existing option, you will + * just need to extend the appropriate _curl_*_option macro + */ +#define curl_easy_setopt(handle, option, value) \ + __extension__({ \ + CURLoption _curl_opt = (option); \ + if(__builtin_constant_p(_curl_opt)) { \ + CURL_IGNORE_DEPRECATION( \ + if(curlcheck_long_option(_curl_opt)) \ + if(!curlcheck_long(value)) \ + _curl_easy_setopt_err_long(); \ + if(curlcheck_off_t_option(_curl_opt)) \ + if(!curlcheck_off_t(value)) \ + _curl_easy_setopt_err_curl_off_t(); \ + if(curlcheck_string_option(_curl_opt)) \ + if(!curlcheck_string(value)) \ + _curl_easy_setopt_err_string(); \ + if(curlcheck_write_cb_option(_curl_opt)) \ + if(!curlcheck_write_cb(value)) \ + _curl_easy_setopt_err_write_callback(); \ + if((_curl_opt) == CURLOPT_RESOLVER_START_FUNCTION) \ + if(!curlcheck_resolver_start_callback(value)) \ + _curl_easy_setopt_err_resolver_start_callback(); \ + if((_curl_opt) == CURLOPT_READFUNCTION) \ + if(!curlcheck_read_cb(value)) \ + _curl_easy_setopt_err_read_cb(); \ + if((_curl_opt) == CURLOPT_IOCTLFUNCTION) \ + if(!curlcheck_ioctl_cb(value)) \ + _curl_easy_setopt_err_ioctl_cb(); \ + if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION) \ + if(!curlcheck_sockopt_cb(value)) \ + _curl_easy_setopt_err_sockopt_cb(); \ + if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION) \ + if(!curlcheck_opensocket_cb(value)) \ + _curl_easy_setopt_err_opensocket_cb(); \ + if((_curl_opt) == CURLOPT_PROGRESSFUNCTION) \ + if(!curlcheck_progress_cb(value)) \ + _curl_easy_setopt_err_progress_cb(); \ + if((_curl_opt) == CURLOPT_DEBUGFUNCTION) \ + if(!curlcheck_debug_cb(value)) \ + _curl_easy_setopt_err_debug_cb(); \ + if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION) \ + if(!curlcheck_ssl_ctx_cb(value)) \ + _curl_easy_setopt_err_ssl_ctx_cb(); \ + if(curlcheck_conv_cb_option(_curl_opt)) \ + if(!curlcheck_conv_cb(value)) \ + _curl_easy_setopt_err_conv_cb(); \ + if((_curl_opt) == CURLOPT_SEEKFUNCTION) \ + if(!curlcheck_seek_cb(value)) \ + _curl_easy_setopt_err_seek_cb(); \ + if(curlcheck_cb_data_option(_curl_opt)) \ + if(!curlcheck_cb_data(value)) \ + _curl_easy_setopt_err_cb_data(); \ + if((_curl_opt) == CURLOPT_ERRORBUFFER) \ + if(!curlcheck_error_buffer(value)) \ + _curl_easy_setopt_err_error_buffer(); \ + if((_curl_opt) == CURLOPT_STDERR) \ + if(!curlcheck_FILE(value)) \ + _curl_easy_setopt_err_FILE(); \ + if(curlcheck_postfields_option(_curl_opt)) \ + if(!curlcheck_postfields(value)) \ + _curl_easy_setopt_err_postfields(); \ + if((_curl_opt) == CURLOPT_HTTPPOST) \ + if(!curlcheck_arr((value), struct curl_httppost)) \ + _curl_easy_setopt_err_curl_httpost(); \ + if((_curl_opt) == CURLOPT_MIMEPOST) \ + if(!curlcheck_ptr((value), curl_mime)) \ + _curl_easy_setopt_err_curl_mimepost(); \ + if(curlcheck_slist_option(_curl_opt)) \ + if(!curlcheck_arr((value), struct curl_slist)) \ + _curl_easy_setopt_err_curl_slist(); \ + if((_curl_opt) == CURLOPT_SHARE) \ + if(!curlcheck_ptr((value), CURLSH)) \ + _curl_easy_setopt_err_CURLSH(); \ + ) \ + } \ + curl_easy_setopt(handle, _curl_opt, value); \ + }) + +/* wraps curl_easy_getinfo() with typechecking */ +#define curl_easy_getinfo(handle, info, arg) \ + __extension__({ \ + CURLINFO _curl_info = (info); \ + if(__builtin_constant_p(_curl_info)) { \ + CURL_IGNORE_DEPRECATION( \ + if(curlcheck_string_info(_curl_info)) \ + if(!curlcheck_arr((arg), char *)) \ + _curl_easy_getinfo_err_string(); \ + if(curlcheck_long_info(_curl_info)) \ + if(!curlcheck_arr((arg), long)) \ + _curl_easy_getinfo_err_long(); \ + if(curlcheck_double_info(_curl_info)) \ + if(!curlcheck_arr((arg), double)) \ + _curl_easy_getinfo_err_double(); \ + if(curlcheck_slist_info(_curl_info)) \ + if(!curlcheck_arr((arg), struct curl_slist *)) \ + _curl_easy_getinfo_err_curl_slist(); \ + if(curlcheck_tlssessioninfo_info(_curl_info)) \ + if(!curlcheck_arr((arg), struct curl_tlssessioninfo *)) \ + _curl_easy_getinfo_err_curl_tlssesssioninfo(); \ + if(curlcheck_certinfo_info(_curl_info)) \ + if(!curlcheck_arr((arg), struct curl_certinfo *)) \ + _curl_easy_getinfo_err_curl_certinfo(); \ + if(curlcheck_socket_info(_curl_info)) \ + if(!curlcheck_arr((arg), curl_socket_t)) \ + _curl_easy_getinfo_err_curl_socket(); \ + if(curlcheck_off_t_info(_curl_info)) \ + if(!curlcheck_arr((arg), curl_off_t)) \ + _curl_easy_getinfo_err_curl_off_t(); \ + ) \ + } \ + curl_easy_getinfo(handle, _curl_info, arg); \ + }) + +/* + * For now, just make sure that the functions are called with three arguments + */ +#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param) +#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) + + +/* the actual warnings, triggered by calling the _curl_easy_setopt_err* + * functions */ + +/* To define a new warning, use _CURL_WARNING(identifier, "message") */ +#define CURLWARNING(id, message) \ + static void __attribute__((__warning__(message))) \ + __attribute__((__unused__)) __attribute__((__noinline__)) \ + id(void) { __asm__(""); } + +CURLWARNING(_curl_easy_setopt_err_long, + "curl_easy_setopt expects a long argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_off_t, + "curl_easy_setopt expects a curl_off_t argument for this option") +CURLWARNING(_curl_easy_setopt_err_string, + "curl_easy_setopt expects a " + "string ('char *' or char[]) argument for this option" + ) +CURLWARNING(_curl_easy_setopt_err_write_callback, + "curl_easy_setopt expects a curl_write_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_resolver_start_callback, + "curl_easy_setopt expects a " + "curl_resolver_start_callback argument for this option" + ) +CURLWARNING(_curl_easy_setopt_err_read_cb, + "curl_easy_setopt expects a curl_read_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_ioctl_cb, + "curl_easy_setopt expects a curl_ioctl_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_sockopt_cb, + "curl_easy_setopt expects a curl_sockopt_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_opensocket_cb, + "curl_easy_setopt expects a " + "curl_opensocket_callback argument for this option" + ) +CURLWARNING(_curl_easy_setopt_err_progress_cb, + "curl_easy_setopt expects a curl_progress_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_debug_cb, + "curl_easy_setopt expects a curl_debug_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_ssl_ctx_cb, + "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_conv_cb, + "curl_easy_setopt expects a curl_conv_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_seek_cb, + "curl_easy_setopt expects a curl_seek_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_cb_data, + "curl_easy_setopt expects a " + "private data pointer as argument for this option") +CURLWARNING(_curl_easy_setopt_err_error_buffer, + "curl_easy_setopt expects a " + "char buffer of CURL_ERROR_SIZE as argument for this option") +CURLWARNING(_curl_easy_setopt_err_FILE, + "curl_easy_setopt expects a 'FILE *' argument for this option") +CURLWARNING(_curl_easy_setopt_err_postfields, + "curl_easy_setopt expects a 'void *' or 'char *' argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_httpost, + "curl_easy_setopt expects a 'struct curl_httppost *' " + "argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_mimepost, + "curl_easy_setopt expects a 'curl_mime *' " + "argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_slist, + "curl_easy_setopt expects a 'struct curl_slist *' argument for this option") +CURLWARNING(_curl_easy_setopt_err_CURLSH, + "curl_easy_setopt expects a CURLSH* argument for this option") + +CURLWARNING(_curl_easy_getinfo_err_string, + "curl_easy_getinfo expects a pointer to 'char *' for this info") +CURLWARNING(_curl_easy_getinfo_err_long, + "curl_easy_getinfo expects a pointer to long for this info") +CURLWARNING(_curl_easy_getinfo_err_double, + "curl_easy_getinfo expects a pointer to double for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_slist, + "curl_easy_getinfo expects a pointer to 'struct curl_slist *' for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_tlssesssioninfo, + "curl_easy_getinfo expects a pointer to " + "'struct curl_tlssessioninfo *' for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_certinfo, + "curl_easy_getinfo expects a pointer to " + "'struct curl_certinfo *' for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_socket, + "curl_easy_getinfo expects a pointer to curl_socket_t for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_off_t, + "curl_easy_getinfo expects a pointer to curl_off_t for this info") + +/* groups of curl_easy_setops options that take the same type of argument */ + +/* To add a new option to one of the groups, just add + * (option) == CURLOPT_SOMETHING + * to the or-expression. If the option takes a long or curl_off_t, you do not + * have to do anything + */ + +/* evaluates to true if option takes a long argument */ +#define curlcheck_long_option(option) \ + (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT) + +#define curlcheck_off_t_option(option) \ + (((option) > CURLOPTTYPE_OFF_T) && ((option) < CURLOPTTYPE_BLOB)) + +/* evaluates to true if option takes a char* argument */ +#define curlcheck_string_option(option) \ + ((option) == CURLOPT_ABSTRACT_UNIX_SOCKET || \ + (option) == CURLOPT_ACCEPT_ENCODING || \ + (option) == CURLOPT_ALTSVC || \ + (option) == CURLOPT_CAINFO || \ + (option) == CURLOPT_CAPATH || \ + (option) == CURLOPT_COOKIE || \ + (option) == CURLOPT_COOKIEFILE || \ + (option) == CURLOPT_COOKIEJAR || \ + (option) == CURLOPT_COOKIELIST || \ + (option) == CURLOPT_CRLFILE || \ + (option) == CURLOPT_CUSTOMREQUEST || \ + (option) == CURLOPT_DEFAULT_PROTOCOL || \ + (option) == CURLOPT_DNS_INTERFACE || \ + (option) == CURLOPT_DNS_LOCAL_IP4 || \ + (option) == CURLOPT_DNS_LOCAL_IP6 || \ + (option) == CURLOPT_DNS_SERVERS || \ + (option) == CURLOPT_DOH_URL || \ + (option) == CURLOPT_ECH || \ + (option) == CURLOPT_EGDSOCKET || \ + (option) == CURLOPT_FTP_ACCOUNT || \ + (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ + (option) == CURLOPT_FTPPORT || \ + (option) == CURLOPT_HSTS || \ + (option) == CURLOPT_HAPROXY_CLIENT_IP || \ + (option) == CURLOPT_INTERFACE || \ + (option) == CURLOPT_ISSUERCERT || \ + (option) == CURLOPT_KEYPASSWD || \ + (option) == CURLOPT_KRBLEVEL || \ + (option) == CURLOPT_LOGIN_OPTIONS || \ + (option) == CURLOPT_MAIL_AUTH || \ + (option) == CURLOPT_MAIL_FROM || \ + (option) == CURLOPT_NETRC_FILE || \ + (option) == CURLOPT_NOPROXY || \ + (option) == CURLOPT_PASSWORD || \ + (option) == CURLOPT_PINNEDPUBLICKEY || \ + (option) == CURLOPT_PRE_PROXY || \ + (option) == CURLOPT_PROTOCOLS_STR || \ + (option) == CURLOPT_PROXY || \ + (option) == CURLOPT_PROXY_CAINFO || \ + (option) == CURLOPT_PROXY_CAPATH || \ + (option) == CURLOPT_PROXY_CRLFILE || \ + (option) == CURLOPT_PROXY_ISSUERCERT || \ + (option) == CURLOPT_PROXY_KEYPASSWD || \ + (option) == CURLOPT_PROXY_PINNEDPUBLICKEY || \ + (option) == CURLOPT_PROXY_SERVICE_NAME || \ + (option) == CURLOPT_PROXY_SSL_CIPHER_LIST || \ + (option) == CURLOPT_PROXY_SSLCERT || \ + (option) == CURLOPT_PROXY_SSLCERTTYPE || \ + (option) == CURLOPT_PROXY_SSLKEY || \ + (option) == CURLOPT_PROXY_SSLKEYTYPE || \ + (option) == CURLOPT_PROXY_TLS13_CIPHERS || \ + (option) == CURLOPT_PROXY_TLSAUTH_PASSWORD || \ + (option) == CURLOPT_PROXY_TLSAUTH_TYPE || \ + (option) == CURLOPT_PROXY_TLSAUTH_USERNAME || \ + (option) == CURLOPT_PROXYPASSWORD || \ + (option) == CURLOPT_PROXYUSERNAME || \ + (option) == CURLOPT_PROXYUSERPWD || \ + (option) == CURLOPT_RANDOM_FILE || \ + (option) == CURLOPT_RANGE || \ + (option) == CURLOPT_REDIR_PROTOCOLS_STR || \ + (option) == CURLOPT_REFERER || \ + (option) == CURLOPT_REQUEST_TARGET || \ + (option) == CURLOPT_RTSP_SESSION_ID || \ + (option) == CURLOPT_RTSP_STREAM_URI || \ + (option) == CURLOPT_RTSP_TRANSPORT || \ + (option) == CURLOPT_SASL_AUTHZID || \ + (option) == CURLOPT_SERVICE_NAME || \ + (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 || \ + (option) == CURLOPT_SSH_KNOWNHOSTS || \ + (option) == CURLOPT_SSH_PRIVATE_KEYFILE || \ + (option) == CURLOPT_SSH_PUBLIC_KEYFILE || \ + (option) == CURLOPT_SSLCERT || \ + (option) == CURLOPT_SSLCERTTYPE || \ + (option) == CURLOPT_SSLENGINE || \ + (option) == CURLOPT_SSLKEY || \ + (option) == CURLOPT_SSLKEYTYPE || \ + (option) == CURLOPT_SSL_CIPHER_LIST || \ + (option) == CURLOPT_TLS13_CIPHERS || \ + (option) == CURLOPT_TLSAUTH_PASSWORD || \ + (option) == CURLOPT_TLSAUTH_TYPE || \ + (option) == CURLOPT_TLSAUTH_USERNAME || \ + (option) == CURLOPT_UNIX_SOCKET_PATH || \ + (option) == CURLOPT_URL || \ + (option) == CURLOPT_USERAGENT || \ + (option) == CURLOPT_USERNAME || \ + (option) == CURLOPT_AWS_SIGV4 || \ + (option) == CURLOPT_USERPWD || \ + (option) == CURLOPT_XOAUTH2_BEARER || \ + (option) == CURLOPT_SSL_EC_CURVES || \ + 0) + +/* evaluates to true if option takes a curl_write_callback argument */ +#define curlcheck_write_cb_option(option) \ + ((option) == CURLOPT_HEADERFUNCTION || \ + (option) == CURLOPT_WRITEFUNCTION) + +/* evaluates to true if option takes a curl_conv_callback argument */ +#define curlcheck_conv_cb_option(option) \ + ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION || \ + (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION || \ + (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION) + +/* evaluates to true if option takes a data argument to pass to a callback */ +#define curlcheck_cb_data_option(option) \ + ((option) == CURLOPT_CHUNK_DATA || \ + (option) == CURLOPT_CLOSESOCKETDATA || \ + (option) == CURLOPT_DEBUGDATA || \ + (option) == CURLOPT_FNMATCH_DATA || \ + (option) == CURLOPT_HEADERDATA || \ + (option) == CURLOPT_HSTSREADDATA || \ + (option) == CURLOPT_HSTSWRITEDATA || \ + (option) == CURLOPT_INTERLEAVEDATA || \ + (option) == CURLOPT_IOCTLDATA || \ + (option) == CURLOPT_OPENSOCKETDATA || \ + (option) == CURLOPT_PREREQDATA || \ + (option) == CURLOPT_PROGRESSDATA || \ + (option) == CURLOPT_READDATA || \ + (option) == CURLOPT_SEEKDATA || \ + (option) == CURLOPT_SOCKOPTDATA || \ + (option) == CURLOPT_SSH_KEYDATA || \ + (option) == CURLOPT_SSL_CTX_DATA || \ + (option) == CURLOPT_WRITEDATA || \ + (option) == CURLOPT_RESOLVER_START_DATA || \ + (option) == CURLOPT_TRAILERDATA || \ + (option) == CURLOPT_SSH_HOSTKEYDATA || \ + 0) + +/* evaluates to true if option takes a POST data argument (void* or char*) */ +#define curlcheck_postfields_option(option) \ + ((option) == CURLOPT_POSTFIELDS || \ + (option) == CURLOPT_COPYPOSTFIELDS || \ + 0) + +/* evaluates to true if option takes a struct curl_slist * argument */ +#define curlcheck_slist_option(option) \ + ((option) == CURLOPT_HTTP200ALIASES || \ + (option) == CURLOPT_HTTPHEADER || \ + (option) == CURLOPT_MAIL_RCPT || \ + (option) == CURLOPT_POSTQUOTE || \ + (option) == CURLOPT_PREQUOTE || \ + (option) == CURLOPT_PROXYHEADER || \ + (option) == CURLOPT_QUOTE || \ + (option) == CURLOPT_RESOLVE || \ + (option) == CURLOPT_TELNETOPTIONS || \ + (option) == CURLOPT_CONNECT_TO || \ + 0) + +/* groups of curl_easy_getinfo infos that take the same type of argument */ + +/* evaluates to true if info expects a pointer to char * argument */ +#define curlcheck_string_info(info) \ + (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG && \ + (info) != CURLINFO_PRIVATE) + +/* evaluates to true if info expects a pointer to long argument */ +#define curlcheck_long_info(info) \ + (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE) + +/* evaluates to true if info expects a pointer to double argument */ +#define curlcheck_double_info(info) \ + (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST) + +/* true if info expects a pointer to struct curl_slist * argument */ +#define curlcheck_slist_info(info) \ + (((info) == CURLINFO_SSL_ENGINES) || ((info) == CURLINFO_COOKIELIST)) + +/* true if info expects a pointer to struct curl_tlssessioninfo * argument */ +#define curlcheck_tlssessioninfo_info(info) \ + (((info) == CURLINFO_TLS_SSL_PTR) || ((info) == CURLINFO_TLS_SESSION)) + +/* true if info expects a pointer to struct curl_certinfo * argument */ +#define curlcheck_certinfo_info(info) ((info) == CURLINFO_CERTINFO) + +/* true if info expects a pointer to struct curl_socket_t argument */ +#define curlcheck_socket_info(info) \ + (CURLINFO_SOCKET < (info) && (info) < CURLINFO_OFF_T) + +/* true if info expects a pointer to curl_off_t argument */ +#define curlcheck_off_t_info(info) \ + (CURLINFO_OFF_T < (info)) + + +/* typecheck helpers -- check whether given expression has requested type */ + +/* For pointers, you can use the curlcheck_ptr/curlcheck_arr macros, + * otherwise define a new macro. Search for __builtin_types_compatible_p + * in the GCC manual. + * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is + * the actual expression passed to the curl_easy_setopt macro. This + * means that you can only apply the sizeof and __typeof__ operators, no + * == or whatsoever. + */ + +/* XXX: should evaluate to true if expr is a pointer */ +#define curlcheck_any_ptr(expr) \ + (sizeof(expr) == sizeof(void *)) + +/* evaluates to true if expr is NULL */ +/* XXX: must not evaluate expr, so this check is not accurate */ +#define curlcheck_NULL(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL))) + +/* evaluates to true if expr is type*, const type* or NULL */ +#define curlcheck_ptr(expr, type) \ + (curlcheck_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), type *) || \ + __builtin_types_compatible_p(__typeof__(expr), const type *)) + +/* evaluates to true if expr is one of type[], type*, NULL or const type* */ +#define curlcheck_arr(expr, type) \ + (curlcheck_ptr((expr), type) || \ + __builtin_types_compatible_p(__typeof__(expr), type [])) + +/* evaluates to true if expr is a string */ +#define curlcheck_string(expr) \ + (curlcheck_arr((expr), char) || \ + curlcheck_arr((expr), signed char) || \ + curlcheck_arr((expr), unsigned char)) + +/* evaluates to true if expr is a long (no matter the signedness) + * XXX: for now, int is also accepted (and therefore short and char, which + * are promoted to int when passed to a variadic function) */ +#define curlcheck_long(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), long) || \ + __builtin_types_compatible_p(__typeof__(expr), signed long) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned long) || \ + __builtin_types_compatible_p(__typeof__(expr), int) || \ + __builtin_types_compatible_p(__typeof__(expr), signed int) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned int) || \ + __builtin_types_compatible_p(__typeof__(expr), short) || \ + __builtin_types_compatible_p(__typeof__(expr), signed short) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned short) || \ + __builtin_types_compatible_p(__typeof__(expr), char) || \ + __builtin_types_compatible_p(__typeof__(expr), signed char) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned char)) + +/* evaluates to true if expr is of type curl_off_t */ +#define curlcheck_off_t(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), curl_off_t)) + +/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */ +/* XXX: also check size of an char[] array? */ +#define curlcheck_error_buffer(expr) \ + (curlcheck_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), char *) || \ + __builtin_types_compatible_p(__typeof__(expr), char[])) + +/* evaluates to true if expr is of type (const) void* or (const) FILE* */ +#if 0 +#define curlcheck_cb_data(expr) \ + (curlcheck_ptr((expr), void) || \ + curlcheck_ptr((expr), FILE)) +#else /* be less strict */ +#define curlcheck_cb_data(expr) \ + curlcheck_any_ptr(expr) +#endif + +/* evaluates to true if expr is of type FILE* */ +#define curlcheck_FILE(expr) \ + (curlcheck_NULL(expr) || \ + (__builtin_types_compatible_p(__typeof__(expr), FILE *))) + +/* evaluates to true if expr can be passed as POST data (void* or char*) */ +#define curlcheck_postfields(expr) \ + (curlcheck_ptr((expr), void) || \ + curlcheck_arr((expr), char) || \ + curlcheck_arr((expr), unsigned char)) + +/* helper: __builtin_types_compatible_p distinguishes between functions and + * function pointers, hide it */ +#define curlcheck_cb_compatible(func, type) \ + (__builtin_types_compatible_p(__typeof__(func), type) || \ + __builtin_types_compatible_p(__typeof__(func) *, type)) + +/* evaluates to true if expr is of type curl_resolver_start_callback */ +#define curlcheck_resolver_start_callback(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_resolver_start_callback)) + +/* evaluates to true if expr is of type curl_read_callback or "similar" */ +#define curlcheck_read_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), __typeof__(fread) *) || \ + curlcheck_cb_compatible((expr), curl_read_callback) || \ + curlcheck_cb_compatible((expr), _curl_read_callback1) || \ + curlcheck_cb_compatible((expr), _curl_read_callback2) || \ + curlcheck_cb_compatible((expr), _curl_read_callback3) || \ + curlcheck_cb_compatible((expr), _curl_read_callback4) || \ + curlcheck_cb_compatible((expr), _curl_read_callback5) || \ + curlcheck_cb_compatible((expr), _curl_read_callback6)) +typedef size_t (*_curl_read_callback1)(char *, size_t, size_t, void *); +typedef size_t (*_curl_read_callback2)(char *, size_t, size_t, const void *); +typedef size_t (*_curl_read_callback3)(char *, size_t, size_t, FILE *); +typedef size_t (*_curl_read_callback4)(void *, size_t, size_t, void *); +typedef size_t (*_curl_read_callback5)(void *, size_t, size_t, const void *); +typedef size_t (*_curl_read_callback6)(void *, size_t, size_t, FILE *); + +/* evaluates to true if expr is of type curl_write_callback or "similar" */ +#define curlcheck_write_cb(expr) \ + (curlcheck_read_cb(expr) || \ + curlcheck_cb_compatible((expr), __typeof__(fwrite) *) || \ + curlcheck_cb_compatible((expr), curl_write_callback) || \ + curlcheck_cb_compatible((expr), _curl_write_callback1) || \ + curlcheck_cb_compatible((expr), _curl_write_callback2) || \ + curlcheck_cb_compatible((expr), _curl_write_callback3) || \ + curlcheck_cb_compatible((expr), _curl_write_callback4) || \ + curlcheck_cb_compatible((expr), _curl_write_callback5) || \ + curlcheck_cb_compatible((expr), _curl_write_callback6)) +typedef size_t (*_curl_write_callback1)(const char *, size_t, size_t, void *); +typedef size_t (*_curl_write_callback2)(const char *, size_t, size_t, + const void *); +typedef size_t (*_curl_write_callback3)(const char *, size_t, size_t, FILE *); +typedef size_t (*_curl_write_callback4)(const void *, size_t, size_t, void *); +typedef size_t (*_curl_write_callback5)(const void *, size_t, size_t, + const void *); +typedef size_t (*_curl_write_callback6)(const void *, size_t, size_t, FILE *); + +/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */ +#define curlcheck_ioctl_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_ioctl_callback) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback1) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback2) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback3) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback4)) +typedef curlioerr (*_curl_ioctl_callback1)(CURL *, int, void *); +typedef curlioerr (*_curl_ioctl_callback2)(CURL *, int, const void *); +typedef curlioerr (*_curl_ioctl_callback3)(CURL *, curliocmd, void *); +typedef curlioerr (*_curl_ioctl_callback4)(CURL *, curliocmd, const void *); + +/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */ +#define curlcheck_sockopt_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_sockopt_callback) || \ + curlcheck_cb_compatible((expr), _curl_sockopt_callback1) || \ + curlcheck_cb_compatible((expr), _curl_sockopt_callback2)) +typedef int (*_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype); +typedef int (*_curl_sockopt_callback2)(const void *, curl_socket_t, + curlsocktype); + +/* evaluates to true if expr is of type curl_opensocket_callback or + "similar" */ +#define curlcheck_opensocket_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_opensocket_callback) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback1) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback2) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback3) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback4)) +typedef curl_socket_t (*_curl_opensocket_callback1) + (void *, curlsocktype, struct curl_sockaddr *); +typedef curl_socket_t (*_curl_opensocket_callback2) + (void *, curlsocktype, const struct curl_sockaddr *); +typedef curl_socket_t (*_curl_opensocket_callback3) + (const void *, curlsocktype, struct curl_sockaddr *); +typedef curl_socket_t (*_curl_opensocket_callback4) + (const void *, curlsocktype, const struct curl_sockaddr *); + +/* evaluates to true if expr is of type curl_progress_callback or "similar" */ +#define curlcheck_progress_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_progress_callback) || \ + curlcheck_cb_compatible((expr), _curl_progress_callback1) || \ + curlcheck_cb_compatible((expr), _curl_progress_callback2)) +typedef int (*_curl_progress_callback1)(void *, + double, double, double, double); +typedef int (*_curl_progress_callback2)(const void *, + double, double, double, double); + +/* evaluates to true if expr is of type curl_debug_callback or "similar" */ +#define curlcheck_debug_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_debug_callback) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback1) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback2) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback3) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback4) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback5) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback6) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback7) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback8)) +typedef int (*_curl_debug_callback1) (CURL *, + curl_infotype, char *, size_t, void *); +typedef int (*_curl_debug_callback2) (CURL *, + curl_infotype, char *, size_t, const void *); +typedef int (*_curl_debug_callback3) (CURL *, + curl_infotype, const char *, size_t, void *); +typedef int (*_curl_debug_callback4) (CURL *, + curl_infotype, const char *, size_t, const void *); +typedef int (*_curl_debug_callback5) (CURL *, + curl_infotype, unsigned char *, size_t, void *); +typedef int (*_curl_debug_callback6) (CURL *, + curl_infotype, unsigned char *, size_t, const void *); +typedef int (*_curl_debug_callback7) (CURL *, + curl_infotype, const unsigned char *, size_t, void *); +typedef int (*_curl_debug_callback8) (CURL *, + curl_infotype, const unsigned char *, size_t, const void *); + +/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */ +/* this is getting even messier... */ +#define curlcheck_ssl_ctx_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_ssl_ctx_callback) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback1) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback2) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback3) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback4) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback5) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback6) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback7) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback8)) +typedef CURLcode (*_curl_ssl_ctx_callback1)(CURL *, void *, void *); +typedef CURLcode (*_curl_ssl_ctx_callback2)(CURL *, void *, const void *); +typedef CURLcode (*_curl_ssl_ctx_callback3)(CURL *, const void *, void *); +typedef CURLcode (*_curl_ssl_ctx_callback4)(CURL *, const void *, + const void *); +#ifdef HEADER_SSL_H +/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX + * this will of course break if we are included before OpenSSL headers... + */ +typedef CURLcode (*_curl_ssl_ctx_callback5)(CURL *, SSL_CTX *, void *); +typedef CURLcode (*_curl_ssl_ctx_callback6)(CURL *, SSL_CTX *, const void *); +typedef CURLcode (*_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX *, void *); +typedef CURLcode (*_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX *, + const void *); +#else +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8; +#endif + +/* evaluates to true if expr is of type curl_conv_callback or "similar" */ +#define curlcheck_conv_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_conv_callback) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback1) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback2) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback3) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback4)) +typedef CURLcode (*_curl_conv_callback1)(char *, size_t length); +typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length); +typedef CURLcode (*_curl_conv_callback3)(void *, size_t length); +typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length); + +/* evaluates to true if expr is of type curl_seek_callback or "similar" */ +#define curlcheck_seek_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_seek_callback) || \ + curlcheck_cb_compatible((expr), _curl_seek_callback1) || \ + curlcheck_cb_compatible((expr), _curl_seek_callback2)) +typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int); +typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int); + + +#endif /* CURLINC_TYPECHECK_GCC_H */ diff --git a/deps/libcurl/include/curl/urlapi.h b/deps/libcurl/include/curl/urlapi.h new file mode 100644 index 0000000000..b4a6e5d567 --- /dev/null +++ b/deps/libcurl/include/curl/urlapi.h @@ -0,0 +1,155 @@ +#ifndef CURLINC_URLAPI_H +#define CURLINC_URLAPI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ + +#include "curl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* the error codes for the URL API */ +typedef enum { + CURLUE_OK, + CURLUE_BAD_HANDLE, /* 1 */ + CURLUE_BAD_PARTPOINTER, /* 2 */ + CURLUE_MALFORMED_INPUT, /* 3 */ + CURLUE_BAD_PORT_NUMBER, /* 4 */ + CURLUE_UNSUPPORTED_SCHEME, /* 5 */ + CURLUE_URLDECODE, /* 6 */ + CURLUE_OUT_OF_MEMORY, /* 7 */ + CURLUE_USER_NOT_ALLOWED, /* 8 */ + CURLUE_UNKNOWN_PART, /* 9 */ + CURLUE_NO_SCHEME, /* 10 */ + CURLUE_NO_USER, /* 11 */ + CURLUE_NO_PASSWORD, /* 12 */ + CURLUE_NO_OPTIONS, /* 13 */ + CURLUE_NO_HOST, /* 14 */ + CURLUE_NO_PORT, /* 15 */ + CURLUE_NO_QUERY, /* 16 */ + CURLUE_NO_FRAGMENT, /* 17 */ + CURLUE_NO_ZONEID, /* 18 */ + CURLUE_BAD_FILE_URL, /* 19 */ + CURLUE_BAD_FRAGMENT, /* 20 */ + CURLUE_BAD_HOSTNAME, /* 21 */ + CURLUE_BAD_IPV6, /* 22 */ + CURLUE_BAD_LOGIN, /* 23 */ + CURLUE_BAD_PASSWORD, /* 24 */ + CURLUE_BAD_PATH, /* 25 */ + CURLUE_BAD_QUERY, /* 26 */ + CURLUE_BAD_SCHEME, /* 27 */ + CURLUE_BAD_SLASHES, /* 28 */ + CURLUE_BAD_USER, /* 29 */ + CURLUE_LACKS_IDN, /* 30 */ + CURLUE_TOO_LARGE, /* 31 */ + CURLUE_LAST +} CURLUcode; + +typedef enum { + CURLUPART_URL, + CURLUPART_SCHEME, + CURLUPART_USER, + CURLUPART_PASSWORD, + CURLUPART_OPTIONS, + CURLUPART_HOST, + CURLUPART_PORT, + CURLUPART_PATH, + CURLUPART_QUERY, + CURLUPART_FRAGMENT, + CURLUPART_ZONEID /* added in 7.65.0 */ +} CURLUPart; + +#define CURLU_DEFAULT_PORT (1<<0) /* return default port number */ +#define CURLU_NO_DEFAULT_PORT (1<<1) /* act as if no port number was set, + if the port number matches the + default for the scheme */ +#define CURLU_DEFAULT_SCHEME (1<<2) /* return default scheme if + missing */ +#define CURLU_NON_SUPPORT_SCHEME (1<<3) /* allow non-supported scheme */ +#define CURLU_PATH_AS_IS (1<<4) /* leave dot sequences */ +#define CURLU_DISALLOW_USER (1<<5) /* no user+password allowed */ +#define CURLU_URLDECODE (1<<6) /* URL decode on get */ +#define CURLU_URLENCODE (1<<7) /* URL encode on set */ +#define CURLU_APPENDQUERY (1<<8) /* append a form style part */ +#define CURLU_GUESS_SCHEME (1<<9) /* legacy curl-style guessing */ +#define CURLU_NO_AUTHORITY (1<<10) /* Allow empty authority when the + scheme is unknown. */ +#define CURLU_ALLOW_SPACE (1<<11) /* Allow spaces in the URL */ +#define CURLU_PUNYCODE (1<<12) /* get the hostname in punycode */ +#define CURLU_PUNY2IDN (1<<13) /* punycode => IDN conversion */ +#define CURLU_GET_EMPTY (1<<14) /* allow empty queries and fragments + when extracting the URL or the + components */ +#define CURLU_NO_GUESS_SCHEME (1<<15) /* for get, do not accept a guess */ + +typedef struct Curl_URL CURLU; + +/* + * curl_url() creates a new CURLU handle and returns a pointer to it. + * Must be freed with curl_url_cleanup(). + */ +CURL_EXTERN CURLU *curl_url(void); + +/* + * curl_url_cleanup() frees the CURLU handle and related resources used for + * the URL parsing. It will not free strings previously returned with the URL + * API. + */ +CURL_EXTERN void curl_url_cleanup(CURLU *handle); + +/* + * curl_url_dup() duplicates a CURLU handle and returns a new copy. The new + * handle must also be freed with curl_url_cleanup(). + */ +CURL_EXTERN CURLU *curl_url_dup(const CURLU *in); + +/* + * curl_url_get() extracts a specific part of the URL from a CURLU + * handle. Returns error code. The returned pointer MUST be freed with + * curl_free() afterwards. + */ +CURL_EXTERN CURLUcode curl_url_get(const CURLU *handle, CURLUPart what, + char **part, unsigned int flags); + +/* + * curl_url_set() sets a specific part of the URL in a CURLU handle. Returns + * error code. The passed in string will be copied. Passing a NULL instead of + * a part string, clears that part. + */ +CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what, + const char *part, unsigned int flags); + +/* + * curl_url_strerror() turns a CURLUcode value into the equivalent human + * readable error string. This is useful for printing meaningful error + * messages. + */ +CURL_EXTERN const char *curl_url_strerror(CURLUcode); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif /* CURLINC_URLAPI_H */ diff --git a/deps/libcurl/include/curl/websockets.h b/deps/libcurl/include/curl/websockets.h new file mode 100644 index 0000000000..6ef6a2bc92 --- /dev/null +++ b/deps/libcurl/include/curl/websockets.h @@ -0,0 +1,84 @@ +#ifndef CURLINC_WEBSOCKETS_H +#define CURLINC_WEBSOCKETS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * SPDX-License-Identifier: curl + * + ***************************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +struct curl_ws_frame { + int age; /* zero */ + int flags; /* See the CURLWS_* defines */ + curl_off_t offset; /* the offset of this data into the frame */ + curl_off_t bytesleft; /* number of pending bytes left of the payload */ + size_t len; /* size of the current data chunk */ +}; + +/* flag bits */ +#define CURLWS_TEXT (1<<0) +#define CURLWS_BINARY (1<<1) +#define CURLWS_CONT (1<<2) +#define CURLWS_CLOSE (1<<3) +#define CURLWS_PING (1<<4) +#define CURLWS_OFFSET (1<<5) + +/* + * NAME curl_ws_recv() + * + * DESCRIPTION + * + * Receives data from the websocket connection. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +CURL_EXTERN CURLcode curl_ws_recv(CURL *curl, void *buffer, size_t buflen, + size_t *recv, + const struct curl_ws_frame **metap); + +/* flags for curl_ws_send() */ +#define CURLWS_PONG (1<<6) + +/* + * NAME curl_ws_send() + * + * DESCRIPTION + * + * Sends data over the websocket connection. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +CURL_EXTERN CURLcode curl_ws_send(CURL *curl, const void *buffer, + size_t buflen, size_t *sent, + curl_off_t fragsize, + unsigned int flags); + +/* bits for the CURLOPT_WS_OPTIONS bitmask: */ +#define CURLWS_RAW_MODE (1<<0) + +CURL_EXTERN const struct curl_ws_frame *curl_ws_meta(CURL *curl); + +#ifdef __cplusplus +} +#endif + +#endif /* CURLINC_WEBSOCKETS_H */ diff --git a/deps/libcurl/lib/libcurl.a b/deps/libcurl/lib/libcurl.a new file mode 100644 index 0000000000000000000000000000000000000000..72707170fba0835a5a8b32221e585e0e6b4e657e GIT binary patch literal 1123738 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¨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

*DWG|`1{`*e@ULJNaFrVHsky6 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 MSI%MgZ>L88H;wh=U;qFB literal 0 HcmV?d00001 From 84a706c8f0d5361eb47169507b2a579abaa7ca45 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Sun, 8 Mar 2026 00:02:07 +1100 Subject: [PATCH 02/31] temporary delete --- docs/multiplayer_readme.txt | 44 ------------------------------------- 1 file changed, 44 deletions(-) delete mode 100644 docs/multiplayer_readme.txt diff --git a/docs/multiplayer_readme.txt b/docs/multiplayer_readme.txt deleted file mode 100644 index fa10cf0116..0000000000 --- a/docs/multiplayer_readme.txt +++ /dev/null @@ -1,44 +0,0 @@ -Multiplayer in KeeperFX ------------------------------- - -KeeperFX supports multiplayer over TCP/IP or ENET/UDP. Serial, Modem and IPX are -not supported. 1Player allows you to practice multiplayer maps alone. - -KeeperFX, like Dungeon Keeper, requires a low latency connection to work properly. -Latency is always high when playing over very high distances, so playing with -people near you will work best. Multiplayer will start to become unplayable when -you are over a couple hundred kilometer away from each other. - -* High-latency connections will make both games run very slow. -* Limited to two players. -* Desyncs and crashes are very possible, report issues and they may be fixed. - -Multiplayer over ENET/UDP ------------------------------- - -To host a ENET/UDP game: -Make sure the port 5556 is open for traffic and is forwarded to port 5556 on -your computer. When you have started the game, click Multiplayer -> ENET/UDP -> -Create Game. - -To join a ENET/UDP game: -Specify a command line option -sessions [ip_address]:5556 when starting game. -For instance, if the host's IP address is 55.83.54.187, the appropriate command -line option is -sessions 55.83.54.187:5556 -The launcher can be used to set this. - -Several sessions can be added to command line by prepending a semicolon before -each extra address, e.g. -sessions 55.83.54.187:5555;214.43.45.67:5556 - -When you have started the game, click Multiplayer -> ENET/UDP -> [select IP -address in list] -> Join Game. - -Multiplayer over TCP/IP ------------------------------- - -Hosting or joining a game over TCP/IP works the same as over ENET/UDP, with a -key difference. Open port 5555 instead and select TCP/IP from the multiplayer -menu. - -TCP/IP is less suitable for multiplayer as a protocol, and there's no known -reason to use this over ENET/UDP as you will have significantly more lag. \ No newline at end of file From 64a06bfe9153610a3b9ad3d20a49c911c4aa5ccd Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Sat, 7 Mar 2026 03:56:07 +1100 Subject: [PATCH 03/31] disabled upnp and natpmp --- src/net_portforward.cpp | 8 +++++++- src/net_portforward.h | 3 +++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/src/net_portforward.cpp b/src/net_portforward.cpp index 556628a86b..e7a0660769 100644 --- a/src/net_portforward.cpp +++ b/src/net_portforward.cpp @@ -60,6 +60,9 @@ enum PortForwardMethod { static enum PortForwardMethod active_method = PORT_FORWARD_NONE; static uint16_t mapped_port = 0; +int upnp_enabled = 0; +int natpmp_enabled = 0; + static struct UPNPUrls upnp_urls; static struct IGDdatas upnp_data; static char upnp_lanaddr[64]; @@ -201,7 +204,10 @@ static void port_forward_add_mapping_internal(uint16_t port) { if (active_method != PORT_FORWARD_NONE) { port_forward_remove_mapping(); } - if (natpmp_add_port_mapping(port)) { + if (natpmp_enabled && natpmp_add_port_mapping(port)) { + return; + } + if (!upnp_enabled) { return; } int error = 0; diff --git a/src/net_portforward.h b/src/net_portforward.h index cd6115894d..87453e0062 100644 --- a/src/net_portforward.h +++ b/src/net_portforward.h @@ -25,6 +25,9 @@ extern "C" { #endif +extern int upnp_enabled; +extern int natpmp_enabled; + int port_forward_add_mapping(uint16_t port); void port_forward_remove_mapping(void); From 0b8814db7b6e2eebab73ef6c87cfb9451b00d542 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Fri, 6 Mar 2026 10:15:35 +1100 Subject: [PATCH 04/31] matchmaking --- Makefile | 14 +- src/bflib_enet.cpp | 78 ++++++++--- src/bflib_enet.h | 8 ++ src/bflib_netsession.h | 8 +- src/bflib_network.cpp | 15 ++ src/bflib_network.h | 2 +- src/front_network.c | 8 ++ src/net_game.c | 3 + src/net_holepunch.c | 168 ++++++++++++++++++++++ src/net_holepunch.h | 39 ++++++ src/net_matchmaking.c | 312 +++++++++++++++++++++++++++++++++++++++++ src/net_matchmaking.h | 53 +++++++ 12 files changed, 681 insertions(+), 27 deletions(-) create mode 100644 src/net_holepunch.c create mode 100644 src/net_holepunch.h create mode 100644 src/net_matchmaking.c create mode 100644 src/net_matchmaking.h diff --git a/Makefile b/Makefile index c7a3fd6d63..2f1de638a5 100644 --- a/Makefile +++ b/Makefile @@ -105,6 +105,7 @@ obj/bflib_datetm.o \ obj/bflib_dernc.o \ obj/bflib_enet.o \ obj/net_portforward.o \ +obj/net_holepunch.o \ obj/bflib_fileio.o \ obj/bflib_filelst.o \ obj/bflib_fmvids.o \ @@ -287,6 +288,7 @@ obj/net_input_lag.o \ obj/net_received_packets.o \ obj/net_redundant_packets.o \ obj/net_checksums.o \ +obj/net_matchmaking.o \ obj/packets.o \ obj/packets_cheats.o \ obj/packets_input.o \ @@ -377,6 +379,7 @@ LINKLIB = -mwindows \ -L"deps/enet6/lib" -lenet6 \ -L"deps/miniupnpc" -lminiupnpc \ -L"deps/libnatpmp" -lnatpmp -liphlpapi \ + -L"deps/libcurl/lib" -lcurl -lwldap32 -lcrypt32 \ -L"deps/spng" -lspng \ -L"deps/centijson" -ljson \ -L"deps/zlib" -lminizip -lz \ @@ -395,7 +398,8 @@ INCS = \ -I"deps/openal/include" \ -I"deps/luajit/include" \ -I"deps/miniupnpc/include" \ - -I"deps/libnatpmp/include" + -I"deps/libnatpmp/include" \ + -I"deps/libcurl/include" CXXINCS = $(INCS) STDOBJS = $(subst obj/,obj/std/,$(OBJS)) @@ -435,7 +439,7 @@ HVLOGFLAGS = -DBFDEBUG_LEVEL=10 WARNFLAGS = -Wall -W -Wshadow -Wno-sign-compare -Wno-unused-parameter -Wno-maybe-uninitialized -Wno-sign-compare -Wno-strict-aliasing -Wno-unknown-pragmas -Werror # disabled warnings: -Wextra -Wtype-limits CXXFLAGS = $(CXXINCS) -c -std=gnu++1y -fmessage-length=0 $(WARNFLAGS) $(DEPFLAGS) $(OPTFLAGS) $(DBGFLAGS) $(FTEST_DBGFLAGS) $(INCFLAGS) -CFLAGS = $(INCS) -c -std=gnu11 -fmessage-length=0 $(WARNFLAGS) -Werror=implicit $(DEPFLAGS) $(FTEST_DBGFLAGS) $(OPTFLAGS) $(DBGFLAGS) $(INCFLAGS) +CFLAGS = $(INCS) -c -std=gnu11 -fmessage-length=0 $(WARNFLAGS) -Werror=implicit $(DEPFLAGS) $(FTEST_DBGFLAGS) $(OPTFLAGS) $(DBGFLAGS) $(INCFLAGS) -DCURL_STATICLIB LDFLAGS = $(LINKLIB) $(OPTFLAGS) $(DBGFLAGS) $(FTEST_DBGFLAGS) $(LINKFLAGS) -Wl,-Map,"$(@:%.exe=%.map)" ifeq ($(USE_PRE_FILE), 1) @@ -654,7 +658,7 @@ clean-libexterns: libexterns.mk -$(RM) -rf deps/enet6 deps/zlib deps/spng deps/astronomy deps/centijson deps/luajit deps/miniupnpc deps/libnatpmp -$(RM) libexterns -deps/enet6 deps/zlib deps/spng deps/astronomy deps/centijson deps/ffmpeg deps/openal deps/luajit deps/miniupnpc deps/libnatpmp: +deps/enet6 deps/zlib deps/spng deps/astronomy deps/centijson deps/ffmpeg deps/openal deps/luajit deps/miniupnpc deps/libnatpmp deps/libcurl: $(MKDIR) $@ src/api.c: deps/centijson/include/json.h @@ -668,6 +672,7 @@ src/bflib_sndlib.cpp: deps/openal/include/AL/al.h src/net_resync.cpp: deps/zlib/include/zlib.h src/console_cmd.c: deps/luajit/include/lua.h src/net_portforward.cpp: deps/miniupnpc/include/miniupnpc/miniupnpc.h deps/libnatpmp/include/natpmp/natpmp.h +src/net_matchmaking.c: deps/libcurl/include/curl/curl.h deps/enet6-mingw32.tar.gz: curl -Lso $@ "https://github.com/dkfans/kfx-deps/releases/download/20260212/enet6-mingw32.tar.gz" @@ -731,6 +736,9 @@ deps/libnatpmp-mingw32.tar.gz: deps/libnatpmp/include/natpmp/natpmp.h: deps/libnatpmp-mingw32.tar.gz | deps/libnatpmp tar xzmf $< -C deps/libnatpmp +deps/libcurl/include/curl/curl.h: deps/curl-mingw32.tar.gz | deps/libcurl + tar xzmf $< -C deps/libcurl + cppcheck: | src/ver_defs.h cppcheck: | deps/zlib/include/zlib.h cppcheck: | deps/spng/include/spng.h diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index d1df7b8063..4828b29424 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -17,6 +17,8 @@ #include "bflib_network.h" #include "bflib_math.h" #include "net_portforward.h" +#include "net_holepunch.h" +#include "net_matchmaking.h" #include "game_legacy.h" #include "player_data.h" @@ -32,6 +34,10 @@ #define NUM_CHANNELS 2 #define DEFAULT_PORT 5556 +#define HOLEPUNCH_CONNECT_DELAY_MS 300 + +uint16_t g_external_port = 0; +char g_external_ip[EXTERNAL_IP_LEN] = {0}; namespace { @@ -112,6 +118,7 @@ namespace } enet_host_compress_with_range_coder(host); port_forward_add_mapping(address.port); + g_external_port = holepunch_stun_query(host, g_external_ip, sizeof(g_external_ip)); return Lb_OK; } @@ -188,33 +195,49 @@ namespace TbError bf_enet_join(const char *session, void *options) { - char buf[128] = {0}; ENetAddress connect_address; - enet_uint16 port = parse_session_address(session, buf, sizeof(buf)); - if (port == 0) { - return Lb_FAIL; - } - if (buf[0] == '\0') { - return Lb_FAIL; - } - if (enet_address_set_host(&connect_address, ENET_ADDRESS_TYPE_ANY, buf) < 0) { - return Lb_FAIL; - } - connect_address.port = port; - host = enet_host_create(connect_address.type, NULL, 4, NUM_CHANNELS, 0, 0); - if (!host) - { - return Lb_FAIL; + if (g_join_lobby_id[0] != '\0') { + host = enet_host_create(ENET_ADDRESS_TYPE_IPV4, NULL, 4, NUM_CHANNELS, 0, 0); + if (!host) { + return Lb_FAIL; + } + uint16_t ext_port = holepunch_stun_query(host, NULL, 0); + char peer_ip[MATCHMAKING_IP_MAX] = {0}; + int peer_port = 0; + if (matchmaking_punch(g_join_lobby_id, (int)ext_port, peer_ip, &peer_port) != 0) { + host_destroy(); + return Lb_FAIL; + } + g_join_lobby_id[0] = '\0'; + if (enet_address_set_host(&connect_address, ENET_ADDRESS_TYPE_IPV4, peer_ip) < 0) { + host_destroy(); + return Lb_FAIL; + } + connect_address.port = (enet_uint16)peer_port; + Sleep(HOLEPUNCH_CONNECT_DELAY_MS); + } else { + char buf[128] = {0}; + enet_uint16 port = parse_session_address(session, buf, sizeof(buf)); + if (port == 0 || buf[0] == '\0') { + return Lb_FAIL; + } + if (enet_address_set_host(&connect_address, ENET_ADDRESS_TYPE_ANY, buf) < 0) { + return Lb_FAIL; + } + connect_address.port = port; + host = enet_host_create(connect_address.type, NULL, 4, NUM_CHANNELS, 0, 0); + if (!host) { + return Lb_FAIL; + } } enet_host_compress_with_range_coder(host); + holepunch_punch_to(host, &connect_address); client_peer = enet_host_connect(host, &connect_address, NUM_CHANNELS, 0); - if (!client_peer) - { + if (!client_peer) { host_destroy(); return Lb_FAIL; } - if (wait_for_connect(TIMEOUT_ENET_CONNECT)) - { + if (wait_for_connect(TIMEOUT_ENET_CONNECT)) { host_destroy(); return Lb_FAIL; } @@ -703,6 +726,21 @@ unsigned int GetClientReliableCommandsInFlight() { return ClampSizeToUInt(best_value); } +void enet_matchmaking_host_update(void) +{ + if (!host) + return; + char peer_ip[MATCHMAKING_IP_MAX]; + int peer_port = 0; + if (!matchmaking_poll_punch(peer_ip, &peer_port)) + return; + ENetAddress target; + if (enet_address_set_host(&target, ENET_ADDRESS_TYPE_IPV4, peer_ip) != 0) + return; + target.port = (enet_uint16)peer_port; + holepunch_punch_to(host, &target); +} + struct NetSP *InitEnetSP() { static struct NetSP ret = diff --git a/src/bflib_enet.h b/src/bflib_enet.h index cf3599f318..d447fcffd8 100644 --- a/src/bflib_enet.h +++ b/src/bflib_enet.h @@ -15,10 +15,15 @@ #ifndef GIT_BFLIB_ENET_H #define GIT_BFLIB_ENET_H +#include + #ifdef __cplusplus extern "C" { #endif +#define ENET_DEFAULT_PORT 5556 +#define EXTERNAL_IP_LEN 64 + enum { ENET_CHANNEL_RELIABLE = 0, ENET_CHANNEL_UNSEQUENCED = 1 @@ -35,6 +40,9 @@ unsigned int GetClientPacketsLost(); unsigned int GetClientOutgoingDataTotal(); unsigned int GetClientIncomingDataTotal(); unsigned int GetClientReliableCommandsInFlight(); +void enet_matchmaking_host_update(void); +extern uint16_t g_external_port; +extern char g_external_ip[EXTERNAL_IP_LEN]; #ifdef __cplusplus } diff --git a/src/bflib_netsession.h b/src/bflib_netsession.h index 234ed00b31..4cef779d6e 100644 --- a/src/bflib_netsession.h +++ b/src/bflib_netsession.h @@ -27,8 +27,9 @@ extern "C" { /******************************************************************************/ #define NETSP_PLAYERS_COUNT 32 #define SESSION_ENTRIES_COUNT 32 -#define SESSION_NAME_MAX_LEN 128 -#define NETSP_PLAYER_NAME_MAX_LEN 32 +#define SESSION_NAME_MAX_LEN 128 +#define SESSION_LOBBY_ID_MAX_LEN 64 +#define NETSP_PLAYER_NAME_MAX_LEN 32 enum NetMsgType { @@ -44,10 +45,11 @@ enum NetMsgType }; struct TbNetworkSessionNameEntry { - unsigned char joinable; //possibly active or selected is better name + unsigned char joinable; unsigned long id; unsigned long in_use; char text[SESSION_NAME_MAX_LEN]; + char lobby_id[SESSION_LOBBY_ID_MAX_LEN]; }; struct TbNetworkPlayerEntry { diff --git a/src/bflib_network.cpp b/src/bflib_network.cpp index 4d1b2f5f9e..708154cc09 100644 --- a/src/bflib_network.cpp +++ b/src/bflib_network.cpp @@ -31,7 +31,11 @@ #include "front_landview.h" #include "front_network.h" #include "net_received_packets.h" +#include "net_matchmaking.h" +#include "bflib_enet.h" #include "keeperfx.hpp" +#include +#include #include "post_inc.h" #ifdef __cplusplus @@ -145,6 +149,16 @@ TbError LbNetwork_Create(char *nsname_str, char *plyr_name, uint32_t *plyr_num, if (netstate.sp->host(port, optns) == Lb_FAIL) { return Lb_FAIL; } + std::string host_name(plyr_name); + uint16_t ext_port = g_external_port; + if (ext_port == 0 && ServerPort > 0) + ext_port = (uint16_t)ServerPort; + if (ext_port == 0) + ext_port = (uint16_t)ENET_DEFAULT_PORT; + std::thread([ext_port, host_name]() { + if (matchmaking_connect() == 0) + matchmaking_create(host_name.c_str(), (int)ext_port, g_external_ip); + }).detach(); netstate.my_id = SERVER_ID; snprintf(netstate.users[netstate.my_id].name, sizeof(netstate.users[netstate.my_id].name), "%s", plyr_name); netstate.users[netstate.my_id].progress = USER_LOGGEDIN; @@ -189,6 +203,7 @@ TbError LbNetwork_EnableNewPlayers(TbBool allow) { } TbError LbNetwork_Stop(void) { + matchmaking_disconnect(); if (netstate.sp) { netstate.sp->exit(); } diff --git a/src/bflib_network.h b/src/bflib_network.h index b62dc54e26..f293d39760 100644 --- a/src/bflib_network.h +++ b/src/bflib_network.h @@ -30,7 +30,7 @@ extern "C" { #define CLIENT_TABLE_LEN 32 -#define TIMEOUT_ENET_CONNECT 2000 +#define TIMEOUT_ENET_CONNECT 5000 #define TIMEOUT_JOIN_LOBBY 2000 #define TIMEOUT_LOBBY_EXCHANGE 3000 #define TIMEOUT_GAMEPLAY_MISSING_PACKET 8000 diff --git a/src/front_network.c b/src/front_network.c index 99298b83a2..73ef5bd486 100644 --- a/src/front_network.c +++ b/src/front_network.c @@ -43,6 +43,8 @@ #include "config_strings.h" #include "game_merge.h" #include "game_legacy.h" +#include "net_matchmaking.h" +#include "bflib_enet.h" #include "post_inc.h" #ifdef __cplusplus @@ -242,6 +244,9 @@ void frontnet_session_update(void) memset(net_session, 0, sizeof(net_session)); if ( LbNetwork_EnumerateSessions(enum_sessions_callback, 0) ) ERRORLOG("LbNetwork_EnumerateSessions() failed"); + matchmaking_refresh_sessions(); + for (int i = 0; i < g_mm_session_count && net_number_of_sessions < SESSION_ENTRIES_COUNT; i++) + net_session[net_number_of_sessions++] = &g_mm_sessions[i]; last_enum_sessions = LbTimerClock(); if (net_number_of_sessions == 0) @@ -416,6 +421,7 @@ void frontnet_start_update(void) frontnet_rewite_net_messages(); LbNetwork_UpdateInputLagIfHost(); + enet_matchmaking_host_update(); } void display_attempting_to_join_message(void) @@ -474,6 +480,7 @@ void frontnet_service_setup(void) net_number_of_services++; } net_load_config_file(); + matchmaking_init(); } void frontnet_session_setup(void) @@ -487,6 +494,7 @@ void frontnet_session_setup(void) fe_computer_players = 2; lbInkey = 0; net_session_index_active_id = -1; + matchmaking_connect_async(); } void frontnet_start_setup(void) diff --git a/src/net_game.c b/src/net_game.c index 5f2825c3d5..6459fc5b5f 100644 --- a/src/net_game.c +++ b/src/net_game.c @@ -17,6 +17,7 @@ */ /******************************************************************************/ #include "pre_inc.h" +#include "net_matchmaking.h" #include "net_game.h" #include "globals.h" @@ -189,8 +190,10 @@ long network_session_join(void) { int32_t plyr_num; display_attempting_to_join_message(); + snprintf(g_join_lobby_id, sizeof(g_join_lobby_id), "%s", net_session[net_session_index_active]->lobby_id); if ( LbNetwork_Join(net_session[net_session_index_active], net_player_name, &plyr_num, NULL) ) { + g_join_lobby_id[0] = '\0'; process_network_error(-802); return -1; } diff --git a/src/net_holepunch.c b/src/net_holepunch.c new file mode 100644 index 0000000000..70cb2e5d46 --- /dev/null +++ b/src/net_holepunch.c @@ -0,0 +1,168 @@ +/******************************************************************************/ +// Free implementation of Bullfrog's Dungeon Keeper strategy game. +/******************************************************************************/ +/** + * @file net_holepunch.cpp + * UDP hole punching via STUN. + * @par Purpose: + * holepunch_stun_query() sends a STUN Binding Request (RFC 5389) from the + * ENet host's own socket. This serves two purposes: + * 1. Creates a NAT table entry so incoming ENet connections reach us even + * when UPnP/NAT-PMP is unavailable. + * 2. Logs our external IP:port so the host can share it with others. + * + * holepunch_punch_to() sends a burst of small UDP datagrams to the server + * before enet_host_connect() is called. This opens a mapping in the + * client's cone NAT and primes port-restricted cone NATs on the server. + * @author KeeperFX Team + * @date 06 Mar 2026 + * @par Copying and copyrights: + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ +/******************************************************************************/ +#include "pre_inc.h" +#include "net_holepunch.h" +#include "bflib_basics.h" + +#if defined(_WIN32) +#define WIN32_LEAN_AND_MEAN +#include +#endif +#include +#include +#include +#include + +#include "post_inc.h" + +#define STUN_SERVER "stun.l.google.com" +#define STUN_PORT 19302 +#define STUN_TIMEOUT_MS 500 +#define STUN_MAGIC_COOKIE 0x2112A442U +#define STUN_BINDING_REQUEST 0x0001U +#define STUN_BINDING_SUCCESS 0x0101U +#define STUN_ATTR_XOR_MAPPED 0x0020U +#define STUN_RESPONSE_BUF_SIZE 512 +#define HOLE_PUNCH_COUNT 5 +#define HOLE_PUNCH_PAYLOAD_SIZE 8 + +#pragma pack(push, 1) +struct StunHeader { + uint16_t type; + uint16_t length; + uint32_t magic; + uint8_t txid[12]; +}; + +struct StunAttrHeader { + uint16_t type; + uint16_t length; +}; +#pragma pack(pop) + +uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) +{ + ENetAddress stun_addr; + if (enet_address_set_host(&stun_addr, ENET_ADDRESS_TYPE_IPV4, STUN_SERVER) < 0) { + LbNetLog("STUN: Failed to resolve %s\n", STUN_SERVER); + return 0; + } + stun_addr.port = STUN_PORT; + + static unsigned s_counter = 0; + s_counter++; + struct StunHeader req = {htons(STUN_BINDING_REQUEST), htons(0), htonl(STUN_MAGIC_COOKIE), {0}}; + memcpy(req.txid, &s_counter, sizeof(s_counter)); + ENetBuffer send_buf = {sizeof(req), &req}; + ENetSocket sock = host->socket; + ENetSocket tmp_sock = ENET_SOCKET_NULL; + if (enet_socket_send(sock, &stun_addr, &send_buf, 1) < 0) { + tmp_sock = enet_socket_create(ENET_ADDRESS_TYPE_IPV4, ENET_SOCKET_TYPE_DATAGRAM); + if (tmp_sock == ENET_SOCKET_NULL) { + LbNetLog("STUN: failed to create IPv4 socket\n"); + return 0; + } + if (enet_socket_send(tmp_sock, &stun_addr, &send_buf, 1) < 0) { + LbNetLog("STUN: IPv4 socket send failed\n"); + enet_socket_destroy(tmp_sock); + return 0; + } + sock = tmp_sock; + } + + DWORD deadline = GetTickCount() + STUN_TIMEOUT_MS; + uint16_t result = 0; + for (;;) { + DWORD now = GetTickCount(); + if (now >= deadline) + break; + enet_uint32 wait_flags = ENET_SOCKET_WAIT_RECEIVE; + if (enet_socket_wait(sock, &wait_flags, deadline - now) < 0 + || !(wait_flags & ENET_SOCKET_WAIT_RECEIVE)) { + LbNetLog("STUN: No response within %d ms\n", STUN_TIMEOUT_MS); + break; + } + uint8_t resp[STUN_RESPONSE_BUF_SIZE]; + ENetAddress from; + ENetBuffer recv_buf = {sizeof(resp), resp}; + int n = enet_socket_receive(sock, &from, &recv_buf, 1); + if (n <= 0) + continue; + if (n < (int)sizeof(struct StunHeader)) + break; + const struct StunHeader *hdr = (const struct StunHeader *)resp; + if (ntohs(hdr->type) != STUN_BINDING_SUCCESS + || ntohl(hdr->magic) != STUN_MAGIC_COOKIE + || memcmp(hdr->txid, req.txid, sizeof(hdr->txid)) != 0) + continue; + int offset = (int)sizeof(struct StunHeader); + int attrs_end = offset + (int)ntohs(hdr->length); + if (attrs_end > n) attrs_end = n; + char ip[64] = {0}; + uint16_t ext_port = 0; + while (offset + 4 <= attrs_end) { + const struct StunAttrHeader *attr = (const struct StunAttrHeader *)(resp + offset); + uint16_t atype = ntohs(attr->type); + uint16_t alen = ntohs(attr->length); + offset += 4; + if (atype == STUN_ATTR_XOR_MAPPED && alen >= 8 + && offset + alen <= attrs_end && resp[offset + 1] == 0x01) { + uint16_t xor_port = ((uint16_t)resp[offset + 2] << 8) | resp[offset + 3]; + ext_port = xor_port ^ (uint16_t)(STUN_MAGIC_COOKIE >> 16); + uint32_t xaddr; + memcpy(&xaddr, resp + offset + 4, 4); + uint32_t addr = ntohl(xaddr) ^ STUN_MAGIC_COOKIE; + snprintf(ip, sizeof(ip), "%u.%u.%u.%u", + (addr >> 24) & 0xFFu, (addr >> 16) & 0xFFu, + (addr >> 8) & 0xFFu, addr & 0xFFu); + break; + } + offset += (alen + 3) & ~3; + } + if (!ext_port) + continue; + if (tmp_sock != ENET_SOCKET_NULL) + ext_port = host->address.port; + LbNetLog("STUN: External address %s:%u\n", ip, (unsigned)ext_port); + if (ip_out && ip_len > 0) + snprintf(ip_out, ip_len, "%s", ip); + result = ext_port; + break; + } + if (!result) + LbNetLog("STUN: Failed to parse mapped address\n"); + if (tmp_sock != ENET_SOCKET_NULL) + enet_socket_destroy(tmp_sock); + return result; +} + +void holepunch_punch_to(ENetHost *host, const ENetAddress *target) +{ + static const uint8_t payload[HOLE_PUNCH_PAYLOAD_SIZE] = {0}; + ENetBuffer buf = {sizeof(payload), (void *)payload}; + for (int i = 0; i < HOLE_PUNCH_COUNT; i++) + enet_socket_send(host->socket, target, &buf, 1); +} diff --git a/src/net_holepunch.h b/src/net_holepunch.h new file mode 100644 index 0000000000..d9822129ae --- /dev/null +++ b/src/net_holepunch.h @@ -0,0 +1,39 @@ +/******************************************************************************/ +// Free implementation of Bullfrog's Dungeon Keeper strategy game. +/******************************************************************************/ +/** + * @file net_holepunch.h + * UDP hole punching via STUN. + * @par Purpose: + * Sends a STUN Binding Request from the ENet host socket to discover the + * external address and create a NAT mapping. Also provides a helper to + * send pre-connect punch packets when joining. + * @author KeeperFX Team + * @date 06 Mar 2026 + * @par Copying and copyrights: + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ +/******************************************************************************/ +#ifndef NET_HOLEPUNCH_H +#define NET_HOLEPUNCH_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct _ENetHost; +struct _ENetAddress; + +uint16_t holepunch_stun_query(struct _ENetHost *host, char *ip_out, size_t ip_len); +void holepunch_punch_to(struct _ENetHost *host, const struct _ENetAddress *target); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c new file mode 100644 index 0000000000..a09ac0bb66 --- /dev/null +++ b/src/net_matchmaking.c @@ -0,0 +1,312 @@ +/******************************************************************************/ +// Free implementation of Bullfrog's Dungeon Keeper strategy game. +/******************************************************************************/ +/** + * @file net_matchmaking.c + * Matchmaking client for the KeeperFX lobby server. + * @par Purpose: + * Manages a WebSocket connection to the matchmaking server. + * Hosts register their lobby; clients list and join via hole-punch relay. + * @author KeeperFX Team + * @date 06 Mar 2026 + * @par Copying and copyrights: + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ +/******************************************************************************/ +#include "pre_inc.h" +#include "net_matchmaking.h" +#include "bflib_basics.h" +#include "ver_defs.h" + +#define WIN32_LEAN_AND_MEAN +#include +#include +#include +#include +#include +#include +#include +#include "post_inc.h" + +#define STR_(x) #x +#define STR(x) STR_(x) +#define MATCHMAKING_VERSION STR(VER_MAJOR) "." STR(VER_MINOR) "." STR(VER_RELEASE) + +#define WS_BUF_SIZE 8192 +#define WS_RECV_TIMEOUT_MS 3000 +#define SEND_BUF_SIZE 512 +#define CONNECT_TIMEOUT_MS 5000 + +static CURL *g_curl = NULL; +static char g_hosted_lobby_id[MATCHMAKING_ID_MAX] = {0}; +static DWORD g_last_refresh_tick = 0; +char g_join_lobby_id[MATCHMAKING_ID_MAX] = {0}; +static CRITICAL_SECTION g_cs; + +struct TbNetworkSessionNameEntry g_mm_sessions[MATCHMAKING_SESSIONS_MAX]; +int g_mm_session_count = 0; + +static void ws_cleanup(void) +{ + curl_easy_cleanup(g_curl); + g_curl = NULL; + g_hosted_lobby_id[0] = '\0'; + g_mm_session_count = 0; + g_last_refresh_tick = 0; +} + +static int ws_send(const char *msg) +{ + size_t sent = 0; + CURLcode rc = curl_ws_send(g_curl, msg, strlen(msg), &sent, 0, CURLWS_TEXT); + if (rc != CURLE_OK) { + LbNetLog("Matchmaking: ws_send failed: %s\n", curl_easy_strerror(rc)); + ws_cleanup(); + return -1; + } + return 0; +} + +static int ws_recv(char *buf, size_t bufsz, int timeout_ms) +{ + curl_socket_t sock = CURL_SOCKET_BAD; + if (curl_easy_getinfo(g_curl, CURLINFO_ACTIVESOCKET, &sock) != CURLE_OK || sock == CURL_SOCKET_BAD) + return -1; + + fd_set fds; + FD_ZERO(&fds); + FD_SET((SOCKET)sock, &fds); + struct timeval tv = { timeout_ms / 1000, (timeout_ms % 1000) * 1000 }; + if (select(0, &fds, NULL, NULL, &tv) <= 0) + return 0; + + size_t recvd = 0; + const struct curl_ws_frame *frame = NULL; + CURLcode rc = curl_ws_recv(g_curl, buf, bufsz - 1, &recvd, &frame); + if (rc == CURLE_AGAIN) + return 0; + if (rc != CURLE_OK) { + LbNetLog("Matchmaking: ws_recv failed: %s\n", curl_easy_strerror(rc)); + ws_cleanup(); + return -1; + } + buf[recvd] = '\0'; + return (int)recvd; +} + +static int ws_exchange(const char *msg, char *buf, size_t bufsz) +{ + if (!g_curl) return -1; + if (ws_send(msg) != 0) return -1; + return ws_recv(buf, bufsz, WS_RECV_TIMEOUT_MS); +} + +static const char *json_str(const char *json, const char *key, char *out, size_t outsz) +{ + char search[128]; + snprintf(search, sizeof(search), "\"%s\":\"", key); + const char *p = strstr(json, search); + if (!p) + return NULL; + p += strlen(search); + size_t len = 0; + while (*p && *p != '"' && len < outsz - 1) + out[len++] = *p++; + out[len] = '\0'; + if (*p != '"') + return NULL; + return p + 1; +} + +static int json_int(const char *json, const char *key, int *out) +{ + char search[128]; + snprintf(search, sizeof(search), "\"%s\":", key); + const char *p = strstr(json, search); + if (!p) + return 0; + p += strlen(search); + *out = atoi(p); + return 1; +} + +void matchmaking_init(void) +{ + static BOOL s_done = FALSE; + if (s_done) + return; + s_done = TRUE; + InitializeCriticalSection(&g_cs); + curl_global_init(CURL_GLOBAL_DEFAULT); +} + +static DWORD WINAPI connect_thread(LPVOID arg) +{ + matchmaking_connect(); + return 0; +} + +void matchmaking_connect_async(void) +{ + HANDLE h = CreateThread(NULL, 0, connect_thread, NULL, 0, NULL); + if (h) + CloseHandle(h); +} + +int matchmaking_connect(void) +{ + EnterCriticalSection(&g_cs); + if (g_curl) { + LeaveCriticalSection(&g_cs); + return 0; + } + g_curl = curl_easy_init(); + if (!g_curl) { + LeaveCriticalSection(&g_cs); + return -1; + } + curl_easy_setopt(g_curl, CURLOPT_URL, MATCHMAKING_URL); + curl_easy_setopt(g_curl, CURLOPT_CONNECT_ONLY, 2L); + curl_easy_setopt(g_curl, CURLOPT_CONNECTTIMEOUT_MS, (long)CONNECT_TIMEOUT_MS); + CURLcode rc = curl_easy_perform(g_curl); + if (rc != CURLE_OK) { + LbNetLog("Matchmaking: connect to %s failed: %s\n", MATCHMAKING_URL, curl_easy_strerror(rc)); + ws_cleanup(); + LeaveCriticalSection(&g_cs); + return -1; + } + LbNetLog("Matchmaking: connected\n"); + LeaveCriticalSection(&g_cs); + return 0; +} + +void matchmaking_disconnect(void) +{ + EnterCriticalSection(&g_cs); + if (g_curl) { + if (g_hosted_lobby_id[0] != '\0') { + char msg[SEND_BUF_SIZE]; + snprintf(msg, sizeof(msg), "{\"action\":\"delete\",\"id\":\"%s\"}", g_hosted_lobby_id); + ws_send(msg); + } + ws_cleanup(); + LbNetLog("Matchmaking: disconnected\n"); + } + LeaveCriticalSection(&g_cs); +} + +void matchmaking_refresh_sessions(void) +{ + EnterCriticalSection(&g_cs); + if (!g_curl) { + LeaveCriticalSection(&g_cs); + return; + } + DWORD now = GetTickCount(); + if (g_last_refresh_tick != 0 && (now - g_last_refresh_tick) < MATCHMAKING_REFRESH_MS) { + LeaveCriticalSection(&g_cs); + return; + } + char buf[WS_BUF_SIZE]; + if (ws_exchange("{\"action\":\"list\",\"version\":\"" MATCHMAKING_VERSION "\"}", buf, sizeof(buf)) > 0 + && strstr(buf, "\"lobbies\"")) { + int count = 0; + const char *p = buf; + while (count < MATCHMAKING_SESSIONS_MAX) { + char id[MATCHMAKING_ID_MAX]; + char name[MATCHMAKING_NAME_MAX]; + p = json_str(p, "id", id, sizeof(id)); + if (!p) break; + p = json_str(p, "name", name, sizeof(name)); + if (!p) break; + struct TbNetworkSessionNameEntry *s = &g_mm_sessions[count++]; + memset(s, 0, sizeof(*s)); + s->joinable = 1; + s->in_use = 1; + s->id = (unsigned long)count; + snprintf(s->text, SESSION_NAME_MAX_LEN, "%s", name); + snprintf(s->lobby_id, SESSION_LOBBY_ID_MAX_LEN, "%s", id); + } + g_mm_session_count = count; + } + g_last_refresh_tick = GetTickCount(); + LeaveCriticalSection(&g_cs); +} + +int matchmaking_create(const char *name, int udp_port, const char *ip) +{ + char escaped_name[MATCHMAKING_NAME_MAX * 2]; + char ip_field[80]; + char msg[SEND_BUF_SIZE]; + char buf[WS_BUF_SIZE]; + EnterCriticalSection(&g_cs); + if (!g_curl) { + LeaveCriticalSection(&g_cs); + return -1; + } + int pos = 0; + for (int i = 0; name[i] && pos < (int)sizeof(escaped_name) - 2; i++) { + if (name[i] == '"' || name[i] == '\\') + escaped_name[pos++] = '\\'; + escaped_name[pos++] = name[i]; + } + escaped_name[pos] = '\0'; + ip_field[0] = '\0'; + if (ip && ip[0]) + snprintf(ip_field, sizeof(ip_field), ",\"ip\":\"%s\"", ip); + snprintf(msg, sizeof(msg), + "{\"action\":\"create\",\"name\":\"%s\",\"port\":%d%s,\"version\":\"%s\"}", + escaped_name, udp_port, ip_field, MATCHMAKING_VERSION); + if (ws_exchange(msg, buf, sizeof(buf)) <= 0) { + LeaveCriticalSection(&g_cs); + return -1; + } + if (!strstr(buf, "\"created\"") || !json_str(buf, "id", g_hosted_lobby_id, MATCHMAKING_ID_MAX)) { + LeaveCriticalSection(&g_cs); + return -1; + } + LbNetLog("Matchmaking: created lobby id=%s\n", g_hosted_lobby_id); + LeaveCriticalSection(&g_cs); + return 0; +} + +int matchmaking_punch(const char *lobby_id, int udp_port, char *out_ip, int *out_port) +{ + char msg[SEND_BUF_SIZE]; + char buf[WS_BUF_SIZE]; + EnterCriticalSection(&g_cs); + snprintf(msg, sizeof(msg), + "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d}", + lobby_id, udp_port); + if (ws_exchange(msg, buf, sizeof(buf)) <= 0) { + LeaveCriticalSection(&g_cs); + return -1; + } + if (!strstr(buf, "\"punch\"") + || !json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) + || !json_int(buf, "peerPort", out_port)) { + LeaveCriticalSection(&g_cs); + return -1; + } + LbNetLog("Matchmaking: punch relay -> %s:%d\n", out_ip, *out_port); + LeaveCriticalSection(&g_cs); + return 0; +} + +int matchmaking_poll_punch(char *out_ip, int *out_port) +{ + if (!g_curl || !TryEnterCriticalSection(&g_cs)) + return 0; + char buf[WS_BUF_SIZE]; + int n = ws_recv(buf, sizeof(buf), 0); + int got_punch = 0; + if (n > 0 && strstr(buf, "\"punch\"")) { + got_punch = json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) + && json_int(buf, "peerPort", out_port); + } + LeaveCriticalSection(&g_cs); + return got_punch; +} diff --git a/src/net_matchmaking.h b/src/net_matchmaking.h new file mode 100644 index 0000000000..c9713c87c6 --- /dev/null +++ b/src/net_matchmaking.h @@ -0,0 +1,53 @@ +/******************************************************************************/ +// Free implementation of Bullfrog's Dungeon Keeper strategy game. +/******************************************************************************/ +/** + * @file net_matchmaking.h + * Matchmaking client for the KeeperFX lobby server. + * @par Purpose: + * Connects to the WebSocket-based matchmaking server to list, host, and + * join game sessions. Provides the hole-punch relay flow required for + * NAT traversal when direct port-forwarding is unavailable. + * @author KeeperFX Team + * @date 06 Mar 2026 + * @par Copying and copyrights: + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ +/******************************************************************************/ +#ifndef NET_MATCHMAKING_H +#define NET_MATCHMAKING_H + +#include "bflib_netsession.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MATCHMAKING_URL "wss://matchmaking.keeperfx.workers.dev/ws" +#define MATCHMAKING_ID_MAX 64 +#define MATCHMAKING_IP_MAX 64 +#define MATCHMAKING_NAME_MAX SESSION_NAME_MAX_LEN +#define MATCHMAKING_SESSIONS_MAX 32 +#define MATCHMAKING_REFRESH_MS 5000 + +extern struct TbNetworkSessionNameEntry g_mm_sessions[MATCHMAKING_SESSIONS_MAX]; +extern int g_mm_session_count; +extern char g_join_lobby_id[MATCHMAKING_ID_MAX]; + +void matchmaking_init(void); +void matchmaking_connect_async(void); +int matchmaking_connect(void); +void matchmaking_disconnect(void); +void matchmaking_refresh_sessions(void); +int matchmaking_create(const char *name, int udp_port, const char *ip); +int matchmaking_punch(const char *lobby_id, int udp_port, char *out_ip, int *out_port); +int matchmaking_poll_punch(char *out_ip, int *out_port); + +#ifdef __cplusplus +} +#endif + +#endif From 8ad7454322f63c265e691377027666f2c0fc283a Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Sat, 7 Mar 2026 11:48:13 +1100 Subject: [PATCH 05/31] logging --- src/bflib_enet.cpp | 23 +++++++++++++-- src/net_holepunch.c | 65 +++++++++++++++++++++++++++++++++---------- src/net_matchmaking.c | 56 +++++++++++++++++++++++++++++-------- 3 files changed, 115 insertions(+), 29 deletions(-) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index 4828b29424..7378456979 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -136,13 +136,15 @@ namespace } else { - fprintf(stderr, "Unexpected event %d\n", ev.type); + LbNetLog("wait_for_connect: unexpected event type=%d\n", (int)ev.type); } } if (ret < 0) { - fprintf(stderr, "Unable to connect! %d\n", ret); + LbNetLog("wait_for_connect: enet_host_service error %d\n", ret); ERRORLOG("Unable to connect: %d", ret); + } else { + LbNetLog("wait_for_connect: timed out (ret=0)\n"); } return 1; } @@ -199,21 +201,28 @@ namespace if (g_join_lobby_id[0] != '\0') { host = enet_host_create(ENET_ADDRESS_TYPE_IPV4, NULL, 4, NUM_CHANNELS, 0, 0); if (!host) { + LbNetLog("Join: failed to create ENet host\n"); return Lb_FAIL; } + LbNetLog("Join: created client host, local port=%u\n", (unsigned)host->address.port); uint16_t ext_port = holepunch_stun_query(host, NULL, 0); + LbNetLog("Join: STUN ext_port=%u\n", (unsigned)ext_port); char peer_ip[MATCHMAKING_IP_MAX] = {0}; int peer_port = 0; if (matchmaking_punch(g_join_lobby_id, (int)ext_port, peer_ip, &peer_port) != 0) { + LbNetLog("Join: matchmaking_punch failed\n"); host_destroy(); return Lb_FAIL; } g_join_lobby_id[0] = '\0'; + LbNetLog("Join: resolving peer address %s\n", peer_ip); if (enet_address_set_host(&connect_address, ENET_ADDRESS_TYPE_IPV4, peer_ip) < 0) { + LbNetLog("Join: failed to resolve peer address %s\n", peer_ip); host_destroy(); return Lb_FAIL; } connect_address.port = (enet_uint16)peer_port; + LbNetLog("Join: sleeping %dms before connect\n", HOLEPUNCH_CONNECT_DELAY_MS); Sleep(HOLEPUNCH_CONNECT_DELAY_MS); } else { char buf[128] = {0}; @@ -232,15 +241,25 @@ namespace } enet_host_compress_with_range_coder(host); holepunch_punch_to(host, &connect_address); + LbNetLog("Join: calling enet_host_connect to %u.%u.%u.%u:%u\n", + (unsigned)connect_address.host.v4[0], + (unsigned)connect_address.host.v4[1], + (unsigned)connect_address.host.v4[2], + (unsigned)connect_address.host.v4[3], + (unsigned)connect_address.port); client_peer = enet_host_connect(host, &connect_address, NUM_CHANNELS, 0); if (!client_peer) { + LbNetLog("Join: enet_host_connect returned NULL\n"); host_destroy(); return Lb_FAIL; } + LbNetLog("Join: waiting up to %dms for connection\n", TIMEOUT_ENET_CONNECT); if (wait_for_connect(TIMEOUT_ENET_CONNECT)) { + LbNetLog("Join: connection timed out or failed\n"); host_destroy(); return Lb_FAIL; } + LbNetLog("Join: connected successfully\n"); return Lb_OK; } diff --git a/src/net_holepunch.c b/src/net_holepunch.c index 70cb2e5d46..21043e0547 100644 --- a/src/net_holepunch.c +++ b/src/net_holepunch.c @@ -66,67 +66,91 @@ struct StunAttrHeader { uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) { ENetAddress stun_addr; + LbNetLog("STUN: resolving %s\n", STUN_SERVER); if (enet_address_set_host(&stun_addr, ENET_ADDRESS_TYPE_IPV4, STUN_SERVER) < 0) { - LbNetLog("STUN: Failed to resolve %s\n", STUN_SERVER); + LbNetLog("STUN: failed to resolve %s\n", STUN_SERVER); return 0; } stun_addr.port = STUN_PORT; + LbNetLog("STUN: resolved, sending binding request to port %u\n", (unsigned)STUN_PORT); static unsigned s_counter = 0; s_counter++; struct StunHeader req = {htons(STUN_BINDING_REQUEST), htons(0), htonl(STUN_MAGIC_COOKIE), {0}}; memcpy(req.txid, &s_counter, sizeof(s_counter)); + LbNetLog("STUN: txid counter=%u, host socket=%d\n", s_counter, (int)host->socket); ENetBuffer send_buf = {sizeof(req), &req}; ENetSocket sock = host->socket; ENetSocket tmp_sock = ENET_SOCKET_NULL; if (enet_socket_send(sock, &stun_addr, &send_buf, 1) < 0) { + LbNetLog("STUN: host socket send failed, falling back to fresh IPv4 socket\n"); tmp_sock = enet_socket_create(ENET_ADDRESS_TYPE_IPV4, ENET_SOCKET_TYPE_DATAGRAM); if (tmp_sock == ENET_SOCKET_NULL) { - LbNetLog("STUN: failed to create IPv4 socket\n"); + LbNetLog("STUN: failed to create fallback IPv4 socket\n"); return 0; } if (enet_socket_send(tmp_sock, &stun_addr, &send_buf, 1) < 0) { - LbNetLog("STUN: IPv4 socket send failed\n"); + LbNetLog("STUN: fallback IPv4 socket send failed\n"); enet_socket_destroy(tmp_sock); return 0; } + LbNetLog("STUN: sent via fallback socket (port will be host port %u)\n", (unsigned)host->address.port); sock = tmp_sock; + } else { + LbNetLog("STUN: sent via host socket\n"); } DWORD deadline = GetTickCount() + STUN_TIMEOUT_MS; uint16_t result = 0; + LbNetLog("STUN: waiting up to %d ms for response\n", STUN_TIMEOUT_MS); for (;;) { DWORD now = GetTickCount(); - if (now >= deadline) + if (now >= deadline) { + LbNetLog("STUN: deadline exceeded\n"); break; + } enet_uint32 wait_flags = ENET_SOCKET_WAIT_RECEIVE; if (enet_socket_wait(sock, &wait_flags, deadline - now) < 0 || !(wait_flags & ENET_SOCKET_WAIT_RECEIVE)) { - LbNetLog("STUN: No response within %d ms\n", STUN_TIMEOUT_MS); + LbNetLog("STUN: no response within %d ms\n", STUN_TIMEOUT_MS); break; } uint8_t resp[STUN_RESPONSE_BUF_SIZE]; ENetAddress from; ENetBuffer recv_buf = {sizeof(resp), resp}; int n = enet_socket_receive(sock, &from, &recv_buf, 1); + LbNetLog("STUN: received %d bytes\n", n); if (n <= 0) continue; - if (n < (int)sizeof(struct StunHeader)) + if (n < (int)sizeof(struct StunHeader)) { + LbNetLog("STUN: packet too short (%d bytes), ignoring\n", n); break; + } const struct StunHeader *hdr = (const struct StunHeader *)resp; - if (ntohs(hdr->type) != STUN_BINDING_SUCCESS - || ntohl(hdr->magic) != STUN_MAGIC_COOKIE - || memcmp(hdr->txid, req.txid, sizeof(hdr->txid)) != 0) + uint16_t pkt_type = ntohs(hdr->type); + uint32_t pkt_magic = ntohl(hdr->magic); + int txid_match = (memcmp(hdr->txid, req.txid, sizeof(hdr->txid)) == 0); + LbNetLog("STUN: pkt type=0x%04x magic=0x%08x txid_match=%d\n", + (unsigned)pkt_type, (unsigned)pkt_magic, txid_match); + if (pkt_type != STUN_BINDING_SUCCESS + || pkt_magic != STUN_MAGIC_COOKIE + || !txid_match) { + LbNetLog("STUN: packet discarded (expected type=0x%04x magic=0x%08x)\n", + (unsigned)STUN_BINDING_SUCCESS, (unsigned)STUN_MAGIC_COOKIE); continue; + } int offset = (int)sizeof(struct StunHeader); int attrs_end = offset + (int)ntohs(hdr->length); if (attrs_end > n) attrs_end = n; + LbNetLog("STUN: parsing attributes (attrs_end=%d)\n", attrs_end); char ip[64] = {0}; uint16_t ext_port = 0; while (offset + 4 <= attrs_end) { const struct StunAttrHeader *attr = (const struct StunAttrHeader *)(resp + offset); uint16_t atype = ntohs(attr->type); uint16_t alen = ntohs(attr->length); + LbNetLog("STUN: attribute type=0x%04x len=%u at offset=%d\n", + (unsigned)atype, (unsigned)alen, offset); offset += 4; if (atype == STUN_ATTR_XOR_MAPPED && alen >= 8 && offset + alen <= attrs_end && resp[offset + 1] == 0x01) { @@ -138,22 +162,29 @@ uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) snprintf(ip, sizeof(ip), "%u.%u.%u.%u", (addr >> 24) & 0xFFu, (addr >> 16) & 0xFFu, (addr >> 8) & 0xFFu, addr & 0xFFu); + LbNetLog("STUN: XOR-MAPPED-ADDRESS raw xor_port=0x%04x -> ext_port=%u, ip=%s\n", + (unsigned)xor_port, (unsigned)ext_port, ip); break; } offset += (alen + 3) & ~3; } - if (!ext_port) + if (!ext_port) { + LbNetLog("STUN: no XOR-MAPPED-ADDRESS found in response\n"); continue; - if (tmp_sock != ENET_SOCKET_NULL) + } + if (tmp_sock != ENET_SOCKET_NULL) { + LbNetLog("STUN: used fallback socket, overriding ext_port %u -> host port %u\n", + (unsigned)ext_port, (unsigned)host->address.port); ext_port = host->address.port; - LbNetLog("STUN: External address %s:%u\n", ip, (unsigned)ext_port); + } + LbNetLog("STUN: external address %s:%u\n", ip, (unsigned)ext_port); if (ip_out && ip_len > 0) snprintf(ip_out, ip_len, "%s", ip); result = ext_port; break; } if (!result) - LbNetLog("STUN: Failed to parse mapped address\n"); + LbNetLog("STUN: failed to obtain mapped address\n"); if (tmp_sock != ENET_SOCKET_NULL) enet_socket_destroy(tmp_sock); return result; @@ -161,8 +192,12 @@ uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) void holepunch_punch_to(ENetHost *host, const ENetAddress *target) { + LbNetLog("Holepunch: sending %d punch packets to port %u\n", + HOLE_PUNCH_COUNT, (unsigned)target->port); static const uint8_t payload[HOLE_PUNCH_PAYLOAD_SIZE] = {0}; ENetBuffer buf = {sizeof(payload), (void *)payload}; - for (int i = 0; i < HOLE_PUNCH_COUNT; i++) - enet_socket_send(host->socket, target, &buf, 1); + for (int i = 0; i < HOLE_PUNCH_COUNT; i++) { + int r = enet_socket_send(host->socket, target, &buf, 1); + LbNetLog("Holepunch: punch %d/%d result=%d\n", i + 1, HOLE_PUNCH_COUNT, r); + } } diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index a09ac0bb66..2415779ff6 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -51,6 +51,9 @@ int g_mm_session_count = 0; static void ws_cleanup(void) { + LbNetLog("Matchmaking: ws_cleanup (had curl: %s, lobby_id: %s)\n", + g_curl ? "yes" : "no", + g_hosted_lobby_id[0] ? g_hosted_lobby_id : "none"); curl_easy_cleanup(g_curl); g_curl = NULL; g_hosted_lobby_id[0] = '\0'; @@ -60,40 +63,50 @@ static void ws_cleanup(void) static int ws_send(const char *msg) { + LbNetLog("Matchmaking: ws_send: %s\n", msg); size_t sent = 0; CURLcode rc = curl_ws_send(g_curl, msg, strlen(msg), &sent, 0, CURLWS_TEXT); if (rc != CURLE_OK) { - LbNetLog("Matchmaking: ws_send failed: %s\n", curl_easy_strerror(rc)); + LbNetLog("Matchmaking: ws_send failed (%s)\n", curl_easy_strerror(rc)); ws_cleanup(); return -1; } + LbNetLog("Matchmaking: ws_send ok (%d bytes)\n", (int)sent); return 0; } static int ws_recv(char *buf, size_t bufsz, int timeout_ms) { curl_socket_t sock = CURL_SOCKET_BAD; - if (curl_easy_getinfo(g_curl, CURLINFO_ACTIVESOCKET, &sock) != CURLE_OK || sock == CURL_SOCKET_BAD) + if (curl_easy_getinfo(g_curl, CURLINFO_ACTIVESOCKET, &sock) != CURLE_OK || sock == CURL_SOCKET_BAD) { + LbNetLog("Matchmaking: ws_recv failed to get active socket\n"); return -1; + } fd_set fds; FD_ZERO(&fds); FD_SET((SOCKET)sock, &fds); struct timeval tv = { timeout_ms / 1000, (timeout_ms % 1000) * 1000 }; - if (select(0, &fds, NULL, NULL, &tv) <= 0) + if (select(0, &fds, NULL, NULL, &tv) <= 0) { + if (timeout_ms > 0) + LbNetLog("Matchmaking: ws_recv no data within %d ms\n", timeout_ms); return 0; + } size_t recvd = 0; const struct curl_ws_frame *frame = NULL; CURLcode rc = curl_ws_recv(g_curl, buf, bufsz - 1, &recvd, &frame); - if (rc == CURLE_AGAIN) + if (rc == CURLE_AGAIN) { + LbNetLog("Matchmaking: ws_recv CURLE_AGAIN\n"); return 0; + } if (rc != CURLE_OK) { - LbNetLog("Matchmaking: ws_recv failed: %s\n", curl_easy_strerror(rc)); + LbNetLog("Matchmaking: ws_recv failed (%s)\n", curl_easy_strerror(rc)); ws_cleanup(); return -1; } buf[recvd] = '\0'; + LbNetLog("Matchmaking: ws_recv got %d bytes: %s\n", (int)recvd, buf); return (int)recvd; } @@ -168,6 +181,7 @@ int matchmaking_connect(void) LeaveCriticalSection(&g_cs); return -1; } + LbNetLog("Matchmaking: connecting to %s\n", MATCHMAKING_URL); curl_easy_setopt(g_curl, CURLOPT_URL, MATCHMAKING_URL); curl_easy_setopt(g_curl, CURLOPT_CONNECT_ONLY, 2L); curl_easy_setopt(g_curl, CURLOPT_CONNECTTIMEOUT_MS, (long)CONNECT_TIMEOUT_MS); @@ -211,8 +225,9 @@ void matchmaking_refresh_sessions(void) return; } char buf[WS_BUF_SIZE]; - if (ws_exchange("{\"action\":\"list\",\"version\":\"" MATCHMAKING_VERSION "\"}", buf, sizeof(buf)) > 0 - && strstr(buf, "\"lobbies\"")) { + int list_n = ws_exchange("{\"action\":\"list\",\"version\":\"" MATCHMAKING_VERSION "\"}", buf, sizeof(buf)); + LbNetLog("Matchmaking: list response (%d bytes): %s\n", list_n, list_n > 0 ? buf : "(empty)"); + if (list_n > 0 && strstr(buf, "\"lobbies\"")) { int count = 0; const char *p = buf; while (count < MATCHMAKING_SESSIONS_MAX) { @@ -222,6 +237,7 @@ void matchmaking_refresh_sessions(void) if (!p) break; p = json_str(p, "name", name, sizeof(name)); if (!p) break; + LbNetLog("Matchmaking: session[%d] id=%s name=%s\n", count, id, name); struct TbNetworkSessionNameEntry *s = &g_mm_sessions[count++]; memset(s, 0, sizeof(*s)); s->joinable = 1; @@ -231,6 +247,7 @@ void matchmaking_refresh_sessions(void) snprintf(s->lobby_id, SESSION_LOBBY_ID_MAX_LEN, "%s", id); } g_mm_session_count = count; + LbNetLog("Matchmaking: parsed %d session(s)\n", count); } g_last_refresh_tick = GetTickCount(); LeaveCriticalSection(&g_cs); @@ -260,11 +277,14 @@ int matchmaking_create(const char *name, int udp_port, const char *ip) snprintf(msg, sizeof(msg), "{\"action\":\"create\",\"name\":\"%s\",\"port\":%d%s,\"version\":\"%s\"}", escaped_name, udp_port, ip_field, MATCHMAKING_VERSION); - if (ws_exchange(msg, buf, sizeof(buf)) <= 0) { + int create_n = ws_exchange(msg, buf, sizeof(buf)); + LbNetLog("Matchmaking: create response (%d bytes): %s\n", create_n, create_n > 0 ? buf : "(empty)"); + if (create_n <= 0) { LeaveCriticalSection(&g_cs); return -1; } if (!strstr(buf, "\"created\"") || !json_str(buf, "id", g_hosted_lobby_id, MATCHMAKING_ID_MAX)) { + LbNetLog("Matchmaking: create failed - unexpected response\n"); LeaveCriticalSection(&g_cs); return -1; } @@ -281,13 +301,16 @@ int matchmaking_punch(const char *lobby_id, int udp_port, char *out_ip, int *out snprintf(msg, sizeof(msg), "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d}", lobby_id, udp_port); - if (ws_exchange(msg, buf, sizeof(buf)) <= 0) { + int punch_n = ws_exchange(msg, buf, sizeof(buf)); + LbNetLog("Matchmaking: punch response (%d bytes): %s\n", punch_n, punch_n > 0 ? buf : "(empty)"); + if (punch_n <= 0) { LeaveCriticalSection(&g_cs); return -1; } if (!strstr(buf, "\"punch\"") || !json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) || !json_int(buf, "peerPort", out_port)) { + LbNetLog("Matchmaking: punch failed - unexpected response\n"); LeaveCriticalSection(&g_cs); return -1; } @@ -303,9 +326,18 @@ int matchmaking_poll_punch(char *out_ip, int *out_port) char buf[WS_BUF_SIZE]; int n = ws_recv(buf, sizeof(buf), 0); int got_punch = 0; - if (n > 0 && strstr(buf, "\"punch\"")) { - got_punch = json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) - && json_int(buf, "peerPort", out_port); + if (n > 0) { + LbNetLog("Matchmaking: poll_punch received %d bytes: %s\n", n, buf); + if (strstr(buf, "\"punch\"")) { + got_punch = json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) + && json_int(buf, "peerPort", out_port); + if (got_punch) + LbNetLog("Matchmaking: poll_punch -> %s:%d\n", out_ip, *out_port); + else + LbNetLog("Matchmaking: poll_punch parse failed\n"); + } else { + LbNetLog("Matchmaking: poll_punch ignored message (not a punch)\n"); + } } LeaveCriticalSection(&g_cs); return got_punch; From fa315be2bbd17748c2fb8447bbff6ec6bc022b69 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Sat, 7 Mar 2026 12:04:04 +1100 Subject: [PATCH 06/31] possible bugfix --- src/bflib_enet.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index 7378456979..d24ba686b5 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -105,14 +105,16 @@ namespace TbError bf_enet_host(const char *session, void *options) { ENetAddress address; - enet_address_build_any(&address, ENET_ADDRESS_TYPE_IPV6); + enet_address_build_any(&address, ENET_ADDRESS_TYPE_IPV4); address.port = DEFAULT_PORT; if (!*session) return Lb_FAIL; - int port = atoi(session); + const char *port_str = session; + if (*port_str == ':') port_str++; + int port = atoi(port_str); if (port > 0) address.port = port; - host = enet_host_create(ENET_ADDRESS_TYPE_ANY, &address, 4, NUM_CHANNELS, 0, 0); + host = enet_host_create(ENET_ADDRESS_TYPE_IPV4, &address, 4, NUM_CHANNELS, 0, 0); if (!host) { return Lb_FAIL; } From 24d29afb5455aab892850420c3b5e89035343f9d Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Sun, 8 Mar 2026 00:09:07 +1100 Subject: [PATCH 07/31] port fix --- src/bflib_enet.cpp | 5 ++--- src/bflib_enet.h | 2 +- src/bflib_network.cpp | 4 +++- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index d24ba686b5..9bf6aaeaa1 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -33,7 +33,6 @@ #include "post_inc.h" #define NUM_CHANNELS 2 -#define DEFAULT_PORT 5556 #define HOLEPUNCH_CONNECT_DELAY_MS 300 uint16_t g_external_port = 0; @@ -106,7 +105,7 @@ namespace { ENetAddress address; enet_address_build_any(&address, ENET_ADDRESS_TYPE_IPV4); - address.port = DEFAULT_PORT; + address.port = ENET_DEFAULT_PORT; if (!*session) return Lb_FAIL; const char *port_str = session; @@ -154,7 +153,7 @@ namespace enet_uint16 parse_session_address(const char *session, char *host_out, size_t host_size) { char *E; - enet_uint16 port = DEFAULT_PORT; + enet_uint16 port = ENET_DEFAULT_PORT; if (session[0] == '[') { const char *bracket_end = strchr(session, ']'); if (!bracket_end) { diff --git a/src/bflib_enet.h b/src/bflib_enet.h index d447fcffd8..ef173d9f5d 100644 --- a/src/bflib_enet.h +++ b/src/bflib_enet.h @@ -21,7 +21,7 @@ extern "C" { #endif -#define ENET_DEFAULT_PORT 5556 +#define ENET_DEFAULT_PORT 5765 #define EXTERNAL_IP_LEN 64 enum { diff --git a/src/bflib_network.cpp b/src/bflib_network.cpp index 708154cc09..ee03c2f1b6 100644 --- a/src/bflib_network.cpp +++ b/src/bflib_network.cpp @@ -140,7 +140,9 @@ TbError LbNetwork_Create(char *nsname_str, char *plyr_name, uint32_t *plyr_num, ERRORLOG("No network SP selected"); return Lb_FAIL; } - const char *port = ":5555"; + char default_port_buf[16]; + snprintf(default_port_buf, sizeof(default_port_buf), ":%u", (unsigned)ENET_DEFAULT_PORT); + const char *port = default_port_buf; char buf[16] = ""; if (ServerPort != 0) { snprintf(buf, sizeof(buf), "%d", ServerPort); From 3e3ec8b1fb1f82b2612ac54ba98d179ea069c380 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Sun, 8 Mar 2026 10:45:45 +1100 Subject: [PATCH 08/31] test fix --- src/bflib_enet.cpp | 5 +++-- src/net_matchmaking.c | 14 ++++++++++---- src/net_matchmaking.h | 2 +- 3 files changed, 14 insertions(+), 7 deletions(-) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index 9bf6aaeaa1..1f8615d577 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -206,11 +206,12 @@ namespace return Lb_FAIL; } LbNetLog("Join: created client host, local port=%u\n", (unsigned)host->address.port); - uint16_t ext_port = holepunch_stun_query(host, NULL, 0); + char ext_ip[MATCHMAKING_IP_MAX] = {0}; + uint16_t ext_port = holepunch_stun_query(host, ext_ip, sizeof(ext_ip)); LbNetLog("Join: STUN ext_port=%u\n", (unsigned)ext_port); char peer_ip[MATCHMAKING_IP_MAX] = {0}; int peer_port = 0; - if (matchmaking_punch(g_join_lobby_id, (int)ext_port, peer_ip, &peer_port) != 0) { + if (matchmaking_punch(g_join_lobby_id, (int)ext_port, ext_ip, peer_ip, &peer_port) != 0) { LbNetLog("Join: matchmaking_punch failed\n"); host_destroy(); return Lb_FAIL; diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index 2415779ff6..c811c079da 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -293,14 +293,20 @@ int matchmaking_create(const char *name, int udp_port, const char *ip) return 0; } -int matchmaking_punch(const char *lobby_id, int udp_port, char *out_ip, int *out_port) +int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, char *out_ip, int *out_port) { char msg[SEND_BUF_SIZE]; char buf[WS_BUF_SIZE]; EnterCriticalSection(&g_cs); - snprintf(msg, sizeof(msg), - "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d}", - lobby_id, udp_port); + if (udp_ip && udp_ip[0]) { + snprintf(msg, sizeof(msg), + "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d,\"udpIp\":\"%s\"}", + lobby_id, udp_port, udp_ip); + } else { + snprintf(msg, sizeof(msg), + "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d}", + lobby_id, udp_port); + } int punch_n = ws_exchange(msg, buf, sizeof(buf)); LbNetLog("Matchmaking: punch response (%d bytes): %s\n", punch_n, punch_n > 0 ? buf : "(empty)"); if (punch_n <= 0) { diff --git a/src/net_matchmaking.h b/src/net_matchmaking.h index c9713c87c6..94e3aca473 100644 --- a/src/net_matchmaking.h +++ b/src/net_matchmaking.h @@ -43,7 +43,7 @@ int matchmaking_connect(void); void matchmaking_disconnect(void); void matchmaking_refresh_sessions(void); int matchmaking_create(const char *name, int udp_port, const char *ip); -int matchmaking_punch(const char *lobby_id, int udp_port, char *out_ip, int *out_port); +int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, char *out_ip, int *out_port); int matchmaking_poll_punch(char *out_ip, int *out_port); #ifdef __cplusplus From 603c51a5ab00ff0c4ae88d181bb872380c013253 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Sun, 8 Mar 2026 11:49:26 +1100 Subject: [PATCH 09/31] big fix! --- src/net_matchmaking.c | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index c811c079da..91ca17e4ed 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -307,12 +307,31 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d}", lobby_id, udp_port); } - int punch_n = ws_exchange(msg, buf, sizeof(buf)); - LbNetLog("Matchmaking: punch response (%d bytes): %s\n", punch_n, punch_n > 0 ? buf : "(empty)"); - if (punch_n <= 0) { + if (ws_send(msg) != 0) { LeaveCriticalSection(&g_cs); return -1; } + int punch_n; + DWORD deadline = GetTickCount() + WS_RECV_TIMEOUT_MS; + for (;;) { + int remaining = (int)(deadline - GetTickCount()); + if (remaining <= 0) { + LbNetLog("Matchmaking: punch failed - timeout\n"); + LeaveCriticalSection(&g_cs); + return -1; + } + punch_n = ws_recv(buf, sizeof(buf), remaining); + LbNetLog("Matchmaking: punch response (%d bytes): %s\n", punch_n, punch_n > 0 ? buf : "(empty)"); + if (punch_n <= 0) { + LeaveCriticalSection(&g_cs); + return -1; + } + if (strstr(buf, "\"lobbies\"")) { + LbNetLog("Matchmaking: punch skipping lobbies message\n"); + continue; + } + break; + } if (!strstr(buf, "\"punch\"") || !json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) || !json_int(buf, "peerPort", out_port)) { From fdfbf0e55627d33131302aa914d2f1b9b5dfd101 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Mon, 9 Mar 2026 00:43:19 +1100 Subject: [PATCH 10/31] instant lobby update --- src/net_matchmaking.c | 14 +++++++------- src/net_matchmaking.h | 1 - 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index 91ca17e4ed..ea41c82fd4 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -219,13 +219,14 @@ void matchmaking_refresh_sessions(void) LeaveCriticalSection(&g_cs); return; } - DWORD now = GetTickCount(); - if (g_last_refresh_tick != 0 && (now - g_last_refresh_tick) < MATCHMAKING_REFRESH_MS) { - LeaveCriticalSection(&g_cs); - return; - } char buf[WS_BUF_SIZE]; - int list_n = ws_exchange("{\"action\":\"list\",\"version\":\"" MATCHMAKING_VERSION "\"}", buf, sizeof(buf)); + int list_n; + if (g_last_refresh_tick == 0) { + list_n = ws_exchange("{\"action\":\"list\",\"version\":\"" MATCHMAKING_VERSION "\"}", buf, sizeof(buf)); + g_last_refresh_tick = GetTickCount(); + } else { + list_n = ws_recv(buf, sizeof(buf), 0); + } LbNetLog("Matchmaking: list response (%d bytes): %s\n", list_n, list_n > 0 ? buf : "(empty)"); if (list_n > 0 && strstr(buf, "\"lobbies\"")) { int count = 0; @@ -249,7 +250,6 @@ void matchmaking_refresh_sessions(void) g_mm_session_count = count; LbNetLog("Matchmaking: parsed %d session(s)\n", count); } - g_last_refresh_tick = GetTickCount(); LeaveCriticalSection(&g_cs); } diff --git a/src/net_matchmaking.h b/src/net_matchmaking.h index 94e3aca473..7dbbc8e8d2 100644 --- a/src/net_matchmaking.h +++ b/src/net_matchmaking.h @@ -31,7 +31,6 @@ extern "C" { #define MATCHMAKING_IP_MAX 64 #define MATCHMAKING_NAME_MAX SESSION_NAME_MAX_LEN #define MATCHMAKING_SESSIONS_MAX 32 -#define MATCHMAKING_REFRESH_MS 5000 extern struct TbNetworkSessionNameEntry g_mm_sessions[MATCHMAKING_SESSIONS_MAX]; extern int g_mm_session_count; From 745a2ed264d3169cc5c6a67e3a03e3fc4bfd12dc Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Mon, 9 Mar 2026 05:48:48 +1100 Subject: [PATCH 11/31] refactor --- src/net_matchmaking.c | 32 +++++++++++++++----------------- 1 file changed, 15 insertions(+), 17 deletions(-) diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index ea41c82fd4..9d82271a25 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -38,6 +38,7 @@ #define WS_BUF_SIZE 8192 #define WS_RECV_TIMEOUT_MS 3000 #define SEND_BUF_SIZE 512 +#define IP_FIELD_SIZE 80 #define CONNECT_TIMEOUT_MS 5000 static CURL *g_curl = NULL; @@ -51,9 +52,7 @@ int g_mm_session_count = 0; static void ws_cleanup(void) { - LbNetLog("Matchmaking: ws_cleanup (had curl: %s, lobby_id: %s)\n", - g_curl ? "yes" : "no", - g_hosted_lobby_id[0] ? g_hosted_lobby_id : "none"); + LbNetLog("Matchmaking: ws_cleanup\n"); curl_easy_cleanup(g_curl); g_curl = NULL; g_hosted_lobby_id[0] = '\0'; @@ -71,7 +70,6 @@ static int ws_send(const char *msg) ws_cleanup(); return -1; } - LbNetLog("Matchmaking: ws_send ok (%d bytes)\n", (int)sent); return 0; } @@ -227,7 +225,8 @@ void matchmaking_refresh_sessions(void) } else { list_n = ws_recv(buf, sizeof(buf), 0); } - LbNetLog("Matchmaking: list response (%d bytes): %s\n", list_n, list_n > 0 ? buf : "(empty)"); + if (list_n > 0) + LbNetLog("Matchmaking: list response (%d bytes): %s\n", list_n, buf); if (list_n > 0 && strstr(buf, "\"lobbies\"")) { int count = 0; const char *p = buf; @@ -256,7 +255,7 @@ void matchmaking_refresh_sessions(void) int matchmaking_create(const char *name, int udp_port, const char *ip) { char escaped_name[MATCHMAKING_NAME_MAX * 2]; - char ip_field[80]; + char ip_field[IP_FIELD_SIZE]; char msg[SEND_BUF_SIZE]; char buf[WS_BUF_SIZE]; EnterCriticalSection(&g_cs); @@ -278,7 +277,8 @@ int matchmaking_create(const char *name, int udp_port, const char *ip) "{\"action\":\"create\",\"name\":\"%s\",\"port\":%d%s,\"version\":\"%s\"}", escaped_name, udp_port, ip_field, MATCHMAKING_VERSION); int create_n = ws_exchange(msg, buf, sizeof(buf)); - LbNetLog("Matchmaking: create response (%d bytes): %s\n", create_n, create_n > 0 ? buf : "(empty)"); + if (create_n > 0) + LbNetLog("Matchmaking: create response (%d bytes): %s\n", create_n, buf); if (create_n <= 0) { LeaveCriticalSection(&g_cs); return -1; @@ -298,15 +298,12 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch char msg[SEND_BUF_SIZE]; char buf[WS_BUF_SIZE]; EnterCriticalSection(&g_cs); - if (udp_ip && udp_ip[0]) { - snprintf(msg, sizeof(msg), - "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d,\"udpIp\":\"%s\"}", - lobby_id, udp_port, udp_ip); - } else { - snprintf(msg, sizeof(msg), - "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d}", - lobby_id, udp_port); - } + char ip_field[IP_FIELD_SIZE] = ""; + if (udp_ip && udp_ip[0]) + snprintf(ip_field, sizeof(ip_field), ",\"udpIp\":\"%s\"", udp_ip); + snprintf(msg, sizeof(msg), + "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d%s}", + lobby_id, udp_port, ip_field); if (ws_send(msg) != 0) { LeaveCriticalSection(&g_cs); return -1; @@ -321,7 +318,8 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch return -1; } punch_n = ws_recv(buf, sizeof(buf), remaining); - LbNetLog("Matchmaking: punch response (%d bytes): %s\n", punch_n, punch_n > 0 ? buf : "(empty)"); + if (punch_n > 0) + LbNetLog("Matchmaking: punch response (%d bytes): %s\n", punch_n, buf); if (punch_n <= 0) { LeaveCriticalSection(&g_cs); return -1; From 0f76e1753258c14a0a77773a61d4445c92d968cc Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Mon, 9 Mar 2026 11:00:03 +1100 Subject: [PATCH 12/31] correct port --- src/bflib_enet.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/bflib_enet.h b/src/bflib_enet.h index ef173d9f5d..d447fcffd8 100644 --- a/src/bflib_enet.h +++ b/src/bflib_enet.h @@ -21,7 +21,7 @@ extern "C" { #endif -#define ENET_DEFAULT_PORT 5765 +#define ENET_DEFAULT_PORT 5556 #define EXTERNAL_IP_LEN 64 enum { From 8256141c97098c93cb89fb5f7f0c8db539acc5e1 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Tue, 10 Mar 2026 13:44:03 +1100 Subject: [PATCH 13/31] enable upnp --- src/net_portforward.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/net_portforward.cpp b/src/net_portforward.cpp index e7a0660769..28d0743ad1 100644 --- a/src/net_portforward.cpp +++ b/src/net_portforward.cpp @@ -60,8 +60,8 @@ enum PortForwardMethod { static enum PortForwardMethod active_method = PORT_FORWARD_NONE; static uint16_t mapped_port = 0; -int upnp_enabled = 0; -int natpmp_enabled = 0; +int upnp_enabled = 1; +int natpmp_enabled = 1; static struct UPNPUrls upnp_urls; static struct IGDdatas upnp_data; From 177a2e134d56d72eba50ff3d094ff20015c1e687 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Tue, 10 Mar 2026 13:56:49 +1100 Subject: [PATCH 14/31] fix --- src/front_network.c | 1 - src/net_matchmaking.c | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/src/front_network.c b/src/front_network.c index 73ef5bd486..6a048c227a 100644 --- a/src/front_network.c +++ b/src/front_network.c @@ -480,7 +480,6 @@ void frontnet_service_setup(void) net_number_of_services++; } net_load_config_file(); - matchmaking_init(); } void frontnet_session_setup(void) diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index 9d82271a25..784cd6172b 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -162,6 +162,7 @@ static DWORD WINAPI connect_thread(LPVOID arg) void matchmaking_connect_async(void) { + matchmaking_init(); HANDLE h = CreateThread(NULL, 0, connect_thread, NULL, 0, NULL); if (h) CloseHandle(h); From dda5358de62b31db253ee69d0f54fa3fa8471bda Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Tue, 10 Mar 2026 14:07:47 +1100 Subject: [PATCH 15/31] fix --- src/bflib_enet.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index 1f8615d577..d2187799c6 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -232,11 +232,15 @@ namespace if (port == 0 || buf[0] == '\0') { return Lb_FAIL; } - if (enet_address_set_host(&connect_address, ENET_ADDRESS_TYPE_ANY, buf) < 0) { + ENetAddressType addr_type = ENET_ADDRESS_TYPE_IPV4; + if (strchr(buf, ':') != NULL) { + addr_type = ENET_ADDRESS_TYPE_IPV6; + } + if (enet_address_set_host(&connect_address, addr_type, buf) < 0) { return Lb_FAIL; } connect_address.port = port; - host = enet_host_create(connect_address.type, NULL, 4, NUM_CHANNELS, 0, 0); + host = enet_host_create(addr_type, NULL, 4, NUM_CHANNELS, 0, 0); if (!host) { return Lb_FAIL; } From bd4b1f8bf10d540c0767f4d20bc5ec3504643015 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 05:49:45 +1100 Subject: [PATCH 16/31] removed deps --- deps/libcurl/include/curl/curl.h | 3312 --------------------- deps/libcurl/include/curl/curlver.h | 79 - deps/libcurl/include/curl/easy.h | 125 - deps/libcurl/include/curl/header.h | 74 - deps/libcurl/include/curl/mprintf.h | 85 - deps/libcurl/include/curl/multi.h | 481 --- deps/libcurl/include/curl/options.h | 70 - deps/libcurl/include/curl/stdcheaders.h | 35 - deps/libcurl/include/curl/system.h | 440 --- deps/libcurl/include/curl/typecheck-gcc.h | 718 ----- deps/libcurl/include/curl/urlapi.h | 155 - deps/libcurl/include/curl/websockets.h | 84 - deps/libcurl/lib/libcurl.a | Bin 1123738 -> 0 bytes 13 files changed, 5658 deletions(-) delete mode 100644 deps/libcurl/include/curl/curl.h delete mode 100644 deps/libcurl/include/curl/curlver.h delete mode 100644 deps/libcurl/include/curl/easy.h delete mode 100644 deps/libcurl/include/curl/header.h delete mode 100644 deps/libcurl/include/curl/mprintf.h delete mode 100644 deps/libcurl/include/curl/multi.h delete mode 100644 deps/libcurl/include/curl/options.h delete mode 100644 deps/libcurl/include/curl/stdcheaders.h delete mode 100644 deps/libcurl/include/curl/system.h delete mode 100644 deps/libcurl/include/curl/typecheck-gcc.h delete mode 100644 deps/libcurl/include/curl/urlapi.h delete mode 100644 deps/libcurl/include/curl/websockets.h delete mode 100644 deps/libcurl/lib/libcurl.a diff --git a/deps/libcurl/include/curl/curl.h b/deps/libcurl/include/curl/curl.h deleted file mode 100644 index 84cf5f2f52..0000000000 --- a/deps/libcurl/include/curl/curl.h +++ /dev/null @@ -1,3312 +0,0 @@ -#ifndef CURLINC_CURL_H -#define CURLINC_CURL_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ - -/* - * If you have libcurl problems, all docs and details are found here: - * https://curl.se/libcurl/ - */ - -#ifdef CURL_NO_OLDIES -#define CURL_STRICTER /* not used since 8.11.0 */ -#endif - -/* Compile-time deprecation macros. */ -#if (defined(__GNUC__) && \ - ((__GNUC__ > 12) || ((__GNUC__ == 12) && (__GNUC_MINOR__ >= 1))) || \ - (defined(__clang__) && __clang_major__ >= 3) || \ - defined(__IAR_SYSTEMS_ICC__)) && \ - !defined(__INTEL_COMPILER) && \ - !defined(CURL_DISABLE_DEPRECATION) && !defined(BUILDING_LIBCURL) -#define CURL_DEPRECATED(version, message) \ - __attribute__((deprecated("since " # version ". " message))) -#if defined(__IAR_SYSTEMS_ICC__) -#define CURL_IGNORE_DEPRECATION(statements) \ - _Pragma("diag_suppress=Pe1444") \ - statements \ - _Pragma("diag_default=Pe1444") -#else -#define CURL_IGNORE_DEPRECATION(statements) \ - _Pragma("GCC diagnostic push") \ - _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \ - statements \ - _Pragma("GCC diagnostic pop") -#endif -#else -#define CURL_DEPRECATED(version, message) -#define CURL_IGNORE_DEPRECATION(statements) statements -#endif - -#include "curlver.h" /* libcurl version defines */ -#include "system.h" /* determine things runtime */ - -#include -#include - -#if defined(__FreeBSD__) || defined(__MidnightBSD__) -/* Needed for __FreeBSD_version or __MidnightBSD_version symbol definition */ -#include -#endif - -/* The include stuff here below is mainly for time_t! */ -#include -#include - -#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__) -#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || \ - defined(__LWIP_OPT_H__) || defined(LWIP_HDR_OPT_H)) -/* The check above prevents the winsock2.h inclusion if winsock.h already was - included, since they cannot co-exist without problems */ -#include -#include -#endif -#endif - -/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish - libc5-based Linux systems. Only include it on systems that are known to - require it! */ -#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \ - defined(__minix) || defined(__INTEGRITY) || \ - defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \ - defined(__CYGWIN__) || defined(AMIGA) || defined(__NuttX__) || \ - (defined(__FreeBSD_version) && (__FreeBSD_version < 800000)) || \ - (defined(__MidnightBSD_version) && (__MidnightBSD_version < 100000)) || \ - defined(__sun__) || defined(__serenity__) || defined(__vxworks__) -#include -#endif - -#if !defined(_WIN32) && !defined(_WIN32_WCE) -#include -#endif - -#if !defined(_WIN32) -#include -#endif - -/* Compatibility for non-Clang compilers */ -#ifndef __has_declspec_attribute -# define __has_declspec_attribute(x) 0 -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void CURL; -typedef void CURLSH; - -/* - * libcurl external API function linkage decorations. - */ - -#ifdef CURL_STATICLIB -# define CURL_EXTERN -#elif defined(_WIN32) || \ - (__has_declspec_attribute(dllexport) && \ - __has_declspec_attribute(dllimport)) -# if defined(BUILDING_LIBCURL) -# define CURL_EXTERN __declspec(dllexport) -# else -# define CURL_EXTERN __declspec(dllimport) -# endif -#elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS) -# define CURL_EXTERN CURL_EXTERN_SYMBOL -#else -# define CURL_EXTERN -#endif - -#ifndef curl_socket_typedef -/* socket typedef */ -#if defined(_WIN32) && !defined(__LWIP_OPT_H__) && !defined(LWIP_HDR_OPT_H) -typedef SOCKET curl_socket_t; -#define CURL_SOCKET_BAD INVALID_SOCKET -#else -typedef int curl_socket_t; -#define CURL_SOCKET_BAD -1 -#endif -#define curl_socket_typedef -#endif /* curl_socket_typedef */ - -/* enum for the different supported SSL backends */ -typedef enum { - CURLSSLBACKEND_NONE = 0, - CURLSSLBACKEND_OPENSSL = 1, - CURLSSLBACKEND_GNUTLS = 2, - CURLSSLBACKEND_NSS CURL_DEPRECATED(8.3.0, "") = 3, - CURLSSLBACKEND_OBSOLETE4 = 4, /* Was QSOSSL. */ - CURLSSLBACKEND_GSKIT CURL_DEPRECATED(8.3.0, "") = 5, - CURLSSLBACKEND_POLARSSL CURL_DEPRECATED(7.69.0, "") = 6, - CURLSSLBACKEND_WOLFSSL = 7, - CURLSSLBACKEND_SCHANNEL = 8, - CURLSSLBACKEND_SECURETRANSPORT = 9, - CURLSSLBACKEND_AXTLS CURL_DEPRECATED(7.61.0, "") = 10, - CURLSSLBACKEND_MBEDTLS = 11, - CURLSSLBACKEND_MESALINK CURL_DEPRECATED(7.82.0, "") = 12, - CURLSSLBACKEND_BEARSSL = 13, - CURLSSLBACKEND_RUSTLS = 14 -} curl_sslbackend; - -/* aliases for library clones and renames */ -#define CURLSSLBACKEND_AWSLC CURLSSLBACKEND_OPENSSL -#define CURLSSLBACKEND_BORINGSSL CURLSSLBACKEND_OPENSSL -#define CURLSSLBACKEND_LIBRESSL CURLSSLBACKEND_OPENSSL - -/* deprecated names: */ -#define CURLSSLBACKEND_CYASSL CURLSSLBACKEND_WOLFSSL -#define CURLSSLBACKEND_DARWINSSL CURLSSLBACKEND_SECURETRANSPORT - -struct curl_httppost { - struct curl_httppost *next; /* next entry in the list */ - char *name; /* pointer to allocated name */ - long namelength; /* length of name length */ - char *contents; /* pointer to allocated data contents */ - long contentslength; /* length of contents field, see also - CURL_HTTPPOST_LARGE */ - char *buffer; /* pointer to allocated buffer contents */ - long bufferlength; /* length of buffer field */ - char *contenttype; /* Content-Type */ - struct curl_slist *contentheader; /* list of extra headers for this form */ - struct curl_httppost *more; /* if one field name has more than one - file, this link should link to following - files */ - long flags; /* as defined below */ - -/* specified content is a filename */ -#define CURL_HTTPPOST_FILENAME (1<<0) -/* specified content is a filename */ -#define CURL_HTTPPOST_READFILE (1<<1) -/* name is only stored pointer do not free in formfree */ -#define CURL_HTTPPOST_PTRNAME (1<<2) -/* contents is only stored pointer do not free in formfree */ -#define CURL_HTTPPOST_PTRCONTENTS (1<<3) -/* upload file from buffer */ -#define CURL_HTTPPOST_BUFFER (1<<4) -/* upload file from pointer contents */ -#define CURL_HTTPPOST_PTRBUFFER (1<<5) -/* upload file contents by using the regular read callback to get the data and - pass the given pointer as custom pointer */ -#define CURL_HTTPPOST_CALLBACK (1<<6) -/* use size in 'contentlen', added in 7.46.0 */ -#define CURL_HTTPPOST_LARGE (1<<7) - - char *showfilename; /* The filename to show. If not set, the - actual filename will be used (if this - is a file part) */ - void *userp; /* custom pointer used for - HTTPPOST_CALLBACK posts */ - curl_off_t contentlen; /* alternative length of contents - field. Used if CURL_HTTPPOST_LARGE is - set. Added in 7.46.0 */ -}; - - -/* This is a return code for the progress callback that, when returned, will - signal libcurl to continue executing the default progress function */ -#define CURL_PROGRESSFUNC_CONTINUE 0x10000001 - -/* This is the CURLOPT_PROGRESSFUNCTION callback prototype. It is now - considered deprecated but was the only choice up until 7.31.0 */ -typedef int (*curl_progress_callback)(void *clientp, - double dltotal, - double dlnow, - double ultotal, - double ulnow); - -/* This is the CURLOPT_XFERINFOFUNCTION callback prototype. It was introduced - in 7.32.0, avoids the use of floating point numbers and provides more - detailed information. */ -typedef int (*curl_xferinfo_callback)(void *clientp, - curl_off_t dltotal, - curl_off_t dlnow, - curl_off_t ultotal, - curl_off_t ulnow); - -#ifndef CURL_MAX_READ_SIZE - /* The maximum receive buffer size configurable via CURLOPT_BUFFERSIZE. */ -#define CURL_MAX_READ_SIZE (10*1024*1024) -#endif - -#ifndef CURL_MAX_WRITE_SIZE - /* Tests have proven that 20K is a bad buffer size for uploads on Windows, - while 16K for some odd reason performed a lot better. We do the ifndef - check to allow this value to easier be changed at build time for those - who feel adventurous. The practical minimum is about 400 bytes since - libcurl uses a buffer of this size as a scratch area (unrelated to - network send operations). */ -#define CURL_MAX_WRITE_SIZE 16384 -#endif - -#ifndef CURL_MAX_HTTP_HEADER -/* The only reason to have a max limit for this is to avoid the risk of a bad - server feeding libcurl with a never-ending header that will cause reallocs - infinitely */ -#define CURL_MAX_HTTP_HEADER (100*1024) -#endif - -/* This is a magic return code for the write callback that, when returned, - will signal libcurl to pause receiving on the current transfer. */ -#define CURL_WRITEFUNC_PAUSE 0x10000001 - -/* This is a magic return code for the write callback that, when returned, - will signal an error from the callback. */ -#define CURL_WRITEFUNC_ERROR 0xFFFFFFFF - -typedef size_t (*curl_write_callback)(char *buffer, - size_t size, - size_t nitems, - void *outstream); - -/* This callback will be called when a new resolver request is made */ -typedef int (*curl_resolver_start_callback)(void *resolver_state, - void *reserved, void *userdata); - -/* enumeration of file types */ -typedef enum { - CURLFILETYPE_FILE = 0, - CURLFILETYPE_DIRECTORY, - CURLFILETYPE_SYMLINK, - CURLFILETYPE_DEVICE_BLOCK, - CURLFILETYPE_DEVICE_CHAR, - CURLFILETYPE_NAMEDPIPE, - CURLFILETYPE_SOCKET, - CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */ - - CURLFILETYPE_UNKNOWN /* should never occur */ -} curlfiletype; - -#define CURLFINFOFLAG_KNOWN_FILENAME (1<<0) -#define CURLFINFOFLAG_KNOWN_FILETYPE (1<<1) -#define CURLFINFOFLAG_KNOWN_TIME (1<<2) -#define CURLFINFOFLAG_KNOWN_PERM (1<<3) -#define CURLFINFOFLAG_KNOWN_UID (1<<4) -#define CURLFINFOFLAG_KNOWN_GID (1<<5) -#define CURLFINFOFLAG_KNOWN_SIZE (1<<6) -#define CURLFINFOFLAG_KNOWN_HLINKCOUNT (1<<7) - -/* Information about a single file, used when doing FTP wildcard matching */ -struct curl_fileinfo { - char *filename; - curlfiletype filetype; - time_t time; /* always zero! */ - unsigned int perm; - int uid; - int gid; - curl_off_t size; - long int hardlinks; - - struct { - /* If some of these fields is not NULL, it is a pointer to b_data. */ - char *time; - char *perm; - char *user; - char *group; - char *target; /* pointer to the target filename of a symlink */ - } strings; - - unsigned int flags; - - /* These are libcurl private struct fields. Previously used by libcurl, so - they must never be interfered with. */ - char *b_data; - size_t b_size; - size_t b_used; -}; - -/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */ -#define CURL_CHUNK_BGN_FUNC_OK 0 -#define CURL_CHUNK_BGN_FUNC_FAIL 1 /* tell the lib to end the task */ -#define CURL_CHUNK_BGN_FUNC_SKIP 2 /* skip this chunk over */ - -/* if splitting of data transfer is enabled, this callback is called before - download of an individual chunk started. Note that parameter "remains" works - only for FTP wildcard downloading (for now), otherwise is not used */ -typedef long (*curl_chunk_bgn_callback)(const void *transfer_info, - void *ptr, - int remains); - -/* return codes for CURLOPT_CHUNK_END_FUNCTION */ -#define CURL_CHUNK_END_FUNC_OK 0 -#define CURL_CHUNK_END_FUNC_FAIL 1 /* tell the lib to end the task */ - -/* If splitting of data transfer is enabled this callback is called after - download of an individual chunk finished. - Note! After this callback was set then it have to be called FOR ALL chunks. - Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC. - This is the reason why we do not need "transfer_info" parameter in this - callback and we are not interested in "remains" parameter too. */ -typedef long (*curl_chunk_end_callback)(void *ptr); - -/* return codes for FNMATCHFUNCTION */ -#define CURL_FNMATCHFUNC_MATCH 0 /* string corresponds to the pattern */ -#define CURL_FNMATCHFUNC_NOMATCH 1 /* pattern does not match the string */ -#define CURL_FNMATCHFUNC_FAIL 2 /* an error occurred */ - -/* callback type for wildcard downloading pattern matching. If the - string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */ -typedef int (*curl_fnmatch_callback)(void *ptr, - const char *pattern, - const char *string); - -/* These are the return codes for the seek callbacks */ -#define CURL_SEEKFUNC_OK 0 -#define CURL_SEEKFUNC_FAIL 1 /* fail the entire transfer */ -#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking cannot be done, so - libcurl might try other means instead */ -typedef int (*curl_seek_callback)(void *instream, - curl_off_t offset, - int origin); /* 'whence' */ - -/* This is a return code for the read callback that, when returned, will - signal libcurl to immediately abort the current transfer. */ -#define CURL_READFUNC_ABORT 0x10000000 -/* This is a return code for the read callback that, when returned, will - signal libcurl to pause sending data on the current transfer. */ -#define CURL_READFUNC_PAUSE 0x10000001 - -/* Return code for when the trailing headers' callback has terminated - without any errors */ -#define CURL_TRAILERFUNC_OK 0 -/* Return code for when was an error in the trailing header's list and we - want to abort the request */ -#define CURL_TRAILERFUNC_ABORT 1 - -typedef size_t (*curl_read_callback)(char *buffer, - size_t size, - size_t nitems, - void *instream); - -typedef int (*curl_trailer_callback)(struct curl_slist **list, - void *userdata); - -typedef enum { - CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */ - CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */ - CURLSOCKTYPE_LAST /* never use */ -} curlsocktype; - -/* The return code from the sockopt_callback can signal information back - to libcurl: */ -#define CURL_SOCKOPT_OK 0 -#define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return - CURLE_ABORTED_BY_CALLBACK */ -#define CURL_SOCKOPT_ALREADY_CONNECTED 2 - -typedef int (*curl_sockopt_callback)(void *clientp, - curl_socket_t curlfd, - curlsocktype purpose); - -struct curl_sockaddr { - int family; - int socktype; - int protocol; - unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it - turned really ugly and painful on the systems that - lack this type */ - struct sockaddr addr; -}; - -typedef curl_socket_t -(*curl_opensocket_callback)(void *clientp, - curlsocktype purpose, - struct curl_sockaddr *address); - -typedef int -(*curl_closesocket_callback)(void *clientp, curl_socket_t item); - -typedef enum { - CURLIOE_OK, /* I/O operation successful */ - CURLIOE_UNKNOWNCMD, /* command was unknown to callback */ - CURLIOE_FAILRESTART, /* failed to restart the read */ - CURLIOE_LAST /* never use */ -} curlioerr; - -typedef enum { - CURLIOCMD_NOP, /* no operation */ - CURLIOCMD_RESTARTREAD, /* restart the read stream from start */ - CURLIOCMD_LAST /* never use */ -} curliocmd; - -typedef curlioerr (*curl_ioctl_callback)(CURL *handle, - int cmd, - void *clientp); - -#ifndef CURL_DID_MEMORY_FUNC_TYPEDEFS -/* - * The following typedef's are signatures of malloc, free, realloc, strdup and - * calloc respectively. Function pointers of these types can be passed to the - * curl_global_init_mem() function to set user defined memory management - * callback routines. - */ -typedef void *(*curl_malloc_callback)(size_t size); -typedef void (*curl_free_callback)(void *ptr); -typedef void *(*curl_realloc_callback)(void *ptr, size_t size); -typedef char *(*curl_strdup_callback)(const char *str); -typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size); - -#define CURL_DID_MEMORY_FUNC_TYPEDEFS -#endif - -/* the kind of data that is passed to information_callback */ -typedef enum { - CURLINFO_TEXT = 0, - CURLINFO_HEADER_IN, /* 1 */ - CURLINFO_HEADER_OUT, /* 2 */ - CURLINFO_DATA_IN, /* 3 */ - CURLINFO_DATA_OUT, /* 4 */ - CURLINFO_SSL_DATA_IN, /* 5 */ - CURLINFO_SSL_DATA_OUT, /* 6 */ - CURLINFO_END -} curl_infotype; - -typedef int (*curl_debug_callback) - (CURL *handle, /* the handle/transfer this concerns */ - curl_infotype type, /* what kind of data */ - char *data, /* points to the data */ - size_t size, /* size of the data pointed to */ - void *userptr); /* whatever the user please */ - -/* This is the CURLOPT_PREREQFUNCTION callback prototype. */ -typedef int (*curl_prereq_callback)(void *clientp, - char *conn_primary_ip, - char *conn_local_ip, - int conn_primary_port, - int conn_local_port); - -/* Return code for when the pre-request callback has terminated without - any errors */ -#define CURL_PREREQFUNC_OK 0 -/* Return code for when the pre-request callback wants to abort the - request */ -#define CURL_PREREQFUNC_ABORT 1 - -/* All possible error codes from all sorts of curl functions. Future versions - may return other values, stay prepared. - - Always add new return codes last. Never *EVER* remove any. The return - codes must remain the same! - */ - -typedef enum { - CURLE_OK = 0, - CURLE_UNSUPPORTED_PROTOCOL, /* 1 */ - CURLE_FAILED_INIT, /* 2 */ - CURLE_URL_MALFORMAT, /* 3 */ - CURLE_NOT_BUILT_IN, /* 4 - [was obsoleted in August 2007 for - 7.17.0, reused in April 2011 for 7.21.5] */ - CURLE_COULDNT_RESOLVE_PROXY, /* 5 */ - CURLE_COULDNT_RESOLVE_HOST, /* 6 */ - CURLE_COULDNT_CONNECT, /* 7 */ - CURLE_WEIRD_SERVER_REPLY, /* 8 */ - CURLE_REMOTE_ACCESS_DENIED, /* 9 a service was denied by the server - due to lack of access - when login fails - this is not returned. */ - CURLE_FTP_ACCEPT_FAILED, /* 10 - [was obsoleted in April 2006 for - 7.15.4, reused in Dec 2011 for 7.24.0]*/ - CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */ - CURLE_FTP_ACCEPT_TIMEOUT, /* 12 - timeout occurred accepting server - [was obsoleted in August 2007 for 7.17.0, - reused in Dec 2011 for 7.24.0]*/ - CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */ - CURLE_FTP_WEIRD_227_FORMAT, /* 14 */ - CURLE_FTP_CANT_GET_HOST, /* 15 */ - CURLE_HTTP2, /* 16 - A problem in the http2 framing layer. - [was obsoleted in August 2007 for 7.17.0, - reused in July 2014 for 7.38.0] */ - CURLE_FTP_COULDNT_SET_TYPE, /* 17 */ - CURLE_PARTIAL_FILE, /* 18 */ - CURLE_FTP_COULDNT_RETR_FILE, /* 19 */ - CURLE_OBSOLETE20, /* 20 - NOT USED */ - CURLE_QUOTE_ERROR, /* 21 - quote command failure */ - CURLE_HTTP_RETURNED_ERROR, /* 22 */ - CURLE_WRITE_ERROR, /* 23 */ - CURLE_OBSOLETE24, /* 24 - NOT USED */ - CURLE_UPLOAD_FAILED, /* 25 - failed upload "command" */ - CURLE_READ_ERROR, /* 26 - could not open/read from file */ - CURLE_OUT_OF_MEMORY, /* 27 */ - CURLE_OPERATION_TIMEDOUT, /* 28 - the timeout time was reached */ - CURLE_OBSOLETE29, /* 29 - NOT USED */ - CURLE_FTP_PORT_FAILED, /* 30 - FTP PORT operation failed */ - CURLE_FTP_COULDNT_USE_REST, /* 31 - the REST command failed */ - CURLE_OBSOLETE32, /* 32 - NOT USED */ - CURLE_RANGE_ERROR, /* 33 - RANGE "command" did not work */ - CURLE_OBSOLETE34, /* 34 */ - CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */ - CURLE_BAD_DOWNLOAD_RESUME, /* 36 - could not resume download */ - CURLE_FILE_COULDNT_READ_FILE, /* 37 */ - CURLE_LDAP_CANNOT_BIND, /* 38 */ - CURLE_LDAP_SEARCH_FAILED, /* 39 */ - CURLE_OBSOLETE40, /* 40 - NOT USED */ - CURLE_OBSOLETE41, /* 41 - NOT USED starting with 7.53.0 */ - CURLE_ABORTED_BY_CALLBACK, /* 42 */ - CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */ - CURLE_OBSOLETE44, /* 44 - NOT USED */ - CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */ - CURLE_OBSOLETE46, /* 46 - NOT USED */ - CURLE_TOO_MANY_REDIRECTS, /* 47 - catch endless re-direct loops */ - CURLE_UNKNOWN_OPTION, /* 48 - User specified an unknown option */ - CURLE_SETOPT_OPTION_SYNTAX, /* 49 - Malformed setopt option */ - CURLE_OBSOLETE50, /* 50 - NOT USED */ - CURLE_OBSOLETE51, /* 51 - NOT USED */ - CURLE_GOT_NOTHING, /* 52 - when this is a specific error */ - CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */ - CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as - default */ - CURLE_SEND_ERROR, /* 55 - failed sending network data */ - CURLE_RECV_ERROR, /* 56 - failure in receiving network data */ - CURLE_OBSOLETE57, /* 57 - NOT IN USE */ - CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */ - CURLE_SSL_CIPHER, /* 59 - could not use specified cipher */ - CURLE_PEER_FAILED_VERIFICATION, /* 60 - peer's certificate or fingerprint - was not verified fine */ - CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */ - CURLE_OBSOLETE62, /* 62 - NOT IN USE since 7.82.0 */ - CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */ - CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */ - CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind - that failed */ - CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */ - CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not - accepted and we failed to login */ - CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */ - CURLE_TFTP_PERM, /* 69 - permission problem on server */ - CURLE_REMOTE_DISK_FULL, /* 70 - out of disk space on server */ - CURLE_TFTP_ILLEGAL, /* 71 - Illegal TFTP operation */ - CURLE_TFTP_UNKNOWNID, /* 72 - Unknown transfer ID */ - CURLE_REMOTE_FILE_EXISTS, /* 73 - File already exists */ - CURLE_TFTP_NOSUCHUSER, /* 74 - No such user */ - CURLE_OBSOLETE75, /* 75 - NOT IN USE since 7.82.0 */ - CURLE_OBSOLETE76, /* 76 - NOT IN USE since 7.82.0 */ - CURLE_SSL_CACERT_BADFILE, /* 77 - could not load CACERT file, missing - or wrong format */ - CURLE_REMOTE_FILE_NOT_FOUND, /* 78 - remote file not found */ - CURLE_SSH, /* 79 - error from the SSH layer, somewhat - generic so the error message will be of - interest when this has happened */ - - CURLE_SSL_SHUTDOWN_FAILED, /* 80 - Failed to shut down the SSL - connection */ - CURLE_AGAIN, /* 81 - socket is not ready for send/recv, - wait till it is ready and try again (Added - in 7.18.2) */ - CURLE_SSL_CRL_BADFILE, /* 82 - could not load CRL file, missing or - wrong format (Added in 7.19.0) */ - CURLE_SSL_ISSUER_ERROR, /* 83 - Issuer check failed. (Added in - 7.19.0) */ - CURLE_FTP_PRET_FAILED, /* 84 - a PRET command failed */ - CURLE_RTSP_CSEQ_ERROR, /* 85 - mismatch of RTSP CSeq numbers */ - CURLE_RTSP_SESSION_ERROR, /* 86 - mismatch of RTSP Session Ids */ - CURLE_FTP_BAD_FILE_LIST, /* 87 - unable to parse FTP file list */ - CURLE_CHUNK_FAILED, /* 88 - chunk callback reported error */ - CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the - session will be queued */ - CURLE_SSL_PINNEDPUBKEYNOTMATCH, /* 90 - specified pinned public key did not - match */ - CURLE_SSL_INVALIDCERTSTATUS, /* 91 - invalid certificate status */ - CURLE_HTTP2_STREAM, /* 92 - stream error in HTTP/2 framing layer - */ - CURLE_RECURSIVE_API_CALL, /* 93 - an api function was called from - inside a callback */ - CURLE_AUTH_ERROR, /* 94 - an authentication function returned an - error */ - CURLE_HTTP3, /* 95 - An HTTP/3 layer problem */ - CURLE_QUIC_CONNECT_ERROR, /* 96 - QUIC connection error */ - CURLE_PROXY, /* 97 - proxy handshake error */ - CURLE_SSL_CLIENTCERT, /* 98 - client-side certificate required */ - CURLE_UNRECOVERABLE_POLL, /* 99 - poll/select returned fatal error */ - CURLE_TOO_LARGE, /* 100 - a value/data met its maximum */ - CURLE_ECH_REQUIRED, /* 101 - ECH tried but failed */ - CURL_LAST /* never use! */ -} CURLcode; - -#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all - the obsolete stuff removed! */ - -/* removed in 7.53.0 */ -#define CURLE_FUNCTION_NOT_FOUND CURLE_OBSOLETE41 - -/* removed in 7.56.0 */ -#define CURLE_HTTP_POST_ERROR CURLE_OBSOLETE34 - -/* Previously obsolete error code reused in 7.38.0 */ -#define CURLE_OBSOLETE16 CURLE_HTTP2 - -/* Previously obsolete error codes reused in 7.24.0 */ -#define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED -#define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT - -/* compatibility with older names */ -#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING -#define CURLE_FTP_WEIRD_SERVER_REPLY CURLE_WEIRD_SERVER_REPLY - -/* The following were added in 7.62.0 */ -#define CURLE_SSL_CACERT CURLE_PEER_FAILED_VERIFICATION - -/* The following were added in 7.21.5, April 2011 */ -#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION - -/* Added for 7.78.0 */ -#define CURLE_TELNET_OPTION_SYNTAX CURLE_SETOPT_OPTION_SYNTAX - -/* The following were added in 7.17.1 */ -/* These are scheduled to disappear by 2009 */ -#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION - -/* The following were added in 7.17.0 */ -/* These are scheduled to disappear by 2009 */ -#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */ -#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46 -#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44 -#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10 -#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16 -#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32 -#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29 -#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12 -#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20 -#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40 -#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24 -#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57 -#define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN - -#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED -#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE -#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR -#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL -#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS -#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR -#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED - -/* The following were added earlier */ - -#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT -#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR -#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED -#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED -#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE -#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME -#define CURLE_LDAP_INVALID_URL CURLE_OBSOLETE62 -#define CURLE_CONV_REQD CURLE_OBSOLETE76 -#define CURLE_CONV_FAILED CURLE_OBSOLETE75 - -/* This was the error code 50 in 7.7.3 and a few earlier versions, this - is no longer used by libcurl but is instead #defined here only to not - make programs break */ -#define CURLE_ALREADY_COMPLETE 99999 - -/* Provide defines for really old option names */ -#define CURLOPT_FILE CURLOPT_WRITEDATA /* name changed in 7.9.7 */ -#define CURLOPT_INFILE CURLOPT_READDATA /* name changed in 7.9.7 */ -#define CURLOPT_WRITEHEADER CURLOPT_HEADERDATA - -/* Since long deprecated options with no code in the lib that does anything - with them. */ -#define CURLOPT_WRITEINFO CURLOPT_OBSOLETE40 -#define CURLOPT_CLOSEPOLICY CURLOPT_OBSOLETE72 -#define CURLOPT_OBSOLETE72 9999 -#define CURLOPT_OBSOLETE40 9999 - -#endif /* !CURL_NO_OLDIES */ - -/* - * Proxy error codes. Returned in CURLINFO_PROXY_ERROR if CURLE_PROXY was - * return for the transfers. - */ -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; - -/* This prototype applies to all conversion callbacks */ -typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length); - -typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */ - void *ssl_ctx, /* actually an OpenSSL - or wolfSSL SSL_CTX, - or an mbedTLS - mbedtls_ssl_config */ - void *userptr); - -typedef enum { - CURLPROXY_HTTP = 0, /* added in 7.10, new in 7.19.4 default is to use - CONNECT HTTP/1.1 */ - CURLPROXY_HTTP_1_0 = 1, /* added in 7.19.4, force to use CONNECT - HTTP/1.0 */ - CURLPROXY_HTTPS = 2, /* HTTPS but stick to HTTP/1 added in 7.52.0 */ - CURLPROXY_HTTPS2 = 3, /* HTTPS and attempt HTTP/2 added in 8.2.0 */ - CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already - in 7.10 */ - CURLPROXY_SOCKS5 = 5, /* added in 7.10 */ - CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */ - CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the - hostname rather than the IP address. added - in 7.18.0 */ -} curl_proxytype; /* this enum was added in 7.10 */ - -/* - * Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options: - * - * CURLAUTH_NONE - No HTTP authentication - * CURLAUTH_BASIC - HTTP Basic authentication (default) - * CURLAUTH_DIGEST - HTTP Digest authentication - * CURLAUTH_NEGOTIATE - HTTP Negotiate (SPNEGO) authentication - * CURLAUTH_GSSNEGOTIATE - Alias for CURLAUTH_NEGOTIATE (deprecated) - * CURLAUTH_NTLM - HTTP NTLM authentication - * CURLAUTH_DIGEST_IE - HTTP Digest authentication with IE flavour - * CURLAUTH_NTLM_WB - HTTP NTLM authentication delegated to winbind helper - * CURLAUTH_BEARER - HTTP Bearer token authentication - * CURLAUTH_ONLY - Use together with a single other type to force no - * authentication or just that single type - * CURLAUTH_ANY - All fine types set - * CURLAUTH_ANYSAFE - All fine types except Basic - */ - -#define CURLAUTH_NONE ((unsigned long)0) -#define CURLAUTH_BASIC (((unsigned long)1)<<0) -#define CURLAUTH_DIGEST (((unsigned long)1)<<1) -#define CURLAUTH_NEGOTIATE (((unsigned long)1)<<2) -/* Deprecated since the advent of CURLAUTH_NEGOTIATE */ -#define CURLAUTH_GSSNEGOTIATE CURLAUTH_NEGOTIATE -/* Used for CURLOPT_SOCKS5_AUTH to stay terminologically correct */ -#define CURLAUTH_GSSAPI CURLAUTH_NEGOTIATE -#define CURLAUTH_NTLM (((unsigned long)1)<<3) -#define CURLAUTH_DIGEST_IE (((unsigned long)1)<<4) -#ifndef CURL_NO_OLDIES - /* functionality removed since 8.8.0 */ -#define CURLAUTH_NTLM_WB (((unsigned long)1)<<5) -#endif -#define CURLAUTH_BEARER (((unsigned long)1)<<6) -#define CURLAUTH_AWS_SIGV4 (((unsigned long)1)<<7) -#define CURLAUTH_ONLY (((unsigned long)1)<<31) -#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE) -#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE)) - -#define CURLSSH_AUTH_ANY ~0 /* all types supported by the server */ -#define CURLSSH_AUTH_NONE 0 /* none allowed, silly but complete */ -#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */ -#define CURLSSH_AUTH_PASSWORD (1<<1) /* password */ -#define CURLSSH_AUTH_HOST (1<<2) /* host key files */ -#define CURLSSH_AUTH_KEYBOARD (1<<3) /* keyboard interactive */ -#define CURLSSH_AUTH_AGENT (1<<4) /* agent (ssh-agent, pageant...) */ -#define CURLSSH_AUTH_GSSAPI (1<<5) /* gssapi (kerberos, ...) */ -#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY - -#define CURLGSSAPI_DELEGATION_NONE 0 /* no delegation (default) */ -#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */ -#define CURLGSSAPI_DELEGATION_FLAG (1<<1) /* delegate always */ - -#define CURL_ERROR_SIZE 256 - -enum curl_khtype { - CURLKHTYPE_UNKNOWN, - CURLKHTYPE_RSA1, - CURLKHTYPE_RSA, - CURLKHTYPE_DSS, - CURLKHTYPE_ECDSA, - CURLKHTYPE_ED25519 -}; - -struct curl_khkey { - const char *key; /* points to a null-terminated string encoded with base64 - if len is zero, otherwise to the "raw" data */ - size_t len; - enum curl_khtype keytype; -}; - -/* this is the set of return values expected from the curl_sshkeycallback - callback */ -enum curl_khstat { - CURLKHSTAT_FINE_ADD_TO_FILE, - CURLKHSTAT_FINE, - CURLKHSTAT_REJECT, /* reject the connection, return an error */ - CURLKHSTAT_DEFER, /* do not accept it, but we cannot answer right now. - Causes a CURLE_PEER_FAILED_VERIFICATION error but the - connection will be left intact etc */ - CURLKHSTAT_FINE_REPLACE, /* accept and replace the wrong key */ - CURLKHSTAT_LAST /* not for use, only a marker for last-in-list */ -}; - -/* this is the set of status codes pass in to the callback */ -enum curl_khmatch { - CURLKHMATCH_OK, /* match */ - CURLKHMATCH_MISMATCH, /* host found, key mismatch! */ - CURLKHMATCH_MISSING, /* no matching host/key found */ - CURLKHMATCH_LAST /* not for use, only a marker for last-in-list */ -}; - -typedef int - (*curl_sshkeycallback) (CURL *easy, /* easy handle */ - const struct curl_khkey *knownkey, /* known */ - const struct curl_khkey *foundkey, /* found */ - enum curl_khmatch, /* libcurl's view on the keys */ - void *clientp); /* custom pointer passed with */ - /* CURLOPT_SSH_KEYDATA */ - -typedef int - (*curl_sshhostkeycallback) (void *clientp,/* custom pointer passed */ - /* with CURLOPT_SSH_HOSTKEYDATA */ - int keytype, /* CURLKHTYPE */ - const char *key, /* hostkey to check */ - size_t keylen); /* length of the key */ - /* return CURLE_OK to accept */ - /* or something else to refuse */ - - -/* parameter for the CURLOPT_USE_SSL option */ -typedef enum { - CURLUSESSL_NONE, /* do not attempt to use SSL */ - CURLUSESSL_TRY, /* try using SSL, proceed anyway otherwise */ - CURLUSESSL_CONTROL, /* SSL for the control connection or fail */ - CURLUSESSL_ALL, /* SSL for all communication or fail */ - CURLUSESSL_LAST /* not an option, never use */ -} curl_usessl; - -/* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */ - -/* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the - name of improving interoperability with older servers. Some SSL libraries - have introduced work-arounds for this flaw but those work-arounds sometimes - make the SSL communication fail. To regain functionality with those broken - servers, a user can this way allow the vulnerability back. */ -#define CURLSSLOPT_ALLOW_BEAST (1<<0) - -/* - NO_REVOKE tells libcurl to disable certificate revocation checks for those - SSL backends where such behavior is present. */ -#define CURLSSLOPT_NO_REVOKE (1<<1) - -/* - NO_PARTIALCHAIN tells libcurl to *NOT* accept a partial certificate chain - if possible. The OpenSSL backend has this ability. */ -#define CURLSSLOPT_NO_PARTIALCHAIN (1<<2) - -/* - REVOKE_BEST_EFFORT tells libcurl to ignore certificate revocation offline - checks and ignore missing revocation list for those SSL backends where such - behavior is present. */ -#define CURLSSLOPT_REVOKE_BEST_EFFORT (1<<3) - -/* - CURLSSLOPT_NATIVE_CA tells libcurl to use standard certificate store of - operating system. Currently implemented under MS-Windows. */ -#define CURLSSLOPT_NATIVE_CA (1<<4) - -/* - CURLSSLOPT_AUTO_CLIENT_CERT tells libcurl to automatically locate and use - a client certificate for authentication. (Schannel) */ -#define CURLSSLOPT_AUTO_CLIENT_CERT (1<<5) - -/* If possible, send data using TLS 1.3 early data */ -#define CURLSSLOPT_EARLYDATA (1<<6) - -/* The default connection attempt delay in milliseconds for happy eyeballs. - CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS.3 and happy-eyeballs-timeout-ms.d document - this value, keep them in sync. */ -#define CURL_HET_DEFAULT 200L - -/* The default connection upkeep interval in milliseconds. */ -#define CURL_UPKEEP_INTERVAL_DEFAULT 60000L - -#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all - the obsolete stuff removed! */ - -/* Backwards compatibility with older names */ -/* These are scheduled to disappear by 2009 */ - -#define CURLFTPSSL_NONE CURLUSESSL_NONE -#define CURLFTPSSL_TRY CURLUSESSL_TRY -#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL -#define CURLFTPSSL_ALL CURLUSESSL_ALL -#define CURLFTPSSL_LAST CURLUSESSL_LAST -#define curl_ftpssl curl_usessl -#endif /* !CURL_NO_OLDIES */ - -/* parameter for the CURLOPT_FTP_SSL_CCC option */ -typedef enum { - CURLFTPSSL_CCC_NONE, /* do not send CCC */ - CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */ - CURLFTPSSL_CCC_ACTIVE, /* Initiate the shutdown */ - CURLFTPSSL_CCC_LAST /* not an option, never use */ -} curl_ftpccc; - -/* parameter for the CURLOPT_FTPSSLAUTH option */ -typedef enum { - CURLFTPAUTH_DEFAULT, /* let libcurl decide */ - CURLFTPAUTH_SSL, /* use "AUTH SSL" */ - CURLFTPAUTH_TLS, /* use "AUTH TLS" */ - CURLFTPAUTH_LAST /* not an option, never use */ -} curl_ftpauth; - -/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */ -typedef enum { - CURLFTP_CREATE_DIR_NONE, /* do NOT create missing dirs! */ - CURLFTP_CREATE_DIR, /* (FTP/SFTP) if CWD fails, try MKD and then CWD - again if MKD succeeded, for SFTP this does - similar magic */ - CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD - again even if MKD failed! */ - CURLFTP_CREATE_DIR_LAST /* not an option, never use */ -} curl_ftpcreatedir; - -/* parameter for the CURLOPT_FTP_FILEMETHOD option */ -typedef enum { - CURLFTPMETHOD_DEFAULT, /* let libcurl pick */ - CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */ - CURLFTPMETHOD_NOCWD, /* no CWD at all */ - CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */ - CURLFTPMETHOD_LAST /* not an option, never use */ -} curl_ftpmethod; - -/* bitmask defines for CURLOPT_HEADEROPT */ -#define CURLHEADER_UNIFIED 0 -#define CURLHEADER_SEPARATE (1<<0) - -/* CURLALTSVC_* are bits for the CURLOPT_ALTSVC_CTRL option */ -#define CURLALTSVC_READONLYFILE (1<<2) -#define CURLALTSVC_H1 (1<<3) -#define CURLALTSVC_H2 (1<<4) -#define CURLALTSVC_H3 (1<<5) - - -struct curl_hstsentry { - char *name; - size_t namelen; - unsigned int includeSubDomains:1; - char expire[18]; /* YYYYMMDD HH:MM:SS [null-terminated] */ -}; - -struct curl_index { - size_t index; /* the provided entry's "index" or count */ - size_t total; /* total number of entries to save */ -}; - -typedef enum { - CURLSTS_OK, - CURLSTS_DONE, - CURLSTS_FAIL -} CURLSTScode; - -typedef CURLSTScode (*curl_hstsread_callback)(CURL *easy, - struct curl_hstsentry *e, - void *userp); -typedef CURLSTScode (*curl_hstswrite_callback)(CURL *easy, - struct curl_hstsentry *e, - struct curl_index *i, - void *userp); - -/* CURLHSTS_* are bits for the CURLOPT_HSTS option */ -#define CURLHSTS_ENABLE (long)(1<<0) -#define CURLHSTS_READONLYFILE (long)(1<<1) - -/* The CURLPROTO_ defines below are for the **deprecated** CURLOPT_*PROTOCOLS - options. Do not use. */ -#define CURLPROTO_HTTP (1<<0) -#define CURLPROTO_HTTPS (1<<1) -#define CURLPROTO_FTP (1<<2) -#define CURLPROTO_FTPS (1<<3) -#define CURLPROTO_SCP (1<<4) -#define CURLPROTO_SFTP (1<<5) -#define CURLPROTO_TELNET (1<<6) -#define CURLPROTO_LDAP (1<<7) -#define CURLPROTO_LDAPS (1<<8) -#define CURLPROTO_DICT (1<<9) -#define CURLPROTO_FILE (1<<10) -#define CURLPROTO_TFTP (1<<11) -#define CURLPROTO_IMAP (1<<12) -#define CURLPROTO_IMAPS (1<<13) -#define CURLPROTO_POP3 (1<<14) -#define CURLPROTO_POP3S (1<<15) -#define CURLPROTO_SMTP (1<<16) -#define CURLPROTO_SMTPS (1<<17) -#define CURLPROTO_RTSP (1<<18) -#define CURLPROTO_RTMP (1<<19) -#define CURLPROTO_RTMPT (1<<20) -#define CURLPROTO_RTMPE (1<<21) -#define CURLPROTO_RTMPTE (1<<22) -#define CURLPROTO_RTMPS (1<<23) -#define CURLPROTO_RTMPTS (1<<24) -#define CURLPROTO_GOPHER (1<<25) -#define CURLPROTO_SMB (1<<26) -#define CURLPROTO_SMBS (1<<27) -#define CURLPROTO_MQTT (1<<28) -#define CURLPROTO_GOPHERS (1<<29) -#define CURLPROTO_ALL (~0) /* enable everything */ - -/* long may be 32 or 64 bits, but we should never depend on anything else - but 32 */ -#define CURLOPTTYPE_LONG 0 -#define CURLOPTTYPE_OBJECTPOINT 10000 -#define CURLOPTTYPE_FUNCTIONPOINT 20000 -#define CURLOPTTYPE_OFF_T 30000 -#define CURLOPTTYPE_BLOB 40000 - -/* *STRINGPOINT is an alias for OBJECTPOINT to allow tools to extract the - string options from the header file */ - - -#define CURLOPT(na,t,nu) na = t + nu -#define CURLOPTDEPRECATED(na,t,nu,v,m) na CURL_DEPRECATED(v,m) = t + nu - -/* CURLOPT aliases that make no runtime difference */ - -/* 'char *' argument to a string with a trailing zero */ -#define CURLOPTTYPE_STRINGPOINT CURLOPTTYPE_OBJECTPOINT - -/* 'struct curl_slist *' argument */ -#define CURLOPTTYPE_SLISTPOINT CURLOPTTYPE_OBJECTPOINT - -/* 'void *' argument passed untouched to callback */ -#define CURLOPTTYPE_CBPOINT CURLOPTTYPE_OBJECTPOINT - -/* 'long' argument with a set of values/bitmask */ -#define CURLOPTTYPE_VALUES CURLOPTTYPE_LONG - -/* - * All CURLOPT_* values. - */ - -typedef enum { - /* This is the FILE * or void * the regular output should be written to. */ - CURLOPT(CURLOPT_WRITEDATA, CURLOPTTYPE_CBPOINT, 1), - - /* The full URL to get/put */ - CURLOPT(CURLOPT_URL, CURLOPTTYPE_STRINGPOINT, 2), - - /* Port number to connect to, if other than default. */ - CURLOPT(CURLOPT_PORT, CURLOPTTYPE_LONG, 3), - - /* Name of proxy to use. */ - CURLOPT(CURLOPT_PROXY, CURLOPTTYPE_STRINGPOINT, 4), - - /* "user:password;options" to use when fetching. */ - CURLOPT(CURLOPT_USERPWD, CURLOPTTYPE_STRINGPOINT, 5), - - /* "user:password" to use with proxy. */ - CURLOPT(CURLOPT_PROXYUSERPWD, CURLOPTTYPE_STRINGPOINT, 6), - - /* Range to get, specified as an ASCII string. */ - CURLOPT(CURLOPT_RANGE, CURLOPTTYPE_STRINGPOINT, 7), - - /* not used */ - - /* Specified file stream to upload from (use as input): */ - CURLOPT(CURLOPT_READDATA, CURLOPTTYPE_CBPOINT, 9), - - /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE - * bytes big. */ - CURLOPT(CURLOPT_ERRORBUFFER, CURLOPTTYPE_OBJECTPOINT, 10), - - /* Function that will be called to store the output (instead of fwrite). The - * parameters will use fwrite() syntax, make sure to follow them. */ - CURLOPT(CURLOPT_WRITEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 11), - - /* Function that will be called to read the input (instead of fread). The - * parameters will use fread() syntax, make sure to follow them. */ - CURLOPT(CURLOPT_READFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 12), - - /* Time-out the read operation after this amount of seconds */ - CURLOPT(CURLOPT_TIMEOUT, CURLOPTTYPE_LONG, 13), - - /* If CURLOPT_READDATA is used, this can be used to inform libcurl about - * how large the file being sent really is. That allows better error - * checking and better verifies that the upload was successful. -1 means - * unknown size. - * - * For large file support, there is also a _LARGE version of the key - * which takes an off_t type, allowing platforms with larger off_t - * sizes to handle larger files. See below for INFILESIZE_LARGE. - */ - CURLOPT(CURLOPT_INFILESIZE, CURLOPTTYPE_LONG, 14), - - /* POST static input fields. */ - CURLOPT(CURLOPT_POSTFIELDS, CURLOPTTYPE_OBJECTPOINT, 15), - - /* Set the referrer page (needed by some CGIs) */ - CURLOPT(CURLOPT_REFERER, CURLOPTTYPE_STRINGPOINT, 16), - - /* Set the FTP PORT string (interface name, named or numerical IP address) - Use i.e '-' to use default address. */ - CURLOPT(CURLOPT_FTPPORT, CURLOPTTYPE_STRINGPOINT, 17), - - /* Set the User-Agent string (examined by some CGIs) */ - CURLOPT(CURLOPT_USERAGENT, CURLOPTTYPE_STRINGPOINT, 18), - - /* If the download receives less than "low speed limit" bytes/second - * during "low speed time" seconds, the operations is aborted. - * You could i.e if you have a pretty high speed connection, abort if - * it is less than 2000 bytes/sec during 20 seconds. - */ - - /* Set the "low speed limit" */ - CURLOPT(CURLOPT_LOW_SPEED_LIMIT, CURLOPTTYPE_LONG, 19), - - /* Set the "low speed time" */ - CURLOPT(CURLOPT_LOW_SPEED_TIME, CURLOPTTYPE_LONG, 20), - - /* Set the continuation offset. - * - * Note there is also a _LARGE version of this key which uses - * off_t types, allowing for large file offsets on platforms which - * use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE. - */ - CURLOPT(CURLOPT_RESUME_FROM, CURLOPTTYPE_LONG, 21), - - /* Set cookie in request: */ - CURLOPT(CURLOPT_COOKIE, CURLOPTTYPE_STRINGPOINT, 22), - - /* This points to a linked list of headers, struct curl_slist kind. This - list is also used for RTSP (in spite of its name) */ - CURLOPT(CURLOPT_HTTPHEADER, CURLOPTTYPE_SLISTPOINT, 23), - - /* This points to a linked list of post entries, struct curl_httppost */ - CURLOPTDEPRECATED(CURLOPT_HTTPPOST, CURLOPTTYPE_OBJECTPOINT, 24, - 7.56.0, "Use CURLOPT_MIMEPOST"), - - /* name of the file keeping your private SSL-certificate */ - CURLOPT(CURLOPT_SSLCERT, CURLOPTTYPE_STRINGPOINT, 25), - - /* password for the SSL or SSH private key */ - CURLOPT(CURLOPT_KEYPASSWD, CURLOPTTYPE_STRINGPOINT, 26), - - /* send TYPE parameter? */ - CURLOPT(CURLOPT_CRLF, CURLOPTTYPE_LONG, 27), - - /* send linked-list of QUOTE commands */ - CURLOPT(CURLOPT_QUOTE, CURLOPTTYPE_SLISTPOINT, 28), - - /* send FILE * or void * to store headers to, if you use a callback it - is simply passed to the callback unmodified */ - CURLOPT(CURLOPT_HEADERDATA, CURLOPTTYPE_CBPOINT, 29), - - /* point to a file to read the initial cookies from, also enables - "cookie awareness" */ - CURLOPT(CURLOPT_COOKIEFILE, CURLOPTTYPE_STRINGPOINT, 31), - - /* What version to specifically try to use. - See CURL_SSLVERSION defines below. */ - CURLOPT(CURLOPT_SSLVERSION, CURLOPTTYPE_VALUES, 32), - - /* What kind of HTTP time condition to use, see defines */ - CURLOPT(CURLOPT_TIMECONDITION, CURLOPTTYPE_VALUES, 33), - - /* Time to use with the above condition. Specified in number of seconds - since 1 Jan 1970 */ - CURLOPT(CURLOPT_TIMEVALUE, CURLOPTTYPE_LONG, 34), - - /* 35 = OBSOLETE */ - - /* Custom request, for customizing the get command like - HTTP: DELETE, TRACE and others - FTP: to use a different list command - */ - CURLOPT(CURLOPT_CUSTOMREQUEST, CURLOPTTYPE_STRINGPOINT, 36), - - /* FILE handle to use instead of stderr */ - CURLOPT(CURLOPT_STDERR, CURLOPTTYPE_OBJECTPOINT, 37), - - /* 38 is not used */ - - /* send linked-list of post-transfer QUOTE commands */ - CURLOPT(CURLOPT_POSTQUOTE, CURLOPTTYPE_SLISTPOINT, 39), - - /* 40 is not used */ - - /* talk a lot */ - CURLOPT(CURLOPT_VERBOSE, CURLOPTTYPE_LONG, 41), - - /* throw the header out too */ - CURLOPT(CURLOPT_HEADER, CURLOPTTYPE_LONG, 42), - - /* shut off the progress meter */ - CURLOPT(CURLOPT_NOPROGRESS, CURLOPTTYPE_LONG, 43), - - /* use HEAD to get http document */ - CURLOPT(CURLOPT_NOBODY, CURLOPTTYPE_LONG, 44), - - /* no output on http error codes >= 400 */ - CURLOPT(CURLOPT_FAILONERROR, CURLOPTTYPE_LONG, 45), - - /* this is an upload */ - CURLOPT(CURLOPT_UPLOAD, CURLOPTTYPE_LONG, 46), - - /* HTTP POST method */ - CURLOPT(CURLOPT_POST, CURLOPTTYPE_LONG, 47), - - /* bare names when listing directories */ - CURLOPT(CURLOPT_DIRLISTONLY, CURLOPTTYPE_LONG, 48), - - /* Append instead of overwrite on upload! */ - CURLOPT(CURLOPT_APPEND, CURLOPTTYPE_LONG, 50), - - /* Specify whether to read the user+password from the .netrc or the URL. - * This must be one of the CURL_NETRC_* enums below. */ - CURLOPT(CURLOPT_NETRC, CURLOPTTYPE_VALUES, 51), - - /* use Location: Luke! */ - CURLOPT(CURLOPT_FOLLOWLOCATION, CURLOPTTYPE_LONG, 52), - - /* transfer data in text/ASCII format */ - CURLOPT(CURLOPT_TRANSFERTEXT, CURLOPTTYPE_LONG, 53), - - /* HTTP PUT */ - CURLOPTDEPRECATED(CURLOPT_PUT, CURLOPTTYPE_LONG, 54, - 7.12.1, "Use CURLOPT_UPLOAD"), - - /* 55 = OBSOLETE */ - - /* DEPRECATED - * Function that will be called instead of the internal progress display - * function. This function should be defined as the curl_progress_callback - * prototype defines. */ - CURLOPTDEPRECATED(CURLOPT_PROGRESSFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 56, - 7.32.0, "Use CURLOPT_XFERINFOFUNCTION"), - - /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION - callbacks */ - CURLOPT(CURLOPT_XFERINFODATA, CURLOPTTYPE_CBPOINT, 57), -#define CURLOPT_PROGRESSDATA CURLOPT_XFERINFODATA - - /* We want the referrer field set automatically when following locations */ - CURLOPT(CURLOPT_AUTOREFERER, CURLOPTTYPE_LONG, 58), - - /* Port of the proxy, can be set in the proxy string as well with: - "[host]:[port]" */ - CURLOPT(CURLOPT_PROXYPORT, CURLOPTTYPE_LONG, 59), - - /* size of the POST input data, if strlen() is not good to use */ - CURLOPT(CURLOPT_POSTFIELDSIZE, CURLOPTTYPE_LONG, 60), - - /* tunnel non-http operations through an HTTP proxy */ - CURLOPT(CURLOPT_HTTPPROXYTUNNEL, CURLOPTTYPE_LONG, 61), - - /* Set the interface string to use as outgoing network interface */ - CURLOPT(CURLOPT_INTERFACE, CURLOPTTYPE_STRINGPOINT, 62), - - /* Set the krb4/5 security level, this also enables krb4/5 awareness. This - * is a string, 'clear', 'safe', 'confidential' or 'private'. If the string - * is set but does not match one of these, 'private' will be used. */ - CURLOPT(CURLOPT_KRBLEVEL, CURLOPTTYPE_STRINGPOINT, 63), - - /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ - CURLOPT(CURLOPT_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 64), - - /* The CApath or CAfile used to validate the peer certificate - this option is used only if SSL_VERIFYPEER is true */ - CURLOPT(CURLOPT_CAINFO, CURLOPTTYPE_STRINGPOINT, 65), - - /* 66 = OBSOLETE */ - /* 67 = OBSOLETE */ - - /* Maximum number of http redirects to follow */ - CURLOPT(CURLOPT_MAXREDIRS, CURLOPTTYPE_LONG, 68), - - /* Pass a long set to 1 to get the date of the requested document (if - possible)! Pass a zero to shut it off. */ - CURLOPT(CURLOPT_FILETIME, CURLOPTTYPE_LONG, 69), - - /* This points to a linked list of telnet options */ - CURLOPT(CURLOPT_TELNETOPTIONS, CURLOPTTYPE_SLISTPOINT, 70), - - /* Max amount of cached alive connections */ - CURLOPT(CURLOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 71), - - /* 72 = OBSOLETE */ - /* 73 = OBSOLETE */ - - /* Set to explicitly use a new connection for the upcoming transfer. - Do not use this unless you are absolutely sure of this, as it makes the - operation slower and is less friendly for the network. */ - CURLOPT(CURLOPT_FRESH_CONNECT, CURLOPTTYPE_LONG, 74), - - /* Set to explicitly forbid the upcoming transfer's connection to be reused - when done. Do not use this unless you are absolutely sure of this, as it - makes the operation slower and is less friendly for the network. */ - CURLOPT(CURLOPT_FORBID_REUSE, CURLOPTTYPE_LONG, 75), - - /* Set to a filename that contains random data for libcurl to use to - seed the random engine when doing SSL connects. */ - CURLOPTDEPRECATED(CURLOPT_RANDOM_FILE, CURLOPTTYPE_STRINGPOINT, 76, - 7.84.0, "Serves no purpose anymore"), - - /* Set to the Entropy Gathering Daemon socket pathname */ - CURLOPTDEPRECATED(CURLOPT_EGDSOCKET, CURLOPTTYPE_STRINGPOINT, 77, - 7.84.0, "Serves no purpose anymore"), - - /* Time-out connect operations after this amount of seconds, if connects are - OK within this time, then fine... This only aborts the connect phase. */ - CURLOPT(CURLOPT_CONNECTTIMEOUT, CURLOPTTYPE_LONG, 78), - - /* Function that will be called to store headers (instead of fwrite). The - * parameters will use fwrite() syntax, make sure to follow them. */ - CURLOPT(CURLOPT_HEADERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 79), - - /* Set this to force the HTTP request to get back to GET. Only really usable - if POST, PUT or a custom request have been used first. - */ - CURLOPT(CURLOPT_HTTPGET, CURLOPTTYPE_LONG, 80), - - /* Set if we should verify the Common name from the peer certificate in ssl - * handshake, set 1 to check existence, 2 to ensure that it matches the - * provided hostname. */ - CURLOPT(CURLOPT_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 81), - - /* Specify which filename to write all known cookies in after completed - operation. Set filename to "-" (dash) to make it go to stdout. */ - CURLOPT(CURLOPT_COOKIEJAR, CURLOPTTYPE_STRINGPOINT, 82), - - /* Specify which TLS 1.2 (1.1, 1.0) ciphers to use */ - CURLOPT(CURLOPT_SSL_CIPHER_LIST, CURLOPTTYPE_STRINGPOINT, 83), - - /* Specify which HTTP version to use! This must be set to one of the - CURL_HTTP_VERSION* enums set below. */ - CURLOPT(CURLOPT_HTTP_VERSION, CURLOPTTYPE_VALUES, 84), - - /* Specifically switch on or off the FTP engine's use of the EPSV command. By - default, that one will always be attempted before the more traditional - PASV command. */ - CURLOPT(CURLOPT_FTP_USE_EPSV, CURLOPTTYPE_LONG, 85), - - /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ - CURLOPT(CURLOPT_SSLCERTTYPE, CURLOPTTYPE_STRINGPOINT, 86), - - /* name of the file keeping your private SSL-key */ - CURLOPT(CURLOPT_SSLKEY, CURLOPTTYPE_STRINGPOINT, 87), - - /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ - CURLOPT(CURLOPT_SSLKEYTYPE, CURLOPTTYPE_STRINGPOINT, 88), - - /* crypto engine for the SSL-sub system */ - CURLOPT(CURLOPT_SSLENGINE, CURLOPTTYPE_STRINGPOINT, 89), - - /* set the crypto engine for the SSL-sub system as default - the param has no meaning... - */ - CURLOPT(CURLOPT_SSLENGINE_DEFAULT, CURLOPTTYPE_LONG, 90), - - /* Non-zero value means to use the global dns cache */ - /* DEPRECATED, do not use! */ - CURLOPTDEPRECATED(CURLOPT_DNS_USE_GLOBAL_CACHE, CURLOPTTYPE_LONG, 91, - 7.11.1, "Use CURLOPT_SHARE"), - - /* DNS cache timeout */ - CURLOPT(CURLOPT_DNS_CACHE_TIMEOUT, CURLOPTTYPE_LONG, 92), - - /* send linked-list of pre-transfer QUOTE commands */ - CURLOPT(CURLOPT_PREQUOTE, CURLOPTTYPE_SLISTPOINT, 93), - - /* set the debug function */ - CURLOPT(CURLOPT_DEBUGFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 94), - - /* set the data for the debug function */ - CURLOPT(CURLOPT_DEBUGDATA, CURLOPTTYPE_CBPOINT, 95), - - /* mark this as start of a cookie session */ - CURLOPT(CURLOPT_COOKIESESSION, CURLOPTTYPE_LONG, 96), - - /* The CApath directory used to validate the peer certificate - this option is used only if SSL_VERIFYPEER is true */ - CURLOPT(CURLOPT_CAPATH, CURLOPTTYPE_STRINGPOINT, 97), - - /* Instruct libcurl to use a smaller receive buffer */ - CURLOPT(CURLOPT_BUFFERSIZE, CURLOPTTYPE_LONG, 98), - - /* Instruct libcurl to not use any signal/alarm handlers, even when using - timeouts. This option is useful for multi-threaded applications. - See libcurl-the-guide for more background information. */ - CURLOPT(CURLOPT_NOSIGNAL, CURLOPTTYPE_LONG, 99), - - /* Provide a CURLShare for mutexing non-ts data */ - CURLOPT(CURLOPT_SHARE, CURLOPTTYPE_OBJECTPOINT, 100), - - /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), - CURLPROXY_HTTPS, CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and - CURLPROXY_SOCKS5. */ - CURLOPT(CURLOPT_PROXYTYPE, CURLOPTTYPE_VALUES, 101), - - /* Set the Accept-Encoding string. Use this to tell a server you would like - the response to be compressed. Before 7.21.6, this was known as - CURLOPT_ENCODING */ - CURLOPT(CURLOPT_ACCEPT_ENCODING, CURLOPTTYPE_STRINGPOINT, 102), - - /* Set pointer to private data */ - CURLOPT(CURLOPT_PRIVATE, CURLOPTTYPE_OBJECTPOINT, 103), - - /* Set aliases for HTTP 200 in the HTTP Response header */ - CURLOPT(CURLOPT_HTTP200ALIASES, CURLOPTTYPE_SLISTPOINT, 104), - - /* Continue to send authentication (user+password) when following locations, - even when hostname changed. This can potentially send off the name - and password to whatever host the server decides. */ - CURLOPT(CURLOPT_UNRESTRICTED_AUTH, CURLOPTTYPE_LONG, 105), - - /* Specifically switch on or off the FTP engine's use of the EPRT command ( - it also disables the LPRT attempt). By default, those ones will always be - attempted before the good old traditional PORT command. */ - CURLOPT(CURLOPT_FTP_USE_EPRT, CURLOPTTYPE_LONG, 106), - - /* Set this to a bitmask value to enable the particular authentications - methods you like. Use this in combination with CURLOPT_USERPWD. - Note that setting multiple bits may cause extra network round-trips. */ - CURLOPT(CURLOPT_HTTPAUTH, CURLOPTTYPE_VALUES, 107), - - /* Set the ssl context callback function, currently only for OpenSSL or - wolfSSL ssl_ctx, or mbedTLS mbedtls_ssl_config in the second argument. - The function must match the curl_ssl_ctx_callback prototype. */ - CURLOPT(CURLOPT_SSL_CTX_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 108), - - /* Set the userdata for the ssl context callback function's third - argument */ - CURLOPT(CURLOPT_SSL_CTX_DATA, CURLOPTTYPE_CBPOINT, 109), - - /* FTP Option that causes missing dirs to be created on the remote server. - In 7.19.4 we introduced the convenience enums for this option using the - CURLFTP_CREATE_DIR prefix. - */ - CURLOPT(CURLOPT_FTP_CREATE_MISSING_DIRS, CURLOPTTYPE_LONG, 110), - - /* Set this to a bitmask value to enable the particular authentications - methods you like. Use this in combination with CURLOPT_PROXYUSERPWD. - Note that setting multiple bits may cause extra network round-trips. */ - CURLOPT(CURLOPT_PROXYAUTH, CURLOPTTYPE_VALUES, 111), - - /* Option that changes the timeout, in seconds, associated with getting a - response. This is different from transfer timeout time and essentially - places a demand on the server to acknowledge commands in a timely - manner. For FTP, SMTP, IMAP and POP3. */ - CURLOPT(CURLOPT_SERVER_RESPONSE_TIMEOUT, CURLOPTTYPE_LONG, 112), - - /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to - tell libcurl to use those IP versions only. This only has effect on - systems with support for more than one, i.e IPv4 _and_ IPv6. */ - CURLOPT(CURLOPT_IPRESOLVE, CURLOPTTYPE_VALUES, 113), - - /* Set this option to limit the size of a file that will be downloaded from - an HTTP or FTP server. - - Note there is also _LARGE version which adds large file support for - platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */ - CURLOPT(CURLOPT_MAXFILESIZE, CURLOPTTYPE_LONG, 114), - - /* See the comment for INFILESIZE above, but in short, specifies - * the size of the file being uploaded. -1 means unknown. - */ - CURLOPT(CURLOPT_INFILESIZE_LARGE, CURLOPTTYPE_OFF_T, 115), - - /* Sets the continuation offset. There is also a CURLOPTTYPE_LONG version - * of this; look above for RESUME_FROM. - */ - CURLOPT(CURLOPT_RESUME_FROM_LARGE, CURLOPTTYPE_OFF_T, 116), - - /* Sets the maximum size of data that will be downloaded from - * an HTTP or FTP server. See MAXFILESIZE above for the LONG version. - */ - CURLOPT(CURLOPT_MAXFILESIZE_LARGE, CURLOPTTYPE_OFF_T, 117), - - /* Set this option to the filename of your .netrc file you want libcurl - to parse (using the CURLOPT_NETRC option). If not set, libcurl will do - a poor attempt to find the user's home directory and check for a .netrc - file in there. */ - CURLOPT(CURLOPT_NETRC_FILE, CURLOPTTYPE_STRINGPOINT, 118), - - /* Enable SSL/TLS for FTP, pick one of: - CURLUSESSL_TRY - try using SSL, proceed anyway otherwise - CURLUSESSL_CONTROL - SSL for the control connection or fail - CURLUSESSL_ALL - SSL for all communication or fail - */ - CURLOPT(CURLOPT_USE_SSL, CURLOPTTYPE_VALUES, 119), - - /* The _LARGE version of the standard POSTFIELDSIZE option */ - CURLOPT(CURLOPT_POSTFIELDSIZE_LARGE, CURLOPTTYPE_OFF_T, 120), - - /* Enable/disable the TCP Nagle algorithm */ - CURLOPT(CURLOPT_TCP_NODELAY, CURLOPTTYPE_LONG, 121), - - /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ - /* 123 OBSOLETE. Gone in 7.16.0 */ - /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ - /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ - /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ - /* 127 OBSOLETE. Gone in 7.16.0 */ - /* 128 OBSOLETE. Gone in 7.16.0 */ - - /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option - can be used to change libcurl's default action which is to first try - "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK - response has been received. - - Available parameters are: - CURLFTPAUTH_DEFAULT - let libcurl decide - CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS - CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL - */ - CURLOPT(CURLOPT_FTPSSLAUTH, CURLOPTTYPE_VALUES, 129), - - CURLOPTDEPRECATED(CURLOPT_IOCTLFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 130, - 7.18.0, "Use CURLOPT_SEEKFUNCTION"), - CURLOPTDEPRECATED(CURLOPT_IOCTLDATA, CURLOPTTYPE_CBPOINT, 131, - 7.18.0, "Use CURLOPT_SEEKDATA"), - - /* 132 OBSOLETE. Gone in 7.16.0 */ - /* 133 OBSOLETE. Gone in 7.16.0 */ - - /* null-terminated string for pass on to the FTP server when asked for - "account" info */ - CURLOPT(CURLOPT_FTP_ACCOUNT, CURLOPTTYPE_STRINGPOINT, 134), - - /* feed cookie into cookie engine */ - CURLOPT(CURLOPT_COOKIELIST, CURLOPTTYPE_STRINGPOINT, 135), - - /* ignore Content-Length */ - CURLOPT(CURLOPT_IGNORE_CONTENT_LENGTH, CURLOPTTYPE_LONG, 136), - - /* Set to non-zero to skip the IP address received in a 227 PASV FTP server - response. Typically used for FTP-SSL purposes but is not restricted to - that. libcurl will then instead use the same IP address it used for the - control connection. */ - CURLOPT(CURLOPT_FTP_SKIP_PASV_IP, CURLOPTTYPE_LONG, 137), - - /* Select "file method" to use when doing FTP, see the curl_ftpmethod - above. */ - CURLOPT(CURLOPT_FTP_FILEMETHOD, CURLOPTTYPE_VALUES, 138), - - /* Local port number to bind the socket to */ - CURLOPT(CURLOPT_LOCALPORT, CURLOPTTYPE_LONG, 139), - - /* Number of ports to try, including the first one set with LOCALPORT. - Thus, setting it to 1 will make no additional attempts but the first. - */ - CURLOPT(CURLOPT_LOCALPORTRANGE, CURLOPTTYPE_LONG, 140), - - /* no transfer, set up connection and let application use the socket by - extracting it with CURLINFO_LASTSOCKET */ - CURLOPT(CURLOPT_CONNECT_ONLY, CURLOPTTYPE_LONG, 141), - - /* Function that will be called to convert from the - network encoding (instead of using the iconv calls in libcurl) */ - CURLOPTDEPRECATED(CURLOPT_CONV_FROM_NETWORK_FUNCTION, - CURLOPTTYPE_FUNCTIONPOINT, 142, - 7.82.0, "Serves no purpose anymore"), - - /* Function that will be called to convert to the - network encoding (instead of using the iconv calls in libcurl) */ - CURLOPTDEPRECATED(CURLOPT_CONV_TO_NETWORK_FUNCTION, - CURLOPTTYPE_FUNCTIONPOINT, 143, - 7.82.0, "Serves no purpose anymore"), - - /* Function that will be called to convert from UTF8 - (instead of using the iconv calls in libcurl) - Note that this is used only for SSL certificate processing */ - CURLOPTDEPRECATED(CURLOPT_CONV_FROM_UTF8_FUNCTION, - CURLOPTTYPE_FUNCTIONPOINT, 144, - 7.82.0, "Serves no purpose anymore"), - - /* if the connection proceeds too quickly then need to slow it down */ - /* limit-rate: maximum number of bytes per second to send or receive */ - CURLOPT(CURLOPT_MAX_SEND_SPEED_LARGE, CURLOPTTYPE_OFF_T, 145), - CURLOPT(CURLOPT_MAX_RECV_SPEED_LARGE, CURLOPTTYPE_OFF_T, 146), - - /* Pointer to command string to send if USER/PASS fails. */ - CURLOPT(CURLOPT_FTP_ALTERNATIVE_TO_USER, CURLOPTTYPE_STRINGPOINT, 147), - - /* callback function for setting socket options */ - CURLOPT(CURLOPT_SOCKOPTFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 148), - CURLOPT(CURLOPT_SOCKOPTDATA, CURLOPTTYPE_CBPOINT, 149), - - /* set to 0 to disable session ID reuse for this transfer, default is - enabled (== 1) */ - CURLOPT(CURLOPT_SSL_SESSIONID_CACHE, CURLOPTTYPE_LONG, 150), - - /* allowed SSH authentication methods */ - CURLOPT(CURLOPT_SSH_AUTH_TYPES, CURLOPTTYPE_VALUES, 151), - - /* Used by scp/sftp to do public/private key authentication */ - CURLOPT(CURLOPT_SSH_PUBLIC_KEYFILE, CURLOPTTYPE_STRINGPOINT, 152), - CURLOPT(CURLOPT_SSH_PRIVATE_KEYFILE, CURLOPTTYPE_STRINGPOINT, 153), - - /* Send CCC (Clear Command Channel) after authentication */ - CURLOPT(CURLOPT_FTP_SSL_CCC, CURLOPTTYPE_LONG, 154), - - /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ - CURLOPT(CURLOPT_TIMEOUT_MS, CURLOPTTYPE_LONG, 155), - CURLOPT(CURLOPT_CONNECTTIMEOUT_MS, CURLOPTTYPE_LONG, 156), - - /* set to zero to disable the libcurl's decoding and thus pass the raw body - data to the application even when it is encoded/compressed */ - CURLOPT(CURLOPT_HTTP_TRANSFER_DECODING, CURLOPTTYPE_LONG, 157), - CURLOPT(CURLOPT_HTTP_CONTENT_DECODING, CURLOPTTYPE_LONG, 158), - - /* Permission used when creating new files and directories on the remote - server for protocols that support it, SFTP/SCP/FILE */ - CURLOPT(CURLOPT_NEW_FILE_PERMS, CURLOPTTYPE_LONG, 159), - CURLOPT(CURLOPT_NEW_DIRECTORY_PERMS, CURLOPTTYPE_LONG, 160), - - /* Set the behavior of POST when redirecting. Values must be set to one - of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */ - CURLOPT(CURLOPT_POSTREDIR, CURLOPTTYPE_VALUES, 161), - - /* used by scp/sftp to verify the host's public key */ - CURLOPT(CURLOPT_SSH_HOST_PUBLIC_KEY_MD5, CURLOPTTYPE_STRINGPOINT, 162), - - /* Callback function for opening socket (instead of socket(2)). Optionally, - callback is able change the address or refuse to connect returning - CURL_SOCKET_BAD. The callback should have type - curl_opensocket_callback */ - CURLOPT(CURLOPT_OPENSOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 163), - CURLOPT(CURLOPT_OPENSOCKETDATA, CURLOPTTYPE_CBPOINT, 164), - - /* POST volatile input fields. */ - CURLOPT(CURLOPT_COPYPOSTFIELDS, CURLOPTTYPE_OBJECTPOINT, 165), - - /* set transfer mode (;type=) when doing FTP via an HTTP proxy */ - CURLOPT(CURLOPT_PROXY_TRANSFER_MODE, CURLOPTTYPE_LONG, 166), - - /* Callback function for seeking in the input stream */ - CURLOPT(CURLOPT_SEEKFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 167), - CURLOPT(CURLOPT_SEEKDATA, CURLOPTTYPE_CBPOINT, 168), - - /* CRL file */ - CURLOPT(CURLOPT_CRLFILE, CURLOPTTYPE_STRINGPOINT, 169), - - /* Issuer certificate */ - CURLOPT(CURLOPT_ISSUERCERT, CURLOPTTYPE_STRINGPOINT, 170), - - /* (IPv6) Address scope */ - CURLOPT(CURLOPT_ADDRESS_SCOPE, CURLOPTTYPE_LONG, 171), - - /* Collect certificate chain info and allow it to get retrievable with - CURLINFO_CERTINFO after the transfer is complete. */ - CURLOPT(CURLOPT_CERTINFO, CURLOPTTYPE_LONG, 172), - - /* "name" and "pwd" to use when fetching. */ - CURLOPT(CURLOPT_USERNAME, CURLOPTTYPE_STRINGPOINT, 173), - CURLOPT(CURLOPT_PASSWORD, CURLOPTTYPE_STRINGPOINT, 174), - - /* "name" and "pwd" to use with Proxy when fetching. */ - CURLOPT(CURLOPT_PROXYUSERNAME, CURLOPTTYPE_STRINGPOINT, 175), - CURLOPT(CURLOPT_PROXYPASSWORD, CURLOPTTYPE_STRINGPOINT, 176), - - /* Comma separated list of hostnames defining no-proxy zones. These should - match both hostnames directly, and hostnames within a domain. For - example, local.com will match local.com and www.local.com, but NOT - notlocal.com or www.notlocal.com. For compatibility with other - implementations of this, .local.com will be considered to be the same as - local.com. A single * is the only valid wildcard, and effectively - disables the use of proxy. */ - CURLOPT(CURLOPT_NOPROXY, CURLOPTTYPE_STRINGPOINT, 177), - - /* block size for TFTP transfers */ - CURLOPT(CURLOPT_TFTP_BLKSIZE, CURLOPTTYPE_LONG, 178), - - /* Socks Service */ - /* DEPRECATED, do not use! */ - CURLOPTDEPRECATED(CURLOPT_SOCKS5_GSSAPI_SERVICE, - CURLOPTTYPE_STRINGPOINT, 179, - 7.49.0, "Use CURLOPT_PROXY_SERVICE_NAME"), - - /* Socks Service */ - CURLOPT(CURLOPT_SOCKS5_GSSAPI_NEC, CURLOPTTYPE_LONG, 180), - - /* set the bitmask for the protocols that are allowed to be used for the - transfer, which thus helps the app which takes URLs from users or other - external inputs and want to restrict what protocol(s) to deal - with. Defaults to CURLPROTO_ALL. */ - CURLOPTDEPRECATED(CURLOPT_PROTOCOLS, CURLOPTTYPE_LONG, 181, - 7.85.0, "Use CURLOPT_PROTOCOLS_STR"), - - /* set the bitmask for the protocols that libcurl is allowed to follow to, - as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs - to be set in both bitmasks to be allowed to get redirected to. */ - CURLOPTDEPRECATED(CURLOPT_REDIR_PROTOCOLS, CURLOPTTYPE_LONG, 182, - 7.85.0, "Use CURLOPT_REDIR_PROTOCOLS_STR"), - - /* set the SSH knownhost filename to use */ - CURLOPT(CURLOPT_SSH_KNOWNHOSTS, CURLOPTTYPE_STRINGPOINT, 183), - - /* set the SSH host key callback, must point to a curl_sshkeycallback - function */ - CURLOPT(CURLOPT_SSH_KEYFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 184), - - /* set the SSH host key callback custom pointer */ - CURLOPT(CURLOPT_SSH_KEYDATA, CURLOPTTYPE_CBPOINT, 185), - - /* set the SMTP mail originator */ - CURLOPT(CURLOPT_MAIL_FROM, CURLOPTTYPE_STRINGPOINT, 186), - - /* set the list of SMTP mail receiver(s) */ - CURLOPT(CURLOPT_MAIL_RCPT, CURLOPTTYPE_SLISTPOINT, 187), - - /* FTP: send PRET before PASV */ - CURLOPT(CURLOPT_FTP_USE_PRET, CURLOPTTYPE_LONG, 188), - - /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */ - CURLOPT(CURLOPT_RTSP_REQUEST, CURLOPTTYPE_VALUES, 189), - - /* The RTSP session identifier */ - CURLOPT(CURLOPT_RTSP_SESSION_ID, CURLOPTTYPE_STRINGPOINT, 190), - - /* The RTSP stream URI */ - CURLOPT(CURLOPT_RTSP_STREAM_URI, CURLOPTTYPE_STRINGPOINT, 191), - - /* The Transport: header to use in RTSP requests */ - CURLOPT(CURLOPT_RTSP_TRANSPORT, CURLOPTTYPE_STRINGPOINT, 192), - - /* Manually initialize the client RTSP CSeq for this handle */ - CURLOPT(CURLOPT_RTSP_CLIENT_CSEQ, CURLOPTTYPE_LONG, 193), - - /* Manually initialize the server RTSP CSeq for this handle */ - CURLOPT(CURLOPT_RTSP_SERVER_CSEQ, CURLOPTTYPE_LONG, 194), - - /* The stream to pass to INTERLEAVEFUNCTION. */ - CURLOPT(CURLOPT_INTERLEAVEDATA, CURLOPTTYPE_CBPOINT, 195), - - /* Let the application define a custom write method for RTP data */ - CURLOPT(CURLOPT_INTERLEAVEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 196), - - /* Turn on wildcard matching */ - CURLOPT(CURLOPT_WILDCARDMATCH, CURLOPTTYPE_LONG, 197), - - /* Directory matching callback called before downloading of an - individual file (chunk) started */ - CURLOPT(CURLOPT_CHUNK_BGN_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 198), - - /* Directory matching callback called after the file (chunk) - was downloaded, or skipped */ - CURLOPT(CURLOPT_CHUNK_END_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 199), - - /* Change match (fnmatch-like) callback for wildcard matching */ - CURLOPT(CURLOPT_FNMATCH_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 200), - - /* Let the application define custom chunk data pointer */ - CURLOPT(CURLOPT_CHUNK_DATA, CURLOPTTYPE_CBPOINT, 201), - - /* FNMATCH_FUNCTION user pointer */ - CURLOPT(CURLOPT_FNMATCH_DATA, CURLOPTTYPE_CBPOINT, 202), - - /* send linked-list of name:port:address sets */ - CURLOPT(CURLOPT_RESOLVE, CURLOPTTYPE_SLISTPOINT, 203), - - /* Set a username for authenticated TLS */ - CURLOPT(CURLOPT_TLSAUTH_USERNAME, CURLOPTTYPE_STRINGPOINT, 204), - - /* Set a password for authenticated TLS */ - CURLOPT(CURLOPT_TLSAUTH_PASSWORD, CURLOPTTYPE_STRINGPOINT, 205), - - /* Set authentication type for authenticated TLS */ - CURLOPT(CURLOPT_TLSAUTH_TYPE, CURLOPTTYPE_STRINGPOINT, 206), - - /* Set to 1 to enable the "TE:" header in HTTP requests to ask for - compressed transfer-encoded responses. Set to 0 to disable the use of TE: - in outgoing requests. The current default is 0, but it might change in a - future libcurl release. - - libcurl will ask for the compressed methods it knows of, and if that - is not any, it will not ask for transfer-encoding at all even if this - option is set to 1. - - */ - CURLOPT(CURLOPT_TRANSFER_ENCODING, CURLOPTTYPE_LONG, 207), - - /* Callback function for closing socket (instead of close(2)). The callback - should have type curl_closesocket_callback */ - CURLOPT(CURLOPT_CLOSESOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 208), - CURLOPT(CURLOPT_CLOSESOCKETDATA, CURLOPTTYPE_CBPOINT, 209), - - /* allow GSSAPI credential delegation */ - CURLOPT(CURLOPT_GSSAPI_DELEGATION, CURLOPTTYPE_VALUES, 210), - - /* Set the name servers to use for DNS resolution. - * Only supported by the c-ares DNS backend */ - CURLOPT(CURLOPT_DNS_SERVERS, CURLOPTTYPE_STRINGPOINT, 211), - - /* Time-out accept operations (currently for FTP only) after this amount - of milliseconds. */ - CURLOPT(CURLOPT_ACCEPTTIMEOUT_MS, CURLOPTTYPE_LONG, 212), - - /* Set TCP keepalive */ - CURLOPT(CURLOPT_TCP_KEEPALIVE, CURLOPTTYPE_LONG, 213), - - /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */ - CURLOPT(CURLOPT_TCP_KEEPIDLE, CURLOPTTYPE_LONG, 214), - CURLOPT(CURLOPT_TCP_KEEPINTVL, CURLOPTTYPE_LONG, 215), - - /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */ - CURLOPT(CURLOPT_SSL_OPTIONS, CURLOPTTYPE_VALUES, 216), - - /* Set the SMTP auth originator */ - CURLOPT(CURLOPT_MAIL_AUTH, CURLOPTTYPE_STRINGPOINT, 217), - - /* Enable/disable SASL initial response */ - CURLOPT(CURLOPT_SASL_IR, CURLOPTTYPE_LONG, 218), - - /* Function that will be called instead of the internal progress display - * function. This function should be defined as the curl_xferinfo_callback - * prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */ - CURLOPT(CURLOPT_XFERINFOFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 219), - - /* The XOAUTH2 bearer token */ - CURLOPT(CURLOPT_XOAUTH2_BEARER, CURLOPTTYPE_STRINGPOINT, 220), - - /* Set the interface string to use as outgoing network - * interface for DNS requests. - * Only supported by the c-ares DNS backend */ - CURLOPT(CURLOPT_DNS_INTERFACE, CURLOPTTYPE_STRINGPOINT, 221), - - /* Set the local IPv4 address to use for outgoing DNS requests. - * Only supported by the c-ares DNS backend */ - CURLOPT(CURLOPT_DNS_LOCAL_IP4, CURLOPTTYPE_STRINGPOINT, 222), - - /* Set the local IPv6 address to use for outgoing DNS requests. - * Only supported by the c-ares DNS backend */ - CURLOPT(CURLOPT_DNS_LOCAL_IP6, CURLOPTTYPE_STRINGPOINT, 223), - - /* Set authentication options directly */ - CURLOPT(CURLOPT_LOGIN_OPTIONS, CURLOPTTYPE_STRINGPOINT, 224), - - /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */ - CURLOPTDEPRECATED(CURLOPT_SSL_ENABLE_NPN, CURLOPTTYPE_LONG, 225, - 7.86.0, "Has no function"), - - /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */ - CURLOPT(CURLOPT_SSL_ENABLE_ALPN, CURLOPTTYPE_LONG, 226), - - /* Time to wait for a response to an HTTP request containing an - * Expect: 100-continue header before sending the data anyway. */ - CURLOPT(CURLOPT_EXPECT_100_TIMEOUT_MS, CURLOPTTYPE_LONG, 227), - - /* This points to a linked list of headers used for proxy requests only, - struct curl_slist kind */ - CURLOPT(CURLOPT_PROXYHEADER, CURLOPTTYPE_SLISTPOINT, 228), - - /* Pass in a bitmask of "header options" */ - CURLOPT(CURLOPT_HEADEROPT, CURLOPTTYPE_VALUES, 229), - - /* The public key in DER form used to validate the peer public key - this option is used only if SSL_VERIFYPEER is true */ - CURLOPT(CURLOPT_PINNEDPUBLICKEY, CURLOPTTYPE_STRINGPOINT, 230), - - /* Path to Unix domain socket */ - CURLOPT(CURLOPT_UNIX_SOCKET_PATH, CURLOPTTYPE_STRINGPOINT, 231), - - /* Set if we should verify the certificate status. */ - CURLOPT(CURLOPT_SSL_VERIFYSTATUS, CURLOPTTYPE_LONG, 232), - - /* Set if we should enable TLS false start. */ - CURLOPT(CURLOPT_SSL_FALSESTART, CURLOPTTYPE_LONG, 233), - - /* Do not squash dot-dot sequences */ - CURLOPT(CURLOPT_PATH_AS_IS, CURLOPTTYPE_LONG, 234), - - /* Proxy Service Name */ - CURLOPT(CURLOPT_PROXY_SERVICE_NAME, CURLOPTTYPE_STRINGPOINT, 235), - - /* Service Name */ - CURLOPT(CURLOPT_SERVICE_NAME, CURLOPTTYPE_STRINGPOINT, 236), - - /* Wait/do not wait for pipe/mutex to clarify */ - CURLOPT(CURLOPT_PIPEWAIT, CURLOPTTYPE_LONG, 237), - - /* Set the protocol used when curl is given a URL without a protocol */ - CURLOPT(CURLOPT_DEFAULT_PROTOCOL, CURLOPTTYPE_STRINGPOINT, 238), - - /* Set stream weight, 1 - 256 (default is 16) */ - CURLOPT(CURLOPT_STREAM_WEIGHT, CURLOPTTYPE_LONG, 239), - - /* Set stream dependency on another curl handle */ - CURLOPT(CURLOPT_STREAM_DEPENDS, CURLOPTTYPE_OBJECTPOINT, 240), - - /* Set E-xclusive stream dependency on another curl handle */ - CURLOPT(CURLOPT_STREAM_DEPENDS_E, CURLOPTTYPE_OBJECTPOINT, 241), - - /* Do not send any tftp option requests to the server */ - CURLOPT(CURLOPT_TFTP_NO_OPTIONS, CURLOPTTYPE_LONG, 242), - - /* Linked-list of host:port:connect-to-host:connect-to-port, - overrides the URL's host:port (only for the network layer) */ - CURLOPT(CURLOPT_CONNECT_TO, CURLOPTTYPE_SLISTPOINT, 243), - - /* Set TCP Fast Open */ - CURLOPT(CURLOPT_TCP_FASTOPEN, CURLOPTTYPE_LONG, 244), - - /* Continue to send data if the server responds early with an - * HTTP status code >= 300 */ - CURLOPT(CURLOPT_KEEP_SENDING_ON_ERROR, CURLOPTTYPE_LONG, 245), - - /* The CApath or CAfile used to validate the proxy certificate - this option is used only if PROXY_SSL_VERIFYPEER is true */ - CURLOPT(CURLOPT_PROXY_CAINFO, CURLOPTTYPE_STRINGPOINT, 246), - - /* The CApath directory used to validate the proxy certificate - this option is used only if PROXY_SSL_VERIFYPEER is true */ - CURLOPT(CURLOPT_PROXY_CAPATH, CURLOPTTYPE_STRINGPOINT, 247), - - /* Set if we should verify the proxy in ssl handshake, - set 1 to verify. */ - CURLOPT(CURLOPT_PROXY_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 248), - - /* Set if we should verify the Common name from the proxy certificate in ssl - * handshake, set 1 to check existence, 2 to ensure that it matches - * the provided hostname. */ - CURLOPT(CURLOPT_PROXY_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 249), - - /* What version to specifically try to use for proxy. - See CURL_SSLVERSION defines below. */ - CURLOPT(CURLOPT_PROXY_SSLVERSION, CURLOPTTYPE_VALUES, 250), - - /* Set a username for authenticated TLS for proxy */ - CURLOPT(CURLOPT_PROXY_TLSAUTH_USERNAME, CURLOPTTYPE_STRINGPOINT, 251), - - /* Set a password for authenticated TLS for proxy */ - CURLOPT(CURLOPT_PROXY_TLSAUTH_PASSWORD, CURLOPTTYPE_STRINGPOINT, 252), - - /* Set authentication type for authenticated TLS for proxy */ - CURLOPT(CURLOPT_PROXY_TLSAUTH_TYPE, CURLOPTTYPE_STRINGPOINT, 253), - - /* name of the file keeping your private SSL-certificate for proxy */ - CURLOPT(CURLOPT_PROXY_SSLCERT, CURLOPTTYPE_STRINGPOINT, 254), - - /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") for - proxy */ - CURLOPT(CURLOPT_PROXY_SSLCERTTYPE, CURLOPTTYPE_STRINGPOINT, 255), - - /* name of the file keeping your private SSL-key for proxy */ - CURLOPT(CURLOPT_PROXY_SSLKEY, CURLOPTTYPE_STRINGPOINT, 256), - - /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") for - proxy */ - CURLOPT(CURLOPT_PROXY_SSLKEYTYPE, CURLOPTTYPE_STRINGPOINT, 257), - - /* password for the SSL private key for proxy */ - CURLOPT(CURLOPT_PROXY_KEYPASSWD, CURLOPTTYPE_STRINGPOINT, 258), - - /* Specify which TLS 1.2 (1.1, 1.0) ciphers to use for proxy */ - CURLOPT(CURLOPT_PROXY_SSL_CIPHER_LIST, CURLOPTTYPE_STRINGPOINT, 259), - - /* CRL file for proxy */ - CURLOPT(CURLOPT_PROXY_CRLFILE, CURLOPTTYPE_STRINGPOINT, 260), - - /* Enable/disable specific SSL features with a bitmask for proxy, see - CURLSSLOPT_* */ - CURLOPT(CURLOPT_PROXY_SSL_OPTIONS, CURLOPTTYPE_LONG, 261), - - /* Name of pre proxy to use. */ - CURLOPT(CURLOPT_PRE_PROXY, CURLOPTTYPE_STRINGPOINT, 262), - - /* The public key in DER form used to validate the proxy public key - this option is used only if PROXY_SSL_VERIFYPEER is true */ - CURLOPT(CURLOPT_PROXY_PINNEDPUBLICKEY, CURLOPTTYPE_STRINGPOINT, 263), - - /* Path to an abstract Unix domain socket */ - CURLOPT(CURLOPT_ABSTRACT_UNIX_SOCKET, CURLOPTTYPE_STRINGPOINT, 264), - - /* Suppress proxy CONNECT response headers from user callbacks */ - CURLOPT(CURLOPT_SUPPRESS_CONNECT_HEADERS, CURLOPTTYPE_LONG, 265), - - /* The request target, instead of extracted from the URL */ - CURLOPT(CURLOPT_REQUEST_TARGET, CURLOPTTYPE_STRINGPOINT, 266), - - /* bitmask of allowed auth methods for connections to SOCKS5 proxies */ - CURLOPT(CURLOPT_SOCKS5_AUTH, CURLOPTTYPE_LONG, 267), - - /* Enable/disable SSH compression */ - CURLOPT(CURLOPT_SSH_COMPRESSION, CURLOPTTYPE_LONG, 268), - - /* Post MIME data. */ - CURLOPT(CURLOPT_MIMEPOST, CURLOPTTYPE_OBJECTPOINT, 269), - - /* Time to use with the CURLOPT_TIMECONDITION. Specified in number of - seconds since 1 Jan 1970. */ - CURLOPT(CURLOPT_TIMEVALUE_LARGE, CURLOPTTYPE_OFF_T, 270), - - /* Head start in milliseconds to give happy eyeballs. */ - CURLOPT(CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS, CURLOPTTYPE_LONG, 271), - - /* Function that will be called before a resolver request is made */ - CURLOPT(CURLOPT_RESOLVER_START_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 272), - - /* User data to pass to the resolver start callback. */ - CURLOPT(CURLOPT_RESOLVER_START_DATA, CURLOPTTYPE_CBPOINT, 273), - - /* send HAProxy PROXY protocol header? */ - CURLOPT(CURLOPT_HAPROXYPROTOCOL, CURLOPTTYPE_LONG, 274), - - /* shuffle addresses before use when DNS returns multiple */ - CURLOPT(CURLOPT_DNS_SHUFFLE_ADDRESSES, CURLOPTTYPE_LONG, 275), - - /* Specify which TLS 1.3 ciphers suites to use */ - CURLOPT(CURLOPT_TLS13_CIPHERS, CURLOPTTYPE_STRINGPOINT, 276), - CURLOPT(CURLOPT_PROXY_TLS13_CIPHERS, CURLOPTTYPE_STRINGPOINT, 277), - - /* Disallow specifying username/login in URL. */ - CURLOPT(CURLOPT_DISALLOW_USERNAME_IN_URL, CURLOPTTYPE_LONG, 278), - - /* DNS-over-HTTPS URL */ - CURLOPT(CURLOPT_DOH_URL, CURLOPTTYPE_STRINGPOINT, 279), - - /* Preferred buffer size to use for uploads */ - CURLOPT(CURLOPT_UPLOAD_BUFFERSIZE, CURLOPTTYPE_LONG, 280), - - /* Time in ms between connection upkeep calls for long-lived connections. */ - CURLOPT(CURLOPT_UPKEEP_INTERVAL_MS, CURLOPTTYPE_LONG, 281), - - /* Specify URL using CURL URL API. */ - CURLOPT(CURLOPT_CURLU, CURLOPTTYPE_OBJECTPOINT, 282), - - /* add trailing data just after no more data is available */ - CURLOPT(CURLOPT_TRAILERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 283), - - /* pointer to be passed to HTTP_TRAILER_FUNCTION */ - CURLOPT(CURLOPT_TRAILERDATA, CURLOPTTYPE_CBPOINT, 284), - - /* set this to 1L to allow HTTP/0.9 responses or 0L to disallow */ - CURLOPT(CURLOPT_HTTP09_ALLOWED, CURLOPTTYPE_LONG, 285), - - /* alt-svc control bitmask */ - CURLOPT(CURLOPT_ALTSVC_CTRL, CURLOPTTYPE_LONG, 286), - - /* alt-svc cache filename to possibly read from/write to */ - CURLOPT(CURLOPT_ALTSVC, CURLOPTTYPE_STRINGPOINT, 287), - - /* maximum age (idle time) of a connection to consider it for reuse - * (in seconds) */ - CURLOPT(CURLOPT_MAXAGE_CONN, CURLOPTTYPE_LONG, 288), - - /* SASL authorization identity */ - CURLOPT(CURLOPT_SASL_AUTHZID, CURLOPTTYPE_STRINGPOINT, 289), - - /* allow RCPT TO command to fail for some recipients */ - CURLOPT(CURLOPT_MAIL_RCPT_ALLOWFAILS, CURLOPTTYPE_LONG, 290), - - /* the private SSL-certificate as a "blob" */ - CURLOPT(CURLOPT_SSLCERT_BLOB, CURLOPTTYPE_BLOB, 291), - CURLOPT(CURLOPT_SSLKEY_BLOB, CURLOPTTYPE_BLOB, 292), - CURLOPT(CURLOPT_PROXY_SSLCERT_BLOB, CURLOPTTYPE_BLOB, 293), - CURLOPT(CURLOPT_PROXY_SSLKEY_BLOB, CURLOPTTYPE_BLOB, 294), - CURLOPT(CURLOPT_ISSUERCERT_BLOB, CURLOPTTYPE_BLOB, 295), - - /* Issuer certificate for proxy */ - CURLOPT(CURLOPT_PROXY_ISSUERCERT, CURLOPTTYPE_STRINGPOINT, 296), - CURLOPT(CURLOPT_PROXY_ISSUERCERT_BLOB, CURLOPTTYPE_BLOB, 297), - - /* the EC curves requested by the TLS client (RFC 8422, 5.1); - * OpenSSL support via 'set_groups'/'set_curves': - * https://docs.openssl.org/master/man3/SSL_CTX_set1_curves/ - */ - CURLOPT(CURLOPT_SSL_EC_CURVES, CURLOPTTYPE_STRINGPOINT, 298), - - /* HSTS bitmask */ - CURLOPT(CURLOPT_HSTS_CTRL, CURLOPTTYPE_LONG, 299), - /* HSTS filename */ - CURLOPT(CURLOPT_HSTS, CURLOPTTYPE_STRINGPOINT, 300), - - /* HSTS read callback */ - CURLOPT(CURLOPT_HSTSREADFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 301), - CURLOPT(CURLOPT_HSTSREADDATA, CURLOPTTYPE_CBPOINT, 302), - - /* HSTS write callback */ - CURLOPT(CURLOPT_HSTSWRITEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 303), - CURLOPT(CURLOPT_HSTSWRITEDATA, CURLOPTTYPE_CBPOINT, 304), - - /* Parameters for V4 signature */ - CURLOPT(CURLOPT_AWS_SIGV4, CURLOPTTYPE_STRINGPOINT, 305), - - /* Same as CURLOPT_SSL_VERIFYPEER but for DoH (DNS-over-HTTPS) servers. */ - CURLOPT(CURLOPT_DOH_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 306), - - /* Same as CURLOPT_SSL_VERIFYHOST but for DoH (DNS-over-HTTPS) servers. */ - CURLOPT(CURLOPT_DOH_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 307), - - /* Same as CURLOPT_SSL_VERIFYSTATUS but for DoH (DNS-over-HTTPS) servers. */ - CURLOPT(CURLOPT_DOH_SSL_VERIFYSTATUS, CURLOPTTYPE_LONG, 308), - - /* The CA certificates as "blob" used to validate the peer certificate - this option is used only if SSL_VERIFYPEER is true */ - CURLOPT(CURLOPT_CAINFO_BLOB, CURLOPTTYPE_BLOB, 309), - - /* The CA certificates as "blob" used to validate the proxy certificate - this option is used only if PROXY_SSL_VERIFYPEER is true */ - CURLOPT(CURLOPT_PROXY_CAINFO_BLOB, CURLOPTTYPE_BLOB, 310), - - /* used by scp/sftp to verify the host's public key */ - CURLOPT(CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256, CURLOPTTYPE_STRINGPOINT, 311), - - /* Function that will be called immediately before the initial request - is made on a connection (after any protocol negotiation step). */ - CURLOPT(CURLOPT_PREREQFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 312), - - /* Data passed to the CURLOPT_PREREQFUNCTION callback */ - CURLOPT(CURLOPT_PREREQDATA, CURLOPTTYPE_CBPOINT, 313), - - /* maximum age (since creation) of a connection to consider it for reuse - * (in seconds) */ - CURLOPT(CURLOPT_MAXLIFETIME_CONN, CURLOPTTYPE_LONG, 314), - - /* Set MIME option flags. */ - CURLOPT(CURLOPT_MIME_OPTIONS, CURLOPTTYPE_LONG, 315), - - /* set the SSH host key callback, must point to a curl_sshkeycallback - function */ - CURLOPT(CURLOPT_SSH_HOSTKEYFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 316), - - /* set the SSH host key callback custom pointer */ - CURLOPT(CURLOPT_SSH_HOSTKEYDATA, CURLOPTTYPE_CBPOINT, 317), - - /* specify which protocols that are allowed to be used for the transfer, - which thus helps the app which takes URLs from users or other external - inputs and want to restrict what protocol(s) to deal with. Defaults to - all built-in protocols. */ - CURLOPT(CURLOPT_PROTOCOLS_STR, CURLOPTTYPE_STRINGPOINT, 318), - - /* specify which protocols that libcurl is allowed to follow directs to */ - CURLOPT(CURLOPT_REDIR_PROTOCOLS_STR, CURLOPTTYPE_STRINGPOINT, 319), - - /* WebSockets options */ - CURLOPT(CURLOPT_WS_OPTIONS, CURLOPTTYPE_LONG, 320), - - /* CA cache timeout */ - CURLOPT(CURLOPT_CA_CACHE_TIMEOUT, CURLOPTTYPE_LONG, 321), - - /* Can leak things, gonna exit() soon */ - CURLOPT(CURLOPT_QUICK_EXIT, CURLOPTTYPE_LONG, 322), - - /* set a specific client IP for HAProxy PROXY protocol header? */ - CURLOPT(CURLOPT_HAPROXY_CLIENT_IP, CURLOPTTYPE_STRINGPOINT, 323), - - /* millisecond version */ - CURLOPT(CURLOPT_SERVER_RESPONSE_TIMEOUT_MS, CURLOPTTYPE_LONG, 324), - - /* set ECH configuration */ - CURLOPT(CURLOPT_ECH, CURLOPTTYPE_STRINGPOINT, 325), - - /* maximum number of keepalive probes (Linux, *BSD, macOS, etc.) */ - CURLOPT(CURLOPT_TCP_KEEPCNT, CURLOPTTYPE_LONG, 326), - - CURLOPT_LASTENTRY /* the last unused */ -} CURLoption; - -#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all - the obsolete stuff removed! */ - -/* Backwards compatibility with older names */ -/* These are scheduled to disappear by 2011 */ - -/* This was added in version 7.19.1 */ -#define CURLOPT_POST301 CURLOPT_POSTREDIR - -/* These are scheduled to disappear by 2009 */ - -/* The following were added in 7.17.0 */ -#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD -#define CURLOPT_FTPAPPEND CURLOPT_APPEND -#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY -#define CURLOPT_FTP_SSL CURLOPT_USE_SSL - -/* The following were added earlier */ - -#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD -#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL - -/* */ -#define CURLOPT_FTP_RESPONSE_TIMEOUT CURLOPT_SERVER_RESPONSE_TIMEOUT - -/* Added in 8.2.0 */ -#define CURLOPT_MAIL_RCPT_ALLLOWFAILS CURLOPT_MAIL_RCPT_ALLOWFAILS - -#else -/* This is set if CURL_NO_OLDIES is defined at compile-time */ -#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */ -#endif - - - /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host - name resolves addresses using more than one IP protocol version, this - option might be handy to force libcurl to use a specific IP version. */ -#define CURL_IPRESOLVE_WHATEVER 0 /* default, uses addresses to all IP - versions that your system allows */ -#define CURL_IPRESOLVE_V4 1 /* uses only IPv4 addresses/connections */ -#define CURL_IPRESOLVE_V6 2 /* uses only IPv6 addresses/connections */ - - /* Convenient "aliases" */ -#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER - - /* These enums are for use with the CURLOPT_HTTP_VERSION option. */ -enum { - CURL_HTTP_VERSION_NONE, /* setting this means we do not care, and that we - would like the library to choose the best - possible for us! */ - CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */ - CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */ - CURL_HTTP_VERSION_2_0, /* please use HTTP 2 in the request */ - CURL_HTTP_VERSION_2TLS, /* use version 2 for HTTPS, version 1.1 for HTTP */ - CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE, /* please use HTTP 2 without HTTP/1.1 - Upgrade */ - CURL_HTTP_VERSION_3 = 30, /* Use HTTP/3, fallback to HTTP/2 or HTTP/1 if - needed. For HTTPS only. For HTTP, this option - makes libcurl return error. */ - CURL_HTTP_VERSION_3ONLY = 31, /* Use HTTP/3 without fallback. For HTTPS - only. For HTTP, this makes libcurl - return error. */ - - CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */ -}; - -/* Convenience definition simple because the name of the version is HTTP/2 and - not 2.0. The 2_0 version of the enum name was set while the version was - still planned to be 2.0 and we stick to it for compatibility. */ -#define CURL_HTTP_VERSION_2 CURL_HTTP_VERSION_2_0 - -/* - * Public API enums for RTSP requests - */ -enum { - CURL_RTSPREQ_NONE, /* first in list */ - CURL_RTSPREQ_OPTIONS, - CURL_RTSPREQ_DESCRIBE, - CURL_RTSPREQ_ANNOUNCE, - CURL_RTSPREQ_SETUP, - CURL_RTSPREQ_PLAY, - CURL_RTSPREQ_PAUSE, - CURL_RTSPREQ_TEARDOWN, - CURL_RTSPREQ_GET_PARAMETER, - CURL_RTSPREQ_SET_PARAMETER, - CURL_RTSPREQ_RECORD, - CURL_RTSPREQ_RECEIVE, - CURL_RTSPREQ_LAST /* last in list */ -}; - - /* These enums are for use with the CURLOPT_NETRC option. */ -enum CURL_NETRC_OPTION { - CURL_NETRC_IGNORED, /* The .netrc will never be read. - * This is the default. */ - CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred - * to one in the .netrc. */ - CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored. - * Unless one is set programmatically, the .netrc - * will be queried. */ - CURL_NETRC_LAST -}; - -#define CURL_SSLVERSION_DEFAULT 0 -#define CURL_SSLVERSION_TLSv1 1 /* TLS 1.x */ -#define CURL_SSLVERSION_SSLv2 2 -#define CURL_SSLVERSION_SSLv3 3 -#define CURL_SSLVERSION_TLSv1_0 4 -#define CURL_SSLVERSION_TLSv1_1 5 -#define CURL_SSLVERSION_TLSv1_2 6 -#define CURL_SSLVERSION_TLSv1_3 7 - -#define CURL_SSLVERSION_LAST 8 /* never use, keep last */ - -#define CURL_SSLVERSION_MAX_NONE 0 -#define CURL_SSLVERSION_MAX_DEFAULT (CURL_SSLVERSION_TLSv1 << 16) -#define CURL_SSLVERSION_MAX_TLSv1_0 (CURL_SSLVERSION_TLSv1_0 << 16) -#define CURL_SSLVERSION_MAX_TLSv1_1 (CURL_SSLVERSION_TLSv1_1 << 16) -#define CURL_SSLVERSION_MAX_TLSv1_2 (CURL_SSLVERSION_TLSv1_2 << 16) -#define CURL_SSLVERSION_MAX_TLSv1_3 (CURL_SSLVERSION_TLSv1_3 << 16) - - /* never use, keep last */ -#define CURL_SSLVERSION_MAX_LAST (CURL_SSLVERSION_LAST << 16) - -enum CURL_TLSAUTH { - CURL_TLSAUTH_NONE, - CURL_TLSAUTH_SRP, - CURL_TLSAUTH_LAST /* never use, keep last */ -}; - -/* symbols to use with CURLOPT_POSTREDIR. - CURL_REDIR_POST_301, CURL_REDIR_POST_302 and CURL_REDIR_POST_303 - can be bitwise ORed so that CURL_REDIR_POST_301 | CURL_REDIR_POST_302 - | CURL_REDIR_POST_303 == CURL_REDIR_POST_ALL */ - -#define CURL_REDIR_GET_ALL 0 -#define CURL_REDIR_POST_301 1 -#define CURL_REDIR_POST_302 2 -#define CURL_REDIR_POST_303 4 -#define CURL_REDIR_POST_ALL \ - (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303) - -typedef enum { - CURL_TIMECOND_NONE, - - CURL_TIMECOND_IFMODSINCE, - CURL_TIMECOND_IFUNMODSINCE, - CURL_TIMECOND_LASTMOD, - - CURL_TIMECOND_LAST -} curl_TimeCond; - -/* Special size_t value signaling a null-terminated string. */ -#define CURL_ZERO_TERMINATED ((size_t) -1) - -/* curl_strequal() and curl_strnequal() are subject for removal in a future - release */ -CURL_EXTERN int curl_strequal(const char *s1, const char *s2); -CURL_EXTERN int curl_strnequal(const char *s1, const char *s2, size_t n); - -/* Mime/form handling support. */ -typedef struct curl_mime curl_mime; /* Mime context. */ -typedef struct curl_mimepart curl_mimepart; /* Mime part context. */ - -/* CURLMIMEOPT_ defines are for the CURLOPT_MIME_OPTIONS option. */ -#define CURLMIMEOPT_FORMESCAPE (1<<0) /* Use backslash-escaping for forms. */ - -/* - * NAME curl_mime_init() - * - * DESCRIPTION - * - * Create a mime context and return its handle. The easy parameter is the - * target handle. - */ -CURL_EXTERN curl_mime *curl_mime_init(CURL *easy); - -/* - * NAME curl_mime_free() - * - * DESCRIPTION - * - * release a mime handle and its substructures. - */ -CURL_EXTERN void curl_mime_free(curl_mime *mime); - -/* - * NAME curl_mime_addpart() - * - * DESCRIPTION - * - * Append a new empty part to the given mime context and return a handle to - * the created part. - */ -CURL_EXTERN curl_mimepart *curl_mime_addpart(curl_mime *mime); - -/* - * NAME curl_mime_name() - * - * DESCRIPTION - * - * Set mime/form part name. - */ -CURL_EXTERN CURLcode curl_mime_name(curl_mimepart *part, const char *name); - -/* - * NAME curl_mime_filename() - * - * DESCRIPTION - * - * Set mime part remote filename. - */ -CURL_EXTERN CURLcode curl_mime_filename(curl_mimepart *part, - const char *filename); - -/* - * NAME curl_mime_type() - * - * DESCRIPTION - * - * Set mime part type. - */ -CURL_EXTERN CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype); - -/* - * NAME curl_mime_encoder() - * - * DESCRIPTION - * - * Set mime data transfer encoder. - */ -CURL_EXTERN CURLcode curl_mime_encoder(curl_mimepart *part, - const char *encoding); - -/* - * NAME curl_mime_data() - * - * DESCRIPTION - * - * Set mime part data source from memory data, - */ -CURL_EXTERN CURLcode curl_mime_data(curl_mimepart *part, - const char *data, size_t datasize); - -/* - * NAME curl_mime_filedata() - * - * DESCRIPTION - * - * Set mime part data source from named file. - */ -CURL_EXTERN CURLcode curl_mime_filedata(curl_mimepart *part, - const char *filename); - -/* - * NAME curl_mime_data_cb() - * - * DESCRIPTION - * - * Set mime part data source from callback function. - */ -CURL_EXTERN CURLcode curl_mime_data_cb(curl_mimepart *part, - curl_off_t datasize, - curl_read_callback readfunc, - curl_seek_callback seekfunc, - curl_free_callback freefunc, - void *arg); - -/* - * NAME curl_mime_subparts() - * - * DESCRIPTION - * - * Set mime part data source from subparts. - */ -CURL_EXTERN CURLcode curl_mime_subparts(curl_mimepart *part, - curl_mime *subparts); -/* - * NAME curl_mime_headers() - * - * DESCRIPTION - * - * Set mime part headers. - */ -CURL_EXTERN CURLcode curl_mime_headers(curl_mimepart *part, - struct curl_slist *headers, - int take_ownership); - -typedef enum { - /********* the first one is unused ************/ - CURLFORM_NOTHING CURL_DEPRECATED(7.56.0, ""), - CURLFORM_COPYNAME CURL_DEPRECATED(7.56.0, "Use curl_mime_name()"), - CURLFORM_PTRNAME CURL_DEPRECATED(7.56.0, "Use curl_mime_name()"), - CURLFORM_NAMELENGTH CURL_DEPRECATED(7.56.0, ""), - CURLFORM_COPYCONTENTS CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), - CURLFORM_PTRCONTENTS CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), - CURLFORM_CONTENTSLENGTH CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), - CURLFORM_FILECONTENT CURL_DEPRECATED(7.56.0, "Use curl_mime_data_cb()"), - CURLFORM_ARRAY CURL_DEPRECATED(7.56.0, ""), - CURLFORM_OBSOLETE, - CURLFORM_FILE CURL_DEPRECATED(7.56.0, "Use curl_mime_filedata()"), - - CURLFORM_BUFFER CURL_DEPRECATED(7.56.0, "Use curl_mime_filename()"), - CURLFORM_BUFFERPTR CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), - CURLFORM_BUFFERLENGTH CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), - - CURLFORM_CONTENTTYPE CURL_DEPRECATED(7.56.0, "Use curl_mime_type()"), - CURLFORM_CONTENTHEADER CURL_DEPRECATED(7.56.0, "Use curl_mime_headers()"), - CURLFORM_FILENAME CURL_DEPRECATED(7.56.0, "Use curl_mime_filename()"), - CURLFORM_END, - CURLFORM_OBSOLETE2, - - CURLFORM_STREAM CURL_DEPRECATED(7.56.0, "Use curl_mime_data_cb()"), - CURLFORM_CONTENTLEN /* added in 7.46.0, provide a curl_off_t length */ - CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"), - - CURLFORM_LASTENTRY /* the last unused */ -} CURLformoption; - -/* structure to be used as parameter for CURLFORM_ARRAY */ -struct curl_forms { - CURLformoption option; - const char *value; -}; - -/* use this for multipart formpost building */ -/* Returns code for curl_formadd() - * - * Returns: - * CURL_FORMADD_OK on success - * CURL_FORMADD_MEMORY if the FormInfo allocation fails - * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form - * CURL_FORMADD_NULL if a null pointer was given for a char - * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed - * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used - * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error) - * CURL_FORMADD_MEMORY if a curl_httppost struct cannot be allocated - * CURL_FORMADD_MEMORY if some allocation for string copying failed. - * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array - * - ***************************************************************************/ -typedef enum { - CURL_FORMADD_OK CURL_DEPRECATED(7.56.0, ""), /* 1st, no error */ - - CURL_FORMADD_MEMORY CURL_DEPRECATED(7.56.0, ""), - CURL_FORMADD_OPTION_TWICE CURL_DEPRECATED(7.56.0, ""), - CURL_FORMADD_NULL CURL_DEPRECATED(7.56.0, ""), - CURL_FORMADD_UNKNOWN_OPTION CURL_DEPRECATED(7.56.0, ""), - CURL_FORMADD_INCOMPLETE CURL_DEPRECATED(7.56.0, ""), - CURL_FORMADD_ILLEGAL_ARRAY CURL_DEPRECATED(7.56.0, ""), - /* libcurl was built with form api disabled */ - CURL_FORMADD_DISABLED CURL_DEPRECATED(7.56.0, ""), - - CURL_FORMADD_LAST /* last */ -} CURLFORMcode; - -/* - * NAME curl_formadd() - * - * DESCRIPTION - * - * Pretty advanced function for building multi-part formposts. Each invoke - * adds one part that together construct a full post. Then use - * CURLOPT_HTTPPOST to send it off to libcurl. - */ -CURL_EXTERN CURLFORMcode CURL_DEPRECATED(7.56.0, "Use curl_mime_init()") -curl_formadd(struct curl_httppost **httppost, - struct curl_httppost **last_post, - ...); - -/* - * callback function for curl_formget() - * The void *arg pointer will be the one passed as second argument to - * curl_formget(). - * The character buffer passed to it must not be freed. - * Should return the buffer length passed to it as the argument "len" on - * success. - */ -typedef size_t (*curl_formget_callback)(void *arg, const char *buf, - size_t len); - -/* - * NAME curl_formget() - * - * DESCRIPTION - * - * Serialize a curl_httppost struct built with curl_formadd(). - * Accepts a void pointer as second argument which will be passed to - * the curl_formget_callback function. - * Returns 0 on success. - */ -CURL_EXTERN int CURL_DEPRECATED(7.56.0, "") -curl_formget(struct curl_httppost *form, void *arg, - curl_formget_callback append); -/* - * NAME curl_formfree() - * - * DESCRIPTION - * - * Free a multipart formpost previously built with curl_formadd(). - */ -CURL_EXTERN void CURL_DEPRECATED(7.56.0, "Use curl_mime_free()") -curl_formfree(struct curl_httppost *form); - -/* - * NAME curl_getenv() - * - * DESCRIPTION - * - * Returns a malloc()'ed string that MUST be curl_free()ed after usage is - * complete. DEPRECATED - see lib/README.curlx - */ -CURL_EXTERN char *curl_getenv(const char *variable); - -/* - * NAME curl_version() - * - * DESCRIPTION - * - * Returns a static ASCII string of the libcurl version. - */ -CURL_EXTERN char *curl_version(void); - -/* - * NAME curl_easy_escape() - * - * DESCRIPTION - * - * Escapes URL strings (converts all letters consider illegal in URLs to their - * %XX versions). This function returns a new allocated string or NULL if an - * error occurred. - */ -CURL_EXTERN char *curl_easy_escape(CURL *handle, - const char *string, - int length); - -/* the previous version: */ -CURL_EXTERN char *curl_escape(const char *string, - int length); - - -/* - * NAME curl_easy_unescape() - * - * DESCRIPTION - * - * Unescapes URL encoding in strings (converts all %XX codes to their 8bit - * versions). This function returns a new allocated string or NULL if an error - * occurred. - * Conversion Note: On non-ASCII platforms the ASCII %XX codes are - * converted into the host encoding. - */ -CURL_EXTERN char *curl_easy_unescape(CURL *handle, - const char *string, - int length, - int *outlength); - -/* the previous version */ -CURL_EXTERN char *curl_unescape(const char *string, - int length); - -/* - * NAME curl_free() - * - * DESCRIPTION - * - * Provided for de-allocation in the same translation unit that did the - * allocation. Added in libcurl 7.10 - */ -CURL_EXTERN void curl_free(void *p); - -/* - * NAME curl_global_init() - * - * DESCRIPTION - * - * curl_global_init() should be invoked exactly once for each application that - * uses libcurl and before any call of other libcurl functions. - - * This function is thread-safe if CURL_VERSION_THREADSAFE is set in the - * curl_version_info_data.features flag (fetch by curl_version_info()). - - */ -CURL_EXTERN CURLcode curl_global_init(long flags); - -/* - * NAME curl_global_init_mem() - * - * DESCRIPTION - * - * curl_global_init() or curl_global_init_mem() should be invoked exactly once - * for each application that uses libcurl. This function can be used to - * initialize libcurl and set user defined memory management callback - * functions. Users can implement memory management routines to check for - * memory leaks, check for mis-use of the curl library etc. User registered - * callback routines will be invoked by this library instead of the system - * memory management routines like malloc, free etc. - */ -CURL_EXTERN CURLcode curl_global_init_mem(long flags, - curl_malloc_callback m, - curl_free_callback f, - curl_realloc_callback r, - curl_strdup_callback s, - curl_calloc_callback c); - -/* - * NAME curl_global_cleanup() - * - * DESCRIPTION - * - * curl_global_cleanup() should be invoked exactly once for each application - * that uses libcurl - */ -CURL_EXTERN void curl_global_cleanup(void); - -/* - * NAME curl_global_trace() - * - * DESCRIPTION - * - * curl_global_trace() can be invoked at application start to - * configure which components in curl should participate in tracing. - - * This function is thread-safe if CURL_VERSION_THREADSAFE is set in the - * curl_version_info_data.features flag (fetch by curl_version_info()). - - */ -CURL_EXTERN CURLcode curl_global_trace(const char *config); - -/* linked-list structure for the CURLOPT_QUOTE option (and other) */ -struct curl_slist { - char *data; - struct curl_slist *next; -}; - -/* - * NAME curl_global_sslset() - * - * DESCRIPTION - * - * When built with multiple SSL backends, curl_global_sslset() allows to - * choose one. This function can only be called once, and it must be called - * *before* curl_global_init(). - * - * The backend can be identified by the id (e.g. CURLSSLBACKEND_OPENSSL). The - * backend can also be specified via the name parameter (passing -1 as id). - * If both id and name are specified, the name will be ignored. If neither id - * nor name are specified, the function will fail with - * CURLSSLSET_UNKNOWN_BACKEND and set the "avail" pointer to the - * NULL-terminated list of available backends. - * - * Upon success, the function returns CURLSSLSET_OK. - * - * If the specified SSL backend is not available, the function returns - * CURLSSLSET_UNKNOWN_BACKEND and sets the "avail" pointer to a NULL-terminated - * list of available SSL backends. - * - * The SSL backend can be set only once. If it has already been set, a - * subsequent attempt to change it will result in a CURLSSLSET_TOO_LATE. - */ - -struct curl_ssl_backend { - curl_sslbackend id; - const char *name; -}; -typedef struct curl_ssl_backend curl_ssl_backend; - -typedef enum { - CURLSSLSET_OK = 0, - CURLSSLSET_UNKNOWN_BACKEND, - CURLSSLSET_TOO_LATE, - CURLSSLSET_NO_BACKENDS /* libcurl was built without any SSL support */ -} CURLsslset; - -CURL_EXTERN CURLsslset curl_global_sslset(curl_sslbackend id, const char *name, - const curl_ssl_backend ***avail); - -/* - * NAME curl_slist_append() - * - * DESCRIPTION - * - * Appends a string to a linked list. If no list exists, it will be created - * first. Returns the new list, after appending. - */ -CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *list, - const char *data); - -/* - * NAME curl_slist_free_all() - * - * DESCRIPTION - * - * free a previously built curl_slist. - */ -CURL_EXTERN void curl_slist_free_all(struct curl_slist *list); - -/* - * NAME curl_getdate() - * - * DESCRIPTION - * - * Returns the time, in seconds since 1 Jan 1970 of the time string given in - * the first argument. The time argument in the second parameter is unused - * and should be set to NULL. - */ -CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused); - -/* info about the certificate chain, for SSL backends that support it. Asked - for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */ -struct curl_certinfo { - int num_of_certs; /* number of certificates with information */ - struct curl_slist **certinfo; /* for each index in this array, there is a - linked list with textual information for a - certificate in the format "name:content". - eg "Subject:foo", "Issuer:bar", etc. */ -}; - -/* Information about the SSL library used and the respective internal SSL - handle, which can be used to obtain further information regarding the - connection. Asked for with CURLINFO_TLS_SSL_PTR or CURLINFO_TLS_SESSION. */ -struct curl_tlssessioninfo { - curl_sslbackend backend; - void *internals; -}; - -#define CURLINFO_STRING 0x100000 -#define CURLINFO_LONG 0x200000 -#define CURLINFO_DOUBLE 0x300000 -#define CURLINFO_SLIST 0x400000 -#define CURLINFO_PTR 0x400000 /* same as SLIST */ -#define CURLINFO_SOCKET 0x500000 -#define CURLINFO_OFF_T 0x600000 -#define CURLINFO_MASK 0x0fffff -#define CURLINFO_TYPEMASK 0xf00000 - -typedef enum { - CURLINFO_NONE, /* first, never use this */ - CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1, - CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2, - CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3, - CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4, - CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5, - CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6, - CURLINFO_SIZE_UPLOAD CURL_DEPRECATED(7.55.0, "Use CURLINFO_SIZE_UPLOAD_T") - = CURLINFO_DOUBLE + 7, - CURLINFO_SIZE_UPLOAD_T = CURLINFO_OFF_T + 7, - CURLINFO_SIZE_DOWNLOAD - CURL_DEPRECATED(7.55.0, "Use CURLINFO_SIZE_DOWNLOAD_T") - = CURLINFO_DOUBLE + 8, - CURLINFO_SIZE_DOWNLOAD_T = CURLINFO_OFF_T + 8, - CURLINFO_SPEED_DOWNLOAD - CURL_DEPRECATED(7.55.0, "Use CURLINFO_SPEED_DOWNLOAD_T") - = CURLINFO_DOUBLE + 9, - CURLINFO_SPEED_DOWNLOAD_T = CURLINFO_OFF_T + 9, - CURLINFO_SPEED_UPLOAD - CURL_DEPRECATED(7.55.0, "Use CURLINFO_SPEED_UPLOAD_T") - = CURLINFO_DOUBLE + 10, - CURLINFO_SPEED_UPLOAD_T = CURLINFO_OFF_T + 10, - CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11, - CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12, - CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13, - CURLINFO_FILETIME = CURLINFO_LONG + 14, - CURLINFO_FILETIME_T = CURLINFO_OFF_T + 14, - CURLINFO_CONTENT_LENGTH_DOWNLOAD - CURL_DEPRECATED(7.55.0, - "Use CURLINFO_CONTENT_LENGTH_DOWNLOAD_T") - = CURLINFO_DOUBLE + 15, - CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = CURLINFO_OFF_T + 15, - CURLINFO_CONTENT_LENGTH_UPLOAD - CURL_DEPRECATED(7.55.0, - "Use CURLINFO_CONTENT_LENGTH_UPLOAD_T") - = CURLINFO_DOUBLE + 16, - CURLINFO_CONTENT_LENGTH_UPLOAD_T = CURLINFO_OFF_T + 16, - CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17, - CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18, - CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19, - CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20, - CURLINFO_PRIVATE = CURLINFO_STRING + 21, - CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22, - CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23, - CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24, - CURLINFO_OS_ERRNO = CURLINFO_LONG + 25, - CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26, - CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27, - CURLINFO_COOKIELIST = CURLINFO_SLIST + 28, - CURLINFO_LASTSOCKET CURL_DEPRECATED(7.45.0, "Use CURLINFO_ACTIVESOCKET") - = CURLINFO_LONG + 29, - CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30, - CURLINFO_REDIRECT_URL = CURLINFO_STRING + 31, - CURLINFO_PRIMARY_IP = CURLINFO_STRING + 32, - CURLINFO_APPCONNECT_TIME = CURLINFO_DOUBLE + 33, - CURLINFO_CERTINFO = CURLINFO_PTR + 34, - CURLINFO_CONDITION_UNMET = CURLINFO_LONG + 35, - CURLINFO_RTSP_SESSION_ID = CURLINFO_STRING + 36, - CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG + 37, - CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG + 38, - CURLINFO_RTSP_CSEQ_RECV = CURLINFO_LONG + 39, - CURLINFO_PRIMARY_PORT = CURLINFO_LONG + 40, - CURLINFO_LOCAL_IP = CURLINFO_STRING + 41, - CURLINFO_LOCAL_PORT = CURLINFO_LONG + 42, - CURLINFO_TLS_SESSION CURL_DEPRECATED(7.48.0, "Use CURLINFO_TLS_SSL_PTR") - = CURLINFO_PTR + 43, - CURLINFO_ACTIVESOCKET = CURLINFO_SOCKET + 44, - CURLINFO_TLS_SSL_PTR = CURLINFO_PTR + 45, - CURLINFO_HTTP_VERSION = CURLINFO_LONG + 46, - CURLINFO_PROXY_SSL_VERIFYRESULT = CURLINFO_LONG + 47, - CURLINFO_PROTOCOL CURL_DEPRECATED(7.85.0, "Use CURLINFO_SCHEME") - = CURLINFO_LONG + 48, - CURLINFO_SCHEME = CURLINFO_STRING + 49, - CURLINFO_TOTAL_TIME_T = CURLINFO_OFF_T + 50, - CURLINFO_NAMELOOKUP_TIME_T = CURLINFO_OFF_T + 51, - CURLINFO_CONNECT_TIME_T = CURLINFO_OFF_T + 52, - CURLINFO_PRETRANSFER_TIME_T = CURLINFO_OFF_T + 53, - CURLINFO_STARTTRANSFER_TIME_T = CURLINFO_OFF_T + 54, - CURLINFO_REDIRECT_TIME_T = CURLINFO_OFF_T + 55, - CURLINFO_APPCONNECT_TIME_T = CURLINFO_OFF_T + 56, - CURLINFO_RETRY_AFTER = CURLINFO_OFF_T + 57, - CURLINFO_EFFECTIVE_METHOD = CURLINFO_STRING + 58, - CURLINFO_PROXY_ERROR = CURLINFO_LONG + 59, - CURLINFO_REFERER = CURLINFO_STRING + 60, - CURLINFO_CAINFO = CURLINFO_STRING + 61, - CURLINFO_CAPATH = CURLINFO_STRING + 62, - CURLINFO_XFER_ID = CURLINFO_OFF_T + 63, - CURLINFO_CONN_ID = CURLINFO_OFF_T + 64, - CURLINFO_QUEUE_TIME_T = CURLINFO_OFF_T + 65, - CURLINFO_USED_PROXY = CURLINFO_LONG + 66, - CURLINFO_POSTTRANSFER_TIME_T = CURLINFO_OFF_T + 67, - CURLINFO_EARLYDATA_SENT_T = CURLINFO_OFF_T + 68, - CURLINFO_HTTPAUTH_USED = CURLINFO_LONG + 69, - CURLINFO_PROXYAUTH_USED = CURLINFO_LONG + 70, - CURLINFO_LASTONE = 70 -} CURLINFO; - -/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as - CURLINFO_HTTP_CODE */ -#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE - -typedef enum { - CURLCLOSEPOLICY_NONE, /* first, never use this */ - - CURLCLOSEPOLICY_OLDEST, - CURLCLOSEPOLICY_LEAST_RECENTLY_USED, - CURLCLOSEPOLICY_LEAST_TRAFFIC, - CURLCLOSEPOLICY_SLOWEST, - CURLCLOSEPOLICY_CALLBACK, - - CURLCLOSEPOLICY_LAST /* last, never use this */ -} curl_closepolicy; - -#define CURL_GLOBAL_SSL (1<<0) /* no purpose since 7.57.0 */ -#define CURL_GLOBAL_WIN32 (1<<1) -#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32) -#define CURL_GLOBAL_NOTHING 0 -#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL -#define CURL_GLOBAL_ACK_EINTR (1<<2) - - -/***************************************************************************** - * Setup defines, protos etc for the sharing stuff. - */ - -/* Different data locks for a single share */ -typedef enum { - CURL_LOCK_DATA_NONE = 0, - /* CURL_LOCK_DATA_SHARE is used internally to say that - * the locking is just made to change the internal state of the share - * itself. - */ - CURL_LOCK_DATA_SHARE, - CURL_LOCK_DATA_COOKIE, - CURL_LOCK_DATA_DNS, - CURL_LOCK_DATA_SSL_SESSION, - CURL_LOCK_DATA_CONNECT, - CURL_LOCK_DATA_PSL, - CURL_LOCK_DATA_HSTS, - CURL_LOCK_DATA_LAST -} curl_lock_data; - -/* Different lock access types */ -typedef enum { - CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */ - CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */ - CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */ - CURL_LOCK_ACCESS_LAST /* never use */ -} curl_lock_access; - -typedef void (*curl_lock_function)(CURL *handle, - curl_lock_data data, - curl_lock_access locktype, - void *userptr); -typedef void (*curl_unlock_function)(CURL *handle, - curl_lock_data data, - void *userptr); - - -typedef enum { - CURLSHE_OK, /* all is fine */ - CURLSHE_BAD_OPTION, /* 1 */ - CURLSHE_IN_USE, /* 2 */ - CURLSHE_INVALID, /* 3 */ - CURLSHE_NOMEM, /* 4 out of memory */ - CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */ - CURLSHE_LAST /* never use */ -} CURLSHcode; - -typedef enum { - CURLSHOPT_NONE, /* do not use */ - CURLSHOPT_SHARE, /* specify a data type to share */ - CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */ - CURLSHOPT_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */ - CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */ - CURLSHOPT_USERDATA, /* pass in a user data pointer used in the lock/unlock - callback functions */ - CURLSHOPT_LAST /* never use */ -} CURLSHoption; - -CURL_EXTERN CURLSH *curl_share_init(void); -CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *share, CURLSHoption option, - ...); -CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *share); - -/**************************************************************************** - * Structures for querying information about the curl library at runtime. - */ - -typedef enum { - CURLVERSION_FIRST, /* 7.10 */ - CURLVERSION_SECOND, /* 7.11.1 */ - CURLVERSION_THIRD, /* 7.12.0 */ - CURLVERSION_FOURTH, /* 7.16.1 */ - CURLVERSION_FIFTH, /* 7.57.0 */ - CURLVERSION_SIXTH, /* 7.66.0 */ - CURLVERSION_SEVENTH, /* 7.70.0 */ - CURLVERSION_EIGHTH, /* 7.72.0 */ - CURLVERSION_NINTH, /* 7.75.0 */ - CURLVERSION_TENTH, /* 7.77.0 */ - CURLVERSION_ELEVENTH, /* 7.87.0 */ - CURLVERSION_TWELFTH, /* 8.8.0 */ - CURLVERSION_LAST /* never actually use this */ -} CURLversion; - -/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by - basically all programs ever that want to get version information. It is - meant to be a built-in version number for what kind of struct the caller - expects. If the struct ever changes, we redefine the NOW to another enum - from above. */ -#define CURLVERSION_NOW CURLVERSION_TWELFTH - -struct curl_version_info_data { - CURLversion age; /* age of the returned struct */ - const char *version; /* LIBCURL_VERSION */ - unsigned int version_num; /* LIBCURL_VERSION_NUM */ - const char *host; /* OS/host/cpu/machine when configured */ - int features; /* bitmask, see defines below */ - const char *ssl_version; /* human readable string */ - long ssl_version_num; /* not used anymore, always 0 */ - const char *libz_version; /* human readable string */ - /* protocols is terminated by an entry with a NULL protoname */ - const char * const *protocols; - - /* The fields below this were added in CURLVERSION_SECOND */ - const char *ares; - int ares_num; - - /* This field was added in CURLVERSION_THIRD */ - const char *libidn; - - /* These field were added in CURLVERSION_FOURTH */ - - /* Same as '_libiconv_version' if built with HAVE_ICONV */ - int iconv_ver_num; - - const char *libssh_version; /* human readable string */ - - /* These fields were added in CURLVERSION_FIFTH */ - unsigned int brotli_ver_num; /* Numeric Brotli version - (MAJOR << 24) | (MINOR << 12) | PATCH */ - const char *brotli_version; /* human readable string. */ - - /* These fields were added in CURLVERSION_SIXTH */ - unsigned int nghttp2_ver_num; /* Numeric nghttp2 version - (MAJOR << 16) | (MINOR << 8) | PATCH */ - const char *nghttp2_version; /* human readable string. */ - const char *quic_version; /* human readable quic (+ HTTP/3) library + - version or NULL */ - - /* These fields were added in CURLVERSION_SEVENTH */ - const char *cainfo; /* the built-in default CURLOPT_CAINFO, might - be NULL */ - const char *capath; /* the built-in default CURLOPT_CAPATH, might - be NULL */ - - /* These fields were added in CURLVERSION_EIGHTH */ - unsigned int zstd_ver_num; /* Numeric Zstd version - (MAJOR << 24) | (MINOR << 12) | PATCH */ - const char *zstd_version; /* human readable string. */ - - /* These fields were added in CURLVERSION_NINTH */ - const char *hyper_version; /* human readable string. */ - - /* These fields were added in CURLVERSION_TENTH */ - const char *gsasl_version; /* human readable string. */ - - /* These fields were added in CURLVERSION_ELEVENTH */ - /* feature_names is terminated by an entry with a NULL feature name */ - const char * const *feature_names; - - /* These fields were added in CURLVERSION_TWELFTH */ - const char *rtmp_version; /* human readable string. */ -}; -typedef struct curl_version_info_data curl_version_info_data; - -#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */ -#define CURL_VERSION_KERBEROS4 (1<<1) /* Kerberos V4 auth is supported - (deprecated) */ -#define CURL_VERSION_SSL (1<<2) /* SSL options are present */ -#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */ -#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */ -#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth is supported - (deprecated) */ -#define CURL_VERSION_DEBUG (1<<6) /* Built with debug capabilities */ -#define CURL_VERSION_ASYNCHDNS (1<<7) /* Asynchronous DNS resolves */ -#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth is supported */ -#define CURL_VERSION_LARGEFILE (1<<9) /* Supports files larger than 2GB */ -#define CURL_VERSION_IDN (1<<10) /* Internationized Domain Names are - supported */ -#define CURL_VERSION_SSPI (1<<11) /* Built against Windows SSPI */ -#define CURL_VERSION_CONV (1<<12) /* Character conversions supported */ -#define CURL_VERSION_CURLDEBUG (1<<13) /* Debug memory tracking supported */ -#define CURL_VERSION_TLSAUTH_SRP (1<<14) /* TLS-SRP auth is supported */ -#define CURL_VERSION_NTLM_WB (1<<15) /* NTLM delegation to winbind helper - is supported */ -#define CURL_VERSION_HTTP2 (1<<16) /* HTTP2 support built-in */ -#define CURL_VERSION_GSSAPI (1<<17) /* Built against a GSS-API library */ -#define CURL_VERSION_KERBEROS5 (1<<18) /* Kerberos V5 auth is supported */ -#define CURL_VERSION_UNIX_SOCKETS (1<<19) /* Unix domain sockets support */ -#define CURL_VERSION_PSL (1<<20) /* Mozilla's Public Suffix List, used - for cookie domain verification */ -#define CURL_VERSION_HTTPS_PROXY (1<<21) /* HTTPS-proxy support built-in */ -#define CURL_VERSION_MULTI_SSL (1<<22) /* Multiple SSL backends available */ -#define CURL_VERSION_BROTLI (1<<23) /* Brotli features are present. */ -#define CURL_VERSION_ALTSVC (1<<24) /* Alt-Svc handling built-in */ -#define CURL_VERSION_HTTP3 (1<<25) /* HTTP3 support built-in */ -#define CURL_VERSION_ZSTD (1<<26) /* zstd features are present */ -#define CURL_VERSION_UNICODE (1<<27) /* Unicode support on Windows */ -#define CURL_VERSION_HSTS (1<<28) /* HSTS is supported */ -#define CURL_VERSION_GSASL (1<<29) /* libgsasl is supported */ -#define CURL_VERSION_THREADSAFE (1<<30) /* libcurl API is thread-safe */ - -/* - * NAME curl_version_info() - * - * DESCRIPTION - * - * This function returns a pointer to a static copy of the version info - * struct. See above. - */ -CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion); - -/* - * NAME curl_easy_strerror() - * - * DESCRIPTION - * - * The curl_easy_strerror function may be used to turn a CURLcode value - * into the equivalent human readable error string. This is useful - * for printing meaningful error messages. - */ -CURL_EXTERN const char *curl_easy_strerror(CURLcode); - -/* - * NAME curl_share_strerror() - * - * DESCRIPTION - * - * The curl_share_strerror function may be used to turn a CURLSHcode value - * into the equivalent human readable error string. This is useful - * for printing meaningful error messages. - */ -CURL_EXTERN const char *curl_share_strerror(CURLSHcode); - -/* - * NAME curl_easy_pause() - * - * DESCRIPTION - * - * The curl_easy_pause function pauses or unpauses transfers. Select the new - * state by setting the bitmask, use the convenience defines below. - * - */ -CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask); - -#define CURLPAUSE_RECV (1<<0) -#define CURLPAUSE_RECV_CONT (0) - -#define CURLPAUSE_SEND (1<<2) -#define CURLPAUSE_SEND_CONT (0) - -#define CURLPAUSE_ALL (CURLPAUSE_RECV|CURLPAUSE_SEND) -#define CURLPAUSE_CONT (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT) - -/* - * NAME curl_easy_ssls_import() - * - * DESCRIPTION - * - * The curl_easy_ssls_import function adds a previously exported SSL session - * to the SSL session cache of the easy handle (or the underlying share). - */ -CURL_EXTERN CURLcode curl_easy_ssls_import(CURL *handle, - const char *session_key, - const unsigned char *shmac, - size_t shmac_len, - const unsigned char *sdata, - size_t sdata_len); - -/* This is the curl_ssls_export_cb callback prototype. It - * is passed to curl_easy_ssls_export() to extract SSL sessions/tickets. */ -typedef CURLcode curl_ssls_export_cb(CURL *handle, - void *userptr, - const char *session_key, - const unsigned char *shmac, - size_t shmac_len, - const unsigned char *sdata, - size_t sdata_len, - curl_off_t valid_until, - int ietf_tls_id, - const char *alpn, - size_t earlydata_max); - -/* - * NAME curl_easy_ssls_export() - * - * DESCRIPTION - * - * The curl_easy_ssls_export function iterates over all SSL sessions stored - * in the easy handle (or underlying share) and invokes the passed - * callback. - * - */ -CURL_EXTERN CURLcode curl_easy_ssls_export(CURL *handle, - curl_ssls_export_cb *export_fn, - void *userptr); - - -#ifdef __cplusplus -} /* end of extern "C" */ -#endif - -/* unfortunately, the easy.h and multi.h include files need options and info - stuff before they can be included! */ -#include "easy.h" /* nothing in curl is fun without the easy stuff */ -#include "multi.h" -#include "urlapi.h" -#include "options.h" -#include "header.h" -#include "websockets.h" -#ifndef CURL_SKIP_INCLUDE_MPRINTF -#include "mprintf.h" -#endif - -/* the typechecker does not work in C++ (yet) */ -#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \ - ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \ - !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK) -#include "typecheck-gcc.h" -#else -#if defined(__STDC__) && (__STDC__ >= 1) -/* This preprocessor magic that replaces a call with the exact same call is - only done to make sure application authors pass exactly three arguments - to these functions. */ -#define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param) -#define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg) -#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param) -#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) -#endif /* __STDC__ >= 1 */ -#endif /* gcc >= 4.3 && !__cplusplus && !CURL_DISABLE_TYPECHECK */ - -#endif /* CURLINC_CURL_H */ diff --git a/deps/libcurl/include/curl/curlver.h b/deps/libcurl/include/curl/curlver.h deleted file mode 100644 index fc8ba4cd4b..0000000000 --- a/deps/libcurl/include/curl/curlver.h +++ /dev/null @@ -1,79 +0,0 @@ -#ifndef CURLINC_CURLVER_H -#define CURLINC_CURLVER_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ - -/* This header file contains nothing but libcurl version info, generated by - a script at release-time. This was made its own header file in 7.11.2 */ - -/* This is the global package copyright */ -#define LIBCURL_COPYRIGHT "Daniel Stenberg, ." - -/* This is the version number of the libcurl package from which this header - file origins: */ -#define LIBCURL_VERSION "8.12.1" - -/* The numeric version number is also available "in parts" by using these - defines: */ -#define LIBCURL_VERSION_MAJOR 8 -#define LIBCURL_VERSION_MINOR 12 -#define LIBCURL_VERSION_PATCH 1 - -/* This is the numeric version of the libcurl version number, meant for easier - parsing and comparisons by programs. The LIBCURL_VERSION_NUM define will - always follow this syntax: - - 0xXXYYZZ - - Where XX, YY and ZZ are the main version, release and patch numbers in - hexadecimal (using 8 bits each). All three numbers are always represented - using two digits. 1.2 would appear as "0x010200" while version 9.11.7 - appears as "0x090b07". - - This 6-digit (24 bits) hexadecimal number does not show pre-release number, - and it is always a greater number in a more recent release. It makes - comparisons with greater than and less than work. - - Note: This define is the full hex number and _does not_ use the - CURL_VERSION_BITS() macro since curl's own configure script greps for it - and needs it to contain the full number. -*/ -#define LIBCURL_VERSION_NUM 0x080c01 - -/* - * This is the date and time when the full source package was created. The - * timestamp is not stored in git, as the timestamp is properly set in the - * tarballs by the maketgz script. - * - * The format of the date follows this template: - * - * "2007-11-23" - */ -#define LIBCURL_TIMESTAMP "2025-02-13" - -#define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|(z)) -#define CURL_AT_LEAST_VERSION(x,y,z) \ - (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z)) - -#endif /* CURLINC_CURLVER_H */ diff --git a/deps/libcurl/include/curl/easy.h b/deps/libcurl/include/curl/easy.h deleted file mode 100644 index 56f8060e04..0000000000 --- a/deps/libcurl/include/curl/easy.h +++ /dev/null @@ -1,125 +0,0 @@ -#ifndef CURLINC_EASY_H -#define CURLINC_EASY_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ -#ifdef __cplusplus -extern "C" { -#endif - -/* Flag bits in the curl_blob struct: */ -#define CURL_BLOB_COPY 1 /* tell libcurl to copy the data */ -#define CURL_BLOB_NOCOPY 0 /* tell libcurl to NOT copy the data */ - -struct curl_blob { - void *data; - size_t len; - unsigned int flags; /* bit 0 is defined, the rest are reserved and should be - left zeroes */ -}; - -CURL_EXTERN CURL *curl_easy_init(void); -CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...); -CURL_EXTERN CURLcode curl_easy_perform(CURL *curl); -CURL_EXTERN void curl_easy_cleanup(CURL *curl); - -/* - * NAME curl_easy_getinfo() - * - * DESCRIPTION - * - * Request internal information from the curl session with this function. - * The third argument MUST be pointing to the specific type of the used option - * which is documented in each manpage of the option. The data pointed to - * will be filled in accordingly and can be relied upon only if the function - * returns CURLE_OK. This function is intended to get used *AFTER* a performed - * transfer, all results from this function are undefined until the transfer - * is completed. - */ -CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...); - - -/* - * NAME curl_easy_duphandle() - * - * DESCRIPTION - * - * Creates a new curl session handle with the same options set for the handle - * passed in. Duplicating a handle could only be a matter of cloning data and - * options, internal state info and things like persistent connections cannot - * be transferred. It is useful in multithreaded applications when you can run - * curl_easy_duphandle() for each new thread to avoid a series of identical - * curl_easy_setopt() invokes in every thread. - */ -CURL_EXTERN CURL *curl_easy_duphandle(CURL *curl); - -/* - * NAME curl_easy_reset() - * - * DESCRIPTION - * - * Re-initializes a curl handle to the default values. This puts back the - * handle to the same state as it was in when it was just created. - * - * It does keep: live connections, the Session ID cache, the DNS cache and the - * cookies. - */ -CURL_EXTERN void curl_easy_reset(CURL *curl); - -/* - * NAME curl_easy_recv() - * - * DESCRIPTION - * - * Receives data from the connected socket. Use after successful - * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. - */ -CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen, - size_t *n); - -/* - * NAME curl_easy_send() - * - * DESCRIPTION - * - * Sends data over the connected socket. Use after successful - * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. - */ -CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer, - size_t buflen, size_t *n); - - -/* - * NAME curl_easy_upkeep() - * - * DESCRIPTION - * - * Performs connection upkeep for the given session handle. - */ -CURL_EXTERN CURLcode curl_easy_upkeep(CURL *curl); - -#ifdef __cplusplus -} /* end of extern "C" */ -#endif - -#endif diff --git a/deps/libcurl/include/curl/header.h b/deps/libcurl/include/curl/header.h deleted file mode 100644 index 8df11e1e42..0000000000 --- a/deps/libcurl/include/curl/header.h +++ /dev/null @@ -1,74 +0,0 @@ -#ifndef CURLINC_HEADER_H -#define CURLINC_HEADER_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ - -#ifdef __cplusplus -extern "C" { -#endif - -struct curl_header { - char *name; /* this might not use the same case */ - char *value; - size_t amount; /* number of headers using this name */ - size_t index; /* ... of this instance, 0 or higher */ - unsigned int origin; /* see bits below */ - void *anchor; /* handle privately used by libcurl */ -}; - -/* 'origin' bits */ -#define CURLH_HEADER (1<<0) /* plain server header */ -#define CURLH_TRAILER (1<<1) /* trailers */ -#define CURLH_CONNECT (1<<2) /* CONNECT headers */ -#define CURLH_1XX (1<<3) /* 1xx headers */ -#define CURLH_PSEUDO (1<<4) /* pseudo headers */ - -typedef enum { - CURLHE_OK, - CURLHE_BADINDEX, /* header exists but not with this index */ - CURLHE_MISSING, /* no such header exists */ - CURLHE_NOHEADERS, /* no headers at all exist (yet) */ - CURLHE_NOREQUEST, /* no request with this number was used */ - CURLHE_OUT_OF_MEMORY, /* out of memory while processing */ - CURLHE_BAD_ARGUMENT, /* a function argument was not okay */ - CURLHE_NOT_BUILT_IN /* if API was disabled in the build */ -} CURLHcode; - -CURL_EXTERN CURLHcode curl_easy_header(CURL *easy, - const char *name, - size_t index, - unsigned int origin, - int request, - struct curl_header **hout); - -CURL_EXTERN struct curl_header *curl_easy_nextheader(CURL *easy, - unsigned int origin, - int request, - struct curl_header *prev); - -#ifdef __cplusplus -} /* end of extern "C" */ -#endif - -#endif /* CURLINC_HEADER_H */ diff --git a/deps/libcurl/include/curl/mprintf.h b/deps/libcurl/include/curl/mprintf.h deleted file mode 100644 index 88059c851f..0000000000 --- a/deps/libcurl/include/curl/mprintf.h +++ /dev/null @@ -1,85 +0,0 @@ -#ifndef CURLINC_MPRINTF_H -#define CURLINC_MPRINTF_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ - -#include -#include /* needed for FILE */ -#include "curl.h" /* for CURL_EXTERN */ - -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef CURL_TEMP_PRINTF -#if (defined(__GNUC__) || defined(__clang__) || \ - defined(__IAR_SYSTEMS_ICC__)) && \ - defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ - !defined(CURL_NO_FMT_CHECKS) -#if defined(__MINGW32__) && !defined(__clang__) -#if defined(__MINGW_PRINTF_FORMAT) /* mingw-w64 3.0.0+. Needs stdio.h. */ -#define CURL_TEMP_PRINTF(fmt, arg) \ - __attribute__((format(__MINGW_PRINTF_FORMAT, fmt, arg))) -#else -#define CURL_TEMP_PRINTF(fmt, arg) -#endif -#else -#define CURL_TEMP_PRINTF(fmt, arg) \ - __attribute__((format(printf, fmt, arg))) -#endif -#else -#define CURL_TEMP_PRINTF(fmt, arg) -#endif -#endif - -CURL_EXTERN int curl_mprintf(const char *format, ...) - CURL_TEMP_PRINTF(1, 2); -CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...) - CURL_TEMP_PRINTF(2, 3); -CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...) - CURL_TEMP_PRINTF(2, 3); -CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength, - const char *format, ...) - CURL_TEMP_PRINTF(3, 4); -CURL_EXTERN int curl_mvprintf(const char *format, va_list args) - CURL_TEMP_PRINTF(1, 0); -CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args) - CURL_TEMP_PRINTF(2, 0); -CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args) - CURL_TEMP_PRINTF(2, 0); -CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength, - const char *format, va_list args) - CURL_TEMP_PRINTF(3, 0); -CURL_EXTERN char *curl_maprintf(const char *format, ...) - CURL_TEMP_PRINTF(1, 2); -CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args) - CURL_TEMP_PRINTF(1, 0); - -#undef CURL_TEMP_PRINTF - -#ifdef __cplusplus -} /* end of extern "C" */ -#endif - -#endif /* CURLINC_MPRINTF_H */ diff --git a/deps/libcurl/include/curl/multi.h b/deps/libcurl/include/curl/multi.h deleted file mode 100644 index 42469bb565..0000000000 --- a/deps/libcurl/include/curl/multi.h +++ /dev/null @@ -1,481 +0,0 @@ -#ifndef CURLINC_MULTI_H -#define CURLINC_MULTI_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ -/* - This is an "external" header file. Do not give away any internals here! - - GOALS - - o Enable a "pull" interface. The application that uses libcurl decides where - and when to ask libcurl to get/send data. - - o Enable multiple simultaneous transfers in the same thread without making it - complicated for the application. - - o Enable the application to select() on its own file descriptors and curl's - file descriptors simultaneous easily. - -*/ - -/* - * This header file should not really need to include "curl.h" since curl.h - * itself includes this file and we expect user applications to do #include - * without the need for especially including multi.h. - * - * For some reason we added this include here at one point, and rather than to - * break existing (wrongly written) libcurl applications, we leave it as-is - * but with this warning attached. - */ -#include "curl.h" - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void CURLM; - -typedef enum { - CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or - curl_multi_socket*() soon */ - CURLM_OK, - CURLM_BAD_HANDLE, /* the passed-in handle is not a valid CURLM handle */ - CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */ - CURLM_OUT_OF_MEMORY, /* if you ever get this, you are in deep sh*t */ - CURLM_INTERNAL_ERROR, /* this is a libcurl bug */ - CURLM_BAD_SOCKET, /* the passed in socket argument did not match */ - CURLM_UNKNOWN_OPTION, /* curl_multi_setopt() with unsupported option */ - CURLM_ADDED_ALREADY, /* an easy handle already added to a multi handle was - attempted to get added - again */ - CURLM_RECURSIVE_API_CALL, /* an api function was called from inside a - callback */ - CURLM_WAKEUP_FAILURE, /* wakeup is unavailable or failed */ - CURLM_BAD_FUNCTION_ARGUMENT, /* function called with a bad parameter */ - CURLM_ABORTED_BY_CALLBACK, - CURLM_UNRECOVERABLE_POLL, - CURLM_LAST -} CURLMcode; - -/* just to make code nicer when using curl_multi_socket() you can now check - for CURLM_CALL_MULTI_SOCKET too in the same style it works for - curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */ -#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM - -/* bitmask bits for CURLMOPT_PIPELINING */ -#define CURLPIPE_NOTHING 0L -#define CURLPIPE_HTTP1 1L -#define CURLPIPE_MULTIPLEX 2L - -typedef enum { - CURLMSG_NONE, /* first, not used */ - CURLMSG_DONE, /* This easy handle has completed. 'result' contains - the CURLcode of the transfer */ - CURLMSG_LAST /* last, not used */ -} CURLMSG; - -struct CURLMsg { - CURLMSG msg; /* what this message means */ - CURL *easy_handle; /* the handle it concerns */ - union { - void *whatever; /* message-specific data */ - CURLcode result; /* return code for transfer */ - } data; -}; -typedef struct CURLMsg CURLMsg; - -/* Based on poll(2) structure and values. - * We do not use pollfd and POLL* constants explicitly - * to cover platforms without poll(). */ -#define CURL_WAIT_POLLIN 0x0001 -#define CURL_WAIT_POLLPRI 0x0002 -#define CURL_WAIT_POLLOUT 0x0004 - -struct curl_waitfd { - curl_socket_t fd; - short events; - short revents; -}; - -/* - * Name: curl_multi_init() - * - * Desc: initialize multi-style curl usage - * - * Returns: a new CURLM handle to use in all 'curl_multi' functions. - */ -CURL_EXTERN CURLM *curl_multi_init(void); - -/* - * Name: curl_multi_add_handle() - * - * Desc: add a standard curl handle to the multi stack - * - * Returns: CURLMcode type, general multi error code. - */ -CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle, - CURL *curl_handle); - - /* - * Name: curl_multi_remove_handle() - * - * Desc: removes a curl handle from the multi stack again - * - * Returns: CURLMcode type, general multi error code. - */ -CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle, - CURL *curl_handle); - - /* - * Name: curl_multi_fdset() - * - * Desc: Ask curl for its fd_set sets. The app can use these to select() or - * poll() on. We want curl_multi_perform() called as soon as one of - * them are ready. - * - * Returns: CURLMcode type, general multi error code. - */ -CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle, - fd_set *read_fd_set, - fd_set *write_fd_set, - fd_set *exc_fd_set, - int *max_fd); - -/* - * Name: curl_multi_wait() - * - * Desc: Poll on all fds within a CURLM set as well as any - * additional fds passed to the function. - * - * Returns: CURLMcode type, general multi error code. - */ -CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle, - struct curl_waitfd extra_fds[], - unsigned int extra_nfds, - int timeout_ms, - int *ret); - -/* - * Name: curl_multi_poll() - * - * Desc: Poll on all fds within a CURLM set as well as any - * additional fds passed to the function. - * - * Returns: CURLMcode type, general multi error code. - */ -CURL_EXTERN CURLMcode curl_multi_poll(CURLM *multi_handle, - struct curl_waitfd extra_fds[], - unsigned int extra_nfds, - int timeout_ms, - int *ret); - -/* - * Name: curl_multi_wakeup() - * - * Desc: wakes up a sleeping curl_multi_poll call. - * - * Returns: CURLMcode type, general multi error code. - */ -CURL_EXTERN CURLMcode curl_multi_wakeup(CURLM *multi_handle); - - /* - * Name: curl_multi_perform() - * - * Desc: When the app thinks there is data available for curl it calls this - * function to read/write whatever there is right now. This returns - * as soon as the reads and writes are done. This function does not - * require that there actually is data available for reading or that - * data can be written, it can be called just in case. It returns - * the number of handles that still transfer data in the second - * argument's integer-pointer. - * - * Returns: CURLMcode type, general multi error code. *NOTE* that this only - * returns errors etc regarding the whole multi stack. There might - * still have occurred problems on individual transfers even when - * this returns OK. - */ -CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle, - int *running_handles); - - /* - * Name: curl_multi_cleanup() - * - * Desc: Cleans up and removes a whole multi stack. It does not free or - * touch any individual easy handles in any way. We need to define - * in what state those handles will be if this function is called - * in the middle of a transfer. - * - * Returns: CURLMcode type, general multi error code. - */ -CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle); - -/* - * Name: curl_multi_info_read() - * - * Desc: Ask the multi handle if there is any messages/informationals from - * the individual transfers. Messages include informationals such as - * error code from the transfer or just the fact that a transfer is - * completed. More details on these should be written down as well. - * - * Repeated calls to this function will return a new struct each - * time, until a special "end of msgs" struct is returned as a signal - * that there is no more to get at this point. - * - * The data the returned pointer points to will not survive calling - * curl_multi_cleanup(). - * - * The 'CURLMsg' struct is meant to be simple and only contain basic - * information. If more involved information is wanted, we will - * provide the particular "transfer handle" in that struct and that - * should/could/would be used in subsequent curl_easy_getinfo() calls - * (or similar). The point being that we must never expose complex - * structs to applications, as then we will undoubtably get backwards - * compatibility problems in the future. - * - * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out - * of structs. It also writes the number of messages left in the - * queue (after this read) in the integer the second argument points - * to. - */ -CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle, - int *msgs_in_queue); - -/* - * Name: curl_multi_strerror() - * - * Desc: The curl_multi_strerror function may be used to turn a CURLMcode - * value into the equivalent human readable error string. This is - * useful for printing meaningful error messages. - * - * Returns: A pointer to a null-terminated error message. - */ -CURL_EXTERN const char *curl_multi_strerror(CURLMcode); - -/* - * Name: curl_multi_socket() and - * curl_multi_socket_all() - * - * Desc: An alternative version of curl_multi_perform() that allows the - * application to pass in one of the file descriptors that have been - * detected to have "action" on them and let libcurl perform. - * See manpage for details. - */ -#define CURL_POLL_NONE 0 -#define CURL_POLL_IN 1 -#define CURL_POLL_OUT 2 -#define CURL_POLL_INOUT 3 -#define CURL_POLL_REMOVE 4 - -#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD - -#define CURL_CSELECT_IN 0x01 -#define CURL_CSELECT_OUT 0x02 -#define CURL_CSELECT_ERR 0x04 - -typedef int (*curl_socket_callback)(CURL *easy, /* easy handle */ - curl_socket_t s, /* socket */ - int what, /* see above */ - void *userp, /* private callback - pointer */ - void *socketp); /* private socket - pointer */ -/* - * Name: curl_multi_timer_callback - * - * Desc: Called by libcurl whenever the library detects a change in the - * maximum number of milliseconds the app is allowed to wait before - * curl_multi_socket() or curl_multi_perform() must be called - * (to allow libcurl's timed events to take place). - * - * Returns: The callback should return zero. - */ -typedef int (*curl_multi_timer_callback)(CURLM *multi, /* multi handle */ - long timeout_ms, /* see above */ - void *userp); /* private callback - pointer */ - -CURL_EXTERN CURLMcode CURL_DEPRECATED(7.19.5, "Use curl_multi_socket_action()") -curl_multi_socket(CURLM *multi_handle, curl_socket_t s, int *running_handles); - -CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle, - curl_socket_t s, - int ev_bitmask, - int *running_handles); - -CURL_EXTERN CURLMcode CURL_DEPRECATED(7.19.5, "Use curl_multi_socket_action()") -curl_multi_socket_all(CURLM *multi_handle, int *running_handles); - -#ifndef CURL_ALLOW_OLD_MULTI_SOCKET -/* This macro below was added in 7.16.3 to push users who recompile to use - the new curl_multi_socket_action() instead of the old curl_multi_socket() -*/ -#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z) -#endif - -/* - * Name: curl_multi_timeout() - * - * Desc: Returns the maximum number of milliseconds the app is allowed to - * wait before curl_multi_socket() or curl_multi_perform() must be - * called (to allow libcurl's timed events to take place). - * - * Returns: CURLM error code. - */ -CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle, - long *milliseconds); - -typedef enum { - /* This is the socket callback function pointer */ - CURLOPT(CURLMOPT_SOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 1), - - /* This is the argument passed to the socket callback */ - CURLOPT(CURLMOPT_SOCKETDATA, CURLOPTTYPE_OBJECTPOINT, 2), - - /* set to 1 to enable pipelining for this multi handle */ - CURLOPT(CURLMOPT_PIPELINING, CURLOPTTYPE_LONG, 3), - - /* This is the timer callback function pointer */ - CURLOPT(CURLMOPT_TIMERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 4), - - /* This is the argument passed to the timer callback */ - CURLOPT(CURLMOPT_TIMERDATA, CURLOPTTYPE_OBJECTPOINT, 5), - - /* maximum number of entries in the connection cache */ - CURLOPT(CURLMOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 6), - - /* maximum number of (pipelining) connections to one host */ - CURLOPT(CURLMOPT_MAX_HOST_CONNECTIONS, CURLOPTTYPE_LONG, 7), - - /* maximum number of requests in a pipeline */ - CURLOPT(CURLMOPT_MAX_PIPELINE_LENGTH, CURLOPTTYPE_LONG, 8), - - /* a connection with a content-length longer than this - will not be considered for pipelining */ - CURLOPT(CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 9), - - /* a connection with a chunk length longer than this - will not be considered for pipelining */ - CURLOPT(CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 10), - - /* a list of site names(+port) that are blocked from pipelining */ - CURLOPT(CURLMOPT_PIPELINING_SITE_BL, CURLOPTTYPE_OBJECTPOINT, 11), - - /* a list of server types that are blocked from pipelining */ - CURLOPT(CURLMOPT_PIPELINING_SERVER_BL, CURLOPTTYPE_OBJECTPOINT, 12), - - /* maximum number of open connections in total */ - CURLOPT(CURLMOPT_MAX_TOTAL_CONNECTIONS, CURLOPTTYPE_LONG, 13), - - /* This is the server push callback function pointer */ - CURLOPT(CURLMOPT_PUSHFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 14), - - /* This is the argument passed to the server push callback */ - CURLOPT(CURLMOPT_PUSHDATA, CURLOPTTYPE_OBJECTPOINT, 15), - - /* maximum number of concurrent streams to support on a connection */ - CURLOPT(CURLMOPT_MAX_CONCURRENT_STREAMS, CURLOPTTYPE_LONG, 16), - - CURLMOPT_LASTENTRY /* the last unused */ -} CURLMoption; - - -/* - * Name: curl_multi_setopt() - * - * Desc: Sets options for the multi handle. - * - * Returns: CURLM error code. - */ -CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle, - CURLMoption option, ...); - - -/* - * Name: curl_multi_assign() - * - * Desc: This function sets an association in the multi handle between the - * given socket and a private pointer of the application. This is - * (only) useful for curl_multi_socket uses. - * - * Returns: CURLM error code. - */ -CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle, - curl_socket_t sockfd, void *sockp); - -/* - * Name: curl_multi_get_handles() - * - * Desc: Returns an allocated array holding all handles currently added to - * the multi handle. Marks the final entry with a NULL pointer. If - * there is no easy handle added to the multi handle, this function - * returns an array with the first entry as a NULL pointer. - * - * Returns: NULL on failure, otherwise a CURL **array pointer - */ -CURL_EXTERN CURL **curl_multi_get_handles(CURLM *multi_handle); - -/* - * Name: curl_push_callback - * - * Desc: This callback gets called when a new stream is being pushed by the - * server. It approves or denies the new stream. It can also decide - * to completely fail the connection. - * - * Returns: CURL_PUSH_OK, CURL_PUSH_DENY or CURL_PUSH_ERROROUT - */ -#define CURL_PUSH_OK 0 -#define CURL_PUSH_DENY 1 -#define CURL_PUSH_ERROROUT 2 /* added in 7.72.0 */ - -struct curl_pushheaders; /* forward declaration only */ - -CURL_EXTERN char *curl_pushheader_bynum(struct curl_pushheaders *h, - size_t num); -CURL_EXTERN char *curl_pushheader_byname(struct curl_pushheaders *h, - const char *name); - -typedef int (*curl_push_callback)(CURL *parent, - CURL *easy, - size_t num_headers, - struct curl_pushheaders *headers, - void *userp); - -/* - * Name: curl_multi_waitfds() - * - * Desc: Ask curl for fds for polling. The app can use these to poll on. - * We want curl_multi_perform() called as soon as one of them are - * ready. Passing zero size allows to get just a number of fds. - * - * Returns: CURLMcode type, general multi error code. - */ -CURL_EXTERN CURLMcode curl_multi_waitfds(CURLM *multi, - struct curl_waitfd *ufds, - unsigned int size, - unsigned int *fd_count); - -#ifdef __cplusplus -} /* end of extern "C" */ -#endif - -#endif diff --git a/deps/libcurl/include/curl/options.h b/deps/libcurl/include/curl/options.h deleted file mode 100644 index 1ed76a95c6..0000000000 --- a/deps/libcurl/include/curl/options.h +++ /dev/null @@ -1,70 +0,0 @@ -#ifndef CURLINC_OPTIONS_H -#define CURLINC_OPTIONS_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ - -#ifdef __cplusplus -extern "C" { -#endif - -typedef enum { - CURLOT_LONG, /* long (a range of values) */ - CURLOT_VALUES, /* (a defined set or bitmask) */ - CURLOT_OFF_T, /* curl_off_t (a range of values) */ - CURLOT_OBJECT, /* pointer (void *) */ - CURLOT_STRING, /* (char * to null-terminated buffer) */ - CURLOT_SLIST, /* (struct curl_slist *) */ - CURLOT_CBPTR, /* (void * passed as-is to a callback) */ - CURLOT_BLOB, /* blob (struct curl_blob *) */ - CURLOT_FUNCTION /* function pointer */ -} curl_easytype; - -/* Flag bits */ - -/* "alias" means it is provided for old programs to remain functional, - we prefer another name */ -#define CURLOT_FLAG_ALIAS (1<<0) - -/* The CURLOPTTYPE_* id ranges can still be used to figure out what type/size - to use for curl_easy_setopt() for the given id */ -struct curl_easyoption { - const char *name; - CURLoption id; - curl_easytype type; - unsigned int flags; -}; - -CURL_EXTERN const struct curl_easyoption * -curl_easy_option_by_name(const char *name); - -CURL_EXTERN const struct curl_easyoption * -curl_easy_option_by_id(CURLoption id); - -CURL_EXTERN const struct curl_easyoption * -curl_easy_option_next(const struct curl_easyoption *prev); - -#ifdef __cplusplus -} /* end of extern "C" */ -#endif -#endif /* CURLINC_OPTIONS_H */ diff --git a/deps/libcurl/include/curl/stdcheaders.h b/deps/libcurl/include/curl/stdcheaders.h deleted file mode 100644 index 7451aa3052..0000000000 --- a/deps/libcurl/include/curl/stdcheaders.h +++ /dev/null @@ -1,35 +0,0 @@ -#ifndef CURLINC_STDCHEADERS_H -#define CURLINC_STDCHEADERS_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ - -#include - -size_t fread(void *, size_t, size_t, FILE *); -size_t fwrite(const void *, size_t, size_t, FILE *); - -int strcasecmp(const char *, const char *); -int strncasecmp(const char *, const char *, size_t); - -#endif /* CURLINC_STDCHEADERS_H */ diff --git a/deps/libcurl/include/curl/system.h b/deps/libcurl/include/curl/system.h deleted file mode 100644 index 820fe96b39..0000000000 --- a/deps/libcurl/include/curl/system.h +++ /dev/null @@ -1,440 +0,0 @@ -#ifndef CURLINC_SYSTEM_H -#define CURLINC_SYSTEM_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ - -/* - * Try to keep one section per platform, compiler and architecture, otherwise, - * if an existing section is reused for a different one and later on the - * original is adjusted, probably the piggybacking one can be adversely - * changed. - * - * In order to differentiate between platforms/compilers/architectures use - * only compiler built-in predefined preprocessor symbols. - * - * curl_off_t - * ---------- - * - * For any given platform/compiler curl_off_t must be typedef'ed to a 64-bit - * wide signed integral data type. The width of this data type must remain - * constant and independent of any possible large file support settings. - * - * As an exception to the above, curl_off_t shall be typedef'ed to a 32-bit - * wide signed integral data type if there is no 64-bit type. - * - * As a general rule, curl_off_t shall not be mapped to off_t. This rule shall - * only be violated if off_t is the only 64-bit data type available and the - * size of off_t is independent of large file support settings. Keep your - * build on the safe side avoiding an off_t gating. If you have a 64-bit - * off_t then take for sure that another 64-bit data type exists, dig deeper - * and you will find it. - * - */ - -#if defined(__DJGPP__) -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# define CURL_TYPEOF_CURL_SOCKLEN_T int - -#elif defined(__BORLANDC__) -# define CURL_TYPEOF_CURL_OFF_T __int64 -# define CURL_FORMAT_CURL_OFF_T "I64d" -# define CURL_FORMAT_CURL_OFF_TU "I64u" -# define CURL_SUFFIX_CURL_OFF_T i64 -# define CURL_SUFFIX_CURL_OFF_TU ui64 -# define CURL_TYPEOF_CURL_SOCKLEN_T int - -#elif defined(__POCC__) -# if defined(_MSC_VER) -# define CURL_TYPEOF_CURL_OFF_T __int64 -# define CURL_FORMAT_CURL_OFF_T "I64d" -# define CURL_FORMAT_CURL_OFF_TU "I64u" -# define CURL_SUFFIX_CURL_OFF_T i64 -# define CURL_SUFFIX_CURL_OFF_TU ui64 -# else -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# endif -# define CURL_TYPEOF_CURL_SOCKLEN_T int - -#elif defined(__LCC__) -# if defined(__MCST__) /* MCST eLbrus Compiler Collection */ -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t -# define CURL_PULL_SYS_TYPES_H 1 -# define CURL_PULL_SYS_SOCKET_H 1 -# else /* Local (or Little) C Compiler */ -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# define CURL_TYPEOF_CURL_SOCKLEN_T int -# endif - -#elif defined(macintosh) -# include -# if TYPE_LONGLONG -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# else -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# endif -# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int - -#elif defined(__TANDEM) -# if !defined(__LP64) -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# define CURL_TYPEOF_CURL_SOCKLEN_T int -# else -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int -# endif - -#elif defined(_WIN32_WCE) -# define CURL_TYPEOF_CURL_OFF_T __int64 -# define CURL_FORMAT_CURL_OFF_T "I64d" -# define CURL_FORMAT_CURL_OFF_TU "I64u" -# define CURL_SUFFIX_CURL_OFF_T i64 -# define CURL_SUFFIX_CURL_OFF_TU ui64 -# define CURL_TYPEOF_CURL_SOCKLEN_T int - -#elif defined(__MINGW32__) -# include -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T PRId64 -# define CURL_FORMAT_CURL_OFF_TU PRIu64 -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# define CURL_TYPEOF_CURL_SOCKLEN_T int -# define CURL_PULL_SYS_TYPES_H 1 - -#elif defined(__VMS) -# if defined(__VAX) -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# else -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# endif -# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int - -#elif defined(__OS400__) -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t -# define CURL_PULL_SYS_TYPES_H 1 -# define CURL_PULL_SYS_SOCKET_H 1 - -#elif defined(__MVS__) -# if defined(_LONG_LONG) -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# else /* _LP64 and default */ -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# endif -# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t -# define CURL_PULL_SYS_TYPES_H 1 -# define CURL_PULL_SYS_SOCKET_H 1 - -#elif defined(__370__) -# if defined(__IBMC__) || defined(__IBMCPP__) -# if defined(_LONG_LONG) -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# else /* _LP64 and default */ -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# endif -# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t -# define CURL_PULL_SYS_TYPES_H 1 -# define CURL_PULL_SYS_SOCKET_H 1 -# endif - -#elif defined(TPF) -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# define CURL_TYPEOF_CURL_SOCKLEN_T int - -#elif defined(__TINYC__) /* also known as tcc */ -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t -# define CURL_PULL_SYS_TYPES_H 1 -# define CURL_PULL_SYS_SOCKET_H 1 - -#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) /* Oracle Solaris Studio */ -# if !defined(__LP64) && (defined(__ILP32) || \ - defined(__i386) || \ - defined(__sparcv8) || \ - defined(__sparcv8plus)) -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# elif defined(__LP64) || \ - defined(__amd64) || defined(__sparcv9) -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# endif -# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t -# define CURL_PULL_SYS_TYPES_H 1 -# define CURL_PULL_SYS_SOCKET_H 1 - -#elif defined(__xlc__) /* IBM xlc compiler */ -# if !defined(_LP64) -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# else -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# endif -# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t -# define CURL_PULL_SYS_TYPES_H 1 -# define CURL_PULL_SYS_SOCKET_H 1 - -#elif defined(__hpux) /* HP aCC compiler */ -# if !defined(_LP64) -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# else -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# endif -# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t -# define CURL_PULL_SYS_TYPES_H 1 -# define CURL_PULL_SYS_SOCKET_H 1 - -/* ===================================== */ -/* KEEP MSVC THE PENULTIMATE ENTRY */ -/* ===================================== */ - -#elif defined(_MSC_VER) -# if (_MSC_VER >= 1800) -# include -# define CURL_FORMAT_CURL_OFF_T PRId64 -# define CURL_FORMAT_CURL_OFF_TU PRIu64 -# else -# define CURL_FORMAT_CURL_OFF_T "I64d" -# define CURL_FORMAT_CURL_OFF_TU "I64u" -# endif -# define CURL_TYPEOF_CURL_OFF_T __int64 -# define CURL_SUFFIX_CURL_OFF_T i64 -# define CURL_SUFFIX_CURL_OFF_TU ui64 -# define CURL_TYPEOF_CURL_SOCKLEN_T int - -/* ===================================== */ -/* KEEP GENERIC GCC THE LAST ENTRY */ -/* ===================================== */ - -#elif defined(__GNUC__) && !defined(_SCO_DS) -# if !defined(__LP64__) && \ - (defined(__ILP32__) || defined(__i386__) || defined(__hppa__) || \ - defined(__ppc__) || defined(__powerpc__) || defined(__arm__) || \ - defined(__sparc__) || defined(__mips__) || defined(__sh__) || \ - defined(__XTENSA__) || \ - (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 4) || \ - (defined(__LONG_MAX__) && __LONG_MAX__ == 2147483647L)) -# define CURL_TYPEOF_CURL_OFF_T long long -# define CURL_FORMAT_CURL_OFF_T "lld" -# define CURL_FORMAT_CURL_OFF_TU "llu" -# define CURL_SUFFIX_CURL_OFF_T LL -# define CURL_SUFFIX_CURL_OFF_TU ULL -# elif defined(__LP64__) || \ - defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__) || \ - defined(__e2k__) || \ - (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 8) || \ - (defined(__LONG_MAX__) && __LONG_MAX__ == 9223372036854775807L) -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# endif -# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t -# define CURL_PULL_SYS_TYPES_H 1 -# define CURL_PULL_SYS_SOCKET_H 1 - -#else -/* generic "safe guess" on old 32-bit style */ -# define CURL_TYPEOF_CURL_OFF_T long -# define CURL_FORMAT_CURL_OFF_T "ld" -# define CURL_FORMAT_CURL_OFF_TU "lu" -# define CURL_SUFFIX_CURL_OFF_T L -# define CURL_SUFFIX_CURL_OFF_TU UL -# define CURL_TYPEOF_CURL_SOCKLEN_T int -#endif - -#ifdef _AIX -/* AIX needs */ -#define CURL_PULL_SYS_POLL_H -#endif - -/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file */ -/* sys/types.h is required here to properly make type definitions below. */ -#ifdef CURL_PULL_SYS_TYPES_H -# include -#endif - -/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file */ -/* sys/socket.h is required here to properly make type definitions below. */ -#ifdef CURL_PULL_SYS_SOCKET_H -# include -#endif - -/* CURL_PULL_SYS_POLL_H is defined above when inclusion of header file */ -/* sys/poll.h is required here to properly make type definitions below. */ -#ifdef CURL_PULL_SYS_POLL_H -# include -#endif - -/* Data type definition of curl_socklen_t. */ -#ifdef CURL_TYPEOF_CURL_SOCKLEN_T - typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; -#endif - -/* Data type definition of curl_off_t. */ - -#ifdef CURL_TYPEOF_CURL_OFF_T - typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; -#endif - -/* - * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow - * these to be visible and exported by the external libcurl interface API, - * while also making them visible to the library internals, simply including - * curl_setup.h, without actually needing to include curl.h internally. - * If some day this section would grow big enough, all this should be moved - * to its own header file. - */ - -/* - * Figure out if we can use the ## preprocessor operator, which is supported - * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__ - * or __cplusplus so we need to carefully check for them too. - */ - -#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ - defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \ - defined(__POCC__) || defined(__HIGHC__) || \ - defined(__ILEC400__) - /* This compiler is believed to have an ISO compatible preprocessor */ -#define CURL_ISOCPP -#else - /* This compiler is believed NOT to have an ISO compatible preprocessor */ -#undef CURL_ISOCPP -#endif - -/* - * Macros for minimum-width signed and unsigned curl_off_t integer constants. - */ - -#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551) -# define CURLINC_OFF_T_C_HLPR2(x) x -# define CURLINC_OFF_T_C_HLPR1(x) CURLINC_OFF_T_C_HLPR2(x) -# define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ - CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) -# define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ - CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) -#else -# ifdef CURL_ISOCPP -# define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix -# else -# define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix -# endif -# define CURLINC_OFF_T_C_HLPR1(Val,Suffix) CURLINC_OFF_T_C_HLPR2(Val,Suffix) -# define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) -# define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) -#endif - -#endif /* CURLINC_SYSTEM_H */ diff --git a/deps/libcurl/include/curl/typecheck-gcc.h b/deps/libcurl/include/curl/typecheck-gcc.h deleted file mode 100644 index e532e6997d..0000000000 --- a/deps/libcurl/include/curl/typecheck-gcc.h +++ /dev/null @@ -1,718 +0,0 @@ -#ifndef CURLINC_TYPECHECK_GCC_H -#define CURLINC_TYPECHECK_GCC_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ - -/* wraps curl_easy_setopt() with typechecking */ - -/* To add a new kind of warning, add an - * if(curlcheck_sometype_option(_curl_opt)) - * if(!curlcheck_sometype(value)) - * _curl_easy_setopt_err_sometype(); - * block and define curlcheck_sometype_option, curlcheck_sometype and - * _curl_easy_setopt_err_sometype below - * - * NOTE: We use two nested 'if' statements here instead of the && operator, in - * order to work around gcc bug #32061. It affects only gcc 4.3.x/4.4.x - * when compiling with -Wlogical-op. - * - * To add an option that uses the same type as an existing option, you will - * just need to extend the appropriate _curl_*_option macro - */ -#define curl_easy_setopt(handle, option, value) \ - __extension__({ \ - CURLoption _curl_opt = (option); \ - if(__builtin_constant_p(_curl_opt)) { \ - CURL_IGNORE_DEPRECATION( \ - if(curlcheck_long_option(_curl_opt)) \ - if(!curlcheck_long(value)) \ - _curl_easy_setopt_err_long(); \ - if(curlcheck_off_t_option(_curl_opt)) \ - if(!curlcheck_off_t(value)) \ - _curl_easy_setopt_err_curl_off_t(); \ - if(curlcheck_string_option(_curl_opt)) \ - if(!curlcheck_string(value)) \ - _curl_easy_setopt_err_string(); \ - if(curlcheck_write_cb_option(_curl_opt)) \ - if(!curlcheck_write_cb(value)) \ - _curl_easy_setopt_err_write_callback(); \ - if((_curl_opt) == CURLOPT_RESOLVER_START_FUNCTION) \ - if(!curlcheck_resolver_start_callback(value)) \ - _curl_easy_setopt_err_resolver_start_callback(); \ - if((_curl_opt) == CURLOPT_READFUNCTION) \ - if(!curlcheck_read_cb(value)) \ - _curl_easy_setopt_err_read_cb(); \ - if((_curl_opt) == CURLOPT_IOCTLFUNCTION) \ - if(!curlcheck_ioctl_cb(value)) \ - _curl_easy_setopt_err_ioctl_cb(); \ - if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION) \ - if(!curlcheck_sockopt_cb(value)) \ - _curl_easy_setopt_err_sockopt_cb(); \ - if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION) \ - if(!curlcheck_opensocket_cb(value)) \ - _curl_easy_setopt_err_opensocket_cb(); \ - if((_curl_opt) == CURLOPT_PROGRESSFUNCTION) \ - if(!curlcheck_progress_cb(value)) \ - _curl_easy_setopt_err_progress_cb(); \ - if((_curl_opt) == CURLOPT_DEBUGFUNCTION) \ - if(!curlcheck_debug_cb(value)) \ - _curl_easy_setopt_err_debug_cb(); \ - if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION) \ - if(!curlcheck_ssl_ctx_cb(value)) \ - _curl_easy_setopt_err_ssl_ctx_cb(); \ - if(curlcheck_conv_cb_option(_curl_opt)) \ - if(!curlcheck_conv_cb(value)) \ - _curl_easy_setopt_err_conv_cb(); \ - if((_curl_opt) == CURLOPT_SEEKFUNCTION) \ - if(!curlcheck_seek_cb(value)) \ - _curl_easy_setopt_err_seek_cb(); \ - if(curlcheck_cb_data_option(_curl_opt)) \ - if(!curlcheck_cb_data(value)) \ - _curl_easy_setopt_err_cb_data(); \ - if((_curl_opt) == CURLOPT_ERRORBUFFER) \ - if(!curlcheck_error_buffer(value)) \ - _curl_easy_setopt_err_error_buffer(); \ - if((_curl_opt) == CURLOPT_STDERR) \ - if(!curlcheck_FILE(value)) \ - _curl_easy_setopt_err_FILE(); \ - if(curlcheck_postfields_option(_curl_opt)) \ - if(!curlcheck_postfields(value)) \ - _curl_easy_setopt_err_postfields(); \ - if((_curl_opt) == CURLOPT_HTTPPOST) \ - if(!curlcheck_arr((value), struct curl_httppost)) \ - _curl_easy_setopt_err_curl_httpost(); \ - if((_curl_opt) == CURLOPT_MIMEPOST) \ - if(!curlcheck_ptr((value), curl_mime)) \ - _curl_easy_setopt_err_curl_mimepost(); \ - if(curlcheck_slist_option(_curl_opt)) \ - if(!curlcheck_arr((value), struct curl_slist)) \ - _curl_easy_setopt_err_curl_slist(); \ - if((_curl_opt) == CURLOPT_SHARE) \ - if(!curlcheck_ptr((value), CURLSH)) \ - _curl_easy_setopt_err_CURLSH(); \ - ) \ - } \ - curl_easy_setopt(handle, _curl_opt, value); \ - }) - -/* wraps curl_easy_getinfo() with typechecking */ -#define curl_easy_getinfo(handle, info, arg) \ - __extension__({ \ - CURLINFO _curl_info = (info); \ - if(__builtin_constant_p(_curl_info)) { \ - CURL_IGNORE_DEPRECATION( \ - if(curlcheck_string_info(_curl_info)) \ - if(!curlcheck_arr((arg), char *)) \ - _curl_easy_getinfo_err_string(); \ - if(curlcheck_long_info(_curl_info)) \ - if(!curlcheck_arr((arg), long)) \ - _curl_easy_getinfo_err_long(); \ - if(curlcheck_double_info(_curl_info)) \ - if(!curlcheck_arr((arg), double)) \ - _curl_easy_getinfo_err_double(); \ - if(curlcheck_slist_info(_curl_info)) \ - if(!curlcheck_arr((arg), struct curl_slist *)) \ - _curl_easy_getinfo_err_curl_slist(); \ - if(curlcheck_tlssessioninfo_info(_curl_info)) \ - if(!curlcheck_arr((arg), struct curl_tlssessioninfo *)) \ - _curl_easy_getinfo_err_curl_tlssesssioninfo(); \ - if(curlcheck_certinfo_info(_curl_info)) \ - if(!curlcheck_arr((arg), struct curl_certinfo *)) \ - _curl_easy_getinfo_err_curl_certinfo(); \ - if(curlcheck_socket_info(_curl_info)) \ - if(!curlcheck_arr((arg), curl_socket_t)) \ - _curl_easy_getinfo_err_curl_socket(); \ - if(curlcheck_off_t_info(_curl_info)) \ - if(!curlcheck_arr((arg), curl_off_t)) \ - _curl_easy_getinfo_err_curl_off_t(); \ - ) \ - } \ - curl_easy_getinfo(handle, _curl_info, arg); \ - }) - -/* - * For now, just make sure that the functions are called with three arguments - */ -#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param) -#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) - - -/* the actual warnings, triggered by calling the _curl_easy_setopt_err* - * functions */ - -/* To define a new warning, use _CURL_WARNING(identifier, "message") */ -#define CURLWARNING(id, message) \ - static void __attribute__((__warning__(message))) \ - __attribute__((__unused__)) __attribute__((__noinline__)) \ - id(void) { __asm__(""); } - -CURLWARNING(_curl_easy_setopt_err_long, - "curl_easy_setopt expects a long argument for this option") -CURLWARNING(_curl_easy_setopt_err_curl_off_t, - "curl_easy_setopt expects a curl_off_t argument for this option") -CURLWARNING(_curl_easy_setopt_err_string, - "curl_easy_setopt expects a " - "string ('char *' or char[]) argument for this option" - ) -CURLWARNING(_curl_easy_setopt_err_write_callback, - "curl_easy_setopt expects a curl_write_callback argument for this option") -CURLWARNING(_curl_easy_setopt_err_resolver_start_callback, - "curl_easy_setopt expects a " - "curl_resolver_start_callback argument for this option" - ) -CURLWARNING(_curl_easy_setopt_err_read_cb, - "curl_easy_setopt expects a curl_read_callback argument for this option") -CURLWARNING(_curl_easy_setopt_err_ioctl_cb, - "curl_easy_setopt expects a curl_ioctl_callback argument for this option") -CURLWARNING(_curl_easy_setopt_err_sockopt_cb, - "curl_easy_setopt expects a curl_sockopt_callback argument for this option") -CURLWARNING(_curl_easy_setopt_err_opensocket_cb, - "curl_easy_setopt expects a " - "curl_opensocket_callback argument for this option" - ) -CURLWARNING(_curl_easy_setopt_err_progress_cb, - "curl_easy_setopt expects a curl_progress_callback argument for this option") -CURLWARNING(_curl_easy_setopt_err_debug_cb, - "curl_easy_setopt expects a curl_debug_callback argument for this option") -CURLWARNING(_curl_easy_setopt_err_ssl_ctx_cb, - "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option") -CURLWARNING(_curl_easy_setopt_err_conv_cb, - "curl_easy_setopt expects a curl_conv_callback argument for this option") -CURLWARNING(_curl_easy_setopt_err_seek_cb, - "curl_easy_setopt expects a curl_seek_callback argument for this option") -CURLWARNING(_curl_easy_setopt_err_cb_data, - "curl_easy_setopt expects a " - "private data pointer as argument for this option") -CURLWARNING(_curl_easy_setopt_err_error_buffer, - "curl_easy_setopt expects a " - "char buffer of CURL_ERROR_SIZE as argument for this option") -CURLWARNING(_curl_easy_setopt_err_FILE, - "curl_easy_setopt expects a 'FILE *' argument for this option") -CURLWARNING(_curl_easy_setopt_err_postfields, - "curl_easy_setopt expects a 'void *' or 'char *' argument for this option") -CURLWARNING(_curl_easy_setopt_err_curl_httpost, - "curl_easy_setopt expects a 'struct curl_httppost *' " - "argument for this option") -CURLWARNING(_curl_easy_setopt_err_curl_mimepost, - "curl_easy_setopt expects a 'curl_mime *' " - "argument for this option") -CURLWARNING(_curl_easy_setopt_err_curl_slist, - "curl_easy_setopt expects a 'struct curl_slist *' argument for this option") -CURLWARNING(_curl_easy_setopt_err_CURLSH, - "curl_easy_setopt expects a CURLSH* argument for this option") - -CURLWARNING(_curl_easy_getinfo_err_string, - "curl_easy_getinfo expects a pointer to 'char *' for this info") -CURLWARNING(_curl_easy_getinfo_err_long, - "curl_easy_getinfo expects a pointer to long for this info") -CURLWARNING(_curl_easy_getinfo_err_double, - "curl_easy_getinfo expects a pointer to double for this info") -CURLWARNING(_curl_easy_getinfo_err_curl_slist, - "curl_easy_getinfo expects a pointer to 'struct curl_slist *' for this info") -CURLWARNING(_curl_easy_getinfo_err_curl_tlssesssioninfo, - "curl_easy_getinfo expects a pointer to " - "'struct curl_tlssessioninfo *' for this info") -CURLWARNING(_curl_easy_getinfo_err_curl_certinfo, - "curl_easy_getinfo expects a pointer to " - "'struct curl_certinfo *' for this info") -CURLWARNING(_curl_easy_getinfo_err_curl_socket, - "curl_easy_getinfo expects a pointer to curl_socket_t for this info") -CURLWARNING(_curl_easy_getinfo_err_curl_off_t, - "curl_easy_getinfo expects a pointer to curl_off_t for this info") - -/* groups of curl_easy_setops options that take the same type of argument */ - -/* To add a new option to one of the groups, just add - * (option) == CURLOPT_SOMETHING - * to the or-expression. If the option takes a long or curl_off_t, you do not - * have to do anything - */ - -/* evaluates to true if option takes a long argument */ -#define curlcheck_long_option(option) \ - (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT) - -#define curlcheck_off_t_option(option) \ - (((option) > CURLOPTTYPE_OFF_T) && ((option) < CURLOPTTYPE_BLOB)) - -/* evaluates to true if option takes a char* argument */ -#define curlcheck_string_option(option) \ - ((option) == CURLOPT_ABSTRACT_UNIX_SOCKET || \ - (option) == CURLOPT_ACCEPT_ENCODING || \ - (option) == CURLOPT_ALTSVC || \ - (option) == CURLOPT_CAINFO || \ - (option) == CURLOPT_CAPATH || \ - (option) == CURLOPT_COOKIE || \ - (option) == CURLOPT_COOKIEFILE || \ - (option) == CURLOPT_COOKIEJAR || \ - (option) == CURLOPT_COOKIELIST || \ - (option) == CURLOPT_CRLFILE || \ - (option) == CURLOPT_CUSTOMREQUEST || \ - (option) == CURLOPT_DEFAULT_PROTOCOL || \ - (option) == CURLOPT_DNS_INTERFACE || \ - (option) == CURLOPT_DNS_LOCAL_IP4 || \ - (option) == CURLOPT_DNS_LOCAL_IP6 || \ - (option) == CURLOPT_DNS_SERVERS || \ - (option) == CURLOPT_DOH_URL || \ - (option) == CURLOPT_ECH || \ - (option) == CURLOPT_EGDSOCKET || \ - (option) == CURLOPT_FTP_ACCOUNT || \ - (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ - (option) == CURLOPT_FTPPORT || \ - (option) == CURLOPT_HSTS || \ - (option) == CURLOPT_HAPROXY_CLIENT_IP || \ - (option) == CURLOPT_INTERFACE || \ - (option) == CURLOPT_ISSUERCERT || \ - (option) == CURLOPT_KEYPASSWD || \ - (option) == CURLOPT_KRBLEVEL || \ - (option) == CURLOPT_LOGIN_OPTIONS || \ - (option) == CURLOPT_MAIL_AUTH || \ - (option) == CURLOPT_MAIL_FROM || \ - (option) == CURLOPT_NETRC_FILE || \ - (option) == CURLOPT_NOPROXY || \ - (option) == CURLOPT_PASSWORD || \ - (option) == CURLOPT_PINNEDPUBLICKEY || \ - (option) == CURLOPT_PRE_PROXY || \ - (option) == CURLOPT_PROTOCOLS_STR || \ - (option) == CURLOPT_PROXY || \ - (option) == CURLOPT_PROXY_CAINFO || \ - (option) == CURLOPT_PROXY_CAPATH || \ - (option) == CURLOPT_PROXY_CRLFILE || \ - (option) == CURLOPT_PROXY_ISSUERCERT || \ - (option) == CURLOPT_PROXY_KEYPASSWD || \ - (option) == CURLOPT_PROXY_PINNEDPUBLICKEY || \ - (option) == CURLOPT_PROXY_SERVICE_NAME || \ - (option) == CURLOPT_PROXY_SSL_CIPHER_LIST || \ - (option) == CURLOPT_PROXY_SSLCERT || \ - (option) == CURLOPT_PROXY_SSLCERTTYPE || \ - (option) == CURLOPT_PROXY_SSLKEY || \ - (option) == CURLOPT_PROXY_SSLKEYTYPE || \ - (option) == CURLOPT_PROXY_TLS13_CIPHERS || \ - (option) == CURLOPT_PROXY_TLSAUTH_PASSWORD || \ - (option) == CURLOPT_PROXY_TLSAUTH_TYPE || \ - (option) == CURLOPT_PROXY_TLSAUTH_USERNAME || \ - (option) == CURLOPT_PROXYPASSWORD || \ - (option) == CURLOPT_PROXYUSERNAME || \ - (option) == CURLOPT_PROXYUSERPWD || \ - (option) == CURLOPT_RANDOM_FILE || \ - (option) == CURLOPT_RANGE || \ - (option) == CURLOPT_REDIR_PROTOCOLS_STR || \ - (option) == CURLOPT_REFERER || \ - (option) == CURLOPT_REQUEST_TARGET || \ - (option) == CURLOPT_RTSP_SESSION_ID || \ - (option) == CURLOPT_RTSP_STREAM_URI || \ - (option) == CURLOPT_RTSP_TRANSPORT || \ - (option) == CURLOPT_SASL_AUTHZID || \ - (option) == CURLOPT_SERVICE_NAME || \ - (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \ - (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ - (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 || \ - (option) == CURLOPT_SSH_KNOWNHOSTS || \ - (option) == CURLOPT_SSH_PRIVATE_KEYFILE || \ - (option) == CURLOPT_SSH_PUBLIC_KEYFILE || \ - (option) == CURLOPT_SSLCERT || \ - (option) == CURLOPT_SSLCERTTYPE || \ - (option) == CURLOPT_SSLENGINE || \ - (option) == CURLOPT_SSLKEY || \ - (option) == CURLOPT_SSLKEYTYPE || \ - (option) == CURLOPT_SSL_CIPHER_LIST || \ - (option) == CURLOPT_TLS13_CIPHERS || \ - (option) == CURLOPT_TLSAUTH_PASSWORD || \ - (option) == CURLOPT_TLSAUTH_TYPE || \ - (option) == CURLOPT_TLSAUTH_USERNAME || \ - (option) == CURLOPT_UNIX_SOCKET_PATH || \ - (option) == CURLOPT_URL || \ - (option) == CURLOPT_USERAGENT || \ - (option) == CURLOPT_USERNAME || \ - (option) == CURLOPT_AWS_SIGV4 || \ - (option) == CURLOPT_USERPWD || \ - (option) == CURLOPT_XOAUTH2_BEARER || \ - (option) == CURLOPT_SSL_EC_CURVES || \ - 0) - -/* evaluates to true if option takes a curl_write_callback argument */ -#define curlcheck_write_cb_option(option) \ - ((option) == CURLOPT_HEADERFUNCTION || \ - (option) == CURLOPT_WRITEFUNCTION) - -/* evaluates to true if option takes a curl_conv_callback argument */ -#define curlcheck_conv_cb_option(option) \ - ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION || \ - (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION || \ - (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION) - -/* evaluates to true if option takes a data argument to pass to a callback */ -#define curlcheck_cb_data_option(option) \ - ((option) == CURLOPT_CHUNK_DATA || \ - (option) == CURLOPT_CLOSESOCKETDATA || \ - (option) == CURLOPT_DEBUGDATA || \ - (option) == CURLOPT_FNMATCH_DATA || \ - (option) == CURLOPT_HEADERDATA || \ - (option) == CURLOPT_HSTSREADDATA || \ - (option) == CURLOPT_HSTSWRITEDATA || \ - (option) == CURLOPT_INTERLEAVEDATA || \ - (option) == CURLOPT_IOCTLDATA || \ - (option) == CURLOPT_OPENSOCKETDATA || \ - (option) == CURLOPT_PREREQDATA || \ - (option) == CURLOPT_PROGRESSDATA || \ - (option) == CURLOPT_READDATA || \ - (option) == CURLOPT_SEEKDATA || \ - (option) == CURLOPT_SOCKOPTDATA || \ - (option) == CURLOPT_SSH_KEYDATA || \ - (option) == CURLOPT_SSL_CTX_DATA || \ - (option) == CURLOPT_WRITEDATA || \ - (option) == CURLOPT_RESOLVER_START_DATA || \ - (option) == CURLOPT_TRAILERDATA || \ - (option) == CURLOPT_SSH_HOSTKEYDATA || \ - 0) - -/* evaluates to true if option takes a POST data argument (void* or char*) */ -#define curlcheck_postfields_option(option) \ - ((option) == CURLOPT_POSTFIELDS || \ - (option) == CURLOPT_COPYPOSTFIELDS || \ - 0) - -/* evaluates to true if option takes a struct curl_slist * argument */ -#define curlcheck_slist_option(option) \ - ((option) == CURLOPT_HTTP200ALIASES || \ - (option) == CURLOPT_HTTPHEADER || \ - (option) == CURLOPT_MAIL_RCPT || \ - (option) == CURLOPT_POSTQUOTE || \ - (option) == CURLOPT_PREQUOTE || \ - (option) == CURLOPT_PROXYHEADER || \ - (option) == CURLOPT_QUOTE || \ - (option) == CURLOPT_RESOLVE || \ - (option) == CURLOPT_TELNETOPTIONS || \ - (option) == CURLOPT_CONNECT_TO || \ - 0) - -/* groups of curl_easy_getinfo infos that take the same type of argument */ - -/* evaluates to true if info expects a pointer to char * argument */ -#define curlcheck_string_info(info) \ - (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG && \ - (info) != CURLINFO_PRIVATE) - -/* evaluates to true if info expects a pointer to long argument */ -#define curlcheck_long_info(info) \ - (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE) - -/* evaluates to true if info expects a pointer to double argument */ -#define curlcheck_double_info(info) \ - (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST) - -/* true if info expects a pointer to struct curl_slist * argument */ -#define curlcheck_slist_info(info) \ - (((info) == CURLINFO_SSL_ENGINES) || ((info) == CURLINFO_COOKIELIST)) - -/* true if info expects a pointer to struct curl_tlssessioninfo * argument */ -#define curlcheck_tlssessioninfo_info(info) \ - (((info) == CURLINFO_TLS_SSL_PTR) || ((info) == CURLINFO_TLS_SESSION)) - -/* true if info expects a pointer to struct curl_certinfo * argument */ -#define curlcheck_certinfo_info(info) ((info) == CURLINFO_CERTINFO) - -/* true if info expects a pointer to struct curl_socket_t argument */ -#define curlcheck_socket_info(info) \ - (CURLINFO_SOCKET < (info) && (info) < CURLINFO_OFF_T) - -/* true if info expects a pointer to curl_off_t argument */ -#define curlcheck_off_t_info(info) \ - (CURLINFO_OFF_T < (info)) - - -/* typecheck helpers -- check whether given expression has requested type */ - -/* For pointers, you can use the curlcheck_ptr/curlcheck_arr macros, - * otherwise define a new macro. Search for __builtin_types_compatible_p - * in the GCC manual. - * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is - * the actual expression passed to the curl_easy_setopt macro. This - * means that you can only apply the sizeof and __typeof__ operators, no - * == or whatsoever. - */ - -/* XXX: should evaluate to true if expr is a pointer */ -#define curlcheck_any_ptr(expr) \ - (sizeof(expr) == sizeof(void *)) - -/* evaluates to true if expr is NULL */ -/* XXX: must not evaluate expr, so this check is not accurate */ -#define curlcheck_NULL(expr) \ - (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL))) - -/* evaluates to true if expr is type*, const type* or NULL */ -#define curlcheck_ptr(expr, type) \ - (curlcheck_NULL(expr) || \ - __builtin_types_compatible_p(__typeof__(expr), type *) || \ - __builtin_types_compatible_p(__typeof__(expr), const type *)) - -/* evaluates to true if expr is one of type[], type*, NULL or const type* */ -#define curlcheck_arr(expr, type) \ - (curlcheck_ptr((expr), type) || \ - __builtin_types_compatible_p(__typeof__(expr), type [])) - -/* evaluates to true if expr is a string */ -#define curlcheck_string(expr) \ - (curlcheck_arr((expr), char) || \ - curlcheck_arr((expr), signed char) || \ - curlcheck_arr((expr), unsigned char)) - -/* evaluates to true if expr is a long (no matter the signedness) - * XXX: for now, int is also accepted (and therefore short and char, which - * are promoted to int when passed to a variadic function) */ -#define curlcheck_long(expr) \ - (__builtin_types_compatible_p(__typeof__(expr), long) || \ - __builtin_types_compatible_p(__typeof__(expr), signed long) || \ - __builtin_types_compatible_p(__typeof__(expr), unsigned long) || \ - __builtin_types_compatible_p(__typeof__(expr), int) || \ - __builtin_types_compatible_p(__typeof__(expr), signed int) || \ - __builtin_types_compatible_p(__typeof__(expr), unsigned int) || \ - __builtin_types_compatible_p(__typeof__(expr), short) || \ - __builtin_types_compatible_p(__typeof__(expr), signed short) || \ - __builtin_types_compatible_p(__typeof__(expr), unsigned short) || \ - __builtin_types_compatible_p(__typeof__(expr), char) || \ - __builtin_types_compatible_p(__typeof__(expr), signed char) || \ - __builtin_types_compatible_p(__typeof__(expr), unsigned char)) - -/* evaluates to true if expr is of type curl_off_t */ -#define curlcheck_off_t(expr) \ - (__builtin_types_compatible_p(__typeof__(expr), curl_off_t)) - -/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */ -/* XXX: also check size of an char[] array? */ -#define curlcheck_error_buffer(expr) \ - (curlcheck_NULL(expr) || \ - __builtin_types_compatible_p(__typeof__(expr), char *) || \ - __builtin_types_compatible_p(__typeof__(expr), char[])) - -/* evaluates to true if expr is of type (const) void* or (const) FILE* */ -#if 0 -#define curlcheck_cb_data(expr) \ - (curlcheck_ptr((expr), void) || \ - curlcheck_ptr((expr), FILE)) -#else /* be less strict */ -#define curlcheck_cb_data(expr) \ - curlcheck_any_ptr(expr) -#endif - -/* evaluates to true if expr is of type FILE* */ -#define curlcheck_FILE(expr) \ - (curlcheck_NULL(expr) || \ - (__builtin_types_compatible_p(__typeof__(expr), FILE *))) - -/* evaluates to true if expr can be passed as POST data (void* or char*) */ -#define curlcheck_postfields(expr) \ - (curlcheck_ptr((expr), void) || \ - curlcheck_arr((expr), char) || \ - curlcheck_arr((expr), unsigned char)) - -/* helper: __builtin_types_compatible_p distinguishes between functions and - * function pointers, hide it */ -#define curlcheck_cb_compatible(func, type) \ - (__builtin_types_compatible_p(__typeof__(func), type) || \ - __builtin_types_compatible_p(__typeof__(func) *, type)) - -/* evaluates to true if expr is of type curl_resolver_start_callback */ -#define curlcheck_resolver_start_callback(expr) \ - (curlcheck_NULL(expr) || \ - curlcheck_cb_compatible((expr), curl_resolver_start_callback)) - -/* evaluates to true if expr is of type curl_read_callback or "similar" */ -#define curlcheck_read_cb(expr) \ - (curlcheck_NULL(expr) || \ - curlcheck_cb_compatible((expr), __typeof__(fread) *) || \ - curlcheck_cb_compatible((expr), curl_read_callback) || \ - curlcheck_cb_compatible((expr), _curl_read_callback1) || \ - curlcheck_cb_compatible((expr), _curl_read_callback2) || \ - curlcheck_cb_compatible((expr), _curl_read_callback3) || \ - curlcheck_cb_compatible((expr), _curl_read_callback4) || \ - curlcheck_cb_compatible((expr), _curl_read_callback5) || \ - curlcheck_cb_compatible((expr), _curl_read_callback6)) -typedef size_t (*_curl_read_callback1)(char *, size_t, size_t, void *); -typedef size_t (*_curl_read_callback2)(char *, size_t, size_t, const void *); -typedef size_t (*_curl_read_callback3)(char *, size_t, size_t, FILE *); -typedef size_t (*_curl_read_callback4)(void *, size_t, size_t, void *); -typedef size_t (*_curl_read_callback5)(void *, size_t, size_t, const void *); -typedef size_t (*_curl_read_callback6)(void *, size_t, size_t, FILE *); - -/* evaluates to true if expr is of type curl_write_callback or "similar" */ -#define curlcheck_write_cb(expr) \ - (curlcheck_read_cb(expr) || \ - curlcheck_cb_compatible((expr), __typeof__(fwrite) *) || \ - curlcheck_cb_compatible((expr), curl_write_callback) || \ - curlcheck_cb_compatible((expr), _curl_write_callback1) || \ - curlcheck_cb_compatible((expr), _curl_write_callback2) || \ - curlcheck_cb_compatible((expr), _curl_write_callback3) || \ - curlcheck_cb_compatible((expr), _curl_write_callback4) || \ - curlcheck_cb_compatible((expr), _curl_write_callback5) || \ - curlcheck_cb_compatible((expr), _curl_write_callback6)) -typedef size_t (*_curl_write_callback1)(const char *, size_t, size_t, void *); -typedef size_t (*_curl_write_callback2)(const char *, size_t, size_t, - const void *); -typedef size_t (*_curl_write_callback3)(const char *, size_t, size_t, FILE *); -typedef size_t (*_curl_write_callback4)(const void *, size_t, size_t, void *); -typedef size_t (*_curl_write_callback5)(const void *, size_t, size_t, - const void *); -typedef size_t (*_curl_write_callback6)(const void *, size_t, size_t, FILE *); - -/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */ -#define curlcheck_ioctl_cb(expr) \ - (curlcheck_NULL(expr) || \ - curlcheck_cb_compatible((expr), curl_ioctl_callback) || \ - curlcheck_cb_compatible((expr), _curl_ioctl_callback1) || \ - curlcheck_cb_compatible((expr), _curl_ioctl_callback2) || \ - curlcheck_cb_compatible((expr), _curl_ioctl_callback3) || \ - curlcheck_cb_compatible((expr), _curl_ioctl_callback4)) -typedef curlioerr (*_curl_ioctl_callback1)(CURL *, int, void *); -typedef curlioerr (*_curl_ioctl_callback2)(CURL *, int, const void *); -typedef curlioerr (*_curl_ioctl_callback3)(CURL *, curliocmd, void *); -typedef curlioerr (*_curl_ioctl_callback4)(CURL *, curliocmd, const void *); - -/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */ -#define curlcheck_sockopt_cb(expr) \ - (curlcheck_NULL(expr) || \ - curlcheck_cb_compatible((expr), curl_sockopt_callback) || \ - curlcheck_cb_compatible((expr), _curl_sockopt_callback1) || \ - curlcheck_cb_compatible((expr), _curl_sockopt_callback2)) -typedef int (*_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype); -typedef int (*_curl_sockopt_callback2)(const void *, curl_socket_t, - curlsocktype); - -/* evaluates to true if expr is of type curl_opensocket_callback or - "similar" */ -#define curlcheck_opensocket_cb(expr) \ - (curlcheck_NULL(expr) || \ - curlcheck_cb_compatible((expr), curl_opensocket_callback) || \ - curlcheck_cb_compatible((expr), _curl_opensocket_callback1) || \ - curlcheck_cb_compatible((expr), _curl_opensocket_callback2) || \ - curlcheck_cb_compatible((expr), _curl_opensocket_callback3) || \ - curlcheck_cb_compatible((expr), _curl_opensocket_callback4)) -typedef curl_socket_t (*_curl_opensocket_callback1) - (void *, curlsocktype, struct curl_sockaddr *); -typedef curl_socket_t (*_curl_opensocket_callback2) - (void *, curlsocktype, const struct curl_sockaddr *); -typedef curl_socket_t (*_curl_opensocket_callback3) - (const void *, curlsocktype, struct curl_sockaddr *); -typedef curl_socket_t (*_curl_opensocket_callback4) - (const void *, curlsocktype, const struct curl_sockaddr *); - -/* evaluates to true if expr is of type curl_progress_callback or "similar" */ -#define curlcheck_progress_cb(expr) \ - (curlcheck_NULL(expr) || \ - curlcheck_cb_compatible((expr), curl_progress_callback) || \ - curlcheck_cb_compatible((expr), _curl_progress_callback1) || \ - curlcheck_cb_compatible((expr), _curl_progress_callback2)) -typedef int (*_curl_progress_callback1)(void *, - double, double, double, double); -typedef int (*_curl_progress_callback2)(const void *, - double, double, double, double); - -/* evaluates to true if expr is of type curl_debug_callback or "similar" */ -#define curlcheck_debug_cb(expr) \ - (curlcheck_NULL(expr) || \ - curlcheck_cb_compatible((expr), curl_debug_callback) || \ - curlcheck_cb_compatible((expr), _curl_debug_callback1) || \ - curlcheck_cb_compatible((expr), _curl_debug_callback2) || \ - curlcheck_cb_compatible((expr), _curl_debug_callback3) || \ - curlcheck_cb_compatible((expr), _curl_debug_callback4) || \ - curlcheck_cb_compatible((expr), _curl_debug_callback5) || \ - curlcheck_cb_compatible((expr), _curl_debug_callback6) || \ - curlcheck_cb_compatible((expr), _curl_debug_callback7) || \ - curlcheck_cb_compatible((expr), _curl_debug_callback8)) -typedef int (*_curl_debug_callback1) (CURL *, - curl_infotype, char *, size_t, void *); -typedef int (*_curl_debug_callback2) (CURL *, - curl_infotype, char *, size_t, const void *); -typedef int (*_curl_debug_callback3) (CURL *, - curl_infotype, const char *, size_t, void *); -typedef int (*_curl_debug_callback4) (CURL *, - curl_infotype, const char *, size_t, const void *); -typedef int (*_curl_debug_callback5) (CURL *, - curl_infotype, unsigned char *, size_t, void *); -typedef int (*_curl_debug_callback6) (CURL *, - curl_infotype, unsigned char *, size_t, const void *); -typedef int (*_curl_debug_callback7) (CURL *, - curl_infotype, const unsigned char *, size_t, void *); -typedef int (*_curl_debug_callback8) (CURL *, - curl_infotype, const unsigned char *, size_t, const void *); - -/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */ -/* this is getting even messier... */ -#define curlcheck_ssl_ctx_cb(expr) \ - (curlcheck_NULL(expr) || \ - curlcheck_cb_compatible((expr), curl_ssl_ctx_callback) || \ - curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback1) || \ - curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback2) || \ - curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback3) || \ - curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback4) || \ - curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback5) || \ - curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback6) || \ - curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback7) || \ - curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback8)) -typedef CURLcode (*_curl_ssl_ctx_callback1)(CURL *, void *, void *); -typedef CURLcode (*_curl_ssl_ctx_callback2)(CURL *, void *, const void *); -typedef CURLcode (*_curl_ssl_ctx_callback3)(CURL *, const void *, void *); -typedef CURLcode (*_curl_ssl_ctx_callback4)(CURL *, const void *, - const void *); -#ifdef HEADER_SSL_H -/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX - * this will of course break if we are included before OpenSSL headers... - */ -typedef CURLcode (*_curl_ssl_ctx_callback5)(CURL *, SSL_CTX *, void *); -typedef CURLcode (*_curl_ssl_ctx_callback6)(CURL *, SSL_CTX *, const void *); -typedef CURLcode (*_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX *, void *); -typedef CURLcode (*_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX *, - const void *); -#else -typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5; -typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6; -typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7; -typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8; -#endif - -/* evaluates to true if expr is of type curl_conv_callback or "similar" */ -#define curlcheck_conv_cb(expr) \ - (curlcheck_NULL(expr) || \ - curlcheck_cb_compatible((expr), curl_conv_callback) || \ - curlcheck_cb_compatible((expr), _curl_conv_callback1) || \ - curlcheck_cb_compatible((expr), _curl_conv_callback2) || \ - curlcheck_cb_compatible((expr), _curl_conv_callback3) || \ - curlcheck_cb_compatible((expr), _curl_conv_callback4)) -typedef CURLcode (*_curl_conv_callback1)(char *, size_t length); -typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length); -typedef CURLcode (*_curl_conv_callback3)(void *, size_t length); -typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length); - -/* evaluates to true if expr is of type curl_seek_callback or "similar" */ -#define curlcheck_seek_cb(expr) \ - (curlcheck_NULL(expr) || \ - curlcheck_cb_compatible((expr), curl_seek_callback) || \ - curlcheck_cb_compatible((expr), _curl_seek_callback1) || \ - curlcheck_cb_compatible((expr), _curl_seek_callback2)) -typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int); -typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int); - - -#endif /* CURLINC_TYPECHECK_GCC_H */ diff --git a/deps/libcurl/include/curl/urlapi.h b/deps/libcurl/include/curl/urlapi.h deleted file mode 100644 index b4a6e5d567..0000000000 --- a/deps/libcurl/include/curl/urlapi.h +++ /dev/null @@ -1,155 +0,0 @@ -#ifndef CURLINC_URLAPI_H -#define CURLINC_URLAPI_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ - -#include "curl.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* the error codes for the URL API */ -typedef enum { - CURLUE_OK, - CURLUE_BAD_HANDLE, /* 1 */ - CURLUE_BAD_PARTPOINTER, /* 2 */ - CURLUE_MALFORMED_INPUT, /* 3 */ - CURLUE_BAD_PORT_NUMBER, /* 4 */ - CURLUE_UNSUPPORTED_SCHEME, /* 5 */ - CURLUE_URLDECODE, /* 6 */ - CURLUE_OUT_OF_MEMORY, /* 7 */ - CURLUE_USER_NOT_ALLOWED, /* 8 */ - CURLUE_UNKNOWN_PART, /* 9 */ - CURLUE_NO_SCHEME, /* 10 */ - CURLUE_NO_USER, /* 11 */ - CURLUE_NO_PASSWORD, /* 12 */ - CURLUE_NO_OPTIONS, /* 13 */ - CURLUE_NO_HOST, /* 14 */ - CURLUE_NO_PORT, /* 15 */ - CURLUE_NO_QUERY, /* 16 */ - CURLUE_NO_FRAGMENT, /* 17 */ - CURLUE_NO_ZONEID, /* 18 */ - CURLUE_BAD_FILE_URL, /* 19 */ - CURLUE_BAD_FRAGMENT, /* 20 */ - CURLUE_BAD_HOSTNAME, /* 21 */ - CURLUE_BAD_IPV6, /* 22 */ - CURLUE_BAD_LOGIN, /* 23 */ - CURLUE_BAD_PASSWORD, /* 24 */ - CURLUE_BAD_PATH, /* 25 */ - CURLUE_BAD_QUERY, /* 26 */ - CURLUE_BAD_SCHEME, /* 27 */ - CURLUE_BAD_SLASHES, /* 28 */ - CURLUE_BAD_USER, /* 29 */ - CURLUE_LACKS_IDN, /* 30 */ - CURLUE_TOO_LARGE, /* 31 */ - CURLUE_LAST -} CURLUcode; - -typedef enum { - CURLUPART_URL, - CURLUPART_SCHEME, - CURLUPART_USER, - CURLUPART_PASSWORD, - CURLUPART_OPTIONS, - CURLUPART_HOST, - CURLUPART_PORT, - CURLUPART_PATH, - CURLUPART_QUERY, - CURLUPART_FRAGMENT, - CURLUPART_ZONEID /* added in 7.65.0 */ -} CURLUPart; - -#define CURLU_DEFAULT_PORT (1<<0) /* return default port number */ -#define CURLU_NO_DEFAULT_PORT (1<<1) /* act as if no port number was set, - if the port number matches the - default for the scheme */ -#define CURLU_DEFAULT_SCHEME (1<<2) /* return default scheme if - missing */ -#define CURLU_NON_SUPPORT_SCHEME (1<<3) /* allow non-supported scheme */ -#define CURLU_PATH_AS_IS (1<<4) /* leave dot sequences */ -#define CURLU_DISALLOW_USER (1<<5) /* no user+password allowed */ -#define CURLU_URLDECODE (1<<6) /* URL decode on get */ -#define CURLU_URLENCODE (1<<7) /* URL encode on set */ -#define CURLU_APPENDQUERY (1<<8) /* append a form style part */ -#define CURLU_GUESS_SCHEME (1<<9) /* legacy curl-style guessing */ -#define CURLU_NO_AUTHORITY (1<<10) /* Allow empty authority when the - scheme is unknown. */ -#define CURLU_ALLOW_SPACE (1<<11) /* Allow spaces in the URL */ -#define CURLU_PUNYCODE (1<<12) /* get the hostname in punycode */ -#define CURLU_PUNY2IDN (1<<13) /* punycode => IDN conversion */ -#define CURLU_GET_EMPTY (1<<14) /* allow empty queries and fragments - when extracting the URL or the - components */ -#define CURLU_NO_GUESS_SCHEME (1<<15) /* for get, do not accept a guess */ - -typedef struct Curl_URL CURLU; - -/* - * curl_url() creates a new CURLU handle and returns a pointer to it. - * Must be freed with curl_url_cleanup(). - */ -CURL_EXTERN CURLU *curl_url(void); - -/* - * curl_url_cleanup() frees the CURLU handle and related resources used for - * the URL parsing. It will not free strings previously returned with the URL - * API. - */ -CURL_EXTERN void curl_url_cleanup(CURLU *handle); - -/* - * curl_url_dup() duplicates a CURLU handle and returns a new copy. The new - * handle must also be freed with curl_url_cleanup(). - */ -CURL_EXTERN CURLU *curl_url_dup(const CURLU *in); - -/* - * curl_url_get() extracts a specific part of the URL from a CURLU - * handle. Returns error code. The returned pointer MUST be freed with - * curl_free() afterwards. - */ -CURL_EXTERN CURLUcode curl_url_get(const CURLU *handle, CURLUPart what, - char **part, unsigned int flags); - -/* - * curl_url_set() sets a specific part of the URL in a CURLU handle. Returns - * error code. The passed in string will be copied. Passing a NULL instead of - * a part string, clears that part. - */ -CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what, - const char *part, unsigned int flags); - -/* - * curl_url_strerror() turns a CURLUcode value into the equivalent human - * readable error string. This is useful for printing meaningful error - * messages. - */ -CURL_EXTERN const char *curl_url_strerror(CURLUcode); - -#ifdef __cplusplus -} /* end of extern "C" */ -#endif - -#endif /* CURLINC_URLAPI_H */ diff --git a/deps/libcurl/include/curl/websockets.h b/deps/libcurl/include/curl/websockets.h deleted file mode 100644 index 6ef6a2bc92..0000000000 --- a/deps/libcurl/include/curl/websockets.h +++ /dev/null @@ -1,84 +0,0 @@ -#ifndef CURLINC_WEBSOCKETS_H -#define CURLINC_WEBSOCKETS_H -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - * SPDX-License-Identifier: curl - * - ***************************************************************************/ - -#ifdef __cplusplus -extern "C" { -#endif - -struct curl_ws_frame { - int age; /* zero */ - int flags; /* See the CURLWS_* defines */ - curl_off_t offset; /* the offset of this data into the frame */ - curl_off_t bytesleft; /* number of pending bytes left of the payload */ - size_t len; /* size of the current data chunk */ -}; - -/* flag bits */ -#define CURLWS_TEXT (1<<0) -#define CURLWS_BINARY (1<<1) -#define CURLWS_CONT (1<<2) -#define CURLWS_CLOSE (1<<3) -#define CURLWS_PING (1<<4) -#define CURLWS_OFFSET (1<<5) - -/* - * NAME curl_ws_recv() - * - * DESCRIPTION - * - * Receives data from the websocket connection. Use after successful - * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. - */ -CURL_EXTERN CURLcode curl_ws_recv(CURL *curl, void *buffer, size_t buflen, - size_t *recv, - const struct curl_ws_frame **metap); - -/* flags for curl_ws_send() */ -#define CURLWS_PONG (1<<6) - -/* - * NAME curl_ws_send() - * - * DESCRIPTION - * - * Sends data over the websocket connection. Use after successful - * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. - */ -CURL_EXTERN CURLcode curl_ws_send(CURL *curl, const void *buffer, - size_t buflen, size_t *sent, - curl_off_t fragsize, - unsigned int flags); - -/* bits for the CURLOPT_WS_OPTIONS bitmask: */ -#define CURLWS_RAW_MODE (1<<0) - -CURL_EXTERN const struct curl_ws_frame *curl_ws_meta(CURL *curl); - -#ifdef __cplusplus -} -#endif - -#endif /* CURLINC_WEBSOCKETS_H */ diff --git a/deps/libcurl/lib/libcurl.a b/deps/libcurl/lib/libcurl.a deleted file mode 100644 index 72707170fba0835a5a8b32221e585e0e6b4e657e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1123738 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¨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%0Dd? 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

*DWG|`1{`*e@ULJNaFrVHsky6 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 MSI%MgZ>L88H;wh=U;qFB From 836e22d0eaa89e3a6cc2f3a90ef02255228e2a7c Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 10:09:06 +1100 Subject: [PATCH 17/31] makefile --- .gitignore | 1 + Makefile | 10 +++++++--- linux.mk | 14 ++++++++++++-- 3 files changed, 20 insertions(+), 5 deletions(-) diff --git a/.gitignore b/.gitignore index 12a85c294f..04f217aed8 100644 --- a/.gitignore +++ b/.gitignore @@ -28,6 +28,7 @@ res/keeperfx_icon.ico .header_checksum /deps/enet /deps/enet6 +/deps/libcurl /deps/zlib /deps/spng /deps/astronomy diff --git a/Makefile b/Makefile index 2f1de638a5..b2e73d2257 100644 --- a/Makefile +++ b/Makefile @@ -379,7 +379,7 @@ LINKLIB = -mwindows \ -L"deps/enet6/lib" -lenet6 \ -L"deps/miniupnpc" -lminiupnpc \ -L"deps/libnatpmp" -lnatpmp -liphlpapi \ - -L"deps/libcurl/lib" -lcurl -lwldap32 -lcrypt32 \ + -L"deps/libcurl/lib" -lcurl -lwldap32 -lcrypt32 -lsecur32 -liphlpapi \ -L"deps/spng" -lspng \ -L"deps/centijson" -ljson \ -L"deps/zlib" -lminizip -lz \ @@ -655,7 +655,8 @@ libexterns: libexterns.mk clean-libexterns: libexterns.mk -$(MAKE) -f libexterns.mk clean-libexterns - -$(RM) -rf deps/enet6 deps/zlib deps/spng deps/astronomy deps/centijson deps/luajit deps/miniupnpc deps/libnatpmp + -$(RM) -rf deps/enet6 deps/zlib deps/spng deps/astronomy deps/centijson deps/luajit deps/miniupnpc deps/libnatpmp deps/libcurl + -$(RM) deps/libcurl-mingw32.tar.gz -$(RM) libexterns deps/enet6 deps/zlib deps/spng deps/astronomy deps/centijson deps/ffmpeg deps/openal deps/luajit deps/miniupnpc deps/libnatpmp deps/libcurl: @@ -736,7 +737,10 @@ deps/libnatpmp-mingw32.tar.gz: deps/libnatpmp/include/natpmp/natpmp.h: deps/libnatpmp-mingw32.tar.gz | deps/libnatpmp tar xzmf $< -C deps/libnatpmp -deps/libcurl/include/curl/curl.h: deps/curl-mingw32.tar.gz | deps/libcurl +deps/libcurl-mingw32.tar.gz: + curl -Lso $@ "https://github.com/dkfans/kfx-deps/releases/download/20260310/libcurl-mingw32.tar.gz" + +deps/libcurl/include/curl/curl.h: deps/libcurl-mingw32.tar.gz | deps/libcurl tar xzmf $< -C deps/libcurl cppcheck: | src/ver_defs.h diff --git a/linux.mk b/linux.mk index 74adfa966f..f209f139c9 100644 --- a/linux.mk +++ b/linux.mk @@ -282,6 +282,7 @@ KFX_INCLUDES = \ -Ideps/centitoml \ -Ideps/astronomy/include \ -Ideps/enet6/include \ + -Ideps/libcurl/include \ $(shell pkg-config --cflags-only-I luajit) KFX_CFLAGS += -g -DDEBUG -DBFDEBUG_LEVEL=0 -O3 -march=x86-64 $(KFX_INCLUDES) -Wall -Wextra -Werror -Wno-unused-parameter -Wno-absolute-value -Wno-unknown-pragmas -Wno-format-truncation -Wno-sign-compare @@ -309,6 +310,7 @@ KFX_LDFLAGS += \ $(shell pkg-config --libs-only-l zlib) \ -lminiupnpc \ -lnatpmp \ + -Ldeps/libcurl/lib -lcurl -lssl -lcrypto \ -ldl TOML_SOURCES = \ @@ -331,7 +333,8 @@ endif all: bin/keeperfx clean: - rm -rf obj bin src/ver_defs.h deps/astronomy deps/centijson deps/enet6 + rm -rf obj bin src/ver_defs.h deps/astronomy deps/centijson deps/enet6 deps/libcurl + rm -f deps/libcurl-lin64.tar.gz .PHONY: all clean @@ -349,13 +352,14 @@ $(KFX_CXX_OBJECTS): obj/%.o: src/%.cpp src/ver_defs.h | obj $(TOML_OBJECTS): obj/centitoml/%.o: deps/centitoml/%.c | obj/centitoml $(CC) $(TOML_CFLAGS) -c $< -o $@ -bin obj deps/astronomy deps/centijson deps/enet6 obj/centitoml: +bin obj deps/astronomy deps/centijson deps/enet6 deps/libcurl obj/centitoml: $(MKDIR) $@ src/actionpt.c: deps/centijson/include/json.h src/api.c: deps/centijson/include/json.h src/bflib_enet.cpp: deps/enet6/include/enet6/enet.h src/moonphase.c: deps/astronomy/include/astronomy.h +src/net_matchmaking.c: deps/libcurl/include/curl/curl.h deps/centitoml/toml_api.c: deps/centijson/include/json.h deps/centitoml/toml_conv.c: deps/centijson/include/json.h @@ -377,6 +381,12 @@ deps/enet6-lin64.tar.gz: deps/enet6/include/enet6/enet.h: deps/enet6-lin64.tar.gz | deps/enet6 tar xzmf $< -C deps/enet6 +deps/libcurl-lin64.tar.gz: + curl -Lso $@ "https://github.com/dkfans/kfx-deps/releases/download/20260310/libcurl-lin64.tar.gz" + +deps/libcurl/include/curl/curl.h: deps/libcurl-lin64.tar.gz | deps/libcurl + tar xzmf $< -C deps/libcurl + src/ver_defs.h: version.mk $(ECHO) "#define VER_MAJOR $(VER_MAJOR)" > $@.swp $(ECHO) "#define VER_MINOR $(VER_MINOR)" >> $@.swp From 1256d75a83af2e67db82124388a6f3afc2f27c1c Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 10:36:07 +1100 Subject: [PATCH 18/31] better logging --- src/bflib_enet.cpp | 12 +-------- src/net_holepunch.c | 56 ++++++++--------------------------------- src/net_matchmaking.c | 41 ++++++++++++------------------ src/net_portforward.cpp | 13 +++++----- 4 files changed, 34 insertions(+), 88 deletions(-) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index d2187799c6..e2f88c65b1 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -200,15 +200,14 @@ namespace { ENetAddress connect_address; if (g_join_lobby_id[0] != '\0') { + LbNetLog("Join: connecting via UDP hole punching\n"); host = enet_host_create(ENET_ADDRESS_TYPE_IPV4, NULL, 4, NUM_CHANNELS, 0, 0); if (!host) { LbNetLog("Join: failed to create ENet host\n"); return Lb_FAIL; } - LbNetLog("Join: created client host, local port=%u\n", (unsigned)host->address.port); char ext_ip[MATCHMAKING_IP_MAX] = {0}; uint16_t ext_port = holepunch_stun_query(host, ext_ip, sizeof(ext_ip)); - LbNetLog("Join: STUN ext_port=%u\n", (unsigned)ext_port); char peer_ip[MATCHMAKING_IP_MAX] = {0}; int peer_port = 0; if (matchmaking_punch(g_join_lobby_id, (int)ext_port, ext_ip, peer_ip, &peer_port) != 0) { @@ -217,14 +216,12 @@ namespace return Lb_FAIL; } g_join_lobby_id[0] = '\0'; - LbNetLog("Join: resolving peer address %s\n", peer_ip); if (enet_address_set_host(&connect_address, ENET_ADDRESS_TYPE_IPV4, peer_ip) < 0) { LbNetLog("Join: failed to resolve peer address %s\n", peer_ip); host_destroy(); return Lb_FAIL; } connect_address.port = (enet_uint16)peer_port; - LbNetLog("Join: sleeping %dms before connect\n", HOLEPUNCH_CONNECT_DELAY_MS); Sleep(HOLEPUNCH_CONNECT_DELAY_MS); } else { char buf[128] = {0}; @@ -247,19 +244,12 @@ namespace } enet_host_compress_with_range_coder(host); holepunch_punch_to(host, &connect_address); - LbNetLog("Join: calling enet_host_connect to %u.%u.%u.%u:%u\n", - (unsigned)connect_address.host.v4[0], - (unsigned)connect_address.host.v4[1], - (unsigned)connect_address.host.v4[2], - (unsigned)connect_address.host.v4[3], - (unsigned)connect_address.port); client_peer = enet_host_connect(host, &connect_address, NUM_CHANNELS, 0); if (!client_peer) { LbNetLog("Join: enet_host_connect returned NULL\n"); host_destroy(); return Lb_FAIL; } - LbNetLog("Join: waiting up to %dms for connection\n", TIMEOUT_ENET_CONNECT); if (wait_for_connect(TIMEOUT_ENET_CONNECT)) { LbNetLog("Join: connection timed out or failed\n"); host_destroy(); diff --git a/src/net_holepunch.c b/src/net_holepunch.c index 21043e0547..fbdf74f247 100644 --- a/src/net_holepunch.c +++ b/src/net_holepunch.c @@ -66,19 +66,16 @@ struct StunAttrHeader { uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) { ENetAddress stun_addr; - LbNetLog("STUN: resolving %s\n", STUN_SERVER); if (enet_address_set_host(&stun_addr, ENET_ADDRESS_TYPE_IPV4, STUN_SERVER) < 0) { LbNetLog("STUN: failed to resolve %s\n", STUN_SERVER); return 0; } stun_addr.port = STUN_PORT; - LbNetLog("STUN: resolved, sending binding request to port %u\n", (unsigned)STUN_PORT); static unsigned s_counter = 0; s_counter++; struct StunHeader req = {htons(STUN_BINDING_REQUEST), htons(0), htonl(STUN_MAGIC_COOKIE), {0}}; memcpy(req.txid, &s_counter, sizeof(s_counter)); - LbNetLog("STUN: txid counter=%u, host socket=%d\n", s_counter, (int)host->socket); ENetBuffer send_buf = {sizeof(req), &req}; ENetSocket sock = host->socket; ENetSocket tmp_sock = ENET_SOCKET_NULL; @@ -94,63 +91,41 @@ uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) enet_socket_destroy(tmp_sock); return 0; } - LbNetLog("STUN: sent via fallback socket (port will be host port %u)\n", (unsigned)host->address.port); sock = tmp_sock; - } else { - LbNetLog("STUN: sent via host socket\n"); } DWORD deadline = GetTickCount() + STUN_TIMEOUT_MS; uint16_t result = 0; - LbNetLog("STUN: waiting up to %d ms for response\n", STUN_TIMEOUT_MS); for (;;) { DWORD now = GetTickCount(); - if (now >= deadline) { - LbNetLog("STUN: deadline exceeded\n"); + if (now >= deadline) break; - } enet_uint32 wait_flags = ENET_SOCKET_WAIT_RECEIVE; if (enet_socket_wait(sock, &wait_flags, deadline - now) < 0 - || !(wait_flags & ENET_SOCKET_WAIT_RECEIVE)) { - LbNetLog("STUN: no response within %d ms\n", STUN_TIMEOUT_MS); + || !(wait_flags & ENET_SOCKET_WAIT_RECEIVE)) break; - } uint8_t resp[STUN_RESPONSE_BUF_SIZE]; ENetAddress from; ENetBuffer recv_buf = {sizeof(resp), resp}; int n = enet_socket_receive(sock, &from, &recv_buf, 1); - LbNetLog("STUN: received %d bytes\n", n); if (n <= 0) continue; - if (n < (int)sizeof(struct StunHeader)) { - LbNetLog("STUN: packet too short (%d bytes), ignoring\n", n); + if (n < (int)sizeof(struct StunHeader)) break; - } const struct StunHeader *hdr = (const struct StunHeader *)resp; - uint16_t pkt_type = ntohs(hdr->type); - uint32_t pkt_magic = ntohl(hdr->magic); - int txid_match = (memcmp(hdr->txid, req.txid, sizeof(hdr->txid)) == 0); - LbNetLog("STUN: pkt type=0x%04x magic=0x%08x txid_match=%d\n", - (unsigned)pkt_type, (unsigned)pkt_magic, txid_match); - if (pkt_type != STUN_BINDING_SUCCESS - || pkt_magic != STUN_MAGIC_COOKIE - || !txid_match) { - LbNetLog("STUN: packet discarded (expected type=0x%04x magic=0x%08x)\n", - (unsigned)STUN_BINDING_SUCCESS, (unsigned)STUN_MAGIC_COOKIE); + if (ntohs(hdr->type) != STUN_BINDING_SUCCESS + || ntohl(hdr->magic) != STUN_MAGIC_COOKIE + || memcmp(hdr->txid, req.txid, sizeof(hdr->txid)) != 0) continue; - } int offset = (int)sizeof(struct StunHeader); int attrs_end = offset + (int)ntohs(hdr->length); if (attrs_end > n) attrs_end = n; - LbNetLog("STUN: parsing attributes (attrs_end=%d)\n", attrs_end); char ip[64] = {0}; uint16_t ext_port = 0; while (offset + 4 <= attrs_end) { const struct StunAttrHeader *attr = (const struct StunAttrHeader *)(resp + offset); uint16_t atype = ntohs(attr->type); uint16_t alen = ntohs(attr->length); - LbNetLog("STUN: attribute type=0x%04x len=%u at offset=%d\n", - (unsigned)atype, (unsigned)alen, offset); offset += 4; if (atype == STUN_ATTR_XOR_MAPPED && alen >= 8 && offset + alen <= attrs_end && resp[offset + 1] == 0x01) { @@ -162,21 +137,14 @@ uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) snprintf(ip, sizeof(ip), "%u.%u.%u.%u", (addr >> 24) & 0xFFu, (addr >> 16) & 0xFFu, (addr >> 8) & 0xFFu, addr & 0xFFu); - LbNetLog("STUN: XOR-MAPPED-ADDRESS raw xor_port=0x%04x -> ext_port=%u, ip=%s\n", - (unsigned)xor_port, (unsigned)ext_port, ip); break; } offset += (alen + 3) & ~3; } - if (!ext_port) { - LbNetLog("STUN: no XOR-MAPPED-ADDRESS found in response\n"); + if (!ext_port) continue; - } - if (tmp_sock != ENET_SOCKET_NULL) { - LbNetLog("STUN: used fallback socket, overriding ext_port %u -> host port %u\n", - (unsigned)ext_port, (unsigned)host->address.port); + if (tmp_sock != ENET_SOCKET_NULL) ext_port = host->address.port; - } LbNetLog("STUN: external address %s:%u\n", ip, (unsigned)ext_port); if (ip_out && ip_len > 0) snprintf(ip_out, ip_len, "%s", ip); @@ -192,12 +160,8 @@ uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) void holepunch_punch_to(ENetHost *host, const ENetAddress *target) { - LbNetLog("Holepunch: sending %d punch packets to port %u\n", - HOLE_PUNCH_COUNT, (unsigned)target->port); static const uint8_t payload[HOLE_PUNCH_PAYLOAD_SIZE] = {0}; ENetBuffer buf = {sizeof(payload), (void *)payload}; - for (int i = 0; i < HOLE_PUNCH_COUNT; i++) { - int r = enet_socket_send(host->socket, target, &buf, 1); - LbNetLog("Holepunch: punch %d/%d result=%d\n", i + 1, HOLE_PUNCH_COUNT, r); - } + for (int i = 0; i < HOLE_PUNCH_COUNT; i++) + enet_socket_send(host->socket, target, &buf, 1); } diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index 784cd6172b..5b80859415 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -62,7 +62,6 @@ static void ws_cleanup(void) static int ws_send(const char *msg) { - LbNetLog("Matchmaking: ws_send: %s\n", msg); size_t sent = 0; CURLcode rc = curl_ws_send(g_curl, msg, strlen(msg), &sent, 0, CURLWS_TEXT); if (rc != CURLE_OK) { @@ -85,26 +84,20 @@ static int ws_recv(char *buf, size_t bufsz, int timeout_ms) FD_ZERO(&fds); FD_SET((SOCKET)sock, &fds); struct timeval tv = { timeout_ms / 1000, (timeout_ms % 1000) * 1000 }; - if (select(0, &fds, NULL, NULL, &tv) <= 0) { - if (timeout_ms > 0) - LbNetLog("Matchmaking: ws_recv no data within %d ms\n", timeout_ms); + if (select(0, &fds, NULL, NULL, &tv) <= 0) return 0; - } size_t recvd = 0; const struct curl_ws_frame *frame = NULL; CURLcode rc = curl_ws_recv(g_curl, buf, bufsz - 1, &recvd, &frame); - if (rc == CURLE_AGAIN) { - LbNetLog("Matchmaking: ws_recv CURLE_AGAIN\n"); + if (rc == CURLE_AGAIN) return 0; - } if (rc != CURLE_OK) { LbNetLog("Matchmaking: ws_recv failed (%s)\n", curl_easy_strerror(rc)); ws_cleanup(); return -1; } buf[recvd] = '\0'; - LbNetLog("Matchmaking: ws_recv got %d bytes: %s\n", (int)recvd, buf); return (int)recvd; } @@ -238,7 +231,6 @@ void matchmaking_refresh_sessions(void) if (!p) break; p = json_str(p, "name", name, sizeof(name)); if (!p) break; - LbNetLog("Matchmaking: session[%d] id=%s name=%s\n", count, id, name); struct TbNetworkSessionNameEntry *s = &g_mm_sessions[count++]; memset(s, 0, sizeof(*s)); s->joinable = 1; @@ -261,6 +253,7 @@ int matchmaking_create(const char *name, int udp_port, const char *ip) char buf[WS_BUF_SIZE]; EnterCriticalSection(&g_cs); if (!g_curl) { + LbNetLog("Matchmaking: not connected to server, lobby won't be listed online\n"); LeaveCriticalSection(&g_cs); return -1; } @@ -299,6 +292,11 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch char msg[SEND_BUF_SIZE]; char buf[WS_BUF_SIZE]; EnterCriticalSection(&g_cs); + if (!g_curl) { + LbNetLog("Matchmaking: not connected to server, UDP hole punching unavailable\n"); + LeaveCriticalSection(&g_cs); + return -1; + } char ip_field[IP_FIELD_SIZE] = ""; if (udp_ip && udp_ip[0]) snprintf(ip_field, sizeof(ip_field), ",\"udpIp\":\"%s\"", udp_ip); @@ -325,10 +323,8 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch LeaveCriticalSection(&g_cs); return -1; } - if (strstr(buf, "\"lobbies\"")) { - LbNetLog("Matchmaking: punch skipping lobbies message\n"); + if (strstr(buf, "\"lobbies\"")) continue; - } break; } if (!strstr(buf, "\"punch\"") @@ -350,18 +346,13 @@ int matchmaking_poll_punch(char *out_ip, int *out_port) char buf[WS_BUF_SIZE]; int n = ws_recv(buf, sizeof(buf), 0); int got_punch = 0; - if (n > 0) { - LbNetLog("Matchmaking: poll_punch received %d bytes: %s\n", n, buf); - if (strstr(buf, "\"punch\"")) { - got_punch = json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) - && json_int(buf, "peerPort", out_port); - if (got_punch) - LbNetLog("Matchmaking: poll_punch -> %s:%d\n", out_ip, *out_port); - else - LbNetLog("Matchmaking: poll_punch parse failed\n"); - } else { - LbNetLog("Matchmaking: poll_punch ignored message (not a punch)\n"); - } + if (n > 0 && strstr(buf, "\"punch\"")) { + got_punch = json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) + && json_int(buf, "peerPort", out_port); + if (got_punch) + LbNetLog("Matchmaking: poll_punch -> %s:%d\n", out_ip, *out_port); + else + LbNetLog("Matchmaking: poll_punch parse failed\n"); } LeaveCriticalSection(&g_cs); return got_punch; diff --git a/src/net_portforward.cpp b/src/net_portforward.cpp index 28d0743ad1..42cb8695ef 100644 --- a/src/net_portforward.cpp +++ b/src/net_portforward.cpp @@ -189,7 +189,7 @@ static int natpmp_add_port_mapping(uint16_t port) { return 0; } } - LbNetLog("NAT-PMP: Mapped port %u\n", port); + LbNetLog("NAT-PMP: port forwarding active on port %u\n", port); mapped_port = port; active_method = PORT_FORWARD_NATPMP; closenatpmp(&natpmp); @@ -208,12 +208,13 @@ static void port_forward_add_mapping_internal(uint16_t port) { return; } if (!upnp_enabled) { + LbNetLog("Port forwarding unavailable (NAT-PMP failed or disabled, UPnP disabled), UDP hole punching will be used\n"); return; } int error = 0; struct UPNPDev *device_list = upnpDiscover(UPNP_TIMEOUT_MS, NULL, NULL, 0, 0, 2, &error); if (!device_list) { - LbNetLog("UPnP: No devices found\n"); + LbNetLog("UPnP: no devices found, port forwarding unavailable, UDP hole punching will be used\n"); return; } #if (MINIUPNPC_API_VERSION >= 18) @@ -223,7 +224,7 @@ static void port_forward_add_mapping_internal(uint16_t port) { #endif freeUPNPDevlist(device_list); if (internet_gateway_device_result == 0) { - LbNetLog("UPnP: Failed to get valid IGD\n"); + LbNetLog("UPnP: router found but no valid IGD, port forwarding unavailable, UDP hole punching will be used\n"); FreeUPNPUrls(&upnp_urls); return; } @@ -232,15 +233,15 @@ static void port_forward_add_mapping_internal(uint16_t port) { UPNP_DeletePortMapping(upnp_urls.controlURL, upnp_data.first.servicetype, port_string, "UDP", ""); int result = UPNP_AddPortMapping(upnp_urls.controlURL, upnp_data.first.servicetype, port_string, port_string, upnp_lanaddr, "KeeperFX", "UDP", "", "0"); if (result != UPNPCOMMAND_SUCCESS) { - LbNetLog("UPnP: Permanent lease rejected, trying timed lease\n"); + LbNetLog("UPnP: permanent lease rejected, trying timed lease\n"); result = UPNP_AddPortMapping(upnp_urls.controlURL, upnp_data.first.servicetype, port_string, port_string, upnp_lanaddr, "KeeperFX", "UDP", "", "3600"); if (result != UPNPCOMMAND_SUCCESS) { - LbNetLog("UPnP: Failed to add port mapping\n"); + LbNetLog("UPnP: failed to add port mapping, UDP hole punching will be used\n"); FreeUPNPUrls(&upnp_urls); return; } } - LbNetLog("UPnP: Mapped port %u\n", port); + LbNetLog("UPnP: port forwarding active on port %u\n", port); mapped_port = port; active_method = PORT_FORWARD_UPNP; } From de9f2e49c6d394dae6baf3eaf8251d6533077859 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 10:53:53 +1100 Subject: [PATCH 19/31] multiplayer_readme --- docs/multiplayer_readme.txt | 51 +++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 docs/multiplayer_readme.txt diff --git a/docs/multiplayer_readme.txt b/docs/multiplayer_readme.txt new file mode 100644 index 0000000000..c128c28e7b --- /dev/null +++ b/docs/multiplayer_readme.txt @@ -0,0 +1,51 @@ +Multiplayer in KeeperFX +------------------------------ + +KeeperFX supports multiplayer over TCP/IP or ENET/UDP. Serial, Modem and IPX are +not supported. 1Player allows you to practice multiplayer maps alone. + +KeeperFX, like Dungeon Keeper, requires a low latency connection to work properly. +Latency is always high when playing over very high distances, so playing with +people near you will work best. Multiplayer will start to become unplayable when +you are over a couple hundred kilometer away from each other. + +* High-latency connections will make both games run very slow. +* Limited to two players. +* Desyncs and crashes are very possible, report issues and they may be fixed. + +Multiplayer over ENET/UDP +------------------------------ + +KeeperFX includes an online matchmaking server. Hosted games are listed there +automatically, allowing others to browse and join without exchanging IP addresses. + +To host a ENET/UDP game: +Make sure the port 5556 is open for traffic and is forwarded to port 5556 on +your computer. When you have started the game, click Multiplayer -> ENET/UDP -> +Create Game. Your game will appear in the matchmaking list for others to join. + +To join a ENET/UDP game: +Click Multiplayer -> ENET/UDP to browse available games from the matchmaking +server, then select one and click Join Game. + +Alternatively, join directly by specifying a command line option +-sessions [ip_address]:5556 when starting game. For instance, if the host's IP +address is 55.83.54.187, the appropriate command line option is +-sessions 55.83.54.187:5556 +The launcher can be used to set this. + +Several sessions can be added to command line by prepending a semicolon before +each extra address, e.g. -sessions 55.83.54.187:5555;214.43.45.67:5556 + +When you have started the game, click Multiplayer -> ENET/UDP -> [select IP +address in list] -> Join Game. + +Multiplayer over TCP/IP +------------------------------ + +Hosting or joining a game over TCP/IP works the same as over ENET/UDP, with a +key difference. Open port 5555 instead and select TCP/IP from the multiplayer +menu. + +TCP/IP is less suitable for multiplayer as a protocol, and there's no known +reason to use this over ENET/UDP as you will have significantly more lag. \ No newline at end of file From ba7cb4d711b2ae86483a3f4751680f8de12a4dd1 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 13:41:53 +1100 Subject: [PATCH 20/31] LbSleepFor --- src/bflib_enet.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index e2f88c65b1..2d3a92dc49 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -14,6 +14,7 @@ #include "pre_inc.h" #include "bflib_enet.h" +#include "bflib_datetm.h" #include "bflib_network.h" #include "bflib_math.h" #include "net_portforward.h" @@ -222,7 +223,7 @@ namespace return Lb_FAIL; } connect_address.port = (enet_uint16)peer_port; - Sleep(HOLEPUNCH_CONNECT_DELAY_MS); + LbSleepFor(HOLEPUNCH_CONNECT_DELAY_MS); } else { char buf[128] = {0}; enet_uint16 port = parse_session_address(session, buf, sizeof(buf)); From f03dc210f576e33a52ff3dbc3578cb5ea35d7dcd Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 14:06:03 +1100 Subject: [PATCH 21/31] linux fix --- linux.mk | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/linux.mk b/linux.mk index f209f139c9..77d0951b5c 100644 --- a/linux.mk +++ b/linux.mk @@ -338,7 +338,7 @@ clean: .PHONY: all clean -bin/keeperfx: $(KFX_OBJECTS) $(TOML_OBJECTS) | bin +bin/keeperfx: $(KFX_OBJECTS) $(TOML_OBJECTS) deps/libcurl/lib/libcurl.a | bin $(CXX) -o $@ $(KFX_OBJECTS) $(TOML_OBJECTS) $(KFX_LDFLAGS) $(KFX_C_OBJECTS): obj/%.o: src/%.c src/ver_defs.h | obj @@ -384,9 +384,11 @@ deps/enet6/include/enet6/enet.h: deps/enet6-lin64.tar.gz | deps/enet6 deps/libcurl-lin64.tar.gz: curl -Lso $@ "https://github.com/dkfans/kfx-deps/releases/download/20260310/libcurl-lin64.tar.gz" -deps/libcurl/include/curl/curl.h: deps/libcurl-lin64.tar.gz | deps/libcurl +deps/libcurl/lib/libcurl.a: deps/libcurl-lin64.tar.gz | deps/libcurl tar xzmf $< -C deps/libcurl +deps/libcurl/include/curl/curl.h: deps/libcurl/lib/libcurl.a + src/ver_defs.h: version.mk $(ECHO) "#define VER_MAJOR $(VER_MAJOR)" > $@.swp $(ECHO) "#define VER_MINOR $(VER_MINOR)" >> $@.swp From e0121447050e00de51d265d83280e8b0ea3ada5f Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 14:13:37 +1100 Subject: [PATCH 22/31] linux fix2 --- linux.mk | 2 ++ 1 file changed, 2 insertions(+) diff --git a/linux.mk b/linux.mk index 77d0951b5c..68ba47edbc 100644 --- a/linux.mk +++ b/linux.mk @@ -211,6 +211,8 @@ src/map_utils.c \ src/moonphase.c \ src/net_checksums.c \ src/net_game.c \ +src/net_holepunch.c \ +src/net_matchmaking.c \ src/net_input_lag.c \ src/net_received_packets.c \ src/net_redundant_packets.c \ From 93aa18a462359c5f2aefdaf604c170585e69b972 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 14:18:38 +1100 Subject: [PATCH 23/31] linux fix3 --- linux.mk | 1 + src/net_holepunch.h | 1 + 2 files changed, 2 insertions(+) diff --git a/linux.mk b/linux.mk index 68ba47edbc..b38fb19cdb 100644 --- a/linux.mk +++ b/linux.mk @@ -361,6 +361,7 @@ src/actionpt.c: deps/centijson/include/json.h src/api.c: deps/centijson/include/json.h src/bflib_enet.cpp: deps/enet6/include/enet6/enet.h src/moonphase.c: deps/astronomy/include/astronomy.h +src/net_holepunch.c: deps/enet6/include/enet6/enet.h src/net_matchmaking.c: deps/libcurl/include/curl/curl.h deps/centitoml/toml_api.c: deps/centijson/include/json.h deps/centitoml/toml_conv.c: deps/centijson/include/json.h diff --git a/src/net_holepunch.h b/src/net_holepunch.h index d9822129ae..250a7f10cc 100644 --- a/src/net_holepunch.h +++ b/src/net_holepunch.h @@ -20,6 +20,7 @@ #ifndef NET_HOLEPUNCH_H #define NET_HOLEPUNCH_H +#include #include #ifdef __cplusplus From b9a69de384511dc98c12d797e1abdd0948835802 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 14:27:57 +1100 Subject: [PATCH 24/31] linux fix4 --- src/net_holepunch.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/net_holepunch.c b/src/net_holepunch.c index fbdf74f247..0bf5a48092 100644 --- a/src/net_holepunch.c +++ b/src/net_holepunch.c @@ -30,6 +30,10 @@ #if defined(_WIN32) #define WIN32_LEAN_AND_MEAN #include +#else +#include +typedef Uint32 DWORD; +#define GetTickCount SDL_GetTicks #endif #include #include @@ -76,7 +80,7 @@ uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) s_counter++; struct StunHeader req = {htons(STUN_BINDING_REQUEST), htons(0), htonl(STUN_MAGIC_COOKIE), {0}}; memcpy(req.txid, &s_counter, sizeof(s_counter)); - ENetBuffer send_buf = {sizeof(req), &req}; + ENetBuffer send_buf = {.data = &req, .dataLength = sizeof(req)}; ENetSocket sock = host->socket; ENetSocket tmp_sock = ENET_SOCKET_NULL; if (enet_socket_send(sock, &stun_addr, &send_buf, 1) < 0) { @@ -106,7 +110,7 @@ uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) break; uint8_t resp[STUN_RESPONSE_BUF_SIZE]; ENetAddress from; - ENetBuffer recv_buf = {sizeof(resp), resp}; + ENetBuffer recv_buf = {.data = resp, .dataLength = sizeof(resp)}; int n = enet_socket_receive(sock, &from, &recv_buf, 1); if (n <= 0) continue; @@ -161,7 +165,7 @@ uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) void holepunch_punch_to(ENetHost *host, const ENetAddress *target) { static const uint8_t payload[HOLE_PUNCH_PAYLOAD_SIZE] = {0}; - ENetBuffer buf = {sizeof(payload), (void *)payload}; + ENetBuffer buf = {.data = (void *)payload, .dataLength = sizeof(payload)}; for (int i = 0; i < HOLE_PUNCH_COUNT; i++) enet_socket_send(host->socket, target, &buf, 1); } From a94af9b849ac16906b869e794ecac9bab0817271 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 14:34:51 +1100 Subject: [PATCH 25/31] linux fix5 --- linux.mk | 3 ++- src/net_matchmaking.c | 43 ++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 42 insertions(+), 4 deletions(-) diff --git a/linux.mk b/linux.mk index b38fb19cdb..c936e0f9f4 100644 --- a/linux.mk +++ b/linux.mk @@ -313,7 +313,8 @@ KFX_LDFLAGS += \ -lminiupnpc \ -lnatpmp \ -Ldeps/libcurl/lib -lcurl -lssl -lcrypto \ - -ldl + -ldl \ + -lpthread TOML_SOURCES = \ deps/centitoml/toml_api.c diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index 5b80859415..e7e2fbcb44 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -21,9 +21,21 @@ #include "bflib_basics.h" #include "ver_defs.h" +#if defined(_WIN32) #define WIN32_LEAN_AND_MEAN #include #include +#else +#include +#include +#include +typedef Uint32 DWORD; +#define GetTickCount SDL_GetTicks +#define EnterCriticalSection(cs) pthread_mutex_lock(cs) +#define LeaveCriticalSection(cs) pthread_mutex_unlock(cs) +#define TryEnterCriticalSection(cs) (pthread_mutex_trylock(cs) == 0) +#endif + #include #include #include @@ -45,7 +57,11 @@ static CURL *g_curl = NULL; static char g_hosted_lobby_id[MATCHMAKING_ID_MAX] = {0}; static DWORD g_last_refresh_tick = 0; char g_join_lobby_id[MATCHMAKING_ID_MAX] = {0}; +#if defined(_WIN32) static CRITICAL_SECTION g_cs; +#else +static pthread_mutex_t g_cs = PTHREAD_MUTEX_INITIALIZER; +#endif struct TbNetworkSessionNameEntry g_mm_sessions[MATCHMAKING_SESSIONS_MAX]; int g_mm_session_count = 0; @@ -82,9 +98,14 @@ static int ws_recv(char *buf, size_t bufsz, int timeout_ms) fd_set fds; FD_ZERO(&fds); - FD_SET((SOCKET)sock, &fds); struct timeval tv = { timeout_ms / 1000, (timeout_ms % 1000) * 1000 }; +#if defined(_WIN32) + FD_SET((SOCKET)sock, &fds); if (select(0, &fds, NULL, NULL, &tv) <= 0) +#else + FD_SET((int)sock, &fds); + if (select((int)sock + 1, &fds, NULL, NULL, &tv) <= 0) +#endif return 0; size_t recvd = 0; @@ -139,26 +160,42 @@ static int json_int(const char *json, const char *key, int *out) void matchmaking_init(void) { - static BOOL s_done = FALSE; + static int s_done = 0; if (s_done) return; - s_done = TRUE; + s_done = 1; +#if defined(_WIN32) InitializeCriticalSection(&g_cs); +#endif curl_global_init(CURL_GLOBAL_DEFAULT); } +#if defined(_WIN32) static DWORD WINAPI connect_thread(LPVOID arg) { matchmaking_connect(); return 0; } +#else +static void *connect_thread(void *arg) +{ + matchmaking_connect(); + return NULL; +} +#endif void matchmaking_connect_async(void) { matchmaking_init(); +#if defined(_WIN32) HANDLE h = CreateThread(NULL, 0, connect_thread, NULL, 0, NULL); if (h) CloseHandle(h); +#else + pthread_t t; + if (pthread_create(&t, NULL, connect_thread, NULL) == 0) + pthread_detach(t); +#endif } int matchmaking_connect(void) From d104c5c2af364d3e274e7efd19f5146e001ed8b2 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 14:39:24 +1100 Subject: [PATCH 26/31] SDL --- linux.mk | 3 +- src/net_matchmaking.c | 108 ++++++++++++++---------------------------- 2 files changed, 37 insertions(+), 74 deletions(-) diff --git a/linux.mk b/linux.mk index c936e0f9f4..b38fb19cdb 100644 --- a/linux.mk +++ b/linux.mk @@ -313,8 +313,7 @@ KFX_LDFLAGS += \ -lminiupnpc \ -lnatpmp \ -Ldeps/libcurl/lib -lcurl -lssl -lcrypto \ - -ldl \ - -lpthread + -ldl TOML_SOURCES = \ deps/centitoml/toml_api.c diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index e7e2fbcb44..9d547b5246 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -21,21 +21,10 @@ #include "bflib_basics.h" #include "ver_defs.h" -#if defined(_WIN32) -#define WIN32_LEAN_AND_MEAN -#include -#include -#else #include -#include +#ifndef _WIN32 #include -typedef Uint32 DWORD; -#define GetTickCount SDL_GetTicks -#define EnterCriticalSection(cs) pthread_mutex_lock(cs) -#define LeaveCriticalSection(cs) pthread_mutex_unlock(cs) -#define TryEnterCriticalSection(cs) (pthread_mutex_trylock(cs) == 0) #endif - #include #include #include @@ -55,13 +44,9 @@ typedef Uint32 DWORD; static CURL *g_curl = NULL; static char g_hosted_lobby_id[MATCHMAKING_ID_MAX] = {0}; -static DWORD g_last_refresh_tick = 0; +static Uint32 g_last_refresh_tick = 0; char g_join_lobby_id[MATCHMAKING_ID_MAX] = {0}; -#if defined(_WIN32) -static CRITICAL_SECTION g_cs; -#else -static pthread_mutex_t g_cs = PTHREAD_MUTEX_INITIALIZER; -#endif +static SDL_mutex *g_cs = NULL; struct TbNetworkSessionNameEntry g_mm_sessions[MATCHMAKING_SESSIONS_MAX]; int g_mm_session_count = 0; @@ -98,14 +83,9 @@ static int ws_recv(char *buf, size_t bufsz, int timeout_ms) fd_set fds; FD_ZERO(&fds); + FD_SET(sock, &fds); struct timeval tv = { timeout_ms / 1000, (timeout_ms % 1000) * 1000 }; -#if defined(_WIN32) - FD_SET((SOCKET)sock, &fds); - if (select(0, &fds, NULL, NULL, &tv) <= 0) -#else - FD_SET((int)sock, &fds); if (select((int)sock + 1, &fds, NULL, NULL, &tv) <= 0) -#endif return 0; size_t recvd = 0; @@ -164,50 +144,34 @@ void matchmaking_init(void) if (s_done) return; s_done = 1; -#if defined(_WIN32) - InitializeCriticalSection(&g_cs); -#endif + g_cs = SDL_CreateMutex(); curl_global_init(CURL_GLOBAL_DEFAULT); } -#if defined(_WIN32) -static DWORD WINAPI connect_thread(LPVOID arg) +static int connect_thread(void *arg) { matchmaking_connect(); return 0; } -#else -static void *connect_thread(void *arg) -{ - matchmaking_connect(); - return NULL; -} -#endif void matchmaking_connect_async(void) { matchmaking_init(); -#if defined(_WIN32) - HANDLE h = CreateThread(NULL, 0, connect_thread, NULL, 0, NULL); - if (h) - CloseHandle(h); -#else - pthread_t t; - if (pthread_create(&t, NULL, connect_thread, NULL) == 0) - pthread_detach(t); -#endif + SDL_Thread *t = SDL_CreateThread(connect_thread, "matchmaking", NULL); + if (t) + SDL_DetachThread(t); } int matchmaking_connect(void) { - EnterCriticalSection(&g_cs); + SDL_LockMutex(g_cs); if (g_curl) { - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return 0; } g_curl = curl_easy_init(); if (!g_curl) { - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return -1; } LbNetLog("Matchmaking: connecting to %s\n", MATCHMAKING_URL); @@ -218,17 +182,17 @@ int matchmaking_connect(void) if (rc != CURLE_OK) { LbNetLog("Matchmaking: connect to %s failed: %s\n", MATCHMAKING_URL, curl_easy_strerror(rc)); ws_cleanup(); - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return -1; } LbNetLog("Matchmaking: connected\n"); - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return 0; } void matchmaking_disconnect(void) { - EnterCriticalSection(&g_cs); + SDL_LockMutex(g_cs); if (g_curl) { if (g_hosted_lobby_id[0] != '\0') { char msg[SEND_BUF_SIZE]; @@ -238,21 +202,21 @@ void matchmaking_disconnect(void) ws_cleanup(); LbNetLog("Matchmaking: disconnected\n"); } - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); } void matchmaking_refresh_sessions(void) { - EnterCriticalSection(&g_cs); + SDL_LockMutex(g_cs); if (!g_curl) { - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return; } char buf[WS_BUF_SIZE]; int list_n; if (g_last_refresh_tick == 0) { list_n = ws_exchange("{\"action\":\"list\",\"version\":\"" MATCHMAKING_VERSION "\"}", buf, sizeof(buf)); - g_last_refresh_tick = GetTickCount(); + g_last_refresh_tick = SDL_GetTicks(); } else { list_n = ws_recv(buf, sizeof(buf), 0); } @@ -279,7 +243,7 @@ void matchmaking_refresh_sessions(void) g_mm_session_count = count; LbNetLog("Matchmaking: parsed %d session(s)\n", count); } - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); } int matchmaking_create(const char *name, int udp_port, const char *ip) @@ -288,10 +252,10 @@ int matchmaking_create(const char *name, int udp_port, const char *ip) char ip_field[IP_FIELD_SIZE]; char msg[SEND_BUF_SIZE]; char buf[WS_BUF_SIZE]; - EnterCriticalSection(&g_cs); + SDL_LockMutex(g_cs); if (!g_curl) { LbNetLog("Matchmaking: not connected to server, lobby won't be listed online\n"); - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return -1; } int pos = 0; @@ -311,16 +275,16 @@ int matchmaking_create(const char *name, int udp_port, const char *ip) if (create_n > 0) LbNetLog("Matchmaking: create response (%d bytes): %s\n", create_n, buf); if (create_n <= 0) { - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return -1; } if (!strstr(buf, "\"created\"") || !json_str(buf, "id", g_hosted_lobby_id, MATCHMAKING_ID_MAX)) { LbNetLog("Matchmaking: create failed - unexpected response\n"); - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return -1; } LbNetLog("Matchmaking: created lobby id=%s\n", g_hosted_lobby_id); - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return 0; } @@ -328,10 +292,10 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch { char msg[SEND_BUF_SIZE]; char buf[WS_BUF_SIZE]; - EnterCriticalSection(&g_cs); + SDL_LockMutex(g_cs); if (!g_curl) { LbNetLog("Matchmaking: not connected to server, UDP hole punching unavailable\n"); - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return -1; } char ip_field[IP_FIELD_SIZE] = ""; @@ -341,23 +305,23 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d%s}", lobby_id, udp_port, ip_field); if (ws_send(msg) != 0) { - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return -1; } int punch_n; - DWORD deadline = GetTickCount() + WS_RECV_TIMEOUT_MS; + Uint32 deadline = SDL_GetTicks() + WS_RECV_TIMEOUT_MS; for (;;) { - int remaining = (int)(deadline - GetTickCount()); + int remaining = (int)(deadline - SDL_GetTicks()); if (remaining <= 0) { LbNetLog("Matchmaking: punch failed - timeout\n"); - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return -1; } punch_n = ws_recv(buf, sizeof(buf), remaining); if (punch_n > 0) LbNetLog("Matchmaking: punch response (%d bytes): %s\n", punch_n, buf); if (punch_n <= 0) { - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return -1; } if (strstr(buf, "\"lobbies\"")) @@ -368,17 +332,17 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch || !json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) || !json_int(buf, "peerPort", out_port)) { LbNetLog("Matchmaking: punch failed - unexpected response\n"); - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return -1; } LbNetLog("Matchmaking: punch relay -> %s:%d\n", out_ip, *out_port); - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return 0; } int matchmaking_poll_punch(char *out_ip, int *out_port) { - if (!g_curl || !TryEnterCriticalSection(&g_cs)) + if (!g_curl || !g_cs || SDL_TryLockMutex(g_cs) != 0) return 0; char buf[WS_BUF_SIZE]; int n = ws_recv(buf, sizeof(buf), 0); @@ -391,6 +355,6 @@ int matchmaking_poll_punch(char *out_ip, int *out_port) else LbNetLog("Matchmaking: poll_punch parse failed\n"); } - LeaveCriticalSection(&g_cs); + SDL_UnlockMutex(g_cs); return got_punch; } From 085fa72ce24749efc570b7bdf37ffc8f0fb234a8 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 14:43:36 +1100 Subject: [PATCH 27/31] more sdl fixes --- src/bflib_datetm.cpp | 9 ++------- src/bflib_enet.cpp | 3 +-- src/net_holepunch.c | 11 ++--------- 3 files changed, 5 insertions(+), 18 deletions(-) diff --git a/src/bflib_datetm.cpp b/src/bflib_datetm.cpp index 06c46f405d..32d0b32bfc 100644 --- a/src/bflib_datetm.cpp +++ b/src/bflib_datetm.cpp @@ -25,10 +25,7 @@ #include "bflib_basics.h" #include "game_legacy.h" -#if defined(_WIN32) -#define WIN32_LEAN_AND_MEAN -#include -#endif +#include #include "post_inc.h" #ifdef __cplusplus @@ -307,9 +304,7 @@ TbResult LbDateTimeDecode(const time_t *datetime,struct TbDate *curr_date,struct inline void LbDoMultitasking(void) { -#if defined(_WIN32) - Sleep(LARGE_DELAY_TIME>>1); // This switches to other tasks -#endif + SDL_Delay(LARGE_DELAY_TIME>>1); } TbBool LbSleepFor(TbClockMSec delay) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index 2d3a92dc49..eae66846f6 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -23,9 +23,8 @@ #include "game_legacy.h" #include "player_data.h" -#if defined(_WIN32) +#ifdef _WIN32 #define WIN32_LEAN_AND_MEAN -#include #endif #include #include diff --git a/src/net_holepunch.c b/src/net_holepunch.c index 0bf5a48092..17e7bee19f 100644 --- a/src/net_holepunch.c +++ b/src/net_holepunch.c @@ -27,14 +27,7 @@ #include "net_holepunch.h" #include "bflib_basics.h" -#if defined(_WIN32) -#define WIN32_LEAN_AND_MEAN -#include -#else #include -typedef Uint32 DWORD; -#define GetTickCount SDL_GetTicks -#endif #include #include #include @@ -98,10 +91,10 @@ uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) sock = tmp_sock; } - DWORD deadline = GetTickCount() + STUN_TIMEOUT_MS; + Uint32 deadline = SDL_GetTicks() + STUN_TIMEOUT_MS; uint16_t result = 0; for (;;) { - DWORD now = GetTickCount(); + Uint32 now = SDL_GetTicks(); if (now >= deadline) break; enet_uint32 wait_flags = ENET_SOCKET_WAIT_RECEIVE; From e067b0af2a18aecc26d276426cce4768d87b400a Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 15:02:45 +1100 Subject: [PATCH 28/31] linux fix6 --- linux.mk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/linux.mk b/linux.mk index b38fb19cdb..5ebd6c1bd0 100644 --- a/linux.mk +++ b/linux.mk @@ -312,7 +312,7 @@ KFX_LDFLAGS += \ $(shell pkg-config --libs-only-l zlib) \ -lminiupnpc \ -lnatpmp \ - -Ldeps/libcurl/lib -lcurl -lssl -lcrypto \ + -Ldeps/libcurl/lib -lcurl -lssl -lcrypto -lzstd \ -ldl TOML_SOURCES = \ From ef5290a62b5d823d215103e794641d709764a755 Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Wed, 11 Mar 2026 16:07:23 +1100 Subject: [PATCH 29/31] fix broken connection --- src/bflib_enet.cpp | 59 ++++++++++++++++++++-------------------------- 1 file changed, 26 insertions(+), 33 deletions(-) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index eae66846f6..9405e316d9 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -123,32 +123,6 @@ namespace return Lb_OK; } - int wait_for_connect(int timeout) - { - ENetEvent ev; - int ret; - while ( - (ret = enet_host_service(host, &ev, timeout)) > 0 - ) - { - if (ev.type == ENET_EVENT_TYPE_CONNECT) - { - return 0; - } - else - { - LbNetLog("wait_for_connect: unexpected event type=%d\n", (int)ev.type); - } - } - if (ret < 0) - { - LbNetLog("wait_for_connect: enet_host_service error %d\n", ret); - ERRORLOG("Unable to connect: %d", ret); - } else { - LbNetLog("wait_for_connect: timed out (ret=0)\n"); - } - return 1; - } enet_uint16 parse_session_address(const char *session, char *host_out, size_t host_size) { @@ -222,7 +196,6 @@ namespace return Lb_FAIL; } connect_address.port = (enet_uint16)peer_port; - LbSleepFor(HOLEPUNCH_CONNECT_DELAY_MS); } else { char buf[128] = {0}; enet_uint16 port = parse_session_address(session, buf, sizeof(buf)); @@ -250,13 +223,33 @@ namespace host_destroy(); return Lb_FAIL; } - if (wait_for_connect(TIMEOUT_ENET_CONNECT)) { - LbNetLog("Join: connection timed out or failed\n"); - host_destroy(); - return Lb_FAIL; + { + ENetEvent ev; + TbClockMSec deadline = LbTimerClock() + TIMEOUT_ENET_CONNECT; + while (LbTimerClock() < deadline) { + TbClockMSec remaining = deadline - LbTimerClock(); + enet_uint32 wait_ms = HOLEPUNCH_CONNECT_DELAY_MS; + if (remaining < wait_ms) { + wait_ms = (enet_uint32)remaining; + } + int ret = enet_host_service(host, &ev, wait_ms); + if (ret > 0 && ev.type == ENET_EVENT_TYPE_CONNECT) { + LbNetLog("Join: connected successfully\n"); + return Lb_OK; + } + if (ret > 0) { + LbNetLog("Join: unexpected event type=%d\n", (int)ev.type); + } else if (ret < 0) { + LbNetLog("Join: enet_host_service error %d\n", ret); + ERRORLOG("Unable to connect: %d", ret); + break; + } + holepunch_punch_to(host, &connect_address); + } } - LbNetLog("Join: connected successfully\n"); - return Lb_OK; + LbNetLog("Join: connection timed out or failed\n"); + host_destroy(); + return Lb_FAIL; } /* From 4c15b2629d5c59ed8dd66a6611ffdb7000f4654a Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Thu, 12 Mar 2026 06:19:36 +1100 Subject: [PATCH 30/31] improve readability --- src/bflib_enet.cpp | 96 ++++++------ src/bflib_network.cpp | 20 +-- src/front_network.c | 4 +- src/net_holepunch.c | 142 +++++++++--------- src/net_holepunch.h | 2 +- src/net_matchmaking.c | 332 +++++++++++++++++++++--------------------- src/net_matchmaking.h | 8 +- 7 files changed, 302 insertions(+), 302 deletions(-) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index 9405e316d9..447b0fec9b 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -108,9 +108,9 @@ namespace address.port = ENET_DEFAULT_PORT; if (!*session) return Lb_FAIL; - const char *port_str = session; - if (*port_str == ':') port_str++; - int port = atoi(port_str); + const char *port_string = session; + if (*port_string == ':') port_string++; + int port = atoi(port_string); if (port > 0) address.port = port; host = enet_host_create(ENET_ADDRESS_TYPE_IPV4, &address, 4, NUM_CHANNELS, 0, 0); @@ -124,23 +124,23 @@ namespace } - enet_uint16 parse_session_address(const char *session, char *host_out, size_t host_size) + enet_uint16 parse_session_address(const char *session, char *output_hostname, size_t hostname_buffer_size) { - char *E; + char *parse_end_ptr; enet_uint16 port = ENET_DEFAULT_PORT; if (session[0] == '[') { const char *bracket_end = strchr(session, ']'); if (!bracket_end) { return 0; } - size_t addr_len = bracket_end - session - 1; - if (addr_len >= host_size) { + size_t address_length = bracket_end - session - 1; + if (address_length >= hostname_buffer_size) { return 0; } - strncpy(host_out, session + 1, addr_len); - host_out[addr_len] = '\0'; + strncpy(output_hostname, session + 1, address_length); + output_hostname[address_length] = '\0'; if (bracket_end[1] == ':') { - port = strtoul(bracket_end + 2, &E, 10); + port = strtoul(bracket_end + 2, &parse_end_ptr, 10); if (port == 0) { return 0; } @@ -149,22 +149,22 @@ namespace const char *first_colon = strchr(session, ':'); const char *last_colon = strrchr(session, ':'); if (first_colon && first_colon != last_colon) { - strncpy(host_out, session, host_size - 1); - host_out[host_size - 1] = '\0'; + strncpy(output_hostname, session, hostname_buffer_size - 1); + output_hostname[hostname_buffer_size - 1] = '\0'; } else if (first_colon) { - size_t addr_len = first_colon - session; - if (addr_len >= host_size) { + size_t address_length = first_colon - session; + if (address_length >= hostname_buffer_size) { return 0; } - strncpy(host_out, session, addr_len); - host_out[addr_len] = '\0'; - port = strtoul(first_colon + 1, &E, 10); + strncpy(output_hostname, session, address_length); + output_hostname[address_length] = '\0'; + port = strtoul(first_colon + 1, &parse_end_ptr, 10); if (port == 0) { return 0; } } else { - strncpy(host_out, session, host_size - 1); - host_out[host_size - 1] = '\0'; + strncpy(output_hostname, session, hostname_buffer_size - 1); + output_hostname[hostname_buffer_size - 1] = '\0'; } } return port; @@ -180,11 +180,11 @@ namespace LbNetLog("Join: failed to create ENet host\n"); return Lb_FAIL; } - char ext_ip[MATCHMAKING_IP_MAX] = {0}; - uint16_t ext_port = holepunch_stun_query(host, ext_ip, sizeof(ext_ip)); + char external_ip[MATCHMAKING_IP_MAX] = {0}; + uint16_t external_port = holepunch_stun_query(host, external_ip, sizeof(external_ip)); char peer_ip[MATCHMAKING_IP_MAX] = {0}; int peer_port = 0; - if (matchmaking_punch(g_join_lobby_id, (int)ext_port, ext_ip, peer_ip, &peer_port) != 0) { + if (matchmaking_punch(g_join_lobby_id, (int)external_port, external_ip, peer_ip, &peer_port) != 0) { LbNetLog("Join: matchmaking_punch failed\n"); host_destroy(); return Lb_FAIL; @@ -197,20 +197,20 @@ namespace } connect_address.port = (enet_uint16)peer_port; } else { - char buf[128] = {0}; - enet_uint16 port = parse_session_address(session, buf, sizeof(buf)); - if (port == 0 || buf[0] == '\0') { + char address_string[128] = {0}; + enet_uint16 port = parse_session_address(session, address_string, sizeof(address_string)); + if (port == 0 || address_string[0] == '\0') { return Lb_FAIL; } - ENetAddressType addr_type = ENET_ADDRESS_TYPE_IPV4; - if (strchr(buf, ':') != NULL) { - addr_type = ENET_ADDRESS_TYPE_IPV6; + ENetAddressType address_type = ENET_ADDRESS_TYPE_IPV4; + if (strchr(address_string, ':') != NULL) { + address_type = ENET_ADDRESS_TYPE_IPV6; } - if (enet_address_set_host(&connect_address, addr_type, buf) < 0) { + if (enet_address_set_host(&connect_address, address_type, address_string) < 0) { return Lb_FAIL; } connect_address.port = port; - host = enet_host_create(addr_type, NULL, 4, NUM_CHANNELS, 0, 0); + host = enet_host_create(address_type, NULL, 4, NUM_CHANNELS, 0, 0); if (!host) { return Lb_FAIL; } @@ -224,24 +224,24 @@ namespace return Lb_FAIL; } { - ENetEvent ev; - TbClockMSec deadline = LbTimerClock() + TIMEOUT_ENET_CONNECT; - while (LbTimerClock() < deadline) { - TbClockMSec remaining = deadline - LbTimerClock(); - enet_uint32 wait_ms = HOLEPUNCH_CONNECT_DELAY_MS; - if (remaining < wait_ms) { - wait_ms = (enet_uint32)remaining; + ENetEvent enet_event; + TbClockMSec connection_deadline = LbTimerClock() + TIMEOUT_ENET_CONNECT; + while (LbTimerClock() < connection_deadline) { + TbClockMSec time_remaining = connection_deadline - LbTimerClock(); + enet_uint32 service_wait_ms = HOLEPUNCH_CONNECT_DELAY_MS; + if (time_remaining < service_wait_ms) { + service_wait_ms = (enet_uint32)time_remaining; } - int ret = enet_host_service(host, &ev, wait_ms); - if (ret > 0 && ev.type == ENET_EVENT_TYPE_CONNECT) { + int service_result = enet_host_service(host, &enet_event, service_wait_ms); + if (service_result > 0 && enet_event.type == ENET_EVENT_TYPE_CONNECT) { LbNetLog("Join: connected successfully\n"); return Lb_OK; } - if (ret > 0) { - LbNetLog("Join: unexpected event type=%d\n", (int)ev.type); - } else if (ret < 0) { - LbNetLog("Join: enet_host_service error %d\n", ret); - ERRORLOG("Unable to connect: %d", ret); + if (service_result > 0) { + LbNetLog("Join: unexpected event type=%d\n", (int)enet_event.type); + } else if (service_result < 0) { + LbNetLog("Join: enet_host_service error %d\n", service_result); + ERRORLOG("Unable to connect: %d", service_result); break; } holepunch_punch_to(host, &connect_address); @@ -742,11 +742,11 @@ void enet_matchmaking_host_update(void) int peer_port = 0; if (!matchmaking_poll_punch(peer_ip, &peer_port)) return; - ENetAddress target; - if (enet_address_set_host(&target, ENET_ADDRESS_TYPE_IPV4, peer_ip) != 0) + ENetAddress peer_address; + if (enet_address_set_host(&peer_address, ENET_ADDRESS_TYPE_IPV4, peer_ip) != 0) return; - target.port = (enet_uint16)peer_port; - holepunch_punch_to(host, &target); + peer_address.port = (enet_uint16)peer_port; + holepunch_punch_to(host, &peer_address); } struct NetSP *InitEnetSP() diff --git a/src/bflib_network.cpp b/src/bflib_network.cpp index ee03c2f1b6..6224965a17 100644 --- a/src/bflib_network.cpp +++ b/src/bflib_network.cpp @@ -143,23 +143,23 @@ TbError LbNetwork_Create(char *nsname_str, char *plyr_name, uint32_t *plyr_num, char default_port_buf[16]; snprintf(default_port_buf, sizeof(default_port_buf), ":%u", (unsigned)ENET_DEFAULT_PORT); const char *port = default_port_buf; - char buf[16] = ""; + char port_string[16] = ""; if (ServerPort != 0) { - snprintf(buf, sizeof(buf), "%d", ServerPort); - port = buf; + snprintf(port_string, sizeof(port_string), "%d", ServerPort); + port = port_string; } if (netstate.sp->host(port, optns) == Lb_FAIL) { return Lb_FAIL; } std::string host_name(plyr_name); - uint16_t ext_port = g_external_port; - if (ext_port == 0 && ServerPort > 0) - ext_port = (uint16_t)ServerPort; - if (ext_port == 0) - ext_port = (uint16_t)ENET_DEFAULT_PORT; - std::thread([ext_port, host_name]() { + uint16_t external_port = g_external_port; + if (external_port == 0 && ServerPort > 0) + external_port = (uint16_t)ServerPort; + if (external_port == 0) + external_port = (uint16_t)ENET_DEFAULT_PORT; + std::thread([external_port, host_name]() { if (matchmaking_connect() == 0) - matchmaking_create(host_name.c_str(), (int)ext_port, g_external_ip); + matchmaking_create(host_name.c_str(), (int)external_port, g_external_ip); }).detach(); netstate.my_id = SERVER_ID; snprintf(netstate.users[netstate.my_id].name, sizeof(netstate.users[netstate.my_id].name), "%s", plyr_name); diff --git a/src/front_network.c b/src/front_network.c index 6a048c227a..0733085db5 100644 --- a/src/front_network.c +++ b/src/front_network.c @@ -245,8 +245,8 @@ void frontnet_session_update(void) if ( LbNetwork_EnumerateSessions(enum_sessions_callback, 0) ) ERRORLOG("LbNetwork_EnumerateSessions() failed"); matchmaking_refresh_sessions(); - for (int i = 0; i < g_mm_session_count && net_number_of_sessions < SESSION_ENTRIES_COUNT; i++) - net_session[net_number_of_sessions++] = &g_mm_sessions[i]; + for (int i = 0; i < g_matchmaking_session_count && net_number_of_sessions < SESSION_ENTRIES_COUNT; i++) + net_session[net_number_of_sessions++] = &g_matchmaking_sessions[i]; last_enum_sessions = LbTimerClock(); if (net_number_of_sessions == 0) diff --git a/src/net_holepunch.c b/src/net_holepunch.c index 17e7bee19f..1cfab340c2 100644 --- a/src/net_holepunch.c +++ b/src/net_holepunch.c @@ -41,8 +41,8 @@ #define STUN_MAGIC_COOKIE 0x2112A442U #define STUN_BINDING_REQUEST 0x0001U #define STUN_BINDING_SUCCESS 0x0101U -#define STUN_ATTR_XOR_MAPPED 0x0020U -#define STUN_RESPONSE_BUF_SIZE 512 +#define STUN_ATTRIBUTE_XOR_MAPPED 0x0020U +#define STUN_RESPONSE_BUFFER_SIZE 512 #define HOLE_PUNCH_COUNT 5 #define HOLE_PUNCH_PAYLOAD_SIZE 8 @@ -51,7 +51,7 @@ struct StunHeader { uint16_t type; uint16_t length; uint32_t magic; - uint8_t txid[12]; + uint8_t transaction_id[12]; }; struct StunAttrHeader { @@ -60,105 +60,105 @@ struct StunAttrHeader { }; #pragma pack(pop) -uint16_t holepunch_stun_query(ENetHost *host, char *ip_out, size_t ip_len) +uint16_t holepunch_stun_query(ENetHost *host, char *output_ip, size_t output_ip_buffer_size) { - ENetAddress stun_addr; - if (enet_address_set_host(&stun_addr, ENET_ADDRESS_TYPE_IPV4, STUN_SERVER) < 0) { + ENetAddress stun_server_address; + if (enet_address_set_host(&stun_server_address, ENET_ADDRESS_TYPE_IPV4, STUN_SERVER) < 0) { LbNetLog("STUN: failed to resolve %s\n", STUN_SERVER); return 0; } - stun_addr.port = STUN_PORT; + stun_server_address.port = STUN_PORT; - static unsigned s_counter = 0; - s_counter++; - struct StunHeader req = {htons(STUN_BINDING_REQUEST), htons(0), htonl(STUN_MAGIC_COOKIE), {0}}; - memcpy(req.txid, &s_counter, sizeof(s_counter)); - ENetBuffer send_buf = {.data = &req, .dataLength = sizeof(req)}; - ENetSocket sock = host->socket; - ENetSocket tmp_sock = ENET_SOCKET_NULL; - if (enet_socket_send(sock, &stun_addr, &send_buf, 1) < 0) { + static unsigned s_transaction_counter = 0; + s_transaction_counter++; + struct StunHeader stun_request = {htons(STUN_BINDING_REQUEST), htons(0), htonl(STUN_MAGIC_COOKIE), {0}}; + memcpy(stun_request.transaction_id, &s_transaction_counter, sizeof(s_transaction_counter)); + ENetBuffer send_buffer = {.data = &stun_request, .dataLength = sizeof(stun_request)}; + ENetSocket send_socket = host->socket; + ENetSocket fallback_socket = ENET_SOCKET_NULL; + if (enet_socket_send(send_socket, &stun_server_address, &send_buffer, 1) < 0) { LbNetLog("STUN: host socket send failed, falling back to fresh IPv4 socket\n"); - tmp_sock = enet_socket_create(ENET_ADDRESS_TYPE_IPV4, ENET_SOCKET_TYPE_DATAGRAM); - if (tmp_sock == ENET_SOCKET_NULL) { + fallback_socket = enet_socket_create(ENET_ADDRESS_TYPE_IPV4, ENET_SOCKET_TYPE_DATAGRAM); + if (fallback_socket == ENET_SOCKET_NULL) { LbNetLog("STUN: failed to create fallback IPv4 socket\n"); return 0; } - if (enet_socket_send(tmp_sock, &stun_addr, &send_buf, 1) < 0) { + if (enet_socket_send(fallback_socket, &stun_server_address, &send_buffer, 1) < 0) { LbNetLog("STUN: fallback IPv4 socket send failed\n"); - enet_socket_destroy(tmp_sock); + enet_socket_destroy(fallback_socket); return 0; } - sock = tmp_sock; + send_socket = fallback_socket; } - Uint32 deadline = SDL_GetTicks() + STUN_TIMEOUT_MS; - uint16_t result = 0; + Uint32 timeout_deadline = SDL_GetTicks() + STUN_TIMEOUT_MS; + uint16_t external_port_result = 0; for (;;) { Uint32 now = SDL_GetTicks(); - if (now >= deadline) + if (now >= timeout_deadline) break; - enet_uint32 wait_flags = ENET_SOCKET_WAIT_RECEIVE; - if (enet_socket_wait(sock, &wait_flags, deadline - now) < 0 - || !(wait_flags & ENET_SOCKET_WAIT_RECEIVE)) + enet_uint32 socket_wait_flags = ENET_SOCKET_WAIT_RECEIVE; + if (enet_socket_wait(send_socket, &socket_wait_flags, timeout_deadline - now) < 0 + || !(socket_wait_flags & ENET_SOCKET_WAIT_RECEIVE)) break; - uint8_t resp[STUN_RESPONSE_BUF_SIZE]; - ENetAddress from; - ENetBuffer recv_buf = {.data = resp, .dataLength = sizeof(resp)}; - int n = enet_socket_receive(sock, &from, &recv_buf, 1); - if (n <= 0) + uint8_t response_buffer[STUN_RESPONSE_BUFFER_SIZE]; + ENetAddress sender_address; + ENetBuffer receive_buffer = {.data = response_buffer, .dataLength = sizeof(response_buffer)}; + int bytes_received = enet_socket_receive(send_socket, &sender_address, &receive_buffer, 1); + if (bytes_received <= 0) continue; - if (n < (int)sizeof(struct StunHeader)) + if (bytes_received < (int)sizeof(struct StunHeader)) break; - const struct StunHeader *hdr = (const struct StunHeader *)resp; - if (ntohs(hdr->type) != STUN_BINDING_SUCCESS - || ntohl(hdr->magic) != STUN_MAGIC_COOKIE - || memcmp(hdr->txid, req.txid, sizeof(hdr->txid)) != 0) + const struct StunHeader *stun_response_header = (const struct StunHeader *)response_buffer; + if (ntohs(stun_response_header->type) != STUN_BINDING_SUCCESS + || ntohl(stun_response_header->magic) != STUN_MAGIC_COOKIE + || memcmp(stun_response_header->transaction_id, stun_request.transaction_id, sizeof(stun_response_header->transaction_id)) != 0) continue; - int offset = (int)sizeof(struct StunHeader); - int attrs_end = offset + (int)ntohs(hdr->length); - if (attrs_end > n) attrs_end = n; - char ip[64] = {0}; - uint16_t ext_port = 0; - while (offset + 4 <= attrs_end) { - const struct StunAttrHeader *attr = (const struct StunAttrHeader *)(resp + offset); - uint16_t atype = ntohs(attr->type); - uint16_t alen = ntohs(attr->length); - offset += 4; - if (atype == STUN_ATTR_XOR_MAPPED && alen >= 8 - && offset + alen <= attrs_end && resp[offset + 1] == 0x01) { - uint16_t xor_port = ((uint16_t)resp[offset + 2] << 8) | resp[offset + 3]; - ext_port = xor_port ^ (uint16_t)(STUN_MAGIC_COOKIE >> 16); - uint32_t xaddr; - memcpy(&xaddr, resp + offset + 4, 4); - uint32_t addr = ntohl(xaddr) ^ STUN_MAGIC_COOKIE; - snprintf(ip, sizeof(ip), "%u.%u.%u.%u", - (addr >> 24) & 0xFFu, (addr >> 16) & 0xFFu, - (addr >> 8) & 0xFFu, addr & 0xFFu); + int attribute_offset = (int)sizeof(struct StunHeader); + int attributes_end = attribute_offset + (int)ntohs(stun_response_header->length); + if (attributes_end > bytes_received) attributes_end = bytes_received; + char mapped_ip[64] = {0}; + uint16_t external_port = 0; + while (attribute_offset + 4 <= attributes_end) { + const struct StunAttrHeader *stun_attribute = (const struct StunAttrHeader *)(response_buffer + attribute_offset); + uint16_t attribute_type = ntohs(stun_attribute->type); + uint16_t attribute_length = ntohs(stun_attribute->length); + attribute_offset += 4; + if (attribute_type == STUN_ATTRIBUTE_XOR_MAPPED && attribute_length >= 8 + && attribute_offset + attribute_length <= attributes_end && response_buffer[attribute_offset + 1] == 0x01) { + uint16_t xor_encoded_port = ((uint16_t)response_buffer[attribute_offset + 2] << 8) | response_buffer[attribute_offset + 3]; + external_port = xor_encoded_port ^ (uint16_t)(STUN_MAGIC_COOKIE >> 16); + uint32_t xor_encoded_address; + memcpy(&xor_encoded_address, response_buffer + attribute_offset + 4, 4); + uint32_t decoded_address = ntohl(xor_encoded_address) ^ STUN_MAGIC_COOKIE; + snprintf(mapped_ip, sizeof(mapped_ip), "%u.%u.%u.%u", + (decoded_address >> 24) & 0xFFu, (decoded_address >> 16) & 0xFFu, + (decoded_address >> 8) & 0xFFu, decoded_address & 0xFFu); break; } - offset += (alen + 3) & ~3; + attribute_offset += (attribute_length + 3) & ~3; } - if (!ext_port) + if (!external_port) continue; - if (tmp_sock != ENET_SOCKET_NULL) - ext_port = host->address.port; - LbNetLog("STUN: external address %s:%u\n", ip, (unsigned)ext_port); - if (ip_out && ip_len > 0) - snprintf(ip_out, ip_len, "%s", ip); - result = ext_port; + if (fallback_socket != ENET_SOCKET_NULL) + external_port = host->address.port; + LbNetLog("STUN: external address %s:%u\n", mapped_ip, (unsigned)external_port); + if (output_ip && output_ip_buffer_size > 0) + snprintf(output_ip, output_ip_buffer_size, "%s", mapped_ip); + external_port_result = external_port; break; } - if (!result) + if (!external_port_result) LbNetLog("STUN: failed to obtain mapped address\n"); - if (tmp_sock != ENET_SOCKET_NULL) - enet_socket_destroy(tmp_sock); - return result; + if (fallback_socket != ENET_SOCKET_NULL) + enet_socket_destroy(fallback_socket); + return external_port_result; } void holepunch_punch_to(ENetHost *host, const ENetAddress *target) { - static const uint8_t payload[HOLE_PUNCH_PAYLOAD_SIZE] = {0}; - ENetBuffer buf = {.data = (void *)payload, .dataLength = sizeof(payload)}; + static const uint8_t punch_payload[HOLE_PUNCH_PAYLOAD_SIZE] = {0}; + ENetBuffer send_buffer = {.data = (void *)punch_payload, .dataLength = sizeof(punch_payload)}; for (int i = 0; i < HOLE_PUNCH_COUNT; i++) - enet_socket_send(host->socket, target, &buf, 1); + enet_socket_send(host->socket, target, &send_buffer, 1); } diff --git a/src/net_holepunch.h b/src/net_holepunch.h index 250a7f10cc..8b048113ec 100644 --- a/src/net_holepunch.h +++ b/src/net_holepunch.h @@ -30,7 +30,7 @@ extern "C" { struct _ENetHost; struct _ENetAddress; -uint16_t holepunch_stun_query(struct _ENetHost *host, char *ip_out, size_t ip_len); +uint16_t holepunch_stun_query(struct _ENetHost *host, char *output_ip, size_t output_ip_buffer_size); void holepunch_punch_to(struct _ENetHost *host, const struct _ENetAddress *target); #ifdef __cplusplus diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index 9d547b5246..c557826a85 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -36,119 +36,119 @@ #define STR(x) STR_(x) #define MATCHMAKING_VERSION STR(VER_MAJOR) "." STR(VER_MINOR) "." STR(VER_RELEASE) -#define WS_BUF_SIZE 8192 -#define WS_RECV_TIMEOUT_MS 3000 -#define SEND_BUF_SIZE 512 -#define IP_FIELD_SIZE 80 -#define CONNECT_TIMEOUT_MS 5000 +#define WEBSOCKET_BUFFER_SIZE 8192 +#define WEBSOCKET_RECEIVE_TIMEOUT_MS 3000 +#define SEND_BUFFER_SIZE 512 +#define IP_JSON_FIELD_SIZE 80 +#define CONNECT_TIMEOUT_MS 5000 static CURL *g_curl = NULL; static char g_hosted_lobby_id[MATCHMAKING_ID_MAX] = {0}; static Uint32 g_last_refresh_tick = 0; char g_join_lobby_id[MATCHMAKING_ID_MAX] = {0}; -static SDL_mutex *g_cs = NULL; +static SDL_mutex *g_mutex = NULL; -struct TbNetworkSessionNameEntry g_mm_sessions[MATCHMAKING_SESSIONS_MAX]; -int g_mm_session_count = 0; +struct TbNetworkSessionNameEntry g_matchmaking_sessions[MATCHMAKING_SESSIONS_MAX]; +int g_matchmaking_session_count = 0; -static void ws_cleanup(void) +static void websocket_cleanup(void) { - LbNetLog("Matchmaking: ws_cleanup\n"); + LbNetLog("Matchmaking: websocket_cleanup\n"); curl_easy_cleanup(g_curl); g_curl = NULL; g_hosted_lobby_id[0] = '\0'; - g_mm_session_count = 0; + g_matchmaking_session_count = 0; g_last_refresh_tick = 0; } -static int ws_send(const char *msg) +static int websocket_send(const char *request) { - size_t sent = 0; - CURLcode rc = curl_ws_send(g_curl, msg, strlen(msg), &sent, 0, CURLWS_TEXT); - if (rc != CURLE_OK) { - LbNetLog("Matchmaking: ws_send failed (%s)\n", curl_easy_strerror(rc)); - ws_cleanup(); + size_t bytes_sent = 0; + CURLcode curl_result = curl_ws_send(g_curl, request, strlen(request), &bytes_sent, 0, CURLWS_TEXT); + if (curl_result != CURLE_OK) { + LbNetLog("Matchmaking: websocket_send failed (%s)\n", curl_easy_strerror(curl_result)); + websocket_cleanup(); return -1; } return 0; } -static int ws_recv(char *buf, size_t bufsz, int timeout_ms) +static int websocket_receive(char *response_buffer, size_t buffer_size, int timeout_ms) { - curl_socket_t sock = CURL_SOCKET_BAD; - if (curl_easy_getinfo(g_curl, CURLINFO_ACTIVESOCKET, &sock) != CURLE_OK || sock == CURL_SOCKET_BAD) { - LbNetLog("Matchmaking: ws_recv failed to get active socket\n"); + curl_socket_t raw_socket = CURL_SOCKET_BAD; + if (curl_easy_getinfo(g_curl, CURLINFO_ACTIVESOCKET, &raw_socket) != CURLE_OK || raw_socket == CURL_SOCKET_BAD) { + LbNetLog("Matchmaking: websocket_receive failed to get active socket\n"); return -1; } - fd_set fds; - FD_ZERO(&fds); - FD_SET(sock, &fds); - struct timeval tv = { timeout_ms / 1000, (timeout_ms % 1000) * 1000 }; - if (select((int)sock + 1, &fds, NULL, NULL, &tv) <= 0) + fd_set readable_sockets; + FD_ZERO(&readable_sockets); + FD_SET(raw_socket, &readable_sockets); + struct timeval timeout_value = { timeout_ms / 1000, (timeout_ms % 1000) * 1000 }; + if (select((int)raw_socket + 1, &readable_sockets, NULL, NULL, &timeout_value) <= 0) return 0; - size_t recvd = 0; - const struct curl_ws_frame *frame = NULL; - CURLcode rc = curl_ws_recv(g_curl, buf, bufsz - 1, &recvd, &frame); - if (rc == CURLE_AGAIN) + size_t bytes_received = 0; + const struct curl_ws_frame *websocket_frame = NULL; + CURLcode curl_result = curl_ws_recv(g_curl, response_buffer, buffer_size - 1, &bytes_received, &websocket_frame); + if (curl_result == CURLE_AGAIN) return 0; - if (rc != CURLE_OK) { - LbNetLog("Matchmaking: ws_recv failed (%s)\n", curl_easy_strerror(rc)); - ws_cleanup(); + if (curl_result != CURLE_OK) { + LbNetLog("Matchmaking: websocket_receive failed (%s)\n", curl_easy_strerror(curl_result)); + websocket_cleanup(); return -1; } - buf[recvd] = '\0'; - return (int)recvd; + response_buffer[bytes_received] = '\0'; + return (int)bytes_received; } -static int ws_exchange(const char *msg, char *buf, size_t bufsz) +static int websocket_exchange(const char *request, char *response_buffer, size_t buffer_size) { if (!g_curl) return -1; - if (ws_send(msg) != 0) return -1; - return ws_recv(buf, bufsz, WS_RECV_TIMEOUT_MS); + if (websocket_send(request) != 0) return -1; + return websocket_receive(response_buffer, buffer_size, WEBSOCKET_RECEIVE_TIMEOUT_MS); } -static const char *json_str(const char *json, const char *key, char *out, size_t outsz) +static const char *json_parse_string(const char *json, const char *key, char *output, size_t output_buffer_size) { - char search[128]; - snprintf(search, sizeof(search), "\"%s\":\"", key); - const char *p = strstr(json, search); - if (!p) + char key_pattern[128]; + snprintf(key_pattern, sizeof(key_pattern), "\"%s\":\"", key); + const char *json_cursor = strstr(json, key_pattern); + if (!json_cursor) return NULL; - p += strlen(search); - size_t len = 0; - while (*p && *p != '"' && len < outsz - 1) - out[len++] = *p++; - out[len] = '\0'; - if (*p != '"') + json_cursor += strlen(key_pattern); + size_t output_length = 0; + while (*json_cursor && *json_cursor != '"' && output_length < output_buffer_size - 1) + output[output_length++] = *json_cursor++; + output[output_length] = '\0'; + if (*json_cursor != '"') return NULL; - return p + 1; + return json_cursor + 1; } -static int json_int(const char *json, const char *key, int *out) +static int json_parse_int(const char *json, const char *key, int *output) { - char search[128]; - snprintf(search, sizeof(search), "\"%s\":", key); - const char *p = strstr(json, search); - if (!p) + char key_pattern[128]; + snprintf(key_pattern, sizeof(key_pattern), "\"%s\":", key); + const char *json_cursor = strstr(json, key_pattern); + if (!json_cursor) return 0; - p += strlen(search); - *out = atoi(p); + json_cursor += strlen(key_pattern); + *output = atoi(json_cursor); return 1; } void matchmaking_init(void) { - static int s_done = 0; - if (s_done) + static int s_initialized = 0; + if (s_initialized) return; - s_done = 1; - g_cs = SDL_CreateMutex(); + s_initialized = 1; + g_mutex = SDL_CreateMutex(); curl_global_init(CURL_GLOBAL_DEFAULT); } -static int connect_thread(void *arg) +static int matchmaking_connect_thread(void *arg) { matchmaking_connect(); return 0; @@ -157,204 +157,204 @@ static int connect_thread(void *arg) void matchmaking_connect_async(void) { matchmaking_init(); - SDL_Thread *t = SDL_CreateThread(connect_thread, "matchmaking", NULL); - if (t) - SDL_DetachThread(t); + SDL_Thread *thread = SDL_CreateThread(matchmaking_connect_thread, "matchmaking", NULL); + if (thread) + SDL_DetachThread(thread); } int matchmaking_connect(void) { - SDL_LockMutex(g_cs); + SDL_LockMutex(g_mutex); if (g_curl) { - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); return 0; } g_curl = curl_easy_init(); if (!g_curl) { - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); return -1; } LbNetLog("Matchmaking: connecting to %s\n", MATCHMAKING_URL); curl_easy_setopt(g_curl, CURLOPT_URL, MATCHMAKING_URL); curl_easy_setopt(g_curl, CURLOPT_CONNECT_ONLY, 2L); curl_easy_setopt(g_curl, CURLOPT_CONNECTTIMEOUT_MS, (long)CONNECT_TIMEOUT_MS); - CURLcode rc = curl_easy_perform(g_curl); - if (rc != CURLE_OK) { - LbNetLog("Matchmaking: connect to %s failed: %s\n", MATCHMAKING_URL, curl_easy_strerror(rc)); - ws_cleanup(); - SDL_UnlockMutex(g_cs); + CURLcode curl_result = curl_easy_perform(g_curl); + if (curl_result != CURLE_OK) { + LbNetLog("Matchmaking: connect to %s failed: %s\n", MATCHMAKING_URL, curl_easy_strerror(curl_result)); + websocket_cleanup(); + SDL_UnlockMutex(g_mutex); return -1; } LbNetLog("Matchmaking: connected\n"); - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); return 0; } void matchmaking_disconnect(void) { - SDL_LockMutex(g_cs); + SDL_LockMutex(g_mutex); if (g_curl) { if (g_hosted_lobby_id[0] != '\0') { - char msg[SEND_BUF_SIZE]; - snprintf(msg, sizeof(msg), "{\"action\":\"delete\",\"id\":\"%s\"}", g_hosted_lobby_id); - ws_send(msg); + char delete_message[SEND_BUFFER_SIZE]; + snprintf(delete_message, sizeof(delete_message), "{\"action\":\"delete\",\"id\":\"%s\"}", g_hosted_lobby_id); + websocket_send(delete_message); } - ws_cleanup(); + websocket_cleanup(); LbNetLog("Matchmaking: disconnected\n"); } - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); } void matchmaking_refresh_sessions(void) { - SDL_LockMutex(g_cs); + SDL_LockMutex(g_mutex); if (!g_curl) { - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); return; } - char buf[WS_BUF_SIZE]; - int list_n; + char response_buffer[WEBSOCKET_BUFFER_SIZE]; + int bytes_received; if (g_last_refresh_tick == 0) { - list_n = ws_exchange("{\"action\":\"list\",\"version\":\"" MATCHMAKING_VERSION "\"}", buf, sizeof(buf)); + bytes_received = websocket_exchange("{\"action\":\"list\",\"version\":\"" MATCHMAKING_VERSION "\"}", response_buffer, sizeof(response_buffer)); g_last_refresh_tick = SDL_GetTicks(); } else { - list_n = ws_recv(buf, sizeof(buf), 0); + bytes_received = websocket_receive(response_buffer, sizeof(response_buffer), 0); } - if (list_n > 0) - LbNetLog("Matchmaking: list response (%d bytes): %s\n", list_n, buf); - if (list_n > 0 && strstr(buf, "\"lobbies\"")) { + if (bytes_received > 0) + LbNetLog("Matchmaking: list response (%d bytes): %s\n", bytes_received, response_buffer); + if (bytes_received > 0 && strstr(response_buffer, "\"lobbies\"")) { int count = 0; - const char *p = buf; + const char *json_cursor = response_buffer; while (count < MATCHMAKING_SESSIONS_MAX) { char id[MATCHMAKING_ID_MAX]; char name[MATCHMAKING_NAME_MAX]; - p = json_str(p, "id", id, sizeof(id)); - if (!p) break; - p = json_str(p, "name", name, sizeof(name)); - if (!p) break; - struct TbNetworkSessionNameEntry *s = &g_mm_sessions[count++]; - memset(s, 0, sizeof(*s)); - s->joinable = 1; - s->in_use = 1; - s->id = (unsigned long)count; - snprintf(s->text, SESSION_NAME_MAX_LEN, "%s", name); - snprintf(s->lobby_id, SESSION_LOBBY_ID_MAX_LEN, "%s", id); + json_cursor = json_parse_string(json_cursor, "id", id, sizeof(id)); + if (!json_cursor) break; + json_cursor = json_parse_string(json_cursor, "name", name, sizeof(name)); + if (!json_cursor) break; + struct TbNetworkSessionNameEntry *session = &g_matchmaking_sessions[count++]; + memset(session, 0, sizeof(*session)); + session->joinable = 1; + session->in_use = 1; + session->id = (unsigned long)count; + snprintf(session->text, SESSION_NAME_MAX_LEN, "%s", name); + snprintf(session->lobby_id, SESSION_LOBBY_ID_MAX_LEN, "%s", id); } - g_mm_session_count = count; + g_matchmaking_session_count = count; LbNetLog("Matchmaking: parsed %d session(s)\n", count); } - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); } int matchmaking_create(const char *name, int udp_port, const char *ip) { - char escaped_name[MATCHMAKING_NAME_MAX * 2]; - char ip_field[IP_FIELD_SIZE]; - char msg[SEND_BUF_SIZE]; - char buf[WS_BUF_SIZE]; - SDL_LockMutex(g_cs); + char escaped_lobby_name[MATCHMAKING_NAME_MAX * 2]; + char ip_json_field[IP_JSON_FIELD_SIZE]; + char request_message[SEND_BUFFER_SIZE]; + char response_buffer[WEBSOCKET_BUFFER_SIZE]; + SDL_LockMutex(g_mutex); if (!g_curl) { LbNetLog("Matchmaking: not connected to server, lobby won't be listed online\n"); - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); return -1; } - int pos = 0; - for (int i = 0; name[i] && pos < (int)sizeof(escaped_name) - 2; i++) { + int write_pos = 0; + for (int i = 0; name[i] && write_pos < (int)sizeof(escaped_lobby_name) - 2; i++) { if (name[i] == '"' || name[i] == '\\') - escaped_name[pos++] = '\\'; - escaped_name[pos++] = name[i]; + escaped_lobby_name[write_pos++] = '\\'; + escaped_lobby_name[write_pos++] = name[i]; } - escaped_name[pos] = '\0'; - ip_field[0] = '\0'; + escaped_lobby_name[write_pos] = '\0'; + ip_json_field[0] = '\0'; if (ip && ip[0]) - snprintf(ip_field, sizeof(ip_field), ",\"ip\":\"%s\"", ip); - snprintf(msg, sizeof(msg), + snprintf(ip_json_field, sizeof(ip_json_field), ",\"ip\":\"%s\"", ip); + snprintf(request_message, sizeof(request_message), "{\"action\":\"create\",\"name\":\"%s\",\"port\":%d%s,\"version\":\"%s\"}", - escaped_name, udp_port, ip_field, MATCHMAKING_VERSION); - int create_n = ws_exchange(msg, buf, sizeof(buf)); - if (create_n > 0) - LbNetLog("Matchmaking: create response (%d bytes): %s\n", create_n, buf); - if (create_n <= 0) { - SDL_UnlockMutex(g_cs); + escaped_lobby_name, udp_port, ip_json_field, MATCHMAKING_VERSION); + int bytes_received = websocket_exchange(request_message, response_buffer, sizeof(response_buffer)); + if (bytes_received > 0) + LbNetLog("Matchmaking: create response (%d bytes): %s\n", bytes_received, response_buffer); + if (bytes_received <= 0) { + SDL_UnlockMutex(g_mutex); return -1; } - if (!strstr(buf, "\"created\"") || !json_str(buf, "id", g_hosted_lobby_id, MATCHMAKING_ID_MAX)) { + if (!strstr(response_buffer, "\"created\"") || !json_parse_string(response_buffer, "id", g_hosted_lobby_id, MATCHMAKING_ID_MAX)) { LbNetLog("Matchmaking: create failed - unexpected response\n"); - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); return -1; } LbNetLog("Matchmaking: created lobby id=%s\n", g_hosted_lobby_id); - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); return 0; } -int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, char *out_ip, int *out_port) +int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, char *output_ip, int *output_port) { - char msg[SEND_BUF_SIZE]; - char buf[WS_BUF_SIZE]; - SDL_LockMutex(g_cs); + char request_message[SEND_BUFFER_SIZE]; + char response_buffer[WEBSOCKET_BUFFER_SIZE]; + SDL_LockMutex(g_mutex); if (!g_curl) { LbNetLog("Matchmaking: not connected to server, UDP hole punching unavailable\n"); - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); return -1; } - char ip_field[IP_FIELD_SIZE] = ""; + char ip_json_field[IP_JSON_FIELD_SIZE] = ""; if (udp_ip && udp_ip[0]) - snprintf(ip_field, sizeof(ip_field), ",\"udpIp\":\"%s\"", udp_ip); - snprintf(msg, sizeof(msg), + snprintf(ip_json_field, sizeof(ip_json_field), ",\"udpIp\":\"%s\"", udp_ip); + snprintf(request_message, sizeof(request_message), "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d%s}", - lobby_id, udp_port, ip_field); - if (ws_send(msg) != 0) { - SDL_UnlockMutex(g_cs); + lobby_id, udp_port, ip_json_field); + if (websocket_send(request_message) != 0) { + SDL_UnlockMutex(g_mutex); return -1; } - int punch_n; - Uint32 deadline = SDL_GetTicks() + WS_RECV_TIMEOUT_MS; + int bytes_received; + Uint32 timeout_deadline = SDL_GetTicks() + WEBSOCKET_RECEIVE_TIMEOUT_MS; for (;;) { - int remaining = (int)(deadline - SDL_GetTicks()); - if (remaining <= 0) { + int time_remaining = (int)(timeout_deadline - SDL_GetTicks()); + if (time_remaining <= 0) { LbNetLog("Matchmaking: punch failed - timeout\n"); - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); return -1; } - punch_n = ws_recv(buf, sizeof(buf), remaining); - if (punch_n > 0) - LbNetLog("Matchmaking: punch response (%d bytes): %s\n", punch_n, buf); - if (punch_n <= 0) { - SDL_UnlockMutex(g_cs); + bytes_received = websocket_receive(response_buffer, sizeof(response_buffer), time_remaining); + if (bytes_received > 0) + LbNetLog("Matchmaking: punch response (%d bytes): %s\n", bytes_received, response_buffer); + if (bytes_received <= 0) { + SDL_UnlockMutex(g_mutex); return -1; } - if (strstr(buf, "\"lobbies\"")) + if (strstr(response_buffer, "\"lobbies\"")) continue; break; } - if (!strstr(buf, "\"punch\"") - || !json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) - || !json_int(buf, "peerPort", out_port)) { + if (!strstr(response_buffer, "\"punch\"") + || !json_parse_string(response_buffer, "peerIp", output_ip, MATCHMAKING_IP_MAX) + || !json_parse_int(response_buffer, "peerPort", output_port)) { LbNetLog("Matchmaking: punch failed - unexpected response\n"); - SDL_UnlockMutex(g_cs); + SDL_UnlockMutex(g_mutex); return -1; } - LbNetLog("Matchmaking: punch relay -> %s:%d\n", out_ip, *out_port); - SDL_UnlockMutex(g_cs); + LbNetLog("Matchmaking: punch relay -> %s:%d\n", output_ip, *output_port); + SDL_UnlockMutex(g_mutex); return 0; } -int matchmaking_poll_punch(char *out_ip, int *out_port) +int matchmaking_poll_punch(char *output_ip, int *output_port) { - if (!g_curl || !g_cs || SDL_TryLockMutex(g_cs) != 0) + if (!g_curl || !g_mutex || SDL_TryLockMutex(g_mutex) != 0) return 0; - char buf[WS_BUF_SIZE]; - int n = ws_recv(buf, sizeof(buf), 0); - int got_punch = 0; - if (n > 0 && strstr(buf, "\"punch\"")) { - got_punch = json_str(buf, "peerIp", out_ip, MATCHMAKING_IP_MAX) - && json_int(buf, "peerPort", out_port); - if (got_punch) - LbNetLog("Matchmaking: poll_punch -> %s:%d\n", out_ip, *out_port); + char response_buffer[WEBSOCKET_BUFFER_SIZE]; + int bytes_received = websocket_receive(response_buffer, sizeof(response_buffer), 0); + int punch_was_received = 0; + if (bytes_received > 0 && strstr(response_buffer, "\"punch\"")) { + punch_was_received = json_parse_string(response_buffer, "peerIp", output_ip, MATCHMAKING_IP_MAX) + && json_parse_int(response_buffer, "peerPort", output_port); + if (punch_was_received) + LbNetLog("Matchmaking: poll_punch -> %s:%d\n", output_ip, *output_port); else LbNetLog("Matchmaking: poll_punch parse failed\n"); } - SDL_UnlockMutex(g_cs); - return got_punch; + SDL_UnlockMutex(g_mutex); + return punch_was_received; } diff --git a/src/net_matchmaking.h b/src/net_matchmaking.h index 7dbbc8e8d2..1fbdf3661f 100644 --- a/src/net_matchmaking.h +++ b/src/net_matchmaking.h @@ -32,8 +32,8 @@ extern "C" { #define MATCHMAKING_NAME_MAX SESSION_NAME_MAX_LEN #define MATCHMAKING_SESSIONS_MAX 32 -extern struct TbNetworkSessionNameEntry g_mm_sessions[MATCHMAKING_SESSIONS_MAX]; -extern int g_mm_session_count; +extern struct TbNetworkSessionNameEntry g_matchmaking_sessions[MATCHMAKING_SESSIONS_MAX]; +extern int g_matchmaking_session_count; extern char g_join_lobby_id[MATCHMAKING_ID_MAX]; void matchmaking_init(void); @@ -42,8 +42,8 @@ int matchmaking_connect(void); void matchmaking_disconnect(void); void matchmaking_refresh_sessions(void); int matchmaking_create(const char *name, int udp_port, const char *ip); -int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, char *out_ip, int *out_port); -int matchmaking_poll_punch(char *out_ip, int *out_port); +int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, char *output_ip, int *output_port); +int matchmaking_poll_punch(char *output_ip, int *output_port); #ifdef __cplusplus } From 0038914e6eb3e62f91884d903f0ba388835851eb Mon Sep 17 00:00:00 2001 From: rainlizard <15337628+rainlizard@users.noreply.github.com> Date: Thu, 12 Mar 2026 06:31:53 +1100 Subject: [PATCH 31/31] remove g_ prefix --- src/bflib_enet.cpp | 12 ++--- src/bflib_enet.h | 4 +- src/bflib_network.cpp | 14 ++--- src/front_network.c | 4 +- src/net_game.c | 4 +- src/net_matchmaking.c | 120 +++++++++++++++++++++--------------------- src/net_matchmaking.h | 6 +-- 7 files changed, 82 insertions(+), 82 deletions(-) diff --git a/src/bflib_enet.cpp b/src/bflib_enet.cpp index 447b0fec9b..c3f57792a7 100644 --- a/src/bflib_enet.cpp +++ b/src/bflib_enet.cpp @@ -35,8 +35,8 @@ #define NUM_CHANNELS 2 #define HOLEPUNCH_CONNECT_DELAY_MS 300 -uint16_t g_external_port = 0; -char g_external_ip[EXTERNAL_IP_LEN] = {0}; +uint16_t external_port = 0; +char external_ip[EXTERNAL_IP_LEN] = {0}; namespace { @@ -119,7 +119,7 @@ namespace } enet_host_compress_with_range_coder(host); port_forward_add_mapping(address.port); - g_external_port = holepunch_stun_query(host, g_external_ip, sizeof(g_external_ip)); + external_port = holepunch_stun_query(host, external_ip, sizeof(external_ip)); return Lb_OK; } @@ -173,7 +173,7 @@ namespace TbError bf_enet_join(const char *session, void *options) { ENetAddress connect_address; - if (g_join_lobby_id[0] != '\0') { + if (join_lobby_id[0] != '\0') { LbNetLog("Join: connecting via UDP hole punching\n"); host = enet_host_create(ENET_ADDRESS_TYPE_IPV4, NULL, 4, NUM_CHANNELS, 0, 0); if (!host) { @@ -184,12 +184,12 @@ namespace uint16_t external_port = holepunch_stun_query(host, external_ip, sizeof(external_ip)); char peer_ip[MATCHMAKING_IP_MAX] = {0}; int peer_port = 0; - if (matchmaking_punch(g_join_lobby_id, (int)external_port, external_ip, peer_ip, &peer_port) != 0) { + if (matchmaking_punch(join_lobby_id, (int)external_port, external_ip, peer_ip, &peer_port) != 0) { LbNetLog("Join: matchmaking_punch failed\n"); host_destroy(); return Lb_FAIL; } - g_join_lobby_id[0] = '\0'; + join_lobby_id[0] = '\0'; if (enet_address_set_host(&connect_address, ENET_ADDRESS_TYPE_IPV4, peer_ip) < 0) { LbNetLog("Join: failed to resolve peer address %s\n", peer_ip); host_destroy(); diff --git a/src/bflib_enet.h b/src/bflib_enet.h index d447fcffd8..35500b6450 100644 --- a/src/bflib_enet.h +++ b/src/bflib_enet.h @@ -41,8 +41,8 @@ unsigned int GetClientOutgoingDataTotal(); unsigned int GetClientIncomingDataTotal(); unsigned int GetClientReliableCommandsInFlight(); void enet_matchmaking_host_update(void); -extern uint16_t g_external_port; -extern char g_external_ip[EXTERNAL_IP_LEN]; +extern uint16_t external_port; +extern char external_ip[EXTERNAL_IP_LEN]; #ifdef __cplusplus } diff --git a/src/bflib_network.cpp b/src/bflib_network.cpp index 6224965a17..23530c2ace 100644 --- a/src/bflib_network.cpp +++ b/src/bflib_network.cpp @@ -152,14 +152,14 @@ TbError LbNetwork_Create(char *nsname_str, char *plyr_name, uint32_t *plyr_num, return Lb_FAIL; } std::string host_name(plyr_name); - uint16_t external_port = g_external_port; - if (external_port == 0 && ServerPort > 0) - external_port = (uint16_t)ServerPort; - if (external_port == 0) - external_port = (uint16_t)ENET_DEFAULT_PORT; - std::thread([external_port, host_name]() { + uint16_t resolved_port = external_port; + if (resolved_port == 0 && ServerPort > 0) + resolved_port = (uint16_t)ServerPort; + if (resolved_port == 0) + resolved_port = (uint16_t)ENET_DEFAULT_PORT; + std::thread([resolved_port, host_name]() { if (matchmaking_connect() == 0) - matchmaking_create(host_name.c_str(), (int)external_port, g_external_ip); + matchmaking_create(host_name.c_str(), (int)resolved_port, external_ip); }).detach(); netstate.my_id = SERVER_ID; snprintf(netstate.users[netstate.my_id].name, sizeof(netstate.users[netstate.my_id].name), "%s", plyr_name); diff --git a/src/front_network.c b/src/front_network.c index 0733085db5..bc14996759 100644 --- a/src/front_network.c +++ b/src/front_network.c @@ -245,8 +245,8 @@ void frontnet_session_update(void) if ( LbNetwork_EnumerateSessions(enum_sessions_callback, 0) ) ERRORLOG("LbNetwork_EnumerateSessions() failed"); matchmaking_refresh_sessions(); - for (int i = 0; i < g_matchmaking_session_count && net_number_of_sessions < SESSION_ENTRIES_COUNT; i++) - net_session[net_number_of_sessions++] = &g_matchmaking_sessions[i]; + for (int i = 0; i < matchmaking_session_count && net_number_of_sessions < SESSION_ENTRIES_COUNT; i++) + net_session[net_number_of_sessions++] = &matchmaking_sessions[i]; last_enum_sessions = LbTimerClock(); if (net_number_of_sessions == 0) diff --git a/src/net_game.c b/src/net_game.c index 6459fc5b5f..940133ba57 100644 --- a/src/net_game.c +++ b/src/net_game.c @@ -190,10 +190,10 @@ long network_session_join(void) { int32_t plyr_num; display_attempting_to_join_message(); - snprintf(g_join_lobby_id, sizeof(g_join_lobby_id), "%s", net_session[net_session_index_active]->lobby_id); + snprintf(join_lobby_id, sizeof(join_lobby_id), "%s", net_session[net_session_index_active]->lobby_id); if ( LbNetwork_Join(net_session[net_session_index_active], net_player_name, &plyr_num, NULL) ) { - g_join_lobby_id[0] = '\0'; + join_lobby_id[0] = '\0'; process_network_error(-802); return -1; } diff --git a/src/net_matchmaking.c b/src/net_matchmaking.c index c557826a85..ef37000bbc 100644 --- a/src/net_matchmaking.c +++ b/src/net_matchmaking.c @@ -42,29 +42,29 @@ #define IP_JSON_FIELD_SIZE 80 #define CONNECT_TIMEOUT_MS 5000 -static CURL *g_curl = NULL; -static char g_hosted_lobby_id[MATCHMAKING_ID_MAX] = {0}; -static Uint32 g_last_refresh_tick = 0; -char g_join_lobby_id[MATCHMAKING_ID_MAX] = {0}; -static SDL_mutex *g_mutex = NULL; +static CURL *curl_handle = NULL; +static char hosted_lobby_id[MATCHMAKING_ID_MAX] = {0}; +static Uint32 last_refresh_tick = 0; +char join_lobby_id[MATCHMAKING_ID_MAX] = {0}; +static SDL_mutex *mutex = NULL; -struct TbNetworkSessionNameEntry g_matchmaking_sessions[MATCHMAKING_SESSIONS_MAX]; -int g_matchmaking_session_count = 0; +struct TbNetworkSessionNameEntry matchmaking_sessions[MATCHMAKING_SESSIONS_MAX]; +int matchmaking_session_count = 0; static void websocket_cleanup(void) { LbNetLog("Matchmaking: websocket_cleanup\n"); - curl_easy_cleanup(g_curl); - g_curl = NULL; - g_hosted_lobby_id[0] = '\0'; - g_matchmaking_session_count = 0; - g_last_refresh_tick = 0; + curl_easy_cleanup(curl_handle); + curl_handle = NULL; + hosted_lobby_id[0] = '\0'; + matchmaking_session_count = 0; + last_refresh_tick = 0; } static int websocket_send(const char *request) { size_t bytes_sent = 0; - CURLcode curl_result = curl_ws_send(g_curl, request, strlen(request), &bytes_sent, 0, CURLWS_TEXT); + CURLcode curl_result = curl_ws_send(curl_handle, request, strlen(request), &bytes_sent, 0, CURLWS_TEXT); if (curl_result != CURLE_OK) { LbNetLog("Matchmaking: websocket_send failed (%s)\n", curl_easy_strerror(curl_result)); websocket_cleanup(); @@ -76,7 +76,7 @@ static int websocket_send(const char *request) static int websocket_receive(char *response_buffer, size_t buffer_size, int timeout_ms) { curl_socket_t raw_socket = CURL_SOCKET_BAD; - if (curl_easy_getinfo(g_curl, CURLINFO_ACTIVESOCKET, &raw_socket) != CURLE_OK || raw_socket == CURL_SOCKET_BAD) { + if (curl_easy_getinfo(curl_handle, CURLINFO_ACTIVESOCKET, &raw_socket) != CURLE_OK || raw_socket == CURL_SOCKET_BAD) { LbNetLog("Matchmaking: websocket_receive failed to get active socket\n"); return -1; } @@ -90,7 +90,7 @@ static int websocket_receive(char *response_buffer, size_t buffer_size, int time size_t bytes_received = 0; const struct curl_ws_frame *websocket_frame = NULL; - CURLcode curl_result = curl_ws_recv(g_curl, response_buffer, buffer_size - 1, &bytes_received, &websocket_frame); + CURLcode curl_result = curl_ws_recv(curl_handle, response_buffer, buffer_size - 1, &bytes_received, &websocket_frame); if (curl_result == CURLE_AGAIN) return 0; if (curl_result != CURLE_OK) { @@ -104,7 +104,7 @@ static int websocket_receive(char *response_buffer, size_t buffer_size, int time static int websocket_exchange(const char *request, char *response_buffer, size_t buffer_size) { - if (!g_curl) return -1; + if (!curl_handle) return -1; if (websocket_send(request) != 0) return -1; return websocket_receive(response_buffer, buffer_size, WEBSOCKET_RECEIVE_TIMEOUT_MS); } @@ -144,7 +144,7 @@ void matchmaking_init(void) if (s_initialized) return; s_initialized = 1; - g_mutex = SDL_CreateMutex(); + mutex = SDL_CreateMutex(); curl_global_init(CURL_GLOBAL_DEFAULT); } @@ -164,59 +164,59 @@ void matchmaking_connect_async(void) int matchmaking_connect(void) { - SDL_LockMutex(g_mutex); - if (g_curl) { - SDL_UnlockMutex(g_mutex); + SDL_LockMutex(mutex); + if (curl_handle) { + SDL_UnlockMutex(mutex); return 0; } - g_curl = curl_easy_init(); - if (!g_curl) { - SDL_UnlockMutex(g_mutex); + curl_handle = curl_easy_init(); + if (!curl_handle) { + SDL_UnlockMutex(mutex); return -1; } LbNetLog("Matchmaking: connecting to %s\n", MATCHMAKING_URL); - curl_easy_setopt(g_curl, CURLOPT_URL, MATCHMAKING_URL); - curl_easy_setopt(g_curl, CURLOPT_CONNECT_ONLY, 2L); - curl_easy_setopt(g_curl, CURLOPT_CONNECTTIMEOUT_MS, (long)CONNECT_TIMEOUT_MS); - CURLcode curl_result = curl_easy_perform(g_curl); + curl_easy_setopt(curl_handle, CURLOPT_URL, MATCHMAKING_URL); + curl_easy_setopt(curl_handle, CURLOPT_CONNECT_ONLY, 2L); + curl_easy_setopt(curl_handle, CURLOPT_CONNECTTIMEOUT_MS, (long)CONNECT_TIMEOUT_MS); + CURLcode curl_result = curl_easy_perform(curl_handle); if (curl_result != CURLE_OK) { LbNetLog("Matchmaking: connect to %s failed: %s\n", MATCHMAKING_URL, curl_easy_strerror(curl_result)); websocket_cleanup(); - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return -1; } LbNetLog("Matchmaking: connected\n"); - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return 0; } void matchmaking_disconnect(void) { - SDL_LockMutex(g_mutex); - if (g_curl) { - if (g_hosted_lobby_id[0] != '\0') { + SDL_LockMutex(mutex); + if (curl_handle) { + if (hosted_lobby_id[0] != '\0') { char delete_message[SEND_BUFFER_SIZE]; - snprintf(delete_message, sizeof(delete_message), "{\"action\":\"delete\",\"id\":\"%s\"}", g_hosted_lobby_id); + snprintf(delete_message, sizeof(delete_message), "{\"action\":\"delete\",\"id\":\"%s\"}", hosted_lobby_id); websocket_send(delete_message); } websocket_cleanup(); LbNetLog("Matchmaking: disconnected\n"); } - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); } void matchmaking_refresh_sessions(void) { - SDL_LockMutex(g_mutex); - if (!g_curl) { - SDL_UnlockMutex(g_mutex); + SDL_LockMutex(mutex); + if (!curl_handle) { + SDL_UnlockMutex(mutex); return; } char response_buffer[WEBSOCKET_BUFFER_SIZE]; int bytes_received; - if (g_last_refresh_tick == 0) { + if (last_refresh_tick == 0) { bytes_received = websocket_exchange("{\"action\":\"list\",\"version\":\"" MATCHMAKING_VERSION "\"}", response_buffer, sizeof(response_buffer)); - g_last_refresh_tick = SDL_GetTicks(); + last_refresh_tick = SDL_GetTicks(); } else { bytes_received = websocket_receive(response_buffer, sizeof(response_buffer), 0); } @@ -232,7 +232,7 @@ void matchmaking_refresh_sessions(void) if (!json_cursor) break; json_cursor = json_parse_string(json_cursor, "name", name, sizeof(name)); if (!json_cursor) break; - struct TbNetworkSessionNameEntry *session = &g_matchmaking_sessions[count++]; + struct TbNetworkSessionNameEntry *session = &matchmaking_sessions[count++]; memset(session, 0, sizeof(*session)); session->joinable = 1; session->in_use = 1; @@ -240,10 +240,10 @@ void matchmaking_refresh_sessions(void) snprintf(session->text, SESSION_NAME_MAX_LEN, "%s", name); snprintf(session->lobby_id, SESSION_LOBBY_ID_MAX_LEN, "%s", id); } - g_matchmaking_session_count = count; + matchmaking_session_count = count; LbNetLog("Matchmaking: parsed %d session(s)\n", count); } - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); } int matchmaking_create(const char *name, int udp_port, const char *ip) @@ -252,10 +252,10 @@ int matchmaking_create(const char *name, int udp_port, const char *ip) char ip_json_field[IP_JSON_FIELD_SIZE]; char request_message[SEND_BUFFER_SIZE]; char response_buffer[WEBSOCKET_BUFFER_SIZE]; - SDL_LockMutex(g_mutex); - if (!g_curl) { + SDL_LockMutex(mutex); + if (!curl_handle) { LbNetLog("Matchmaking: not connected to server, lobby won't be listed online\n"); - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return -1; } int write_pos = 0; @@ -275,16 +275,16 @@ int matchmaking_create(const char *name, int udp_port, const char *ip) if (bytes_received > 0) LbNetLog("Matchmaking: create response (%d bytes): %s\n", bytes_received, response_buffer); if (bytes_received <= 0) { - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return -1; } - if (!strstr(response_buffer, "\"created\"") || !json_parse_string(response_buffer, "id", g_hosted_lobby_id, MATCHMAKING_ID_MAX)) { + if (!strstr(response_buffer, "\"created\"") || !json_parse_string(response_buffer, "id", hosted_lobby_id, MATCHMAKING_ID_MAX)) { LbNetLog("Matchmaking: create failed - unexpected response\n"); - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return -1; } - LbNetLog("Matchmaking: created lobby id=%s\n", g_hosted_lobby_id); - SDL_UnlockMutex(g_mutex); + LbNetLog("Matchmaking: created lobby id=%s\n", hosted_lobby_id); + SDL_UnlockMutex(mutex); return 0; } @@ -292,10 +292,10 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch { char request_message[SEND_BUFFER_SIZE]; char response_buffer[WEBSOCKET_BUFFER_SIZE]; - SDL_LockMutex(g_mutex); - if (!g_curl) { + SDL_LockMutex(mutex); + if (!curl_handle) { LbNetLog("Matchmaking: not connected to server, UDP hole punching unavailable\n"); - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return -1; } char ip_json_field[IP_JSON_FIELD_SIZE] = ""; @@ -305,7 +305,7 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch "{\"action\":\"punch\",\"lobbyId\":\"%s\",\"udpPort\":%d%s}", lobby_id, udp_port, ip_json_field); if (websocket_send(request_message) != 0) { - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return -1; } int bytes_received; @@ -314,14 +314,14 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch int time_remaining = (int)(timeout_deadline - SDL_GetTicks()); if (time_remaining <= 0) { LbNetLog("Matchmaking: punch failed - timeout\n"); - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return -1; } bytes_received = websocket_receive(response_buffer, sizeof(response_buffer), time_remaining); if (bytes_received > 0) LbNetLog("Matchmaking: punch response (%d bytes): %s\n", bytes_received, response_buffer); if (bytes_received <= 0) { - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return -1; } if (strstr(response_buffer, "\"lobbies\"")) @@ -332,17 +332,17 @@ int matchmaking_punch(const char *lobby_id, int udp_port, const char *udp_ip, ch || !json_parse_string(response_buffer, "peerIp", output_ip, MATCHMAKING_IP_MAX) || !json_parse_int(response_buffer, "peerPort", output_port)) { LbNetLog("Matchmaking: punch failed - unexpected response\n"); - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return -1; } LbNetLog("Matchmaking: punch relay -> %s:%d\n", output_ip, *output_port); - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return 0; } int matchmaking_poll_punch(char *output_ip, int *output_port) { - if (!g_curl || !g_mutex || SDL_TryLockMutex(g_mutex) != 0) + if (!curl_handle || !mutex || SDL_TryLockMutex(mutex) != 0) return 0; char response_buffer[WEBSOCKET_BUFFER_SIZE]; int bytes_received = websocket_receive(response_buffer, sizeof(response_buffer), 0); @@ -355,6 +355,6 @@ int matchmaking_poll_punch(char *output_ip, int *output_port) else LbNetLog("Matchmaking: poll_punch parse failed\n"); } - SDL_UnlockMutex(g_mutex); + SDL_UnlockMutex(mutex); return punch_was_received; } diff --git a/src/net_matchmaking.h b/src/net_matchmaking.h index 1fbdf3661f..0bf8cf5c3c 100644 --- a/src/net_matchmaking.h +++ b/src/net_matchmaking.h @@ -32,9 +32,9 @@ extern "C" { #define MATCHMAKING_NAME_MAX SESSION_NAME_MAX_LEN #define MATCHMAKING_SESSIONS_MAX 32 -extern struct TbNetworkSessionNameEntry g_matchmaking_sessions[MATCHMAKING_SESSIONS_MAX]; -extern int g_matchmaking_session_count; -extern char g_join_lobby_id[MATCHMAKING_ID_MAX]; +extern struct TbNetworkSessionNameEntry matchmaking_sessions[MATCHMAKING_SESSIONS_MAX]; +extern int matchmaking_session_count; +extern char join_lobby_id[MATCHMAKING_ID_MAX]; void matchmaking_init(void); void matchmaking_connect_async(void);

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%0Dd? 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