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"
8 #include "net/quic/quic_spdy_decompressor.h"
10 using base::StringPiece;
16 const QuicStreamId kInvalidStreamId = 0;
20 // A SpdyFramer visitor which passed SYN_STREAM and SYN_REPLY frames to
21 // the QuicDataStream, and closes the connection if any unexpected frames
23 class QuicHeadersStream::SpdyFramerVisitor
24 : public SpdyFramerVisitorInterface,
25 public SpdyFramerDebugVisitorInterface {
27 explicit SpdyFramerVisitor(QuicHeadersStream* stream) : stream_(stream) {}
29 // SpdyFramerVisitorInterface implementation
30 virtual void OnSynStream(SpdyStreamId stream_id,
31 SpdyStreamId associated_stream_id,
32 SpdyPriority priority,
33 uint8 credential_slot,
35 bool unidirectional) OVERRIDE {
36 if (!stream_->IsConnected()) {
40 if (associated_stream_id != 0) {
41 CloseConnection("associated_stream_id != 0");
45 if (credential_slot != 0) {
46 CloseConnection("credential_slot != 0");
50 if (unidirectional != 0) {
51 CloseConnection("unidirectional != 0");
55 stream_->OnSynStream(stream_id, priority, fin);
58 virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
59 if (!stream_->IsConnected()) {
63 stream_->OnSynReply(stream_id, fin);
66 virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
67 const char* header_data,
68 size_t len) OVERRIDE {
69 if (!stream_->IsConnected()) {
72 stream_->OnControlFrameHeaderData(stream_id, header_data, len);
76 virtual void OnStreamFrameData(SpdyStreamId stream_id,
80 if (fin && len == 0) {
81 // The framer invokes OnStreamFrameData with zero-length data and
82 // fin = true after processing a SYN_STREAM or SYN_REPLY frame
83 // that had the fin bit set.
86 CloseConnection("SPDY DATA frame recevied.");
89 virtual void OnError(SpdyFramer* framer) OVERRIDE {
90 CloseConnection("SPDY framing error.");
93 virtual void OnDataFrameHeader(SpdyStreamId stream_id,
96 CloseConnection("SPDY DATA frame recevied.");
99 virtual void OnRstStream(SpdyStreamId stream_id,
100 SpdyRstStreamStatus status) OVERRIDE {
101 CloseConnection("SPDY RST_STREAM frame recevied.");
104 virtual void OnSetting(SpdySettingsIds id,
106 uint32 value) OVERRIDE {
107 CloseConnection("SPDY SETTINGS frame recevied.");
110 virtual void OnPing(uint32 unique_id) OVERRIDE {
111 CloseConnection("SPDY PING frame recevied.");
114 virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
115 SpdyGoAwayStatus status) OVERRIDE {
116 CloseConnection("SPDY GOAWAY frame recevied.");
119 virtual void OnHeaders(SpdyStreamId stream_id, bool fin) OVERRIDE {
120 CloseConnection("SPDY HEADERS frame recevied.");
123 virtual void OnWindowUpdate(SpdyStreamId stream_id,
124 uint32 delta_window_size) OVERRIDE {
125 CloseConnection("SPDY WINDOW_UPDATE frame recevied.");
128 virtual void OnPushPromise(SpdyStreamId stream_id,
129 SpdyStreamId promised_stream_id) OVERRIDE {
130 LOG(DFATAL) << "PUSH_PROMISE frame received from a SPDY/3 framer";
131 CloseConnection("SPDY PUSH_PROMISE frame recevied.");
134 // SpdyFramerDebugVisitorInterface implementation
135 virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
138 size_t frame_len) OVERRIDE {}
140 virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
142 size_t frame_len) OVERRIDE {
143 if (stream_->IsConnected()) {
144 stream_->OnCompressedFrameSize(frame_len);
149 void CloseConnection(const string& details) {
150 if (stream_->IsConnected()) {
151 stream_->CloseConnectionWithDetails(
152 QUIC_INVALID_HEADERS_STREAM_DATA, details);
157 QuicHeadersStream* stream_;
159 DISALLOW_COPY_AND_ASSIGN(SpdyFramerVisitor);
162 QuicHeadersStream::QuicHeadersStream(QuicSession* session)
163 : ReliableQuicStream(kHeadersStreamId, session),
164 stream_id_(kInvalidStreamId),
168 spdy_framer_visitor_(new SpdyFramerVisitor(this)) {
169 spdy_framer_.set_visitor(spdy_framer_visitor_.get());
170 spdy_framer_.set_debug_visitor(spdy_framer_visitor_.get());
173 QuicHeadersStream::~QuicHeadersStream() {}
175 size_t QuicHeadersStream::WriteHeaders(QuicStreamId stream_id,
176 const SpdyHeaderBlock& headers,
178 scoped_ptr<SpdySerializedFrame> frame;
179 if (session()->is_server()) {
180 SpdySynReplyIR syn_reply(stream_id);
181 syn_reply.set_name_value_block(headers);
182 syn_reply.set_fin(fin);
183 frame.reset(spdy_framer_.SerializeFrame(syn_reply));
185 SpdySynStreamIR syn_stream(stream_id);
186 syn_stream.set_name_value_block(headers);
187 syn_stream.set_fin(fin);
188 frame.reset(spdy_framer_.SerializeFrame(syn_stream));
190 WriteOrBufferData(StringPiece(frame->data(), frame->size()), false);
191 return frame->size();
194 uint32 QuicHeadersStream::ProcessRawData(const char* data,
196 return spdy_framer_.ProcessInput(data, data_len);
199 QuicPriority QuicHeadersStream::EffectivePriority() const { return 0; }
201 void QuicHeadersStream::OnSynStream(SpdyStreamId stream_id,
202 SpdyPriority priority,
204 if (!session()->is_server()) {
205 CloseConnectionWithDetails(
206 QUIC_INVALID_HEADERS_STREAM_DATA,
207 "SPDY SYN_STREAM frame recevied at the client");
210 DCHECK_EQ(kInvalidStreamId, stream_id_);
211 stream_id_ = stream_id;
213 session()->OnStreamHeadersPriority(stream_id, priority);
216 void QuicHeadersStream::OnSynReply(SpdyStreamId stream_id, bool fin) {
217 if (session()->is_server()) {
218 CloseConnectionWithDetails(
219 QUIC_INVALID_HEADERS_STREAM_DATA,
220 "SPDY SYN_REPLY frame recevied at the server");
223 DCHECK_EQ(kInvalidStreamId, stream_id_);
224 stream_id_ = stream_id;
228 void QuicHeadersStream::OnControlFrameHeaderData(SpdyStreamId stream_id,
229 const char* header_data,
231 DCHECK_EQ(stream_id_, stream_id);
233 DCHECK_NE(0u, stream_id_);
234 DCHECK_NE(0u, frame_len_);
235 session()->OnStreamHeadersComplete(stream_id_, fin_, frame_len_);
236 // Reset state for the next frame.
237 stream_id_ = kInvalidStreamId;
241 session()->OnStreamHeaders(stream_id_, StringPiece(header_data, len));
245 void QuicHeadersStream::OnCompressedFrameSize(size_t frame_len) {
246 DCHECK_EQ(kInvalidStreamId, stream_id_);
247 DCHECK_EQ(0u, frame_len_);
248 frame_len_ = frame_len;
251 bool QuicHeadersStream::IsConnected() {
252 return session()->connection()->connected();