1 #ifndef HEADER_CURL_URLDATA_H 2 #define HEADER_CURL_URLDATA_H 3 /*************************************************************************** 4 * _ _ ____ _ 5 * Project ___| | | | _ \| | 6 * / __| | | | |_) | | 7 * | (__| |_| | _ <| |___ 8 * \___|\___/|_| \_\_____| 9 * 10 * Copyright (C) 1998 - 2018, Daniel Stenberg, <daniel@haxx.se>, et al. 11 * 12 * This software is licensed as described in the file COPYING, which 13 * you should have received as part of this distribution. The terms 14 * are also available at https://curl.haxx.se/docs/copyright.html. 15 * 16 * You may opt to use, copy, modify, merge, publish, distribute and/or sell 17 * copies of the Software, and permit persons to whom the Software is 18 * furnished to do so, under the terms of the COPYING file. 19 * 20 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY 21 * KIND, either express or implied. 22 * 23 ***************************************************************************/ 24 25 /* This file is for lib internal stuff */ 26 27 #include "curl_setup.h" 28 29 #define PORT_FTP 21 30 #define PORT_FTPS 990 31 #define PORT_TELNET 23 32 #define PORT_HTTP 80 33 #define PORT_HTTPS 443 34 #define PORT_DICT 2628 35 #define PORT_LDAP 389 36 #define PORT_LDAPS 636 37 #define PORT_TFTP 69 38 #define PORT_SSH 22 39 #define PORT_IMAP 143 40 #define PORT_IMAPS 993 41 #define PORT_POP3 110 42 #define PORT_POP3S 995 43 #define PORT_SMB 445 44 #define PORT_SMBS 445 45 #define PORT_SMTP 25 46 #define PORT_SMTPS 465 /* sometimes called SSMTP */ 47 #define PORT_RTSP 554 48 #define PORT_RTMP 1935 49 #define PORT_RTMPT PORT_HTTP 50 #define PORT_RTMPS PORT_HTTPS 51 #define PORT_GOPHER 70 52 53 #define DICT_MATCH "/MATCH:" 54 #define DICT_MATCH2 "/M:" 55 #define DICT_MATCH3 "/FIND:" 56 #define DICT_DEFINE "/DEFINE:" 57 #define DICT_DEFINE2 "/D:" 58 #define DICT_DEFINE3 "/LOOKUP:" 59 60 #define CURL_DEFAULT_USER "anonymous" 61 #define CURL_DEFAULT_PASSWORD "ftp@example.com" 62 63 /* Convenience defines for checking protocols or their SSL based version. Each 64 protocol handler should only ever have a single CURLPROTO_ in its protocol 65 field. */ 66 #define PROTO_FAMILY_HTTP (CURLPROTO_HTTP|CURLPROTO_HTTPS) 67 #define PROTO_FAMILY_FTP (CURLPROTO_FTP|CURLPROTO_FTPS) 68 #define PROTO_FAMILY_POP3 (CURLPROTO_POP3|CURLPROTO_POP3S) 69 #define PROTO_FAMILY_SMB (CURLPROTO_SMB|CURLPROTO_SMBS) 70 #define PROTO_FAMILY_SMTP (CURLPROTO_SMTP|CURLPROTO_SMTPS) 71 72 #define DEFAULT_CONNCACHE_SIZE 5 73 74 /* length of longest IPv6 address string including the trailing null */ 75 #define MAX_IPADR_LEN sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255") 76 77 /* Default FTP/IMAP etc response timeout in milliseconds. 78 Symbian OS panics when given a timeout much greater than 1/2 hour. 79 */ 80 #define RESP_TIMEOUT (1800*1000) 81 82 #include "cookie.h" 83 #include "formdata.h" 84 85 #ifdef HAVE_NETINET_IN_H 86 #include <netinet/in.h> 87 #endif 88 #ifdef HAVE_NETINET_IN6_H 89 #include <netinet/in6.h> 90 #endif 91 92 #include "timeval.h" 93 94 #include <curl/curl.h> 95 96 #include "http_chunks.h" /* for the structs and enum stuff */ 97 #include "hostip.h" 98 #include "hash.h" 99 #include "splay.h" 100 101 #include "mime.h" 102 #include "imap.h" 103 #include "pop3.h" 104 #include "smtp.h" 105 #include "ftp.h" 106 #include "file.h" 107 #include "ssh.h" 108 #include "http.h" 109 #include "rtsp.h" 110 #include "smb.h" 111 #include "wildcard.h" 112 #include "multihandle.h" 113 114 #ifdef HAVE_GSSAPI 115 # ifdef HAVE_GSSGNU 116 # include <gss.h> 117 # elif defined HAVE_GSSMIT 118 # include <gssapi/gssapi.h> 119 # include <gssapi/gssapi_generic.h> 120 # else 121 # include <gssapi.h> 122 # endif 123 #endif 124 125 #ifdef HAVE_LIBSSH2_H 126 #include <libssh2.h> 127 #include <libssh2_sftp.h> 128 #endif /* HAVE_LIBSSH2_H */ 129 130 /* The upload buffer size, should not be smaller than CURL_MAX_WRITE_SIZE, as 131 it needs to hold a full buffer as could be sent in a write callback */ 132 #define UPLOAD_BUFSIZE CURL_MAX_WRITE_SIZE 133 134 /* The "master buffer" is for HTTP pipelining */ 135 #define MASTERBUF_SIZE 16384 136 137 /* Initial size of the buffer to store headers in, it'll be enlarged in case 138 of need. */ 139 #define HEADERSIZE 256 140 141 #define CURLEASY_MAGIC_NUMBER 0xc0dedbadU 142 #define GOOD_EASY_HANDLE(x) \ 143 ((x) && ((x)->magic == CURLEASY_MAGIC_NUMBER)) 144 145 /* Some convenience macros to get the larger/smaller value out of two given. 146 We prefix with CURL to prevent name collisions. */ 147 #define CURLMAX(x,y) ((x)>(y)?(x):(y)) 148 #define CURLMIN(x,y) ((x)<(y)?(x):(y)) 149 150 #ifdef HAVE_GSSAPI 151 /* Types needed for krb5-ftp connections */ 152 struct krb5buffer { 153 void *data; 154 size_t size; 155 size_t index; 156 int eof_flag; 157 }; 158 159 enum protection_level { 160 PROT_NONE, /* first in list */ 161 PROT_CLEAR, 162 PROT_SAFE, 163 PROT_CONFIDENTIAL, 164 PROT_PRIVATE, 165 PROT_CMD, 166 PROT_LAST /* last in list */ 167 }; 168 #endif 169 170 /* enum for the nonblocking SSL connection state machine */ 171 typedef enum { 172 ssl_connect_1, 173 ssl_connect_2, 174 ssl_connect_2_reading, 175 ssl_connect_2_writing, 176 ssl_connect_3, 177 ssl_connect_done 178 } ssl_connect_state; 179 180 typedef enum { 181 ssl_connection_none, 182 ssl_connection_negotiating, 183 ssl_connection_complete 184 } ssl_connection_state; 185 186 /* SSL backend-specific data; declared differently by each SSL backend */ 187 struct ssl_backend_data; 188 189 /* struct for data related to each SSL connection */ 190 struct ssl_connect_data { 191 /* Use ssl encrypted communications TRUE/FALSE, not necessarily using it atm 192 but at least asked to or meaning to use it. See 'state' for the exact 193 current state of the connection. */ 194 bool use; 195 ssl_connection_state state; 196 ssl_connect_state connecting_state; 197 #if defined(USE_SSL) 198 struct ssl_backend_data *backend; 199 #endif 200 }; 201 202 struct ssl_primary_config { 203 long version; /* what version the client wants to use */ 204 long version_max; /* max supported version the client wants to use*/ 205 bool verifypeer; /* set TRUE if this is desired */ 206 bool verifyhost; /* set TRUE if CN/SAN must match hostname */ 207 bool verifystatus; /* set TRUE if certificate status must be checked */ 208 bool sessionid; /* cache session IDs or not */ 209 char *CApath; /* certificate dir (doesn't work on windows) */ 210 char *CAfile; /* certificate to verify peer against */ 211 char *clientcert; 212 char *random_file; /* path to file containing "random" data */ 213 char *egdsocket; /* path to file containing the EGD daemon socket */ 214 char *cipher_list; /* list of ciphers to use */ 215 }; 216 217 struct ssl_config_data { 218 struct ssl_primary_config primary; 219 bool enable_beast; /* especially allow this flaw for interoperability's 220 sake*/ 221 bool no_revoke; /* disable SSL certificate revocation checks */ 222 long certverifyresult; /* result from the certificate verification */ 223 char *CRLfile; /* CRL to check certificate revocation */ 224 char *issuercert;/* optional issuer certificate filename */ 225 curl_ssl_ctx_callback fsslctx; /* function to initialize ssl ctx */ 226 void *fsslctxp; /* parameter for call back */ 227 bool certinfo; /* gather lots of certificate info */ 228 bool falsestart; 229 230 char *cert; /* client certificate file name */ 231 char *cert_type; /* format for certificate (default: PEM)*/ 232 char *key; /* private key file name */ 233 char *key_type; /* format for private key (default: PEM) */ 234 char *key_passwd; /* plain text private key password */ 235 236 #ifdef USE_TLS_SRP 237 char *username; /* TLS username (for, e.g., SRP) */ 238 char *password; /* TLS password (for, e.g., SRP) */ 239 enum CURL_TLSAUTH authtype; /* TLS authentication type (default SRP) */ 240 #endif 241 }; 242 243 struct ssl_general_config { 244 size_t max_ssl_sessions; /* SSL session id cache size */ 245 }; 246 247 /* information stored about one single SSL session */ 248 struct curl_ssl_session { 249 char *name; /* host name for which this ID was used */ 250 char *conn_to_host; /* host name for the connection (may be NULL) */ 251 const char *scheme; /* protocol scheme used */ 252 void *sessionid; /* as returned from the SSL layer */ 253 size_t idsize; /* if known, otherwise 0 */ 254 long age; /* just a number, the higher the more recent */ 255 int remote_port; /* remote port */ 256 int conn_to_port; /* remote port for the connection (may be -1) */ 257 struct ssl_primary_config ssl_config; /* setup for this session */ 258 }; 259 260 #ifdef USE_WINDOWS_SSPI 261 #include "curl_sspi.h" 262 #endif 263 264 /* Struct used for Digest challenge-response authentication */ 265 struct digestdata { 266 #if defined(USE_WINDOWS_SSPI) 267 BYTE *input_token; 268 size_t input_token_len; 269 CtxtHandle *http_context; 270 /* copy of user/passwd used to make the identity for http_context. 271 either may be NULL. */ 272 char *user; 273 char *passwd; 274 #else 275 char *nonce; 276 char *cnonce; 277 char *realm; 278 int algo; 279 bool stale; /* set true for re-negotiation */ 280 char *opaque; 281 char *qop; 282 char *algorithm; 283 int nc; /* nounce count */ 284 bool userhash; 285 #endif 286 }; 287 288 typedef enum { 289 NTLMSTATE_NONE, 290 NTLMSTATE_TYPE1, 291 NTLMSTATE_TYPE2, 292 NTLMSTATE_TYPE3, 293 NTLMSTATE_LAST 294 } curlntlm; 295 296 #if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV) 297 #include <iconv.h> 298 #endif 299 300 /* Struct used for GSSAPI (Kerberos V5) authentication */ 301 #if defined(USE_KERBEROS5) 302 struct kerberos5data { 303 #if defined(USE_WINDOWS_SSPI) 304 CredHandle *credentials; 305 CtxtHandle *context; 306 TCHAR *spn; 307 SEC_WINNT_AUTH_IDENTITY identity; 308 SEC_WINNT_AUTH_IDENTITY *p_identity; 309 size_t token_max; 310 BYTE *output_token; 311 #else 312 gss_ctx_id_t context; 313 gss_name_t spn; 314 #endif 315 }; 316 #endif 317 318 /* Struct used for NTLM challenge-response authentication */ 319 #if defined(USE_NTLM) 320 struct ntlmdata { 321 curlntlm state; 322 #ifdef USE_WINDOWS_SSPI 323 CredHandle *credentials; 324 CtxtHandle *context; 325 SEC_WINNT_AUTH_IDENTITY identity; 326 SEC_WINNT_AUTH_IDENTITY *p_identity; 327 size_t token_max; 328 BYTE *output_token; 329 BYTE *input_token; 330 size_t input_token_len; 331 #else 332 unsigned int flags; 333 unsigned char nonce[8]; 334 void *target_info; /* TargetInfo received in the ntlm type-2 message */ 335 unsigned int target_info_len; 336 #endif 337 }; 338 #endif 339 340 #ifdef USE_SPNEGO 341 struct negotiatedata { 342 /* When doing Negotiate (SPNEGO) auth, we first need to send a token 343 and then validate the received one. */ 344 enum { GSS_AUTHNONE, GSS_AUTHRECV, GSS_AUTHSENT } state; 345 #ifdef HAVE_GSSAPI 346 OM_uint32 status; 347 gss_ctx_id_t context; 348 gss_name_t spn; 349 gss_buffer_desc output_token; 350 #else 351 #ifdef USE_WINDOWS_SSPI 352 DWORD status; 353 CredHandle *credentials; 354 CtxtHandle *context; 355 SEC_WINNT_AUTH_IDENTITY identity; 356 SEC_WINNT_AUTH_IDENTITY *p_identity; 357 TCHAR *spn; 358 size_t token_max; 359 BYTE *output_token; 360 size_t output_token_length; 361 #endif 362 #endif 363 }; 364 #endif 365 366 367 /* 368 * Boolean values that concerns this connection. 369 */ 370 struct ConnectBits { 371 /* always modify bits.close with the connclose() and connkeep() macros! */ 372 bool close; /* if set, we close the connection after this request */ 373 bool reuse; /* if set, this is a re-used connection */ 374 bool conn_to_host; /* if set, this connection has a "connect to host" 375 that overrides the host in the URL */ 376 bool conn_to_port; /* if set, this connection has a "connect to port" 377 that overrides the port in the URL (remote port) */ 378 bool proxy; /* if set, this transfer is done through a proxy - any type */ 379 bool httpproxy; /* if set, this transfer is done through a http proxy */ 380 bool socksproxy; /* if set, this transfer is done through a socks proxy */ 381 bool user_passwd; /* do we use user+password for this connection? */ 382 bool proxy_user_passwd; /* user+password for the proxy? */ 383 bool ipv6_ip; /* we communicate with a remote site specified with pure IPv6 384 IP address */ 385 bool ipv6; /* we communicate with a site using an IPv6 address */ 386 387 bool do_more; /* this is set TRUE if the ->curl_do_more() function is 388 supposed to be called, after ->curl_do() */ 389 bool tcpconnect[2]; /* the TCP layer (or similar) is connected, this is set 390 the first time on the first connect function call */ 391 bool protoconnstart;/* the protocol layer has STARTED its operation after 392 the TCP layer connect */ 393 394 bool retry; /* this connection is about to get closed and then 395 re-attempted at another connection. */ 396 bool tunnel_proxy; /* if CONNECT is used to "tunnel" through the proxy. 397 This is implicit when SSL-protocols are used through 398 proxies, but can also be enabled explicitly by 399 apps */ 400 bool authneg; /* TRUE when the auth phase has started, which means 401 that we are creating a request with an auth header, 402 but it is not the final request in the auth 403 negotiation. */ 404 bool rewindaftersend;/* TRUE when the sending couldn't be stopped even 405 though it will be discarded. When the whole send 406 operation is done, we must call the data rewind 407 callback. */ 408 bool ftp_use_epsv; /* As set with CURLOPT_FTP_USE_EPSV, but if we find out 409 EPSV doesn't work we disable it for the forthcoming 410 requests */ 411 412 bool ftp_use_eprt; /* As set with CURLOPT_FTP_USE_EPRT, but if we find out 413 EPRT doesn't work we disable it for the forthcoming 414 requests */ 415 bool ftp_use_data_ssl; /* Enabled SSL for the data connection */ 416 bool netrc; /* name+password provided by netrc */ 417 bool userpwd_in_url; /* name+password found in url */ 418 bool stream_was_rewound; /* Indicates that the stream was rewound after a 419 request read past the end of its response byte 420 boundary */ 421 bool proxy_connect_closed; /* set true if a proxy disconnected the 422 connection in a CONNECT request with auth, so 423 that libcurl should reconnect and continue. */ 424 bool bound; /* set true if bind() has already been done on this socket/ 425 connection */ 426 bool type_set; /* type= was used in the URL */ 427 bool multiplex; /* connection is multiplexed */ 428 429 bool tcp_fastopen; /* use TCP Fast Open */ 430 bool tls_enable_npn; /* TLS NPN extension? */ 431 bool tls_enable_alpn; /* TLS ALPN extension? */ 432 bool proxy_ssl_connected[2]; /* TRUE when SSL initialization for HTTPS proxy 433 is complete */ 434 bool socksproxy_connecting; /* connecting through a socks proxy */ 435 }; 436 437 struct hostname { 438 char *rawalloc; /* allocated "raw" version of the name */ 439 char *encalloc; /* allocated IDN-encoded version of the name */ 440 char *name; /* name to use internally, might be encoded, might be raw */ 441 const char *dispname; /* name to display, as 'name' might be encoded */ 442 }; 443 444 /* 445 * Flags on the keepon member of the Curl_transfer_keeper 446 */ 447 448 #define KEEP_NONE 0 449 #define KEEP_RECV (1<<0) /* there is or may be data to read */ 450 #define KEEP_SEND (1<<1) /* there is or may be data to write */ 451 #define KEEP_RECV_HOLD (1<<2) /* when set, no reading should be done but there 452 might still be data to read */ 453 #define KEEP_SEND_HOLD (1<<3) /* when set, no writing should be done but there 454 might still be data to write */ 455 #define KEEP_RECV_PAUSE (1<<4) /* reading is paused */ 456 #define KEEP_SEND_PAUSE (1<<5) /* writing is paused */ 457 458 #define KEEP_RECVBITS (KEEP_RECV | KEEP_RECV_HOLD | KEEP_RECV_PAUSE) 459 #define KEEP_SENDBITS (KEEP_SEND | KEEP_SEND_HOLD | KEEP_SEND_PAUSE) 460 461 462 #ifdef CURLRES_ASYNCH 463 struct Curl_async { 464 char *hostname; 465 int port; 466 struct Curl_dns_entry *dns; 467 bool done; /* set TRUE when the lookup is complete */ 468 int status; /* if done is TRUE, this is the status from the callback */ 469 void *os_specific; /* 'struct thread_data' for Windows */ 470 }; 471 #endif 472 473 #define FIRSTSOCKET 0 474 #define SECONDARYSOCKET 1 475 476 /* These function pointer types are here only to allow easier typecasting 477 within the source when we need to cast between data pointers (such as NULL) 478 and function pointers. */ 479 typedef CURLcode (*Curl_do_more_func)(struct connectdata *, int *); 480 typedef CURLcode (*Curl_done_func)(struct connectdata *, CURLcode, bool); 481 482 enum expect100 { 483 EXP100_SEND_DATA, /* enough waiting, just send the body now */ 484 EXP100_AWAITING_CONTINUE, /* waiting for the 100 Continue header */ 485 EXP100_SENDING_REQUEST, /* still sending the request but will wait for 486 the 100 header once done with the request */ 487 EXP100_FAILED /* used on 417 Expectation Failed */ 488 }; 489 490 enum upgrade101 { 491 UPGR101_INIT, /* default state */ 492 UPGR101_REQUESTED, /* upgrade requested */ 493 UPGR101_RECEIVED, /* response received */ 494 UPGR101_WORKING /* talking upgraded protocol */ 495 }; 496 497 /* 498 * Request specific data in the easy handle (Curl_easy). Previously, 499 * these members were on the connectdata struct but since a conn struct may 500 * now be shared between different Curl_easys, we store connection-specific 501 * data here. This struct only keeps stuff that's interesting for *this* 502 * request, as it will be cleared between multiple ones 503 */ 504 struct SingleRequest { 505 curl_off_t size; /* -1 if unknown at this point */ 506 curl_off_t *bytecountp; /* return number of bytes read or NULL */ 507 508 curl_off_t maxdownload; /* in bytes, the maximum amount of data to fetch, 509 -1 means unlimited */ 510 curl_off_t *writebytecountp; /* return number of bytes written or NULL */ 511 512 curl_off_t bytecount; /* total number of bytes read */ 513 curl_off_t writebytecount; /* number of bytes written */ 514 515 long headerbytecount; /* only count received headers */ 516 long deductheadercount; /* this amount of bytes doesn't count when we check 517 if anything has been transferred at the end of a 518 connection. We use this counter to make only a 519 100 reply (without a following second response 520 code) result in a CURLE_GOT_NOTHING error code */ 521 522 struct curltime start; /* transfer started at this time */ 523 struct curltime now; /* current time */ 524 bool header; /* incoming data has HTTP header */ 525 enum { 526 HEADER_NORMAL, /* no bad header at all */ 527 HEADER_PARTHEADER, /* part of the chunk is a bad header, the rest 528 is normal data */ 529 HEADER_ALLBAD /* all was believed to be header */ 530 } badheader; /* the header was deemed bad and will be 531 written as body */ 532 int headerline; /* counts header lines to better track the 533 first one */ 534 char *hbufp; /* points at *end* of header line */ 535 size_t hbuflen; 536 char *str; /* within buf */ 537 char *str_start; /* within buf */ 538 char *end_ptr; /* within buf */ 539 char *p; /* within headerbuff */ 540 bool content_range; /* set TRUE if Content-Range: was found */ 541 curl_off_t offset; /* possible resume offset read from the 542 Content-Range: header */ 543 int httpcode; /* error code from the 'HTTP/1.? XXX' or 544 'RTSP/1.? XXX' line */ 545 struct curltime start100; /* time stamp to wait for the 100 code from */ 546 enum expect100 exp100; /* expect 100 continue state */ 547 enum upgrade101 upgr101; /* 101 upgrade state */ 548 549 struct contenc_writer_s *writer_stack; /* Content unencoding stack. */ 550 /* See sec 3.5, RFC2616. */ 551 time_t timeofdoc; 552 long bodywrites; 553 554 char *buf; 555 curl_socket_t maxfd; 556 557 int keepon; 558 559 bool upload_done; /* set to TRUE when doing chunked transfer-encoding upload 560 and we're uploading the last chunk */ 561 562 bool ignorebody; /* we read a response-body but we ignore it! */ 563 bool ignorecl; /* This HTTP response has no body so we ignore the Content- 564 Length: header */ 565 566 char *location; /* This points to an allocated version of the Location: 567 header data */ 568 char *newurl; /* Set to the new URL to use when a redirect or a retry is 569 wanted */ 570 571 /* 'upload_present' is used to keep a byte counter of how much data there is 572 still left in the buffer, aimed for upload. */ 573 ssize_t upload_present; 574 575 /* 'upload_fromhere' is used as a read-pointer when we uploaded parts of a 576 buffer, so the next read should read from where this pointer points to, 577 and the 'upload_present' contains the number of bytes available at this 578 position */ 579 char *upload_fromhere; 580 581 bool chunk; /* if set, this is a chunked transfer-encoding */ 582 bool upload_chunky; /* set TRUE if we are doing chunked transfer-encoding 583 on upload */ 584 bool getheader; /* TRUE if header parsing is wanted */ 585 586 bool forbidchunk; /* used only to explicitly forbid chunk-upload for 587 specific upload buffers. See readmoredata() in 588 http.c for details. */ 589 590 void *protop; /* Allocated protocol-specific data. Each protocol 591 handler makes sure this points to data it needs. */ 592 }; 593 594 /* 595 * Specific protocol handler. 596 */ 597 598 struct Curl_handler { 599 const char *scheme; /* URL scheme name. */ 600 601 /* Complement to setup_connection_internals(). */ 602 CURLcode (*setup_connection)(struct connectdata *); 603 604 /* These two functions MUST be set to be protocol dependent */ 605 CURLcode (*do_it)(struct connectdata *, bool *done); 606 Curl_done_func done; 607 608 /* If the curl_do() function is better made in two halves, this 609 * curl_do_more() function will be called afterwards, if set. For example 610 * for doing the FTP stuff after the PASV/PORT command. 611 */ 612 Curl_do_more_func do_more; 613 614 /* This function *MAY* be set to a protocol-dependent function that is run 615 * after the connect() and everything is done, as a step in the connection. 616 * The 'done' pointer points to a bool that should be set to TRUE if the 617 * function completes before return. If it doesn't complete, the caller 618 * should call the curl_connecting() function until it is. 619 */ 620 CURLcode (*connect_it)(struct connectdata *, bool *done); 621 622 /* See above. Currently only used for FTP. */ 623 CURLcode (*connecting)(struct connectdata *, bool *done); 624 CURLcode (*doing)(struct connectdata *, bool *done); 625 626 /* Called from the multi interface during the PROTOCONNECT phase, and it 627 should then return a proper fd set */ 628 int (*proto_getsock)(struct connectdata *conn, 629 curl_socket_t *socks, 630 int numsocks); 631 632 /* Called from the multi interface during the DOING phase, and it should 633 then return a proper fd set */ 634 int (*doing_getsock)(struct connectdata *conn, 635 curl_socket_t *socks, 636 int numsocks); 637 638 /* Called from the multi interface during the DO_MORE phase, and it should 639 then return a proper fd set */ 640 int (*domore_getsock)(struct connectdata *conn, 641 curl_socket_t *socks, 642 int numsocks); 643 644 /* Called from the multi interface during the DO_DONE, PERFORM and 645 WAITPERFORM phases, and it should then return a proper fd set. Not setting 646 this will make libcurl use the generic default one. */ 647 int (*perform_getsock)(const struct connectdata *conn, 648 curl_socket_t *socks, 649 int numsocks); 650 651 /* This function *MAY* be set to a protocol-dependent function that is run 652 * by the curl_disconnect(), as a step in the disconnection. If the handler 653 * is called because the connection has been considered dead, dead_connection 654 * is set to TRUE. 655 */ 656 CURLcode (*disconnect)(struct connectdata *, bool dead_connection); 657 658 /* If used, this function gets called from transfer.c:readwrite_data() to 659 allow the protocol to do extra reads/writes */ 660 CURLcode (*readwrite)(struct Curl_easy *data, struct connectdata *conn, 661 ssize_t *nread, bool *readmore); 662 663 /* This function can perform various checks on the connection. See 664 CONNCHECK_* for more information about the checks that can be performed, 665 and CONNRESULT_* for the results that can be returned. */ 666 unsigned int (*connection_check)(struct connectdata *conn, 667 unsigned int checks_to_perform); 668 669 long defport; /* Default port. */ 670 unsigned int protocol; /* See CURLPROTO_* - this needs to be the single 671 specific protocol bit */ 672 unsigned int flags; /* Extra particular characteristics, see PROTOPT_* */ 673 }; 674 675 #define PROTOPT_NONE 0 /* nothing extra */ 676 #define PROTOPT_SSL (1<<0) /* uses SSL */ 677 #define PROTOPT_DUAL (1<<1) /* this protocol uses two connections */ 678 #define PROTOPT_CLOSEACTION (1<<2) /* need action before socket close */ 679 /* some protocols will have to call the underlying functions without regard to 680 what exact state the socket signals. IE even if the socket says "readable", 681 the send function might need to be called while uploading, or vice versa. 682 */ 683 #define PROTOPT_DIRLOCK (1<<3) 684 #define PROTOPT_NONETWORK (1<<4) /* protocol doesn't use the network! */ 685 #define PROTOPT_NEEDSPWD (1<<5) /* needs a password, and if none is set it 686 gets a default */ 687 #define PROTOPT_NOURLQUERY (1<<6) /* protocol can't handle 688 url query strings (?foo=bar) ! */ 689 #define PROTOPT_CREDSPERREQUEST (1<<7) /* requires login credentials per 690 request instead of per connection */ 691 #define PROTOPT_ALPN_NPN (1<<8) /* set ALPN and/or NPN for this */ 692 #define PROTOPT_STREAM (1<<9) /* a protocol with individual logical streams */ 693 #define PROTOPT_URLOPTIONS (1<<10) /* allow options part in the userinfo field 694 of the URL */ 695 #define PROTOPT_PROXY_AS_HTTP (1<<11) /* allow this non-HTTP scheme over a 696 HTTP proxy as HTTP proxies may know 697 this protocol and act as a gateway */ 698 #define PROTOPT_WILDCARD (1<<12) /* protocol supports wildcard matching */ 699 700 #define CONNCHECK_NONE 0 /* No checks */ 701 #define CONNCHECK_ISDEAD (1<<0) /* Check if the connection is dead. */ 702 703 #define CONNRESULT_NONE 0 /* No extra information. */ 704 #define CONNRESULT_DEAD (1<<0) /* The connection is dead. */ 705 706 /* return the count of bytes sent, or -1 on error */ 707 typedef ssize_t (Curl_send)(struct connectdata *conn, /* connection data */ 708 int sockindex, /* socketindex */ 709 const void *buf, /* data to write */ 710 size_t len, /* max amount to write */ 711 CURLcode *err); /* error to return */ 712 713 /* return the count of bytes read, or -1 on error */ 714 typedef ssize_t (Curl_recv)(struct connectdata *conn, /* connection data */ 715 int sockindex, /* socketindex */ 716 char *buf, /* store data here */ 717 size_t len, /* max amount to read */ 718 CURLcode *err); /* error to return */ 719 720 #ifdef USE_RECV_BEFORE_SEND_WORKAROUND 721 struct postponed_data { 722 char *buffer; /* Temporal store for received data during 723 sending, must be freed */ 724 size_t allocated_size; /* Size of temporal store */ 725 size_t recv_size; /* Size of received data during sending */ 726 size_t recv_processed; /* Size of processed part of postponed data */ 727 #ifdef DEBUGBUILD 728 curl_socket_t bindsock;/* Structure must be bound to specific socket, 729 used only for DEBUGASSERT */ 730 #endif /* DEBUGBUILD */ 731 }; 732 #endif /* USE_RECV_BEFORE_SEND_WORKAROUND */ 733 734 struct proxy_info { 735 struct hostname host; 736 long port; 737 curl_proxytype proxytype; /* what kind of proxy that is in use */ 738 char *user; /* proxy user name string, allocated */ 739 char *passwd; /* proxy password string, allocated */ 740 }; 741 742 #define CONNECT_BUFFER_SIZE 16384 743 744 /* struct for HTTP CONNECT state data */ 745 struct http_connect_state { 746 char connect_buffer[CONNECT_BUFFER_SIZE]; 747 int perline; /* count bytes per line */ 748 int keepon; 749 char *line_start; 750 char *ptr; /* where to store more data */ 751 curl_off_t cl; /* size of content to read and ignore */ 752 bool chunked_encoding; 753 enum { 754 TUNNEL_INIT, /* init/default/no tunnel state */ 755 TUNNEL_CONNECT, /* CONNECT has been sent off */ 756 TUNNEL_COMPLETE /* CONNECT response received completely */ 757 } tunnel_state; 758 bool close_connection; 759 }; 760 761 /* 762 * The connectdata struct contains all fields and variables that should be 763 * unique for an entire connection. 764 */ 765 struct connectdata { 766 /* 'data' is the CURRENT Curl_easy using this connection -- take great 767 caution that this might very well vary between different times this 768 connection is used! */ 769 struct Curl_easy *data; 770 771 struct curl_llist_element bundle_node; /* conncache */ 772 773 /* chunk is for HTTP chunked encoding, but is in the general connectdata 774 struct only because we can do just about any protocol through a HTTP proxy 775 and a HTTP proxy may in fact respond using chunked encoding */ 776 struct Curl_chunker chunk; 777 778 curl_closesocket_callback fclosesocket; /* function closing the socket(s) */ 779 void *closesocket_client; 780 781 bool inuse; /* This is a marker for the connection cache logic. If this is 782 TRUE this handle is being used by one or more easy handles 783 and can only used by any other easy handle without careful 784 consideration (== only for pipelining/multiplexing) and it 785 cannot be used by another multi handle! */ 786 787 /**** Fields set when inited and not modified again */ 788 long connection_id; /* Contains a unique number to make it easier to 789 track the connections in the log output */ 790 791 /* 'dns_entry' is the particular host we use. This points to an entry in the 792 DNS cache and it will not get pruned while locked. It gets unlocked in 793 Curl_done(). This entry will be NULL if the connection is re-used as then 794 there is no name resolve done. */ 795 struct Curl_dns_entry *dns_entry; 796 797 /* 'ip_addr' is the particular IP we connected to. It points to a struct 798 within the DNS cache, so this pointer is only valid as long as the DNS 799 cache entry remains locked. It gets unlocked in Curl_done() */ 800 Curl_addrinfo *ip_addr; 801 Curl_addrinfo *tempaddr[2]; /* for happy eyeballs */ 802 803 /* 'ip_addr_str' is the ip_addr data as a human readable string. 804 It remains available as long as the connection does, which is longer than 805 the ip_addr itself. */ 806 char ip_addr_str[MAX_IPADR_LEN]; 807 808 unsigned int scope_id; /* Scope id for IPv6 */ 809 810 int socktype; /* SOCK_STREAM or SOCK_DGRAM */ 811 812 struct hostname host; 813 char *secondaryhostname; /* secondary socket host name (ftp) */ 814 struct hostname conn_to_host; /* the host to connect to. valid only if 815 bits.conn_to_host is set */ 816 817 struct proxy_info socks_proxy; 818 struct proxy_info http_proxy; 819 820 long port; /* which port to use locally */ 821 int remote_port; /* the remote port, not the proxy port! */ 822 int conn_to_port; /* the remote port to connect to. valid only if 823 bits.conn_to_port is set */ 824 unsigned short secondary_port; /* secondary socket remote port to connect to 825 (ftp) */ 826 827 /* 'primary_ip' and 'primary_port' get filled with peer's numerical 828 ip address and port number whenever an outgoing connection is 829 *attempted* from the primary socket to a remote address. When more 830 than one address is tried for a connection these will hold data 831 for the last attempt. When the connection is actually established 832 these are updated with data which comes directly from the socket. */ 833 834 char primary_ip[MAX_IPADR_LEN]; 835 long primary_port; 836 837 /* 'local_ip' and 'local_port' get filled with local's numerical 838 ip address and port number whenever an outgoing connection is 839 **established** from the primary socket to a remote address. */ 840 841 char local_ip[MAX_IPADR_LEN]; 842 long local_port; 843 844 char *user; /* user name string, allocated */ 845 char *passwd; /* password string, allocated */ 846 char *options; /* options string, allocated */ 847 848 char *oauth_bearer; /* bearer token for OAuth 2.0, allocated */ 849 850 int httpversion; /* the HTTP version*10 reported by the server */ 851 int rtspversion; /* the RTSP version*10 reported by the server */ 852 853 struct curltime now; /* "current" time */ 854 struct curltime created; /* creation time */ 855 curl_socket_t sock[2]; /* two sockets, the second is used for the data 856 transfer when doing FTP */ 857 curl_socket_t tempsock[2]; /* temporary sockets for happy eyeballs */ 858 bool sock_accepted[2]; /* TRUE if the socket on this index was created with 859 accept() */ 860 Curl_recv *recv[2]; 861 Curl_send *send[2]; 862 863 #ifdef USE_RECV_BEFORE_SEND_WORKAROUND 864 struct postponed_data postponed[2]; /* two buffers for two sockets */ 865 #endif /* USE_RECV_BEFORE_SEND_WORKAROUND */ 866 struct ssl_connect_data ssl[2]; /* this is for ssl-stuff */ 867 struct ssl_connect_data proxy_ssl[2]; /* this is for proxy ssl-stuff */ 868 #ifdef USE_SSL 869 void *ssl_extra; /* separately allocated backend-specific data */ 870 #endif 871 struct ssl_primary_config ssl_config; 872 struct ssl_primary_config proxy_ssl_config; 873 bool tls_upgraded; 874 875 struct ConnectBits bits; /* various state-flags for this connection */ 876 877 /* connecttime: when connect() is called on the current IP address. Used to 878 be able to track when to move on to try next IP - but only when the multi 879 interface is used. */ 880 struct curltime connecttime; 881 /* The two fields below get set in Curl_connecthost */ 882 int num_addr; /* number of addresses to try to connect to */ 883 time_t timeoutms_per_addr; /* how long time in milliseconds to spend on 884 trying to connect to each IP address */ 885 886 const struct Curl_handler *handler; /* Connection's protocol handler */ 887 const struct Curl_handler *given; /* The protocol first given */ 888 889 long ip_version; /* copied from the Curl_easy at creation time */ 890 891 /**** curl_get() phase fields */ 892 893 curl_socket_t sockfd; /* socket to read from or CURL_SOCKET_BAD */ 894 curl_socket_t writesockfd; /* socket to write to, it may very 895 well be the same we read from. 896 CURL_SOCKET_BAD disables */ 897 898 /** Dynamicly allocated strings, MUST be freed before this **/ 899 /** struct is killed. **/ 900 struct dynamically_allocated_data { 901 char *proxyuserpwd; 902 char *uagent; 903 char *accept_encoding; 904 char *userpwd; 905 char *rangeline; 906 char *ref; 907 char *host; 908 char *cookiehost; 909 char *rtsp_transport; 910 char *te; /* TE: request header */ 911 } allocptr; 912 913 #ifdef HAVE_GSSAPI 914 int sec_complete; /* if Kerberos is enabled for this connection */ 915 enum protection_level command_prot; 916 enum protection_level data_prot; 917 enum protection_level request_data_prot; 918 size_t buffer_size; 919 struct krb5buffer in_buffer; 920 void *app_data; 921 const struct Curl_sec_client_mech *mech; 922 struct sockaddr_in local_addr; 923 #endif 924 925 #if defined(USE_KERBEROS5) /* Consider moving some of the above GSS-API */ 926 struct kerberos5data krb5; /* variables into the structure definition, */ 927 #endif /* however, some of them are ftp specific. */ 928 929 /* the two following *_inuse fields are only flags, not counters in any way. 930 If TRUE it means the channel is in use, and if FALSE it means the channel 931 is up for grabs by one. */ 932 933 bool readchannel_inuse; /* whether the read channel is in use by an easy 934 handle */ 935 bool writechannel_inuse; /* whether the write channel is in use by an easy 936 handle */ 937 struct curl_llist send_pipe; /* List of handles waiting to send on this 938 pipeline */ 939 struct curl_llist recv_pipe; /* List of handles waiting to read their 940 responses on this pipeline */ 941 char *master_buffer; /* The master buffer allocated on-demand; 942 used for pipelining. */ 943 size_t read_pos; /* Current read position in the master buffer */ 944 size_t buf_len; /* Length of the buffer?? */ 945 946 947 curl_seek_callback seek_func; /* function that seeks the input */ 948 void *seek_client; /* pointer to pass to the seek() above */ 949 950 /*************** Request - specific items ************/ 951 952 #if defined(USE_NTLM) 953 struct ntlmdata ntlm; /* NTLM differs from other authentication schemes 954 because it authenticates connections, not 955 single requests! */ 956 struct ntlmdata proxyntlm; /* NTLM data for proxy */ 957 958 #if defined(NTLM_WB_ENABLED) 959 /* used for communication with Samba's winbind daemon helper ntlm_auth */ 960 curl_socket_t ntlm_auth_hlpr_socket; 961 pid_t ntlm_auth_hlpr_pid; 962 char *challenge_header; 963 char *response_header; 964 #endif 965 #endif 966 967 char syserr_buf [256]; /* buffer for Curl_strerror() */ 968 969 #ifdef CURLRES_ASYNCH 970 /* data used for the asynch name resolve callback */ 971 struct Curl_async async; 972 #endif 973 974 /* These three are used for chunked-encoding trailer support */ 975 char *trailer; /* allocated buffer to store trailer in */ 976 int trlMax; /* allocated buffer size */ 977 int trlPos; /* index of where to store data */ 978 979 union { 980 struct ftp_conn ftpc; 981 struct http_conn httpc; 982 struct ssh_conn sshc; 983 struct tftp_state_data *tftpc; 984 struct imap_conn imapc; 985 struct pop3_conn pop3c; 986 struct smtp_conn smtpc; 987 struct rtsp_conn rtspc; 988 struct smb_conn smbc; 989 void *generic; /* RTMP and LDAP use this */ 990 } proto; 991 992 int cselect_bits; /* bitmask of socket events */ 993 int waitfor; /* current READ/WRITE bits to wait for */ 994 995 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) 996 int socks5_gssapi_enctype; 997 #endif 998 999 /* When this connection is created, store the conditions for the local end 1000 bind. This is stored before the actual bind and before any connection is 1001 made and will serve the purpose of being used for comparison reasons so 1002 that subsequent bound-requested connections aren't accidentally re-using 1003 wrong connections. */ 1004 char *localdev; 1005 unsigned short localport; 1006 int localportrange; 1007 struct http_connect_state *connect_state; /* for HTTP CONNECT */ 1008 struct connectbundle *bundle; /* The bundle we are member of */ 1009 int negnpn; /* APLN or NPN TLS negotiated protocol, CURL_HTTP_VERSION* */ 1010 1011 #ifdef USE_UNIX_SOCKETS 1012 char *unix_domain_socket; 1013 bool abstract_unix_socket; 1014 #endif 1015 }; 1016 1017 /* The end of connectdata. */ 1018 1019 /* 1020 * Struct to keep statistical and informational data. 1021 * All variables in this struct must be initialized/reset in Curl_initinfo(). 1022 */ 1023 struct PureInfo { 1024 int httpcode; /* Recent HTTP, FTP, RTSP or SMTP response code */ 1025 int httpproxycode; /* response code from proxy when received separate */ 1026 int httpversion; /* the http version number X.Y = X*10+Y */ 1027 long filetime; /* If requested, this is might get set. Set to -1 if the time 1028 was unretrievable. We cannot have this of type time_t, 1029 since time_t is unsigned on several platforms such as 1030 OpenVMS. */ 1031 bool timecond; /* set to TRUE if the time condition didn't match, which 1032 thus made the document NOT get fetched */ 1033 long header_size; /* size of read header(s) in bytes */ 1034 long request_size; /* the amount of bytes sent in the request(s) */ 1035 unsigned long proxyauthavail; /* what proxy auth types were announced */ 1036 unsigned long httpauthavail; /* what host auth types were announced */ 1037 long numconnects; /* how many new connection did libcurl created */ 1038 char *contenttype; /* the content type of the object */ 1039 char *wouldredirect; /* URL this would've been redirected to if asked to */ 1040 1041 /* PureInfo members 'conn_primary_ip', 'conn_primary_port', 'conn_local_ip' 1042 and, 'conn_local_port' are copied over from the connectdata struct in 1043 order to allow curl_easy_getinfo() to return this information even when 1044 the session handle is no longer associated with a connection, and also 1045 allow curl_easy_reset() to clear this information from the session handle 1046 without disturbing information which is still alive, and that might be 1047 reused, in the connection cache. */ 1048 1049 char conn_primary_ip[MAX_IPADR_LEN]; 1050 long conn_primary_port; 1051 1052 char conn_local_ip[MAX_IPADR_LEN]; 1053 long conn_local_port; 1054 1055 const char *conn_scheme; 1056 unsigned int conn_protocol; 1057 1058 struct curl_certinfo certs; /* info about the certs, only populated in 1059 OpenSSL builds. Asked for with 1060 CURLOPT_CERTINFO / CURLINFO_CERTINFO */ 1061 }; 1062 1063 1064 struct Progress { 1065 time_t lastshow; /* time() of the last displayed progress meter or NULL to 1066 force redraw at next call */ 1067 curl_off_t size_dl; /* total expected size */ 1068 curl_off_t size_ul; /* total expected size */ 1069 curl_off_t downloaded; /* transferred so far */ 1070 curl_off_t uploaded; /* transferred so far */ 1071 1072 curl_off_t current_speed; /* uses the currently fastest transfer */ 1073 1074 bool callback; /* set when progress callback is used */ 1075 int width; /* screen width at download start */ 1076 int flags; /* see progress.h */ 1077 1078 time_t timespent; 1079 1080 curl_off_t dlspeed; 1081 curl_off_t ulspeed; 1082 1083 time_t t_nslookup; 1084 time_t t_connect; 1085 time_t t_appconnect; 1086 time_t t_pretransfer; 1087 time_t t_starttransfer; 1088 time_t t_redirect; 1089 1090 struct curltime start; 1091 struct curltime t_startsingle; 1092 struct curltime t_startop; 1093 struct curltime t_acceptdata; 1094 1095 bool is_t_startransfer_set; 1096 1097 /* upload speed limit */ 1098 struct curltime ul_limit_start; 1099 curl_off_t ul_limit_size; 1100 /* download speed limit */ 1101 struct curltime dl_limit_start; 1102 curl_off_t dl_limit_size; 1103 1104 #define CURR_TIME (5 + 1) /* 6 entries for 5 seconds */ 1105 1106 curl_off_t speeder[ CURR_TIME ]; 1107 struct curltime speeder_time[ CURR_TIME ]; 1108 int speeder_c; 1109 }; 1110 1111 typedef enum { 1112 HTTPREQ_NONE, /* first in list */ 1113 HTTPREQ_GET, 1114 HTTPREQ_POST, 1115 HTTPREQ_POST_FORM, /* we make a difference internally */ 1116 HTTPREQ_POST_MIME, /* we make a difference internally */ 1117 HTTPREQ_PUT, 1118 HTTPREQ_HEAD, 1119 HTTPREQ_OPTIONS, 1120 HTTPREQ_CUSTOM, 1121 HTTPREQ_LAST /* last in list */ 1122 } Curl_HttpReq; 1123 1124 typedef enum { 1125 RTSPREQ_NONE, /* first in list */ 1126 RTSPREQ_OPTIONS, 1127 RTSPREQ_DESCRIBE, 1128 RTSPREQ_ANNOUNCE, 1129 RTSPREQ_SETUP, 1130 RTSPREQ_PLAY, 1131 RTSPREQ_PAUSE, 1132 RTSPREQ_TEARDOWN, 1133 RTSPREQ_GET_PARAMETER, 1134 RTSPREQ_SET_PARAMETER, 1135 RTSPREQ_RECORD, 1136 RTSPREQ_RECEIVE, 1137 RTSPREQ_LAST /* last in list */ 1138 } Curl_RtspReq; 1139 1140 /* 1141 * Values that are generated, temporary or calculated internally for a 1142 * "session handle" must be defined within the 'struct UrlState'. This struct 1143 * will be used within the Curl_easy struct. When the 'Curl_easy' 1144 * struct is cloned, this data MUST NOT be copied. 1145 * 1146 * Remember that any "state" information goes globally for the curl handle. 1147 * Session-data MUST be put in the connectdata struct and here. */ 1148 #define MAX_CURL_USER_LENGTH 256 1149 #define MAX_CURL_PASSWORD_LENGTH 256 1150 1151 struct auth { 1152 unsigned long want; /* Bitmask set to the authentication methods wanted by 1153 app (with CURLOPT_HTTPAUTH or CURLOPT_PROXYAUTH). */ 1154 unsigned long picked; 1155 unsigned long avail; /* Bitmask for what the server reports to support for 1156 this resource */ 1157 bool done; /* TRUE when the auth phase is done and ready to do the *actual* 1158 request */ 1159 bool multipass; /* TRUE if this is not yet authenticated but within the 1160 auth multipass negotiation */ 1161 bool iestyle; /* TRUE if digest should be done IE-style or FALSE if it should 1162 be RFC compliant */ 1163 }; 1164 1165 struct Curl_http2_dep { 1166 struct Curl_http2_dep *next; 1167 struct Curl_easy *data; 1168 }; 1169 1170 /* 1171 * This struct is for holding data that was attemped to get sent to the user's 1172 * callback but is held due to pausing. One instance per type (BOTH, HEADER, 1173 * BODY). 1174 */ 1175 struct tempbuf { 1176 char *buf; /* allocated buffer to keep data in when a write callback 1177 returns to make the connection paused */ 1178 size_t len; /* size of the 'tempwrite' allocated buffer */ 1179 int type; /* type of the 'tempwrite' buffer as a bitmask that is used with 1180 Curl_client_write() */ 1181 }; 1182 1183 /* Timers */ 1184 typedef enum { 1185 EXPIRE_100_TIMEOUT, 1186 EXPIRE_ASYNC_NAME, 1187 EXPIRE_CONNECTTIMEOUT, 1188 EXPIRE_DNS_PER_NAME, 1189 EXPIRE_HAPPY_EYEBALLS, 1190 EXPIRE_MULTI_PENDING, 1191 EXPIRE_RUN_NOW, 1192 EXPIRE_SPEEDCHECK, 1193 EXPIRE_TIMEOUT, 1194 EXPIRE_TOOFAST, 1195 EXPIRE_LAST /* not an actual timer, used as a marker only */ 1196 } expire_id; 1197 1198 /* 1199 * One instance for each timeout an easy handle can set. 1200 */ 1201 struct time_node { 1202 struct curl_llist_element list; 1203 struct curltime time; 1204 expire_id eid; 1205 }; 1206 1207 struct UrlState { 1208 1209 /* Points to the connection cache */ 1210 struct conncache *conn_cache; 1211 1212 /* when curl_easy_perform() is called, the multi handle is "owned" by 1213 the easy handle so curl_easy_cleanup() on such an easy handle will 1214 also close the multi handle! */ 1215 bool multi_owned_by_easy; 1216 1217 /* buffers to store authentication data in, as parsed from input options */ 1218 struct curltime keeps_speed; /* for the progress meter really */ 1219 1220 struct connectdata *lastconnect; /* The last connection, NULL if undefined */ 1221 1222 char *headerbuff; /* allocated buffer to store headers in */ 1223 size_t headersize; /* size of the allocation */ 1224 1225 char *buffer; /* download buffer */ 1226 char uploadbuffer[UPLOAD_BUFSIZE + 1]; /* upload buffer */ 1227 curl_off_t current_speed; /* the ProgressShow() function sets this, 1228 bytes / second */ 1229 bool this_is_a_follow; /* this is a followed Location: request */ 1230 1231 char *first_host; /* host name of the first (not followed) request. 1232 if set, this should be the host name that we will 1233 sent authorization to, no else. Used to make Location: 1234 following not keep sending user+password... This is 1235 strdup() data. 1236 */ 1237 int first_remote_port; /* remote port of the first (not followed) request */ 1238 struct curl_ssl_session *session; /* array of 'max_ssl_sessions' size */ 1239 long sessionage; /* number of the most recent session */ 1240 unsigned int tempcount; /* number of entries in use in tempwrite, 0 - 3 */ 1241 struct tempbuf tempwrite[3]; /* BOTH, HEADER, BODY */ 1242 char *scratch; /* huge buffer[set.buffer_size*2] for upload CRLF replacing */ 1243 bool errorbuf; /* Set to TRUE if the error buffer is already filled in. 1244 This must be set to FALSE every time _easy_perform() is 1245 called. */ 1246 int os_errno; /* filled in with errno whenever an error occurs */ 1247 #ifdef HAVE_SIGNAL 1248 /* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */ 1249 void (*prev_signal)(int sig); 1250 #endif 1251 bool allow_port; /* Is set.use_port allowed to take effect or not. This 1252 is always set TRUE when curl_easy_perform() is called. */ 1253 struct digestdata digest; /* state data for host Digest auth */ 1254 struct digestdata proxydigest; /* state data for proxy Digest auth */ 1255 1256 #ifdef USE_SPNEGO 1257 struct negotiatedata negotiate; /* state data for host Negotiate auth */ 1258 struct negotiatedata proxyneg; /* state data for proxy Negotiate auth */ 1259 #endif 1260 1261 struct auth authhost; /* auth details for host */ 1262 struct auth authproxy; /* auth details for proxy */ 1263 1264 bool authproblem; /* TRUE if there's some problem authenticating */ 1265 1266 void *resolver; /* resolver state, if it is used in the URL state - 1267 ares_channel f.e. */ 1268 1269 #if defined(USE_OPENSSL) && defined(HAVE_OPENSSL_ENGINE_H) 1270 /* void instead of ENGINE to avoid bleeding OpenSSL into this header */ 1271 void *engine; 1272 #endif /* USE_OPENSSL */ 1273 struct curltime expiretime; /* set this with Curl_expire() only */ 1274 struct Curl_tree timenode; /* for the splay stuff */ 1275 struct curl_llist timeoutlist; /* list of pending timeouts */ 1276 struct time_node expires[EXPIRE_LAST]; /* nodes for each expire type */ 1277 1278 /* a place to store the most recently set FTP entrypath */ 1279 char *most_recent_ftp_entrypath; 1280 1281 /* set after initial USER failure, to prevent an authentication loop */ 1282 bool ftp_trying_alternative; 1283 bool wildcardmatch; /* enable wildcard matching */ 1284 int httpversion; /* the lowest HTTP version*10 reported by any server 1285 involved in this request */ 1286 bool expect100header; /* TRUE if we added Expect: 100-continue */ 1287 1288 bool pipe_broke; /* TRUE if the connection we were pipelined on broke 1289 and we need to restart from the beginning */ 1290 1291 #if !defined(WIN32) && !defined(MSDOS) && !defined(__EMX__) && \ 1292 !defined(__SYMBIAN32__) 1293 /* do FTP line-end conversions on most platforms */ 1294 #define CURL_DO_LINEEND_CONV 1295 /* for FTP downloads: track CRLF sequences that span blocks */ 1296 bool prev_block_had_trailing_cr; 1297 /* for FTP downloads: how many CRLFs did we converted to LFs? */ 1298 curl_off_t crlf_conversions; 1299 #endif 1300 char *pathbuffer;/* allocated buffer to store the URL's path part in */ 1301 char *path; /* path to use, points to somewhere within the pathbuffer 1302 area */ 1303 bool slash_removed; /* set TRUE if the 'path' points to a path where the 1304 initial URL slash separator has been taken off */ 1305 bool use_range; 1306 bool rangestringalloc; /* the range string is malloc()'ed */ 1307 1308 char *range; /* range, if used. See README for detailed specification on 1309 this syntax. */ 1310 curl_off_t resume_from; /* continue [ftp] transfer from here */ 1311 1312 /* This RTSP state information survives requests and connections */ 1313 long rtsp_next_client_CSeq; /* the session's next client CSeq */ 1314 long rtsp_next_server_CSeq; /* the session's next server CSeq */ 1315 long rtsp_CSeq_recv; /* most recent CSeq received */ 1316 1317 curl_off_t infilesize; /* size of file to upload, -1 means unknown. 1318 Copied from set.filesize at start of operation */ 1319 1320 size_t drain; /* Increased when this stream has data to read, even if its 1321 socket is not necessarily is readable. Decreased when 1322 checked. */ 1323 bool done; /* set to FALSE when Curl_init_do() is called and set to TRUE 1324 when multi_done() is called, to prevent multi_done() to get 1325 invoked twice when the multi interface is used. */ 1326 1327 curl_read_callback fread_func; /* read callback/function */ 1328 void *in; /* CURLOPT_READDATA */ 1329 1330 struct Curl_easy *stream_depends_on; 1331 bool stream_depends_e; /* set or don't set the Exclusive bit */ 1332 int stream_weight; 1333 #ifdef CURLDEBUG 1334 bool conncache_lock; 1335 #endif 1336 }; 1337 1338 1339 /* 1340 * This 'DynamicStatic' struct defines dynamic states that actually change 1341 * values in the 'UserDefined' area, which MUST be taken into consideration 1342 * if the UserDefined struct is cloned or similar. You can probably just 1343 * copy these, but each one indicate a special action on other data. 1344 */ 1345 1346 struct DynamicStatic { 1347 char *url; /* work URL, copied from UserDefined */ 1348 bool url_alloc; /* URL string is malloc()'ed */ 1349 char *referer; /* referer string */ 1350 bool referer_alloc; /* referer sting is malloc()ed */ 1351 struct curl_slist *cookielist; /* list of cookie files set by 1352 curl_easy_setopt(COOKIEFILE) calls */ 1353 struct curl_slist *resolve; /* set to point to the set.resolve list when 1354 this should be dealt with in pretransfer */ 1355 }; 1356 1357 /* 1358 * This 'UserDefined' struct must only contain data that is set once to go 1359 * for many (perhaps) independent connections. Values that are generated or 1360 * calculated internally for the "session handle" MUST be defined within the 1361 * 'struct UrlState' instead. The only exceptions MUST note the changes in 1362 * the 'DynamicStatic' struct. 1363 * Character pointer fields point to dynamic storage, unless otherwise stated. 1364 */ 1365 1366 struct Curl_multi; /* declared and used only in multi.c */ 1367 1368 enum dupstring { 1369 STRING_CERT_ORIG, /* client certificate file name */ 1370 STRING_CERT_PROXY, /* client certificate file name */ 1371 STRING_CERT_TYPE_ORIG, /* format for certificate (default: PEM)*/ 1372 STRING_CERT_TYPE_PROXY, /* format for certificate (default: PEM)*/ 1373 STRING_COOKIE, /* HTTP cookie string to send */ 1374 STRING_COOKIEJAR, /* dump all cookies to this file */ 1375 STRING_CUSTOMREQUEST, /* HTTP/FTP/RTSP request/method to use */ 1376 STRING_DEFAULT_PROTOCOL, /* Protocol to use when the URL doesn't specify */ 1377 STRING_DEVICE, /* local network interface/address to use */ 1378 STRING_ENCODING, /* Accept-Encoding string */ 1379 STRING_FTP_ACCOUNT, /* ftp account data */ 1380 STRING_FTP_ALTERNATIVE_TO_USER, /* command to send if USER/PASS fails */ 1381 STRING_FTPPORT, /* port to send with the FTP PORT command */ 1382 STRING_KEY_ORIG, /* private key file name */ 1383 STRING_KEY_PROXY, /* private key file name */ 1384 STRING_KEY_PASSWD_ORIG, /* plain text private key password */ 1385 STRING_KEY_PASSWD_PROXY, /* plain text private key password */ 1386 STRING_KEY_TYPE_ORIG, /* format for private key (default: PEM) */ 1387 STRING_KEY_TYPE_PROXY, /* format for private key (default: PEM) */ 1388 STRING_KRB_LEVEL, /* krb security level */ 1389 STRING_NETRC_FILE, /* if not NULL, use this instead of trying to find 1390 $HOME/.netrc */ 1391 STRING_PROXY, /* proxy to use */ 1392 STRING_PRE_PROXY, /* pre socks proxy to use */ 1393 STRING_SET_RANGE, /* range, if used */ 1394 STRING_SET_REFERER, /* custom string for the HTTP referer field */ 1395 STRING_SET_URL, /* what original URL to work on */ 1396 STRING_SSL_CAPATH_ORIG, /* CA directory name (doesn't work on windows) */ 1397 STRING_SSL_CAPATH_PROXY, /* CA directory name (doesn't work on windows) */ 1398 STRING_SSL_CAFILE_ORIG, /* certificate file to verify peer against */ 1399 STRING_SSL_CAFILE_PROXY, /* certificate file to verify peer against */ 1400 STRING_SSL_PINNEDPUBLICKEY_ORIG, /* public key file to verify peer against */ 1401 STRING_SSL_PINNEDPUBLICKEY_PROXY, /* public key file to verify proxy */ 1402 STRING_SSL_CIPHER_LIST_ORIG, /* list of ciphers to use */ 1403 STRING_SSL_CIPHER_LIST_PROXY, /* list of ciphers to use */ 1404 STRING_SSL_EGDSOCKET, /* path to file containing the EGD daemon socket */ 1405 STRING_SSL_RANDOM_FILE, /* path to file containing "random" data */ 1406 STRING_USERAGENT, /* User-Agent string */ 1407 STRING_SSL_CRLFILE_ORIG, /* crl file to check certificate */ 1408 STRING_SSL_CRLFILE_PROXY, /* crl file to check certificate */ 1409 STRING_SSL_ISSUERCERT_ORIG, /* issuer cert file to check certificate */ 1410 STRING_SSL_ISSUERCERT_PROXY, /* issuer cert file to check certificate */ 1411 STRING_USERNAME, /* <username>, if used */ 1412 STRING_PASSWORD, /* <password>, if used */ 1413 STRING_OPTIONS, /* <options>, if used */ 1414 STRING_PROXYUSERNAME, /* Proxy <username>, if used */ 1415 STRING_PROXYPASSWORD, /* Proxy <password>, if used */ 1416 STRING_NOPROXY, /* List of hosts which should not use the proxy, if 1417 used */ 1418 STRING_RTSP_SESSION_ID, /* Session ID to use */ 1419 STRING_RTSP_STREAM_URI, /* Stream URI for this request */ 1420 STRING_RTSP_TRANSPORT, /* Transport for this session */ 1421 #if defined(USE_LIBSSH2) || defined(USE_LIBSSH) 1422 STRING_SSH_PRIVATE_KEY, /* path to the private key file for auth */ 1423 STRING_SSH_PUBLIC_KEY, /* path to the public key file for auth */ 1424 STRING_SSH_HOST_PUBLIC_KEY_MD5, /* md5 of host public key in ascii hex */ 1425 STRING_SSH_KNOWNHOSTS, /* file name of knownhosts file */ 1426 #endif 1427 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) 1428 STRING_PROXY_SERVICE_NAME, /* Proxy service name */ 1429 #endif 1430 #if !defined(CURL_DISABLE_CRYPTO_AUTH) || defined(USE_KERBEROS5) || \ 1431 defined(USE_SPNEGO) || defined(HAVE_GSSAPI) 1432 STRING_SERVICE_NAME, /* Service name */ 1433 #endif 1434 STRING_MAIL_FROM, 1435 STRING_MAIL_AUTH, 1436 1437 #ifdef USE_TLS_SRP 1438 STRING_TLSAUTH_USERNAME_ORIG, /* TLS auth <username> */ 1439 STRING_TLSAUTH_USERNAME_PROXY, /* TLS auth <username> */ 1440 STRING_TLSAUTH_PASSWORD_ORIG, /* TLS auth <password> */ 1441 STRING_TLSAUTH_PASSWORD_PROXY, /* TLS auth <password> */ 1442 #endif 1443 STRING_BEARER, /* <bearer>, if used */ 1444 #ifdef USE_UNIX_SOCKETS 1445 STRING_UNIX_SOCKET_PATH, /* path to Unix socket, if used */ 1446 #endif 1447 STRING_TARGET, /* CURLOPT_REQUEST_TARGET */ 1448 /* -- end of zero-terminated strings -- */ 1449 1450 STRING_LASTZEROTERMINATED, 1451 1452 /* -- below this are pointers to binary data that cannot be strdup'ed. 1453 Each such pointer must be added manually to Curl_dupset() --- */ 1454 1455 STRING_COPYPOSTFIELDS, /* if POST, set the fields' values here */ 1456 1457 STRING_LAST /* not used, just an end-of-list marker */ 1458 }; 1459 1460 struct UserDefined { 1461 FILE *err; /* the stderr user data goes here */ 1462 void *debugdata; /* the data that will be passed to fdebug */ 1463 char *errorbuffer; /* (Static) store failure messages in here */ 1464 long proxyport; /* If non-zero, use this port number by default. If the 1465 proxy string features a ":[port]" that one will override 1466 this. */ 1467 void *out; /* CURLOPT_WRITEDATA */ 1468 void *in_set; /* CURLOPT_READDATA */ 1469 void *writeheader; /* write the header to this if non-NULL */ 1470 void *rtp_out; /* write RTP to this if non-NULL */ 1471 long use_port; /* which port to use (when not using default) */ 1472 unsigned long httpauth; /* kind of HTTP authentication to use (bitmask) */ 1473 unsigned long proxyauth; /* kind of proxy authentication to use (bitmask) */ 1474 unsigned long socks5auth;/* kind of SOCKS5 authentication to use (bitmask) */ 1475 long followlocation; /* as in HTTP Location: */ 1476 long maxredirs; /* maximum no. of http(s) redirects to follow, set to -1 1477 for infinity */ 1478 1479 int keep_post; /* keep POSTs as POSTs after a 30x request; each 1480 bit represents a request, from 301 to 303 */ 1481 bool free_referer; /* set TRUE if 'referer' points to a string we 1482 allocated */ 1483 void *postfields; /* if POST, set the fields' values here */ 1484 curl_seek_callback seek_func; /* function that seeks the input */ 1485 curl_off_t postfieldsize; /* if POST, this might have a size to use instead 1486 of strlen(), and then the data *may* be binary 1487 (contain zero bytes) */ 1488 unsigned short localport; /* local port number to bind to */ 1489 int localportrange; /* number of additional port numbers to test in case the 1490 'localport' one can't be bind()ed */ 1491 curl_write_callback fwrite_func; /* function that stores the output */ 1492 curl_write_callback fwrite_header; /* function that stores headers */ 1493 curl_write_callback fwrite_rtp; /* function that stores interleaved RTP */ 1494 curl_read_callback fread_func_set; /* function that reads the input */ 1495 int is_fread_set; /* boolean, has read callback been set to non-NULL? */ 1496 int is_fwrite_set; /* boolean, has write callback been set to non-NULL? */ 1497 curl_progress_callback fprogress; /* OLD and deprecated progress callback */ 1498 curl_xferinfo_callback fxferinfo; /* progress callback */ 1499 curl_debug_callback fdebug; /* function that write informational data */ 1500 curl_ioctl_callback ioctl_func; /* function for I/O control */ 1501 curl_sockopt_callback fsockopt; /* function for setting socket options */ 1502 void *sockopt_client; /* pointer to pass to the socket options callback */ 1503 curl_opensocket_callback fopensocket; /* function for checking/translating 1504 the address and opening the 1505 socket */ 1506 void *opensocket_client; 1507 curl_closesocket_callback fclosesocket; /* function for closing the 1508 socket */ 1509 void *closesocket_client; 1510 1511 void *seek_client; /* pointer to pass to the seek callback */ 1512 /* the 3 curl_conv_callback functions below are used on non-ASCII hosts */ 1513 /* function to convert from the network encoding: */ 1514 curl_conv_callback convfromnetwork; 1515 /* function to convert to the network encoding: */ 1516 curl_conv_callback convtonetwork; 1517 /* function to convert from UTF-8 encoding: */ 1518 curl_conv_callback convfromutf8; 1519 1520 void *progress_client; /* pointer to pass to the progress callback */ 1521 void *ioctl_client; /* pointer to pass to the ioctl callback */ 1522 long timeout; /* in milliseconds, 0 means no timeout */ 1523 long connecttimeout; /* in milliseconds, 0 means no timeout */ 1524 long accepttimeout; /* in milliseconds, 0 means no timeout */ 1525 long server_response_timeout; /* in milliseconds, 0 means no timeout */ 1526 long tftp_blksize; /* in bytes, 0 means use default */ 1527 bool tftp_no_options; /* do not send TFTP options requests */ 1528 curl_off_t filesize; /* size of file to upload, -1 means unknown */ 1529 long low_speed_limit; /* bytes/second */ 1530 long low_speed_time; /* number of seconds */ 1531 curl_off_t max_send_speed; /* high speed limit in bytes/second for upload */ 1532 curl_off_t max_recv_speed; /* high speed limit in bytes/second for 1533 download */ 1534 curl_off_t set_resume_from; /* continue [ftp] transfer from here */ 1535 struct curl_slist *headers; /* linked list of extra headers */ 1536 struct curl_slist *proxyheaders; /* linked list of extra CONNECT headers */ 1537 struct curl_httppost *httppost; /* linked list of old POST data */ 1538 curl_mimepart mimepost; /* MIME/POST data. */ 1539 bool sep_headers; /* handle host and proxy headers separately */ 1540 bool cookiesession; /* new cookie session? */ 1541 bool crlf; /* convert crlf on ftp upload(?) */ 1542 struct curl_slist *quote; /* after connection is established */ 1543 struct curl_slist *postquote; /* after the transfer */ 1544 struct curl_slist *prequote; /* before the transfer, after type */ 1545 struct curl_slist *source_quote; /* 3rd party quote */ 1546 struct curl_slist *source_prequote; /* in 3rd party transfer mode - before 1547 the transfer on source host */ 1548 struct curl_slist *source_postquote; /* in 3rd party transfer mode - after 1549 the transfer on source host */ 1550 struct curl_slist *telnet_options; /* linked list of telnet options */ 1551 struct curl_slist *resolve; /* list of names to add/remove from 1552 DNS cache */ 1553 struct curl_slist *connect_to; /* list of host:port mappings to override 1554 the hostname and port to connect to */ 1555 curl_TimeCond timecondition; /* kind of time/date comparison */ 1556 time_t timevalue; /* what time to compare with */ 1557 Curl_HttpReq httpreq; /* what kind of HTTP request (if any) is this */ 1558 long httpversion; /* when non-zero, a specific HTTP version requested to 1559 be used in the library's request(s) */ 1560 bool strip_path_slash; /* strip off initial slash from path */ 1561 struct ssl_config_data ssl; /* user defined SSL stuff */ 1562 struct ssl_config_data proxy_ssl; /* user defined SSL stuff for proxy */ 1563 struct ssl_general_config general_ssl; /* general user defined SSL stuff */ 1564 curl_proxytype proxytype; /* what kind of proxy that is in use */ 1565 long dns_cache_timeout; /* DNS cache timeout */ 1566 long buffer_size; /* size of receive buffer to use */ 1567 void *private_data; /* application-private data */ 1568 1569 struct curl_slist *http200aliases; /* linked list of aliases for http200 */ 1570 1571 long ipver; /* the CURL_IPRESOLVE_* defines in the public header file 1572 0 - whatever, 1 - v2, 2 - v6 */ 1573 1574 curl_off_t max_filesize; /* Maximum file size to download */ 1575 1576 curl_ftpfile ftp_filemethod; /* how to get to a file when FTP is used */ 1577 1578 int ftp_create_missing_dirs; /* 1 - create directories that don't exist 1579 2 - the same but also allow MKD to fail once 1580 */ 1581 1582 curl_sshkeycallback ssh_keyfunc; /* key matching callback */ 1583 void *ssh_keyfunc_userp; /* custom pointer to callback */ 1584 bool ssh_compression; /* enable SSH compression */ 1585 1586 /* Here follows boolean settings that define how to behave during 1587 this session. They are STATIC, set by libcurl users or at least initially 1588 and they don't change during operations. */ 1589 1590 bool printhost; /* printing host name in debug info */ 1591 bool get_filetime; /* get the time and get of the remote file */ 1592 bool tunnel_thru_httpproxy; /* use CONNECT through a HTTP proxy */ 1593 bool prefer_ascii; /* ASCII rather than binary */ 1594 bool ftp_append; /* append, not overwrite, on upload */ 1595 bool ftp_list_only; /* switch FTP command for listing directories */ 1596 bool ftp_use_port; /* use the FTP PORT command */ 1597 bool hide_progress; /* don't use the progress meter */ 1598 bool http_fail_on_error; /* fail on HTTP error codes >= 400 */ 1599 bool http_keep_sending_on_error; /* for HTTP status codes >= 300 */ 1600 bool http_follow_location; /* follow HTTP redirects */ 1601 bool http_transfer_encoding; /* request compressed HTTP transfer-encoding */ 1602 bool allow_auth_to_other_hosts; 1603 bool include_header; /* include received protocol headers in data output */ 1604 bool http_set_referer; /* is a custom referer used */ 1605 bool http_auto_referer; /* set "correct" referer when following location: */ 1606 bool opt_no_body; /* as set with CURLOPT_NOBODY */ 1607 bool upload; /* upload request */ 1608 enum CURL_NETRC_OPTION 1609 use_netrc; /* defined in include/curl.h */ 1610 bool verbose; /* output verbosity */ 1611 bool krb; /* Kerberos connection requested */ 1612 bool reuse_forbid; /* forbidden to be reused, close after use */ 1613 bool reuse_fresh; /* do not re-use an existing connection */ 1614 bool ftp_use_epsv; /* if EPSV is to be attempted or not */ 1615 bool ftp_use_eprt; /* if EPRT is to be attempted or not */ 1616 bool ftp_use_pret; /* if PRET is to be used before PASV or not */ 1617 1618 curl_usessl use_ssl; /* if AUTH TLS is to be attempted etc, for FTP or 1619 IMAP or POP3 or others! */ 1620 curl_ftpauth ftpsslauth; /* what AUTH XXX to be attempted */ 1621 curl_ftpccc ftp_ccc; /* FTP CCC options */ 1622 bool no_signal; /* do not use any signal/alarm handler */ 1623 bool global_dns_cache; /* subject for future removal */ 1624 bool tcp_nodelay; /* whether to enable TCP_NODELAY or not */ 1625 bool ignorecl; /* ignore content length */ 1626 bool ftp_skip_ip; /* skip the IP address the FTP server passes on to 1627 us */ 1628 bool connect_only; /* make connection, let application use the socket */ 1629 long ssh_auth_types; /* allowed SSH auth types */ 1630 bool http_te_skip; /* pass the raw body data to the user, even when 1631 transfer-encoded (chunked, compressed) */ 1632 bool http_ce_skip; /* pass the raw body data to the user, even when 1633 content-encoded (chunked, compressed) */ 1634 long new_file_perms; /* Permissions to use when creating remote files */ 1635 long new_directory_perms; /* Permissions to use when creating remote dirs */ 1636 bool proxy_transfer_mode; /* set transfer mode (;type=<a|i>) when doing FTP 1637 via an HTTP proxy */ 1638 char *str[STRING_LAST]; /* array of strings, pointing to allocated memory */ 1639 unsigned int scope_id; /* Scope id for IPv6 */ 1640 long allowed_protocols; 1641 long redir_protocols; 1642 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI) 1643 bool socks5_gssapi_nec; /* Flag to support NEC SOCKS5 server */ 1644 #endif 1645 struct curl_slist *mail_rcpt; /* linked list of mail recipients */ 1646 bool sasl_ir; /* Enable/disable SASL initial response */ 1647 /* Common RTSP header options */ 1648 Curl_RtspReq rtspreq; /* RTSP request type */ 1649 long rtspversion; /* like httpversion, for RTSP */ 1650 bool wildcard_enabled; /* enable wildcard matching */ 1651 curl_chunk_bgn_callback chunk_bgn; /* called before part of transfer 1652 starts */ 1653 curl_chunk_end_callback chunk_end; /* called after part transferring 1654 stopped */ 1655 curl_fnmatch_callback fnmatch; /* callback to decide which file corresponds 1656 to pattern (e.g. if WILDCARDMATCH is on) */ 1657 void *fnmatch_data; 1658 1659 long gssapi_delegation; /* GSS-API credential delegation, see the 1660 documentation of CURLOPT_GSSAPI_DELEGATION */ 1661 1662 bool tcp_keepalive; /* use TCP keepalives */ 1663 long tcp_keepidle; /* seconds in idle before sending keepalive probe */ 1664 long tcp_keepintvl; /* seconds between TCP keepalive probes */ 1665 bool tcp_fastopen; /* use TCP Fast Open */ 1666 1667 size_t maxconnects; /* Max idle connections in the connection cache */ 1668 1669 bool ssl_enable_npn; /* TLS NPN extension? */ 1670 bool ssl_enable_alpn; /* TLS ALPN extension? */ 1671 bool path_as_is; /* allow dotdots? */ 1672 bool pipewait; /* wait for pipe/multiplex status before starting a 1673 new connection */ 1674 long expect_100_timeout; /* in milliseconds */ 1675 bool suppress_connect_headers; /* suppress proxy CONNECT response headers 1676 from user callbacks */ 1677 1678 struct Curl_easy *stream_depends_on; 1679 bool stream_depends_e; /* set or don't set the Exclusive bit */ 1680 int stream_weight; 1681 1682 struct Curl_http2_dep *stream_dependents; 1683 1684 bool abstract_unix_socket; 1685 }; 1686 1687 struct Names { 1688 struct curl_hash *hostcache; 1689 enum { 1690 HCACHE_NONE, /* not pointing to anything */ 1691 HCACHE_GLOBAL, /* points to the (shrug) global one */ 1692 HCACHE_MULTI, /* points to a shared one in the multi handle */ 1693 HCACHE_SHARED /* points to a shared one in a shared object */ 1694 } hostcachetype; 1695 }; 1696 1697 /* 1698 * The 'connectdata' struct MUST have all the connection oriented stuff as we 1699 * may have several simultaneous connections and connection structs in memory. 1700 * 1701 * The 'struct UserDefined' must only contain data that is set once to go for 1702 * many (perhaps) independent connections. Values that are generated or 1703 * calculated internally for the "session handle" must be defined within the 1704 * 'struct UrlState' instead. 1705 */ 1706 1707 struct Curl_easy { 1708 /* first, two fields for the linked list of these */ 1709 struct Curl_easy *next; 1710 struct Curl_easy *prev; 1711 1712 struct connectdata *easy_conn; /* the "unit's" connection */ 1713 struct curl_llist_element connect_queue; 1714 struct curl_llist_element pipeline_queue; 1715 1716 CURLMstate mstate; /* the handle's state */ 1717 CURLcode result; /* previous result */ 1718 1719 struct Curl_message msg; /* A single posted message. */ 1720 1721 /* Array with the plain socket numbers this handle takes care of, in no 1722 particular order. Note that all sockets are added to the sockhash, where 1723 the state etc are also kept. This array is mostly used to detect when a 1724 socket is to be removed from the hash. See singlesocket(). */ 1725 curl_socket_t sockets[MAX_SOCKSPEREASYHANDLE]; 1726 int numsocks; 1727 1728 struct Names dns; 1729 struct Curl_multi *multi; /* if non-NULL, points to the multi handle 1730 struct to which this "belongs" when used by 1731 the multi interface */ 1732 struct Curl_multi *multi_easy; /* if non-NULL, points to the multi handle 1733 struct to which this "belongs" when used 1734 by the easy interface */ 1735 struct Curl_share *share; /* Share, handles global variable mutexing */ 1736 struct SingleRequest req; /* Request-specific data */ 1737 struct UserDefined set; /* values set by the libcurl user */ 1738 struct DynamicStatic change; /* possibly modified userdefined data */ 1739 struct CookieInfo *cookies; /* the cookies, read from files and servers. 1740 NOTE that the 'cookie' field in the 1741 UserDefined struct defines if the "engine" 1742 is to be used or not. */ 1743 struct Progress progress; /* for all the progress meter data */ 1744 struct UrlState state; /* struct for fields used for state info and 1745 other dynamic purposes */ 1746 struct WildcardData wildcard; /* wildcard download state info */ 1747 struct PureInfo info; /* stats, reports and info data */ 1748 struct curl_tlssessioninfo tsi; /* Information about the TLS session, only 1749 valid after a client has asked for it */ 1750 #if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV) 1751 iconv_t outbound_cd; /* for translating to the network encoding */ 1752 iconv_t inbound_cd; /* for translating from the network encoding */ 1753 iconv_t utf8_cd; /* for translating to UTF8 */ 1754 #endif /* CURL_DOES_CONVERSIONS && HAVE_ICONV */ 1755 unsigned int magic; /* set to a CURLEASY_MAGIC_NUMBER */ 1756 }; 1757 1758 #define LIBCURL_NAME "libcurl" 1759 1760 #endif /* HEADER_CURL_URLDATA_H */ 1761