Utilities/cmcurl/lib/urldata.h

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