From 7f279bf63319ea9e07eb6015b044ec65749a5afa Mon Sep 17 00:00:00 2001 From: R4SAS Date: Sun, 23 Jun 2019 14:11:00 +0300 Subject: [PATCH] add prebuilt curl --- .gitignore | 15 + README | 9 + compat/curl-win-x86/bin/curl-config | 194 ++ compat/curl-win-x86/include/curl/curl.h | 2870 +++++++++++++++++ compat/curl-win-x86/include/curl/curlver.h | 77 + compat/curl-win-x86/include/curl/easy.h | 112 + compat/curl-win-x86/include/curl/mprintf.h | 50 + compat/curl-win-x86/include/curl/multi.h | 441 +++ .../curl-win-x86/include/curl/stdcheaders.h | 33 + compat/curl-win-x86/include/curl/system.h | 493 +++ .../curl-win-x86/include/curl/typecheck-gcc.h | 694 ++++ compat/curl-win-x86/include/curl/urlapi.h | 123 + compat/curl-win-x86/lib/libcurl.a | Bin 0 -> 616564 bytes compat/curl-win-x86/lib/libcurl.dll.a | Bin 0 -> 51982 bytes compat/curl-win-x86/lib/libcurl.la | 41 + compat/curl-win-x86/lib/pkgconfig/libcurl.pc | 39 + compat/curl-win-x86_64/bin/curl-config | 194 ++ compat/curl-win-x86_64/include/curl/curl.h | 2870 +++++++++++++++++ compat/curl-win-x86_64/include/curl/curlver.h | 77 + compat/curl-win-x86_64/include/curl/easy.h | 112 + compat/curl-win-x86_64/include/curl/mprintf.h | 50 + compat/curl-win-x86_64/include/curl/multi.h | 441 +++ .../include/curl/stdcheaders.h | 33 + compat/curl-win-x86_64/include/curl/system.h | 493 +++ .../include/curl/typecheck-gcc.h | 694 ++++ compat/curl-win-x86_64/include/curl/urlapi.h | 123 + compat/curl-win-x86_64/lib/libcurl.a | Bin 0 -> 639706 bytes compat/curl-win-x86_64/lib/libcurl.dll.a | Bin 0 -> 50696 bytes compat/curl-win-x86_64/lib/libcurl.la | 41 + .../curl-win-x86_64/lib/pkgconfig/libcurl.pc | 39 + cpuminer-config.h | 191 -- gost.c | 57 +- stamp-h1 | 1 - 33 files changed, 10386 insertions(+), 221 deletions(-) create mode 100644 .gitignore create mode 100644 compat/curl-win-x86/bin/curl-config create mode 100644 compat/curl-win-x86/include/curl/curl.h create mode 100644 compat/curl-win-x86/include/curl/curlver.h create mode 100644 compat/curl-win-x86/include/curl/easy.h create mode 100644 compat/curl-win-x86/include/curl/mprintf.h create mode 100644 compat/curl-win-x86/include/curl/multi.h create mode 100644 compat/curl-win-x86/include/curl/stdcheaders.h create mode 100644 compat/curl-win-x86/include/curl/system.h create mode 100644 compat/curl-win-x86/include/curl/typecheck-gcc.h create mode 100644 compat/curl-win-x86/include/curl/urlapi.h create mode 100644 compat/curl-win-x86/lib/libcurl.a create mode 100644 compat/curl-win-x86/lib/libcurl.dll.a create mode 100644 compat/curl-win-x86/lib/libcurl.la create mode 100644 compat/curl-win-x86/lib/pkgconfig/libcurl.pc create mode 100644 compat/curl-win-x86_64/bin/curl-config create mode 100644 compat/curl-win-x86_64/include/curl/curl.h create mode 100644 compat/curl-win-x86_64/include/curl/curlver.h create mode 100644 compat/curl-win-x86_64/include/curl/easy.h create mode 100644 compat/curl-win-x86_64/include/curl/mprintf.h create mode 100644 compat/curl-win-x86_64/include/curl/multi.h create mode 100644 compat/curl-win-x86_64/include/curl/stdcheaders.h create mode 100644 compat/curl-win-x86_64/include/curl/system.h create mode 100644 compat/curl-win-x86_64/include/curl/typecheck-gcc.h create mode 100644 compat/curl-win-x86_64/include/curl/urlapi.h create mode 100644 compat/curl-win-x86_64/lib/libcurl.a create mode 100644 compat/curl-win-x86_64/lib/libcurl.dll.a create mode 100644 compat/curl-win-x86_64/lib/libcurl.la create mode 100644 compat/curl-win-x86_64/lib/pkgconfig/libcurl.pc delete mode 100644 cpuminer-config.h delete mode 100644 stamp-h1 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..419ebe7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +.deps +/autom4te.cache +/config.* +aclocal.m4 +compile +depcomp +install-sh +missing +configure +cpuminer-config.* +*.o +Makefile +Makefile.in +stamp-h1 +*.exe diff --git a/README b/README index a301bac..fa9fc0a 100644 --- a/README +++ b/README @@ -1,2 +1,11 @@ Run with your gostcoin wallet app +```bash ./minerd -a gostd -t -o http://127.0.0.1:9376 -u -p +``` + +Building on Windows is possible with MSYS2. +```bash +./autogen.sh +./configure CFLAGS="-O3 -DCURL_STATICLIB" --with-libcurl=compat/curl-win-x86_64 +make +``` \ No newline at end of file diff --git a/compat/curl-win-x86/bin/curl-config b/compat/curl-win-x86/bin/curl-config new file mode 100644 index 0000000..42255e4 --- /dev/null +++ b/compat/curl-win-x86/bin/curl-config @@ -0,0 +1,194 @@ +#! /bin/sh +#*************************************************************************** +# _ _ ____ _ +# Project ___| | | | _ \| | +# / __| | | | |_) | | +# | (__| |_| | _ <| |___ +# \___|\___/|_| \_\_____| +# +# Copyright (C) 2001 - 2018, 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.haxx.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. +# +########################################################################### + +prefix=compat/curl-win-x86 +exec_prefix=${prefix} +includedir=${prefix}/include +cppflag_curl_staticlib= + +usage() +{ + cat <&2 + exit 1 + fi + ;; + + --configure) + echo " '--prefix=compat/curl-win-x86' '--without-nghttp2' '--without-libidn2' '--without-librtmp' '--without-libpsl' '--without-ssl' '--without-brotli' '--disable-rtsp' '--disable-ldap' '--disable-ldaps' '--disable-manual'" + ;; + + *) + echo "unknown option: $1" + usage 1 + ;; + esac + shift +done + +exit 0 diff --git a/compat/curl-win-x86/include/curl/curl.h b/compat/curl-win-x86/include/curl/curl.h new file mode 100644 index 0000000..e7f812d --- /dev/null +++ b/compat/curl-win-x86/include/curl/curl.h @@ -0,0 +1,2870 @@ +#ifndef __CURL_CURL_H +#define __CURL_CURL_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2019, 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.haxx.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. + * + ***************************************************************************/ + +/* + * If you have libcurl problems, all docs and details are found here: + * https://curl.haxx.se/libcurl/ + * + * curl-library mailing list subscription and unsubscription web interface: + * https://cool.haxx.se/mailman/listinfo/curl-library/ + */ + +#ifdef CURL_NO_OLDIES +#define CURL_STRICTER +#endif + +#include "curlver.h" /* libcurl version defines */ +#include "system.h" /* determine things run-time */ + +/* + * Define WIN32 when build target is Win32 API + */ + +#if (defined(_WIN32) || defined(__WIN32__)) && \ + !defined(WIN32) && !defined(__SYMBIAN32__) +#define WIN32 +#endif + +#include +#include + +#if defined(__FreeBSD__) && (__FreeBSD__ >= 2) +/* Needed for __FreeBSD_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 inclusion if winsock.h already was + included, since they can't 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(__SYMBIAN32__) || defined(__INTEGRITY) || \ + defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \ + defined(__CYGWIN__) || \ + (defined(__FreeBSD_version) && (__FreeBSD_version < 800000)) +#include +#endif + +#if !defined(WIN32) && !defined(_WIN32_WCE) +#include +#endif + +#if !defined(WIN32) && !defined(__WATCOMC__) && !defined(__VXWORKS__) +#include +#endif + +#ifdef __BEOS__ +#include +#endif + +/* Compatibility for non-Clang compilers */ +#ifndef __has_declspec_attribute +# define __has_declspec_attribute(x) 0 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER) +typedef struct Curl_easy CURL; +typedef struct Curl_share CURLSH; +#else +typedef void CURL; +typedef void CURLSH; +#endif + +/* + * libcurl external API function linkage decorations. + */ + +#ifdef CURL_STATICLIB +# define CURL_EXTERN +#elif defined(WIN32) || defined(__SYMBIAN32__) || \ + (__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 = 3, + CURLSSLBACKEND_OBSOLETE4 = 4, /* Was QSOSSL. */ + CURLSSLBACKEND_GSKIT = 5, + CURLSSLBACKEND_POLARSSL = 6, + CURLSSLBACKEND_WOLFSSL = 7, + CURLSSLBACKEND_SCHANNEL = 8, + CURLSSLBACKEND_SECURETRANSPORT = 9, + CURLSSLBACKEND_AXTLS = 10, /* never used since 7.63.0 */ + CURLSSLBACKEND_MBEDTLS = 11, + CURLSSLBACKEND_MESALINK = 12 +} curl_sslbackend; + +/* aliases for library clones and renames */ +#define CURLSSLBACKEND_LIBRESSL CURLSSLBACKEND_OPENSSL +#define CURLSSLBACKEND_BORINGSSL 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 file name */ +#define CURL_HTTPPOST_FILENAME (1<<0) +/* specified content is a file name */ +#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 file name to show. If not set, the + actual file name 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 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 524288 +#endif + +#ifndef CURL_MAX_WRITE_SIZE + /* Tests have proven that 20K is a very 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 + +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) + +/* Content of this structure depends on information which is known and is + achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man + page for callbacks returning this structure -- some fields are mandatory, + some others are optional. The FLAG field has special meaning. */ +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; + + /* used internally */ + 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 don't 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 doesn't 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 can't 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 */ + +/* 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 - couldn't open/read from file */ + CURLE_OUT_OF_MEMORY, /* 27 */ + /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error + instead of a memory allocation error if CURL_DOES_CONVERSIONS + is defined + */ + 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" didn't work */ + CURLE_HTTP_POST_ERROR, /* 34 */ + CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */ + CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */ + CURLE_FILE_COULDNT_READ_FILE, /* 37 */ + CURLE_LDAP_CANNOT_BIND, /* 38 */ + CURLE_LDAP_SEARCH_FAILED, /* 39 */ + CURLE_OBSOLETE40, /* 40 - NOT USED */ + CURLE_FUNCTION_NOT_FOUND, /* 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_TELNET_OPTION_SYNTAX, /* 49 - Malformed telnet 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 - couldn't use specified cipher */ + CURLE_PEER_FAILED_VERIFICATION, /* 60 - peer's certificate or fingerprint + wasn't verified fine */ + CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */ + CURLE_LDAP_INVALID_URL, /* 62 - Invalid LDAP URL */ + 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_CONV_FAILED, /* 75 - conversion failed */ + CURLE_CONV_REQD, /* 76 - caller must register conversion + callbacks using curl_easy_setopt options + CURLOPT_CONV_FROM_NETWORK_FUNCTION, + CURLOPT_CONV_TO_NETWORK_FUNCTION, and + CURLOPT_CONV_FROM_UTF8_FUNCTION */ + 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's 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 */ + CURL_LAST /* never use! */ +} CURLcode; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Previously obsolete error code re-used in 7.38.0 */ +#define CURLE_OBSOLETE16 CURLE_HTTP2 + +/* Previously obsolete error codes re-used 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 + +/* 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 + +/* 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 + +#endif /*!CURL_NO_OLDIES*/ + +/* 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, /* added in 7.52.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 + host name 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) +#define CURLAUTH_NTLM_WB (((unsigned long)1)<<5) +#define CURLAUTH_BEARER (((unsigned long)1)<<6) +#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 zero-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 can't answer right now so + this causes a CURLE_DEFER error but otherwise the + connection will be left intact etc */ + 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 from app */ + +/* 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) + +/* 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_IMMEDIATELY (1<<0) +#define CURLALTSVC_ALTUSED (1<<1) +#define CURLALTSVC_READONLYFILE (1<<2) +#define CURLALTSVC_H1 (1<<3) +#define CURLALTSVC_H2 (1<<4) +#define CURLALTSVC_H3 (1<<5) + +/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */ +#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_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_STRINGPOINT 10000 +#define CURLOPTTYPE_FUNCTIONPOINT 20000 +#define CURLOPTTYPE_OFF_T 30000 + +/* *STRINGPOINT is an alias for OBJECTPOINT to allow tools to extract the + string options from the header file */ + +/* name is uppercase CURLOPT_, + type is one of the defined CURLOPTTYPE_ + number is unique identifier */ +#ifdef CINIT +#undef CINIT +#endif + +#ifdef CURL_ISOCPP +#define CINIT(na,t,nu) CURLOPT_ ## na = CURLOPTTYPE_ ## t + nu +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define LONG CURLOPTTYPE_LONG +#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT +#define STRINGPOINT CURLOPTTYPE_OBJECTPOINT +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT +#define OFF_T CURLOPTTYPE_OFF_T +#define CINIT(name,type,number) CURLOPT_/**/name = type + number +#endif + +/* + * This macro-mania below setups the CURLOPT_[what] enum, to be used with + * curl_easy_setopt(). The first argument in the CINIT() macro is the [what] + * word. + */ + +typedef enum { + /* This is the FILE * or void * the regular output should be written to. */ + CINIT(WRITEDATA, OBJECTPOINT, 1), + + /* The full URL to get/put */ + CINIT(URL, STRINGPOINT, 2), + + /* Port number to connect to, if other than default. */ + CINIT(PORT, LONG, 3), + + /* Name of proxy to use. */ + CINIT(PROXY, STRINGPOINT, 4), + + /* "user:password;options" to use when fetching. */ + CINIT(USERPWD, STRINGPOINT, 5), + + /* "user:password" to use with proxy. */ + CINIT(PROXYUSERPWD, STRINGPOINT, 6), + + /* Range to get, specified as an ASCII string. */ + CINIT(RANGE, STRINGPOINT, 7), + + /* not used */ + + /* Specified file stream to upload from (use as input): */ + CINIT(READDATA, OBJECTPOINT, 9), + + /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE + * bytes big. */ + CINIT(ERRORBUFFER, 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. */ + CINIT(WRITEFUNCTION, 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. */ + CINIT(READFUNCTION, FUNCTIONPOINT, 12), + + /* Time-out the read operation after this amount of seconds */ + CINIT(TIMEOUT, LONG, 13), + + /* If the CURLOPT_INFILE 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. + */ + CINIT(INFILESIZE, LONG, 14), + + /* POST static input fields. */ + CINIT(POSTFIELDS, OBJECTPOINT, 15), + + /* Set the referrer page (needed by some CGIs) */ + CINIT(REFERER, STRINGPOINT, 16), + + /* Set the FTP PORT string (interface name, named or numerical IP address) + Use i.e '-' to use default address. */ + CINIT(FTPPORT, STRINGPOINT, 17), + + /* Set the User-Agent string (examined by some CGIs) */ + CINIT(USERAGENT, 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" */ + CINIT(LOW_SPEED_LIMIT, LONG, 19), + + /* Set the "low speed time" */ + CINIT(LOW_SPEED_TIME, 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. + */ + CINIT(RESUME_FROM, LONG, 21), + + /* Set cookie in request: */ + CINIT(COOKIE, 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) */ + CINIT(HTTPHEADER, OBJECTPOINT, 23), + + /* This points to a linked list of post entries, struct curl_httppost */ + CINIT(HTTPPOST, OBJECTPOINT, 24), + + /* name of the file keeping your private SSL-certificate */ + CINIT(SSLCERT, STRINGPOINT, 25), + + /* password for the SSL or SSH private key */ + CINIT(KEYPASSWD, STRINGPOINT, 26), + + /* send TYPE parameter? */ + CINIT(CRLF, LONG, 27), + + /* send linked-list of QUOTE commands */ + CINIT(QUOTE, OBJECTPOINT, 28), + + /* send FILE * or void * to store headers to, if you use a callback it + is simply passed to the callback unmodified */ + CINIT(HEADERDATA, OBJECTPOINT, 29), + + /* point to a file to read the initial cookies from, also enables + "cookie awareness" */ + CINIT(COOKIEFILE, STRINGPOINT, 31), + + /* What version to specifically try to use. + See CURL_SSLVERSION defines below. */ + CINIT(SSLVERSION, LONG, 32), + + /* What kind of HTTP time condition to use, see defines */ + CINIT(TIMECONDITION, LONG, 33), + + /* Time to use with the above condition. Specified in number of seconds + since 1 Jan 1970 */ + CINIT(TIMEVALUE, LONG, 34), + + /* 35 = OBSOLETE */ + + /* Custom request, for customizing the get command like + HTTP: DELETE, TRACE and others + FTP: to use a different list command + */ + CINIT(CUSTOMREQUEST, STRINGPOINT, 36), + + /* FILE handle to use instead of stderr */ + CINIT(STDERR, OBJECTPOINT, 37), + + /* 38 is not used */ + + /* send linked-list of post-transfer QUOTE commands */ + CINIT(POSTQUOTE, OBJECTPOINT, 39), + + CINIT(OBSOLETE40, OBJECTPOINT, 40), /* OBSOLETE, do not use! */ + + CINIT(VERBOSE, LONG, 41), /* talk a lot */ + CINIT(HEADER, LONG, 42), /* throw the header out too */ + CINIT(NOPROGRESS, LONG, 43), /* shut off the progress meter */ + CINIT(NOBODY, LONG, 44), /* use HEAD to get http document */ + CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 400 */ + CINIT(UPLOAD, LONG, 46), /* this is an upload */ + CINIT(POST, LONG, 47), /* HTTP POST method */ + CINIT(DIRLISTONLY, LONG, 48), /* bare names when listing directories */ + + CINIT(APPEND, LONG, 50), /* Append instead of overwrite on upload! */ + + /* Specify whether to read the user+password from the .netrc or the URL. + * This must be one of the CURL_NETRC_* enums below. */ + CINIT(NETRC, LONG, 51), + + CINIT(FOLLOWLOCATION, LONG, 52), /* use Location: Luke! */ + + CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */ + CINIT(PUT, LONG, 54), /* HTTP PUT */ + + /* 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. */ + CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56), + + /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION + callbacks */ + CINIT(PROGRESSDATA, OBJECTPOINT, 57), +#define CURLOPT_XFERINFODATA CURLOPT_PROGRESSDATA + + /* We want the referrer field set automatically when following locations */ + CINIT(AUTOREFERER, LONG, 58), + + /* Port of the proxy, can be set in the proxy string as well with: + "[host]:[port]" */ + CINIT(PROXYPORT, LONG, 59), + + /* size of the POST input data, if strlen() is not good to use */ + CINIT(POSTFIELDSIZE, LONG, 60), + + /* tunnel non-http operations through a HTTP proxy */ + CINIT(HTTPPROXYTUNNEL, LONG, 61), + + /* Set the interface string to use as outgoing network interface */ + CINIT(INTERFACE, 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 doesn't match one of these, 'private' will be used. */ + CINIT(KRBLEVEL, STRINGPOINT, 63), + + /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ + CINIT(SSL_VERIFYPEER, LONG, 64), + + /* The CApath or CAfile used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CINIT(CAINFO, STRINGPOINT, 65), + + /* 66 = OBSOLETE */ + /* 67 = OBSOLETE */ + + /* Maximum number of http redirects to follow */ + CINIT(MAXREDIRS, 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. */ + CINIT(FILETIME, LONG, 69), + + /* This points to a linked list of telnet options */ + CINIT(TELNETOPTIONS, OBJECTPOINT, 70), + + /* Max amount of cached alive connections */ + CINIT(MAXCONNECTS, LONG, 71), + + CINIT(OBSOLETE72, LONG, 72), /* OBSOLETE, do not use! */ + + /* 73 = OBSOLETE */ + + /* Set to explicitly use a new connection for the upcoming transfer. + Do not use this unless you're absolutely sure of this, as it makes the + operation slower and is less friendly for the network. */ + CINIT(FRESH_CONNECT, LONG, 74), + + /* Set to explicitly forbid the upcoming transfer's connection to be re-used + when done. Do not use this unless you're absolutely sure of this, as it + makes the operation slower and is less friendly for the network. */ + CINIT(FORBID_REUSE, LONG, 75), + + /* Set to a file name that contains random data for libcurl to use to + seed the random engine when doing SSL connects. */ + CINIT(RANDOM_FILE, STRINGPOINT, 76), + + /* Set to the Entropy Gathering Daemon socket pathname */ + CINIT(EGDSOCKET, STRINGPOINT, 77), + + /* Time-out connect operations after this amount of seconds, if connects are + OK within this time, then fine... This only aborts the connect phase. */ + CINIT(CONNECTTIMEOUT, LONG, 78), + + /* Function that will be called to store headers (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CINIT(HEADERFUNCTION, 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. + */ + CINIT(HTTPGET, 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. */ + CINIT(SSL_VERIFYHOST, LONG, 81), + + /* Specify which file name to write all known cookies in after completed + operation. Set file name to "-" (dash) to make it go to stdout. */ + CINIT(COOKIEJAR, STRINGPOINT, 82), + + /* Specify which SSL ciphers to use */ + CINIT(SSL_CIPHER_LIST, STRINGPOINT, 83), + + /* Specify which HTTP version to use! This must be set to one of the + CURL_HTTP_VERSION* enums set below. */ + CINIT(HTTP_VERSION, LONG, 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. */ + CINIT(FTP_USE_EPSV, LONG, 85), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ + CINIT(SSLCERTTYPE, STRINGPOINT, 86), + + /* name of the file keeping your private SSL-key */ + CINIT(SSLKEY, STRINGPOINT, 87), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ + CINIT(SSLKEYTYPE, STRINGPOINT, 88), + + /* crypto engine for the SSL-sub system */ + CINIT(SSLENGINE, STRINGPOINT, 89), + + /* set the crypto engine for the SSL-sub system as default + the param has no meaning... + */ + CINIT(SSLENGINE_DEFAULT, LONG, 90), + + /* Non-zero value means to use the global dns cache */ + CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* DEPRECATED, do not use! */ + + /* DNS cache timeout */ + CINIT(DNS_CACHE_TIMEOUT, LONG, 92), + + /* send linked-list of pre-transfer QUOTE commands */ + CINIT(PREQUOTE, OBJECTPOINT, 93), + + /* set the debug function */ + CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94), + + /* set the data for the debug function */ + CINIT(DEBUGDATA, OBJECTPOINT, 95), + + /* mark this as start of a cookie session */ + CINIT(COOKIESESSION, LONG, 96), + + /* The CApath directory used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CINIT(CAPATH, STRINGPOINT, 97), + + /* Instruct libcurl to use a smaller receive buffer */ + CINIT(BUFFERSIZE, 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. */ + CINIT(NOSIGNAL, LONG, 99), + + /* Provide a CURLShare for mutexing non-ts data */ + CINIT(SHARE, OBJECTPOINT, 100), + + /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), + CURLPROXY_HTTPS, CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and + CURLPROXY_SOCKS5. */ + CINIT(PROXYTYPE, LONG, 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 */ + CINIT(ACCEPT_ENCODING, STRINGPOINT, 102), + + /* Set pointer to private data */ + CINIT(PRIVATE, OBJECTPOINT, 103), + + /* Set aliases for HTTP 200 in the HTTP Response header */ + CINIT(HTTP200ALIASES, OBJECTPOINT, 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. */ + CINIT(UNRESTRICTED_AUTH, 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. */ + CINIT(FTP_USE_EPRT, 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. */ + CINIT(HTTPAUTH, LONG, 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. */ + CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108), + + /* Set the userdata for the ssl context callback function's third + argument */ + CINIT(SSL_CTX_DATA, OBJECTPOINT, 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. + */ + CINIT(FTP_CREATE_MISSING_DIRS, 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. */ + CINIT(PROXYAUTH, LONG, 111), + + /* FTP 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 FTP server to acknowledge commands + in a timely manner. */ + CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112), +#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT + + /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to + tell libcurl to resolve names to those IP versions only. This only has + affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */ + CINIT(IPRESOLVE, LONG, 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. */ + CINIT(MAXFILESIZE, LONG, 114), + + /* See the comment for INFILESIZE above, but in short, specifies + * the size of the file being uploaded. -1 means unknown. + */ + CINIT(INFILESIZE_LARGE, OFF_T, 115), + + /* Sets the continuation offset. There is also a LONG version of this; + * look above for RESUME_FROM. + */ + CINIT(RESUME_FROM_LARGE, 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. + */ + CINIT(MAXFILESIZE_LARGE, OFF_T, 117), + + /* Set this option to the file name 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. */ + CINIT(NETRC_FILE, 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 + */ + CINIT(USE_SSL, LONG, 119), + + /* The _LARGE version of the standard POSTFIELDSIZE option */ + CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120), + + /* Enable/disable the TCP Nagle algorithm */ + CINIT(TCP_NODELAY, 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 + */ + CINIT(FTPSSLAUTH, LONG, 129), + + CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130), + CINIT(IOCTLDATA, OBJECTPOINT, 131), + + /* 132 OBSOLETE. Gone in 7.16.0 */ + /* 133 OBSOLETE. Gone in 7.16.0 */ + + /* zero terminated string for pass on to the FTP server when asked for + "account" info */ + CINIT(FTP_ACCOUNT, STRINGPOINT, 134), + + /* feed cookie into cookie engine */ + CINIT(COOKIELIST, STRINGPOINT, 135), + + /* ignore Content-Length */ + CINIT(IGNORE_CONTENT_LENGTH, 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. */ + CINIT(FTP_SKIP_PASV_IP, LONG, 137), + + /* Select "file method" to use when doing FTP, see the curl_ftpmethod + above. */ + CINIT(FTP_FILEMETHOD, LONG, 138), + + /* Local port number to bind the socket to */ + CINIT(LOCALPORT, 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. + */ + CINIT(LOCALPORTRANGE, LONG, 140), + + /* no transfer, set up connection and let application use the socket by + extracting it with CURLINFO_LASTSOCKET */ + CINIT(CONNECT_ONLY, LONG, 141), + + /* Function that will be called to convert from the + network encoding (instead of using the iconv calls in libcurl) */ + CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142), + + /* Function that will be called to convert to the + network encoding (instead of using the iconv calls in libcurl) */ + CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143), + + /* 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 */ + CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144), + + /* if the connection proceeds too quickly then need to slow it down */ + /* limit-rate: maximum number of bytes per second to send or receive */ + CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145), + CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146), + + /* Pointer to command string to send if USER/PASS fails. */ + CINIT(FTP_ALTERNATIVE_TO_USER, STRINGPOINT, 147), + + /* callback function for setting socket options */ + CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148), + CINIT(SOCKOPTDATA, OBJECTPOINT, 149), + + /* set to 0 to disable session ID re-use for this transfer, default is + enabled (== 1) */ + CINIT(SSL_SESSIONID_CACHE, LONG, 150), + + /* allowed SSH authentication methods */ + CINIT(SSH_AUTH_TYPES, LONG, 151), + + /* Used by scp/sftp to do public/private key authentication */ + CINIT(SSH_PUBLIC_KEYFILE, STRINGPOINT, 152), + CINIT(SSH_PRIVATE_KEYFILE, STRINGPOINT, 153), + + /* Send CCC (Clear Command Channel) after authentication */ + CINIT(FTP_SSL_CCC, LONG, 154), + + /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ + CINIT(TIMEOUT_MS, LONG, 155), + CINIT(CONNECTTIMEOUT_MS, 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 */ + CINIT(HTTP_TRANSFER_DECODING, LONG, 157), + CINIT(HTTP_CONTENT_DECODING, LONG, 158), + + /* Permission used when creating new files and directories on the remote + server for protocols that support it, SFTP/SCP/FILE */ + CINIT(NEW_FILE_PERMS, LONG, 159), + CINIT(NEW_DIRECTORY_PERMS, LONG, 160), + + /* Set the behaviour of POST when redirecting. Values must be set to one + of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */ + CINIT(POSTREDIR, LONG, 161), + + /* used by scp/sftp to verify the host's public key */ + CINIT(SSH_HOST_PUBLIC_KEY_MD5, 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 */ + CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163), + CINIT(OPENSOCKETDATA, OBJECTPOINT, 164), + + /* POST volatile input fields. */ + CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165), + + /* set transfer mode (;type=) when doing FTP via an HTTP proxy */ + CINIT(PROXY_TRANSFER_MODE, LONG, 166), + + /* Callback function for seeking in the input stream */ + CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167), + CINIT(SEEKDATA, OBJECTPOINT, 168), + + /* CRL file */ + CINIT(CRLFILE, STRINGPOINT, 169), + + /* Issuer certificate */ + CINIT(ISSUERCERT, STRINGPOINT, 170), + + /* (IPv6) Address scope */ + CINIT(ADDRESS_SCOPE, LONG, 171), + + /* Collect certificate chain info and allow it to get retrievable with + CURLINFO_CERTINFO after the transfer is complete. */ + CINIT(CERTINFO, LONG, 172), + + /* "name" and "pwd" to use when fetching. */ + CINIT(USERNAME, STRINGPOINT, 173), + CINIT(PASSWORD, STRINGPOINT, 174), + + /* "name" and "pwd" to use with Proxy when fetching. */ + CINIT(PROXYUSERNAME, STRINGPOINT, 175), + CINIT(PROXYPASSWORD, 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. */ + CINIT(NOPROXY, STRINGPOINT, 177), + + /* block size for TFTP transfers */ + CINIT(TFTP_BLKSIZE, LONG, 178), + + /* Socks Service */ + CINIT(SOCKS5_GSSAPI_SERVICE, STRINGPOINT, 179), /* DEPRECATED, do not use! */ + + /* Socks Service */ + CINIT(SOCKS5_GSSAPI_NEC, 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. */ + CINIT(PROTOCOLS, LONG, 181), + + /* 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. Defaults + to all protocols except FILE and SCP. */ + CINIT(REDIR_PROTOCOLS, LONG, 182), + + /* set the SSH knownhost file name to use */ + CINIT(SSH_KNOWNHOSTS, STRINGPOINT, 183), + + /* set the SSH host key callback, must point to a curl_sshkeycallback + function */ + CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184), + + /* set the SSH host key callback custom pointer */ + CINIT(SSH_KEYDATA, OBJECTPOINT, 185), + + /* set the SMTP mail originator */ + CINIT(MAIL_FROM, STRINGPOINT, 186), + + /* set the list of SMTP mail receiver(s) */ + CINIT(MAIL_RCPT, OBJECTPOINT, 187), + + /* FTP: send PRET before PASV */ + CINIT(FTP_USE_PRET, LONG, 188), + + /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */ + CINIT(RTSP_REQUEST, LONG, 189), + + /* The RTSP session identifier */ + CINIT(RTSP_SESSION_ID, STRINGPOINT, 190), + + /* The RTSP stream URI */ + CINIT(RTSP_STREAM_URI, STRINGPOINT, 191), + + /* The Transport: header to use in RTSP requests */ + CINIT(RTSP_TRANSPORT, STRINGPOINT, 192), + + /* Manually initialize the client RTSP CSeq for this handle */ + CINIT(RTSP_CLIENT_CSEQ, LONG, 193), + + /* Manually initialize the server RTSP CSeq for this handle */ + CINIT(RTSP_SERVER_CSEQ, LONG, 194), + + /* The stream to pass to INTERLEAVEFUNCTION. */ + CINIT(INTERLEAVEDATA, OBJECTPOINT, 195), + + /* Let the application define a custom write method for RTP data */ + CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196), + + /* Turn on wildcard matching */ + CINIT(WILDCARDMATCH, LONG, 197), + + /* Directory matching callback called before downloading of an + individual file (chunk) started */ + CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198), + + /* Directory matching callback called after the file (chunk) + was downloaded, or skipped */ + CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199), + + /* Change match (fnmatch-like) callback for wildcard matching */ + CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200), + + /* Let the application define custom chunk data pointer */ + CINIT(CHUNK_DATA, OBJECTPOINT, 201), + + /* FNMATCH_FUNCTION user pointer */ + CINIT(FNMATCH_DATA, OBJECTPOINT, 202), + + /* send linked-list of name:port:address sets */ + CINIT(RESOLVE, OBJECTPOINT, 203), + + /* Set a username for authenticated TLS */ + CINIT(TLSAUTH_USERNAME, STRINGPOINT, 204), + + /* Set a password for authenticated TLS */ + CINIT(TLSAUTH_PASSWORD, STRINGPOINT, 205), + + /* Set authentication type for authenticated TLS */ + CINIT(TLSAUTH_TYPE, 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 + isn't any, it will not ask for transfer-encoding at all even if this + option is set to 1. + + */ + CINIT(TRANSFER_ENCODING, LONG, 207), + + /* Callback function for closing socket (instead of close(2)). The callback + should have type curl_closesocket_callback */ + CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208), + CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209), + + /* allow GSSAPI credential delegation */ + CINIT(GSSAPI_DELEGATION, LONG, 210), + + /* Set the name servers to use for DNS resolution */ + CINIT(DNS_SERVERS, STRINGPOINT, 211), + + /* Time-out accept operations (currently for FTP only) after this amount + of milliseconds. */ + CINIT(ACCEPTTIMEOUT_MS, LONG, 212), + + /* Set TCP keepalive */ + CINIT(TCP_KEEPALIVE, LONG, 213), + + /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */ + CINIT(TCP_KEEPIDLE, LONG, 214), + CINIT(TCP_KEEPINTVL, LONG, 215), + + /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */ + CINIT(SSL_OPTIONS, LONG, 216), + + /* Set the SMTP auth originator */ + CINIT(MAIL_AUTH, STRINGPOINT, 217), + + /* Enable/disable SASL initial response */ + CINIT(SASL_IR, 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) */ + CINIT(XFERINFOFUNCTION, FUNCTIONPOINT, 219), + + /* The XOAUTH2 bearer token */ + CINIT(XOAUTH2_BEARER, STRINGPOINT, 220), + + /* Set the interface string to use as outgoing network + * interface for DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_INTERFACE, STRINGPOINT, 221), + + /* Set the local IPv4 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_LOCAL_IP4, STRINGPOINT, 222), + + /* Set the local IPv6 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_LOCAL_IP6, STRINGPOINT, 223), + + /* Set authentication options directly */ + CINIT(LOGIN_OPTIONS, STRINGPOINT, 224), + + /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */ + CINIT(SSL_ENABLE_NPN, LONG, 225), + + /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */ + CINIT(SSL_ENABLE_ALPN, LONG, 226), + + /* Time to wait for a response to a HTTP request containing an + * Expect: 100-continue header before sending the data anyway. */ + CINIT(EXPECT_100_TIMEOUT_MS, LONG, 227), + + /* This points to a linked list of headers used for proxy requests only, + struct curl_slist kind */ + CINIT(PROXYHEADER, OBJECTPOINT, 228), + + /* Pass in a bitmask of "header options" */ + CINIT(HEADEROPT, LONG, 229), + + /* The public key in DER form used to validate the peer public key + this option is used only if SSL_VERIFYPEER is true */ + CINIT(PINNEDPUBLICKEY, STRINGPOINT, 230), + + /* Path to Unix domain socket */ + CINIT(UNIX_SOCKET_PATH, STRINGPOINT, 231), + + /* Set if we should verify the certificate status. */ + CINIT(SSL_VERIFYSTATUS, LONG, 232), + + /* Set if we should enable TLS false start. */ + CINIT(SSL_FALSESTART, LONG, 233), + + /* Do not squash dot-dot sequences */ + CINIT(PATH_AS_IS, LONG, 234), + + /* Proxy Service Name */ + CINIT(PROXY_SERVICE_NAME, STRINGPOINT, 235), + + /* Service Name */ + CINIT(SERVICE_NAME, STRINGPOINT, 236), + + /* Wait/don't wait for pipe/mutex to clarify */ + CINIT(PIPEWAIT, LONG, 237), + + /* Set the protocol used when curl is given a URL without a protocol */ + CINIT(DEFAULT_PROTOCOL, STRINGPOINT, 238), + + /* Set stream weight, 1 - 256 (default is 16) */ + CINIT(STREAM_WEIGHT, LONG, 239), + + /* Set stream dependency on another CURL handle */ + CINIT(STREAM_DEPENDS, OBJECTPOINT, 240), + + /* Set E-xclusive stream dependency on another CURL handle */ + CINIT(STREAM_DEPENDS_E, OBJECTPOINT, 241), + + /* Do not send any tftp option requests to the server */ + CINIT(TFTP_NO_OPTIONS, LONG, 242), + + /* Linked-list of host:port:connect-to-host:connect-to-port, + overrides the URL's host:port (only for the network layer) */ + CINIT(CONNECT_TO, OBJECTPOINT, 243), + + /* Set TCP Fast Open */ + CINIT(TCP_FASTOPEN, LONG, 244), + + /* Continue to send data if the server responds early with an + * HTTP status code >= 300 */ + CINIT(KEEP_SENDING_ON_ERROR, LONG, 245), + + /* The CApath or CAfile used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CINIT(PROXY_CAINFO, STRINGPOINT, 246), + + /* The CApath directory used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CINIT(PROXY_CAPATH, STRINGPOINT, 247), + + /* Set if we should verify the proxy in ssl handshake, + set 1 to verify. */ + CINIT(PROXY_SSL_VERIFYPEER, 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. */ + CINIT(PROXY_SSL_VERIFYHOST, LONG, 249), + + /* What version to specifically try to use for proxy. + See CURL_SSLVERSION defines below. */ + CINIT(PROXY_SSLVERSION, LONG, 250), + + /* Set a username for authenticated TLS for proxy */ + CINIT(PROXY_TLSAUTH_USERNAME, STRINGPOINT, 251), + + /* Set a password for authenticated TLS for proxy */ + CINIT(PROXY_TLSAUTH_PASSWORD, STRINGPOINT, 252), + + /* Set authentication type for authenticated TLS for proxy */ + CINIT(PROXY_TLSAUTH_TYPE, STRINGPOINT, 253), + + /* name of the file keeping your private SSL-certificate for proxy */ + CINIT(PROXY_SSLCERT, STRINGPOINT, 254), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") for + proxy */ + CINIT(PROXY_SSLCERTTYPE, STRINGPOINT, 255), + + /* name of the file keeping your private SSL-key for proxy */ + CINIT(PROXY_SSLKEY, STRINGPOINT, 256), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") for + proxy */ + CINIT(PROXY_SSLKEYTYPE, STRINGPOINT, 257), + + /* password for the SSL private key for proxy */ + CINIT(PROXY_KEYPASSWD, STRINGPOINT, 258), + + /* Specify which SSL ciphers to use for proxy */ + CINIT(PROXY_SSL_CIPHER_LIST, STRINGPOINT, 259), + + /* CRL file for proxy */ + CINIT(PROXY_CRLFILE, STRINGPOINT, 260), + + /* Enable/disable specific SSL features with a bitmask for proxy, see + CURLSSLOPT_* */ + CINIT(PROXY_SSL_OPTIONS, LONG, 261), + + /* Name of pre proxy to use. */ + CINIT(PRE_PROXY, 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 */ + CINIT(PROXY_PINNEDPUBLICKEY, STRINGPOINT, 263), + + /* Path to an abstract Unix domain socket */ + CINIT(ABSTRACT_UNIX_SOCKET, STRINGPOINT, 264), + + /* Suppress proxy CONNECT response headers from user callbacks */ + CINIT(SUPPRESS_CONNECT_HEADERS, LONG, 265), + + /* The request target, instead of extracted from the URL */ + CINIT(REQUEST_TARGET, STRINGPOINT, 266), + + /* bitmask of allowed auth methods for connections to SOCKS5 proxies */ + CINIT(SOCKS5_AUTH, LONG, 267), + + /* Enable/disable SSH compression */ + CINIT(SSH_COMPRESSION, LONG, 268), + + /* Post MIME data. */ + CINIT(MIMEPOST, OBJECTPOINT, 269), + + /* Time to use with the CURLOPT_TIMECONDITION. Specified in number of + seconds since 1 Jan 1970. */ + CINIT(TIMEVALUE_LARGE, OFF_T, 270), + + /* Head start in milliseconds to give happy eyeballs. */ + CINIT(HAPPY_EYEBALLS_TIMEOUT_MS, LONG, 271), + + /* Function that will be called before a resolver request is made */ + CINIT(RESOLVER_START_FUNCTION, FUNCTIONPOINT, 272), + + /* User data to pass to the resolver start callback. */ + CINIT(RESOLVER_START_DATA, OBJECTPOINT, 273), + + /* send HAProxy PROXY protocol header? */ + CINIT(HAPROXYPROTOCOL, LONG, 274), + + /* shuffle addresses before use when DNS returns multiple */ + CINIT(DNS_SHUFFLE_ADDRESSES, LONG, 275), + + /* Specify which TLS 1.3 ciphers suites to use */ + CINIT(TLS13_CIPHERS, STRINGPOINT, 276), + CINIT(PROXY_TLS13_CIPHERS, STRINGPOINT, 277), + + /* Disallow specifying username/login in URL. */ + CINIT(DISALLOW_USERNAME_IN_URL, LONG, 278), + + /* DNS-over-HTTPS URL */ + CINIT(DOH_URL, STRINGPOINT, 279), + + /* Preferred buffer size to use for uploads */ + CINIT(UPLOAD_BUFFERSIZE, LONG, 280), + + /* Time in ms between connection upkeep calls for long-lived connections. */ + CINIT(UPKEEP_INTERVAL_MS, LONG, 281), + + /* Specify URL using CURL URL API. */ + CINIT(CURLU, OBJECTPOINT, 282), + + /* add trailing data just after no more data is available */ + CINIT(TRAILERFUNCTION, FUNCTIONPOINT, 283), + + /* pointer to be passed to HTTP_TRAILER_FUNCTION */ + CINIT(TRAILERDATA, OBJECTPOINT, 284), + + /* set this to 1L to allow HTTP/0.9 responses or 0L to disallow */ + CINIT(HTTP09_ALLOWED, LONG, 285), + + /* alt-svc control bitmask */ + CINIT(ALTSVC_CTRL, LONG, 286), + + /* alt-svc cache file name to possibly read from/write to */ + CINIT(ALTSVC, STRINGPOINT, 287), + + /* maximum age of a connection to consider it for reuse (in seconds) */ + CINIT(MAXAGE_CONN, LONG, 288), + + 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 + +#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, resolves addresses to all IP + versions that your system allows */ +#define CURL_IPRESOLVE_V4 1 /* resolve to IPv4 addresses */ +#define CURL_IPRESOLVE_V6 2 /* resolve to IPv6 addresses */ + + /* three convenient "aliases" that follow the name scheme better */ +#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 don't care, and that we'd + 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_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 +}; + +enum { + CURL_SSLVERSION_DEFAULT, + CURL_SSLVERSION_TLSv1, /* TLS 1.x */ + CURL_SSLVERSION_SSLv2, + CURL_SSLVERSION_SSLv3, + CURL_SSLVERSION_TLSv1_0, + CURL_SSLVERSION_TLSv1_1, + CURL_SSLVERSION_TLSv1_2, + CURL_SSLVERSION_TLSv1_3, + + CURL_SSLVERSION_LAST /* never use, keep last */ +}; + +enum { + CURL_SSLVERSION_MAX_NONE = 0, + CURL_SSLVERSION_MAX_DEFAULT = (CURL_SSLVERSION_TLSv1 << 16), + CURL_SSLVERSION_MAX_TLSv1_0 = (CURL_SSLVERSION_TLSv1_0 << 16), + CURL_SSLVERSION_MAX_TLSv1_1 = (CURL_SSLVERSION_TLSv1_1 << 16), + CURL_SSLVERSION_MAX_TLSv1_2 = (CURL_SSLVERSION_TLSv1_2 << 16), + CURL_SSLVERSION_MAX_TLSv1_3 = (CURL_SSLVERSION_TLSv1_3 << 16), + + /* never use, keep last */ + 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 zero-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_s curl_mime; /* Mime context. */ +typedef struct curl_mimepart_s curl_mimepart; /* Mime part context. */ + +/* + * 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 file name. + */ +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); + +/* Old form API. */ +/* name is uppercase CURLFORM_ */ +#ifdef CFINIT +#undef CFINIT +#endif + +#ifdef CURL_ISOCPP +#define CFINIT(name) CURLFORM_ ## name +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define CFINIT(name) CURLFORM_/**/name +#endif + +typedef enum { + CFINIT(NOTHING), /********* the first one is unused ************/ + + /* */ + CFINIT(COPYNAME), + CFINIT(PTRNAME), + CFINIT(NAMELENGTH), + CFINIT(COPYCONTENTS), + CFINIT(PTRCONTENTS), + CFINIT(CONTENTSLENGTH), + CFINIT(FILECONTENT), + CFINIT(ARRAY), + CFINIT(OBSOLETE), + CFINIT(FILE), + + CFINIT(BUFFER), + CFINIT(BUFFERPTR), + CFINIT(BUFFERLENGTH), + + CFINIT(CONTENTTYPE), + CFINIT(CONTENTHEADER), + CFINIT(FILENAME), + CFINIT(END), + CFINIT(OBSOLETE2), + + CFINIT(STREAM), + CFINIT(CONTENTLEN), /* added in 7.46.0, provide a curl_off_t length */ + + CURLFORM_LASTENTRY /* the last unused */ +} CURLformoption; + +#undef CFINIT /* done */ + +/* 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, /* first, no error */ + + CURL_FORMADD_MEMORY, + CURL_FORMADD_OPTION_TWICE, + CURL_FORMADD_NULL, + CURL_FORMADD_UNKNOWN_OPTION, + CURL_FORMADD_INCOMPLETE, + CURL_FORMADD_ILLEGAL_ARRAY, + CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */ + + 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_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_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_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 not thread-safe! + */ +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 with 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); + +/* 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. + */ + +typedef struct { + curl_sslbackend id; + const char *name; +} 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 *, + const char *); + +/* + * NAME curl_slist_free_all() + * + * DESCRIPTION + * + * free a previously built curl_slist. + */ +CURL_EXTERN void curl_slist_free_all(struct curl_slist *); + +/* + * 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, only for OpenSSL, GnuTLS, Schannel, NSS + and GSKit builds. 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's a + linked list with textual information in the + format "name: value" */ +}; + +/* 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 = CURLINFO_DOUBLE + 7, + CURLINFO_SIZE_UPLOAD_T = CURLINFO_OFF_T + 7, + CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8, + CURLINFO_SIZE_DOWNLOAD_T = CURLINFO_OFF_T + 8, + CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9, + CURLINFO_SPEED_DOWNLOAD_T = CURLINFO_OFF_T + 9, + CURLINFO_SPEED_UPLOAD = 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 = CURLINFO_DOUBLE + 15, + CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = CURLINFO_OFF_T + 15, + CURLINFO_CONTENT_LENGTH_UPLOAD = 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 = 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 = 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 = CURLINFO_LONG + 48, + CURLINFO_SCHEME = CURLINFO_STRING + 49, + /* Fill in new entries below here! */ + + /* Preferably these would be defined conditionally based on the + sizeof curl_off_t being 64-bits */ + 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_LASTONE = 56 +} 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 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_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, /* don't 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 *, CURLSHoption option, ...); +CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *); + +/**************************************************************************** + * Structures for querying information about the curl library at runtime. + */ + +typedef enum { + CURLVERSION_FIRST, + CURLVERSION_SECOND, + CURLVERSION_THIRD, + CURLVERSION_FOURTH, + CURLVERSION_FIFTH, + 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_FIFTH + +typedef struct { + 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. */ + +} 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 */ + + /* + * 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) + +#ifdef __cplusplus +} +#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" + +/* the typechecker doesn't 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 */ + +#endif /* __CURL_CURL_H */ diff --git a/compat/curl-win-x86/include/curl/curlver.h b/compat/curl-win-x86/include/curl/curlver.h new file mode 100644 index 0000000..0f58874 --- /dev/null +++ b/compat/curl-win-x86/include/curl/curlver.h @@ -0,0 +1,77 @@ +#ifndef __CURL_CURLVER_H +#define __CURL_CURLVER_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2019, 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.haxx.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. + * + ***************************************************************************/ + +/* 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 "1996 - 2019 Daniel Stenberg, ." + +/* This is the version number of the libcurl package from which this header + file origins: */ +#define LIBCURL_VERSION "7.65.1" + +/* The numeric version number is also available "in parts" by using these + defines: */ +#define LIBCURL_VERSION_MAJOR 7 +#define LIBCURL_VERSION_MINOR 65 +#define LIBCURL_VERSION_PATCH 1 + +/* This is the numeric version of the libcurl version number, meant for easier + parsing and comparions 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 0x074101 + +/* + * 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 "2019-06-05" + +#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 /* __CURL_CURLVER_H */ diff --git a/compat/curl-win-x86/include/curl/easy.h b/compat/curl-win-x86/include/curl/easy.h new file mode 100644 index 0000000..f42a8a9 --- /dev/null +++ b/compat/curl-win-x86/include/curl/easy.h @@ -0,0 +1,112 @@ +#ifndef __CURL_EASY_H +#define __CURL_EASY_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2016, 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.haxx.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. + * + ***************************************************************************/ +#ifdef __cplusplus +extern "C" { +#endif + +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 a pointer to a long, a pointer to a char * or a + * pointer to a double (as the documentation describes elsewhere). 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 +} +#endif + +#endif diff --git a/compat/curl-win-x86/include/curl/mprintf.h b/compat/curl-win-x86/include/curl/mprintf.h new file mode 100644 index 0000000..e20f546 --- /dev/null +++ b/compat/curl-win-x86/include/curl/mprintf.h @@ -0,0 +1,50 @@ +#ifndef __CURL_MPRINTF_H +#define __CURL_MPRINTF_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2016, 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.haxx.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. + * + ***************************************************************************/ + +#include +#include /* needed for FILE */ +#include "curl.h" /* for CURL_EXTERN */ + +#ifdef __cplusplus +extern "C" { +#endif + +CURL_EXTERN int curl_mprintf(const char *format, ...); +CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...); +CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...); +CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength, + const char *format, ...); +CURL_EXTERN int curl_mvprintf(const char *format, va_list args); +CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args); +CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args); +CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength, + const char *format, va_list args); +CURL_EXTERN char *curl_maprintf(const char *format, ...); +CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args); + +#ifdef __cplusplus +} +#endif + +#endif /* __CURL_MPRINTF_H */ diff --git a/compat/curl-win-x86/include/curl/multi.h b/compat/curl-win-x86/include/curl/multi.h new file mode 100644 index 0000000..b19dbaf --- /dev/null +++ b/compat/curl-win-x86/include/curl/multi.h @@ -0,0 +1,441 @@ +#ifndef __CURL_MULTI_H +#define __CURL_MULTI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2017, 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.haxx.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. + * + ***************************************************************************/ +/* + This is an "external" header file. Don't 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 + +#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER) +typedef struct Curl_multi CURLM; +#else +typedef void CURLM; +#endif + +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're 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_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 don't 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; /* not supported yet */ +}; + +/* + * Name: curl_multi_init() + * + * Desc: inititalize 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_perform() + * + * Desc: When the app thinks there's 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's 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 very simple and only contain + * very 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'll + * 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 zero-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 man page 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_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_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); + +#undef CINIT /* re-using the same name as in curl.h */ + +#ifdef CURL_ISOCPP +#define CINIT(name,type,num) CURLMOPT_ ## name = CURLOPTTYPE_ ## type + num +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define LONG CURLOPTTYPE_LONG +#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT +#define OFF_T CURLOPTTYPE_OFF_T +#define CINIT(name,type,number) CURLMOPT_/**/name = type + number +#endif + +typedef enum { + /* This is the socket callback function pointer */ + CINIT(SOCKETFUNCTION, FUNCTIONPOINT, 1), + + /* This is the argument passed to the socket callback */ + CINIT(SOCKETDATA, OBJECTPOINT, 2), + + /* set to 1 to enable pipelining for this multi handle */ + CINIT(PIPELINING, LONG, 3), + + /* This is the timer callback function pointer */ + CINIT(TIMERFUNCTION, FUNCTIONPOINT, 4), + + /* This is the argument passed to the timer callback */ + CINIT(TIMERDATA, OBJECTPOINT, 5), + + /* maximum number of entries in the connection cache */ + CINIT(MAXCONNECTS, LONG, 6), + + /* maximum number of (pipelining) connections to one host */ + CINIT(MAX_HOST_CONNECTIONS, LONG, 7), + + /* maximum number of requests in a pipeline */ + CINIT(MAX_PIPELINE_LENGTH, LONG, 8), + + /* a connection with a content-length longer than this + will not be considered for pipelining */ + CINIT(CONTENT_LENGTH_PENALTY_SIZE, OFF_T, 9), + + /* a connection with a chunk length longer than this + will not be considered for pipelining */ + CINIT(CHUNK_LENGTH_PENALTY_SIZE, OFF_T, 10), + + /* a list of site names(+port) that are blacklisted from + pipelining */ + CINIT(PIPELINING_SITE_BL, OBJECTPOINT, 11), + + /* a list of server types that are blacklisted from + pipelining */ + CINIT(PIPELINING_SERVER_BL, OBJECTPOINT, 12), + + /* maximum number of open connections in total */ + CINIT(MAX_TOTAL_CONNECTIONS, LONG, 13), + + /* This is the server push callback function pointer */ + CINIT(PUSHFUNCTION, FUNCTIONPOINT, 14), + + /* This is the argument passed to the server push callback */ + CINIT(PUSHDATA, OBJECTPOINT, 15), + + 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_push_callback + * + * Desc: This callback gets called when a new stream is being pushed by the + * server. It approves or denies the new stream. + * + * Returns: CURL_PUSH_OK or CURL_PUSH_DENY. + */ +#define CURL_PUSH_OK 0 +#define CURL_PUSH_DENY 1 + +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); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/compat/curl-win-x86/include/curl/stdcheaders.h b/compat/curl-win-x86/include/curl/stdcheaders.h new file mode 100644 index 0000000..027b6f4 --- /dev/null +++ b/compat/curl-win-x86/include/curl/stdcheaders.h @@ -0,0 +1,33 @@ +#ifndef __STDC_HEADERS_H +#define __STDC_HEADERS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2016, 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.haxx.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. + * + ***************************************************************************/ + +#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 /* __STDC_HEADERS_H */ diff --git a/compat/curl-win-x86/include/curl/system.h b/compat/curl-win-x86/include/curl/system.h new file mode 100644 index 0000000..1e555ec --- /dev/null +++ b/compat/curl-win-x86/include/curl/system.h @@ -0,0 +1,493 @@ +#ifndef __CURL_SYSTEM_H +#define __CURL_SYSTEM_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2017, 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.haxx.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. + * + ***************************************************************************/ + +/* + * 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__) || defined(__GO32__) +# if defined(__DJGPP__) && (__DJGPP__ > 1) +# 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 int + +#elif defined(__SALFORDC__) +# 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(__BORLANDC__) +# if (__BORLANDC__ < 0x520) +# 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 __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 +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__TURBOC__) +# 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(__WATCOMC__) +# if defined(__386__) +# 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 +# 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 int + +#elif defined(__POCC__) +# if (__POCC__ < 280) +# 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 +# elif 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__) +# 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(__SYMBIAN32__) +# if defined(__EABI__) /* Treat all ARM compilers equally */ +# 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(__CW32__) +# pragma longlong on +# 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(__VC32__) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# 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(__MWERKS__) +# 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(_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__) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# 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_WS2TCPIP_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__) +# if defined(__ILEC400__) +# 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 +# endif + +#elif defined(__MVS__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_ILP32) +# elif defined(_LP64) +# endif +# 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 +# elif defined(_LP64) +# 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 +# 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(__370__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_ILP32) +# elif defined(_LP64) +# endif +# 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 +# elif defined(_LP64) +# 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 +# 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 + +/* ===================================== */ +/* KEEP MSVC THE PENULTIMATE ENTRY */ +/* ===================================== */ + +#elif defined(_MSC_VER) +# if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) +# 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 +# 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 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(__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_WS2TCPIP_H is defined above when inclusion of header file */ +/* ws2tcpip.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_WS2TCPIP_H +# include +# include +# include +#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(__SALFORDC__) || 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 __CURL_OFF_T_C_HLPR2(x) x +# define __CURL_OFF_T_C_HLPR1(x) __CURL_OFF_T_C_HLPR2(x) +# define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \ + __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \ + __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) +#else +# ifdef CURL_ISOCPP +# define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix +# else +# define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix +# endif +# define __CURL_OFF_T_C_HLPR1(Val,Suffix) __CURL_OFF_T_C_HLPR2(Val,Suffix) +# define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) +#endif + +#endif /* __CURL_SYSTEM_H */ diff --git a/compat/curl-win-x86/include/curl/typecheck-gcc.h b/compat/curl-win-x86/include/curl/typecheck-gcc.h new file mode 100644 index 0000000..2d1de4d --- /dev/null +++ b/compat/curl-win-x86/include/curl/typecheck-gcc.h @@ -0,0 +1,694 @@ +#ifndef __CURL_TYPECHECK_GCC_H +#define __CURL_TYPECHECK_GCC_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2019, 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.haxx.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. + * + ***************************************************************************/ + +/* wraps curl_easy_setopt() with typechecking */ + +/* To add a new kind of warning, add an + * if(_curl_is_sometype_option(_curl_opt)) + * if(!_curl_is_sometype(value)) + * _curl_easy_setopt_err_sometype(); + * block and define _curl_is_sometype_option, _curl_is_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'll just + * need to extend the appropriate _curl_*_option macro + */ +#define curl_easy_setopt(handle, option, value) \ +__extension__ ({ \ + __typeof__(option) _curl_opt = option; \ + if(__builtin_constant_p(_curl_opt)) { \ + if(_curl_is_long_option(_curl_opt)) \ + if(!_curl_is_long(value)) \ + _curl_easy_setopt_err_long(); \ + if(_curl_is_off_t_option(_curl_opt)) \ + if(!_curl_is_off_t(value)) \ + _curl_easy_setopt_err_curl_off_t(); \ + if(_curl_is_string_option(_curl_opt)) \ + if(!_curl_is_string(value)) \ + _curl_easy_setopt_err_string(); \ + if(_curl_is_write_cb_option(_curl_opt)) \ + if(!_curl_is_write_cb(value)) \ + _curl_easy_setopt_err_write_callback(); \ + if((_curl_opt) == CURLOPT_RESOLVER_START_FUNCTION) \ + if(!_curl_is_resolver_start_callback(value)) \ + _curl_easy_setopt_err_resolver_start_callback(); \ + if((_curl_opt) == CURLOPT_READFUNCTION) \ + if(!_curl_is_read_cb(value)) \ + _curl_easy_setopt_err_read_cb(); \ + if((_curl_opt) == CURLOPT_IOCTLFUNCTION) \ + if(!_curl_is_ioctl_cb(value)) \ + _curl_easy_setopt_err_ioctl_cb(); \ + if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION) \ + if(!_curl_is_sockopt_cb(value)) \ + _curl_easy_setopt_err_sockopt_cb(); \ + if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION) \ + if(!_curl_is_opensocket_cb(value)) \ + _curl_easy_setopt_err_opensocket_cb(); \ + if((_curl_opt) == CURLOPT_PROGRESSFUNCTION) \ + if(!_curl_is_progress_cb(value)) \ + _curl_easy_setopt_err_progress_cb(); \ + if((_curl_opt) == CURLOPT_DEBUGFUNCTION) \ + if(!_curl_is_debug_cb(value)) \ + _curl_easy_setopt_err_debug_cb(); \ + if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION) \ + if(!_curl_is_ssl_ctx_cb(value)) \ + _curl_easy_setopt_err_ssl_ctx_cb(); \ + if(_curl_is_conv_cb_option(_curl_opt)) \ + if(!_curl_is_conv_cb(value)) \ + _curl_easy_setopt_err_conv_cb(); \ + if((_curl_opt) == CURLOPT_SEEKFUNCTION) \ + if(!_curl_is_seek_cb(value)) \ + _curl_easy_setopt_err_seek_cb(); \ + if(_curl_is_cb_data_option(_curl_opt)) \ + if(!_curl_is_cb_data(value)) \ + _curl_easy_setopt_err_cb_data(); \ + if((_curl_opt) == CURLOPT_ERRORBUFFER) \ + if(!_curl_is_error_buffer(value)) \ + _curl_easy_setopt_err_error_buffer(); \ + if((_curl_opt) == CURLOPT_STDERR) \ + if(!_curl_is_FILE(value)) \ + _curl_easy_setopt_err_FILE(); \ + if(_curl_is_postfields_option(_curl_opt)) \ + if(!_curl_is_postfields(value)) \ + _curl_easy_setopt_err_postfields(); \ + if((_curl_opt) == CURLOPT_HTTPPOST) \ + if(!_curl_is_arr((value), struct curl_httppost)) \ + _curl_easy_setopt_err_curl_httpost(); \ + if((_curl_opt) == CURLOPT_MIMEPOST) \ + if(!_curl_is_ptr((value), curl_mime)) \ + _curl_easy_setopt_err_curl_mimepost(); \ + if(_curl_is_slist_option(_curl_opt)) \ + if(!_curl_is_arr((value), struct curl_slist)) \ + _curl_easy_setopt_err_curl_slist(); \ + if((_curl_opt) == CURLOPT_SHARE) \ + if(!_curl_is_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__ ({ \ + __typeof__(info) _curl_info = info; \ + if(__builtin_constant_p(_curl_info)) { \ + if(_curl_is_string_info(_curl_info)) \ + if(!_curl_is_arr((arg), char *)) \ + _curl_easy_getinfo_err_string(); \ + if(_curl_is_long_info(_curl_info)) \ + if(!_curl_is_arr((arg), long)) \ + _curl_easy_getinfo_err_long(); \ + if(_curl_is_double_info(_curl_info)) \ + if(!_curl_is_arr((arg), double)) \ + _curl_easy_getinfo_err_double(); \ + if(_curl_is_slist_info(_curl_info)) \ + if(!_curl_is_arr((arg), struct curl_slist *)) \ + _curl_easy_getinfo_err_curl_slist(); \ + if(_curl_is_tlssessioninfo_info(_curl_info)) \ + if(!_curl_is_arr((arg), struct curl_tlssessioninfo *)) \ + _curl_easy_getinfo_err_curl_tlssesssioninfo(); \ + if(_curl_is_certinfo_info(_curl_info)) \ + if(!_curl_is_arr((arg), struct curl_certinfo *)) \ + _curl_easy_getinfo_err_curl_certinfo(); \ + if(_curl_is_socket_info(_curl_info)) \ + if(!_curl_is_arr((arg), curl_socket_t)) \ + _curl_easy_getinfo_err_curl_socket(); \ + if(_curl_is_off_t_info(_curl_info)) \ + if(!_curl_is_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 _CURL_WARNING(id, message) \ + static void __attribute__((__warning__(message))) \ + __attribute__((__unused__)) __attribute__((__noinline__)) \ + id(void) { __asm__(""); } + +_CURL_WARNING(_curl_easy_setopt_err_long, + "curl_easy_setopt expects a long argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_off_t, + "curl_easy_setopt expects a curl_off_t argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_string, + "curl_easy_setopt expects a " + "string ('char *' or char[]) argument for this option" + ) +_CURL_WARNING(_curl_easy_setopt_err_write_callback, + "curl_easy_setopt expects a curl_write_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_resolver_start_callback, + "curl_easy_setopt expects a " + "curl_resolver_start_callback argument for this option" + ) +_CURL_WARNING(_curl_easy_setopt_err_read_cb, + "curl_easy_setopt expects a curl_read_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_ioctl_cb, + "curl_easy_setopt expects a curl_ioctl_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_sockopt_cb, + "curl_easy_setopt expects a curl_sockopt_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_opensocket_cb, + "curl_easy_setopt expects a " + "curl_opensocket_callback argument for this option" + ) +_CURL_WARNING(_curl_easy_setopt_err_progress_cb, + "curl_easy_setopt expects a curl_progress_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_debug_cb, + "curl_easy_setopt expects a curl_debug_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_ssl_ctx_cb, + "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_conv_cb, + "curl_easy_setopt expects a curl_conv_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_seek_cb, + "curl_easy_setopt expects a curl_seek_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_cb_data, + "curl_easy_setopt expects a " + "private data pointer as argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_error_buffer, + "curl_easy_setopt expects a " + "char buffer of CURL_ERROR_SIZE as argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_FILE, + "curl_easy_setopt expects a 'FILE *' argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_postfields, + "curl_easy_setopt expects a 'void *' or 'char *' argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_httpost, + "curl_easy_setopt expects a 'struct curl_httppost *' " + "argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_mimepost, + "curl_easy_setopt expects a 'curl_mime *' " + "argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_slist, + "curl_easy_setopt expects a 'struct curl_slist *' argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_CURLSH, + "curl_easy_setopt expects a CURLSH* argument for this option") + +_CURL_WARNING(_curl_easy_getinfo_err_string, + "curl_easy_getinfo expects a pointer to 'char *' for this info") +_CURL_WARNING(_curl_easy_getinfo_err_long, + "curl_easy_getinfo expects a pointer to long for this info") +_CURL_WARNING(_curl_easy_getinfo_err_double, + "curl_easy_getinfo expects a pointer to double for this info") +_CURL_WARNING(_curl_easy_getinfo_err_curl_slist, + "curl_easy_getinfo expects a pointer to 'struct curl_slist *' for this info") +_CURL_WARNING(_curl_easy_getinfo_err_curl_tlssesssioninfo, + "curl_easy_getinfo expects a pointer to " + "'struct curl_tlssessioninfo *' for this info") +_CURL_WARNING(_curl_easy_getinfo_err_curl_certinfo, + "curl_easy_getinfo expects a pointer to " + "'struct curl_certinfo *' for this info") +_CURL_WARNING(_curl_easy_getinfo_err_curl_socket, + "curl_easy_getinfo expects a pointer to curl_socket_t for this info") +_CURL_WARNING(_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 don't + * have to do anything + */ + +/* evaluates to true if option takes a long argument */ +#define _curl_is_long_option(option) \ + (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT) + +#define _curl_is_off_t_option(option) \ + ((option) > CURLOPTTYPE_OFF_T) + +/* evaluates to true if option takes a char* argument */ +#define _curl_is_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_EGDSOCKET || \ + (option) == CURLOPT_FTPPORT || \ + (option) == CURLOPT_FTP_ACCOUNT || \ + (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ + (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_PROXY || \ + (option) == CURLOPT_PROXYPASSWORD || \ + (option) == CURLOPT_PROXYUSERNAME || \ + (option) == CURLOPT_PROXYUSERPWD || \ + (option) == CURLOPT_PROXY_CAINFO || \ + (option) == CURLOPT_PROXY_CAPATH || \ + (option) == CURLOPT_PROXY_CRLFILE || \ + (option) == CURLOPT_PROXY_KEYPASSWD || \ + (option) == CURLOPT_PROXY_PINNEDPUBLICKEY || \ + (option) == CURLOPT_PROXY_SERVICE_NAME || \ + (option) == CURLOPT_PROXY_SSLCERT || \ + (option) == CURLOPT_PROXY_SSLCERTTYPE || \ + (option) == CURLOPT_PROXY_SSLKEY || \ + (option) == CURLOPT_PROXY_SSLKEYTYPE || \ + (option) == CURLOPT_PROXY_SSL_CIPHER_LIST || \ + (option) == CURLOPT_PROXY_TLSAUTH_PASSWORD || \ + (option) == CURLOPT_PROXY_TLSAUTH_USERNAME || \ + (option) == CURLOPT_PROXY_TLSAUTH_TYPE || \ + (option) == CURLOPT_RANDOM_FILE || \ + (option) == CURLOPT_RANGE || \ + (option) == CURLOPT_REFERER || \ + (option) == CURLOPT_RTSP_SESSION_ID || \ + (option) == CURLOPT_RTSP_STREAM_URI || \ + (option) == CURLOPT_RTSP_TRANSPORT || \ + (option) == CURLOPT_SERVICE_NAME || \ + (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ + (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_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_USERPWD || \ + (option) == CURLOPT_XOAUTH2_BEARER || \ + 0) + +/* evaluates to true if option takes a curl_write_callback argument */ +#define _curl_is_write_cb_option(option) \ + ((option) == CURLOPT_HEADERFUNCTION || \ + (option) == CURLOPT_WRITEFUNCTION) + +/* evaluates to true if option takes a curl_conv_callback argument */ +#define _curl_is_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 _curl_is_cb_data_option(option) \ + ((option) == CURLOPT_CHUNK_DATA || \ + (option) == CURLOPT_CLOSESOCKETDATA || \ + (option) == CURLOPT_DEBUGDATA || \ + (option) == CURLOPT_FNMATCH_DATA || \ + (option) == CURLOPT_HEADERDATA || \ + (option) == CURLOPT_INTERLEAVEDATA || \ + (option) == CURLOPT_IOCTLDATA || \ + (option) == CURLOPT_OPENSOCKETDATA || \ + (option) == CURLOPT_PRIVATE || \ + (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_CURLU || \ + 0) + +/* evaluates to true if option takes a POST data argument (void* or char*) */ +#define _curl_is_postfields_option(option) \ + ((option) == CURLOPT_POSTFIELDS || \ + (option) == CURLOPT_COPYPOSTFIELDS || \ + 0) + +/* evaluates to true if option takes a struct curl_slist * argument */ +#define _curl_is_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 || \ + 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 _curl_is_string_info(info) \ + (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG) + +/* evaluates to true if info expects a pointer to long argument */ +#define _curl_is_long_info(info) \ + (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE) + +/* evaluates to true if info expects a pointer to double argument */ +#define _curl_is_double_info(info) \ + (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST) + +/* true if info expects a pointer to struct curl_slist * argument */ +#define _curl_is_slist_info(info) \ + (((info) == CURLINFO_SSL_ENGINES) || ((info) == CURLINFO_COOKIELIST)) + +/* true if info expects a pointer to struct curl_tlssessioninfo * argument */ +#define _curl_is_tlssessioninfo_info(info) \ + (((info) == CURLINFO_TLS_SSL_PTR) || ((info) == CURLINFO_TLS_SESSION)) + +/* true if info expects a pointer to struct curl_certinfo * argument */ +#define _curl_is_certinfo_info(info) ((info) == CURLINFO_CERTINFO) + +/* true if info expects a pointer to struct curl_socket_t argument */ +#define _curl_is_socket_info(info) \ + (CURLINFO_SOCKET < (info) && (info) < CURLINFO_OFF_T) + +/* true if info expects a pointer to curl_off_t argument */ +#define _curl_is_off_t_info(info) \ + (CURLINFO_OFF_T < (info)) + + +/* typecheck helpers -- check whether given expression has requested type*/ + +/* For pointers, you can use the _curl_is_ptr/_curl_is_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 _curl_is_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 _curl_is_NULL(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL))) + +/* evaluates to true if expr is type*, const type* or NULL */ +#define _curl_is_ptr(expr, type) \ + (_curl_is_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 _curl_is_arr(expr, type) \ + (_curl_is_ptr((expr), type) || \ + __builtin_types_compatible_p(__typeof__(expr), type [])) + +/* evaluates to true if expr is a string */ +#define _curl_is_string(expr) \ + (_curl_is_arr((expr), char) || \ + _curl_is_arr((expr), signed char) || \ + _curl_is_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 _curl_is_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 _curl_is_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 _curl_is_error_buffer(expr) \ + (_curl_is_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 _curl_is_cb_data(expr) \ + (_curl_is_ptr((expr), void) || \ + _curl_is_ptr((expr), FILE)) +#else /* be less strict */ +#define _curl_is_cb_data(expr) \ + _curl_is_any_ptr(expr) +#endif + +/* evaluates to true if expr is of type FILE* */ +#define _curl_is_FILE(expr) \ + (_curl_is_NULL(expr) || \ + (__builtin_types_compatible_p(__typeof__(expr), FILE *))) + +/* evaluates to true if expr can be passed as POST data (void* or char*) */ +#define _curl_is_postfields(expr) \ + (_curl_is_ptr((expr), void) || \ + _curl_is_arr((expr), char) || \ + _curl_is_arr((expr), unsigned char)) + +/* helper: __builtin_types_compatible_p distinguishes between functions and + * function pointers, hide it */ +#define _curl_callback_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 _curl_is_resolver_start_callback(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_resolver_start_callback)) + +/* evaluates to true if expr is of type curl_read_callback or "similar" */ +#define _curl_is_read_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), __typeof__(fread) *) || \ + _curl_callback_compatible((expr), curl_read_callback) || \ + _curl_callback_compatible((expr), _curl_read_callback1) || \ + _curl_callback_compatible((expr), _curl_read_callback2) || \ + _curl_callback_compatible((expr), _curl_read_callback3) || \ + _curl_callback_compatible((expr), _curl_read_callback4) || \ + _curl_callback_compatible((expr), _curl_read_callback5) || \ + _curl_callback_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 _curl_is_write_cb(expr) \ + (_curl_is_read_cb(expr) || \ + _curl_callback_compatible((expr), __typeof__(fwrite) *) || \ + _curl_callback_compatible((expr), curl_write_callback) || \ + _curl_callback_compatible((expr), _curl_write_callback1) || \ + _curl_callback_compatible((expr), _curl_write_callback2) || \ + _curl_callback_compatible((expr), _curl_write_callback3) || \ + _curl_callback_compatible((expr), _curl_write_callback4) || \ + _curl_callback_compatible((expr), _curl_write_callback5) || \ + _curl_callback_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 _curl_is_ioctl_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_ioctl_callback) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback1) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback2) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback3) || \ + _curl_callback_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 _curl_is_sockopt_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_sockopt_callback) || \ + _curl_callback_compatible((expr), _curl_sockopt_callback1) || \ + _curl_callback_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 _curl_is_opensocket_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_opensocket_callback) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback1) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback2) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback3) || \ + _curl_callback_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 _curl_is_progress_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_progress_callback) || \ + _curl_callback_compatible((expr), _curl_progress_callback1) || \ + _curl_callback_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 _curl_is_debug_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_debug_callback) || \ + _curl_callback_compatible((expr), _curl_debug_callback1) || \ + _curl_callback_compatible((expr), _curl_debug_callback2) || \ + _curl_callback_compatible((expr), _curl_debug_callback3) || \ + _curl_callback_compatible((expr), _curl_debug_callback4) || \ + _curl_callback_compatible((expr), _curl_debug_callback5) || \ + _curl_callback_compatible((expr), _curl_debug_callback6) || \ + _curl_callback_compatible((expr), _curl_debug_callback7) || \ + _curl_callback_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 _curl_is_ssl_ctx_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_ssl_ctx_callback) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback1) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback2) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback3) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback4) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback5) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback6) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback7) || \ + _curl_callback_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're 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 _curl_is_conv_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_conv_callback) || \ + _curl_callback_compatible((expr), _curl_conv_callback1) || \ + _curl_callback_compatible((expr), _curl_conv_callback2) || \ + _curl_callback_compatible((expr), _curl_conv_callback3) || \ + _curl_callback_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 _curl_is_seek_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_seek_callback) || \ + _curl_callback_compatible((expr), _curl_seek_callback1) || \ + _curl_callback_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 /* __CURL_TYPECHECK_GCC_H */ diff --git a/compat/curl-win-x86/include/curl/urlapi.h b/compat/curl-win-x86/include/curl/urlapi.h new file mode 100644 index 0000000..58e89d8 --- /dev/null +++ b/compat/curl-win-x86/include/curl/urlapi.h @@ -0,0 +1,123 @@ +#ifndef __CURL_URLAPI_H +#define __CURL_URLAPI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 2018 - 2019, 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.haxx.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. + * + ***************************************************************************/ + +#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 */ +} 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 */ + +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(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(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); + + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/compat/curl-win-x86/lib/libcurl.a b/compat/curl-win-x86/lib/libcurl.a new file mode 100644 index 0000000000000000000000000000000000000000..d8a941fb6bf5fa2ca96e408f01b3f504fd033790 GIT binary patch literal 616564 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

A+ltM|>7feY>&*vh2h1BVGV{>0(V~v&xeyoK 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 literal 0 HcmV?d00001 diff --git a/compat/curl-win-x86/lib/libcurl.dll.a b/compat/curl-win-x86/lib/libcurl.dll.a new file mode 100644 index 0000000000000000000000000000000000000000..f37e1e2bf94009e6cb8735b1781b44038f41a83c GIT binary patch literal 51982 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 MDxgD@G5C1;FBZNFkpKVy literal 0 HcmV?d00001 diff --git a/compat/curl-win-x86/lib/libcurl.la b/compat/curl-win-x86/lib/libcurl.la new file mode 100644 index 0000000..f95e56a --- /dev/null +++ b/compat/curl-win-x86/lib/libcurl.la @@ -0,0 +1,41 @@ +# libcurl.la - a libtool library file +# Generated by libtool (GNU libtool) 2.4.6 Debian-2.4.6-10 +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='../bin/libcurl-4.dll' + +# Names of this library. +library_names='libcurl.dll.a' + +# The name of the static archive. +old_library='libcurl.a' + +# Linker flags that cannot go in dependency_libs. +inherited_linker_flags='' + +# Libraries that this one depends upon. +dependency_libs=' -L=/mingw32/lib -lz -lws2_32' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libcurl. +current=9 +age=5 +revision=0 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='compat/curl-win-x86/lib' diff --git a/compat/curl-win-x86/lib/pkgconfig/libcurl.pc b/compat/curl-win-x86/lib/pkgconfig/libcurl.pc new file mode 100644 index 0000000..8b1a5bc --- /dev/null +++ b/compat/curl-win-x86/lib/pkgconfig/libcurl.pc @@ -0,0 +1,39 @@ +#*************************************************************************** +# _ _ ____ _ +# Project ___| | | | _ \| | +# / __| | | | |_) | | +# | (__| |_| | _ <| |___ +# \___|\___/|_| \_\_____| +# +# Copyright (C) 1998 - 2012, 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.haxx.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. +# +########################################################################### + +# This should most probably benefit from getting a "Requires:" field added +# dynamically by configure. +# +prefix=compat/curl-win-x86 +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include +supported_protocols="DICT FILE FTP GOPHER HTTP IMAP POP3 SMTP TELNET TFTP" +supported_features="IPv6 libz AsynchDNS" + +Name: libcurl +URL: https://curl.haxx.se/ +Description: Library to transfer files with ftp, http, etc. +Version: 7.65.1 +Libs: -L${libdir} -lcurl +Libs.private: -lz -lws2_32 +Cflags: -I${includedir} diff --git a/compat/curl-win-x86_64/bin/curl-config b/compat/curl-win-x86_64/bin/curl-config new file mode 100644 index 0000000..69e516d --- /dev/null +++ b/compat/curl-win-x86_64/bin/curl-config @@ -0,0 +1,194 @@ +#! /bin/sh +#*************************************************************************** +# _ _ ____ _ +# Project ___| | | | _ \| | +# / __| | | | |_) | | +# | (__| |_| | _ <| |___ +# \___|\___/|_| \_\_____| +# +# Copyright (C) 2001 - 2018, 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.haxx.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. +# +########################################################################### + +prefix=compat/curl-win-x86_64 +exec_prefix=${prefix} +includedir=${prefix}/include +cppflag_curl_staticlib= + +usage() +{ + cat <&2 + exit 1 + fi + ;; + + --configure) + echo " '--prefix=compat/curl-win-x86_64' '--without-nghttp2' '--without-libidn2' '--without-librtmp' '--without-libpsl' '--without-ssl' '--without-brotli' '--disable-rtsp' '--disable-ldap' '--disable-ldaps' '--disable-manual'" + ;; + + *) + echo "unknown option: $1" + usage 1 + ;; + esac + shift +done + +exit 0 diff --git a/compat/curl-win-x86_64/include/curl/curl.h b/compat/curl-win-x86_64/include/curl/curl.h new file mode 100644 index 0000000..e7f812d --- /dev/null +++ b/compat/curl-win-x86_64/include/curl/curl.h @@ -0,0 +1,2870 @@ +#ifndef __CURL_CURL_H +#define __CURL_CURL_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2019, 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.haxx.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. + * + ***************************************************************************/ + +/* + * If you have libcurl problems, all docs and details are found here: + * https://curl.haxx.se/libcurl/ + * + * curl-library mailing list subscription and unsubscription web interface: + * https://cool.haxx.se/mailman/listinfo/curl-library/ + */ + +#ifdef CURL_NO_OLDIES +#define CURL_STRICTER +#endif + +#include "curlver.h" /* libcurl version defines */ +#include "system.h" /* determine things run-time */ + +/* + * Define WIN32 when build target is Win32 API + */ + +#if (defined(_WIN32) || defined(__WIN32__)) && \ + !defined(WIN32) && !defined(__SYMBIAN32__) +#define WIN32 +#endif + +#include +#include + +#if defined(__FreeBSD__) && (__FreeBSD__ >= 2) +/* Needed for __FreeBSD_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 inclusion if winsock.h already was + included, since they can't 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(__SYMBIAN32__) || defined(__INTEGRITY) || \ + defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \ + defined(__CYGWIN__) || \ + (defined(__FreeBSD_version) && (__FreeBSD_version < 800000)) +#include +#endif + +#if !defined(WIN32) && !defined(_WIN32_WCE) +#include +#endif + +#if !defined(WIN32) && !defined(__WATCOMC__) && !defined(__VXWORKS__) +#include +#endif + +#ifdef __BEOS__ +#include +#endif + +/* Compatibility for non-Clang compilers */ +#ifndef __has_declspec_attribute +# define __has_declspec_attribute(x) 0 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER) +typedef struct Curl_easy CURL; +typedef struct Curl_share CURLSH; +#else +typedef void CURL; +typedef void CURLSH; +#endif + +/* + * libcurl external API function linkage decorations. + */ + +#ifdef CURL_STATICLIB +# define CURL_EXTERN +#elif defined(WIN32) || defined(__SYMBIAN32__) || \ + (__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 = 3, + CURLSSLBACKEND_OBSOLETE4 = 4, /* Was QSOSSL. */ + CURLSSLBACKEND_GSKIT = 5, + CURLSSLBACKEND_POLARSSL = 6, + CURLSSLBACKEND_WOLFSSL = 7, + CURLSSLBACKEND_SCHANNEL = 8, + CURLSSLBACKEND_SECURETRANSPORT = 9, + CURLSSLBACKEND_AXTLS = 10, /* never used since 7.63.0 */ + CURLSSLBACKEND_MBEDTLS = 11, + CURLSSLBACKEND_MESALINK = 12 +} curl_sslbackend; + +/* aliases for library clones and renames */ +#define CURLSSLBACKEND_LIBRESSL CURLSSLBACKEND_OPENSSL +#define CURLSSLBACKEND_BORINGSSL 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 file name */ +#define CURL_HTTPPOST_FILENAME (1<<0) +/* specified content is a file name */ +#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 file name to show. If not set, the + actual file name 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 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 524288 +#endif + +#ifndef CURL_MAX_WRITE_SIZE + /* Tests have proven that 20K is a very 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 + +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) + +/* Content of this structure depends on information which is known and is + achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man + page for callbacks returning this structure -- some fields are mandatory, + some others are optional. The FLAG field has special meaning. */ +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; + + /* used internally */ + 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 don't 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 doesn't 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 can't 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 */ + +/* 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 - couldn't open/read from file */ + CURLE_OUT_OF_MEMORY, /* 27 */ + /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error + instead of a memory allocation error if CURL_DOES_CONVERSIONS + is defined + */ + 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" didn't work */ + CURLE_HTTP_POST_ERROR, /* 34 */ + CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */ + CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */ + CURLE_FILE_COULDNT_READ_FILE, /* 37 */ + CURLE_LDAP_CANNOT_BIND, /* 38 */ + CURLE_LDAP_SEARCH_FAILED, /* 39 */ + CURLE_OBSOLETE40, /* 40 - NOT USED */ + CURLE_FUNCTION_NOT_FOUND, /* 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_TELNET_OPTION_SYNTAX, /* 49 - Malformed telnet 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 - couldn't use specified cipher */ + CURLE_PEER_FAILED_VERIFICATION, /* 60 - peer's certificate or fingerprint + wasn't verified fine */ + CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */ + CURLE_LDAP_INVALID_URL, /* 62 - Invalid LDAP URL */ + 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_CONV_FAILED, /* 75 - conversion failed */ + CURLE_CONV_REQD, /* 76 - caller must register conversion + callbacks using curl_easy_setopt options + CURLOPT_CONV_FROM_NETWORK_FUNCTION, + CURLOPT_CONV_TO_NETWORK_FUNCTION, and + CURLOPT_CONV_FROM_UTF8_FUNCTION */ + 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's 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 */ + CURL_LAST /* never use! */ +} CURLcode; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Previously obsolete error code re-used in 7.38.0 */ +#define CURLE_OBSOLETE16 CURLE_HTTP2 + +/* Previously obsolete error codes re-used 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 + +/* 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 + +/* 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 + +#endif /*!CURL_NO_OLDIES*/ + +/* 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, /* added in 7.52.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 + host name 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) +#define CURLAUTH_NTLM_WB (((unsigned long)1)<<5) +#define CURLAUTH_BEARER (((unsigned long)1)<<6) +#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 zero-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 can't answer right now so + this causes a CURLE_DEFER error but otherwise the + connection will be left intact etc */ + 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 from app */ + +/* 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) + +/* 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_IMMEDIATELY (1<<0) +#define CURLALTSVC_ALTUSED (1<<1) +#define CURLALTSVC_READONLYFILE (1<<2) +#define CURLALTSVC_H1 (1<<3) +#define CURLALTSVC_H2 (1<<4) +#define CURLALTSVC_H3 (1<<5) + +/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */ +#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_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_STRINGPOINT 10000 +#define CURLOPTTYPE_FUNCTIONPOINT 20000 +#define CURLOPTTYPE_OFF_T 30000 + +/* *STRINGPOINT is an alias for OBJECTPOINT to allow tools to extract the + string options from the header file */ + +/* name is uppercase CURLOPT_, + type is one of the defined CURLOPTTYPE_ + number is unique identifier */ +#ifdef CINIT +#undef CINIT +#endif + +#ifdef CURL_ISOCPP +#define CINIT(na,t,nu) CURLOPT_ ## na = CURLOPTTYPE_ ## t + nu +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define LONG CURLOPTTYPE_LONG +#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT +#define STRINGPOINT CURLOPTTYPE_OBJECTPOINT +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT +#define OFF_T CURLOPTTYPE_OFF_T +#define CINIT(name,type,number) CURLOPT_/**/name = type + number +#endif + +/* + * This macro-mania below setups the CURLOPT_[what] enum, to be used with + * curl_easy_setopt(). The first argument in the CINIT() macro is the [what] + * word. + */ + +typedef enum { + /* This is the FILE * or void * the regular output should be written to. */ + CINIT(WRITEDATA, OBJECTPOINT, 1), + + /* The full URL to get/put */ + CINIT(URL, STRINGPOINT, 2), + + /* Port number to connect to, if other than default. */ + CINIT(PORT, LONG, 3), + + /* Name of proxy to use. */ + CINIT(PROXY, STRINGPOINT, 4), + + /* "user:password;options" to use when fetching. */ + CINIT(USERPWD, STRINGPOINT, 5), + + /* "user:password" to use with proxy. */ + CINIT(PROXYUSERPWD, STRINGPOINT, 6), + + /* Range to get, specified as an ASCII string. */ + CINIT(RANGE, STRINGPOINT, 7), + + /* not used */ + + /* Specified file stream to upload from (use as input): */ + CINIT(READDATA, OBJECTPOINT, 9), + + /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE + * bytes big. */ + CINIT(ERRORBUFFER, 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. */ + CINIT(WRITEFUNCTION, 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. */ + CINIT(READFUNCTION, FUNCTIONPOINT, 12), + + /* Time-out the read operation after this amount of seconds */ + CINIT(TIMEOUT, LONG, 13), + + /* If the CURLOPT_INFILE 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. + */ + CINIT(INFILESIZE, LONG, 14), + + /* POST static input fields. */ + CINIT(POSTFIELDS, OBJECTPOINT, 15), + + /* Set the referrer page (needed by some CGIs) */ + CINIT(REFERER, STRINGPOINT, 16), + + /* Set the FTP PORT string (interface name, named or numerical IP address) + Use i.e '-' to use default address. */ + CINIT(FTPPORT, STRINGPOINT, 17), + + /* Set the User-Agent string (examined by some CGIs) */ + CINIT(USERAGENT, 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" */ + CINIT(LOW_SPEED_LIMIT, LONG, 19), + + /* Set the "low speed time" */ + CINIT(LOW_SPEED_TIME, 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. + */ + CINIT(RESUME_FROM, LONG, 21), + + /* Set cookie in request: */ + CINIT(COOKIE, 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) */ + CINIT(HTTPHEADER, OBJECTPOINT, 23), + + /* This points to a linked list of post entries, struct curl_httppost */ + CINIT(HTTPPOST, OBJECTPOINT, 24), + + /* name of the file keeping your private SSL-certificate */ + CINIT(SSLCERT, STRINGPOINT, 25), + + /* password for the SSL or SSH private key */ + CINIT(KEYPASSWD, STRINGPOINT, 26), + + /* send TYPE parameter? */ + CINIT(CRLF, LONG, 27), + + /* send linked-list of QUOTE commands */ + CINIT(QUOTE, OBJECTPOINT, 28), + + /* send FILE * or void * to store headers to, if you use a callback it + is simply passed to the callback unmodified */ + CINIT(HEADERDATA, OBJECTPOINT, 29), + + /* point to a file to read the initial cookies from, also enables + "cookie awareness" */ + CINIT(COOKIEFILE, STRINGPOINT, 31), + + /* What version to specifically try to use. + See CURL_SSLVERSION defines below. */ + CINIT(SSLVERSION, LONG, 32), + + /* What kind of HTTP time condition to use, see defines */ + CINIT(TIMECONDITION, LONG, 33), + + /* Time to use with the above condition. Specified in number of seconds + since 1 Jan 1970 */ + CINIT(TIMEVALUE, LONG, 34), + + /* 35 = OBSOLETE */ + + /* Custom request, for customizing the get command like + HTTP: DELETE, TRACE and others + FTP: to use a different list command + */ + CINIT(CUSTOMREQUEST, STRINGPOINT, 36), + + /* FILE handle to use instead of stderr */ + CINIT(STDERR, OBJECTPOINT, 37), + + /* 38 is not used */ + + /* send linked-list of post-transfer QUOTE commands */ + CINIT(POSTQUOTE, OBJECTPOINT, 39), + + CINIT(OBSOLETE40, OBJECTPOINT, 40), /* OBSOLETE, do not use! */ + + CINIT(VERBOSE, LONG, 41), /* talk a lot */ + CINIT(HEADER, LONG, 42), /* throw the header out too */ + CINIT(NOPROGRESS, LONG, 43), /* shut off the progress meter */ + CINIT(NOBODY, LONG, 44), /* use HEAD to get http document */ + CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 400 */ + CINIT(UPLOAD, LONG, 46), /* this is an upload */ + CINIT(POST, LONG, 47), /* HTTP POST method */ + CINIT(DIRLISTONLY, LONG, 48), /* bare names when listing directories */ + + CINIT(APPEND, LONG, 50), /* Append instead of overwrite on upload! */ + + /* Specify whether to read the user+password from the .netrc or the URL. + * This must be one of the CURL_NETRC_* enums below. */ + CINIT(NETRC, LONG, 51), + + CINIT(FOLLOWLOCATION, LONG, 52), /* use Location: Luke! */ + + CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */ + CINIT(PUT, LONG, 54), /* HTTP PUT */ + + /* 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. */ + CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56), + + /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION + callbacks */ + CINIT(PROGRESSDATA, OBJECTPOINT, 57), +#define CURLOPT_XFERINFODATA CURLOPT_PROGRESSDATA + + /* We want the referrer field set automatically when following locations */ + CINIT(AUTOREFERER, LONG, 58), + + /* Port of the proxy, can be set in the proxy string as well with: + "[host]:[port]" */ + CINIT(PROXYPORT, LONG, 59), + + /* size of the POST input data, if strlen() is not good to use */ + CINIT(POSTFIELDSIZE, LONG, 60), + + /* tunnel non-http operations through a HTTP proxy */ + CINIT(HTTPPROXYTUNNEL, LONG, 61), + + /* Set the interface string to use as outgoing network interface */ + CINIT(INTERFACE, 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 doesn't match one of these, 'private' will be used. */ + CINIT(KRBLEVEL, STRINGPOINT, 63), + + /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ + CINIT(SSL_VERIFYPEER, LONG, 64), + + /* The CApath or CAfile used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CINIT(CAINFO, STRINGPOINT, 65), + + /* 66 = OBSOLETE */ + /* 67 = OBSOLETE */ + + /* Maximum number of http redirects to follow */ + CINIT(MAXREDIRS, 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. */ + CINIT(FILETIME, LONG, 69), + + /* This points to a linked list of telnet options */ + CINIT(TELNETOPTIONS, OBJECTPOINT, 70), + + /* Max amount of cached alive connections */ + CINIT(MAXCONNECTS, LONG, 71), + + CINIT(OBSOLETE72, LONG, 72), /* OBSOLETE, do not use! */ + + /* 73 = OBSOLETE */ + + /* Set to explicitly use a new connection for the upcoming transfer. + Do not use this unless you're absolutely sure of this, as it makes the + operation slower and is less friendly for the network. */ + CINIT(FRESH_CONNECT, LONG, 74), + + /* Set to explicitly forbid the upcoming transfer's connection to be re-used + when done. Do not use this unless you're absolutely sure of this, as it + makes the operation slower and is less friendly for the network. */ + CINIT(FORBID_REUSE, LONG, 75), + + /* Set to a file name that contains random data for libcurl to use to + seed the random engine when doing SSL connects. */ + CINIT(RANDOM_FILE, STRINGPOINT, 76), + + /* Set to the Entropy Gathering Daemon socket pathname */ + CINIT(EGDSOCKET, STRINGPOINT, 77), + + /* Time-out connect operations after this amount of seconds, if connects are + OK within this time, then fine... This only aborts the connect phase. */ + CINIT(CONNECTTIMEOUT, LONG, 78), + + /* Function that will be called to store headers (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CINIT(HEADERFUNCTION, 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. + */ + CINIT(HTTPGET, 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. */ + CINIT(SSL_VERIFYHOST, LONG, 81), + + /* Specify which file name to write all known cookies in after completed + operation. Set file name to "-" (dash) to make it go to stdout. */ + CINIT(COOKIEJAR, STRINGPOINT, 82), + + /* Specify which SSL ciphers to use */ + CINIT(SSL_CIPHER_LIST, STRINGPOINT, 83), + + /* Specify which HTTP version to use! This must be set to one of the + CURL_HTTP_VERSION* enums set below. */ + CINIT(HTTP_VERSION, LONG, 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. */ + CINIT(FTP_USE_EPSV, LONG, 85), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ + CINIT(SSLCERTTYPE, STRINGPOINT, 86), + + /* name of the file keeping your private SSL-key */ + CINIT(SSLKEY, STRINGPOINT, 87), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ + CINIT(SSLKEYTYPE, STRINGPOINT, 88), + + /* crypto engine for the SSL-sub system */ + CINIT(SSLENGINE, STRINGPOINT, 89), + + /* set the crypto engine for the SSL-sub system as default + the param has no meaning... + */ + CINIT(SSLENGINE_DEFAULT, LONG, 90), + + /* Non-zero value means to use the global dns cache */ + CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* DEPRECATED, do not use! */ + + /* DNS cache timeout */ + CINIT(DNS_CACHE_TIMEOUT, LONG, 92), + + /* send linked-list of pre-transfer QUOTE commands */ + CINIT(PREQUOTE, OBJECTPOINT, 93), + + /* set the debug function */ + CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94), + + /* set the data for the debug function */ + CINIT(DEBUGDATA, OBJECTPOINT, 95), + + /* mark this as start of a cookie session */ + CINIT(COOKIESESSION, LONG, 96), + + /* The CApath directory used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CINIT(CAPATH, STRINGPOINT, 97), + + /* Instruct libcurl to use a smaller receive buffer */ + CINIT(BUFFERSIZE, 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. */ + CINIT(NOSIGNAL, LONG, 99), + + /* Provide a CURLShare for mutexing non-ts data */ + CINIT(SHARE, OBJECTPOINT, 100), + + /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), + CURLPROXY_HTTPS, CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and + CURLPROXY_SOCKS5. */ + CINIT(PROXYTYPE, LONG, 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 */ + CINIT(ACCEPT_ENCODING, STRINGPOINT, 102), + + /* Set pointer to private data */ + CINIT(PRIVATE, OBJECTPOINT, 103), + + /* Set aliases for HTTP 200 in the HTTP Response header */ + CINIT(HTTP200ALIASES, OBJECTPOINT, 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. */ + CINIT(UNRESTRICTED_AUTH, 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. */ + CINIT(FTP_USE_EPRT, 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. */ + CINIT(HTTPAUTH, LONG, 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. */ + CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108), + + /* Set the userdata for the ssl context callback function's third + argument */ + CINIT(SSL_CTX_DATA, OBJECTPOINT, 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. + */ + CINIT(FTP_CREATE_MISSING_DIRS, 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. */ + CINIT(PROXYAUTH, LONG, 111), + + /* FTP 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 FTP server to acknowledge commands + in a timely manner. */ + CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112), +#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT + + /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to + tell libcurl to resolve names to those IP versions only. This only has + affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */ + CINIT(IPRESOLVE, LONG, 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. */ + CINIT(MAXFILESIZE, LONG, 114), + + /* See the comment for INFILESIZE above, but in short, specifies + * the size of the file being uploaded. -1 means unknown. + */ + CINIT(INFILESIZE_LARGE, OFF_T, 115), + + /* Sets the continuation offset. There is also a LONG version of this; + * look above for RESUME_FROM. + */ + CINIT(RESUME_FROM_LARGE, 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. + */ + CINIT(MAXFILESIZE_LARGE, OFF_T, 117), + + /* Set this option to the file name 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. */ + CINIT(NETRC_FILE, 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 + */ + CINIT(USE_SSL, LONG, 119), + + /* The _LARGE version of the standard POSTFIELDSIZE option */ + CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120), + + /* Enable/disable the TCP Nagle algorithm */ + CINIT(TCP_NODELAY, 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 + */ + CINIT(FTPSSLAUTH, LONG, 129), + + CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130), + CINIT(IOCTLDATA, OBJECTPOINT, 131), + + /* 132 OBSOLETE. Gone in 7.16.0 */ + /* 133 OBSOLETE. Gone in 7.16.0 */ + + /* zero terminated string for pass on to the FTP server when asked for + "account" info */ + CINIT(FTP_ACCOUNT, STRINGPOINT, 134), + + /* feed cookie into cookie engine */ + CINIT(COOKIELIST, STRINGPOINT, 135), + + /* ignore Content-Length */ + CINIT(IGNORE_CONTENT_LENGTH, 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. */ + CINIT(FTP_SKIP_PASV_IP, LONG, 137), + + /* Select "file method" to use when doing FTP, see the curl_ftpmethod + above. */ + CINIT(FTP_FILEMETHOD, LONG, 138), + + /* Local port number to bind the socket to */ + CINIT(LOCALPORT, 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. + */ + CINIT(LOCALPORTRANGE, LONG, 140), + + /* no transfer, set up connection and let application use the socket by + extracting it with CURLINFO_LASTSOCKET */ + CINIT(CONNECT_ONLY, LONG, 141), + + /* Function that will be called to convert from the + network encoding (instead of using the iconv calls in libcurl) */ + CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142), + + /* Function that will be called to convert to the + network encoding (instead of using the iconv calls in libcurl) */ + CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143), + + /* 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 */ + CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144), + + /* if the connection proceeds too quickly then need to slow it down */ + /* limit-rate: maximum number of bytes per second to send or receive */ + CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145), + CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146), + + /* Pointer to command string to send if USER/PASS fails. */ + CINIT(FTP_ALTERNATIVE_TO_USER, STRINGPOINT, 147), + + /* callback function for setting socket options */ + CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148), + CINIT(SOCKOPTDATA, OBJECTPOINT, 149), + + /* set to 0 to disable session ID re-use for this transfer, default is + enabled (== 1) */ + CINIT(SSL_SESSIONID_CACHE, LONG, 150), + + /* allowed SSH authentication methods */ + CINIT(SSH_AUTH_TYPES, LONG, 151), + + /* Used by scp/sftp to do public/private key authentication */ + CINIT(SSH_PUBLIC_KEYFILE, STRINGPOINT, 152), + CINIT(SSH_PRIVATE_KEYFILE, STRINGPOINT, 153), + + /* Send CCC (Clear Command Channel) after authentication */ + CINIT(FTP_SSL_CCC, LONG, 154), + + /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ + CINIT(TIMEOUT_MS, LONG, 155), + CINIT(CONNECTTIMEOUT_MS, 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 */ + CINIT(HTTP_TRANSFER_DECODING, LONG, 157), + CINIT(HTTP_CONTENT_DECODING, LONG, 158), + + /* Permission used when creating new files and directories on the remote + server for protocols that support it, SFTP/SCP/FILE */ + CINIT(NEW_FILE_PERMS, LONG, 159), + CINIT(NEW_DIRECTORY_PERMS, LONG, 160), + + /* Set the behaviour of POST when redirecting. Values must be set to one + of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */ + CINIT(POSTREDIR, LONG, 161), + + /* used by scp/sftp to verify the host's public key */ + CINIT(SSH_HOST_PUBLIC_KEY_MD5, 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 */ + CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163), + CINIT(OPENSOCKETDATA, OBJECTPOINT, 164), + + /* POST volatile input fields. */ + CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165), + + /* set transfer mode (;type=) when doing FTP via an HTTP proxy */ + CINIT(PROXY_TRANSFER_MODE, LONG, 166), + + /* Callback function for seeking in the input stream */ + CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167), + CINIT(SEEKDATA, OBJECTPOINT, 168), + + /* CRL file */ + CINIT(CRLFILE, STRINGPOINT, 169), + + /* Issuer certificate */ + CINIT(ISSUERCERT, STRINGPOINT, 170), + + /* (IPv6) Address scope */ + CINIT(ADDRESS_SCOPE, LONG, 171), + + /* Collect certificate chain info and allow it to get retrievable with + CURLINFO_CERTINFO after the transfer is complete. */ + CINIT(CERTINFO, LONG, 172), + + /* "name" and "pwd" to use when fetching. */ + CINIT(USERNAME, STRINGPOINT, 173), + CINIT(PASSWORD, STRINGPOINT, 174), + + /* "name" and "pwd" to use with Proxy when fetching. */ + CINIT(PROXYUSERNAME, STRINGPOINT, 175), + CINIT(PROXYPASSWORD, 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. */ + CINIT(NOPROXY, STRINGPOINT, 177), + + /* block size for TFTP transfers */ + CINIT(TFTP_BLKSIZE, LONG, 178), + + /* Socks Service */ + CINIT(SOCKS5_GSSAPI_SERVICE, STRINGPOINT, 179), /* DEPRECATED, do not use! */ + + /* Socks Service */ + CINIT(SOCKS5_GSSAPI_NEC, 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. */ + CINIT(PROTOCOLS, LONG, 181), + + /* 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. Defaults + to all protocols except FILE and SCP. */ + CINIT(REDIR_PROTOCOLS, LONG, 182), + + /* set the SSH knownhost file name to use */ + CINIT(SSH_KNOWNHOSTS, STRINGPOINT, 183), + + /* set the SSH host key callback, must point to a curl_sshkeycallback + function */ + CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184), + + /* set the SSH host key callback custom pointer */ + CINIT(SSH_KEYDATA, OBJECTPOINT, 185), + + /* set the SMTP mail originator */ + CINIT(MAIL_FROM, STRINGPOINT, 186), + + /* set the list of SMTP mail receiver(s) */ + CINIT(MAIL_RCPT, OBJECTPOINT, 187), + + /* FTP: send PRET before PASV */ + CINIT(FTP_USE_PRET, LONG, 188), + + /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */ + CINIT(RTSP_REQUEST, LONG, 189), + + /* The RTSP session identifier */ + CINIT(RTSP_SESSION_ID, STRINGPOINT, 190), + + /* The RTSP stream URI */ + CINIT(RTSP_STREAM_URI, STRINGPOINT, 191), + + /* The Transport: header to use in RTSP requests */ + CINIT(RTSP_TRANSPORT, STRINGPOINT, 192), + + /* Manually initialize the client RTSP CSeq for this handle */ + CINIT(RTSP_CLIENT_CSEQ, LONG, 193), + + /* Manually initialize the server RTSP CSeq for this handle */ + CINIT(RTSP_SERVER_CSEQ, LONG, 194), + + /* The stream to pass to INTERLEAVEFUNCTION. */ + CINIT(INTERLEAVEDATA, OBJECTPOINT, 195), + + /* Let the application define a custom write method for RTP data */ + CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196), + + /* Turn on wildcard matching */ + CINIT(WILDCARDMATCH, LONG, 197), + + /* Directory matching callback called before downloading of an + individual file (chunk) started */ + CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198), + + /* Directory matching callback called after the file (chunk) + was downloaded, or skipped */ + CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199), + + /* Change match (fnmatch-like) callback for wildcard matching */ + CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200), + + /* Let the application define custom chunk data pointer */ + CINIT(CHUNK_DATA, OBJECTPOINT, 201), + + /* FNMATCH_FUNCTION user pointer */ + CINIT(FNMATCH_DATA, OBJECTPOINT, 202), + + /* send linked-list of name:port:address sets */ + CINIT(RESOLVE, OBJECTPOINT, 203), + + /* Set a username for authenticated TLS */ + CINIT(TLSAUTH_USERNAME, STRINGPOINT, 204), + + /* Set a password for authenticated TLS */ + CINIT(TLSAUTH_PASSWORD, STRINGPOINT, 205), + + /* Set authentication type for authenticated TLS */ + CINIT(TLSAUTH_TYPE, 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 + isn't any, it will not ask for transfer-encoding at all even if this + option is set to 1. + + */ + CINIT(TRANSFER_ENCODING, LONG, 207), + + /* Callback function for closing socket (instead of close(2)). The callback + should have type curl_closesocket_callback */ + CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208), + CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209), + + /* allow GSSAPI credential delegation */ + CINIT(GSSAPI_DELEGATION, LONG, 210), + + /* Set the name servers to use for DNS resolution */ + CINIT(DNS_SERVERS, STRINGPOINT, 211), + + /* Time-out accept operations (currently for FTP only) after this amount + of milliseconds. */ + CINIT(ACCEPTTIMEOUT_MS, LONG, 212), + + /* Set TCP keepalive */ + CINIT(TCP_KEEPALIVE, LONG, 213), + + /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */ + CINIT(TCP_KEEPIDLE, LONG, 214), + CINIT(TCP_KEEPINTVL, LONG, 215), + + /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */ + CINIT(SSL_OPTIONS, LONG, 216), + + /* Set the SMTP auth originator */ + CINIT(MAIL_AUTH, STRINGPOINT, 217), + + /* Enable/disable SASL initial response */ + CINIT(SASL_IR, 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) */ + CINIT(XFERINFOFUNCTION, FUNCTIONPOINT, 219), + + /* The XOAUTH2 bearer token */ + CINIT(XOAUTH2_BEARER, STRINGPOINT, 220), + + /* Set the interface string to use as outgoing network + * interface for DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_INTERFACE, STRINGPOINT, 221), + + /* Set the local IPv4 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_LOCAL_IP4, STRINGPOINT, 222), + + /* Set the local IPv6 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_LOCAL_IP6, STRINGPOINT, 223), + + /* Set authentication options directly */ + CINIT(LOGIN_OPTIONS, STRINGPOINT, 224), + + /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */ + CINIT(SSL_ENABLE_NPN, LONG, 225), + + /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */ + CINIT(SSL_ENABLE_ALPN, LONG, 226), + + /* Time to wait for a response to a HTTP request containing an + * Expect: 100-continue header before sending the data anyway. */ + CINIT(EXPECT_100_TIMEOUT_MS, LONG, 227), + + /* This points to a linked list of headers used for proxy requests only, + struct curl_slist kind */ + CINIT(PROXYHEADER, OBJECTPOINT, 228), + + /* Pass in a bitmask of "header options" */ + CINIT(HEADEROPT, LONG, 229), + + /* The public key in DER form used to validate the peer public key + this option is used only if SSL_VERIFYPEER is true */ + CINIT(PINNEDPUBLICKEY, STRINGPOINT, 230), + + /* Path to Unix domain socket */ + CINIT(UNIX_SOCKET_PATH, STRINGPOINT, 231), + + /* Set if we should verify the certificate status. */ + CINIT(SSL_VERIFYSTATUS, LONG, 232), + + /* Set if we should enable TLS false start. */ + CINIT(SSL_FALSESTART, LONG, 233), + + /* Do not squash dot-dot sequences */ + CINIT(PATH_AS_IS, LONG, 234), + + /* Proxy Service Name */ + CINIT(PROXY_SERVICE_NAME, STRINGPOINT, 235), + + /* Service Name */ + CINIT(SERVICE_NAME, STRINGPOINT, 236), + + /* Wait/don't wait for pipe/mutex to clarify */ + CINIT(PIPEWAIT, LONG, 237), + + /* Set the protocol used when curl is given a URL without a protocol */ + CINIT(DEFAULT_PROTOCOL, STRINGPOINT, 238), + + /* Set stream weight, 1 - 256 (default is 16) */ + CINIT(STREAM_WEIGHT, LONG, 239), + + /* Set stream dependency on another CURL handle */ + CINIT(STREAM_DEPENDS, OBJECTPOINT, 240), + + /* Set E-xclusive stream dependency on another CURL handle */ + CINIT(STREAM_DEPENDS_E, OBJECTPOINT, 241), + + /* Do not send any tftp option requests to the server */ + CINIT(TFTP_NO_OPTIONS, LONG, 242), + + /* Linked-list of host:port:connect-to-host:connect-to-port, + overrides the URL's host:port (only for the network layer) */ + CINIT(CONNECT_TO, OBJECTPOINT, 243), + + /* Set TCP Fast Open */ + CINIT(TCP_FASTOPEN, LONG, 244), + + /* Continue to send data if the server responds early with an + * HTTP status code >= 300 */ + CINIT(KEEP_SENDING_ON_ERROR, LONG, 245), + + /* The CApath or CAfile used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CINIT(PROXY_CAINFO, STRINGPOINT, 246), + + /* The CApath directory used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CINIT(PROXY_CAPATH, STRINGPOINT, 247), + + /* Set if we should verify the proxy in ssl handshake, + set 1 to verify. */ + CINIT(PROXY_SSL_VERIFYPEER, 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. */ + CINIT(PROXY_SSL_VERIFYHOST, LONG, 249), + + /* What version to specifically try to use for proxy. + See CURL_SSLVERSION defines below. */ + CINIT(PROXY_SSLVERSION, LONG, 250), + + /* Set a username for authenticated TLS for proxy */ + CINIT(PROXY_TLSAUTH_USERNAME, STRINGPOINT, 251), + + /* Set a password for authenticated TLS for proxy */ + CINIT(PROXY_TLSAUTH_PASSWORD, STRINGPOINT, 252), + + /* Set authentication type for authenticated TLS for proxy */ + CINIT(PROXY_TLSAUTH_TYPE, STRINGPOINT, 253), + + /* name of the file keeping your private SSL-certificate for proxy */ + CINIT(PROXY_SSLCERT, STRINGPOINT, 254), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") for + proxy */ + CINIT(PROXY_SSLCERTTYPE, STRINGPOINT, 255), + + /* name of the file keeping your private SSL-key for proxy */ + CINIT(PROXY_SSLKEY, STRINGPOINT, 256), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") for + proxy */ + CINIT(PROXY_SSLKEYTYPE, STRINGPOINT, 257), + + /* password for the SSL private key for proxy */ + CINIT(PROXY_KEYPASSWD, STRINGPOINT, 258), + + /* Specify which SSL ciphers to use for proxy */ + CINIT(PROXY_SSL_CIPHER_LIST, STRINGPOINT, 259), + + /* CRL file for proxy */ + CINIT(PROXY_CRLFILE, STRINGPOINT, 260), + + /* Enable/disable specific SSL features with a bitmask for proxy, see + CURLSSLOPT_* */ + CINIT(PROXY_SSL_OPTIONS, LONG, 261), + + /* Name of pre proxy to use. */ + CINIT(PRE_PROXY, 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 */ + CINIT(PROXY_PINNEDPUBLICKEY, STRINGPOINT, 263), + + /* Path to an abstract Unix domain socket */ + CINIT(ABSTRACT_UNIX_SOCKET, STRINGPOINT, 264), + + /* Suppress proxy CONNECT response headers from user callbacks */ + CINIT(SUPPRESS_CONNECT_HEADERS, LONG, 265), + + /* The request target, instead of extracted from the URL */ + CINIT(REQUEST_TARGET, STRINGPOINT, 266), + + /* bitmask of allowed auth methods for connections to SOCKS5 proxies */ + CINIT(SOCKS5_AUTH, LONG, 267), + + /* Enable/disable SSH compression */ + CINIT(SSH_COMPRESSION, LONG, 268), + + /* Post MIME data. */ + CINIT(MIMEPOST, OBJECTPOINT, 269), + + /* Time to use with the CURLOPT_TIMECONDITION. Specified in number of + seconds since 1 Jan 1970. */ + CINIT(TIMEVALUE_LARGE, OFF_T, 270), + + /* Head start in milliseconds to give happy eyeballs. */ + CINIT(HAPPY_EYEBALLS_TIMEOUT_MS, LONG, 271), + + /* Function that will be called before a resolver request is made */ + CINIT(RESOLVER_START_FUNCTION, FUNCTIONPOINT, 272), + + /* User data to pass to the resolver start callback. */ + CINIT(RESOLVER_START_DATA, OBJECTPOINT, 273), + + /* send HAProxy PROXY protocol header? */ + CINIT(HAPROXYPROTOCOL, LONG, 274), + + /* shuffle addresses before use when DNS returns multiple */ + CINIT(DNS_SHUFFLE_ADDRESSES, LONG, 275), + + /* Specify which TLS 1.3 ciphers suites to use */ + CINIT(TLS13_CIPHERS, STRINGPOINT, 276), + CINIT(PROXY_TLS13_CIPHERS, STRINGPOINT, 277), + + /* Disallow specifying username/login in URL. */ + CINIT(DISALLOW_USERNAME_IN_URL, LONG, 278), + + /* DNS-over-HTTPS URL */ + CINIT(DOH_URL, STRINGPOINT, 279), + + /* Preferred buffer size to use for uploads */ + CINIT(UPLOAD_BUFFERSIZE, LONG, 280), + + /* Time in ms between connection upkeep calls for long-lived connections. */ + CINIT(UPKEEP_INTERVAL_MS, LONG, 281), + + /* Specify URL using CURL URL API. */ + CINIT(CURLU, OBJECTPOINT, 282), + + /* add trailing data just after no more data is available */ + CINIT(TRAILERFUNCTION, FUNCTIONPOINT, 283), + + /* pointer to be passed to HTTP_TRAILER_FUNCTION */ + CINIT(TRAILERDATA, OBJECTPOINT, 284), + + /* set this to 1L to allow HTTP/0.9 responses or 0L to disallow */ + CINIT(HTTP09_ALLOWED, LONG, 285), + + /* alt-svc control bitmask */ + CINIT(ALTSVC_CTRL, LONG, 286), + + /* alt-svc cache file name to possibly read from/write to */ + CINIT(ALTSVC, STRINGPOINT, 287), + + /* maximum age of a connection to consider it for reuse (in seconds) */ + CINIT(MAXAGE_CONN, LONG, 288), + + 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 + +#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, resolves addresses to all IP + versions that your system allows */ +#define CURL_IPRESOLVE_V4 1 /* resolve to IPv4 addresses */ +#define CURL_IPRESOLVE_V6 2 /* resolve to IPv6 addresses */ + + /* three convenient "aliases" that follow the name scheme better */ +#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 don't care, and that we'd + 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_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 +}; + +enum { + CURL_SSLVERSION_DEFAULT, + CURL_SSLVERSION_TLSv1, /* TLS 1.x */ + CURL_SSLVERSION_SSLv2, + CURL_SSLVERSION_SSLv3, + CURL_SSLVERSION_TLSv1_0, + CURL_SSLVERSION_TLSv1_1, + CURL_SSLVERSION_TLSv1_2, + CURL_SSLVERSION_TLSv1_3, + + CURL_SSLVERSION_LAST /* never use, keep last */ +}; + +enum { + CURL_SSLVERSION_MAX_NONE = 0, + CURL_SSLVERSION_MAX_DEFAULT = (CURL_SSLVERSION_TLSv1 << 16), + CURL_SSLVERSION_MAX_TLSv1_0 = (CURL_SSLVERSION_TLSv1_0 << 16), + CURL_SSLVERSION_MAX_TLSv1_1 = (CURL_SSLVERSION_TLSv1_1 << 16), + CURL_SSLVERSION_MAX_TLSv1_2 = (CURL_SSLVERSION_TLSv1_2 << 16), + CURL_SSLVERSION_MAX_TLSv1_3 = (CURL_SSLVERSION_TLSv1_3 << 16), + + /* never use, keep last */ + 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 zero-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_s curl_mime; /* Mime context. */ +typedef struct curl_mimepart_s curl_mimepart; /* Mime part context. */ + +/* + * 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 file name. + */ +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); + +/* Old form API. */ +/* name is uppercase CURLFORM_ */ +#ifdef CFINIT +#undef CFINIT +#endif + +#ifdef CURL_ISOCPP +#define CFINIT(name) CURLFORM_ ## name +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define CFINIT(name) CURLFORM_/**/name +#endif + +typedef enum { + CFINIT(NOTHING), /********* the first one is unused ************/ + + /* */ + CFINIT(COPYNAME), + CFINIT(PTRNAME), + CFINIT(NAMELENGTH), + CFINIT(COPYCONTENTS), + CFINIT(PTRCONTENTS), + CFINIT(CONTENTSLENGTH), + CFINIT(FILECONTENT), + CFINIT(ARRAY), + CFINIT(OBSOLETE), + CFINIT(FILE), + + CFINIT(BUFFER), + CFINIT(BUFFERPTR), + CFINIT(BUFFERLENGTH), + + CFINIT(CONTENTTYPE), + CFINIT(CONTENTHEADER), + CFINIT(FILENAME), + CFINIT(END), + CFINIT(OBSOLETE2), + + CFINIT(STREAM), + CFINIT(CONTENTLEN), /* added in 7.46.0, provide a curl_off_t length */ + + CURLFORM_LASTENTRY /* the last unused */ +} CURLformoption; + +#undef CFINIT /* done */ + +/* 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, /* first, no error */ + + CURL_FORMADD_MEMORY, + CURL_FORMADD_OPTION_TWICE, + CURL_FORMADD_NULL, + CURL_FORMADD_UNKNOWN_OPTION, + CURL_FORMADD_INCOMPLETE, + CURL_FORMADD_ILLEGAL_ARRAY, + CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */ + + 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_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_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_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 not thread-safe! + */ +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 with 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); + +/* 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. + */ + +typedef struct { + curl_sslbackend id; + const char *name; +} 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 *, + const char *); + +/* + * NAME curl_slist_free_all() + * + * DESCRIPTION + * + * free a previously built curl_slist. + */ +CURL_EXTERN void curl_slist_free_all(struct curl_slist *); + +/* + * 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, only for OpenSSL, GnuTLS, Schannel, NSS + and GSKit builds. 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's a + linked list with textual information in the + format "name: value" */ +}; + +/* 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 = CURLINFO_DOUBLE + 7, + CURLINFO_SIZE_UPLOAD_T = CURLINFO_OFF_T + 7, + CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8, + CURLINFO_SIZE_DOWNLOAD_T = CURLINFO_OFF_T + 8, + CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9, + CURLINFO_SPEED_DOWNLOAD_T = CURLINFO_OFF_T + 9, + CURLINFO_SPEED_UPLOAD = 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 = CURLINFO_DOUBLE + 15, + CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = CURLINFO_OFF_T + 15, + CURLINFO_CONTENT_LENGTH_UPLOAD = 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 = 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 = 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 = CURLINFO_LONG + 48, + CURLINFO_SCHEME = CURLINFO_STRING + 49, + /* Fill in new entries below here! */ + + /* Preferably these would be defined conditionally based on the + sizeof curl_off_t being 64-bits */ + 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_LASTONE = 56 +} 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 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_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, /* don't 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 *, CURLSHoption option, ...); +CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *); + +/**************************************************************************** + * Structures for querying information about the curl library at runtime. + */ + +typedef enum { + CURLVERSION_FIRST, + CURLVERSION_SECOND, + CURLVERSION_THIRD, + CURLVERSION_FOURTH, + CURLVERSION_FIFTH, + 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_FIFTH + +typedef struct { + 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. */ + +} 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 */ + + /* + * 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) + +#ifdef __cplusplus +} +#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" + +/* the typechecker doesn't 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 */ + +#endif /* __CURL_CURL_H */ diff --git a/compat/curl-win-x86_64/include/curl/curlver.h b/compat/curl-win-x86_64/include/curl/curlver.h new file mode 100644 index 0000000..0f58874 --- /dev/null +++ b/compat/curl-win-x86_64/include/curl/curlver.h @@ -0,0 +1,77 @@ +#ifndef __CURL_CURLVER_H +#define __CURL_CURLVER_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2019, 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.haxx.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. + * + ***************************************************************************/ + +/* 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 "1996 - 2019 Daniel Stenberg, ." + +/* This is the version number of the libcurl package from which this header + file origins: */ +#define LIBCURL_VERSION "7.65.1" + +/* The numeric version number is also available "in parts" by using these + defines: */ +#define LIBCURL_VERSION_MAJOR 7 +#define LIBCURL_VERSION_MINOR 65 +#define LIBCURL_VERSION_PATCH 1 + +/* This is the numeric version of the libcurl version number, meant for easier + parsing and comparions 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 0x074101 + +/* + * 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 "2019-06-05" + +#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 /* __CURL_CURLVER_H */ diff --git a/compat/curl-win-x86_64/include/curl/easy.h b/compat/curl-win-x86_64/include/curl/easy.h new file mode 100644 index 0000000..f42a8a9 --- /dev/null +++ b/compat/curl-win-x86_64/include/curl/easy.h @@ -0,0 +1,112 @@ +#ifndef __CURL_EASY_H +#define __CURL_EASY_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2016, 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.haxx.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. + * + ***************************************************************************/ +#ifdef __cplusplus +extern "C" { +#endif + +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 a pointer to a long, a pointer to a char * or a + * pointer to a double (as the documentation describes elsewhere). 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 +} +#endif + +#endif diff --git a/compat/curl-win-x86_64/include/curl/mprintf.h b/compat/curl-win-x86_64/include/curl/mprintf.h new file mode 100644 index 0000000..e20f546 --- /dev/null +++ b/compat/curl-win-x86_64/include/curl/mprintf.h @@ -0,0 +1,50 @@ +#ifndef __CURL_MPRINTF_H +#define __CURL_MPRINTF_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2016, 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.haxx.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. + * + ***************************************************************************/ + +#include +#include /* needed for FILE */ +#include "curl.h" /* for CURL_EXTERN */ + +#ifdef __cplusplus +extern "C" { +#endif + +CURL_EXTERN int curl_mprintf(const char *format, ...); +CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...); +CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...); +CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength, + const char *format, ...); +CURL_EXTERN int curl_mvprintf(const char *format, va_list args); +CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args); +CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args); +CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength, + const char *format, va_list args); +CURL_EXTERN char *curl_maprintf(const char *format, ...); +CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args); + +#ifdef __cplusplus +} +#endif + +#endif /* __CURL_MPRINTF_H */ diff --git a/compat/curl-win-x86_64/include/curl/multi.h b/compat/curl-win-x86_64/include/curl/multi.h new file mode 100644 index 0000000..b19dbaf --- /dev/null +++ b/compat/curl-win-x86_64/include/curl/multi.h @@ -0,0 +1,441 @@ +#ifndef __CURL_MULTI_H +#define __CURL_MULTI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2017, 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.haxx.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. + * + ***************************************************************************/ +/* + This is an "external" header file. Don't 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 + +#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER) +typedef struct Curl_multi CURLM; +#else +typedef void CURLM; +#endif + +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're 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_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 don't 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; /* not supported yet */ +}; + +/* + * Name: curl_multi_init() + * + * Desc: inititalize 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_perform() + * + * Desc: When the app thinks there's 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's 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 very simple and only contain + * very 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'll + * 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 zero-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 man page 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_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_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); + +#undef CINIT /* re-using the same name as in curl.h */ + +#ifdef CURL_ISOCPP +#define CINIT(name,type,num) CURLMOPT_ ## name = CURLOPTTYPE_ ## type + num +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define LONG CURLOPTTYPE_LONG +#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT +#define OFF_T CURLOPTTYPE_OFF_T +#define CINIT(name,type,number) CURLMOPT_/**/name = type + number +#endif + +typedef enum { + /* This is the socket callback function pointer */ + CINIT(SOCKETFUNCTION, FUNCTIONPOINT, 1), + + /* This is the argument passed to the socket callback */ + CINIT(SOCKETDATA, OBJECTPOINT, 2), + + /* set to 1 to enable pipelining for this multi handle */ + CINIT(PIPELINING, LONG, 3), + + /* This is the timer callback function pointer */ + CINIT(TIMERFUNCTION, FUNCTIONPOINT, 4), + + /* This is the argument passed to the timer callback */ + CINIT(TIMERDATA, OBJECTPOINT, 5), + + /* maximum number of entries in the connection cache */ + CINIT(MAXCONNECTS, LONG, 6), + + /* maximum number of (pipelining) connections to one host */ + CINIT(MAX_HOST_CONNECTIONS, LONG, 7), + + /* maximum number of requests in a pipeline */ + CINIT(MAX_PIPELINE_LENGTH, LONG, 8), + + /* a connection with a content-length longer than this + will not be considered for pipelining */ + CINIT(CONTENT_LENGTH_PENALTY_SIZE, OFF_T, 9), + + /* a connection with a chunk length longer than this + will not be considered for pipelining */ + CINIT(CHUNK_LENGTH_PENALTY_SIZE, OFF_T, 10), + + /* a list of site names(+port) that are blacklisted from + pipelining */ + CINIT(PIPELINING_SITE_BL, OBJECTPOINT, 11), + + /* a list of server types that are blacklisted from + pipelining */ + CINIT(PIPELINING_SERVER_BL, OBJECTPOINT, 12), + + /* maximum number of open connections in total */ + CINIT(MAX_TOTAL_CONNECTIONS, LONG, 13), + + /* This is the server push callback function pointer */ + CINIT(PUSHFUNCTION, FUNCTIONPOINT, 14), + + /* This is the argument passed to the server push callback */ + CINIT(PUSHDATA, OBJECTPOINT, 15), + + 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_push_callback + * + * Desc: This callback gets called when a new stream is being pushed by the + * server. It approves or denies the new stream. + * + * Returns: CURL_PUSH_OK or CURL_PUSH_DENY. + */ +#define CURL_PUSH_OK 0 +#define CURL_PUSH_DENY 1 + +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); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/compat/curl-win-x86_64/include/curl/stdcheaders.h b/compat/curl-win-x86_64/include/curl/stdcheaders.h new file mode 100644 index 0000000..027b6f4 --- /dev/null +++ b/compat/curl-win-x86_64/include/curl/stdcheaders.h @@ -0,0 +1,33 @@ +#ifndef __STDC_HEADERS_H +#define __STDC_HEADERS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2016, 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.haxx.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. + * + ***************************************************************************/ + +#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 /* __STDC_HEADERS_H */ diff --git a/compat/curl-win-x86_64/include/curl/system.h b/compat/curl-win-x86_64/include/curl/system.h new file mode 100644 index 0000000..1e555ec --- /dev/null +++ b/compat/curl-win-x86_64/include/curl/system.h @@ -0,0 +1,493 @@ +#ifndef __CURL_SYSTEM_H +#define __CURL_SYSTEM_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2017, 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.haxx.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. + * + ***************************************************************************/ + +/* + * 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__) || defined(__GO32__) +# if defined(__DJGPP__) && (__DJGPP__ > 1) +# 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 int + +#elif defined(__SALFORDC__) +# 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(__BORLANDC__) +# if (__BORLANDC__ < 0x520) +# 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 __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 +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__TURBOC__) +# 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(__WATCOMC__) +# if defined(__386__) +# 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 +# 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 int + +#elif defined(__POCC__) +# if (__POCC__ < 280) +# 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 +# elif 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__) +# 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(__SYMBIAN32__) +# if defined(__EABI__) /* Treat all ARM compilers equally */ +# 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(__CW32__) +# pragma longlong on +# 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(__VC32__) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# 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(__MWERKS__) +# 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(_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__) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# 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_WS2TCPIP_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__) +# if defined(__ILEC400__) +# 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 +# endif + +#elif defined(__MVS__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_ILP32) +# elif defined(_LP64) +# endif +# 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 +# elif defined(_LP64) +# 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 +# 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(__370__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_ILP32) +# elif defined(_LP64) +# endif +# 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 +# elif defined(_LP64) +# 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 +# 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 + +/* ===================================== */ +/* KEEP MSVC THE PENULTIMATE ENTRY */ +/* ===================================== */ + +#elif defined(_MSC_VER) +# if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) +# 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 +# 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 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(__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_WS2TCPIP_H is defined above when inclusion of header file */ +/* ws2tcpip.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_WS2TCPIP_H +# include +# include +# include +#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(__SALFORDC__) || 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 __CURL_OFF_T_C_HLPR2(x) x +# define __CURL_OFF_T_C_HLPR1(x) __CURL_OFF_T_C_HLPR2(x) +# define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \ + __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \ + __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) +#else +# ifdef CURL_ISOCPP +# define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix +# else +# define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix +# endif +# define __CURL_OFF_T_C_HLPR1(Val,Suffix) __CURL_OFF_T_C_HLPR2(Val,Suffix) +# define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) +#endif + +#endif /* __CURL_SYSTEM_H */ diff --git a/compat/curl-win-x86_64/include/curl/typecheck-gcc.h b/compat/curl-win-x86_64/include/curl/typecheck-gcc.h new file mode 100644 index 0000000..2d1de4d --- /dev/null +++ b/compat/curl-win-x86_64/include/curl/typecheck-gcc.h @@ -0,0 +1,694 @@ +#ifndef __CURL_TYPECHECK_GCC_H +#define __CURL_TYPECHECK_GCC_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2019, 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.haxx.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. + * + ***************************************************************************/ + +/* wraps curl_easy_setopt() with typechecking */ + +/* To add a new kind of warning, add an + * if(_curl_is_sometype_option(_curl_opt)) + * if(!_curl_is_sometype(value)) + * _curl_easy_setopt_err_sometype(); + * block and define _curl_is_sometype_option, _curl_is_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'll just + * need to extend the appropriate _curl_*_option macro + */ +#define curl_easy_setopt(handle, option, value) \ +__extension__ ({ \ + __typeof__(option) _curl_opt = option; \ + if(__builtin_constant_p(_curl_opt)) { \ + if(_curl_is_long_option(_curl_opt)) \ + if(!_curl_is_long(value)) \ + _curl_easy_setopt_err_long(); \ + if(_curl_is_off_t_option(_curl_opt)) \ + if(!_curl_is_off_t(value)) \ + _curl_easy_setopt_err_curl_off_t(); \ + if(_curl_is_string_option(_curl_opt)) \ + if(!_curl_is_string(value)) \ + _curl_easy_setopt_err_string(); \ + if(_curl_is_write_cb_option(_curl_opt)) \ + if(!_curl_is_write_cb(value)) \ + _curl_easy_setopt_err_write_callback(); \ + if((_curl_opt) == CURLOPT_RESOLVER_START_FUNCTION) \ + if(!_curl_is_resolver_start_callback(value)) \ + _curl_easy_setopt_err_resolver_start_callback(); \ + if((_curl_opt) == CURLOPT_READFUNCTION) \ + if(!_curl_is_read_cb(value)) \ + _curl_easy_setopt_err_read_cb(); \ + if((_curl_opt) == CURLOPT_IOCTLFUNCTION) \ + if(!_curl_is_ioctl_cb(value)) \ + _curl_easy_setopt_err_ioctl_cb(); \ + if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION) \ + if(!_curl_is_sockopt_cb(value)) \ + _curl_easy_setopt_err_sockopt_cb(); \ + if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION) \ + if(!_curl_is_opensocket_cb(value)) \ + _curl_easy_setopt_err_opensocket_cb(); \ + if((_curl_opt) == CURLOPT_PROGRESSFUNCTION) \ + if(!_curl_is_progress_cb(value)) \ + _curl_easy_setopt_err_progress_cb(); \ + if((_curl_opt) == CURLOPT_DEBUGFUNCTION) \ + if(!_curl_is_debug_cb(value)) \ + _curl_easy_setopt_err_debug_cb(); \ + if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION) \ + if(!_curl_is_ssl_ctx_cb(value)) \ + _curl_easy_setopt_err_ssl_ctx_cb(); \ + if(_curl_is_conv_cb_option(_curl_opt)) \ + if(!_curl_is_conv_cb(value)) \ + _curl_easy_setopt_err_conv_cb(); \ + if((_curl_opt) == CURLOPT_SEEKFUNCTION) \ + if(!_curl_is_seek_cb(value)) \ + _curl_easy_setopt_err_seek_cb(); \ + if(_curl_is_cb_data_option(_curl_opt)) \ + if(!_curl_is_cb_data(value)) \ + _curl_easy_setopt_err_cb_data(); \ + if((_curl_opt) == CURLOPT_ERRORBUFFER) \ + if(!_curl_is_error_buffer(value)) \ + _curl_easy_setopt_err_error_buffer(); \ + if((_curl_opt) == CURLOPT_STDERR) \ + if(!_curl_is_FILE(value)) \ + _curl_easy_setopt_err_FILE(); \ + if(_curl_is_postfields_option(_curl_opt)) \ + if(!_curl_is_postfields(value)) \ + _curl_easy_setopt_err_postfields(); \ + if((_curl_opt) == CURLOPT_HTTPPOST) \ + if(!_curl_is_arr((value), struct curl_httppost)) \ + _curl_easy_setopt_err_curl_httpost(); \ + if((_curl_opt) == CURLOPT_MIMEPOST) \ + if(!_curl_is_ptr((value), curl_mime)) \ + _curl_easy_setopt_err_curl_mimepost(); \ + if(_curl_is_slist_option(_curl_opt)) \ + if(!_curl_is_arr((value), struct curl_slist)) \ + _curl_easy_setopt_err_curl_slist(); \ + if((_curl_opt) == CURLOPT_SHARE) \ + if(!_curl_is_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__ ({ \ + __typeof__(info) _curl_info = info; \ + if(__builtin_constant_p(_curl_info)) { \ + if(_curl_is_string_info(_curl_info)) \ + if(!_curl_is_arr((arg), char *)) \ + _curl_easy_getinfo_err_string(); \ + if(_curl_is_long_info(_curl_info)) \ + if(!_curl_is_arr((arg), long)) \ + _curl_easy_getinfo_err_long(); \ + if(_curl_is_double_info(_curl_info)) \ + if(!_curl_is_arr((arg), double)) \ + _curl_easy_getinfo_err_double(); \ + if(_curl_is_slist_info(_curl_info)) \ + if(!_curl_is_arr((arg), struct curl_slist *)) \ + _curl_easy_getinfo_err_curl_slist(); \ + if(_curl_is_tlssessioninfo_info(_curl_info)) \ + if(!_curl_is_arr((arg), struct curl_tlssessioninfo *)) \ + _curl_easy_getinfo_err_curl_tlssesssioninfo(); \ + if(_curl_is_certinfo_info(_curl_info)) \ + if(!_curl_is_arr((arg), struct curl_certinfo *)) \ + _curl_easy_getinfo_err_curl_certinfo(); \ + if(_curl_is_socket_info(_curl_info)) \ + if(!_curl_is_arr((arg), curl_socket_t)) \ + _curl_easy_getinfo_err_curl_socket(); \ + if(_curl_is_off_t_info(_curl_info)) \ + if(!_curl_is_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 _CURL_WARNING(id, message) \ + static void __attribute__((__warning__(message))) \ + __attribute__((__unused__)) __attribute__((__noinline__)) \ + id(void) { __asm__(""); } + +_CURL_WARNING(_curl_easy_setopt_err_long, + "curl_easy_setopt expects a long argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_off_t, + "curl_easy_setopt expects a curl_off_t argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_string, + "curl_easy_setopt expects a " + "string ('char *' or char[]) argument for this option" + ) +_CURL_WARNING(_curl_easy_setopt_err_write_callback, + "curl_easy_setopt expects a curl_write_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_resolver_start_callback, + "curl_easy_setopt expects a " + "curl_resolver_start_callback argument for this option" + ) +_CURL_WARNING(_curl_easy_setopt_err_read_cb, + "curl_easy_setopt expects a curl_read_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_ioctl_cb, + "curl_easy_setopt expects a curl_ioctl_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_sockopt_cb, + "curl_easy_setopt expects a curl_sockopt_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_opensocket_cb, + "curl_easy_setopt expects a " + "curl_opensocket_callback argument for this option" + ) +_CURL_WARNING(_curl_easy_setopt_err_progress_cb, + "curl_easy_setopt expects a curl_progress_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_debug_cb, + "curl_easy_setopt expects a curl_debug_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_ssl_ctx_cb, + "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_conv_cb, + "curl_easy_setopt expects a curl_conv_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_seek_cb, + "curl_easy_setopt expects a curl_seek_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_cb_data, + "curl_easy_setopt expects a " + "private data pointer as argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_error_buffer, + "curl_easy_setopt expects a " + "char buffer of CURL_ERROR_SIZE as argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_FILE, + "curl_easy_setopt expects a 'FILE *' argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_postfields, + "curl_easy_setopt expects a 'void *' or 'char *' argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_httpost, + "curl_easy_setopt expects a 'struct curl_httppost *' " + "argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_mimepost, + "curl_easy_setopt expects a 'curl_mime *' " + "argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_slist, + "curl_easy_setopt expects a 'struct curl_slist *' argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_CURLSH, + "curl_easy_setopt expects a CURLSH* argument for this option") + +_CURL_WARNING(_curl_easy_getinfo_err_string, + "curl_easy_getinfo expects a pointer to 'char *' for this info") +_CURL_WARNING(_curl_easy_getinfo_err_long, + "curl_easy_getinfo expects a pointer to long for this info") +_CURL_WARNING(_curl_easy_getinfo_err_double, + "curl_easy_getinfo expects a pointer to double for this info") +_CURL_WARNING(_curl_easy_getinfo_err_curl_slist, + "curl_easy_getinfo expects a pointer to 'struct curl_slist *' for this info") +_CURL_WARNING(_curl_easy_getinfo_err_curl_tlssesssioninfo, + "curl_easy_getinfo expects a pointer to " + "'struct curl_tlssessioninfo *' for this info") +_CURL_WARNING(_curl_easy_getinfo_err_curl_certinfo, + "curl_easy_getinfo expects a pointer to " + "'struct curl_certinfo *' for this info") +_CURL_WARNING(_curl_easy_getinfo_err_curl_socket, + "curl_easy_getinfo expects a pointer to curl_socket_t for this info") +_CURL_WARNING(_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 don't + * have to do anything + */ + +/* evaluates to true if option takes a long argument */ +#define _curl_is_long_option(option) \ + (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT) + +#define _curl_is_off_t_option(option) \ + ((option) > CURLOPTTYPE_OFF_T) + +/* evaluates to true if option takes a char* argument */ +#define _curl_is_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_EGDSOCKET || \ + (option) == CURLOPT_FTPPORT || \ + (option) == CURLOPT_FTP_ACCOUNT || \ + (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ + (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_PROXY || \ + (option) == CURLOPT_PROXYPASSWORD || \ + (option) == CURLOPT_PROXYUSERNAME || \ + (option) == CURLOPT_PROXYUSERPWD || \ + (option) == CURLOPT_PROXY_CAINFO || \ + (option) == CURLOPT_PROXY_CAPATH || \ + (option) == CURLOPT_PROXY_CRLFILE || \ + (option) == CURLOPT_PROXY_KEYPASSWD || \ + (option) == CURLOPT_PROXY_PINNEDPUBLICKEY || \ + (option) == CURLOPT_PROXY_SERVICE_NAME || \ + (option) == CURLOPT_PROXY_SSLCERT || \ + (option) == CURLOPT_PROXY_SSLCERTTYPE || \ + (option) == CURLOPT_PROXY_SSLKEY || \ + (option) == CURLOPT_PROXY_SSLKEYTYPE || \ + (option) == CURLOPT_PROXY_SSL_CIPHER_LIST || \ + (option) == CURLOPT_PROXY_TLSAUTH_PASSWORD || \ + (option) == CURLOPT_PROXY_TLSAUTH_USERNAME || \ + (option) == CURLOPT_PROXY_TLSAUTH_TYPE || \ + (option) == CURLOPT_RANDOM_FILE || \ + (option) == CURLOPT_RANGE || \ + (option) == CURLOPT_REFERER || \ + (option) == CURLOPT_RTSP_SESSION_ID || \ + (option) == CURLOPT_RTSP_STREAM_URI || \ + (option) == CURLOPT_RTSP_TRANSPORT || \ + (option) == CURLOPT_SERVICE_NAME || \ + (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ + (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_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_USERPWD || \ + (option) == CURLOPT_XOAUTH2_BEARER || \ + 0) + +/* evaluates to true if option takes a curl_write_callback argument */ +#define _curl_is_write_cb_option(option) \ + ((option) == CURLOPT_HEADERFUNCTION || \ + (option) == CURLOPT_WRITEFUNCTION) + +/* evaluates to true if option takes a curl_conv_callback argument */ +#define _curl_is_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 _curl_is_cb_data_option(option) \ + ((option) == CURLOPT_CHUNK_DATA || \ + (option) == CURLOPT_CLOSESOCKETDATA || \ + (option) == CURLOPT_DEBUGDATA || \ + (option) == CURLOPT_FNMATCH_DATA || \ + (option) == CURLOPT_HEADERDATA || \ + (option) == CURLOPT_INTERLEAVEDATA || \ + (option) == CURLOPT_IOCTLDATA || \ + (option) == CURLOPT_OPENSOCKETDATA || \ + (option) == CURLOPT_PRIVATE || \ + (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_CURLU || \ + 0) + +/* evaluates to true if option takes a POST data argument (void* or char*) */ +#define _curl_is_postfields_option(option) \ + ((option) == CURLOPT_POSTFIELDS || \ + (option) == CURLOPT_COPYPOSTFIELDS || \ + 0) + +/* evaluates to true if option takes a struct curl_slist * argument */ +#define _curl_is_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 || \ + 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 _curl_is_string_info(info) \ + (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG) + +/* evaluates to true if info expects a pointer to long argument */ +#define _curl_is_long_info(info) \ + (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE) + +/* evaluates to true if info expects a pointer to double argument */ +#define _curl_is_double_info(info) \ + (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST) + +/* true if info expects a pointer to struct curl_slist * argument */ +#define _curl_is_slist_info(info) \ + (((info) == CURLINFO_SSL_ENGINES) || ((info) == CURLINFO_COOKIELIST)) + +/* true if info expects a pointer to struct curl_tlssessioninfo * argument */ +#define _curl_is_tlssessioninfo_info(info) \ + (((info) == CURLINFO_TLS_SSL_PTR) || ((info) == CURLINFO_TLS_SESSION)) + +/* true if info expects a pointer to struct curl_certinfo * argument */ +#define _curl_is_certinfo_info(info) ((info) == CURLINFO_CERTINFO) + +/* true if info expects a pointer to struct curl_socket_t argument */ +#define _curl_is_socket_info(info) \ + (CURLINFO_SOCKET < (info) && (info) < CURLINFO_OFF_T) + +/* true if info expects a pointer to curl_off_t argument */ +#define _curl_is_off_t_info(info) \ + (CURLINFO_OFF_T < (info)) + + +/* typecheck helpers -- check whether given expression has requested type*/ + +/* For pointers, you can use the _curl_is_ptr/_curl_is_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 _curl_is_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 _curl_is_NULL(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL))) + +/* evaluates to true if expr is type*, const type* or NULL */ +#define _curl_is_ptr(expr, type) \ + (_curl_is_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 _curl_is_arr(expr, type) \ + (_curl_is_ptr((expr), type) || \ + __builtin_types_compatible_p(__typeof__(expr), type [])) + +/* evaluates to true if expr is a string */ +#define _curl_is_string(expr) \ + (_curl_is_arr((expr), char) || \ + _curl_is_arr((expr), signed char) || \ + _curl_is_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 _curl_is_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 _curl_is_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 _curl_is_error_buffer(expr) \ + (_curl_is_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 _curl_is_cb_data(expr) \ + (_curl_is_ptr((expr), void) || \ + _curl_is_ptr((expr), FILE)) +#else /* be less strict */ +#define _curl_is_cb_data(expr) \ + _curl_is_any_ptr(expr) +#endif + +/* evaluates to true if expr is of type FILE* */ +#define _curl_is_FILE(expr) \ + (_curl_is_NULL(expr) || \ + (__builtin_types_compatible_p(__typeof__(expr), FILE *))) + +/* evaluates to true if expr can be passed as POST data (void* or char*) */ +#define _curl_is_postfields(expr) \ + (_curl_is_ptr((expr), void) || \ + _curl_is_arr((expr), char) || \ + _curl_is_arr((expr), unsigned char)) + +/* helper: __builtin_types_compatible_p distinguishes between functions and + * function pointers, hide it */ +#define _curl_callback_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 _curl_is_resolver_start_callback(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_resolver_start_callback)) + +/* evaluates to true if expr is of type curl_read_callback or "similar" */ +#define _curl_is_read_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), __typeof__(fread) *) || \ + _curl_callback_compatible((expr), curl_read_callback) || \ + _curl_callback_compatible((expr), _curl_read_callback1) || \ + _curl_callback_compatible((expr), _curl_read_callback2) || \ + _curl_callback_compatible((expr), _curl_read_callback3) || \ + _curl_callback_compatible((expr), _curl_read_callback4) || \ + _curl_callback_compatible((expr), _curl_read_callback5) || \ + _curl_callback_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 _curl_is_write_cb(expr) \ + (_curl_is_read_cb(expr) || \ + _curl_callback_compatible((expr), __typeof__(fwrite) *) || \ + _curl_callback_compatible((expr), curl_write_callback) || \ + _curl_callback_compatible((expr), _curl_write_callback1) || \ + _curl_callback_compatible((expr), _curl_write_callback2) || \ + _curl_callback_compatible((expr), _curl_write_callback3) || \ + _curl_callback_compatible((expr), _curl_write_callback4) || \ + _curl_callback_compatible((expr), _curl_write_callback5) || \ + _curl_callback_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 _curl_is_ioctl_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_ioctl_callback) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback1) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback2) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback3) || \ + _curl_callback_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 _curl_is_sockopt_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_sockopt_callback) || \ + _curl_callback_compatible((expr), _curl_sockopt_callback1) || \ + _curl_callback_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 _curl_is_opensocket_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_opensocket_callback) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback1) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback2) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback3) || \ + _curl_callback_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 _curl_is_progress_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_progress_callback) || \ + _curl_callback_compatible((expr), _curl_progress_callback1) || \ + _curl_callback_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 _curl_is_debug_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_debug_callback) || \ + _curl_callback_compatible((expr), _curl_debug_callback1) || \ + _curl_callback_compatible((expr), _curl_debug_callback2) || \ + _curl_callback_compatible((expr), _curl_debug_callback3) || \ + _curl_callback_compatible((expr), _curl_debug_callback4) || \ + _curl_callback_compatible((expr), _curl_debug_callback5) || \ + _curl_callback_compatible((expr), _curl_debug_callback6) || \ + _curl_callback_compatible((expr), _curl_debug_callback7) || \ + _curl_callback_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 _curl_is_ssl_ctx_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_ssl_ctx_callback) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback1) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback2) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback3) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback4) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback5) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback6) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback7) || \ + _curl_callback_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're 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 _curl_is_conv_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_conv_callback) || \ + _curl_callback_compatible((expr), _curl_conv_callback1) || \ + _curl_callback_compatible((expr), _curl_conv_callback2) || \ + _curl_callback_compatible((expr), _curl_conv_callback3) || \ + _curl_callback_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 _curl_is_seek_cb(expr) \ + (_curl_is_NULL(expr) || \ + _curl_callback_compatible((expr), curl_seek_callback) || \ + _curl_callback_compatible((expr), _curl_seek_callback1) || \ + _curl_callback_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 /* __CURL_TYPECHECK_GCC_H */ diff --git a/compat/curl-win-x86_64/include/curl/urlapi.h b/compat/curl-win-x86_64/include/curl/urlapi.h new file mode 100644 index 0000000..58e89d8 --- /dev/null +++ b/compat/curl-win-x86_64/include/curl/urlapi.h @@ -0,0 +1,123 @@ +#ifndef __CURL_URLAPI_H +#define __CURL_URLAPI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 2018 - 2019, 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.haxx.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. + * + ***************************************************************************/ + +#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 */ +} 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 */ + +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(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(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); + + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/compat/curl-win-x86_64/lib/libcurl.a b/compat/curl-win-x86_64/lib/libcurl.a new file mode 100644 index 0000000000000000000000000000000000000000..37d9a8a99eb7d2b0e81437b2c0f8109b2c774a36 GIT binary patch literal 639706 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 CdD}l4EGYHF!uw)9Yrb3&w=6kmlWnX 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, 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.haxx.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. +# +########################################################################### + +# This should most probably benefit from getting a "Requires:" field added +# dynamically by configure. +# +prefix=compat/curl-win-x86_64 +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include +supported_protocols="DICT FILE FTP GOPHER HTTP IMAP POP3 SMTP TELNET TFTP" +supported_features="IPv6 libz AsynchDNS" + +Name: libcurl +URL: https://curl.haxx.se/ +Description: Library to transfer files with ftp, http, etc. +Version: 7.65.1 +Libs: -L${libdir} -lcurl +Libs.private: -lz -lws2_32 +Cflags: -I${includedir} diff --git a/cpuminer-config.h b/cpuminer-config.h deleted file mode 100644 index 34597d4..0000000 --- a/cpuminer-config.h +++ /dev/null @@ -1,191 +0,0 @@ -/* cpuminer-config.h. Generated from cpuminer-config.h.in by configure. */ -/* cpuminer-config.h.in. Generated from configure.ac by autoheader. */ - -/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP - systems. This function is required for `alloca.c' support on those systems. - */ -/* #undef CRAY_STACKSEG_END */ - -/* Define to 1 if using `alloca.c'. */ -/* #undef C_ALLOCA */ - -/* Define to 1 if you have `alloca', as a function or macro. */ -#define HAVE_ALLOCA 1 - -/* Define to 1 if you have and it should be used (not on Ultrix). - */ -/* #undef HAVE_ALLOCA_H */ - -/* Define to 1 if you have the declaration of `be32dec', and to 0 if you - don't. */ -#define HAVE_DECL_BE32DEC 0 - -/* Define to 1 if you have the declaration of `be32enc', and to 0 if you - don't. */ -#define HAVE_DECL_BE32ENC 0 - -/* Define to 1 if you have the declaration of `le32dec', and to 0 if you - don't. */ -#define HAVE_DECL_LE32DEC 0 - -/* Define to 1 if you have the declaration of `le32enc', and to 0 if you - don't. */ -#define HAVE_DECL_LE32ENC 0 - -/* Define to 1 if you have the `getopt_long' function. */ -#define HAVE_GETOPT_LONG 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_INTTYPES_H 1 - -/* Define to 1 if you have a functional curl library. */ -#define HAVE_LIBCURL 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_MEMORY_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STDINT_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STDLIB_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STRINGS_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STRING_H 1 - -/* Define to 1 if you have the header file. */ -/* #undef HAVE_SYSLOG_H */ - -/* Define to 1 if you have the header file. */ -/* #undef HAVE_SYS_ENDIAN_H */ - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_PARAM_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_STAT_H 1 - -/* Define to 1 if you have the header file. */ -/* #undef HAVE_SYS_SYSCTL_H */ - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_TYPES_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_UNISTD_H 1 - -/* Defined if libcurl supports AsynchDNS */ -#define LIBCURL_FEATURE_ASYNCHDNS 1 - -/* Defined if libcurl supports IDN */ -/* #undef LIBCURL_FEATURE_IDN */ - -/* Defined if libcurl supports IPv6 */ -#define LIBCURL_FEATURE_IPV6 1 - -/* Defined if libcurl supports KRB4 */ -/* #undef LIBCURL_FEATURE_KRB4 */ - -/* Defined if libcurl supports libz */ -#define LIBCURL_FEATURE_LIBZ 1 - -/* Defined if libcurl supports NTLM */ -#define LIBCURL_FEATURE_NTLM 1 - -/* Defined if libcurl supports SSL */ -#define LIBCURL_FEATURE_SSL 1 - -/* Defined if libcurl supports SSPI */ -/* #undef LIBCURL_FEATURE_SSPI */ - -/* Defined if libcurl supports DICT */ -#define LIBCURL_PROTOCOL_DICT 1 - -/* Defined if libcurl supports FILE */ -#define LIBCURL_PROTOCOL_FILE 1 - -/* Defined if libcurl supports FTP */ -#define LIBCURL_PROTOCOL_FTP 1 - -/* Defined if libcurl supports FTPS */ -#define LIBCURL_PROTOCOL_FTPS 1 - -/* Defined if libcurl supports HTTP */ -#define LIBCURL_PROTOCOL_HTTP 1 - -/* Defined if libcurl supports HTTPS */ -#define LIBCURL_PROTOCOL_HTTPS 1 - -/* Defined if libcurl supports IMAP */ -#define LIBCURL_PROTOCOL_IMAP 1 - -/* Defined if libcurl supports LDAP */ -#define LIBCURL_PROTOCOL_LDAP 1 - -/* Defined if libcurl supports POP3 */ -#define LIBCURL_PROTOCOL_POP3 1 - -/* Defined if libcurl supports RTSP */ -#define LIBCURL_PROTOCOL_RTSP 1 - -/* Defined if libcurl supports SMTP */ -#define LIBCURL_PROTOCOL_SMTP 1 - -/* Defined if libcurl supports TELNET */ -#define LIBCURL_PROTOCOL_TELNET 1 - -/* Defined if libcurl supports TFTP */ -#define LIBCURL_PROTOCOL_TFTP 1 - -/* Name of package */ -#define PACKAGE "cpuminer" - -/* Define to the address where bug reports for this package should be sent. */ -#define PACKAGE_BUGREPORT "" - -/* Define to the full name of this package. */ -#define PACKAGE_NAME "cpuminer" - -/* Define to the full name and version of this package. */ -#define PACKAGE_STRING "cpuminer 2.3.2" - -/* Define to the one symbol short name of this package. */ -#define PACKAGE_TARNAME "cpuminer" - -/* Define to the home page for this package. */ -#define PACKAGE_URL "" - -/* Define to the version of this package. */ -#define PACKAGE_VERSION "2.3.2" - -/* If using the C implementation of alloca, define if you know the - direction of stack growth for your system; otherwise it will be - automatically deduced at runtime. - STACK_DIRECTION > 0 => grows toward higher addresses - STACK_DIRECTION < 0 => grows toward lower addresses - STACK_DIRECTION = 0 => direction of growth unknown */ -/* #undef STACK_DIRECTION */ - -/* Define to 1 if you have the ANSI C header files. */ -#define STDC_HEADERS 1 - -/* Define to 1 if AVX assembly is available. */ -#define USE_AVX 1 - -/* Define to 1 if AVX2 assembly is available. */ -#define USE_AVX2 1 - -/* Define to 1 if XOP assembly is available. */ -#define USE_XOP 1 - -/* Version number of package */ -#define VERSION "2.3.2" - -/* Define curl_free() as free() if our version of curl lacks curl_free. */ -/* #undef curl_free */ - -/* Define to `unsigned int' if does not define. */ -/* #undef size_t */ diff --git a/gost.c b/gost.c index 327d8ff..f686332 100644 --- a/gost.c +++ b/gost.c @@ -52,7 +52,7 @@ extern "C"{ //-------------------------------------------------------------------------------------------- // -// stribog implementation +// stribog implementation // //-------------------------------------------------------------------------------------------- @@ -938,7 +938,7 @@ void F(unsigned char *state) { uint64_t return_state[8]; FS (state, return_state); - memcpy(state, return_state, 64); + memcpy(state, return_state, 64); } #define KeySchedule(tmp,K1,i) AddXor512(K1,C[i],tmp); FS((const unsigned char *)tmp,K1); @@ -951,53 +951,53 @@ void E(const unsigned char *K,const unsigned char *m, unsigned char *state) memcpy (K1, K, 64); AddXor512(m,K1,state); - KeySchedule(state1,K1,0); + KeySchedule(state1,K1,0); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,1); + KeySchedule(state1,K1,1); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,2); + KeySchedule(state1,K1,2); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,3); + KeySchedule(state1,K1,3); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,4); + KeySchedule(state1,K1,4); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,5); + KeySchedule(state1,K1,5); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,6); + KeySchedule(state1,K1,6); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,7); + KeySchedule(state1,K1,7); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,8); + KeySchedule(state1,K1,8); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,9); + KeySchedule(state1,K1,9); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,10); + KeySchedule(state1,K1,10); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); - KeySchedule(state1,K1,11); + KeySchedule(state1,K1,11); FS(state, state1); - AddXor512(state1,K1,state); + AddXor512(state1,K1,state); #else int i = 0; uint64_t state1[8], K1[8]; @@ -1279,14 +1279,13 @@ int scanhash_gostd(int thr_id, uint32_t *pdata, const uint32_t *ptarget, g_0((unsigned char *)hash, (unsigned char *)Sigma); // result is first 32 bytes of hash - if (swab32(hash[0]) <= Htarg) { if (!Htarg && swab32(hash[1]) > ptarget[6]) // if difficulty >= 1 continue; pdata[19] = swab32 (block2[15]); *hashes_done = n - first_nonce + 1; - + // uncomment following for verification /*uint32_t data[20] __attribute__((aligned(128))); uint32_t hash1[8] __attribute__((aligned(32))); @@ -1296,7 +1295,7 @@ int scanhash_gostd(int thr_id, uint32_t *pdata, const uint32_t *ptarget, sph_gost256 (hash1, digest, 64); if (hash[0] != hash1[0]) printf("verification failed\n");*/ - + return 1; } } while (n < max_nonce && !work_restart[thr_id].restart); diff --git a/stamp-h1 b/stamp-h1 deleted file mode 100644 index f8179e5..0000000 --- a/stamp-h1 +++ /dev/null @@ -1 +0,0 @@ -timestamp for cpuminer-config.h