full QUIC support
This commit is contained in:
parent
45479a46ff
commit
28fab2509b
18 changed files with 1334 additions and 645 deletions
|
|
@ -20,19 +20,35 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
|
||||
export module Crafter.Network:ClientHTTP;
|
||||
import std;
|
||||
import :ClientTCP;
|
||||
import :HTTP;
|
||||
import :ClientQUIC;
|
||||
|
||||
namespace Crafter {
|
||||
export class ClientHTTP {
|
||||
public:
|
||||
std::string host;
|
||||
std::uint16_t port;
|
||||
ClientHTTP(const char* host, std::uint16_t port);
|
||||
ClientHTTP(std::string host, std::uint16_t port);
|
||||
HTTPResponse Send(const char* request, std::uint32_t length);
|
||||
HTTPResponse Send(std::string request);
|
||||
private:
|
||||
ClientTCP client;
|
||||
};
|
||||
}
|
||||
// HTTP/3 client over QUIC. The constructor establishes the QUIC connection
|
||||
// (TLS handshake + ALPN "h3"); each Send() opens a fresh request stream
|
||||
// on the multiplexed connection. Thread-affinity: Send() is not safe to
|
||||
// call from multiple threads concurrently against the same ClientHTTP,
|
||||
// but distinct ClientHTTP instances are independent.
|
||||
//
|
||||
// For local development against a self-signed listener, pass
|
||||
// QUICClientCredentials{insecureNoServerValidation = true}.
|
||||
export class ClientHTTP {
|
||||
public:
|
||||
std::string host;
|
||||
std::uint16_t port;
|
||||
|
||||
ClientHTTP(const char* host, std::uint16_t port, QUICClientCredentials creds = {});
|
||||
ClientHTTP(std::string host, std::uint16_t port, QUICClientCredentials creds = {});
|
||||
|
||||
~ClientHTTP();
|
||||
ClientHTTP(const ClientHTTP&) = delete;
|
||||
ClientHTTP(ClientHTTP&&) noexcept;
|
||||
|
||||
// Send a request and synchronously read back the full response.
|
||||
HTTPResponse Send(const HTTPRequest& request);
|
||||
|
||||
private:
|
||||
struct Impl;
|
||||
std::unique_ptr<Impl> impl;
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,10 +52,12 @@ namespace Crafter {
|
|||
|
||||
export class ClientQUIC;
|
||||
|
||||
// A reliable, ordered, bidirectional stream within a QUIC connection.
|
||||
// Owned by ClientQUIC; do not destroy directly. Obtain via
|
||||
// ClientQUIC::OpenStream() or via the on-stream callback for inbound
|
||||
// streams initiated by the peer.
|
||||
// A reliable, ordered stream within a QUIC connection. May be
|
||||
// bidirectional or unidirectional; for unidi streams either canSend or
|
||||
// canReceive will be false depending on which side initiated. Owned by
|
||||
// ClientQUIC; do not destroy directly. Obtain via ClientQUIC::OpenStream
|
||||
// (optionally with unidirectional=true) or via the on-stream callback
|
||||
// for inbound streams initiated by the peer.
|
||||
export class QUICStream {
|
||||
public:
|
||||
// Underlying msquic HQUIC handle. Treated as opaque by callers.
|
||||
|
|
@ -64,7 +66,12 @@ namespace Crafter {
|
|||
// The connection that owns this stream (non-owning).
|
||||
ClientQUIC* connection = nullptr;
|
||||
|
||||
QUICStream() = default;
|
||||
// Direction flags. Bidi streams have both true; outgoing unidi sets
|
||||
// canReceive=false; incoming unidi (peer-initiated) sets canSend=false.
|
||||
bool canSend = true;
|
||||
bool canReceive = true;
|
||||
|
||||
QUICStream();
|
||||
QUICStream(HQUIC handle, ClientQUIC* connection);
|
||||
~QUICStream();
|
||||
QUICStream(const QUICStream&) = delete;
|
||||
|
|
@ -135,9 +142,11 @@ namespace Crafter {
|
|||
ClientQUIC(const ClientQUIC&) = delete;
|
||||
ClientQUIC(ClientQUIC&&) noexcept;
|
||||
|
||||
// Open a new bidirectional stream initiated by this side.
|
||||
// Open a new stream initiated by this side. Defaults to bidirectional;
|
||||
// pass unidirectional=true to open a one-way send stream (used for
|
||||
// HTTP/3's control + QPACK encoder/decoder streams).
|
||||
// Blocks until the stream is started; throws on failure.
|
||||
QUICStream OpenStream();
|
||||
QUICStream OpenStream(bool unidirectional = false);
|
||||
|
||||
// Send a datagram. Best-effort: may be silently dropped under loss
|
||||
// or congestion. Size must fit within the path MTU (msquic surfaces
|
||||
|
|
|
|||
|
|
@ -22,63 +22,98 @@ export module Crafter.Network:HTTP;
|
|||
import std;
|
||||
|
||||
namespace Crafter {
|
||||
// HTTP/3 request as carried over a QUIC bidirectional stream. The four
|
||||
// pseudo-headers (method/scheme/authority/path) are split out as named
|
||||
// fields rather than living in the headers map, because RFC 9114 forbids
|
||||
// them from appearing in the regular header section and this shape makes
|
||||
// route dispatch and request construction cleaner. `headers` keys are
|
||||
// expected lowercase; HTTP/3 forbids uppercase characters in field names.
|
||||
export struct HTTPRequest {
|
||||
std::string method;
|
||||
std::string scheme = "https";
|
||||
std::string authority;
|
||||
std::string path = "/";
|
||||
std::unordered_map<std::string, std::string> headers;
|
||||
std::string body;
|
||||
};
|
||||
|
||||
// HTTP/3 response. `status` is the numeric three-digit code as a string
|
||||
// (e.g. "200") — HTTP/3 has no reason phrase. `headers` keys are expected
|
||||
// lowercase.
|
||||
export struct HTTPResponse {
|
||||
std::string status;
|
||||
std::string status = "200";
|
||||
std::unordered_map<std::string, std::string> headers;
|
||||
std::string body;
|
||||
};
|
||||
|
||||
export constexpr std::string CreateResponseHTTP(std::string status) {
|
||||
return std::format("HTTP/1.1 {}\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n", status);
|
||||
}
|
||||
|
||||
export constexpr std::string CreateResponseHTTP(std::string status, std::unordered_map<std::string, std::string> headers) {
|
||||
std::string headersString;
|
||||
for (auto const& [key, val] : headers) {
|
||||
headersString+=std::format("{}: {}\r\n", key, val);
|
||||
}
|
||||
return std::format("HTTP/1.1 {}\r\nConnection: keep-alive\r\nContent-Length: 0\r\n{}\r\n", status, headersString);
|
||||
}
|
||||
|
||||
export constexpr std::string CreateResponseHTTP(std::string status, std::string body) {
|
||||
return std::format("HTTP/1.1 {}\r\nContent-Length: {}\r\nConnection: keep-alive\r\n\r\n{}", status, body.size(), body);
|
||||
}
|
||||
|
||||
export constexpr std::string CreateResponseHTTP(std::string status, std::unordered_map<std::string, std::string> headers, std::string body) {
|
||||
std::string headersString;
|
||||
for (auto const& [key, val] : headers) {
|
||||
headersString+=std::format("{}: {}\r\n", key, val);
|
||||
}
|
||||
return std::format("HTTP/1.1 {}\r\nConnection: keep-alive\r\nContent-Length: {}\r\n{}\r\n{}", status, body.size(), headersString, body);
|
||||
export inline HTTPRequest CreateRequestHTTP(std::string method, std::string path, std::string authority) {
|
||||
HTTPRequest r;
|
||||
r.method = std::move(method);
|
||||
r.path = std::move(path);
|
||||
r.authority = std::move(authority);
|
||||
return r;
|
||||
}
|
||||
|
||||
export constexpr std::string CreateRequestHTTP(std::string method, std::string route, std::string host) {
|
||||
return std::format("{} {} HTTP/1.1\r\nConnection: keep-alive\r\nAccept-Encoding: identity\r\nContent-Length: 0\r\nHost: {}\r\n\r\n", method, route, host);
|
||||
}
|
||||
export inline HTTPRequest CreateRequestHTTP(std::string method, std::string path, std::string authority,
|
||||
std::unordered_map<std::string, std::string> headers) {
|
||||
HTTPRequest r;
|
||||
r.method = std::move(method);
|
||||
r.path = std::move(path);
|
||||
r.authority = std::move(authority);
|
||||
r.headers = std::move(headers);
|
||||
return r;
|
||||
}
|
||||
|
||||
export constexpr std::string CreateRequestHTTP(std::string method, std::string route, std::string host, std::unordered_map<std::string, std::string> headers) {
|
||||
std::string headersString;
|
||||
for (auto const& [key, val] : headers) {
|
||||
headersString+=std::format("{}: {}\r\n", key, val);
|
||||
}
|
||||
return std::format("{} {} HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\nAccept-Encoding: identity\r\nHost: {}\r\n{}\r\n", method, route, host, headersString);
|
||||
}
|
||||
export inline HTTPRequest CreateRequestHTTP(std::string method, std::string path, std::string authority,
|
||||
std::string body) {
|
||||
HTTPRequest r;
|
||||
r.method = std::move(method);
|
||||
r.path = std::move(path);
|
||||
r.authority = std::move(authority);
|
||||
r.body = std::move(body);
|
||||
return r;
|
||||
}
|
||||
|
||||
export constexpr std::string CreateRequestHTTP(std::string method, std::string route, std::string host, std::string body) {
|
||||
return std::format("{} {} HTTP/1.1\r\nContent-Length: {}\r\nConnection: keep-alive\r\nAccept-Encoding: identity\r\nHost: {}\r\n\r\n{}", method, route, body.size(), host, body);
|
||||
}
|
||||
export inline HTTPRequest CreateRequestHTTP(std::string method, std::string path, std::string authority,
|
||||
std::unordered_map<std::string, std::string> headers,
|
||||
std::string body) {
|
||||
HTTPRequest r;
|
||||
r.method = std::move(method);
|
||||
r.path = std::move(path);
|
||||
r.authority = std::move(authority);
|
||||
r.headers = std::move(headers);
|
||||
r.body = std::move(body);
|
||||
return r;
|
||||
}
|
||||
|
||||
export constexpr std::string CreateRequestHTTP(std::string method, std::string route, std::string host, std::unordered_map<std::string, std::string> headers, std::string body) {
|
||||
std::string headersString;
|
||||
for (auto const& [key, val] : headers) {
|
||||
headersString+=std::format("{}: {}\r\n", key, val);
|
||||
}
|
||||
return std::format("{} {} HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: {}\r\nHost: {}\r\nAccept-Encoding: identity\r\n{}\r\n{}", method, route, body.size(), host, headersString, body);
|
||||
}
|
||||
}
|
||||
export inline HTTPResponse CreateResponseHTTP(std::string status) {
|
||||
HTTPResponse r;
|
||||
r.status = std::move(status);
|
||||
return r;
|
||||
}
|
||||
|
||||
export inline HTTPResponse CreateResponseHTTP(std::string status,
|
||||
std::unordered_map<std::string, std::string> headers) {
|
||||
HTTPResponse r;
|
||||
r.status = std::move(status);
|
||||
r.headers = std::move(headers);
|
||||
return r;
|
||||
}
|
||||
|
||||
export inline HTTPResponse CreateResponseHTTP(std::string status, std::string body) {
|
||||
HTTPResponse r;
|
||||
r.status = std::move(status);
|
||||
r.body = std::move(body);
|
||||
return r;
|
||||
}
|
||||
|
||||
export inline HTTPResponse CreateResponseHTTP(std::string status,
|
||||
std::unordered_map<std::string, std::string> headers,
|
||||
std::string body) {
|
||||
HTTPResponse r;
|
||||
r.status = std::move(status);
|
||||
r.headers = std::move(headers);
|
||||
r.body = std::move(body);
|
||||
return r;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
578
interfaces/Crafter.Network-HTTP3.cppm
Normal file
578
interfaces/Crafter.Network-HTTP3.cppm
Normal file
|
|
@ -0,0 +1,578 @@
|
|||
/*
|
||||
Crafter®.Network
|
||||
Copyright (C) 2026 Catcrafts®
|
||||
Catcrafts.net
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 3.0 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
// HTTP/3 wire-format helpers. This partition is intentionally NOT re-exported
|
||||
// from Crafter.Network — it's an internal building block shared between the
|
||||
// ClientHTTP and ListenerHTTP implementation files.
|
||||
//
|
||||
// Scope:
|
||||
// - QUIC variable-length integers (RFC 9000 §16)
|
||||
// - HTTP/3 frame type/length codec (RFC 9114 §7)
|
||||
// - QPACK field-section encode/decode (RFC 9204) limited to the static
|
||||
// table + literal representations. No dynamic table, no Huffman. This
|
||||
// suffices because both peers in this library are this same library;
|
||||
// interoperability with browsers/curl over h3 would additionally require
|
||||
// a Huffman codec which is out of scope here.
|
||||
|
||||
export module Crafter.Network:HTTP3;
|
||||
import std;
|
||||
|
||||
namespace Crafter::HTTP3 {
|
||||
// ---------------- ALPN ----------------
|
||||
// RFC 9114 §3.1 — final h3 ALPN identifier.
|
||||
export inline constexpr std::string_view kAlpn = "h3";
|
||||
|
||||
// ---------------- Frame types (RFC 9114 §7.2) ----------------
|
||||
export inline constexpr std::uint64_t kFrameData = 0x00;
|
||||
export inline constexpr std::uint64_t kFrameHeaders = 0x01;
|
||||
export inline constexpr std::uint64_t kFrameSettings = 0x04;
|
||||
|
||||
// ---------------- Unidirectional stream types (RFC 9114 §6.2) ----------------
|
||||
export inline constexpr std::uint64_t kStreamControl = 0x00;
|
||||
export inline constexpr std::uint64_t kStreamQpackEnc = 0x02;
|
||||
export inline constexpr std::uint64_t kStreamQpackDec = 0x03;
|
||||
|
||||
// ---------------- Errors ----------------
|
||||
export class HTTP3ProtocolError : public std::runtime_error {
|
||||
public:
|
||||
using std::runtime_error::runtime_error;
|
||||
};
|
||||
|
||||
// ---------------- QUIC varint (RFC 9000 §16) ----------------
|
||||
// Encodes value into the smallest of {1, 2, 4, 8}-byte forms.
|
||||
export inline void EncodeVarint(std::uint64_t value, std::vector<std::uint8_t>& out) {
|
||||
if (value < (1ULL << 6)) {
|
||||
out.push_back(static_cast<std::uint8_t>(value));
|
||||
} else if (value < (1ULL << 14)) {
|
||||
out.push_back(static_cast<std::uint8_t>(0x40 | (value >> 8)));
|
||||
out.push_back(static_cast<std::uint8_t>(value & 0xFF));
|
||||
} else if (value < (1ULL << 30)) {
|
||||
out.push_back(static_cast<std::uint8_t>(0x80 | ((value >> 24) & 0x3F)));
|
||||
out.push_back(static_cast<std::uint8_t>((value >> 16) & 0xFF));
|
||||
out.push_back(static_cast<std::uint8_t>((value >> 8) & 0xFF));
|
||||
out.push_back(static_cast<std::uint8_t>(value & 0xFF));
|
||||
} else if (value < (1ULL << 62)) {
|
||||
out.push_back(static_cast<std::uint8_t>(0xC0 | ((value >> 56) & 0x3F)));
|
||||
out.push_back(static_cast<std::uint8_t>((value >> 48) & 0xFF));
|
||||
out.push_back(static_cast<std::uint8_t>((value >> 40) & 0xFF));
|
||||
out.push_back(static_cast<std::uint8_t>((value >> 32) & 0xFF));
|
||||
out.push_back(static_cast<std::uint8_t>((value >> 24) & 0xFF));
|
||||
out.push_back(static_cast<std::uint8_t>((value >> 16) & 0xFF));
|
||||
out.push_back(static_cast<std::uint8_t>((value >> 8) & 0xFF));
|
||||
out.push_back(static_cast<std::uint8_t>(value & 0xFF));
|
||||
} else {
|
||||
throw HTTP3ProtocolError("varint value exceeds 2^62-1");
|
||||
}
|
||||
}
|
||||
|
||||
// Returns true on success. On false, no consumed/value mutation observed.
|
||||
export inline bool DecodeVarint(const std::uint8_t* data, std::size_t available,
|
||||
std::uint64_t& value, std::size_t& consumed) {
|
||||
if (available == 0) return false;
|
||||
std::uint8_t first = data[0];
|
||||
std::size_t len = std::size_t{1} << (first >> 6);
|
||||
if (available < len) return false;
|
||||
std::uint64_t v = first & 0x3F;
|
||||
for (std::size_t i = 1; i < len; ++i) {
|
||||
v = (v << 8) | data[i];
|
||||
}
|
||||
value = v;
|
||||
consumed = len;
|
||||
return true;
|
||||
}
|
||||
|
||||
// ---------------- QPACK / HPACK-style integer (RFC 7541 §5.1) ----------------
|
||||
// Different beast from QUIC varint. N-bit prefix integer used inside QPACK
|
||||
// representations; the high (8-N) bits of the first byte carry pattern flags.
|
||||
export inline void EncodeQpackInt(std::vector<std::uint8_t>& out, std::uint8_t topBits,
|
||||
int N, std::uint64_t value) {
|
||||
std::uint8_t mask = static_cast<std::uint8_t>((1U << N) - 1);
|
||||
if (value < mask) {
|
||||
out.push_back(static_cast<std::uint8_t>(topBits | value));
|
||||
return;
|
||||
}
|
||||
out.push_back(static_cast<std::uint8_t>(topBits | mask));
|
||||
value -= mask;
|
||||
while (value >= 128) {
|
||||
out.push_back(static_cast<std::uint8_t>((value & 0x7F) | 0x80));
|
||||
value >>= 7;
|
||||
}
|
||||
out.push_back(static_cast<std::uint8_t>(value));
|
||||
}
|
||||
|
||||
// Decode N-bit-prefix integer. data[0] holds prefix flags; the low N bits
|
||||
// contribute to the value (continuation bytes follow if low N bits == mask).
|
||||
export inline bool DecodeQpackInt(const std::uint8_t* data, std::size_t available,
|
||||
int N, std::uint64_t& value, std::size_t& consumed) {
|
||||
if (available == 0) return false;
|
||||
std::uint8_t mask = static_cast<std::uint8_t>((1U << N) - 1);
|
||||
std::uint8_t first = data[0] & mask;
|
||||
if (first < mask) {
|
||||
value = first;
|
||||
consumed = 1;
|
||||
return true;
|
||||
}
|
||||
std::uint64_t v = mask;
|
||||
int shift = 0;
|
||||
std::size_t i = 1;
|
||||
while (true) {
|
||||
if (i >= available) return false;
|
||||
std::uint8_t b = data[i++];
|
||||
v += static_cast<std::uint64_t>(b & 0x7F) << shift;
|
||||
if ((b & 0x80) == 0) break;
|
||||
shift += 7;
|
||||
if (shift > 63) return false;
|
||||
}
|
||||
value = v;
|
||||
consumed = i;
|
||||
return true;
|
||||
}
|
||||
|
||||
// ---------------- Huffman codec (RFC 7541 Appendix B) ----------------
|
||||
// Decode-only. Real h3 peers (browsers, curl, cloudflare, etc.) Huffman-
|
||||
// encode header values by default, so without this any external interop
|
||||
// collapses on the first response. We don't emit Huffman ourselves —
|
||||
// peers MUST accept H=0 literal per the spec, so encoding doesn't add
|
||||
// interop value, only wire compactness. The 256-entry table plus a
|
||||
// straightforward bit-walking decoder is the smallest viable form.
|
||||
struct HuffmanCode {
|
||||
std::uint32_t code;
|
||||
std::uint8_t length;
|
||||
};
|
||||
inline constexpr std::array<HuffmanCode, 256> kHuffmanTable = {{
|
||||
/* 0 */ {0x1ff8, 13}, /* 1 */ {0x7fffd8, 23}, /* 2 */ {0xfffffe2, 28},
|
||||
/* 3 */ {0xfffffe3, 28}, /* 4 */ {0xfffffe4, 28}, /* 5 */ {0xfffffe5, 28},
|
||||
/* 6 */ {0xfffffe6, 28}, /* 7 */ {0xfffffe7, 28}, /* 8 */ {0xfffffe8, 28},
|
||||
/* 9 */ {0xffffea, 24}, /* 10 */ {0x3ffffffc,30}, /* 11 */ {0xfffffe9, 28},
|
||||
/* 12 */ {0xfffffea, 28}, /* 13 */ {0x3ffffffd,30}, /* 14 */ {0xfffffeb, 28},
|
||||
/* 15 */ {0xfffffec, 28}, /* 16 */ {0xfffffed, 28}, /* 17 */ {0xfffffee, 28},
|
||||
/* 18 */ {0xfffffef, 28}, /* 19 */ {0xffffff0, 28}, /* 20 */ {0xffffff1, 28},
|
||||
/* 21 */ {0xffffff2, 28}, /* 22 */ {0x3ffffffe,30}, /* 23 */ {0xffffff3, 28},
|
||||
/* 24 */ {0xffffff4, 28}, /* 25 */ {0xffffff5, 28}, /* 26 */ {0xffffff6, 28},
|
||||
/* 27 */ {0xffffff7, 28}, /* 28 */ {0xffffff8, 28}, /* 29 */ {0xffffff9, 28},
|
||||
/* 30 */ {0xffffffa, 28}, /* 31 */ {0xffffffb, 28}, /* 32 */ {0x14, 6},
|
||||
/* 33 */ {0x3f8, 10}, /* 34 */ {0x3f9, 10}, /* 35 */ {0xffa, 12},
|
||||
/* 36 */ {0x1ff9, 13}, /* 37 */ {0x15, 6}, /* 38 */ {0xf8, 8},
|
||||
/* 39 */ {0x7fa, 11}, /* 40 */ {0x3fa, 10}, /* 41 */ {0x3fb, 10},
|
||||
/* 42 */ {0xf9, 8}, /* 43 */ {0x7fb, 11}, /* 44 */ {0xfa, 8},
|
||||
/* 45 */ {0x16, 6}, /* 46 */ {0x17, 6}, /* 47 */ {0x18, 6},
|
||||
/* 48 */ {0x0, 5}, /* 49 */ {0x1, 5}, /* 50 */ {0x2, 5},
|
||||
/* 51 */ {0x19, 6}, /* 52 */ {0x1a, 6}, /* 53 */ {0x1b, 6},
|
||||
/* 54 */ {0x1c, 6}, /* 55 */ {0x1d, 6}, /* 56 */ {0x1e, 6},
|
||||
/* 57 */ {0x1f, 6}, /* 58 */ {0x5c, 7}, /* 59 */ {0xfb, 8},
|
||||
/* 60 */ {0x7ffc, 15}, /* 61 */ {0x20, 6}, /* 62 */ {0xffb, 12},
|
||||
/* 63 */ {0x3fc, 10}, /* 64 */ {0x1ffa, 13}, /* 65 */ {0x21, 6},
|
||||
/* 66 */ {0x5d, 7}, /* 67 */ {0x5e, 7}, /* 68 */ {0x5f, 7},
|
||||
/* 69 */ {0x60, 7}, /* 70 */ {0x61, 7}, /* 71 */ {0x62, 7},
|
||||
/* 72 */ {0x63, 7}, /* 73 */ {0x64, 7}, /* 74 */ {0x65, 7},
|
||||
/* 75 */ {0x66, 7}, /* 76 */ {0x67, 7}, /* 77 */ {0x68, 7},
|
||||
/* 78 */ {0x69, 7}, /* 79 */ {0x6a, 7}, /* 80 */ {0x6b, 7},
|
||||
/* 81 */ {0x6c, 7}, /* 82 */ {0x6d, 7}, /* 83 */ {0x6e, 7},
|
||||
/* 84 */ {0x6f, 7}, /* 85 */ {0x70, 7}, /* 86 */ {0x71, 7},
|
||||
/* 87 */ {0x72, 7}, /* 88 */ {0xfc, 8}, /* 89 */ {0x73, 7},
|
||||
/* 90 */ {0xfd, 8}, /* 91 */ {0x1ffb, 13}, /* 92 */ {0x7fff0, 19},
|
||||
/* 93 */ {0x1ffc, 13}, /* 94 */ {0x3ffc, 14}, /* 95 */ {0x22, 6},
|
||||
/* 96 */ {0x7ffd, 15}, /* 97 */ {0x3, 5}, /* 98 */ {0x23, 6},
|
||||
/* 99 */ {0x4, 5}, /*100 */ {0x24, 6}, /*101 */ {0x5, 5},
|
||||
/*102 */ {0x25, 6}, /*103 */ {0x26, 6}, /*104 */ {0x27, 6},
|
||||
/*105 */ {0x6, 5}, /*106 */ {0x74, 7}, /*107 */ {0x75, 7},
|
||||
/*108 */ {0x28, 6}, /*109 */ {0x29, 6}, /*110 */ {0x2a, 6},
|
||||
/*111 */ {0x7, 5}, /*112 */ {0x2b, 6}, /*113 */ {0x76, 7},
|
||||
/*114 */ {0x2c, 6}, /*115 */ {0x8, 5}, /*116 */ {0x9, 5},
|
||||
/*117 */ {0x2d, 6}, /*118 */ {0x77, 7}, /*119 */ {0x78, 7},
|
||||
/*120 */ {0x79, 7}, /*121 */ {0x7a, 7}, /*122 */ {0x7b, 7},
|
||||
/*123 */ {0x7ffe, 15}, /*124 */ {0x7fc, 11}, /*125 */ {0x3ffd, 14},
|
||||
/*126 */ {0x1ffd, 13}, /*127 */ {0xffffffc, 28}, /*128 */ {0xfffe6, 20},
|
||||
/*129 */ {0x3fffd2, 22}, /*130 */ {0xfffe7, 20}, /*131 */ {0xfffe8, 20},
|
||||
/*132 */ {0x3fffd3, 22}, /*133 */ {0x3fffd4, 22}, /*134 */ {0x3fffd5, 22},
|
||||
/*135 */ {0x7fffd9, 23}, /*136 */ {0x3fffd6, 22}, /*137 */ {0x7fffda, 23},
|
||||
/*138 */ {0x7fffdb, 23}, /*139 */ {0x7fffdc, 23}, /*140 */ {0x7fffdd, 23},
|
||||
/*141 */ {0x7fffde, 23}, /*142 */ {0xffffeb, 24}, /*143 */ {0x7fffdf, 23},
|
||||
/*144 */ {0xffffec, 24}, /*145 */ {0xffffed, 24}, /*146 */ {0x3fffd7, 22},
|
||||
/*147 */ {0x7fffe0, 23}, /*148 */ {0xffffee, 24}, /*149 */ {0x7fffe1, 23},
|
||||
/*150 */ {0x7fffe2, 23}, /*151 */ {0x7fffe3, 23}, /*152 */ {0x7fffe4, 23},
|
||||
/*153 */ {0x1fffdc, 21}, /*154 */ {0x3fffd8, 22}, /*155 */ {0x7fffe5, 23},
|
||||
/*156 */ {0x3fffd9, 22}, /*157 */ {0x7fffe6, 23}, /*158 */ {0x7fffe7, 23},
|
||||
/*159 */ {0xffffef, 24}, /*160 */ {0x3fffda, 22}, /*161 */ {0x1fffdd, 21},
|
||||
/*162 */ {0xfffe9, 20}, /*163 */ {0x3fffdb, 22}, /*164 */ {0x3fffdc, 22},
|
||||
/*165 */ {0x7fffe8, 23}, /*166 */ {0x7fffe9, 23}, /*167 */ {0x1fffde, 21},
|
||||
/*168 */ {0x7fffea, 23}, /*169 */ {0x3fffdd, 22}, /*170 */ {0x3fffde, 22},
|
||||
/*171 */ {0xfffff0, 24}, /*172 */ {0x1fffdf, 21}, /*173 */ {0x3fffdf, 22},
|
||||
/*174 */ {0x7fffeb, 23}, /*175 */ {0x7fffec, 23}, /*176 */ {0x1fffe0, 21},
|
||||
/*177 */ {0x1fffe1, 21}, /*178 */ {0x3fffe0, 22}, /*179 */ {0x1fffe2, 21},
|
||||
/*180 */ {0x7fffed, 23}, /*181 */ {0x3fffe1, 22}, /*182 */ {0x7fffee, 23},
|
||||
/*183 */ {0x7fffef, 23}, /*184 */ {0xfffea, 20}, /*185 */ {0x3fffe2, 22},
|
||||
/*186 */ {0x3fffe3, 22}, /*187 */ {0x3fffe4, 22}, /*188 */ {0x7ffff0, 23},
|
||||
/*189 */ {0x3fffe5, 22}, /*190 */ {0x3fffe6, 22}, /*191 */ {0x7ffff1, 23},
|
||||
/*192 */ {0x3ffffe0,26}, /*193 */ {0x3ffffe1, 26}, /*194 */ {0xfffeb, 20},
|
||||
/*195 */ {0x7fff1, 19}, /*196 */ {0x3fffe7, 22}, /*197 */ {0x7ffff2, 23},
|
||||
/*198 */ {0x3fffe8, 22}, /*199 */ {0x1ffffec, 25}, /*200 */ {0x3ffffe2, 26},
|
||||
/*201 */ {0x3ffffe3,26}, /*202 */ {0x3ffffe4, 26}, /*203 */ {0x7ffffde, 27},
|
||||
/*204 */ {0x7ffffdf,27}, /*205 */ {0x3ffffe5, 26}, /*206 */ {0xfffff1, 24},
|
||||
/*207 */ {0x1ffffed,25}, /*208 */ {0x7fff2, 19}, /*209 */ {0x1fffe3, 21},
|
||||
/*210 */ {0x3ffffe6,26}, /*211 */ {0x7ffffe0, 27}, /*212 */ {0x7ffffe1, 27},
|
||||
/*213 */ {0x3ffffe7,26}, /*214 */ {0x7ffffe2, 27}, /*215 */ {0xfffff2, 24},
|
||||
/*216 */ {0x1fffe4, 21}, /*217 */ {0x1fffe5, 21}, /*218 */ {0x3ffffe8, 26},
|
||||
/*219 */ {0x3ffffe9,26}, /*220 */ {0xffffffd,28}, /*221 */ {0x7ffffe3, 27},
|
||||
/*222 */ {0x7ffffe4,27}, /*223 */ {0x7ffffe5, 27}, /*224 */ {0xfffec, 20},
|
||||
/*225 */ {0xfffff3, 24}, /*226 */ {0xfffed, 20}, /*227 */ {0x1fffe6, 21},
|
||||
/*228 */ {0x3fffe9, 22}, /*229 */ {0x1fffe7, 21}, /*230 */ {0x1fffe8, 21},
|
||||
/*231 */ {0x7ffff3, 23}, /*232 */ {0x3fffea, 22}, /*233 */ {0x3fffeb, 22},
|
||||
/*234 */ {0x1ffffee,25}, /*235 */ {0x1ffffef, 25}, /*236 */ {0xfffff4, 24},
|
||||
/*237 */ {0xfffff5, 24}, /*238 */ {0x3ffffea, 26}, /*239 */ {0x7ffff4, 23},
|
||||
/*240 */ {0x3ffffeb,26}, /*241 */ {0x7ffffe6, 27}, /*242 */ {0x3ffffec, 26},
|
||||
/*243 */ {0x3ffffed,26}, /*244 */ {0x7ffffe7, 27}, /*245 */ {0x7ffffe8, 27},
|
||||
/*246 */ {0x7ffffe9,27}, /*247 */ {0x7ffffea, 27}, /*248 */ {0x7ffffeb, 27},
|
||||
/*249 */ {0xffffffe,28}, /*250 */ {0x7ffffec, 27}, /*251 */ {0x7ffffed, 27},
|
||||
/*252 */ {0x7ffffee,27}, /*253 */ {0x7ffffef, 27}, /*254 */ {0x7fffff0, 27},
|
||||
/*255 */ {0x3ffffee,26},
|
||||
}};
|
||||
|
||||
export inline std::string DecodeHuffman(const std::uint8_t* in, std::size_t inLen) {
|
||||
// Bit-walking decoder. Refill a 64-bit register from the input byte
|
||||
// stream, then for each output symbol scan the 256-entry table for
|
||||
// the unique code that matches the top `bits` of the register at
|
||||
// some length L in [5, 30]. Linear scan is acceptable for the
|
||||
// header-section sizes seen in HTTP/3 traffic; the inner loop is
|
||||
// hot for ~100s of bytes per request.
|
||||
std::string out;
|
||||
std::uint64_t reg = 0;
|
||||
int bits = 0;
|
||||
std::size_t pos = 0;
|
||||
while (true) {
|
||||
while (bits <= 56 && pos < inLen) {
|
||||
reg = (reg << 8) | in[pos++];
|
||||
bits += 8;
|
||||
}
|
||||
if (bits == 0) return out;
|
||||
|
||||
bool matched = false;
|
||||
const int maxL = bits < 30 ? bits : 30;
|
||||
for (int L = 5; L <= maxL; ++L) {
|
||||
std::uint32_t want = static_cast<std::uint32_t>(
|
||||
(reg >> (bits - L)) & ((std::uint64_t{1} << L) - 1));
|
||||
for (std::size_t s = 0; s < 256; ++s) {
|
||||
if (kHuffmanTable[s].length == L && kHuffmanTable[s].code == want) {
|
||||
out.push_back(static_cast<char>(s));
|
||||
bits -= L;
|
||||
matched = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (matched) break;
|
||||
}
|
||||
if (!matched) {
|
||||
// Tail must be ≤ 7 bits and all 1s — that's the EOS-prefix
|
||||
// padding RFC 7541 §5.2 mandates. Anything else is malformed.
|
||||
if (bits <= 7) {
|
||||
std::uint64_t mask = (std::uint64_t{1} << bits) - 1;
|
||||
if ((reg & mask) == mask) return out;
|
||||
}
|
||||
throw HTTP3ProtocolError("Huffman: invalid encoding");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- QPACK static table (RFC 9204 Appendix A, subset) ----------------
|
||||
// We embed only the entries we either emit (encode) or might need to look
|
||||
// up by index (decode peers using indexed/literal-with-name-ref). The
|
||||
// subset covers all pseudo-headers and a few common content-type/status
|
||||
// values — enough for self-interop. If the peer references an index
|
||||
// outside this table we throw HTTP3ProtocolError.
|
||||
struct StaticEntry {
|
||||
std::string_view name;
|
||||
std::string_view value; // empty if no canonical value (name-only entry)
|
||||
};
|
||||
|
||||
inline constexpr std::array<StaticEntry, 99> kStaticTable = {{
|
||||
{":authority", ""}, // 0
|
||||
{":path", "/"}, // 1
|
||||
{"age", "0"}, // 2
|
||||
{"content-disposition", ""}, // 3
|
||||
{"content-length", "0"}, // 4
|
||||
{"cookie", ""}, // 5
|
||||
{"date", ""}, // 6
|
||||
{"etag", ""}, // 7
|
||||
{"if-modified-since", ""}, // 8
|
||||
{"if-none-match", ""}, // 9
|
||||
{"last-modified", ""}, // 10
|
||||
{"link", ""}, // 11
|
||||
{"location", ""}, // 12
|
||||
{"referer", ""}, // 13
|
||||
{"set-cookie", ""}, // 14
|
||||
{":method", "CONNECT"}, // 15
|
||||
{":method", "DELETE"}, // 16
|
||||
{":method", "GET"}, // 17
|
||||
{":method", "HEAD"}, // 18
|
||||
{":method", "OPTIONS"}, // 19
|
||||
{":method", "POST"}, // 20
|
||||
{":method", "PUT"}, // 21
|
||||
{":scheme", "http"}, // 22
|
||||
{":scheme", "https"}, // 23
|
||||
{":status", "103"}, // 24
|
||||
{":status", "200"}, // 25
|
||||
{":status", "304"}, // 26
|
||||
{":status", "404"}, // 27
|
||||
{":status", "503"}, // 28
|
||||
{"accept", "*/*"}, // 29
|
||||
{"accept", "application/dns-message"}, // 30
|
||||
{"accept-encoding", "gzip, deflate, br"}, // 31
|
||||
{"accept-ranges", "bytes"}, // 32
|
||||
{"access-control-allow-headers", "cache-control"}, // 33
|
||||
{"access-control-allow-headers", "content-type"}, // 34
|
||||
{"access-control-allow-origin", "*"}, // 35
|
||||
{"cache-control", "max-age=0"}, // 36
|
||||
{"cache-control", "max-age=2592000"}, // 37
|
||||
{"cache-control", "max-age=604800"}, // 38
|
||||
{"cache-control", "no-cache"}, // 39
|
||||
{"cache-control", "no-store"}, // 40
|
||||
{"cache-control", "public, max-age=31536000"}, // 41
|
||||
{"content-encoding", "br"}, // 42
|
||||
{"content-encoding", "gzip"}, // 43
|
||||
{"content-type", "application/dns-message"}, // 44
|
||||
{"content-type", "application/javascript"}, // 45
|
||||
{"content-type", "application/json"}, // 46
|
||||
{"content-type", "application/x-www-form-urlencoded"}, // 47
|
||||
{"content-type", "image/gif"}, // 48
|
||||
{"content-type", "image/jpeg"}, // 49
|
||||
{"content-type", "image/png"}, // 50
|
||||
{"content-type", "text/css"}, // 51
|
||||
{"content-type", "text/html; charset=utf-8"}, // 52
|
||||
{"content-type", "text/plain"}, // 53
|
||||
{"content-type", "text/plain;charset=utf-8"}, // 54
|
||||
{"range", "bytes=0-"}, // 55
|
||||
{"strict-transport-security", "max-age=31536000"}, // 56
|
||||
{"strict-transport-security", "max-age=31536000; includesubdomains"}, // 57
|
||||
{"strict-transport-security", "max-age=31536000; includesubdomains; preload"}, // 58
|
||||
{"vary", "accept-encoding"}, // 59
|
||||
{"vary", "origin"}, // 60
|
||||
{"x-content-type-options", "nosniff"}, // 61
|
||||
{"x-xss-protection", "1; mode=block"}, // 62
|
||||
{":status", "100"}, // 63
|
||||
{":status", "204"}, // 64
|
||||
{":status", "206"}, // 65
|
||||
{":status", "302"}, // 66
|
||||
{":status", "400"}, // 67
|
||||
{":status", "403"}, // 68
|
||||
{":status", "421"}, // 69
|
||||
{":status", "425"}, // 70
|
||||
{":status", "500"}, // 71
|
||||
{"accept-language", ""}, // 72
|
||||
{"access-control-allow-credentials", "FALSE"}, // 73
|
||||
{"access-control-allow-credentials", "TRUE"}, // 74
|
||||
{"access-control-allow-headers", "*"}, // 75
|
||||
{"access-control-allow-methods", "get"}, // 76
|
||||
{"access-control-allow-methods", "get, post, options"}, // 77
|
||||
{"access-control-allow-methods", "options"}, // 78
|
||||
{"access-control-expose-headers", "content-length"}, // 79
|
||||
{"access-control-request-headers", "content-type"}, // 80
|
||||
{"access-control-request-method", "get"}, // 81
|
||||
{"access-control-request-method", "post"}, // 82
|
||||
{"alt-svc", "clear"}, // 83
|
||||
{"authorization", ""}, // 84
|
||||
{"content-security-policy", "script-src 'none'; object-src 'none'; base-uri 'none'"}, // 85
|
||||
{"early-data", "1"}, // 86
|
||||
{"expect-ct", ""}, // 87
|
||||
{"forwarded", ""}, // 88
|
||||
{"if-range", ""}, // 89
|
||||
{"origin", ""}, // 90
|
||||
{"purpose", "prefetch"}, // 91
|
||||
{"server", ""}, // 92
|
||||
{"timing-allow-origin", "*"}, // 93
|
||||
{"upgrade-insecure-requests", "1"}, // 94
|
||||
{"user-agent", ""}, // 95
|
||||
{"x-forwarded-for", ""}, // 96
|
||||
{"x-frame-options", "deny"}, // 97
|
||||
{"x-frame-options", "sameorigin"}, // 98
|
||||
}};
|
||||
|
||||
// Lookup a (name, value) pair against the static table; returns -1 if not
|
||||
// present. Linear scan is fine here: ~100 entries, called per header.
|
||||
inline int StaticTableExactLookup(std::string_view name, std::string_view value) {
|
||||
for (std::size_t i = 0; i < kStaticTable.size(); ++i) {
|
||||
if (kStaticTable[i].name == name && kStaticTable[i].value == value) {
|
||||
return static_cast<int>(i);
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
// Lookup name-only; returns the lowest matching index or -1.
|
||||
inline int StaticTableNameLookup(std::string_view name) {
|
||||
for (std::size_t i = 0; i < kStaticTable.size(); ++i) {
|
||||
if (kStaticTable[i].name == name) return static_cast<int>(i);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// ---------------- Field section codec ----------------
|
||||
// Encodes the QPACK-on-the-wire field section: a 2-byte prefix (Required
|
||||
// Insert Count = 0, Sign+DeltaBase = 0 — i.e. no dynamic table reliance)
|
||||
// followed by per-field representations. We pick the most compact static
|
||||
// representation each header allows; never emit Huffman; never use the
|
||||
// dynamic table.
|
||||
export inline std::vector<std::uint8_t> EncodeFieldSection(
|
||||
const std::vector<std::pair<std::string, std::string>>& fields) {
|
||||
std::vector<std::uint8_t> out;
|
||||
// Prefix: Required Insert Count (8-bit prefix int = 0)
|
||||
EncodeQpackInt(out, 0x00, 8, 0);
|
||||
// Sign + Delta Base (sign in high bit of 7-bit-prefix int = 0)
|
||||
EncodeQpackInt(out, 0x00, 7, 0);
|
||||
|
||||
for (const auto& [name, value] : fields) {
|
||||
int exact = StaticTableExactLookup(name, value);
|
||||
if (exact >= 0) {
|
||||
// Indexed Field Line, T=1 (static): pattern 1Tixxxxx, 6-bit prefix.
|
||||
EncodeQpackInt(out, 0xC0, 6, static_cast<std::uint64_t>(exact));
|
||||
continue;
|
||||
}
|
||||
int nameIdx = StaticTableNameLookup(name);
|
||||
if (nameIdx >= 0) {
|
||||
// Literal Field Line With Name Reference, T=1 (static),
|
||||
// N=0 (allow indexing on intermediaries — moot since no DT):
|
||||
// pattern 01NTxxxx, 4-bit name-index prefix.
|
||||
EncodeQpackInt(out, 0x50, 4, static_cast<std::uint64_t>(nameIdx));
|
||||
} else {
|
||||
// Literal Field Line With Literal Name, N=0, H=0: pattern
|
||||
// 001NHxxx with a 3-bit name-length prefix.
|
||||
EncodeQpackInt(out, 0x20, 3, name.size());
|
||||
out.insert(out.end(), name.begin(), name.end());
|
||||
}
|
||||
// Value: 7-bit length prefix, H=0 (no Huffman).
|
||||
EncodeQpackInt(out, 0x00, 7, value.size());
|
||||
out.insert(out.end(), value.begin(), value.end());
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
export inline std::vector<std::pair<std::string, std::string>> DecodeFieldSection(
|
||||
const std::uint8_t* data, std::size_t available) {
|
||||
std::size_t pos = 0;
|
||||
std::uint64_t reqIc = 0, deltaBase = 0;
|
||||
std::size_t cn = 0;
|
||||
if (!DecodeQpackInt(data + pos, available - pos, 8, reqIc, cn)) {
|
||||
throw HTTP3ProtocolError("QPACK: truncated Required Insert Count");
|
||||
}
|
||||
pos += cn;
|
||||
if (pos >= available) throw HTTP3ProtocolError("QPACK: missing Base");
|
||||
if (!DecodeQpackInt(data + pos, available - pos, 7, deltaBase, cn)) {
|
||||
throw HTTP3ProtocolError("QPACK: truncated Base");
|
||||
}
|
||||
pos += cn;
|
||||
if (reqIc != 0) {
|
||||
// Encoder used the dynamic table, which we don't track. Required
|
||||
// Insert Count != 0 means we cannot decode without dynamic-table
|
||||
// state; surface a clean protocol error rather than mis-decoding.
|
||||
throw HTTP3ProtocolError("QPACK: dynamic table reference (Required Insert Count != 0)");
|
||||
}
|
||||
|
||||
std::vector<std::pair<std::string, std::string>> fields;
|
||||
while (pos < available) {
|
||||
std::uint8_t b = data[pos];
|
||||
if ((b & 0x80) != 0) {
|
||||
// 1Txxxxxx — Indexed Field Line.
|
||||
bool isStatic = (b & 0x40) != 0;
|
||||
std::uint64_t idx = 0;
|
||||
if (!DecodeQpackInt(data + pos, available - pos, 6, idx, cn)) {
|
||||
throw HTTP3ProtocolError("QPACK: truncated indexed field line");
|
||||
}
|
||||
pos += cn;
|
||||
if (!isStatic) throw HTTP3ProtocolError("QPACK: dynamic-table indexed line unsupported");
|
||||
if (idx >= kStaticTable.size()) throw HTTP3ProtocolError("QPACK: static index out of range");
|
||||
const auto& e = kStaticTable[static_cast<std::size_t>(idx)];
|
||||
fields.emplace_back(std::string(e.name), std::string(e.value));
|
||||
} else if ((b & 0xC0) == 0x40) {
|
||||
// 01NTxxxx — Literal Field Line With Name Reference.
|
||||
bool isStatic = (b & 0x10) != 0;
|
||||
std::uint64_t idx = 0;
|
||||
if (!DecodeQpackInt(data + pos, available - pos, 4, idx, cn)) {
|
||||
throw HTTP3ProtocolError("QPACK: truncated literal-with-nameref index");
|
||||
}
|
||||
pos += cn;
|
||||
if (!isStatic) throw HTTP3ProtocolError("QPACK: dynamic-table name reference unsupported");
|
||||
if (idx >= kStaticTable.size()) throw HTTP3ProtocolError("QPACK: static name index out of range");
|
||||
if (pos >= available) throw HTTP3ProtocolError("QPACK: missing value byte");
|
||||
bool huffman = (data[pos] & 0x80) != 0;
|
||||
std::uint64_t vlen = 0;
|
||||
if (!DecodeQpackInt(data + pos, available - pos, 7, vlen, cn)) {
|
||||
throw HTTP3ProtocolError("QPACK: truncated value length");
|
||||
}
|
||||
pos += cn;
|
||||
if (pos + vlen > available) throw HTTP3ProtocolError("QPACK: value runs past buffer");
|
||||
std::string value = huffman
|
||||
? DecodeHuffman(data + pos, static_cast<std::size_t>(vlen))
|
||||
: std::string(reinterpret_cast<const char*>(data + pos),
|
||||
static_cast<std::size_t>(vlen));
|
||||
pos += static_cast<std::size_t>(vlen);
|
||||
fields.emplace_back(std::string(kStaticTable[static_cast<std::size_t>(idx)].name), std::move(value));
|
||||
} else if ((b & 0xE0) == 0x20) {
|
||||
// 001NHxxx — Literal Field Line With Literal Name.
|
||||
bool huffmanName = (b & 0x08) != 0;
|
||||
std::uint64_t nlen = 0;
|
||||
if (!DecodeQpackInt(data + pos, available - pos, 3, nlen, cn)) {
|
||||
throw HTTP3ProtocolError("QPACK: truncated literal-name length");
|
||||
}
|
||||
pos += cn;
|
||||
if (pos + nlen > available) throw HTTP3ProtocolError("QPACK: literal name runs past buffer");
|
||||
std::string name = huffmanName
|
||||
? DecodeHuffman(data + pos, static_cast<std::size_t>(nlen))
|
||||
: std::string(reinterpret_cast<const char*>(data + pos),
|
||||
static_cast<std::size_t>(nlen));
|
||||
pos += static_cast<std::size_t>(nlen);
|
||||
if (pos >= available) throw HTTP3ProtocolError("QPACK: missing value byte");
|
||||
bool huffmanValue = (data[pos] & 0x80) != 0;
|
||||
std::uint64_t vlen = 0;
|
||||
if (!DecodeQpackInt(data + pos, available - pos, 7, vlen, cn)) {
|
||||
throw HTTP3ProtocolError("QPACK: truncated literal-value length");
|
||||
}
|
||||
pos += cn;
|
||||
if (pos + vlen > available) throw HTTP3ProtocolError("QPACK: literal value runs past buffer");
|
||||
std::string value = huffmanValue
|
||||
? DecodeHuffman(data + pos, static_cast<std::size_t>(vlen))
|
||||
: std::string(reinterpret_cast<const char*>(data + pos),
|
||||
static_cast<std::size_t>(vlen));
|
||||
pos += static_cast<std::size_t>(vlen);
|
||||
fields.emplace_back(std::move(name), std::move(value));
|
||||
} else {
|
||||
// Indexed-with-Post-Base / Literal-with-Post-Base-Name-Reference
|
||||
// both rely on a dynamic-table base offset we don't maintain.
|
||||
throw HTTP3ProtocolError("QPACK: post-base reference unsupported");
|
||||
}
|
||||
}
|
||||
return fields;
|
||||
}
|
||||
|
||||
// ---------------- Frame helpers ----------------
|
||||
// A frame is: type (varint) | length (varint) | payload (length bytes).
|
||||
export inline void WriteFrame(std::vector<std::uint8_t>& out, std::uint64_t type,
|
||||
const std::uint8_t* payload, std::size_t length) {
|
||||
EncodeVarint(type, out);
|
||||
EncodeVarint(static_cast<std::uint64_t>(length), out);
|
||||
out.insert(out.end(), payload, payload + length);
|
||||
}
|
||||
|
||||
// Empty SETTINGS frame body — we send no settings, accepting all defaults.
|
||||
export inline std::vector<std::uint8_t> BuildControlStreamPrelude() {
|
||||
std::vector<std::uint8_t> out;
|
||||
EncodeVarint(kStreamControl, out); // unidi stream type
|
||||
EncodeVarint(kFrameSettings, out); // SETTINGS frame type
|
||||
EncodeVarint(0, out); // frame length 0
|
||||
return out;
|
||||
}
|
||||
}
|
||||
|
|
@ -21,38 +21,57 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
export module Crafter.Network:ListenerHTTP;
|
||||
import std;
|
||||
import :HTTP;
|
||||
import :ClientTCP;
|
||||
import :ListenerQUIC;
|
||||
import :ClientQUIC;
|
||||
|
||||
namespace Crafter {
|
||||
export class ListenerHTTP;
|
||||
class ListenerHTTPClient {
|
||||
public:
|
||||
std::atomic<bool> disconnected;
|
||||
ClientTCP client;
|
||||
std::thread thread;
|
||||
ListenerHTTP* server;
|
||||
ListenerHTTPClient(ListenerHTTP* server, int s);
|
||||
void ListenRoutes();
|
||||
};
|
||||
// HTTP/3 server. Wraps a ListenerQUIC: each accepted QUIC connection
|
||||
// registers a per-stream handler that parses one request, dispatches it
|
||||
// through the route map, and writes a response back on the same bidi
|
||||
// stream. ALPN is fixed to "h3".
|
||||
//
|
||||
// Routes are keyed by `:path` (exact match). Unknown paths return a
|
||||
// synthetic 404. Route handlers run on the ThreadPool — multiple requests
|
||||
// on the same connection can therefore execute concurrently.
|
||||
export class ListenerHTTP {
|
||||
public:
|
||||
// The underlying QUIC listener owns the accept loop, certificates,
|
||||
// and the per-connection ClientQUIC instances. It is heap-allocated
|
||||
// and owned by this Impl so that move construction/destruction is
|
||||
// straightforward.
|
||||
std::unordered_map<std::string, std::function<HTTPResponse(const HTTPRequest&)>> routes;
|
||||
std::string alpn;
|
||||
|
||||
export class ListenerHTTP {
|
||||
public:
|
||||
int s;
|
||||
std::vector<ListenerHTTPClient*> clients;
|
||||
bool running = true;
|
||||
const std::unordered_map<std::string, std::function<std::string(const HTTPRequest&)>> routes;
|
||||
ListenerHTTP(std::uint16_t port, std::unordered_map<std::string, std::function<std::string(const HTTPRequest&)>> routes);
|
||||
~ListenerHTTP();
|
||||
void Listen();
|
||||
void Stop();
|
||||
};
|
||||
ListenerHTTP(std::uint16_t port,
|
||||
QUICServerCredentials creds,
|
||||
std::unordered_map<std::string, std::function<HTTPResponse(const HTTPRequest&)>> routes);
|
||||
|
||||
export class ListenerAsyncHTTP {
|
||||
public:
|
||||
ListenerHTTP listener;
|
||||
std::thread thread;
|
||||
ListenerAsyncHTTP(std::uint16_t port, std::unordered_map<std::string, std::function<std::string(const HTTPRequest&)>> routes);
|
||||
~ListenerAsyncHTTP();
|
||||
void Stop();
|
||||
};
|
||||
~ListenerHTTP();
|
||||
ListenerHTTP(const ListenerHTTP&) = delete;
|
||||
ListenerHTTP(ListenerHTTP&&) noexcept;
|
||||
|
||||
// Block on this thread, dispatch each accepted connection on this
|
||||
// thread (matches ListenerQUIC::ListenSyncSync semantics).
|
||||
void Listen();
|
||||
void Stop();
|
||||
|
||||
private:
|
||||
struct Impl;
|
||||
std::unique_ptr<Impl> impl;
|
||||
};
|
||||
|
||||
// Async wrapper: runs the listener's accept loop on a background thread
|
||||
// so the caller can construct it and continue. Mirrors the old
|
||||
// ListenerAsyncHTTP so existing call sites keep working.
|
||||
export class ListenerAsyncHTTP {
|
||||
public:
|
||||
ListenerHTTP listener;
|
||||
std::thread thread;
|
||||
|
||||
ListenerAsyncHTTP(std::uint16_t port,
|
||||
QUICServerCredentials creds,
|
||||
std::unordered_map<std::string, std::function<HTTPResponse(const HTTPRequest&)>> routes);
|
||||
~ListenerAsyncHTTP();
|
||||
void Stop();
|
||||
};
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue