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