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