mirror of
https://github.com/moparisthebest/curl
synced 2024-10-31 15:45:12 -04:00
1335 lines
47 KiB
C
1335 lines
47 KiB
C
#ifndef __CURL_CURL_H
|
|
#define __CURL_CURL_H
|
|
/***************************************************************************
|
|
* _ _ ____ _
|
|
* Project ___| | | | _ \| |
|
|
* / __| | | | |_) | |
|
|
* | (__| |_| | _ <| |___
|
|
* \___|\___/|_| \_\_____|
|
|
*
|
|
* Copyright (C) 1998 - 2004, 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$
|
|
***************************************************************************/
|
|
|
|
/* 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
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
#if defined(_MSC_VER) || defined(__LCC__)
|
|
/* MSVC */
|
|
typedef signed __int64 curl_off_t;
|
|
#define CURL_FORMAT_OFF_T "%I64d"
|
|
#else /* _MSC_VER || __LCC__ */
|
|
#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 || __LCC__ */
|
|
|
|
#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);
|
|
|
|
typedef size_t (*curl_read_callback)(char *buffer,
|
|
size_t size,
|
|
size_t nitems,
|
|
void *instream);
|
|
|
|
/* 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);
|
|
|
|
/*
|
|
* 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_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 */
|
|
CURLE_FTP_USER_PASSWORD_INCORRECT, /* 10 */
|
|
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 */
|
|
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 */
|
|
|
|
CURL_LAST /* never use! */
|
|
} CURLcode;
|
|
|
|
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
|
|
|
|
/* backwards compatibility with older names */
|
|
#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR
|
|
#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED
|
|
|
|
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)
|
|
|
|
/* 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
|
|
|
|
/* This is 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
|
|
|
|
#define CURL_ERROR_SIZE 256
|
|
|
|
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;
|
|
|
|
/* 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__)
|
|
/* 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 pointer to a time_t to get a possible date of the requested
|
|
document! Pass a NULL to shut it off. */
|
|
CINIT(FILETIME, OBJECTPOINT, 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 become OBSOLETE 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),
|
|
|
|
/* When doing 3rd party transfer, set the source host name with this */
|
|
CINIT(SOURCE_HOST, OBJECTPOINT, 122),
|
|
|
|
/* When doing 3rd party transfer, set the source user and password with
|
|
this */
|
|
CINIT(SOURCE_USERPWD, OBJECTPOINT, 123),
|
|
|
|
/* When doing 3rd party transfer, set the source file path with this */
|
|
CINIT(SOURCE_PATH, OBJECTPOINT, 124),
|
|
|
|
/* When doing 3rd party transfer, set the source server's port number
|
|
with this */
|
|
CINIT(SOURCE_PORT, LONG, 125),
|
|
|
|
/* When doing 3rd party transfer, decide which server that should get the
|
|
PASV command (and the other gets the PORT).
|
|
0 (default) - The target host issues PASV.
|
|
1 - The source host issues PASV */
|
|
CINIT(PASV_HOST, LONG, 126),
|
|
|
|
/* 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),
|
|
|
|
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
|
|
|
|
#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 */
|
|
extern int (curl_strequal)(const char *s1, const char *s2);
|
|
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_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.
|
|
*/
|
|
CURLFORMcode curl_formadd(struct curl_httppost **httppost,
|
|
struct curl_httppost **last_post,
|
|
...);
|
|
|
|
/*
|
|
* NAME curl_formfree()
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* Free a multipart formpost previously built with curl_formadd().
|
|
*/
|
|
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
|
|
*/
|
|
char *curl_getenv(const char *variable);
|
|
|
|
/*
|
|
* NAME curl_version()
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* Returns a static ascii string of the libcurl version.
|
|
*/
|
|
char *curl_version(void);
|
|
|
|
/*
|
|
* NAME curl_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.
|
|
*/
|
|
char *curl_escape(const char *string, int length);
|
|
|
|
/*
|
|
* NAME curl_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.
|
|
*/
|
|
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
|
|
*/
|
|
void curl_free(void *p);
|
|
|
|
/*
|
|
* NAME curl_global_init()
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* curl_global_init() should be invoked exactly once for each application that
|
|
* uses libcurl
|
|
*/
|
|
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.
|
|
*/
|
|
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
|
|
*/
|
|
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.
|
|
*/
|
|
struct curl_slist *curl_slist_append(struct curl_slist *, const char *);
|
|
|
|
/*
|
|
* NAME curl_slist_free_all()
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* free a previously built curl_slist.
|
|
*/
|
|
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 for cases
|
|
* where the specified time is relative now, like 'two weeks' or 'tomorrow'
|
|
* etc.
|
|
*/
|
|
time_t curl_getdate(const char *p, const time_t *now);
|
|
|
|
#define CURLINFO_STRING 0x100000
|
|
#define CURLINFO_LONG 0x200000
|
|
#define CURLINFO_DOUBLE 0x300000
|
|
#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,
|
|
/* Fill in new entries below here! */
|
|
|
|
CURLINFO_LASTONE = 23
|
|
} 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;
|
|
|
|
CURLSH *curl_share_init(void);
|
|
CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...);
|
|
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 redfine 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 */
|
|
char *ssl_version; /* human readable string */
|
|
long ssl_version_num; /* number */
|
|
const char *libz_version; /* human readable string */
|
|
/* protocols is terminated by an entry with a NULL protoname */
|
|
const char **protocols;
|
|
|
|
/* The fields below this were added in CURLVERSION_SECOND */
|
|
const char *ares;
|
|
int ares_num;
|
|
|
|
/* This field was aded in CURLVERSION_THIRD */
|
|
const char *libidn;
|
|
} 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 */
|
|
|
|
/*
|
|
* NAME curl_version_info()
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* This function returns a pointer to a static copy of the version info
|
|
* struct. See above.
|
|
*/
|
|
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.
|
|
*/
|
|
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.
|
|
*/
|
|
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 */
|