|
0
|
1 module dynamin.c.curl;
|
|
|
2
|
|
|
3 /*
|
|
|
4 * A largely complete binding to the cURL library version 7.15.
|
|
|
5 */
|
|
|
6
|
|
|
7 version(build) { pragma(link, curl); }
|
|
|
8
|
|
|
9 extern(C):
|
|
|
10
|
|
|
11 alias void CURL;
|
|
|
12
|
|
|
13 CURL* curl_easy_init();
|
|
|
14
|
|
|
15 CURLcode curl_easy_setopt(CURL* curl, CURLoption option, ...);
|
|
|
16
|
|
|
17 CURLcode curl_easy_perform(CURL* curl);
|
|
|
18
|
|
|
19 void curl_easy_cleanup(CURL* curl);
|
|
|
20
|
|
|
21 CURLcode curl_easy_getinfo(CURL* curl, CURLINFO info, ...);
|
|
|
22
|
|
|
23 CURL* curl_easy_duphandle(CURL* curl);
|
|
|
24
|
|
|
25 void curl_easy_reset(CURL* curl);
|
|
|
26
|
|
|
27 const int HTTPPOST_FILENAME = 1 << 0;
|
|
|
28 const int HTTPPOST_READFILE = 1 << 1;
|
|
|
29 const int HTTPPOST_PTRNAME = 1 << 2;
|
|
|
30 const int HTTPPOST_PTRCONTENTS = 1 << 3;
|
|
|
31 const int HTTPPOST_BUFFER = 1 << 4;
|
|
|
32 const int HTTPPOST_PTRBUFFER = 1 << 5;
|
|
|
33
|
|
|
34 struct curl_httppost {
|
|
|
35 curl_httppost* next;
|
|
|
36 char* name;
|
|
|
37 int namelength;
|
|
|
38 char* contents;
|
|
|
39 int contentslength;
|
|
|
40 char* buffer;
|
|
|
41 int bufferlength;
|
|
|
42 char* contenttype;
|
|
|
43 curl_slist* contentheader;
|
|
|
44 curl_httppost* more;
|
|
|
45 int flags;
|
|
|
46 char* showfilename;
|
|
|
47 }
|
|
|
48
|
|
|
49 alias int function(
|
|
|
50 void* clientp,
|
|
|
51 double dltotal,
|
|
|
52 double dlnow,
|
|
|
53 double ultotal,
|
|
|
54 double ulnow) curl_progress_callback;
|
|
|
55
|
|
|
56 const int CURL_MAX_WRITE_SIZE = 16384;
|
|
|
57
|
|
|
58 alias size_t function(
|
|
|
59 char* buffer,
|
|
|
60 size_t size,
|
|
|
61 size_t nitems,
|
|
|
62 void* outstream) curl_write_callback;
|
|
|
63
|
|
|
64 const int CURL_READFUNC_ABORT = 0x10000000;
|
|
|
65
|
|
|
66 alias size_t function(
|
|
|
67 char* buffer,
|
|
|
68 size_t size,
|
|
|
69 size_t nitems,
|
|
|
70 void* instream) curl_read_callback;
|
|
|
71
|
|
|
72 alias int curlioerr;
|
|
|
73 enum {
|
|
|
74 CURLIOE_OK,
|
|
|
75 CURLIOE_UNKNOWNCMD,
|
|
|
76 CURLIOE_FAILRESTART,
|
|
|
77
|
|
|
78 CURLIOE_LAST
|
|
|
79 }
|
|
|
80
|
|
|
81 alias int curliocmd;
|
|
|
82 enum {
|
|
|
83 CURLIOCMD_NOP,
|
|
|
84 CURLIOCMD_RESTARTREAD,
|
|
|
85
|
|
|
86 CURLIOCMD_LAST
|
|
|
87 }
|
|
|
88
|
|
|
89 alias curlioerr function(
|
|
|
90 CURL* handle,
|
|
|
91 int cmd,
|
|
|
92 void* clientp) curl_ioctl_callback;
|
|
|
93
|
|
|
94 alias void* function(size_t size) curl_malloc_callback;
|
|
|
95 alias void function(void* ptr) curl_free_callback;
|
|
|
96 alias void* function(void* ptr, size_t size) curl_realloc_callback;
|
|
|
97 alias char* function(char* str) curl_strdup_callback;
|
|
|
98 alias void* function(size_t nmemb, size_t size) curl_calloc_callback;
|
|
|
99
|
|
|
100 alias int curl_infotype;
|
|
|
101 enum {
|
|
|
102 CURLINFO_TEXT = 0,
|
|
|
103 CURLINFO_HEADER_IN,
|
|
|
104 CURLINFO_HEADER_OUT,
|
|
|
105 CURLINFO_DATA_IN,
|
|
|
106 CURLINFO_DATA_OUT,
|
|
|
107 CURLINFO_SSL_DATA_IN,
|
|
|
108 CURLINFO_SSL_DATA_OUT,
|
|
|
109
|
|
|
110 CURLINFO_END
|
|
|
111 }
|
|
|
112
|
|
|
113 alias int function(
|
|
|
114 CURL* handle,
|
|
|
115 curl_infotype type,
|
|
|
116 char* data,
|
|
|
117 size_t size,
|
|
|
118 void* userptr) curl_debug_callback;
|
|
|
119
|
|
|
120 alias int CURLcode;
|
|
|
121 enum {
|
|
|
122 CURLE_OK = 0,
|
|
|
123 CURLE_UNSUPPORTED_PROTOCOL,
|
|
|
124 CURLE_FAILED_INIT,
|
|
|
125 CURLE_URL_MALFORMAT,
|
|
|
126 CURLE_URL_MALFORMAT_USER,
|
|
|
127 CURLE_COULDNT_RESOLVE_PROXY,
|
|
|
128 CURLE_COULDNT_RESOLVE_HOST,
|
|
|
129 CURLE_COULDNT_CONNECT,
|
|
|
130 CURLE_FTP_WEIRD_SERVER_REPLY,
|
|
|
131 CURLE_FTP_ACCESS_DENIED,
|
|
|
132 CURLE_FTP_USER_PASSWORD_INCORRECT,
|
|
|
133 CURLE_FTP_WEIRD_PASS_REPLY,
|
|
|
134 CURLE_FTP_WEIRD_USER_REPLY,
|
|
|
135 CURLE_FTP_WEIRD_PASV_REPLY,
|
|
|
136 CURLE_FTP_WEIRD_227_FORMAT,
|
|
|
137 CURLE_FTP_CANT_GET_HOST,
|
|
|
138 CURLE_FTP_CANT_RECONNECT,
|
|
|
139 CURLE_FTP_COULDNT_SET_BINARY,
|
|
|
140 CURLE_PARTIAL_FILE,
|
|
|
141 CURLE_FTP_COULDNT_RETR_FILE,
|
|
|
142 CURLE_FTP_WRITE_ERROR,
|
|
|
143 CURLE_FTP_QUOTE_ERROR,
|
|
|
144 CURLE_HTTP_RETURNED_ERROR,
|
|
|
145 CURLE_WRITE_ERROR,
|
|
|
146 CURLE_MALFORMAT_USER,
|
|
|
147 CURLE_FTP_COULDNT_STOR_FILE,
|
|
|
148 CURLE_READ_ERROR,
|
|
|
149 CURLE_OUT_OF_MEMORY,
|
|
|
150 CURLE_OPERATION_TIMEOUTED,
|
|
|
151 CURLE_FTP_COULDNT_SET_ASCII,
|
|
|
152 CURLE_FTP_PORT_FAILED,
|
|
|
153 CURLE_FTP_COULDNT_USE_REST,
|
|
|
154 CURLE_FTP_COULDNT_GET_SIZE,
|
|
|
155 CURLE_HTTP_RANGE_ERROR,
|
|
|
156 CURLE_HTTP_POST_ERROR,
|
|
|
157 CURLE_SSL_CONNECT_ERROR,
|
|
|
158 CURLE_BAD_DOWNLOAD_RESUME,
|
|
|
159 CURLE_FILE_COULDNT_READ_FILE,
|
|
|
160 CURLE_LDAP_CANNOT_BIND,
|
|
|
161 CURLE_LDAP_SEARCH_FAILED,
|
|
|
162 CURLE_LIBRARY_NOT_FOUND,
|
|
|
163 CURLE_FUNCTION_NOT_FOUND,
|
|
|
164 CURLE_ABORTED_BY_CALLBACK,
|
|
|
165 CURLE_BAD_FUNCTION_ARGUMENT,
|
|
|
166 CURLE_BAD_CALLING_ORDER,
|
|
|
167 CURLE_INTERFACE_FAILED,
|
|
|
168 CURLE_BAD_PASSWORD_ENTERED,
|
|
|
169 CURLE_TOO_MANY_REDIRECTS ,
|
|
|
170 CURLE_UNKNOWN_TELNET_OPTION,
|
|
|
171 CURLE_TELNET_OPTION_SYNTAX ,
|
|
|
172 CURLE_OBSOLETE,
|
|
|
173 CURLE_SSL_PEER_CERTIFICATE,
|
|
|
174 CURLE_GOT_NOTHING,
|
|
|
175 CURLE_SSL_ENGINE_NOTFOUND,
|
|
|
176 CURLE_SSL_ENGINE_SETFAILED,
|
|
|
177 CURLE_SEND_ERROR,
|
|
|
178 CURLE_RECV_ERROR,
|
|
|
179 CURLE_SHARE_IN_USE,
|
|
|
180 CURLE_SSL_CERTPROBLEM,
|
|
|
181 CURLE_SSL_CIPHER,
|
|
|
182 CURLE_SSL_CACERT,
|
|
|
183 CURLE_BAD_CONTENT_ENCODING,
|
|
|
184 CURLE_LDAP_INVALID_URL,
|
|
|
185 CURLE_FILESIZE_EXCEEDED,
|
|
|
186 CURLE_FTP_SSL_FAILED,
|
|
|
187 CURLE_SEND_FAIL_REWIND,
|
|
|
188 CURLE_SSL_ENGINE_INITFAILED,
|
|
|
189 CURLE_LOGIN_DENIED,
|
|
|
190 CURLE_TFTP_NOTFOUND,
|
|
|
191 CURLE_TFTP_PERM,
|
|
|
192 CURLE_TFTP_DISKFULL,
|
|
|
193 CURLE_TFTP_ILLEGAL,
|
|
|
194 CURLE_TFTP_UNKNOWNID,
|
|
|
195 CURLE_TFTP_EXISTS,
|
|
|
196 CURLE_TFTP_NOSUCHUSER,
|
|
|
197 CURLE_CONV_FAILED,
|
|
|
198 CURLE_CONV_REQD,
|
|
|
199
|
|
|
200 CURL_LAST
|
|
|
201 }
|
|
|
202
|
|
|
203 alias CURLcode function(char* buffer, size_t length) curl_conv_callback;
|
|
|
204 alias CURLcode function(
|
|
|
205 CURL* curl,
|
|
|
206 void* ssl_ctx,
|
|
|
207 void* userptr) curl_ssl_ctx_callback;
|
|
|
208
|
|
|
209 alias int curl_proxytype;
|
|
|
210 enum {
|
|
|
211 CURLPROXY_HTTP = 0,
|
|
|
212 CURLPROXY_SOCKS4 = 4,
|
|
|
213 CURLPROXY_SOCKS5 = 5
|
|
|
214 }
|
|
|
215
|
|
|
216 const int CURLAUTH_NONE = 0;
|
|
|
217 const int CURLAUTH_BASIC = 1 << 0;
|
|
|
218 const int CURLAUTH_DIGEST = 1 << 1;
|
|
|
219 const int CURLAUTH_GSSNEGOTIATE = 1 << 2;
|
|
|
220 const int CURLAUTH_NTLM = 1 << 3;
|
|
|
221 const int CURLAUTH_ANY = ~0;
|
|
|
222 const int CURLAUTH_ANYSAFE = ~CURLAUTH_BASIC;
|
|
|
223
|
|
|
224 alias int curl_ftpssl;
|
|
|
225 enum {
|
|
|
226 CURLFTPSSL_NONE,
|
|
|
227 CURLFTPSSL_TRY,
|
|
|
228 CURLFTPSSL_CONTROL,
|
|
|
229 CURLFTPSSL_ALL,
|
|
|
230
|
|
|
231 CURLFTPSSL_LAST
|
|
|
232 }
|
|
|
233
|
|
|
234 alias int curl_ftpauth;
|
|
|
235 enum {
|
|
|
236 CURLFTPAUTH_DEFAULT,
|
|
|
237 CURLFTPAUTH_SSL,
|
|
|
238 CURLFTPAUTH_TLS,
|
|
|
239
|
|
|
240 CURLFTPAUTH_LAST
|
|
|
241 }
|
|
|
242
|
|
|
243 alias int curl_ftpmethod;
|
|
|
244 enum {
|
|
|
245 CURLFTPMETHOD_DEFAULT,
|
|
|
246 CURLFTPMETHOD_MULTICWD,
|
|
|
247 CURLFTPMETHOD_NOCWD,
|
|
|
248 CURLFTPMETHOD_SINGLECWD,
|
|
|
249
|
|
|
250 CURLFTPMETHOD_LAST
|
|
|
251 }
|
|
|
252
|
|
|
253 const int CURLOPTTYPE_LONG = 0; // usually 32 bits
|
|
|
254 const int CURLOPTTYPE_OBJECTPOINT = 10000; // a pointer
|
|
|
255 const int CURLOPTTYPE_FUNCTIONPOINT = 20000; // a function pointer
|
|
|
256 const int CURLOPTTYPE_OFF_T = 30000; // usually 64 bits
|
|
|
257
|
|
|
258 alias int CURLoption;
|
|
|
259 enum {
|
|
|
260 CURLOPT_FILE = CURLOPTTYPE_OBJECTPOINT + 1,
|
|
|
261 CURLOPT_URL = CURLOPTTYPE_OBJECTPOINT + 2,
|
|
|
262 CURLOPT_PORT = CURLOPTTYPE_LONG + 3,
|
|
|
263 CURLOPT_PROXY = CURLOPTTYPE_OBJECTPOINT + 4,
|
|
|
264 CURLOPT_USERPWD = CURLOPTTYPE_OBJECTPOINT + 5,
|
|
|
265 CURLOPT_PROXYUSERPWD = CURLOPTTYPE_OBJECTPOINT + 6,
|
|
|
266 CURLOPT_RANGE = CURLOPTTYPE_OBJECTPOINT + 7,
|
|
|
267 CURLOPT_INFILE = CURLOPTTYPE_OBJECTPOINT + 9,
|
|
|
268 CURLOPT_ERRORBUFFER = CURLOPTTYPE_OBJECTPOINT + 10,
|
|
|
269 CURLOPT_WRITEFUNCTION = CURLOPTTYPE_FUNCTIONPOINT + 11,
|
|
|
270 CURLOPT_READFUNCTION = CURLOPTTYPE_FUNCTIONPOINT + 12,
|
|
|
271 CURLOPT_TIMEOUT = CURLOPTTYPE_LONG + 13,
|
|
|
272 CURLOPT_INFILESIZE = CURLOPTTYPE_LONG + 14,
|
|
|
273 CURLOPT_POSTFIELDS = CURLOPTTYPE_OBJECTPOINT + 15,
|
|
|
274 CURLOPT_REFERER = CURLOPTTYPE_OBJECTPOINT + 16,
|
|
|
275 CURLOPT_FTPPORT = CURLOPTTYPE_OBJECTPOINT + 17,
|
|
|
276 CURLOPT_USERAGENT = CURLOPTTYPE_OBJECTPOINT + 18,
|
|
|
277 CURLOPT_LOW_SPEED_LIMIT = CURLOPTTYPE_LONG + 19,
|
|
|
278 CURLOPT_LOW_SPEED_TIME = CURLOPTTYPE_LONG + 20,
|
|
|
279 CURLOPT_RESUME_FROM = CURLOPTTYPE_LONG + 21,
|
|
|
280 CURLOPT_COOKIE = CURLOPTTYPE_OBJECTPOINT + 22,
|
|
|
281 CURLOPT_HTTPHEADER = CURLOPTTYPE_OBJECTPOINT + 23,
|
|
|
282 CURLOPT_HTTPPOST = CURLOPTTYPE_OBJECTPOINT + 24,
|
|
|
283 CURLOPT_SSLCERT = CURLOPTTYPE_OBJECTPOINT + 25,
|
|
|
284 CURLOPT_SSLCERTPASSWD = CURLOPTTYPE_OBJECTPOINT + 26,
|
|
|
285 CURLOPT_SSLKEYPASSWD = CURLOPTTYPE_OBJECTPOINT + 26,
|
|
|
286 CURLOPT_CRLF = CURLOPTTYPE_LONG + 27,
|
|
|
287 CURLOPT_QUOTE = CURLOPTTYPE_OBJECTPOINT + 28,
|
|
|
288 CURLOPT_WRITEHEADER = CURLOPTTYPE_OBJECTPOINT + 29,
|
|
|
289 CURLOPT_COOKIEFILE = CURLOPTTYPE_OBJECTPOINT + 31,
|
|
|
290 CURLOPT_SSLVERSION = CURLOPTTYPE_LONG + 32,
|
|
|
291 CURLOPT_TIMECONDITION = CURLOPTTYPE_LONG + 33,
|
|
|
292 CURLOPT_TIMEVALUE = CURLOPTTYPE_LONG + 34,
|
|
|
293 CURLOPT_CUSTOMREQUEST = CURLOPTTYPE_OBJECTPOINT + 36,
|
|
|
294 CURLOPT_STDERR = CURLOPTTYPE_OBJECTPOINT + 37,
|
|
|
295 CURLOPT_POSTQUOTE = CURLOPTTYPE_OBJECTPOINT + 39,
|
|
|
296 CURLOPT_WRITEINFO = CURLOPTTYPE_OBJECTPOINT + 40,
|
|
|
297 CURLOPT_VERBOSE = CURLOPTTYPE_LONG + 41,
|
|
|
298 CURLOPT_HEADER = CURLOPTTYPE_LONG + 42,
|
|
|
299 CURLOPT_NOPROGRESS = CURLOPTTYPE_LONG + 43,
|
|
|
300 CURLOPT_NOBODY = CURLOPTTYPE_LONG + 44,
|
|
|
301 CURLOPT_FAILONERROR = CURLOPTTYPE_LONG + 45,
|
|
|
302 CURLOPT_UPLOAD = CURLOPTTYPE_LONG + 46,
|
|
|
303 CURLOPT_POST = CURLOPTTYPE_LONG + 47,
|
|
|
304 CURLOPT_FTPLISTONLY = CURLOPTTYPE_LONG + 48,
|
|
|
305 CURLOPT_FTPAPPEND = CURLOPTTYPE_LONG + 50,
|
|
|
306 CURLOPT_NETRC = CURLOPTTYPE_LONG + 51,
|
|
|
307 CURLOPT_FOLLOWLOCATION = CURLOPTTYPE_LONG + 52,
|
|
|
308 CURLOPT_TRANSFERTEXT = CURLOPTTYPE_LONG + 53,
|
|
|
309 CURLOPT_PUT = CURLOPTTYPE_LONG + 54,
|
|
|
310 CURLOPT_PROGRESSFUNCTION = CURLOPTTYPE_FUNCTIONPOINT + 56,
|
|
|
311 CURLOPT_PROGRESSDATA = CURLOPTTYPE_OBJECTPOINT + 57,
|
|
|
312 CURLOPT_AUTOREFERER = CURLOPTTYPE_LONG + 58,
|
|
|
313 CURLOPT_PROXYPORT = CURLOPTTYPE_LONG + 59,
|
|
|
314 CURLOPT_POSTFIELDSIZE = CURLOPTTYPE_LONG + 60,
|
|
|
315 CURLOPT_HTTPPROXYTUNNEL = CURLOPTTYPE_LONG + 61,
|
|
|
316 CURLOPT_INTERFACE = CURLOPTTYPE_OBJECTPOINT + 62,
|
|
|
317 CURLOPT_KRB4LEVEL = CURLOPTTYPE_OBJECTPOINT + 63,
|
|
|
318 CURLOPT_SSL_VERIFYPEER = CURLOPTTYPE_LONG + 64,
|
|
|
319 CURLOPT_CAINFO = CURLOPTTYPE_OBJECTPOINT + 65,
|
|
|
320 CURLOPT_MAXREDIRS = CURLOPTTYPE_LONG + 68,
|
|
|
321 CURLOPT_FILETIME = CURLOPTTYPE_LONG + 69,
|
|
|
322 CURLOPT_TELNETOPTIONS = CURLOPTTYPE_OBJECTPOINT + 70,
|
|
|
323 CURLOPT_MAXCONNECTS = CURLOPTTYPE_LONG + 71,
|
|
|
324 CURLOPT_CLOSEPOLICY = CURLOPTTYPE_LONG + 72,
|
|
|
325 CURLOPT_FRESH_CONNECT = CURLOPTTYPE_LONG + 74,
|
|
|
326 CURLOPT_FORBID_REUSE = CURLOPTTYPE_LONG + 75,
|
|
|
327 CURLOPT_RANDOM_FILE = CURLOPTTYPE_OBJECTPOINT + 76,
|
|
|
328 CURLOPT_EGDSOCKET = CURLOPTTYPE_OBJECTPOINT + 77,
|
|
|
329 CURLOPT_CONNECTTIMEOUT = CURLOPTTYPE_LONG + 78,
|
|
|
330 CURLOPT_HEADERFUNCTION = CURLOPTTYPE_FUNCTIONPOINT + 79,
|
|
|
331 CURLOPT_HTTPGET = CURLOPTTYPE_LONG + 80,
|
|
|
332 CURLOPT_SSL_VERIFYHOST = CURLOPTTYPE_LONG + 81,
|
|
|
333 CURLOPT_COOKIEJAR = CURLOPTTYPE_OBJECTPOINT + 82,
|
|
|
334 CURLOPT_SSL_CIPHER_LIST = CURLOPTTYPE_OBJECTPOINT + 83,
|
|
|
335 CURLOPT_HTTP_VERSION = CURLOPTTYPE_LONG + 84,
|
|
|
336 CURLOPT_FTP_USE_EPSV = CURLOPTTYPE_LONG + 85,
|
|
|
337 CURLOPT_SSLCERTTYPE = CURLOPTTYPE_OBJECTPOINT + 86,
|
|
|
338 CURLOPT_SSLKEY = CURLOPTTYPE_OBJECTPOINT + 87,
|
|
|
339 CURLOPT_SSLKEYTYPE = CURLOPTTYPE_OBJECTPOINT + 88,
|
|
|
340 CURLOPT_SSLENGINE = CURLOPTTYPE_OBJECTPOINT + 89,
|
|
|
341 CURLOPT_SSLENGINE_DEFAULT = CURLOPTTYPE_LONG + 90,
|
|
|
342 CURLOPT_DNS_USE_GLOBAL_CACHE = CURLOPTTYPE_LONG + 91,
|
|
|
343 CURLOPT_DNS_CACHE_TIMEOUT = CURLOPTTYPE_LONG + 92,
|
|
|
344 CURLOPT_PREQUOTE = CURLOPTTYPE_OBJECTPOINT + 93,
|
|
|
345 CURLOPT_DEBUGFUNCTION = CURLOPTTYPE_FUNCTIONPOINT + 94,
|
|
|
346 CURLOPT_DEBUGDATA = CURLOPTTYPE_OBJECTPOINT + 95,
|
|
|
347 CURLOPT_COOKIESESSION = CURLOPTTYPE_LONG + 96,
|
|
|
348 CURLOPT_CAPATH = CURLOPTTYPE_OBJECTPOINT + 97,
|
|
|
349 CURLOPT_BUFFERSIZE = CURLOPTTYPE_LONG + 98,
|
|
|
350 CURLOPT_NOSIGNAL = CURLOPTTYPE_LONG + 99,
|
|
|
351 CURLOPT_SHARE = CURLOPTTYPE_OBJECTPOINT + 100,
|
|
|
352 CURLOPT_PROXYTYPE = CURLOPTTYPE_LONG + 101,
|
|
|
353 CURLOPT_ENCODING = CURLOPTTYPE_OBJECTPOINT + 102,
|
|
|
354 CURLOPT_PRIVATE = CURLOPTTYPE_OBJECTPOINT + 103,
|
|
|
355 CURLOPT_HTTP200ALIASES = CURLOPTTYPE_OBJECTPOINT + 104,
|
|
|
356 CURLOPT_UNRESTRICTED_AUTH = CURLOPTTYPE_LONG + 105,
|
|
|
357 CURLOPT_FTP_USE_EPRT = CURLOPTTYPE_LONG + 106,
|
|
|
358 CURLOPT_HTTPAUTH = CURLOPTTYPE_LONG + 107,
|
|
|
359 CURLOPT_SSL_CTX_FUNCTION = CURLOPTTYPE_FUNCTIONPOINT + 108,
|
|
|
360 CURLOPT_SSL_CTX_DATA = CURLOPTTYPE_OBJECTPOINT + 109,
|
|
|
361 CURLOPT_FTP_CREATE_MISSING_DIRS = CURLOPTTYPE_LONG + 110,
|
|
|
362 CURLOPT_PROXYAUTH = CURLOPTTYPE_LONG + 111,
|
|
|
363 CURLOPT_FTP_RESPONSE_TIMEOUT = CURLOPTTYPE_LONG + 112,
|
|
|
364 CURLOPT_IPRESOLVE = CURLOPTTYPE_LONG + 113,
|
|
|
365 CURLOPT_MAXFILESIZE = CURLOPTTYPE_LONG + 114,
|
|
|
366 CURLOPT_INFILESIZE_LARGE = CURLOPTTYPE_OFF_T + 115,
|
|
|
367 CURLOPT_RESUME_FROM_LARGE = CURLOPTTYPE_OFF_T + 116,
|
|
|
368 CURLOPT_MAXFILESIZE_LARGE = CURLOPTTYPE_OFF_T + 117,
|
|
|
369 CURLOPT_NETRC_FILE = CURLOPTTYPE_OBJECTPOINT + 118,
|
|
|
370 CURLOPT_FTP_SSL = CURLOPTTYPE_LONG + 119,
|
|
|
371 CURLOPT_POSTFIELDSIZE_LARGE = CURLOPTTYPE_OFF_T + 120,
|
|
|
372 CURLOPT_TCP_NODELAY = CURLOPTTYPE_LONG + 121,
|
|
|
373 CURLOPT_SOURCE_USERPWD = CURLOPTTYPE_OBJECTPOINT + 123,
|
|
|
374 CURLOPT_SOURCE_PREQUOTE = CURLOPTTYPE_OBJECTPOINT + 127,
|
|
|
375 CURLOPT_SOURCE_POSTQUOTE = CURLOPTTYPE_OBJECTPOINT + 128,
|
|
|
376 CURLOPT_FTPSSLAUTH = CURLOPTTYPE_LONG + 129,
|
|
|
377 CURLOPT_IOCTLFUNCTION = CURLOPTTYPE_FUNCTIONPOINT + 130,
|
|
|
378 CURLOPT_IOCTLDATA = CURLOPTTYPE_OBJECTPOINT + 131,
|
|
|
379 CURLOPT_SOURCE_URL = CURLOPTTYPE_OBJECTPOINT + 132,
|
|
|
380 CURLOPT_SOURCE_QUOTE = CURLOPTTYPE_OBJECTPOINT + 133,
|
|
|
381 CURLOPT_FTP_ACCOUNT = CURLOPTTYPE_OBJECTPOINT + 134,
|
|
|
382 CURLOPT_COOKIELIST = CURLOPTTYPE_OBJECTPOINT + 135,
|
|
|
383 CURLOPT_IGNORE_CONTENT_LENGTH = CURLOPTTYPE_LONG + 136,
|
|
|
384 CURLOPT_FTP_SKIP_PASV_IP = CURLOPTTYPE_LONG + 137,
|
|
|
385 CURLOPT_FTP_FILEMETHOD = CURLOPTTYPE_LONG + 138,
|
|
|
386 CURLOPT_LOCALPORT = CURLOPTTYPE_LONG + 139,
|
|
|
387 CURLOPT_LOCALPORTRANGE = CURLOPTTYPE_LONG + 140,
|
|
|
388 CURLOPT_CONNECT_ONLY = CURLOPTTYPE_LONG + 141,
|
|
|
389 CURLOPT_CONV_FROM_NETWORK_FUNCTION = CURLOPTTYPE_FUNCTIONPOINT + 142,
|
|
|
390 CURLOPT_CONV_TO_NETWORK_FUNCTION = CURLOPTTYPE_FUNCTIONPOINT + 143,
|
|
|
391 CURLOPT_CONV_FROM_UTF8_FUNCTION = CURLOPTTYPE_FUNCTIONPOINT + 144,
|
|
|
392 CURLOPT_MAX_SEND_SPEED_LARGE = CURLOPTTYPE_OFF_T + 145,
|
|
|
393 CURLOPT_MAX_RECV_SPEED_LARGE = CURLOPTTYPE_OFF_T + 146,
|
|
|
394 CURLOPT_FTP_ALTERNATIVE_TO_USER = CURLOPTTYPE_OBJECTPOINT + 147,
|
|
|
395
|
|
|
396 CURLOPT_LASTENTRY
|
|
|
397 }
|
|
|
398
|
|
|
399 const int CURL_IPRESOLVE_WHATEVER = 0;
|
|
|
400 const int CURL_IPRESOLVE_V4 = 1;
|
|
|
401 const int CURL_IPRESOLVE_V6 = 2;
|
|
|
402 const int CURLOPT_WRITEDATA = CURLOPT_FILE;
|
|
|
403 const int CURLOPT_READDATA = CURLOPT_INFILE;
|
|
|
404 const int CURLOPT_HEADERDATA = CURLOPT_WRITEHEADER;
|
|
|
405
|
|
|
406 enum {
|
|
|
407 CURL_HTTP_VERSION_NONE,
|
|
|
408 CURL_HTTP_VERSION_1_0,
|
|
|
409 CURL_HTTP_VERSION_1_1,
|
|
|
410
|
|
|
411 CURL_HTTP_VERSION_LAST
|
|
|
412 }
|
|
|
413
|
|
|
414 enum {
|
|
|
415 CURL_NETRC_IGNORED,
|
|
|
416 CURL_NETRC_OPTIONAL,
|
|
|
417 CURL_NETRC_REQUIRED,
|
|
|
418
|
|
|
419 CURL_NETRC_LAST
|
|
|
420 }
|
|
|
421
|
|
|
422 enum {
|
|
|
423 CURL_SSLVERSION_DEFAULT,
|
|
|
424 CURL_SSLVERSION_TLSv1,
|
|
|
425 CURL_SSLVERSION_SSLv2,
|
|
|
426 CURL_SSLVERSION_SSLv3,
|
|
|
427
|
|
|
428 CURL_SSLVERSION_LAST
|
|
|
429 }
|
|
|
430
|
|
|
431 enum {
|
|
|
432 CURL_TIMECOND_NONE,
|
|
|
433 CURL_TIMECOND_IFMODSINCE,
|
|
|
434 CURL_TIMECOND_IFUNMODSINCE,
|
|
|
435 CURL_TIMECOND_LASTMOD,
|
|
|
436
|
|
|
437 CURL_TIMECOND_LAST
|
|
|
438 }
|
|
|
439
|
|
|
440 alias int CURLformoption;
|
|
|
441 enum {
|
|
|
442 CURLFORM_NOTHING,
|
|
|
443 CURLFORM_COPYNAME,
|
|
|
444 CURLFORM_PTRNAME,
|
|
|
445 CURLFORM_NAMELENGTH,
|
|
|
446 CURLFORM_COPYCONTENTS,
|
|
|
447 CURLFORM_PTRCONTENTS,
|
|
|
448 CURLFORM_CONTENTSLENGTH,
|
|
|
449 CURLFORM_FILECONTENT,
|
|
|
450 CURLFORM_ARRAY,
|
|
|
451 CURLFORM_OBSOLETE,
|
|
|
452 CURLFORM_FILE,
|
|
|
453 CURLFORM_BUFFER,
|
|
|
454 CURLFORM_BUFFERPTR,
|
|
|
455 CURLFORM_BUFFERLENGTH,
|
|
|
456 CURLFORM_CONTENTTYPE,
|
|
|
457 CURLFORM_CONTENTHEADER,
|
|
|
458 CURLFORM_FILENAME,
|
|
|
459 CURLFORM_END,
|
|
|
460 CURLFORM_OBSOLETE2,
|
|
|
461 CURLFORM_LASTENTRY
|
|
|
462 }
|
|
|
463
|
|
|
464 struct curl_forms {
|
|
|
465 CURLformoption option;
|
|
|
466 char* value;
|
|
|
467 }
|
|
|
468
|
|
|
469 alias int CURLFORMcode;
|
|
|
470 enum {
|
|
|
471 CURL_FORMADD_OK,
|
|
|
472 CURL_FORMADD_MEMORY,
|
|
|
473 CURL_FORMADD_OPTION_TWICE,
|
|
|
474 CURL_FORMADD_NULL,
|
|
|
475 CURL_FORMADD_UNKNOWN_OPTION,
|
|
|
476 CURL_FORMADD_INCOMPLETE,
|
|
|
477 CURL_FORMADD_ILLEGAL_ARRAY,
|
|
|
478 CURL_FORMADD_DISABLED,
|
|
|
479
|
|
|
480 CURL_FORMADD_LAST
|
|
|
481 }
|
|
|
482
|
|
|
483 CURLFORMcode curl_formadd(
|
|
|
484 curl_httppost** httppost,
|
|
|
485 curl_httppost** last_post,
|
|
|
486 ...);
|
|
|
487
|
|
|
488 alias size_t function(void* arg, char* buf, size_t len) curl_formget_callback;
|
|
|
489
|
|
|
490 int curl_formget(curl_httppost* form, void* arg, curl_formget_callback append);
|
|
|
491
|
|
|
492 void curl_formfree(curl_httppost* form);
|
|
|
493
|
|
|
494 char* curl_getenv(char* variable);
|
|
|
495
|
|
|
496 char* curl_version();
|
|
|
497
|
|
|
498 char* curl_easy_escape(CURL* handle, char* string, int length);
|
|
|
499
|
|
|
500 char* curl_easy_unescape(
|
|
|
501 CURL* handle,
|
|
|
502 char* string,
|
|
|
503 int length,
|
|
|
504 int* outlength);
|
|
|
505
|
|
|
506 void curl_free(void* p);
|
|
|
507
|
|
|
508 CURLcode curl_global_init(int flags);
|
|
|
509
|
|
|
510 CURLcode curl_global_init_mem(
|
|
|
511 int flags,
|
|
|
512 curl_malloc_callback m,
|
|
|
513 curl_free_callback f,
|
|
|
514 curl_realloc_callback r,
|
|
|
515 curl_strdup_callback s,
|
|
|
516 curl_calloc_callback c);
|
|
|
517
|
|
|
518 void curl_global_cleanup();
|
|
|
519
|
|
|
520 struct curl_slist {
|
|
|
521 char* data;
|
|
|
522 curl_slist* next;
|
|
|
523 }
|
|
|
524
|
|
|
525 curl_slist* curl_slist_append(curl_slist*, char*);
|
|
|
526
|
|
|
527 void curl_slist_free_all(curl_slist*);
|
|
|
528
|
|
|
529 size_t curl_getdate(char* p, size_t* unused);
|
|
|
530
|
|
|
531 const int CURLINFO_STRING = 0x100000;
|
|
|
532 const int CURLINFO_LONG = 0x200000;
|
|
|
533 const int CURLINFO_DOUBLE = 0x300000;
|
|
|
534 const int CURLINFO_SLIST = 0x400000;
|
|
|
535 const int CURLINFO_MASK = 0x0fffff;
|
|
|
536 const int CURLINFO_TYPEMASK = 0xf00000;
|
|
|
537
|
|
|
538 alias int CURLINFO;
|
|
|
539 enum {
|
|
|
540 CURLINFO_NONE,
|
|
|
541
|
|
|
542 CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1,
|
|
|
543 CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2,
|
|
|
544 CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3,
|
|
|
545 CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4,
|
|
|
546 CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5,
|
|
|
547 CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
|
|
|
548 CURLINFO_SIZE_UPLOAD = CURLINFO_DOUBLE + 7,
|
|
|
549 CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8,
|
|
|
550 CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9,
|
|
|
551 CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10,
|
|
|
552 CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11,
|
|
|
553 CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12,
|
|
|
554 CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13,
|
|
|
555 CURLINFO_FILETIME = CURLINFO_LONG + 14,
|
|
|
556 CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15,
|
|
|
557 CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16,
|
|
|
558 CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
|
|
|
559 CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18,
|
|
|
560 CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19,
|
|
|
561 CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20,
|
|
|
562 CURLINFO_PRIVATE = CURLINFO_STRING + 21,
|
|
|
563 CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22,
|
|
|
564 CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23,
|
|
|
565 CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24,
|
|
|
566 CURLINFO_OS_ERRNO = CURLINFO_LONG + 25,
|
|
|
567 CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26,
|
|
|
568 CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27,
|
|
|
569 CURLINFO_COOKIELIST = CURLINFO_SLIST + 28,
|
|
|
570 CURLINFO_LASTSOCKET = CURLINFO_LONG + 29,
|
|
|
571 CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30,
|
|
|
572
|
|
|
573 CURLINFO_LASTONE = 30
|
|
|
574 }
|
|
|
575
|
|
|
576 alias int curl_closepolicy;
|
|
|
577 enum {
|
|
|
578 CURLCLOSEPOLICY_NONE,
|
|
|
579
|
|
|
580 CURLCLOSEPOLICY_OLDEST,
|
|
|
581 CURLCLOSEPOLICY_LEAST_RECENTLY_USED,
|
|
|
582 CURLCLOSEPOLICY_LEAST_TRAFFIC,
|
|
|
583 CURLCLOSEPOLICY_SLOWEST,
|
|
|
584 CURLCLOSEPOLICY_CALLBACK,
|
|
|
585
|
|
|
586 CURLCLOSEPOLICY_LAST
|
|
|
587 }
|
|
|
588
|
|
|
589 const int CURL_GLOBAL_SSL = 1 << 0;
|
|
|
590 const int CURL_GLOBAL_WIN32 = 1 << 1;
|
|
|
591 const int CURL_GLOBAL_ALL = CURL_GLOBAL_SSL | CURL_GLOBAL_WIN32;
|
|
|
592 const int CURL_GLOBAL_NOTHING = 0;
|
|
|
593 const int CURL_GLOBAL_DEFAULT = CURL_GLOBAL_ALL;
|
|
|
594
|
|
|
595 //{{{ share
|
|
|
596 alias int curl_lock_data;
|
|
|
597 enum {
|
|
|
598 CURL_LOCK_DATA_NONE = 0,
|
|
|
599 CURL_LOCK_DATA_SHARE,
|
|
|
600 CURL_LOCK_DATA_COOKIE,
|
|
|
601 CURL_LOCK_DATA_DNS,
|
|
|
602 CURL_LOCK_DATA_SSL_SESSION,
|
|
|
603 CURL_LOCK_DATA_CONNECT,
|
|
|
604
|
|
|
605 CURL_LOCK_DATA_LAST
|
|
|
606 }
|
|
|
607
|
|
|
608 alias int curl_lock_access;
|
|
|
609 enum {
|
|
|
610 CURL_LOCK_ACCESS_NONE = 0,
|
|
|
611 CURL_LOCK_ACCESS_SHARED = 1,
|
|
|
612 CURL_LOCK_ACCESS_SINGLE = 2,
|
|
|
613
|
|
|
614 CURL_LOCK_ACCESS_LAST
|
|
|
615 }
|
|
|
616
|
|
|
617 alias void function(
|
|
|
618 CURL* handle,
|
|
|
619 curl_lock_data data,
|
|
|
620 curl_lock_access locktype,
|
|
|
621 void* userptr) curl_lock_function;
|
|
|
622 alias void function(
|
|
|
623 CURL* handle,
|
|
|
624 curl_lock_data data,
|
|
|
625 void* userptr) curl_unlock_function;
|
|
|
626
|
|
|
627 alias void CURLSH;
|
|
|
628
|
|
|
629 alias int CURLSHcode;
|
|
|
630 enum {
|
|
|
631 CURLSHE_OK,
|
|
|
632 CURLSHE_BAD_OPTION,
|
|
|
633 CURLSHE_IN_USE,
|
|
|
634 CURLSHE_INVALID,
|
|
|
635 CURLSHE_NOMEM,
|
|
|
636
|
|
|
637 CURLSHE_LAST
|
|
|
638 }
|
|
|
639
|
|
|
640 alias int CURLSHoption;
|
|
|
641 enum {
|
|
|
642 CURLSHOPT_NONE,
|
|
|
643 CURLSHOPT_SHARE,
|
|
|
644 CURLSHOPT_UNSHARE,
|
|
|
645 CURLSHOPT_LOCKFUNC,
|
|
|
646 CURLSHOPT_UNLOCKFUNC,
|
|
|
647 CURLSHOPT_USERDATA,
|
|
|
648
|
|
|
649 CURLSHOPT_LAST
|
|
|
650 }
|
|
|
651
|
|
|
652 CURLSH* curl_share_init();
|
|
|
653
|
|
|
654 CURLSHcode curl_share_setopt(CURLSH*, CURLSHoption option, ...);
|
|
|
655
|
|
|
656 CURLSHcode curl_share_cleanup(CURLSH*);
|
|
|
657
|
|
|
658 char* curl_share_strerror(CURLSHcode);
|
|
|
659 //}}}
|
|
|
660
|
|
|
661 //{{{ version
|
|
|
662 alias int CURLversion;
|
|
|
663 enum {
|
|
|
664 CURLVERSION_FIRST,
|
|
|
665 CURLVERSION_SECOND,
|
|
|
666 CURLVERSION_THIRD,
|
|
|
667
|
|
|
668 CURLVERSION_LAST
|
|
|
669 }
|
|
|
670
|
|
|
671 const int CURLVERSION_NOW = CURLVERSION_THIRD;
|
|
|
672
|
|
|
673 struct curl_version_info_data {
|
|
|
674 CURLversion age;
|
|
|
675 char* version_str;
|
|
|
676 uint version_num;
|
|
|
677 char* host;
|
|
|
678 int features;
|
|
|
679 char* ssl_version;
|
|
|
680 int ssl_version_num;
|
|
|
681 char* libz_version;
|
|
|
682 char** protocols;
|
|
|
683 char* ares;
|
|
|
684 int ares_num;
|
|
|
685 char* libidn;
|
|
|
686 int iconv_ver_num;
|
|
|
687 }
|
|
|
688
|
|
|
689 const int CURL_VERSION_IPV6 = 1 << 0;
|
|
|
690 const int CURL_VERSION_KERBEROS4 = 1 << 1;
|
|
|
691 const int CURL_VERSION_SSL = 1 << 2;
|
|
|
692 const int CURL_VERSION_LIBZ = 1 << 3;
|
|
|
693 const int CURL_VERSION_NTLM = 1 << 4;
|
|
|
694 const int CURL_VERSION_GSSNEGOTIATE = 1 << 5;
|
|
|
695 const int CURL_VERSION_DEBUG = 1 << 6;
|
|
|
696 const int CURL_VERSION_ASYNCHDNS = 1 << 7;
|
|
|
697 const int CURL_VERSION_SPNEGO = 1 << 8;
|
|
|
698 const int CURL_VERSION_LARGEFILE = 1 << 9;
|
|
|
699 const int CURL_VERSION_IDN = 1 << 10;
|
|
|
700 const int CURL_VERSION_SSPI = 1 << 11;
|
|
|
701 const int CURL_VERSION_CONV = 1 << 12;
|
|
|
702
|
|
|
703 curl_version_info_data* curl_version_info(CURLversion);
|
|
|
704
|
|
|
705 char* curl_easy_strerror(CURLcode);
|
|
|
706 //}}}
|
|
|
707
|
