1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
#ifndef QUICHE_HTTP2_ADAPTER_HTTP2_ADAPTER_H_
#define QUICHE_HTTP2_ADAPTER_HTTP2_ADAPTER_H_
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "absl/types/span.h"
#include "http2/adapter/http2_protocol.h"
#include "http2/adapter/http2_session.h"
#include "http2/adapter/http2_visitor_interface.h"
namespace http2 {
namespace adapter {
// Http2Adapter is an HTTP/2-processing class that exposes an interface similar
// to the nghttp2 library for processing the HTTP/2 wire format. As nghttp2
// parses HTTP/2 frames and invokes callbacks on Http2Adapter, Http2Adapter then
// invokes corresponding callbacks on its passed-in Http2VisitorInterface.
// Http2Adapter is a base class shared between client-side and server-side
// implementations.
class Http2Adapter {
public:
enum class Perspective {
kClient,
kServer,
};
Http2Adapter(const Http2Adapter&) = delete;
Http2Adapter& operator=(const Http2Adapter&) = delete;
// Processes the incoming |bytes| as HTTP/2 and invokes callbacks on the
// |visitor_| as appropriate.
virtual ssize_t ProcessBytes(absl::string_view bytes) = 0;
// Submits the |settings| to be written to the peer, e.g., as part of the
// HTTP/2 connection preface.
virtual void SubmitSettings(absl::Span<const Http2Setting> settings) = 0;
// Submits a PRIORITY frame for the given stream.
virtual void SubmitPriorityForStream(Http2StreamId stream_id,
Http2StreamId parent_stream_id,
int weight,
bool exclusive) = 0;
// Submits a PING on the connection. Note that nghttp2 automatically submits
// PING acks upon receiving non-ack PINGs from the peer, so callers only use
// this method to originate PINGs. See nghttp2_option_set_no_auto_ping_ack().
virtual void SubmitPing(Http2PingId ping_id) = 0;
// Submits a GOAWAY on the connection. Note that |last_accepted_stream_id|
// refers to stream IDs initiated by the peer. For client-side, this last
// stream ID must be even (or 0); for server-side, this last stream ID must be
// odd (or 0). To submit a GOAWAY with |last_accepted_stream_id| with the
// maximum stream ID, signaling imminent connection termination, call
// SubmitShutdownNotice() instead (though this is only possible server-side).
virtual void SubmitGoAway(Http2StreamId last_accepted_stream_id,
Http2ErrorCode error_code,
absl::string_view opaque_data) = 0;
// Submits a WINDOW_UPDATE for the given stream (a |stream_id| of 0 indicates
// a connection-level WINDOW_UPDATE).
virtual void SubmitWindowUpdate(Http2StreamId stream_id,
int window_increment) = 0;
// Submits a METADATA frame for the given stream (a |stream_id| of 0 indicates
// connection-level METADATA). If |fin|, the frame will also have the
// END_METADATA flag set.
virtual void SubmitMetadata(Http2StreamId stream_id, bool fin) = 0;
// Returns serialized bytes for writing to the wire.
// Writes should be submitted to Http2Adapter first, so that Http2Adapter
// has data to serialize and return in this method.
virtual std::string GetBytesToWrite(absl::optional<size_t> max_bytes) = 0;
// Returns the connection-level flow control window for the peer.
virtual int GetPeerConnectionWindow() const = 0;
// Marks the given amount of data as consumed for the given stream, which
// enables the nghttp2 layer to trigger WINDOW_UPDATEs as appropriate.
virtual void MarkDataConsumedForStream(Http2StreamId stream_id,
size_t num_bytes) = 0;
protected:
// Subclasses should expose a public factory method for constructing and
// initializing (via Initialize()) adapter instances.
explicit Http2Adapter(Http2VisitorInterface& visitor) : visitor_(visitor) {}
virtual ~Http2Adapter() {}
// Accessors. Do not transfer ownership.
Http2VisitorInterface& visitor() { return visitor_; }
private:
// Http2Adapter will invoke callbacks upon the |visitor_| while processing.
Http2VisitorInterface& visitor_;
};
} // namespace adapter
} // namespace http2
#endif // QUICHE_HTTP2_ADAPTER_HTTP2_ADAPTER_H_
|
