1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "net/quic/quic_headers_stream.h"
7 #include "net/quic/quic_session.h"
9 using base::StringPiece;
15 const QuicStreamId kInvalidStreamId = 0;
19 // A SpdyFramer visitor which passed SYN_STREAM and SYN_REPLY frames to
20 // the QuicDataStream, and closes the connection if any unexpected frames
22 class QuicHeadersStream::SpdyFramerVisitor
23 : public SpdyFramerVisitorInterface,
24 public SpdyFramerDebugVisitorInterface {
26 explicit SpdyFramerVisitor(QuicHeadersStream* stream) : stream_(stream) {}
28 // SpdyFramerVisitorInterface implementation
29 virtual void OnSynStream(SpdyStreamId stream_id,
30 SpdyStreamId associated_stream_id,
31 SpdyPriority priority,
33 bool unidirectional) OVERRIDE {
34 if (!stream_->IsConnected()) {
38 if (associated_stream_id != 0) {
39 CloseConnection("associated_stream_id != 0");
43 if (unidirectional != 0) {
44 CloseConnection("unidirectional != 0");
48 stream_->OnSynStream(stream_id, priority, fin);
51 virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
52 if (!stream_->IsConnected()) {
56 stream_->OnSynReply(stream_id, fin);
59 virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
60 const char* header_data,
61 size_t len) OVERRIDE {
62 if (!stream_->IsConnected()) {
65 stream_->OnControlFrameHeaderData(stream_id, header_data, len);
69 virtual void OnStreamFrameData(SpdyStreamId stream_id,
73 if (fin && len == 0) {
74 // The framer invokes OnStreamFrameData with zero-length data and
75 // fin = true after processing a SYN_STREAM or SYN_REPLY frame
76 // that had the fin bit set.
79 CloseConnection("SPDY DATA frame received.");
82 virtual void OnError(SpdyFramer* framer) OVERRIDE {
83 CloseConnection("SPDY framing error.");
86 virtual void OnDataFrameHeader(SpdyStreamId stream_id,
89 CloseConnection("SPDY DATA frame received.");
92 virtual void OnRstStream(SpdyStreamId stream_id,
93 SpdyRstStreamStatus status) OVERRIDE {
94 CloseConnection("SPDY RST_STREAM frame received.");
97 virtual void OnSetting(SpdySettingsIds id,
99 uint32 value) OVERRIDE {
100 CloseConnection("SPDY SETTINGS frame received.");
103 virtual void OnSettingsAck() OVERRIDE {
104 CloseConnection("SPDY SETTINGS frame received.");
107 virtual void OnSettingsEnd() OVERRIDE {
108 CloseConnection("SPDY SETTINGS frame received.");
111 virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {
112 CloseConnection("SPDY PING frame received.");
115 virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
116 SpdyGoAwayStatus status) OVERRIDE {
117 CloseConnection("SPDY GOAWAY frame received.");
120 virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) OVERRIDE {
121 CloseConnection("SPDY HEADERS frame received.");
124 virtual void OnWindowUpdate(SpdyStreamId stream_id,
125 uint32 delta_window_size) OVERRIDE {
126 CloseConnection("SPDY WINDOW_UPDATE frame received.");
129 virtual void OnPushPromise(SpdyStreamId stream_id,
130 SpdyStreamId promised_stream_id,
132 LOG(DFATAL) << "PUSH_PROMISE frame received from a SPDY/3 framer";
133 CloseConnection("SPDY PUSH_PROMISE frame received.");
136 virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
137 CloseConnection("SPDY CONTINUATION frame received.");
140 virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE {
141 CloseConnection("SPDY unknown frame received.");
145 // SpdyFramerDebugVisitorInterface implementation
146 virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
149 size_t frame_len) OVERRIDE {}
151 virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
153 size_t frame_len) OVERRIDE {
154 if (stream_->IsConnected()) {
155 stream_->OnCompressedFrameSize(frame_len);
160 void CloseConnection(const string& details) {
161 if (stream_->IsConnected()) {
162 stream_->CloseConnectionWithDetails(
163 QUIC_INVALID_HEADERS_STREAM_DATA, details);
168 QuicHeadersStream* stream_;
170 DISALLOW_COPY_AND_ASSIGN(SpdyFramerVisitor);
173 QuicHeadersStream::QuicHeadersStream(QuicSession* session)
174 : ReliableQuicStream(kHeadersStreamId, session),
175 stream_id_(kInvalidStreamId),
179 spdy_framer_visitor_(new SpdyFramerVisitor(this)) {
180 spdy_framer_.set_visitor(spdy_framer_visitor_.get());
181 spdy_framer_.set_debug_visitor(spdy_framer_visitor_.get());
182 if (version() < QUIC_VERSION_21) {
183 // Prior to QUIC_VERSION_21 the headers stream is not subject to any flow
185 DisableFlowControl();
187 // The headers stream is exempt from connection level flow control.
188 DisableConnectionFlowControlForThisStream();
191 QuicHeadersStream::~QuicHeadersStream() {}
193 size_t QuicHeadersStream::WriteHeaders(
194 QuicStreamId stream_id,
195 const SpdyHeaderBlock& headers,
197 QuicAckNotifier::DelegateInterface* ack_notifier_delegate) {
198 scoped_ptr<SpdySerializedFrame> frame;
199 if (session()->is_server()) {
200 SpdySynReplyIR syn_reply(stream_id);
201 syn_reply.set_name_value_block(headers);
202 syn_reply.set_fin(fin);
203 frame.reset(spdy_framer_.SerializeFrame(syn_reply));
205 SpdySynStreamIR syn_stream(stream_id);
206 syn_stream.set_name_value_block(headers);
207 syn_stream.set_fin(fin);
208 frame.reset(spdy_framer_.SerializeFrame(syn_stream));
210 WriteOrBufferData(StringPiece(frame->data(), frame->size()), false,
211 ack_notifier_delegate);
212 return frame->size();
215 uint32 QuicHeadersStream::ProcessRawData(const char* data,
217 return spdy_framer_.ProcessInput(data, data_len);
220 QuicPriority QuicHeadersStream::EffectivePriority() const { return 0; }
222 void QuicHeadersStream::OnSynStream(SpdyStreamId stream_id,
223 SpdyPriority priority,
225 if (!session()->is_server()) {
226 CloseConnectionWithDetails(
227 QUIC_INVALID_HEADERS_STREAM_DATA,
228 "SPDY SYN_STREAM frame received at the client");
231 DCHECK_EQ(kInvalidStreamId, stream_id_);
232 stream_id_ = stream_id;
234 session()->OnStreamHeadersPriority(stream_id, priority);
237 void QuicHeadersStream::OnSynReply(SpdyStreamId stream_id, bool fin) {
238 if (session()->is_server()) {
239 CloseConnectionWithDetails(
240 QUIC_INVALID_HEADERS_STREAM_DATA,
241 "SPDY SYN_REPLY frame received at the server");
244 DCHECK_EQ(kInvalidStreamId, stream_id_);
245 stream_id_ = stream_id;
249 void QuicHeadersStream::OnControlFrameHeaderData(SpdyStreamId stream_id,
250 const char* header_data,
252 DCHECK_EQ(stream_id_, stream_id);
254 DCHECK_NE(0u, stream_id_);
255 DCHECK_NE(0u, frame_len_);
256 session()->OnStreamHeadersComplete(stream_id_, fin_, frame_len_);
257 // Reset state for the next frame.
258 stream_id_ = kInvalidStreamId;
262 session()->OnStreamHeaders(stream_id_, StringPiece(header_data, len));
266 void QuicHeadersStream::OnCompressedFrameSize(size_t frame_len) {
267 DCHECK_EQ(kInvalidStreamId, stream_id_);
268 DCHECK_EQ(0u, frame_len_);
269 frame_len_ = frame_len;
272 bool QuicHeadersStream::IsConnected() {
273 return session()->connection()->connected();