Interprets SETTINGS_INITIAL_WINDOW_SIZE from the peer.
Once the setting is received, the session will use the new value for all streams created subsequently. In addition, the send window for any existing streams is updated by the delta between the old and new values.
PiperOrigin-RevId: 427558116
diff --git a/http2/adapter/http2_util.cc b/http2/adapter/http2_util.cc
index 553c0bd..0419952 100644
--- a/http2/adapter/http2_util.cc
+++ b/http2/adapter/http2_util.cc
@@ -97,6 +97,8 @@
return "InvalidPushPromise";
case ConnectionError::kExceededMaxConcurrentStreams:
return "ExceededMaxConcurrentStreams";
+ case ConnectionError::kFlowControlError:
+ return "FlowControlError";
}
return "UnknownConnectionError";
}
diff --git a/http2/adapter/http2_visitor_interface.h b/http2/adapter/http2_visitor_interface.h
index 574bac4..db292d0 100644
--- a/http2/adapter/http2_visitor_interface.h
+++ b/http2/adapter/http2_visitor_interface.h
@@ -78,6 +78,8 @@
kInvalidPushPromise,
// The peer exceeded the max concurrent streams limit.
kExceededMaxConcurrentStreams,
+ // The peer caused a flow control error.
+ kFlowControlError,
};
virtual void OnConnectionError(ConnectionError error) = 0;
diff --git a/http2/adapter/nghttp2_adapter_test.cc b/http2/adapter/nghttp2_adapter_test.cc
index 0b570c3..e72727c 100644
--- a/http2/adapter/nghttp2_adapter_test.cc
+++ b/http2/adapter/nghttp2_adapter_test.cc
@@ -2157,6 +2157,264 @@
EXPECT_FALSE(adapter->want_write());
}
+TEST(NgHttp2AdapterTest, ClientReceivesInitialWindowSetting) {
+ DataSavingVisitor visitor;
+ auto adapter = NgHttp2Adapter::CreateClientAdapter(visitor);
+
+ const std::string initial_frames =
+ TestFrameSequence()
+ .Settings({{INITIAL_WINDOW_SIZE, 80000u}})
+ .WindowUpdate(0, 65536)
+ .Serialize();
+ // Server preface (SETTINGS with INITIAL_STREAM_WINDOW)
+ EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ EXPECT_CALL(visitor, OnSetting(Http2Setting{INITIAL_WINDOW_SIZE, 80000u}));
+ EXPECT_CALL(visitor, OnSettingsEnd());
+ EXPECT_CALL(visitor, OnFrameHeader(0, 4, WINDOW_UPDATE, 0));
+ EXPECT_CALL(visitor, OnWindowUpdate(0, 65536));
+
+ const int64_t initial_result = adapter->ProcessBytes(initial_frames);
+ EXPECT_EQ(initial_frames.size(), static_cast<size_t>(initial_result));
+
+ // Session will want to write a SETTINGS ack.
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+
+ int64_t result = adapter->Send();
+ EXPECT_EQ(0, result);
+ absl::string_view serialized = visitor.data();
+ EXPECT_THAT(serialized,
+ testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
+ serialized.remove_prefix(strlen(spdy::kHttp2ConnectionHeaderPrefix));
+ EXPECT_THAT(serialized, EqualsFrames({spdy::SpdyFrameType::SETTINGS}));
+ visitor.Clear();
+
+ const std::string kLongBody = std::string(81000, 'c');
+ auto body1 = absl::make_unique<TestDataFrameSource>(visitor, true);
+ body1->AppendPayload(kLongBody);
+ body1->EndData();
+ const int stream_id =
+ adapter->SubmitRequest(ToHeaders({{":method", "POST"},
+ {":scheme", "http"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/one"}}),
+ std::move(body1), nullptr);
+ EXPECT_GT(stream_id, 0);
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(HEADERS, stream_id, _, 0x4));
+ EXPECT_CALL(visitor, OnFrameSent(HEADERS, stream_id, _, 0x4, 0));
+ // The client can send more than 4 frames (65536 bytes) of data.
+ EXPECT_CALL(visitor, OnFrameSent(DATA, stream_id, 16384, 0x0, 0)).Times(4);
+ EXPECT_CALL(visitor, OnFrameSent(DATA, stream_id, 14464, 0x0, 0));
+
+ result = adapter->Send();
+ EXPECT_EQ(0, result);
+ EXPECT_THAT(
+ visitor.data(),
+ EqualsFrames({spdy::SpdyFrameType::HEADERS, spdy::SpdyFrameType::DATA,
+ spdy::SpdyFrameType::DATA, spdy::SpdyFrameType::DATA,
+ spdy::SpdyFrameType::DATA, spdy::SpdyFrameType::DATA}));
+}
+
+TEST(NgHttp2AdapterTest, ClientReceivesInitialWindowSettingAfterStreamStart) {
+ DataSavingVisitor visitor;
+ auto adapter = NgHttp2Adapter::CreateClientAdapter(visitor);
+
+ const std::string initial_frames =
+ TestFrameSequence().ServerPreface().WindowUpdate(0, 65536).Serialize();
+ // Server preface (empty SETTINGS)
+ EXPECT_CALL(visitor, OnFrameHeader(0, 0, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ EXPECT_CALL(visitor, OnSettingsEnd());
+ EXPECT_CALL(visitor, OnFrameHeader(0, 4, WINDOW_UPDATE, 0));
+ EXPECT_CALL(visitor, OnWindowUpdate(0, 65536));
+
+ const int64_t initial_result = adapter->ProcessBytes(initial_frames);
+ EXPECT_EQ(initial_frames.size(), static_cast<size_t>(initial_result));
+
+ // Session will want to write a SETTINGS ack.
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+
+ int64_t result = adapter->Send();
+ EXPECT_EQ(0, result);
+ visitor.Clear();
+
+ const std::string kLongBody = std::string(81000, 'c');
+ auto body1 = absl::make_unique<TestDataFrameSource>(visitor, true);
+ body1->AppendPayload(kLongBody);
+ body1->EndData();
+ const int stream_id =
+ adapter->SubmitRequest(ToHeaders({{":method", "POST"},
+ {":scheme", "http"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/one"}}),
+ std::move(body1), nullptr);
+ EXPECT_GT(stream_id, 0);
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(HEADERS, stream_id, _, 0x4));
+ EXPECT_CALL(visitor, OnFrameSent(HEADERS, stream_id, _, 0x4, 0));
+ // The client can only send 65535 bytes of data, as the stream window has not
+ // yet been increased.
+ EXPECT_CALL(visitor, OnFrameSent(DATA, stream_id, 16384, 0x0, 0)).Times(3);
+ EXPECT_CALL(visitor, OnFrameSent(DATA, stream_id, 16383, 0x0, 0));
+
+ result = adapter->Send();
+ EXPECT_EQ(0, result);
+ EXPECT_THAT(
+ visitor.data(),
+ EqualsFrames({spdy::SpdyFrameType::HEADERS, spdy::SpdyFrameType::DATA,
+ spdy::SpdyFrameType::DATA, spdy::SpdyFrameType::DATA,
+ spdy::SpdyFrameType::DATA}));
+ visitor.Clear();
+
+ // Can't write any more due to flow control.
+ EXPECT_FALSE(adapter->want_write());
+
+ const std::string settings_frame =
+ TestFrameSequence().Settings({{INITIAL_WINDOW_SIZE, 80000u}}).Serialize();
+ // SETTINGS with INITIAL_STREAM_WINDOW
+ EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ EXPECT_CALL(visitor, OnSetting(Http2Setting{INITIAL_WINDOW_SIZE, 80000u}));
+ EXPECT_CALL(visitor, OnSettingsEnd());
+
+ const int64_t settings_result = adapter->ProcessBytes(settings_frame);
+ EXPECT_EQ(settings_frame.size(), static_cast<size_t>(settings_result));
+
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+ // The client can write more after receiving the INITIAL_WINDOW_SIZE setting.
+ EXPECT_CALL(visitor, OnFrameSent(DATA, stream_id, 14465, 0x0, 0));
+
+ result = adapter->Send();
+ EXPECT_EQ(0, result);
+ EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS,
+ spdy::SpdyFrameType::DATA}));
+}
+
+TEST(NgHttp2AdapterTest, InvalidInitialWindowSetting) {
+ DataSavingVisitor visitor;
+ auto adapter = NgHttp2Adapter::CreateClientAdapter(visitor);
+
+ const uint32_t kTooLargeInitialWindow = 1u << 31;
+ const std::string initial_frames =
+ TestFrameSequence()
+ .Settings({{INITIAL_WINDOW_SIZE, kTooLargeInitialWindow}})
+ .Serialize();
+ // Server preface (SETTINGS with INITIAL_STREAM_WINDOW)
+ EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+ EXPECT_CALL(visitor,
+ OnInvalidFrame(
+ 0, Http2VisitorInterface::InvalidFrameError::kFlowControl));
+
+ const int64_t initial_result = adapter->ProcessBytes(initial_frames);
+ EXPECT_EQ(initial_frames.size(), static_cast<size_t>(initial_result));
+
+ // Session will want to write a GOAWAY.
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(GOAWAY, 0, _, 0x0));
+ EXPECT_CALL(
+ visitor,
+ OnFrameSent(GOAWAY, 0, _, 0x0,
+ static_cast<int>(Http2ErrorCode::FLOW_CONTROL_ERROR)));
+
+ int64_t result = adapter->Send();
+ EXPECT_EQ(0, result);
+ absl::string_view serialized = visitor.data();
+ EXPECT_THAT(serialized,
+ testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
+ serialized.remove_prefix(strlen(spdy::kHttp2ConnectionHeaderPrefix));
+ EXPECT_THAT(serialized, EqualsFrames({spdy::SpdyFrameType::GOAWAY}));
+ visitor.Clear();
+}
+
+TEST(NgHttp2AdapterTest, InitialWindowSettingCausesOverflow) {
+ DataSavingVisitor visitor;
+ auto adapter = NgHttp2Adapter::CreateClientAdapter(visitor);
+
+ testing::InSequence s;
+
+ const std::vector<Header> headers =
+ ToHeaders({{":method", "GET"},
+ {":scheme", "http"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/one"}});
+ const int32_t stream_id = adapter->SubmitRequest(headers, nullptr, nullptr);
+ ASSERT_GT(stream_id, 0);
+ EXPECT_CALL(visitor, OnBeforeFrameSent(HEADERS, stream_id, _, 0x5));
+ EXPECT_CALL(visitor, OnFrameSent(HEADERS, stream_id, _, 0x5, 0));
+ int64_t write_result = adapter->Send();
+ EXPECT_EQ(0, write_result);
+ absl::string_view data = visitor.data();
+ EXPECT_THAT(data, testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
+ data.remove_prefix(strlen(spdy::kHttp2ConnectionHeaderPrefix));
+ EXPECT_THAT(data, EqualsFrames({spdy::SpdyFrameType::HEADERS}));
+ visitor.Clear();
+
+ const uint32_t kLargeInitialWindow = (1u << 31) - 1;
+ const std::string frames =
+ TestFrameSequence()
+ .ServerPreface()
+ .Headers(stream_id, {{":status", "200"}}, /*fin=*/false)
+ .WindowUpdate(stream_id, 65536u)
+ .Settings({{INITIAL_WINDOW_SIZE, kLargeInitialWindow}})
+ .Serialize();
+
+ EXPECT_CALL(visitor, OnFrameHeader(0, 0, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ EXPECT_CALL(visitor, OnSettingsEnd());
+
+ EXPECT_CALL(visitor, OnFrameHeader(stream_id, _, HEADERS, 0x4));
+ EXPECT_CALL(visitor, OnBeginHeadersForStream(stream_id));
+ EXPECT_CALL(visitor, OnHeaderForStream(stream_id, ":status", "200"));
+ EXPECT_CALL(visitor, OnEndHeadersForStream(stream_id));
+
+ EXPECT_CALL(visitor, OnFrameHeader(stream_id, 4, WINDOW_UPDATE, 0x0));
+ EXPECT_CALL(visitor, OnWindowUpdate(stream_id, 65536));
+
+ EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ EXPECT_CALL(visitor, OnSetting(Http2Setting{INITIAL_WINDOW_SIZE,
+ kLargeInitialWindow}));
+ EXPECT_CALL(visitor, OnSettingsEnd());
+
+ const int64_t read_result = adapter->ProcessBytes(frames);
+ EXPECT_EQ(static_cast<size_t>(read_result), frames.size());
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, 0, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, 0, 0x1, 0));
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, 0, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, 0, 0x1, 0));
+
+ // The stream window update plus the SETTINGS frame with INITIAL_WINDOW_SIZE
+ // pushes the stream's flow control window outside of the acceptable range.
+ EXPECT_CALL(visitor, OnBeforeFrameSent(RST_STREAM, stream_id, 4, 0x0));
+ EXPECT_CALL(
+ visitor,
+ OnFrameSent(RST_STREAM, stream_id, 4, 0x0,
+ static_cast<int>(Http2ErrorCode::FLOW_CONTROL_ERROR)));
+ EXPECT_CALL(visitor,
+ OnCloseStream(stream_id, Http2ErrorCode::FLOW_CONTROL_ERROR));
+
+ int result = adapter->Send();
+ EXPECT_EQ(0, result);
+ EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS,
+ spdy::SpdyFrameType::SETTINGS,
+ spdy::SpdyFrameType::RST_STREAM}));
+}
+
TEST(NgHttp2AdapterTest, ClientForbidsPushPromise) {
DataSavingVisitor visitor;
auto adapter = NgHttp2Adapter::CreateClientAdapter(visitor);
diff --git a/http2/adapter/oghttp2_adapter_test.cc b/http2/adapter/oghttp2_adapter_test.cc
index 474a86c..41de2e4 100644
--- a/http2/adapter/oghttp2_adapter_test.cc
+++ b/http2/adapter/oghttp2_adapter_test.cc
@@ -2047,6 +2047,290 @@
EXPECT_FALSE(adapter->want_write());
}
+TEST(OgHttp2AdapterClientTest, ClientReceivesInitialWindowSetting) {
+ DataSavingVisitor visitor;
+ OgHttp2Adapter::Options options{.perspective = Perspective::kClient};
+ auto adapter = OgHttp2Adapter::Create(visitor, options);
+
+ const std::string initial_frames =
+ TestFrameSequence()
+ .Settings({{INITIAL_WINDOW_SIZE, 80000u}})
+ .WindowUpdate(0, 65536)
+ .Serialize();
+ // Server preface (SETTINGS with INITIAL_STREAM_WINDOW)
+ EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ // TODO(diannahu): Remove the duplicate call with a separate
+ // ExtensionVisitorInterface implementation.
+ EXPECT_CALL(visitor, OnSetting(Http2Setting{INITIAL_WINDOW_SIZE, 80000u}))
+ .Times(2);
+ EXPECT_CALL(visitor, OnSettingsEnd());
+ EXPECT_CALL(visitor, OnFrameHeader(0, 4, WINDOW_UPDATE, 0));
+ EXPECT_CALL(visitor, OnWindowUpdate(0, 65536));
+
+ const int64_t initial_result = adapter->ProcessBytes(initial_frames);
+ EXPECT_EQ(initial_frames.size(), static_cast<size_t>(initial_result));
+
+ // Session will want to write a SETTINGS ack.
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x0));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x0, 0));
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+
+ int64_t result = adapter->Send();
+ EXPECT_EQ(0, result);
+ absl::string_view serialized = visitor.data();
+ EXPECT_THAT(serialized,
+ testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
+ serialized.remove_prefix(strlen(spdy::kHttp2ConnectionHeaderPrefix));
+ EXPECT_THAT(serialized,
+ EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::SETTINGS}));
+ visitor.Clear();
+
+ const std::string kLongBody = std::string(81000, 'c');
+ auto body1 = absl::make_unique<TestDataFrameSource>(visitor, true);
+ body1->AppendPayload(kLongBody);
+ body1->EndData();
+ const int stream_id =
+ adapter->SubmitRequest(ToHeaders({{":method", "POST"},
+ {":scheme", "http"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/one"}}),
+ std::move(body1), nullptr);
+ EXPECT_GT(stream_id, 0);
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(HEADERS, stream_id, _, 0x4));
+ EXPECT_CALL(visitor, OnFrameSent(HEADERS, stream_id, _, 0x4, 0));
+ // The client can send more than 4 frames (65536 bytes) of data.
+ EXPECT_CALL(visitor, OnFrameSent(DATA, stream_id, 16384, 0x0, 0)).Times(4);
+ EXPECT_CALL(visitor, OnFrameSent(DATA, stream_id, 14464, 0x0, 0));
+
+ result = adapter->Send();
+ EXPECT_EQ(0, result);
+ EXPECT_THAT(visitor.data(),
+ EqualsFrames({SpdyFrameType::HEADERS, SpdyFrameType::DATA,
+ SpdyFrameType::DATA, SpdyFrameType::DATA,
+ SpdyFrameType::DATA, SpdyFrameType::DATA}));
+}
+
+TEST(OgHttp2AdapterClientTest,
+ ClientReceivesInitialWindowSettingAfterStreamStart) {
+ DataSavingVisitor visitor;
+ OgHttp2Adapter::Options options{.perspective = Perspective::kClient};
+ auto adapter = OgHttp2Adapter::Create(visitor, options);
+
+ const std::string initial_frames =
+ TestFrameSequence().ServerPreface().WindowUpdate(0, 65536).Serialize();
+ // Server preface (empty SETTINGS)
+ EXPECT_CALL(visitor, OnFrameHeader(0, 0, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ EXPECT_CALL(visitor, OnSettingsEnd());
+ EXPECT_CALL(visitor, OnFrameHeader(0, 4, WINDOW_UPDATE, 0));
+ EXPECT_CALL(visitor, OnWindowUpdate(0, 65536));
+
+ const int64_t initial_result = adapter->ProcessBytes(initial_frames);
+ EXPECT_EQ(initial_frames.size(), static_cast<size_t>(initial_result));
+
+ // Session will want to write a SETTINGS ack.
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x0));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x0, 0));
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+
+ int64_t result = adapter->Send();
+ EXPECT_EQ(0, result);
+ visitor.Clear();
+
+ const std::string kLongBody = std::string(81000, 'c');
+ auto body1 = absl::make_unique<TestDataFrameSource>(visitor, true);
+ body1->AppendPayload(kLongBody);
+ body1->EndData();
+ const int stream_id =
+ adapter->SubmitRequest(ToHeaders({{":method", "POST"},
+ {":scheme", "http"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/one"}}),
+ std::move(body1), nullptr);
+ EXPECT_GT(stream_id, 0);
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(HEADERS, stream_id, _, 0x4));
+ EXPECT_CALL(visitor, OnFrameSent(HEADERS, stream_id, _, 0x4, 0));
+ // The client can only send 65535 bytes of data, as the stream window has not
+ // yet been increased.
+ EXPECT_CALL(visitor, OnFrameSent(DATA, stream_id, 16384, 0x0, 0)).Times(3);
+ EXPECT_CALL(visitor, OnFrameSent(DATA, stream_id, 16383, 0x0, 0));
+
+ result = adapter->Send();
+ EXPECT_EQ(0, result);
+ EXPECT_THAT(visitor.data(),
+ EqualsFrames({SpdyFrameType::HEADERS, SpdyFrameType::DATA,
+ SpdyFrameType::DATA, SpdyFrameType::DATA,
+ SpdyFrameType::DATA}));
+ visitor.Clear();
+
+ // Can't write any more due to flow control.
+ EXPECT_FALSE(adapter->want_write());
+
+ const std::string settings_frame =
+ TestFrameSequence().Settings({{INITIAL_WINDOW_SIZE, 80000u}}).Serialize();
+ // SETTINGS with INITIAL_STREAM_WINDOW
+ EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ // TODO(diannahu): Remove the duplicate call with a separate
+ // ExtensionVisitorInterface implementation.
+ EXPECT_CALL(visitor, OnSetting(Http2Setting{INITIAL_WINDOW_SIZE, 80000u}))
+ .Times(2);
+ EXPECT_CALL(visitor, OnSettingsEnd());
+
+ const int64_t settings_result = adapter->ProcessBytes(settings_frame);
+ EXPECT_EQ(settings_frame.size(), static_cast<size_t>(settings_result));
+
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+ // The client can write more after receiving the INITIAL_WINDOW_SIZE setting.
+ EXPECT_CALL(visitor, OnFrameSent(DATA, stream_id, 14465, 0x0, 0));
+
+ result = adapter->Send();
+ EXPECT_EQ(0, result);
+ EXPECT_THAT(visitor.data(),
+ EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::DATA}));
+}
+
+TEST(OgHttp2AdapterClientTest, InvalidInitialWindowSetting) {
+ DataSavingVisitor visitor;
+ OgHttp2Adapter::Options options{.perspective = Perspective::kClient};
+ auto adapter = OgHttp2Adapter::Create(visitor, options);
+
+ const uint32_t kTooLargeInitialWindow = 1u << 31;
+ const std::string initial_frames =
+ TestFrameSequence()
+ .Settings({{INITIAL_WINDOW_SIZE, kTooLargeInitialWindow}})
+ .Serialize();
+ // Server preface (SETTINGS with INITIAL_STREAM_WINDOW)
+ EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ // TODO(diannahu): Remove the duplicate call with a separate
+ // ExtensionVisitorInterface implementation.
+ EXPECT_CALL(
+ visitor,
+ OnInvalidFrame(0, Http2VisitorInterface::InvalidFrameError::kFlowControl))
+ .Times(2);
+ EXPECT_CALL(visitor,
+ OnConnectionError(
+ Http2VisitorInterface::ConnectionError::kFlowControlError));
+
+ const int64_t initial_result = adapter->ProcessBytes(initial_frames);
+ EXPECT_EQ(initial_frames.size(), static_cast<size_t>(initial_result));
+
+ // Session will want to write a GOAWAY.
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x0));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x0, 0));
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+
+ int64_t result = adapter->Send();
+ EXPECT_EQ(0, result);
+ absl::string_view serialized = visitor.data();
+ EXPECT_THAT(serialized,
+ testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
+ serialized.remove_prefix(strlen(spdy::kHttp2ConnectionHeaderPrefix));
+ EXPECT_THAT(serialized,
+ EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::SETTINGS}));
+ visitor.Clear();
+}
+
+TEST(OggHttp2AdapterClientTest, InitialWindowSettingCausesOverflow) {
+ DataSavingVisitor visitor;
+ OgHttp2Adapter::Options options{.perspective = Perspective::kClient};
+ auto adapter = OgHttp2Adapter::Create(visitor, options);
+
+ testing::InSequence s;
+
+ const std::vector<Header> headers =
+ ToHeaders({{":method", "GET"},
+ {":scheme", "http"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/one"}});
+ const int32_t stream_id = adapter->SubmitRequest(headers, nullptr, nullptr);
+ ASSERT_GT(stream_id, 0);
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x0));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x0, 0));
+ EXPECT_CALL(visitor, OnBeforeFrameSent(HEADERS, stream_id, _, 0x5));
+ EXPECT_CALL(visitor, OnFrameSent(HEADERS, stream_id, _, 0x5, 0));
+ int64_t write_result = adapter->Send();
+ EXPECT_EQ(0, write_result);
+ absl::string_view data = visitor.data();
+ EXPECT_THAT(data, testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
+ data.remove_prefix(strlen(spdy::kHttp2ConnectionHeaderPrefix));
+ EXPECT_THAT(data,
+ EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::HEADERS}));
+ visitor.Clear();
+
+ const uint32_t kLargeInitialWindow = (1u << 31) - 1;
+ const std::string frames =
+ TestFrameSequence()
+ .ServerPreface()
+ .Headers(stream_id, {{":status", "200"}}, /*fin=*/false)
+ .WindowUpdate(stream_id, 65536u)
+ .Settings({{INITIAL_WINDOW_SIZE, kLargeInitialWindow}})
+ .Serialize();
+
+ EXPECT_CALL(visitor, OnFrameHeader(0, 0, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ EXPECT_CALL(visitor, OnSettingsEnd());
+
+ EXPECT_CALL(visitor, OnFrameHeader(stream_id, _, HEADERS, 0x4));
+ EXPECT_CALL(visitor, OnBeginHeadersForStream(stream_id));
+ EXPECT_CALL(visitor, OnHeaderForStream(stream_id, ":status", "200"));
+ EXPECT_CALL(visitor, OnEndHeadersForStream(stream_id));
+
+ EXPECT_CALL(visitor, OnFrameHeader(stream_id, 4, WINDOW_UPDATE, 0x0));
+ EXPECT_CALL(visitor, OnWindowUpdate(stream_id, 65536));
+
+ EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+ EXPECT_CALL(visitor, OnSettingsStart());
+ EXPECT_CALL(visitor,
+ OnSetting(Http2Setting{INITIAL_WINDOW_SIZE, kLargeInitialWindow}))
+ .Times(2);
+ EXPECT_CALL(visitor, OnSettingsEnd());
+
+ const int64_t read_result = adapter->ProcessBytes(frames);
+ EXPECT_EQ(static_cast<size_t>(read_result), frames.size());
+ EXPECT_TRUE(adapter->want_write());
+
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, 0, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, 0, 0x1, 0));
+ EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, 0, 0x1));
+ EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, 0, 0x1, 0));
+
+ // The stream window update plus the SETTINGS frame with INITIAL_WINDOW_SIZE
+ // pushes the stream's flow control window outside of the acceptable range.
+ EXPECT_CALL(visitor, OnBeforeFrameSent(RST_STREAM, stream_id, 4, 0x0));
+ EXPECT_CALL(
+ visitor,
+ OnFrameSent(RST_STREAM, stream_id, 4, 0x0,
+ static_cast<int>(Http2ErrorCode::FLOW_CONTROL_ERROR)));
+ EXPECT_CALL(visitor,
+ OnCloseStream(stream_id, Http2ErrorCode::HTTP2_NO_ERROR));
+
+ int result = adapter->Send();
+ EXPECT_EQ(0, result);
+ EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS,
+ spdy::SpdyFrameType::SETTINGS,
+ spdy::SpdyFrameType::RST_STREAM}));
+}
+
TEST(OgHttp2AdapterClientTest, FailureSendingConnectionPreface) {
DataSavingVisitor visitor;
OgHttp2Adapter::Options options{.perspective = Perspective::kClient};
diff --git a/http2/adapter/oghttp2_session.cc b/http2/adapter/oghttp2_session.cc
index 98e200b..6cdbff7 100644
--- a/http2/adapter/oghttp2_session.cc
+++ b/http2/adapter/oghttp2_session.cc
@@ -1207,6 +1207,19 @@
encoder_header_table_capacity_when_acking_ = value;
}
break;
+ case INITIAL_WINDOW_SIZE:
+ if (value > spdy::kSpdyMaximumWindowSize) {
+ visitor_.OnInvalidFrame(
+ 0, Http2VisitorInterface::InvalidFrameError::kFlowControl);
+ // The specification says this is a connection-level flow control error.
+ LatchErrorAndNotify(
+ Http2ErrorCode::FLOW_CONTROL_ERROR,
+ Http2VisitorInterface::ConnectionError::kFlowControlError);
+ return;
+ } else {
+ UpdateInitialWindowSize(value);
+ }
+ break;
default:
// TODO(bnc): See if C++17 inline constants are allowed in QUICHE.
if (id == kMetadataExtensionId) {
@@ -1584,8 +1597,8 @@
absl::flat_hash_map<Http2StreamId, StreamState>::iterator iter;
bool inserted;
std::tie(iter, inserted) = stream_map_.try_emplace(
- stream_id,
- StreamState(stream_receive_window_limit_, std::move(listener)));
+ stream_id, StreamState(initial_stream_receive_window_,
+ initial_stream_send_window_, std::move(listener)));
if (inserted) {
// Add the stream to the write scheduler.
const WriteScheduler::StreamPrecedenceType precedence(3);
@@ -1745,5 +1758,23 @@
stream_id, spdy::ERROR_CODE_PROTOCOL_ERROR));
}
+void OgHttp2Session::UpdateInitialWindowSize(uint32_t new_value) {
+ const int32_t delta =
+ static_cast<int32_t>(new_value) - initial_stream_send_window_;
+ initial_stream_send_window_ = new_value;
+ for (auto& [stream_id, stream_state] : stream_map_) {
+ const int64_t current_window_size = stream_state.send_window;
+ const int64_t new_window_size = current_window_size + delta;
+ if (new_window_size > spdy::kSpdyMaximumWindowSize) {
+ EnqueueFrame(absl::make_unique<spdy::SpdyRstStreamIR>(
+ stream_id, spdy::ERROR_CODE_FLOW_CONTROL_ERROR));
+ }
+ stream_state.send_window += delta;
+ if (current_window_size <= 0 && new_window_size > 0) {
+ write_scheduler_.MarkStreamReady(stream_id, false);
+ }
+ }
+}
+
} // namespace adapter
} // namespace http2
diff --git a/http2/adapter/oghttp2_session.h b/http2/adapter/oghttp2_session.h
index 53df0d4..6efa032 100644
--- a/http2/adapter/oghttp2_session.h
+++ b/http2/adapter/oghttp2_session.h
@@ -212,16 +212,17 @@
using MetadataSequence = std::vector<std::unique_ptr<MetadataSource>>;
struct QUICHE_EXPORT_PRIVATE StreamState {
- StreamState(int32_t stream_receive_window,
+ StreamState(int32_t stream_receive_window, int32_t stream_send_window,
WindowManager::WindowUpdateListener listener)
- : window_manager(stream_receive_window, std::move(listener)) {}
+ : window_manager(stream_receive_window, std::move(listener)),
+ send_window(stream_send_window) {}
WindowManager window_manager;
std::unique_ptr<DataFrameSource> outbound_body;
MetadataSequence outbound_metadata;
std::unique_ptr<spdy::SpdyHeaderBlock> trailers;
void* user_data = nullptr;
- int32_t send_window = kInitialFlowControlWindowSize;
+ int32_t send_window;
absl::optional<HeaderType> received_header_type;
absl::optional<size_t> remaining_content_length;
bool half_closed_local = false;
@@ -397,6 +398,8 @@
void HandleContentLengthError(Http2StreamId stream_id);
+ void UpdateInitialWindowSize(uint32_t new_value);
+
// Receives events when inbound frames are parsed.
Http2VisitorInterface& visitor_;
@@ -472,7 +475,9 @@
size_t metadata_length_ = 0;
int32_t connection_send_window_ = kInitialFlowControlWindowSize;
// The initial flow control receive window size for any newly created streams.
- int32_t stream_receive_window_limit_ = kInitialFlowControlWindowSize;
+ int32_t initial_stream_receive_window_ = kInitialFlowControlWindowSize;
+ // The initial flow control send window size for any newly created streams.
+ int32_t initial_stream_send_window_ = kInitialFlowControlWindowSize;
uint32_t max_frame_payload_ = 16384u;
// The maximum number of concurrent streams that this connection can open to
// its peer and allow from its peer, respectively. Although the initial value
