http::parser_config& parser_cfg,

http::request& headers,

client::config const& cfg)

{

std::string accept_encoding;

auto const accept = [&](char const* coding)

{

if(!accept_encoding.empty())

accept_encoding += ", ";

accept_encoding += coding;

};

if(cfg.brotli)

{

parser_cfg.apply_brotli_decoder = true;

accept("br");

}

if(cfg.deflate)

{

parser_cfg.apply_deflate_decoder = true;

accept("deflate");

}

if(cfg.gzip)

{

parser_cfg.apply_gzip_decoder = true;

accept("gzip");

}

if(!accept_encoding.empty())

headers.set(http::field::accept_encoding, accept_encoding);

{

auto target = url.encoded_target();

if(url.path().empty())

headers.set_target("/" + std::string(target));

else

headers.set_target(target);

capy::executor_ref exec,

corosio::tls_context tls_ctx,

config cfg)

: config_(cfg)

, pool_(

std::make_shared<detail::connection_pool>(

exec, std::move(tls_ctx), cfg))

{

// Disable codings whose decoder service is unavailable.

auto const& ctx = capy::get_system_context();

if(!ctx.has_service<http::brotli::decode_service>())

config_.brotli = false;

if(!ctx.has_service<http::zlib::inflate_service>())

config_.deflate = config_.gzip = false;

{

std::string credentials{ user };

credentials += ':';

credentials += pass;

std::string value = "Basic ";

detail::base64_encode(value, credentials);

headers_.set(http::field::authorization, value);

{

std::string value = "Bearer ";

value += token;

headers_.set(http::field::authorization, value);

{

auto timeout =

request.options.timeout ? request.options.timeout : config_.timeout;

if(!timeout)

return execute_impl(std::move(request), std::nullopt);

auto deadline = config::clock::now() + *timeout;

return capy::timeout(execute_impl(std::move(request), deadline), *timeout);

burl::request request,

std::optional<config::clock::time_point> deadline)

{

using field = http::field;

http::parser_config parser_cfg{ false };

parser_cfg.min_buffer = config_.response_inplace_buffer;

parser_cfg.body_limit = config_.response_body_limit;

http::request headers(request.method, "/", config_.version);

for(auto f : headers_)

if(!request.headers.exists(f.name))

headers.append(f.name, f.value);

for(auto f : request.headers)

headers.append(f.name, f.value);

if(request.body.has_value())

{

// Use the body's content type only if the caller did not set one.

if(!headers.exists(field::content_type))

{

if(auto ct = request.body.content_type())

headers.set(field::content_type, ct.value());

}

// Content length is always derived from the body.

if(auto cl = request.body.content_length())

headers.set_content_length(cl.value());

else

headers.set_chunked(true);

}

// Advertise codings and enable decoders only when the caller did

// not set Accept-Encoding themselves.

if(!headers.exists(field::accept_encoding))

set_accept_encoding(parser_cfg, headers, config_);

http::serializer serializer(http::make_serializer_config({}));

serializer.reset();

serializer.set_message(headers);

http::response_parser parser(http::make_parser_config(parser_cfg));

auto url = request.url;

auto trusted = true;

auto followlocation = request.options.followlocation.value_or(config_.followlocation);

auto maxredirs = config_.maxredirs;

auto request_cookies = request.headers.value_or(field::cookie, "");

for(;;)

{

set_target(headers, url);

headers.set(field::host, url.encoded_host_and_port());

// set cookies

headers.erase(field::cookie);

if(!request_cookies.empty())

{

if(trusted)

headers.set(field::cookie, request_cookies);

}

else if(config_.cookies)

{

auto cookies = cookie_jar_.cookie_header(url);

if(!cookies.empty())

headers.set(field::cookie, cookies);

}

auto [cec, conn] = co_await pool_->acquire(url);

if(cec)

co_return { cec, {} };

// TODO: expect100timeout

if(request.body.has_value())

{

serializer.start_buffers();

capy::any_buffer_sink sink(serializer.sink_for(conn));

if(auto [wec] = co_await request.body.write(sink); wec)

co_return { wec, {} };

// The body only writes its bytes; finalize the sink here.

if(auto [wec] = co_await sink.write_eof(); wec)

co_return { wec, {} };

}

else

{

auto [wec, n] =

co_await capy::write(conn, capy::make_buffer(headers.buffer()));

if(wec)

co_return { wec, {} };

}

parser.reset();

if(headers.method() == http::method::head)

parser.start_head_response();

else

parser.start();

auto [rec] = co_await parser.read_header(conn);

if(rec)

co_return { rec, {} };

// extract cookies

if(config_.cookies)

{

for(auto sv : parser.get().find_all(field::set_cookie))

{

auto rs = parse_cookie(sv);

if(rs.has_value())

cookie_jar_.add(url, rs.value());

}

}

auto [is_redirect, need_method_change] =

detail::is_redirect(parser.get().status(), config_);

if(!is_redirect || !followlocation)

{

auto ec = std::error_code{};

auto status_int = parser.get().status_int();

if(status_int >= 400)

ec = std::error_code(status_int, burl_category());

co_return {

ec,

response{ url, std::move(conn), std::move(parser), deadline }

};

}

// Read and discard small bodies so the connection can be reused

auto [dec] = co_await capy::timeout(

detail::drain_body(parser, capy::any_stream(&conn), 1024 * 1024),

std::chrono::seconds(2));

if(!dec && detail::can_reuse_conn(parser))

conn.return_to_pool();

if(maxredirs-- == 0)

co_return { error::too_many_redirects, {} };

// Set the Referer header to the URL we are leaving.

if(config_.autoreferer)

{

auto referer = url;

referer.remove_userinfo();

referer.remove_fragment();

headers.set(field::referer, referer);

}

// Prepare the next request to follow the redirect

url = detail::resolve_location(parser.get(), url);

if(url.empty())

co_return { error::bad_redirect_response, {} };

// Change the method according to RFC 9110, Section 15.4.4.

if(need_method_change && headers.method() != http::method::head)

{

headers.set_method(http::method::get);

headers.erase(field::content_length);

headers.erase(field::transfer_encoding);

headers.erase(field::content_encoding);

headers.erase(field::content_type);

headers.erase(field::expect);

request.body = {}; // drop the body

}

trusted = (request.url.encoded_origin() == url.encoded_origin()) ||

config_.unrestricted_auth;

if(!trusted)

{

headers.erase(field::authorization);

headers.erase(field::proxy_authorization);

// cookies are removed on each iteration

}

}