net/quic/quic_headers_stream.cc

   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.
   4
   5 #include "net/quic/quic_headers_stream.h"
   6
   7 #include "base/strings/stringprintf.h"
   8 #include "net/quic/quic_spdy_session.h"
   9
  10 using base::StringPiece;
  11 using std::string;
  12
  13 namespace net {
  14
  15 namespace {
  16
  17 const QuicStreamId kInvalidStreamId = 0;
  18
  19 }  // namespace
  20
  21 // A SpdyFramer visitor which passed SYN_STREAM and SYN_REPLY frames to
  22 // the QuicDataStream, and closes the connection if any unexpected frames
  23 // are received.
  24 class QuicHeadersStream::SpdyFramerVisitor
  25     : public SpdyFramerVisitorInterface,
  26       public SpdyFramerDebugVisitorInterface {
  27  public:
  28   SpdyFramerVisitor(SpdyMajorVersion spdy_version, QuicHeadersStream* stream)
  29       : spdy_version_(spdy_version), stream_(stream) {}
  30
  31   // SpdyFramerVisitorInterface implementation
  32   void OnSynStream(SpdyStreamId stream_id,
  33                    SpdyStreamId associated_stream_id,
  34                    SpdyPriority priority,
  35                    bool fin,
  36                    bool unidirectional) override {
  37     CloseConnection("SPDY SYN_STREAM frame received.");
  38   }
  39
  40   void OnSynReply(SpdyStreamId stream_id, bool fin) override {
  41     CloseConnection("SPDY SYN_REPLY frame received.");
  42   }
  43
  44   bool OnControlFrameHeaderData(SpdyStreamId stream_id,
  45                                 const char* header_data,
  46                                 size_t len) override {
  47     if (!stream_->IsConnected()) {
  48       return false;
  49     }
  50     stream_->OnControlFrameHeaderData(stream_id, header_data, len);
  51     return true;
  52   }
  53
  54   void OnStreamFrameData(SpdyStreamId stream_id,
  55                          const char* data,
  56                          size_t len,
  57                          bool fin) override {
  58     if (fin && len == 0) {
  59       // The framer invokes OnStreamFrameData with zero-length data and
  60       // fin = true after processing a SYN_STREAM or SYN_REPLY frame
  61       // that had the fin bit set.
  62       return;
  63     }
  64     CloseConnection("SPDY DATA frame received.");
  65   }
  66
  67   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
  68     CloseConnection("SPDY frame padding received.");
  69   }
  70
  71   void OnError(SpdyFramer* framer) override {
  72     CloseConnection(base::StringPrintf(
  73         "SPDY framing error: %s",
  74         SpdyFramer::ErrorCodeToString(framer->error_code())));
  75   }
  76
  77   void OnDataFrameHeader(SpdyStreamId stream_id,
  78                          size_t length,
  79                          bool fin) override {
  80     CloseConnection("SPDY DATA frame received.");
  81   }
  82
  83   void OnRstStream(SpdyStreamId stream_id,
  84                    SpdyRstStreamStatus status) override {
  85     CloseConnection("SPDY RST_STREAM frame received.");
  86   }
  87
  88   void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {
  89     CloseConnection("SPDY SETTINGS frame received.");
  90   }
  91
  92   void OnSettingsAck() override {
  93     CloseConnection("SPDY SETTINGS frame received.");
  94   }
  95
  96   void OnSettingsEnd() override {
  97     CloseConnection("SPDY SETTINGS frame received.");
  98   }
  99
 100   void OnPing(SpdyPingId unique_id, bool is_ack) override {
 101     CloseConnection("SPDY PING frame received.");
 102   }
 103
 104   void OnGoAway(SpdyStreamId last_accepted_stream_id,
 105                 SpdyGoAwayStatus status) override {
 106     CloseConnection("SPDY GOAWAY frame received.");
 107   }
 108
 109   void OnHeaders(SpdyStreamId stream_id,
 110                  bool has_priority,
 111                  SpdyPriority priority,
 112                  bool fin,
 113                  bool end) override {
 114     if (!stream_->IsConnected()) {
 115       return;
 116     }
 117     if (has_priority) {
 118       stream_->OnSynStream(stream_id, priority, fin);
 119     } else {
 120       stream_->OnSynReply(stream_id, fin);
 121     }
 122   }
 123
 124   void OnWindowUpdate(SpdyStreamId stream_id,
 125                       uint32 delta_window_size) override {
 126     CloseConnection("SPDY WINDOW_UPDATE frame received.");
 127   }
 128
 129   void OnPushPromise(SpdyStreamId stream_id,
 130                      SpdyStreamId promised_stream_id,
 131                      bool end) override {
 132     CloseConnection("SPDY PUSH_PROMISE frame received.");
 133   }
 134
 135   void OnContinuation(SpdyStreamId stream_id, bool end) override {
 136   }
 137
 138   bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
 139     CloseConnection("Unknown frame type received.");
 140     return false;
 141   }
 142
 143   // SpdyFramerDebugVisitorInterface implementation
 144   void OnSendCompressedFrame(SpdyStreamId stream_id,
 145                              SpdyFrameType type,
 146                              size_t payload_len,
 147                              size_t frame_len) override {}
 148
 149   void OnReceiveCompressedFrame(SpdyStreamId stream_id,
 150                                 SpdyFrameType type,
 151                                 size_t frame_len) override {
 152     if (stream_->IsConnected()) {
 153       stream_->OnCompressedFrameSize(frame_len);
 154     }
 155   }
 156
 157  private:
 158   void CloseConnection(const string& details) {
 159     if (stream_->IsConnected()) {
 160       stream_->CloseConnectionWithDetails(
 161           QUIC_INVALID_HEADERS_STREAM_DATA, details);
 162     }
 163   }
 164
 165  private:
 166   SpdyMajorVersion spdy_version_;
 167   QuicHeadersStream* stream_;
 168
 169   DISALLOW_COPY_AND_ASSIGN(SpdyFramerVisitor);
 170 };
 171
 172 QuicHeadersStream::QuicHeadersStream(QuicSpdySession* session)
 173     : ReliableQuicStream(kHeadersStreamId, session),
 174       spdy_session_(session),
 175       stream_id_(kInvalidStreamId),
 176       fin_(false),
 177       frame_len_(0),
 178       spdy_framer_(HTTP2),
 179       spdy_framer_visitor_(new SpdyFramerVisitor(HTTP2, this)) {
 180   spdy_framer_.set_visitor(spdy_framer_visitor_.get());
 181   spdy_framer_.set_debug_visitor(spdy_framer_visitor_.get());
 182   // The headers stream is exempt from connection level flow control.
 183   DisableConnectionFlowControlForThisStream();
 184 }
 185
 186 QuicHeadersStream::~QuicHeadersStream() {}
 187
 188 size_t QuicHeadersStream::WriteHeaders(
 189     QuicStreamId stream_id,
 190     const SpdyHeaderBlock& headers,
 191     bool fin,
 192     QuicPriority priority,
 193     QuicAckNotifier::DelegateInterface* ack_notifier_delegate) {
 194   SpdyHeadersIR headers_frame(stream_id);
 195   headers_frame.set_name_value_block(headers);
 196   headers_frame.set_fin(fin);
 197   if (session()->perspective() == Perspective::IS_CLIENT) {
 198     headers_frame.set_has_priority(true);
 199     headers_frame.set_priority(priority);
 200   }
 201   scoped_ptr<SpdySerializedFrame> frame(
 202       spdy_framer_.SerializeFrame(headers_frame));
 203   WriteOrBufferData(StringPiece(frame->data(), frame->size()), false,
 204                     ack_notifier_delegate);
 205   return frame->size();
 206 }
 207
 208 uint32 QuicHeadersStream::ProcessRawData(const char* data,
 209                                          uint32 data_len) {
 210   return spdy_framer_.ProcessInput(data, data_len);
 211 }
 212
 213 QuicPriority QuicHeadersStream::EffectivePriority() const { return 0; }
 214
 215 void QuicHeadersStream::OnSynStream(SpdyStreamId stream_id,
 216                                     SpdyPriority priority,
 217                                     bool fin) {
 218   if (session()->perspective() == Perspective::IS_CLIENT) {
 219     CloseConnectionWithDetails(
 220         QUIC_INVALID_HEADERS_STREAM_DATA,
 221         "SPDY SYN_STREAM frame received at the client");
 222     return;
 223   }
 224   DCHECK_EQ(kInvalidStreamId, stream_id_);
 225   stream_id_ = stream_id;
 226   fin_ = fin;
 227   spdy_session_->OnStreamHeadersPriority(stream_id, priority);
 228 }
 229
 230 void QuicHeadersStream::OnSynReply(SpdyStreamId stream_id, bool fin) {
 231   if (session()->perspective() == Perspective::IS_SERVER) {
 232     CloseConnectionWithDetails(
 233         QUIC_INVALID_HEADERS_STREAM_DATA,
 234         "SPDY SYN_REPLY frame received at the server");
 235     return;
 236   }
 237   DCHECK_EQ(kInvalidStreamId, stream_id_);
 238   stream_id_ = stream_id;
 239   fin_ = fin;
 240 }
 241
 242 void QuicHeadersStream::OnControlFrameHeaderData(SpdyStreamId stream_id,
 243                                                  const char* header_data,
 244                                                  size_t len) {
 245   DCHECK_EQ(stream_id_, stream_id);
 246   if (len == 0) {
 247     DCHECK_NE(0u, stream_id_);
 248     DCHECK_NE(0u, frame_len_);
 249     spdy_session_->OnStreamHeadersComplete(stream_id_, fin_, frame_len_);
 250     // Reset state for the next frame.
 251     stream_id_ = kInvalidStreamId;
 252     fin_ = false;
 253     frame_len_ = 0;
 254   } else {
 255     spdy_session_->OnStreamHeaders(stream_id_, StringPiece(header_data, len));
 256   }
 257 }
 258
 259 void QuicHeadersStream::OnCompressedFrameSize(size_t frame_len) {
 260   frame_len_ += frame_len;
 261 }
 262
 263 bool QuicHeadersStream::IsConnected() {
 264   return session()->connection()->connected();
 265 }
 266
 267 }  // namespace net