luna - curl/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) 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 * SPDX-License-Identifier: curl
  24 *
  25 ***************************************************************************/
  26/* This file is for lib internal stuff */
  27#include "curl_setup.h"
  28
  29#define CURL_DEFAULT_USER     "anonymous"
  30#define CURL_DEFAULT_PASSWORD "ftp@example.com"
  31
  32#if !defined(_WIN32) && !defined(MSDOS)
  33/* do FTP line-end CRLF => LF conversions on platforms that prefer LF-only. It
  34   also means: keep CRLF line endings on the CRLF platforms */
  35#define CURL_PREFER_LF_LINEENDS
  36#endif
  37
  38#define DEFAULT_CONNCACHE_SIZE 5
  39
  40/* length of longest IPv6 address string including the trailing null */
  41#define MAX_IPADR_LEN sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")
  42
  43/* Max string input length is a precaution against abuse and to detect junk
  44   input easier and better. */
  45#define CURL_MAX_INPUT_LENGTH 8000000
  46
  47#ifdef HAVE_NETINET_IN_H
  48#include <netinet/in.h>
  49#endif
  50#ifdef HAVE_NETINET_IN6_H
  51#include <netinet/in6.h>
  52#endif
  53
  54#include "curlx/timeval.h"
  55
  56#include "asyn.h"
  57#include "cookie.h"
  58#include "creds.h"
  59#include "psl.h"
  60#include "formdata.h"
  61#include "http_chunks.h" /* for the structs and enum stuff */
  62#include "hostip.h"
  63#include "hash.h"
  64#include "peer.h"
  65#include "splay.h"
  66#include "curlx/dynbuf.h"
  67#include "bufref.h"
  68#include "dynhds.h"
  69#include "request.h"
  70#include "ratelimit.h"
  71#include "netrc.h"
  72
  73/* On error return, the value of `pnwritten` has no meaning */
  74typedef CURLcode (Curl_send)(struct Curl_easy *data,   /* transfer */
  75                             int sockindex,            /* socketindex */
  76                             const uint8_t *buf,       /* data to write */
  77                             size_t len,               /* amount to send */
  78                             bool eos,                 /* last chunk */
  79                             size_t *pnwritten);       /* how much sent */
  80
  81/* On error return, the value of `pnread` has no meaning */
  82typedef CURLcode (Curl_recv)(struct Curl_easy *data,   /* transfer */
  83                             int sockindex,            /* socketindex */
  84                             char *buf,                /* store data here */
  85                             size_t len,               /* max amount to read */
  86                             size_t *pnread);          /* how much received */
  87
  88#include "mime.h"
  89#include "protocol.h"
  90#include "ftp.h"
  91#include "http.h"
  92#include "smb.h"
  93#include "mqtt.h"
  94#include "ftplistparser.h"
  95#include "multihandle.h"
  96#include "cf-socket.h"
  97
  98#ifdef HAVE_GSSAPI
  99#  ifdef HAVE_GSSGNU
 100#    include <gss.h>
 101#  elif defined(HAVE_GSSAPI_H)
 102#    include <gssapi.h>
 103#  else /* MIT Kerberos */
 104#    include <gssapi/gssapi.h>
 105#    include <gssapi/gssapi_krb5.h> /* for GSS_C_CHANNEL_BOUND_FLAG in 1.19+ */
 106#  endif
 107#endif
 108
 109#ifdef USE_LIBSSH2
 110#include <libssh2.h>
 111#include <libssh2_sftp.h>
 112#endif /* USE_LIBSSH2 */
 113
 114#define READBUFFER_SIZE CURL_MAX_WRITE_SIZE
 115#define READBUFFER_MAX  CURL_MAX_READ_SIZE
 116#define READBUFFER_MIN  1024
 117
 118/* The default upload buffer size, should not be smaller than
 119   CURL_MAX_WRITE_SIZE, as it needs to hold a full buffer as could be sent in
 120   a write callback.
 121
 122   The size was 16KB for many years but was bumped to 64KB because it makes
 123   libcurl able to do significantly faster uploads in some circumstances. Even
 124   larger buffers can help further, but this is deemed a fair memory/speed
 125   compromise. */
 126#define UPLOADBUFFER_DEFAULT 65536
 127#define UPLOADBUFFER_MAX     (2 * 1024 * 1024)
 128#define UPLOADBUFFER_MIN     CURL_MAX_WRITE_SIZE
 129
 130#define CURLEASY_MAGIC_NUMBER 0xc0dedbadU
 131#ifdef DEBUGBUILD
 132/* On a debug build, we want to fail hard on easy handles that
 133 * are not NULL, but no longer have the MAGIC touch. This gives
 134 * us early warning on things only discovered by valgrind otherwise. */
 135#define GOOD_EASY_HANDLE(x) \
 136  (((x) && ((x)->magic == CURLEASY_MAGIC_NUMBER)) ? TRUE : \
 137   (DEBUGASSERT(!(x)), FALSE))
 138#else
 139#define GOOD_EASY_HANDLE(x) \
 140  ((x) && ((x)->magic == CURLEASY_MAGIC_NUMBER))
 141#endif
 142
 143struct ssl_primary_config {
 144  char *CApath;          /* certificate directory (does not work on Windows) */
 145  char *CAfile;          /* certificate to verify peer against */
 146  char *issuercert;      /* optional issuer certificate filename */
 147  char *clientcert;
 148  char *cipher_list;     /* list of ciphers to use */
 149  char *cipher_list13;   /* list of TLS 1.3 cipher suites to use */
 150  char *signature_algorithms; /* list of signature algorithms to use */
 151  char *pinned_key;
 152  char *CRLfile;         /* CRL to check certificate revocation */
 153  struct curl_blob *cert_blob;
 154  struct curl_blob *ca_info_blob;
 155  struct curl_blob *issuercert_blob;
 156#ifdef USE_TLS_SRP
 157  char *username; /* TLS username (for, e.g., SRP) */
 158  char *password; /* TLS password (for, e.g., SRP) */
 159#endif
 160  char *curves;          /* list of curves to use */
 161  uint32_t version_max; /* max supported version the client wants to use */
 162  uint8_t ssl_options;  /* the CURLOPT_SSL_OPTIONS bitmask */
 163  uint8_t version;    /* what version the client wants to use */
 164  BIT(verifypeer);       /* set TRUE if this is desired */
 165  BIT(verifyhost);       /* set TRUE if CN/SAN must match hostname */
 166  BIT(verifystatus);     /* set TRUE if certificate status must be checked */
 167  BIT(cache_session);    /* cache session or not */
 168};
 169
 170struct ssl_config_data {
 171  struct ssl_primary_config primary;
 172  long certverifyresult; /* result from the certificate verification */
 173  curl_ssl_ctx_callback fsslctx; /* function to initialize ssl ctx */
 174  void *fsslctxp;        /* parameter for call back */
 175  char *cert_type; /* format for certificate (default: PEM) */
 176  char *key; /* private key filename */
 177  struct curl_blob *key_blob;
 178  char *key_type; /* format for private key (default: PEM) */
 179  char *key_passwd; /* plain text private key password */
 180  BIT(certinfo);     /* gather lots of certificate info */
 181  BIT(earlydata);    /* use TLS 1.3 early data */
 182  BIT(enable_beast); /* allow this flaw for interoperability's sake */
 183  BIT(no_revoke);    /* disable SSL certificate revocation checks */
 184  BIT(no_partialchain); /* do not accept partial certificate chains */
 185  BIT(revoke_best_effort); /* ignore SSL revocation offline/missing revocation
 186                              list errors */
 187  BIT(native_ca_store); /* use the native CA store of operating system */
 188  BIT(auto_client_cert);   /* automatically locate and use a client
 189                              certificate for authentication (Schannel) */
 190  BIT(custom_cafile); /* application has set custom CA file */
 191  BIT(custom_capath); /* application has set custom CA path */
 192  BIT(custom_cablob); /* application has set custom CA blob */
 193};
 194
 195struct ssl_general_config {
 196  int ca_cache_timeout;  /* Certificate store cache timeout (seconds) */
 197};
 198
 199#ifdef USE_WINDOWS_SSPI
 200#include "curl_sspi.h"
 201#endif
 202
 203#ifndef CURL_DISABLE_DIGEST_AUTH
 204/* Struct used for Digest challenge-response authentication */
 205struct digestdata {
 206#ifdef USE_WINDOWS_SSPI
 207  BYTE *input_token;
 208  size_t input_token_len;
 209  CtxtHandle *http_context;
 210  /* linked credentials used to make the identity for http_context.
 211     may be NULL. */
 212  struct Curl_creds *creds;
 213#else
 214  char *nonce;
 215  char *cnonce;
 216  char *realm;
 217  char *opaque;
 218  char *qop;
 219  char *algorithm;
 220  int nc; /* nonce count */
 221  uint8_t algo;
 222  BIT(stale); /* set true for re-negotiation */
 223  BIT(userhash);
 224#endif
 225};
 226#endif
 227
 228typedef enum {
 229  NTLMSTATE_NONE,
 230  NTLMSTATE_TYPE1,
 231  NTLMSTATE_TYPE2,
 232  NTLMSTATE_TYPE3,
 233  NTLMSTATE_LAST
 234} curlntlm;
 235
 236typedef enum {
 237  GSS_AUTHNONE,
 238  GSS_AUTHRECV,
 239  GSS_AUTHSENT,
 240  GSS_AUTHDONE,
 241  GSS_AUTHSUCC
 242} curlnegotiate;
 243
 244/*
 245 * Boolean values that concerns this connection.
 246 */
 247struct ConnectBits {
 248  BIT(connect_only);
 249#ifndef CURL_DISABLE_PROXY
 250  BIT(httpproxy);  /* if set, this transfer is done through an HTTP proxy */
 251  BIT(socksproxy); /* if set, this transfer is done through a socks proxy */
 252  BIT(tunnel_proxy);  /* if CONNECT is used to "tunnel" through the proxy.
 253                         This is implicit when SSL-protocols are used through
 254                         proxies, but can also be enabled explicitly by
 255                         apps */
 256  BIT(proxy); /* if set, this transfer is done through a proxy - any type */
 257#endif
 258  /* always modify bits.close with the connclose() and connkeep() macros! */
 259  BIT(close); /* if set, we close the connection after this request */
 260  BIT(reuse); /* if set, this is a reused connection */
 261  BIT(altused); /* this is an alt-svc "redirect" */
 262  BIT(ipv6);    /* we communicate with a site using an IPv6 address */
 263  BIT(do_more); /* this is set TRUE if the ->curl_do_more() function is
 264                   supposed to be called, after ->curl_do() */
 265  BIT(protoconnstart);/* the protocol layer has STARTED its operation after
 266                         the TCP layer connect */
 267  BIT(retry);         /* this connection is about to get closed and then
 268                         re-attempted at another connection. */
 269#ifndef CURL_DISABLE_FTP
 270  BIT(ftp_use_epsv);  /* As set with CURLOPT_FTP_USE_EPSV, but if we find out
 271                         EPSV does not work we disable it for the forthcoming
 272                         requests */
 273  BIT(ftp_use_eprt);  /* As set with CURLOPT_FTP_USE_EPRT, but if we find out
 274                         EPRT does not work we disable it for the forthcoming
 275                         requests */
 276  BIT(ftp_use_data_ssl); /* Enabled SSL for the data connection */
 277#endif
 278  BIT(bound); /* set true if bind() has already been done on this socket/
 279                 connection */
 280  BIT(upgrade_in_progress); /* protocol upgrade is in progress */
 281  BIT(multiplex); /* connection is multiplexed */
 282  BIT(tcp_fastopen); /* use TCP Fast Open */
 283  BIT(tls_enable_alpn); /* TLS ALPN extension? */
 284  BIT(sock_accepted); /* TRUE if the SECONDARYSOCKET was created with
 285                         accept() */
 286  BIT(parallel_connect); /* set TRUE when a parallel connect attempt has
 287                            started (happy eyeballs) */
 288  BIT(aborted); /* connection was aborted, e.g. in unclean state */
 289  BIT(no_reuse); /* connection should not be reused */
 290  BIT(shutdown_handler); /* connection shutdown: handler shut down */
 291  BIT(shutdown_filters); /* connection shutdown: filters shut down */
 292  BIT(in_cpool);     /* connection is kept in a connection pool */
 293  BIT(dns_resolved); /* DNS records for connection were resolved */
 294};
 295
 296struct hostname {
 297  char *rawalloc; /* allocated "raw" version of the name */
 298  char *encalloc; /* allocated IDN-encoded version of the name */
 299  char *name;     /* name to use internally, might be encoded, might be raw */
 300  const char *dispname; /* name to display, as 'name' might be encoded */
 301};
 302
 303#define FIRSTSOCKET     0
 304#define SECONDARYSOCKET 1
 305
 306#define TRNSPRT_NONE 0
 307#define TRNSPRT_TCP  3
 308#define TRNSPRT_UDP  4
 309#define TRNSPRT_QUIC 5
 310#define TRNSPRT_UNIX 6
 311
 312struct ip_quadruple {
 313  char remote_ip[MAX_IPADR_LEN];
 314  char local_ip[MAX_IPADR_LEN];
 315  uint16_t remote_port;
 316  uint16_t local_port;
 317  uint8_t transport;
 318};
 319
 320#define CUR_IP_QUAD_HAS_PORTS(x)      \
 321  (((x)->transport == TRNSPRT_TCP) || \
 322   ((x)->transport == TRNSPRT_UDP) || \
 323   ((x)->transport == TRNSPRT_QUIC))
 324
 325struct proxy_info {
 326  struct Curl_peer *peer; /* proxy to this peer */
 327  struct Curl_creds *creds; /* use these credentials, maybe NULL */
 328  uint8_t proxytype; /* what kind of proxy that is in use */
 329};
 330
 331/*
 332 * The connectdata struct contains all fields and variables that should be
 333 * unique for an entire connection.
 334 */
 335struct connectdata {
 336  struct Curl_llist_node cpool_node; /* conncache lists */
 337  struct Curl_llist_node cshutdn_node; /* cshutdn list */
 338
 339  curl_closesocket_callback fclosesocket; /* function closing the socket(s) */
 340  void *closesocket_client;
 341
 342  /* This is used by the connection pool logic. If this returns TRUE, this
 343     handle is still used by one or more easy handles and can only used by any
 344     other easy handle without careful consideration (== only for
 345     multiplexing) and it cannot be used by another multi handle! */
 346#define CONN_INUSE(c) (!!(c)->attached_xfers)
 347
 348  /**** Fields set when inited and not modified again */
 349  curl_off_t connection_id; /* Contains a unique number to make it easier to
 350                               track the connections in the log output */
 351  char *destination; /* string carrying normalized hostname+port+scope */
 352
 353  /* `meta_hash` is a general key-value store for implementations
 354   * with the lifetime of the connection.
 355   * Elements need to be added with their own destructor to be invoked when
 356   * the connection is cleaned up (see Curl_hash_add2()).*/
 357  struct Curl_hash meta_hash;
 358
 359  /* Who the connection is talking to, ultimately */
 360  struct Curl_peer *origin; /* connection ultimately talks to this */
 361  struct Curl_peer *via_peer; /* if set, connection really talks to this */
 362  struct Curl_peer *origin2; /* origin of SECONDARYSOCKET */
 363  struct Curl_peer *via_peer2; /* peer of SECONDARYSOCKET */
 364#ifndef CURL_DISABLE_PROXY
 365  struct proxy_info socks_proxy;
 366  struct proxy_info http_proxy;
 367#endif
 368  struct Curl_creds *creds; /* When connection itself is tied to credentials */
 369  char *options; /* options string, allocated */
 370  struct curltime created; /* creation time */
 371  struct curltime lastused; /* when returned to the connection pool as idle */
 372
 373  /* A connection can have one or two sockets and connection filters.
 374   * The protocol using the 2nd one is FTP for CONTROL+DATA sockets */
 375  curl_socket_t sock[2];
 376  struct Curl_cfilter *cfilter[2]; /* connection filters */
 377  Curl_recv *recv[2];
 378  Curl_send *send[2];
 379  int recv_idx;  /* on which socket index to receive, default 0 */
 380  int send_idx;  /* on which socket index to send, default 0 */
 381
 382#define CONN_SOCK_IDX_VALID(i)    (((i) >= 0) && ((i) < 2))
 383
 384  struct {
 385    struct curltime start[2]; /* when filter shutdown started */
 386    timediff_t timeout_ms; /* 0 means no timeout */
 387  } shutdown;
 388
 389  struct ssl_primary_config ssl_config;
 390#ifndef CURL_DISABLE_PROXY
 391  struct ssl_primary_config proxy_ssl_config;
 392#endif
 393  struct ConnectBits bits;    /* various state-flags for this connection */
 394
 395  const struct Curl_scheme *scheme; /* Connection's protocol handler */
 396  const struct Curl_scheme *given;   /* The protocol first given */
 397
 398  /* Protocols can use a custom keepalive mechanism to keep connections alive.
 399     This allows those protocols to track the last time the keepalive mechanism
 400     was used on this connection. */
 401  struct curltime keepalive;
 402
 403  /* A connection cache from a SHARE might be used in several multi handles.
 404   * We MUST not reuse connections that are running in another multi,
 405   * for concurrency reasons. That multi might run in another thread.
 406   * `attached_multi` is set by the first transfer attached and cleared
 407   * when the last one is detached.
 408   * NEVER call anything on this multi, check for equality. */
 409  struct Curl_multi *attached_multi;
 410
 411  /*************** Request - specific items ************/
 412#if defined(USE_WINDOWS_SSPI) && defined(SECPKG_ATTR_ENDPOINT_BINDINGS)
 413  CtxtHandle *sslContext;  /* mingw-w64 v9+, MS SDK 7.0A/VS2010+ */
 414#endif
 415
 416#ifdef USE_NTLM
 417  curlntlm http_ntlm_state;
 418  curlntlm proxy_ntlm_state;
 419#endif
 420
 421#ifdef USE_SPNEGO
 422  curlnegotiate http_negotiate_state;
 423  curlnegotiate proxy_negotiate_state;
 424#endif
 425
 426  /* When this connection is created, store the conditions for the local end
 427     bind. This is stored before the actual bind and before any connection is
 428     made and will serve the purpose of being used for comparison reasons so
 429     that subsequent bound-requested connections are not accidentally reusing
 430     wrong connections. */
 431  char *localdev;
 432#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 433  int socks5_gssapi_enctype;
 434#endif
 435  uint32_t attached_xfers; /* # of attached easy handles */
 436
 437#ifdef USE_IPV6
 438  uint32_t scope_id;  /* Scope id for IPv6 */
 439#endif
 440  uint16_t localportrange;
 441  uint16_t localport;
 442  uint8_t transport_wanted; /* one of the TRNSPRT_* defines. Not necessarily
 443   the transport the connection ends using due to Alt-Svc and happy
 444   eyeballing. Use Curl_conn_get_transport() for actual value once the
 445   connection is set up. */
 446  uint8_t ip_version; /* copied from the Curl_easy at creation time */
 447  /* HTTP version last responded with by the server or negotiated via ALPN.
 448   * 0 at start, then one of 09, 10, 11, etc. */
 449  uint8_t httpversion_seen;
 450  uint8_t gssapi_delegation; /* inherited from set.gssapi_delegation */
 451};
 452
 453#ifndef CURL_DISABLE_PROXY
 454#define CURL_CONN_HOST_DISPNAME(c) \
 455  ((c)->bits.socksproxy ? (c)->socks_proxy.peer->user_hostname : \
 456    (c)->bits.httpproxy ? (c)->http_proxy.peer->user_hostname : \
 457      (c)->via_peer ? (c)->via_peer->user_hostname : \
 458        (c)->origin->user_hostname)
 459#else
 460#define CURL_CONN_HOST_DISPNAME(c) \
 461  ((c)->via_peer ? (c)->via_peer->user_hostname : (c)->origin->user_hostname)
 462#endif
 463
 464/* The end of connectdata. */
 465
 466/*
 467 * Struct to keep statistical and informational data.
 468 * All variables in this struct must be initialized/reset in Curl_initinfo().
 469 */
 470struct PureInfo {
 471  int httpcode;  /* Recent HTTP, FTP, RTSP or SMTP response code */
 472  int httpproxycode; /* response code from proxy when received separate */
 473  int httpversion; /* the http version number X.Y = X*10+Y */
 474  time_t filetime; /* If requested, this is might get set. Set to -1 if the
 475                      time was unretrievable. */
 476  curl_off_t request_size; /* the amount of bytes sent in the request(s) */
 477  curl_off_t numconnects; /* how many new connections libcurl created */
 478  uint32_t proxyauthavail; /* what proxy auth types were announced */
 479  uint32_t httpauthavail;  /* what host auth types were announced */
 480  uint32_t proxyauthpicked; /* selected proxy auth type */
 481  uint32_t httpauthpicked;  /* selected host auth type */
 482  char *contenttype; /* the content type of the object */
 483  char *wouldredirect; /* URL this would have been redirected to if asked to */
 484  curl_off_t retry_after; /* info from Retry-After: header */
 485  uint32_t header_size;  /* size of read header(s) in bytes */
 486
 487  /* PureInfo primary ip_quadruple is copied over from the connectdata
 488     struct in order to allow curl_easy_getinfo() to return this information
 489     even when the session handle is no longer associated with a connection,
 490     and also allow curl_easy_reset() to clear this information from the
 491     session handle without disturbing information which is still alive, and
 492     that might be reused, in the connection pool. */
 493  struct ip_quadruple primary;
 494  int conn_remote_port;  /* this is the "remote port", which is the port
 495                            number of the used URL, independent of proxy or
 496                            not */
 497  const char *conn_scheme;
 498  uint32_t conn_protocol;
 499  struct curl_certinfo certs; /* info about the certs. Asked for with
 500                                 CURLOPT_CERTINFO / CURLINFO_CERTINFO */
 501  CURLproxycode pxcode;
 502  BIT(timecond);  /* set to TRUE if the time condition did not match, which
 503                     thus made the document NOT get fetched */
 504  BIT(used_proxy); /* the transfer used a proxy */
 505};
 506
 507struct pgrs_dir {
 508  curl_off_t total_size; /* total expected bytes */
 509  curl_off_t cur_size; /* transferred bytes so far */
 510  curl_off_t speed; /* bytes per second transferred */
 511  struct Curl_rlimit rlimit; /* speed limiting / pausing */
 512};
 513
 514struct Progress {
 515  struct curltime now; /* current time of processing */
 516  time_t lastshow; /* time() of the last displayed progress meter or NULL to
 517                      force redraw at next call */
 518  struct pgrs_dir ul;
 519  struct pgrs_dir dl;
 520  curl_off_t deliver; /* amount of data delivered to application */
 521
 522  curl_off_t current_speed; /* uses the currently fastest transfer */
 523  curl_off_t earlydata_sent;
 524
 525  timediff_t timespent;
 526
 527  timediff_t t_postqueue;
 528  timediff_t t_nslookup;
 529  timediff_t t_connect;
 530  timediff_t t_appconnect;
 531  timediff_t t_pretransfer;
 532  timediff_t t_posttransfer;
 533  timediff_t t_starttransfer;
 534  timediff_t t_redirect;
 535
 536  struct curltime start;
 537  struct curltime t_startsingle;
 538  struct curltime t_startop;
 539  struct curltime t_startqueue;
 540  struct curltime t_acceptdata;
 541
 542#define CURL_SPEED_RECORDS (5 + 1) /* 6 entries for 5 seconds */
 543
 544  curl_off_t speed_amount[CURL_SPEED_RECORDS];
 545  struct curltime speed_time[CURL_SPEED_RECORDS];
 546  uint32_t speeder_c;
 547  BIT(hide);
 548  BIT(ul_size_known);
 549  BIT(dl_size_known);
 550  BIT(headers_out); /* when the headers have been written */
 551  BIT(callback);  /* set when progress callback is used */
 552  BIT(is_t_startransfer_set);
 553};
 554
 555typedef enum {
 556  RTSPREQ_NONE, /* first in list */
 557  RTSPREQ_OPTIONS,
 558  RTSPREQ_DESCRIBE,
 559  RTSPREQ_ANNOUNCE,
 560  RTSPREQ_SETUP,
 561  RTSPREQ_PLAY,
 562  RTSPREQ_PAUSE,
 563  RTSPREQ_TEARDOWN,
 564  RTSPREQ_GET_PARAMETER,
 565  RTSPREQ_SET_PARAMETER,
 566  RTSPREQ_RECORD,
 567  RTSPREQ_RECEIVE,
 568  RTSPREQ_LAST /* last in list */
 569} Curl_RtspReq;
 570
 571struct auth {
 572  uint32_t want;  /* Bitmask set to the authentication methods wanted by app
 573                     (with CURLOPT_HTTPAUTH or CURLOPT_PROXYAUTH). */
 574  uint32_t picked;
 575  uint32_t avail; /* Bitmask for what the server reports to support for this
 576                     resource */
 577  BIT(done);  /* TRUE when the auth phase is done and ready to do the
 578                 actual request */
 579  BIT(multipass); /* TRUE if this is not yet authenticated but within the
 580                     auth multipass negotiation */
 581};
 582
 583#ifdef USE_NGHTTP2
 584struct Curl_data_prio_node {
 585  struct Curl_data_prio_node *next;
 586  struct Curl_easy *data;
 587};
 588#endif
 589
 590/**
 591 * Priority information for an easy handle in relation to others
 592 * on the same connection.
 593 */
 594struct Curl_data_priority {
 595#ifdef USE_NGHTTP2
 596  /* tree like dependencies only implemented in nghttp2 */
 597  struct Curl_easy *parent;
 598  struct Curl_data_prio_node *children;
 599#endif
 600  int weight;
 601#ifdef USE_NGHTTP2
 602  BIT(exclusive);
 603#endif
 604};
 605
 606/* Timers */
 607typedef enum {
 608  EXPIRE_100_TIMEOUT,
 609  EXPIRE_ASYNC_NAME,
 610  EXPIRE_CONNECTTIMEOUT,
 611  EXPIRE_DNS_PER_NAME, /* family1 */
 612  EXPIRE_DNS_PER_NAME2, /* family2 */
 613  EXPIRE_HAPPY_EYEBALLS_DNS, /* See asyn-ares.c */
 614  EXPIRE_HAPPY_EYEBALLS,
 615  EXPIRE_MULTI_PENDING,
 616  EXPIRE_SPEEDCHECK,
 617  EXPIRE_TIMEOUT,
 618  EXPIRE_TOOFAST,
 619  EXPIRE_QUIC,
 620  EXPIRE_FTP_ACCEPT,
 621  EXPIRE_ALPN_EYEBALLS,
 622  EXPIRE_SHUTDOWN,
 623  EXPIRE_LAST /* not an actual timer, used as a marker only */
 624} expire_id;
 625
 626/*
 627 * One instance for each timeout an easy handle can set.
 628 */
 629struct time_node {
 630  struct Curl_llist_node list;
 631  struct curltime time;
 632  expire_id eid;
 633};
 634
 635/* individual pieces of the URL */
 636struct urlpieces {
 637  char *scheme;
 638  char *hostname;
 639  char *port;
 640  char *user;
 641  char *password;
 642  char *options;
 643  char *path;
 644  char *query;
 645};
 646
 647struct UrlState {
 648  /* buffers to store authentication data in, as parsed from input options */
 649  struct curltime keeps_speed; /* for the progress meter really */
 650
 651  curl_off_t lastconnect_id; /* The last connection, -1 if undefined */
 652  curl_off_t recent_conn_id; /* The most recent connection used, might no
 653                              * longer exist */
 654  struct dynbuf headerb; /* buffer to store headers in */
 655#ifndef CURL_DISABLE_HSTS
 656  struct curl_slist *hstslist; /* list of HSTS files set by
 657                                  curl_easy_setopt(HSTS) calls */
 658#endif
 659  curl_off_t current_speed;  /* the ProgressShow() function sets this,
 660                                bytes / second */
 661
 662  /* Origin of the initial (e.g. not followed) request of a transfer.
 663     Credentials from CURLOPT_* are only valid for this origin.
 664     Always set once a transfer starts searching for connections. */
 665  struct Curl_peer *initial_origin;
 666
 667  int os_errno;  /* filled in with errno whenever an error occurs */
 668  int requests; /* request counter: redirects + authentication retakes */
 669#ifdef HAVE_SIGNAL
 670  /* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */
 671  void (*prev_signal)(int sig);
 672#endif
 673#ifndef CURL_DISABLE_DIGEST_AUTH
 674  struct digestdata digest;      /* state data for host Digest auth */
 675  struct digestdata proxydigest; /* state data for proxy Digest auth */
 676#endif
 677  struct auth authhost;  /* auth details for host */
 678  struct auth authproxy; /* auth details for proxy */
 679
 680#ifdef USE_CURL_ASYNC
 681  struct Curl_resolv_async *async;  /* asynchronous name resolver data */
 682#endif
 683
 684#ifdef USE_OPENSSL
 685  /* void instead of ENGINE to avoid bleeding OpenSSL into this header */
 686  void *engine;
 687  /* void instead of OSSL_PROVIDER */
 688  void *provider;
 689  void *baseprov;
 690  void *libctx;
 691  char *propq; /* for a provider */
 692
 693  BIT(provider_loaded);
 694#endif /* USE_OPENSSL */
 695  struct curltime expiretime; /* set this with Curl_expire() only */
 696  struct Curl_tree timenode; /* for the splay stuff */
 697  struct Curl_llist timeoutlist; /* list of pending timeouts */
 698  struct time_node expires[EXPIRE_LAST]; /* nodes for each expire type */
 699
 700  /* a place to store the most recently set (S)FTP entrypath */
 701  char *most_recent_ftp_entrypath;
 702  char *range; /* range, if used. See README for detailed specification on
 703                  this syntax. */
 704  curl_off_t resume_from; /* continue [ftp] transfer from here */
 705
 706#ifndef CURL_DISABLE_RTSP
 707  /* This RTSP state information survives requests and connections */
 708  uint32_t rtsp_next_client_CSeq; /* the session's next client CSeq */
 709  uint32_t rtsp_next_server_CSeq; /* the session's next server CSeq */
 710  uint32_t rtsp_CSeq_recv; /* most recent CSeq received */
 711  uint8_t rtp_channel_mask[32]; /* for the correctness checking of the
 712                                         interleaved data */
 713#endif
 714
 715  curl_off_t infilesize; /* size of file to upload, -1 means unknown.
 716                            Copied from set.filesize at start of operation */
 717#if defined(USE_HTTP2) || defined(USE_HTTP3)
 718  struct Curl_data_priority priority; /* shallow copy of data->set */
 719#endif
 720
 721  curl_read_callback fread_func; /* read callback/function */
 722  void *in;                      /* CURLOPT_READDATA */
 723  CURLU *uh; /* URL handle for the current parsed URL */
 724  struct urlpieces up;
 725  struct bufref url;        /* work URL, initially copied from UserDefined */
 726  struct bufref referer;    /* referer string */
 727  struct curl_slist *resolve; /* set to point to the set.resolve list when
 728                                 this should be dealt with in pretransfer */
 729#ifndef CURL_DISABLE_HTTP
 730  curl_mimepart *mimepost;
 731#ifndef CURL_DISABLE_FORM_API
 732  curl_mimepart *formp; /* storage for old API form-posting, allocated on
 733                           demand */
 734#endif
 735  size_t trailers_bytes_sent;
 736  struct dynbuf trailers_buf; /* a buffer containing the compiled trailing
 737                                 headers */
 738  struct Curl_llist httphdrs; /* received headers */
 739  struct curl_header headerout[2]; /* for external purposes */
 740  struct Curl_header_store *prevhead; /* the latest added header */
 741#endif
 742#ifndef CURL_DISABLE_COOKIES
 743  struct curl_slist *cookielist; /* list of cookie files set by
 744                                    curl_easy_setopt(COOKIEFILE) calls */
 745#endif
 746
 747#ifdef CURLVERBOSE
 748  struct curl_trc_feat *feat; /* opt. trace feature transfer is part of */
 749#endif
 750
 751#ifndef CURL_DISABLE_NETRC
 752  struct store_netrc netrc;
 753#endif
 754
 755  struct Curl_creds *creds; /* Credentials for the origin only */
 756
 757  /* Dynamically allocated strings, MUST be freed before this struct is
 758     killed. */
 759  struct dynamically_allocated_data {
 760    char *uagent;
 761    char *accept_encoding;
 762    char *rangeline;
 763    char *ref;
 764    char *host;
 765#ifndef CURL_DISABLE_RTSP
 766    char *rtsp_transport;
 767#endif
 768  } aptr;
 769#ifndef CURL_DISABLE_HTTP
 770  struct http_negotiation http_neg;
 771#endif
 772  uint16_t followlocation; /* redirect counter */
 773  uint8_t retrycount; /* number of retries on a new connection, up to
 774                               CONN_MAX_RETRIES */
 775  uint8_t httpreq; /* Curl_HttpReq; what kind of HTTP request (if any)
 776                            is this */
 777
 778  /* when curl_easy_perform() is called, the multi handle is "owned" by
 779     the easy handle so curl_easy_cleanup() on such an easy handle will
 780     also close the multi handle! */
 781  BIT(multi_owned_by_easy);
 782
 783  BIT(this_is_a_follow); /* this is a followed Location: request */
 784  BIT(refused_stream); /* this was refused, try again */
 785  BIT(errorbuf); /* Set to TRUE if the error buffer is already filled in.
 786                    This must be set to FALSE every time _easy_perform() is
 787                    called. */
 788  BIT(allow_port); /* Is set.use_port allowed to take effect or not. This
 789                      is always set TRUE when curl_easy_perform() is called. */
 790  BIT(authproblem); /* TRUE if there is some problem authenticating */
 791  /* set after initial USER failure, to prevent an authentication loop */
 792  BIT(wildcardmatch); /* enable wildcard matching */
 793  BIT(disableexpect);    /* TRUE if Expect: is disabled due to a previous
 794                            417 response */
 795  BIT(use_range);
 796  BIT(rangestringalloc); /* the range string is malloc()'ed */
 797  BIT(done); /* set to FALSE when Curl_init_do() is called and set to TRUE
 798                when multi_done() is called, to prevent multi_done() to get
 799                invoked twice when the multi interface is used. */
 800#ifndef CURL_DISABLE_COOKIES
 801  BIT(cookie_engine);
 802#endif
 803  BIT(prefer_ascii);   /* ASCII rather than binary */
 804#ifdef CURL_LIST_ONLY_PROTOCOL
 805  BIT(list_only);      /* list directory contents */
 806#endif
 807  BIT(wildcard_resolve); /* Set to true if any resolve change is a wildcard */
 808  BIT(upload);         /* upload request */
 809  BIT(internal); /* internal: true if this easy handle was created for
 810                    internal use and the user does not have ownership of the
 811                    handle. */
 812  BIT(http_ignorecustom); /* ignore custom method from now */
 813#ifndef CURL_DISABLE_HTTP
 814  BIT(http_hd_te); /* Added HTTP header TE: */
 815  BIT(http_hd_upgrade); /* Added HTTP header Upgrade: */
 816  BIT(http_hd_h2_settings); /* Added HTTP header H2Settings: */
 817  BIT(maybe_folded);
 818  BIT(leading_unfold); /* unfold started, this is the leading bytes */
 819#endif
 820};
 821
 822/*
 823 * This 'UserDefined' struct must only contain data that is set once to go
 824 * for many (perhaps) independent connections. Values that are generated or
 825 * calculated internally for the "session handle" MUST be defined within the
 826 * 'struct UrlState' instead. The only exceptions MUST note the changes in
 827 * the 'DynamicStatic' struct.
 828 * Character pointer fields point to dynamic storage, unless otherwise stated.
 829 */
 830
 831struct Curl_multi;    /* declared in multihandle.c */
 832
 833enum dupstring {
 834  STRING_CERT,            /* client certificate filename */
 835  STRING_CERT_TYPE,       /* format for certificate (default: PEM)*/
 836  STRING_KEY,             /* private key filename */
 837  STRING_KEY_PASSWD,      /* plain text private key password */
 838  STRING_KEY_TYPE,        /* format for private key (default: PEM) */
 839  STRING_SSL_CAPATH,      /* CA directory name (does not work on Windows) */
 840  STRING_SSL_CAFILE,      /* certificate file to verify peer against */
 841  STRING_SSL_PINNEDPUBLICKEY, /* public key file to verify peer against */
 842  STRING_SSL_CIPHER_LIST, /* list of ciphers to use */
 843  STRING_SSL_CIPHER13_LIST, /* list of TLS 1.3 ciphers to use */
 844  STRING_SSL_CRLFILE,     /* CRL file to check certificate */
 845  STRING_SSL_ISSUERCERT,  /* issuer cert file to check certificate */
 846  STRING_SERVICE_NAME,    /* Service name */
 847#ifndef CURL_DISABLE_PROXY
 848  STRING_CERT_PROXY,      /* client certificate filename */
 849  STRING_CERT_TYPE_PROXY, /* format for certificate (default: PEM)*/
 850  STRING_KEY_PROXY,       /* private key filename */
 851  STRING_KEY_PASSWD_PROXY, /* plain text private key password */
 852  STRING_KEY_TYPE_PROXY,  /* format for private key (default: PEM) */
 853  STRING_SSL_CAPATH_PROXY, /* CA directory name (does not work on Windows) */
 854  STRING_SSL_CAFILE_PROXY, /* certificate file to verify peer against */
 855  STRING_SSL_PINNEDPUBLICKEY_PROXY, /* public key file to verify proxy */
 856  STRING_SSL_CIPHER_LIST_PROXY, /* list of ciphers to use */
 857  STRING_SSL_CIPHER13_LIST_PROXY, /* list of TLS 1.3 ciphers to use */
 858  STRING_SSL_CRLFILE_PROXY, /* CRL file to check certificate */
 859  STRING_SSL_ISSUERCERT_PROXY, /* issuer cert file to check certificate */
 860  STRING_PROXY_SERVICE_NAME, /* Proxy service name */
 861#endif
 862#ifndef CURL_DISABLE_COOKIES
 863  STRING_COOKIE,          /* HTTP cookie string to send */
 864  STRING_COOKIEJAR,       /* dump all cookies to this file */
 865#endif
 866  STRING_CUSTOMREQUEST,   /* HTTP/FTP/RTSP request/method to use */
 867  STRING_DEFAULT_PROTOCOL, /* Protocol to use when the URL does not specify */
 868  STRING_DEVICE,          /* local network interface/address to use */
 869  STRING_INTERFACE,       /* local network interface to use */
 870  STRING_BINDHOST,        /* local address to use */
 871  STRING_ENCODING,        /* Accept-Encoding string */
 872#ifndef CURL_DISABLE_FTP
 873  STRING_FTP_ACCOUNT,     /* ftp account data */
 874  STRING_FTP_ALTERNATIVE_TO_USER, /* command to send if USER/PASS fails */
 875  STRING_FTPPORT,         /* port to send with the FTP PORT command */
 876#endif
 877#ifndef CURL_DISABLE_NETRC
 878  STRING_NETRC_FILE,      /* if not NULL, use this instead of trying to find
 879                             $HOME/.netrc */
 880#endif
 881#ifndef CURL_DISABLE_PROXY
 882  STRING_PROXY,           /* proxy to use */
 883  STRING_PRE_PROXY,       /* pre socks proxy to use */
 884#endif
 885  STRING_SET_RANGE,       /* range, if used */
 886  STRING_SET_REFERER,     /* custom string for the HTTP referer field */
 887  STRING_SET_URL,         /* what original URL to work on */
 888  STRING_USERAGENT,       /* User-Agent string */
 889  STRING_SSL_ENGINE,      /* name of ssl engine */
 890  STRING_USERNAME,        /* <username>, if used */
 891  STRING_PASSWORD,        /* <password>, if used */
 892  STRING_OPTIONS,         /* <options>, if used */
 893#ifndef CURL_DISABLE_PROXY
 894  STRING_PROXYUSERNAME,   /* Proxy <username>, if used */
 895  STRING_PROXYPASSWORD,   /* Proxy <password>, if used */
 896  STRING_NOPROXY,         /* List of hosts which should not use the proxy, if
 897                             used */
 898#endif
 899#ifndef CURL_DISABLE_RTSP
 900  STRING_RTSP_SESSION_ID, /* Session ID to use */
 901  STRING_RTSP_STREAM_URI, /* Stream URI for this request */
 902  STRING_RTSP_TRANSPORT,  /* Transport for this session */
 903#endif
 904#ifdef USE_SSH
 905  STRING_SSH_PRIVATE_KEY, /* path to the private key file for auth */
 906  STRING_SSH_PUBLIC_KEY,  /* path to the public key file for auth */
 907  STRING_SSH_HOST_PUBLIC_KEY_MD5, /* md5 of host public key in ASCII hex */
 908  STRING_SSH_HOST_PUBLIC_KEY_SHA256, /* sha256 of host public key in base64 */
 909  STRING_SSH_KNOWNHOSTS,  /* filename of knownhosts file */
 910#endif
 911#ifndef CURL_DISABLE_SMTP
 912  STRING_MAIL_FROM,
 913  STRING_MAIL_AUTH,
 914#endif
 915#ifdef USE_TLS_SRP
 916  STRING_TLSAUTH_USERNAME,  /* TLS auth <username> */
 917  STRING_TLSAUTH_PASSWORD,  /* TLS auth <password> */
 918#ifndef CURL_DISABLE_PROXY
 919  STRING_TLSAUTH_USERNAME_PROXY, /* TLS auth <username> */
 920  STRING_TLSAUTH_PASSWORD_PROXY, /* TLS auth <password> */
 921#endif
 922#endif
 923  STRING_BEARER,                /* <bearer>, if used */
 924#ifdef USE_UNIX_SOCKETS
 925  STRING_UNIX_SOCKET_PATH,      /* path to Unix socket, if used */
 926#endif
 927  STRING_TARGET,                /* CURLOPT_REQUEST_TARGET */
 928#ifndef CURL_DISABLE_DOH
 929  STRING_DOH,                   /* CURLOPT_DOH_URL */
 930#endif
 931#ifndef CURL_DISABLE_ALTSVC
 932  STRING_ALTSVC,                /* CURLOPT_ALTSVC */
 933#endif
 934#ifndef CURL_DISABLE_HSTS
 935  STRING_HSTS,                  /* CURLOPT_HSTS */
 936#endif
 937  STRING_SASL_AUTHZID,          /* CURLOPT_SASL_AUTHZID */
 938#ifdef USE_ARES
 939  STRING_DNS_SERVERS,
 940  STRING_DNS_INTERFACE,
 941  STRING_DNS_LOCAL_IP4,
 942  STRING_DNS_LOCAL_IP6,
 943#endif
 944  STRING_SSL_EC_CURVES,
 945#ifndef CURL_DISABLE_AWS
 946  STRING_AWS_SIGV4, /* Parameters for V4 signature */
 947#endif
 948#ifndef CURL_DISABLE_PROXY
 949  STRING_HAPROXY_CLIENT_IP,     /* CURLOPT_HAPROXY_CLIENT_IP */
 950#endif
 951  STRING_ECH_CONFIG,            /* CURLOPT_ECH_CONFIG */
 952  STRING_ECH_PUBLIC,            /* CURLOPT_ECH_PUBLIC */
 953  STRING_SSL_SIGNATURE_ALGORITHMS, /* CURLOPT_SSL_SIGNATURE_ALGORITHMS */
 954
 955  /* -- end of null-terminated strings -- */
 956
 957  STRING_LASTZEROTERMINATED,
 958
 959  /* -- below this are pointers to binary data that cannot be strdup'ed. --- */
 960
 961  STRING_COPYPOSTFIELDS,  /* if POST, set the fields' values here */
 962
 963  STRING_LAST /* not used, an end-of-list marker */
 964};
 965
 966enum dupblob {
 967  BLOB_CERT,
 968  BLOB_KEY,
 969  BLOB_SSL_ISSUERCERT,
 970  BLOB_CAINFO,
 971#ifndef CURL_DISABLE_PROXY
 972  BLOB_CERT_PROXY,
 973  BLOB_KEY_PROXY,
 974  BLOB_SSL_ISSUERCERT_PROXY,
 975  BLOB_CAINFO_PROXY,
 976#endif
 977  BLOB_LAST
 978};
 979
 980struct UserDefined {
 981  FILE *err;         /* the stderr user data goes here */
 982  void *debugdata;   /* the data that will be passed to fdebug */
 983  char *errorbuffer; /* (Static) store failure messages in here */
 984  void *out;         /* CURLOPT_WRITEDATA */
 985  void *in_set;      /* CURLOPT_READDATA */
 986  void *writeheader; /* write the header to this if non-NULL */
 987  uint32_t httpauth;  /* kind of HTTP authentication to use (bitmask) */
 988  uint32_t proxyauth; /* kind of proxy authentication to use (bitmask) */
 989  void *postfields;  /* if POST, set the fields' values here */
 990  curl_seek_callback seek_func;      /* function that seeks the input */
 991  curl_off_t postfieldsize; /* if POST, this might have a size to use instead
 992                               of strlen(), and then the data *may* be binary
 993                               (contain zero bytes) */
 994  curl_write_callback fwrite_func;   /* function that stores the output */
 995  curl_write_callback fwrite_header; /* function that stores headers */
 996  curl_write_callback fwrite_rtp;    /* function that stores interleaved RTP */
 997  curl_read_callback fread_func_set; /* function that reads the input */
 998  curl_progress_callback fprogress; /* OLD and deprecated progress callback */
 999  curl_xferinfo_callback fxferinfo; /* progress callback */
1000  curl_debug_callback fdebug;      /* function that write informational data */
1001  curl_ioctl_callback ioctl_func;  /* function for I/O control */
1002  curl_sockopt_callback fsockopt;  /* function for setting socket options */
1003  void *sockopt_client; /* pointer to pass to the socket options callback */
1004  curl_opensocket_callback fopensocket; /* function for checking/translating
1005                                           the address and opening the
1006                                           socket */
1007  void *opensocket_client;
1008  curl_closesocket_callback fclosesocket; /* function for closing the
1009                                             socket */
1010  void *closesocket_client;
1011  curl_prereq_callback fprereq; /* pre-initial request callback */
1012  void *prereq_userp; /* pre-initial request user data */
1013
1014  void *seek_client;    /* pointer to pass to the seek callback */
1015#ifndef CURL_DISABLE_HSTS
1016  curl_hstsread_callback hsts_read;
1017  void *hsts_read_userp;
1018  curl_hstswrite_callback hsts_write;
1019  void *hsts_write_userp;
1020#endif
1021  void *progress_client; /* pointer to pass to the progress callback */
1022  void *ioctl_client;   /* pointer to pass to the ioctl callback */
1023  timediff_t conn_max_idle_ms; /* max idle time to allow a connection that
1024                                  is to be reused */
1025  timediff_t conn_max_age_ms; /* max time since creation to allow a
1026                                 connection that is to be reused */
1027  curl_off_t filesize;  /* size of file to upload, -1 means unknown */
1028  curl_off_t low_speed_limit; /* bytes/second */
1029  curl_off_t max_send_speed; /* high speed limit in bytes/second for upload */
1030  curl_off_t max_recv_speed; /* high speed limit in bytes/second for
1031                                download */
1032  curl_off_t set_resume_from;  /* continue [ftp] transfer from here */
1033  struct curl_slist *headers; /* linked list of extra headers */
1034  struct curl_httppost *httppost;  /* linked list of old POST data */
1035#if !defined(CURL_DISABLE_MIME) || !defined(CURL_DISABLE_FORM_API)
1036  curl_mimepart *mimepostp;  /* MIME/POST data. */
1037#endif
1038#ifndef CURL_DISABLE_TELNET
1039  struct curl_slist *telnet_options; /* linked list of telnet options */
1040#endif
1041  struct curl_slist *resolve;     /* list of names to add/remove from
1042                                     DNS cache */
1043  struct curl_slist *connect_to; /* list of host:port mappings to override
1044                                    the hostname and port to connect to */
1045  time_t timevalue;       /* what time to compare with */
1046  struct ssl_config_data ssl;  /* user defined SSL stuff */
1047#ifndef CURL_DISABLE_PROXY
1048  struct ssl_config_data proxy_ssl;  /* user defined SSL stuff for proxy */
1049  struct curl_slist *proxyheaders; /* linked list of extra CONNECT headers */
1050  uint16_t proxyport;       /* If non-zero, use this port number by
1051                               default. If the proxy string features a
1052                               ":[port]" that one will override this. */
1053  uint8_t proxytype; /* what kind of proxy */
1054  uint8_t socks5auth;/* kind of SOCKS5 authentication to use (bitmask) */
1055#endif
1056  struct ssl_general_config general_ssl; /* general user defined SSL stuff */
1057  timediff_t dns_cache_timeout_ms; /* DNS cache timeout (milliseconds) */
1058  uint32_t buffer_size;        /* size of receive buffer to use */
1059  uint32_t upload_buffer_size; /* size of upload buffer to use, keep it >=
1060                                  CURL_MAX_WRITE_SIZE */
1061  void *private_data; /* application-private data */
1062#ifndef CURL_DISABLE_HTTP
1063  struct curl_slist *http200aliases; /* linked list of aliases for http200 */
1064#endif
1065  curl_off_t max_filesize; /* Maximum file size to download */
1066#ifndef CURL_DISABLE_FTP
1067  timediff_t accepttimeout;   /* in milliseconds, 0 means no timeout */
1068  uint8_t ftp_filemethod; /* how to get to a file: curl_ftpfile */
1069  uint8_t ftpsslauth; /* what AUTH XXX to try: curl_ftpauth */
1070  uint8_t ftp_ccc;   /* FTP CCC options: curl_ftpccc */
1071#endif
1072#if !defined(CURL_DISABLE_FTP) || defined(USE_SSH)
1073  struct curl_slist *quote;     /* after connection is established */
1074  struct curl_slist *postquote; /* after the transfer */
1075  struct curl_slist *prequote; /* before the transfer, after type */
1076#endif
1077#ifdef USE_LIBSSH2
1078  curl_sshhostkeycallback ssh_hostkeyfunc; /* hostkey check callback */
1079  void *ssh_hostkeyfunc_userp;         /* custom pointer to callback */
1080#endif
1081#ifdef USE_SSH
1082  curl_sshkeycallback ssh_keyfunc; /* key matching callback */
1083  void *ssh_keyfunc_userp;         /* custom pointer to callback */
1084  uint32_t ssh_auth_types;   /* allowed SSH auth types */
1085  uint32_t new_directory_perms; /* when creating remote dirs */
1086#endif
1087  uint32_t new_file_perms;      /* when creating remote files */
1088  char *str[STRING_LAST]; /* array of strings, pointing to allocated memory */
1089  struct curl_blob *blobs[BLOB_LAST];
1090#ifdef USE_IPV6
1091  uint32_t scope_id;  /* Scope id for IPv6 */
1092#endif
1093  curl_prot_t allowed_protocols;
1094  curl_prot_t redir_protocols;
1095#ifndef CURL_DISABLE_RTSP
1096  void *rtp_out;     /* write RTP to this if non-NULL */
1097  /* Common RTSP header options */
1098  Curl_RtspReq rtspreq; /* RTSP request type */
1099#endif
1100#ifndef CURL_DISABLE_FTP
1101  curl_chunk_bgn_callback chunk_bgn; /* called before part of transfer
1102                                        starts */
1103  curl_chunk_end_callback chunk_end; /* called after part transferring
1104                                        stopped */
1105  curl_fnmatch_callback fnmatch; /* callback to decide which file corresponds
1106                                    to pattern (e.g. if WILDCARDMATCH is on) */
1107  void *fnmatch_data;
1108  void *wildcardptr;
1109#endif
1110
1111  timediff_t timeout;   /* ms, 0 means no timeout */
1112  timediff_t connecttimeout; /* ms, 0 means default timeout */
1113  timediff_t happy_eyeballs_timeout; /* ms, 0 is a valid value */
1114  timediff_t server_response_timeout; /* ms, 0 means no timeout */
1115  timediff_t shutdowntimeout; /* ms, 0 means default timeout */
1116  int tcp_keepidle;     /* seconds in idle before sending keepalive probe */
1117  int tcp_keepintvl;    /* seconds between TCP keepalive probes */
1118  int tcp_keepcnt;      /* maximum number of keepalive probes */
1119
1120#if defined(USE_HTTP2) || defined(USE_HTTP3)
1121  struct Curl_data_priority priority;
1122#endif
1123  curl_resolver_start_callback resolver_start; /* optional callback called
1124                                                  before resolver start */
1125  void *resolver_start_client; /* pointer to pass to resolver start callback */
1126  timediff_t upkeep_interval_ms; /* Time between calls for connection
1127                                    upkeep. */
1128  CURLU *uh; /* URL handle for the current parsed URL */
1129#ifndef CURL_DISABLE_HTTP
1130  void *trailer_data; /* pointer to pass to trailer data callback */
1131  curl_trailer_callback trailer_callback; /* trailing data callback */
1132#endif
1133#ifndef CURL_DISABLE_SMTP
1134  struct curl_slist *mail_rcpt; /* linked list of mail recipients */
1135#endif
1136  uint32_t maxconnects; /* Max idle connections in the connection cache */
1137  short maxredirs;    /* maximum no. of http(s) redirects to follow,
1138                         set to -1 for infinity */
1139  uint16_t expect_100_timeout; /* in milliseconds */
1140  uint16_t use_port; /* which port to use (when not using default) */
1141  uint16_t low_speed_time;  /* number of seconds */
1142#ifndef CURL_DISABLE_BINDLOCAL
1143  uint16_t localport; /* local port number to bind to */
1144  uint16_t localportrange; /* number of additional port numbers to test
1145                                    in case the 'localport' one cannot be
1146                                    bind()ed */
1147#endif
1148#ifndef CURL_DISABLE_TFTP
1149  uint16_t tftp_blksize;    /* in bytes, 0 means use default */
1150#endif
1151#ifdef USE_ECH
1152  uint8_t tls_ech;      /* TLS ECH configuration */
1153#endif
1154#ifndef CURL_DISABLE_NETRC
1155  uint8_t use_netrc;        /* enum CURL_NETRC_OPTION values */
1156#endif
1157#if !defined(CURL_DISABLE_FTP) || defined(USE_SSH)
1158  /* Despite the name, ftp_create_missing_dirs is for FTP(S) and SFTP
1159     1 - create directories that do not exist
1160     2 - the same but also allow MKD to fail once
1161  */
1162  uint8_t ftp_create_missing_dirs;
1163#endif
1164  uint8_t use_ssl;   /* if AUTH TLS is to be attempted etc, for FTP or IMAP or
1165                        POP3 or others! (type: curl_usessl)*/
1166  uint8_t timecondition; /* kind of time comparison: curl_TimeCond */
1167  uint8_t method;   /* what kind of HTTP request: Curl_HttpReq */
1168  uint8_t httpwant; /* when non-zero, a specific HTTP version requested
1169                             to be used in the library's request(s) */
1170  uint8_t ipver; /* the CURL_IPRESOLVE_* defines in the public header
1171                          file 0 - whatever, 1 - v2, 2 - v6 */
1172  uint8_t upload_flags; /* flags set by CURLOPT_UPLOAD_FLAGS */
1173#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
1174  /* GSS-API/SSPI credential delegation, see CURLOPT_GSSAPI_DELEGATION */
1175  uint8_t gssapi_delegation;
1176#endif
1177  uint8_t http_follow_mode; /* follow HTTP redirects */
1178  BIT(connect_only); /* make connection/request, then let application use the
1179                        socket */
1180  BIT(connect_only_ws); /* special websocket connect-only level */
1181#ifndef CURL_DISABLE_SMTP
1182  BIT(mail_rcpt_allowfails); /* allow RCPT TO command to fail for some
1183                                recipients */
1184#endif
1185#ifndef CURL_DISABLE_MIME
1186  BIT(mime_formescape);
1187#endif
1188  BIT(is_fread_set); /* has read callback been set to non-NULL? */
1189#ifndef CURL_DISABLE_TFTP
1190  BIT(tftp_no_options); /* do not send TFTP options requests */
1191#endif
1192  BIT(sep_headers);     /* handle host and proxy headers separately */
1193#ifndef CURL_DISABLE_COOKIES
1194  BIT(cookiesession);   /* new cookie session? */
1195#endif
1196  BIT(crlf);            /* convert crlf on ftp upload(?) */
1197#ifdef USE_SSH
1198  BIT(ssh_compression);            /* enable SSH compression */
1199#endif
1200
1201/* Here follows boolean settings that define how to behave during
1202   this session. They are STATIC, set by libcurl users or at least initially
1203   and they do not change during operations. */
1204  BIT(quick_exit);       /* set 1L when it is okay to leak things (like
1205                            threads), as we are about to exit() anyway and
1206                            do not want lengthy cleanups to delay termination,
1207                            e.g. after a DNS timeout */
1208  BIT(get_filetime);     /* get the time and get of the remote file */
1209#ifndef CURL_DISABLE_PROXY
1210  BIT(tunnel_thru_httpproxy); /* use CONNECT through an HTTP proxy */
1211#endif
1212  BIT(prefer_ascii);     /* ASCII rather than binary */
1213  BIT(remote_append);    /* append, not overwrite, on upload */
1214#ifdef CURL_LIST_ONLY_PROTOCOL
1215  BIT(list_only);        /* list directory */
1216#endif
1217#ifndef CURL_DISABLE_FTP
1218  BIT(ftp_use_port);     /* use the FTP PORT command */
1219  BIT(ftp_use_epsv);     /* if EPSV is to be attempted or not */
1220  BIT(ftp_use_eprt);     /* if EPRT is to be attempted or not */
1221  BIT(ftp_use_pret);     /* if PRET is to be used before PASV or not */
1222  BIT(ftp_skip_ip);      /* skip the IP address the FTP server passes on to
1223                            us */
1224  BIT(wildcard_enabled); /* enable wildcard matching */
1225#endif
1226  BIT(http_fail_on_error);  /* fail on HTTP error codes >= 400 */
1227  BIT(http_keep_sending_on_error); /* for HTTP status codes >= 300 */
1228  BIT(http_transfer_encoding); /* request compressed HTTP transfer-encoding */
1229  BIT(allow_auth_to_other_hosts);
1230  BIT(include_header); /* include received protocol headers in data output */
1231  BIT(http_set_referer); /* is a custom referer used */
1232  BIT(http_auto_referer); /* set "correct" referer when following
1233                             location: */
1234  BIT(opt_no_body);    /* as set with CURLOPT_NOBODY */
1235  BIT(verbose);        /* output verbosity */
1236  BIT(reuse_forbid);   /* forbidden to be reused, close after use */
1237  BIT(reuse_fresh);    /* do not reuse an existing connection */
1238  BIT(no_signal);      /* do not use any signal/alarm handler */
1239  BIT(tcp_nodelay);    /* whether to enable TCP_NODELAY or not */
1240  BIT(ignorecl);       /* ignore content length */
1241  BIT(http_te_skip);   /* pass the raw body data to the user, even when
1242                          transfer-encoded (chunked, compressed) */
1243  BIT(http_ce_skip);   /* pass the raw body data to the user, even when
1244                          content-encoded (chunked, compressed) */
1245  BIT(proxy_transfer_mode); /* set transfer mode (;type=<a|i>) when doing
1246                               FTP via an HTTP proxy */
1247#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
1248  BIT(socks5_gssapi_nec); /* Flag to support NEC SOCKS5 server */
1249#endif
1250  BIT(sasl_ir);         /* Enable/disable SASL initial response */
1251  BIT(tcp_keepalive);  /* use TCP keepalives */
1252  BIT(tcp_fastopen);   /* use TCP Fast Open */
1253  BIT(ssl_enable_alpn);/* TLS ALPN extension? */
1254  BIT(path_as_is);     /* allow dotdots? */
1255  BIT(pipewait);       /* wait for multiplex status before starting a new
1256                          connection */
1257  BIT(suppress_connect_headers); /* suppress proxy CONNECT response headers
1258                                    from user callbacks */
1259  BIT(dns_shuffle_addresses); /* whether to shuffle addresses before use */
1260#ifndef CURL_DISABLE_PROXY
1261  BIT(haproxyprotocol); /* whether to send HAProxy PROXY protocol v1
1262                           header */
1263#endif
1264#ifdef USE_UNIX_SOCKETS
1265  BIT(abstract_unix_socket);
1266#endif
1267  BIT(disallow_username_in_url); /* disallow username in URL */
1268#ifndef CURL_DISABLE_DOH
1269  BIT(doh); /* DNS-over-HTTPS enabled */
1270  BIT(doh_verifypeer);     /* DoH certificate peer verification */
1271  BIT(doh_verifyhost);     /* DoH certificate hostname verification */
1272  BIT(doh_verifystatus);   /* DoH certificate status verification */
1273#endif
1274  BIT(http09_allowed); /* allow HTTP/0.9 responses */
1275#ifndef CURL_DISABLE_WEBSOCKETS
1276  BIT(ws_raw_mode);
1277  BIT(ws_no_auto_pong);
1278#endif
1279  BIT(post301); /* keep POSTs as POSTs after a 301 request */
1280  BIT(post302); /* keep POSTs as POSTs after a 302 request */
1281  BIT(post303); /* keep POSTs as POSTs after a 303 request */
1282};
1283
1284#ifndef CURL_DISABLE_MIME
1285#define IS_MIME_POST(a)                                                 \
1286  ((a)->set.mimepostp && ((a)->set.mimepostp->kind != MIMEKIND_NONE))
1287#else
1288#define IS_MIME_POST(a) FALSE
1289#endif
1290
1291/* callback that gets called when a sub easy (data->master_mid set) is
1292   DONE. Called on the master easy. */
1293typedef void multi_sub_xfer_done_cb(struct Curl_easy *master_easy,
1294                                    struct Curl_easy *sub_easy,
1295                                    CURLcode result);
1296
1297/*
1298 * The 'connectdata' struct MUST have all the connection oriented stuff as we
1299 * may have several simultaneous connections and connection structs in memory.
1300 *
1301 * The 'struct UserDefined' must only contain data that is set once to go for
1302 * many (perhaps) independent connections. Values that are generated or
1303 * calculated internally for the "session handle" must be defined within the
1304 * 'struct UrlState' instead.
1305 */
1306
1307struct Curl_easy {
1308  /* First a simple identifier to easier detect if a user mix up this easy
1309     handle with a multi handle. Set this to CURLEASY_MAGIC_NUMBER */
1310  uint32_t magic;
1311  /* once an easy handle is tied to a connection pool a non-negative number to
1312     distinguish this transfer from other using the same pool. For easier
1313     tracking in log output. This may wrap around after LONG_MAX to 0 again,
1314     so it has no uniqueness guarantee for large processings. Note: it has no
1315     uniqueness either IFF more than one connection pool is used by the
1316     libcurl application. */
1317  curl_off_t id;
1318  /* once an easy handle is added to a multi, either explicitly by the
1319   * libcurl application or implicitly during `curl_easy_perform()`,
1320   * a unique identifier inside this one multi instance. */
1321  uint32_t mid;
1322  uint32_t master_mid; /* if set, this transfer belongs to a master */
1323  multi_sub_xfer_done_cb *sub_xfer_done;
1324
1325  struct connectdata *conn;
1326
1327  CURLMstate mstate;  /* the handle's state */
1328  CURLcode result;   /* previous result */
1329
1330  struct Curl_message msg; /* A single posted message. */
1331
1332  struct Curl_multi *multi;    /* if non-NULL, points to the multi handle
1333                                  struct to which this "belongs" when used by
1334                                  the multi interface */
1335  struct Curl_multi *multi_easy; /* if non-NULL, points to the multi handle
1336                                    struct to which this "belongs" when used
1337                                    by the easy interface */
1338  struct Curl_share *share;    /* Share, handles global variable mutexing */
1339
1340  /* `meta_hash` is a general key-value store for implementations
1341   * with the lifetime of the easy handle.
1342   * Elements need to be added with their own destructor to be invoked when
1343   * the easy handle is cleaned up (see Curl_hash_add2()).*/
1344  struct Curl_hash meta_hash;
1345
1346#ifdef USE_LIBPSL
1347  struct PslCache *psl;        /* The associated PSL cache. */
1348#endif
1349  struct SingleRequest req;    /* Request-specific data */
1350  struct UserDefined set;      /* values set by the libcurl user */
1351#ifndef CURL_DISABLE_COOKIES
1352  struct CookieInfo *cookies;  /* the cookies, read from files and servers.
1353                                  NOTE that the 'cookie' field in the
1354                                  UserDefined struct defines if the "engine"
1355                                  is to be used or not. */
1356#endif
1357#ifndef CURL_DISABLE_HSTS
1358  struct hsts *hsts;
1359#endif
1360#ifndef CURL_DISABLE_ALTSVC
1361  struct altsvcinfo *asi;      /* the alt-svc cache */
1362#endif
1363  struct Progress progress;    /* for all the progress meter data */
1364  struct UrlState state;       /* struct for fields used for state info and
1365                                  other dynamic purposes */
1366#ifndef CURL_DISABLE_FTP
1367  struct WildcardData *wildcard; /* wildcard download state info */
1368#endif
1369  struct PureInfo info;        /* stats, reports and info data */
1370  struct curl_tlssessioninfo tsi; /* Information about the TLS session, only
1371                                     valid after a client has asked for it */
1372};
1373
1374#define LIBCURL_NAME "libcurl"
1375
1376#endif /* HEADER_CURL_URLDATA_H */