Mercurial > hg > CbC > CbC_gcc
diff libphobos/src/etc/c/curl.d @ 145:1830386684a0
gcc-9.2.0
| author | anatofuz |
|---|---|
| date | Thu, 13 Feb 2020 11:34:05 +0900 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libphobos/src/etc/c/curl.d Thu Feb 13 11:34:05 2020 +0900 @@ -0,0 +1,2336 @@ +/** + This is an interface to the libcurl library. + + Converted to D from curl headers by $(LINK2 http://www.digitalmars.com/d/2.0/htod.html, htod) and + cleaned up by Jonas Drewsen (jdrewsen) + + Windows x86 note: + A DMD compatible libcurl static library can be downloaded from the dlang.org + $(LINK2 http://dlang.org/download.html, download page). +*/ + +/* ************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + */ + +/** + * Copyright (C) 1998 - 2010, 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 $(LINK 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. + * + ***************************************************************************/ + +module etc.c.curl; + +import core.stdc.config; +import core.stdc.time; +import std.socket; + +// linux +import core.sys.posix.sys.socket; + +// +// LICENSE FROM CURL HEADERS +// + +/** This is the global package copyright */ +enum LIBCURL_COPYRIGHT = "1996 - 2010 Daniel Stenberg, <daniel@haxx.se>."; + +/** This is the version number of the libcurl package from which this header + file origins: */ +enum LIBCURL_VERSION = "7.21.4"; + +/** The numeric version number is also available "in parts" by using these + constants */ +enum LIBCURL_VERSION_MAJOR = 7; +/// ditto +enum LIBCURL_VERSION_MINOR = 21; +/// ditto +enum LIBCURL_VERSION_PATCH = 4; + +/** This is the numeric version of the libcurl version number, meant for easier + parsing and comparions by programs. The LIBCURL_VERSION_NUM define will + always follow this syntax: + + 0xXXYYZZ + + Where XX, YY and ZZ are the main version, release and patch numbers in + hexadecimal (using 8 bits each). All three numbers are always represented + using two digits. 1.2 would appear as "0x010200" while version 9.11.7 + appears as "0x090b07". + + This 6-digit (24 bits) hexadecimal number does not show pre-release number, + and it is always a greater number in a more recent release. It makes + comparisons with greater than and less than work. +*/ + +enum LIBCURL_VERSION_NUM = 0x071504; + +/** + * This is the date and time when the full source package was created. The + * timestamp is not stored in git, as the timestamp is properly set in the + * tarballs by the maketgz script. + * + * The format of the date should follow this template: + * + * "Mon Feb 12 11:35:33 UTC 2007" + */ +enum LIBCURL_TIMESTAMP = "Thu Feb 17 12:19:40 UTC 2011"; + +/** Data type definition of curl_off_t. + * + * jdrewsen - Always 64bit signed and that is what long is in D. + * + * Comment below is from curlbuild.h: + * + * NOTE 2: + * + * For any given platform/compiler curl_off_t must be typedef'ed to a + * 64-bit wide signed integral data type. The width of this data type + * must remain constant and independent of any possible large file + * support settings. + * + * As an exception to the above, curl_off_t shall be typedef'ed to a + * 32-bit wide signed integral data type if there is no 64-bit type. + */ +alias curl_off_t = long; + +/// +alias CURL = void; + +/// jdrewsen - Get socket alias from std.socket +alias curl_socket_t = socket_t; + +/// jdrewsen - Would like to get socket error constant from std.socket by it is private atm. +version (Windows) +{ + import core.sys.windows.windows, core.sys.windows.winsock2; + enum CURL_SOCKET_BAD = SOCKET_ERROR; +} +version (Posix) enum CURL_SOCKET_BAD = -1; + +/// +extern (C) struct curl_httppost +{ + curl_httppost *next; /** next entry in the list */ + char *name; /** pointer to allocated name */ + c_long namelength; /** length of name length */ + char *contents; /** pointer to allocated data contents */ + c_long contentslength; /** length of contents field */ + char *buffer; /** pointer to allocated buffer contents */ + c_long bufferlength; /** length of buffer field */ + char *contenttype; /** Content-Type */ + curl_slist *contentheader; /** list of extra headers for this form */ + curl_httppost *more; /** if one field name has more than one + file, this link should link to following + files */ + c_long flags; /** as defined below */ + char *showfilename; /** The file name to show. If not set, the + actual file name will be used (if this + is a file part) */ + void *userp; /** custom pointer used for + HTTPPOST_CALLBACK posts */ +} + +enum HTTPPOST_FILENAME = 1; /** specified content is a file name */ +enum HTTPPOST_READFILE = 2; /** specified content is a file name */ +enum HTTPPOST_PTRNAME = 4; /** name is only stored pointer + do not free in formfree */ +enum HTTPPOST_PTRCONTENTS = 8; /** contents is only stored pointer + do not free in formfree */ +enum HTTPPOST_BUFFER = 16; /** upload file from buffer */ +enum HTTPPOST_PTRBUFFER = 32; /** upload file from pointer contents */ +enum HTTPPOST_CALLBACK = 64; /** upload file contents by using the + regular read callback to get the data + and pass the given pointer as custom + pointer */ + +/// +alias curl_progress_callback = int function(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. + We do the ifndef check to allow this value to easier be changed at build + time for those who feel adventurous. The practical minimum is about + 400 bytes since libcurl uses a buffer of this size as a scratch area + (unrelated to network send operations). */ +enum CURL_MAX_WRITE_SIZE = 16_384; + +/** The only reason to have a max limit for this is to avoid the risk of a bad + server feeding libcurl with a never-ending header that will cause reallocs + infinitely */ +enum CURL_MAX_HTTP_HEADER = (100*1024); + + +/** This is a magic return code for the write callback that, when returned, + will signal libcurl to pause receiving on the current transfer. */ +enum CURL_WRITEFUNC_PAUSE = 0x10000001; + +/// +alias curl_write_callback = size_t function(char *buffer, size_t size, size_t nitems, void *outstream); + +/** enumeration of file types */ +enum CurlFileType { + file, /// + directory, /// + symlink, /// + device_block, /// + device_char, /// + namedpipe, /// + socket, /// + door, /// + unknown /** is possible only on Sun Solaris now */ +} + +/// +alias curlfiletype = int; + +/// +enum CurlFInfoFlagKnown { + filename = 1, /// + filetype = 2, /// + time = 4, /// + perm = 8, /// + uid = 16, /// + gid = 32, /// + size = 64, /// + hlinkcount = 128 /// +} + +/** Content of this structure depends on information which is known and is + achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man + page for callbacks returning this structure -- some fields are mandatory, + some others are optional. The FLAG field has special meaning. */ + + +/** If some of these fields is not NULL, it is a pointer to b_data. */ +extern (C) struct _N2 +{ + char *time; /// + char *perm; /// + char *user; /// + char *group; /// + char *target; /** pointer to the target filename of a symlink */ +} + +/** Content of this structure depends on information which is known and is + achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man + page for callbacks returning this structure -- some fields are mandatory, + some others are optional. The FLAG field has special meaning. */ +extern (C) struct curl_fileinfo +{ + char *filename; /// + curlfiletype filetype; /// + time_t time; /// + uint perm; /// + int uid; /// + int gid; /// + curl_off_t size; /// + c_long hardlinks; /// + _N2 strings; /// + uint flags; /// + char *b_data; /// + size_t b_size; /// + size_t b_used; /// +} + +/** return codes for CURLOPT_CHUNK_BGN_FUNCTION */ +enum CurlChunkBgnFunc { + ok = 0, /// + fail = 1, /** tell the lib to end the task */ + skip = 2 /** skip this chunk over */ +} + +/** if splitting of data transfer is enabled, this callback is called before + download of an individual chunk started. Note that parameter "remains" works + only for FTP wildcard downloading (for now), otherwise is not used */ +alias curl_chunk_bgn_callback = c_long function(void *transfer_info, void *ptr, int remains); + +/** return codes for CURLOPT_CHUNK_END_FUNCTION */ +enum CurlChunkEndFunc { + ok = 0, /// + fail = 1, /// +} +/** If splitting of data transfer is enabled this callback is called after + download of an individual chunk finished. + Note! After this callback was set then it have to be called FOR ALL chunks. + Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC. + This is the reason why we don't need "transfer_info" parameter in this + callback and we are not interested in "remains" parameter too. */ +alias curl_chunk_end_callback = c_long function(void *ptr); + +/** return codes for FNMATCHFUNCTION */ +enum CurlFnMAtchFunc { + match = 0, /// + nomatch = 1, /// + fail = 2 /// +} + +/** callback type for wildcard downloading pattern matching. If the + string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */ +alias curl_fnmatch_callback = int function(void *ptr, in char *pattern, in char *string); + +/// seek whence... +enum CurlSeekPos { + set, /// + current, /// + end /// +} + +/** These are the return codes for the seek callbacks */ +enum CurlSeek { + ok, /// + fail, /** fail the entire transfer */ + cantseek /** tell libcurl seeking can't be done, so + libcurl might try other means instead */ +} + +/// +alias curl_seek_callback = int function(void *instream, curl_off_t offset, int origin); + +/// +enum CurlReadFunc { + /** This is a return code for the read callback that, when returned, will + signal libcurl to immediately abort the current transfer. */ + abort = 0x10000000, + + /** This is a return code for the read callback that, when returned, + will const signal libcurl to pause sending data on the current + transfer. */ + pause = 0x10000001 +} + +/// +alias curl_read_callback = size_t function(char *buffer, size_t size, size_t nitems, void *instream); + +/// +enum CurlSockType { + ipcxn, /** socket created for a specific IP connection */ + last /** never use */ +} +/// +alias curlsocktype = int; + +/// +alias curl_sockopt_callback = int function(void *clientp, curl_socket_t curlfd, curlsocktype purpose); + +/** addrlen was a socklen_t type before 7.18.0 but it turned really + ugly and painful on the systems that lack this type */ +extern (C) struct curl_sockaddr +{ + int family; /// + int socktype; /// + int protocol; /// + uint addrlen; /** addrlen was a socklen_t type before 7.18.0 but it + turned really ugly and painful on the systems that + lack this type */ + sockaddr addr; /// +} + +/// +alias curl_opensocket_callback = curl_socket_t function(void *clientp, curlsocktype purpose, curl_sockaddr *address); + +/// +enum CurlIoError +{ + ok, /** I/O operation successful */ + unknowncmd, /** command was unknown to callback */ + failrestart, /** failed to restart the read */ + last /** never use */ +} +/// +alias curlioerr = int; + +/// +enum CurlIoCmd { + nop, /** command was unknown to callback */ + restartread, /** failed to restart the read */ + last, /** never use */ +} +/// +alias curliocmd = int; + +/// +alias curl_ioctl_callback = curlioerr function(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. + */ +alias curl_malloc_callback = void* function(size_t size); +/// ditto +alias curl_free_callback = void function(void *ptr); +/// ditto +alias curl_realloc_callback = void* function(void *ptr, size_t size); +/// ditto +alias curl_strdup_callback = char * function(in char *str); +/// ditto +alias curl_calloc_callback = void* function(size_t nmemb, size_t size); + +/** the kind of data that is passed to information_callback*/ +enum CurlCallbackInfo { + text, /// + header_in, /// + header_out, /// + data_in, /// + data_out, /// + ssl_data_in, /// + ssl_data_out, /// + end /// +} +/// +alias curl_infotype = int; + +/// +alias curl_debug_callback = + int function(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! + */ +enum CurlError +{ + ok, /// + unsupported_protocol, /** 1 */ + failed_init, /** 2 */ + url_malformat, /** 3 */ + not_built_in, /** 4 - [was obsoleted in August 2007 for + 7.17.0, reused in April 2011 for 7.21.5] */ + couldnt_resolve_proxy, /** 5 */ + couldnt_resolve_host, /** 6 */ + couldnt_connect, /** 7 */ + ftp_weird_server_reply, /** 8 */ + remote_access_denied, /** 9 a service was denied by the server + due to lack of access - when login fails + this is not returned. */ + obsolete10, /** 10 - NOT USED */ + ftp_weird_pass_reply, /** 11 */ + obsolete12, /** 12 - NOT USED */ + ftp_weird_pasv_reply, /** 13 */ + ftp_weird_227_format, /** 14 */ + ftp_cant_get_host, /** 15 */ + obsolete16, /** 16 - NOT USED */ + ftp_couldnt_set_type, /** 17 */ + partial_file, /** 18 */ + ftp_couldnt_retr_file, /** 19 */ + obsolete20, /** 20 - NOT USED */ + quote_error, /** 21 - quote command failure */ + http_returned_error, /** 22 */ + write_error, /** 23 */ + obsolete24, /** 24 - NOT USED */ + upload_failed, /** 25 - failed upload "command" */ + read_error, /** 26 - couldn't open/read from file */ + 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 + */ + operation_timedout, /** 28 - the timeout time was reached */ + obsolete29, /** 29 - NOT USED */ + ftp_port_failed, /** 30 - FTP PORT operation failed */ + ftp_couldnt_use_rest, /** 31 - the REST command failed */ + obsolete32, /** 32 - NOT USED */ + range_error, /** 33 - RANGE "command" didn't work */ + http_post_error, /** 34 */ + ssl_connect_error, /** 35 - wrong when connecting with SSL */ + bad_download_resume, /** 36 - couldn't resume download */ + file_couldnt_read_file, /** 37 */ + ldap_cannot_bind, /** 38 */ + ldap_search_failed, /** 39 */ + obsolete40, /** 40 - NOT USED */ + function_not_found, /** 41 */ + aborted_by_callback, /** 42 */ + bad_function_argument, /** 43 */ + obsolete44, /** 44 - NOT USED */ + interface_failed, /** 45 - CURLOPT_INTERFACE failed */ + obsolete46, /** 46 - NOT USED */ + too_many_redirects, /** 47 - catch endless re-direct loops */ + unknown_option, /** 48 - User specified an unknown option */ + telnet_option_syntax, /** 49 - Malformed telnet option */ + obsolete50, /** 50 - NOT USED */ + peer_failed_verification, /** 51 - peer's certificate or fingerprint + wasn't verified fine */ + got_nothing, /** 52 - when this is a specific error */ + ssl_engine_notfound, /** 53 - SSL crypto engine not found */ + ssl_engine_setfailed, /** 54 - can not set SSL crypto engine as default */ + send_error, /** 55 - failed sending network data */ + recv_error, /** 56 - failure in receiving network data */ + obsolete57, /** 57 - NOT IN USE */ + ssl_certproblem, /** 58 - problem with the local certificate */ + ssl_cipher, /** 59 - couldn't use specified cipher */ + ssl_cacert, /** 60 - problem with the CA cert (path?) */ + bad_content_encoding, /** 61 - Unrecognized transfer encoding */ + ldap_invalid_url, /** 62 - Invalid LDAP URL */ + filesize_exceeded, /** 63 - Maximum file size exceeded */ + use_ssl_failed, /** 64 - Requested FTP SSL level failed */ + send_fail_rewind, /** 65 - Sending the data requires a rewind that failed */ + ssl_engine_initfailed, /** 66 - failed to initialise ENGINE */ + login_denied, /** 67 - user, password or similar was not accepted and we failed to login */ + tftp_notfound, /** 68 - file not found on server */ + tftp_perm, /** 69 - permission problem on server */ + remote_disk_full, /** 70 - out of disk space on server */ + tftp_illegal, /** 71 - Illegal TFTP operation */ + tftp_unknownid, /** 72 - Unknown transfer ID */ + remote_file_exists, /** 73 - File already exists */ + tftp_nosuchuser, /** 74 - No such user */ + conv_failed, /** 75 - conversion failed */ + 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 */ + ssl_cacert_badfile, /** 77 - could not load CACERT file, missing or wrong format */ + remote_file_not_found, /** 78 - remote file not found */ + ssh, /** 79 - error from the SSH layer, somewhat + generic so the error message will be of + interest when this has happened */ + ssl_shutdown_failed, /** 80 - Failed to shut down the SSL connection */ + again, /** 81 - socket is not ready for send/recv, + wait till it's ready and try again (Added + in 7.18.2) */ + ssl_crl_badfile, /** 82 - could not load CRL file, missing or wrong format (Added in 7.19.0) */ + ssl_issuer_error, /** 83 - Issuer check failed. (Added in 7.19.0) */ + ftp_pret_failed, /** 84 - a PRET command failed */ + rtsp_cseq_error, /** 85 - mismatch of RTSP CSeq numbers */ + rtsp_session_error, /** 86 - mismatch of RTSP Session Identifiers */ + ftp_bad_file_list, /** 87 - unable to parse FTP file list */ + chunk_failed, /** 88 - chunk callback reported error */ + curl_last /** never use! */ +} +/// +alias CURLcode = int; + +/** This prototype applies to all conversion callbacks */ +alias curl_conv_callback = CURLcode function(char *buffer, size_t length); + +/** actually an OpenSSL SSL_CTX */ +alias curl_ssl_ctx_callback = + CURLcode function(CURL *curl, /** easy handle */ + void *ssl_ctx, /** actually an OpenSSL SSL_CTX */ + void *userptr + ); + +/// +enum CurlProxy { + http, /** added in 7.10, new in 7.19.4 default is to use CONNECT HTTP/1.1 */ + http_1_0, /** added in 7.19.4, force to use CONNECT HTTP/1.0 */ + socks4 = 4, /** support added in 7.15.2, enum existed already in 7.10 */ + socks5 = 5, /** added in 7.10 */ + socks4a = 6, /** added in 7.18.0 */ + socks5_hostname =7 /** Use the SOCKS5 protocol but pass along the + host name rather than the IP address. added + in 7.18.0 */ +} +/// +alias curl_proxytype = int; + +/// +enum CurlAuth : long { + none = 0, + basic = 1, /** Basic (default) */ + digest = 2, /** Digest */ + gssnegotiate = 4, /** GSS-Negotiate */ + ntlm = 8, /** NTLM */ + digest_ie = 16, /** Digest with IE flavour */ + only = 2_147_483_648, /** used together with a single other + type to force no auth or just that + single type */ + any = -17, /* (~CURLAUTH_DIGEST_IE) */ /** all fine types set */ + anysafe = -18 /* (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE)) */ /// +} + +/// +enum CurlSshAuth { + any = -1, /** all types supported by the server */ + none = 0, /** none allowed, silly but complete */ + publickey = 1, /** public/private key files */ + password = 2, /** password */ + host = 4, /** host key files */ + keyboard = 8, /** keyboard interactive */ + default_ = -1 // CURLSSH_AUTH_ANY; +} +/// +enum CURL_ERROR_SIZE = 256; +/** points to a zero-terminated string encoded with base64 + if len is zero, otherwise to the "raw" data */ +enum CurlKHType +{ + unknown, /// + rsa1, /// + rsa, /// + dss /// +} +/// +extern (C) struct curl_khkey +{ + const(char) *key; /** points to a zero-terminated string encoded with base64 + if len is zero, otherwise to the "raw" data */ + size_t len; /// + CurlKHType keytype; /// +} + +/** this is the set of return values expected from the curl_sshkeycallback + callback */ +enum CurlKHStat { + fine_add_to_file, /// + fine, /// + reject, /** reject the connection, return an error */ + defer, /** do not accept it, but we can't answer right now so + this causes a CURLE_DEFER error but otherwise the + connection will be left intact etc */ + last /** not for use, only a marker for last-in-list */ +} + +/** this is the set of status codes pass in to the callback */ +enum CurlKHMatch { + ok, /** match */ + mismatch, /** host found, key mismatch! */ + missing, /** no matching host/key found */ + last /** not for use, only a marker for last-in-list */ +} + +/// +alias curl_sshkeycallback = + int function(CURL *easy, /** easy handle */ + curl_khkey *knownkey, /** known */ + curl_khkey *foundkey, /** found */ + CurlKHMatch m, /** libcurl's view on the keys */ + void *clientp /** custom pointer passed from app */ + ); + +/** parameter for the CURLOPT_USE_SSL option */ +enum CurlUseSSL { + none, /** do not attempt to use SSL */ + tryssl, /** try using SSL, proceed anyway otherwise */ + control, /** SSL for the control connection or fail */ + all, /** SSL for all communication or fail */ + last /** not an option, never use */ +} +/// +alias curl_usessl = int; + +/** parameter for the CURLOPT_FTP_SSL_CCC option */ +enum CurlFtpSSL { + ccc_none, /** do not send CCC */ + ccc_passive, /** Let the server initiate the shutdown */ + ccc_active, /** Initiate the shutdown */ + ccc_last /** not an option, never use */ +} +/// +alias curl_ftpccc = int; + +/** parameter for the CURLOPT_FTPSSLAUTH option */ +enum CurlFtpAuth { + defaultauth, /** let libcurl decide */ + ssl, /** use "AUTH SSL" */ + tls, /** use "AUTH TLS" */ + last /** not an option, never use */ +} +/// +alias curl_ftpauth = int; + +/** parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */ +enum CurlFtp { + create_dir_none, /** do NOT create missing dirs! */ + create_dir, /** (FTP/SFTP) if CWD fails, try MKD and then CWD again if MKD + succeeded, for SFTP this does similar magic */ + create_dir_retry, /** (FTP only) if CWD fails, try MKD and then CWD again even if MKD + failed! */ + create_dir_last /** not an option, never use */ +} +/// +alias curl_ftpcreatedir = int; + +/** parameter for the CURLOPT_FTP_FILEMETHOD option */ +enum CurlFtpMethod { + defaultmethod, /** let libcurl pick */ + multicwd, /** single CWD operation for each path part */ + nocwd, /** no CWD at all */ + singlecwd, /** one CWD to full dir, then work on file */ + last /** not an option, never use */ +} +/// +alias curl_ftpmethod = int; + +/** CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */ +enum CurlProto { + http = 1, /// + https = 2, /// + ftp = 4, /// + ftps = 8, /// + scp = 16, /// + sftp = 32, /// + telnet = 64, /// + ldap = 128, /// + ldaps = 256, /// + dict = 512, /// + file = 1024, /// + tftp = 2048, /// + imap = 4096, /// + imaps = 8192, /// + pop3 = 16_384, /// + pop3s = 32_768, /// + smtp = 65_536, /// + smtps = 131_072, /// + rtsp = 262_144, /// + rtmp = 524_288, /// + rtmpt = 1_048_576, /// + rtmpe = 2_097_152, /// + rtmpte = 4_194_304, /// + rtmps = 8_388_608, /// + rtmpts = 16_777_216, /// + gopher = 33_554_432, /// + all = -1 /** enable everything */ +} + +/** long may be 32 or 64 bits, but we should never depend on anything else + but 32 */ +enum CURLOPTTYPE_LONG = 0; +/// ditto +enum CURLOPTTYPE_OBJECTPOINT = 10_000; +/// ditto +enum CURLOPTTYPE_FUNCTIONPOINT = 20_000; + +/// ditto +enum CURLOPTTYPE_OFF_T = 30_000; +/** name is uppercase CURLOPT_$(LT)name$(GT), + type is one of the defined CURLOPTTYPE_$(LT)type$(GT) + number is unique identifier */ + +/** The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +alias LONG = CURLOPTTYPE_LONG; +/// ditto +alias OBJECTPOINT = CURLOPTTYPE_OBJECTPOINT; +/// ditto +alias FUNCTIONPOINT = CURLOPTTYPE_FUNCTIONPOINT; + +/// ditto +alias OFF_T = CURLOPTTYPE_OFF_T; + +/// +enum CurlOption { + /** This is the FILE * or void * the regular output should be written to. */ + file = 10_001, + /** The full URL to get/put */ + url, + /** Port number to connect to, if other than default. */ + port = 3, + /** Name of proxy to use. */ + proxy = 10_004, + /** "name:password" to use when fetching. */ + userpwd, + /** "name:password" to use with proxy. */ + proxyuserpwd, + /** Range to get, specified as an ASCII string. */ + range, + /** not used */ + + /** Specified file stream to upload from (use as input): */ + infile = 10_009, + /** 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: */ + errorbuffer, + /** Function that will be called to store the output (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + writefunction = 20_011, + /** Function that will be called to read the input (instead of fread). The + * parameters will use fread() syntax, make sure to follow them. */ + readfunction, + /** Time-out the read operation after this amount of seconds */ + timeout = 13, + /** If the CURLOPT_INFILE is used, this can be used to inform libcurl about + * how large the file being sent really is. That allows better error + * checking and better verifies that the upload was successful. -1 means + * unknown size. + * + * For large file support, there is also a _LARGE version of the key + * which takes an off_t type, allowing platforms with larger off_t + * sizes to handle larger files. See below for INFILESIZE_LARGE. + */ + infilesize, + /** POST static input fields. */ + postfields = 10_015, + /** Set the referrer page (needed by some CGIs) */ + referer, + /** Set the FTP PORT string (interface name, named or numerical IP address) + Use i.e '-' to use default address. */ + ftpport, + /** Set the User-Agent string (examined by some CGIs) */ + useragent, + /** 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" */ + low_speed_limit = 19, + /** Set the "low speed time" */ + low_speed_time, + /** 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. + */ + resume_from, + /** Set cookie in request: */ + cookie = 10_022, + /** This points to a linked list of headers, struct curl_slist kind */ + httpheader, + /** This points to a linked list of post entries, struct curl_httppost */ + httppost, + /** name of the file keeping your private SSL-certificate */ + sslcert, + /** password for the SSL or SSH private key */ + keypasswd, + /** send TYPE parameter? */ + crlf = 27, + /** send linked-list of QUOTE commands */ + quote = 10_028, + /** send FILE * or void * to store headers to, if you use a callback it + is simply passed to the callback unmodified */ + writeheader, + /** point to a file to read the initial cookies from, also enables + "cookie awareness" */ + cookiefile = 10_031, + /** What version to specifically try to use. + See CURL_SSLVERSION defines below. */ + sslversion = 32, + /** What kind of HTTP time condition to use, see defines */ + timecondition, + /** Time to use with the above condition. Specified in number of seconds + since 1 Jan 1970 */ + timevalue, + /* 35 = OBSOLETE */ + + /** Custom request, for customizing the get command like + HTTP: DELETE, TRACE and others + FTP: to use a different list command + */ + customrequest = 10_036, + /** HTTP request, for odd commands like DELETE, TRACE and others */ + stderr, + /* 38 is not used */ + + /** send linked-list of post-transfer QUOTE commands */ + postquote = 10_039, + /** Pass a pointer to string of the output using full variable-replacement + as described elsewhere. */ + writeinfo, + verbose = 41, /** talk a lot */ + header, /** throw the header out too */ + noprogress, /** shut off the progress meter */ + nobody, /** use HEAD to get http document */ + failonerror, /** no output on http error codes >= 300 */ + upload, /** this is an upload */ + post, /** HTTP POST method */ + dirlistonly, /** return bare names when listing directories */ + append = 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. */ + netrc, + followlocation, /** use Location: Luke! */ + transfertext, /** transfer data in text/ASCII format */ + put, /** 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. */ + progressfunction = 20_056, + /** Data passed to the progress callback */ + progressdata = 10_057, + /** We want the referrer field set automatically when following locations */ + autoreferer = 58, + /** Port of the proxy, can be set in the proxy string as well with: + "[host]:[port]" */ + proxyport, + /** size of the POST input data, if strlen() is not good to use */ + postfieldsize, + /** tunnel non-http operations through a HTTP proxy */ + httpproxytunnel, + /** Set the interface string to use as outgoing network interface */ + intrface = 10_062, + /** Set the krb4/5 security level, this also enables krb4/5 awareness. This + * is a string, 'clear', 'safe', 'confidential' or 'private'. If the string + * is set but doesn't match one of these, 'private' will be used. */ + krblevel, + /** Set if we should verify the peer in ssl handshake, set 1 to verify. */ + ssl_verifypeer = 64, + /** The CApath or CAfile used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + cainfo = 10_065, + /* 66 = OBSOLETE */ + /* 67 = OBSOLETE */ + + /** Maximum number of http redirects to follow */ + maxredirs = 68, + /** Pass a long set to 1 to get the date of the requested document (if + possible)! Pass a zero to shut it off. */ + filetime, + /** This points to a linked list of telnet options */ + telnetoptions = 10_070, + /** Max amount of cached alive connections */ + maxconnects = 71, + /** What policy to use when closing connections when the cache is filled + up */ + closepolicy, + /* 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. */ + fresh_connect = 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. */ + forbid_reuse, + /** Set to a file name that contains random data for libcurl to use to + seed the random engine when doing SSL connects. */ + random_file = 10_076, + /** Set to the Entropy Gathering Daemon socket pathname */ + egdsocket, + /** 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] */ + connecttimeout = 78, + /** Function that will be called to store headers (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + headerfunction = 20_079, + /** 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. + */ + httpget = 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. */ + ssl_verifyhost, + /** Specify which file name to write all known cookies in after completed + operation. Set file name to "-" (dash) to make it go to stdout. */ + cookiejar = 10_082, + /** Specify which SSL ciphers to use */ + ssl_cipher_list, + /** Specify which HTTP version to use! This must be set to one of the + CURL_HTTP_VERSION* enums set below. */ + http_version = 84, + /** Specifically switch on or off the FTP engine's use of the EPSV command. By + default, that one will always be attempted before the more traditional + PASV command. */ + ftp_use_epsv, + /** type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ + sslcerttype = 10_086, + /** name of the file keeping your private SSL-key */ + sslkey, + /** type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ + sslkeytype, + /** crypto engine for the SSL-sub system */ + sslengine, + /** set the crypto engine for the SSL-sub system as default + the param has no meaning... + */ + sslengine_default = 90, + /** Non-zero value means to use the global dns cache */ + dns_use_global_cache, + /** DNS cache timeout */ + dns_cache_timeout, + /** send linked-list of pre-transfer QUOTE commands */ + prequote = 10_093, + /** set the debug function */ + debugfunction = 20_094, + /** set the data for the debug function */ + debugdata = 10_095, + /** mark this as start of a cookie session */ + cookiesession = 96, + /** The CApath directory used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + capath = 10_097, + /** Instruct libcurl to use a smaller receive buffer */ + buffersize = 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. */ + nosignal, + /** Provide a CURLShare for mutexing non-ts data */ + share = 10_100, + /** indicates type of proxy. accepted values are CURLPROXY_HTTP (default), + CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */ + proxytype = 101, + /** Set the Accept-Encoding string. Use this to tell a server you would like + the response to be compressed. */ + encoding = 10_102, + /** Set pointer to private data */ + private_opt, + /** Set aliases for HTTP 200 in the HTTP Response header */ + http200aliases, + /** Continue to send authentication (user+password) when following locations, + even when hostname changed. This can potentially send off the name + and password to whatever host the server decides. */ + unrestricted_auth = 105, + /** Specifically switch on or off the FTP engine's use of the EPRT command ( it + also disables the LPRT attempt). By default, those ones will always be + attempted before the good old traditional PORT command. */ + ftp_use_eprt, + /** 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. */ + httpauth, + /** 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. */ + ssl_ctx_function = 20_108, + /** Set the userdata for the ssl context callback function's third + argument */ + ssl_ctx_data = 10_109, + /** FTP Option that causes missing dirs to be created on the remote server. + In 7.19.4 we introduced the convenience enums for this option using the + CURLFTP_CREATE_DIR prefix. + */ + ftp_create_missing_dirs = 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. */ + proxyauth, + /** 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. */ + ftp_response_timeout, + /** Set this option to one of the CURL_IPRESOLVE_* defines (see below) to + tell libcurl to resolve names to those IP versions only. This only has + affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */ + ipresolve, + /** 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. */ + maxfilesize, + /** See the comment for INFILESIZE above, but in short, specifies + * the size of the file being uploaded. -1 means unknown. + */ + infilesize_large = 30_115, + /** Sets the continuation offset. There is also a LONG version of this; + * look above for RESUME_FROM. + */ + resume_from_large, + /** Sets the maximum size of data that will be downloaded from + * an HTTP or FTP server. See MAXFILESIZE above for the LONG version. + */ + maxfilesize_large, + /** 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. */ + netrc_file = 10_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 + */ + use_ssl = 119, + /** The _LARGE version of the standard POSTFIELDSIZE option */ + postfieldsize_large = 30_120, + /** Enable/disable the TCP Nagle algorithm */ + tcp_nodelay = 121, + /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 123 OBSOLETE. Gone in 7.16.0 */ + /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 127 OBSOLETE. Gone in 7.16.0 */ + /* 128 OBSOLETE. Gone in 7.16.0 */ + + /** When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option + can be used to change libcurl's default action which is to first try + "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK + response has been received. + + Available parameters are: + CURLFTPAUTH_DEFAULT - let libcurl decide + CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS + CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL + */ + ftpsslauth = 129, + ioctlfunction = 20_130, /// + ioctldata = 10_131, /// + /* 132 OBSOLETE. Gone in 7.16.0 */ + /* 133 OBSOLETE. Gone in 7.16.0 */ + + /** zero terminated string for pass on to the FTP server when asked for + "account" info */ + ftp_account = 10_134, + /** feed cookies into cookie engine */ + cookielist, + /** ignore Content-Length */ + ignore_content_length = 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. */ + ftp_skip_pasv_ip, + /** Select "file method" to use when doing FTP, see the curl_ftpmethod + above. */ + ftp_filemethod, + /** Local port number to bind the socket to */ + localport, + /** 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. + */ + localportrange, + /** no transfer, set up connection and let application use the socket by + extracting it with CURLINFO_LASTSOCKET */ + connect_only, + /** Function that will be called to convert from the + network encoding (instead of using the iconv calls in libcurl) */ + conv_from_network_function = 20_142, + /** Function that will be called to convert to the + network encoding (instead of using the iconv calls in libcurl) */ + conv_to_network_function, + /** 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 */ + conv_from_utf8_function, + /** If the connection proceeds too quickly then need to slow it down */ + /** */ + /** limit-rate: maximum number of bytes per second to send or receive */ + max_send_speed_large = 30_145, + max_recv_speed_large, /// ditto + /** Pointer to command string to send if USER/PASS fails. */ + ftp_alternative_to_user = 10_147, + /** callback function for setting socket options */ + sockoptfunction = 20_148, + sockoptdata = 10_149, + /** set to 0 to disable session ID re-use for this transfer, default is + enabled (== 1) */ + ssl_sessionid_cache = 150, + /** allowed SSH authentication methods */ + ssh_auth_types, + /** Used by scp/sftp to do public/private key authentication */ + ssh_public_keyfile = 10_152, + ssh_private_keyfile, + /** Send CCC (Clear Command Channel) after authentication */ + ftp_ssl_ccc = 154, + /** Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ + timeout_ms, + connecttimeout_ms, + /** set to zero to disable the libcurl's decoding and thus pass the raw body + data to the application even when it is encoded/compressed */ + http_transfer_decoding, + http_content_decoding, /// ditto + /** Permission used when creating new files and directories on the remote + server for protocols that support it, SFTP/SCP/FILE */ + new_file_perms, + new_directory_perms, /// ditto + /** Set the behaviour of POST when redirecting. Values must be set to one + of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */ + postredir, + /** used by scp/sftp to verify the host's public key */ + ssh_host_public_key_md5 = 10_162, + /** Callback function for opening socket (instead of socket(2)). Optionally, + callback is able change the address or refuse to connect returning + CURL_SOCKET_BAD. The callback should have type + curl_opensocket_callback */ + opensocketfunction = 20_163, + opensocketdata = 10_164, /// ditto + /** POST volatile input fields. */ + copypostfields, + /** set transfer mode (;type=$(LT)a|i$(GT)) when doing FTP via an HTTP proxy */ + proxy_transfer_mode = 166, + /** Callback function for seeking in the input stream */ + seekfunction = 20_167, + seekdata = 10_168, /// ditto + /** CRL file */ + crlfile, + /** Issuer certificate */ + issuercert, + /** (IPv6) Address scope */ + address_scope = 171, + /** Collect certificate chain info and allow it to get retrievable with + CURLINFO_CERTINFO after the transfer is complete. (Unfortunately) only + working with OpenSSL-powered builds. */ + certinfo, + /** "name" and "pwd" to use when fetching. */ + username = 10_173, + password, /// ditto + /** "name" and "pwd" to use with Proxy when fetching. */ + proxyusername, + proxypassword, /// ditto + /** Comma separated list of hostnames defining no-proxy zones. These should + match both hostnames directly, and hostnames within a domain. For + example, local.com will match local.com and www.local.com, but NOT + notlocal.com or www.notlocal.com. For compatibility with other + implementations of this, .local.com will be considered to be the same as + local.com. A single * is the only valid wildcard, and effectively + disables the use of proxy. */ + noproxy, + /** block size for TFTP transfers */ + tftp_blksize = 178, + /** Socks Service */ + socks5_gssapi_service = 10_179, + /** Socks Service */ + socks5_gssapi_nec = 180, + /** set the bitmask for the protocols that are allowed to be used for the + transfer, which thus helps the app which takes URLs from users or other + external inputs and want to restrict what protocol(s) to deal + with. Defaults to CURLPROTO_ALL. */ + protocols, + /** set the bitmask for the protocols that libcurl is allowed to follow to, + as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs + to be set in both bitmasks to be allowed to get redirected to. Defaults + to all protocols except FILE and SCP. */ + redir_protocols, + /** set the SSH knownhost file name to use */ + ssh_knownhosts = 10_183, + /** set the SSH host key callback, must point to a curl_sshkeycallback + function */ + ssh_keyfunction = 20_184, + /** set the SSH host key callback custom pointer */ + ssh_keydata = 10_185, + /** set the SMTP mail originator */ + mail_from, + /** set the SMTP mail receiver(s) */ + mail_rcpt, + /** FTP: send PRET before PASV */ + ftp_use_pret = 188, + /** RTSP request method (OPTIONS, SETUP, PLAY, etc...) */ + rtsp_request, + /** The RTSP session identifier */ + rtsp_session_id = 10_190, + /** The RTSP stream URI */ + rtsp_stream_uri, + /** The Transport: header to use in RTSP requests */ + rtsp_transport, + /** Manually initialize the client RTSP CSeq for this handle */ + rtsp_client_cseq = 193, + /** Manually initialize the server RTSP CSeq for this handle */ + rtsp_server_cseq, + /** The stream to pass to INTERLEAVEFUNCTION. */ + interleavedata = 10_195, + /** Let the application define a custom write method for RTP data */ + interleavefunction = 20_196, + /** Turn on wildcard matching */ + wildcardmatch = 197, + /** Directory matching callback called before downloading of an + individual file (chunk) started */ + chunk_bgn_function = 20_198, + /** Directory matching callback called after the file (chunk) + was downloaded, or skipped */ + chunk_end_function, + /** Change match (fnmatch-like) callback for wildcard matching */ + fnmatch_function, + /** Let the application define custom chunk data pointer */ + chunk_data = 10_201, + /** FNMATCH_FUNCTION user pointer */ + fnmatch_data, + /** send linked-list of name:port:address sets */ + resolve, + /** Set a username for authenticated TLS */ + tlsauth_username, + /** Set a password for authenticated TLS */ + tlsauth_password, + /** Set authentication type for authenticated TLS */ + tlsauth_type, + /** the last unused */ + lastentry, + + writedata = file, /// convenient alias + readdata = infile, /// ditto + headerdata = writeheader, /// ditto + rtspheader = httpheader, /// ditto +} +/// +alias CURLoption = int; +/// +enum CURLOPT_SERVER_RESPONSE_TIMEOUT = CurlOption.ftp_response_timeout; + +/** 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. */ +enum CurlIpResolve { + whatever = 0, /** default, resolves addresses to all IP versions that your system allows */ + v4 = 1, /** resolve to ipv4 addresses */ + v6 = 2 /** resolve to ipv6 addresses */ +} + +/** three convenient "aliases" that follow the name scheme better */ +enum CURLOPT_WRITEDATA = CurlOption.file; +/// ditto +enum CURLOPT_READDATA = CurlOption.infile; +/// ditto +enum CURLOPT_HEADERDATA = CurlOption.writeheader; +/// ditto +enum CURLOPT_RTSPHEADER = CurlOption.httpheader; + +/** These enums are for use with the CURLOPT_HTTP_VERSION option. */ +enum CurlHttpVersion { + none, /** setting this means we don't care, and that we'd + like the library to choose the best possible + for us! */ + v1_0, /** please use HTTP 1.0 in the request */ + v1_1, /** please use HTTP 1.1 in the request */ + last /** *ILLEGAL* http version */ +} + +/** + * Public API enums for RTSP requests + */ +enum CurlRtspReq { + none, /// + options, /// + describe, /// + announce, /// + setup, /// + play, /// + pause, /// + teardown, /// + get_parameter, /// + set_parameter, /// + record, /// + receive, /// + last /// +} + + /** These enums are for use with the CURLOPT_NETRC option. */ +enum CurlNetRcOption { + ignored, /** The .netrc will never be read. This is the default. */ + optional /** A user:password in the URL will be preferred to one in the .netrc. */, + required, /** A user:password in the URL will be ignored. + * Unless one is set programmatically, the .netrc + * will be queried. */ + last /// +} + +/// +enum CurlSslVersion { + default_version, /// + tlsv1, /// + sslv2, /// + sslv3, /// + last /** never use */ +} + +/// +enum CurlTlsAuth { + none, /// + srp, /// + last /** never use */ +} + +/** symbols to use with CURLOPT_POSTREDIR. + CURL_REDIR_POST_301 and CURL_REDIR_POST_302 can be bitwise ORed so that + CURL_REDIR_POST_301 | CURL_REDIR_POST_302 == CURL_REDIR_POST_ALL */ +enum CurlRedir { + get_all = 0, /// + post_301 = 1, /// + post_302 = 2, /// + /// + post_all = (1 | 2) // (CURL_REDIR_POST_301|CURL_REDIR_POST_302); +} +/// +enum CurlTimeCond { + none, /// + ifmodsince, /// + ifunmodsince, /// + lastmod, /// + last /// +} +/// +alias curl_TimeCond = int; + + +/** curl_strequal() and curl_strnequal() are subject for removal in a future + libcurl, see lib/README.curlx for details */ +extern (C) { +int curl_strequal(in char *s1, in char *s2); +/// ditto +int curl_strnequal(in char *s1, in char *s2, size_t n); +} +enum CurlForm { + nothing, /********** the first one is unused ************/ + copyname, + ptrname, + namelength, + copycontents, + ptrcontents, + contentslength, + filecontent, + array, + obsolete, + file, + buffer, + bufferptr, + bufferlength, + contenttype, + contentheader, + filename, + end, + obsolete2, + stream, + lastentry /** the last unused */ +} +alias CURLformoption = int; + + +/** structure to be used as parameter for CURLFORM_ARRAY */ +extern (C) struct curl_forms +{ + CURLformoption option; /// + const(char) *value; /// +} + +/** Use this for multipart formpost building + * + * Returns code for curl_formadd() + * + * Returns: + * + * $(UL + * $(LI CURL_FORMADD_OK on success ) + * $(LI CURL_FORMADD_MEMORY if the FormInfo allocation fails ) + * $(LI CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form ) + * $(LI CURL_FORMADD_NULL if a null pointer was given for a char ) + * $(LI CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed ) + * $(LI CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used ) + * $(LI CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error) ) + * $(LI CURL_FORMADD_MEMORY if a curl_httppost struct cannot be allocated ) + * $(LI CURL_FORMADD_MEMORY if some allocation for string copying failed. ) + * $(LI CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array ) + * ) + * + ***************************************************************************/ +enum CurlFormAdd { + ok, /** first, no error */ + memory, /// + option_twice, /// + null_ptr, /// + unknown_option, /// + incomplete, /// + illegal_array, /// + disabled, /** libcurl was built with this disabled */ + last /// +} +/// +alias CURLFORMcode = int; + +extern (C) { + +/** + * Name: curl_formadd() + * + * Description: + * + * Pretty advanced function for building multi-part formposts. Each invoke + * adds one part that together construct a full post. Then use + * CURLOPT_HTTPPOST to send it off to libcurl. + */ +CURLFORMcode curl_formadd(curl_httppost **httppost, 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. + */ +alias curl_formget_callback = size_t function(void *arg, in 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. + */ +int curl_formget(curl_httppost *form, void *arg, curl_formget_callback append); +/** + * Name: curl_formfree() + * + * Description: + * + * Free a multipart formpost previously built with curl_formadd(). + */ +void curl_formfree(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(in char *variable); + +/** + * Name: curl_version() + * + * Description: + * + * Returns a static ascii string of the libcurl version. + */ +char * curl_version(); + +/** + * 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. + */ +char * curl_easy_escape(CURL *handle, in char *string, int length); + +/** the previous version: */ +char * curl_escape(in 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. + */ +char * curl_easy_unescape(CURL *handle, in char *string, int length, int *outlength); + +/** the previous version */ +char * curl_unescape(in 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 and before any call of other libcurl functions. + * + * This function is not thread-safe! + */ +CURLcode curl_global_init(c_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( + c_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(); +} + +/** linked-list structure for the CURLOPT_QUOTE option (and other) */ +extern (C) { + +struct curl_slist +{ + char *data; + 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_slist * curl_slist_append(curl_slist *, in char *); + +/** + * Name: curl_slist_free_all() + * + * Description: + * + * free a previously built curl_slist. + */ +void curl_slist_free_all(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. + */ +time_t curl_getdate(char *p, time_t *unused); + +/** info about the certificate chain, only for OpenSSL builds. Asked + for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */ +struct curl_certinfo +{ + int num_of_certs; /** number of certificates with information */ + curl_slist **certinfo; /** for each index in this array, there's a + linked list with textual information in the + format "name: value" */ +} + +} // extern (C) end + +/// +enum CURLINFO_STRING = 0x100000; +/// +enum CURLINFO_LONG = 0x200000; +/// +enum CURLINFO_DOUBLE = 0x300000; +/// +enum CURLINFO_SLIST = 0x400000; +/// +enum CURLINFO_MASK = 0x0fffff; + +/// +enum CURLINFO_TYPEMASK = 0xf00000; + +/// +enum CurlInfo { + none, /// + effective_url = 1_048_577, /// + response_code = 2_097_154, /// + total_time = 3_145_731, /// + namelookup_time, /// + connect_time, /// + pretransfer_time, /// + size_upload, /// + size_download, /// + speed_download, /// + speed_upload, /// + header_size = 2_097_163, /// + request_size, /// + ssl_verifyresult, /// + filetime, /// + content_length_download = 3_145_743, /// + content_length_upload, /// + starttransfer_time, /// + content_type = 1_048_594, /// + redirect_time = 3_145_747, /// + redirect_count = 2_097_172, /// + private_info = 1_048_597, /// + http_connectcode = 2_097_174, /// + httpauth_avail, /// + proxyauth_avail, /// + os_errno, /// + num_connects, /// + ssl_engines = 4_194_331, /// + cookielist, /// + lastsocket = 2_097_181, /// + ftp_entry_path = 1_048_606, /// + redirect_url, /// + primary_ip, /// + appconnect_time = 3_145_761, /// + certinfo = 4_194_338, /// + condition_unmet = 2_097_187, /// + rtsp_session_id = 1_048_612, /// + rtsp_client_cseq = 2_097_189, /// + rtsp_server_cseq, /// + rtsp_cseq_recv, /// + primary_port, /// + local_ip = 1_048_617, /// + local_port = 2_097_194, /// + /** Fill in new entries below here! */ + lastone = 42 +} +/// +alias CURLINFO = int; + +/** CURLINFO_RESPONSE_CODE is the new name for the option previously known as + CURLINFO_HTTP_CODE */ +enum CURLINFO_HTTP_CODE = CurlInfo.response_code; + +/// +enum CurlClosePolicy { + none, /// + oldest, /// + least_recently_used, /// + least_traffic, /// + slowest, /// + callback, /// + last /// +} +/// +alias curl_closepolicy = int; + +/// +enum CurlGlobal { + ssl = 1, /// + win32 = 2, /// + /// + all = (1 | 2), // (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32); + nothing = 0, /// + default_ = (1 | 2) /// all +} + +/****************************************************************************** + * Setup defines, protos etc for the sharing stuff. + */ + +/** Different data locks for a single share */ +enum CurlLockData { + none, /// + /** CURL_LOCK_DATA_SHARE is used internally to say that + * the locking is just made to change the internal state of the share + * itself. + */ + share, + cookie, /// + dns, /// + ssl_session, /// + connect, /// + last /// +} +/// +alias curl_lock_data = int; + +/** Different lock access types */ +enum CurlLockAccess { + none, /** unspecified action */ + shared_access, /** for read perhaps */ + single, /** for write perhaps */ + last /** never use */ +} +/// +alias curl_lock_access = int; + +/// +alias curl_lock_function = void function(CURL *handle, curl_lock_data data, curl_lock_access locktype, void *userptr); +/// +alias curl_unlock_function = void function(CURL *handle, curl_lock_data data, void *userptr); + +/// +alias CURLSH = void; + +/// +enum CurlShError { + ok, /** all is fine */ + bad_option, /** 1 */ + in_use, /** 2 */ + invalid, /** 3 */ + nomem, /** out of memory */ + last /** never use */ +} +/// +alias CURLSHcode = int; + +/** pass in a user data pointer used in the lock/unlock callback + functions */ +enum CurlShOption { + none, /** don't use */ + share, /** specify a data type to share */ + unshare, /** specify which data type to stop sharing */ + lockfunc, /** pass in a 'curl_lock_function' pointer */ + unlockfunc, /** pass in a 'curl_unlock_function' pointer */ + userdata, /** pass in a user data pointer used in the lock/unlock + callback functions */ + last /** never use */ +} +/// +alias CURLSHoption = int; + +extern (C) { +/// +CURLSH * curl_share_init(); +/// +CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option,...); +/// +CURLSHcode curl_share_cleanup(CURLSH *); +} + +/***************************************************************************** + * Structures for querying information about the curl library at runtime. + */ + +// CURLVERSION_* +enum CurlVer { + first, /// + second, /// + third, /// + fourth, /// + last /// +} +/// +alias CURLversion = int; + +/** The 'CURLVERSION_NOW' is the symbolic name meant to be used by + basically all programs ever that want to get version information. It is + meant to be a built-in version number for what kind of struct the caller + expects. If the struct ever changes, we redefine the NOW to another enum + from above. */ +enum CURLVERSION_NOW = CurlVer.fourth; + +/// +extern (C) struct _N28 +{ + CURLversion age; /** age of the returned struct */ + const(char) *version_; /** LIBCURL_VERSION */ + uint 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 */ + c_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) **protocols; + /** The fields below this were added in CURLVERSION_SECOND */ + const(char) *ares; + int ares_num; + /** This field was added in CURLVERSION_THIRD */ + const(char) *libidn; + /** These field were added in CURLVERSION_FOURTH. */ + /** Same as '_libiconv_version' if built with HAVE_ICONV */ + int iconv_ver_num; + const(char) *libssh_version; /** human readable string */ +} +/// +alias curl_version_info_data = _N28; + +/// +// CURL_VERSION_* +enum CurlVersion { + ipv6 = 1, /** IPv6-enabled */ + kerberos4 = 2, /** kerberos auth is supported */ + ssl = 4, /** SSL options are present */ + libz = 8, /** libz features are present */ + ntlm = 16, /** NTLM auth is supported */ + gssnegotiate = 32, /** Negotiate auth support */ + dbg = 64, /** built with debug capabilities */ + asynchdns = 128, /** asynchronous dns resolves */ + spnego = 256, /** SPNEGO auth */ + largefile = 512, /** supports files bigger than 2GB */ + idn = 1024, /** International Domain Names support */ + sspi = 2048, /** SSPI is supported */ + conv = 4096, /** character conversions supported */ + curldebug = 8192, /** debug memory tracking supported */ + tlsauth_srp = 16_384 /** TLS-SRP auth is supported */ +} + +extern (C) { +/** + * 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 ); + +/** + * Name: curl_easy_pause() + * + * Description: + * + * The curl_easy_pause function pauses or unpauses transfers. Select the new + * state by setting the bitmask, use the convenience defines below. + * + */ +CURLcode curl_easy_pause(CURL *handle, int bitmask); +} + + +/// +enum CurlPause { + recv = 1, /// + recv_cont = 0, /// + send = 4, /// + send_cont = 0, /// + /// + all = (1 | 4), // CURLPAUSE_RECV | CURLPAUSE_SEND + /// + cont = (0 | 0), // CURLPAUSE_RECV_CONT | CURLPAUSE_SEND_CONT +} + +/* unfortunately, the easy.h and multi.h include files need options and info + stuff before they can be included! */ +/* *************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2008, 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. + * + ***************************************************************************/ + +extern (C) { + /// + CURL * curl_easy_init(); + /// + CURLcode curl_easy_setopt(CURL *curl, CURLoption option,...); + /// + CURLcode curl_easy_perform(CURL *curl); + /// + void curl_easy_cleanup(CURL *curl); +} + +/** + * Name: curl_easy_getinfo() + * + * Description: + * + * Request internal information from the curl session with this function. The + * third argument MUST be a pointer to a long, a pointer to a char * or a + * pointer to a double (as the documentation describes elsewhere). The data + * pointed to will be filled in accordingly and can be relied upon only if the + * function returns CURLE_OK. This function is intended to get used *AFTER* a + * performed transfer, all results from this function are undefined until the + * transfer is completed. + */ +extern (C) CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info,...); + + +/** + * Name: curl_easy_duphandle() + * + * Description: + * + * Creates a new curl session handle with the same options set for the handle + * passed in. Duplicating a handle could only be a matter of cloning data and + * options, internal state info and things like persistant connections cannot + * be transfered. It is useful in multithreaded applications when you can run + * curl_easy_duphandle() for each new thread to avoid a series of identical + * curl_easy_setopt() invokes in every thread. + */ +extern (C) CURL * curl_easy_duphandle(CURL *curl); + +/** + * Name: curl_easy_reset() + * + * Description: + * + * Re-initializes a CURL handle to the default values. This puts back the + * handle to the same state as it was in when it was just created. + * + * It does keep: live connections, the Session ID cache, the DNS cache and the + * cookies. + */ +extern (C) void curl_easy_reset(CURL *curl); + +/** + * Name: curl_easy_recv() + * + * Description: + * + * Receives data from the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +extern (C) CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen, size_t *n); + +/** + * Name: curl_easy_send() + * + * Description: + * + * Sends data over the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +extern (C) CURLcode curl_easy_send(CURL *curl, void *buffer, size_t buflen, size_t *n); + + +/* + * This header file should not really need to include "curl.h" since curl.h + * itself includes this file and we expect user applications to do #include + * <curl/curl.h> without the need for especially including multi.h. + * + * For some reason we added this include here at one point, and rather than to + * break existing (wrongly written) libcurl applications, we leave it as-is + * but with this warning attached. + */ +/* *************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2010, 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. + * + ***************************************************************************/ + +/// +alias CURLM = void; + +/// +enum CurlM { + call_multi_perform = -1, /** please call curl_multi_perform() or curl_multi_socket*() soon */ + ok, /// + bad_handle, /** the passed-in handle is not a valid CURLM handle */ + bad_easy_handle, /** an easy handle was not good/valid */ + out_of_memory, /** if you ever get this, you're in deep sh*t */ + internal_error, /** this is a libcurl bug */ + bad_socket, /** the passed in socket argument did not match */ + unknown_option, /** curl_multi_setopt() with unsupported option */ + last, /// +} +/// +alias CURLMcode = int; + +/** just to make code nicer when using curl_multi_socket() you can now check + for CURLM_CALL_MULTI_SOCKET too in the same style it works for + curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */ +enum CURLM_CALL_MULTI_SOCKET = CurlM.call_multi_perform; + +/// +enum CurlMsg +{ + none, /// + done, /** This easy handle has completed. 'result' contains + the CURLcode of the transfer */ + last, /** no used */ +} +/// +alias CURLMSG = int; + +/// +extern (C) union _N31 +{ + void *whatever; /** message-specific data */ + CURLcode result; /** return code for transfer */ +} + +/// +extern (C) struct CURLMsg +{ + CURLMSG msg; /** what this message means */ + CURL *easy_handle; /** the handle it concerns */ + _N31 data; /// +} + +/** + * Name: curl_multi_init() + * + * Desc: inititalize multi-style curl usage + * + * Returns: a new CURLM handle to use in all 'curl_multi' functions. + */ +extern (C) CURLM * curl_multi_init(); + +/** + * Name: curl_multi_add_handle() + * + * Desc: add a standard curl handle to the multi stack + * + * Returns: CURLMcode type, general multi error code. + */ +extern (C) CURLMcode curl_multi_add_handle(CURLM *multi_handle, CURL *curl_handle); + + /** + * Name: curl_multi_remove_handle() + * + * Desc: removes a curl handle from the multi stack again + * + * Returns: CURLMcode type, general multi error code. + */ +extern (C) CURLMcode curl_multi_remove_handle(CURLM *multi_handle, CURL *curl_handle); + + /** + * Name: curl_multi_fdset() + * + * Desc: Ask curl for its fd_set sets. The app can use these to select() or + * poll() on. We want curl_multi_perform() called as soon as one of + * them are ready. + * + * Returns: CURLMcode type, general multi error code. + */ + +/** tmp decl */ +alias fd_set = int; +/// +extern (C) CURLMcode curl_multi_fdset( + CURLM *multi_handle, + fd_set *read_fd_set, + fd_set *write_fd_set, + fd_set *exc_fd_set, + int *max_fd +); + + /** + * Name: curl_multi_perform() + * + * Desc: When the app thinks there's data available for curl it calls this + * function to read/write whatever there is right now. This returns + * as soon as the reads and writes are done. This function does not + * require that there actually is data available for reading or that + * data can be written, it can be called just in case. It returns + * the number of handles that still transfer data in the second + * argument's integer-pointer. + * + * Returns: CURLMcode type, general multi error code. *NOTE* that this only + * returns errors etc regarding the whole multi stack. There might + * still have occurred problems on invidual transfers even when this + * returns OK. + */ +extern (C) CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles); + + /** + * Name: curl_multi_cleanup() + * + * Desc: Cleans up and removes a whole multi stack. It does not free or + * touch any individual easy handles in any way. We need to define + * in what state those handles will be if this function is called + * in the middle of a transfer. + * + * Returns: CURLMcode type, general multi error code. + */ +extern (C) CURLMcode curl_multi_cleanup(CURLM *multi_handle); + +/** + * Name: curl_multi_info_read() + * + * Desc: Ask the multi handle if there's any messages/informationals from + * the individual transfers. Messages include informationals such as + * error code from the transfer or just the fact that a transfer is + * completed. More details on these should be written down as well. + * + * Repeated calls to this function will return a new struct each + * time, until a special "end of msgs" struct is returned as a signal + * that there is no more to get at this point. + * + * The data the returned pointer points to will not survive calling + * curl_multi_cleanup(). + * + * The 'CURLMsg' struct is meant to be very simple and only contain + * very basic informations. If more involved information is wanted, + * we will provide the particular "transfer handle" in that struct + * and that should/could/would be used in subsequent + * curl_easy_getinfo() calls (or similar). The point being that we + * must never expose complex structs to applications, as then we'll + * undoubtably get backwards compatibility problems in the future. + * + * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out + * of structs. It also writes the number of messages left in the + * queue (after this read) in the integer the second argument points + * to. + */ +extern (C) CURLMsg * curl_multi_info_read(CURLM *multi_handle, int *msgs_in_queue); + +/** + * Name: curl_multi_strerror() + * + * Desc: The curl_multi_strerror function may be used to turn a CURLMcode + * value into the equivalent human readable error string. This is + * useful for printing meaningful error messages. + * + * Returns: A pointer to a zero-terminated error message. + */ +extern (C) const(char)* curl_multi_strerror(CURLMcode ); + +/** + * Name: curl_multi_socket() and + * curl_multi_socket_all() + * + * Desc: An alternative version of curl_multi_perform() that allows the + * application to pass in one of the file descriptors that have been + * detected to have "action" on them and let libcurl perform. + * See man page for details. + */ +enum CurlPoll { + none_ = 0, /** jdrewsen - underscored in order not to clash with reserved D symbols */ + in_ = 1, /// + out_ = 2, /// + inout_ = 3, /// + remove_ = 4 /// +} + +/// +alias CURL_SOCKET_TIMEOUT = CURL_SOCKET_BAD; + +/// +enum CurlCSelect { + in_ = 0x01, /** jdrewsen - underscored in order not to clash with reserved D symbols */ + out_ = 0x02, /// + err_ = 0x04 /// +} + +extern (C) { + /// + alias curl_socket_callback = + int function(CURL *easy, /** easy handle */ + curl_socket_t s, /** socket */ + int what, /** see above */ + void *userp, /** private callback pointer */ + void *socketp); /** private socket pointer */ +} + +/** + * Name: curl_multi_timer_callback + * + * Desc: Called by libcurl whenever the library detects a change in the + * maximum number of milliseconds the app is allowed to wait before + * curl_multi_socket() or curl_multi_perform() must be called + * (to allow libcurl's timed events to take place). + * + * Returns: The callback should return zero. + */ + +extern (C) { + alias curl_multi_timer_callback = + int function(CURLM *multi, /** multi handle */ + c_long timeout_ms, /** see above */ + void *userp); /** private callback pointer */ + /// ditto + CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s, int *running_handles); + /// ditto + CURLMcode curl_multi_socket_action(CURLM *multi_handle, curl_socket_t s, int ev_bitmask, int *running_handles); + /// ditto + CURLMcode curl_multi_socket_all(CURLM *multi_handle, int *running_handles); +} + +/** This macro below was added in 7.16.3 to push users who recompile to use + the new curl_multi_socket_action() instead of the old curl_multi_socket() +*/ + +/** + * Name: curl_multi_timeout() + * + * Desc: Returns the maximum number of milliseconds the app is allowed to + * wait before curl_multi_socket() or curl_multi_perform() must be + * called (to allow libcurl's timed events to take place). + * + * Returns: CURLM error code. + */ +extern (C) CURLMcode curl_multi_timeout(CURLM *multi_handle, c_long *milliseconds); + +/// +enum CurlMOption { + socketfunction = 20_001, /** This is the socket callback function pointer */ + socketdata = 10_002, /** This is the argument passed to the socket callback */ + pipelining = 3, /** set to 1 to enable pipelining for this multi handle */ + timerfunction = 20_004, /** This is the timer callback function pointer */ + timerdata = 10_005, /** This is the argument passed to the timer callback */ + maxconnects = 6, /** maximum number of entries in the connection cache */ + lastentry /// +} +/// +alias CURLMoption = int; + +/** + * Name: curl_multi_setopt() + * + * Desc: Sets options for the multi handle. + * + * Returns: CURLM error code. + */ +extern (C) CURLMcode curl_multi_setopt(CURLM *multi_handle, CURLMoption option,...); + +/** + * Name: curl_multi_assign() + * + * Desc: This function sets an association in the multi handle between the + * given socket and a private pointer of the application. This is + * (only) useful for curl_multi_socket uses. + * + * Returns: CURLM error code. + */ +extern (C) CURLMcode curl_multi_assign(CURLM *multi_handle, curl_socket_t sockfd, void *sockp);