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