nghttp2/nghttp2
1
0
Fork 0
mirror of https://github.com/nghttp2/nghttp2.git synced 2025-12-06 18:18:52 +08:00
Code Issues Projects Releases Wiki Activity

Merge pull request #2420 from nghttp2/nghttpx-ranges-part4

Browse Source 
Nghttpx ranges part4
This commit is contained in:
Tatsuhiro Tsujikawa
2025-05-24 18:40:33 +09:00
committed by GitHub
parent 34b18758cb c3574b711d
commit 3ed14f2b38
8 changed files with 48 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/buffer_test.cc
View File

@@ -56,13 +56,13 @@ void test_buffer_write(void) {
assert_size(3, ==, b.rleft());
assert_size(13, ==, b.wleft());
assert_ptr_equal(b.pos, std::begin(b.buf));
assert_ptr_equal(b.pos, std::ranges::begin(b.buf));
b.drain(3);
assert_size(0, ==, b.rleft());
assert_size(13, ==, b.wleft());
assert_ptrdiff(3, ==, b.pos - std::begin(b.buf));
assert_ptrdiff(3, ==, b.pos - std::ranges::begin(b.buf));
auto n = b.write("0123456789ABCDEF", 16);
@@ -70,20 +70,20 @@ void test_buffer_write(void) {
assert_size(13, ==, b.rleft());
assert_size(0, ==, b.wleft());
assert_ptrdiff(3, ==, b.pos - std::begin(b.buf));
assert_ptrdiff(3, ==, b.pos - std::ranges::begin(b.buf));
assert_memory_equal(13, b.pos, "0123456789ABC");
b.reset();
assert_size(0, ==, b.rleft());
assert_size(16, ==, b.wleft());
assert_ptr_equal(b.pos, std::begin(b.buf));
assert_ptr_equal(b.pos, std::ranges::begin(b.buf));
b.write(5);
assert_size(5, ==, b.rleft());
assert_size(11, ==, b.wleft());
assert_ptr_equal(b.pos, std::begin(b.buf));
assert_ptr_equal(b.pos, std::ranges::begin(b.buf));
}
} // namespace nghttp2

10
src/shrpx_config.cc
View File

@@ -755,7 +755,7 @@ std::vector<LogFragment> parse_log_format(BlockAllocator &balloc,
var_name = StringRef{var_name_start, p};
}
auto value = std::begin(var_name);
auto value = std::ranges::begin(var_name);
auto type = log_var_lookup_token(var_name);
@@ -1250,10 +1250,10 @@ int parse_mapping(Config *config, DownstreamAddrConfig &addr,
auto path = http2::normalize_path_colon(
downstreamconf.balloc, StringRef{slash, std::ranges::end(raw_pattern)},
StringRef{});
auto iov =
make_byte_ref(downstreamconf.balloc,
std::ranges::distance(std::begin(raw_pattern), slash) +
path.size() + 1);
auto iov = make_byte_ref(
downstreamconf.balloc,
std::ranges::distance(std::ranges::begin(raw_pattern), slash) +
path.size() + 1);
auto p = util::tolower(std::ranges::begin(raw_pattern), slash,
std::ranges::begin(iov));
p = std::ranges::copy(path, p).out;

52
src/shrpx_config_test.cc
View File

@@ -196,25 +196,19 @@ void test_shrpx_config_read_tls_ticket_key_file(void) {
assert_not_null(ticket_keys.get());
assert_size(2, ==, ticket_keys->keys.size());
auto key = &ticket_keys->keys[0];
assert_true(std::equal(std::begin(key->data.name), std::end(key->data.name),
"0..............1"));
assert_true(std::equal(std::begin(key->data.enc_key),
std::begin(key->data.enc_key) + 16,
"2..............3"));
assert_true(std::equal(std::begin(key->data.hmac_key),
std::begin(key->data.hmac_key) + 16,
"4..............5"));
assert_true(std::ranges::equal(key->data.name, "0..............1"sv));
assert_true(std::ranges::equal(std::span{key->data.enc_key}.first(16),
"2..............3"sv));
assert_true(std::ranges::equal(std::span{key->data.hmac_key}.first(16),
"4..............5"sv));
assert_size(16, ==, key->hmac_keylen);
key = &ticket_keys->keys[1];
assert_true(std::equal(std::begin(key->data.name), std::end(key->data.name),
"6..............7"));
assert_true(std::equal(std::begin(key->data.enc_key),
std::begin(key->data.enc_key) + 16,
"8..............9"));
assert_true(std::equal(std::begin(key->data.hmac_key),
std::begin(key->data.hmac_key) + 16,
"a..............b"));
assert_true(std::ranges::equal(key->data.name, "6..............7"sv));
assert_true(std::ranges::equal(std::span{key->data.enc_key}.first(16),
"8..............9"sv));
assert_true(std::ranges::equal(std::span{key->data.hmac_key}.first(16),
"a..............b"sv));
assert_size(16, ==, key->hmac_keylen);
}
@@ -245,24 +239,18 @@ void test_shrpx_config_read_tls_ticket_key_file_aes_256(void) {
assert_not_null(ticket_keys.get());
assert_size(2, ==, ticket_keys->keys.size());
auto key = &ticket_keys->keys[0];
assert_true(std::equal(std::begin(key->data.name), std::end(key->data.name),
"0..............1"));
assert_true(std::equal(std::begin(key->data.enc_key),
std::end(key->data.enc_key),
"2..............................3"));
assert_true(std::equal(std::begin(key->data.hmac_key),
std::end(key->data.hmac_key),
"4..............................5"));
assert_true(std::ranges::equal(key->data.name, "0..............1"sv));
assert_true(std::ranges::equal(key->data.enc_key,
"2..............................3"sv));
assert_true(std::ranges::equal(key->data.hmac_key,
"4..............................5"sv));
key = &ticket_keys->keys[1];
assert_true(std::equal(std::begin(key->data.name), std::end(key->data.name),
"6..............7"));
assert_true(std::equal(std::begin(key->data.enc_key),
std::end(key->data.enc_key),
"8..............................9"));
assert_true(std::equal(std::begin(key->data.hmac_key),
std::end(key->data.hmac_key),
"a..............................b"));
assert_true(std::ranges::equal(key->data.name, "6..............7"sv));
assert_true(std::ranges::equal(key->data.enc_key,
"8..............................9"sv));
assert_true(std::ranges::equal(key->data.hmac_key,
"a..............................b"sv));
}
} // namespace shrpx

12
src/shrpx_http_test.cc
View File

@@ -90,15 +90,17 @@ void test_shrpx_http_create_forwarded(void) {
void test_shrpx_http_create_via_header_value(void) {
std::array<char, 16> buf;
auto end = http::create_via_header_value(std::begin(buf), 1, 1);
auto end = http::create_via_header_value(std::ranges::begin(buf), 1, 1);
assert_stdstring_equal("1.1 nghttpx", (std::string{std::begin(buf), end}));
assert_stdstring_equal("1.1 nghttpx",
(std::string{std::ranges::begin(buf), end}));
std::fill(std::begin(buf), std::end(buf), '\0');
std::ranges::fill(buf, '\0');
end = http::create_via_header_value(std::begin(buf), 2, 0);
end = http::create_via_header_value(std::ranges::begin(buf), 2, 0);
assert_stdstring_equal("2 nghttpx", (std::string{std::begin(buf), end}));
assert_stdstring_equal("2 nghttpx",
(std::string{std::ranges::begin(buf), end}));
}
void test_shrpx_http_create_affinity_cookie(void) {

2
src/shrpx_worker.h
View File

@@ -278,7 +278,7 @@ struct QUICPacket {
remote_addr{remote_addr},
local_addr{local_addr},
pi{pi},
data{std::begin(data), std::end(data)} {}
data{std::ranges::begin(data), std::ranges::end(data)} {}
QUICPacket() : upstream_addr_index{}, remote_addr{}, local_addr{}, pi{} {}
size_t upstream_addr_index;
Address remote_addr;

2
src/siphash.cc
View File

@@ -95,7 +95,7 @@ uint64_t siphash24(std::span<const uint64_t, 2> key,
}
std::array<uint8_t, sizeof(uint64_t)> last_block{};
std::ranges::copy(input, std::begin(last_block));
std::ranges::copy(input, std::ranges::begin(last_block));
last_block.back() = orig_input_len & 0xff;
auto last_block_word = CRYPTO_load_u64_le(last_block);

4
src/siphash_test.cc
View File

@@ -49,7 +49,7 @@ const MunitSuite siphash_suite{
void test_siphash(void) {
std::array<uint8_t, 16> key_bytes;
std::iota(std::begin(key_bytes), std::end(key_bytes), 0);
std::iota(std::ranges::begin(key_bytes), std::ranges::end(key_bytes), 0);
std::array<uint64_t, 2> key;
memcpy(key.data(), key_bytes.data(), key_bytes.size());
@@ -60,7 +60,7 @@ void test_siphash(void) {
}
std::array<uint8_t, 15> input;
std::iota(std::begin(input), std::end(input), 0);
std::iota(std::ranges::begin(input), std::ranges::end(input), 0);
assert_uint64(0xa129ca6149be45e5ull, ==, siphash24(key, input));
}

13
src/util_test.cc
View File

@@ -222,8 +222,8 @@ void test_util_percent_encode_token(void) {
void test_util_percent_decode(void) {
{
std::string s = "%66%6F%6f%62%61%72";
assert_stdstring_equal("foobar",
util::percent_decode(std::begin(s), std::end(s)));
assert_stdstring_equal("foobar", util::percent_decode(std::ranges::begin(s),
std::ranges::end(s)));
}
{
std::string s = "%66%6";
@@ -231,8 +231,8 @@ void test_util_percent_decode(void) {
}
{
std::string s = "%66%";
assert_stdstring_equal("f%",
util::percent_decode(std::begin(s), std::end(s)));
assert_stdstring_equal(
"f%", util::percent_decode(std::ranges::begin(s), std::ranges::end(s)));
}
BlockAllocator balloc(1024, 1024);
@@ -828,9 +828,10 @@ void test_util_random_alpha_digit(void) {
std::mt19937 gen(rd());
std::array<uint8_t, 19> data;
auto p = util::random_alpha_digit(std::begin(data), std::end(data), gen);
auto p = util::random_alpha_digit(std::ranges::begin(data),
std::ranges::end(data), gen);
assert_true(std::end(data) == p);
assert_true(std::ranges::end(data) == p);
for (auto b : data) {
assert_true(('A' <= b && b <= 'Z') || ('a' <= b && b <= 'z') ||