Adds a wrapper class for the nghttp2 session data type.
PiperOrigin-RevId: 367513350
Change-Id: If86cb1e72347fef86ed6df76a1723cdaf0b4584a
diff --git a/http2/adapter/http2_adapter.h b/http2/adapter/http2_adapter.h
index 5ea6045..4ce8a48 100644
--- a/http2/adapter/http2_adapter.h
+++ b/http2/adapter/http2_adapter.h
@@ -19,11 +19,6 @@
// implementations.
class Http2Adapter {
public:
- enum class Perspective {
- kClient,
- kServer,
- };
-
Http2Adapter(const Http2Adapter&) = delete;
Http2Adapter& operator=(const Http2Adapter&) = delete;
diff --git a/http2/adapter/http2_session.h b/http2/adapter/http2_session.h
index ddbed44..43a26e9 100644
--- a/http2/adapter/http2_session.h
+++ b/http2/adapter/http2_session.h
@@ -26,13 +26,9 @@
virtual int GetRemoteWindowSize() const = 0;
};
-class Http2Options {
- public:
- Http2Options() = default;
- virtual ~Http2Options() {}
-
- // This method returns an opaque reference to the underlying type.
- virtual void* GetOptions() = 0;
+enum class Perspective {
+ kClient,
+ kServer,
};
} // namespace adapter
diff --git a/http2/adapter/nghttp2_callbacks.cc b/http2/adapter/nghttp2_callbacks.cc
index 337f230..e897fa8 100644
--- a/http2/adapter/nghttp2_callbacks.cc
+++ b/http2/adapter/nghttp2_callbacks.cc
@@ -30,6 +30,8 @@
void* user_data) {
auto* visitor = static_cast<Http2VisitorInterface*>(user_data);
const Http2StreamId stream_id = frame->hd.stream_id;
+ QUICHE_VLOG(2) << "Frame " << static_cast<int>(frame->hd.type)
+ << " for stream " << stream_id;
switch (frame->hd.type) {
// The beginning of the DATA frame is handled in OnBeginFrame(), and the
// beginning of the header block is handled in client/server-specific
diff --git a/http2/adapter/nghttp2_session.cc b/http2/adapter/nghttp2_session.cc
new file mode 100644
index 0000000..b288037
--- /dev/null
+++ b/http2/adapter/nghttp2_session.cc
@@ -0,0 +1,73 @@
+#include "http2/adapter/nghttp2_session.h"
+
+#include "common/platform/api/quiche_logging.h"
+
+namespace http2 {
+namespace adapter {
+namespace {
+
+void DeleteSession(nghttp2_session* session) {
+ nghttp2_session_del(session);
+}
+
+void DeleteOptions(nghttp2_option* options) {
+ nghttp2_option_del(options);
+}
+
+} // namespace
+
+NgHttp2Session::NgHttp2Session(Perspective perspective,
+ nghttp2_session_callbacks* callbacks,
+ nghttp2_option* options,
+ void* userdata)
+ : session_(nullptr, DeleteSession),
+ options_(options, DeleteOptions),
+ perspective_(perspective) {
+ nghttp2_session* session;
+ switch (perspective) {
+ case Perspective::kClient:
+ nghttp2_session_client_new2(&session, callbacks, userdata,
+ options_.get());
+ break;
+ case Perspective::kServer:
+ nghttp2_session_server_new2(&session, callbacks, userdata,
+ options_.get());
+ break;
+ }
+ nghttp2_session_callbacks_del(callbacks);
+ session_.reset(session);
+}
+
+NgHttp2Session::~NgHttp2Session() {
+ // Can't invoke want_read() or want_write(), as they are virtual methods.
+ const bool pending_reads = nghttp2_session_want_read(session_.get()) != 0;
+ const bool pending_writes = nghttp2_session_want_write(session_.get()) != 0;
+ QUICHE_LOG_IF(WARNING, pending_reads || pending_writes)
+ << "Shutting down connection with pending reads: " << pending_reads
+ << " or pending writes: " << pending_writes;
+}
+
+ssize_t NgHttp2Session::ProcessBytes(absl::string_view bytes) {
+ return nghttp2_session_mem_recv(
+ session_.get(), reinterpret_cast<const uint8_t*>(bytes.data()),
+ bytes.size());
+}
+
+int NgHttp2Session::Consume(Http2StreamId stream_id, size_t num_bytes) {
+ return nghttp2_session_consume(session_.get(), stream_id, num_bytes);
+}
+
+bool NgHttp2Session::want_read() const {
+ return nghttp2_session_want_read(session_.get()) != 0;
+}
+
+bool NgHttp2Session::want_write() const {
+ return nghttp2_session_want_write(session_.get()) != 0;
+}
+
+int NgHttp2Session::GetRemoteWindowSize() const {
+ return nghttp2_session_get_remote_window_size(session_.get());
+}
+
+} // namespace adapter
+} // namespace http2
diff --git a/http2/adapter/nghttp2_session.h b/http2/adapter/nghttp2_session.h
new file mode 100644
index 0000000..27a2153
--- /dev/null
+++ b/http2/adapter/nghttp2_session.h
@@ -0,0 +1,41 @@
+#ifndef QUICHE_HTTP2_ADAPTER_NGHTTP2_SESSION_H_
+#define QUICHE_HTTP2_ADAPTER_NGHTTP2_SESSION_H_
+
+#include "http2/adapter/http2_session.h"
+#include "third_party/nghttp2/src/lib/includes/nghttp2/nghttp2.h"
+
+namespace http2 {
+namespace adapter {
+
+// A C++ wrapper around common nghttp2_session operations.
+class NgHttp2Session : public Http2Session {
+ public:
+ NgHttp2Session(Perspective perspective,
+ nghttp2_session_callbacks* callbacks,
+ nghttp2_option* options,
+ void* userdata);
+ ~NgHttp2Session() override;
+
+ ssize_t ProcessBytes(absl::string_view bytes) override;
+
+ int Consume(Http2StreamId stream_id, size_t num_bytes) override;
+
+ bool want_read() const override;
+ bool want_write() const override;
+ int GetRemoteWindowSize() const override;
+
+ nghttp2_session* raw_ptr() const { return session_.get(); }
+
+ private:
+ using SessionDeleter = void (&)(nghttp2_session*);
+ using OptionsDeleter = void (&)(nghttp2_option*);
+
+ std::unique_ptr<nghttp2_session, SessionDeleter> session_;
+ std::unique_ptr<nghttp2_option, OptionsDeleter> options_;
+ Perspective perspective_;
+};
+
+} // namespace adapter
+} // namespace http2
+
+#endif // QUICHE_HTTP2_ADAPTER_NGHTTP2_SESSION_H_
diff --git a/http2/adapter/nghttp2_session_test.cc b/http2/adapter/nghttp2_session_test.cc
new file mode 100644
index 0000000..ad74013
--- /dev/null
+++ b/http2/adapter/nghttp2_session_test.cc
@@ -0,0 +1,239 @@
+#include "http2/adapter/nghttp2_session.h"
+
+#include "http2/adapter/mock_http2_visitor.h"
+#include "http2/adapter/nghttp2_callbacks.h"
+#include "http2/adapter/nghttp2_util.h"
+#include "http2/adapter/test_frame_sequence.h"
+#include "common/platform/api/quiche_test.h"
+
+namespace http2 {
+namespace adapter {
+namespace test {
+namespace {
+
+class DataSavingVisitor : public testing::StrictMock<MockHttp2Visitor> {
+ public:
+ void Save(absl::string_view data) { absl::StrAppend(&data_, data); }
+
+ const std::string& data() { return data_; }
+
+ private:
+ std::string data_;
+};
+
+ssize_t SaveSessionOutput(nghttp2_session* session,
+ const uint8_t* data,
+ size_t length,
+ int flags,
+ void* user_data) {
+ auto visitor = static_cast<DataSavingVisitor*>(user_data);
+ visitor->Save(ToStringView(data, length));
+ return length;
+}
+
+class NgHttp2SessionTest : public testing::Test {
+ public:
+ nghttp2_option* CreateOptions() {
+ nghttp2_option* options;
+ nghttp2_option_new(&options);
+ nghttp2_option_set_no_auto_window_update(options, 1);
+ return options;
+ }
+
+ nghttp2_session_callbacks* CreateCallbacks() {
+ nghttp2_session_callbacks* callbacks;
+ nghttp2_session_callbacks_new(&callbacks);
+
+ nghttp2_session_callbacks_set_on_begin_frame_callback(callbacks,
+ &OnBeginFrame);
+ nghttp2_session_callbacks_set_on_frame_recv_callback(callbacks,
+ &OnFrameReceived);
+ nghttp2_session_callbacks_set_on_begin_headers_callback(callbacks,
+ &OnBeginHeaders);
+ nghttp2_session_callbacks_set_on_header_callback2(callbacks, &OnHeader);
+ nghttp2_session_callbacks_set_on_data_chunk_recv_callback(callbacks,
+ &OnDataChunk);
+ nghttp2_session_callbacks_set_on_stream_close_callback(callbacks,
+ &OnStreamClosed);
+
+ nghttp2_session_callbacks_set_send_callback(callbacks, &SaveSessionOutput);
+ return callbacks;
+ }
+
+ DataSavingVisitor visitor_;
+};
+
+TEST_F(NgHttp2SessionTest, ClientConstruction) {
+ NgHttp2Session session(Perspective::kClient, CreateCallbacks(),
+ CreateOptions(), &visitor_);
+ EXPECT_TRUE(session.want_read());
+ EXPECT_FALSE(session.want_write());
+ EXPECT_EQ(session.GetRemoteWindowSize(), kDefaultInitialStreamWindowSize);
+ EXPECT_NE(session.raw_ptr(), nullptr);
+}
+
+TEST_F(NgHttp2SessionTest, ClientHandlesFrames) {
+ NgHttp2Session session(Perspective::kClient, CreateCallbacks(),
+ CreateOptions(), &visitor_);
+
+ ASSERT_EQ(0, nghttp2_session_send(session.raw_ptr()));
+ ASSERT_GT(visitor_.data().size(), 0);
+
+ const std::string initial_frames = TestFrameSequence()
+ .ServerPreface()
+ .Ping(42)
+ .WindowUpdate(0, 1000)
+ .Serialize();
+ testing::InSequence s;
+
+ // Server preface (empty SETTINGS)
+ EXPECT_CALL(visitor_, OnSettingsStart());
+ EXPECT_CALL(visitor_, OnSettingsEnd());
+
+ EXPECT_CALL(visitor_, OnPing(42, false));
+ EXPECT_CALL(visitor_, OnWindowUpdate(0, 1000));
+
+ const ssize_t initial_result = session.ProcessBytes(initial_frames);
+ EXPECT_EQ(initial_frames.size(), initial_result);
+
+ EXPECT_EQ(session.GetRemoteWindowSize(),
+ kDefaultInitialStreamWindowSize + 1000);
+ ASSERT_EQ(0, nghttp2_session_send(session.raw_ptr()));
+
+ const std::vector<Header> headers1 = {{":method", "GET"},
+ {":scheme", "http"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/one"}};
+ const auto nvs1 = GetRequestNghttp2Nvs(headers1);
+
+ const std::vector<Header> headers2 = {{":method", "GET"},
+ {":scheme", "http"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/two"}};
+ const auto nvs2 = GetRequestNghttp2Nvs(headers2);
+
+ const std::vector<Header> headers3 = {{":method", "GET"},
+ {":scheme", "http"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/three"}};
+ const auto nvs3 = GetRequestNghttp2Nvs(headers3);
+
+ const int32_t stream_id1 = nghttp2_submit_request(
+ session.raw_ptr(), nullptr, nvs1.data(), nvs1.size(), nullptr, nullptr);
+ ASSERT_GT(stream_id1, 0);
+ QUICHE_LOG(INFO) << "Created stream: " << stream_id1;
+
+ const int32_t stream_id2 = nghttp2_submit_request(
+ session.raw_ptr(), nullptr, nvs2.data(), nvs2.size(), nullptr, nullptr);
+ ASSERT_GT(stream_id2, 0);
+ QUICHE_LOG(INFO) << "Created stream: " << stream_id2;
+
+ const int32_t stream_id3 = nghttp2_submit_request(
+ session.raw_ptr(), nullptr, nvs3.data(), nvs3.size(), nullptr, nullptr);
+ ASSERT_GT(stream_id3, 0);
+ QUICHE_LOG(INFO) << "Created stream: " << stream_id3;
+
+ ASSERT_EQ(0, nghttp2_session_send(session.raw_ptr()));
+
+ const std::string stream_frames =
+ TestFrameSequence()
+ .Headers(1,
+ {{":status", "200"},
+ {"server", "my-fake-server"},
+ {"date", "Tue, 6 Apr 2021 12:54:01 GMT"}},
+ /*fin=*/false)
+ .Data(1, "This is the response body.")
+ .RstStream(3, Http2ErrorCode::INTERNAL_ERROR)
+ .GoAway(5, Http2ErrorCode::ENHANCE_YOUR_CALM, "calm down!!")
+ .Serialize();
+
+ EXPECT_CALL(visitor_, OnBeginHeadersForStream(1));
+ EXPECT_CALL(visitor_, OnHeaderForStream(1, ":status", "200"));
+ EXPECT_CALL(visitor_, OnHeaderForStream(1, "server", "my-fake-server"));
+ EXPECT_CALL(visitor_,
+ OnHeaderForStream(1, "date", "Tue, 6 Apr 2021 12:54:01 GMT"));
+ EXPECT_CALL(visitor_, OnEndHeadersForStream(1));
+ EXPECT_CALL(visitor_, OnBeginDataForStream(1, 26));
+ EXPECT_CALL(visitor_, OnDataForStream(1, "This is the response body."));
+ EXPECT_CALL(visitor_, OnRstStream(3, Http2ErrorCode::INTERNAL_ERROR));
+ EXPECT_CALL(visitor_, OnAbortStream(3, Http2ErrorCode::INTERNAL_ERROR));
+ EXPECT_CALL(visitor_,
+ OnGoAway(5, Http2ErrorCode::ENHANCE_YOUR_CALM, "calm down!!"));
+ const ssize_t stream_result = session.ProcessBytes(stream_frames);
+ EXPECT_EQ(stream_frames.size(), stream_result);
+ ASSERT_EQ(0, nghttp2_session_send(session.raw_ptr()));
+}
+
+TEST_F(NgHttp2SessionTest, ServerConstruction) {
+ NgHttp2Session session(Perspective::kServer, CreateCallbacks(),
+ CreateOptions(), &visitor_);
+ EXPECT_TRUE(session.want_read());
+ EXPECT_FALSE(session.want_write());
+ EXPECT_EQ(session.GetRemoteWindowSize(), kDefaultInitialStreamWindowSize);
+ EXPECT_NE(session.raw_ptr(), nullptr);
+}
+
+TEST_F(NgHttp2SessionTest, ServerHandlesFrames) {
+ NgHttp2Session session(Perspective::kServer, CreateCallbacks(),
+ CreateOptions(), &visitor_);
+
+ const std::string frames = TestFrameSequence()
+ .ClientPreface()
+ .Ping(42)
+ .WindowUpdate(0, 1000)
+ .Headers(1,
+ {{":method", "POST"},
+ {":scheme", "https"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/one"}},
+ /*fin=*/false)
+ .WindowUpdate(1, 2000)
+ .Data(1, "This is the request body.")
+ .Headers(3,
+ {{":method", "GET"},
+ {":scheme", "http"},
+ {":authority", "example.com"},
+ {":path", "/this/is/request/two"}},
+ /*fin=*/true)
+ .RstStream(3, Http2ErrorCode::CANCEL)
+ .Ping(47)
+ .Serialize();
+ testing::InSequence s;
+
+ // Client preface (empty SETTINGS)
+ EXPECT_CALL(visitor_, OnSettingsStart());
+ EXPECT_CALL(visitor_, OnSettingsEnd());
+
+ EXPECT_CALL(visitor_, OnPing(42, false));
+ EXPECT_CALL(visitor_, OnWindowUpdate(0, 1000));
+ EXPECT_CALL(visitor_, OnBeginHeadersForStream(1));
+ EXPECT_CALL(visitor_, OnHeaderForStream(1, ":method", "POST"));
+ EXPECT_CALL(visitor_, OnHeaderForStream(1, ":scheme", "https"));
+ EXPECT_CALL(visitor_, OnHeaderForStream(1, ":authority", "example.com"));
+ EXPECT_CALL(visitor_, OnHeaderForStream(1, ":path", "/this/is/request/one"));
+ EXPECT_CALL(visitor_, OnEndHeadersForStream(1));
+ EXPECT_CALL(visitor_, OnWindowUpdate(1, 2000));
+ EXPECT_CALL(visitor_, OnBeginDataForStream(1, 25));
+ EXPECT_CALL(visitor_, OnDataForStream(1, "This is the request body."));
+ EXPECT_CALL(visitor_, OnBeginHeadersForStream(3));
+ EXPECT_CALL(visitor_, OnHeaderForStream(3, ":method", "GET"));
+ EXPECT_CALL(visitor_, OnHeaderForStream(3, ":scheme", "http"));
+ EXPECT_CALL(visitor_, OnHeaderForStream(3, ":authority", "example.com"));
+ EXPECT_CALL(visitor_, OnHeaderForStream(3, ":path", "/this/is/request/two"));
+ EXPECT_CALL(visitor_, OnEndHeadersForStream(3));
+ EXPECT_CALL(visitor_, OnEndStream(3));
+ EXPECT_CALL(visitor_, OnRstStream(3, Http2ErrorCode::CANCEL));
+ EXPECT_CALL(visitor_, OnAbortStream(3, Http2ErrorCode::CANCEL));
+ EXPECT_CALL(visitor_, OnPing(47, false));
+
+ const ssize_t result = session.ProcessBytes(frames);
+ EXPECT_EQ(frames.size(), result);
+
+ EXPECT_EQ(session.GetRemoteWindowSize(),
+ kDefaultInitialStreamWindowSize + 1000);
+}
+
+} // namespace
+} // namespace test
+} // namespace adapter
+} // namespace http2
diff --git a/http2/adapter/nghttp2_util.cc b/http2/adapter/nghttp2_util.cc
index e134148..c191f4d 100644
--- a/http2/adapter/nghttp2_util.cc
+++ b/http2/adapter/nghttp2_util.cc
@@ -25,6 +25,10 @@
return absl::string_view(reinterpret_cast<const char*>(pointer), length);
}
+absl::string_view ToStringView(const uint8_t* pointer, size_t length) {
+ return absl::string_view(reinterpret_cast<const char*>(pointer), length);
+}
+
std::vector<nghttp2_nv> GetRequestNghttp2Nvs(absl::Span<const Header> headers) {
const int num_headers = headers.size();
auto nghttp2_nvs = std::vector<nghttp2_nv>(num_headers);
diff --git a/http2/adapter/nghttp2_util.h b/http2/adapter/nghttp2_util.h
index 3fcbfcd..b9c03bb 100644
--- a/http2/adapter/nghttp2_util.h
+++ b/http2/adapter/nghttp2_util.h
@@ -25,6 +25,7 @@
absl::string_view ToStringView(nghttp2_rcbuf* rc_buffer);
absl::string_view ToStringView(uint8_t* pointer, size_t length);
+absl::string_view ToStringView(const uint8_t* pointer, size_t length);
// Returns the nghttp2 header structure from the given request |headers|, which
// must have the correct pseudoheaders preceding other headers.
