1 | #ifndef __CURL_CURL_H
|
---|
2 | #define __CURL_CURL_H
|
---|
3 | /***************************************************************************
|
---|
4 | * _ _ ____ _
|
---|
5 | * Project ___| | | | _ \| |
|
---|
6 | * / __| | | | |_) | |
|
---|
7 | * | (__| |_| | _ <| |___
|
---|
8 | * \___|\___/|_| \_\_____|
|
---|
9 | *
|
---|
10 | * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
|
---|
11 | *
|
---|
12 | * This software is licensed as described in the file COPYING, which
|
---|
13 | * you should have received as part of this distribution. The terms
|
---|
14 | * are also available at https://curl.haxx.se/docs/copyright.html.
|
---|
15 | *
|
---|
16 | * You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
---|
17 | * copies of the Software, and permit persons to whom the Software is
|
---|
18 | * furnished to do so, under the terms of the COPYING file.
|
---|
19 | *
|
---|
20 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
---|
21 | * KIND, either express or implied.
|
---|
22 | *
|
---|
23 | ***************************************************************************/
|
---|
24 |
|
---|
25 | /*
|
---|
26 | * If you have libcurl problems, all docs and details are found here:
|
---|
27 | * https://curl.haxx.se/libcurl/
|
---|
28 | *
|
---|
29 | * curl-library mailing list subscription and unsubscription web interface:
|
---|
30 | * https://cool.haxx.se/mailman/listinfo/curl-library/
|
---|
31 | */
|
---|
32 |
|
---|
33 | #include "curlver.h" /* libcurl version defines */
|
---|
34 | #include "curlbuild.h" /* libcurl build definitions */
|
---|
35 | #include "curlrules.h" /* libcurl rules enforcement */
|
---|
36 |
|
---|
37 | /*
|
---|
38 | * Define WIN32 when build target is Win32 API
|
---|
39 | */
|
---|
40 |
|
---|
41 | #if (defined(_WIN32) || defined(__WIN32__)) && \
|
---|
42 | !defined(WIN32) && !defined(__SYMBIAN32__)
|
---|
43 | #define WIN32
|
---|
44 | #endif
|
---|
45 |
|
---|
46 | #include <stdio.h>
|
---|
47 | #include <limits.h>
|
---|
48 |
|
---|
49 | #if defined(__FreeBSD__) && (__FreeBSD__ >= 2)
|
---|
50 | /* Needed for __FreeBSD_version symbol definition */
|
---|
51 | #include <osreldate.h>
|
---|
52 | #endif
|
---|
53 |
|
---|
54 | /* The include stuff here below is mainly for time_t! */
|
---|
55 | #include <sys/types.h>
|
---|
56 | #include <time.h>
|
---|
57 |
|
---|
58 | #if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__)
|
---|
59 | #if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || \
|
---|
60 | defined(__LWIP_OPT_H__) || defined(LWIP_HDR_OPT_H))
|
---|
61 | /* The check above prevents the winsock2 inclusion if winsock.h already was
|
---|
62 | included, since they can't co-exist without problems */
|
---|
63 | #include <winsock2.h>
|
---|
64 | #include <ws2tcpip.h>
|
---|
65 | #endif
|
---|
66 | #endif
|
---|
67 |
|
---|
68 | /* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish
|
---|
69 | libc5-based Linux systems. Only include it on systems that are known to
|
---|
70 | require it! */
|
---|
71 | #if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \
|
---|
72 | defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \
|
---|
73 | defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \
|
---|
74 | (defined(__FreeBSD_version) && (__FreeBSD_version < 800000))
|
---|
75 | #include <sys/select.h>
|
---|
76 | #endif
|
---|
77 |
|
---|
78 | #if !defined(WIN32) && !defined(_WIN32_WCE) && !defined(USE_LWIPSOCK)
|
---|
79 | #include <sys/socket.h>
|
---|
80 | #endif
|
---|
81 |
|
---|
82 | #if !defined(WIN32) && !defined(__WATCOMC__) && !defined(__VXWORKS__)
|
---|
83 | #include <sys/time.h>
|
---|
84 | #endif
|
---|
85 |
|
---|
86 | #ifdef __BEOS__
|
---|
87 | #include <support/SupportDefs.h>
|
---|
88 | #endif
|
---|
89 |
|
---|
90 | #ifdef __cplusplus
|
---|
91 | extern "C" {
|
---|
92 | #endif
|
---|
93 |
|
---|
94 | typedef void CURL;
|
---|
95 |
|
---|
96 | /*
|
---|
97 | * libcurl external API function linkage decorations.
|
---|
98 | */
|
---|
99 |
|
---|
100 | #ifdef CURL_STATICLIB
|
---|
101 | # define CURL_EXTERN
|
---|
102 | #elif defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__)
|
---|
103 | # if defined(BUILDING_LIBCURL)
|
---|
104 | # define CURL_EXTERN __declspec(dllexport)
|
---|
105 | # else
|
---|
106 | # define CURL_EXTERN __declspec(dllimport)
|
---|
107 | # endif
|
---|
108 | #elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS)
|
---|
109 | # define CURL_EXTERN CURL_EXTERN_SYMBOL
|
---|
110 | #else
|
---|
111 | # define CURL_EXTERN
|
---|
112 | #endif
|
---|
113 |
|
---|
114 | #ifndef curl_socket_typedef
|
---|
115 | /* socket typedef */
|
---|
116 | #if defined(WIN32) && !defined(__LWIP_OPT_H__) && !defined(LWIP_HDR_OPT_H)
|
---|
117 | typedef SOCKET curl_socket_t;
|
---|
118 | #define CURL_SOCKET_BAD INVALID_SOCKET
|
---|
119 | #else
|
---|
120 | typedef int curl_socket_t;
|
---|
121 | #define CURL_SOCKET_BAD -1
|
---|
122 | #endif
|
---|
123 | #define curl_socket_typedef
|
---|
124 | #endif /* curl_socket_typedef */
|
---|
125 |
|
---|
126 | struct curl_httppost {
|
---|
127 | struct curl_httppost *next; /* next entry in the list */
|
---|
128 | char *name; /* pointer to allocated name */
|
---|
129 | long namelength; /* length of name length */
|
---|
130 | char *contents; /* pointer to allocated data contents */
|
---|
131 | long contentslength; /* length of contents field, see also
|
---|
132 | CURL_HTTPPOST_LARGE */
|
---|
133 | char *buffer; /* pointer to allocated buffer contents */
|
---|
134 | long bufferlength; /* length of buffer field */
|
---|
135 | char *contenttype; /* Content-Type */
|
---|
136 | struct curl_slist* contentheader; /* list of extra headers for this form */
|
---|
137 | struct curl_httppost *more; /* if one field name has more than one
|
---|
138 | file, this link should link to following
|
---|
139 | files */
|
---|
140 | long flags; /* as defined below */
|
---|
141 |
|
---|
142 | /* specified content is a file name */
|
---|
143 | #define CURL_HTTPPOST_FILENAME (1<<0)
|
---|
144 | /* specified content is a file name */
|
---|
145 | #define CURL_HTTPPOST_READFILE (1<<1)
|
---|
146 | /* name is only stored pointer do not free in formfree */
|
---|
147 | #define CURL_HTTPPOST_PTRNAME (1<<2)
|
---|
148 | /* contents is only stored pointer do not free in formfree */
|
---|
149 | #define CURL_HTTPPOST_PTRCONTENTS (1<<3)
|
---|
150 | /* upload file from buffer */
|
---|
151 | #define CURL_HTTPPOST_BUFFER (1<<4)
|
---|
152 | /* upload file from pointer contents */
|
---|
153 | #define CURL_HTTPPOST_PTRBUFFER (1<<5)
|
---|
154 | /* upload file contents by using the regular read callback to get the data and
|
---|
155 | pass the given pointer as custom pointer */
|
---|
156 | #define CURL_HTTPPOST_CALLBACK (1<<6)
|
---|
157 | /* use size in 'contentlen', added in 7.46.0 */
|
---|
158 | #define CURL_HTTPPOST_LARGE (1<<7)
|
---|
159 |
|
---|
160 | char *showfilename; /* The file name to show. If not set, the
|
---|
161 | actual file name will be used (if this
|
---|
162 | is a file part) */
|
---|
163 | void *userp; /* custom pointer used for
|
---|
164 | HTTPPOST_CALLBACK posts */
|
---|
165 | curl_off_t contentlen; /* alternative length of contents
|
---|
166 | field. Used if CURL_HTTPPOST_LARGE is
|
---|
167 | set. Added in 7.46.0 */
|
---|
168 | };
|
---|
169 |
|
---|
170 | /* This is the CURLOPT_PROGRESSFUNCTION callback proto. It is now considered
|
---|
171 | deprecated but was the only choice up until 7.31.0 */
|
---|
172 | typedef int (*curl_progress_callback)(void *clientp,
|
---|
173 | double dltotal,
|
---|
174 | double dlnow,
|
---|
175 | double ultotal,
|
---|
176 | double ulnow);
|
---|
177 |
|
---|
178 | /* This is the CURLOPT_XFERINFOFUNCTION callback proto. It was introduced in
|
---|
179 | 7.32.0, it avoids floating point and provides more detailed information. */
|
---|
180 | typedef int (*curl_xferinfo_callback)(void *clientp,
|
---|
181 | curl_off_t dltotal,
|
---|
182 | curl_off_t dlnow,
|
---|
183 | curl_off_t ultotal,
|
---|
184 | curl_off_t ulnow);
|
---|
185 |
|
---|
186 | #ifndef CURL_MAX_WRITE_SIZE
|
---|
187 | /* Tests have proven that 20K is a very bad buffer size for uploads on
|
---|
188 | Windows, while 16K for some odd reason performed a lot better.
|
---|
189 | We do the ifndef check to allow this value to easier be changed at build
|
---|
190 | time for those who feel adventurous. The practical minimum is about
|
---|
191 | 400 bytes since libcurl uses a buffer of this size as a scratch area
|
---|
192 | (unrelated to network send operations). */
|
---|
193 | #define CURL_MAX_WRITE_SIZE 16384
|
---|
194 | #endif
|
---|
195 |
|
---|
196 | #ifndef CURL_MAX_HTTP_HEADER
|
---|
197 | /* The only reason to have a max limit for this is to avoid the risk of a bad
|
---|
198 | server feeding libcurl with a never-ending header that will cause reallocs
|
---|
199 | infinitely */
|
---|
200 | #define CURL_MAX_HTTP_HEADER (100*1024)
|
---|
201 | #endif
|
---|
202 |
|
---|
203 | /* This is a magic return code for the write callback that, when returned,
|
---|
204 | will signal libcurl to pause receiving on the current transfer. */
|
---|
205 | #define CURL_WRITEFUNC_PAUSE 0x10000001
|
---|
206 |
|
---|
207 | typedef size_t (*curl_write_callback)(char *buffer,
|
---|
208 | size_t size,
|
---|
209 | size_t nitems,
|
---|
210 | void *outstream);
|
---|
211 |
|
---|
212 |
|
---|
213 |
|
---|
214 | /* enumeration of file types */
|
---|
215 | typedef enum {
|
---|
216 | CURLFILETYPE_FILE = 0,
|
---|
217 | CURLFILETYPE_DIRECTORY,
|
---|
218 | CURLFILETYPE_SYMLINK,
|
---|
219 | CURLFILETYPE_DEVICE_BLOCK,
|
---|
220 | CURLFILETYPE_DEVICE_CHAR,
|
---|
221 | CURLFILETYPE_NAMEDPIPE,
|
---|
222 | CURLFILETYPE_SOCKET,
|
---|
223 | CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */
|
---|
224 |
|
---|
225 | CURLFILETYPE_UNKNOWN /* should never occur */
|
---|
226 | } curlfiletype;
|
---|
227 |
|
---|
228 | #define CURLFINFOFLAG_KNOWN_FILENAME (1<<0)
|
---|
229 | #define CURLFINFOFLAG_KNOWN_FILETYPE (1<<1)
|
---|
230 | #define CURLFINFOFLAG_KNOWN_TIME (1<<2)
|
---|
231 | #define CURLFINFOFLAG_KNOWN_PERM (1<<3)
|
---|
232 | #define CURLFINFOFLAG_KNOWN_UID (1<<4)
|
---|
233 | #define CURLFINFOFLAG_KNOWN_GID (1<<5)
|
---|
234 | #define CURLFINFOFLAG_KNOWN_SIZE (1<<6)
|
---|
235 | #define CURLFINFOFLAG_KNOWN_HLINKCOUNT (1<<7)
|
---|
236 |
|
---|
237 | /* Content of this structure depends on information which is known and is
|
---|
238 | achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man
|
---|
239 | page for callbacks returning this structure -- some fields are mandatory,
|
---|
240 | some others are optional. The FLAG field has special meaning. */
|
---|
241 | struct curl_fileinfo {
|
---|
242 | char *filename;
|
---|
243 | curlfiletype filetype;
|
---|
244 | time_t time;
|
---|
245 | unsigned int perm;
|
---|
246 | int uid;
|
---|
247 | int gid;
|
---|
248 | curl_off_t size;
|
---|
249 | long int hardlinks;
|
---|
250 |
|
---|
251 | struct {
|
---|
252 | /* If some of these fields is not NULL, it is a pointer to b_data. */
|
---|
253 | char *time;
|
---|
254 | char *perm;
|
---|
255 | char *user;
|
---|
256 | char *group;
|
---|
257 | char *target; /* pointer to the target filename of a symlink */
|
---|
258 | } strings;
|
---|
259 |
|
---|
260 | unsigned int flags;
|
---|
261 |
|
---|
262 | /* used internally */
|
---|
263 | char * b_data;
|
---|
264 | size_t b_size;
|
---|
265 | size_t b_used;
|
---|
266 | };
|
---|
267 |
|
---|
268 | /* return codes for CURLOPT_CHUNK_BGN_FUNCTION */
|
---|
269 | #define CURL_CHUNK_BGN_FUNC_OK 0
|
---|
270 | #define CURL_CHUNK_BGN_FUNC_FAIL 1 /* tell the lib to end the task */
|
---|
271 | #define CURL_CHUNK_BGN_FUNC_SKIP 2 /* skip this chunk over */
|
---|
272 |
|
---|
273 | /* if splitting of data transfer is enabled, this callback is called before
|
---|
274 | download of an individual chunk started. Note that parameter "remains" works
|
---|
275 | only for FTP wildcard downloading (for now), otherwise is not used */
|
---|
276 | typedef long (*curl_chunk_bgn_callback)(const void *transfer_info,
|
---|
277 | void *ptr,
|
---|
278 | int remains);
|
---|
279 |
|
---|
280 | /* return codes for CURLOPT_CHUNK_END_FUNCTION */
|
---|
281 | #define CURL_CHUNK_END_FUNC_OK 0
|
---|
282 | #define CURL_CHUNK_END_FUNC_FAIL 1 /* tell the lib to end the task */
|
---|
283 |
|
---|
284 | /* If splitting of data transfer is enabled this callback is called after
|
---|
285 | download of an individual chunk finished.
|
---|
286 | Note! After this callback was set then it have to be called FOR ALL chunks.
|
---|
287 | Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC.
|
---|
288 | This is the reason why we don't need "transfer_info" parameter in this
|
---|
289 | callback and we are not interested in "remains" parameter too. */
|
---|
290 | typedef long (*curl_chunk_end_callback)(void *ptr);
|
---|
291 |
|
---|
292 | /* return codes for FNMATCHFUNCTION */
|
---|
293 | #define CURL_FNMATCHFUNC_MATCH 0 /* string corresponds to the pattern */
|
---|
294 | #define CURL_FNMATCHFUNC_NOMATCH 1 /* pattern doesn't match the string */
|
---|
295 | #define CURL_FNMATCHFUNC_FAIL 2 /* an error occurred */
|
---|
296 |
|
---|
297 | /* callback type for wildcard downloading pattern matching. If the
|
---|
298 | string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */
|
---|
299 | typedef int (*curl_fnmatch_callback)(void *ptr,
|
---|
300 | const char *pattern,
|
---|
301 | const char *string);
|
---|
302 |
|
---|
303 | /* These are the return codes for the seek callbacks */
|
---|
304 | #define CURL_SEEKFUNC_OK 0
|
---|
305 | #define CURL_SEEKFUNC_FAIL 1 /* fail the entire transfer */
|
---|
306 | #define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so
|
---|
307 | libcurl might try other means instead */
|
---|
308 | typedef int (*curl_seek_callback)(void *instream,
|
---|
309 | curl_off_t offset,
|
---|
310 | int origin); /* 'whence' */
|
---|
311 |
|
---|
312 | /* This is a return code for the read callback that, when returned, will
|
---|
313 | signal libcurl to immediately abort the current transfer. */
|
---|
314 | #define CURL_READFUNC_ABORT 0x10000000
|
---|
315 | /* This is a return code for the read callback that, when returned, will
|
---|
316 | signal libcurl to pause sending data on the current transfer. */
|
---|
317 | #define CURL_READFUNC_PAUSE 0x10000001
|
---|
318 |
|
---|
319 | typedef size_t (*curl_read_callback)(char *buffer,
|
---|
320 | size_t size,
|
---|
321 | size_t nitems,
|
---|
322 | void *instream);
|
---|
323 |
|
---|
324 | typedef enum {
|
---|
325 | CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */
|
---|
326 | CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */
|
---|
327 | CURLSOCKTYPE_LAST /* never use */
|
---|
328 | } curlsocktype;
|
---|
329 |
|
---|
330 | /* The return code from the sockopt_callback can signal information back
|
---|
331 | to libcurl: */
|
---|
332 | #define CURL_SOCKOPT_OK 0
|
---|
333 | #define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return
|
---|
334 | CURLE_ABORTED_BY_CALLBACK */
|
---|
335 | #define CURL_SOCKOPT_ALREADY_CONNECTED 2
|
---|
336 |
|
---|
337 | typedef int (*curl_sockopt_callback)(void *clientp,
|
---|
338 | curl_socket_t curlfd,
|
---|
339 | curlsocktype purpose);
|
---|
340 |
|
---|
341 | struct curl_sockaddr {
|
---|
342 | int family;
|
---|
343 | int socktype;
|
---|
344 | int protocol;
|
---|
345 | unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it
|
---|
346 | turned really ugly and painful on the systems that
|
---|
347 | lack this type */
|
---|
348 | struct sockaddr addr;
|
---|
349 | };
|
---|
350 |
|
---|
351 | typedef curl_socket_t
|
---|
352 | (*curl_opensocket_callback)(void *clientp,
|
---|
353 | curlsocktype purpose,
|
---|
354 | struct curl_sockaddr *address);
|
---|
355 |
|
---|
356 | typedef int
|
---|
357 | (*curl_closesocket_callback)(void *clientp, curl_socket_t item);
|
---|
358 |
|
---|
359 | typedef enum {
|
---|
360 | CURLIOE_OK, /* I/O operation successful */
|
---|
361 | CURLIOE_UNKNOWNCMD, /* command was unknown to callback */
|
---|
362 | CURLIOE_FAILRESTART, /* failed to restart the read */
|
---|
363 | CURLIOE_LAST /* never use */
|
---|
364 | } curlioerr;
|
---|
365 |
|
---|
366 | typedef enum {
|
---|
367 | CURLIOCMD_NOP, /* no operation */
|
---|
368 | CURLIOCMD_RESTARTREAD, /* restart the read stream from start */
|
---|
369 | CURLIOCMD_LAST /* never use */
|
---|
370 | } curliocmd;
|
---|
371 |
|
---|
372 | typedef curlioerr (*curl_ioctl_callback)(CURL *handle,
|
---|
373 | int cmd,
|
---|
374 | void *clientp);
|
---|
375 |
|
---|
376 | /*
|
---|
377 | * The following typedef's are signatures of malloc, free, realloc, strdup and
|
---|
378 | * calloc respectively. Function pointers of these types can be passed to the
|
---|
379 | * curl_global_init_mem() function to set user defined memory management
|
---|
380 | * callback routines.
|
---|
381 | */
|
---|
382 | typedef void *(*curl_malloc_callback)(size_t size);
|
---|
383 | typedef void (*curl_free_callback)(void *ptr);
|
---|
384 | typedef void *(*curl_realloc_callback)(void *ptr, size_t size);
|
---|
385 | typedef char *(*curl_strdup_callback)(const char *str);
|
---|
386 | typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size);
|
---|
387 |
|
---|
388 | /* the kind of data that is passed to information_callback*/
|
---|
389 | typedef enum {
|
---|
390 | CURLINFO_TEXT = 0,
|
---|
391 | CURLINFO_HEADER_IN, /* 1 */
|
---|
392 | CURLINFO_HEADER_OUT, /* 2 */
|
---|
393 | CURLINFO_DATA_IN, /* 3 */
|
---|
394 | CURLINFO_DATA_OUT, /* 4 */
|
---|
395 | CURLINFO_SSL_DATA_IN, /* 5 */
|
---|
396 | CURLINFO_SSL_DATA_OUT, /* 6 */
|
---|
397 | CURLINFO_END
|
---|
398 | } curl_infotype;
|
---|
399 |
|
---|
400 | typedef int (*curl_debug_callback)
|
---|
401 | (CURL *handle, /* the handle/transfer this concerns */
|
---|
402 | curl_infotype type, /* what kind of data */
|
---|
403 | char *data, /* points to the data */
|
---|
404 | size_t size, /* size of the data pointed to */
|
---|
405 | void *userptr); /* whatever the user please */
|
---|
406 |
|
---|
407 | /* All possible error codes from all sorts of curl functions. Future versions
|
---|
408 | may return other values, stay prepared.
|
---|
409 |
|
---|
410 | Always add new return codes last. Never *EVER* remove any. The return
|
---|
411 | codes must remain the same!
|
---|
412 | */
|
---|
413 |
|
---|
414 | typedef enum {
|
---|
415 | CURLE_OK = 0,
|
---|
416 | CURLE_UNSUPPORTED_PROTOCOL, /* 1 */
|
---|
417 | CURLE_FAILED_INIT, /* 2 */
|
---|
418 | CURLE_URL_MALFORMAT, /* 3 */
|
---|
419 | CURLE_NOT_BUILT_IN, /* 4 - [was obsoleted in August 2007 for
|
---|
420 | 7.17.0, reused in April 2011 for 7.21.5] */
|
---|
421 | CURLE_COULDNT_RESOLVE_PROXY, /* 5 */
|
---|
422 | CURLE_COULDNT_RESOLVE_HOST, /* 6 */
|
---|
423 | CURLE_COULDNT_CONNECT, /* 7 */
|
---|
424 | CURLE_FTP_WEIRD_SERVER_REPLY, /* 8 */
|
---|
425 | CURLE_REMOTE_ACCESS_DENIED, /* 9 a service was denied by the server
|
---|
426 | due to lack of access - when login fails
|
---|
427 | this is not returned. */
|
---|
428 | CURLE_FTP_ACCEPT_FAILED, /* 10 - [was obsoleted in April 2006 for
|
---|
429 | 7.15.4, reused in Dec 2011 for 7.24.0]*/
|
---|
430 | CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */
|
---|
431 | CURLE_FTP_ACCEPT_TIMEOUT, /* 12 - timeout occurred accepting server
|
---|
432 | [was obsoleted in August 2007 for 7.17.0,
|
---|
433 | reused in Dec 2011 for 7.24.0]*/
|
---|
434 | CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */
|
---|
435 | CURLE_FTP_WEIRD_227_FORMAT, /* 14 */
|
---|
436 | CURLE_FTP_CANT_GET_HOST, /* 15 */
|
---|
437 | CURLE_HTTP2, /* 16 - A problem in the http2 framing layer.
|
---|
438 | [was obsoleted in August 2007 for 7.17.0,
|
---|
439 | reused in July 2014 for 7.38.0] */
|
---|
440 | CURLE_FTP_COULDNT_SET_TYPE, /* 17 */
|
---|
441 | CURLE_PARTIAL_FILE, /* 18 */
|
---|
442 | CURLE_FTP_COULDNT_RETR_FILE, /* 19 */
|
---|
443 | CURLE_OBSOLETE20, /* 20 - NOT USED */
|
---|
444 | CURLE_QUOTE_ERROR, /* 21 - quote command failure */
|
---|
445 | CURLE_HTTP_RETURNED_ERROR, /* 22 */
|
---|
446 | CURLE_WRITE_ERROR, /* 23 */
|
---|
447 | CURLE_OBSOLETE24, /* 24 - NOT USED */
|
---|
448 | CURLE_UPLOAD_FAILED, /* 25 - failed upload "command" */
|
---|
449 | CURLE_READ_ERROR, /* 26 - couldn't open/read from file */
|
---|
450 | CURLE_OUT_OF_MEMORY, /* 27 */
|
---|
451 | /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error
|
---|
452 | instead of a memory allocation error if CURL_DOES_CONVERSIONS
|
---|
453 | is defined
|
---|
454 | */
|
---|
455 | CURLE_OPERATION_TIMEDOUT, /* 28 - the timeout time was reached */
|
---|
456 | CURLE_OBSOLETE29, /* 29 - NOT USED */
|
---|
457 | CURLE_FTP_PORT_FAILED, /* 30 - FTP PORT operation failed */
|
---|
458 | CURLE_FTP_COULDNT_USE_REST, /* 31 - the REST command failed */
|
---|
459 | CURLE_OBSOLETE32, /* 32 - NOT USED */
|
---|
460 | CURLE_RANGE_ERROR, /* 33 - RANGE "command" didn't work */
|
---|
461 | CURLE_HTTP_POST_ERROR, /* 34 */
|
---|
462 | CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */
|
---|
463 | CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */
|
---|
464 | CURLE_FILE_COULDNT_READ_FILE, /* 37 */
|
---|
465 | CURLE_LDAP_CANNOT_BIND, /* 38 */
|
---|
466 | CURLE_LDAP_SEARCH_FAILED, /* 39 */
|
---|
467 | CURLE_OBSOLETE40, /* 40 - NOT USED */
|
---|
468 | CURLE_FUNCTION_NOT_FOUND, /* 41 */
|
---|
469 | CURLE_ABORTED_BY_CALLBACK, /* 42 */
|
---|
470 | CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */
|
---|
471 | CURLE_OBSOLETE44, /* 44 - NOT USED */
|
---|
472 | CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */
|
---|
473 | CURLE_OBSOLETE46, /* 46 - NOT USED */
|
---|
474 | CURLE_TOO_MANY_REDIRECTS , /* 47 - catch endless re-direct loops */
|
---|
475 | CURLE_UNKNOWN_OPTION, /* 48 - User specified an unknown option */
|
---|
476 | CURLE_TELNET_OPTION_SYNTAX , /* 49 - Malformed telnet option */
|
---|
477 | CURLE_OBSOLETE50, /* 50 - NOT USED */
|
---|
478 | CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint
|
---|
479 | wasn't verified fine */
|
---|
480 | CURLE_GOT_NOTHING, /* 52 - when this is a specific error */
|
---|
481 | CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */
|
---|
482 | CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as
|
---|
483 | default */
|
---|
484 | CURLE_SEND_ERROR, /* 55 - failed sending network data */
|
---|
485 | CURLE_RECV_ERROR, /* 56 - failure in receiving network data */
|
---|
486 | CURLE_OBSOLETE57, /* 57 - NOT IN USE */
|
---|
487 | CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */
|
---|
488 | CURLE_SSL_CIPHER, /* 59 - couldn't use specified cipher */
|
---|
489 | CURLE_SSL_CACERT, /* 60 - problem with the CA cert (path?) */
|
---|
490 | CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */
|
---|
491 | CURLE_LDAP_INVALID_URL, /* 62 - Invalid LDAP URL */
|
---|
492 | CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */
|
---|
493 | CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */
|
---|
494 | CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind
|
---|
495 | that failed */
|
---|
496 | CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */
|
---|
497 | CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not
|
---|
498 | accepted and we failed to login */
|
---|
499 | CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */
|
---|
500 | CURLE_TFTP_PERM, /* 69 - permission problem on server */
|
---|
501 | CURLE_REMOTE_DISK_FULL, /* 70 - out of disk space on server */
|
---|
502 | CURLE_TFTP_ILLEGAL, /* 71 - Illegal TFTP operation */
|
---|
503 | CURLE_TFTP_UNKNOWNID, /* 72 - Unknown transfer ID */
|
---|
504 | CURLE_REMOTE_FILE_EXISTS, /* 73 - File already exists */
|
---|
505 | CURLE_TFTP_NOSUCHUSER, /* 74 - No such user */
|
---|
506 | CURLE_CONV_FAILED, /* 75 - conversion failed */
|
---|
507 | CURLE_CONV_REQD, /* 76 - caller must register conversion
|
---|
508 | callbacks using curl_easy_setopt options
|
---|
509 | CURLOPT_CONV_FROM_NETWORK_FUNCTION,
|
---|
510 | CURLOPT_CONV_TO_NETWORK_FUNCTION, and
|
---|
511 | CURLOPT_CONV_FROM_UTF8_FUNCTION */
|
---|
512 | CURLE_SSL_CACERT_BADFILE, /* 77 - could not load CACERT file, missing
|
---|
513 | or wrong format */
|
---|
514 | CURLE_REMOTE_FILE_NOT_FOUND, /* 78 - remote file not found */
|
---|
515 | CURLE_SSH, /* 79 - error from the SSH layer, somewhat
|
---|
516 | generic so the error message will be of
|
---|
517 | interest when this has happened */
|
---|
518 |
|
---|
519 | CURLE_SSL_SHUTDOWN_FAILED, /* 80 - Failed to shut down the SSL
|
---|
520 | connection */
|
---|
521 | CURLE_AGAIN, /* 81 - socket is not ready for send/recv,
|
---|
522 | wait till it's ready and try again (Added
|
---|
523 | in 7.18.2) */
|
---|
524 | CURLE_SSL_CRL_BADFILE, /* 82 - could not load CRL file, missing or
|
---|
525 | wrong format (Added in 7.19.0) */
|
---|
526 | CURLE_SSL_ISSUER_ERROR, /* 83 - Issuer check failed. (Added in
|
---|
527 | 7.19.0) */
|
---|
528 | CURLE_FTP_PRET_FAILED, /* 84 - a PRET command failed */
|
---|
529 | CURLE_RTSP_CSEQ_ERROR, /* 85 - mismatch of RTSP CSeq numbers */
|
---|
530 | CURLE_RTSP_SESSION_ERROR, /* 86 - mismatch of RTSP Session Ids */
|
---|
531 | CURLE_FTP_BAD_FILE_LIST, /* 87 - unable to parse FTP file list */
|
---|
532 | CURLE_CHUNK_FAILED, /* 88 - chunk callback reported error */
|
---|
533 | CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the
|
---|
534 | session will be queued */
|
---|
535 | CURLE_SSL_PINNEDPUBKEYNOTMATCH, /* 90 - specified pinned public key did not
|
---|
536 | match */
|
---|
537 | CURLE_SSL_INVALIDCERTSTATUS, /* 91 - invalid certificate status */
|
---|
538 | CURL_LAST /* never use! */
|
---|
539 | } CURLcode;
|
---|
540 |
|
---|
541 | #ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
|
---|
542 | the obsolete stuff removed! */
|
---|
543 |
|
---|
544 | /* Previously obsolete error code re-used in 7.38.0 */
|
---|
545 | #define CURLE_OBSOLETE16 CURLE_HTTP2
|
---|
546 |
|
---|
547 | /* Previously obsolete error codes re-used in 7.24.0 */
|
---|
548 | #define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED
|
---|
549 | #define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT
|
---|
550 |
|
---|
551 | /* compatibility with older names */
|
---|
552 | #define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING
|
---|
553 |
|
---|
554 | /* The following were added in 7.21.5, April 2011 */
|
---|
555 | #define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION
|
---|
556 |
|
---|
557 | /* The following were added in 7.17.1 */
|
---|
558 | /* These are scheduled to disappear by 2009 */
|
---|
559 | #define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION
|
---|
560 |
|
---|
561 | /* The following were added in 7.17.0 */
|
---|
562 | /* These are scheduled to disappear by 2009 */
|
---|
563 | #define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */
|
---|
564 | #define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46
|
---|
565 | #define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44
|
---|
566 | #define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10
|
---|
567 | #define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16
|
---|
568 | #define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32
|
---|
569 | #define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29
|
---|
570 | #define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12
|
---|
571 | #define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20
|
---|
572 | #define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40
|
---|
573 | #define CURLE_MALFORMAT_USER CURLE_OBSOLETE24
|
---|
574 | #define CURLE_SHARE_IN_USE CURLE_OBSOLETE57
|
---|
575 | #define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN
|
---|
576 |
|
---|
577 | #define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED
|
---|
578 | #define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE
|
---|
579 | #define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR
|
---|
580 | #define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL
|
---|
581 | #define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS
|
---|
582 | #define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR
|
---|
583 | #define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED
|
---|
584 |
|
---|
585 | /* The following were added earlier */
|
---|
586 |
|
---|
587 | #define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT
|
---|
588 |
|
---|
589 | #define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR
|
---|
590 | #define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED
|
---|
591 | #define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED
|
---|
592 |
|
---|
593 | #define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE
|
---|
594 | #define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME
|
---|
595 |
|
---|
596 | /* This was the error code 50 in 7.7.3 and a few earlier versions, this
|
---|
597 | is no longer used by libcurl but is instead #defined here only to not
|
---|
598 | make programs break */
|
---|
599 | #define CURLE_ALREADY_COMPLETE 99999
|
---|
600 |
|
---|
601 | /* Provide defines for really old option names */
|
---|
602 | #define CURLOPT_FILE CURLOPT_WRITEDATA /* name changed in 7.9.7 */
|
---|
603 | #define CURLOPT_INFILE CURLOPT_READDATA /* name changed in 7.9.7 */
|
---|
604 | #define CURLOPT_WRITEHEADER CURLOPT_HEADERDATA
|
---|
605 |
|
---|
606 | /* Since long deprecated options with no code in the lib that does anything
|
---|
607 | with them. */
|
---|
608 | #define CURLOPT_WRITEINFO CURLOPT_OBSOLETE40
|
---|
609 | #define CURLOPT_CLOSEPOLICY CURLOPT_OBSOLETE72
|
---|
610 |
|
---|
611 | #endif /*!CURL_NO_OLDIES*/
|
---|
612 |
|
---|
613 | /* This prototype applies to all conversion callbacks */
|
---|
614 | typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length);
|
---|
615 |
|
---|
616 | typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */
|
---|
617 | void *ssl_ctx, /* actually an
|
---|
618 | OpenSSL SSL_CTX */
|
---|
619 | void *userptr);
|
---|
620 |
|
---|
621 | typedef enum {
|
---|
622 | CURLPROXY_HTTP = 0, /* added in 7.10, new in 7.19.4 default is to use
|
---|
623 | CONNECT HTTP/1.1 */
|
---|
624 | CURLPROXY_HTTP_1_0 = 1, /* added in 7.19.4, force to use CONNECT
|
---|
625 | HTTP/1.0 */
|
---|
626 | CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already
|
---|
627 | in 7.10 */
|
---|
628 | CURLPROXY_SOCKS5 = 5, /* added in 7.10 */
|
---|
629 | CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */
|
---|
630 | CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the
|
---|
631 | host name rather than the IP address. added
|
---|
632 | in 7.18.0 */
|
---|
633 | } curl_proxytype; /* this enum was added in 7.10 */
|
---|
634 |
|
---|
635 | /*
|
---|
636 | * Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options:
|
---|
637 | *
|
---|
638 | * CURLAUTH_NONE - No HTTP authentication
|
---|
639 | * CURLAUTH_BASIC - HTTP Basic authentication (default)
|
---|
640 | * CURLAUTH_DIGEST - HTTP Digest authentication
|
---|
641 | * CURLAUTH_NEGOTIATE - HTTP Negotiate (SPNEGO) authentication
|
---|
642 | * CURLAUTH_GSSNEGOTIATE - Alias for CURLAUTH_NEGOTIATE (deprecated)
|
---|
643 | * CURLAUTH_NTLM - HTTP NTLM authentication
|
---|
644 | * CURLAUTH_DIGEST_IE - HTTP Digest authentication with IE flavour
|
---|
645 | * CURLAUTH_NTLM_WB - HTTP NTLM authentication delegated to winbind helper
|
---|
646 | * CURLAUTH_ONLY - Use together with a single other type to force no
|
---|
647 | * authentication or just that single type
|
---|
648 | * CURLAUTH_ANY - All fine types set
|
---|
649 | * CURLAUTH_ANYSAFE - All fine types except Basic
|
---|
650 | */
|
---|
651 |
|
---|
652 | #define CURLAUTH_NONE ((unsigned long)0)
|
---|
653 | #define CURLAUTH_BASIC (((unsigned long)1)<<0)
|
---|
654 | #define CURLAUTH_DIGEST (((unsigned long)1)<<1)
|
---|
655 | #define CURLAUTH_NEGOTIATE (((unsigned long)1)<<2)
|
---|
656 | /* Deprecated since the advent of CURLAUTH_NEGOTIATE */
|
---|
657 | #define CURLAUTH_GSSNEGOTIATE CURLAUTH_NEGOTIATE
|
---|
658 | #define CURLAUTH_NTLM (((unsigned long)1)<<3)
|
---|
659 | #define CURLAUTH_DIGEST_IE (((unsigned long)1)<<4)
|
---|
660 | #define CURLAUTH_NTLM_WB (((unsigned long)1)<<5)
|
---|
661 | #define CURLAUTH_ONLY (((unsigned long)1)<<31)
|
---|
662 | #define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE)
|
---|
663 | #define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE))
|
---|
664 |
|
---|
665 | #define CURLSSH_AUTH_ANY ~0 /* all types supported by the server */
|
---|
666 | #define CURLSSH_AUTH_NONE 0 /* none allowed, silly but complete */
|
---|
667 | #define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */
|
---|
668 | #define CURLSSH_AUTH_PASSWORD (1<<1) /* password */
|
---|
669 | #define CURLSSH_AUTH_HOST (1<<2) /* host key files */
|
---|
670 | #define CURLSSH_AUTH_KEYBOARD (1<<3) /* keyboard interactive */
|
---|
671 | #define CURLSSH_AUTH_AGENT (1<<4) /* agent (ssh-agent, pageant...) */
|
---|
672 | #define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY
|
---|
673 |
|
---|
674 | #define CURLGSSAPI_DELEGATION_NONE 0 /* no delegation (default) */
|
---|
675 | #define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */
|
---|
676 | #define CURLGSSAPI_DELEGATION_FLAG (1<<1) /* delegate always */
|
---|
677 |
|
---|
678 | #define CURL_ERROR_SIZE 256
|
---|
679 |
|
---|
680 | enum curl_khtype {
|
---|
681 | CURLKHTYPE_UNKNOWN,
|
---|
682 | CURLKHTYPE_RSA1,
|
---|
683 | CURLKHTYPE_RSA,
|
---|
684 | CURLKHTYPE_DSS
|
---|
685 | };
|
---|
686 |
|
---|
687 | struct curl_khkey {
|
---|
688 | const char *key; /* points to a zero-terminated string encoded with base64
|
---|
689 | if len is zero, otherwise to the "raw" data */
|
---|
690 | size_t len;
|
---|
691 | enum curl_khtype keytype;
|
---|
692 | };
|
---|
693 |
|
---|
694 | /* this is the set of return values expected from the curl_sshkeycallback
|
---|
695 | callback */
|
---|
696 | enum curl_khstat {
|
---|
697 | CURLKHSTAT_FINE_ADD_TO_FILE,
|
---|
698 | CURLKHSTAT_FINE,
|
---|
699 | CURLKHSTAT_REJECT, /* reject the connection, return an error */
|
---|
700 | CURLKHSTAT_DEFER, /* do not accept it, but we can't answer right now so
|
---|
701 | this causes a CURLE_DEFER error but otherwise the
|
---|
702 | connection will be left intact etc */
|
---|
703 | CURLKHSTAT_LAST /* not for use, only a marker for last-in-list */
|
---|
704 | };
|
---|
705 |
|
---|
706 | /* this is the set of status codes pass in to the callback */
|
---|
707 | enum curl_khmatch {
|
---|
708 | CURLKHMATCH_OK, /* match */
|
---|
709 | CURLKHMATCH_MISMATCH, /* host found, key mismatch! */
|
---|
710 | CURLKHMATCH_MISSING, /* no matching host/key found */
|
---|
711 | CURLKHMATCH_LAST /* not for use, only a marker for last-in-list */
|
---|
712 | };
|
---|
713 |
|
---|
714 | typedef int
|
---|
715 | (*curl_sshkeycallback) (CURL *easy, /* easy handle */
|
---|
716 | const struct curl_khkey *knownkey, /* known */
|
---|
717 | const struct curl_khkey *foundkey, /* found */
|
---|
718 | enum curl_khmatch, /* libcurl's view on the keys */
|
---|
719 | void *clientp); /* custom pointer passed from app */
|
---|
720 |
|
---|
721 | /* parameter for the CURLOPT_USE_SSL option */
|
---|
722 | typedef enum {
|
---|
723 | CURLUSESSL_NONE, /* do not attempt to use SSL */
|
---|
724 | CURLUSESSL_TRY, /* try using SSL, proceed anyway otherwise */
|
---|
725 | CURLUSESSL_CONTROL, /* SSL for the control connection or fail */
|
---|
726 | CURLUSESSL_ALL, /* SSL for all communication or fail */
|
---|
727 | CURLUSESSL_LAST /* not an option, never use */
|
---|
728 | } curl_usessl;
|
---|
729 |
|
---|
730 | /* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */
|
---|
731 |
|
---|
732 | /* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the
|
---|
733 | name of improving interoperability with older servers. Some SSL libraries
|
---|
734 | have introduced work-arounds for this flaw but those work-arounds sometimes
|
---|
735 | make the SSL communication fail. To regain functionality with those broken
|
---|
736 | servers, a user can this way allow the vulnerability back. */
|
---|
737 | #define CURLSSLOPT_ALLOW_BEAST (1<<0)
|
---|
738 |
|
---|
739 | /* - NO_REVOKE tells libcurl to disable certificate revocation checks for those
|
---|
740 | SSL backends where such behavior is present. */
|
---|
741 | #define CURLSSLOPT_NO_REVOKE (1<<1)
|
---|
742 |
|
---|
743 | #ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
|
---|
744 | the obsolete stuff removed! */
|
---|
745 |
|
---|
746 | /* Backwards compatibility with older names */
|
---|
747 | /* These are scheduled to disappear by 2009 */
|
---|
748 |
|
---|
749 | #define CURLFTPSSL_NONE CURLUSESSL_NONE
|
---|
750 | #define CURLFTPSSL_TRY CURLUSESSL_TRY
|
---|
751 | #define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL
|
---|
752 | #define CURLFTPSSL_ALL CURLUSESSL_ALL
|
---|
753 | #define CURLFTPSSL_LAST CURLUSESSL_LAST
|
---|
754 | #define curl_ftpssl curl_usessl
|
---|
755 | #endif /*!CURL_NO_OLDIES*/
|
---|
756 |
|
---|
757 | /* parameter for the CURLOPT_FTP_SSL_CCC option */
|
---|
758 | typedef enum {
|
---|
759 | CURLFTPSSL_CCC_NONE, /* do not send CCC */
|
---|
760 | CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */
|
---|
761 | CURLFTPSSL_CCC_ACTIVE, /* Initiate the shutdown */
|
---|
762 | CURLFTPSSL_CCC_LAST /* not an option, never use */
|
---|
763 | } curl_ftpccc;
|
---|
764 |
|
---|
765 | /* parameter for the CURLOPT_FTPSSLAUTH option */
|
---|
766 | typedef enum {
|
---|
767 | CURLFTPAUTH_DEFAULT, /* let libcurl decide */
|
---|
768 | CURLFTPAUTH_SSL, /* use "AUTH SSL" */
|
---|
769 | CURLFTPAUTH_TLS, /* use "AUTH TLS" */
|
---|
770 | CURLFTPAUTH_LAST /* not an option, never use */
|
---|
771 | } curl_ftpauth;
|
---|
772 |
|
---|
773 | /* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */
|
---|
774 | typedef enum {
|
---|
775 | CURLFTP_CREATE_DIR_NONE, /* do NOT create missing dirs! */
|
---|
776 | CURLFTP_CREATE_DIR, /* (FTP/SFTP) if CWD fails, try MKD and then CWD
|
---|
777 | again if MKD succeeded, for SFTP this does
|
---|
778 | similar magic */
|
---|
779 | CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD
|
---|
780 | again even if MKD failed! */
|
---|
781 | CURLFTP_CREATE_DIR_LAST /* not an option, never use */
|
---|
782 | } curl_ftpcreatedir;
|
---|
783 |
|
---|
784 | /* parameter for the CURLOPT_FTP_FILEMETHOD option */
|
---|
785 | typedef enum {
|
---|
786 | CURLFTPMETHOD_DEFAULT, /* let libcurl pick */
|
---|
787 | CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */
|
---|
788 | CURLFTPMETHOD_NOCWD, /* no CWD at all */
|
---|
789 | CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */
|
---|
790 | CURLFTPMETHOD_LAST /* not an option, never use */
|
---|
791 | } curl_ftpmethod;
|
---|
792 |
|
---|
793 | /* bitmask defines for CURLOPT_HEADEROPT */
|
---|
794 | #define CURLHEADER_UNIFIED 0
|
---|
795 | #define CURLHEADER_SEPARATE (1<<0)
|
---|
796 |
|
---|
797 | /* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */
|
---|
798 | #define CURLPROTO_HTTP (1<<0)
|
---|
799 | #define CURLPROTO_HTTPS (1<<1)
|
---|
800 | #define CURLPROTO_FTP (1<<2)
|
---|
801 | #define CURLPROTO_FTPS (1<<3)
|
---|
802 | #define CURLPROTO_SCP (1<<4)
|
---|
803 | #define CURLPROTO_SFTP (1<<5)
|
---|
804 | #define CURLPROTO_TELNET (1<<6)
|
---|
805 | #define CURLPROTO_LDAP (1<<7)
|
---|
806 | #define CURLPROTO_LDAPS (1<<8)
|
---|
807 | #define CURLPROTO_DICT (1<<9)
|
---|
808 | #define CURLPROTO_FILE (1<<10)
|
---|
809 | #define CURLPROTO_TFTP (1<<11)
|
---|
810 | #define CURLPROTO_IMAP (1<<12)
|
---|
811 | #define CURLPROTO_IMAPS (1<<13)
|
---|
812 | #define CURLPROTO_POP3 (1<<14)
|
---|
813 | #define CURLPROTO_POP3S (1<<15)
|
---|
814 | #define CURLPROTO_SMTP (1<<16)
|
---|
815 | #define CURLPROTO_SMTPS (1<<17)
|
---|
816 | #define CURLPROTO_RTSP (1<<18)
|
---|
817 | #define CURLPROTO_RTMP (1<<19)
|
---|
818 | #define CURLPROTO_RTMPT (1<<20)
|
---|
819 | #define CURLPROTO_RTMPE (1<<21)
|
---|
820 | #define CURLPROTO_RTMPTE (1<<22)
|
---|
821 | #define CURLPROTO_RTMPS (1<<23)
|
---|
822 | #define CURLPROTO_RTMPTS (1<<24)
|
---|
823 | #define CURLPROTO_GOPHER (1<<25)
|
---|
824 | #define CURLPROTO_SMB (1<<26)
|
---|
825 | #define CURLPROTO_SMBS (1<<27)
|
---|
826 | #define CURLPROTO_ALL (~0) /* enable everything */
|
---|
827 |
|
---|
828 | /* long may be 32 or 64 bits, but we should never depend on anything else
|
---|
829 | but 32 */
|
---|
830 | #define CURLOPTTYPE_LONG 0
|
---|
831 | #define CURLOPTTYPE_OBJECTPOINT 10000
|
---|
832 | #define CURLOPTTYPE_STRINGPOINT 10000
|
---|
833 | #define CURLOPTTYPE_FUNCTIONPOINT 20000
|
---|
834 | #define CURLOPTTYPE_OFF_T 30000
|
---|
835 |
|
---|
836 | /* *STRINGPOINT is an alias for OBJECTPOINT to allow tools to extract the
|
---|
837 | string options from the header file */
|
---|
838 |
|
---|
839 | /* name is uppercase CURLOPT_<name>,
|
---|
840 | type is one of the defined CURLOPTTYPE_<type>
|
---|
841 | number is unique identifier */
|
---|
842 | #ifdef CINIT
|
---|
843 | #undef CINIT
|
---|
844 | #endif
|
---|
845 |
|
---|
846 | #ifdef CURL_ISOCPP
|
---|
847 | #define CINIT(na,t,nu) CURLOPT_ ## na = CURLOPTTYPE_ ## t + nu
|
---|
848 | #else
|
---|
849 | /* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
|
---|
850 | #define LONG CURLOPTTYPE_LONG
|
---|
851 | #define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT
|
---|
852 | #define STRINGPOINT CURLOPTTYPE_OBJECTPOINT
|
---|
853 | #define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT
|
---|
854 | #define OFF_T CURLOPTTYPE_OFF_T
|
---|
855 | #define CINIT(name,type,number) CURLOPT_/**/name = type + number
|
---|
856 | #endif
|
---|
857 |
|
---|
858 | /*
|
---|
859 | * This macro-mania below setups the CURLOPT_[what] enum, to be used with
|
---|
860 | * curl_easy_setopt(). The first argument in the CINIT() macro is the [what]
|
---|
861 | * word.
|
---|
862 | */
|
---|
863 |
|
---|
864 | typedef enum {
|
---|
865 | /* This is the FILE * or void * the regular output should be written to. */
|
---|
866 | CINIT(WRITEDATA, OBJECTPOINT, 1),
|
---|
867 |
|
---|
868 | /* The full URL to get/put */
|
---|
869 | CINIT(URL, STRINGPOINT, 2),
|
---|
870 |
|
---|
871 | /* Port number to connect to, if other than default. */
|
---|
872 | CINIT(PORT, LONG, 3),
|
---|
873 |
|
---|
874 | /* Name of proxy to use. */
|
---|
875 | CINIT(PROXY, STRINGPOINT, 4),
|
---|
876 |
|
---|
877 | /* "user:password;options" to use when fetching. */
|
---|
878 | CINIT(USERPWD, STRINGPOINT, 5),
|
---|
879 |
|
---|
880 | /* "user:password" to use with proxy. */
|
---|
881 | CINIT(PROXYUSERPWD, STRINGPOINT, 6),
|
---|
882 |
|
---|
883 | /* Range to get, specified as an ASCII string. */
|
---|
884 | CINIT(RANGE, STRINGPOINT, 7),
|
---|
885 |
|
---|
886 | /* not used */
|
---|
887 |
|
---|
888 | /* Specified file stream to upload from (use as input): */
|
---|
889 | CINIT(READDATA, OBJECTPOINT, 9),
|
---|
890 |
|
---|
891 | /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE
|
---|
892 | * bytes big. If this is not used, error messages go to stderr instead: */
|
---|
893 | CINIT(ERRORBUFFER, OBJECTPOINT, 10),
|
---|
894 |
|
---|
895 | /* Function that will be called to store the output (instead of fwrite). The
|
---|
896 | * parameters will use fwrite() syntax, make sure to follow them. */
|
---|
897 | CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11),
|
---|
898 |
|
---|
899 | /* Function that will be called to read the input (instead of fread). The
|
---|
900 | * parameters will use fread() syntax, make sure to follow them. */
|
---|
901 | CINIT(READFUNCTION, FUNCTIONPOINT, 12),
|
---|
902 |
|
---|
903 | /* Time-out the read operation after this amount of seconds */
|
---|
904 | CINIT(TIMEOUT, LONG, 13),
|
---|
905 |
|
---|
906 | /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about
|
---|
907 | * how large the file being sent really is. That allows better error
|
---|
908 | * checking and better verifies that the upload was successful. -1 means
|
---|
909 | * unknown size.
|
---|
910 | *
|
---|
911 | * For large file support, there is also a _LARGE version of the key
|
---|
912 | * which takes an off_t type, allowing platforms with larger off_t
|
---|
913 | * sizes to handle larger files. See below for INFILESIZE_LARGE.
|
---|
914 | */
|
---|
915 | CINIT(INFILESIZE, LONG, 14),
|
---|
916 |
|
---|
917 | /* POST static input fields. */
|
---|
918 | CINIT(POSTFIELDS, OBJECTPOINT, 15),
|
---|
919 |
|
---|
920 | /* Set the referrer page (needed by some CGIs) */
|
---|
921 | CINIT(REFERER, STRINGPOINT, 16),
|
---|
922 |
|
---|
923 | /* Set the FTP PORT string (interface name, named or numerical IP address)
|
---|
924 | Use i.e '-' to use default address. */
|
---|
925 | CINIT(FTPPORT, STRINGPOINT, 17),
|
---|
926 |
|
---|
927 | /* Set the User-Agent string (examined by some CGIs) */
|
---|
928 | CINIT(USERAGENT, STRINGPOINT, 18),
|
---|
929 |
|
---|
930 | /* If the download receives less than "low speed limit" bytes/second
|
---|
931 | * during "low speed time" seconds, the operations is aborted.
|
---|
932 | * You could i.e if you have a pretty high speed connection, abort if
|
---|
933 | * it is less than 2000 bytes/sec during 20 seconds.
|
---|
934 | */
|
---|
935 |
|
---|
936 | /* Set the "low speed limit" */
|
---|
937 | CINIT(LOW_SPEED_LIMIT, LONG, 19),
|
---|
938 |
|
---|
939 | /* Set the "low speed time" */
|
---|
940 | CINIT(LOW_SPEED_TIME, LONG, 20),
|
---|
941 |
|
---|
942 | /* Set the continuation offset.
|
---|
943 | *
|
---|
944 | * Note there is also a _LARGE version of this key which uses
|
---|
945 | * off_t types, allowing for large file offsets on platforms which
|
---|
946 | * use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE.
|
---|
947 | */
|
---|
948 | CINIT(RESUME_FROM, LONG, 21),
|
---|
949 |
|
---|
950 | /* Set cookie in request: */
|
---|
951 | CINIT(COOKIE, STRINGPOINT, 22),
|
---|
952 |
|
---|
953 | /* This points to a linked list of headers, struct curl_slist kind. This
|
---|
954 | list is also used for RTSP (in spite of its name) */
|
---|
955 | CINIT(HTTPHEADER, OBJECTPOINT, 23),
|
---|
956 |
|
---|
957 | /* This points to a linked list of post entries, struct curl_httppost */
|
---|
958 | CINIT(HTTPPOST, OBJECTPOINT, 24),
|
---|
959 |
|
---|
960 | /* name of the file keeping your private SSL-certificate */
|
---|
961 | CINIT(SSLCERT, STRINGPOINT, 25),
|
---|
962 |
|
---|
963 | /* password for the SSL or SSH private key */
|
---|
964 | CINIT(KEYPASSWD, STRINGPOINT, 26),
|
---|
965 |
|
---|
966 | /* send TYPE parameter? */
|
---|
967 | CINIT(CRLF, LONG, 27),
|
---|
968 |
|
---|
969 | /* send linked-list of QUOTE commands */
|
---|
970 | CINIT(QUOTE, OBJECTPOINT, 28),
|
---|
971 |
|
---|
972 | /* send FILE * or void * to store headers to, if you use a callback it
|
---|
973 | is simply passed to the callback unmodified */
|
---|
974 | CINIT(HEADERDATA, OBJECTPOINT, 29),
|
---|
975 |
|
---|
976 | /* point to a file to read the initial cookies from, also enables
|
---|
977 | "cookie awareness" */
|
---|
978 | CINIT(COOKIEFILE, STRINGPOINT, 31),
|
---|
979 |
|
---|
980 | /* What version to specifically try to use.
|
---|
981 | See CURL_SSLVERSION defines below. */
|
---|
982 | CINIT(SSLVERSION, LONG, 32),
|
---|
983 |
|
---|
984 | /* What kind of HTTP time condition to use, see defines */
|
---|
985 | CINIT(TIMECONDITION, LONG, 33),
|
---|
986 |
|
---|
987 | /* Time to use with the above condition. Specified in number of seconds
|
---|
988 | since 1 Jan 1970 */
|
---|
989 | CINIT(TIMEVALUE, LONG, 34),
|
---|
990 |
|
---|
991 | /* 35 = OBSOLETE */
|
---|
992 |
|
---|
993 | /* Custom request, for customizing the get command like
|
---|
994 | HTTP: DELETE, TRACE and others
|
---|
995 | FTP: to use a different list command
|
---|
996 | */
|
---|
997 | CINIT(CUSTOMREQUEST, STRINGPOINT, 36),
|
---|
998 |
|
---|
999 | /* FILE handle to use instead of stderr */
|
---|
1000 | CINIT(STDERR, OBJECTPOINT, 37),
|
---|
1001 |
|
---|
1002 | /* 38 is not used */
|
---|
1003 |
|
---|
1004 | /* send linked-list of post-transfer QUOTE commands */
|
---|
1005 | CINIT(POSTQUOTE, OBJECTPOINT, 39),
|
---|
1006 |
|
---|
1007 | CINIT(OBSOLETE40, OBJECTPOINT, 40), /* OBSOLETE, do not use! */
|
---|
1008 |
|
---|
1009 | CINIT(VERBOSE, LONG, 41), /* talk a lot */
|
---|
1010 | CINIT(HEADER, LONG, 42), /* throw the header out too */
|
---|
1011 | CINIT(NOPROGRESS, LONG, 43), /* shut off the progress meter */
|
---|
1012 | CINIT(NOBODY, LONG, 44), /* use HEAD to get http document */
|
---|
1013 | CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 400 */
|
---|
1014 | CINIT(UPLOAD, LONG, 46), /* this is an upload */
|
---|
1015 | CINIT(POST, LONG, 47), /* HTTP POST method */
|
---|
1016 | CINIT(DIRLISTONLY, LONG, 48), /* bare names when listing directories */
|
---|
1017 |
|
---|
1018 | CINIT(APPEND, LONG, 50), /* Append instead of overwrite on upload! */
|
---|
1019 |
|
---|
1020 | /* Specify whether to read the user+password from the .netrc or the URL.
|
---|
1021 | * This must be one of the CURL_NETRC_* enums below. */
|
---|
1022 | CINIT(NETRC, LONG, 51),
|
---|
1023 |
|
---|
1024 | CINIT(FOLLOWLOCATION, LONG, 52), /* use Location: Luke! */
|
---|
1025 |
|
---|
1026 | CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */
|
---|
1027 | CINIT(PUT, LONG, 54), /* HTTP PUT */
|
---|
1028 |
|
---|
1029 | /* 55 = OBSOLETE */
|
---|
1030 |
|
---|
1031 | /* DEPRECATED
|
---|
1032 | * Function that will be called instead of the internal progress display
|
---|
1033 | * function. This function should be defined as the curl_progress_callback
|
---|
1034 | * prototype defines. */
|
---|
1035 | CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56),
|
---|
1036 |
|
---|
1037 | /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION
|
---|
1038 | callbacks */
|
---|
1039 | CINIT(PROGRESSDATA, OBJECTPOINT, 57),
|
---|
1040 | #define CURLOPT_XFERINFODATA CURLOPT_PROGRESSDATA
|
---|
1041 |
|
---|
1042 | /* We want the referrer field set automatically when following locations */
|
---|
1043 | CINIT(AUTOREFERER, LONG, 58),
|
---|
1044 |
|
---|
1045 | /* Port of the proxy, can be set in the proxy string as well with:
|
---|
1046 | "[host]:[port]" */
|
---|
1047 | CINIT(PROXYPORT, LONG, 59),
|
---|
1048 |
|
---|
1049 | /* size of the POST input data, if strlen() is not good to use */
|
---|
1050 | CINIT(POSTFIELDSIZE, LONG, 60),
|
---|
1051 |
|
---|
1052 | /* tunnel non-http operations through a HTTP proxy */
|
---|
1053 | CINIT(HTTPPROXYTUNNEL, LONG, 61),
|
---|
1054 |
|
---|
1055 | /* Set the interface string to use as outgoing network interface */
|
---|
1056 | CINIT(INTERFACE, STRINGPOINT, 62),
|
---|
1057 |
|
---|
1058 | /* Set the krb4/5 security level, this also enables krb4/5 awareness. This
|
---|
1059 | * is a string, 'clear', 'safe', 'confidential' or 'private'. If the string
|
---|
1060 | * is set but doesn't match one of these, 'private' will be used. */
|
---|
1061 | CINIT(KRBLEVEL, STRINGPOINT, 63),
|
---|
1062 |
|
---|
1063 | /* Set if we should verify the peer in ssl handshake, set 1 to verify. */
|
---|
1064 | CINIT(SSL_VERIFYPEER, LONG, 64),
|
---|
1065 |
|
---|
1066 | /* The CApath or CAfile used to validate the peer certificate
|
---|
1067 | this option is used only if SSL_VERIFYPEER is true */
|
---|
1068 | CINIT(CAINFO, STRINGPOINT, 65),
|
---|
1069 |
|
---|
1070 | /* 66 = OBSOLETE */
|
---|
1071 | /* 67 = OBSOLETE */
|
---|
1072 |
|
---|
1073 | /* Maximum number of http redirects to follow */
|
---|
1074 | CINIT(MAXREDIRS, LONG, 68),
|
---|
1075 |
|
---|
1076 | /* Pass a long set to 1 to get the date of the requested document (if
|
---|
1077 | possible)! Pass a zero to shut it off. */
|
---|
1078 | CINIT(FILETIME, LONG, 69),
|
---|
1079 |
|
---|
1080 | /* This points to a linked list of telnet options */
|
---|
1081 | CINIT(TELNETOPTIONS, OBJECTPOINT, 70),
|
---|
1082 |
|
---|
1083 | /* Max amount of cached alive connections */
|
---|
1084 | CINIT(MAXCONNECTS, LONG, 71),
|
---|
1085 |
|
---|
1086 | CINIT(OBSOLETE72, LONG, 72), /* OBSOLETE, do not use! */
|
---|
1087 |
|
---|
1088 | /* 73 = OBSOLETE */
|
---|
1089 |
|
---|
1090 | /* Set to explicitly use a new connection for the upcoming transfer.
|
---|
1091 | Do not use this unless you're absolutely sure of this, as it makes the
|
---|
1092 | operation slower and is less friendly for the network. */
|
---|
1093 | CINIT(FRESH_CONNECT, LONG, 74),
|
---|
1094 |
|
---|
1095 | /* Set to explicitly forbid the upcoming transfer's connection to be re-used
|
---|
1096 | when done. Do not use this unless you're absolutely sure of this, as it
|
---|
1097 | makes the operation slower and is less friendly for the network. */
|
---|
1098 | CINIT(FORBID_REUSE, LONG, 75),
|
---|
1099 |
|
---|
1100 | /* Set to a file name that contains random data for libcurl to use to
|
---|
1101 | seed the random engine when doing SSL connects. */
|
---|
1102 | CINIT(RANDOM_FILE, STRINGPOINT, 76),
|
---|
1103 |
|
---|
1104 | /* Set to the Entropy Gathering Daemon socket pathname */
|
---|
1105 | CINIT(EGDSOCKET, STRINGPOINT, 77),
|
---|
1106 |
|
---|
1107 | /* Time-out connect operations after this amount of seconds, if connects are
|
---|
1108 | OK within this time, then fine... This only aborts the connect phase. */
|
---|
1109 | CINIT(CONNECTTIMEOUT, LONG, 78),
|
---|
1110 |
|
---|
1111 | /* Function that will be called to store headers (instead of fwrite). The
|
---|
1112 | * parameters will use fwrite() syntax, make sure to follow them. */
|
---|
1113 | CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),
|
---|
1114 |
|
---|
1115 | /* Set this to force the HTTP request to get back to GET. Only really usable
|
---|
1116 | if POST, PUT or a custom request have been used first.
|
---|
1117 | */
|
---|
1118 | CINIT(HTTPGET, LONG, 80),
|
---|
1119 |
|
---|
1120 | /* Set if we should verify the Common name from the peer certificate in ssl
|
---|
1121 | * handshake, set 1 to check existence, 2 to ensure that it matches the
|
---|
1122 | * provided hostname. */
|
---|
1123 | CINIT(SSL_VERIFYHOST, LONG, 81),
|
---|
1124 |
|
---|
1125 | /* Specify which file name to write all known cookies in after completed
|
---|
1126 | operation. Set file name to "-" (dash) to make it go to stdout. */
|
---|
1127 | CINIT(COOKIEJAR, STRINGPOINT, 82),
|
---|
1128 |
|
---|
1129 | /* Specify which SSL ciphers to use */
|
---|
1130 | CINIT(SSL_CIPHER_LIST, STRINGPOINT, 83),
|
---|
1131 |
|
---|
1132 | /* Specify which HTTP version to use! This must be set to one of the
|
---|
1133 | CURL_HTTP_VERSION* enums set below. */
|
---|
1134 | CINIT(HTTP_VERSION, LONG, 84),
|
---|
1135 |
|
---|
1136 | /* Specifically switch on or off the FTP engine's use of the EPSV command. By
|
---|
1137 | default, that one will always be attempted before the more traditional
|
---|
1138 | PASV command. */
|
---|
1139 | CINIT(FTP_USE_EPSV, LONG, 85),
|
---|
1140 |
|
---|
1141 | /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */
|
---|
1142 | CINIT(SSLCERTTYPE, STRINGPOINT, 86),
|
---|
1143 |
|
---|
1144 | /* name of the file keeping your private SSL-key */
|
---|
1145 | CINIT(SSLKEY, STRINGPOINT, 87),
|
---|
1146 |
|
---|
1147 | /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */
|
---|
1148 | CINIT(SSLKEYTYPE, STRINGPOINT, 88),
|
---|
1149 |
|
---|
1150 | /* crypto engine for the SSL-sub system */
|
---|
1151 | CINIT(SSLENGINE, STRINGPOINT, 89),
|
---|
1152 |
|
---|
1153 | /* set the crypto engine for the SSL-sub system as default
|
---|
1154 | the param has no meaning...
|
---|
1155 | */
|
---|
1156 | CINIT(SSLENGINE_DEFAULT, LONG, 90),
|
---|
1157 |
|
---|
1158 | /* Non-zero value means to use the global dns cache */
|
---|
1159 | CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* DEPRECATED, do not use! */
|
---|
1160 |
|
---|
1161 | /* DNS cache timeout */
|
---|
1162 | CINIT(DNS_CACHE_TIMEOUT, LONG, 92),
|
---|
1163 |
|
---|
1164 | /* send linked-list of pre-transfer QUOTE commands */
|
---|
1165 | CINIT(PREQUOTE, OBJECTPOINT, 93),
|
---|
1166 |
|
---|
1167 | /* set the debug function */
|
---|
1168 | CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94),
|
---|
1169 |
|
---|
1170 | /* set the data for the debug function */
|
---|
1171 | CINIT(DEBUGDATA, OBJECTPOINT, 95),
|
---|
1172 |
|
---|
1173 | /* mark this as start of a cookie session */
|
---|
1174 | CINIT(COOKIESESSION, LONG, 96),
|
---|
1175 |
|
---|
1176 | /* The CApath directory used to validate the peer certificate
|
---|
1177 | this option is used only if SSL_VERIFYPEER is true */
|
---|
1178 | CINIT(CAPATH, STRINGPOINT, 97),
|
---|
1179 |
|
---|
1180 | /* Instruct libcurl to use a smaller receive buffer */
|
---|
1181 | CINIT(BUFFERSIZE, LONG, 98),
|
---|
1182 |
|
---|
1183 | /* Instruct libcurl to not use any signal/alarm handlers, even when using
|
---|
1184 | timeouts. This option is useful for multi-threaded applications.
|
---|
1185 | See libcurl-the-guide for more background information. */
|
---|
1186 | CINIT(NOSIGNAL, LONG, 99),
|
---|
1187 |
|
---|
1188 | /* Provide a CURLShare for mutexing non-ts data */
|
---|
1189 | CINIT(SHARE, OBJECTPOINT, 100),
|
---|
1190 |
|
---|
1191 | /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default),
|
---|
1192 | CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */
|
---|
1193 | CINIT(PROXYTYPE, LONG, 101),
|
---|
1194 |
|
---|
1195 | /* Set the Accept-Encoding string. Use this to tell a server you would like
|
---|
1196 | the response to be compressed. Before 7.21.6, this was known as
|
---|
1197 | CURLOPT_ENCODING */
|
---|
1198 | CINIT(ACCEPT_ENCODING, STRINGPOINT, 102),
|
---|
1199 |
|
---|
1200 | /* Set pointer to private data */
|
---|
1201 | CINIT(PRIVATE, OBJECTPOINT, 103),
|
---|
1202 |
|
---|
1203 | /* Set aliases for HTTP 200 in the HTTP Response header */
|
---|
1204 | CINIT(HTTP200ALIASES, OBJECTPOINT, 104),
|
---|
1205 |
|
---|
1206 | /* Continue to send authentication (user+password) when following locations,
|
---|
1207 | even when hostname changed. This can potentially send off the name
|
---|
1208 | and password to whatever host the server decides. */
|
---|
1209 | CINIT(UNRESTRICTED_AUTH, LONG, 105),
|
---|
1210 |
|
---|
1211 | /* Specifically switch on or off the FTP engine's use of the EPRT command (
|
---|
1212 | it also disables the LPRT attempt). By default, those ones will always be
|
---|
1213 | attempted before the good old traditional PORT command. */
|
---|
1214 | CINIT(FTP_USE_EPRT, LONG, 106),
|
---|
1215 |
|
---|
1216 | /* Set this to a bitmask value to enable the particular authentications
|
---|
1217 | methods you like. Use this in combination with CURLOPT_USERPWD.
|
---|
1218 | Note that setting multiple bits may cause extra network round-trips. */
|
---|
1219 | CINIT(HTTPAUTH, LONG, 107),
|
---|
1220 |
|
---|
1221 | /* Set the ssl context callback function, currently only for OpenSSL ssl_ctx
|
---|
1222 | in second argument. The function must be matching the
|
---|
1223 | curl_ssl_ctx_callback proto. */
|
---|
1224 | CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108),
|
---|
1225 |
|
---|
1226 | /* Set the userdata for the ssl context callback function's third
|
---|
1227 | argument */
|
---|
1228 | CINIT(SSL_CTX_DATA, OBJECTPOINT, 109),
|
---|
1229 |
|
---|
1230 | /* FTP Option that causes missing dirs to be created on the remote server.
|
---|
1231 | In 7.19.4 we introduced the convenience enums for this option using the
|
---|
1232 | CURLFTP_CREATE_DIR prefix.
|
---|
1233 | */
|
---|
1234 | CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110),
|
---|
1235 |
|
---|
1236 | /* Set this to a bitmask value to enable the particular authentications
|
---|
1237 | methods you like. Use this in combination with CURLOPT_PROXYUSERPWD.
|
---|
1238 | Note that setting multiple bits may cause extra network round-trips. */
|
---|
1239 | CINIT(PROXYAUTH, LONG, 111),
|
---|
1240 |
|
---|
1241 | /* FTP option that changes the timeout, in seconds, associated with
|
---|
1242 | getting a response. This is different from transfer timeout time and
|
---|
1243 | essentially places a demand on the FTP server to acknowledge commands
|
---|
1244 | in a timely manner. */
|
---|
1245 | CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112),
|
---|
1246 | #define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT
|
---|
1247 |
|
---|
1248 | /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to
|
---|
1249 | tell libcurl to resolve names to those IP versions only. This only has
|
---|
1250 | affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */
|
---|
1251 | CINIT(IPRESOLVE, LONG, 113),
|
---|
1252 |
|
---|
1253 | /* Set this option to limit the size of a file that will be downloaded from
|
---|
1254 | an HTTP or FTP server.
|
---|
1255 |
|
---|
1256 | Note there is also _LARGE version which adds large file support for
|
---|
1257 | platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */
|
---|
1258 | CINIT(MAXFILESIZE, LONG, 114),
|
---|
1259 |
|
---|
1260 | /* See the comment for INFILESIZE above, but in short, specifies
|
---|
1261 | * the size of the file being uploaded. -1 means unknown.
|
---|
1262 | */
|
---|
1263 | CINIT(INFILESIZE_LARGE, OFF_T, 115),
|
---|
1264 |
|
---|
1265 | /* Sets the continuation offset. There is also a LONG version of this;
|
---|
1266 | * look above for RESUME_FROM.
|
---|
1267 | */
|
---|
1268 | CINIT(RESUME_FROM_LARGE, OFF_T, 116),
|
---|
1269 |
|
---|
1270 | /* Sets the maximum size of data that will be downloaded from
|
---|
1271 | * an HTTP or FTP server. See MAXFILESIZE above for the LONG version.
|
---|
1272 | */
|
---|
1273 | CINIT(MAXFILESIZE_LARGE, OFF_T, 117),
|
---|
1274 |
|
---|
1275 | /* Set this option to the file name of your .netrc file you want libcurl
|
---|
1276 | to parse (using the CURLOPT_NETRC option). If not set, libcurl will do
|
---|
1277 | a poor attempt to find the user's home directory and check for a .netrc
|
---|
1278 | file in there. */
|
---|
1279 | CINIT(NETRC_FILE, STRINGPOINT, 118),
|
---|
1280 |
|
---|
1281 | /* Enable SSL/TLS for FTP, pick one of:
|
---|
1282 | CURLUSESSL_TRY - try using SSL, proceed anyway otherwise
|
---|
1283 | CURLUSESSL_CONTROL - SSL for the control connection or fail
|
---|
1284 | CURLUSESSL_ALL - SSL for all communication or fail
|
---|
1285 | */
|
---|
1286 | CINIT(USE_SSL, LONG, 119),
|
---|
1287 |
|
---|
1288 | /* The _LARGE version of the standard POSTFIELDSIZE option */
|
---|
1289 | CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120),
|
---|
1290 |
|
---|
1291 | /* Enable/disable the TCP Nagle algorithm */
|
---|
1292 | CINIT(TCP_NODELAY, LONG, 121),
|
---|
1293 |
|
---|
1294 | /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
|
---|
1295 | /* 123 OBSOLETE. Gone in 7.16.0 */
|
---|
1296 | /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
|
---|
1297 | /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
|
---|
1298 | /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
|
---|
1299 | /* 127 OBSOLETE. Gone in 7.16.0 */
|
---|
1300 | /* 128 OBSOLETE. Gone in 7.16.0 */
|
---|
1301 |
|
---|
1302 | /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option
|
---|
1303 | can be used to change libcurl's default action which is to first try
|
---|
1304 | "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK
|
---|
1305 | response has been received.
|
---|
1306 |
|
---|
1307 | Available parameters are:
|
---|
1308 | CURLFTPAUTH_DEFAULT - let libcurl decide
|
---|
1309 | CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS
|
---|
1310 | CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL
|
---|
1311 | */
|
---|
1312 | CINIT(FTPSSLAUTH, LONG, 129),
|
---|
1313 |
|
---|
1314 | CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130),
|
---|
1315 | CINIT(IOCTLDATA, OBJECTPOINT, 131),
|
---|
1316 |
|
---|
1317 | /* 132 OBSOLETE. Gone in 7.16.0 */
|
---|
1318 | /* 133 OBSOLETE. Gone in 7.16.0 */
|
---|
1319 |
|
---|
1320 | /* zero terminated string for pass on to the FTP server when asked for
|
---|
1321 | "account" info */
|
---|
1322 | CINIT(FTP_ACCOUNT, STRINGPOINT, 134),
|
---|
1323 |
|
---|
1324 | /* feed cookie into cookie engine */
|
---|
1325 | CINIT(COOKIELIST, STRINGPOINT, 135),
|
---|
1326 |
|
---|
1327 | /* ignore Content-Length */
|
---|
1328 | CINIT(IGNORE_CONTENT_LENGTH, LONG, 136),
|
---|
1329 |
|
---|
1330 | /* Set to non-zero to skip the IP address received in a 227 PASV FTP server
|
---|
1331 | response. Typically used for FTP-SSL purposes but is not restricted to
|
---|
1332 | that. libcurl will then instead use the same IP address it used for the
|
---|
1333 | control connection. */
|
---|
1334 | CINIT(FTP_SKIP_PASV_IP, LONG, 137),
|
---|
1335 |
|
---|
1336 | /* Select "file method" to use when doing FTP, see the curl_ftpmethod
|
---|
1337 | above. */
|
---|
1338 | CINIT(FTP_FILEMETHOD, LONG, 138),
|
---|
1339 |
|
---|
1340 | /* Local port number to bind the socket to */
|
---|
1341 | CINIT(LOCALPORT, LONG, 139),
|
---|
1342 |
|
---|
1343 | /* Number of ports to try, including the first one set with LOCALPORT.
|
---|
1344 | Thus, setting it to 1 will make no additional attempts but the first.
|
---|
1345 | */
|
---|
1346 | CINIT(LOCALPORTRANGE, LONG, 140),
|
---|
1347 |
|
---|
1348 | /* no transfer, set up connection and let application use the socket by
|
---|
1349 | extracting it with CURLINFO_LASTSOCKET */
|
---|
1350 | CINIT(CONNECT_ONLY, LONG, 141),
|
---|
1351 |
|
---|
1352 | /* Function that will be called to convert from the
|
---|
1353 | network encoding (instead of using the iconv calls in libcurl) */
|
---|
1354 | CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142),
|
---|
1355 |
|
---|
1356 | /* Function that will be called to convert to the
|
---|
1357 | network encoding (instead of using the iconv calls in libcurl) */
|
---|
1358 | CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143),
|
---|
1359 |
|
---|
1360 | /* Function that will be called to convert from UTF8
|
---|
1361 | (instead of using the iconv calls in libcurl)
|
---|
1362 | Note that this is used only for SSL certificate processing */
|
---|
1363 | CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144),
|
---|
1364 |
|
---|
1365 | /* if the connection proceeds too quickly then need to slow it down */
|
---|
1366 | /* limit-rate: maximum number of bytes per second to send or receive */
|
---|
1367 | CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145),
|
---|
1368 | CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146),
|
---|
1369 |
|
---|
1370 | /* Pointer to command string to send if USER/PASS fails. */
|
---|
1371 | CINIT(FTP_ALTERNATIVE_TO_USER, STRINGPOINT, 147),
|
---|
1372 |
|
---|
1373 | /* callback function for setting socket options */
|
---|
1374 | CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148),
|
---|
1375 | CINIT(SOCKOPTDATA, OBJECTPOINT, 149),
|
---|
1376 |
|
---|
1377 | /* set to 0 to disable session ID re-use for this transfer, default is
|
---|
1378 | enabled (== 1) */
|
---|
1379 | CINIT(SSL_SESSIONID_CACHE, LONG, 150),
|
---|
1380 |
|
---|
1381 | /* allowed SSH authentication methods */
|
---|
1382 | CINIT(SSH_AUTH_TYPES, LONG, 151),
|
---|
1383 |
|
---|
1384 | /* Used by scp/sftp to do public/private key authentication */
|
---|
1385 | CINIT(SSH_PUBLIC_KEYFILE, STRINGPOINT, 152),
|
---|
1386 | CINIT(SSH_PRIVATE_KEYFILE, STRINGPOINT, 153),
|
---|
1387 |
|
---|
1388 | /* Send CCC (Clear Command Channel) after authentication */
|
---|
1389 | CINIT(FTP_SSL_CCC, LONG, 154),
|
---|
1390 |
|
---|
1391 | /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */
|
---|
1392 | CINIT(TIMEOUT_MS, LONG, 155),
|
---|
1393 | CINIT(CONNECTTIMEOUT_MS, LONG, 156),
|
---|
1394 |
|
---|
1395 | /* set to zero to disable the libcurl's decoding and thus pass the raw body
|
---|
1396 | data to the application even when it is encoded/compressed */
|
---|
1397 | CINIT(HTTP_TRANSFER_DECODING, LONG, 157),
|
---|
1398 | CINIT(HTTP_CONTENT_DECODING, LONG, 158),
|
---|
1399 |
|
---|
1400 | /* Permission used when creating new files and directories on the remote
|
---|
1401 | server for protocols that support it, SFTP/SCP/FILE */
|
---|
1402 | CINIT(NEW_FILE_PERMS, LONG, 159),
|
---|
1403 | CINIT(NEW_DIRECTORY_PERMS, LONG, 160),
|
---|
1404 |
|
---|
1405 | /* Set the behaviour of POST when redirecting. Values must be set to one
|
---|
1406 | of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */
|
---|
1407 | CINIT(POSTREDIR, LONG, 161),
|
---|
1408 |
|
---|
1409 | /* used by scp/sftp to verify the host's public key */
|
---|
1410 | CINIT(SSH_HOST_PUBLIC_KEY_MD5, STRINGPOINT, 162),
|
---|
1411 |
|
---|
1412 | /* Callback function for opening socket (instead of socket(2)). Optionally,
|
---|
1413 | callback is able change the address or refuse to connect returning
|
---|
1414 | CURL_SOCKET_BAD. The callback should have type
|
---|
1415 | curl_opensocket_callback */
|
---|
1416 | CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163),
|
---|
1417 | CINIT(OPENSOCKETDATA, OBJECTPOINT, 164),
|
---|
1418 |
|
---|
1419 | /* POST volatile input fields. */
|
---|
1420 | CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165),
|
---|
1421 |
|
---|
1422 | /* set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy */
|
---|
1423 | CINIT(PROXY_TRANSFER_MODE, LONG, 166),
|
---|
1424 |
|
---|
1425 | /* Callback function for seeking in the input stream */
|
---|
1426 | CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167),
|
---|
1427 | CINIT(SEEKDATA, OBJECTPOINT, 168),
|
---|
1428 |
|
---|
1429 | /* CRL file */
|
---|
1430 | CINIT(CRLFILE, STRINGPOINT, 169),
|
---|
1431 |
|
---|
1432 | /* Issuer certificate */
|
---|
1433 | CINIT(ISSUERCERT, STRINGPOINT, 170),
|
---|
1434 |
|
---|
1435 | /* (IPv6) Address scope */
|
---|
1436 | CINIT(ADDRESS_SCOPE, LONG, 171),
|
---|
1437 |
|
---|
1438 | /* Collect certificate chain info and allow it to get retrievable with
|
---|
1439 | CURLINFO_CERTINFO after the transfer is complete. */
|
---|
1440 | CINIT(CERTINFO, LONG, 172),
|
---|
1441 |
|
---|
1442 | /* "name" and "pwd" to use when fetching. */
|
---|
1443 | CINIT(USERNAME, STRINGPOINT, 173),
|
---|
1444 | CINIT(PASSWORD, STRINGPOINT, 174),
|
---|
1445 |
|
---|
1446 | /* "name" and "pwd" to use with Proxy when fetching. */
|
---|
1447 | CINIT(PROXYUSERNAME, STRINGPOINT, 175),
|
---|
1448 | CINIT(PROXYPASSWORD, STRINGPOINT, 176),
|
---|
1449 |
|
---|
1450 | /* Comma separated list of hostnames defining no-proxy zones. These should
|
---|
1451 | match both hostnames directly, and hostnames within a domain. For
|
---|
1452 | example, local.com will match local.com and www.local.com, but NOT
|
---|
1453 | notlocal.com or www.notlocal.com. For compatibility with other
|
---|
1454 | implementations of this, .local.com will be considered to be the same as
|
---|
1455 | local.com. A single * is the only valid wildcard, and effectively
|
---|
1456 | disables the use of proxy. */
|
---|
1457 | CINIT(NOPROXY, STRINGPOINT, 177),
|
---|
1458 |
|
---|
1459 | /* block size for TFTP transfers */
|
---|
1460 | CINIT(TFTP_BLKSIZE, LONG, 178),
|
---|
1461 |
|
---|
1462 | /* Socks Service */
|
---|
1463 | CINIT(SOCKS5_GSSAPI_SERVICE, STRINGPOINT, 179),
|
---|
1464 |
|
---|
1465 | /* Socks Service */
|
---|
1466 | CINIT(SOCKS5_GSSAPI_NEC, LONG, 180),
|
---|
1467 |
|
---|
1468 | /* set the bitmask for the protocols that are allowed to be used for the
|
---|
1469 | transfer, which thus helps the app which takes URLs from users or other
|
---|
1470 | external inputs and want to restrict what protocol(s) to deal
|
---|
1471 | with. Defaults to CURLPROTO_ALL. */
|
---|
1472 | CINIT(PROTOCOLS, LONG, 181),
|
---|
1473 |
|
---|
1474 | /* set the bitmask for the protocols that libcurl is allowed to follow to,
|
---|
1475 | as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs
|
---|
1476 | to be set in both bitmasks to be allowed to get redirected to. Defaults
|
---|
1477 | to all protocols except FILE and SCP. */
|
---|
1478 | CINIT(REDIR_PROTOCOLS, LONG, 182),
|
---|
1479 |
|
---|
1480 | /* set the SSH knownhost file name to use */
|
---|
1481 | CINIT(SSH_KNOWNHOSTS, STRINGPOINT, 183),
|
---|
1482 |
|
---|
1483 | /* set the SSH host key callback, must point to a curl_sshkeycallback
|
---|
1484 | function */
|
---|
1485 | CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184),
|
---|
1486 |
|
---|
1487 | /* set the SSH host key callback custom pointer */
|
---|
1488 | CINIT(SSH_KEYDATA, OBJECTPOINT, 185),
|
---|
1489 |
|
---|
1490 | /* set the SMTP mail originator */
|
---|
1491 | CINIT(MAIL_FROM, STRINGPOINT, 186),
|
---|
1492 |
|
---|
1493 | /* set the list of SMTP mail receiver(s) */
|
---|
1494 | CINIT(MAIL_RCPT, OBJECTPOINT, 187),
|
---|
1495 |
|
---|
1496 | /* FTP: send PRET before PASV */
|
---|
1497 | CINIT(FTP_USE_PRET, LONG, 188),
|
---|
1498 |
|
---|
1499 | /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */
|
---|
1500 | CINIT(RTSP_REQUEST, LONG, 189),
|
---|
1501 |
|
---|
1502 | /* The RTSP session identifier */
|
---|
1503 | CINIT(RTSP_SESSION_ID, STRINGPOINT, 190),
|
---|
1504 |
|
---|
1505 | /* The RTSP stream URI */
|
---|
1506 | CINIT(RTSP_STREAM_URI, STRINGPOINT, 191),
|
---|
1507 |
|
---|
1508 | /* The Transport: header to use in RTSP requests */
|
---|
1509 | CINIT(RTSP_TRANSPORT, STRINGPOINT, 192),
|
---|
1510 |
|
---|
1511 | /* Manually initialize the client RTSP CSeq for this handle */
|
---|
1512 | CINIT(RTSP_CLIENT_CSEQ, LONG, 193),
|
---|
1513 |
|
---|
1514 | /* Manually initialize the server RTSP CSeq for this handle */
|
---|
1515 | CINIT(RTSP_SERVER_CSEQ, LONG, 194),
|
---|
1516 |
|
---|
1517 | /* The stream to pass to INTERLEAVEFUNCTION. */
|
---|
1518 | CINIT(INTERLEAVEDATA, OBJECTPOINT, 195),
|
---|
1519 |
|
---|
1520 | /* Let the application define a custom write method for RTP data */
|
---|
1521 | CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196),
|
---|
1522 |
|
---|
1523 | /* Turn on wildcard matching */
|
---|
1524 | CINIT(WILDCARDMATCH, LONG, 197),
|
---|
1525 |
|
---|
1526 | /* Directory matching callback called before downloading of an
|
---|
1527 | individual file (chunk) started */
|
---|
1528 | CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198),
|
---|
1529 |
|
---|
1530 | /* Directory matching callback called after the file (chunk)
|
---|
1531 | was downloaded, or skipped */
|
---|
1532 | CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199),
|
---|
1533 |
|
---|
1534 | /* Change match (fnmatch-like) callback for wildcard matching */
|
---|
1535 | CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200),
|
---|
1536 |
|
---|
1537 | /* Let the application define custom chunk data pointer */
|
---|
1538 | CINIT(CHUNK_DATA, OBJECTPOINT, 201),
|
---|
1539 |
|
---|
1540 | /* FNMATCH_FUNCTION user pointer */
|
---|
1541 | CINIT(FNMATCH_DATA, OBJECTPOINT, 202),
|
---|
1542 |
|
---|
1543 | /* send linked-list of name:port:address sets */
|
---|
1544 | CINIT(RESOLVE, OBJECTPOINT, 203),
|
---|
1545 |
|
---|
1546 | /* Set a username for authenticated TLS */
|
---|
1547 | CINIT(TLSAUTH_USERNAME, STRINGPOINT, 204),
|
---|
1548 |
|
---|
1549 | /* Set a password for authenticated TLS */
|
---|
1550 | CINIT(TLSAUTH_PASSWORD, STRINGPOINT, 205),
|
---|
1551 |
|
---|
1552 | /* Set authentication type for authenticated TLS */
|
---|
1553 | CINIT(TLSAUTH_TYPE, STRINGPOINT, 206),
|
---|
1554 |
|
---|
1555 | /* Set to 1 to enable the "TE:" header in HTTP requests to ask for
|
---|
1556 | compressed transfer-encoded responses. Set to 0 to disable the use of TE:
|
---|
1557 | in outgoing requests. The current default is 0, but it might change in a
|
---|
1558 | future libcurl release.
|
---|
1559 |
|
---|
1560 | libcurl will ask for the compressed methods it knows of, and if that
|
---|
1561 | isn't any, it will not ask for transfer-encoding at all even if this
|
---|
1562 | option is set to 1.
|
---|
1563 |
|
---|
1564 | */
|
---|
1565 | CINIT(TRANSFER_ENCODING, LONG, 207),
|
---|
1566 |
|
---|
1567 | /* Callback function for closing socket (instead of close(2)). The callback
|
---|
1568 | should have type curl_closesocket_callback */
|
---|
1569 | CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208),
|
---|
1570 | CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209),
|
---|
1571 |
|
---|
1572 | /* allow GSSAPI credential delegation */
|
---|
1573 | CINIT(GSSAPI_DELEGATION, LONG, 210),
|
---|
1574 |
|
---|
1575 | /* Set the name servers to use for DNS resolution */
|
---|
1576 | CINIT(DNS_SERVERS, STRINGPOINT, 211),
|
---|
1577 |
|
---|
1578 | /* Time-out accept operations (currently for FTP only) after this amount
|
---|
1579 | of miliseconds. */
|
---|
1580 | CINIT(ACCEPTTIMEOUT_MS, LONG, 212),
|
---|
1581 |
|
---|
1582 | /* Set TCP keepalive */
|
---|
1583 | CINIT(TCP_KEEPALIVE, LONG, 213),
|
---|
1584 |
|
---|
1585 | /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */
|
---|
1586 | CINIT(TCP_KEEPIDLE, LONG, 214),
|
---|
1587 | CINIT(TCP_KEEPINTVL, LONG, 215),
|
---|
1588 |
|
---|
1589 | /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */
|
---|
1590 | CINIT(SSL_OPTIONS, LONG, 216),
|
---|
1591 |
|
---|
1592 | /* Set the SMTP auth originator */
|
---|
1593 | CINIT(MAIL_AUTH, STRINGPOINT, 217),
|
---|
1594 |
|
---|
1595 | /* Enable/disable SASL initial response */
|
---|
1596 | CINIT(SASL_IR, LONG, 218),
|
---|
1597 |
|
---|
1598 | /* Function that will be called instead of the internal progress display
|
---|
1599 | * function. This function should be defined as the curl_xferinfo_callback
|
---|
1600 | * prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */
|
---|
1601 | CINIT(XFERINFOFUNCTION, FUNCTIONPOINT, 219),
|
---|
1602 |
|
---|
1603 | /* The XOAUTH2 bearer token */
|
---|
1604 | CINIT(XOAUTH2_BEARER, STRINGPOINT, 220),
|
---|
1605 |
|
---|
1606 | /* Set the interface string to use as outgoing network
|
---|
1607 | * interface for DNS requests.
|
---|
1608 | * Only supported by the c-ares DNS backend */
|
---|
1609 | CINIT(DNS_INTERFACE, STRINGPOINT, 221),
|
---|
1610 |
|
---|
1611 | /* Set the local IPv4 address to use for outgoing DNS requests.
|
---|
1612 | * Only supported by the c-ares DNS backend */
|
---|
1613 | CINIT(DNS_LOCAL_IP4, STRINGPOINT, 222),
|
---|
1614 |
|
---|
1615 | /* Set the local IPv4 address to use for outgoing DNS requests.
|
---|
1616 | * Only supported by the c-ares DNS backend */
|
---|
1617 | CINIT(DNS_LOCAL_IP6, STRINGPOINT, 223),
|
---|
1618 |
|
---|
1619 | /* Set authentication options directly */
|
---|
1620 | CINIT(LOGIN_OPTIONS, STRINGPOINT, 224),
|
---|
1621 |
|
---|
1622 | /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */
|
---|
1623 | CINIT(SSL_ENABLE_NPN, LONG, 225),
|
---|
1624 |
|
---|
1625 | /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */
|
---|
1626 | CINIT(SSL_ENABLE_ALPN, LONG, 226),
|
---|
1627 |
|
---|
1628 | /* Time to wait for a response to a HTTP request containing an
|
---|
1629 | * Expect: 100-continue header before sending the data anyway. */
|
---|
1630 | CINIT(EXPECT_100_TIMEOUT_MS, LONG, 227),
|
---|
1631 |
|
---|
1632 | /* This points to a linked list of headers used for proxy requests only,
|
---|
1633 | struct curl_slist kind */
|
---|
1634 | CINIT(PROXYHEADER, OBJECTPOINT, 228),
|
---|
1635 |
|
---|
1636 | /* Pass in a bitmask of "header options" */
|
---|
1637 | CINIT(HEADEROPT, LONG, 229),
|
---|
1638 |
|
---|
1639 | /* The public key in DER form used to validate the peer public key
|
---|
1640 | this option is used only if SSL_VERIFYPEER is true */
|
---|
1641 | CINIT(PINNEDPUBLICKEY, STRINGPOINT, 230),
|
---|
1642 |
|
---|
1643 | /* Path to Unix domain socket */
|
---|
1644 | CINIT(UNIX_SOCKET_PATH, STRINGPOINT, 231),
|
---|
1645 |
|
---|
1646 | /* Set if we should verify the certificate status. */
|
---|
1647 | CINIT(SSL_VERIFYSTATUS, LONG, 232),
|
---|
1648 |
|
---|
1649 | /* Set if we should enable TLS false start. */
|
---|
1650 | CINIT(SSL_FALSESTART, LONG, 233),
|
---|
1651 |
|
---|
1652 | /* Do not squash dot-dot sequences */
|
---|
1653 | CINIT(PATH_AS_IS, LONG, 234),
|
---|
1654 |
|
---|
1655 | /* Proxy Service Name */
|
---|
1656 | CINIT(PROXY_SERVICE_NAME, STRINGPOINT, 235),
|
---|
1657 |
|
---|
1658 | /* Service Name */
|
---|
1659 | CINIT(SERVICE_NAME, STRINGPOINT, 236),
|
---|
1660 |
|
---|
1661 | /* Wait/don't wait for pipe/mutex to clarify */
|
---|
1662 | CINIT(PIPEWAIT, LONG, 237),
|
---|
1663 |
|
---|
1664 | /* Set the protocol used when curl is given a URL without a protocol */
|
---|
1665 | CINIT(DEFAULT_PROTOCOL, STRINGPOINT, 238),
|
---|
1666 |
|
---|
1667 | /* Set stream weight, 1 - 256 (default is 16) */
|
---|
1668 | CINIT(STREAM_WEIGHT, LONG, 239),
|
---|
1669 |
|
---|
1670 | /* Set stream dependency on another CURL handle */
|
---|
1671 | CINIT(STREAM_DEPENDS, OBJECTPOINT, 240),
|
---|
1672 |
|
---|
1673 | /* Set E-xclusive stream dependency on another CURL handle */
|
---|
1674 | CINIT(STREAM_DEPENDS_E, OBJECTPOINT, 241),
|
---|
1675 |
|
---|
1676 | CURLOPT_LASTENTRY /* the last unused */
|
---|
1677 | } CURLoption;
|
---|
1678 |
|
---|
1679 | #ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
|
---|
1680 | the obsolete stuff removed! */
|
---|
1681 |
|
---|
1682 | /* Backwards compatibility with older names */
|
---|
1683 | /* These are scheduled to disappear by 2011 */
|
---|
1684 |
|
---|
1685 | /* This was added in version 7.19.1 */
|
---|
1686 | #define CURLOPT_POST301 CURLOPT_POSTREDIR
|
---|
1687 |
|
---|
1688 | /* These are scheduled to disappear by 2009 */
|
---|
1689 |
|
---|
1690 | /* The following were added in 7.17.0 */
|
---|
1691 | #define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD
|
---|
1692 | #define CURLOPT_FTPAPPEND CURLOPT_APPEND
|
---|
1693 | #define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY
|
---|
1694 | #define CURLOPT_FTP_SSL CURLOPT_USE_SSL
|
---|
1695 |
|
---|
1696 | /* The following were added earlier */
|
---|
1697 |
|
---|
1698 | #define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD
|
---|
1699 | #define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL
|
---|
1700 |
|
---|
1701 | #else
|
---|
1702 | /* This is set if CURL_NO_OLDIES is defined at compile-time */
|
---|
1703 | #undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */
|
---|
1704 | #endif
|
---|
1705 |
|
---|
1706 |
|
---|
1707 | /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host
|
---|
1708 | name resolves addresses using more than one IP protocol version, this
|
---|
1709 | option might be handy to force libcurl to use a specific IP version. */
|
---|
1710 | #define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP
|
---|
1711 | versions that your system allows */
|
---|
1712 | #define CURL_IPRESOLVE_V4 1 /* resolve to IPv4 addresses */
|
---|
1713 | #define CURL_IPRESOLVE_V6 2 /* resolve to IPv6 addresses */
|
---|
1714 |
|
---|
1715 | /* three convenient "aliases" that follow the name scheme better */
|
---|
1716 | #define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER
|
---|
1717 |
|
---|
1718 | /* These enums are for use with the CURLOPT_HTTP_VERSION option. */
|
---|
1719 | enum {
|
---|
1720 | CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd
|
---|
1721 | like the library to choose the best possible
|
---|
1722 | for us! */
|
---|
1723 | CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */
|
---|
1724 | CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */
|
---|
1725 | CURL_HTTP_VERSION_2_0, /* please use HTTP 2 in the request */
|
---|
1726 | CURL_HTTP_VERSION_2TLS, /* use version 2 for HTTPS, version 1.1 for HTTP */
|
---|
1727 |
|
---|
1728 | CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */
|
---|
1729 | };
|
---|
1730 |
|
---|
1731 | /* Convenience definition simple because the name of the version is HTTP/2 and
|
---|
1732 | not 2.0. The 2_0 version of the enum name was set while the version was
|
---|
1733 | still planned to be 2.0 and we stick to it for compatibility. */
|
---|
1734 | #define CURL_HTTP_VERSION_2 CURL_HTTP_VERSION_2_0
|
---|
1735 |
|
---|
1736 | /*
|
---|
1737 | * Public API enums for RTSP requests
|
---|
1738 | */
|
---|
1739 | enum {
|
---|
1740 | CURL_RTSPREQ_NONE, /* first in list */
|
---|
1741 | CURL_RTSPREQ_OPTIONS,
|
---|
1742 | CURL_RTSPREQ_DESCRIBE,
|
---|
1743 | CURL_RTSPREQ_ANNOUNCE,
|
---|
1744 | CURL_RTSPREQ_SETUP,
|
---|
1745 | CURL_RTSPREQ_PLAY,
|
---|
1746 | CURL_RTSPREQ_PAUSE,
|
---|
1747 | CURL_RTSPREQ_TEARDOWN,
|
---|
1748 | CURL_RTSPREQ_GET_PARAMETER,
|
---|
1749 | CURL_RTSPREQ_SET_PARAMETER,
|
---|
1750 | CURL_RTSPREQ_RECORD,
|
---|
1751 | CURL_RTSPREQ_RECEIVE,
|
---|
1752 | CURL_RTSPREQ_LAST /* last in list */
|
---|
1753 | };
|
---|
1754 |
|
---|
1755 | /* These enums are for use with the CURLOPT_NETRC option. */
|
---|
1756 | enum CURL_NETRC_OPTION {
|
---|
1757 | CURL_NETRC_IGNORED, /* The .netrc will never be read.
|
---|
1758 | * This is the default. */
|
---|
1759 | CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred
|
---|
1760 | * to one in the .netrc. */
|
---|
1761 | CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored.
|
---|
1762 | * Unless one is set programmatically, the .netrc
|
---|
1763 | * will be queried. */
|
---|
1764 | CURL_NETRC_LAST
|
---|
1765 | };
|
---|
1766 |
|
---|
1767 | enum {
|
---|
1768 | CURL_SSLVERSION_DEFAULT,
|
---|
1769 | CURL_SSLVERSION_TLSv1, /* TLS 1.x */
|
---|
1770 | CURL_SSLVERSION_SSLv2,
|
---|
1771 | CURL_SSLVERSION_SSLv3,
|
---|
1772 | CURL_SSLVERSION_TLSv1_0,
|
---|
1773 | CURL_SSLVERSION_TLSv1_1,
|
---|
1774 | CURL_SSLVERSION_TLSv1_2,
|
---|
1775 |
|
---|
1776 | CURL_SSLVERSION_LAST /* never use, keep last */
|
---|
1777 | };
|
---|
1778 |
|
---|
1779 | enum CURL_TLSAUTH {
|
---|
1780 | CURL_TLSAUTH_NONE,
|
---|
1781 | CURL_TLSAUTH_SRP,
|
---|
1782 | CURL_TLSAUTH_LAST /* never use, keep last */
|
---|
1783 | };
|
---|
1784 |
|
---|
1785 | /* symbols to use with CURLOPT_POSTREDIR.
|
---|
1786 | CURL_REDIR_POST_301, CURL_REDIR_POST_302 and CURL_REDIR_POST_303
|
---|
1787 | can be bitwise ORed so that CURL_REDIR_POST_301 | CURL_REDIR_POST_302
|
---|
1788 | | CURL_REDIR_POST_303 == CURL_REDIR_POST_ALL */
|
---|
1789 |
|
---|
1790 | #define CURL_REDIR_GET_ALL 0
|
---|
1791 | #define CURL_REDIR_POST_301 1
|
---|
1792 | #define CURL_REDIR_POST_302 2
|
---|
1793 | #define CURL_REDIR_POST_303 4
|
---|
1794 | #define CURL_REDIR_POST_ALL \
|
---|
1795 | (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303)
|
---|
1796 |
|
---|
1797 | typedef enum {
|
---|
1798 | CURL_TIMECOND_NONE,
|
---|
1799 |
|
---|
1800 | CURL_TIMECOND_IFMODSINCE,
|
---|
1801 | CURL_TIMECOND_IFUNMODSINCE,
|
---|
1802 | CURL_TIMECOND_LASTMOD,
|
---|
1803 |
|
---|
1804 | CURL_TIMECOND_LAST
|
---|
1805 | } curl_TimeCond;
|
---|
1806 |
|
---|
1807 |
|
---|
1808 | /* curl_strequal() and curl_strnequal() are subject for removal in a future
|
---|
1809 | libcurl, see lib/README.curlx for details */
|
---|
1810 | CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2);
|
---|
1811 | CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n);
|
---|
1812 |
|
---|
1813 | /* name is uppercase CURLFORM_<name> */
|
---|
1814 | #ifdef CFINIT
|
---|
1815 | #undef CFINIT
|
---|
1816 | #endif
|
---|
1817 |
|
---|
1818 | #ifdef CURL_ISOCPP
|
---|
1819 | #define CFINIT(name) CURLFORM_ ## name
|
---|
1820 | #else
|
---|
1821 | /* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
|
---|
1822 | #define CFINIT(name) CURLFORM_/**/name
|
---|
1823 | #endif
|
---|
1824 |
|
---|
1825 | typedef enum {
|
---|
1826 | CFINIT(NOTHING), /********* the first one is unused ************/
|
---|
1827 |
|
---|
1828 | /* */
|
---|
1829 | CFINIT(COPYNAME),
|
---|
1830 | CFINIT(PTRNAME),
|
---|
1831 | CFINIT(NAMELENGTH),
|
---|
1832 | CFINIT(COPYCONTENTS),
|
---|
1833 | CFINIT(PTRCONTENTS),
|
---|
1834 | CFINIT(CONTENTSLENGTH),
|
---|
1835 | CFINIT(FILECONTENT),
|
---|
1836 | CFINIT(ARRAY),
|
---|
1837 | CFINIT(OBSOLETE),
|
---|
1838 | CFINIT(FILE),
|
---|
1839 |
|
---|
1840 | CFINIT(BUFFER),
|
---|
1841 | CFINIT(BUFFERPTR),
|
---|
1842 | CFINIT(BUFFERLENGTH),
|
---|
1843 |
|
---|
1844 | CFINIT(CONTENTTYPE),
|
---|
1845 | CFINIT(CONTENTHEADER),
|
---|
1846 | CFINIT(FILENAME),
|
---|
1847 | CFINIT(END),
|
---|
1848 | CFINIT(OBSOLETE2),
|
---|
1849 |
|
---|
1850 | CFINIT(STREAM),
|
---|
1851 | CFINIT(CONTENTLEN), /* added in 7.46.0, provide a curl_off_t length */
|
---|
1852 |
|
---|
1853 | CURLFORM_LASTENTRY /* the last unused */
|
---|
1854 | } CURLformoption;
|
---|
1855 |
|
---|
1856 | #undef CFINIT /* done */
|
---|
1857 |
|
---|
1858 | /* structure to be used as parameter for CURLFORM_ARRAY */
|
---|
1859 | struct curl_forms {
|
---|
1860 | CURLformoption option;
|
---|
1861 | const char *value;
|
---|
1862 | };
|
---|
1863 |
|
---|
1864 | /* use this for multipart formpost building */
|
---|
1865 | /* Returns code for curl_formadd()
|
---|
1866 | *
|
---|
1867 | * Returns:
|
---|
1868 | * CURL_FORMADD_OK on success
|
---|
1869 | * CURL_FORMADD_MEMORY if the FormInfo allocation fails
|
---|
1870 | * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form
|
---|
1871 | * CURL_FORMADD_NULL if a null pointer was given for a char
|
---|
1872 | * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed
|
---|
1873 | * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used
|
---|
1874 | * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error)
|
---|
1875 | * CURL_FORMADD_MEMORY if a curl_httppost struct cannot be allocated
|
---|
1876 | * CURL_FORMADD_MEMORY if some allocation for string copying failed.
|
---|
1877 | * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array
|
---|
1878 | *
|
---|
1879 | ***************************************************************************/
|
---|
1880 | typedef enum {
|
---|
1881 | CURL_FORMADD_OK, /* first, no error */
|
---|
1882 |
|
---|
1883 | CURL_FORMADD_MEMORY,
|
---|
1884 | CURL_FORMADD_OPTION_TWICE,
|
---|
1885 | CURL_FORMADD_NULL,
|
---|
1886 | CURL_FORMADD_UNKNOWN_OPTION,
|
---|
1887 | CURL_FORMADD_INCOMPLETE,
|
---|
1888 | CURL_FORMADD_ILLEGAL_ARRAY,
|
---|
1889 | CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */
|
---|
1890 |
|
---|
1891 | CURL_FORMADD_LAST /* last */
|
---|
1892 | } CURLFORMcode;
|
---|
1893 |
|
---|
1894 | /*
|
---|
1895 | * NAME curl_formadd()
|
---|
1896 | *
|
---|
1897 | * DESCRIPTION
|
---|
1898 | *
|
---|
1899 | * Pretty advanced function for building multi-part formposts. Each invoke
|
---|
1900 | * adds one part that together construct a full post. Then use
|
---|
1901 | * CURLOPT_HTTPPOST to send it off to libcurl.
|
---|
1902 | */
|
---|
1903 | CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost,
|
---|
1904 | struct curl_httppost **last_post,
|
---|
1905 | ...);
|
---|
1906 |
|
---|
1907 | /*
|
---|
1908 | * callback function for curl_formget()
|
---|
1909 | * The void *arg pointer will be the one passed as second argument to
|
---|
1910 | * curl_formget().
|
---|
1911 | * The character buffer passed to it must not be freed.
|
---|
1912 | * Should return the buffer length passed to it as the argument "len" on
|
---|
1913 | * success.
|
---|
1914 | */
|
---|
1915 | typedef size_t (*curl_formget_callback)(void *arg, const char *buf,
|
---|
1916 | size_t len);
|
---|
1917 |
|
---|
1918 | /*
|
---|
1919 | * NAME curl_formget()
|
---|
1920 | *
|
---|
1921 | * DESCRIPTION
|
---|
1922 | *
|
---|
1923 | * Serialize a curl_httppost struct built with curl_formadd().
|
---|
1924 | * Accepts a void pointer as second argument which will be passed to
|
---|
1925 | * the curl_formget_callback function.
|
---|
1926 | * Returns 0 on success.
|
---|
1927 | */
|
---|
1928 | CURL_EXTERN int curl_formget(struct curl_httppost *form, void *arg,
|
---|
1929 | curl_formget_callback append);
|
---|
1930 | /*
|
---|
1931 | * NAME curl_formfree()
|
---|
1932 | *
|
---|
1933 | * DESCRIPTION
|
---|
1934 | *
|
---|
1935 | * Free a multipart formpost previously built with curl_formadd().
|
---|
1936 | */
|
---|
1937 | CURL_EXTERN void curl_formfree(struct curl_httppost *form);
|
---|
1938 |
|
---|
1939 | /*
|
---|
1940 | * NAME curl_getenv()
|
---|
1941 | *
|
---|
1942 | * DESCRIPTION
|
---|
1943 | *
|
---|
1944 | * Returns a malloc()'ed string that MUST be curl_free()ed after usage is
|
---|
1945 | * complete. DEPRECATED - see lib/README.curlx
|
---|
1946 | */
|
---|
1947 | CURL_EXTERN char *curl_getenv(const char *variable);
|
---|
1948 |
|
---|
1949 | /*
|
---|
1950 | * NAME curl_version()
|
---|
1951 | *
|
---|
1952 | * DESCRIPTION
|
---|
1953 | *
|
---|
1954 | * Returns a static ascii string of the libcurl version.
|
---|
1955 | */
|
---|
1956 | CURL_EXTERN char *curl_version(void);
|
---|
1957 |
|
---|
1958 | /*
|
---|
1959 | * NAME curl_easy_escape()
|
---|
1960 | *
|
---|
1961 | * DESCRIPTION
|
---|
1962 | *
|
---|
1963 | * Escapes URL strings (converts all letters consider illegal in URLs to their
|
---|
1964 | * %XX versions). This function returns a new allocated string or NULL if an
|
---|
1965 | * error occurred.
|
---|
1966 | */
|
---|
1967 | CURL_EXTERN char *curl_easy_escape(CURL *handle,
|
---|
1968 | const char *string,
|
---|
1969 | int length);
|
---|
1970 |
|
---|
1971 | /* the previous version: */
|
---|
1972 | CURL_EXTERN char *curl_escape(const char *string,
|
---|
1973 | int length);
|
---|
1974 |
|
---|
1975 |
|
---|
1976 | /*
|
---|
1977 | * NAME curl_easy_unescape()
|
---|
1978 | *
|
---|
1979 | * DESCRIPTION
|
---|
1980 | *
|
---|
1981 | * Unescapes URL encoding in strings (converts all %XX codes to their 8bit
|
---|
1982 | * versions). This function returns a new allocated string or NULL if an error
|
---|
1983 | * occurred.
|
---|
1984 | * Conversion Note: On non-ASCII platforms the ASCII %XX codes are
|
---|
1985 | * converted into the host encoding.
|
---|
1986 | */
|
---|
1987 | CURL_EXTERN char *curl_easy_unescape(CURL *handle,
|
---|
1988 | const char *string,
|
---|
1989 | int length,
|
---|
1990 | int *outlength);
|
---|
1991 |
|
---|
1992 | /* the previous version */
|
---|
1993 | CURL_EXTERN char *curl_unescape(const char *string,
|
---|
1994 | int length);
|
---|
1995 |
|
---|
1996 | /*
|
---|
1997 | * NAME curl_free()
|
---|
1998 | *
|
---|
1999 | * DESCRIPTION
|
---|
2000 | *
|
---|
2001 | * Provided for de-allocation in the same translation unit that did the
|
---|
2002 | * allocation. Added in libcurl 7.10
|
---|
2003 | */
|
---|
2004 | CURL_EXTERN void curl_free(void *p);
|
---|
2005 |
|
---|
2006 | /*
|
---|
2007 | * NAME curl_global_init()
|
---|
2008 | *
|
---|
2009 | * DESCRIPTION
|
---|
2010 | *
|
---|
2011 | * curl_global_init() should be invoked exactly once for each application that
|
---|
2012 | * uses libcurl and before any call of other libcurl functions.
|
---|
2013 | *
|
---|
2014 | * This function is not thread-safe!
|
---|
2015 | */
|
---|
2016 | CURL_EXTERN CURLcode curl_global_init(long flags);
|
---|
2017 |
|
---|
2018 | /*
|
---|
2019 | * NAME curl_global_init_mem()
|
---|
2020 | *
|
---|
2021 | * DESCRIPTION
|
---|
2022 | *
|
---|
2023 | * curl_global_init() or curl_global_init_mem() should be invoked exactly once
|
---|
2024 | * for each application that uses libcurl. This function can be used to
|
---|
2025 | * initialize libcurl and set user defined memory management callback
|
---|
2026 | * functions. Users can implement memory management routines to check for
|
---|
2027 | * memory leaks, check for mis-use of the curl library etc. User registered
|
---|
2028 | * callback routines with be invoked by this library instead of the system
|
---|
2029 | * memory management routines like malloc, free etc.
|
---|
2030 | */
|
---|
2031 | CURL_EXTERN CURLcode curl_global_init_mem(long flags,
|
---|
2032 | curl_malloc_callback m,
|
---|
2033 | curl_free_callback f,
|
---|
2034 | curl_realloc_callback r,
|
---|
2035 | curl_strdup_callback s,
|
---|
2036 | curl_calloc_callback c);
|
---|
2037 |
|
---|
2038 | /*
|
---|
2039 | * NAME curl_global_cleanup()
|
---|
2040 | *
|
---|
2041 | * DESCRIPTION
|
---|
2042 | *
|
---|
2043 | * curl_global_cleanup() should be invoked exactly once for each application
|
---|
2044 | * that uses libcurl
|
---|
2045 | */
|
---|
2046 | CURL_EXTERN void curl_global_cleanup(void);
|
---|
2047 |
|
---|
2048 | /* linked-list structure for the CURLOPT_QUOTE option (and other) */
|
---|
2049 | struct curl_slist {
|
---|
2050 | char *data;
|
---|
2051 | struct curl_slist *next;
|
---|
2052 | };
|
---|
2053 |
|
---|
2054 | /*
|
---|
2055 | * NAME curl_slist_append()
|
---|
2056 | *
|
---|
2057 | * DESCRIPTION
|
---|
2058 | *
|
---|
2059 | * Appends a string to a linked list. If no list exists, it will be created
|
---|
2060 | * first. Returns the new list, after appending.
|
---|
2061 | */
|
---|
2062 | CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *,
|
---|
2063 | const char *);
|
---|
2064 |
|
---|
2065 | /*
|
---|
2066 | * NAME curl_slist_free_all()
|
---|
2067 | *
|
---|
2068 | * DESCRIPTION
|
---|
2069 | *
|
---|
2070 | * free a previously built curl_slist.
|
---|
2071 | */
|
---|
2072 | CURL_EXTERN void curl_slist_free_all(struct curl_slist *);
|
---|
2073 |
|
---|
2074 | /*
|
---|
2075 | * NAME curl_getdate()
|
---|
2076 | *
|
---|
2077 | * DESCRIPTION
|
---|
2078 | *
|
---|
2079 | * Returns the time, in seconds since 1 Jan 1970 of the time string given in
|
---|
2080 | * the first argument. The time argument in the second parameter is unused
|
---|
2081 | * and should be set to NULL.
|
---|
2082 | */
|
---|
2083 | CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused);
|
---|
2084 |
|
---|
2085 | /* info about the certificate chain, only for OpenSSL builds. Asked
|
---|
2086 | for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */
|
---|
2087 | struct curl_certinfo {
|
---|
2088 | int num_of_certs; /* number of certificates with information */
|
---|
2089 | struct curl_slist **certinfo; /* for each index in this array, there's a
|
---|
2090 | linked list with textual information in the
|
---|
2091 | format "name: value" */
|
---|
2092 | };
|
---|
2093 |
|
---|
2094 | /* enum for the different supported SSL backends */
|
---|
2095 | typedef enum {
|
---|
2096 | CURLSSLBACKEND_NONE = 0,
|
---|
2097 | CURLSSLBACKEND_OPENSSL = 1,
|
---|
2098 | CURLSSLBACKEND_GNUTLS = 2,
|
---|
2099 | CURLSSLBACKEND_NSS = 3,
|
---|
2100 | CURLSSLBACKEND_OBSOLETE4 = 4, /* Was QSOSSL. */
|
---|
2101 | CURLSSLBACKEND_GSKIT = 5,
|
---|
2102 | CURLSSLBACKEND_POLARSSL = 6,
|
---|
2103 | CURLSSLBACKEND_CYASSL = 7,
|
---|
2104 | CURLSSLBACKEND_SCHANNEL = 8,
|
---|
2105 | CURLSSLBACKEND_DARWINSSL = 9,
|
---|
2106 | CURLSSLBACKEND_AXTLS = 10,
|
---|
2107 | CURLSSLBACKEND_MBEDTLS = 11
|
---|
2108 | } curl_sslbackend;
|
---|
2109 |
|
---|
2110 | /* Information about the SSL library used and the respective internal SSL
|
---|
2111 | handle, which can be used to obtain further information regarding the
|
---|
2112 | connection. Asked for with CURLINFO_TLS_SESSION. */
|
---|
2113 | struct curl_tlssessioninfo {
|
---|
2114 | curl_sslbackend backend;
|
---|
2115 | void *internals;
|
---|
2116 | };
|
---|
2117 |
|
---|
2118 | #define CURLINFO_STRING 0x100000
|
---|
2119 | #define CURLINFO_LONG 0x200000
|
---|
2120 | #define CURLINFO_DOUBLE 0x300000
|
---|
2121 | #define CURLINFO_SLIST 0x400000
|
---|
2122 | #define CURLINFO_SOCKET 0x500000
|
---|
2123 | #define CURLINFO_MASK 0x0fffff
|
---|
2124 | #define CURLINFO_TYPEMASK 0xf00000
|
---|
2125 |
|
---|
2126 | typedef enum {
|
---|
2127 | CURLINFO_NONE, /* first, never use this */
|
---|
2128 | CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1,
|
---|
2129 | CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2,
|
---|
2130 | CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3,
|
---|
2131 | CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4,
|
---|
2132 | CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5,
|
---|
2133 | CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
|
---|
2134 | CURLINFO_SIZE_UPLOAD = CURLINFO_DOUBLE + 7,
|
---|
2135 | CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8,
|
---|
2136 | CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9,
|
---|
2137 | CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10,
|
---|
2138 | CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11,
|
---|
2139 | CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12,
|
---|
2140 | CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13,
|
---|
2141 | CURLINFO_FILETIME = CURLINFO_LONG + 14,
|
---|
2142 | CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15,
|
---|
2143 | CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16,
|
---|
2144 | CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
|
---|
2145 | CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18,
|
---|
2146 | CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19,
|
---|
2147 | CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20,
|
---|
2148 | CURLINFO_PRIVATE = CURLINFO_STRING + 21,
|
---|
2149 | CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22,
|
---|
2150 | CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23,
|
---|
2151 | CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24,
|
---|
2152 | CURLINFO_OS_ERRNO = CURLINFO_LONG + 25,
|
---|
2153 | CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26,
|
---|
2154 | CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27,
|
---|
2155 | CURLINFO_COOKIELIST = CURLINFO_SLIST + 28,
|
---|
2156 | CURLINFO_LASTSOCKET = CURLINFO_LONG + 29,
|
---|
2157 | CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30,
|
---|
2158 | CURLINFO_REDIRECT_URL = CURLINFO_STRING + 31,
|
---|
2159 | CURLINFO_PRIMARY_IP = CURLINFO_STRING + 32,
|
---|
2160 | CURLINFO_APPCONNECT_TIME = CURLINFO_DOUBLE + 33,
|
---|
2161 | CURLINFO_CERTINFO = CURLINFO_SLIST + 34,
|
---|
2162 | CURLINFO_CONDITION_UNMET = CURLINFO_LONG + 35,
|
---|
2163 | CURLINFO_RTSP_SESSION_ID = CURLINFO_STRING + 36,
|
---|
2164 | CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG + 37,
|
---|
2165 | CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG + 38,
|
---|
2166 | CURLINFO_RTSP_CSEQ_RECV = CURLINFO_LONG + 39,
|
---|
2167 | CURLINFO_PRIMARY_PORT = CURLINFO_LONG + 40,
|
---|
2168 | CURLINFO_LOCAL_IP = CURLINFO_STRING + 41,
|
---|
2169 | CURLINFO_LOCAL_PORT = CURLINFO_LONG + 42,
|
---|
2170 | CURLINFO_TLS_SESSION = CURLINFO_SLIST + 43,
|
---|
2171 | CURLINFO_ACTIVESOCKET = CURLINFO_SOCKET + 44,
|
---|
2172 | /* Fill in new entries below here! */
|
---|
2173 |
|
---|
2174 | CURLINFO_LASTONE = 44
|
---|
2175 | } CURLINFO;
|
---|
2176 |
|
---|
2177 | /* CURLINFO_RESPONSE_CODE is the new name for the option previously known as
|
---|
2178 | CURLINFO_HTTP_CODE */
|
---|
2179 | #define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE
|
---|
2180 |
|
---|
2181 | typedef enum {
|
---|
2182 | CURLCLOSEPOLICY_NONE, /* first, never use this */
|
---|
2183 |
|
---|
2184 | CURLCLOSEPOLICY_OLDEST,
|
---|
2185 | CURLCLOSEPOLICY_LEAST_RECENTLY_USED,
|
---|
2186 | CURLCLOSEPOLICY_LEAST_TRAFFIC,
|
---|
2187 | CURLCLOSEPOLICY_SLOWEST,
|
---|
2188 | CURLCLOSEPOLICY_CALLBACK,
|
---|
2189 |
|
---|
2190 | CURLCLOSEPOLICY_LAST /* last, never use this */
|
---|
2191 | } curl_closepolicy;
|
---|
2192 |
|
---|
2193 | #define CURL_GLOBAL_SSL (1<<0)
|
---|
2194 | #define CURL_GLOBAL_WIN32 (1<<1)
|
---|
2195 | #define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32)
|
---|
2196 | #define CURL_GLOBAL_NOTHING 0
|
---|
2197 | #define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL
|
---|
2198 | #define CURL_GLOBAL_ACK_EINTR (1<<2)
|
---|
2199 |
|
---|
2200 |
|
---|
2201 | /*****************************************************************************
|
---|
2202 | * Setup defines, protos etc for the sharing stuff.
|
---|
2203 | */
|
---|
2204 |
|
---|
2205 | /* Different data locks for a single share */
|
---|
2206 | typedef enum {
|
---|
2207 | CURL_LOCK_DATA_NONE = 0,
|
---|
2208 | /* CURL_LOCK_DATA_SHARE is used internally to say that
|
---|
2209 | * the locking is just made to change the internal state of the share
|
---|
2210 | * itself.
|
---|
2211 | */
|
---|
2212 | CURL_LOCK_DATA_SHARE,
|
---|
2213 | CURL_LOCK_DATA_COOKIE,
|
---|
2214 | CURL_LOCK_DATA_DNS,
|
---|
2215 | CURL_LOCK_DATA_SSL_SESSION,
|
---|
2216 | CURL_LOCK_DATA_CONNECT,
|
---|
2217 | CURL_LOCK_DATA_LAST
|
---|
2218 | } curl_lock_data;
|
---|
2219 |
|
---|
2220 | /* Different lock access types */
|
---|
2221 | typedef enum {
|
---|
2222 | CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */
|
---|
2223 | CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */
|
---|
2224 | CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */
|
---|
2225 | CURL_LOCK_ACCESS_LAST /* never use */
|
---|
2226 | } curl_lock_access;
|
---|
2227 |
|
---|
2228 | typedef void (*curl_lock_function)(CURL *handle,
|
---|
2229 | curl_lock_data data,
|
---|
2230 | curl_lock_access locktype,
|
---|
2231 | void *userptr);
|
---|
2232 | typedef void (*curl_unlock_function)(CURL *handle,
|
---|
2233 | curl_lock_data data,
|
---|
2234 | void *userptr);
|
---|
2235 |
|
---|
2236 | typedef void CURLSH;
|
---|
2237 |
|
---|
2238 | typedef enum {
|
---|
2239 | CURLSHE_OK, /* all is fine */
|
---|
2240 | CURLSHE_BAD_OPTION, /* 1 */
|
---|
2241 | CURLSHE_IN_USE, /* 2 */
|
---|
2242 | CURLSHE_INVALID, /* 3 */
|
---|
2243 | CURLSHE_NOMEM, /* 4 out of memory */
|
---|
2244 | CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */
|
---|
2245 | CURLSHE_LAST /* never use */
|
---|
2246 | } CURLSHcode;
|
---|
2247 |
|
---|
2248 | typedef enum {
|
---|
2249 | CURLSHOPT_NONE, /* don't use */
|
---|
2250 | CURLSHOPT_SHARE, /* specify a data type to share */
|
---|
2251 | CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */
|
---|
2252 | CURLSHOPT_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */
|
---|
2253 | CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */
|
---|
2254 | CURLSHOPT_USERDATA, /* pass in a user data pointer used in the lock/unlock
|
---|
2255 | callback functions */
|
---|
2256 | CURLSHOPT_LAST /* never use */
|
---|
2257 | } CURLSHoption;
|
---|
2258 |
|
---|
2259 | CURL_EXTERN CURLSH *curl_share_init(void);
|
---|
2260 | CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...);
|
---|
2261 | CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *);
|
---|
2262 |
|
---|
2263 | /****************************************************************************
|
---|
2264 | * Structures for querying information about the curl library at runtime.
|
---|
2265 | */
|
---|
2266 |
|
---|
2267 | typedef enum {
|
---|
2268 | CURLVERSION_FIRST,
|
---|
2269 | CURLVERSION_SECOND,
|
---|
2270 | CURLVERSION_THIRD,
|
---|
2271 | CURLVERSION_FOURTH,
|
---|
2272 | CURLVERSION_LAST /* never actually use this */
|
---|
2273 | } CURLversion;
|
---|
2274 |
|
---|
2275 | /* The 'CURLVERSION_NOW' is the symbolic name meant to be used by
|
---|
2276 | basically all programs ever that want to get version information. It is
|
---|
2277 | meant to be a built-in version number for what kind of struct the caller
|
---|
2278 | expects. If the struct ever changes, we redefine the NOW to another enum
|
---|
2279 | from above. */
|
---|
2280 | #define CURLVERSION_NOW CURLVERSION_FOURTH
|
---|
2281 |
|
---|
2282 | typedef struct {
|
---|
2283 | CURLversion age; /* age of the returned struct */
|
---|
2284 | const char *version; /* LIBCURL_VERSION */
|
---|
2285 | unsigned int version_num; /* LIBCURL_VERSION_NUM */
|
---|
2286 | const char *host; /* OS/host/cpu/machine when configured */
|
---|
2287 | int features; /* bitmask, see defines below */
|
---|
2288 | const char *ssl_version; /* human readable string */
|
---|
2289 | long ssl_version_num; /* not used anymore, always 0 */
|
---|
2290 | const char *libz_version; /* human readable string */
|
---|
2291 | /* protocols is terminated by an entry with a NULL protoname */
|
---|
2292 | const char * const *protocols;
|
---|
2293 |
|
---|
2294 | /* The fields below this were added in CURLVERSION_SECOND */
|
---|
2295 | const char *ares;
|
---|
2296 | int ares_num;
|
---|
2297 |
|
---|
2298 | /* This field was added in CURLVERSION_THIRD */
|
---|
2299 | const char *libidn;
|
---|
2300 |
|
---|
2301 | /* These field were added in CURLVERSION_FOURTH */
|
---|
2302 |
|
---|
2303 | /* Same as '_libiconv_version' if built with HAVE_ICONV */
|
---|
2304 | int iconv_ver_num;
|
---|
2305 |
|
---|
2306 | const char *libssh_version; /* human readable string */
|
---|
2307 |
|
---|
2308 | } curl_version_info_data;
|
---|
2309 |
|
---|
2310 | #define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */
|
---|
2311 | #define CURL_VERSION_KERBEROS4 (1<<1) /* Kerberos V4 auth is supported
|
---|
2312 | (deprecated) */
|
---|
2313 | #define CURL_VERSION_SSL (1<<2) /* SSL options are present */
|
---|
2314 | #define CURL_VERSION_LIBZ (1<<3) /* libz features are present */
|
---|
2315 | #define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */
|
---|
2316 | #define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth is supported
|
---|
2317 | (deprecated) */
|
---|
2318 | #define CURL_VERSION_DEBUG (1<<6) /* Built with debug capabilities */
|
---|
2319 | #define CURL_VERSION_ASYNCHDNS (1<<7) /* Asynchronous DNS resolves */
|
---|
2320 | #define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth is supported */
|
---|
2321 | #define CURL_VERSION_LARGEFILE (1<<9) /* Supports files larger than 2GB */
|
---|
2322 | #define CURL_VERSION_IDN (1<<10) /* Internationized Domain Names are
|
---|
2323 | supported */
|
---|
2324 | #define CURL_VERSION_SSPI (1<<11) /* Built against Windows SSPI */
|
---|
2325 | #define CURL_VERSION_CONV (1<<12) /* Character conversions supported */
|
---|
2326 | #define CURL_VERSION_CURLDEBUG (1<<13) /* Debug memory tracking supported */
|
---|
2327 | #define CURL_VERSION_TLSAUTH_SRP (1<<14) /* TLS-SRP auth is supported */
|
---|
2328 | #define CURL_VERSION_NTLM_WB (1<<15) /* NTLM delegation to winbind helper
|
---|
2329 | is suported */
|
---|
2330 | #define CURL_VERSION_HTTP2 (1<<16) /* HTTP2 support built-in */
|
---|
2331 | #define CURL_VERSION_GSSAPI (1<<17) /* Built against a GSS-API library */
|
---|
2332 | #define CURL_VERSION_KERBEROS5 (1<<18) /* Kerberos V5 auth is supported */
|
---|
2333 | #define CURL_VERSION_UNIX_SOCKETS (1<<19) /* Unix domain sockets support */
|
---|
2334 | #define CURL_VERSION_PSL (1<<20) /* Mozilla's Public Suffix List, used
|
---|
2335 | for cookie domain verification */
|
---|
2336 |
|
---|
2337 | /*
|
---|
2338 | * NAME curl_version_info()
|
---|
2339 | *
|
---|
2340 | * DESCRIPTION
|
---|
2341 | *
|
---|
2342 | * This function returns a pointer to a static copy of the version info
|
---|
2343 | * struct. See above.
|
---|
2344 | */
|
---|
2345 | CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion);
|
---|
2346 |
|
---|
2347 | /*
|
---|
2348 | * NAME curl_easy_strerror()
|
---|
2349 | *
|
---|
2350 | * DESCRIPTION
|
---|
2351 | *
|
---|
2352 | * The curl_easy_strerror function may be used to turn a CURLcode value
|
---|
2353 | * into the equivalent human readable error string. This is useful
|
---|
2354 | * for printing meaningful error messages.
|
---|
2355 | */
|
---|
2356 | CURL_EXTERN const char *curl_easy_strerror(CURLcode);
|
---|
2357 |
|
---|
2358 | /*
|
---|
2359 | * NAME curl_share_strerror()
|
---|
2360 | *
|
---|
2361 | * DESCRIPTION
|
---|
2362 | *
|
---|
2363 | * The curl_share_strerror function may be used to turn a CURLSHcode value
|
---|
2364 | * into the equivalent human readable error string. This is useful
|
---|
2365 | * for printing meaningful error messages.
|
---|
2366 | */
|
---|
2367 | CURL_EXTERN const char *curl_share_strerror(CURLSHcode);
|
---|
2368 |
|
---|
2369 | /*
|
---|
2370 | * NAME curl_easy_pause()
|
---|
2371 | *
|
---|
2372 | * DESCRIPTION
|
---|
2373 | *
|
---|
2374 | * The curl_easy_pause function pauses or unpauses transfers. Select the new
|
---|
2375 | * state by setting the bitmask, use the convenience defines below.
|
---|
2376 | *
|
---|
2377 | */
|
---|
2378 | CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask);
|
---|
2379 |
|
---|
2380 | #define CURLPAUSE_RECV (1<<0)
|
---|
2381 | #define CURLPAUSE_RECV_CONT (0)
|
---|
2382 |
|
---|
2383 | #define CURLPAUSE_SEND (1<<2)
|
---|
2384 | #define CURLPAUSE_SEND_CONT (0)
|
---|
2385 |
|
---|
2386 | #define CURLPAUSE_ALL (CURLPAUSE_RECV|CURLPAUSE_SEND)
|
---|
2387 | #define CURLPAUSE_CONT (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT)
|
---|
2388 |
|
---|
2389 | #ifdef __cplusplus
|
---|
2390 | }
|
---|
2391 | #endif
|
---|
2392 |
|
---|
2393 | /* unfortunately, the easy.h and multi.h include files need options and info
|
---|
2394 | stuff before they can be included! */
|
---|
2395 | #include "easy.h" /* nothing in curl is fun without the easy stuff */
|
---|
2396 | #include "multi.h"
|
---|
2397 |
|
---|
2398 | /* the typechecker doesn't work in C++ (yet) */
|
---|
2399 | #if defined(__GNUC__) && defined(__GNUC_MINOR__) && \
|
---|
2400 | ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \
|
---|
2401 | !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK)
|
---|
2402 | #include "typecheck-gcc.h"
|
---|
2403 | #else
|
---|
2404 | #if defined(__STDC__) && (__STDC__ >= 1)
|
---|
2405 | /* This preprocessor magic that replaces a call with the exact same call is
|
---|
2406 | only done to make sure application authors pass exactly three arguments
|
---|
2407 | to these functions. */
|
---|
2408 | #define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param)
|
---|
2409 | #define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg)
|
---|
2410 | #define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
|
---|
2411 | #define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
|
---|
2412 | #endif /* __STDC__ >= 1 */
|
---|
2413 | #endif /* gcc >= 4.3 && !__cplusplus */
|
---|
2414 |
|
---|
2415 | #endif /* __CURL_CURL_H */
|
---|