dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Tests/LibHTTP/TestHTTPUtils.cpp

249 lines
11 KiB
C++
Raw Permalink Normal View History

LibWeb: Return the correct substring when parsing an HTTP quoted string We were off-by-one when returning the result of parsing a quoted string in Web::Fetch::Infrastructure::collect_an_http_quoted_string. Instead of backtracking the lexer and consuming the backtracked string, do a simple substring operation.
2024-03-26 13:13:11 -03:00
/*
LibHTTP+LibWeb+RequestServer: Move Fetch's HTTP header infra to LibHTTP The end goal here is for LibHTTP to be the home of our RFC 9111 (HTTP caching) implementation. We currently have one implementation in LibWeb for our in-memory cache and another in RequestServer for our disk cache. The implementations both largely revolve around interacting with HTTP headers. But in LibWeb, we are using Fetch's header infra, and in RS we are using are home-grown header infra from LibHTTP. So to give these a common denominator, this patch replaces the LibHTTP implementation with Fetch's infra. Our existing LibHTTP implementation was not particularly compliant with any spec, so this at least gives us a standards-based common implementation. This migration also required moving a handful of other Fetch AOs over to LibHTTP. (It turns out these AOs were all from the Fetch/Infra/HTTP folder, so perhaps it makes sense for LibHTTP to be the implementation of that entire set of facilities.)
2025-11-26 16:13:23 -03:00
* Copyright (c) 2024-2025, Tim Flynn <trflynn89@ladybird.org>
LibWeb: Return the correct substring when parsing an HTTP quoted string We were off-by-one when returning the result of parsing a quoted string in Web::Fetch::Infrastructure::collect_an_http_quoted_string. Instead of backtracking the lexer and consuming the backtracked string, do a simple substring operation.
2024-03-26 13:13:11 -03:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibTest/TestCase.h>
#include <AK/GenericLexer.h>
#include <AK/String.h>
LibHTTP: Implement a strict method to extract Cache-Control directives Our previous implementation was a bit too tolerant of bad header values. For example, extracting a "max-age" from a header value of "abmax-agecd" would have incorrectly parsed successfully. We now find exact (case-insensitive) directive matches. We also handle quoted string values, which may contain important delimeters that we would have previously split on.
2026-01-27 10:10:11 -03:00
#include <LibHTTP/Cache/Utilities.h>
LibHTTP+LibWeb+RequestServer: Move Fetch's HTTP header infra to LibHTTP The end goal here is for LibHTTP to be the home of our RFC 9111 (HTTP caching) implementation. We currently have one implementation in LibWeb for our in-memory cache and another in RequestServer for our disk cache. The implementations both largely revolve around interacting with HTTP headers. But in LibWeb, we are using Fetch's header infra, and in RS we are using are home-grown header infra from LibHTTP. So to give these a common denominator, this patch replaces the LibHTTP implementation with Fetch's infra. Our existing LibHTTP implementation was not particularly compliant with any spec, so this at least gives us a standards-based common implementation. This migration also required moving a handful of other Fetch AOs over to LibHTTP. (It turns out these AOs were all from the Fetch/Infra/HTTP folder, so perhaps it makes sense for LibHTTP to be the implementation of that entire set of facilities.)
2025-11-26 16:13:23 -03:00
#include <LibHTTP/HTTP.h>
LibHTTP: Parse token-list headers according to their ABNF The previous implementation did not fully align with each headers ABNF, so would not reject some headers as we should have been doing. Fixes 6 WPT subtests for https://wpt.live/cors/access-control-expose-headers-parsing.window.html
2026-02-28 14:36:44 -03:00
#include <LibHTTP/Header.h>
LibRegex: Add ECMAScriptRegex and migrate callers Add `ECMAScriptRegex`, LibRegex's C++ facade for ECMAScript regexes. The facade owns compilation, execution, captures, named groups, and error translation for the Rust backend, which lets callers stop depending on the legacy parser and matcher types directly. Use it in the remaining non-LibJS callers: URLPattern, HTML input pattern handling, and the places in LibHTTP that only needed token validation. Where a full regex engine was unnecessary, replace those call sites with direct character checks. Also update focused LibURL, LibHTTP, and WPT coverage for the migrated callers and corrected surrogate handling.
2026-03-25 06:52:20 -03:00
#include <LibHTTP/Method.h>
LibWeb: Return the correct substring when parsing an HTTP quoted string We were off-by-one when returning the result of parsing a quoted string in Web::Fetch::Infrastructure::collect_an_http_quoted_string. Instead of backtracking the lexer and consuming the backtracked string, do a simple substring operation.
2024-03-26 13:13:11 -03:00
TEST_CASE(collect_an_http_quoted_string)
{
{
auto test = "\"\""_string;
GenericLexer lexer { test };
LibHTTP+LibWeb+RequestServer: Move Fetch's HTTP header infra to LibHTTP The end goal here is for LibHTTP to be the home of our RFC 9111 (HTTP caching) implementation. We currently have one implementation in LibWeb for our in-memory cache and another in RequestServer for our disk cache. The implementations both largely revolve around interacting with HTTP headers. But in LibWeb, we are using Fetch's header infra, and in RS we are using are home-grown header infra from LibHTTP. So to give these a common denominator, this patch replaces the LibHTTP implementation with Fetch's infra. Our existing LibHTTP implementation was not particularly compliant with any spec, so this at least gives us a standards-based common implementation. This migration also required moving a handful of other Fetch AOs over to LibHTTP. (It turns out these AOs were all from the Fetch/Infra/HTTP folder, so perhaps it makes sense for LibHTTP to be the implementation of that entire set of facilities.)
2025-11-26 16:13:23 -03:00
auto result = HTTP::collect_an_http_quoted_string(lexer);
LibWeb: Return the correct substring when parsing an HTTP quoted string We were off-by-one when returning the result of parsing a quoted string in Web::Fetch::Infrastructure::collect_an_http_quoted_string. Instead of backtracking the lexer and consuming the backtracked string, do a simple substring operation.
2024-03-26 13:13:11 -03:00
EXPECT_EQ(result, "\"\""_string);
}
{
auto test = "\"abc\""_string;
GenericLexer lexer { test };
LibHTTP+LibWeb+RequestServer: Move Fetch's HTTP header infra to LibHTTP The end goal here is for LibHTTP to be the home of our RFC 9111 (HTTP caching) implementation. We currently have one implementation in LibWeb for our in-memory cache and another in RequestServer for our disk cache. The implementations both largely revolve around interacting with HTTP headers. But in LibWeb, we are using Fetch's header infra, and in RS we are using are home-grown header infra from LibHTTP. So to give these a common denominator, this patch replaces the LibHTTP implementation with Fetch's infra. Our existing LibHTTP implementation was not particularly compliant with any spec, so this at least gives us a standards-based common implementation. This migration also required moving a handful of other Fetch AOs over to LibHTTP. (It turns out these AOs were all from the Fetch/Infra/HTTP folder, so perhaps it makes sense for LibHTTP to be the implementation of that entire set of facilities.)
2025-11-26 16:13:23 -03:00
auto result = HTTP::collect_an_http_quoted_string(lexer);
LibWeb: Return the correct substring when parsing an HTTP quoted string We were off-by-one when returning the result of parsing a quoted string in Web::Fetch::Infrastructure::collect_an_http_quoted_string. Instead of backtracking the lexer and consuming the backtracked string, do a simple substring operation.
2024-03-26 13:13:11 -03:00
EXPECT_EQ(result, "\"abc\""_string);
}
{
auto test = "foo \"abc\""_string;
GenericLexer lexer { test };
lexer.ignore(4);
LibHTTP+LibWeb+RequestServer: Move Fetch's HTTP header infra to LibHTTP The end goal here is for LibHTTP to be the home of our RFC 9111 (HTTP caching) implementation. We currently have one implementation in LibWeb for our in-memory cache and another in RequestServer for our disk cache. The implementations both largely revolve around interacting with HTTP headers. But in LibWeb, we are using Fetch's header infra, and in RS we are using are home-grown header infra from LibHTTP. So to give these a common denominator, this patch replaces the LibHTTP implementation with Fetch's infra. Our existing LibHTTP implementation was not particularly compliant with any spec, so this at least gives us a standards-based common implementation. This migration also required moving a handful of other Fetch AOs over to LibHTTP. (It turns out these AOs were all from the Fetch/Infra/HTTP folder, so perhaps it makes sense for LibHTTP to be the implementation of that entire set of facilities.)
2025-11-26 16:13:23 -03:00
auto result = HTTP::collect_an_http_quoted_string(lexer);
LibWeb: Return the correct substring when parsing an HTTP quoted string We were off-by-one when returning the result of parsing a quoted string in Web::Fetch::Infrastructure::collect_an_http_quoted_string. Instead of backtracking the lexer and consuming the backtracked string, do a simple substring operation.
2024-03-26 13:13:11 -03:00
EXPECT_EQ(result, "\"abc\""_string);
}
{
auto test = "foo=\"abc\""_string;
GenericLexer lexer { test };
lexer.ignore(4);
LibHTTP+LibWeb+RequestServer: Move Fetch's HTTP header infra to LibHTTP The end goal here is for LibHTTP to be the home of our RFC 9111 (HTTP caching) implementation. We currently have one implementation in LibWeb for our in-memory cache and another in RequestServer for our disk cache. The implementations both largely revolve around interacting with HTTP headers. But in LibWeb, we are using Fetch's header infra, and in RS we are using are home-grown header infra from LibHTTP. So to give these a common denominator, this patch replaces the LibHTTP implementation with Fetch's infra. Our existing LibHTTP implementation was not particularly compliant with any spec, so this at least gives us a standards-based common implementation. This migration also required moving a handful of other Fetch AOs over to LibHTTP. (It turns out these AOs were all from the Fetch/Infra/HTTP folder, so perhaps it makes sense for LibHTTP to be the implementation of that entire set of facilities.)
2025-11-26 16:13:23 -03:00
auto result = HTTP::collect_an_http_quoted_string(lexer);
LibWeb: Return the correct substring when parsing an HTTP quoted string We were off-by-one when returning the result of parsing a quoted string in Web::Fetch::Infrastructure::collect_an_http_quoted_string. Instead of backtracking the lexer and consuming the backtracked string, do a simple substring operation.
2024-03-26 13:13:11 -03:00
EXPECT_EQ(result, "\"abc\""_string);
}
{
auto test = "foo=\"abc\" bar"_string;
GenericLexer lexer { test };
lexer.ignore(4);
LibHTTP+LibWeb+RequestServer: Move Fetch's HTTP header infra to LibHTTP The end goal here is for LibHTTP to be the home of our RFC 9111 (HTTP caching) implementation. We currently have one implementation in LibWeb for our in-memory cache and another in RequestServer for our disk cache. The implementations both largely revolve around interacting with HTTP headers. But in LibWeb, we are using Fetch's header infra, and in RS we are using are home-grown header infra from LibHTTP. So to give these a common denominator, this patch replaces the LibHTTP implementation with Fetch's infra. Our existing LibHTTP implementation was not particularly compliant with any spec, so this at least gives us a standards-based common implementation. This migration also required moving a handful of other Fetch AOs over to LibHTTP. (It turns out these AOs were all from the Fetch/Infra/HTTP folder, so perhaps it makes sense for LibHTTP to be the implementation of that entire set of facilities.)
2025-11-26 16:13:23 -03:00
auto result = HTTP::collect_an_http_quoted_string(lexer);
LibWeb: Return the correct substring when parsing an HTTP quoted string We were off-by-one when returning the result of parsing a quoted string in Web::Fetch::Infrastructure::collect_an_http_quoted_string. Instead of backtracking the lexer and consuming the backtracked string, do a simple substring operation.
2024-03-26 13:13:11 -03:00
EXPECT_EQ(result, "\"abc\""_string);
}
{
auto test = "\"abc\" bar"_string;
GenericLexer lexer { test };
LibHTTP+LibWeb+RequestServer: Move Fetch's HTTP header infra to LibHTTP The end goal here is for LibHTTP to be the home of our RFC 9111 (HTTP caching) implementation. We currently have one implementation in LibWeb for our in-memory cache and another in RequestServer for our disk cache. The implementations both largely revolve around interacting with HTTP headers. But in LibWeb, we are using Fetch's header infra, and in RS we are using are home-grown header infra from LibHTTP. So to give these a common denominator, this patch replaces the LibHTTP implementation with Fetch's infra. Our existing LibHTTP implementation was not particularly compliant with any spec, so this at least gives us a standards-based common implementation. This migration also required moving a handful of other Fetch AOs over to LibHTTP. (It turns out these AOs were all from the Fetch/Infra/HTTP folder, so perhaps it makes sense for LibHTTP to be the implementation of that entire set of facilities.)
2025-11-26 16:13:23 -03:00
auto result = HTTP::collect_an_http_quoted_string(lexer);
LibWeb: Return the correct substring when parsing an HTTP quoted string We were off-by-one when returning the result of parsing a quoted string in Web::Fetch::Infrastructure::collect_an_http_quoted_string. Instead of backtracking the lexer and consuming the backtracked string, do a simple substring operation.
2024-03-26 13:13:11 -03:00
EXPECT_EQ(result, "\"abc\""_string);
}
}
LibHTTP: Implement a strict method to extract Cache-Control directives Our previous implementation was a bit too tolerant of bad header values. For example, extracting a "max-age" from a header value of "abmax-agecd" would have incorrectly parsed successfully. We now find exact (case-insensitive) directive matches. We also handle quoted string values, which may contain important delimeters that we would have previously split on.
2026-01-27 10:10:11 -03:00
TEST_CASE(extract_cache_control_directive)
{
EXPECT(!HTTP::contains_cache_control_directive({}, "no-cache"sv));
EXPECT(!HTTP::contains_cache_control_directive(","sv, "no-cache"sv));
EXPECT(!HTTP::contains_cache_control_directive("no-cache"sv, "no"sv));
EXPECT(!HTTP::contains_cache_control_directive("no-cache"sv, "cache"sv));
EXPECT(!HTTP::contains_cache_control_directive("no-cache"sv, "no cache"sv));
EXPECT(!HTTP::contains_cache_control_directive("abno-cache"sv, "no-cache"sv));
EXPECT(!HTTP::contains_cache_control_directive("no-cachecd"sv, "no-cache"sv));
EXPECT(!HTTP::contains_cache_control_directive("abno-cachecd"sv, "no-cache"sv));
EXPECT_EQ(HTTP::extract_cache_control_directive("no-cache"sv, "no-cache"sv), ""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=4"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age = 4"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age= 4"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age =4"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age = 4 , no-cache"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("no-cache , max-age = 4"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("s-maxage=4, max-age=5"sv, "max-age"sv), "5"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("Max-Age=4"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("MAX-AGE=4"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=4"sv, "MAX-AGE"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("No-Cache"sv, "no-cache"sv), ""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=4,"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("no-cache,"sv, "no-cache"sv), ""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("no-cache, "sv, "no-cache"sv), ""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=4, max-age=5"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("no-cache, max-age=4, max-age=5"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=4, no-cache"sv, "no-cache"sv), ""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=\"4\""sv, "max-age"sv), "\"4\""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=\"004\""sv, "max-age"sv), "\"004\""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=\"4\", no-cache"sv, "max-age"sv), "\"4\""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("foo=\"bar\", max-age=\"4\""sv, "max-age"sv), "\"4\""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=\"4,5\", no-cache"sv, "max-age"sv), "\"4,5\""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=\"4\\5\""sv, "max-age"sv), "\"4\\5\""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=\"4\\\"5\""sv, "max-age"sv), "\"4\\\"5\""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=\"4\\\\5\""sv, "max-age"sv), "\"4\\\\5\""sv);
EXPECT(!HTTP::contains_cache_control_directive("max-age\"4\""sv, "max-age"sv));
EXPECT(!HTTP::contains_cache_control_directive("max-age=\"4"sv, "max-age"sv));
EXPECT(!HTTP::contains_cache_control_directive("foo=\"bar, max-age=4"sv, "max-age"sv));
EXPECT(!HTTP::contains_cache_control_directive("\"unterminated"sv, "max-age"sv));
EXPECT(!HTTP::contains_cache_control_directive("max-age=\"4, no-cache"sv, "max-age"sv));
EXPECT(!HTTP::contains_cache_control_directive("max-age=\"4, no-cache"sv, "no-cache"sv));
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=\"4, no-cache\", foo=bar"sv, "max-age"sv), "\"4, no-cache\""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=\"4, no-cache\", foo=bar"sv, "foo"sv), "bar"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("foo=\"bar,baz\", max-age=4"sv, "foo"sv), "\"bar,baz\""sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("foo=\"bar,baz\", max-age=4"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive(",,max-age=4"sv, "max-age"sv), "4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age==4"sv, "max-age"sv), "=4"sv);
EXPECT_EQ(HTTP::extract_cache_control_directive("max-age=4="sv, "max-age"sv), "4="sv);
EXPECT(!HTTP::contains_cache_control_directive("=4"sv, "max-age"sv));
}
LibHTTP: Parse token-list headers according to their ABNF The previous implementation did not fully align with each headers ABNF, so would not reject some headers as we should have been doing. Fixes 6 WPT subtests for https://wpt.live/cors/access-control-expose-headers-parsing.window.html
2026-02-28 14:36:44 -03:00
LibRegex: Add ECMAScriptRegex and migrate callers Add `ECMAScriptRegex`, LibRegex's C++ facade for ECMAScript regexes. The facade owns compilation, execution, captures, named groups, and error translation for the Rust backend, which lets callers stop depending on the legacy parser and matcher types directly. Use it in the remaining non-LibJS callers: URLPattern, HTML input pattern handling, and the places in LibHTTP that only needed token validation. Where a full regex engine was unnecessary, replace those call sites with direct character checks. Also update focused LibURL, LibHTTP, and WPT coverage for the migrated callers and corrected surrogate handling.
2026-03-25 06:52:20 -03:00
TEST_CASE(token_validation)
{
EXPECT(HTTP::is_method("GET"sv));
EXPECT(HTTP::is_method("PATCH"sv));
EXPECT(HTTP::is_method("M-SEARCH"sv));
EXPECT(!HTTP::is_method(""sv));
EXPECT(!HTTP::is_method("GET "sv));
EXPECT(!HTTP::is_method("GE:T"sv));
EXPECT(HTTP::is_header_name("Content-Type"sv));
EXPECT(HTTP::is_header_name("X-Custom_Header"sv));
EXPECT(!HTTP::is_header_name(""sv));
EXPECT(!HTTP::is_header_name("Content Type"sv));
EXPECT(!HTTP::is_header_name("Content:Type"sv));
}
LibHTTP: Parse token-list headers according to their ABNF The previous implementation did not fully align with each headers ABNF, so would not reject some headers as we should have been doing. Fixes 6 WPT subtests for https://wpt.live/cors/access-control-expose-headers-parsing.window.html
2026-02-28 14:36:44 -03:00
TEST_CASE(extract_header_values)
{
struct TestHeader {
StringView name;
bool requires_at_least_one; // true = 1#token, false = #token
};
TestHeader const headers[] = {
{ "Access-Control-Expose-Headers"sv, false },
{ "access-control-expose-headers"sv, false },
{ "Access-Control-Allow-Headers"sv, false },
{ "Access-Control-Allow-Methods"sv, false },
{ "Access-Control-Request-Headers"sv, true },
{ "Accept-Ranges"sv, true },
};
for (auto const& [header, requires_at_least_one] : headers) {
// Valid single token.
auto result = HTTP::Header { header, "bb-8"sv }.extract_header_values();
EXPECT_EQ(result, (Vector<ByteString> { "bb-8" }));
// Valid multiple tokens, whitespace trimmed.
result = HTTP::Header { header, "bb-8, no"sv }.extract_header_values();
EXPECT_EQ(result, (Vector<ByteString> { "bb-8", "no" }));
// Wildcard is a valid token.
result = HTTP::Header { header, "*"sv }.extract_header_values();
EXPECT_EQ(result, (Vector<ByteString> { "*" }));
// Single-quoted tokens are valid (apostrophe is a tchar).
result = HTTP::Header { header, "'bb-8',bb-8"sv }.extract_header_values();
EXPECT_EQ(result, (Vector<ByteString> { "'bb-8'", "bb-8" }));
// Leading/trailing commas: empty parts discarded.
result = HTTP::Header { header, ",bb-8,"sv }.extract_header_values();
EXPECT_EQ(result, (Vector<ByteString> { "bb-8" }));
// Empty value and only-commas.
result = HTTP::Header { header, ""sv }.extract_header_values();
if (requires_at_least_one) {
EXPECT_EQ(result, OptionalNone {});
} else {
EXPECT_EQ(result, (Vector<ByteString> {}));
}
LibHTTP: Ignore empty list elements when extracting token headers It turns out that the validation of header values in db5f16f042 was a bit over aggressive. extract_token_headers previously treated empty list elements (empty or whitespace-only after trimming) as parse failures. This is incorrect per RFC 9110, which specifies that recipients must ignore empty list elements in comma-separated header values. > A recipient MUST parse and ignore a reasonable number of empty > list elements
2026-03-15 15:39:29 -03:00
// Two commas and some spaces.
result = HTTP::Header { header, ", ,"sv }.extract_header_values();
LibHTTP: Parse token-list headers according to their ABNF The previous implementation did not fully align with each headers ABNF, so would not reject some headers as we should have been doing. Fixes 6 WPT subtests for https://wpt.live/cors/access-control-expose-headers-parsing.window.html
2026-02-28 14:36:44 -03:00
if (requires_at_least_one) {
EXPECT_EQ(result, OptionalNone {});
} else {
EXPECT_EQ(result, (Vector<ByteString> {}));
}
LibHTTP: Ignore empty list elements when extracting token headers It turns out that the validation of header values in db5f16f042 was a bit over aggressive. extract_token_headers previously treated empty list elements (empty or whitespace-only after trimming) as parse failures. This is incorrect per RFC 9110, which specifies that recipients must ignore empty list elements in comma-separated header values. > A recipient MUST parse and ignore a reasonable number of empty > list elements
2026-03-15 15:39:29 -03:00
// Only a comma.
result = HTTP::Header { header, ","sv }.extract_header_values();
if (requires_at_least_one) {
EXPECT_EQ(result, OptionalNone {});
} else {
EXPECT_EQ(result, (Vector<ByteString> {}));
}
// Empty list element ignored.
result = HTTP::Header { header, "foo , ,bar,charlie"sv }.extract_header_values();
EXPECT_EQ(result, (Vector<ByteString> { "foo", "bar", "charlie" }));
// Leading empty list component.
result = HTTP::Header { header, ",foo,bar"sv }.extract_header_values();
EXPECT_EQ(result, (Vector<ByteString> { "foo", "bar" }));
LibHTTP: Parse token-list headers according to their ABNF The previous implementation did not fully align with each headers ABNF, so would not reject some headers as we should have been doing. Fixes 6 WPT subtests for https://wpt.live/cors/access-control-expose-headers-parsing.window.html
2026-02-28 14:36:44 -03:00
// Space inside a token is invalid.
result = HTTP::Header { header, "no no"sv }.extract_header_values();
EXPECT_EQ(result, OptionalNone {});
// Double-quote is invalid.
result = HTTP::Header { header, "\"bb-8\",bb-8"sv }.extract_header_values();
EXPECT_EQ(result, OptionalNone {});
// @ is invalid.
result = HTTP::Header { header, "@invalid,bb-8"sv }.extract_header_values();
EXPECT_EQ(result, OptionalNone {});
// Vertical tab (0x0B) is invalid.
result = HTTP::Header { header, "bb-8\x0B"sv }.extract_header_values();
EXPECT_EQ(result, OptionalNone {});
// Form feed (0x0C) is invalid.
result = HTTP::Header { header, "bb-8\x0C"sv }.extract_header_values();
EXPECT_EQ(result, OptionalNone {});
// Invalid token alongside a valid one still fails.
result = HTTP::Header { header, "bb-8,no no"sv }.extract_header_values();
EXPECT_EQ(result, OptionalNone {});
LibHTTP: Ignore empty list elements when extracting token headers It turns out that the validation of header values in db5f16f042 was a bit over aggressive. extract_token_headers previously treated empty list elements (empty or whitespace-only after trimming) as parse failures. This is incorrect per RFC 9110, which specifies that recipients must ignore empty list elements in comma-separated header values. > A recipient MUST parse and ignore a reasonable number of empty > list elements
2026-03-15 15:39:29 -03:00
// Whitespace-only item is ignored.
LibHTTP: Parse token-list headers according to their ABNF The previous implementation did not fully align with each headers ABNF, so would not reject some headers as we should have been doing. Fixes 6 WPT subtests for https://wpt.live/cors/access-control-expose-headers-parsing.window.html
2026-02-28 14:36:44 -03:00
result = HTTP::Header { header, "bb-8, ,no"sv }.extract_header_values();
LibHTTP: Ignore empty list elements when extracting token headers It turns out that the validation of header values in db5f16f042 was a bit over aggressive. extract_token_headers previously treated empty list elements (empty or whitespace-only after trimming) as parse failures. This is incorrect per RFC 9110, which specifies that recipients must ignore empty list elements in comma-separated header values. > A recipient MUST parse and ignore a reasonable number of empty > list elements
2026-03-15 15:39:29 -03:00
EXPECT_EQ(result, (Vector<ByteString> { "bb-8", "no" }));
LibHTTP: Parse token-list headers according to their ABNF The previous implementation did not fully align with each headers ABNF, so would not reject some headers as we should have been doing. Fixes 6 WPT subtests for https://wpt.live/cors/access-control-expose-headers-parsing.window.html
2026-02-28 14:36:44 -03:00
}
// Other headers: returned as a single-element list regardless of content.
auto result = HTTP::Header { "Content-Type"sv, "text/html; charset=utf-8"sv }.extract_header_values();
EXPECT_EQ(result, (Vector<ByteString> { "text/html; charset=utf-8" }));
}
Reference in a new issue Copy permalink