From 1435e78454965deb2896b980bd15b33413717350 Mon Sep 17 00:00:00 2001 From: hairball Date: Sat, 8 Feb 2014 17:33:56 +0000 Subject: [PATCH] Upgrade from libcurl 7.15.5 (2006-08-07) to 7.35.0 (2014-01-29) Note: This uses the generic curlbuild.h because it is used by multiple platforms. A system curl would have a configure generated one. The libraries for win32 and win64 were cross compiled with these options: --disable-shared --enable-static --disable-ares --enable-http \ --enable-ftp --disable-ldap --disable-ldaps --disable-rtsp \ --disable-dict --disable-file --disable-telnet --disable-tftp \ --disable-pop3 --disable-imap --disable-smtp --disable-gopher \ --enable-ipv6 --without-ssl \ --disable-manual --disable-libcurl-option This effectively enables only HTTP and FTP protocol support. --- code/client/cl_curl.h | 2 +- code/{libcurl => libcurl-7.35.0}/curl/curl.h | 1309 +++++++++++++---- code/libcurl-7.35.0/curl/curlbuild.h | 585 ++++++++ code/libcurl-7.35.0/curl/curlrules.h | 262 ++++ .../curl/curlver.h | 25 +- code/{libcurl => libcurl-7.35.0}/curl/easy.h | 29 +- .../curl/mprintf.h | 29 +- code/{libcurl => libcurl-7.35.0}/curl/multi.h | 141 +- .../curl/stdcheaders.h | 15 +- code/libcurl-7.35.0/curl/typecheck-gcc.h | 610 ++++++++ code/libcurl/curl/types.h | 1 - code/libs/win32/libcurl.a | Bin 253484 -> 345004 bytes code/libs/win64/libcurl.a | Bin 366218 -> 369070 bytes 13 files changed, 2652 insertions(+), 356 deletions(-) rename code/{libcurl => libcurl-7.35.0}/curl/curl.h (53%) create mode 100644 code/libcurl-7.35.0/curl/curlbuild.h create mode 100644 code/libcurl-7.35.0/curl/curlrules.h rename code/{libcurl => libcurl-7.35.0}/curl/curlver.h (75%) rename code/{libcurl => libcurl-7.35.0}/curl/easy.h (76%) rename code/{libcurl => libcurl-7.35.0}/curl/mprintf.h (77%) rename code/{libcurl => libcurl-7.35.0}/curl/multi.h (75%) rename code/{libcurl => libcurl-7.35.0}/curl/stdcheaders.h (74%) create mode 100644 code/libcurl-7.35.0/curl/typecheck-gcc.h delete mode 100644 code/libcurl/curl/types.h diff --git a/code/client/cl_curl.h b/code/client/cl_curl.h index d1d08b4f..c91bcf82 100644 --- a/code/client/cl_curl.h +++ b/code/client/cl_curl.h @@ -28,7 +28,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #include "../qcommon/qcommon.h" #ifdef USE_LOCAL_HEADERS - #include "../libcurl/curl/curl.h" + #include "../libcurl-7.35.0/curl/curl.h" #else #include #endif diff --git a/code/libcurl/curl/curl.h b/code/libcurl-7.35.0/curl/curl.h similarity index 53% rename from code/libcurl/curl/curl.h rename to code/libcurl-7.35.0/curl/curl.h index a0a04148..aafaeed2 100644 --- a/code/libcurl/curl/curl.h +++ b/code/libcurl-7.35.0/curl/curl.h @@ -7,7 +7,7 @@ * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * - * Copyright (C) 1998 - 2006, Daniel Stenberg, , et al. + * Copyright (C) 1998 - 2013, 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 @@ -20,118 +20,107 @@ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * - * $Id: curl.h,v 1.304 2006-08-04 16:08:41 giva Exp $ ***************************************************************************/ -/* If you have problems, all libcurl docs and details are found here: - http://curl.haxx.se/libcurl/ -*/ +/* + * If you have libcurl problems, all docs and details are found here: + * http://curl.haxx.se/libcurl/ + * + * curl-library mailing list subscription and unsubscription web interface: + * http://cool.haxx.se/mailman/listinfo/curl-library/ + */ -#include "curlver.h" /* the libcurl version defines */ +#include "curlver.h" /* libcurl version defines */ +#include "curlbuild.h" /* libcurl build definitions */ +#include "curlrules.h" /* libcurl rules enforcement */ + +/* + * Define WIN32 when build target is Win32 API + */ + +#if (defined(_WIN32) || defined(__WIN32__)) && \ + !defined(WIN32) && !defined(__SYMBIAN32__) +#define WIN32 +#endif #include #include -/* The include stuff here below is mainly for time_t! */ -#ifdef vms -# include -# include -#else -# include -# include -#endif /* defined (vms) */ +#if defined(__FreeBSD__) && (__FreeBSD__ >= 2) +/* Needed for __FreeBSD_version symbol definition */ +#include +#endif -typedef void CURL; +/* 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__)) +/* 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(__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 #ifdef __cplusplus extern "C" { #endif -/* - * Decorate exportable functions for Win32 DLL linking. - * This avoids using a .def file for building libcurl.dll. - */ -#if (defined(WIN32) || defined(_WIN32)) && !defined(CURL_STATICLIB) -#if defined(BUILDING_LIBCURL) -#define CURL_EXTERN __declspec(dllexport) -#else -#define CURL_EXTERN __declspec(dllimport) -#endif -#else - -#ifdef CURL_HIDDEN_SYMBOLS -/* - * This definition is used to make external definitions visibile in the - * shared library when symbols are hidden by default. It makes no - * difference when compiling applications whether this is set or not, - * only when compiling the library. - */ -#define CURL_EXTERN CURL_EXTERN_SYMBOL -#else -#define CURL_EXTERN -#endif -#endif +typedef void CURL; /* - * We want the typedef curl_off_t setup for large file support on all - * platforms. We also provide a CURL_FORMAT_OFF_T define to use in *printf - * format strings when outputting a variable of type curl_off_t. - * - * Note: "pocc -Ze" is MSVC compatibily mode and this sets _MSC_VER! + * libcurl external API function linkage decorations. */ -#if (defined(_MSC_VER) && !defined(__POCC__)) || (defined(__LCC__) && defined(WIN32)) -/* MSVC */ -#ifdef _WIN32_WCE - typedef long curl_off_t; -#define CURL_FORMAT_OFF_T "%ld" +#ifdef CURL_STATICLIB +# define CURL_EXTERN +#elif defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__) +# 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 - typedef signed __int64 curl_off_t; -#define CURL_FORMAT_OFF_T "%I64d" -#endif -#else /* (_MSC_VER && !__POCC__) || (__LCC__ && WIN32) */ -#if (defined(__GNUC__) && defined(WIN32)) || defined(__WATCOMC__) -/* gcc on windows or Watcom */ - typedef long long curl_off_t; -#define CURL_FORMAT_OFF_T "%I64d" -#else /* GCC or Watcom on Windows */ - -/* "normal" POSIX approach, do note that this does not necessarily mean that - the type is >32 bits, see the SIZEOF_CURL_OFF_T define for that! */ - typedef off_t curl_off_t; - -/* Check a range of defines to detect large file support. On Linux it seems - none of these are set by default, so if you don't explicitly switches on - large file support, this define will be made for "small file" support. */ -#ifndef _FILE_OFFSET_BITS -#define _FILE_OFFSET_BITS 0 /* to prevent warnings in the check below */ -#define UNDEF_FILE_OFFSET_BITS -#endif -#ifndef FILESIZEBITS -#define FILESIZEBITS 0 /* to prevent warnings in the check below */ -#define UNDEF_FILESIZEBITS +# define CURL_EXTERN #endif -#if defined(_LARGE_FILES) || (_FILE_OFFSET_BITS > 32) || (FILESIZEBITS > 32) \ - || defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE) - /* For now, we assume at least one of these to be set for large files to - work! */ -#define CURL_FORMAT_OFF_T "%lld" -#else /* LARGE_FILE support */ -#define CURL_FORMAT_OFF_T "%ld" -#endif -#endif /* GCC or Watcom on Windows */ -#endif /* (_MSC_VER && !__POCC__) || (__LCC__ && WIN32) */ - -#ifdef UNDEF_FILE_OFFSET_BITS -/* this was defined above for our checks, undefine it again */ -#undef _FILE_OFFSET_BITS -#endif - -#ifdef UNDEF_FILESIZEBITS -/* this was defined above for our checks, undefine it again */ -#undef FILESIZEBITS +#ifndef curl_socket_typedef +/* socket typedef */ +#if defined(WIN32) && !defined(__LWIP_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 */ struct curl_httppost { struct curl_httppost *next; /* next entry in the list */ @@ -155,43 +144,206 @@ struct curl_httppost { do not free in formfree */ #define HTTPPOST_BUFFER (1<<4) /* upload file from buffer */ #define HTTPPOST_PTRBUFFER (1<<5) /* upload file from pointer contents */ +#define HTTPPOST_CALLBACK (1<<6) /* upload file contents by using the + regular read callback to get the data + and pass the given pointer as custom + pointer */ 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 */ }; +/* This is the CURLOPT_PROGRESSFUNCTION callback proto. 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 proto. It was introduced in + 7.32.0, it avoids floating point 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_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. */ + 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); + + +/* 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; + 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 + typedef size_t (*curl_read_callback)(char *buffer, size_t size, size_t nitems, void *instream); +typedef enum { + CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */ + CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */ + CURLSOCKTYPE_LAST /* never use */ +} curlsocktype; -#ifndef CURL_NO_OLDIES - /* not used since 7.10.8, will be removed in a future release */ -typedef int (*curl_passwd_callback)(void *clientp, - const char *prompt, - char *buffer, - int buflen); -#endif +/* 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 */ @@ -253,74 +405,79 @@ typedef enum { CURLE_UNSUPPORTED_PROTOCOL, /* 1 */ CURLE_FAILED_INIT, /* 2 */ CURLE_URL_MALFORMAT, /* 3 */ - CURLE_URL_MALFORMAT_USER, /* 4 - NOT USED */ + 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_FTP_WEIRD_SERVER_REPLY, /* 8 */ - CURLE_FTP_ACCESS_DENIED, /* 9 a service was denied by the FTP server + 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_USER_PASSWORD_INCORRECT, /* 10 - NOT USED */ + 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_WEIRD_USER_REPLY, /* 12 */ + 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_FTP_CANT_RECONNECT, /* 16 */ - CURLE_FTP_COULDNT_SET_BINARY, /* 17 */ + CURLE_OBSOLETE16, /* 16 - NOT USED */ + CURLE_FTP_COULDNT_SET_TYPE, /* 17 */ CURLE_PARTIAL_FILE, /* 18 */ CURLE_FTP_COULDNT_RETR_FILE, /* 19 */ - CURLE_FTP_WRITE_ERROR, /* 20 */ - CURLE_FTP_QUOTE_ERROR, /* 21 */ + CURLE_OBSOLETE20, /* 20 - NOT USED */ + CURLE_QUOTE_ERROR, /* 21 - quote command failure */ CURLE_HTTP_RETURNED_ERROR, /* 22 */ CURLE_WRITE_ERROR, /* 23 */ - CURLE_MALFORMAT_USER, /* 24 - NOT USED */ - CURLE_FTP_COULDNT_STOR_FILE, /* 25 - failed FTP upload */ - CURLE_READ_ERROR, /* 26 - could open/read from file */ + 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_TIMEOUTED, /* 28 - the timeout time was reached */ - CURLE_FTP_COULDNT_SET_ASCII, /* 29 - TYPE A failed */ + 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_FTP_COULDNT_GET_SIZE, /* 32 - the SIZE command failed */ - CURLE_HTTP_RANGE_ERROR, /* 33 - RANGE "command" didn't work */ + 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_LIBRARY_NOT_FOUND, /* 40 */ + CURLE_OBSOLETE40, /* 40 - NOT USED */ CURLE_FUNCTION_NOT_FOUND, /* 41 */ CURLE_ABORTED_BY_CALLBACK, /* 42 */ CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */ - CURLE_BAD_CALLING_ORDER, /* 44 - NOT USED */ + CURLE_OBSOLETE44, /* 44 - NOT USED */ CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */ - CURLE_BAD_PASSWORD_ENTERED, /* 46 - NOT USED */ + CURLE_OBSOLETE46, /* 46 - NOT USED */ CURLE_TOO_MANY_REDIRECTS , /* 47 - catch endless re-direct loops */ - CURLE_UNKNOWN_TELNET_OPTION, /* 48 - User specified an unknown option */ + CURLE_UNKNOWN_OPTION, /* 48 - User specified an unknown option */ CURLE_TELNET_OPTION_SYNTAX , /* 49 - Malformed telnet option */ - CURLE_OBSOLETE, /* 50 - NOT USED */ - CURLE_SSL_PEER_CERTIFICATE, /* 51 - peer's certificate wasn't ok */ + CURLE_OBSOLETE50, /* 50 - NOT USED */ + CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint + wasn't verified fine */ 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_SHARE_IN_USE, /* 57 - share is in use */ + 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_SSL_CACERT, /* 60 - problem with the CA cert (path?) */ - CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized transfer encoding */ + 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_FTP_SSL_FAILED, /* 64 - Requested FTP SSL level failed */ + 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 */ @@ -328,10 +485,10 @@ typedef enum { accepted and we failed to login */ CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */ CURLE_TFTP_PERM, /* 69 - permission problem on server */ - CURLE_TFTP_DISKFULL, /* 70 - out of disk space 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_TFTP_EXISTS, /* 73 - File already exists */ + 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 @@ -339,9 +496,91 @@ typedef enum { 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 */ CURL_LAST /* never use! */ } CURLcode; +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Previously obsoletes 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 + +/* 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 + +#endif /*!CURL_NO_OLDIES*/ + /* This prototype applies to all conversion callbacks */ typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length); @@ -350,52 +589,142 @@ typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */ OpenSSL SSL_CTX */ void *userptr); -/* Make a spelling correction for the operation timed-out define */ -#define CURLE_OPERATION_TIMEDOUT CURLE_OPERATION_TIMEOUTED - -#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all - the obsolete stuff removed! */ -/* backwards compatibility with older names */ -#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR -#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED -#endif - typedef enum { - CURLPROXY_HTTP = 0, - CURLPROXY_SOCKS4 = 4, - CURLPROXY_SOCKS5 = 5 -} curl_proxytype; + 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_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 */ -#define CURLAUTH_NONE 0 /* nothing */ -#define CURLAUTH_BASIC (1<<0) /* Basic (default) */ -#define CURLAUTH_DIGEST (1<<1) /* Digest */ -#define CURLAUTH_GSSNEGOTIATE (1<<2) /* GSS-Negotiate */ -#define CURLAUTH_NTLM (1<<3) /* NTLM */ -#define CURLAUTH_ANY ~0 /* all types set */ -#define CURLAUTH_ANYSAFE (~CURLAUTH_BASIC) +/* + * 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_GSSNEGOTIATE - HTTP GSS-Negotiate authentication + * 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_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 + */ -#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all - the obsolete stuff removed! */ -/* 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 +#define CURLAUTH_NONE ((unsigned long)0) +#define CURLAUTH_BASIC (((unsigned long)1)<<0) +#define CURLAUTH_DIGEST (((unsigned long)1)<<1) +#define CURLAUTH_GSSNEGOTIATE (((unsigned long)1)<<2) +#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_ONLY (((unsigned long)1)<<31) +#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE) +#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE)) -/* These are just to make older programs not break: */ -#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE -#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME -#endif +#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_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 -/* parameter for the CURLOPT_FTP_SSL option */ +enum curl_khtype { + CURLKHTYPE_UNKNOWN, + CURLKHTYPE_RSA1, + CURLKHTYPE_RSA, + CURLKHTYPE_DSS +}; + +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 { - CURLFTPSSL_NONE, /* do not attempt to use SSL */ - CURLFTPSSL_TRY, /* try using SSL, proceed anyway otherwise */ - CURLFTPSSL_CONTROL, /* SSL for the control connection or fail */ - CURLFTPSSL_ALL, /* SSL for all communication or fail */ - CURLFTPSSL_LAST /* not an option, never use */ -} curl_ftpssl; + 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) + +#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 { @@ -405,6 +734,17 @@ typedef enum { 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 */ @@ -414,6 +754,35 @@ typedef enum { CURLFTPMETHOD_LAST /* not an option, never use */ } curl_ftpmethod; +/* 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_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 @@ -427,25 +796,9 @@ typedef enum { #ifdef CINIT #undef CINIT #endif -/* - * Figure out if we can use the ## 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. We don't use configure-checks - * for these since we want these headers to remain generic and working for all - * platforms. - */ -#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ - defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \ - defined(__POCC__) || defined(__SALFORDC__) - /* 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 #ifdef CURL_ISOCPP -#define CINIT(name,type,number) CURLOPT_ ## name = CURLOPTTYPE_ ## type + number +#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 @@ -474,10 +827,10 @@ typedef enum { /* Name of proxy to use. */ CINIT(PROXY, OBJECTPOINT, 4), - /* "name:password" to use when fetching. */ + /* "user:password;options" to use when fetching. */ CINIT(USERPWD, OBJECTPOINT, 5), - /* "name:password" to use with proxy. */ + /* "user:password" to use with proxy. */ CINIT(PROXYUSERPWD, OBJECTPOINT, 6), /* Range to get, specified as an ASCII string. */ @@ -505,7 +858,7 @@ typedef enum { /* 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 succcessful. -1 means + * 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 @@ -514,10 +867,10 @@ typedef enum { */ CINIT(INFILESIZE, LONG, 14), - /* POST input fields. */ + /* POST static input fields. */ CINIT(POSTFIELDS, OBJECTPOINT, 15), - /* Set the referer page (needed by some CGIs) */ + /* Set the referrer page (needed by some CGIs) */ CINIT(REFERER, OBJECTPOINT, 16), /* Set the FTP PORT string (interface name, named or numerical IP address) @@ -534,7 +887,7 @@ typedef enum { */ /* Set the "low speed limit" */ - CINIT(LOW_SPEED_LIMIT, LONG , 19), + CINIT(LOW_SPEED_LIMIT, LONG, 19), /* Set the "low speed time" */ CINIT(LOW_SPEED_TIME, LONG, 20), @@ -553,16 +906,14 @@ typedef enum { /* This points to a linked list of headers, struct curl_slist kind */ CINIT(HTTPHEADER, OBJECTPOINT, 23), - /* This points to a linked list of post entries, struct HttpPost */ + /* 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, OBJECTPOINT, 25), - /* password for the SSL-private key, keep this for compatibility */ - CINIT(SSLCERTPASSWD, OBJECTPOINT, 26), - /* password for the SSL private key */ - CINIT(SSLKEYPASSWD, OBJECTPOINT, 26), + /* password for the SSL or SSH private key */ + CINIT(KEYPASSWD, OBJECTPOINT, 26), /* send TYPE parameter? */ CINIT(CRLF, LONG, 27), @@ -578,7 +929,7 @@ typedef enum { "cookie awareness" */ CINIT(COOKIEFILE, OBJECTPOINT, 31), - /* What version to specifly try to use. + /* What version to specifically try to use. See CURL_SSLVERSION defines below. */ CINIT(SSLVERSION, LONG, 32), @@ -605,9 +956,7 @@ typedef enum { /* send linked-list of post-transfer QUOTE commands */ CINIT(POSTQUOTE, OBJECTPOINT, 39), - /* Pass a pointer to string of the output using full variable-replacement - as described elsewhere. */ - CINIT(WRITEINFO, OBJECTPOINT, 40), + CINIT(WRITEINFO, OBJECTPOINT, 40), /* DEPRECATED, do not use! */ CINIT(VERBOSE, LONG, 41), /* talk a lot */ CINIT(HEADER, LONG, 42), /* throw the header out too */ @@ -616,9 +965,9 @@ typedef enum { CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 300 */ CINIT(UPLOAD, LONG, 46), /* this is an upload */ CINIT(POST, LONG, 47), /* HTTP POST method */ - CINIT(FTPLISTONLY, LONG, 48), /* Use NLST when listing ftp dir */ + CINIT(DIRLISTONLY, LONG, 48), /* bare names when listing directories */ - CINIT(FTPAPPEND, LONG, 50), /* Append instead of overwrite on upload! */ + 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. */ @@ -631,15 +980,18 @@ typedef enum { /* 55 = OBSOLETE */ - /* Function that will be called instead of the internal progress display + /* 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 progress callback */ + /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION + callbacks */ CINIT(PROGRESSDATA, OBJECTPOINT, 57), +#define CURLOPT_XFERINFODATA CURLOPT_PROGRESSDATA - /* We want the referer field set automatically when following locations */ + /* 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: @@ -655,10 +1007,10 @@ typedef enum { /* Set the interface string to use as outgoing network interface */ CINIT(INTERFACE, OBJECTPOINT, 62), - /* Set the krb4 security level, this also enables krb4 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(KRB4LEVEL, OBJECTPOINT, 63), + /* 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, OBJECTPOINT, 63), /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ CINIT(SSL_VERIFYPEER, LONG, 64), @@ -683,9 +1035,7 @@ typedef enum { /* Max amount of cached alive connections */ CINIT(MAXCONNECTS, LONG, 71), - /* What policy to use when closing connections when the cache is filled - up */ - CINIT(CLOSEPOLICY, LONG, 72), + CINIT(CLOSEPOLICY, LONG, 72), /* DEPRECATED, do not use! */ /* 73 = OBSOLETE */ @@ -706,9 +1056,8 @@ typedef enum { /* Set to the Entropy Gathering Daemon socket pathname */ CINIT(EGDSOCKET, OBJECTPOINT, 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. [Only works on unix-style/SIGALRM operating systems] */ + /* 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 @@ -736,7 +1085,7 @@ typedef enum { CURL_HTTP_VERSION* enums set below. */ CINIT(HTTP_VERSION, LONG, 84), - /* Specificly switch on or off the FTP engine's use of the EPSV command. By + /* 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), @@ -759,12 +1108,12 @@ typedef enum { CINIT(SSLENGINE_DEFAULT, LONG, 90), /* Non-zero value means to use the global dns cache */ - CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* To becomeO BSOLETE soon */ + 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 (Wesley Laxton)*/ + /* send linked-list of pre-transfer QUOTE commands */ CINIT(PREQUOTE, OBJECTPOINT, 93), /* set the debug function */ @@ -792,12 +1141,13 @@ typedef enum { CINIT(SHARE, OBJECTPOINT, 100), /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), - CURLPROXY_SOCKS4 and CURLPROXY_SOCKS5. */ + 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. */ - CINIT(ENCODING, OBJECTPOINT, 102), + the response to be compressed. Before 7.21.6, this was known as + CURLOPT_ENCODING */ + CINIT(ACCEPT_ENCODING, OBJECTPOINT, 102), /* Set pointer to private data */ CINIT(PRIVATE, OBJECTPOINT, 103), @@ -806,12 +1156,12 @@ typedef enum { CINIT(HTTP200ALIASES, OBJECTPOINT, 104), /* Continue to send authentication (user+password) when following locations, - even when hostname changed. This can potentionally send off the name + even when hostname changed. This can potentially send off the name and password to whatever host the server decides. */ CINIT(UNRESTRICTED_AUTH, LONG, 105), - /* Specificly 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 + /* 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), @@ -829,7 +1179,10 @@ typedef enum { argument */ CINIT(SSL_CTX_DATA, OBJECTPOINT, 109), - /* FTP Option that causes missing dirs to be created on the remote server */ + /* 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 @@ -841,7 +1194,8 @@ typedef enum { 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), + 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 @@ -877,11 +1231,11 @@ typedef enum { CINIT(NETRC_FILE, OBJECTPOINT, 118), /* Enable SSL/TLS for FTP, pick one of: - CURLFTPSSL_TRY - try using SSL, proceed anyway otherwise - CURLFTPSSL_CONTROL - SSL for the control connection or fail - CURLFTPSSL_ALL - SSL for all communication or fail + 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(FTP_SSL, LONG, 119), + CINIT(USE_SSL, LONG, 119), /* The _LARGE version of the standard POSTFIELDSIZE option */ CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120), @@ -890,24 +1244,14 @@ typedef enum { CINIT(TCP_NODELAY, LONG, 121), /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ - - /* When doing 3rd party transfer, set the source user and password with - this */ - CINIT(SOURCE_USERPWD, OBJECTPOINT, 123), - + /* 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 doing 3rd party transfer, set the source pre-quote linked list - of commands with this */ - CINIT(SOURCE_PREQUOTE, OBJECTPOINT, 127), - - /* When doing 3rd party transfer, set the source post-quote linked list - of commands with this */ - CINIT(SOURCE_POSTQUOTE, OBJECTPOINT, 128), - - /* When FTP over SSL/TLS is selected (with CURLOPT_FTP_SSL), this option + /* 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. @@ -922,12 +1266,8 @@ typedef enum { CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130), CINIT(IOCTLDATA, OBJECTPOINT, 131), - /* To make a 3rd party transfer, set the source URL with this */ - CINIT(SOURCE_URL, OBJECTPOINT, 132), - - /* When doing 3rd party transfer, set the source quote linked list of - commands with this */ - CINIT(SOURCE_QUOTE, OBJECTPOINT, 133), + /* 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 */ @@ -982,9 +1322,286 @@ typedef enum { /* Pointer to command string to send if USER/PASS fails. */ CINIT(FTP_ALTERNATIVE_TO_USER, OBJECTPOINT, 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, OBJECTPOINT, 152), + CINIT(SSH_PRIVATE_KEYFILE, OBJECTPOINT, 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, OBJECTPOINT, 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, OBJECTPOINT, 169), + + /* Issuer certificate */ + CINIT(ISSUERCERT, OBJECTPOINT, 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, OBJECTPOINT, 173), + CINIT(PASSWORD, OBJECTPOINT, 174), + + /* "name" and "pwd" to use with Proxy when fetching. */ + CINIT(PROXYUSERNAME, OBJECTPOINT, 175), + CINIT(PROXYPASSWORD, OBJECTPOINT, 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, OBJECTPOINT, 177), + + /* block size for TFTP transfers */ + CINIT(TFTP_BLKSIZE, LONG, 178), + + /* Socks Service */ + CINIT(SOCKS5_GSSAPI_SERVICE, OBJECTPOINT, 179), + + /* 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, OBJECTPOINT, 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, OBJECTPOINT, 186), + + /* set the 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, OBJECTPOINT, 190), + + /* The RTSP stream URI */ + CINIT(RTSP_STREAM_URI, OBJECTPOINT, 191), + + /* The Transport: header to use in RTSP requests */ + CINIT(RTSP_TRANSPORT, OBJECTPOINT, 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, OBJECTPOINT, 204), + + /* Set a password for authenticated TLS */ + CINIT(TLSAUTH_PASSWORD, OBJECTPOINT, 205), + + /* Set authentication type for authenticated TLS */ + CINIT(TLSAUTH_TYPE, OBJECTPOINT, 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, OBJECTPOINT, 211), + + /* Time-out accept operations (currently for FTP only) after this amount + of miliseconds. */ + 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, OBJECTPOINT, 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, OBJECTPOINT, 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, OBJECTPOINT, 221), + + /* Set the local IPv4 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_LOCAL_IP4, OBJECTPOINT, 222), + + /* Set the local IPv4 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_LOCAL_IP6, OBJECTPOINT, 223), + + /* Set authentication options directly */ + CINIT(LOGIN_OPTIONS, OBJECTPOINT, 224), + 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. */ @@ -997,26 +1614,7 @@ typedef enum { #define CURLOPT_WRITEDATA CURLOPT_FILE #define CURLOPT_READDATA CURLOPT_INFILE #define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER - -#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all - the obsolete stuff removed! */ -#define CURLOPT_HTTPREQUEST -1 -#define CURLOPT_FTPASCII CURLOPT_TRANSFERTEXT -#define CURLOPT_MUTE -2 -#define CURLOPT_PASSWDFUNCTION -3 -#define CURLOPT_PASSWDDATA -4 -#define CURLOPT_CLOSEFUNCTION -5 - -#define CURLOPT_SOURCE_HOST -6 -#define CURLOPT_SOURCE_PATH -7 -#define CURLOPT_SOURCE_PORT -8 -#define CURLOPT_PASV_HOST -9 - -#else -/* This is set if CURL_NO_OLDIES is defined at compile-time */ -#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */ -#endif - +#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER /* These enums are for use with the CURLOPT_HTTP_VERSION option. */ enum { @@ -1025,10 +1623,30 @@ enum { 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.0 in the request */ CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */ }; +/* + * 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. @@ -1043,13 +1661,33 @@ enum CURL_NETRC_OPTION { enum { CURL_SSLVERSION_DEFAULT, - CURL_SSLVERSION_TLSv1, + 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_LAST /* never use, keep last */ }; +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, @@ -1061,10 +1699,6 @@ typedef enum { CURL_TIMECOND_LAST } curl_TimeCond; -#ifdef __BEOS__ -#include -#endif - /* curl_strequal() and curl_strnequal() are subject for removal in a future libcurl, see lib/README.curlx for details */ @@ -1108,7 +1742,9 @@ typedef enum { CFINIT(END), CFINIT(OBSOLETE2), - CURLFORM_LASTENTRY /* the last unusued */ + CFINIT(STREAM), + + CURLFORM_LASTENTRY /* the last unused */ } CURLformoption; #undef CFINIT /* done */ @@ -1130,7 +1766,7 @@ struct curl_forms { * 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 HttpPost struct cannot be allocated + * 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 * @@ -1154,7 +1790,7 @@ typedef enum { * * DESCRIPTION * - * Pretty advanved function for building multi-part formposts. Each invoke + * 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. */ @@ -1164,11 +1800,14 @@ CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost, /* * callback function for curl_formget() - * The void *arg pointer will be the one passed as second argument to 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. + * 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); +typedef size_t (*curl_formget_callback)(void *arg, const char *buf, + size_t len); /* * NAME curl_formget() @@ -1264,7 +1903,9 @@ CURL_EXTERN void curl_free(void *p); * DESCRIPTION * * curl_global_init() should be invoked exactly once for each application that - * uses libcurl + * uses libcurl and before any call of other libcurl functions. + * + * This function is not thread-safe! */ CURL_EXTERN CURLcode curl_global_init(long flags); @@ -1335,6 +1976,37 @@ CURL_EXTERN void curl_slist_free_all(struct curl_slist *); */ CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused); +/* info about the certificate chain, only for OpenSSL 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" */ +}; + +/* enum for the different supported SSL backends */ +typedef enum { + CURLSSLBACKEND_NONE = 0, + CURLSSLBACKEND_OPENSSL = 1, + CURLSSLBACKEND_GNUTLS = 2, + CURLSSLBACKEND_NSS = 3, + CURLSSLBACKEND_QSOSSL = 4, + CURLSSLBACKEND_GSKIT = 5, + CURLSSLBACKEND_POLARSSL = 6, + CURLSSLBACKEND_CYASSL = 7, + CURLSSLBACKEND_SCHANNEL = 8, + CURLSSLBACKEND_DARWINSSL = 9 +} curl_sslbackend; + +/* 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_SESSION. */ +struct curl_tlssessioninfo { + curl_sslbackend backend; + void *internals; +}; + #define CURLINFO_STRING 0x100000 #define CURLINFO_LONG 0x200000 #define CURLINFO_DOUBLE 0x300000 @@ -1374,9 +2046,22 @@ typedef enum { 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_SLIST + 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_SLIST + 43, /* Fill in new entries below here! */ - CURLINFO_LASTONE = 30 + CURLINFO_LASTONE = 43 } CURLINFO; /* CURLINFO_RESPONSE_CODE is the new name for the option previously known as @@ -1400,6 +2085,7 @@ typedef enum { #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) /***************************************************************************** @@ -1409,7 +2095,7 @@ typedef enum { /* Different data locks for a single share */ typedef enum { CURL_LOCK_DATA_NONE = 0, - /* CURL_LOCK_DATA_SHARE is used internaly to say that + /* CURL_LOCK_DATA_SHARE is used internally to say that * the locking is just made to change the internal state of the share * itself. */ @@ -1444,14 +2130,15 @@ typedef enum { CURLSHE_BAD_OPTION, /* 1 */ CURLSHE_IN_USE, /* 2 */ CURLSHE_INVALID, /* 3 */ - CURLSHE_NOMEM, /* out of memory */ - CURLSHE_LAST /* never use */ + 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 shich data type to stop sharing */ + 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 @@ -1471,15 +2158,16 @@ typedef enum { CURLVERSION_FIRST, CURLVERSION_SECOND, CURLVERSION_THIRD, + CURLVERSION_FOURTH, CURLVERSION_LAST /* never actually use this */ } CURLversion; /* The 'CURLVERSION_NOW' is the symbolic name meant to be used by - basicly all programs ever, that want to get version information. It is + 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_THIRD +#define CURLVERSION_NOW CURLVERSION_FOURTH typedef struct { CURLversion age; /* age of the returned struct */ @@ -1500,8 +2188,13 @@ typedef struct { /* 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 */ + } curl_version_info_data; #define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */ @@ -1516,10 +2209,13 @@ typedef struct { #define CURL_VERSION_LARGEFILE (1<<9) /* supports files bigger than 2GB */ #define CURL_VERSION_IDN (1<<10) /* International Domain Names support */ #define CURL_VERSION_SSPI (1<<11) /* SSPI is supported */ -#define CURL_VERSION_CONV (1<<12) /* character conversions are - supported */ +#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 delegating to winbind helper */ +#define CURL_VERSION_HTTP2 (1<<16) /* HTTP2 support built-in */ -/* + /* * NAME curl_version_info() * * DESCRIPTION @@ -1551,6 +2247,26 @@ CURL_EXTERN const char *curl_easy_strerror(CURLcode); */ 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 @@ -1560,4 +2276,21 @@ CURL_EXTERN const char *curl_share_strerror(CURLSHcode); #include "easy.h" /* nothing in curl is fun without the easy stuff */ #include "multi.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/code/libcurl-7.35.0/curl/curlbuild.h b/code/libcurl-7.35.0/curl/curlbuild.h new file mode 100644 index 00000000..3ad2f018 --- /dev/null +++ b/code/libcurl-7.35.0/curl/curlbuild.h @@ -0,0 +1,585 @@ +#ifndef __CURL_CURLBUILD_H +#define __CURL_CURLBUILD_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2013, 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 http://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. + * + ***************************************************************************/ + +/* ================================================================ */ +/* NOTES FOR CONFIGURE CAPABLE SYSTEMS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * See file include/curl/curlbuild.h.in, run configure, and forget + * that this file exists it is only used for non-configure systems. + * But you can keep reading if you want ;-) + * + */ + +/* ================================================================ */ +/* NOTES FOR NON-CONFIGURE SYSTEMS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * Nothing in this file is intended to be modified or adjusted by the + * curl library user nor by the curl library builder. + * + * If you think that something actually needs to be changed, adjusted + * or fixed in this file, then, report it on the libcurl development + * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/ + * + * 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. + * + * This header file shall only export symbols which are 'curl' or 'CURL' + * prefixed, otherwise public name space would be polluted. + * + * NOTE 2: + * ------- + * + * 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. + * + * NOTE 3: + * ------- + * + * Right now you might be staring at file include/curl/curlbuild.h.dist or + * at file include/curl/curlbuild.h, this is due to the following reason: + * file include/curl/curlbuild.h.dist is renamed to include/curl/curlbuild.h + * when the libcurl source code distribution archive file is created. + * + * File include/curl/curlbuild.h.dist is not included in the distribution + * archive. File include/curl/curlbuild.h is not present in the git tree. + * + * The distributed include/curl/curlbuild.h file is only intended to be used + * on systems which can not run the also distributed configure script. + * + * On systems capable of running the configure script, the configure process + * will overwrite the distributed include/curl/curlbuild.h file with one that + * is suitable and specific to the library being configured and built, which + * is generated from the include/curl/curlbuild.h.in template file. + * + * If you check out from git on a non-configure platform, you must run the + * appropriate buildconf* script to set up curlbuild.h and other local files. + * + */ + +/* ================================================================ */ +/* DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE */ +/* ================================================================ */ + +#ifdef CURL_SIZEOF_LONG +# error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined +#endif + +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T +# error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined +#endif + +#ifdef CURL_SIZEOF_CURL_SOCKLEN_T +# error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined +#endif + +#ifdef CURL_TYPEOF_CURL_OFF_T +# error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_FORMAT_CURL_OFF_T +# error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_FORMAT_CURL_OFF_TU +# error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined +#endif + +#ifdef CURL_FORMAT_OFF_T +# error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined +#endif + +#ifdef CURL_SIZEOF_CURL_OFF_T +# error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_SUFFIX_CURL_OFF_T +# error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_SUFFIX_CURL_OFF_TU +# error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined +#endif + +/* ================================================================ */ +/* EXTERNAL INTERFACE SETTINGS FOR NON-CONFIGURE SYSTEMS ONLY */ +/* ================================================================ */ + +#if defined(__DJGPP__) || defined(__GO32__) +# if defined(__DJGPP__) && (__DJGPP__ > 1) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__SALFORDC__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__BORLANDC__) +# if (__BORLANDC__ < 0x520) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__TURBOC__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__WATCOMC__) +# if defined(__386__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__POCC__) +# if (__POCC__ < 280) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# elif defined(_MSC_VER) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__LCC__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__SYMBIAN32__) +# if defined(__EABI__) /* Treat all ARM compilers equally */ +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__CW32__) +# pragma longlong on +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__VC32__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__MWERKS__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(_WIN32_WCE) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__MINGW32__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__VMS) +# if defined(__VAX) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__OS400__) +# if defined(__ILEC400__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 +# 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) +# define CURL_SIZEOF_LONG 4 +# elif defined(_LP64) +# define CURL_SIZEOF_LONG 8 +# 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_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# 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_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# 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_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# 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_SIZEOF_CURL_SOCKLEN_T 4 +# 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) +# define CURL_SIZEOF_LONG 4 +# elif defined(_LP64) +# define CURL_SIZEOF_LONG 8 +# 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_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# 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_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# 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_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# 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_SIZEOF_CURL_SOCKLEN_T 4 +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(TPF) +# define CURL_SIZEOF_LONG 8 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +/* ===================================== */ +/* KEEP MSVC THE PENULTIMATE ENTRY */ +/* ===================================== */ + +#elif defined(_MSC_VER) +# if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +/* ===================================== */ +/* KEEP GENERIC GCC THE LAST ENTRY */ +/* ===================================== */ + +#elif defined(__GNUC__) +# if defined(__ILP32__) || \ + defined(__i386__) || defined(__ppc__) || defined(__arm__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__LP64__) || \ + defined(__x86_64__) || defined(__ppc64__) +# define CURL_SIZEOF_LONG 8 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# 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_SIZEOF_CURL_SOCKLEN_T 4 +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#else +# error "Unknown non-configure build target!" + Error Compilation_aborted_Unknown_non_configure_build_target +#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 + +/* 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 + +#endif /* __CURL_CURLBUILD_H */ diff --git a/code/libcurl-7.35.0/curl/curlrules.h b/code/libcurl-7.35.0/curl/curlrules.h new file mode 100644 index 00000000..7c2ede35 --- /dev/null +++ b/code/libcurl-7.35.0/curl/curlrules.h @@ -0,0 +1,262 @@ +#ifndef __CURL_CURLRULES_H +#define __CURL_CURLRULES_H +/*************************************************************************** + * _ _ ____ _ + * 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 http://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. + * + ***************************************************************************/ + +/* ================================================================ */ +/* COMPILE TIME SANITY CHECKS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * All checks done in this file are intentionally placed in a public + * header file which is pulled by curl/curl.h when an application is + * being built using an already built libcurl library. Additionally + * this file is also included and used when building the library. + * + * If compilation fails on this file it is certainly sure that the + * problem is elsewhere. It could be a problem in the curlbuild.h + * header file, or simply that you are using different compilation + * settings than those used to build the library. + * + * Nothing in this file is intended to be modified or adjusted by the + * curl library user nor by the curl library builder. + * + * Do not deactivate any check, these are done to make sure that the + * library is properly built and used. + * + * You can find further help on the libcurl development mailing list: + * http://cool.haxx.se/mailman/listinfo/curl-library/ + * + * NOTE 2 + * ------ + * + * Some of the following compile time checks are based on the fact + * that the dimension of a constant array can not be a negative one. + * In this way if the compile time verification fails, the compilation + * will fail issuing an error. The error description wording is compiler + * dependent but it will be quite similar to one of the following: + * + * "negative subscript or subscript is too large" + * "array must have at least one element" + * "-1 is an illegal array size" + * "size of array is negative" + * + * If you are building an application which tries to use an already + * built libcurl library and you are getting this kind of errors on + * this file, it is a clear indication that there is a mismatch between + * how the library was built and how you are trying to use it for your + * application. Your already compiled or binary library provider is the + * only one who can give you the details you need to properly use it. + */ + +/* + * Verify that some macros are actually defined. + */ + +#ifndef CURL_SIZEOF_LONG +# error "CURL_SIZEOF_LONG definition is missing!" + Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing +#endif + +#ifndef CURL_TYPEOF_CURL_SOCKLEN_T +# error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!" + Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing +#endif + +#ifndef CURL_SIZEOF_CURL_SOCKLEN_T +# error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!" + Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing +#endif + +#ifndef CURL_TYPEOF_CURL_OFF_T +# error "CURL_TYPEOF_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_FORMAT_CURL_OFF_T +# error "CURL_FORMAT_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_FORMAT_CURL_OFF_TU +# error "CURL_FORMAT_CURL_OFF_TU definition is missing!" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_is_missing +#endif + +#ifndef CURL_FORMAT_OFF_T +# error "CURL_FORMAT_OFF_T definition is missing!" + Error Compilation_aborted_CURL_FORMAT_OFF_T_is_missing +#endif + +#ifndef CURL_SIZEOF_CURL_OFF_T +# error "CURL_SIZEOF_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_SUFFIX_CURL_OFF_T +# error "CURL_SUFFIX_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_SUFFIX_CURL_OFF_TU +# error "CURL_SUFFIX_CURL_OFF_TU definition is missing!" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_is_missing +#endif + +/* + * Macros private to this header file. + */ + +#define CurlchkszEQ(t, s) sizeof(t) == s ? 1 : -1 + +#define CurlchkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1 + +/* + * Verify that the size previously defined and expected for long + * is the same as the one reported by sizeof() at compile time. + */ + +typedef char + __curl_rule_01__ + [CurlchkszEQ(long, CURL_SIZEOF_LONG)]; + +/* + * Verify that the size previously defined and expected for + * curl_off_t is actually the the same as the one reported + * by sizeof() at compile time. + */ + +typedef char + __curl_rule_02__ + [CurlchkszEQ(curl_off_t, CURL_SIZEOF_CURL_OFF_T)]; + +/* + * Verify at compile time that the size of curl_off_t as reported + * by sizeof() is greater or equal than the one reported for long + * for the current compilation. + */ + +typedef char + __curl_rule_03__ + [CurlchkszGE(curl_off_t, long)]; + +/* + * Verify that the size previously defined and expected for + * curl_socklen_t is actually the the same as the one reported + * by sizeof() at compile time. + */ + +typedef char + __curl_rule_04__ + [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)]; + +/* + * Verify at compile time that the size of curl_socklen_t as reported + * by sizeof() is greater or equal than the one reported for int for + * the current compilation. + */ + +typedef char + __curl_rule_05__ + [CurlchkszGE(curl_socklen_t, int)]; + +/* ================================================================ */ +/* EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS */ +/* ================================================================ */ + +/* + * 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 + +/* + * Get rid of macros private to this header file. + */ + +#undef CurlchkszEQ +#undef CurlchkszGE + +/* + * Get rid of macros not intended to exist beyond this point. + */ + +#undef CURL_PULL_WS2TCPIP_H +#undef CURL_PULL_SYS_TYPES_H +#undef CURL_PULL_SYS_SOCKET_H +#undef CURL_PULL_SYS_POLL_H +#undef CURL_PULL_STDINT_H +#undef CURL_PULL_INTTYPES_H + +#undef CURL_TYPEOF_CURL_SOCKLEN_T +#undef CURL_TYPEOF_CURL_OFF_T + +#ifdef CURL_NO_OLDIES +#undef CURL_FORMAT_OFF_T /* not required since 7.19.0 - obsoleted in 7.20.0 */ +#endif + +#endif /* __CURL_CURLRULES_H */ diff --git a/code/libcurl/curl/curlver.h b/code/libcurl-7.35.0/curl/curlver.h similarity index 75% rename from code/libcurl/curl/curlver.h rename to code/libcurl-7.35.0/curl/curlver.h index 1634b172..2de9e5a5 100644 --- a/code/libcurl/curl/curlver.h +++ b/code/libcurl-7.35.0/curl/curlver.h @@ -7,7 +7,7 @@ * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * - * Copyright (C) 1998 - 2006, Daniel Stenberg, , et al. + * Copyright (C) 1998 - 2014, 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 @@ -20,21 +20,23 @@ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * - * $Id: curlver.h,v 1.21 2006-06-12 07:24:14 bagder Exp $ ***************************************************************************/ /* 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 - 2014 Daniel Stenberg, ." + /* This is the version number of the libcurl package from which this header file origins: */ -#define LIBCURL_VERSION "7.15.5" +#define LIBCURL_VERSION "7.35.0" /* The numeric version number is also available "in parts" by using these defines: */ #define LIBCURL_VERSION_MAJOR 7 -#define LIBCURL_VERSION_MINOR 15 -#define LIBCURL_VERSION_PATCH 5 +#define LIBCURL_VERSION_MINOR 35 +#define LIBCURL_VERSION_PATCH 0 /* This is the numeric version of the libcurl version number, meant for easier parsing and comparions by programs. The LIBCURL_VERSION_NUM define will @@ -51,6 +53,17 @@ and it is always a greater number in a more recent release. It makes comparisons with greater than and less than work. */ -#define LIBCURL_VERSION_NUM 0x070f05 +#define LIBCURL_VERSION_NUM 0x072300 + +/* + * 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 should follow this template: + * + * "Mon Feb 12 11:35:33 UTC 2007" + */ +#define LIBCURL_TIMESTAMP "Wed Jan 29 07:09:27 UTC 2014" #endif /* __CURL_CURLVER_H */ diff --git a/code/libcurl/curl/easy.h b/code/libcurl-7.35.0/curl/easy.h similarity index 76% rename from code/libcurl/curl/easy.h rename to code/libcurl-7.35.0/curl/easy.h index b5867200..c1e3e760 100644 --- a/code/libcurl/curl/easy.h +++ b/code/libcurl-7.35.0/curl/easy.h @@ -7,7 +7,7 @@ * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * - * Copyright (C) 1998 - 2004, Daniel Stenberg, , et al. + * Copyright (C) 1998 - 2008, 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 @@ -20,7 +20,6 @@ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * - * $Id: easy.h,v 1.13 2004/11/09 14:02:58 giva Exp $ ***************************************************************************/ #ifdef __cplusplus extern "C" { @@ -54,8 +53,8 @@ CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...); * * 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 persistant connections cannot - * be transfered. It is useful in multithreaded applications when you can run + * 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. */ @@ -74,6 +73,28 @@ CURL_EXTERN CURL* curl_easy_duphandle(CURL *curl); */ 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); + #ifdef __cplusplus } #endif diff --git a/code/libcurl/curl/mprintf.h b/code/libcurl-7.35.0/curl/mprintf.h similarity index 77% rename from code/libcurl/curl/mprintf.h rename to code/libcurl-7.35.0/curl/mprintf.h index 8d835f13..cc9e7f5d 100644 --- a/code/libcurl/curl/mprintf.h +++ b/code/libcurl-7.35.0/curl/mprintf.h @@ -7,7 +7,7 @@ * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * - * Copyright (C) 1998 - 2006, Daniel Stenberg, , et al. + * Copyright (C) 1998 - 2013, 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 @@ -20,7 +20,6 @@ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * - * $Id: mprintf.h,v 1.13 2006-03-28 10:08:54 bagder Exp $ ***************************************************************************/ #include @@ -28,22 +27,38 @@ #include "curl.h" +#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_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 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 _MPRINTF_REPLACE +# undef printf +# undef fprintf +# undef sprintf +# undef vsprintf +# undef snprintf +# undef vprintf +# undef vfprintf +# undef vsnprintf +# undef aprintf +# undef vaprintf # define printf curl_mprintf # define fprintf curl_mfprintf #ifdef CURLDEBUG -/* When built with CURLDEBUG we define away the sprintf() functions since we +/* When built with CURLDEBUG we define away the sprintf functions since we don't want internal code to be using them */ # define sprintf sprintf_was_used # define vsprintf vsprintf_was_used @@ -59,4 +74,8 @@ CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args); # define vaprintf curl_mvaprintf #endif +#ifdef __cplusplus +} +#endif + #endif /* __CURL_MPRINTF_H */ diff --git a/code/libcurl/curl/multi.h b/code/libcurl-7.35.0/curl/multi.h similarity index 75% rename from code/libcurl/curl/multi.h rename to code/libcurl-7.35.0/curl/multi.h index 05aeafc7..3c4acb0f 100644 --- a/code/libcurl/curl/multi.h +++ b/code/libcurl-7.35.0/curl/multi.h @@ -7,7 +7,7 @@ * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * - * Copyright (C) 1998 - 2006, Daniel Stenberg, , et al. + * Copyright (C) 1998 - 2013, 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 @@ -20,7 +20,6 @@ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * - * $Id: multi.h,v 1.38 2006-08-04 18:53:48 danf Exp $ ***************************************************************************/ /* This is an "external" header file. Don't give away any internals here! @@ -37,34 +36,6 @@ file descriptors simultaneous easily. */ -#if defined(_WIN32) && !defined(WIN32) -/* Chris Lewis mentioned that he doesn't get WIN32 defined, only _WIN32 so we - make this adjustment to catch this. */ -#define WIN32 1 -#endif - -#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__GNUC__) && \ - !defined(__CYGWIN__) || defined(__MINGW32__) -#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H)) -/* The check above prevents the winsock2 inclusion if winsock.h already was - included, since they can't co-exist without problems */ -#include -#endif -#else - -/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish - libc5-based Linux systems. Only include it on system that are known to - require it! */ -#if defined(_AIX) || defined(NETWARE) || defined(__NetBSD__) || defined(_MINIX) -#include -#endif - -#ifndef _WIN32_WCE -#include -#endif -#include -#include -#endif /* * This header file should not really need to include "curl.h" since curl.h @@ -83,18 +54,6 @@ extern "C" { typedef void CURLM; -#ifndef curl_socket_typedef -/* Public socket typedef */ -#ifdef WIN32 -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 */ - typedef enum { CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or curl_multi_socket*() soon */ @@ -105,6 +64,8 @@ typedef enum { 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_LAST } CURLMcode; @@ -130,6 +91,19 @@ struct CURLMsg { }; 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() * @@ -174,6 +148,20 @@ CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle, 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() * @@ -264,6 +252,10 @@ CURL_EXTERN const char *curl_multi_strerror(CURLMcode); #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 */ @@ -271,13 +263,39 @@ typedef int (*curl_socket_callback)(CURL *easy, /* easy handle */ 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() * @@ -293,7 +311,7 @@ CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle, #undef CINIT /* re-using the same name as in curl.h */ #ifdef CURL_ISOCPP -#define CINIT(name,type,number) CURLMOPT_ ## name = CURLOPTTYPE_ ## type + number +#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 @@ -310,6 +328,43 @@ typedef enum { /* 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), + CURLMOPT_LASTENTRY /* the last unused */ } CURLMoption; diff --git a/code/libcurl/curl/stdcheaders.h b/code/libcurl-7.35.0/curl/stdcheaders.h similarity index 74% rename from code/libcurl/curl/stdcheaders.h rename to code/libcurl-7.35.0/curl/stdcheaders.h index 024413ac..ad82ef63 100644 --- a/code/libcurl/curl/stdcheaders.h +++ b/code/libcurl-7.35.0/curl/stdcheaders.h @@ -1,18 +1,18 @@ #ifndef __STDC_HEADERS_H #define __STDC_HEADERS_H /*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * - * Copyright (C) 1998 - 2004, Daniel Stenberg, , et al. + * Copyright (C) 1998 - 2010, 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 http://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. @@ -20,7 +20,6 @@ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * - * $Id: stdcheaders.h,v 1.8 2004/01/07 09:19:34 bagder Exp $ ***************************************************************************/ #include @@ -31,4 +30,4 @@ 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 +#endif /* __STDC_HEADERS_H */ diff --git a/code/libcurl-7.35.0/curl/typecheck-gcc.h b/code/libcurl-7.35.0/curl/typecheck-gcc.h new file mode 100644 index 00000000..cdeba21a --- /dev/null +++ b/code/libcurl-7.35.0/curl/typecheck-gcc.h @@ -0,0 +1,610 @@ +#ifndef __CURL_TYPECHECK_GCC_H +#define __CURL_TYPECHECK_GCC_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2013, 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 http://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_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_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 */ +/* FIXME: don't allow const pointers */ +#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(); \ + } \ + curl_easy_getinfo(handle, _curl_info, arg); \ +}) + +/* TODO: typechecking for curl_share_setopt() and curl_multi_setopt(), + * 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_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_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") + +/* 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_URL || \ + (option) == CURLOPT_PROXY || \ + (option) == CURLOPT_INTERFACE || \ + (option) == CURLOPT_NETRC_FILE || \ + (option) == CURLOPT_USERPWD || \ + (option) == CURLOPT_USERNAME || \ + (option) == CURLOPT_PASSWORD || \ + (option) == CURLOPT_PROXYUSERPWD || \ + (option) == CURLOPT_PROXYUSERNAME || \ + (option) == CURLOPT_PROXYPASSWORD || \ + (option) == CURLOPT_NOPROXY || \ + (option) == CURLOPT_ACCEPT_ENCODING || \ + (option) == CURLOPT_REFERER || \ + (option) == CURLOPT_USERAGENT || \ + (option) == CURLOPT_COOKIE || \ + (option) == CURLOPT_COOKIEFILE || \ + (option) == CURLOPT_COOKIEJAR || \ + (option) == CURLOPT_COOKIELIST || \ + (option) == CURLOPT_FTPPORT || \ + (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ + (option) == CURLOPT_FTP_ACCOUNT || \ + (option) == CURLOPT_RANGE || \ + (option) == CURLOPT_CUSTOMREQUEST || \ + (option) == CURLOPT_SSLCERT || \ + (option) == CURLOPT_SSLCERTTYPE || \ + (option) == CURLOPT_SSLKEY || \ + (option) == CURLOPT_SSLKEYTYPE || \ + (option) == CURLOPT_KEYPASSWD || \ + (option) == CURLOPT_SSLENGINE || \ + (option) == CURLOPT_CAINFO || \ + (option) == CURLOPT_CAPATH || \ + (option) == CURLOPT_RANDOM_FILE || \ + (option) == CURLOPT_EGDSOCKET || \ + (option) == CURLOPT_SSL_CIPHER_LIST || \ + (option) == CURLOPT_KRBLEVEL || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ + (option) == CURLOPT_SSH_PUBLIC_KEYFILE || \ + (option) == CURLOPT_SSH_PRIVATE_KEYFILE || \ + (option) == CURLOPT_CRLFILE || \ + (option) == CURLOPT_ISSUERCERT || \ + (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \ + (option) == CURLOPT_SSH_KNOWNHOSTS || \ + (option) == CURLOPT_MAIL_FROM || \ + (option) == CURLOPT_RTSP_SESSION_ID || \ + (option) == CURLOPT_RTSP_STREAM_URI || \ + (option) == CURLOPT_RTSP_TRANSPORT || \ + (option) == CURLOPT_XOAUTH2_BEARER || \ + (option) == CURLOPT_DNS_SERVERS || \ + (option) == CURLOPT_DNS_INTERFACE || \ + (option) == CURLOPT_DNS_LOCAL_IP4 || \ + (option) == CURLOPT_DNS_LOCAL_IP6 || \ + (option) == CURLOPT_LOGIN_OPTIONS || \ + 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_WRITEDATA || \ + (option) == CURLOPT_READDATA || \ + (option) == CURLOPT_IOCTLDATA || \ + (option) == CURLOPT_SOCKOPTDATA || \ + (option) == CURLOPT_OPENSOCKETDATA || \ + (option) == CURLOPT_PROGRESSDATA || \ + (option) == CURLOPT_WRITEHEADER || \ + (option) == CURLOPT_DEBUGDATA || \ + (option) == CURLOPT_SSL_CTX_DATA || \ + (option) == CURLOPT_SEEKDATA || \ + (option) == CURLOPT_PRIVATE || \ + (option) == CURLOPT_SSH_KEYDATA || \ + (option) == CURLOPT_INTERLEAVEDATA || \ + (option) == CURLOPT_CHUNK_DATA || \ + (option) == CURLOPT_FNMATCH_DATA || \ + 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_HTTPHEADER || \ + (option) == CURLOPT_HTTP200ALIASES || \ + (option) == CURLOPT_QUOTE || \ + (option) == CURLOPT_POSTQUOTE || \ + (option) == CURLOPT_PREQUOTE || \ + (option) == CURLOPT_TELNETOPTIONS || \ + (option) == CURLOPT_MAIL_RCPT || \ + 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) \ + (CURLINFO_SLIST < (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 iff 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) \ + (__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)) + +/* FIXME: the whole callback checking is messy... + * The idea is to tolerate char vs. void and const vs. not const + * pointers in arguments at least + */ +/* 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_read_callback or "similar" */ +#define _curl_is_read_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), __typeof__(fread)) || \ + __builtin_types_compatible_p(__typeof__(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) || \ + __builtin_types_compatible_p(__typeof__(expr), __typeof__(fwrite)) || \ + __builtin_types_compatible_p(__typeof__(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) || \ + __builtin_types_compatible_p(__typeof__(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) || \ + __builtin_types_compatible_p(__typeof__(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) || \ + __builtin_types_compatible_p(__typeof__(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) || \ + __builtin_types_compatible_p(__typeof__(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) || \ + __builtin_types_compatible_p(__typeof__(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) || \ + __builtin_types_compatible_p(__typeof__(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) || \ + __builtin_types_compatible_p(__typeof__(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) || \ + __builtin_types_compatible_p(__typeof__(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/code/libcurl/curl/types.h b/code/libcurl/curl/types.h deleted file mode 100644 index d37d6ae9..00000000 --- a/code/libcurl/curl/types.h +++ /dev/null @@ -1 +0,0 @@ -/* not used */ diff --git a/code/libs/win32/libcurl.a b/code/libs/win32/libcurl.a index 7f6ed2d7a58c61789c291f03a208b423dc296a6f..e64b138bb647fa26616c20944a487656f2c0f4be 100644 GIT binary patch literal 345004 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