return { Method::POST, std::string(url),

{{"Content-Type", "application/json"}},

std::string(body) };

std::string scheme;

std::string host;

int port { 443 };

std::string path;

ParsedUrl result;

// Extract scheme

auto schemeEnd = url.find("://");

if (schemeEnd == std::string_view::npos) {

return result;

}

result.scheme = std::string(url.substr(0, schemeEnd));

url = url.substr(schemeEnd + 3);

// Extract host (and optional port)

auto pathStart = url.find('/');

std::string_view authority;

if (pathStart == std::string_view::npos) {

authority = url;

result.path = "/";

} else {

authority = url.substr(0, pathStart);

result.path = std::string(url.substr(pathStart));

}

// Check for port

auto colonPos = authority.find(':');

if (colonPos != std::string_view::npos) {

result.host = std::string(authority.substr(0, colonPos));

auto portStr = authority.substr(colonPos + 1);

result.port = 0;

for (char c : portStr) {

if (c >= '0' && c <= '9') {

result.port = result.port * 10 + (c - '0');

}

}

} else {

result.host = std::string(authority);

result.port = (result.scheme == "https") ? 443 : 80;

}

if (result.path.empty()) {

result.path = "/";

}

return result;

if (a.size() != b.size()) return false;

for (std::size_t i = 0; i < a.size(); ++i) {

char ca = a[i];

char cb = b[i];

if (ca >= 'A' && ca <= 'Z') ca += 32;

if (cb >= 'A' && cb <= 'Z') cb += 32;

if (ca != cb) return false;

}

return true;

for (const auto& [k, v] : headers) {

if (iequals(k, key)) return true;

}

return false;

std::string_view key) {

for (const auto& [k, v] : headers) {

if (iequals(k, key)) return v;

}

return {};

switch (m) {

case Method::GET: return "GET";

case Method::POST: return "POST";

case Method::PUT: return "PUT";

case Method::DELETE_: return "DELETE";

case Method::PATCH: return "PATCH";

case Method::HEAD: return "HEAD";

}

return "GET";

std::size_t limit) {

if (buffer.size() >= limit) return false;

const std::size_t room = limit - buffer.size();

// Not std::min: <winsock2.h> defines a `min` macro on Windows.

const std::size_t take = data.size() < room ? data.size() : room;

buffer.append(data.substr(0, take));

return take == data.size();

std::string line;

char c {};

while (true) {

if (!sock.wait_readable(timeoutMs)) {

return std::unexpected("timed out before CRLF");

}

auto r = sock.read_some(&c, 1);

if (r.status == ReadStatus::WouldBlock) {

// The transport had nothing decrypted yet. Wait once more; the

// socket is blocking after the handshake, so this is rare.

if (!sock.wait_readable(timeoutMs)) {

return std::unexpected("timed out before CRLF");

}

r = sock.read_some(&c, 1);

}

if (r.status == ReadStatus::Eof) {

return std::unexpected("connection closed before CRLF");

}

if (r.status != ReadStatus::Data) {

return std::unexpected("read error before CRLF");

}

if (sawBytes) *sawBytes = true;

line += c;

if (line.size() >= 2

&& line[line.size() - 2] == '\r'

&& line[line.size() - 1] == '\n') {

line.resize(line.size() - 2);

return line;

}

if (line.size() > max_line_length) {

return std::unexpected("line exceeds " + std::to_string(max_line_length)

+ " bytes without a CRLF");

}

}

const auto deadline = std::chrono::steady_clock::now()

+ std::chrono::milliseconds(timeoutMs);

std::size_t total = 0;

while (total < data.size()) {

int ret = sock.write(data.data() + total,

static_cast<int>(data.size() - total));

if (ret < 0) return false;

if (ret == 0) {

const auto left = std::chrono::duration_cast<std::chrono::milliseconds>(

deadline - std::chrono::steady_clock::now()).count();

if (left <= 0) return false;

if (!sock.wait_writable(static_cast<int>(left))) return false;

continue;

}

total += static_cast<std::size_t>(ret);

}

return true;

int statusCode { 0 };

std::string statusText;

std::map<std::string, std::string> headers;

bool chunked { false };

std::int64_t contentLength { -1 };

bool connectionClose { false };

std::string message;

// Whether any byte of the response had arrived when this failed. False means

// the server never answered, which is what a connection closed while idle

// looks like from here.

bool sawBytes { false };

ResponseHead head;

bool sawBytes = false;

// AN INTERIM RESPONSE IS NOT THE ANSWER, AND STOPPING AT ONE POISONS THE

// POOL. RFC 9112 §2.1 requires a client to be able to read one or more 1xx

// responses before the final one, and each is a complete status line and

// header block of its own.

//

// Returning the 1xx as if it were the answer would report `103 Early Hints`

// (or `100 Continue`, which any server sends for a request carrying

// `Expect: 100-continue`) to the caller, and — because a 1xx carries no

// body — mark the connection clean while the REAL response sat unread on

// it. The next request through the same client would then read that

// response as its own, which is issue #15 arriving by another door.

//

// The `max_head_lines` cap below applies per interim response; the loop

// itself is bounded by the same count, so a server sending nothing but 1xx

// cannot hold the call open forever either.

for (int interim = 0; ; ++interim) {

if (interim >= max_head_lines) {

return std::unexpected(HeadError{

"More than " + std::to_string(max_head_lines)

+ " interim responses", true });

}

auto statusLine = read_complete_line(sock, timeoutMs, &sawBytes);

if (!statusLine) {

return std::unexpected(HeadError{ "No response", sawBytes });

}

auto status = parse_status_line(*statusLine);

if (!status) {

return std::unexpected(HeadError{ "Invalid status line", true });

}

head.statusCode = status->code;

head.statusText = std::move(status->text);

if (head.statusCode >= 200) break;

// Discard the interim response's own header block and read the next

// status line. Its fields describe the interim response, not the

// answer, so keeping them would misreport the final one's headers.

for (int lines = 0; ; ++lines) {

if (lines >= max_head_lines) {

return std::unexpected(HeadError{

"Interim header block exceeds "

+ std::to_string(max_head_lines) + " lines", true });

}

auto line = read_complete_line(sock, timeoutMs);

if (!line) {

return std::unexpected(HeadError{

"Incomplete interim headers: " + line.error(), true });

}

if (line->empty()) break;

}

}

for (int lines = 0; ; ++lines) {

if (lines >= max_head_lines) {

return std::unexpected(HeadError{

"Header block exceeds " + std::to_string(max_head_lines)

+ " lines", true });

}

auto line = read_complete_line(sock, timeoutMs);

if (!line) {

return std::unexpected(HeadError{

"Incomplete headers: " + line.error(), true });

}

if (line->empty()) break; // the blank line that ends the block

auto colon = line->find(':');

if (colon == std::string::npos) continue;

std::string key = line->substr(0, colon);

std::string_view value = std::string_view(*line).substr(colon + 1);

while (!value.empty() && (value.front() == ' ' || value.front() == '\t')) {

value.remove_prefix(1);

}

std::string valStr(value);

if (iequals(key, "Transfer-Encoding") && iequals(valStr, "chunked")) {

head.chunked = true;

}

if (iequals(key, "Content-Length")) {

// Rejected rather than salvaged. A malformed value leaves this at

// -1, which is the same state as an absent header and is a framing

// this reader already handles.

head.contentLength = parse_content_length(valStr).value_or(-1);

}

if (iequals(key, "Connection") && iequals(valStr, "close")) {

head.connectionClose = true;

}

head.headers[std::move(key)] = std::move(valStr);

}

return head;

if (method == Method::HEAD) return false;

if (statusCode >= 100 && statusCode < 200) return false;

return statusCode != 204 && statusCode != 304;

Complete, // read to the end its framing declared

Truncated, // the framing was broken or the body stopped short

ClosedByPeer, // no framing at all; the body ended when the connection did

Stopped, // the sink asked to stop, so bytes are still owed

BodyEnd end { BodyEnd::Truncated };

std::string error;

std::int64_t bytes { 0 };

int timeoutMs, std::int64_t maxBytes,

const BodySink& sink) {

BodyOutcome out;

char buf[8192];

// Reads at least one byte. A timeout on the wait, and a transport that stays

// unready across two waits, are both reported as `WouldBlock` — at that

// point bytes are still owed and the framing is broken either way.

auto pull = [&](std::size_t want) -> ReadResult {

for (int attempt = 0; attempt < 2; ++attempt) {

if (!sock.wait_readable(timeoutMs)) return { ReadStatus::WouldBlock, 0 };

auto r = sock.read_some(buf, static_cast<int>(want));

if (r.status != ReadStatus::WouldBlock) return r;

}

return { ReadStatus::WouldBlock, 0 };

};

auto emit = [&](int n) -> bool {

out.bytes += n;

return sink(std::string_view(buf, static_cast<std::size_t>(n)));

};

auto too_large = [&] {

out.end = BodyEnd::Truncated;

out.error = "Body exceeds the configured limit of "

+ std::to_string(maxBytes) + " bytes";

};

if (head.chunked) {

while (true) {

auto sizeResult = read_complete_line(sock, timeoutMs);

if (!sizeResult) {

out.end = BodyEnd::Truncated;

out.error = "Invalid chunk size line: " + sizeResult.error();

return out;

}

std::string sizeLine = std::move(*sizeResult);

if (auto semi = sizeLine.find(';'); semi != std::string::npos) {

sizeLine.resize(semi);

}

while (!sizeLine.empty()

&& (sizeLine.back() == ' ' || sizeLine.back() == '\t')) {

sizeLine.pop_back();

}

// A CHUNK HEADER THAT DOES NOT PARSE IS NOT A TERMINAL CHUNK. The

// older `parse_hex` returned what it had accumulated when it met a

// character it did not recognise, and 0 for an empty line — and the

// older `read_line` returned an empty line on a timeout. So a stream

// that was cut short read as one that had ended cleanly, and the

// socket went back into the pool with the rest of the body owed.

auto chunkSize = parse_chunk_size_line(sizeLine);

if (!chunkSize) {

out.end = BodyEnd::Truncated;

out.error = "Invalid chunk size: " + sizeLine;

return out;

}

if (*chunkSize == 0) {

// The trailer section, then the blank line that ends it.

// Bounded for the reason `max_head_lines` gives: every line

// resets the read timeout, so an endless supply of them holds

// this call open with nothing else to stop it.

for (int lines = 0; ; ++lines) {

if (lines >= max_head_lines) {

out.end = BodyEnd::Truncated;

out.error = "Trailer section exceeds "

+ std::to_string(max_head_lines) + " lines";

return out;

}

auto trailer = read_complete_line(sock, timeoutMs);

if (!trailer) {

out.end = BodyEnd::Truncated;

out.error = "Invalid chunk trailer: " + trailer.error();

return out;

}

if (trailer->empty()) break;

}

out.end = BodyEnd::Complete;

return out;

}

if (out.bytes + *chunkSize > maxBytes) {

too_large();

return out;

}

std::int64_t remaining = *chunkSize;

while (remaining > 0) {

const auto want = static_cast<std::size_t>(

remaining < static_cast<std::int64_t>(sizeof buf)

? remaining : static_cast<std::int64_t>(sizeof buf));

auto r = pull(want);

if (r.status != ReadStatus::Data) {

out.end = BodyEnd::Truncated;

out.error = r.status == ReadStatus::Eof

? "Connection closed in the middle of a chunk"

: "Read error in the middle of a chunk";

return out;

}

remaining -= r.bytes;

if (!emit(r.bytes)) { out.end = BodyEnd::Stopped; return out; }

}

// The CRLF that follows the data. Discarding it lets a wrong chunk

// length slide into the next chunk header without a word.

auto delimiter = read_complete_line(sock, timeoutMs);

if (!delimiter || !delimiter->empty()) {

out.end = BodyEnd::Truncated;

out.error = "Missing CRLF after chunk data";

return out;

}

}

}

if (head.contentLength >= 0) {

if (head.contentLength > maxBytes) {

too_large();

return out;

}

std::int64_t remaining = head.contentLength;

while (remaining > 0) {

const auto want = static_cast<std::size_t>(

remaining < static_cast<std::int64_t>(sizeof buf)

? remaining : static_cast<std::int64_t>(sizeof buf));

auto r = pull(want);

if (r.status != ReadStatus::Data) {

out.end = BodyEnd::Truncated;

out.error = r.status == ReadStatus::Eof

? "Connection closed before the declared length"

: "Read timed out before the declared length";

return out;

}

remaining -= r.bytes;

if (!emit(r.bytes)) { out.end = BodyEnd::Stopped; return out; }

}

out.end = BodyEnd::Complete;

return out;

}

// Neither chunked nor a declared length: the body ends when the connection

// does, so there is nothing left to reuse afterwards.

while (true) {

auto r = pull(sizeof buf);

if (r.status == ReadStatus::Eof) {

out.end = BodyEnd::ClosedByPeer;

return out;

}

if (r.status != ReadStatus::Data) {

out.end = BodyEnd::Truncated;

out.error = "Read timed out before the connection closed";

return out;

}

if (out.bytes + r.bytes > maxBytes) {

too_large();

return out;

}

if (!emit(r.bytes)) { out.end = BodyEnd::Stopped; return out; }

}

int timeoutMs, std::int64_t cap = 64 * 1024) {

if (head.connectionClose) return false;

if (!head.chunked && head.contentLength < 0) return false;

if (!head.chunked && head.contentLength == 0) return true;

if (head.contentLength > cap) return false;

auto outcome = read_body(sock, head, timeoutMs, cap,

[](std::string_view) { return true; });

return outcome.end == BodyEnd::Complete;

PooledConnection(std::map<std::string, TlsSocket>& pool, std::string key)

: pool_(pool), key_(std::move(key)) {}

~PooledConnection() { drop(); }

PooledConnection(const PooledConnection&) = delete;

PooledConnection& operator=(const PooledConnection&) = delete;

// Call only where the body was read to the end its framing declared and the

// response did not ask for the connection to close.

void keep() noexcept { armed_ = false; }

// Drop now rather than at the end of the scope. Idempotent, and a no-op

// after `keep()`.

//

// ⚠️ Callers that recurse — the redirect paths — MUST settle the guard

// before recursing. The inner call puts its own connection into the pool

// under the same key when the redirect is to the same host, and a guard

// still armed when the outer scope ends would then delete it.

void drop() {

if (!armed_) return;

armed_ = false;

if (auto it = pool_.find(key_); it != pool_.end()) {

it->second.close();

pool_.erase(it);

}

}

// Drop what is there and arm again for what replaces it. The stale-connection

// retry is the one place where a guard outlives the socket it was made for.

void reset() { drop(); armed_ = true; }

std::map<std::string, TlsSocket>& pool_;

std::string key_;

bool armed_ { true };

HttpResponse response;

auto parsed = parse_url(request.url);

if (parsed.scheme != "https") {

response.statusCode = 0;

response.statusText = "Only HTTPS is supported";

return response;

}

const std::string poolKey = parsed.host + ":" + std::to_string(parsed.port);

PooledConnection guard(pool_, poolKey);

auto exchange = perform_exchange(parsed, poolKey,

build_request(request, parsed), guard);

if (!exchange.error.empty()) {

response.statusCode = 0;

response.statusText = exchange.error;

response.bodyComplete = false;

response.bodyError = exchange.error;

return response;

}

response.statusCode = exchange.head.statusCode;

response.statusText = exchange.head.statusText;

response.headers = exchange.head.headers;

// A failed streaming request is answered with an error document rather

// than an event stream, so the parser finds nothing in it. Keeping the

// bytes is the only way a caller learns the reason.

const bool captureBody = !response.ok();

SseParser parser;

auto sink = [&](std::string_view data) -> bool {

if (captureBody) {

append_within_limit(response.body, data, stream_error_body_limit);

}

for (const auto& event : parser.feed(data)) {

if (!callback(event)) return false;

}

return true;

};

finish_body(response, exchange, request.method,

/*maxBytes=*/std::numeric_limits<std::int64_t>::max(),

sink, guard);

return response;

const std::string& url,

const std::filesystem::path& destFile,

DownloadProgressFn onProgress = nullptr,

std::function<bool()> isCancelled = nullptr)

{

return download_to_file_impl(url, destFile, std::move(onProgress),

std::move(isCancelled), 0);

TlsSocket* sock { nullptr };

ResponseHead head;

std::string error;

std::string reqStr;

reqStr += method_to_string(request.method);

reqStr += " ";

reqStr += parsed.path;

reqStr += " HTTP/1.1\r\n";

if (!has_header(request.headers, "Host")) {

reqStr += "Host: ";

reqStr += parsed.host;

if (parsed.port != 443) {

reqStr += ":";

reqStr += std::to_string(parsed.port);

}

reqStr += "\r\n";

}

if (!request.body.empty() && !has_header(request.headers, "Content-Length")) {

reqStr += "Content-Length: ";

reqStr += std::to_string(request.body.size());

reqStr += "\r\n";

}

for (const auto& [key, value] : request.headers) {

reqStr += key;

reqStr += ": ";

reqStr += value;

reqStr += "\r\n";

}

if (!has_header(request.headers, "Connection")) {

reqStr += config_.keepAlive ? "Connection: keep-alive\r\n"

: "Connection: close\r\n";

}

reqStr += "\r\n";

reqStr += request.body;

return reqStr;

if (config_.proxy.has_value()) {

auto proxyConf = parse_proxy_url(config_.proxy.value());

auto tunnel = proxy_connect(proxyConf.host, proxyConf.port,

parsed.host, parsed.port,

config_.connectTimeoutMs);

if (!tunnel.is_valid()) return false;

return sock.connect_over(std::move(tunnel), parsed.host.c_str(),

config_.verifySsl);

}

return sock.connect(parsed.host.c_str(), parsed.port,

config_.connectTimeoutMs, config_.verifySsl);

const std::string& reqStr, PooledConnection& guard) {

for (int attempt = 0; attempt < 2; ++attempt) {

bool reused = false;

TlsSocket* sock = nullptr;

auto it = pool_.find(poolKey);

if (it != pool_.end() && it->second.is_valid()) {

sock = &it->second;

reused = true;

} else {

if (it != pool_.end()) pool_.erase(it);

auto [inserted, ok] = pool_.emplace(poolKey, TlsSocket{});