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