mirror of
https://github.com/UberGames/ioef.git
synced 2024-12-11 21:31:07 +00:00
1564 lines
56 KiB
C
1564 lines
56 KiB
C
|
#ifndef __CURL_CURL_H
|
||
|
#define __CURL_CURL_H
|
||
|
/***************************************************************************
|
||
|
* _ _ ____ _
|
||
|
* Project ___| | | | _ \| |
|
||
|
* / __| | | | |_) | |
|
||
|
* | (__| |_| | _ <| |___
|
||
|
* \___|\___/|_| \_\_____|
|
||
|
*
|
||
|
* Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al.
|
||
|
*
|
||
|
* This software is licensed as described in the file COPYING, which
|
||
|
* you should have received as part of this distribution. The terms
|
||
|
* are also available at 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.
|
||
|
*
|
||
|
* $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/
|
||
|
*/
|
||
|
|
||
|
#include "curlver.h" /* the libcurl version defines */
|
||
|
|
||
|
#include <stdio.h>
|
||
|
#include <limits.h>
|
||
|
|
||
|
/* The include stuff here below is mainly for time_t! */
|
||
|
#ifdef vms
|
||
|
# include <types.h>
|
||
|
# include <time.h>
|
||
|
#else
|
||
|
# include <sys/types.h>
|
||
|
# include <time.h>
|
||
|
#endif /* defined (vms) */
|
||
|
|
||
|
typedef void CURL;
|
||
|
|
||
|
#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
|
||
|
|
||
|
/*
|
||
|
* 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!
|
||
|
*/
|
||
|
|
||
|
#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"
|
||
|
#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
|
||
|
#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
|
||
|
#endif
|
||
|
|
||
|
struct curl_httppost {
|
||
|
struct curl_httppost *next; /* next entry in the list */
|
||
|
char *name; /* pointer to allocated name */
|
||
|
long namelength; /* length of name length */
|
||
|
char *contents; /* pointer to allocated data contents */
|
||
|
long contentslength; /* length of contents field */
|
||
|
char *buffer; /* pointer to allocated buffer contents */
|
||
|
long bufferlength; /* length of buffer field */
|
||
|
char *contenttype; /* Content-Type */
|
||
|
struct curl_slist* contentheader; /* list of extra headers for this form */
|
||
|
struct curl_httppost *more; /* if one field name has more than one
|
||
|
file, this link should link to following
|
||
|
files */
|
||
|
long flags; /* as defined below */
|
||
|
#define HTTPPOST_FILENAME (1<<0) /* specified content is a file name */
|
||
|
#define HTTPPOST_READFILE (1<<1) /* specified content is a file name */
|
||
|
#define HTTPPOST_PTRNAME (1<<2) /* name is only stored pointer
|
||
|
do not free in formfree */
|
||
|
#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer
|
||
|
do not free in formfree */
|
||
|
#define HTTPPOST_BUFFER (1<<4) /* upload file from buffer */
|
||
|
#define HTTPPOST_PTRBUFFER (1<<5) /* upload file from pointer contents */
|
||
|
|
||
|
char *showfilename; /* The file name to show. If not set, the
|
||
|
actual file name will be used (if this
|
||
|
is a file part) */
|
||
|
};
|
||
|
|
||
|
typedef int (*curl_progress_callback)(void *clientp,
|
||
|
double dltotal,
|
||
|
double dlnow,
|
||
|
double ultotal,
|
||
|
double ulnow);
|
||
|
|
||
|
/* 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. */
|
||
|
#define CURL_MAX_WRITE_SIZE 16384
|
||
|
|
||
|
typedef size_t (*curl_write_callback)(char *buffer,
|
||
|
size_t size,
|
||
|
size_t nitems,
|
||
|
void *outstream);
|
||
|
|
||
|
/* 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
|
||
|
typedef size_t (*curl_read_callback)(char *buffer,
|
||
|
size_t size,
|
||
|
size_t nitems,
|
||
|
void *instream);
|
||
|
|
||
|
|
||
|
#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
|
||
|
|
||
|
typedef enum {
|
||
|
CURLIOE_OK, /* I/O operation successful */
|
||
|
CURLIOE_UNKNOWNCMD, /* command was unknown to callback */
|
||
|
CURLIOE_FAILRESTART, /* failed to restart the read */
|
||
|
CURLIOE_LAST /* never use */
|
||
|
} curlioerr;
|
||
|
|
||
|
typedef enum {
|
||
|
CURLIOCMD_NOP, /* no operation */
|
||
|
CURLIOCMD_RESTARTREAD, /* restart the read stream from start */
|
||
|
CURLIOCMD_LAST /* never use */
|
||
|
} curliocmd;
|
||
|
|
||
|
typedef curlioerr (*curl_ioctl_callback)(CURL *handle,
|
||
|
int cmd,
|
||
|
void *clientp);
|
||
|
|
||
|
/*
|
||
|
* The following typedef's are signatures of malloc, free, realloc, strdup and
|
||
|
* calloc respectively. Function pointers of these types can be passed to the
|
||
|
* curl_global_init_mem() function to set user defined memory management
|
||
|
* callback routines.
|
||
|
*/
|
||
|
typedef void *(*curl_malloc_callback)(size_t size);
|
||
|
typedef void (*curl_free_callback)(void *ptr);
|
||
|
typedef void *(*curl_realloc_callback)(void *ptr, size_t size);
|
||
|
typedef char *(*curl_strdup_callback)(const char *str);
|
||
|
typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size);
|
||
|
|
||
|
/* the kind of data that is passed to information_callback*/
|
||
|
typedef enum {
|
||
|
CURLINFO_TEXT = 0,
|
||
|
CURLINFO_HEADER_IN, /* 1 */
|
||
|
CURLINFO_HEADER_OUT, /* 2 */
|
||
|
CURLINFO_DATA_IN, /* 3 */
|
||
|
CURLINFO_DATA_OUT, /* 4 */
|
||
|
CURLINFO_SSL_DATA_IN, /* 5 */
|
||
|
CURLINFO_SSL_DATA_OUT, /* 6 */
|
||
|
CURLINFO_END
|
||
|
} curl_infotype;
|
||
|
|
||
|
typedef int (*curl_debug_callback)
|
||
|
(CURL *handle, /* the handle/transfer this concerns */
|
||
|
curl_infotype type, /* what kind of data */
|
||
|
char *data, /* points to the data */
|
||
|
size_t size, /* size of the data pointed to */
|
||
|
void *userptr); /* whatever the user please */
|
||
|
|
||
|
/* All possible error codes from all sorts of curl functions. Future versions
|
||
|
may return other values, stay prepared.
|
||
|
|
||
|
Always add new return codes last. Never *EVER* remove any. The return
|
||
|
codes must remain the same!
|
||
|
*/
|
||
|
|
||
|
typedef enum {
|
||
|
CURLE_OK = 0,
|
||
|
CURLE_UNSUPPORTED_PROTOCOL, /* 1 */
|
||
|
CURLE_FAILED_INIT, /* 2 */
|
||
|
CURLE_URL_MALFORMAT, /* 3 */
|
||
|
CURLE_URL_MALFORMAT_USER, /* 4 - NOT USED */
|
||
|
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
|
||
|
due to lack of access - when login fails
|
||
|
this is not returned. */
|
||
|
CURLE_FTP_USER_PASSWORD_INCORRECT, /* 10 - NOT USED */
|
||
|
CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */
|
||
|
CURLE_FTP_WEIRD_USER_REPLY, /* 12 */
|
||
|
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_PARTIAL_FILE, /* 18 */
|
||
|
CURLE_FTP_COULDNT_RETR_FILE, /* 19 */
|
||
|
CURLE_FTP_WRITE_ERROR, /* 20 */
|
||
|
CURLE_FTP_QUOTE_ERROR, /* 21 */
|
||
|
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_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_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_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_FUNCTION_NOT_FOUND, /* 41 */
|
||
|
CURLE_ABORTED_BY_CALLBACK, /* 42 */
|
||
|
CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */
|
||
|
CURLE_BAD_CALLING_ORDER, /* 44 - NOT USED */
|
||
|
CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */
|
||
|
CURLE_BAD_PASSWORD_ENTERED, /* 46 - NOT USED */
|
||
|
CURLE_TOO_MANY_REDIRECTS , /* 47 - catch endless re-direct loops */
|
||
|
CURLE_UNKNOWN_TELNET_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_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_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_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_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind
|
||
|
that failed */
|
||
|
CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */
|
||
|
CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not
|
||
|
accepted and we failed to login */
|
||
|
CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */
|
||
|
CURLE_TFTP_PERM, /* 69 - permission problem on server */
|
||
|
CURLE_TFTP_DISKFULL, /* 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_TFTP_NOSUCHUSER, /* 74 - No such user */
|
||
|
CURLE_CONV_FAILED, /* 75 - conversion failed */
|
||
|
CURLE_CONV_REQD, /* 76 - caller must register conversion
|
||
|
callbacks using curl_easy_setopt options
|
||
|
CURLOPT_CONV_FROM_NETWORK_FUNCTION,
|
||
|
CURLOPT_CONV_TO_NETWORK_FUNCTION, and
|
||
|
CURLOPT_CONV_FROM_UTF8_FUNCTION */
|
||
|
CURL_LAST /* never use! */
|
||
|
} CURLcode;
|
||
|
|
||
|
/* This prototype applies to all conversion callbacks */
|
||
|
typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length);
|
||
|
|
||
|
typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */
|
||
|
void *ssl_ctx, /* actually an
|
||
|
OpenSSL 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;
|
||
|
|
||
|
#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)
|
||
|
|
||
|
#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
|
||
|
|
||
|
/* 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 CURL_ERROR_SIZE 256
|
||
|
|
||
|
/* parameter for the CURLOPT_FTP_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;
|
||
|
|
||
|
/* parameter for the CURLOPT_FTPSSLAUTH option */
|
||
|
typedef enum {
|
||
|
CURLFTPAUTH_DEFAULT, /* let libcurl decide */
|
||
|
CURLFTPAUTH_SSL, /* use "AUTH SSL" */
|
||
|
CURLFTPAUTH_TLS, /* use "AUTH TLS" */
|
||
|
CURLFTPAUTH_LAST /* not an option, never use */
|
||
|
} curl_ftpauth;
|
||
|
|
||
|
/* parameter for the CURLOPT_FTP_FILEMETHOD option */
|
||
|
typedef enum {
|
||
|
CURLFTPMETHOD_DEFAULT, /* let libcurl pick */
|
||
|
CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */
|
||
|
CURLFTPMETHOD_NOCWD, /* no CWD at all */
|
||
|
CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */
|
||
|
CURLFTPMETHOD_LAST /* not an option, never use */
|
||
|
} curl_ftpmethod;
|
||
|
|
||
|
/* long may be 32 or 64 bits, but we should never depend on anything else
|
||
|
but 32 */
|
||
|
#define CURLOPTTYPE_LONG 0
|
||
|
#define CURLOPTTYPE_OBJECTPOINT 10000
|
||
|
#define CURLOPTTYPE_FUNCTIONPOINT 20000
|
||
|
#define CURLOPTTYPE_OFF_T 30000
|
||
|
|
||
|
/* name is uppercase CURLOPT_<name>,
|
||
|
type is one of the defined CURLOPTTYPE_<type>
|
||
|
number is unique identifier */
|
||
|
#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
|
||
|
#else
|
||
|
/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
|
||
|
#define LONG CURLOPTTYPE_LONG
|
||
|
#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT
|
||
|
#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT
|
||
|
#define OFF_T CURLOPTTYPE_OFF_T
|
||
|
#define CINIT(name,type,number) CURLOPT_/**/name = type + number
|
||
|
#endif
|
||
|
|
||
|
/*
|
||
|
* This macro-mania below setups the CURLOPT_[what] enum, to be used with
|
||
|
* curl_easy_setopt(). The first argument in the CINIT() macro is the [what]
|
||
|
* word.
|
||
|
*/
|
||
|
|
||
|
typedef enum {
|
||
|
/* This is the FILE * or void * the regular output should be written to. */
|
||
|
CINIT(FILE, OBJECTPOINT, 1),
|
||
|
|
||
|
/* The full URL to get/put */
|
||
|
CINIT(URL, OBJECTPOINT, 2),
|
||
|
|
||
|
/* Port number to connect to, if other than default. */
|
||
|
CINIT(PORT, LONG, 3),
|
||
|
|
||
|
/* Name of proxy to use. */
|
||
|
CINIT(PROXY, OBJECTPOINT, 4),
|
||
|
|
||
|
/* "name:password" to use when fetching. */
|
||
|
CINIT(USERPWD, OBJECTPOINT, 5),
|
||
|
|
||
|
/* "name:password" to use with proxy. */
|
||
|
CINIT(PROXYUSERPWD, OBJECTPOINT, 6),
|
||
|
|
||
|
/* Range to get, specified as an ASCII string. */
|
||
|
CINIT(RANGE, OBJECTPOINT, 7),
|
||
|
|
||
|
/* not used */
|
||
|
|
||
|
/* Specified file stream to upload from (use as input): */
|
||
|
CINIT(INFILE, OBJECTPOINT, 9),
|
||
|
|
||
|
/* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE
|
||
|
* bytes big. If this is not used, error messages go to stderr instead: */
|
||
|
CINIT(ERRORBUFFER, OBJECTPOINT, 10),
|
||
|
|
||
|
/* Function that will be called to store the output (instead of fwrite). The
|
||
|
* parameters will use fwrite() syntax, make sure to follow them. */
|
||
|
CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11),
|
||
|
|
||
|
/* Function that will be called to read the input (instead of fread). The
|
||
|
* parameters will use fread() syntax, make sure to follow them. */
|
||
|
CINIT(READFUNCTION, FUNCTIONPOINT, 12),
|
||
|
|
||
|
/* Time-out the read operation after this amount of seconds */
|
||
|
CINIT(TIMEOUT, LONG, 13),
|
||
|
|
||
|
/* If the CURLOPT_INFILE is used, this can be used to inform libcurl about
|
||
|
* how large the file being sent really is. That allows better error
|
||
|
* checking and better verifies that the upload was succcessful. -1 means
|
||
|
* unknown size.
|
||
|
*
|
||
|
* For large file support, there is also a _LARGE version of the key
|
||
|
* which takes an off_t type, allowing platforms with larger off_t
|
||
|
* sizes to handle larger files. See below for INFILESIZE_LARGE.
|
||
|
*/
|
||
|
CINIT(INFILESIZE, LONG, 14),
|
||
|
|
||
|
/* POST input fields. */
|
||
|
CINIT(POSTFIELDS, OBJECTPOINT, 15),
|
||
|
|
||
|
/* Set the referer page (needed by some CGIs) */
|
||
|
CINIT(REFERER, OBJECTPOINT, 16),
|
||
|
|
||
|
/* Set the FTP PORT string (interface name, named or numerical IP address)
|
||
|
Use i.e '-' to use default address. */
|
||
|
CINIT(FTPPORT, OBJECTPOINT, 17),
|
||
|
|
||
|
/* Set the User-Agent string (examined by some CGIs) */
|
||
|
CINIT(USERAGENT, OBJECTPOINT, 18),
|
||
|
|
||
|
/* If the download receives less than "low speed limit" bytes/second
|
||
|
* during "low speed time" seconds, the operations is aborted.
|
||
|
* You could i.e if you have a pretty high speed connection, abort if
|
||
|
* it is less than 2000 bytes/sec during 20 seconds.
|
||
|
*/
|
||
|
|
||
|
/* Set the "low speed limit" */
|
||
|
CINIT(LOW_SPEED_LIMIT, LONG , 19),
|
||
|
|
||
|
/* Set the "low speed time" */
|
||
|
CINIT(LOW_SPEED_TIME, LONG, 20),
|
||
|
|
||
|
/* Set the continuation offset.
|
||
|
*
|
||
|
* Note there is also a _LARGE version of this key which uses
|
||
|
* off_t types, allowing for large file offsets on platforms which
|
||
|
* use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE.
|
||
|
*/
|
||
|
CINIT(RESUME_FROM, LONG, 21),
|
||
|
|
||
|
/* Set cookie in request: */
|
||
|
CINIT(COOKIE, OBJECTPOINT, 22),
|
||
|
|
||
|
/* 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 */
|
||
|
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),
|
||
|
|
||
|
/* send TYPE parameter? */
|
||
|
CINIT(CRLF, LONG, 27),
|
||
|
|
||
|
/* send linked-list of QUOTE commands */
|
||
|
CINIT(QUOTE, OBJECTPOINT, 28),
|
||
|
|
||
|
/* send FILE * or void * to store headers to, if you use a callback it
|
||
|
is simply passed to the callback unmodified */
|
||
|
CINIT(WRITEHEADER, OBJECTPOINT, 29),
|
||
|
|
||
|
/* point to a file to read the initial cookies from, also enables
|
||
|
"cookie awareness" */
|
||
|
CINIT(COOKIEFILE, OBJECTPOINT, 31),
|
||
|
|
||
|
/* What version to specifly try to use.
|
||
|
See CURL_SSLVERSION defines below. */
|
||
|
CINIT(SSLVERSION, LONG, 32),
|
||
|
|
||
|
/* What kind of HTTP time condition to use, see defines */
|
||
|
CINIT(TIMECONDITION, LONG, 33),
|
||
|
|
||
|
/* Time to use with the above condition. Specified in number of seconds
|
||
|
since 1 Jan 1970 */
|
||
|
CINIT(TIMEVALUE, LONG, 34),
|
||
|
|
||
|
/* 35 = OBSOLETE */
|
||
|
|
||
|
/* Custom request, for customizing the get command like
|
||
|
HTTP: DELETE, TRACE and others
|
||
|
FTP: to use a different list command
|
||
|
*/
|
||
|
CINIT(CUSTOMREQUEST, OBJECTPOINT, 36),
|
||
|
|
||
|
/* HTTP request, for odd commands like DELETE, TRACE and others */
|
||
|
CINIT(STDERR, OBJECTPOINT, 37),
|
||
|
|
||
|
/* 38 is not used */
|
||
|
|
||
|
/* 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(VERBOSE, LONG, 41), /* talk a lot */
|
||
|
CINIT(HEADER, LONG, 42), /* throw the header out too */
|
||
|
CINIT(NOPROGRESS, LONG, 43), /* shut off the progress meter */
|
||
|
CINIT(NOBODY, LONG, 44), /* use HEAD to get http document */
|
||
|
CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 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(FTPAPPEND, LONG, 50), /* Append instead of overwrite on upload! */
|
||
|
|
||
|
/* Specify whether to read the user+password from the .netrc or the URL.
|
||
|
* This must be one of the CURL_NETRC_* enums below. */
|
||
|
CINIT(NETRC, LONG, 51),
|
||
|
|
||
|
CINIT(FOLLOWLOCATION, LONG, 52), /* use Location: Luke! */
|
||
|
|
||
|
CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */
|
||
|
CINIT(PUT, LONG, 54), /* HTTP PUT */
|
||
|
|
||
|
/* 55 = OBSOLETE */
|
||
|
|
||
|
/* 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 */
|
||
|
CINIT(PROGRESSDATA, OBJECTPOINT, 57),
|
||
|
|
||
|
/* We want the referer field set automatically when following locations */
|
||
|
CINIT(AUTOREFERER, LONG, 58),
|
||
|
|
||
|
/* Port of the proxy, can be set in the proxy string as well with:
|
||
|
"[host]:[port]" */
|
||
|
CINIT(PROXYPORT, LONG, 59),
|
||
|
|
||
|
/* size of the POST input data, if strlen() is not good to use */
|
||
|
CINIT(POSTFIELDSIZE, LONG, 60),
|
||
|
|
||
|
/* tunnel non-http operations through a HTTP proxy */
|
||
|
CINIT(HTTPPROXYTUNNEL, LONG, 61),
|
||
|
|
||
|
/* Set the interface string to use as outgoing network interface */
|
||
|
CINIT(INTERFACE, 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 if we should verify the peer in ssl handshake, set 1 to verify. */
|
||
|
CINIT(SSL_VERIFYPEER, LONG, 64),
|
||
|
|
||
|
/* The CApath or CAfile used to validate the peer certificate
|
||
|
this option is used only if SSL_VERIFYPEER is true */
|
||
|
CINIT(CAINFO, OBJECTPOINT, 65),
|
||
|
|
||
|
/* 66 = OBSOLETE */
|
||
|
/* 67 = OBSOLETE */
|
||
|
|
||
|
/* Maximum number of http redirects to follow */
|
||
|
CINIT(MAXREDIRS, LONG, 68),
|
||
|
|
||
|
/* Pass a long set to 1 to get the date of the requested document (if
|
||
|
possible)! Pass a zero to shut it off. */
|
||
|
CINIT(FILETIME, LONG, 69),
|
||
|
|
||
|
/* This points to a linked list of telnet options */
|
||
|
CINIT(TELNETOPTIONS, OBJECTPOINT, 70),
|
||
|
|
||
|
/* Max amount of cached alive connections */
|
||
|
CINIT(MAXCONNECTS, LONG, 71),
|
||
|
|
||
|
/* What policy to use when closing connections when the cache is filled
|
||
|
up */
|
||
|
CINIT(CLOSEPOLICY, LONG, 72),
|
||
|
|
||
|
/* 73 = OBSOLETE */
|
||
|
|
||
|
/* Set to explicitly use a new connection for the upcoming transfer.
|
||
|
Do not use this unless you're absolutely sure of this, as it makes the
|
||
|
operation slower and is less friendly for the network. */
|
||
|
CINIT(FRESH_CONNECT, LONG, 74),
|
||
|
|
||
|
/* Set to explicitly forbid the upcoming transfer's connection to be re-used
|
||
|
when done. Do not use this unless you're absolutely sure of this, as it
|
||
|
makes the operation slower and is less friendly for the network. */
|
||
|
CINIT(FORBID_REUSE, LONG, 75),
|
||
|
|
||
|
/* Set to a file name that contains random data for libcurl to use to
|
||
|
seed the random engine when doing SSL connects. */
|
||
|
CINIT(RANDOM_FILE, OBJECTPOINT, 76),
|
||
|
|
||
|
/* 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] */
|
||
|
CINIT(CONNECTTIMEOUT, LONG, 78),
|
||
|
|
||
|
/* Function that will be called to store headers (instead of fwrite). The
|
||
|
* parameters will use fwrite() syntax, make sure to follow them. */
|
||
|
CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),
|
||
|
|
||
|
/* Set this to force the HTTP request to get back to GET. Only really usable
|
||
|
if POST, PUT or a custom request have been used first.
|
||
|
*/
|
||
|
CINIT(HTTPGET, LONG, 80),
|
||
|
|
||
|
/* Set if we should verify the Common name from the peer certificate in ssl
|
||
|
* handshake, set 1 to check existence, 2 to ensure that it matches the
|
||
|
* provided hostname. */
|
||
|
CINIT(SSL_VERIFYHOST, LONG, 81),
|
||
|
|
||
|
/* Specify which file name to write all known cookies in after completed
|
||
|
operation. Set file name to "-" (dash) to make it go to stdout. */
|
||
|
CINIT(COOKIEJAR, OBJECTPOINT, 82),
|
||
|
|
||
|
/* Specify which SSL ciphers to use */
|
||
|
CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83),
|
||
|
|
||
|
/* Specify which HTTP version to use! This must be set to one of the
|
||
|
CURL_HTTP_VERSION* enums set below. */
|
||
|
CINIT(HTTP_VERSION, LONG, 84),
|
||
|
|
||
|
/* Specificly switch on or off the FTP engine's use of the EPSV command. By
|
||
|
default, that one will always be attempted before the more traditional
|
||
|
PASV command. */
|
||
|
CINIT(FTP_USE_EPSV, LONG, 85),
|
||
|
|
||
|
/* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */
|
||
|
CINIT(SSLCERTTYPE, OBJECTPOINT, 86),
|
||
|
|
||
|
/* name of the file keeping your private SSL-key */
|
||
|
CINIT(SSLKEY, OBJECTPOINT, 87),
|
||
|
|
||
|
/* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */
|
||
|
CINIT(SSLKEYTYPE, OBJECTPOINT, 88),
|
||
|
|
||
|
/* crypto engine for the SSL-sub system */
|
||
|
CINIT(SSLENGINE, OBJECTPOINT, 89),
|
||
|
|
||
|
/* set the crypto engine for the SSL-sub system as default
|
||
|
the param has no meaning...
|
||
|
*/
|
||
|
CINIT(SSLENGINE_DEFAULT, LONG, 90),
|
||
|
|
||
|
/* Non-zero value means to use the global dns cache */
|
||
|
CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* To becomeO BSOLETE soon */
|
||
|
|
||
|
/* DNS cache timeout */
|
||
|
CINIT(DNS_CACHE_TIMEOUT, LONG, 92),
|
||
|
|
||
|
/* send linked-list of pre-transfer QUOTE commands (Wesley Laxton)*/
|
||
|
CINIT(PREQUOTE, OBJECTPOINT, 93),
|
||
|
|
||
|
/* set the debug function */
|
||
|
CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94),
|
||
|
|
||
|
/* set the data for the debug function */
|
||
|
CINIT(DEBUGDATA, OBJECTPOINT, 95),
|
||
|
|
||
|
/* mark this as start of a cookie session */
|
||
|
CINIT(COOKIESESSION, LONG, 96),
|
||
|
|
||
|
/* The CApath directory used to validate the peer certificate
|
||
|
this option is used only if SSL_VERIFYPEER is true */
|
||
|
CINIT(CAPATH, OBJECTPOINT, 97),
|
||
|
|
||
|
/* Instruct libcurl to use a smaller receive buffer */
|
||
|
CINIT(BUFFERSIZE, LONG, 98),
|
||
|
|
||
|
/* Instruct libcurl to not use any signal/alarm handlers, even when using
|
||
|
timeouts. This option is useful for multi-threaded applications.
|
||
|
See libcurl-the-guide for more background information. */
|
||
|
CINIT(NOSIGNAL, LONG, 99),
|
||
|
|
||
|
/* Provide a CURLShare for mutexing non-ts data */
|
||
|
CINIT(SHARE, OBJECTPOINT, 100),
|
||
|
|
||
|
/* indicates type of proxy. accepted values are CURLPROXY_HTTP (default),
|
||
|
CURLPROXY_SOCKS4 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),
|
||
|
|
||
|
/* Set pointer to private data */
|
||
|
CINIT(PRIVATE, OBJECTPOINT, 103),
|
||
|
|
||
|
/* Set aliases for HTTP 200 in the HTTP Response header */
|
||
|
CINIT(HTTP200ALIASES, OBJECTPOINT, 104),
|
||
|
|
||
|
/* Continue to send authentication (user+password) when following locations,
|
||
|
even when hostname changed. This can potentionally 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
|
||
|
attempted before the good old traditional PORT command. */
|
||
|
CINIT(FTP_USE_EPRT, LONG, 106),
|
||
|
|
||
|
/* Set this to a bitmask value to enable the particular authentications
|
||
|
methods you like. Use this in combination with CURLOPT_USERPWD.
|
||
|
Note that setting multiple bits may cause extra network round-trips. */
|
||
|
CINIT(HTTPAUTH, LONG, 107),
|
||
|
|
||
|
/* Set the ssl context callback function, currently only for OpenSSL ssl_ctx
|
||
|
in second argument. The function must be matching the
|
||
|
curl_ssl_ctx_callback proto. */
|
||
|
CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108),
|
||
|
|
||
|
/* Set the userdata for the ssl context callback function's third
|
||
|
argument */
|
||
|
CINIT(SSL_CTX_DATA, OBJECTPOINT, 109),
|
||
|
|
||
|
/* FTP Option that causes missing dirs to be created on the remote server */
|
||
|
CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110),
|
||
|
|
||
|
/* Set this to a bitmask value to enable the particular authentications
|
||
|
methods you like. Use this in combination with CURLOPT_PROXYUSERPWD.
|
||
|
Note that setting multiple bits may cause extra network round-trips. */
|
||
|
CINIT(PROXYAUTH, LONG, 111),
|
||
|
|
||
|
/* FTP option that changes the timeout, in seconds, associated with
|
||
|
getting a response. This is different from transfer timeout time and
|
||
|
essentially places a demand on the FTP server to acknowledge commands
|
||
|
in a timely manner. */
|
||
|
CINIT(FTP_RESPONSE_TIMEOUT, LONG , 112),
|
||
|
|
||
|
/* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to
|
||
|
tell libcurl to resolve names to those IP versions only. This only has
|
||
|
affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */
|
||
|
CINIT(IPRESOLVE, LONG, 113),
|
||
|
|
||
|
/* Set this option to limit the size of a file that will be downloaded from
|
||
|
an HTTP or FTP server.
|
||
|
|
||
|
Note there is also _LARGE version which adds large file support for
|
||
|
platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */
|
||
|
CINIT(MAXFILESIZE, LONG, 114),
|
||
|
|
||
|
/* See the comment for INFILESIZE above, but in short, specifies
|
||
|
* the size of the file being uploaded. -1 means unknown.
|
||
|
*/
|
||
|
CINIT(INFILESIZE_LARGE, OFF_T, 115),
|
||
|
|
||
|
/* Sets the continuation offset. There is also a LONG version of this;
|
||
|
* look above for RESUME_FROM.
|
||
|
*/
|
||
|
CINIT(RESUME_FROM_LARGE, OFF_T, 116),
|
||
|
|
||
|
/* Sets the maximum size of data that will be downloaded from
|
||
|
* an HTTP or FTP server. See MAXFILESIZE above for the LONG version.
|
||
|
*/
|
||
|
CINIT(MAXFILESIZE_LARGE, OFF_T, 117),
|
||
|
|
||
|
/* Set this option to the file name of your .netrc file you want libcurl
|
||
|
to parse (using the CURLOPT_NETRC option). If not set, libcurl will do
|
||
|
a poor attempt to find the user's home directory and check for a .netrc
|
||
|
file in there. */
|
||
|
CINIT(NETRC_FILE, 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
|
||
|
*/
|
||
|
CINIT(FTP_SSL, LONG, 119),
|
||
|
|
||
|
/* The _LARGE version of the standard POSTFIELDSIZE option */
|
||
|
CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120),
|
||
|
|
||
|
/* Enable/disable the TCP Nagle algorithm */
|
||
|
CINIT(TCP_NODELAY, LONG, 121),
|
||
|
|
||
|
/* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
|
||
|
|
||
|
/* When doing 3rd party transfer, set the source user and password with
|
||
|
this */
|
||
|
CINIT(SOURCE_USERPWD, OBJECTPOINT, 123),
|
||
|
|
||
|
/* 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 */
|
||
|
|
||
|
/* 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
|
||
|
can be used to change libcurl's default action which is to first try
|
||
|
"AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK
|
||
|
response has been received.
|
||
|
|
||
|
Available parameters are:
|
||
|
CURLFTPAUTH_DEFAULT - let libcurl decide
|
||
|
CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS
|
||
|
CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL
|
||
|
*/
|
||
|
CINIT(FTPSSLAUTH, LONG, 129),
|
||
|
|
||
|
CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130),
|
||
|
CINIT(IOCTLDATA, OBJECTPOINT, 131),
|
||
|
|
||
|
/* 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),
|
||
|
|
||
|
/* zero terminated string for pass on to the FTP server when asked for
|
||
|
"account" info */
|
||
|
CINIT(FTP_ACCOUNT, OBJECTPOINT, 134),
|
||
|
|
||
|
/* feed cookies into cookie engine */
|
||
|
CINIT(COOKIELIST, OBJECTPOINT, 135),
|
||
|
|
||
|
/* ignore Content-Length */
|
||
|
CINIT(IGNORE_CONTENT_LENGTH, LONG, 136),
|
||
|
|
||
|
/* Set to non-zero to skip the IP address received in a 227 PASV FTP server
|
||
|
response. Typically used for FTP-SSL purposes but is not restricted to
|
||
|
that. libcurl will then instead use the same IP address it used for the
|
||
|
control connection. */
|
||
|
CINIT(FTP_SKIP_PASV_IP, LONG, 137),
|
||
|
|
||
|
/* Select "file method" to use when doing FTP, see the curl_ftpmethod
|
||
|
above. */
|
||
|
CINIT(FTP_FILEMETHOD, LONG, 138),
|
||
|
|
||
|
/* Local port number to bind the socket to */
|
||
|
CINIT(LOCALPORT, LONG, 139),
|
||
|
|
||
|
/* Number of ports to try, including the first one set with LOCALPORT.
|
||
|
Thus, setting it to 1 will make no additional attempts but the first.
|
||
|
*/
|
||
|
CINIT(LOCALPORTRANGE, LONG, 140),
|
||
|
|
||
|
/* no transfer, set up connection and let application use the socket by
|
||
|
extracting it with CURLINFO_LASTSOCKET */
|
||
|
CINIT(CONNECT_ONLY, LONG, 141),
|
||
|
|
||
|
/* Function that will be called to convert from the
|
||
|
network encoding (instead of using the iconv calls in libcurl) */
|
||
|
CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142),
|
||
|
|
||
|
/* Function that will be called to convert to the
|
||
|
network encoding (instead of using the iconv calls in libcurl) */
|
||
|
CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143),
|
||
|
|
||
|
/* Function that will be called to convert from UTF8
|
||
|
(instead of using the iconv calls in libcurl)
|
||
|
Note that this is used only for SSL certificate processing */
|
||
|
CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144),
|
||
|
|
||
|
/* if the connection proceeds too quickly then need to slow it down */
|
||
|
/* limit-rate: maximum number of bytes per second to send or receive */
|
||
|
CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145),
|
||
|
CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146),
|
||
|
|
||
|
/* Pointer to command string to send if USER/PASS fails. */
|
||
|
CINIT(FTP_ALTERNATIVE_TO_USER, OBJECTPOINT, 147),
|
||
|
|
||
|
CURLOPT_LASTENTRY /* the last unused */
|
||
|
} CURLoption;
|
||
|
|
||
|
/* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host
|
||
|
name resolves addresses using more than one IP protocol version, this
|
||
|
option might be handy to force libcurl to use a specific IP version. */
|
||
|
#define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP
|
||
|
versions that your system allows */
|
||
|
#define CURL_IPRESOLVE_V4 1 /* resolve to ipv4 addresses */
|
||
|
#define CURL_IPRESOLVE_V6 2 /* resolve to ipv6 addresses */
|
||
|
|
||
|
/* three convenient "aliases" that follow the name scheme better */
|
||
|
#define CURLOPT_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
|
||
|
|
||
|
|
||
|
/* These enums are for use with the CURLOPT_HTTP_VERSION option. */
|
||
|
enum {
|
||
|
CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd
|
||
|
like the library to choose the best possible
|
||
|
for us! */
|
||
|
CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */
|
||
|
CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */
|
||
|
|
||
|
CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */
|
||
|
};
|
||
|
|
||
|
/* These enums are for use with the CURLOPT_NETRC option. */
|
||
|
enum CURL_NETRC_OPTION {
|
||
|
CURL_NETRC_IGNORED, /* The .netrc will never be read.
|
||
|
* This is the default. */
|
||
|
CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred
|
||
|
* to one in the .netrc. */
|
||
|
CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored.
|
||
|
* Unless one is set programmatically, the .netrc
|
||
|
* will be queried. */
|
||
|
CURL_NETRC_LAST
|
||
|
};
|
||
|
|
||
|
enum {
|
||
|
CURL_SSLVERSION_DEFAULT,
|
||
|
CURL_SSLVERSION_TLSv1,
|
||
|
CURL_SSLVERSION_SSLv2,
|
||
|
CURL_SSLVERSION_SSLv3,
|
||
|
|
||
|
CURL_SSLVERSION_LAST /* never use, keep last */
|
||
|
};
|
||
|
|
||
|
|
||
|
typedef enum {
|
||
|
CURL_TIMECOND_NONE,
|
||
|
|
||
|
CURL_TIMECOND_IFMODSINCE,
|
||
|
CURL_TIMECOND_IFUNMODSINCE,
|
||
|
CURL_TIMECOND_LASTMOD,
|
||
|
|
||
|
CURL_TIMECOND_LAST
|
||
|
} curl_TimeCond;
|
||
|
|
||
|
#ifdef __BEOS__
|
||
|
#include <support/SupportDefs.h>
|
||
|
#endif
|
||
|
|
||
|
|
||
|
/* curl_strequal() and curl_strnequal() are subject for removal in a future
|
||
|
libcurl, see lib/README.curlx for details */
|
||
|
CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2);
|
||
|
CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n);
|
||
|
|
||
|
/* name is uppercase CURLFORM_<name> */
|
||
|
#ifdef CFINIT
|
||
|
#undef CFINIT
|
||
|
#endif
|
||
|
|
||
|
#ifdef CURL_ISOCPP
|
||
|
#define CFINIT(name) CURLFORM_ ## name
|
||
|
#else
|
||
|
/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
|
||
|
#define CFINIT(name) CURLFORM_/**/name
|
||
|
#endif
|
||
|
|
||
|
typedef enum {
|
||
|
CFINIT(NOTHING), /********* the first one is unused ************/
|
||
|
|
||
|
/* */
|
||
|
CFINIT(COPYNAME),
|
||
|
CFINIT(PTRNAME),
|
||
|
CFINIT(NAMELENGTH),
|
||
|
CFINIT(COPYCONTENTS),
|
||
|
CFINIT(PTRCONTENTS),
|
||
|
CFINIT(CONTENTSLENGTH),
|
||
|
CFINIT(FILECONTENT),
|
||
|
CFINIT(ARRAY),
|
||
|
CFINIT(OBSOLETE),
|
||
|
CFINIT(FILE),
|
||
|
|
||
|
CFINIT(BUFFER),
|
||
|
CFINIT(BUFFERPTR),
|
||
|
CFINIT(BUFFERLENGTH),
|
||
|
|
||
|
CFINIT(CONTENTTYPE),
|
||
|
CFINIT(CONTENTHEADER),
|
||
|
CFINIT(FILENAME),
|
||
|
CFINIT(END),
|
||
|
CFINIT(OBSOLETE2),
|
||
|
|
||
|
CURLFORM_LASTENTRY /* the last unusued */
|
||
|
} CURLformoption;
|
||
|
|
||
|
#undef CFINIT /* done */
|
||
|
|
||
|
/* structure to be used as parameter for CURLFORM_ARRAY */
|
||
|
struct curl_forms {
|
||
|
CURLformoption option;
|
||
|
const char *value;
|
||
|
};
|
||
|
|
||
|
/* use this for multipart formpost building */
|
||
|
/* Returns code for curl_formadd()
|
||
|
*
|
||
|
* Returns:
|
||
|
* CURL_FORMADD_OK on success
|
||
|
* CURL_FORMADD_MEMORY if the FormInfo allocation fails
|
||
|
* CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form
|
||
|
* CURL_FORMADD_NULL if a null pointer was given for a char
|
||
|
* CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed
|
||
|
* CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used
|
||
|
* CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error)
|
||
|
* CURL_FORMADD_MEMORY if a HttpPost struct cannot be allocated
|
||
|
* CURL_FORMADD_MEMORY if some allocation for string copying failed.
|
||
|
* CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array
|
||
|
*
|
||
|
***************************************************************************/
|
||
|
typedef enum {
|
||
|
CURL_FORMADD_OK, /* first, no error */
|
||
|
|
||
|
CURL_FORMADD_MEMORY,
|
||
|
CURL_FORMADD_OPTION_TWICE,
|
||
|
CURL_FORMADD_NULL,
|
||
|
CURL_FORMADD_UNKNOWN_OPTION,
|
||
|
CURL_FORMADD_INCOMPLETE,
|
||
|
CURL_FORMADD_ILLEGAL_ARRAY,
|
||
|
CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */
|
||
|
|
||
|
CURL_FORMADD_LAST /* last */
|
||
|
} CURLFORMcode;
|
||
|
|
||
|
/*
|
||
|
* NAME curl_formadd()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* Pretty advanved function for building multi-part formposts. Each invoke
|
||
|
* adds one part that together construct a full post. Then use
|
||
|
* CURLOPT_HTTPPOST to send it off to libcurl.
|
||
|
*/
|
||
|
CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost,
|
||
|
struct curl_httppost **last_post,
|
||
|
...);
|
||
|
|
||
|
/*
|
||
|
* callback function for curl_formget()
|
||
|
* The void *arg pointer will be the one passed as second argument to curl_formget().
|
||
|
* The character buffer passed to it must not be freed.
|
||
|
* Should return the buffer length passed to it as the argument "len" on success.
|
||
|
*/
|
||
|
typedef size_t (*curl_formget_callback)(void *arg, const char *buf, size_t len);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_formget()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* Serialize a curl_httppost struct built with curl_formadd().
|
||
|
* Accepts a void pointer as second argument which will be passed to
|
||
|
* the curl_formget_callback function.
|
||
|
* Returns 0 on success.
|
||
|
*/
|
||
|
CURL_EXTERN int curl_formget(struct curl_httppost *form, void *arg,
|
||
|
curl_formget_callback append);
|
||
|
/*
|
||
|
* NAME curl_formfree()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* Free a multipart formpost previously built with curl_formadd().
|
||
|
*/
|
||
|
CURL_EXTERN void curl_formfree(struct curl_httppost *form);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_getenv()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* Returns a malloc()'ed string that MUST be curl_free()ed after usage is
|
||
|
* complete. DEPRECATED - see lib/README.curlx
|
||
|
*/
|
||
|
CURL_EXTERN char *curl_getenv(const char *variable);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_version()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* Returns a static ascii string of the libcurl version.
|
||
|
*/
|
||
|
CURL_EXTERN char *curl_version(void);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_easy_escape()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* Escapes URL strings (converts all letters consider illegal in URLs to their
|
||
|
* %XX versions). This function returns a new allocated string or NULL if an
|
||
|
* error occurred.
|
||
|
*/
|
||
|
CURL_EXTERN char *curl_easy_escape(CURL *handle,
|
||
|
const char *string,
|
||
|
int length);
|
||
|
|
||
|
/* the previous version: */
|
||
|
CURL_EXTERN char *curl_escape(const char *string,
|
||
|
int length);
|
||
|
|
||
|
|
||
|
/*
|
||
|
* NAME curl_easy_unescape()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* Unescapes URL encoding in strings (converts all %XX codes to their 8bit
|
||
|
* versions). This function returns a new allocated string or NULL if an error
|
||
|
* occurred.
|
||
|
* Conversion Note: On non-ASCII platforms the ASCII %XX codes are
|
||
|
* converted into the host encoding.
|
||
|
*/
|
||
|
CURL_EXTERN char *curl_easy_unescape(CURL *handle,
|
||
|
const char *string,
|
||
|
int length,
|
||
|
int *outlength);
|
||
|
|
||
|
/* the previous version */
|
||
|
CURL_EXTERN char *curl_unescape(const char *string,
|
||
|
int length);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_free()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* Provided for de-allocation in the same translation unit that did the
|
||
|
* allocation. Added in libcurl 7.10
|
||
|
*/
|
||
|
CURL_EXTERN void curl_free(void *p);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_global_init()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* curl_global_init() should be invoked exactly once for each application that
|
||
|
* uses libcurl
|
||
|
*/
|
||
|
CURL_EXTERN CURLcode curl_global_init(long flags);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_global_init_mem()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* curl_global_init() or curl_global_init_mem() should be invoked exactly once
|
||
|
* for each application that uses libcurl. This function can be used to
|
||
|
* initialize libcurl and set user defined memory management callback
|
||
|
* functions. Users can implement memory management routines to check for
|
||
|
* memory leaks, check for mis-use of the curl library etc. User registered
|
||
|
* callback routines with be invoked by this library instead of the system
|
||
|
* memory management routines like malloc, free etc.
|
||
|
*/
|
||
|
CURL_EXTERN CURLcode curl_global_init_mem(long flags,
|
||
|
curl_malloc_callback m,
|
||
|
curl_free_callback f,
|
||
|
curl_realloc_callback r,
|
||
|
curl_strdup_callback s,
|
||
|
curl_calloc_callback c);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_global_cleanup()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* curl_global_cleanup() should be invoked exactly once for each application
|
||
|
* that uses libcurl
|
||
|
*/
|
||
|
CURL_EXTERN void curl_global_cleanup(void);
|
||
|
|
||
|
/* linked-list structure for the CURLOPT_QUOTE option (and other) */
|
||
|
struct curl_slist {
|
||
|
char *data;
|
||
|
struct curl_slist *next;
|
||
|
};
|
||
|
|
||
|
/*
|
||
|
* NAME curl_slist_append()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* Appends a string to a linked list. If no list exists, it will be created
|
||
|
* first. Returns the new list, after appending.
|
||
|
*/
|
||
|
CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *,
|
||
|
const char *);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_slist_free_all()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* free a previously built curl_slist.
|
||
|
*/
|
||
|
CURL_EXTERN void curl_slist_free_all(struct curl_slist *);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_getdate()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* Returns the time, in seconds since 1 Jan 1970 of the time string given in
|
||
|
* the first argument. The time argument in the second parameter is unused
|
||
|
* and should be set to NULL.
|
||
|
*/
|
||
|
CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused);
|
||
|
|
||
|
#define CURLINFO_STRING 0x100000
|
||
|
#define CURLINFO_LONG 0x200000
|
||
|
#define CURLINFO_DOUBLE 0x300000
|
||
|
#define CURLINFO_SLIST 0x400000
|
||
|
#define CURLINFO_MASK 0x0fffff
|
||
|
#define CURLINFO_TYPEMASK 0xf00000
|
||
|
|
||
|
typedef enum {
|
||
|
CURLINFO_NONE, /* first, never use this */
|
||
|
CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1,
|
||
|
CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2,
|
||
|
CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3,
|
||
|
CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4,
|
||
|
CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5,
|
||
|
CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
|
||
|
CURLINFO_SIZE_UPLOAD = CURLINFO_DOUBLE + 7,
|
||
|
CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8,
|
||
|
CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9,
|
||
|
CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10,
|
||
|
CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11,
|
||
|
CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12,
|
||
|
CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13,
|
||
|
CURLINFO_FILETIME = CURLINFO_LONG + 14,
|
||
|
CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15,
|
||
|
CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16,
|
||
|
CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
|
||
|
CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18,
|
||
|
CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19,
|
||
|
CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20,
|
||
|
CURLINFO_PRIVATE = CURLINFO_STRING + 21,
|
||
|
CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22,
|
||
|
CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23,
|
||
|
CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24,
|
||
|
CURLINFO_OS_ERRNO = CURLINFO_LONG + 25,
|
||
|
CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26,
|
||
|
CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27,
|
||
|
CURLINFO_COOKIELIST = CURLINFO_SLIST + 28,
|
||
|
CURLINFO_LASTSOCKET = CURLINFO_LONG + 29,
|
||
|
CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30,
|
||
|
/* Fill in new entries below here! */
|
||
|
|
||
|
CURLINFO_LASTONE = 30
|
||
|
} CURLINFO;
|
||
|
|
||
|
/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as
|
||
|
CURLINFO_HTTP_CODE */
|
||
|
#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE
|
||
|
|
||
|
typedef enum {
|
||
|
CURLCLOSEPOLICY_NONE, /* first, never use this */
|
||
|
|
||
|
CURLCLOSEPOLICY_OLDEST,
|
||
|
CURLCLOSEPOLICY_LEAST_RECENTLY_USED,
|
||
|
CURLCLOSEPOLICY_LEAST_TRAFFIC,
|
||
|
CURLCLOSEPOLICY_SLOWEST,
|
||
|
CURLCLOSEPOLICY_CALLBACK,
|
||
|
|
||
|
CURLCLOSEPOLICY_LAST /* last, never use this */
|
||
|
} curl_closepolicy;
|
||
|
|
||
|
#define CURL_GLOBAL_SSL (1<<0)
|
||
|
#define CURL_GLOBAL_WIN32 (1<<1)
|
||
|
#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32)
|
||
|
#define CURL_GLOBAL_NOTHING 0
|
||
|
#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL
|
||
|
|
||
|
|
||
|
/*****************************************************************************
|
||
|
* Setup defines, protos etc for the sharing stuff.
|
||
|
*/
|
||
|
|
||
|
/* Different data locks for a single share */
|
||
|
typedef enum {
|
||
|
CURL_LOCK_DATA_NONE = 0,
|
||
|
/* CURL_LOCK_DATA_SHARE is used internaly to say that
|
||
|
* the locking is just made to change the internal state of the share
|
||
|
* itself.
|
||
|
*/
|
||
|
CURL_LOCK_DATA_SHARE,
|
||
|
CURL_LOCK_DATA_COOKIE,
|
||
|
CURL_LOCK_DATA_DNS,
|
||
|
CURL_LOCK_DATA_SSL_SESSION,
|
||
|
CURL_LOCK_DATA_CONNECT,
|
||
|
CURL_LOCK_DATA_LAST
|
||
|
} curl_lock_data;
|
||
|
|
||
|
/* Different lock access types */
|
||
|
typedef enum {
|
||
|
CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */
|
||
|
CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */
|
||
|
CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */
|
||
|
CURL_LOCK_ACCESS_LAST /* never use */
|
||
|
} curl_lock_access;
|
||
|
|
||
|
typedef void (*curl_lock_function)(CURL *handle,
|
||
|
curl_lock_data data,
|
||
|
curl_lock_access locktype,
|
||
|
void *userptr);
|
||
|
typedef void (*curl_unlock_function)(CURL *handle,
|
||
|
curl_lock_data data,
|
||
|
void *userptr);
|
||
|
|
||
|
typedef void CURLSH;
|
||
|
|
||
|
typedef enum {
|
||
|
CURLSHE_OK, /* all is fine */
|
||
|
CURLSHE_BAD_OPTION, /* 1 */
|
||
|
CURLSHE_IN_USE, /* 2 */
|
||
|
CURLSHE_INVALID, /* 3 */
|
||
|
CURLSHE_NOMEM, /* out of memory */
|
||
|
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_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */
|
||
|
CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */
|
||
|
CURLSHOPT_USERDATA, /* pass in a user data pointer used in the lock/unlock
|
||
|
callback functions */
|
||
|
CURLSHOPT_LAST /* never use */
|
||
|
} CURLSHoption;
|
||
|
|
||
|
CURL_EXTERN CURLSH *curl_share_init(void);
|
||
|
CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...);
|
||
|
CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *);
|
||
|
|
||
|
/****************************************************************************
|
||
|
* Structures for querying information about the curl library at runtime.
|
||
|
*/
|
||
|
|
||
|
typedef enum {
|
||
|
CURLVERSION_FIRST,
|
||
|
CURLVERSION_SECOND,
|
||
|
CURLVERSION_THIRD,
|
||
|
CURLVERSION_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
|
||
|
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
|
||
|
|
||
|
typedef struct {
|
||
|
CURLversion age; /* age of the returned struct */
|
||
|
const char *version; /* LIBCURL_VERSION */
|
||
|
unsigned int version_num; /* LIBCURL_VERSION_NUM */
|
||
|
const char *host; /* OS/host/cpu/machine when configured */
|
||
|
int features; /* bitmask, see defines below */
|
||
|
const char *ssl_version; /* human readable string */
|
||
|
long ssl_version_num; /* not used anymore, always 0 */
|
||
|
const char *libz_version; /* human readable string */
|
||
|
/* protocols is terminated by an entry with a NULL protoname */
|
||
|
const char * const *protocols;
|
||
|
|
||
|
/* The fields below this were added in CURLVERSION_SECOND */
|
||
|
const char *ares;
|
||
|
int ares_num;
|
||
|
|
||
|
/* This field was added in CURLVERSION_THIRD */
|
||
|
const char *libidn;
|
||
|
|
||
|
/* Same as '_libiconv_version' if built with HAVE_ICONV */
|
||
|
int iconv_ver_num;
|
||
|
} curl_version_info_data;
|
||
|
|
||
|
#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */
|
||
|
#define CURL_VERSION_KERBEROS4 (1<<1) /* kerberos auth is supported */
|
||
|
#define CURL_VERSION_SSL (1<<2) /* SSL options are present */
|
||
|
#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */
|
||
|
#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */
|
||
|
#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth support */
|
||
|
#define CURL_VERSION_DEBUG (1<<6) /* built with debug capabilities */
|
||
|
#define CURL_VERSION_ASYNCHDNS (1<<7) /* asynchronous dns resolves */
|
||
|
#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth */
|
||
|
#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 */
|
||
|
|
||
|
/*
|
||
|
* NAME curl_version_info()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* This function returns a pointer to a static copy of the version info
|
||
|
* struct. See above.
|
||
|
*/
|
||
|
CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_easy_strerror()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* The curl_easy_strerror function may be used to turn a CURLcode value
|
||
|
* into the equivalent human readable error string. This is useful
|
||
|
* for printing meaningful error messages.
|
||
|
*/
|
||
|
CURL_EXTERN const char *curl_easy_strerror(CURLcode);
|
||
|
|
||
|
/*
|
||
|
* NAME curl_share_strerror()
|
||
|
*
|
||
|
* DESCRIPTION
|
||
|
*
|
||
|
* The curl_share_strerror function may be used to turn a CURLSHcode value
|
||
|
* into the equivalent human readable error string. This is useful
|
||
|
* for printing meaningful error messages.
|
||
|
*/
|
||
|
CURL_EXTERN const char *curl_share_strerror(CURLSHcode);
|
||
|
|
||
|
#ifdef __cplusplus
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
/* unfortunately, the easy.h and multi.h include files need options and info
|
||
|
stuff before they can be included! */
|
||
|
#include "easy.h" /* nothing in curl is fun without the easy stuff */
|
||
|
#include "multi.h"
|
||
|
|
||
|
#endif /* __CURL_CURL_H */
|