#ifndef HEADER_CURL_URLDATA_H

#define HEADER_CURL_URLDATA_H

/***************************************************************************

 *                                  _   _ ____  _

 *  Project                     ___| | | |  _ \| |

 *                             / __| | | | |_) | |

 *                            | (__| |_| |  _ <| |___

 *                             \___|\___/|_| \_\_____|

 *

 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.

 *

 * This software is licensed as described in the file COPYING, which

 * you should have received as part of this distribution. The terms

 * are also available at https://curl.se/docs/copyright.html.

 *

 * You may opt to use, copy, modify, merge, publish, distribute and/or sell

 * copies of the Software, and permit persons to whom the Software is

 * furnished to do so, under the terms of the COPYING file.

 *

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY

 * KIND, either express or implied.

 *

 * SPDX-License-Identifier: curl

 *

 ***************************************************************************/

/* This file is for lib internal stuff */

#include "curl_setup.h"

#define CURL_DEFAULT_USER     "anonymous"

#define CURL_DEFAULT_PASSWORD "ftp@example.com"

#if !defined(_WIN32) && !defined(MSDOS)

/* do FTP line-end CRLF => LF conversions on platforms that prefer LF-only. It

   also means: keep CRLF line endings on the CRLF platforms */

#define CURL_PREFER_LF_LINEENDS

#endif

#define DEFAULT_CONNCACHE_SIZE 5

/* length of longest IPv6 address string including the null-terminator */

#define MAX_IPADR_LEN sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")

/* Max string input length is a precaution against abuse and to detect junk

   input easier and better. */

#define CURL_MAX_INPUT_LENGTH 8000000

#ifdef HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#ifdef HAVE_NETINET_IN6_H

#include <netinet/in6.h>

#endif

#include "curlx/timeval.h"

#include "api.h"

#include "cookie.h"

#include "creds.h"

#include "psl.h"

#include "formdata.h"

#include "http_chunks.h" /* for the structs and enum stuff */

#include "hash.h"

#include "peer.h"

#include "proxy.h"

#include "splay.h"

#include "curlx/dynbuf.h"

#include "bufref.h"

#include "dynhds.h"

#include "request.h"

#include "ratelimit.h"

#include "netrc.h"

#include "uint-hashset.h"

#include "vdns/asyn.h"

#include "vdns/hostip.h"

#include "vtls/vtls_config.h"

/* On error return, the value of `pnwritten` has no meaning */

typedef CURLcode (Curl_send)(struct Curl_easy *data,   /* transfer */

                             int8_t sockindex,            /* socketindex */

                             const uint8_t *buf,       /* data to write */

                             size_t len,               /* amount to send */

                             bool eos,                 /* last chunk */

                             size_t *pnwritten);       /* how much sent */

/* On error return, the value of `pnread` has no meaning */

typedef CURLcode (Curl_recv)(struct Curl_easy *data,   /* transfer */

                             int8_t sockindex,            /* socketindex */

                             char *buf,                /* store data here */

                             size_t len,               /* max amount to read */

                             size_t *pnread);          /* how much received */

#include "mime.h"

#include "protocol.h"

#include "ftp.h"

#include "http.h"

#include "smb.h"

#include "mqtt.h"

#include "ftplistparser.h"

#include "multihandle.h"

#include "cf-socket.h"

#ifdef HAVE_GSSAPI

#  ifdef HAVE_GSSAPPLE

#    include <GSS/gssapi.h>

#    include <GSS/gssapi_oid.h>

#  elif defined(HAVE_GSSGNU)

#    include <gss.h>

#  elif defined(HAVE_GSSAPI_H)

#    include <gssapi.h>

#  else /* MIT Kerberos */

#    include <gssapi/gssapi.h>

#    include <gssapi/gssapi_krb5.h> /* for GSS_C_CHANNEL_BOUND_FLAG in 1.19+ */

#  endif

#endif

#ifdef USE_LIBSSH2

#include <libssh2.h>

#include <libssh2_sftp.h>

#endif /* USE_LIBSSH2 */

#define READBUFFER_SIZE CURL_MAX_WRITE_SIZE

#define READBUFFER_MAX  CURL_MAX_READ_SIZE

#define READBUFFER_MIN  1024

/* The default upload buffer size, should not be smaller than

   CURL_MAX_WRITE_SIZE, as it needs to hold a full buffer as could be sent in

   a write callback.

   The size was 16KB for many years but was bumped to 64KB because it makes

   libcurl able to do significantly faster uploads in some circumstances. Even

   larger buffers can help further, but this is deemed a fair memory/speed

   compromise. */

#define UPLOADBUFFER_DEFAULT 65536

#define UPLOADBUFFER_MAX     (2 * 1024 * 1024)

#define UPLOADBUFFER_MIN     CURL_MAX_WRITE_SIZE

#ifdef USE_WINDOWS_SSPI

#include "curl_sspi.h"

#endif

#ifndef CURL_DISABLE_DIGEST_AUTH

/* Struct used for Digest challenge-response authentication */

struct digestdata {

  struct Curl_creds *creds;

  struct Curl_peer *origin;

#ifdef USE_WINDOWS_SSPI

  BYTE *input_token;

  size_t input_token_len;

  CtxtHandle *http_context;

#else

  char *nonce;

  char *cnonce;

  char *realm;

  char *opaque;

  char *qop;

  char *algorithm;

  int nc; /* nonce count */

  uint8_t algo;

  BIT(stale); /* set true for re-negotiation */

  BIT(userhash);

#endif

};

#endif

typedef enum {

  NTLMSTATE_NONE,

  NTLMSTATE_TYPE1,

  NTLMSTATE_TYPE2,

  NTLMSTATE_TYPE3,

  NTLMSTATE_LAST

} curlntlm;

typedef enum {

  GSS_AUTHNONE,

  GSS_AUTHRECV,

  GSS_AUTHSENT,

  GSS_AUTHDONE,

  GSS_AUTHSUCC

} curlnegotiate;

/*

 * Boolean values that concerns this connection.

 */

struct ConnectBits {

  BIT(connect_only);

#ifndef CURL_DISABLE_PROXY

  BIT(origin_is_proxy);  /* if set, the connection's origin is a proxy */

#endif

  /* always modify bits.close with the connclose() and connkeep() macros! */

  BIT(close); /* if set, we close the connection after this request */

  BIT(reuse); /* if set, this is a reused connection */

  BIT(altused); /* this is an alt-svc "redirect" */

  BIT(ipv6);    /* we communicate with a site using an IPv6 address */

  BIT(do_more); /* this is set TRUE if the ->curl_do_more() function is

                   supposed to be called, after ->curl_do() */

  BIT(protoconnstart);/* the protocol layer has STARTED its operation after

                         the TCP layer connect */

  BIT(retry);         /* this connection is about to get closed and then

                         re-attempted at another connection. */

#ifndef CURL_DISABLE_FTP

  BIT(ftp_use_epsv);  /* As set with CURLOPT_FTP_USE_EPSV, but if we find out

                         EPSV does not work we disable it for the forthcoming

                         requests */

  BIT(ftp_use_eprt);  /* As set with CURLOPT_FTP_USE_EPRT, but if we find out

                         EPRT does not work we disable it for the forthcoming

                         requests */

  BIT(ftp_use_data_ssl); /* Enabled SSL for the data connection */

#endif

  BIT(bound); /* set true if bind() has already been done on this socket/

                 connection */

  BIT(upgrade_in_progress); /* protocol upgrade is in progress */

  BIT(multiplex); /* connection is multiplexed */

  BIT(tcp_fastopen); /* use TCP Fast Open */

  BIT(tls_enable_alpn); /* TLS ALPN extension? */

  BIT(sock_accepted); /* TRUE if the SECONDARYSOCKET was created with

                         accept() */

  BIT(parallel_connect); /* set TRUE when a parallel connect attempt has

                            started (happy eyeballs) */

  BIT(aborted); /* connection was aborted, e.g. in unclean state */

  BIT(no_reuse); /* connection should not be reused */

  BIT(shutdown_handler); /* connection shutdown: handler shut down */

  BIT(shutdown_filters); /* connection shutdown: filters shut down */

  BIT(in_cpool);     /* connection is kept in a connection pool */

  BIT(dns_resolved); /* DNS records for connection were resolved */

};

struct hostname {

  char *rawalloc; /* allocated "raw" version of the name */

  char *encalloc; /* allocated IDN-encoded version of the name */

  char *name;     /* name to use internally, might be encoded, might be raw */

  const char *dispname; /* name to display, as 'name' might be encoded */

};

#define FIRSTSOCKET     0

#define SECONDARYSOCKET 1

#define TRNSPRT_NONE 0

#define TRNSPRT_TCP  3

#define TRNSPRT_UDP  4

#define TRNSPRT_QUIC 5

#define TRNSPRT_UNIX 6

#define TRNSPRT_IS_DGRAM(x)   (((x) == TRNSPRT_UDP) || ((x) == TRNSPRT_QUIC))

struct ip_quadruple {

  char remote_ip[MAX_IPADR_LEN];

  char local_ip[MAX_IPADR_LEN];

  uint16_t remote_port;

  uint16_t local_port;

  uint8_t transport;

};

#define CUR_IP_QUAD_HAS_PORTS(x)      \

  (((x)->transport == TRNSPRT_TCP) || \

   ((x)->transport == TRNSPRT_UDP) || \

   ((x)->transport == TRNSPRT_QUIC))

/*

 * The connectdata struct contains all fields and variables that should be

 * unique for an entire connection.

 */

struct connectdata {

  curl_off_t connection_id; /* Contains a unique number to make it easier to

                               track the connections in the log output */

  /* A connection cache from a SHARE might be used in several multi handles.

   * We MUST not reuse connections that are running in another multi,

   * for concurrency reasons. That multi might run in another thread.

   * `attached_multi` is set by the first transfer attached and cleared

   * when the last one is detached.

   * NEVER call anything on this multi, check for equality. */

  struct Curl_multi *attached_multi;

  /* Who the connection is talking to, ultimately */

  struct Curl_peer *origin; /* connection ultimately talks to this */

  struct Curl_peer *via_peer; /* if set, connection really talks to this */

  struct Curl_peer *origin2; /* origin of SECONDARYSOCKET */

  struct Curl_peer *via_peer2; /* peer of SECONDARYSOCKET */

  struct Curl_creds *creds; /* When connection itself is tied to credentials */

  struct Curl_peer *creds_origin; /* origin tied credentials are for */

  const struct Curl_scheme *scheme; /* Connection's real protocol handler */

  const struct Curl_scheme *given;   /* The protocol first given */

  /* `meta_hash` is a general key-value store for implementations

   * with the lifetime of the connection.

   * Elements need to be added with their own destructor to be invoked when

   * the connection is cleaned up (see Curl_hash_add2()).*/

  struct Curl_hash meta_hash;

  struct Curl_llist_node cpool_node; /* conncache lists */

  struct Curl_llist_node cshutdn_node; /* cshutdn list */

  char *destination; /* hostname+port, used in conncache */

  struct curltime created; /* creation time */

  struct curltime lastused; /* when returned to the connection pool as idle */

  struct curltime lastchecked; /* when last checked alive status */

  struct curltime lastupkeep; /* when last done conn_upkeep */

#ifndef CURL_DISABLE_PROXY

  struct proxy_info socks_proxy;

  struct proxy_info http_proxy;

#endif

  struct Curl_cfilter *cfilter[2]; /* connection filters */

  Curl_recv *recv[2];

  Curl_send *send[2];

  /* A connection can have one or two sockets and connection filters.

   * The protocol using the 2nd one is FTP for CONTROL+DATA sockets */

  curl_socket_t sock[2];

#define CONN_SOCK_IDX_VALID(i)    (((i) >= 0) && ((i) < 2))

  struct {

    struct curltime start[2]; /* when filter shutdown started */

    timediff_t timeout_ms; /* 0 means no timeout */

  } shutdown;

  curl_closesocket_callback fclosesocket; /* function closing the socket(s) */

  void *closesocket_client;

  struct ssl_primary_config ssl_config;

#ifndef CURL_DISABLE_PROXY

  struct ssl_primary_config proxy_ssl_config;

#endif

  char *options; /* options string, allocated */

  /*************** Request - specific items ************/

#ifdef USE_WINDOWS_SSPI

  CtxtHandle *sslContext;

#endif

#ifdef USE_NTLM

  curlntlm http_ntlm_state;

  curlntlm proxy_ntlm_state;

#endif

#ifdef USE_SPNEGO

  curlnegotiate http_negotiate_state;

  curlnegotiate proxy_negotiate_state;

#endif

  /* When this connection is created, store the conditions for the local end

     bind. This is stored before the actual bind and before any connection is

     made and will serve the purpose of being used for comparison reasons so

     that subsequent bound-requested connections are not accidentally reusing

     wrong connections. */

  char *localdev;

  struct ConnectBits bits;    /* various state-flags for this connection */

#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)

  int socks5_gssapi_enctype;

#endif

  /* This is used by the connection pool logic. If this returns TRUE, this

     handle is still used by one or more easy handles and can only used by any

     other easy handle without careful consideration (== only for

     multiplexing) and it cannot be used by another multi handle! */

#define CONN_INUSE(c) (!!(c)->attached_xfers)

  uint32_t attached_xfers; /* # of attached easy handles */

#ifdef USE_IPV6

  uint32_t scope_id;  /* Scope id for IPv6 */

#endif

  uint16_t localportrange;

  uint16_t localport;

  int8_t recv_idx;  /* on which socket index to receive, default 0 */

  int8_t send_idx;  /* on which socket index to send, default 0 */

  uint8_t transport_wanted; /* one of the TRNSPRT_* defines. Not necessarily

   the transport the connection ends using due to Alt-Svc and happy

   eyeballing. Use Curl_conn_get_transport() for actual value once the

   connection is set up. */

  uint8_t ip_version; /* copied from the Curl_easy at creation time */

  /* HTTP version last responded with by the server or negotiated via ALPN.

   * 0 at start, then one of 09, 10, 11, etc. */

  uint8_t httpversion_seen;

  uint8_t gssapi_delegation; /* inherited from set.gssapi_delegation */

};

#ifndef CURL_DISABLE_PROXY

#define CURL_CONN_HOST_DISPNAME(c) \

  ((c)->socks_proxy.peer ? (c)->socks_proxy.peer->user_hostname : \

    (c)->http_proxy.peer ? (c)->http_proxy.peer->user_hostname : \

      (c)->via_peer ? (c)->via_peer->user_hostname : \

        (c)->origin->user_hostname)

#else

#define CURL_CONN_HOST_DISPNAME(c) \

  ((c)->via_peer ? (c)->via_peer->user_hostname : (c)->origin->user_hostname)

#endif

/* The end of connectdata. */

/*

 * Struct to keep statistical and informational data.

 * All variables in this struct must be initialized/reset in Curl_initinfo().

 */

struct PureInfo {

  /* PureInfo primary ip_quadruple is copied over from the connectdata

     struct in order to allow curl_easy_getinfo() to return this information

     even when the session handle is no longer associated with a connection,

     and also allow curl_easy_reset() to clear this information from the

     session handle without disturbing information which is still alive, and

     that might be reused, in the connection pool. */

  struct ip_quadruple primary;

  struct curl_certinfo certs; /* info about the certs. Asked for with

                                 CURLOPT_CERTINFO / CURLINFO_CERTINFO */

  time_t filetime; /* If requested, this is might get set. Set to -1 if the

                      time was unretrievable. */

  curl_off_t request_size; /* the amount of bytes sent in the request(s) */

  curl_off_t numconnects; /* how many new connections libcurl created */

  char *contenttype; /* the content type of the object */

  char *wouldredirect; /* URL this would have been redirected to if asked to */

  curl_off_t retry_after; /* info from Retry-After: header */

  const char *conn_scheme;

  int httpcode;  /* Recent HTTP, FTP, RTSP or SMTP response code */

  int httpproxycode; /* response code from proxy when received separate */

  int httpversion; /* the http version number X.Y = X*10+Y */

  uint32_t conn_protocol;

  uint32_t proxyauthavail; /* what proxy auth types were announced */

  uint32_t httpauthavail;  /* what host auth types were announced */

  uint32_t proxyauthpicked; /* selected proxy auth type */

  uint32_t httpauthpicked;  /* selected host auth type */

  uint32_t header_size;  /* size of read header(s) in bytes */

  uint8_t pxcode; /* holds a CURLproxycode */

  BIT(timecond);  /* set to TRUE if the time condition did not match, which

                     thus made the document NOT get fetched */

  BIT(used_proxy); /* the transfer used a proxy */

};

struct pgrs_dir {

  curl_off_t total_size; /* total expected bytes */

  curl_off_t cur_size; /* transferred bytes so far */

  curl_off_t speed; /* bytes per second transferred */

  struct Curl_rlimit rlimit; /* speed limiting / pausing */

};

struct Progress {

  struct curltime now; /* current time of processing */

  struct curltime start; /* when transfer was initialized, set once */

  struct pgrs_dir ul;

  struct pgrs_dir dl;

  curl_off_t deliver; /* amount of data delivered to application */

  curl_off_t current_speed; /* uses the currently fastest transfer */

  curl_off_t earlydata_sent;

  struct {

    timediff_t startop_us; /* since start when operations started */

    timediff_t startsingle_us; /* since start when last request started */

    timediff_t startqueue_us; /* since start when last entered queueing */

    timediff_t startredirect_us; /* since start when last redirected */

    timediff_t lastshow_us; /* since start when last progress shown */

  } delta;

  struct {

    timediff_t spent_us; /* all time spent since start */

    timediff_t queued_us; /* time spent since startsingle's for queueing */

    timediff_t nslookup_us; /* same for name resolves */

    timediff_t connect_us; /* same for connects */

    timediff_t appconnect_us; /* same for application connects, e.g. TLS */

    timediff_t pretransfer_us; /* same until requests were sent */

    timediff_t starttransfer_us; /* same until responses started */

    timediff_t posttransfer_us; /* same until responses ended */

  } total;

#define CURL_SPEED_RECORDS (5 + 1) /* 6 entries for 5 seconds */

  curl_off_t speed_amount[CURL_SPEED_RECORDS];

  timediff_t speed_time[CURL_SPEED_RECORDS];

  uint32_t speeder_c;

  BIT(hide);

  BIT(ul_size_known);

  BIT(dl_size_known);

  BIT(headers_out); /* when the headers have been written */

  BIT(callback);  /* set when progress callback is used */

  BIT(startransfer_added);

};

struct auth {

  uint32_t want;  /* Bitmask set to the authentication methods wanted by app

                     (with CURLOPT_HTTPAUTH or CURLOPT_PROXYAUTH). */

  uint32_t picked;

  uint32_t avail; /* Bitmask for what the server reports to support for this

                     resource */

  BIT(done);  /* TRUE when the auth phase is done and ready to do the

                 actual request */

  BIT(multipass); /* TRUE if this is not yet authenticated but within the

                     auth multipass negotiation */

};

#ifdef USE_NGHTTP2

struct Curl_data_prio_node {

  struct Curl_data_prio_node *next;

  struct Curl_easy *data;

};

#endif

/* Timers */

typedef enum {

  EXPIRE_100_TIMEOUT,

  EXPIRE_ASYNC_NAME,

  EXPIRE_CONNECTTIMEOUT,

  EXPIRE_HAPPY_EYEBALLS,

  EXPIRE_MULTI_PENDING,

  EXPIRE_SPEEDCHECK,

  EXPIRE_TIMEOUT,

  EXPIRE_TOOFAST,

  EXPIRE_QUIC,

  EXPIRE_FTP_ACCEPT,

  EXPIRE_ALPN_EYEBALLS,

  EXPIRE_SHUTDOWN,

  EXPIRE_LAST /* not an actual timer, used as a marker only */

} expire_id;

struct expire_timers {

  struct Curl_tree splaynode; /* for the splay stuff */

  /* microsecond offset from Curl_timeouts base timestamp */

  timediff_t offset_us[EXPIRE_LAST];

  uint8_t next[EXPIRE_LAST];

  uint8_t first;

};

/* individual pieces of the URL */

struct urlpieces {

  char *options;

  char *path;

  char *query;

};

struct UrlState {

  curl_off_t lastconnect_id; /* The last assigned connection or -1 */

  /* Origin of the initial (e.g. not followed) request of a transfer.

     Credentials from CURLOPT_* are only valid for this origin.

     Always set once a transfer starts searching for connections. */

  struct Curl_peer *initial_origin;

  /* Current origin of the transfer, changes to origin of follow

   * requests. */

  struct Curl_peer *origin;

  struct curltime keeps_speed; /* for the progress meter really */

  struct dynbuf headerb; /* buffer to store headers in */

#ifndef CURL_DISABLE_HSTS

  struct curl_slist *hstslist; /* list of HSTS files set by

                                  curl_easy_setopt(HSTS) calls */

#endif

  int os_errno;  /* filled in with errno whenever an error occurs */

  int requests; /* request counter: redirects + authentication retakes */

#ifdef HAVE_SIGNAL

  /* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */

  void (*prev_signal)(int sig);

#endif

#ifndef CURL_DISABLE_DIGEST_AUTH

  char *envproxy; /* last proxy string used for proxy-related state */

  struct digestdata digest;      /* state data for host Digest auth */

  struct digestdata proxydigest; /* state data for proxy Digest auth */

#endif

  struct auth authhost;  /* auth details for host */

  struct auth authproxy; /* auth details for proxy */

#ifdef USE_CURL_ASYNC

  struct Curl_resolv_async *async;  /* asynchronous name resolver data */

#endif

#ifdef USE_OPENSSL

  /* void instead of ENGINE to avoid bleeding OpenSSL into this header */

  void *engine;

  /* void instead of OSSL_PROVIDER */

  void *provider;

  void *baseprov;

  void *libctx;

  char *propq; /* for a provider */

#endif /* USE_OPENSSL */

  struct expire_timers timeouts; /* expire timeouts */

  /* a place to store the most recently set (S)FTP entrypath */

  char *most_recent_ftp_entrypath;

  char *range; /* range, if used. See README for detailed specification on

                  this syntax. */

  curl_off_t resume_from; /* continue [ftp] transfer from here */

  curl_off_t infilesize; /* size of file to upload, -1 means unknown.

                            Copied from set.filesize at start of operation */

  curl_read_callback fread_func; /* read callback/function */

  void *in;                      /* CURLOPT_READDATA */

  CURLU *uh; /* URL handle for the current parsed URL */

  struct urlpieces up;

  struct bufref url;        /* work URL, initially copied from UserDefined */

  struct bufref referer;    /* referer string */

  struct curl_slist *resolve; /* set to point to the set.resolve list when

                                 this should be dealt with in pretransfer */

#ifndef CURL_DISABLE_HTTP

  curl_mimepart *mimepost;

#ifndef CURL_DISABLE_FORM_API

  curl_mimepart *formp; /* storage for old API form-posting, allocated on

                           demand */

#endif

  struct Curl_llist httphdrs; /* received headers */

  struct curl_header headerout[2]; /* for external purposes */

#endif

#ifndef CURL_DISABLE_COOKIES

  struct curl_slist *cookielist; /* list of cookie files set by

                                    curl_easy_setopt(COOKIEFILE) calls */

#endif

#ifdef CURLVERBOSE

  struct curl_trc_feat *feat; /* opt. trace feature transfer is part of */

#endif

#ifndef CURL_DISABLE_NETRC

  struct store_netrc netrc;

#endif

  struct Curl_creds *creds; /* Credentials for the origin only */

#ifndef CURL_DISABLE_HTTP

  char *rangeline; /* allocated */

  char *http_host; /* allocated */

  struct http_negotiation http_neg;

#endif

#ifndef CURL_DISABLE_RTSP

  /* This RTSP state information survives requests and connections */

  uint8_t rtp_channel_mask[32]; /* for the correctness checking of the

                                         interleaved data */

  uint32_t rtsp_next_client_CSeq; /* the session's next client CSeq */

  uint32_t rtsp_next_server_CSeq; /* the session's next server CSeq */

  uint32_t rtsp_CSeq_recv; /* most recent CSeq received */

#endif

#if defined(USE_HTTP2) || defined(USE_HTTP3)

  int weight; /* shallow copy of data->set */

#endif

  uint16_t followlocation; /* redirect counter */

  uint8_t retrycount; /* number of retries on a new connection, up to

                               CONN_MAX_RETRIES */

  uint8_t httpreq; /* Curl_HttpReq; what kind of HTTP request (if any)

                            is this */

#ifdef USE_OPENSSL

  BIT(provider_loaded);

#endif /* USE_OPENSSL */

  BIT(really_alive); /* transfer is really alive in multi, passed INIT */

  BIT(this_is_a_follow); /* this is a followed Location: request */

  BIT(refused_stream); /* this was refused, try again */

  BIT(errorbuf); /* Set to TRUE if the error buffer is already filled in.

                    This must be set to FALSE every time _easy_perform() is

                    called. */

  BIT(allow_port); /* Is set.use_port allowed to take effect or not. This

                      is always set TRUE when curl_easy_perform() is called. */

  BIT(authproblem); /* TRUE if there is some problem authenticating */

  /* set after initial USER failure, to prevent an authentication loop */

  BIT(wildcardmatch); /* enable wildcard matching */

  BIT(disableexpect);    /* TRUE if Expect: is disabled due to a previous

                            417 response */

  BIT(use_range);

  BIT(rangestringalloc); /* the range string is malloc()'ed */

  BIT(done); /* set to FALSE when Curl_init_transfer() is called and set to

                TRUE when multi_done() is called, to prevent multi_done() from

                being invoked twice. */

#ifndef CURL_DISABLE_COOKIES

  BIT(cookie_engine);

#endif

  BIT(prefer_ascii);   /* ASCII rather than binary */

#ifdef CURL_LIST_ONLY_PROTOCOL

  BIT(list_only);      /* list directory contents */

#endif

  BIT(wildcard_resolve); /* Set to true if any resolve change is a wildcard */

  BIT(upload);         /* upload request */

  BIT(internal); /* internal: true if this easy handle was created for

                    internal use and the user does not have ownership of the

                    handle. */

  BIT(http_ignorecustom); /* ignore custom method from now */

#ifndef CURL_DISABLE_HTTP

  BIT(http_hd_te); /* Added HTTP header TE: */

  BIT(http_hd_upgrade); /* Added HTTP header Upgrade: */

  BIT(http_hd_h2_settings); /* Added HTTP header H2Settings: */

  BIT(maybe_folded);

  BIT(leading_unfold); /* unfold started, this is the leading bytes */

#endif

};

/*

 * This 'UserDefined' struct must only contain data that is set once to go

 * for many (perhaps) independent connections. Values that are generated or

 * calculated internally for the "session handle" MUST be defined within the

 * 'struct UrlState' instead. The only exceptions MUST note the changes in

 * the 'DynamicStatic' struct.

 * Character pointer fields point to dynamic storage, unless otherwise stated.

 */

struct Curl_multi;    /* declared in multihandle.c */

enum dupstring {

  STRING_CERT,            /* client certificate filename */

  STRING_CERT_TYPE,       /* format for certificate (default: PEM)*/

  STRING_KEY,             /* private key filename */

  STRING_KEY_PASSWD,      /* plain text private key password */

  STRING_KEY_TYPE,        /* format for private key (default: PEM) */

  STRING_SSL_CAPATH,      /* CA directory name (does not work on Windows) */

  STRING_SSL_CAFILE,      /* certificate file to verify peer against */

  STRING_SSL_PINNEDPUBLICKEY, /* public key file to verify peer against */

  STRING_SSL_CIPHER_LIST, /* list of ciphers to use */

  STRING_SSL_CIPHER13_LIST, /* list of TLS 1.3 ciphers to use */

  STRING_SSL_CRLFILE,     /* CRL file to check certificate */

  STRING_SSL_ISSUERCERT,  /* issuer cert file to check certificate */

  STRING_SERVICE_NAME,    /* Service name */

#ifndef CURL_DISABLE_PROXY

  STRING_CERT_PROXY,      /* client certificate filename */

  STRING_CERT_TYPE_PROXY, /* format for certificate (default: PEM)*/

  STRING_KEY_PROXY,       /* private key filename */

  STRING_KEY_PASSWD_PROXY, /* plain text private key password */

  STRING_KEY_TYPE_PROXY,  /* format for private key (default: PEM) */

  STRING_SSL_CAPATH_PROXY, /* CA directory name (does not work on Windows) */

  STRING_SSL_CAFILE_PROXY, /* certificate file to verify peer against */

  STRING_SSL_PINNEDPUBLICKEY_PROXY, /* public key file to verify proxy */

  STRING_SSL_CIPHER_LIST_PROXY, /* list of ciphers to use */

  STRING_SSL_CIPHER13_LIST_PROXY, /* list of TLS 1.3 ciphers to use */

  STRING_SSL_CRLFILE_PROXY, /* CRL file to check certificate */

  STRING_SSL_ISSUERCERT_PROXY, /* issuer cert file to check certificate */

  STRING_PROXY_SERVICE_NAME, /* Proxy service name */

#endif

#ifndef CURL_DISABLE_COOKIES

  STRING_COOKIE,          /* HTTP cookie string to send */

  STRING_COOKIEJAR,       /* dump all cookies to this file */

#endif

  STRING_CUSTOMREQUEST,   /* HTTP/FTP/RTSP request/method to use */

  STRING_DEFAULT_PROTOCOL, /* Protocol to use when the URL does not specify */

  STRING_DEVICE,          /* local network interface/address to use */

  STRING_INTERFACE,       /* local network interface to use */

  STRING_BINDHOST,        /* local address to use */

  STRING_ENCODING,        /* Accept-Encoding string */

#ifndef CURL_DISABLE_FTP

  STRING_FTP_ACCOUNT,     /* ftp account data */

  STRING_FTP_ALTERNATIVE_TO_USER, /* command to send if USER/PASS fails */

  STRING_FTPPORT,         /* port to send with the FTP PORT command */

#endif

#ifndef CURL_DISABLE_NETRC

  STRING_NETRC_FILE,      /* if not NULL, use this instead of trying to find

                             $HOME/.netrc */

#endif

#ifndef CURL_DISABLE_PROXY

  STRING_PROXY,           /* proxy to use */

  STRING_PRE_PROXY,       /* pre socks proxy to use */

#endif

  STRING_SET_RANGE,       /* range, if used */

  STRING_SET_REFERER,     /* custom string for the HTTP referer field */

  STRING_SET_URL,         /* what original URL to work on */

  STRING_USERAGENT,       /* User-Agent string */

  STRING_SSL_ENGINE,      /* name of SSL engine */

  STRING_USERNAME,        /* <username>, if used */

  STRING_PASSWORD,        /* <password>, if used */

  STRING_OPTIONS,         /* <options>, if used */

#ifndef CURL_DISABLE_PROXY

  STRING_PROXYUSERNAME,   /* Proxy <username>, if used */

  STRING_PROXYPASSWORD,   /* Proxy <password>, if used */

  STRING_NOPROXY,         /* List of hosts which should not use the proxy, if

                             used */

#endif

#ifndef CURL_DISABLE_RTSP

  STRING_RTSP_SESSION_ID, /* Session ID to use */

  STRING_RTSP_STREAM_URI, /* Stream URI for this request */

  STRING_RTSP_TRANSPORT,  /* Transport for this session */

#endif

#ifdef USE_SSH

  STRING_SSH_PRIVATE_KEY, /* path to the private key file for auth */

  STRING_SSH_PUBLIC_KEY,  /* path to the public key file for auth */

  STRING_SSH_HOST_PUBLIC_KEY_MD5, /* md5 of host public key in ASCII hex */

  STRING_SSH_HOST_PUBLIC_KEY_SHA256, /* sha256 of host public key in base64 */

  STRING_SSH_KNOWNHOSTS,  /* filename of knownhosts file */

#endif

#ifndef CURL_DISABLE_SMTP

  STRING_MAIL_FROM,

  STRING_MAIL_AUTH,

#endif

  STRING_BEARER,                /* <bearer>, if used */

#ifdef USE_UNIX_SOCKETS

  STRING_UNIX_SOCKET_PATH,      /* path to Unix socket, if used */

#endif

  STRING_TARGET,                /* CURLOPT_REQUEST_TARGET */

#ifndef CURL_DISABLE_DOH

  STRING_DOH,                   /* CURLOPT_DOH_URL */

#endif

#ifndef CURL_DISABLE_ALTSVC

  STRING_ALTSVC,                /* CURLOPT_ALTSVC */

#endif

#ifndef CURL_DISABLE_HSTS

  STRING_HSTS,                  /* CURLOPT_HSTS */

#endif

  STRING_SASL_AUTHZID,          /* CURLOPT_SASL_AUTHZID */

#ifdef USE_ARES

  STRING_DNS_SERVERS,

  STRING_DNS_INTERFACE,

  STRING_DNS_LOCAL_IP4,

  STRING_DNS_LOCAL_IP6,

#endif

  STRING_SSL_EC_CURVES,

#ifndef CURL_DISABLE_AWS

  STRING_AWS_SIGV4, /* Parameters for V4 signature */

#endif

#ifndef CURL_DISABLE_HTTPSIG

  STRING_HTTPSIG_KEY,    /* hex-encoded key data */

  STRING_HTTPSIG_KEYID,  /* key identifier */

  STRING_HTTPSIG_HEADERS, /* space-separated components to sign */

#endif

#ifndef CURL_DISABLE_PROXY

  STRING_HAPROXY_CLIENT_IP,     /* CURLOPT_HAPROXY_CLIENT_IP */

#endif

  STRING_ECH_CONFIG,            /* CURLOPT_ECH_CONFIG */

  STRING_ECH_PUBLIC,            /* CURLOPT_ECH_PUBLIC */

  STRING_SSL_SIGNATURE_ALGORITHMS, /* CURLOPT_SSL_SIGNATURE_ALGORITHMS */

  STRING_LAST /* not used, an end-of-list marker */

};

enum dupblob {

  BLOB_CERT,

  BLOB_KEY,

  BLOB_SSL_ISSUERCERT,

  BLOB_CAINFO,

#ifndef CURL_DISABLE_PROXY

  BLOB_CERT_PROXY,

  BLOB_KEY_PROXY,

  BLOB_SSL_ISSUERCERT_PROXY,

  BLOB_CAINFO_PROXY,

#endif

  BLOB_LAST

};

struct UserDefined {

  FILE *err;         /* the stderr user data goes here */

  void *debugdata;   /* the data that will be passed to fdebug */

  char *errorbuffer; /* (Static) store failure messages in here */

  void *out;         /* CURLOPT_WRITEDATA */

  void *in_set;      /* CURLOPT_READDATA */

  void *writeheader; /* write the header to this if non-NULL */

  uint32_t httpauth;  /* kind of HTTP authentication to use (bitmask) */

  uint32_t proxyauth; /* kind of proxy authentication to use (bitmask) */

  void *postfields;  /* if POST, set the fields' values here */

  char *str_copypostfields; /* CURLOPT_COPYPOSTFIELDS value */

  curl_seek_callback seek_func;      /* function that seeks the input */

  curl_off_t postfieldsize; /* if POST, this might have a size to use instead

                               of strlen(), and then the data *may* be binary

                               (contain zero bytes) */

  curl_write_callback fwrite_func;   /* function that stores the output */

  curl_write_callback fwrite_header; /* function that stores headers */

  curl_write_callback fwrite_rtp;    /* function that stores interleaved RTP */

  curl_read_callback fread_func_set; /* function that reads the input */

  curl_progress_callback fprogress; /* OLD and deprecated progress callback */

  curl_xferinfo_callback fxferinfo; /* progress callback */

  curl_debug_callback fdebug;      /* function that write informational data */

  curl_ioctl_callback ioctl_func;  /* function for I/O control */

  curl_sockopt_callback fsockopt;  /* function for setting socket options */

  void *sockopt_client; /* pointer to pass to the socket options callback */

  curl_opensocket_callback fopensocket; /* function for checking/translating

                                           the address and opening the

                                           socket */

  void *opensocket_client;

  curl_closesocket_callback fclosesocket; /* function for closing the

                                             socket */

  void *closesocket_client;

  curl_prereq_callback fprereq; /* pre-initial request callback */

  void *prereq_userp; /* pre-initial request user data */

  void *seek_client;    /* pointer to pass to the seek callback */

#ifndef CURL_DISABLE_HSTS

  curl_hstsread_callback hsts_read;

  void *hsts_read_userp;

  curl_hstswrite_callback hsts_write;

  void *hsts_write_userp;

#endif

  void *progress_client; /* pointer to pass to the progress callback */

  void *ioctl_client;   /* pointer to pass to the ioctl callback */

  timediff_t conn_max_idle_ms; /* max idle time to allow a connection that

                                  is to be reused */

  timediff_t conn_max_age_ms; /* max time since creation to allow a

                                 connection that is to be reused */

  curl_off_t filesize;  /* size of file to upload, -1 means unknown */

  curl_off_t low_speed_limit; /* bytes/second */

  curl_off_t max_send_speed; /* high speed limit in bytes/second for upload */

  curl_off_t max_recv_speed; /* high speed limit in bytes/second for

                                download */

  curl_off_t set_resume_from;  /* continue [ftp] transfer from here */

  struct curl_slist *headers; /* linked list of extra headers */

  struct curl_httppost *httppost;  /* linked list of old POST data */

#if !defined(CURL_DISABLE_MIME) || !defined(CURL_DISABLE_FORM_API)

  curl_mimepart *mimepostp;  /* MIME/POST data. */

#endif

#ifndef CURL_DISABLE_TELNET

  struct curl_slist *telnet_options; /* linked list of telnet options */

#endif

  struct curl_slist *resolve;     /* list of names to add/remove from

                                     DNS cache */

  struct curl_slist *connect_to; /* list of host:port mappings to override

                                    the hostname and port to connect to */

  time_t timevalue;       /* what time to compare with */

  struct ssl_config_data ssl;  /* user defined SSL stuff */

#ifndef CURL_DISABLE_PROXY

  struct ssl_config_data proxy_ssl;  /* user defined SSL stuff for proxy */

  struct curl_slist *proxyheaders; /* linked list of extra CONNECT headers */

  uint16_t proxyport;       /* If non-zero, use this port number by

                               default. If the proxy string features a

                               ":[port]" that one will override this. */

  uint8_t proxytype; /* what kind of proxy */

  uint8_t socks5auth;/* kind of SOCKS5 authentication to use (bitmask) */

#endif

  struct ssl_general_config general_ssl; /* general user defined SSL stuff */

  timediff_t dns_cache_timeout_ms; /* DNS cache timeout (milliseconds) */

  uint32_t buffer_size;        /* size of receive buffer to use */

  uint32_t upload_buffer_size; /* size of upload buffer to use, keep it >=

                                  CURL_MAX_WRITE_SIZE */

  void *private_data; /* application-private data */

#ifndef CURL_DISABLE_HTTP

  struct curl_slist *http200aliases; /* linked list of aliases for http200 */

#endif

  curl_off_t max_filesize; /* Maximum file size to download */

#ifndef CURL_DISABLE_FTP

  timediff_t accepttimeout;   /* in milliseconds, 0 means no timeout */

#endif

#if !defined(CURL_DISABLE_FTP) || defined(USE_SSH)

  struct curl_slist *quote;     /* after connection is established */

  struct curl_slist *postquote; /* after the transfer */

  struct curl_slist *prequote; /* before the transfer, after type */

#endif

#ifdef USE_LIBSSH2

  curl_sshhostkeycallback ssh_hostkeyfunc; /* hostkey check callback */

  void *ssh_hostkeyfunc_userp;         /* custom pointer to callback */

#endif

#ifdef USE_SSH

  curl_sshkeycallback ssh_keyfunc; /* key matching callback */

  void *ssh_keyfunc_userp;         /* custom pointer to callback */

  uint32_t ssh_auth_types;   /* allowed SSH auth types */

  uint32_t new_directory_perms; /* when creating remote dirs */

#endif

  struct u8_strset strings;

  struct curl_blob *blobs[BLOB_LAST];

  uint32_t new_file_perms;      /* when creating remote files */

#ifdef USE_IPV6

  uint32_t scope_id;  /* Scope id for IPv6 */

#endif

  curl_prot_t allowed_protocols;

  curl_prot_t redir_protocols;

#ifndef CURL_DISABLE_RTSP

  void *rtp_out;     /* write RTP to this if non-NULL */

#endif

#ifndef CURL_DISABLE_FTP

  curl_chunk_bgn_callback chunk_bgn; /* called before part of transfer

                                        starts */

  curl_chunk_end_callback chunk_end; /* called after part transferring

                                        stopped */

  curl_fnmatch_callback fnmatch; /* callback to decide which file corresponds

                                    to pattern (e.g. if WILDCARDMATCH is on) */

  void *fnmatch_data;

  void *wildcardptr;

#endif

  timediff_t timeout;   /* ms, 0 means no timeout */

  timediff_t connecttimeout; /* ms, 0 means default timeout */

  timediff_t happy_eyeballs_timeout; /* ms, 0 is a valid value */

  timediff_t server_response_timeout; /* ms, 0 means no timeout */

  timediff_t shutdowntimeout; /* ms, 0 means default timeout */

  curl_resolver_start_callback resolver_start; /* optional callback called

                                                  before resolver start */

  void *resolver_start_client; /* pointer to pass to resolver start callback */

  timediff_t upkeep_interval_ms; /* Time between calls for connection

                                    upkeep. */

  CURLU *uh; /* URL handle for the current parsed URL */

#ifndef CURL_DISABLE_HTTP

  void *trailer_data; /* pointer to pass to trailer data callback */

  curl_trailer_callback trailer_callback; /* trailing data callback */

#endif

#ifndef CURL_DISABLE_SMTP

  struct curl_slist *mail_rcpt; /* linked list of mail recipients */

#endif

  int tcp_keepidle;     /* seconds in idle before sending keepalive probe */

  int tcp_keepintvl;    /* seconds between TCP keepalive probes */

  int tcp_keepcnt;      /* maximum number of keepalive probes */

  uint32_t maxconnects; /* Max idle connections in the connection cache */

#if defined(USE_HTTP2) || defined(USE_HTTP3)

  /* Priority information for an easy handle in relation to others on the same

     connection. */

  int weight;

#endif

  short maxredirs;    /* maximum no. of http(s) redirects to follow,

                         set to -1 for infinity */

  uint16_t expect_100_timeout; /* in milliseconds */

  uint16_t use_port; /* which port to use (when not using default) */

  uint16_t low_speed_time;  /* number of seconds */

#ifndef CURL_DISABLE_BINDLOCAL

  uint16_t localport; /* local port number to bind to */

  uint16_t localportrange; /* number of additional port numbers to test

                                    in case the 'localport' one cannot be

                                    bind()ed */

#endif

#ifndef CURL_DISABLE_TFTP

  uint16_t tftp_blksize;    /* in bytes, 0 means use default */

#endif

#ifndef CURL_DISABLE_RTSP

  uint8_t rtspreq; /* RTSP request type */

#endif

#ifdef USE_ECH

  uint8_t tls_ech;      /* TLS ECH configuration */

#endif

#ifndef CURL_DISABLE_NETRC

  uint8_t use_netrc;        /* enum CURL_NETRC_OPTION values */

#endif

#if !defined(CURL_DISABLE_FTP) || defined(USE_SSH)

  /* Despite the name, ftp_create_missing_dirs is for FTP(S) and SFTP

     1 - create directories that do not exist

     2 - the same but also allow MKD to fail once

   */

  uint8_t ftp_create_missing_dirs;

#endif

#ifndef CURL_DISABLE_FTP

  uint8_t ftp_filemethod; /* how to get to a file: curl_ftpfile */

  uint8_t ftpsslauth; /* what AUTH XXX to try: curl_ftpauth */

  uint8_t ftp_ccc;   /* FTP CCC options: curl_ftpccc */

#endif

  uint8_t httpsig_algorithm; /* CURLHTTPSIG_* algorithm for RFC 9421 */

  uint8_t use_ssl;   /* if AUTH TLS is to be attempted etc, for FTP or IMAP or

                        POP3 or others! (type: curl_usessl)*/

  uint8_t timecondition; /* kind of time comparison: curl_TimeCond */

  uint8_t method;   /* what kind of HTTP request: Curl_HttpReq */

  uint8_t httpwant; /* when non-zero, a specific HTTP version requested

                             to be used in the library's request(s) */

  uint8_t ipver; /* the CURL_IPRESOLVE_* defines in the public header

                          file 0 - whatever, 1 - v2, 2 - v6 */

  uint8_t upload_flags; /* flags set by CURLOPT_UPLOAD_FLAGS */

#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)

  /* GSS-API/SSPI credential delegation, see CURLOPT_GSSAPI_DELEGATION */

  uint8_t gssapi_delegation;

#endif

  uint8_t http_follow_mode; /* follow HTTP redirects */

  BIT(connect_only); /* make connection/request, then let application use the

                        socket */

  BIT(connect_only_ws); /* special websocket connect-only level */

#ifndef CURL_DISABLE_SMTP

  BIT(mail_rcpt_allowfails); /* allow RCPT TO command to fail for some

                                recipients */

#endif

#ifndef CURL_DISABLE_MIME

  BIT(mime_formescape);

#endif

  BIT(is_fread_set); /* has read callback been set to non-NULL? */

#ifndef CURL_DISABLE_TFTP

  BIT(tftp_no_options); /* do not send TFTP options requests */

#endif

  BIT(sep_headers);     /* handle host and proxy headers separately */

#ifndef CURL_DISABLE_COOKIES

  BIT(cookiesession);   /* new cookie session? */

#endif

  BIT(crlf);            /* convert crlf on ftp upload(?) */

#ifdef USE_SSH

  BIT(ssh_compression);            /* enable SSH compression */

#endif

/* Here follows boolean settings that define how to behave during

   this session. They are STATIC, set by libcurl users or at least initially

   and they do not change during operations. */

  BIT(quick_exit);       /* set 1L when it is okay to leak things (like

                            threads), as we are about to exit() anyway and

                            do not want lengthy cleanups to delay termination,

                            e.g. after a DNS timeout */

  BIT(get_filetime);     /* get the time and get of the remote file */

#ifndef CURL_DISABLE_PROXY

  BIT(tunnel_thru_httpproxy); /* use CONNECT through an HTTP proxy */

#endif

  BIT(prefer_ascii);     /* ASCII rather than binary */

  BIT(remote_append);    /* append, not overwrite, on upload */

#ifdef CURL_LIST_ONLY_PROTOCOL

  BIT(list_only);        /* list directory */

#endif

#ifndef CURL_DISABLE_FTP

  BIT(ftp_use_port);     /* use the FTP PORT command */

  BIT(ftp_use_epsv);     /* if EPSV is to be attempted or not */

  BIT(ftp_use_eprt);     /* if EPRT is to be attempted or not */

  BIT(ftp_use_pret);     /* if PRET is to be used before PASV or not */

  BIT(ftp_skip_ip);      /* skip the IP address the FTP server passes on to

                            us */

  BIT(wildcard_enabled); /* enable wildcard matching */

#endif

  BIT(http_fail_on_error);  /* fail on HTTP error codes >= 400 */

  BIT(http_keep_sending_on_error); /* for HTTP status codes >= 300 */

  BIT(http_transfer_encoding); /* request compressed HTTP transfer-encoding */

  BIT(allow_auth_to_other_hosts);

  BIT(include_header); /* include received protocol headers in data output */

  BIT(http_set_referer); /* is a custom referer used */

  BIT(http_auto_referer); /* set "correct" referer when following

                             location: */

  BIT(opt_no_body);    /* as set with CURLOPT_NOBODY */

  BIT(verbose);        /* output verbosity */

  BIT(reuse_forbid);   /* forbidden to be reused, close after use */

  BIT(reuse_fresh);    /* do not reuse an existing connection */

  BIT(no_signal);      /* do not use any signal/alarm handler */

  BIT(tcp_nodelay);    /* whether to enable TCP_NODELAY or not */

  BIT(ignorecl);       /* ignore content length */

  BIT(http_te_skip);   /* pass the raw body data to the user, even when

                          transfer-encoded (chunked, compressed) */

  BIT(http_ce_skip);   /* pass the raw body data to the user, even when

                          content-encoded (chunked, compressed) */

  BIT(proxy_transfer_mode); /* set transfer mode (;type=<a|i>) when doing

                               FTP via an HTTP proxy */

#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)

  BIT(socks5_gssapi_nec); /* Flag to support NEC SOCKS5 server */

#endif

  BIT(sasl_ir);         /* Enable/disable SASL initial response */

  BIT(tcp_keepalive);  /* use TCP keepalives */

  BIT(tcp_fastopen);   /* use TCP Fast Open */

  BIT(ssl_enable_alpn);/* TLS ALPN extension? */

  BIT(path_as_is);     /* allow dotdots? */

  BIT(pipewait);       /* wait for multiplex status before starting a new

                          connection */

  BIT(suppress_connect_headers); /* suppress proxy CONNECT response headers

                                    from user callbacks */

  BIT(dns_shuffle_addresses); /* whether to shuffle addresses before use */

#ifndef CURL_DISABLE_PROXY

  BIT(haproxyprotocol); /* whether to send HAProxy PROXY protocol v1

                           header */

#endif

#ifdef USE_UNIX_SOCKETS

  BIT(abstract_unix_socket);

#endif

  BIT(disallow_username_in_url); /* disallow username in URL */

#ifndef CURL_DISABLE_DOH

  BIT(doh); /* DNS-over-HTTPS enabled */

  BIT(doh_verifypeer);     /* DoH certificate peer verification */

  BIT(doh_verifyhost);     /* DoH certificate hostname verification */

  BIT(doh_verifystatus);   /* DoH certificate status verification */

#endif

  BIT(http09_allowed); /* allow HTTP/0.9 responses */

#ifndef CURL_DISABLE_WEBSOCKETS

  BIT(ws_raw_mode);

  BIT(ws_no_auto_pong);

#endif

  BIT(post301); /* keep POSTs as POSTs after a 301 request */

  BIT(post302); /* keep POSTs as POSTs after a 302 request */

  BIT(post303); /* keep POSTs as POSTs after a 303 request */

};