blob: df8c0367b463802fb0a28bd1e75650285b60ef99 [file] [log] [blame]
#include "quiche/binary_http/binary_http_message.h"
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
#include "absl/container/flat_hash_map.h"
#include "quiche/common/platform/api/quiche_test.h"
using ::testing::ContainerEq;
using ::testing::FieldsAre;
using ::testing::StrEq;
namespace quiche {
namespace {
std::string WordToBytes(uint32_t word) {
return std::string({static_cast<char>(word >> 24),
static_cast<char>(word >> 16),
static_cast<char>(word >> 8), static_cast<char>(word)});
}
template <class T>
void TestPrintTo(const T& resp) {
std::ostringstream os;
PrintTo(resp, &os);
EXPECT_EQ(os.str(), resp.DebugString());
}
} // namespace
// Test examples from
// https://www.ietf.org/archive/id/draft-ietf-httpbis-binary-message-06.html
TEST(BinaryHttpRequest, EncodeGetNoBody) {
/*
GET /hello.txt HTTP/1.1
User-Agent: curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3
Host: www.example.com
Accept-Language: en, mi
*/
BinaryHttpRequest request({"GET", "https", "www.example.com", "/hello.txt"});
request
.AddHeaderField({"User-Agent",
"curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3"})
->AddHeaderField({"Host", "www.example.com"})
->AddHeaderField({"Accept-Language", "en, mi"});
/*
00000000: 00034745 54056874 74707300 0a2f6865 ..GET.https../he
00000010: 6c6c6f2e 74787440 6c0a7573 65722d61 llo.txt@l.user-a
00000020: 67656e74 34637572 6c2f372e 31362e33 gent4curl/7.16.3
00000030: 206c6962 6375726c 2f372e31 362e3320 libcurl/7.16.3
00000040: 4f70656e 53534c2f 302e392e 376c207a OpenSSL/0.9.7l z
00000050: 6c69622f 312e322e 3304686f 73740f77 lib/1.2.3.host.w
00000060: 77772e65 78616d70 6c652e63 6f6d0f61 ww.example.com.a
00000070: 63636570 742d6c61 6e677561 67650665 ccept-language.e
00000080: 6e2c206d 6900 n, mi..
*/
const uint32_t expected_words[] = {
0x00034745, 0x54056874, 0x74707300, 0x0a2f6865, 0x6c6c6f2e, 0x74787440,
0x6c0a7573, 0x65722d61, 0x67656e74, 0x34637572, 0x6c2f372e, 0x31362e33,
0x206c6962, 0x6375726c, 0x2f372e31, 0x362e3320, 0x4f70656e, 0x53534c2f,
0x302e392e, 0x376c207a, 0x6c69622f, 0x312e322e, 0x3304686f, 0x73740f77,
0x77772e65, 0x78616d70, 0x6c652e63, 0x6f6d0f61, 0x63636570, 0x742d6c61,
0x6e677561, 0x67650665, 0x6e2c206d, 0x69000000};
std::string expected;
for (const auto& word : expected_words) {
expected += WordToBytes(word);
}
// Remove padding.
expected.resize(expected.size() - 2);
const auto result = request.Serialize();
ASSERT_TRUE(result.ok());
ASSERT_EQ(*result, expected);
EXPECT_THAT(
request.DebugString(),
StrEq("BinaryHttpRequest{BinaryHttpMessage{Headers{Field{user-agent=curl/"
"7.16.3 "
"libcurl/7.16.3 OpenSSL/0.9.7l "
"zlib/1.2.3};Field{host=www.example.com};Field{accept-language=en, "
"mi}}Body{}}}"));
TestPrintTo(request);
}
TEST(BinaryHttpRequest, DecodeGetNoBody) {
const uint32_t words[] = {
0x00034745, 0x54056874, 0x74707300, 0x0a2f6865, 0x6c6c6f2e, 0x74787440,
0x6c0a7573, 0x65722d61, 0x67656e74, 0x34637572, 0x6c2f372e, 0x31362e33,
0x206c6962, 0x6375726c, 0x2f372e31, 0x362e3320, 0x4f70656e, 0x53534c2f,
0x302e392e, 0x376c207a, 0x6c69622f, 0x312e322e, 0x3304686f, 0x73740f77,
0x77772e65, 0x78616d70, 0x6c652e63, 0x6f6d0f61, 0x63636570, 0x742d6c61,
0x6e677561, 0x67650665, 0x6e2c206d, 0x69000000};
std::string data;
for (const auto& word : words) {
data += WordToBytes(word);
}
const auto request_so = BinaryHttpRequest::Create(data);
ASSERT_TRUE(request_so.ok());
const BinaryHttpRequest request = *request_so;
ASSERT_THAT(request.control_data(),
FieldsAre("GET", "https", "", "/hello.txt"));
std::vector<BinaryHttpMessage::Field> expected_fields = {
{"user-agent", "curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3"},
{"host", "www.example.com"},
{"accept-language", "en, mi"}};
for (const auto& field : expected_fields) {
TestPrintTo(field);
}
ASSERT_THAT(request.GetHeaderFields(), ContainerEq(expected_fields));
ASSERT_EQ(request.body(), "");
EXPECT_THAT(
request.DebugString(),
StrEq("BinaryHttpRequest{BinaryHttpMessage{Headers{Field{user-agent=curl/"
"7.16.3 "
"libcurl/7.16.3 OpenSSL/0.9.7l "
"zlib/1.2.3};Field{host=www.example.com};Field{accept-language=en, "
"mi}}Body{}}}"));
TestPrintTo(request);
}
TEST(BinaryHttpRequest, EncodeGetWithAuthority) {
/*
GET https://www.example.com/hello.txt HTTP/1.1
User-Agent: curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3
Accept-Language: en, mi
*/
BinaryHttpRequest request({"GET", "https", "www.example.com", "/hello.txt"});
request
.AddHeaderField({"User-Agent",
"curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3"})
->AddHeaderField({"Accept-Language", "en, mi"});
/*
00000000: 00034745 54056874 7470730f 7777772e ..GET.https.www.
00000010: 6578616d 706c652e 636f6d0a 2f68656c example.com./hel
00000020: 6c6f2e74 78744057 0a757365 722d6167 lo.txt@W.user-ag
00000030: 656e7434 6375726c 2f372e31 362e3320 ent4curl/7.16.3
00000040: 6c696263 75726c2f 372e3136 2e33204f libcurl/7.16.3 O
00000050: 70656e53 534c2f30 2e392e37 6c207a6c penSSL/0.9.7l zl
00000060: 69622f31 2e322e33 0f616363 6570742d ib/1.2.3.accept-
00000070: 6c616e67 75616765 06656e2c 206d6900 language.en, mi.
*/
const uint32_t expected_words[] = {
0x00034745, 0x54056874, 0x7470730f, 0x7777772e, 0x6578616d, 0x706c652e,
0x636f6d0a, 0x2f68656c, 0x6c6f2e74, 0x78744057, 0x0a757365, 0x722d6167,
0x656e7434, 0x6375726c, 0x2f372e31, 0x362e3320, 0x6c696263, 0x75726c2f,
0x372e3136, 0x2e33204f, 0x70656e53, 0x534c2f30, 0x2e392e37, 0x6c207a6c,
0x69622f31, 0x2e322e33, 0x0f616363, 0x6570742d, 0x6c616e67, 0x75616765,
0x06656e2c, 0x206d6900};
std::string expected;
for (const auto& word : expected_words) {
expected += WordToBytes(word);
}
const auto result = request.Serialize();
ASSERT_TRUE(result.ok());
ASSERT_EQ(*result, expected);
EXPECT_THAT(
request.DebugString(),
StrEq("BinaryHttpRequest{BinaryHttpMessage{Headers{Field{user-agent=curl/"
"7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l "
"zlib/1.2.3};Field{accept-language=en, mi}}Body{}}}"));
}
TEST(BinaryHttpRequest, DecodeGetWithAuthority) {
const uint32_t words[] = {
0x00034745, 0x54056874, 0x7470730f, 0x7777772e, 0x6578616d, 0x706c652e,
0x636f6d0a, 0x2f68656c, 0x6c6f2e74, 0x78744057, 0x0a757365, 0x722d6167,
0x656e7434, 0x6375726c, 0x2f372e31, 0x362e3320, 0x6c696263, 0x75726c2f,
0x372e3136, 0x2e33204f, 0x70656e53, 0x534c2f30, 0x2e392e37, 0x6c207a6c,
0x69622f31, 0x2e322e33, 0x0f616363, 0x6570742d, 0x6c616e67, 0x75616765,
0x06656e2c, 0x206d6900, 0x00};
std::string data;
for (const auto& word : words) {
data += WordToBytes(word);
}
const auto request_so = BinaryHttpRequest::Create(data);
ASSERT_TRUE(request_so.ok());
const BinaryHttpRequest request = *request_so;
ASSERT_THAT(request.control_data(),
FieldsAre("GET", "https", "www.example.com", "/hello.txt"));
std::vector<BinaryHttpMessage::Field> expected_fields = {
{"user-agent", "curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3"},
{"accept-language", "en, mi"}};
ASSERT_THAT(request.GetHeaderFields(), ContainerEq(expected_fields));
ASSERT_EQ(request.body(), "");
EXPECT_THAT(
request.DebugString(),
StrEq("BinaryHttpRequest{BinaryHttpMessage{Headers{Field{user-agent=curl/"
"7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l "
"zlib/1.2.3};Field{accept-language=en, mi}}Body{}}}"));
}
TEST(BinaryHttpRequest, EncodePostBody) {
/*
POST /hello.txt HTTP/1.1
User-Agent: not/telling
Host: www.example.com
Accept-Language: en
Some body that I used to post.
*/
BinaryHttpRequest request({"POST", "https", "www.example.com", "/hello.txt"});
request.AddHeaderField({"User-Agent", "not/telling"})
->AddHeaderField({"Host", "www.example.com"})
->AddHeaderField({"Accept-Language", "en"})
->set_body({"Some body that I used to post.\r\n"});
/*
00000000: 0004504f 53540568 74747073 000a2f68 ..POST.https../h
00000010: 656c6c6f 2e747874 3f0a7573 65722d61 ello.txt?.user-a
00000020: 67656e74 0b6e6f74 2f74656c 6c696e67 gent.not/telling
00000030: 04686f73 740f7777 772e6578 616d706c .host.www.exampl
00000040: 652e636f 6d0f6163 63657074 2d6c616e e.com.accept-lan
00000050: 67756167 6502656e 20536f6d 6520626f guage.en Some bo
00000060: 64792074 68617420 49207573 65642074 dy that I used t
00000070: 6f20706f 73742e0d 0a o post....
*/
const uint32_t expected_words[] = {
0x0004504f, 0x53540568, 0x74747073, 0x000a2f68, 0x656c6c6f, 0x2e747874,
0x3f0a7573, 0x65722d61, 0x67656e74, 0x0b6e6f74, 0x2f74656c, 0x6c696e67,
0x04686f73, 0x740f7777, 0x772e6578, 0x616d706c, 0x652e636f, 0x6d0f6163,
0x63657074, 0x2d6c616e, 0x67756167, 0x6502656e, 0x20536f6d, 0x6520626f,
0x64792074, 0x68617420, 0x49207573, 0x65642074, 0x6f20706f, 0x73742e0d,
0x0a000000};
std::string expected;
for (const auto& word : expected_words) {
expected += WordToBytes(word);
}
// Remove padding.
expected.resize(expected.size() - 3);
const auto result = request.Serialize();
ASSERT_TRUE(result.ok());
ASSERT_EQ(*result, expected);
EXPECT_THAT(
request.DebugString(),
StrEq("BinaryHttpRequest{BinaryHttpMessage{Headers{Field{user-agent=not/"
"telling};Field{host=www.example.com};Field{accept-language=en}}"
"Body{Some "
"body that I used to post.\r\n}}}"));
}
TEST(BinaryHttpRequest, DecodePostBody) {
const uint32_t words[] = {
0x0004504f, 0x53540568, 0x74747073, 0x000a2f68, 0x656c6c6f, 0x2e747874,
0x3f0a7573, 0x65722d61, 0x67656e74, 0x0b6e6f74, 0x2f74656c, 0x6c696e67,
0x04686f73, 0x740f7777, 0x772e6578, 0x616d706c, 0x652e636f, 0x6d0f6163,
0x63657074, 0x2d6c616e, 0x67756167, 0x6502656e, 0x20536f6d, 0x6520626f,
0x64792074, 0x68617420, 0x49207573, 0x65642074, 0x6f20706f, 0x73742e0d,
0x0a000000};
std::string data;
for (const auto& word : words) {
data += WordToBytes(word);
}
const auto request_so = BinaryHttpRequest::Create(data);
ASSERT_TRUE(request_so.ok());
BinaryHttpRequest request = *request_so;
ASSERT_THAT(request.control_data(),
FieldsAre("POST", "https", "", "/hello.txt"));
std::vector<BinaryHttpMessage::Field> expected_fields = {
{"user-agent", "not/telling"},
{"host", "www.example.com"},
{"accept-language", "en"}};
ASSERT_THAT(request.GetHeaderFields(), ContainerEq(expected_fields));
ASSERT_EQ(request.body(), "Some body that I used to post.\r\n");
EXPECT_THAT(
request.DebugString(),
StrEq("BinaryHttpRequest{BinaryHttpMessage{Headers{Field{user-agent=not/"
"telling};Field{host=www.example.com};Field{accept-language=en}}"
"Body{Some "
"body that I used to post.\r\n}}}"));
}
TEST(BinaryHttpRequest, Equality) {
BinaryHttpRequest request({"POST", "https", "www.example.com", "/hello.txt"});
request.AddHeaderField({"User-Agent", "not/telling"})
->set_body({"hello, world!\r\n"});
BinaryHttpRequest same({"POST", "https", "www.example.com", "/hello.txt"});
same.AddHeaderField({"User-Agent", "not/telling"})
->set_body({"hello, world!\r\n"});
EXPECT_EQ(request, same);
}
TEST(BinaryHttpRequest, Inequality) {
BinaryHttpRequest request({"POST", "https", "www.example.com", "/hello.txt"});
request.AddHeaderField({"User-Agent", "not/telling"})
->set_body({"hello, world!\r\n"});
BinaryHttpRequest different_control(
{"PUT", "https", "www.example.com", "/hello.txt"});
different_control.AddHeaderField({"User-Agent", "not/telling"})
->set_body({"hello, world!\r\n"});
EXPECT_NE(request, different_control);
BinaryHttpRequest different_header(
{"PUT", "https", "www.example.com", "/hello.txt"});
different_header.AddHeaderField({"User-Agent", "told/you"})
->set_body({"hello, world!\r\n"});
EXPECT_NE(request, different_header);
BinaryHttpRequest no_header(
{"PUT", "https", "www.example.com", "/hello.txt"});
no_header.set_body({"hello, world!\r\n"});
EXPECT_NE(request, no_header);
BinaryHttpRequest different_body(
{"POST", "https", "www.example.com", "/hello.txt"});
different_body.AddHeaderField({"User-Agent", "not/telling"})
->set_body({"goodbye, world!\r\n"});
EXPECT_NE(request, different_body);
BinaryHttpRequest no_body({"POST", "https", "www.example.com", "/hello.txt"});
no_body.AddHeaderField({"User-Agent", "not/telling"});
EXPECT_NE(request, no_body);
}
TEST(BinaryHttpResponse, EncodeNoBody) {
/*
HTTP/1.1 404 Not Found
Server: Apache
*/
BinaryHttpResponse response(404);
response.AddHeaderField({"Server", "Apache"});
/*
0141940e 06736572 76657206 41706163 .A...server.Apac
686500 he..
*/
const uint32_t expected_words[] = {0x0141940e, 0x06736572, 0x76657206,
0x41706163, 0x68650000};
std::string expected;
for (const auto& word : expected_words) {
expected += WordToBytes(word);
}
// Remove padding.
expected.resize(expected.size() - 1);
const auto result = response.Serialize();
ASSERT_TRUE(result.ok());
ASSERT_EQ(*result, expected);
EXPECT_THAT(
response.DebugString(),
StrEq("BinaryHttpResponse(404){BinaryHttpMessage{Headers{Field{server="
"Apache}}Body{}}}"));
}
TEST(BinaryHttpResponse, DecodeNoBody) {
/*
HTTP/1.1 404 Not Found
Server: Apache
*/
const uint32_t words[] = {0x0141940e, 0x06736572, 0x76657206, 0x41706163,
0x68650000};
std::string data;
for (const auto& word : words) {
data += WordToBytes(word);
}
const auto response_so = BinaryHttpResponse::Create(data);
ASSERT_TRUE(response_so.ok());
const BinaryHttpResponse response = *response_so;
ASSERT_EQ(response.status_code(), 404);
std::vector<BinaryHttpMessage::Field> expected_fields = {
{"server", "Apache"}};
ASSERT_THAT(response.GetHeaderFields(), ContainerEq(expected_fields));
ASSERT_EQ(response.body(), "");
ASSERT_TRUE(response.informational_responses().empty());
EXPECT_THAT(
response.DebugString(),
StrEq("BinaryHttpResponse(404){BinaryHttpMessage{Headers{Field{server="
"Apache}}Body{}}}"));
}
TEST(BinaryHttpResponse, EncodeBody) {
/*
HTTP/1.1 200 OK
Server: Apache
Hello, world!
*/
BinaryHttpResponse response(200);
response.AddHeaderField({"Server", "Apache"});
response.set_body("Hello, world!\r\n");
/*
0140c80e 06736572 76657206 41706163 .@...server.Apac
68650f48 656c6c6f 2c20776f 726c6421 he.Hello, world!
0d0a ....
*/
const uint32_t expected_words[] = {0x0140c80e, 0x06736572, 0x76657206,
0x41706163, 0x68650f48, 0x656c6c6f,
0x2c20776f, 0x726c6421, 0x0d0a0000};
std::string expected;
for (const auto& word : expected_words) {
expected += WordToBytes(word);
}
// Remove padding.
expected.resize(expected.size() - 2);
const auto result = response.Serialize();
ASSERT_TRUE(result.ok());
ASSERT_EQ(*result, expected);
EXPECT_THAT(
response.DebugString(),
StrEq("BinaryHttpResponse(200){BinaryHttpMessage{Headers{Field{server="
"Apache}}Body{Hello, world!\r\n}}}"));
}
TEST(BinaryHttpResponse, DecodeBody) {
/*
HTTP/1.1 200 OK
Hello, world!
*/
const uint32_t words[] = {0x0140c80e, 0x06736572, 0x76657206,
0x41706163, 0x68650f48, 0x656c6c6f,
0x2c20776f, 0x726c6421, 0x0d0a0000};
std::string data;
for (const auto& word : words) {
data += WordToBytes(word);
}
const auto response_so = BinaryHttpResponse::Create(data);
ASSERT_TRUE(response_so.ok());
const BinaryHttpResponse response = *response_so;
ASSERT_EQ(response.status_code(), 200);
std::vector<BinaryHttpMessage::Field> expected_fields = {
{"server", "Apache"}};
ASSERT_THAT(response.GetHeaderFields(), ContainerEq(expected_fields));
ASSERT_EQ(response.body(), "Hello, world!\r\n");
ASSERT_TRUE(response.informational_responses().empty());
EXPECT_THAT(
response.DebugString(),
StrEq("BinaryHttpResponse(200){BinaryHttpMessage{Headers{Field{server="
"Apache}}Body{Hello, world!\r\n}}}"));
}
TEST(BHttpResponse, AddBadInformationalResponseCode) {
BinaryHttpResponse response(200);
ASSERT_FALSE(response.AddInformationalResponse(50, {}).ok());
ASSERT_FALSE(response.AddInformationalResponse(300, {}).ok());
}
TEST(BinaryHttpResponse, EncodeMultiInformationalWithBody) {
/*
HTTP/1.1 102 Processing
Running: "sleep 15"
HTTP/1.1 103 Early Hints
Link: </style.css>; rel=preload; as=style
Link: </script.js>; rel=preload; as=script
HTTP/1.1 200 OK
Date: Mon, 27 Jul 2009 12:28:53 GMT
Server: Apache
Last-Modified: Wed, 22 Jul 2009 19:15:56 GMT
ETag: "34aa387-d-1568eb00"
Accept-Ranges: bytes
Content-Length: 51
Vary: Accept-Encoding
Content-Type: text/plain
Hello World! My content includes a trailing CRLF.
*/
BinaryHttpResponse response(200);
response.AddHeaderField({"Date", "Mon, 27 Jul 2009 12:28:53 GMT"})
->AddHeaderField({"Server", "Apache"})
->AddHeaderField({"Last-Modified", "Wed, 22 Jul 2009 19:15:56 GMT"})
->AddHeaderField({"ETag", "\"34aa387-d-1568eb00\""})
->AddHeaderField({"Accept-Ranges", "bytes"})
->AddHeaderField({"Content-Length", "51"})
->AddHeaderField({"Vary", "Accept-Encoding"})
->AddHeaderField({"Content-Type", "text/plain"});
response.set_body("Hello World! My content includes a trailing CRLF.\r\n");
ASSERT_TRUE(
response.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}})
.ok());
ASSERT_TRUE(response
.AddInformationalResponse(
103, {{"Link", "</style.css>; rel=preload; as=style"},
{"Link", "</script.js>; rel=preload; as=script"}})
.ok());
/*
01406613 0772756e 6e696e67 0a22736c .@f..running."sl
65657020 31352240 67405304 6c696e6b eep 15"@g@S.link
233c2f73 74796c65 2e637373 3e3b2072 #</style.css>; r
656c3d70 72656c6f 61643b20 61733d73 el=preload; as=s
74796c65 046c696e 6b243c2f 73637269 tyle.link$</scri
70742e6a 733e3b20 72656c3d 7072656c pt.js>; rel=prel
6f61643b 2061733d 73637269 707440c8 oad; as=script@.
40ca0464 6174651d 4d6f6e2c 20323720 @..date.Mon, 27
4a756c20 32303039 2031323a 32383a35 Jul 2009 12:28:5
3320474d 54067365 72766572 06417061 3 GMT.server.Apa
6368650d 6c617374 2d6d6f64 69666965 che.last-modifie
641d5765 642c2032 32204a75 6c203230 d.Wed, 22 Jul 20
30392031 393a3135 3a353620 474d5404 09 19:15:56 GMT.
65746167 14223334 61613338 372d642d etag."34aa387-d-
31353638 65623030 220d6163 63657074 1568eb00".accept
2d72616e 67657305 62797465 730e636f -ranges.bytes.co
6e74656e 742d6c65 6e677468 02353104 ntent-length.51.
76617279 0f416363 6570742d 456e636f vary.Accept-Enco
64696e67 0c636f6e 74656e74 2d747970 ding.content-typ
650a7465 78742f70 6c61696e 3348656c e.text/plain3Hel
6c6f2057 6f726c64 21204d79 20636f6e lo World! My con
74656e74 20696e63 6c756465 73206120 tent includes a
74726169 6c696e67 2043524c 462e0d0a trailing CRLF...
*/
const uint32_t expected_words[] = {
0x01406613, 0x0772756e, 0x6e696e67, 0x0a22736c, 0x65657020, 0x31352240,
0x67405304, 0x6c696e6b, 0x233c2f73, 0x74796c65, 0x2e637373, 0x3e3b2072,
0x656c3d70, 0x72656c6f, 0x61643b20, 0x61733d73, 0x74796c65, 0x046c696e,
0x6b243c2f, 0x73637269, 0x70742e6a, 0x733e3b20, 0x72656c3d, 0x7072656c,
0x6f61643b, 0x2061733d, 0x73637269, 0x707440c8, 0x40ca0464, 0x6174651d,
0x4d6f6e2c, 0x20323720, 0x4a756c20, 0x32303039, 0x2031323a, 0x32383a35,
0x3320474d, 0x54067365, 0x72766572, 0x06417061, 0x6368650d, 0x6c617374,
0x2d6d6f64, 0x69666965, 0x641d5765, 0x642c2032, 0x32204a75, 0x6c203230,
0x30392031, 0x393a3135, 0x3a353620, 0x474d5404, 0x65746167, 0x14223334,
0x61613338, 0x372d642d, 0x31353638, 0x65623030, 0x220d6163, 0x63657074,
0x2d72616e, 0x67657305, 0x62797465, 0x730e636f, 0x6e74656e, 0x742d6c65,
0x6e677468, 0x02353104, 0x76617279, 0x0f416363, 0x6570742d, 0x456e636f,
0x64696e67, 0x0c636f6e, 0x74656e74, 0x2d747970, 0x650a7465, 0x78742f70,
0x6c61696e, 0x3348656c, 0x6c6f2057, 0x6f726c64, 0x21204d79, 0x20636f6e,
0x74656e74, 0x20696e63, 0x6c756465, 0x73206120, 0x74726169, 0x6c696e67,
0x2043524c, 0x462e0d0a};
std::string expected;
for (const auto& word : expected_words) {
expected += WordToBytes(word);
}
const auto result = response.Serialize();
ASSERT_TRUE(result.ok());
ASSERT_EQ(*result, expected);
EXPECT_THAT(
response.DebugString(),
StrEq(
"BinaryHttpResponse(200){BinaryHttpMessage{Headers{Field{date=Mon, "
"27 Jul 2009 12:28:53 "
"GMT};Field{server=Apache};Field{last-modified=Wed, 22 Jul 2009 "
"19:15:56 "
"GMT};Field{etag=\"34aa387-d-1568eb00\"};Field{accept-ranges=bytes};"
"Field{"
"content-length=51};Field{vary=Accept-Encoding};Field{content-type="
"text/plain}}Body{Hello World! My content includes a trailing "
"CRLF.\r\n}}InformationalResponse{Field{running=\"sleep "
"15\"}};InformationalResponse{Field{link=</style.css>; rel=preload; "
"as=style};Field{link=</script.js>; rel=preload; as=script}}}"));
TestPrintTo(response);
}
TEST(BinaryHttpResponse, DecodeMultiInformationalWithBody) {
/*
HTTP/1.1 102 Processing
Running: "sleep 15"
HTTP/1.1 103 Early Hints
Link: </style.css>; rel=preload; as=style
Link: </script.js>; rel=preload; as=script
HTTP/1.1 200 OK
Date: Mon, 27 Jul 2009 12:28:53 GMT
Server: Apache
Last-Modified: Wed, 22 Jul 2009 19:15:56 GMT
ETag: "34aa387-d-1568eb00"
Accept-Ranges: bytes
Content-Length: 51
Vary: Accept-Encoding
Content-Type: text/plain
Hello World! My content includes a trailing CRLF.
*/
const uint32_t words[] = {
0x01406613, 0x0772756e, 0x6e696e67, 0x0a22736c, 0x65657020, 0x31352240,
0x67405304, 0x6c696e6b, 0x233c2f73, 0x74796c65, 0x2e637373, 0x3e3b2072,
0x656c3d70, 0x72656c6f, 0x61643b20, 0x61733d73, 0x74796c65, 0x046c696e,
0x6b243c2f, 0x73637269, 0x70742e6a, 0x733e3b20, 0x72656c3d, 0x7072656c,
0x6f61643b, 0x2061733d, 0x73637269, 0x707440c8, 0x40ca0464, 0x6174651d,
0x4d6f6e2c, 0x20323720, 0x4a756c20, 0x32303039, 0x2031323a, 0x32383a35,
0x3320474d, 0x54067365, 0x72766572, 0x06417061, 0x6368650d, 0x6c617374,
0x2d6d6f64, 0x69666965, 0x641d5765, 0x642c2032, 0x32204a75, 0x6c203230,
0x30392031, 0x393a3135, 0x3a353620, 0x474d5404, 0x65746167, 0x14223334,
0x61613338, 0x372d642d, 0x31353638, 0x65623030, 0x220d6163, 0x63657074,
0x2d72616e, 0x67657305, 0x62797465, 0x730e636f, 0x6e74656e, 0x742d6c65,
0x6e677468, 0x02353104, 0x76617279, 0x0f416363, 0x6570742d, 0x456e636f,
0x64696e67, 0x0c636f6e, 0x74656e74, 0x2d747970, 0x650a7465, 0x78742f70,
0x6c61696e, 0x3348656c, 0x6c6f2057, 0x6f726c64, 0x21204d79, 0x20636f6e,
0x74656e74, 0x20696e63, 0x6c756465, 0x73206120, 0x74726169, 0x6c696e67,
0x2043524c, 0x462e0d0a, 0x00000000};
std::string data;
for (const auto& word : words) {
data += WordToBytes(word);
}
const auto response_so = BinaryHttpResponse::Create(data);
ASSERT_TRUE(response_so.ok());
const BinaryHttpResponse response = *response_so;
std::vector<BinaryHttpMessage::Field> expected_fields = {
{"date", "Mon, 27 Jul 2009 12:28:53 GMT"},
{"server", "Apache"},
{"last-modified", "Wed, 22 Jul 2009 19:15:56 GMT"},
{"etag", "\"34aa387-d-1568eb00\""},
{"accept-ranges", "bytes"},
{"content-length", "51"},
{"vary", "Accept-Encoding"},
{"content-type", "text/plain"}};
ASSERT_THAT(response.GetHeaderFields(), ContainerEq(expected_fields));
ASSERT_EQ(response.body(),
"Hello World! My content includes a trailing CRLF.\r\n");
std::vector<BinaryHttpMessage::Field> header102 = {
{"running", "\"sleep 15\""}};
std::vector<BinaryHttpMessage::Field> header103 = {
{"link", "</style.css>; rel=preload; as=style"},
{"link", "</script.js>; rel=preload; as=script"}};
std::vector<BinaryHttpResponse::InformationalResponse> expected_control = {
{102, header102}, {103, header103}};
ASSERT_THAT(response.informational_responses(),
ContainerEq(expected_control));
EXPECT_THAT(
response.DebugString(),
StrEq(
"BinaryHttpResponse(200){BinaryHttpMessage{Headers{Field{date=Mon, "
"27 Jul 2009 12:28:53 "
"GMT};Field{server=Apache};Field{last-modified=Wed, 22 Jul 2009 "
"19:15:56 "
"GMT};Field{etag=\"34aa387-d-1568eb00\"};Field{accept-ranges=bytes};"
"Field{"
"content-length=51};Field{vary=Accept-Encoding};Field{content-type="
"text/plain}}Body{Hello World! My content includes a trailing "
"CRLF.\r\n}}InformationalResponse{Field{running=\"sleep "
"15\"}};InformationalResponse{Field{link=</style.css>; rel=preload; "
"as=style};Field{link=</script.js>; rel=preload; as=script}}}"));
TestPrintTo(response);
}
TEST(BinaryHttpMessage, SwapBody) {
BinaryHttpRequest request({});
request.set_body("hello, world!");
std::string other = "goodbye, world!";
request.swap_body(other);
EXPECT_EQ(request.body(), "goodbye, world!");
EXPECT_EQ(other, "hello, world!");
}
TEST(BinaryHttpResponse, Equality) {
BinaryHttpResponse response(200);
response.AddHeaderField({"Server", "Apache"})->set_body("Hello, world!\r\n");
ASSERT_TRUE(
response.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}})
.ok());
BinaryHttpResponse same(200);
same.AddHeaderField({"Server", "Apache"})->set_body("Hello, world!\r\n");
ASSERT_TRUE(
same.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}}).ok());
ASSERT_EQ(response, same);
}
TEST(BinaryHttpResponse, Inequality) {
BinaryHttpResponse response(200);
response.AddHeaderField({"Server", "Apache"})->set_body("Hello, world!\r\n");
ASSERT_TRUE(
response.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}})
.ok());
BinaryHttpResponse different_status(201);
different_status.AddHeaderField({"Server", "Apache"})
->set_body("Hello, world!\r\n");
EXPECT_TRUE(different_status
.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}})
.ok());
EXPECT_NE(response, different_status);
BinaryHttpResponse different_header(200);
different_header.AddHeaderField({"Server", "python3"})
->set_body("Hello, world!\r\n");
EXPECT_TRUE(different_header
.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}})
.ok());
EXPECT_NE(response, different_header);
BinaryHttpResponse no_header(200);
no_header.set_body("Hello, world!\r\n");
EXPECT_TRUE(
no_header.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}})
.ok());
EXPECT_NE(response, no_header);
BinaryHttpResponse different_body(200);
different_body.AddHeaderField({"Server", "Apache"})
->set_body("Goodbye, world!\r\n");
EXPECT_TRUE(different_body
.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}})
.ok());
EXPECT_NE(response, different_body);
BinaryHttpResponse no_body(200);
no_body.AddHeaderField({"Server", "Apache"});
EXPECT_TRUE(
no_body.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}})
.ok());
EXPECT_NE(response, no_body);
BinaryHttpResponse different_informational(200);
different_informational.AddHeaderField({"Server", "Apache"})
->set_body("Hello, world!\r\n");
EXPECT_TRUE(different_informational
.AddInformationalResponse(198, {{"Running", "\"sleep 15\""}})
.ok());
EXPECT_NE(response, different_informational);
BinaryHttpResponse no_informational(200);
no_informational.AddHeaderField({"Server", "Apache"})
->set_body("Hello, world!\r\n");
EXPECT_NE(response, no_informational);
}
MATCHER_P(HasEqPayload, value, "Payloads of messages are equivalent.") {
return arg.IsPayloadEqual(value);
}
template <typename T>
void TestPadding(T& message) {
const auto data_so = message.Serialize();
ASSERT_TRUE(data_so.ok());
auto data = *data_so;
ASSERT_EQ(data.size(), message.EncodedSize());
message.set_num_padding_bytes(10);
const auto padded_data_so = message.Serialize();
ASSERT_TRUE(padded_data_so.ok());
const auto padded_data = *padded_data_so;
ASSERT_EQ(padded_data.size(), message.EncodedSize());
// Check padding size output.
ASSERT_EQ(data.size() + 10, padded_data.size());
// Check for valid null byte padding output
data.resize(data.size() + 10);
ASSERT_EQ(data, padded_data);
// Deserialize padded and not padded, and verify they are the same.
const auto deserialized_padded_message_so = T::Create(data);
ASSERT_TRUE(deserialized_padded_message_so.ok());
const auto deserialized_padded_message = *deserialized_padded_message_so;
ASSERT_EQ(deserialized_padded_message, message);
ASSERT_EQ(deserialized_padded_message.num_padding_bytes(), size_t(10));
// Invalid padding
data[data.size() - 1] = 'a';
const auto bad_so = T::Create(data);
ASSERT_FALSE(bad_so.ok());
// Check that padding does not impact equality.
data.resize(data.size() - 10);
const auto deserialized_message_so = T::Create(data);
ASSERT_TRUE(deserialized_message_so.ok());
const auto deserialized_message = *deserialized_message_so;
ASSERT_EQ(deserialized_message.num_padding_bytes(), size_t(0));
// Confirm that the message payloads are equal, but not fully equivalent due
// to padding.
ASSERT_THAT(deserialized_message, HasEqPayload(deserialized_padded_message));
ASSERT_NE(deserialized_message, deserialized_padded_message);
}
TEST(BinaryHttpRequest, Padding) {
/*
GET /hello.txt HTTP/1.1
User-Agent: curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3
Host: www.example.com
Accept-Language: en, mi
*/
BinaryHttpRequest request({"GET", "https", "", "/hello.txt"});
request
.AddHeaderField({"User-Agent",
"curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3"})
->AddHeaderField({"Host", "www.example.com"})
->AddHeaderField({"Accept-Language", "en, mi"});
TestPadding(request);
}
TEST(BinaryHttpResponse, Padding) {
/*
HTTP/1.1 200 OK
Server: Apache
Hello, world!
*/
BinaryHttpResponse response(200);
response.AddHeaderField({"Server", "Apache"});
response.set_body("Hello, world!\r\n");
TestPadding(response);
}
} // namespace quiche