| #ifndef __CURL_CURL_H |
| #define __CURL_CURL_H |
| /*************************************************************************** |
| * _ _ ____ _ |
| * Project ___| | | | _ \| | |
| * / __| | | | |_) | | |
| * | (__| |_| | _ <| |___ |
| * \___|\___/|_| \_\_____| |
| * |
| * Copyright (C) 1998 - 2003, 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/ |
| */ |
| |
| /* This is the version number of the libcurl package from which this header |
| file origins: */ |
| #define LIBCURL_VERSION "7.10.7-pre4" |
| |
| /* This is the numeric version of the libcurl version number, meant for easier |
| parsing and comparions by programs. The LIBCURL_VERSION_NUM define will |
| always follow this syntax: |
| |
| 0xXXYYZZ |
| |
| Where XX, YY and ZZ are the main version, release and patch numbers in |
| hexadecimal. All three numbers are always represented using two digits. 1.2 |
| would appear as "0x010200" while version 9.11.7 appears as "0x090b07". |
| |
| This 6-digit hexadecimal number does not show pre-release number, and it is |
| always a greater number in a more recent release. It makes comparisons with |
| greater than and less than work. |
| */ |
| #define LIBCURL_VERSION_NUM 0x070a07 |
| |
| #include <stdio.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) */ |
| |
| #ifndef TRUE |
| #define TRUE 1 |
| #endif |
| #ifndef FALSE |
| #define FALSE 0 |
| #endif |
| |
| #include "types.h" |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /* silly trick to preserve functionality with older code, but making it use |
| our name space for the future */ |
| #define HttpPost curl_httppost |
| |
| 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); |
| |
| typedef int (*curl_passwd_callback)(void *clientp, |
| const char *prompt, |
| char *buffer, |
| int buflen); |
| |
| /* 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 */ |
| 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 - user name is illegally specified */ |
| 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 */ |
| CURLE_HTTP_PORT_FAILED, /* 45 - HTTP Interface operation failed */ |
| CURLE_BAD_PASSWORD_ENTERED, /* 46 - my_getpass() returns fail */ |
| 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 - removed after 7.7.3 */ |
| 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 */ |
| |
| 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 |
| #define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR |
| |
| 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 |
| |
| /* 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 |
| |
| /* 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__) |
| /* 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 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 { |
| CINIT(NOTHING, LONG, 0), /********* the first one is unused ************/ |
| |
| /* 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. */ |
| 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 */ |
| 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), |
| |
| /* HTTP request, for odd commands like DELETE, TRACE and others */ |
| /* OBSOLETE DEFINE, left for tradition only */ |
| CINIT(HTTPREQUEST, OBJECTPOINT, 35), |
| |
| /* 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! */ |
| |
| /* This FTPASCII name is now obsolete, to be removed, use the TRANSFERTEXT |
| instead. It goes for more protocols than just ftp... */ |
| CINIT(FTPASCII, LONG, 53), /* use TYPE A for transfer */ |
| |
| CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */ |
| CINIT(PUT, LONG, 54), /* PUT the input file */ |
| |
| CINIT(MUTE, LONG, 55), /* OBSOLETE OPTION, removed in 7.8 */ |
| |
| /* 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), |
| |
| /* Function pointer to replace the internal password prompt */ |
| CINIT(PASSWDFUNCTION, FUNCTIONPOINT, 66), |
| |
| /* Custom pointer that gets passed as first argument to the password |
| function */ |
| CINIT(PASSWDDATA, OBJECTPOINT, 67), |
| |
| /* 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), |
| |
| /* Callback to use when CURLCLOSEPOLICY_CALLBACK is set */ |
| CINIT(CLOSEFUNCTION, FUNCTIONPOINT, 73), |
| |
| /* 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), |
| |
| /* 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), |
| |
| CURLOPT_LASTENTRY /* the last unused */ |
| } CURLoption; |
| |
| /* two convenient "aliases" that follow the name scheme better */ |
| #define CURLOPT_WRITEDATA CURLOPT_FILE |
| #define CURLOPT_READDATA CURLOPT_INFILE |
| #define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER |
| |
| |
| /* 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; |
| |
| /* for backwards compatibility */ |
| #ifndef TIMECOND_IFMODSINCE |
| #define TIMECOND_IFMODSINCE CURL_TIMECOND_IFMODSINCE |
| #endif |
| #ifndef TIMECOND_IFUNMODSINCE |
| #define TIMECOND_IFUNMODSINCE CURL_TIMECOND_IFUNMODSINCE |
| #endif |
| #ifndef TIMECOND_LASTMOD |
| #define TIMECOND_LASTMOD CURL_TIMECOND_LASTMOD |
| #endif |
| |
| #ifdef __BEOS__ |
| #include <support/SupportDefs.h> |
| #endif |
| |
| |
| /* These functions are in libcurl, they're here for portable reasons and they |
| are used by the 'curl' client. They really should be moved to some kind of |
| "portability library" since it has nothing to do with file transfers and |
| might be usable to other programs... |
| |
| NOTE: they return TRUE if the strings match *case insensitively*. |
| */ |
| extern int (curl_strequal)(const char *s1, const char *s2); |
| extern int (curl_strnequal)(const char *s1, const char *s2, size_t n); |
| |
| #ifdef CURL_OLDSTYLE |
| /* DEPRECATED function to build formdata. Stop using this, it will cease |
| to exist. */ |
| int curl_formparse(char *, struct curl_httppost **, |
| struct curl_httppost **_post); |
| #endif |
| |
| /* 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. |
| */ |
| 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_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_HTTP_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, |
| /* Fill in new entries below here! */ |
| |
| CURLINFO_LASTONE = 23 |
| } CURLINFO; |
| |
| 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 access, |
| 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_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_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_FIRST |
| |
| 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; |
| } curl_version_info_data; |
| |
| #define CURL_VERSION_IPV6 (1<<0) |
| #define CURL_VERSION_KERBEROS4 (1<<1) |
| #define CURL_VERSION_SSL (1<<2) |
| #define CURL_VERSION_LIBZ (1<<3) |
| #define CURL_VERSION_NTLM (1<<4) |
| #define CURL_VERSION_GSSNEGOTIATE (1<<5) |
| #define CURL_VERSION_DEBUG (1<<6) /* built with debug capabilities */ |
| #define CURL_VERSION_ASYNCHDNS (1<<7) |
| |
| /* |
| * 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); |
| |
| #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 */ |