curl.h@ 101298

Last change on this file since 101298 was 101127, checked in by vboxsync, 17 months ago
curl-8.3.0: Applied and adjusted our curl changes to 8.0.1. bugref:10526
Property svn:eol-style set to `native`
File size: 126.0 KB

Line
1	#ifndef CURLINC_CURL_H
2	#define CURLINC_CURL_H
3	/***************************************************************************
4	* _ _ ____ _
5	* Project ___\| \| \| \| _ \\| \|
6	* / __\| \| \| \| \|_) \| \|
7	* \| (__\| \|_\| \| _ <\| \|___
8	* \___\|\___/\|_\| \_\_____\|
9	*
10	* Copyright (C) Daniel Stenberg, <[email protected]>, 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.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	* SPDX-License-Identifier: curl
24	*
25	***************************************************************************/
26
27	/*
28	* If you have libcurl problems, all docs and details are found here:
29	* https://curl.se/libcurl/
30	*/
31
32	#ifdef CURL_NO_OLDIES
33	#define CURL_STRICTER
34	#endif
35
36	/* Compile-time deprecation macros. */
37	#if defined(__GNUC__) && \
38	((__GNUC__ > 12) \|\| ((__GNUC__ == 12) && (__GNUC_MINOR__ >= 1 ))) && \
39	!defined(__INTEL_COMPILER) && \
40	!defined(CURL_DISABLE_DEPRECATION) && !defined(BUILDING_LIBCURL)
41	#define CURL_DEPRECATED(version, message) \
42	__attribute__((deprecated("since " # version ". " message)))
43	#define CURL_IGNORE_DEPRECATION(statements) \
44	_Pragma("GCC diagnostic push") \
45	_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \
46	statements \
47	_Pragma("GCC diagnostic pop")
48	#else
49	#define CURL_DEPRECATED(version, message)
50	#define CURL_IGNORE_DEPRECATION(statements) statements
51	#endif
52
53	#include "curlver.h" /* libcurl version defines */
54	#include "system.h" /* determine things run-time */
55
56	/*
57	* Define CURL_WIN32 when build target is Win32 API
58	*/
59
60	#if (defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(WIN32)) && \
61	!defined(__SYMBIAN32__)
62	#define CURL_WIN32
63	#endif
64
65	#include <stdio.h>
66	#include <limits.h>
67
68	#if (defined(__FreeBSD__) && (__FreeBSD__ >= 2)) \|\| defined(__MidnightBSD__)
69	/* Needed for __FreeBSD_version or __MidnightBSD_version symbol definition */
70	#include <osreldate.h>
71	#endif
72
73	/* The include stuff here below is mainly for time_t! */
74	#include <sys/types.h>
75	#include <time.h>
76
77	#if defined(CURL_WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__)
78	#if !(defined(_WINSOCKAPI_) \|\| defined(_WINSOCK_H) \|\| \
79	defined(__LWIP_OPT_H__) \|\| defined(LWIP_HDR_OPT_H))
80	/* The check above prevents the winsock2 inclusion if winsock.h already was
81	included, since they can't co-exist without problems */
82	# ifdef VBOX
83	# include <iprt/win/winsock2.h>
84	# include <iprt/win/ws2tcpip.h>
85	# else
86	#include <winsock2.h>
87	#include <ws2tcpip.h>
88	# endif
89	#endif
90	#endif
91
92	/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish
93	libc5-based Linux systems. Only include it on systems that are known to
94	require it! */
95	#if defined(_AIX) \|\| defined(__NOVELL_LIBC__) \|\| defined(__NetBSD__) \|\| \
96	defined(__minix) \|\| defined(__SYMBIAN32__) \|\| defined(__INTEGRITY) \|\| \
97	defined(ANDROID) \|\| defined(__ANDROID__) \|\| defined(__OpenBSD__) \|\| \
98	defined(__CYGWIN__) \|\| defined(AMIGA) \|\| defined(__NuttX__) \|\| \
99	(defined(__FreeBSD_version) && (__FreeBSD_version < 800000)) \|\| \
100	(defined(__MidnightBSD_version) && (__MidnightBSD_version < 100000)) \|\| \
101	defined(__sun__) \|\| defined(__serenity__) \|\| defined(__vxworks__)
102	#include <sys/select.h>
103	#endif
104
105	#if !defined(CURL_WIN32) && !defined(_WIN32_WCE)
106	#include <sys/socket.h>
107	#endif
108
109	#if !defined(CURL_WIN32)
110	#include <sys/time.h>
111	#endif
112
113	/* Compatibility for non-Clang compilers */
114	#ifndef __has_declspec_attribute
115	# define __has_declspec_attribute(x) 0
116	#endif
117
118	#ifdef __cplusplus
119	extern "C" {
120	#endif
121
122	#if defined(BUILDING_LIBCURL) \|\| defined(CURL_STRICTER)
123	typedef struct Curl_easy CURL;
124	typedef struct Curl_share CURLSH;
125	#else
126	typedef void CURL;
127	typedef void CURLSH;
128	#endif
129
130	/*
131	* libcurl external API function linkage decorations.
132	*/
133
134	#ifdef CURL_STATICLIB
135	# define CURL_EXTERN
136	#elif defined(CURL_WIN32) \|\| defined(__SYMBIAN32__) \|\| \
137	(__has_declspec_attribute(dllexport) && \
138	__has_declspec_attribute(dllimport))
139	# if defined(BUILDING_LIBCURL)
140	# define CURL_EXTERN __declspec(dllexport)
141	# else
142	# define CURL_EXTERN __declspec(dllimport)
143	# endif
144	#elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS)
145	# define CURL_EXTERN CURL_EXTERN_SYMBOL
146	#else
147	# define CURL_EXTERN
148	#endif
149
150	#ifndef curl_socket_typedef
151	/* socket typedef */
152	#if defined(CURL_WIN32) && !defined(__LWIP_OPT_H__) && !defined(LWIP_HDR_OPT_H)
153	typedef SOCKET curl_socket_t;
154	#define CURL_SOCKET_BAD INVALID_SOCKET
155	#else
156	typedef int curl_socket_t;
157	#define CURL_SOCKET_BAD -1
158	#endif
159	#define curl_socket_typedef
160	#endif /* curl_socket_typedef */
161
162	/* enum for the different supported SSL backends */
163	typedef enum {
164	CURLSSLBACKEND_NONE = 0,
165	CURLSSLBACKEND_OPENSSL = 1,
166	CURLSSLBACKEND_GNUTLS = 2,
167	CURLSSLBACKEND_NSS = 3,
168	CURLSSLBACKEND_OBSOLETE4 = 4, /* Was QSOSSL. */
169	CURLSSLBACKEND_GSKIT CURL_DEPRECATED(8.3.0, "") = 5,
170	CURLSSLBACKEND_POLARSSL CURL_DEPRECATED(7.69.0, "") = 6,
171	CURLSSLBACKEND_WOLFSSL = 7,
172	CURLSSLBACKEND_SCHANNEL = 8,
173	CURLSSLBACKEND_SECURETRANSPORT = 9,
174	CURLSSLBACKEND_AXTLS CURL_DEPRECATED(7.61.0, "") = 10,
175	CURLSSLBACKEND_MBEDTLS = 11,
176	CURLSSLBACKEND_MESALINK CURL_DEPRECATED(7.82.0, "") = 12,
177	CURLSSLBACKEND_BEARSSL = 13,
178	CURLSSLBACKEND_RUSTLS = 14
179	} curl_sslbackend;
180
181	/* aliases for library clones and renames */
182	#define CURLSSLBACKEND_AWSLC CURLSSLBACKEND_OPENSSL
183	#define CURLSSLBACKEND_BORINGSSL CURLSSLBACKEND_OPENSSL
184	#define CURLSSLBACKEND_LIBRESSL CURLSSLBACKEND_OPENSSL
185
186	/* deprecated names: */
187	#define CURLSSLBACKEND_CYASSL CURLSSLBACKEND_WOLFSSL
188	#define CURLSSLBACKEND_DARWINSSL CURLSSLBACKEND_SECURETRANSPORT
189
190	struct curl_httppost {
191	struct curl_httppost next; / next entry in the list */
192	char name; / pointer to allocated name */
193	long namelength; /* length of name length */
194	char contents; / pointer to allocated data contents */
195	long contentslength; /* length of contents field, see also
196	CURL_HTTPPOST_LARGE */
197	char buffer; / pointer to allocated buffer contents */
198	long bufferlength; /* length of buffer field */
199	char contenttype; / Content-Type */
200	struct curl_slist contentheader; / list of extra headers for this form */
201	struct curl_httppost more; / if one field name has more than one
202	file, this link should link to following
203	files */
204	long flags; /* as defined below */
205
206	/* specified content is a file name */
207	#define CURL_HTTPPOST_FILENAME (1<<0)
208	/* specified content is a file name */
209	#define CURL_HTTPPOST_READFILE (1<<1)
210	/* name is only stored pointer do not free in formfree */
211	#define CURL_HTTPPOST_PTRNAME (1<<2)
212	/* contents is only stored pointer do not free in formfree */
213	#define CURL_HTTPPOST_PTRCONTENTS (1<<3)
214	/* upload file from buffer */
215	#define CURL_HTTPPOST_BUFFER (1<<4)
216	/* upload file from pointer contents */
217	#define CURL_HTTPPOST_PTRBUFFER (1<<5)
218	/* upload file contents by using the regular read callback to get the data and
219	pass the given pointer as custom pointer */
220	#define CURL_HTTPPOST_CALLBACK (1<<6)
221	/* use size in 'contentlen', added in 7.46.0 */
222	#define CURL_HTTPPOST_LARGE (1<<7)
223
224	char showfilename; / The file name to show. If not set, the
225	actual file name will be used (if this
226	is a file part) */
227	void userp; / custom pointer used for
228	HTTPPOST_CALLBACK posts */
229	curl_off_t contentlen; /* alternative length of contents
230	field. Used if CURL_HTTPPOST_LARGE is
231	set. Added in 7.46.0 */
232	};
233
234
235	/* This is a return code for the progress callback that, when returned, will
236	signal libcurl to continue executing the default progress function */
237	#define CURL_PROGRESSFUNC_CONTINUE 0x10000001
238
239	/* This is the CURLOPT_PROGRESSFUNCTION callback prototype. It is now
240	considered deprecated but was the only choice up until 7.31.0 */
241	typedef int (curl_progress_callback)(void clientp,
242	double dltotal,
243	double dlnow,
244	double ultotal,
245	double ulnow);
246
247	/* This is the CURLOPT_XFERINFOFUNCTION callback prototype. It was introduced
248	in 7.32.0, avoids the use of floating point numbers and provides more
249	detailed information. */
250	typedef int (curl_xferinfo_callback)(void clientp,
251	curl_off_t dltotal,
252	curl_off_t dlnow,
253	curl_off_t ultotal,
254	curl_off_t ulnow);
255
256	#ifndef CURL_MAX_READ_SIZE
257	/* The maximum receive buffer size configurable via CURLOPT_BUFFERSIZE. */
258	#define CURL_MAX_READ_SIZE (1010241024)
259	#endif
260
261	#ifndef CURL_MAX_WRITE_SIZE
262	/* Tests have proven that 20K is a very bad buffer size for uploads on
263	Windows, while 16K for some odd reason performed a lot better.
264	We do the ifndef check to allow this value to easier be changed at build
265	time for those who feel adventurous. The practical minimum is about
266	400 bytes since libcurl uses a buffer of this size as a scratch area
267	(unrelated to network send operations). */
268	#define CURL_MAX_WRITE_SIZE 16384
269	#endif
270
271	#ifndef CURL_MAX_HTTP_HEADER
272	/* The only reason to have a max limit for this is to avoid the risk of a bad
273	server feeding libcurl with a never-ending header that will cause reallocs
274	infinitely */
275	#define CURL_MAX_HTTP_HEADER (100*1024)
276	#endif
277
278	/* This is a magic return code for the write callback that, when returned,
279	will signal libcurl to pause receiving on the current transfer. */
280	#define CURL_WRITEFUNC_PAUSE 0x10000001
281
282	/* This is a magic return code for the write callback that, when returned,
283	will signal an error from the callback. */
284	#define CURL_WRITEFUNC_ERROR 0xFFFFFFFF
285
286	typedef size_t (curl_write_callback)(char buffer,
287	size_t size,
288	size_t nitems,
289	void *outstream);
290
291	/* This callback will be called when a new resolver request is made */
292	typedef int (curl_resolver_start_callback)(void resolver_state,
293	void reserved, void userdata);
294
295	/* enumeration of file types */
296	typedef enum {
297	CURLFILETYPE_FILE = 0,
298	CURLFILETYPE_DIRECTORY,
299	CURLFILETYPE_SYMLINK,
300	CURLFILETYPE_DEVICE_BLOCK,
301	CURLFILETYPE_DEVICE_CHAR,
302	CURLFILETYPE_NAMEDPIPE,
303	CURLFILETYPE_SOCKET,
304	CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */
305
306	CURLFILETYPE_UNKNOWN /* should never occur */
307	} curlfiletype;
308
309	#define CURLFINFOFLAG_KNOWN_FILENAME (1<<0)
310	#define CURLFINFOFLAG_KNOWN_FILETYPE (1<<1)
311	#define CURLFINFOFLAG_KNOWN_TIME (1<<2)
312	#define CURLFINFOFLAG_KNOWN_PERM (1<<3)
313	#define CURLFINFOFLAG_KNOWN_UID (1<<4)
314	#define CURLFINFOFLAG_KNOWN_GID (1<<5)
315	#define CURLFINFOFLAG_KNOWN_SIZE (1<<6)
316	#define CURLFINFOFLAG_KNOWN_HLINKCOUNT (1<<7)
317
318	/* Information about a single file, used when doing FTP wildcard matching */
319	struct curl_fileinfo {
320	char *filename;
321	curlfiletype filetype;
322	time_t time; /* always zero! */
323	unsigned int perm;
324	int uid;
325	int gid;
326	curl_off_t size;
327	long int hardlinks;
328
329	struct {
330	/* If some of these fields is not NULL, it is a pointer to b_data. */
331	char *time;
332	char *perm;
333	char *user;
334	char *group;
335	char target; / pointer to the target filename of a symlink */
336	} strings;
337
338	unsigned int flags;
339
340	/* These are libcurl private struct fields. Previously used by libcurl, so
341	they must never be interfered with. */
342	char *b_data;
343	size_t b_size;
344	size_t b_used;
345	};
346
347	/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */
348	#define CURL_CHUNK_BGN_FUNC_OK 0
349	#define CURL_CHUNK_BGN_FUNC_FAIL 1 /* tell the lib to end the task */
350	#define CURL_CHUNK_BGN_FUNC_SKIP 2 /* skip this chunk over */
351
352	/* if splitting of data transfer is enabled, this callback is called before
353	download of an individual chunk started. Note that parameter "remains" works
354	only for FTP wildcard downloading (for now), otherwise is not used */
355	typedef long (curl_chunk_bgn_callback)(const void transfer_info,
356	void *ptr,
357	int remains);
358
359	/* return codes for CURLOPT_CHUNK_END_FUNCTION */
360	#define CURL_CHUNK_END_FUNC_OK 0
361	#define CURL_CHUNK_END_FUNC_FAIL 1 /* tell the lib to end the task */
362
363	/* If splitting of data transfer is enabled this callback is called after
364	download of an individual chunk finished.
365	Note! After this callback was set then it have to be called FOR ALL chunks.
366	Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC.
367	This is the reason why we don't need "transfer_info" parameter in this
368	callback and we are not interested in "remains" parameter too. */
369	typedef long (curl_chunk_end_callback)(void ptr);
370
371	/* return codes for FNMATCHFUNCTION */
372	#define CURL_FNMATCHFUNC_MATCH 0 /* string corresponds to the pattern */
373	#define CURL_FNMATCHFUNC_NOMATCH 1 /* pattern doesn't match the string */
374	#define CURL_FNMATCHFUNC_FAIL 2 /* an error occurred */
375
376	/* callback type for wildcard downloading pattern matching. If the
377	string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */
378	typedef int (curl_fnmatch_callback)(void ptr,
379	const char *pattern,
380	const char *string);
381
382	/* These are the return codes for the seek callbacks */
383	#define CURL_SEEKFUNC_OK 0
384	#define CURL_SEEKFUNC_FAIL 1 /* fail the entire transfer */
385	#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so
386	libcurl might try other means instead */
387	typedef int (curl_seek_callback)(void instream,
388	curl_off_t offset,
389	int origin); /* 'whence' */
390
391	/* This is a return code for the read callback that, when returned, will
392	signal libcurl to immediately abort the current transfer. */
393	#define CURL_READFUNC_ABORT 0x10000000
394	/* This is a return code for the read callback that, when returned, will
395	signal libcurl to pause sending data on the current transfer. */
396	#define CURL_READFUNC_PAUSE 0x10000001
397
398	/* Return code for when the trailing headers' callback has terminated
399	without any errors */
400	#define CURL_TRAILERFUNC_OK 0
401	/* Return code for when was an error in the trailing header's list and we
402	want to abort the request */
403	#define CURL_TRAILERFUNC_ABORT 1
404
405	typedef size_t (curl_read_callback)(char buffer,
406	size_t size,
407	size_t nitems,
408	void *instream);
409
410	typedef int (curl_trailer_callback)(struct curl_slist *list,
411	void *userdata);
412
413	typedef enum {
414	CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */
415	CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */
416	CURLSOCKTYPE_LAST /* never use */
417	} curlsocktype;
418
419	/* The return code from the sockopt_callback can signal information back
420	to libcurl: */
421	#define CURL_SOCKOPT_OK 0
422	#define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return
423	CURLE_ABORTED_BY_CALLBACK */
424	#define CURL_SOCKOPT_ALREADY_CONNECTED 2
425
426	typedef int (curl_sockopt_callback)(void clientp,
427	curl_socket_t curlfd,
428	curlsocktype purpose);
429
430	struct curl_sockaddr {
431	int family;
432	int socktype;
433	int protocol;
434	unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it
435	turned really ugly and painful on the systems that
436	lack this type */
437	struct sockaddr addr;
438	};
439
440	typedef curl_socket_t
441	(curl_opensocket_callback)(void clientp,
442	curlsocktype purpose,
443	struct curl_sockaddr *address);
444
445	typedef int
446	(curl_closesocket_callback)(void clientp, curl_socket_t item);
447
448	typedef enum {
449	CURLIOE_OK, /* I/O operation successful */
450	CURLIOE_UNKNOWNCMD, /* command was unknown to callback */
451	CURLIOE_FAILRESTART, /* failed to restart the read */
452	CURLIOE_LAST /* never use */
453	} curlioerr;
454
455	typedef enum {
456	CURLIOCMD_NOP, /* no operation */
457	CURLIOCMD_RESTARTREAD, /* restart the read stream from start */
458	CURLIOCMD_LAST /* never use */
459	} curliocmd;
460
461	typedef curlioerr (curl_ioctl_callback)(CURL handle,
462	int cmd,
463	void *clientp);
464
465	#ifndef CURL_DID_MEMORY_FUNC_TYPEDEFS
466	/*
467	* The following typedef's are signatures of malloc, free, realloc, strdup and
468	* calloc respectively. Function pointers of these types can be passed to the
469	* curl_global_init_mem() function to set user defined memory management
470	* callback routines.
471	*/
472	typedef void (curl_malloc_callback)(size_t size);
473	typedef void (curl_free_callback)(void ptr);
474	typedef void (curl_realloc_callback)(void *ptr, size_t size);
475	typedef char (curl_strdup_callback)(const char *str);
476	typedef void (curl_calloc_callback)(size_t nmemb, size_t size);
477
478	#define CURL_DID_MEMORY_FUNC_TYPEDEFS
479	#endif
480
481	/* the kind of data that is passed to information_callback */
482	typedef enum {
483	CURLINFO_TEXT = 0,
484	CURLINFO_HEADER_IN, /* 1 */
485	CURLINFO_HEADER_OUT, /* 2 */
486	CURLINFO_DATA_IN, /* 3 */
487	CURLINFO_DATA_OUT, /* 4 */
488	CURLINFO_SSL_DATA_IN, /* 5 */
489	CURLINFO_SSL_DATA_OUT, /* 6 */
490	CURLINFO_END
491	} curl_infotype;
492
493	typedef int (*curl_debug_callback)
494	(CURL handle, / the handle/transfer this concerns */
495	curl_infotype type, /* what kind of data */
496	char data, / points to the data */
497	size_t size, /* size of the data pointed to */
498	void userptr); / whatever the user please */
499
500	/* This is the CURLOPT_PREREQFUNCTION callback prototype. */
501	typedef int (curl_prereq_callback)(void clientp,
502	char *conn_primary_ip,
503	char *conn_local_ip,
504	int conn_primary_port,
505	int conn_local_port);
506
507	/* Return code for when the pre-request callback has terminated without
508	any errors */
509	#define CURL_PREREQFUNC_OK 0
510	/* Return code for when the pre-request callback wants to abort the
511	request */
512	#define CURL_PREREQFUNC_ABORT 1
513
514	/* All possible error codes from all sorts of curl functions. Future versions
515	may return other values, stay prepared.
516
517	Always add new return codes last. Never EVER remove any. The return
518	codes must remain the same!
519	*/
520
521	typedef enum {
522	CURLE_OK = 0,
523	CURLE_UNSUPPORTED_PROTOCOL, /* 1 */
524	CURLE_FAILED_INIT, /* 2 */
525	CURLE_URL_MALFORMAT, /* 3 */
526	CURLE_NOT_BUILT_IN, /* 4 - [was obsoleted in August 2007 for
527	7.17.0, reused in April 2011 for 7.21.5] */
528	CURLE_COULDNT_RESOLVE_PROXY, /* 5 */
529	CURLE_COULDNT_RESOLVE_HOST, /* 6 */
530	CURLE_COULDNT_CONNECT, /* 7 */
531	CURLE_WEIRD_SERVER_REPLY, /* 8 */
532	CURLE_REMOTE_ACCESS_DENIED, /* 9 a service was denied by the server
533	due to lack of access - when login fails
534	this is not returned. */
535	CURLE_FTP_ACCEPT_FAILED, /* 10 - [was obsoleted in April 2006 for
536	7.15.4, reused in Dec 2011 for 7.24.0]*/
537	CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */
538	CURLE_FTP_ACCEPT_TIMEOUT, /* 12 - timeout occurred accepting server
539	[was obsoleted in August 2007 for 7.17.0,
540	reused in Dec 2011 for 7.24.0]*/
541	CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */
542	CURLE_FTP_WEIRD_227_FORMAT, /* 14 */
543	CURLE_FTP_CANT_GET_HOST, /* 15 */
544	CURLE_HTTP2, /* 16 - A problem in the http2 framing layer.
545	[was obsoleted in August 2007 for 7.17.0,
546	reused in July 2014 for 7.38.0] */
547	CURLE_FTP_COULDNT_SET_TYPE, /* 17 */
548	CURLE_PARTIAL_FILE, /* 18 */
549	CURLE_FTP_COULDNT_RETR_FILE, /* 19 */
550	CURLE_OBSOLETE20, /* 20 - NOT USED */
551	CURLE_QUOTE_ERROR, /* 21 - quote command failure */
552	CURLE_HTTP_RETURNED_ERROR, /* 22 */
553	CURLE_WRITE_ERROR, /* 23 */
554	CURLE_OBSOLETE24, /* 24 - NOT USED */
555	CURLE_UPLOAD_FAILED, /* 25 - failed upload "command" */
556	CURLE_READ_ERROR, /* 26 - couldn't open/read from file */
557	CURLE_OUT_OF_MEMORY, /* 27 */
558	CURLE_OPERATION_TIMEDOUT, /* 28 - the timeout time was reached */
559	CURLE_OBSOLETE29, /* 29 - NOT USED */
560	CURLE_FTP_PORT_FAILED, /* 30 - FTP PORT operation failed */
561	CURLE_FTP_COULDNT_USE_REST, /* 31 - the REST command failed */
562	CURLE_OBSOLETE32, /* 32 - NOT USED */
563	CURLE_RANGE_ERROR, /* 33 - RANGE "command" didn't work */
564	CURLE_HTTP_POST_ERROR, /* 34 */
565	CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */
566	CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */
567	CURLE_FILE_COULDNT_READ_FILE, /* 37 */
568	CURLE_LDAP_CANNOT_BIND, /* 38 */
569	CURLE_LDAP_SEARCH_FAILED, /* 39 */
570	CURLE_OBSOLETE40, /* 40 - NOT USED */
571	CURLE_FUNCTION_NOT_FOUND, /* 41 - NOT USED starting with 7.53.0 */
572	CURLE_ABORTED_BY_CALLBACK, /* 42 */
573	CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */
574	CURLE_OBSOLETE44, /* 44 - NOT USED */
575	CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */
576	CURLE_OBSOLETE46, /* 46 - NOT USED */
577	CURLE_TOO_MANY_REDIRECTS, /* 47 - catch endless re-direct loops */
578	CURLE_UNKNOWN_OPTION, /* 48 - User specified an unknown option */
579	CURLE_SETOPT_OPTION_SYNTAX, /* 49 - Malformed setopt option */
580	CURLE_OBSOLETE50, /* 50 - NOT USED */
581	CURLE_OBSOLETE51, /* 51 - NOT USED */
582	CURLE_GOT_NOTHING, /* 52 - when this is a specific error */
583	CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */
584	CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as
585	default */
586	CURLE_SEND_ERROR, /* 55 - failed sending network data */
587	CURLE_RECV_ERROR, /* 56 - failure in receiving network data */
588	CURLE_OBSOLETE57, /* 57 - NOT IN USE */
589	CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */
590	CURLE_SSL_CIPHER, /* 59 - couldn't use specified cipher */
591	CURLE_PEER_FAILED_VERIFICATION, /* 60 - peer's certificate or fingerprint
592	wasn't verified fine */
593	CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */
594	CURLE_OBSOLETE62, /* 62 - NOT IN USE since 7.82.0 */
595	CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */
596	CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */
597	CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind
598	that failed */
599	CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */
600	CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not
601	accepted and we failed to login */
602	CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */
603	CURLE_TFTP_PERM, /* 69 - permission problem on server */
604	CURLE_REMOTE_DISK_FULL, /* 70 - out of disk space on server */
605	CURLE_TFTP_ILLEGAL, /* 71 - Illegal TFTP operation */
606	CURLE_TFTP_UNKNOWNID, /* 72 - Unknown transfer ID */
607	CURLE_REMOTE_FILE_EXISTS, /* 73 - File already exists */
608	CURLE_TFTP_NOSUCHUSER, /* 74 - No such user */
609	CURLE_OBSOLETE75, /* 75 - NOT IN USE since 7.82.0 */
610	CURLE_OBSOLETE76, /* 76 - NOT IN USE since 7.82.0 */
611	CURLE_SSL_CACERT_BADFILE, /* 77 - could not load CACERT file, missing
612	or wrong format */
613	CURLE_REMOTE_FILE_NOT_FOUND, /* 78 - remote file not found */
614	CURLE_SSH, /* 79 - error from the SSH layer, somewhat
615	generic so the error message will be of
616	interest when this has happened */
617
618	CURLE_SSL_SHUTDOWN_FAILED, /* 80 - Failed to shut down the SSL
619	connection */
620	CURLE_AGAIN, /* 81 - socket is not ready for send/recv,
621	wait till it's ready and try again (Added
622	in 7.18.2) */
623	CURLE_SSL_CRL_BADFILE, /* 82 - could not load CRL file, missing or
624	wrong format (Added in 7.19.0) */
625	CURLE_SSL_ISSUER_ERROR, /* 83 - Issuer check failed. (Added in
626	7.19.0) */
627	CURLE_FTP_PRET_FAILED, /* 84 - a PRET command failed */
628	CURLE_RTSP_CSEQ_ERROR, /* 85 - mismatch of RTSP CSeq numbers */
629	CURLE_RTSP_SESSION_ERROR, /* 86 - mismatch of RTSP Session Ids */
630	CURLE_FTP_BAD_FILE_LIST, /* 87 - unable to parse FTP file list */
631	CURLE_CHUNK_FAILED, /* 88 - chunk callback reported error */
632	CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the
633	session will be queued */
634	CURLE_SSL_PINNEDPUBKEYNOTMATCH, /* 90 - specified pinned public key did not
635	match */
636	CURLE_SSL_INVALIDCERTSTATUS, /* 91 - invalid certificate status */
637	CURLE_HTTP2_STREAM, /* 92 - stream error in HTTP/2 framing layer
638	*/
639	CURLE_RECURSIVE_API_CALL, /* 93 - an api function was called from
640	inside a callback */
641	CURLE_AUTH_ERROR, /* 94 - an authentication function returned an
642	error */
643	CURLE_HTTP3, /* 95 - An HTTP/3 layer problem */
644	CURLE_QUIC_CONNECT_ERROR, /* 96 - QUIC connection error */
645	CURLE_PROXY, /* 97 - proxy handshake error */
646	CURLE_SSL_CLIENTCERT, /* 98 - client-side certificate required */
647	CURLE_UNRECOVERABLE_POLL, /* 99 - poll/select returned fatal error */
648	CURL_LAST /* never use! */
649	} CURLcode;
650
651	#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
652	the obsolete stuff removed! */
653
654	/* Previously obsolete error code re-used in 7.38.0 */
655	#define CURLE_OBSOLETE16 CURLE_HTTP2
656
657	/* Previously obsolete error codes re-used in 7.24.0 */
658	#define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED
659	#define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT
660
661	/* compatibility with older names */
662	#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING
663	#define CURLE_FTP_WEIRD_SERVER_REPLY CURLE_WEIRD_SERVER_REPLY
664
665	/* The following were added in 7.62.0 */
666	#define CURLE_SSL_CACERT CURLE_PEER_FAILED_VERIFICATION
667
668	/* The following were added in 7.21.5, April 2011 */
669	#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION
670
671	/* Added for 7.78.0 */
672	#define CURLE_TELNET_OPTION_SYNTAX CURLE_SETOPT_OPTION_SYNTAX
673
674	/* The following were added in 7.17.1 */
675	/* These are scheduled to disappear by 2009 */
676	#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION
677
678	/* The following were added in 7.17.0 */
679	/* These are scheduled to disappear by 2009 */
680	#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */
681	#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46
682	#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44
683	#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10
684	#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16
685	#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32
686	#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29
687	#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12
688	#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20
689	#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40
690	#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24
691	#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57
692	#define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN
693
694	#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED
695	#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE
696	#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR
697	#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL
698	#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS
699	#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR
700	#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED
701
702	/* The following were added earlier */
703
704	#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT
705	#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR
706	#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED
707	#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED
708	#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE
709	#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME
710	#define CURLE_LDAP_INVALID_URL CURLE_OBSOLETE62
711	#define CURLE_CONV_REQD CURLE_OBSOLETE76
712	#define CURLE_CONV_FAILED CURLE_OBSOLETE75
713
714	/* This was the error code 50 in 7.7.3 and a few earlier versions, this
715	is no longer used by libcurl but is instead #defined here only to not
716	make programs break */
717	#define CURLE_ALREADY_COMPLETE 99999
718
719	/* Provide defines for really old option names */
720	#define CURLOPT_FILE CURLOPT_WRITEDATA /* name changed in 7.9.7 */
721	#define CURLOPT_INFILE CURLOPT_READDATA /* name changed in 7.9.7 */
722	#define CURLOPT_WRITEHEADER CURLOPT_HEADERDATA
723
724	/* Since long deprecated options with no code in the lib that does anything
725	with them. */
726	#define CURLOPT_WRITEINFO CURLOPT_OBSOLETE40
727	#define CURLOPT_CLOSEPOLICY CURLOPT_OBSOLETE72
728
729	#endif /* !CURL_NO_OLDIES */
730
731	/*
732	* Proxy error codes. Returned in CURLINFO_PROXY_ERROR if CURLE_PROXY was
733	* return for the transfers.
734	*/
735	typedef enum {
736	CURLPX_OK,
737	CURLPX_BAD_ADDRESS_TYPE,
738	CURLPX_BAD_VERSION,
739	CURLPX_CLOSED,
740	CURLPX_GSSAPI,
741	CURLPX_GSSAPI_PERMSG,
742	CURLPX_GSSAPI_PROTECTION,
743	CURLPX_IDENTD,
744	CURLPX_IDENTD_DIFFER,
745	CURLPX_LONG_HOSTNAME,
746	CURLPX_LONG_PASSWD,
747	CURLPX_LONG_USER,
748	CURLPX_NO_AUTH,
749	CURLPX_RECV_ADDRESS,
750	CURLPX_RECV_AUTH,
751	CURLPX_RECV_CONNECT,
752	CURLPX_RECV_REQACK,
753	CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED,
754	CURLPX_REPLY_COMMAND_NOT_SUPPORTED,
755	CURLPX_REPLY_CONNECTION_REFUSED,
756	CURLPX_REPLY_GENERAL_SERVER_FAILURE,
757	CURLPX_REPLY_HOST_UNREACHABLE,
758	CURLPX_REPLY_NETWORK_UNREACHABLE,
759	CURLPX_REPLY_NOT_ALLOWED,
760	CURLPX_REPLY_TTL_EXPIRED,
761	CURLPX_REPLY_UNASSIGNED,
762	CURLPX_REQUEST_FAILED,
763	CURLPX_RESOLVE_HOST,
764	CURLPX_SEND_AUTH,
765	CURLPX_SEND_CONNECT,
766	CURLPX_SEND_REQUEST,
767	CURLPX_UNKNOWN_FAIL,
768	CURLPX_UNKNOWN_MODE,
769	CURLPX_USER_REJECTED,
770	CURLPX_LAST /* never use */
771	} CURLproxycode;
772
773	/* This prototype applies to all conversion callbacks */
774	typedef CURLcode (curl_conv_callback)(char buffer, size_t length);
775
776	typedef CURLcode (curl_ssl_ctx_callback)(CURL curl, /* easy handle */
777	void ssl_ctx, / actually an OpenSSL
778	or WolfSSL SSL_CTX,
779	or an mbedTLS
780	mbedtls_ssl_config */
781	void *userptr);
782
783	typedef enum {
784	CURLPROXY_HTTP = 0, /* added in 7.10, new in 7.19.4 default is to use
785	CONNECT HTTP/1.1 */
786	CURLPROXY_HTTP_1_0 = 1, /* added in 7.19.4, force to use CONNECT
787	HTTP/1.0 */
788	CURLPROXY_HTTPS = 2, /* HTTPS but stick to HTTP/1 added in 7.52.0 */
789	CURLPROXY_HTTPS2 = 3, /* HTTPS and attempt HTTP/2 added in 8.2.0 */
790	CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already
791	in 7.10 */
792	CURLPROXY_SOCKS5 = 5, /* added in 7.10 */
793	CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */
794	CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the
795	host name rather than the IP address. added
796	in 7.18.0 */
797	} curl_proxytype; /* this enum was added in 7.10 */
798
799	/*
800	* Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options:
801	*
802	* CURLAUTH_NONE - No HTTP authentication
803	* CURLAUTH_BASIC - HTTP Basic authentication (default)
804	* CURLAUTH_DIGEST - HTTP Digest authentication
805	* CURLAUTH_NEGOTIATE - HTTP Negotiate (SPNEGO) authentication
806	* CURLAUTH_GSSNEGOTIATE - Alias for CURLAUTH_NEGOTIATE (deprecated)
807	* CURLAUTH_NTLM - HTTP NTLM authentication
808	* CURLAUTH_DIGEST_IE - HTTP Digest authentication with IE flavour
809	* CURLAUTH_NTLM_WB - HTTP NTLM authentication delegated to winbind helper
810	* CURLAUTH_BEARER - HTTP Bearer token authentication
811	* CURLAUTH_ONLY - Use together with a single other type to force no
812	* authentication or just that single type
813	* CURLAUTH_ANY - All fine types set
814	* CURLAUTH_ANYSAFE - All fine types except Basic
815	*/
816
817	#define CURLAUTH_NONE ((unsigned long)0)
818	#define CURLAUTH_BASIC (((unsigned long)1)<<0)
819	#define CURLAUTH_DIGEST (((unsigned long)1)<<1)
820	#define CURLAUTH_NEGOTIATE (((unsigned long)1)<<2)
821	/* Deprecated since the advent of CURLAUTH_NEGOTIATE */
822	#define CURLAUTH_GSSNEGOTIATE CURLAUTH_NEGOTIATE
823	/* Used for CURLOPT_SOCKS5_AUTH to stay terminologically correct */
824	#define CURLAUTH_GSSAPI CURLAUTH_NEGOTIATE
825	#define CURLAUTH_NTLM (((unsigned long)1)<<3)
826	#define CURLAUTH_DIGEST_IE (((unsigned long)1)<<4)
827	#define CURLAUTH_NTLM_WB (((unsigned long)1)<<5)
828	#define CURLAUTH_BEARER (((unsigned long)1)<<6)
829	#define CURLAUTH_AWS_SIGV4 (((unsigned long)1)<<7)
830	#define CURLAUTH_ONLY (((unsigned long)1)<<31)
831	#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE)
832	#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC\|CURLAUTH_DIGEST_IE))
833
834	#define CURLSSH_AUTH_ANY ~0 /* all types supported by the server */
835	#define CURLSSH_AUTH_NONE 0 /* none allowed, silly but complete */
836	#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */
837	#define CURLSSH_AUTH_PASSWORD (1<<1) /* password */
838	#define CURLSSH_AUTH_HOST (1<<2) /* host key files */
839	#define CURLSSH_AUTH_KEYBOARD (1<<3) /* keyboard interactive */
840	#define CURLSSH_AUTH_AGENT (1<<4) /* agent (ssh-agent, pageant...) */
841	#define CURLSSH_AUTH_GSSAPI (1<<5) /* gssapi (kerberos, ...) */
842	#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY
843
844	#define CURLGSSAPI_DELEGATION_NONE 0 /* no delegation (default) */
845	#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */
846	#define CURLGSSAPI_DELEGATION_FLAG (1<<1) /* delegate always */
847
848	#define CURL_ERROR_SIZE 256
849
850	enum curl_khtype {
851	CURLKHTYPE_UNKNOWN,
852	CURLKHTYPE_RSA1,
853	CURLKHTYPE_RSA,
854	CURLKHTYPE_DSS,
855	CURLKHTYPE_ECDSA,
856	CURLKHTYPE_ED25519
857	};
858
859	struct curl_khkey {
860	const char key; / points to a null-terminated string encoded with base64
861	if len is zero, otherwise to the "raw" data */
862	size_t len;
863	enum curl_khtype keytype;
864	};
865
866	/* this is the set of return values expected from the curl_sshkeycallback
867	callback */
868	enum curl_khstat {
869	CURLKHSTAT_FINE_ADD_TO_FILE,
870	CURLKHSTAT_FINE,
871	CURLKHSTAT_REJECT, /* reject the connection, return an error */
872	CURLKHSTAT_DEFER, /* do not accept it, but we can't answer right now.
873	Causes a CURLE_PEER_FAILED_VERIFICATION error but the
874	connection will be left intact etc */
875	CURLKHSTAT_FINE_REPLACE, /* accept and replace the wrong key */
876	CURLKHSTAT_LAST /* not for use, only a marker for last-in-list */
877	};
878
879	/* this is the set of status codes pass in to the callback */
880	enum curl_khmatch {
881	CURLKHMATCH_OK, /* match */
882	CURLKHMATCH_MISMATCH, /* host found, key mismatch! */
883	CURLKHMATCH_MISSING, /* no matching host/key found */
884	CURLKHMATCH_LAST /* not for use, only a marker for last-in-list */
885	};
886
887	typedef int
888	(curl_sshkeycallback) (CURL easy, /* easy handle */
889	const struct curl_khkey knownkey, / known */
890	const struct curl_khkey foundkey, / found */
891	enum curl_khmatch, /* libcurl's view on the keys */
892	void clientp); / custom pointer passed with */
893	/* CURLOPT_SSH_KEYDATA */
894
895	typedef int
896	(curl_sshhostkeycallback) (void clientp,/* custom pointer passed */
897	/* with CURLOPT_SSH_HOSTKEYDATA */
898	int keytype, /* CURLKHTYPE */
899	const char key, / hostkey to check */
900	size_t keylen); /* length of the key */
901	/* return CURLE_OK to accept */
902	/* or something else to refuse */
903
904
905	/* parameter for the CURLOPT_USE_SSL option */
906	typedef enum {
907	CURLUSESSL_NONE, /* do not attempt to use SSL */
908	CURLUSESSL_TRY, /* try using SSL, proceed anyway otherwise */
909	CURLUSESSL_CONTROL, /* SSL for the control connection or fail */
910	CURLUSESSL_ALL, /* SSL for all communication or fail */
911	CURLUSESSL_LAST /* not an option, never use */
912	} curl_usessl;
913
914	/* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */
915
916	/* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the
917	name of improving interoperability with older servers. Some SSL libraries
918	have introduced work-arounds for this flaw but those work-arounds sometimes
919	make the SSL communication fail. To regain functionality with those broken
920	servers, a user can this way allow the vulnerability back. */
921	#define CURLSSLOPT_ALLOW_BEAST (1<<0)
922
923	/* - NO_REVOKE tells libcurl to disable certificate revocation checks for those
924	SSL backends where such behavior is present. */
925	#define CURLSSLOPT_NO_REVOKE (1<<1)
926
927	/* - NO_PARTIALCHAIN tells libcurl to NOT accept a partial certificate chain
928	if possible. The OpenSSL backend has this ability. */
929	#define CURLSSLOPT_NO_PARTIALCHAIN (1<<2)
930
931	/* - REVOKE_BEST_EFFORT tells libcurl to ignore certificate revocation offline
932	checks and ignore missing revocation list for those SSL backends where such
933	behavior is present. */
934	#define CURLSSLOPT_REVOKE_BEST_EFFORT (1<<3)
935
936	/* - CURLSSLOPT_NATIVE_CA tells libcurl to use standard certificate store of
937	operating system. Currently implemented under MS-Windows. */
938	#define CURLSSLOPT_NATIVE_CA (1<<4)
939
940	/* - CURLSSLOPT_AUTO_CLIENT_CERT tells libcurl to automatically locate and use
941	a client certificate for authentication. (Schannel) */
942	#define CURLSSLOPT_AUTO_CLIENT_CERT (1<<5)
943
944	/* The default connection attempt delay in milliseconds for happy eyeballs.
945	CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS.3 and happy-eyeballs-timeout-ms.d document
946	this value, keep them in sync. */
947	#define CURL_HET_DEFAULT 200L
948
949	/* The default connection upkeep interval in milliseconds. */
950	#define CURL_UPKEEP_INTERVAL_DEFAULT 60000L
951
952	#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
953	the obsolete stuff removed! */
954
955	/* Backwards compatibility with older names */
956	/* These are scheduled to disappear by 2009 */
957
958	#define CURLFTPSSL_NONE CURLUSESSL_NONE
959	#define CURLFTPSSL_TRY CURLUSESSL_TRY
960	#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL
961	#define CURLFTPSSL_ALL CURLUSESSL_ALL
962	#define CURLFTPSSL_LAST CURLUSESSL_LAST
963	#define curl_ftpssl curl_usessl
964	#endif /* !CURL_NO_OLDIES */
965
966	/* parameter for the CURLOPT_FTP_SSL_CCC option */
967	typedef enum {
968	CURLFTPSSL_CCC_NONE, /* do not send CCC */
969	CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */
970	CURLFTPSSL_CCC_ACTIVE, /* Initiate the shutdown */
971	CURLFTPSSL_CCC_LAST /* not an option, never use */
972	} curl_ftpccc;
973
974	/* parameter for the CURLOPT_FTPSSLAUTH option */
975	typedef enum {
976	CURLFTPAUTH_DEFAULT, /* let libcurl decide */
977	CURLFTPAUTH_SSL, /* use "AUTH SSL" */
978	CURLFTPAUTH_TLS, /* use "AUTH TLS" */
979	CURLFTPAUTH_LAST /* not an option, never use */
980	} curl_ftpauth;
981
982	/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */
983	typedef enum {
984	CURLFTP_CREATE_DIR_NONE, /* do NOT create missing dirs! */
985	CURLFTP_CREATE_DIR, /* (FTP/SFTP) if CWD fails, try MKD and then CWD
986	again if MKD succeeded, for SFTP this does
987	similar magic */
988	CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD
989	again even if MKD failed! */
990	CURLFTP_CREATE_DIR_LAST /* not an option, never use */
991	} curl_ftpcreatedir;
992
993	/* parameter for the CURLOPT_FTP_FILEMETHOD option */
994	typedef enum {
995	CURLFTPMETHOD_DEFAULT, /* let libcurl pick */
996	CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */
997	CURLFTPMETHOD_NOCWD, /* no CWD at all */
998	CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */
999	CURLFTPMETHOD_LAST /* not an option, never use */
1000	} curl_ftpmethod;
1001
1002	/* bitmask defines for CURLOPT_HEADEROPT */
1003	#define CURLHEADER_UNIFIED 0
1004	#define CURLHEADER_SEPARATE (1<<0)
1005
1006	/* CURLALTSVC_* are bits for the CURLOPT_ALTSVC_CTRL option */
1007	#define CURLALTSVC_READONLYFILE (1<<2)
1008	#define CURLALTSVC_H1 (1<<3)
1009	#define CURLALTSVC_H2 (1<<4)
1010	#define CURLALTSVC_H3 (1<<5)
1011
1012
1013	struct curl_hstsentry {
1014	char *name;
1015	size_t namelen;
1016	unsigned int includeSubDomains:1;
1017	char expire[18]; /* YYYYMMDD HH:MM:SS [null-terminated] */
1018	};
1019
1020	struct curl_index {
1021	size_t index; /* the provided entry's "index" or count */
1022	size_t total; /* total number of entries to save */
1023	};
1024
1025	typedef enum {
1026	CURLSTS_OK,
1027	CURLSTS_DONE,
1028	CURLSTS_FAIL
1029	} CURLSTScode;
1030
1031	typedef CURLSTScode (curl_hstsread_callback)(CURL easy,
1032	struct curl_hstsentry *e,
1033	void *userp);
1034	typedef CURLSTScode (curl_hstswrite_callback)(CURL easy,
1035	struct curl_hstsentry *e,
1036	struct curl_index *i,
1037	void *userp);
1038
1039	/* CURLHSTS_* are bits for the CURLOPT_HSTS option */
1040	#define CURLHSTS_ENABLE (long)(1<<0)
1041	#define CURLHSTS_READONLYFILE (long)(1<<1)
1042
1043	/* The CURLPROTO_ defines below are for the deprecated CURLOPT_*PROTOCOLS
1044	options. Do not use. */
1045	#define CURLPROTO_HTTP (1<<0)
1046	#define CURLPROTO_HTTPS (1<<1)
1047	#define CURLPROTO_FTP (1<<2)
1048	#define CURLPROTO_FTPS (1<<3)
1049	#define CURLPROTO_SCP (1<<4)
1050	#define CURLPROTO_SFTP (1<<5)
1051	#define CURLPROTO_TELNET (1<<6)
1052	#define CURLPROTO_LDAP (1<<7)
1053	#define CURLPROTO_LDAPS (1<<8)
1054	#define CURLPROTO_DICT (1<<9)
1055	#define CURLPROTO_FILE (1<<10)
1056	#define CURLPROTO_TFTP (1<<11)
1057	#define CURLPROTO_IMAP (1<<12)
1058	#define CURLPROTO_IMAPS (1<<13)
1059	#define CURLPROTO_POP3 (1<<14)
1060	#define CURLPROTO_POP3S (1<<15)
1061	#define CURLPROTO_SMTP (1<<16)
1062	#define CURLPROTO_SMTPS (1<<17)
1063	#define CURLPROTO_RTSP (1<<18)
1064	#define CURLPROTO_RTMP (1<<19)
1065	#define CURLPROTO_RTMPT (1<<20)
1066	#define CURLPROTO_RTMPE (1<<21)
1067	#define CURLPROTO_RTMPTE (1<<22)
1068	#define CURLPROTO_RTMPS (1<<23)
1069	#define CURLPROTO_RTMPTS (1<<24)
1070	#define CURLPROTO_GOPHER (1<<25)
1071	#define CURLPROTO_SMB (1<<26)
1072	#define CURLPROTO_SMBS (1<<27)
1073	#define CURLPROTO_MQTT (1<<28)
1074	#define CURLPROTO_GOPHERS (1<<29)
1075	#define CURLPROTO_ALL (~0) /* enable everything */
1076
1077	/* long may be 32 or 64 bits, but we should never depend on anything else
1078	but 32 */
1079	#define CURLOPTTYPE_LONG 0
1080	#define CURLOPTTYPE_OBJECTPOINT 10000
1081	#define CURLOPTTYPE_FUNCTIONPOINT 20000
1082	#define CURLOPTTYPE_OFF_T 30000
1083	#define CURLOPTTYPE_BLOB 40000
1084
1085	/* *STRINGPOINT is an alias for OBJECTPOINT to allow tools to extract the
1086	string options from the header file */
1087
1088
1089	#define CURLOPT(na,t,nu) na = t + nu
1090	#define CURLOPTDEPRECATED(na,t,nu,v,m) na CURL_DEPRECATED(v,m) = t + nu
1091
1092	/* CURLOPT aliases that make no run-time difference */
1093
1094	/* 'char ' argument to a string with a trailing zero /
1095	#define CURLOPTTYPE_STRINGPOINT CURLOPTTYPE_OBJECTPOINT
1096
1097	/* 'struct curl_slist ' argument /
1098	#define CURLOPTTYPE_SLISTPOINT CURLOPTTYPE_OBJECTPOINT
1099
1100	/* 'void ' argument passed untouched to callback /
1101	#define CURLOPTTYPE_CBPOINT CURLOPTTYPE_OBJECTPOINT
1102
1103	/* 'long' argument with a set of values/bitmask */
1104	#define CURLOPTTYPE_VALUES CURLOPTTYPE_LONG
1105
1106	/*
1107	* All CURLOPT_* values.
1108	*/
1109
1110	typedef enum {
1111	/* This is the FILE * or void * the regular output should be written to. */
1112	CURLOPT(CURLOPT_WRITEDATA, CURLOPTTYPE_CBPOINT, 1),
1113
1114	/* The full URL to get/put */
1115	CURLOPT(CURLOPT_URL, CURLOPTTYPE_STRINGPOINT, 2),
1116
1117	/* Port number to connect to, if other than default. */
1118	CURLOPT(CURLOPT_PORT, CURLOPTTYPE_LONG, 3),
1119
1120	/* Name of proxy to use. */
1121	CURLOPT(CURLOPT_PROXY, CURLOPTTYPE_STRINGPOINT, 4),
1122
1123	/* "user:password;options" to use when fetching. */
1124	CURLOPT(CURLOPT_USERPWD, CURLOPTTYPE_STRINGPOINT, 5),
1125
1126	/* "user:password" to use with proxy. */
1127	CURLOPT(CURLOPT_PROXYUSERPWD, CURLOPTTYPE_STRINGPOINT, 6),
1128
1129	/* Range to get, specified as an ASCII string. */
1130	CURLOPT(CURLOPT_RANGE, CURLOPTTYPE_STRINGPOINT, 7),
1131
1132	/* not used */
1133
1134	/* Specified file stream to upload from (use as input): */
1135	CURLOPT(CURLOPT_READDATA, CURLOPTTYPE_CBPOINT, 9),
1136
1137	/* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE
1138	* bytes big. */
1139	CURLOPT(CURLOPT_ERRORBUFFER, CURLOPTTYPE_OBJECTPOINT, 10),
1140
1141	/* Function that will be called to store the output (instead of fwrite). The
1142	* parameters will use fwrite() syntax, make sure to follow them. */
1143	CURLOPT(CURLOPT_WRITEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 11),
1144
1145	/* Function that will be called to read the input (instead of fread). The
1146	* parameters will use fread() syntax, make sure to follow them. */
1147	CURLOPT(CURLOPT_READFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 12),
1148
1149	/* Time-out the read operation after this amount of seconds */
1150	CURLOPT(CURLOPT_TIMEOUT, CURLOPTTYPE_LONG, 13),
1151
1152	/* If CURLOPT_READDATA is used, this can be used to inform libcurl about
1153	* how large the file being sent really is. That allows better error
1154	* checking and better verifies that the upload was successful. -1 means
1155	* unknown size.
1156	*
1157	* For large file support, there is also a _LARGE version of the key
1158	* which takes an off_t type, allowing platforms with larger off_t
1159	* sizes to handle larger files. See below for INFILESIZE_LARGE.
1160	*/
1161	CURLOPT(CURLOPT_INFILESIZE, CURLOPTTYPE_LONG, 14),
1162
1163	/* POST static input fields. */
1164	CURLOPT(CURLOPT_POSTFIELDS, CURLOPTTYPE_OBJECTPOINT, 15),
1165
1166	/* Set the referrer page (needed by some CGIs) */
1167	CURLOPT(CURLOPT_REFERER, CURLOPTTYPE_STRINGPOINT, 16),
1168
1169	/* Set the FTP PORT string (interface name, named or numerical IP address)
1170	Use i.e '-' to use default address. */
1171	CURLOPT(CURLOPT_FTPPORT, CURLOPTTYPE_STRINGPOINT, 17),
1172
1173	/* Set the User-Agent string (examined by some CGIs) */
1174	CURLOPT(CURLOPT_USERAGENT, CURLOPTTYPE_STRINGPOINT, 18),
1175
1176	/* If the download receives less than "low speed limit" bytes/second
1177	* during "low speed time" seconds, the operations is aborted.
1178	* You could i.e if you have a pretty high speed connection, abort if
1179	* it is less than 2000 bytes/sec during 20 seconds.
1180	*/
1181
1182	/* Set the "low speed limit" */
1183	CURLOPT(CURLOPT_LOW_SPEED_LIMIT, CURLOPTTYPE_LONG, 19),
1184
1185	/* Set the "low speed time" */
1186	CURLOPT(CURLOPT_LOW_SPEED_TIME, CURLOPTTYPE_LONG, 20),
1187
1188	/* Set the continuation offset.
1189	*
1190	* Note there is also a _LARGE version of this key which uses
1191	* off_t types, allowing for large file offsets on platforms which
1192	* use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE.
1193	*/
1194	CURLOPT(CURLOPT_RESUME_FROM, CURLOPTTYPE_LONG, 21),
1195
1196	/* Set cookie in request: */
1197	CURLOPT(CURLOPT_COOKIE, CURLOPTTYPE_STRINGPOINT, 22),
1198
1199	/* This points to a linked list of headers, struct curl_slist kind. This
1200	list is also used for RTSP (in spite of its name) */
1201	CURLOPT(CURLOPT_HTTPHEADER, CURLOPTTYPE_SLISTPOINT, 23),
1202
1203	/* This points to a linked list of post entries, struct curl_httppost */
1204	CURLOPTDEPRECATED(CURLOPT_HTTPPOST, CURLOPTTYPE_OBJECTPOINT, 24,
1205	7.56.0, "Use CURLOPT_MIMEPOST"),
1206
1207	/* name of the file keeping your private SSL-certificate */
1208	CURLOPT(CURLOPT_SSLCERT, CURLOPTTYPE_STRINGPOINT, 25),
1209
1210	/* password for the SSL or SSH private key */
1211	CURLOPT(CURLOPT_KEYPASSWD, CURLOPTTYPE_STRINGPOINT, 26),
1212
1213	/* send TYPE parameter? */
1214	CURLOPT(CURLOPT_CRLF, CURLOPTTYPE_LONG, 27),
1215
1216	/* send linked-list of QUOTE commands */
1217	CURLOPT(CURLOPT_QUOTE, CURLOPTTYPE_SLISTPOINT, 28),
1218
1219	/* send FILE * or void * to store headers to, if you use a callback it
1220	is simply passed to the callback unmodified */
1221	CURLOPT(CURLOPT_HEADERDATA, CURLOPTTYPE_CBPOINT, 29),
1222
1223	/* point to a file to read the initial cookies from, also enables
1224	"cookie awareness" */
1225	CURLOPT(CURLOPT_COOKIEFILE, CURLOPTTYPE_STRINGPOINT, 31),
1226
1227	/* What version to specifically try to use.
1228	See CURL_SSLVERSION defines below. */
1229	CURLOPT(CURLOPT_SSLVERSION, CURLOPTTYPE_VALUES, 32),
1230
1231	/* What kind of HTTP time condition to use, see defines */
1232	CURLOPT(CURLOPT_TIMECONDITION, CURLOPTTYPE_VALUES, 33),
1233
1234	/* Time to use with the above condition. Specified in number of seconds
1235	since 1 Jan 1970 */
1236	CURLOPT(CURLOPT_TIMEVALUE, CURLOPTTYPE_LONG, 34),
1237
1238	/* 35 = OBSOLETE */
1239
1240	/* Custom request, for customizing the get command like
1241	HTTP: DELETE, TRACE and others
1242	FTP: to use a different list command
1243	*/
1244	CURLOPT(CURLOPT_CUSTOMREQUEST, CURLOPTTYPE_STRINGPOINT, 36),
1245
1246	/* FILE handle to use instead of stderr */
1247	CURLOPT(CURLOPT_STDERR, CURLOPTTYPE_OBJECTPOINT, 37),
1248
1249	/* 38 is not used */
1250
1251	/* send linked-list of post-transfer QUOTE commands */
1252	CURLOPT(CURLOPT_POSTQUOTE, CURLOPTTYPE_SLISTPOINT, 39),
1253
1254	/* OBSOLETE, do not use! */
1255	CURLOPT(CURLOPT_OBSOLETE40, CURLOPTTYPE_OBJECTPOINT, 40),
1256
1257	/* talk a lot */
1258	CURLOPT(CURLOPT_VERBOSE, CURLOPTTYPE_LONG, 41),
1259
1260	/* throw the header out too */
1261	CURLOPT(CURLOPT_HEADER, CURLOPTTYPE_LONG, 42),
1262
1263	/* shut off the progress meter */
1264	CURLOPT(CURLOPT_NOPROGRESS, CURLOPTTYPE_LONG, 43),
1265
1266	/* use HEAD to get http document */
1267	CURLOPT(CURLOPT_NOBODY, CURLOPTTYPE_LONG, 44),
1268
1269	/* no output on http error codes >= 400 */
1270	CURLOPT(CURLOPT_FAILONERROR, CURLOPTTYPE_LONG, 45),
1271
1272	/* this is an upload */
1273	CURLOPT(CURLOPT_UPLOAD, CURLOPTTYPE_LONG, 46),
1274
1275	/* HTTP POST method */
1276	CURLOPT(CURLOPT_POST, CURLOPTTYPE_LONG, 47),
1277
1278	/* bare names when listing directories */
1279	CURLOPT(CURLOPT_DIRLISTONLY, CURLOPTTYPE_LONG, 48),
1280
1281	/* Append instead of overwrite on upload! */
1282	CURLOPT(CURLOPT_APPEND, CURLOPTTYPE_LONG, 50),
1283
1284	/* Specify whether to read the user+password from the .netrc or the URL.
1285	* This must be one of the CURL_NETRC_* enums below. */
1286	CURLOPT(CURLOPT_NETRC, CURLOPTTYPE_VALUES, 51),
1287
1288	/* use Location: Luke! */
1289	CURLOPT(CURLOPT_FOLLOWLOCATION, CURLOPTTYPE_LONG, 52),
1290
1291	/* transfer data in text/ASCII format */
1292	CURLOPT(CURLOPT_TRANSFERTEXT, CURLOPTTYPE_LONG, 53),
1293
1294	/* HTTP PUT */
1295	CURLOPTDEPRECATED(CURLOPT_PUT, CURLOPTTYPE_LONG, 54,
1296	7.12.1, "Use CURLOPT_UPLOAD"),
1297
1298	/* 55 = OBSOLETE */
1299
1300	/* DEPRECATED
1301	* Function that will be called instead of the internal progress display
1302	* function. This function should be defined as the curl_progress_callback
1303	* prototype defines. */
1304	CURLOPTDEPRECATED(CURLOPT_PROGRESSFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 56,
1305	7.32.0, "Use CURLOPT_XFERINFOFUNCTION"),
1306
1307	/* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION
1308	callbacks */
1309	CURLOPT(CURLOPT_XFERINFODATA, CURLOPTTYPE_CBPOINT, 57),
1310	#define CURLOPT_PROGRESSDATA CURLOPT_XFERINFODATA
1311
1312	/* We want the referrer field set automatically when following locations */
1313	CURLOPT(CURLOPT_AUTOREFERER, CURLOPTTYPE_LONG, 58),
1314
1315	/* Port of the proxy, can be set in the proxy string as well with:
1316	"[host]:[port]" */
1317	CURLOPT(CURLOPT_PROXYPORT, CURLOPTTYPE_LONG, 59),
1318
1319	/* size of the POST input data, if strlen() is not good to use */
1320	CURLOPT(CURLOPT_POSTFIELDSIZE, CURLOPTTYPE_LONG, 60),
1321
1322	/* tunnel non-http operations through an HTTP proxy */
1323	CURLOPT(CURLOPT_HTTPPROXYTUNNEL, CURLOPTTYPE_LONG, 61),
1324
1325	/* Set the interface string to use as outgoing network interface */
1326	CURLOPT(CURLOPT_INTERFACE, CURLOPTTYPE_STRINGPOINT, 62),
1327
1328	/* Set the krb4/5 security level, this also enables krb4/5 awareness. This
1329	* is a string, 'clear', 'safe', 'confidential' or 'private'. If the string
1330	* is set but doesn't match one of these, 'private' will be used. */
1331	CURLOPT(CURLOPT_KRBLEVEL, CURLOPTTYPE_STRINGPOINT, 63),
1332
1333	/* Set if we should verify the peer in ssl handshake, set 1 to verify. */
1334	CURLOPT(CURLOPT_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 64),
1335
1336	/* The CApath or CAfile used to validate the peer certificate
1337	this option is used only if SSL_VERIFYPEER is true */
1338	CURLOPT(CURLOPT_CAINFO, CURLOPTTYPE_STRINGPOINT, 65),
1339
1340	/* 66 = OBSOLETE */
1341	/* 67 = OBSOLETE */
1342
1343	/* Maximum number of http redirects to follow */
1344	CURLOPT(CURLOPT_MAXREDIRS, CURLOPTTYPE_LONG, 68),
1345
1346	/* Pass a long set to 1 to get the date of the requested document (if
1347	possible)! Pass a zero to shut it off. */
1348	CURLOPT(CURLOPT_FILETIME, CURLOPTTYPE_LONG, 69),
1349
1350	/* This points to a linked list of telnet options */
1351	CURLOPT(CURLOPT_TELNETOPTIONS, CURLOPTTYPE_SLISTPOINT, 70),
1352
1353	/* Max amount of cached alive connections */
1354	CURLOPT(CURLOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 71),
1355
1356	/* OBSOLETE, do not use! */
1357	CURLOPT(CURLOPT_OBSOLETE72, CURLOPTTYPE_LONG, 72),
1358
1359	/* 73 = OBSOLETE */
1360
1361	/* Set to explicitly use a new connection for the upcoming transfer.
1362	Do not use this unless you're absolutely sure of this, as it makes the
1363	operation slower and is less friendly for the network. */
1364	CURLOPT(CURLOPT_FRESH_CONNECT, CURLOPTTYPE_LONG, 74),
1365
1366	/* Set to explicitly forbid the upcoming transfer's connection to be re-used
1367	when done. Do not use this unless you're absolutely sure of this, as it
1368	makes the operation slower and is less friendly for the network. */
1369	CURLOPT(CURLOPT_FORBID_REUSE, CURLOPTTYPE_LONG, 75),
1370
1371	/* Set to a file name that contains random data for libcurl to use to
1372	seed the random engine when doing SSL connects. */
1373	CURLOPTDEPRECATED(CURLOPT_RANDOM_FILE, CURLOPTTYPE_STRINGPOINT, 76,
1374	7.84.0, "Serves no purpose anymore"),
1375
1376	/* Set to the Entropy Gathering Daemon socket pathname */
1377	CURLOPTDEPRECATED(CURLOPT_EGDSOCKET, CURLOPTTYPE_STRINGPOINT, 77,
1378	7.84.0, "Serves no purpose anymore"),
1379
1380	/* Time-out connect operations after this amount of seconds, if connects are
1381	OK within this time, then fine... This only aborts the connect phase. */
1382	CURLOPT(CURLOPT_CONNECTTIMEOUT, CURLOPTTYPE_LONG, 78),
1383
1384	/* Function that will be called to store headers (instead of fwrite). The
1385	* parameters will use fwrite() syntax, make sure to follow them. */
1386	CURLOPT(CURLOPT_HEADERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 79),
1387
1388	/* Set this to force the HTTP request to get back to GET. Only really usable
1389	if POST, PUT or a custom request have been used first.
1390	*/
1391	CURLOPT(CURLOPT_HTTPGET, CURLOPTTYPE_LONG, 80),
1392
1393	/* Set if we should verify the Common name from the peer certificate in ssl
1394	* handshake, set 1 to check existence, 2 to ensure that it matches the
1395	* provided hostname. */
1396	CURLOPT(CURLOPT_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 81),
1397
1398	/* Specify which file name to write all known cookies in after completed
1399	operation. Set file name to "-" (dash) to make it go to stdout. */
1400	CURLOPT(CURLOPT_COOKIEJAR, CURLOPTTYPE_STRINGPOINT, 82),
1401
1402	/* Specify which SSL ciphers to use */
1403	CURLOPT(CURLOPT_SSL_CIPHER_LIST, CURLOPTTYPE_STRINGPOINT, 83),
1404
1405	/* Specify which HTTP version to use! This must be set to one of the
1406	CURL_HTTP_VERSION* enums set below. */
1407	CURLOPT(CURLOPT_HTTP_VERSION, CURLOPTTYPE_VALUES, 84),
1408
1409	/* Specifically switch on or off the FTP engine's use of the EPSV command. By
1410	default, that one will always be attempted before the more traditional
1411	PASV command. */
1412	CURLOPT(CURLOPT_FTP_USE_EPSV, CURLOPTTYPE_LONG, 85),
1413
1414	/* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */
1415	CURLOPT(CURLOPT_SSLCERTTYPE, CURLOPTTYPE_STRINGPOINT, 86),
1416
1417	/* name of the file keeping your private SSL-key */
1418	CURLOPT(CURLOPT_SSLKEY, CURLOPTTYPE_STRINGPOINT, 87),
1419
1420	/* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */
1421	CURLOPT(CURLOPT_SSLKEYTYPE, CURLOPTTYPE_STRINGPOINT, 88),
1422
1423	/* crypto engine for the SSL-sub system */
1424	CURLOPT(CURLOPT_SSLENGINE, CURLOPTTYPE_STRINGPOINT, 89),
1425
1426	/* set the crypto engine for the SSL-sub system as default
1427	the param has no meaning...
1428	*/
1429	CURLOPT(CURLOPT_SSLENGINE_DEFAULT, CURLOPTTYPE_LONG, 90),
1430
1431	/* Non-zero value means to use the global dns cache */
1432	/* DEPRECATED, do not use! */
1433	CURLOPTDEPRECATED(CURLOPT_DNS_USE_GLOBAL_CACHE, CURLOPTTYPE_LONG, 91,
1434	7.11.1, "Use CURLOPT_SHARE"),
1435
1436	/* DNS cache timeout */
1437	CURLOPT(CURLOPT_DNS_CACHE_TIMEOUT, CURLOPTTYPE_LONG, 92),
1438
1439	/* send linked-list of pre-transfer QUOTE commands */
1440	CURLOPT(CURLOPT_PREQUOTE, CURLOPTTYPE_SLISTPOINT, 93),
1441
1442	/* set the debug function */
1443	CURLOPT(CURLOPT_DEBUGFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 94),
1444
1445	/* set the data for the debug function */
1446	CURLOPT(CURLOPT_DEBUGDATA, CURLOPTTYPE_CBPOINT, 95),
1447
1448	/* mark this as start of a cookie session */
1449	CURLOPT(CURLOPT_COOKIESESSION, CURLOPTTYPE_LONG, 96),
1450
1451	/* The CApath directory used to validate the peer certificate
1452	this option is used only if SSL_VERIFYPEER is true */
1453	CURLOPT(CURLOPT_CAPATH, CURLOPTTYPE_STRINGPOINT, 97),
1454
1455	/* Instruct libcurl to use a smaller receive buffer */
1456	CURLOPT(CURLOPT_BUFFERSIZE, CURLOPTTYPE_LONG, 98),
1457
1458	/* Instruct libcurl to not use any signal/alarm handlers, even when using
1459	timeouts. This option is useful for multi-threaded applications.
1460	See libcurl-the-guide for more background information. */
1461	CURLOPT(CURLOPT_NOSIGNAL, CURLOPTTYPE_LONG, 99),
1462
1463	/* Provide a CURLShare for mutexing non-ts data */
1464	CURLOPT(CURLOPT_SHARE, CURLOPTTYPE_OBJECTPOINT, 100),
1465
1466	/* indicates type of proxy. accepted values are CURLPROXY_HTTP (default),
1467	CURLPROXY_HTTPS, CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and
1468	CURLPROXY_SOCKS5. */
1469	CURLOPT(CURLOPT_PROXYTYPE, CURLOPTTYPE_VALUES, 101),
1470
1471	/* Set the Accept-Encoding string. Use this to tell a server you would like
1472	the response to be compressed. Before 7.21.6, this was known as
1473	CURLOPT_ENCODING */
1474	CURLOPT(CURLOPT_ACCEPT_ENCODING, CURLOPTTYPE_STRINGPOINT, 102),
1475
1476	/* Set pointer to private data */
1477	CURLOPT(CURLOPT_PRIVATE, CURLOPTTYPE_OBJECTPOINT, 103),
1478
1479	/* Set aliases for HTTP 200 in the HTTP Response header */
1480	CURLOPT(CURLOPT_HTTP200ALIASES, CURLOPTTYPE_SLISTPOINT, 104),
1481
1482	/* Continue to send authentication (user+password) when following locations,
1483	even when hostname changed. This can potentially send off the name
1484	and password to whatever host the server decides. */
1485	CURLOPT(CURLOPT_UNRESTRICTED_AUTH, CURLOPTTYPE_LONG, 105),
1486
1487	/* Specifically switch on or off the FTP engine's use of the EPRT command (
1488	it also disables the LPRT attempt). By default, those ones will always be
1489	attempted before the good old traditional PORT command. */
1490	CURLOPT(CURLOPT_FTP_USE_EPRT, CURLOPTTYPE_LONG, 106),
1491
1492	/* Set this to a bitmask value to enable the particular authentications
1493	methods you like. Use this in combination with CURLOPT_USERPWD.
1494	Note that setting multiple bits may cause extra network round-trips. */
1495	CURLOPT(CURLOPT_HTTPAUTH, CURLOPTTYPE_VALUES, 107),
1496
1497	/* Set the ssl context callback function, currently only for OpenSSL or
1498	WolfSSL ssl_ctx, or mbedTLS mbedtls_ssl_config in the second argument.
1499	The function must match the curl_ssl_ctx_callback prototype. */
1500	CURLOPT(CURLOPT_SSL_CTX_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 108),
1501
1502	/* Set the userdata for the ssl context callback function's third
1503	argument */
1504	CURLOPT(CURLOPT_SSL_CTX_DATA, CURLOPTTYPE_CBPOINT, 109),
1505
1506	/* FTP Option that causes missing dirs to be created on the remote server.
1507	In 7.19.4 we introduced the convenience enums for this option using the
1508	CURLFTP_CREATE_DIR prefix.
1509	*/
1510	CURLOPT(CURLOPT_FTP_CREATE_MISSING_DIRS, CURLOPTTYPE_LONG, 110),
1511
1512	/* Set this to a bitmask value to enable the particular authentications
1513	methods you like. Use this in combination with CURLOPT_PROXYUSERPWD.
1514	Note that setting multiple bits may cause extra network round-trips. */
1515	CURLOPT(CURLOPT_PROXYAUTH, CURLOPTTYPE_VALUES, 111),
1516
1517	/* Option that changes the timeout, in seconds, associated with getting a
1518	response. This is different from transfer timeout time and essentially
1519	places a demand on the server to acknowledge commands in a timely
1520	manner. For FTP, SMTP, IMAP and POP3. */
1521	CURLOPT(CURLOPT_SERVER_RESPONSE_TIMEOUT, CURLOPTTYPE_LONG, 112),
1522
1523	/* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to
1524	tell libcurl to use those IP versions only. This only has effect on
1525	systems with support for more than one, i.e IPv4 _and_ IPv6. */
1526	CURLOPT(CURLOPT_IPRESOLVE, CURLOPTTYPE_VALUES, 113),
1527
1528	/* Set this option to limit the size of a file that will be downloaded from
1529	an HTTP or FTP server.
1530
1531	Note there is also _LARGE version which adds large file support for
1532	platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */
1533	CURLOPT(CURLOPT_MAXFILESIZE, CURLOPTTYPE_LONG, 114),
1534
1535	/* See the comment for INFILESIZE above, but in short, specifies
1536	* the size of the file being uploaded. -1 means unknown.
1537	*/
1538	CURLOPT(CURLOPT_INFILESIZE_LARGE, CURLOPTTYPE_OFF_T, 115),
1539
1540	/* Sets the continuation offset. There is also a CURLOPTTYPE_LONG version
1541	* of this; look above for RESUME_FROM.
1542	*/
1543	CURLOPT(CURLOPT_RESUME_FROM_LARGE, CURLOPTTYPE_OFF_T, 116),
1544
1545	/* Sets the maximum size of data that will be downloaded from
1546	* an HTTP or FTP server. See MAXFILESIZE above for the LONG version.
1547	*/
1548	CURLOPT(CURLOPT_MAXFILESIZE_LARGE, CURLOPTTYPE_OFF_T, 117),
1549
1550	/* Set this option to the file name of your .netrc file you want libcurl
1551	to parse (using the CURLOPT_NETRC option). If not set, libcurl will do
1552	a poor attempt to find the user's home directory and check for a .netrc
1553	file in there. */
1554	CURLOPT(CURLOPT_NETRC_FILE, CURLOPTTYPE_STRINGPOINT, 118),
1555
1556	/* Enable SSL/TLS for FTP, pick one of:
1557	CURLUSESSL_TRY - try using SSL, proceed anyway otherwise
1558	CURLUSESSL_CONTROL - SSL for the control connection or fail
1559	CURLUSESSL_ALL - SSL for all communication or fail
1560	*/
1561	CURLOPT(CURLOPT_USE_SSL, CURLOPTTYPE_VALUES, 119),
1562
1563	/* The _LARGE version of the standard POSTFIELDSIZE option */
1564	CURLOPT(CURLOPT_POSTFIELDSIZE_LARGE, CURLOPTTYPE_OFF_T, 120),
1565
1566	/* Enable/disable the TCP Nagle algorithm */
1567	CURLOPT(CURLOPT_TCP_NODELAY, CURLOPTTYPE_LONG, 121),
1568
1569	/* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
1570	/* 123 OBSOLETE. Gone in 7.16.0 */
1571	/* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
1572	/* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
1573	/* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
1574	/* 127 OBSOLETE. Gone in 7.16.0 */
1575	/* 128 OBSOLETE. Gone in 7.16.0 */
1576
1577	/* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option
1578	can be used to change libcurl's default action which is to first try
1579	"AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK
1580	response has been received.
1581
1582	Available parameters are:
1583	CURLFTPAUTH_DEFAULT - let libcurl decide
1584	CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS
1585	CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL
1586	*/
1587	CURLOPT(CURLOPT_FTPSSLAUTH, CURLOPTTYPE_VALUES, 129),
1588
1589	CURLOPTDEPRECATED(CURLOPT_IOCTLFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 130,
1590	7.18.0, "Use CURLOPT_SEEKFUNCTION"),
1591	CURLOPTDEPRECATED(CURLOPT_IOCTLDATA, CURLOPTTYPE_CBPOINT, 131,
1592	7.18.0, "Use CURLOPT_SEEKDATA"),
1593
1594	/* 132 OBSOLETE. Gone in 7.16.0 */
1595	/* 133 OBSOLETE. Gone in 7.16.0 */
1596
1597	/* null-terminated string for pass on to the FTP server when asked for
1598	"account" info */
1599	CURLOPT(CURLOPT_FTP_ACCOUNT, CURLOPTTYPE_STRINGPOINT, 134),
1600
1601	/* feed cookie into cookie engine */
1602	CURLOPT(CURLOPT_COOKIELIST, CURLOPTTYPE_STRINGPOINT, 135),
1603
1604	/* ignore Content-Length */
1605	CURLOPT(CURLOPT_IGNORE_CONTENT_LENGTH, CURLOPTTYPE_LONG, 136),
1606
1607	/* Set to non-zero to skip the IP address received in a 227 PASV FTP server
1608	response. Typically used for FTP-SSL purposes but is not restricted to
1609	that. libcurl will then instead use the same IP address it used for the
1610	control connection. */
1611	CURLOPT(CURLOPT_FTP_SKIP_PASV_IP, CURLOPTTYPE_LONG, 137),
1612
1613	/* Select "file method" to use when doing FTP, see the curl_ftpmethod
1614	above. */
1615	CURLOPT(CURLOPT_FTP_FILEMETHOD, CURLOPTTYPE_VALUES, 138),
1616
1617	/* Local port number to bind the socket to */
1618	CURLOPT(CURLOPT_LOCALPORT, CURLOPTTYPE_LONG, 139),
1619
1620	/* Number of ports to try, including the first one set with LOCALPORT.
1621	Thus, setting it to 1 will make no additional attempts but the first.
1622	*/
1623	CURLOPT(CURLOPT_LOCALPORTRANGE, CURLOPTTYPE_LONG, 140),
1624
1625	/* no transfer, set up connection and let application use the socket by
1626	extracting it with CURLINFO_LASTSOCKET */
1627	CURLOPT(CURLOPT_CONNECT_ONLY, CURLOPTTYPE_LONG, 141),
1628
1629	/* Function that will be called to convert from the
1630	network encoding (instead of using the iconv calls in libcurl) */
1631	CURLOPTDEPRECATED(CURLOPT_CONV_FROM_NETWORK_FUNCTION,
1632	CURLOPTTYPE_FUNCTIONPOINT, 142,
1633	7.82.0, "Serves no purpose anymore"),
1634
1635	/* Function that will be called to convert to the
1636	network encoding (instead of using the iconv calls in libcurl) */
1637	CURLOPTDEPRECATED(CURLOPT_CONV_TO_NETWORK_FUNCTION,
1638	CURLOPTTYPE_FUNCTIONPOINT, 143,
1639	7.82.0, "Serves no purpose anymore"),
1640
1641	/* Function that will be called to convert from UTF8
1642	(instead of using the iconv calls in libcurl)
1643	Note that this is used only for SSL certificate processing */
1644	CURLOPTDEPRECATED(CURLOPT_CONV_FROM_UTF8_FUNCTION,
1645	CURLOPTTYPE_FUNCTIONPOINT, 144,
1646	7.82.0, "Serves no purpose anymore"),
1647
1648	/* if the connection proceeds too quickly then need to slow it down */
1649	/* limit-rate: maximum number of bytes per second to send or receive */
1650	CURLOPT(CURLOPT_MAX_SEND_SPEED_LARGE, CURLOPTTYPE_OFF_T, 145),
1651	CURLOPT(CURLOPT_MAX_RECV_SPEED_LARGE, CURLOPTTYPE_OFF_T, 146),
1652
1653	/* Pointer to command string to send if USER/PASS fails. */
1654	CURLOPT(CURLOPT_FTP_ALTERNATIVE_TO_USER, CURLOPTTYPE_STRINGPOINT, 147),
1655
1656	/* callback function for setting socket options */
1657	CURLOPT(CURLOPT_SOCKOPTFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 148),
1658	CURLOPT(CURLOPT_SOCKOPTDATA, CURLOPTTYPE_CBPOINT, 149),
1659
1660	/* set to 0 to disable session ID re-use for this transfer, default is
1661	enabled (== 1) */
1662	CURLOPT(CURLOPT_SSL_SESSIONID_CACHE, CURLOPTTYPE_LONG, 150),
1663
1664	/* allowed SSH authentication methods */
1665	CURLOPT(CURLOPT_SSH_AUTH_TYPES, CURLOPTTYPE_VALUES, 151),
1666
1667	/* Used by scp/sftp to do public/private key authentication */
1668	CURLOPT(CURLOPT_SSH_PUBLIC_KEYFILE, CURLOPTTYPE_STRINGPOINT, 152),
1669	CURLOPT(CURLOPT_SSH_PRIVATE_KEYFILE, CURLOPTTYPE_STRINGPOINT, 153),
1670
1671	/* Send CCC (Clear Command Channel) after authentication */
1672	CURLOPT(CURLOPT_FTP_SSL_CCC, CURLOPTTYPE_LONG, 154),
1673
1674	/* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */
1675	CURLOPT(CURLOPT_TIMEOUT_MS, CURLOPTTYPE_LONG, 155),
1676	CURLOPT(CURLOPT_CONNECTTIMEOUT_MS, CURLOPTTYPE_LONG, 156),
1677
1678	/* set to zero to disable the libcurl's decoding and thus pass the raw body
1679	data to the application even when it is encoded/compressed */
1680	CURLOPT(CURLOPT_HTTP_TRANSFER_DECODING, CURLOPTTYPE_LONG, 157),
1681	CURLOPT(CURLOPT_HTTP_CONTENT_DECODING, CURLOPTTYPE_LONG, 158),
1682
1683	/* Permission used when creating new files and directories on the remote
1684	server for protocols that support it, SFTP/SCP/FILE */
1685	CURLOPT(CURLOPT_NEW_FILE_PERMS, CURLOPTTYPE_LONG, 159),
1686	CURLOPT(CURLOPT_NEW_DIRECTORY_PERMS, CURLOPTTYPE_LONG, 160),
1687
1688	/* Set the behavior of POST when redirecting. Values must be set to one
1689	of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */
1690	CURLOPT(CURLOPT_POSTREDIR, CURLOPTTYPE_VALUES, 161),
1691
1692	/* used by scp/sftp to verify the host's public key */
1693	CURLOPT(CURLOPT_SSH_HOST_PUBLIC_KEY_MD5, CURLOPTTYPE_STRINGPOINT, 162),
1694
1695	/* Callback function for opening socket (instead of socket(2)). Optionally,
1696	callback is able change the address or refuse to connect returning
1697	CURL_SOCKET_BAD. The callback should have type
1698	curl_opensocket_callback */
1699	CURLOPT(CURLOPT_OPENSOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 163),
1700	CURLOPT(CURLOPT_OPENSOCKETDATA, CURLOPTTYPE_CBPOINT, 164),
1701
1702	/* POST volatile input fields. */
1703	CURLOPT(CURLOPT_COPYPOSTFIELDS, CURLOPTTYPE_OBJECTPOINT, 165),
1704
1705	/* set transfer mode (;type=<a\|i>) when doing FTP via an HTTP proxy */
1706	CURLOPT(CURLOPT_PROXY_TRANSFER_MODE, CURLOPTTYPE_LONG, 166),
1707
1708	/* Callback function for seeking in the input stream */
1709	CURLOPT(CURLOPT_SEEKFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 167),
1710	CURLOPT(CURLOPT_SEEKDATA, CURLOPTTYPE_CBPOINT, 168),
1711
1712	/* CRL file */
1713	CURLOPT(CURLOPT_CRLFILE, CURLOPTTYPE_STRINGPOINT, 169),
1714
1715	/* Issuer certificate */
1716	CURLOPT(CURLOPT_ISSUERCERT, CURLOPTTYPE_STRINGPOINT, 170),
1717
1718	/* (IPv6) Address scope */
1719	CURLOPT(CURLOPT_ADDRESS_SCOPE, CURLOPTTYPE_LONG, 171),
1720
1721	/* Collect certificate chain info and allow it to get retrievable with
1722	CURLINFO_CERTINFO after the transfer is complete. */
1723	CURLOPT(CURLOPT_CERTINFO, CURLOPTTYPE_LONG, 172),
1724
1725	/* "name" and "pwd" to use when fetching. */
1726	CURLOPT(CURLOPT_USERNAME, CURLOPTTYPE_STRINGPOINT, 173),
1727	CURLOPT(CURLOPT_PASSWORD, CURLOPTTYPE_STRINGPOINT, 174),
1728
1729	/* "name" and "pwd" to use with Proxy when fetching. */
1730	CURLOPT(CURLOPT_PROXYUSERNAME, CURLOPTTYPE_STRINGPOINT, 175),
1731	CURLOPT(CURLOPT_PROXYPASSWORD, CURLOPTTYPE_STRINGPOINT, 176),
1732
1733	/* Comma separated list of hostnames defining no-proxy zones. These should
1734	match both hostnames directly, and hostnames within a domain. For
1735	example, local.com will match local.com and www.local.com, but NOT
1736	notlocal.com or www.notlocal.com. For compatibility with other
1737	implementations of this, .local.com will be considered to be the same as
1738	local.com. A single * is the only valid wildcard, and effectively
1739	disables the use of proxy. */
1740	CURLOPT(CURLOPT_NOPROXY, CURLOPTTYPE_STRINGPOINT, 177),
1741
1742	/* block size for TFTP transfers */
1743	CURLOPT(CURLOPT_TFTP_BLKSIZE, CURLOPTTYPE_LONG, 178),
1744
1745	/* Socks Service */
1746	/* DEPRECATED, do not use! */
1747	CURLOPTDEPRECATED(CURLOPT_SOCKS5_GSSAPI_SERVICE,
1748	CURLOPTTYPE_STRINGPOINT, 179,
1749	7.49.0, "Use CURLOPT_PROXY_SERVICE_NAME"),
1750
1751	/* Socks Service */
1752	CURLOPT(CURLOPT_SOCKS5_GSSAPI_NEC, CURLOPTTYPE_LONG, 180),
1753
1754	/* set the bitmask for the protocols that are allowed to be used for the
1755	transfer, which thus helps the app which takes URLs from users or other
1756	external inputs and want to restrict what protocol(s) to deal
1757	with. Defaults to CURLPROTO_ALL. */
1758	CURLOPTDEPRECATED(CURLOPT_PROTOCOLS, CURLOPTTYPE_LONG, 181,
1759	7.85.0, "Use CURLOPT_PROTOCOLS_STR"),
1760
1761	/* set the bitmask for the protocols that libcurl is allowed to follow to,
1762	as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs
1763	to be set in both bitmasks to be allowed to get redirected to. */
1764	CURLOPTDEPRECATED(CURLOPT_REDIR_PROTOCOLS, CURLOPTTYPE_LONG, 182,
1765	7.85.0, "Use CURLOPT_REDIR_PROTOCOLS_STR"),
1766
1767	/* set the SSH knownhost file name to use */
1768	CURLOPT(CURLOPT_SSH_KNOWNHOSTS, CURLOPTTYPE_STRINGPOINT, 183),
1769
1770	/* set the SSH host key callback, must point to a curl_sshkeycallback
1771	function */
1772	CURLOPT(CURLOPT_SSH_KEYFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 184),
1773
1774	/* set the SSH host key callback custom pointer */
1775	CURLOPT(CURLOPT_SSH_KEYDATA, CURLOPTTYPE_CBPOINT, 185),
1776
1777	/* set the SMTP mail originator */
1778	CURLOPT(CURLOPT_MAIL_FROM, CURLOPTTYPE_STRINGPOINT, 186),
1779
1780	/* set the list of SMTP mail receiver(s) */
1781	CURLOPT(CURLOPT_MAIL_RCPT, CURLOPTTYPE_SLISTPOINT, 187),
1782
1783	/* FTP: send PRET before PASV */
1784	CURLOPT(CURLOPT_FTP_USE_PRET, CURLOPTTYPE_LONG, 188),
1785
1786	/* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */
1787	CURLOPT(CURLOPT_RTSP_REQUEST, CURLOPTTYPE_VALUES, 189),
1788
1789	/* The RTSP session identifier */
1790	CURLOPT(CURLOPT_RTSP_SESSION_ID, CURLOPTTYPE_STRINGPOINT, 190),
1791
1792	/* The RTSP stream URI */
1793	CURLOPT(CURLOPT_RTSP_STREAM_URI, CURLOPTTYPE_STRINGPOINT, 191),
1794
1795	/* The Transport: header to use in RTSP requests */
1796	CURLOPT(CURLOPT_RTSP_TRANSPORT, CURLOPTTYPE_STRINGPOINT, 192),
1797
1798	/* Manually initialize the client RTSP CSeq for this handle */
1799	CURLOPT(CURLOPT_RTSP_CLIENT_CSEQ, CURLOPTTYPE_LONG, 193),
1800
1801	/* Manually initialize the server RTSP CSeq for this handle */
1802	CURLOPT(CURLOPT_RTSP_SERVER_CSEQ, CURLOPTTYPE_LONG, 194),
1803
1804	/* The stream to pass to INTERLEAVEFUNCTION. */
1805	CURLOPT(CURLOPT_INTERLEAVEDATA, CURLOPTTYPE_CBPOINT, 195),
1806
1807	/* Let the application define a custom write method for RTP data */
1808	CURLOPT(CURLOPT_INTERLEAVEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 196),
1809
1810	/* Turn on wildcard matching */
1811	CURLOPT(CURLOPT_WILDCARDMATCH, CURLOPTTYPE_LONG, 197),
1812
1813	/* Directory matching callback called before downloading of an
1814	individual file (chunk) started */
1815	CURLOPT(CURLOPT_CHUNK_BGN_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 198),
1816
1817	/* Directory matching callback called after the file (chunk)
1818	was downloaded, or skipped */
1819	CURLOPT(CURLOPT_CHUNK_END_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 199),
1820
1821	/* Change match (fnmatch-like) callback for wildcard matching */
1822	CURLOPT(CURLOPT_FNMATCH_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 200),
1823
1824	/* Let the application define custom chunk data pointer */
1825	CURLOPT(CURLOPT_CHUNK_DATA, CURLOPTTYPE_CBPOINT, 201),
1826
1827	/* FNMATCH_FUNCTION user pointer */
1828	CURLOPT(CURLOPT_FNMATCH_DATA, CURLOPTTYPE_CBPOINT, 202),
1829
1830	/* send linked-list of name:port:address sets */
1831	CURLOPT(CURLOPT_RESOLVE, CURLOPTTYPE_SLISTPOINT, 203),
1832
1833	/* Set a username for authenticated TLS */
1834	CURLOPT(CURLOPT_TLSAUTH_USERNAME, CURLOPTTYPE_STRINGPOINT, 204),
1835
1836	/* Set a password for authenticated TLS */
1837	CURLOPT(CURLOPT_TLSAUTH_PASSWORD, CURLOPTTYPE_STRINGPOINT, 205),
1838
1839	/* Set authentication type for authenticated TLS */
1840	CURLOPT(CURLOPT_TLSAUTH_TYPE, CURLOPTTYPE_STRINGPOINT, 206),
1841
1842	/* Set to 1 to enable the "TE:" header in HTTP requests to ask for
1843	compressed transfer-encoded responses. Set to 0 to disable the use of TE:
1844	in outgoing requests. The current default is 0, but it might change in a
1845	future libcurl release.
1846
1847	libcurl will ask for the compressed methods it knows of, and if that
1848	isn't any, it will not ask for transfer-encoding at all even if this
1849	option is set to 1.
1850
1851	*/
1852	CURLOPT(CURLOPT_TRANSFER_ENCODING, CURLOPTTYPE_LONG, 207),
1853
1854	/* Callback function for closing socket (instead of close(2)). The callback
1855	should have type curl_closesocket_callback */
1856	CURLOPT(CURLOPT_CLOSESOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 208),
1857	CURLOPT(CURLOPT_CLOSESOCKETDATA, CURLOPTTYPE_CBPOINT, 209),
1858
1859	/* allow GSSAPI credential delegation */
1860	CURLOPT(CURLOPT_GSSAPI_DELEGATION, CURLOPTTYPE_VALUES, 210),
1861
1862	/* Set the name servers to use for DNS resolution */
1863	CURLOPT(CURLOPT_DNS_SERVERS, CURLOPTTYPE_STRINGPOINT, 211),
1864
1865	/* Time-out accept operations (currently for FTP only) after this amount
1866	of milliseconds. */
1867	CURLOPT(CURLOPT_ACCEPTTIMEOUT_MS, CURLOPTTYPE_LONG, 212),
1868
1869	/* Set TCP keepalive */
1870	CURLOPT(CURLOPT_TCP_KEEPALIVE, CURLOPTTYPE_LONG, 213),
1871
1872	/* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */
1873	CURLOPT(CURLOPT_TCP_KEEPIDLE, CURLOPTTYPE_LONG, 214),
1874	CURLOPT(CURLOPT_TCP_KEEPINTVL, CURLOPTTYPE_LONG, 215),
1875
1876	/* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */
1877	CURLOPT(CURLOPT_SSL_OPTIONS, CURLOPTTYPE_VALUES, 216),
1878
1879	/* Set the SMTP auth originator */
1880	CURLOPT(CURLOPT_MAIL_AUTH, CURLOPTTYPE_STRINGPOINT, 217),
1881
1882	/* Enable/disable SASL initial response */
1883	CURLOPT(CURLOPT_SASL_IR, CURLOPTTYPE_LONG, 218),
1884
1885	/* Function that will be called instead of the internal progress display
1886	* function. This function should be defined as the curl_xferinfo_callback
1887	* prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */
1888	CURLOPT(CURLOPT_XFERINFOFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 219),
1889
1890	/* The XOAUTH2 bearer token */
1891	CURLOPT(CURLOPT_XOAUTH2_BEARER, CURLOPTTYPE_STRINGPOINT, 220),
1892
1893	/* Set the interface string to use as outgoing network
1894	* interface for DNS requests.
1895	* Only supported by the c-ares DNS backend */
1896	CURLOPT(CURLOPT_DNS_INTERFACE, CURLOPTTYPE_STRINGPOINT, 221),
1897
1898	/* Set the local IPv4 address to use for outgoing DNS requests.
1899	* Only supported by the c-ares DNS backend */
1900	CURLOPT(CURLOPT_DNS_LOCAL_IP4, CURLOPTTYPE_STRINGPOINT, 222),
1901
1902	/* Set the local IPv6 address to use for outgoing DNS requests.
1903	* Only supported by the c-ares DNS backend */
1904	CURLOPT(CURLOPT_DNS_LOCAL_IP6, CURLOPTTYPE_STRINGPOINT, 223),
1905
1906	/* Set authentication options directly */
1907	CURLOPT(CURLOPT_LOGIN_OPTIONS, CURLOPTTYPE_STRINGPOINT, 224),
1908
1909	/* Enable/disable TLS NPN extension (http2 over ssl might fail without) */
1910	CURLOPTDEPRECATED(CURLOPT_SSL_ENABLE_NPN, CURLOPTTYPE_LONG, 225,
1911	7.86.0, "Has no function"),
1912
1913	/* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */
1914	CURLOPT(CURLOPT_SSL_ENABLE_ALPN, CURLOPTTYPE_LONG, 226),
1915
1916	/* Time to wait for a response to an HTTP request containing an
1917	* Expect: 100-continue header before sending the data anyway. */
1918	CURLOPT(CURLOPT_EXPECT_100_TIMEOUT_MS, CURLOPTTYPE_LONG, 227),
1919
1920	/* This points to a linked list of headers used for proxy requests only,
1921	struct curl_slist kind */
1922	CURLOPT(CURLOPT_PROXYHEADER, CURLOPTTYPE_SLISTPOINT, 228),
1923
1924	/* Pass in a bitmask of "header options" */
1925	CURLOPT(CURLOPT_HEADEROPT, CURLOPTTYPE_VALUES, 229),
1926
1927	/* The public key in DER form used to validate the peer public key
1928	this option is used only if SSL_VERIFYPEER is true */
1929	CURLOPT(CURLOPT_PINNEDPUBLICKEY, CURLOPTTYPE_STRINGPOINT, 230),
1930
1931	/* Path to Unix domain socket */
1932	CURLOPT(CURLOPT_UNIX_SOCKET_PATH, CURLOPTTYPE_STRINGPOINT, 231),
1933
1934	/* Set if we should verify the certificate status. */
1935	CURLOPT(CURLOPT_SSL_VERIFYSTATUS, CURLOPTTYPE_LONG, 232),
1936
1937	/* Set if we should enable TLS false start. */
1938	CURLOPT(CURLOPT_SSL_FALSESTART, CURLOPTTYPE_LONG, 233),
1939
1940	/* Do not squash dot-dot sequences */
1941	CURLOPT(CURLOPT_PATH_AS_IS, CURLOPTTYPE_LONG, 234),
1942
1943	/* Proxy Service Name */
1944	CURLOPT(CURLOPT_PROXY_SERVICE_NAME, CURLOPTTYPE_STRINGPOINT, 235),
1945
1946	/* Service Name */
1947	CURLOPT(CURLOPT_SERVICE_NAME, CURLOPTTYPE_STRINGPOINT, 236),
1948
1949	/* Wait/don't wait for pipe/mutex to clarify */
1950	CURLOPT(CURLOPT_PIPEWAIT, CURLOPTTYPE_LONG, 237),
1951
1952	/* Set the protocol used when curl is given a URL without a protocol */
1953	CURLOPT(CURLOPT_DEFAULT_PROTOCOL, CURLOPTTYPE_STRINGPOINT, 238),
1954
1955	/* Set stream weight, 1 - 256 (default is 16) */
1956	CURLOPT(CURLOPT_STREAM_WEIGHT, CURLOPTTYPE_LONG, 239),
1957
1958	/* Set stream dependency on another CURL handle */
1959	CURLOPT(CURLOPT_STREAM_DEPENDS, CURLOPTTYPE_OBJECTPOINT, 240),
1960
1961	/* Set E-xclusive stream dependency on another CURL handle */
1962	CURLOPT(CURLOPT_STREAM_DEPENDS_E, CURLOPTTYPE_OBJECTPOINT, 241),
1963
1964	/* Do not send any tftp option requests to the server */
1965	CURLOPT(CURLOPT_TFTP_NO_OPTIONS, CURLOPTTYPE_LONG, 242),
1966
1967	/* Linked-list of host:port:connect-to-host:connect-to-port,
1968	overrides the URL's host:port (only for the network layer) */
1969	CURLOPT(CURLOPT_CONNECT_TO, CURLOPTTYPE_SLISTPOINT, 243),
1970
1971	/* Set TCP Fast Open */
1972	CURLOPT(CURLOPT_TCP_FASTOPEN, CURLOPTTYPE_LONG, 244),
1973
1974	/* Continue to send data if the server responds early with an
1975	* HTTP status code >= 300 */
1976	CURLOPT(CURLOPT_KEEP_SENDING_ON_ERROR, CURLOPTTYPE_LONG, 245),
1977
1978	/* The CApath or CAfile used to validate the proxy certificate
1979	this option is used only if PROXY_SSL_VERIFYPEER is true */
1980	CURLOPT(CURLOPT_PROXY_CAINFO, CURLOPTTYPE_STRINGPOINT, 246),
1981
1982	/* The CApath directory used to validate the proxy certificate
1983	this option is used only if PROXY_SSL_VERIFYPEER is true */
1984	CURLOPT(CURLOPT_PROXY_CAPATH, CURLOPTTYPE_STRINGPOINT, 247),
1985
1986	/* Set if we should verify the proxy in ssl handshake,
1987	set 1 to verify. */
1988	CURLOPT(CURLOPT_PROXY_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 248),
1989
1990	/* Set if we should verify the Common name from the proxy certificate in ssl
1991	* handshake, set 1 to check existence, 2 to ensure that it matches
1992	* the provided hostname. */
1993	CURLOPT(CURLOPT_PROXY_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 249),
1994
1995	/* What version to specifically try to use for proxy.
1996	See CURL_SSLVERSION defines below. */
1997	CURLOPT(CURLOPT_PROXY_SSLVERSION, CURLOPTTYPE_VALUES, 250),
1998
1999	/* Set a username for authenticated TLS for proxy */
2000	CURLOPT(CURLOPT_PROXY_TLSAUTH_USERNAME, CURLOPTTYPE_STRINGPOINT, 251),
2001
2002	/* Set a password for authenticated TLS for proxy */
2003	CURLOPT(CURLOPT_PROXY_TLSAUTH_PASSWORD, CURLOPTTYPE_STRINGPOINT, 252),
2004
2005	/* Set authentication type for authenticated TLS for proxy */
2006	CURLOPT(CURLOPT_PROXY_TLSAUTH_TYPE, CURLOPTTYPE_STRINGPOINT, 253),
2007
2008	/* name of the file keeping your private SSL-certificate for proxy */
2009	CURLOPT(CURLOPT_PROXY_SSLCERT, CURLOPTTYPE_STRINGPOINT, 254),
2010
2011	/* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") for
2012	proxy */
2013	CURLOPT(CURLOPT_PROXY_SSLCERTTYPE, CURLOPTTYPE_STRINGPOINT, 255),
2014
2015	/* name of the file keeping your private SSL-key for proxy */
2016	CURLOPT(CURLOPT_PROXY_SSLKEY, CURLOPTTYPE_STRINGPOINT, 256),
2017
2018	/* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") for
2019	proxy */
2020	CURLOPT(CURLOPT_PROXY_SSLKEYTYPE, CURLOPTTYPE_STRINGPOINT, 257),
2021
2022	/* password for the SSL private key for proxy */
2023	CURLOPT(CURLOPT_PROXY_KEYPASSWD, CURLOPTTYPE_STRINGPOINT, 258),
2024
2025	/* Specify which SSL ciphers to use for proxy */
2026	CURLOPT(CURLOPT_PROXY_SSL_CIPHER_LIST, CURLOPTTYPE_STRINGPOINT, 259),
2027
2028	/* CRL file for proxy */
2029	CURLOPT(CURLOPT_PROXY_CRLFILE, CURLOPTTYPE_STRINGPOINT, 260),
2030
2031	/* Enable/disable specific SSL features with a bitmask for proxy, see
2032	CURLSSLOPT_* */
2033	CURLOPT(CURLOPT_PROXY_SSL_OPTIONS, CURLOPTTYPE_LONG, 261),
2034
2035	/* Name of pre proxy to use. */
2036	CURLOPT(CURLOPT_PRE_PROXY, CURLOPTTYPE_STRINGPOINT, 262),
2037
2038	/* The public key in DER form used to validate the proxy public key
2039	this option is used only if PROXY_SSL_VERIFYPEER is true */
2040	CURLOPT(CURLOPT_PROXY_PINNEDPUBLICKEY, CURLOPTTYPE_STRINGPOINT, 263),
2041
2042	/* Path to an abstract Unix domain socket */
2043	CURLOPT(CURLOPT_ABSTRACT_UNIX_SOCKET, CURLOPTTYPE_STRINGPOINT, 264),
2044
2045	/* Suppress proxy CONNECT response headers from user callbacks */
2046	CURLOPT(CURLOPT_SUPPRESS_CONNECT_HEADERS, CURLOPTTYPE_LONG, 265),
2047
2048	/* The request target, instead of extracted from the URL */
2049	CURLOPT(CURLOPT_REQUEST_TARGET, CURLOPTTYPE_STRINGPOINT, 266),
2050
2051	/* bitmask of allowed auth methods for connections to SOCKS5 proxies */
2052	CURLOPT(CURLOPT_SOCKS5_AUTH, CURLOPTTYPE_LONG, 267),
2053
2054	/* Enable/disable SSH compression */
2055	CURLOPT(CURLOPT_SSH_COMPRESSION, CURLOPTTYPE_LONG, 268),
2056
2057	/* Post MIME data. */
2058	CURLOPT(CURLOPT_MIMEPOST, CURLOPTTYPE_OBJECTPOINT, 269),
2059
2060	/* Time to use with the CURLOPT_TIMECONDITION. Specified in number of
2061	seconds since 1 Jan 1970. */
2062	CURLOPT(CURLOPT_TIMEVALUE_LARGE, CURLOPTTYPE_OFF_T, 270),
2063
2064	/* Head start in milliseconds to give happy eyeballs. */
2065	CURLOPT(CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS, CURLOPTTYPE_LONG, 271),
2066
2067	/* Function that will be called before a resolver request is made */
2068	CURLOPT(CURLOPT_RESOLVER_START_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 272),
2069
2070	/* User data to pass to the resolver start callback. */
2071	CURLOPT(CURLOPT_RESOLVER_START_DATA, CURLOPTTYPE_CBPOINT, 273),
2072
2073	/* send HAProxy PROXY protocol header? */
2074	CURLOPT(CURLOPT_HAPROXYPROTOCOL, CURLOPTTYPE_LONG, 274),
2075
2076	/* shuffle addresses before use when DNS returns multiple */
2077	CURLOPT(CURLOPT_DNS_SHUFFLE_ADDRESSES, CURLOPTTYPE_LONG, 275),
2078
2079	/* Specify which TLS 1.3 ciphers suites to use */
2080	CURLOPT(CURLOPT_TLS13_CIPHERS, CURLOPTTYPE_STRINGPOINT, 276),
2081	CURLOPT(CURLOPT_PROXY_TLS13_CIPHERS, CURLOPTTYPE_STRINGPOINT, 277),
2082
2083	/* Disallow specifying username/login in URL. */
2084	CURLOPT(CURLOPT_DISALLOW_USERNAME_IN_URL, CURLOPTTYPE_LONG, 278),
2085
2086	/* DNS-over-HTTPS URL */
2087	CURLOPT(CURLOPT_DOH_URL, CURLOPTTYPE_STRINGPOINT, 279),
2088
2089	/* Preferred buffer size to use for uploads */
2090	CURLOPT(CURLOPT_UPLOAD_BUFFERSIZE, CURLOPTTYPE_LONG, 280),
2091
2092	/* Time in ms between connection upkeep calls for long-lived connections. */
2093	CURLOPT(CURLOPT_UPKEEP_INTERVAL_MS, CURLOPTTYPE_LONG, 281),
2094
2095	/* Specify URL using CURL URL API. */
2096	CURLOPT(CURLOPT_CURLU, CURLOPTTYPE_OBJECTPOINT, 282),
2097
2098	/* add trailing data just after no more data is available */
2099	CURLOPT(CURLOPT_TRAILERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 283),
2100
2101	/* pointer to be passed to HTTP_TRAILER_FUNCTION */
2102	CURLOPT(CURLOPT_TRAILERDATA, CURLOPTTYPE_CBPOINT, 284),
2103
2104	/* set this to 1L to allow HTTP/0.9 responses or 0L to disallow */
2105	CURLOPT(CURLOPT_HTTP09_ALLOWED, CURLOPTTYPE_LONG, 285),
2106
2107	/* alt-svc control bitmask */
2108	CURLOPT(CURLOPT_ALTSVC_CTRL, CURLOPTTYPE_LONG, 286),
2109
2110	/* alt-svc cache file name to possibly read from/write to */
2111	CURLOPT(CURLOPT_ALTSVC, CURLOPTTYPE_STRINGPOINT, 287),
2112
2113	/* maximum age (idle time) of a connection to consider it for reuse
2114	* (in seconds) */
2115	CURLOPT(CURLOPT_MAXAGE_CONN, CURLOPTTYPE_LONG, 288),
2116
2117	/* SASL authorization identity */
2118	CURLOPT(CURLOPT_SASL_AUTHZID, CURLOPTTYPE_STRINGPOINT, 289),
2119
2120	/* allow RCPT TO command to fail for some recipients */
2121	CURLOPT(CURLOPT_MAIL_RCPT_ALLOWFAILS, CURLOPTTYPE_LONG, 290),
2122
2123	/* the private SSL-certificate as a "blob" */
2124	CURLOPT(CURLOPT_SSLCERT_BLOB, CURLOPTTYPE_BLOB, 291),
2125	CURLOPT(CURLOPT_SSLKEY_BLOB, CURLOPTTYPE_BLOB, 292),
2126	CURLOPT(CURLOPT_PROXY_SSLCERT_BLOB, CURLOPTTYPE_BLOB, 293),
2127	CURLOPT(CURLOPT_PROXY_SSLKEY_BLOB, CURLOPTTYPE_BLOB, 294),
2128	CURLOPT(CURLOPT_ISSUERCERT_BLOB, CURLOPTTYPE_BLOB, 295),
2129
2130	/* Issuer certificate for proxy */
2131	CURLOPT(CURLOPT_PROXY_ISSUERCERT, CURLOPTTYPE_STRINGPOINT, 296),
2132	CURLOPT(CURLOPT_PROXY_ISSUERCERT_BLOB, CURLOPTTYPE_BLOB, 297),
2133
2134	/* the EC curves requested by the TLS client (RFC 8422, 5.1);
2135	* OpenSSL support via 'set_groups'/'set_curves':
2136	* https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set1_groups.html
2137	*/
2138	CURLOPT(CURLOPT_SSL_EC_CURVES, CURLOPTTYPE_STRINGPOINT, 298),
2139
2140	/* HSTS bitmask */
2141	CURLOPT(CURLOPT_HSTS_CTRL, CURLOPTTYPE_LONG, 299),
2142	/* HSTS file name */
2143	CURLOPT(CURLOPT_HSTS, CURLOPTTYPE_STRINGPOINT, 300),
2144
2145	/* HSTS read callback */
2146	CURLOPT(CURLOPT_HSTSREADFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 301),
2147	CURLOPT(CURLOPT_HSTSREADDATA, CURLOPTTYPE_CBPOINT, 302),
2148
2149	/* HSTS write callback */
2150	CURLOPT(CURLOPT_HSTSWRITEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 303),
2151	CURLOPT(CURLOPT_HSTSWRITEDATA, CURLOPTTYPE_CBPOINT, 304),
2152
2153	/* Parameters for V4 signature */
2154	CURLOPT(CURLOPT_AWS_SIGV4, CURLOPTTYPE_STRINGPOINT, 305),
2155
2156	/* Same as CURLOPT_SSL_VERIFYPEER but for DoH (DNS-over-HTTPS) servers. */
2157	CURLOPT(CURLOPT_DOH_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 306),
2158
2159	/* Same as CURLOPT_SSL_VERIFYHOST but for DoH (DNS-over-HTTPS) servers. */
2160	CURLOPT(CURLOPT_DOH_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 307),
2161
2162	/* Same as CURLOPT_SSL_VERIFYSTATUS but for DoH (DNS-over-HTTPS) servers. */
2163	CURLOPT(CURLOPT_DOH_SSL_VERIFYSTATUS, CURLOPTTYPE_LONG, 308),
2164
2165	/* The CA certificates as "blob" used to validate the peer certificate
2166	this option is used only if SSL_VERIFYPEER is true */
2167	CURLOPT(CURLOPT_CAINFO_BLOB, CURLOPTTYPE_BLOB, 309),
2168
2169	/* The CA certificates as "blob" used to validate the proxy certificate
2170	this option is used only if PROXY_SSL_VERIFYPEER is true */
2171	CURLOPT(CURLOPT_PROXY_CAINFO_BLOB, CURLOPTTYPE_BLOB, 310),
2172
2173	/* used by scp/sftp to verify the host's public key */
2174	CURLOPT(CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256, CURLOPTTYPE_STRINGPOINT, 311),
2175
2176	/* Function that will be called immediately before the initial request
2177	is made on a connection (after any protocol negotiation step). */
2178	CURLOPT(CURLOPT_PREREQFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 312),
2179
2180	/* Data passed to the CURLOPT_PREREQFUNCTION callback */
2181	CURLOPT(CURLOPT_PREREQDATA, CURLOPTTYPE_CBPOINT, 313),
2182
2183	/* maximum age (since creation) of a connection to consider it for reuse
2184	* (in seconds) */
2185	CURLOPT(CURLOPT_MAXLIFETIME_CONN, CURLOPTTYPE_LONG, 314),
2186
2187	/* Set MIME option flags. */
2188	CURLOPT(CURLOPT_MIME_OPTIONS, CURLOPTTYPE_LONG, 315),
2189
2190	/* set the SSH host key callback, must point to a curl_sshkeycallback
2191	function */
2192	CURLOPT(CURLOPT_SSH_HOSTKEYFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 316),
2193
2194	/* set the SSH host key callback custom pointer */
2195	CURLOPT(CURLOPT_SSH_HOSTKEYDATA, CURLOPTTYPE_CBPOINT, 317),
2196
2197	/* specify which protocols that are allowed to be used for the transfer,
2198	which thus helps the app which takes URLs from users or other external
2199	inputs and want to restrict what protocol(s) to deal with. Defaults to
2200	all built-in protocols. */
2201	CURLOPT(CURLOPT_PROTOCOLS_STR, CURLOPTTYPE_STRINGPOINT, 318),
2202
2203	/* specify which protocols that libcurl is allowed to follow directs to */
2204	CURLOPT(CURLOPT_REDIR_PROTOCOLS_STR, CURLOPTTYPE_STRINGPOINT, 319),
2205
2206	/* websockets options */
2207	CURLOPT(CURLOPT_WS_OPTIONS, CURLOPTTYPE_LONG, 320),
2208
2209	/* CA cache timeout */
2210	CURLOPT(CURLOPT_CA_CACHE_TIMEOUT, CURLOPTTYPE_LONG, 321),
2211
2212	/* Can leak things, gonna exit() soon */
2213	CURLOPT(CURLOPT_QUICK_EXIT, CURLOPTTYPE_LONG, 322),
2214
2215	/* set a specific client IP for HAProxy PROXY protocol header? */
2216	CURLOPT(CURLOPT_HAPROXY_CLIENT_IP, CURLOPTTYPE_STRINGPOINT, 323),
2217
2218	CURLOPT_LASTENTRY /* the last unused */
2219	} CURLoption;
2220
2221	#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
2222	the obsolete stuff removed! */
2223
2224	/* Backwards compatibility with older names */
2225	/* These are scheduled to disappear by 2011 */
2226
2227	/* This was added in version 7.19.1 */
2228	#define CURLOPT_POST301 CURLOPT_POSTREDIR
2229
2230	/* These are scheduled to disappear by 2009 */
2231
2232	/* The following were added in 7.17.0 */
2233	#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD
2234	#define CURLOPT_FTPAPPEND CURLOPT_APPEND
2235	#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY
2236	#define CURLOPT_FTP_SSL CURLOPT_USE_SSL
2237
2238	/* The following were added earlier */
2239
2240	#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD
2241	#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL
2242
2243	/* */
2244	#define CURLOPT_FTP_RESPONSE_TIMEOUT CURLOPT_SERVER_RESPONSE_TIMEOUT
2245
2246	/* Added in 8.2.0 */
2247	#define CURLOPT_MAIL_RCPT_ALLLOWFAILS CURLOPT_MAIL_RCPT_ALLOWFAILS
2248
2249	#else
2250	/* This is set if CURL_NO_OLDIES is defined at compile-time */
2251	#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */
2252	#endif
2253
2254
2255	/* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host
2256	name resolves addresses using more than one IP protocol version, this
2257	option might be handy to force libcurl to use a specific IP version. */
2258	#define CURL_IPRESOLVE_WHATEVER 0 /* default, uses addresses to all IP
2259	versions that your system allows */
2260	#define CURL_IPRESOLVE_V4 1 /* uses only IPv4 addresses/connections */
2261	#define CURL_IPRESOLVE_V6 2 /* uses only IPv6 addresses/connections */
2262
2263	/* Convenient "aliases" */
2264	#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER
2265
2266	/* These enums are for use with the CURLOPT_HTTP_VERSION option. */
2267	enum {
2268	CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd
2269	like the library to choose the best possible
2270	for us! */
2271	CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */
2272	CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */
2273	CURL_HTTP_VERSION_2_0, /* please use HTTP 2 in the request */
2274	CURL_HTTP_VERSION_2TLS, /* use version 2 for HTTPS, version 1.1 for HTTP */
2275	CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE, /* please use HTTP 2 without HTTP/1.1
2276	Upgrade */
2277	CURL_HTTP_VERSION_3 = 30, /* Use HTTP/3, fallback to HTTP/2 or HTTP/1 if
2278	needed. For HTTPS only. For HTTP, this option
2279	makes libcurl return error. */
2280	CURL_HTTP_VERSION_3ONLY = 31, /* Use HTTP/3 without fallback. For HTTPS
2281	only. For HTTP, this makes libcurl
2282	return error. */
2283
2284	CURL_HTTP_VERSION_LAST /* ILLEGAL http version */
2285	};
2286
2287	/* Convenience definition simple because the name of the version is HTTP/2 and
2288	not 2.0. The 2_0 version of the enum name was set while the version was
2289	still planned to be 2.0 and we stick to it for compatibility. */
2290	#define CURL_HTTP_VERSION_2 CURL_HTTP_VERSION_2_0
2291
2292	/*
2293	* Public API enums for RTSP requests
2294	*/
2295	enum {
2296	CURL_RTSPREQ_NONE, /* first in list */
2297	CURL_RTSPREQ_OPTIONS,
2298	CURL_RTSPREQ_DESCRIBE,
2299	CURL_RTSPREQ_ANNOUNCE,
2300	CURL_RTSPREQ_SETUP,
2301	CURL_RTSPREQ_PLAY,
2302	CURL_RTSPREQ_PAUSE,
2303	CURL_RTSPREQ_TEARDOWN,
2304	CURL_RTSPREQ_GET_PARAMETER,
2305	CURL_RTSPREQ_SET_PARAMETER,
2306	CURL_RTSPREQ_RECORD,
2307	CURL_RTSPREQ_RECEIVE,
2308	CURL_RTSPREQ_LAST /* last in list */
2309	};
2310
2311	/* These enums are for use with the CURLOPT_NETRC option. */
2312	enum CURL_NETRC_OPTION {
2313	CURL_NETRC_IGNORED, /* The .netrc will never be read.
2314	* This is the default. */
2315	CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred
2316	* to one in the .netrc. */
2317	CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored.
2318	* Unless one is set programmatically, the .netrc
2319	* will be queried. */
2320	CURL_NETRC_LAST
2321	};
2322
2323	enum {
2324	CURL_SSLVERSION_DEFAULT,
2325	CURL_SSLVERSION_TLSv1, /* TLS 1.x */
2326	CURL_SSLVERSION_SSLv2,
2327	CURL_SSLVERSION_SSLv3,
2328	CURL_SSLVERSION_TLSv1_0,
2329	CURL_SSLVERSION_TLSv1_1,
2330	CURL_SSLVERSION_TLSv1_2,
2331	CURL_SSLVERSION_TLSv1_3,
2332
2333	CURL_SSLVERSION_LAST /* never use, keep last */
2334	};
2335
2336	enum {
2337	CURL_SSLVERSION_MAX_NONE = 0,
2338	CURL_SSLVERSION_MAX_DEFAULT = (CURL_SSLVERSION_TLSv1 << 16),
2339	CURL_SSLVERSION_MAX_TLSv1_0 = (CURL_SSLVERSION_TLSv1_0 << 16),
2340	CURL_SSLVERSION_MAX_TLSv1_1 = (CURL_SSLVERSION_TLSv1_1 << 16),
2341	CURL_SSLVERSION_MAX_TLSv1_2 = (CURL_SSLVERSION_TLSv1_2 << 16),
2342	CURL_SSLVERSION_MAX_TLSv1_3 = (CURL_SSLVERSION_TLSv1_3 << 16),
2343
2344	/* never use, keep last */
2345	CURL_SSLVERSION_MAX_LAST = (CURL_SSLVERSION_LAST << 16)
2346	};
2347
2348	enum CURL_TLSAUTH {
2349	CURL_TLSAUTH_NONE,
2350	CURL_TLSAUTH_SRP,
2351	CURL_TLSAUTH_LAST /* never use, keep last */
2352	};
2353
2354	/* symbols to use with CURLOPT_POSTREDIR.
2355	CURL_REDIR_POST_301, CURL_REDIR_POST_302 and CURL_REDIR_POST_303
2356	can be bitwise ORed so that CURL_REDIR_POST_301 \| CURL_REDIR_POST_302
2357	\| CURL_REDIR_POST_303 == CURL_REDIR_POST_ALL */
2358
2359	#define CURL_REDIR_GET_ALL 0
2360	#define CURL_REDIR_POST_301 1
2361	#define CURL_REDIR_POST_302 2
2362	#define CURL_REDIR_POST_303 4
2363	#define CURL_REDIR_POST_ALL \
2364	(CURL_REDIR_POST_301\|CURL_REDIR_POST_302\|CURL_REDIR_POST_303)
2365
2366	typedef enum {
2367	CURL_TIMECOND_NONE,
2368
2369	CURL_TIMECOND_IFMODSINCE,
2370	CURL_TIMECOND_IFUNMODSINCE,
2371	CURL_TIMECOND_LASTMOD,
2372
2373	CURL_TIMECOND_LAST
2374	} curl_TimeCond;
2375
2376	/* Special size_t value signaling a null-terminated string. */
2377	#define CURL_ZERO_TERMINATED ((size_t) -1)
2378
2379	/* curl_strequal() and curl_strnequal() are subject for removal in a future
2380	release */
2381	CURL_EXTERN int curl_strequal(const char s1, const char s2);
2382	CURL_EXTERN int curl_strnequal(const char s1, const char s2, size_t n);
2383
2384	/* Mime/form handling support. */
2385	typedef struct curl_mime curl_mime; /* Mime context. */
2386	typedef struct curl_mimepart curl_mimepart; /* Mime part context. */
2387
2388	/* CURLMIMEOPT_ defines are for the CURLOPT_MIME_OPTIONS option. */
2389	#define CURLMIMEOPT_FORMESCAPE (1<<0) /* Use backslash-escaping for forms. */
2390
2391	/*
2392	* NAME curl_mime_init()
2393	*
2394	* DESCRIPTION
2395	*
2396	* Create a mime context and return its handle. The easy parameter is the
2397	* target handle.
2398	*/
2399	CURL_EXTERN curl_mime curl_mime_init(CURL easy);
2400
2401	/*
2402	* NAME curl_mime_free()
2403	*
2404	* DESCRIPTION
2405	*
2406	* release a mime handle and its substructures.
2407	*/
2408	CURL_EXTERN void curl_mime_free(curl_mime *mime);
2409
2410	/*
2411	* NAME curl_mime_addpart()
2412	*
2413	* DESCRIPTION
2414	*
2415	* Append a new empty part to the given mime context and return a handle to
2416	* the created part.
2417	*/
2418	CURL_EXTERN curl_mimepart curl_mime_addpart(curl_mime mime);
2419
2420	/*
2421	* NAME curl_mime_name()
2422	*
2423	* DESCRIPTION
2424	*
2425	* Set mime/form part name.
2426	*/
2427	CURL_EXTERN CURLcode curl_mime_name(curl_mimepart part, const char name);
2428
2429	/*
2430	* NAME curl_mime_filename()
2431	*
2432	* DESCRIPTION
2433	*
2434	* Set mime part remote file name.
2435	*/
2436	CURL_EXTERN CURLcode curl_mime_filename(curl_mimepart *part,
2437	const char *filename);
2438
2439	/*
2440	* NAME curl_mime_type()
2441	*
2442	* DESCRIPTION
2443	*
2444	* Set mime part type.
2445	*/
2446	CURL_EXTERN CURLcode curl_mime_type(curl_mimepart part, const char mimetype);
2447
2448	/*
2449	* NAME curl_mime_encoder()
2450	*
2451	* DESCRIPTION
2452	*
2453	* Set mime data transfer encoder.
2454	*/
2455	CURL_EXTERN CURLcode curl_mime_encoder(curl_mimepart *part,
2456	const char *encoding);
2457
2458	/*
2459	* NAME curl_mime_data()
2460	*
2461	* DESCRIPTION
2462	*
2463	* Set mime part data source from memory data,
2464	*/
2465	CURL_EXTERN CURLcode curl_mime_data(curl_mimepart *part,
2466	const char *data, size_t datasize);
2467
2468	/*
2469	* NAME curl_mime_filedata()
2470	*
2471	* DESCRIPTION
2472	*
2473	* Set mime part data source from named file.
2474	*/
2475	CURL_EXTERN CURLcode curl_mime_filedata(curl_mimepart *part,
2476	const char *filename);
2477
2478	/*
2479	* NAME curl_mime_data_cb()
2480	*
2481	* DESCRIPTION
2482	*
2483	* Set mime part data source from callback function.
2484	*/
2485	CURL_EXTERN CURLcode curl_mime_data_cb(curl_mimepart *part,
2486	curl_off_t datasize,
2487	curl_read_callback readfunc,
2488	curl_seek_callback seekfunc,
2489	curl_free_callback freefunc,
2490	void *arg);
2491
2492	/*
2493	* NAME curl_mime_subparts()
2494	*
2495	* DESCRIPTION
2496	*
2497	* Set mime part data source from subparts.
2498	*/
2499	CURL_EXTERN CURLcode curl_mime_subparts(curl_mimepart *part,
2500	curl_mime *subparts);
2501	/*
2502	* NAME curl_mime_headers()
2503	*
2504	* DESCRIPTION
2505	*
2506	* Set mime part headers.
2507	*/
2508	CURL_EXTERN CURLcode curl_mime_headers(curl_mimepart *part,
2509	struct curl_slist *headers,
2510	int take_ownership);
2511
2512	typedef enum {
2513	/******* the first one is unused **********/
2514	CURLFORM_NOTHING CURL_DEPRECATED(7.56.0, ""),
2515	CURLFORM_COPYNAME CURL_DEPRECATED(7.56.0, "Use curl_mime_name()"),
2516	CURLFORM_PTRNAME CURL_DEPRECATED(7.56.0, "Use curl_mime_name()"),
2517	CURLFORM_NAMELENGTH CURL_DEPRECATED(7.56.0, ""),
2518	CURLFORM_COPYCONTENTS CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"),
2519	CURLFORM_PTRCONTENTS CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"),
2520	CURLFORM_CONTENTSLENGTH CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"),
2521	CURLFORM_FILECONTENT CURL_DEPRECATED(7.56.0, "Use curl_mime_data_cb()"),
2522	CURLFORM_ARRAY CURL_DEPRECATED(7.56.0, ""),
2523	CURLFORM_OBSOLETE,
2524	CURLFORM_FILE CURL_DEPRECATED(7.56.0, "Use curl_mime_filedata()"),
2525
2526	CURLFORM_BUFFER CURL_DEPRECATED(7.56.0, "Use curl_mime_filename()"),
2527	CURLFORM_BUFFERPTR CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"),
2528	CURLFORM_BUFFERLENGTH CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"),
2529
2530	CURLFORM_CONTENTTYPE CURL_DEPRECATED(7.56.0, "Use curl_mime_type()"),
2531	CURLFORM_CONTENTHEADER CURL_DEPRECATED(7.56.0, "Use curl_mime_headers()"),
2532	CURLFORM_FILENAME CURL_DEPRECATED(7.56.0, "Use curl_mime_filename()"),
2533	CURLFORM_END,
2534	CURLFORM_OBSOLETE2,
2535
2536	CURLFORM_STREAM CURL_DEPRECATED(7.56.0, "Use curl_mime_data_cb()"),
2537	CURLFORM_CONTENTLEN /* added in 7.46.0, provide a curl_off_t length */
2538	CURL_DEPRECATED(7.56.0, "Use curl_mime_data()"),
2539
2540	CURLFORM_LASTENTRY /* the last unused */
2541	} CURLformoption;
2542
2543	/* structure to be used as parameter for CURLFORM_ARRAY */
2544	struct curl_forms {
2545	CURLformoption option;
2546	const char *value;
2547	};
2548
2549	/* use this for multipart formpost building */
2550	/* Returns code for curl_formadd()
2551	*
2552	* Returns:
2553	* CURL_FORMADD_OK on success
2554	* CURL_FORMADD_MEMORY if the FormInfo allocation fails
2555	* CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form
2556	* CURL_FORMADD_NULL if a null pointer was given for a char
2557	* CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed
2558	* CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used
2559	* CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error)
2560	* CURL_FORMADD_MEMORY if a curl_httppost struct cannot be allocated
2561	* CURL_FORMADD_MEMORY if some allocation for string copying failed.
2562	* CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array
2563	*
2564	***************************************************************************/
2565	typedef enum {
2566	CURL_FORMADD_OK CURL_DEPRECATED(7.56.0, ""), /* 1st, no error */
2567
2568	CURL_FORMADD_MEMORY CURL_DEPRECATED(7.56.0, ""),
2569	CURL_FORMADD_OPTION_TWICE CURL_DEPRECATED(7.56.0, ""),
2570	CURL_FORMADD_NULL CURL_DEPRECATED(7.56.0, ""),
2571	CURL_FORMADD_UNKNOWN_OPTION CURL_DEPRECATED(7.56.0, ""),
2572	CURL_FORMADD_INCOMPLETE CURL_DEPRECATED(7.56.0, ""),
2573	CURL_FORMADD_ILLEGAL_ARRAY CURL_DEPRECATED(7.56.0, ""),
2574	/* libcurl was built with form api disabled */
2575	CURL_FORMADD_DISABLED CURL_DEPRECATED(7.56.0, ""),
2576
2577	CURL_FORMADD_LAST /* last */
2578	} CURLFORMcode;
2579
2580	/*
2581	* NAME curl_formadd()
2582	*
2583	* DESCRIPTION
2584	*
2585	* Pretty advanced function for building multi-part formposts. Each invoke
2586	* adds one part that together construct a full post. Then use
2587	* CURLOPT_HTTPPOST to send it off to libcurl.
2588	*/
2589	CURL_EXTERN CURLFORMcode CURL_DEPRECATED(7.56.0, "Use curl_mime_init()")
2590	curl_formadd(struct curl_httppost **httppost,
2591	struct curl_httppost **last_post,
2592	...);
2593
2594	/*
2595	* callback function for curl_formget()
2596	* The void *arg pointer will be the one passed as second argument to
2597	* curl_formget().
2598	* The character buffer passed to it must not be freed.
2599	* Should return the buffer length passed to it as the argument "len" on
2600	* success.
2601	*/
2602	typedef size_t (curl_formget_callback)(void arg, const char *buf,
2603	size_t len);
2604
2605	/*
2606	* NAME curl_formget()
2607	*
2608	* DESCRIPTION
2609	*
2610	* Serialize a curl_httppost struct built with curl_formadd().
2611	* Accepts a void pointer as second argument which will be passed to
2612	* the curl_formget_callback function.
2613	* Returns 0 on success.
2614	*/
2615	CURL_EXTERN int CURL_DEPRECATED(7.56.0, "")
2616	curl_formget(struct curl_httppost form, void arg,
2617	curl_formget_callback append);
2618	/*
2619	* NAME curl_formfree()
2620	*
2621	* DESCRIPTION
2622	*
2623	* Free a multipart formpost previously built with curl_formadd().
2624	*/
2625	CURL_EXTERN void CURL_DEPRECATED(7.56.0, "Use curl_mime_free()")
2626	curl_formfree(struct curl_httppost *form);
2627
2628	/*
2629	* NAME curl_getenv()
2630	*
2631	* DESCRIPTION
2632	*
2633	* Returns a malloc()'ed string that MUST be curl_free()ed after usage is
2634	* complete. DEPRECATED - see lib/README.curlx
2635	*/
2636	CURL_EXTERN char curl_getenv(const char variable);
2637
2638	/*
2639	* NAME curl_version()
2640	*
2641	* DESCRIPTION
2642	*
2643	* Returns a static ascii string of the libcurl version.
2644	*/
2645	CURL_EXTERN char *curl_version(void);
2646
2647	/*
2648	* NAME curl_easy_escape()
2649	*
2650	* DESCRIPTION
2651	*
2652	* Escapes URL strings (converts all letters consider illegal in URLs to their
2653	* %XX versions). This function returns a new allocated string or NULL if an
2654	* error occurred.
2655	*/
2656	CURL_EXTERN char curl_easy_escape(CURL handle,
2657	const char *string,
2658	int length);
2659
2660	/* the previous version: */
2661	CURL_EXTERN char curl_escape(const char string,
2662	int length);
2663
2664
2665	/*
2666	* NAME curl_easy_unescape()
2667	*
2668	* DESCRIPTION
2669	*
2670	* Unescapes URL encoding in strings (converts all %XX codes to their 8bit
2671	* versions). This function returns a new allocated string or NULL if an error
2672	* occurred.
2673	* Conversion Note: On non-ASCII platforms the ASCII %XX codes are
2674	* converted into the host encoding.
2675	*/
2676	CURL_EXTERN char curl_easy_unescape(CURL handle,
2677	const char *string,
2678	int length,
2679	int *outlength);
2680
2681	/* the previous version */
2682	CURL_EXTERN char curl_unescape(const char string,
2683	int length);
2684
2685	/*
2686	* NAME curl_free()
2687	*
2688	* DESCRIPTION
2689	*
2690	* Provided for de-allocation in the same translation unit that did the
2691	* allocation. Added in libcurl 7.10
2692	*/
2693	CURL_EXTERN void curl_free(void *p);
2694
2695	/*
2696	* NAME curl_global_init()
2697	*
2698	* DESCRIPTION
2699	*
2700	* curl_global_init() should be invoked exactly once for each application that
2701	* uses libcurl and before any call of other libcurl functions.
2702
2703	* This function is thread-safe if CURL_VERSION_THREADSAFE is set in the
2704	* curl_version_info_data.features flag (fetch by curl_version_info()).
2705
2706	*/
2707	CURL_EXTERN CURLcode curl_global_init(long flags);
2708
2709	/*
2710	* NAME curl_global_init_mem()
2711	*
2712	* DESCRIPTION
2713	*
2714	* curl_global_init() or curl_global_init_mem() should be invoked exactly once
2715	* for each application that uses libcurl. This function can be used to
2716	* initialize libcurl and set user defined memory management callback
2717	* functions. Users can implement memory management routines to check for
2718	* memory leaks, check for mis-use of the curl library etc. User registered
2719	* callback routines will be invoked by this library instead of the system
2720	* memory management routines like malloc, free etc.
2721	*/
2722	CURL_EXTERN CURLcode curl_global_init_mem(long flags,
2723	curl_malloc_callback m,
2724	curl_free_callback f,
2725	curl_realloc_callback r,
2726	curl_strdup_callback s,
2727	curl_calloc_callback c);
2728
2729	/*
2730	* NAME curl_global_cleanup()
2731	*
2732	* DESCRIPTION
2733	*
2734	* curl_global_cleanup() should be invoked exactly once for each application
2735	* that uses libcurl
2736	*/
2737	CURL_EXTERN void curl_global_cleanup(void);
2738
2739	/*
2740	* NAME curl_global_trace()
2741	*
2742	* DESCRIPTION
2743	*
2744	* curl_global_trace() can be invoked at application start to
2745	* configure which components in curl should participate in tracing.
2746
2747	* This function is thread-safe if CURL_VERSION_THREADSAFE is set in the
2748	* curl_version_info_data.features flag (fetch by curl_version_info()).
2749
2750	*/
2751	CURL_EXTERN CURLcode curl_global_trace(const char *config);
2752
2753	/* linked-list structure for the CURLOPT_QUOTE option (and other) */
2754	struct curl_slist {
2755	char *data;
2756	struct curl_slist *next;
2757	};
2758
2759	/*
2760	* NAME curl_global_sslset()
2761	*
2762	* DESCRIPTION
2763	*
2764	* When built with multiple SSL backends, curl_global_sslset() allows to
2765	* choose one. This function can only be called once, and it must be called
2766	* before curl_global_init().
2767	*
2768	* The backend can be identified by the id (e.g. CURLSSLBACKEND_OPENSSL). The
2769	* backend can also be specified via the name parameter (passing -1 as id).
2770	* If both id and name are specified, the name will be ignored. If neither id
2771	* nor name are specified, the function will fail with
2772	* CURLSSLSET_UNKNOWN_BACKEND and set the "avail" pointer to the
2773	* NULL-terminated list of available backends.
2774	*
2775	* Upon success, the function returns CURLSSLSET_OK.
2776	*
2777	* If the specified SSL backend is not available, the function returns
2778	* CURLSSLSET_UNKNOWN_BACKEND and sets the "avail" pointer to a NULL-terminated
2779	* list of available SSL backends.
2780	*
2781	* The SSL backend can be set only once. If it has already been set, a
2782	* subsequent attempt to change it will result in a CURLSSLSET_TOO_LATE.
2783	*/
2784
2785	struct curl_ssl_backend {
2786	curl_sslbackend id;
2787	const char *name;
2788	};
2789	typedef struct curl_ssl_backend curl_ssl_backend;
2790
2791	typedef enum {
2792	CURLSSLSET_OK = 0,
2793	CURLSSLSET_UNKNOWN_BACKEND,
2794	CURLSSLSET_TOO_LATE,
2795	CURLSSLSET_NO_BACKENDS /* libcurl was built without any SSL support */
2796	} CURLsslset;
2797
2798	CURL_EXTERN CURLsslset curl_global_sslset(curl_sslbackend id, const char *name,
2799	const curl_ssl_backend ***avail);
2800
2801	/*
2802	* NAME curl_slist_append()
2803	*
2804	* DESCRIPTION
2805	*
2806	* Appends a string to a linked list. If no list exists, it will be created
2807	* first. Returns the new list, after appending.
2808	*/
2809	CURL_EXTERN struct curl_slist curl_slist_append(struct curl_slist list,
2810	const char *data);
2811
2812	/*
2813	* NAME curl_slist_free_all()
2814	*
2815	* DESCRIPTION
2816	*
2817	* free a previously built curl_slist.
2818	*/
2819	CURL_EXTERN void curl_slist_free_all(struct curl_slist *list);
2820
2821	/*
2822	* NAME curl_getdate()
2823	*
2824	* DESCRIPTION
2825	*
2826	* Returns the time, in seconds since 1 Jan 1970 of the time string given in
2827	* the first argument. The time argument in the second parameter is unused
2828	* and should be set to NULL.
2829	*/
2830	CURL_EXTERN time_t curl_getdate(const char p, const time_t unused);
2831
2832	/* info about the certificate chain, for SSL backends that support it. Asked
2833	for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */
2834	struct curl_certinfo {
2835	int num_of_certs; /* number of certificates with information */
2836	struct curl_slist *certinfo; / for each index in this array, there's a
2837	linked list with textual information for a
2838	certificate in the format "name:content".
2839	eg "Subject:foo", "Issuer:bar", etc. */
2840	};
2841
2842	/* Information about the SSL library used and the respective internal SSL
2843	handle, which can be used to obtain further information regarding the
2844	connection. Asked for with CURLINFO_TLS_SSL_PTR or CURLINFO_TLS_SESSION. */
2845	struct curl_tlssessioninfo {
2846	curl_sslbackend backend;
2847	void *internals;
2848	};
2849
2850	#define CURLINFO_STRING 0x100000
2851	#define CURLINFO_LONG 0x200000
2852	#define CURLINFO_DOUBLE 0x300000
2853	#define CURLINFO_SLIST 0x400000
2854	#define CURLINFO_PTR 0x400000 /* same as SLIST */
2855	#define CURLINFO_SOCKET 0x500000
2856	#define CURLINFO_OFF_T 0x600000
2857	#define CURLINFO_MASK 0x0fffff
2858	#define CURLINFO_TYPEMASK 0xf00000
2859
2860	typedef enum {
2861	CURLINFO_NONE, /* first, never use this */
2862	CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1,
2863	CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2,
2864	CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3,
2865	CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4,
2866	CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5,
2867	CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
2868	CURLINFO_SIZE_UPLOAD CURL_DEPRECATED(7.55.0, "Use CURLINFO_SIZE_UPLOAD_T")
2869	= CURLINFO_DOUBLE + 7,
2870	CURLINFO_SIZE_UPLOAD_T = CURLINFO_OFF_T + 7,
2871	CURLINFO_SIZE_DOWNLOAD
2872	CURL_DEPRECATED(7.55.0, "Use CURLINFO_SIZE_DOWNLOAD_T")
2873	= CURLINFO_DOUBLE + 8,
2874	CURLINFO_SIZE_DOWNLOAD_T = CURLINFO_OFF_T + 8,
2875	CURLINFO_SPEED_DOWNLOAD
2876	CURL_DEPRECATED(7.55.0, "Use CURLINFO_SPEED_DOWNLOAD_T")
2877	= CURLINFO_DOUBLE + 9,
2878	CURLINFO_SPEED_DOWNLOAD_T = CURLINFO_OFF_T + 9,
2879	CURLINFO_SPEED_UPLOAD
2880	CURL_DEPRECATED(7.55.0, "Use CURLINFO_SPEED_UPLOAD_T")
2881	= CURLINFO_DOUBLE + 10,
2882	CURLINFO_SPEED_UPLOAD_T = CURLINFO_OFF_T + 10,
2883	CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11,
2884	CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12,
2885	CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13,
2886	CURLINFO_FILETIME = CURLINFO_LONG + 14,
2887	CURLINFO_FILETIME_T = CURLINFO_OFF_T + 14,
2888	CURLINFO_CONTENT_LENGTH_DOWNLOAD
2889	CURL_DEPRECATED(7.55.0,
2890	"Use CURLINFO_CONTENT_LENGTH_DOWNLOAD_T")
2891	= CURLINFO_DOUBLE + 15,
2892	CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = CURLINFO_OFF_T + 15,
2893	CURLINFO_CONTENT_LENGTH_UPLOAD
2894	CURL_DEPRECATED(7.55.0,
2895	"Use CURLINFO_CONTENT_LENGTH_UPLOAD_T")
2896	= CURLINFO_DOUBLE + 16,
2897	CURLINFO_CONTENT_LENGTH_UPLOAD_T = CURLINFO_OFF_T + 16,
2898	CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
2899	CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18,
2900	CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19,
2901	CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20,
2902	CURLINFO_PRIVATE = CURLINFO_STRING + 21,
2903	CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22,
2904	CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23,
2905	CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24,
2906	CURLINFO_OS_ERRNO = CURLINFO_LONG + 25,
2907	CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26,
2908	CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27,
2909	CURLINFO_COOKIELIST = CURLINFO_SLIST + 28,
2910	CURLINFO_LASTSOCKET CURL_DEPRECATED(7.45.0, "Use CURLINFO_ACTIVESOCKET")
2911	= CURLINFO_LONG + 29,
2912	CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30,
2913	CURLINFO_REDIRECT_URL = CURLINFO_STRING + 31,
2914	CURLINFO_PRIMARY_IP = CURLINFO_STRING + 32,
2915	CURLINFO_APPCONNECT_TIME = CURLINFO_DOUBLE + 33,
2916	CURLINFO_CERTINFO = CURLINFO_PTR + 34,
2917	CURLINFO_CONDITION_UNMET = CURLINFO_LONG + 35,
2918	CURLINFO_RTSP_SESSION_ID = CURLINFO_STRING + 36,
2919	CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG + 37,
2920	CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG + 38,
2921	CURLINFO_RTSP_CSEQ_RECV = CURLINFO_LONG + 39,
2922	CURLINFO_PRIMARY_PORT = CURLINFO_LONG + 40,
2923	CURLINFO_LOCAL_IP = CURLINFO_STRING + 41,
2924	CURLINFO_LOCAL_PORT = CURLINFO_LONG + 42,
2925	CURLINFO_TLS_SESSION CURL_DEPRECATED(7.48.0, "Use CURLINFO_TLS_SSL_PTR")
2926	= CURLINFO_PTR + 43,
2927	CURLINFO_ACTIVESOCKET = CURLINFO_SOCKET + 44,
2928	CURLINFO_TLS_SSL_PTR = CURLINFO_PTR + 45,
2929	CURLINFO_HTTP_VERSION = CURLINFO_LONG + 46,
2930	CURLINFO_PROXY_SSL_VERIFYRESULT = CURLINFO_LONG + 47,
2931	CURLINFO_PROTOCOL CURL_DEPRECATED(7.85.0, "Use CURLINFO_SCHEME")
2932	= CURLINFO_LONG + 48,
2933	CURLINFO_SCHEME = CURLINFO_STRING + 49,
2934	CURLINFO_TOTAL_TIME_T = CURLINFO_OFF_T + 50,
2935	CURLINFO_NAMELOOKUP_TIME_T = CURLINFO_OFF_T + 51,
2936	CURLINFO_CONNECT_TIME_T = CURLINFO_OFF_T + 52,
2937	CURLINFO_PRETRANSFER_TIME_T = CURLINFO_OFF_T + 53,
2938	CURLINFO_STARTTRANSFER_TIME_T = CURLINFO_OFF_T + 54,
2939	CURLINFO_REDIRECT_TIME_T = CURLINFO_OFF_T + 55,
2940	CURLINFO_APPCONNECT_TIME_T = CURLINFO_OFF_T + 56,
2941	CURLINFO_RETRY_AFTER = CURLINFO_OFF_T + 57,
2942	CURLINFO_EFFECTIVE_METHOD = CURLINFO_STRING + 58,
2943	CURLINFO_PROXY_ERROR = CURLINFO_LONG + 59,
2944	CURLINFO_REFERER = CURLINFO_STRING + 60,
2945	CURLINFO_CAINFO = CURLINFO_STRING + 61,
2946	CURLINFO_CAPATH = CURLINFO_STRING + 62,
2947	CURLINFO_XFER_ID = CURLINFO_OFF_T + 63,
2948	CURLINFO_CONN_ID = CURLINFO_OFF_T + 64,
2949	CURLINFO_LASTONE = 64
2950	} CURLINFO;
2951
2952	/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as
2953	CURLINFO_HTTP_CODE */
2954	#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE
2955
2956	typedef enum {
2957	CURLCLOSEPOLICY_NONE, /* first, never use this */
2958
2959	CURLCLOSEPOLICY_OLDEST,
2960	CURLCLOSEPOLICY_LEAST_RECENTLY_USED,
2961	CURLCLOSEPOLICY_LEAST_TRAFFIC,
2962	CURLCLOSEPOLICY_SLOWEST,
2963	CURLCLOSEPOLICY_CALLBACK,
2964
2965	CURLCLOSEPOLICY_LAST /* last, never use this */
2966	} curl_closepolicy;
2967
2968	#define CURL_GLOBAL_SSL (1<<0) /* no purpose since 7.57.0 */
2969	#define CURL_GLOBAL_WIN32 (1<<1)
2970	#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL\|CURL_GLOBAL_WIN32)
2971	#define CURL_GLOBAL_NOTHING 0
2972	#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL
2973	#define CURL_GLOBAL_ACK_EINTR (1<<2)
2974
2975
2976	/*****************************************************************************
2977	* Setup defines, protos etc for the sharing stuff.
2978	*/
2979
2980	/* Different data locks for a single share */
2981	typedef enum {
2982	CURL_LOCK_DATA_NONE = 0,
2983	/* CURL_LOCK_DATA_SHARE is used internally to say that
2984	* the locking is just made to change the internal state of the share
2985	* itself.
2986	*/
2987	CURL_LOCK_DATA_SHARE,
2988	CURL_LOCK_DATA_COOKIE,
2989	CURL_LOCK_DATA_DNS,
2990	CURL_LOCK_DATA_SSL_SESSION,
2991	CURL_LOCK_DATA_CONNECT,
2992	CURL_LOCK_DATA_PSL,
2993	CURL_LOCK_DATA_HSTS,
2994	CURL_LOCK_DATA_LAST
2995	} curl_lock_data;
2996
2997	/* Different lock access types */
2998	typedef enum {
2999	CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */
3000	CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */
3001	CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */
3002	CURL_LOCK_ACCESS_LAST /* never use */
3003	} curl_lock_access;
3004
3005	typedef void (curl_lock_function)(CURL handle,
3006	curl_lock_data data,
3007	curl_lock_access locktype,
3008	void *userptr);
3009	typedef void (curl_unlock_function)(CURL handle,
3010	curl_lock_data data,
3011	void *userptr);
3012
3013
3014	typedef enum {
3015	CURLSHE_OK, /* all is fine */
3016	CURLSHE_BAD_OPTION, /* 1 */
3017	CURLSHE_IN_USE, /* 2 */
3018	CURLSHE_INVALID, /* 3 */
3019	CURLSHE_NOMEM, /* 4 out of memory */
3020	CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */
3021	CURLSHE_LAST /* never use */
3022	} CURLSHcode;
3023
3024	typedef enum {
3025	CURLSHOPT_NONE, /* don't use */
3026	CURLSHOPT_SHARE, /* specify a data type to share */
3027	CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */
3028	CURLSHOPT_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */
3029	CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */
3030	CURLSHOPT_USERDATA, /* pass in a user data pointer used in the lock/unlock
3031	callback functions */
3032	CURLSHOPT_LAST /* never use */
3033	} CURLSHoption;
3034
3035	CURL_EXTERN CURLSH *curl_share_init(void);
3036	CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *share, CURLSHoption option,
3037	...);
3038	CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *share);
3039
3040	/****************************************************************************
3041	* Structures for querying information about the curl library at runtime.
3042	*/
3043
3044	typedef enum {
3045	CURLVERSION_FIRST,
3046	CURLVERSION_SECOND,
3047	CURLVERSION_THIRD,
3048	CURLVERSION_FOURTH,
3049	CURLVERSION_FIFTH,
3050	CURLVERSION_SIXTH,
3051	CURLVERSION_SEVENTH,
3052	CURLVERSION_EIGHTH,
3053	CURLVERSION_NINTH,
3054	CURLVERSION_TENTH,
3055	CURLVERSION_ELEVENTH,
3056	CURLVERSION_LAST /* never actually use this */
3057	} CURLversion;
3058
3059	/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by
3060	basically all programs ever that want to get version information. It is
3061	meant to be a built-in version number for what kind of struct the caller
3062	expects. If the struct ever changes, we redefine the NOW to another enum
3063	from above. */
3064	#define CURLVERSION_NOW CURLVERSION_ELEVENTH
3065
3066	struct curl_version_info_data {
3067	CURLversion age; /* age of the returned struct */
3068	const char version; / LIBCURL_VERSION */
3069	unsigned int version_num; /* LIBCURL_VERSION_NUM */
3070	const char host; / OS/host/cpu/machine when configured */
3071	int features; /* bitmask, see defines below */
3072	const char ssl_version; / human readable string */
3073	long ssl_version_num; /* not used anymore, always 0 */
3074	const char libz_version; / human readable string */
3075	/* protocols is terminated by an entry with a NULL protoname */
3076	const char * const *protocols;
3077
3078	/* The fields below this were added in CURLVERSION_SECOND */
3079	const char *ares;
3080	int ares_num;
3081
3082	/* This field was added in CURLVERSION_THIRD */
3083	const char *libidn;
3084
3085	/* These field were added in CURLVERSION_FOURTH */
3086
3087	/* Same as '_libiconv_version' if built with HAVE_ICONV */
3088	int iconv_ver_num;
3089
3090	const char libssh_version; / human readable string */
3091
3092	/* These fields were added in CURLVERSION_FIFTH */
3093	unsigned int brotli_ver_num; /* Numeric Brotli version
3094	(MAJOR << 24) \| (MINOR << 12) \| PATCH */
3095	const char brotli_version; / human readable string. */
3096
3097	/* These fields were added in CURLVERSION_SIXTH */
3098	unsigned int nghttp2_ver_num; /* Numeric nghttp2 version
3099	(MAJOR << 16) \| (MINOR << 8) \| PATCH */
3100	const char nghttp2_version; / human readable string. */
3101	const char quic_version; / human readable quic (+ HTTP/3) library +
3102	version or NULL */
3103
3104	/* These fields were added in CURLVERSION_SEVENTH */
3105	const char cainfo; / the built-in default CURLOPT_CAINFO, might
3106	be NULL */
3107	const char capath; / the built-in default CURLOPT_CAPATH, might
3108	be NULL */
3109
3110	/* These fields were added in CURLVERSION_EIGHTH */
3111	unsigned int zstd_ver_num; /* Numeric Zstd version
3112	(MAJOR << 24) \| (MINOR << 12) \| PATCH */
3113	const char zstd_version; / human readable string. */
3114
3115	/* These fields were added in CURLVERSION_NINTH */
3116	const char hyper_version; / human readable string. */
3117
3118	/* These fields were added in CURLVERSION_TENTH */
3119	const char gsasl_version; / human readable string. */
3120
3121	/* These fields were added in CURLVERSION_ELEVENTH */
3122	/* feature_names is terminated by an entry with a NULL feature name */
3123	const char * const *feature_names;
3124	};
3125	typedef struct curl_version_info_data curl_version_info_data;
3126
3127	#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */
3128	#define CURL_VERSION_KERBEROS4 (1<<1) /* Kerberos V4 auth is supported
3129	(deprecated) */
3130	#define CURL_VERSION_SSL (1<<2) /* SSL options are present */
3131	#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */
3132	#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */
3133	#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth is supported
3134	(deprecated) */
3135	#define CURL_VERSION_DEBUG (1<<6) /* Built with debug capabilities */
3136	#define CURL_VERSION_ASYNCHDNS (1<<7) /* Asynchronous DNS resolves */
3137	#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth is supported */
3138	#define CURL_VERSION_LARGEFILE (1<<9) /* Supports files larger than 2GB */
3139	#define CURL_VERSION_IDN (1<<10) /* Internationized Domain Names are
3140	supported */
3141	#define CURL_VERSION_SSPI (1<<11) /* Built against Windows SSPI */
3142	#define CURL_VERSION_CONV (1<<12) /* Character conversions supported */
3143	#define CURL_VERSION_CURLDEBUG (1<<13) /* Debug memory tracking supported */
3144	#define CURL_VERSION_TLSAUTH_SRP (1<<14) /* TLS-SRP auth is supported */
3145	#define CURL_VERSION_NTLM_WB (1<<15) /* NTLM delegation to winbind helper
3146	is supported */
3147	#define CURL_VERSION_HTTP2 (1<<16) /* HTTP2 support built-in */
3148	#define CURL_VERSION_GSSAPI (1<<17) /* Built against a GSS-API library */
3149	#define CURL_VERSION_KERBEROS5 (1<<18) /* Kerberos V5 auth is supported */
3150	#define CURL_VERSION_UNIX_SOCKETS (1<<19) /* Unix domain sockets support */
3151	#define CURL_VERSION_PSL (1<<20) /* Mozilla's Public Suffix List, used
3152	for cookie domain verification */
3153	#define CURL_VERSION_HTTPS_PROXY (1<<21) /* HTTPS-proxy support built-in */
3154	#define CURL_VERSION_MULTI_SSL (1<<22) /* Multiple SSL backends available */
3155	#define CURL_VERSION_BROTLI (1<<23) /* Brotli features are present. */
3156	#define CURL_VERSION_ALTSVC (1<<24) /* Alt-Svc handling built-in */
3157	#define CURL_VERSION_HTTP3 (1<<25) /* HTTP3 support built-in */
3158	#define CURL_VERSION_ZSTD (1<<26) /* zstd features are present */
3159	#define CURL_VERSION_UNICODE (1<<27) /* Unicode support on Windows */
3160	#define CURL_VERSION_HSTS (1<<28) /* HSTS is supported */
3161	#define CURL_VERSION_GSASL (1<<29) /* libgsasl is supported */
3162	#define CURL_VERSION_THREADSAFE (1<<30) /* libcurl API is thread-safe */
3163
3164	/*
3165	* NAME curl_version_info()
3166	*
3167	* DESCRIPTION
3168	*
3169	* This function returns a pointer to a static copy of the version info
3170	* struct. See above.
3171	*/
3172	CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion);
3173
3174	/*
3175	* NAME curl_easy_strerror()
3176	*
3177	* DESCRIPTION
3178	*
3179	* The curl_easy_strerror function may be used to turn a CURLcode value
3180	* into the equivalent human readable error string. This is useful
3181	* for printing meaningful error messages.
3182	*/
3183	CURL_EXTERN const char *curl_easy_strerror(CURLcode);
3184
3185	/*
3186	* NAME curl_share_strerror()
3187	*
3188	* DESCRIPTION
3189	*
3190	* The curl_share_strerror function may be used to turn a CURLSHcode value
3191	* into the equivalent human readable error string. This is useful
3192	* for printing meaningful error messages.
3193	*/
3194	CURL_EXTERN const char *curl_share_strerror(CURLSHcode);
3195
3196	/*
3197	* NAME curl_easy_pause()
3198	*
3199	* DESCRIPTION
3200	*
3201	* The curl_easy_pause function pauses or unpauses transfers. Select the new
3202	* state by setting the bitmask, use the convenience defines below.
3203	*
3204	*/
3205	CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask);
3206
3207	#define CURLPAUSE_RECV (1<<0)
3208	#define CURLPAUSE_RECV_CONT (0)
3209
3210	#define CURLPAUSE_SEND (1<<2)
3211	#define CURLPAUSE_SEND_CONT (0)
3212
3213	#define CURLPAUSE_ALL (CURLPAUSE_RECV\|CURLPAUSE_SEND)
3214	#define CURLPAUSE_CONT (CURLPAUSE_RECV_CONT\|CURLPAUSE_SEND_CONT)
3215
3216	#ifdef __cplusplus
3217	} /* end of extern "C" */
3218	#endif
3219
3220	/* unfortunately, the easy.h and multi.h include files need options and info
3221	stuff before they can be included! */
3222	#include "easy.h" /* nothing in curl is fun without the easy stuff */
3223	#include "multi.h"
3224	#include "urlapi.h"
3225	#include "options.h"
3226	#include "header.h"
3227	#include "websockets.h"
3228
3229	/* the typechecker doesn't work in C++ (yet) */
3230	#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \
3231	((__GNUC__ > 4) \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \
3232	!defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK)
3233	#include "typecheck-gcc.h"
3234	#else
3235	#if defined(__STDC__) && (__STDC__ >= 1)
3236	/* This preprocessor magic that replaces a call with the exact same call is
3237	only done to make sure application authors pass exactly three arguments
3238	to these functions. */
3239	#define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param)
3240	#define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg)
3241	#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
3242	#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
3243	#endif /* __STDC__ >= 1 */
3244	#endif /* gcc >= 4.3 && !__cplusplus && !CURL_DISABLE_TYPECHECK */
3245
3246	#endif /* CURLINC_CURL_H */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/curl-8.3.0/include/curl/curl.h@ 101298

Download in other formats: