net/spdy/buffered_spdy_framer.cc

   1 // Copyright (c) 2012 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/spdy/buffered_spdy_framer.h"
   6
   7 #include "base/logging.h"
   8
   9 namespace net {
  10
  11 SpdyMajorVersion NextProtoToSpdyMajorVersion(NextProto next_proto) {
  12   switch (next_proto) {
  13     case kProtoSPDY2:
  14     case kProtoSPDY21:
  15       return SPDY2;
  16     case kProtoSPDY3:
  17     case kProtoSPDY31:
  18       return SPDY3;
  19     // SPDY/4 and HTTP/2 share the same framing for now.
  20     case kProtoSPDY4a2:
  21     case kProtoHTTP2Draft04:
  22       return SPDY4;
  23     case kProtoUnknown:
  24     case kProtoHTTP11:
  25     case kProtoSPDY1:
  26     case kProtoQUIC1SPDY3:
  27       break;
  28   }
  29   NOTREACHED();
  30   return SPDY2;
  31 }
  32
  33 BufferedSpdyFramer::BufferedSpdyFramer(SpdyMajorVersion version,
  34                                        bool enable_compression)
  35     : spdy_framer_(version),
  36       visitor_(NULL),
  37       header_buffer_used_(0),
  38       header_buffer_valid_(false),
  39       header_stream_id_(SpdyFramer::kInvalidStream),
  40       frames_received_(0) {
  41   spdy_framer_.set_enable_compression(enable_compression);
  42   memset(header_buffer_, 0, sizeof(header_buffer_));
  43 }
  44
  45 BufferedSpdyFramer::~BufferedSpdyFramer() {
  46 }
  47
  48 void BufferedSpdyFramer::set_visitor(
  49     BufferedSpdyFramerVisitorInterface* visitor) {
  50   visitor_ = visitor;
  51   spdy_framer_.set_visitor(this);
  52 }
  53
  54 void BufferedSpdyFramer::set_debug_visitor(
  55     SpdyFramerDebugVisitorInterface* debug_visitor) {
  56   spdy_framer_.set_debug_visitor(debug_visitor);
  57 }
  58
  59 void BufferedSpdyFramer::OnError(SpdyFramer* spdy_framer) {
  60   DCHECK(spdy_framer);
  61   visitor_->OnError(spdy_framer->error_code());
  62 }
  63
  64 void BufferedSpdyFramer::OnSynStream(SpdyStreamId stream_id,
  65                                      SpdyStreamId associated_stream_id,
  66                                      SpdyPriority priority,
  67                                      uint8 credential_slot,
  68                                      bool fin,
  69                                      bool unidirectional) {
  70   frames_received_++;
  71   DCHECK(!control_frame_fields_.get());
  72   control_frame_fields_.reset(new ControlFrameFields());
  73   control_frame_fields_->type = SYN_STREAM;
  74   control_frame_fields_->stream_id = stream_id;
  75   control_frame_fields_->associated_stream_id = associated_stream_id;
  76   control_frame_fields_->priority = priority;
  77   control_frame_fields_->credential_slot = credential_slot;
  78   control_frame_fields_->fin = fin;
  79   control_frame_fields_->unidirectional = unidirectional;
  80
  81   InitHeaderStreaming(stream_id);
  82 }
  83
  84 void BufferedSpdyFramer::OnHeaders(SpdyStreamId stream_id,
  85                                    bool fin) {
  86   frames_received_++;
  87   DCHECK(!control_frame_fields_.get());
  88   control_frame_fields_.reset(new ControlFrameFields());
  89   control_frame_fields_->type = HEADERS;
  90   control_frame_fields_->stream_id = stream_id;
  91   control_frame_fields_->fin = fin;
  92
  93   InitHeaderStreaming(stream_id);
  94 }
  95
  96 void BufferedSpdyFramer::OnSynReply(SpdyStreamId stream_id,
  97                                     bool fin) {
  98   frames_received_++;
  99   DCHECK(!control_frame_fields_.get());
 100   control_frame_fields_.reset(new ControlFrameFields());
 101   control_frame_fields_->type = SYN_REPLY;
 102   control_frame_fields_->stream_id = stream_id;
 103   control_frame_fields_->fin = fin;
 104
 105   InitHeaderStreaming(stream_id);
 106 }
 107
 108 bool BufferedSpdyFramer::OnCredentialFrameData(const char* frame_data,
 109                                                size_t len) {
 110   DCHECK(false);
 111   return false;
 112 }
 113
 114 bool BufferedSpdyFramer::OnControlFrameHeaderData(SpdyStreamId stream_id,
 115                                                   const char* header_data,
 116                                                   size_t len) {
 117   CHECK_EQ(header_stream_id_, stream_id);
 118
 119   if (len == 0) {
 120     // Indicates end-of-header-block.
 121     CHECK(header_buffer_valid_);
 122
 123     SpdyHeaderBlock headers;
 124     size_t parsed_len = spdy_framer_.ParseHeaderBlockInBuffer(
 125         header_buffer_, header_buffer_used_, &headers);
 126     // TODO(rch): this really should be checking parsed_len != len,
 127     // but a bunch of tests fail.  Need to figure out why.
 128     if (parsed_len == 0) {
 129       visitor_->OnStreamError(
 130           stream_id, "Could not parse Spdy Control Frame Header.");
 131       return false;
 132     }
 133     DCHECK(control_frame_fields_.get());
 134     switch (control_frame_fields_->type) {
 135       case SYN_STREAM:
 136         visitor_->OnSynStream(control_frame_fields_->stream_id,
 137                               control_frame_fields_->associated_stream_id,
 138                               control_frame_fields_->priority,
 139                               control_frame_fields_->credential_slot,
 140                               control_frame_fields_->fin,
 141                               control_frame_fields_->unidirectional,
 142                               headers);
 143         break;
 144       case SYN_REPLY:
 145         visitor_->OnSynReply(control_frame_fields_->stream_id,
 146                              control_frame_fields_->fin,
 147                              headers);
 148         break;
 149       case HEADERS:
 150         visitor_->OnHeaders(control_frame_fields_->stream_id,
 151                             control_frame_fields_->fin,
 152                             headers);
 153         break;
 154       default:
 155         DCHECK(false) << "Unexpect control frame type: "
 156                       << control_frame_fields_->type;
 157         break;
 158     }
 159     control_frame_fields_.reset(NULL);
 160     return true;
 161   }
 162
 163   const size_t available = kHeaderBufferSize - header_buffer_used_;
 164   if (len > available) {
 165     header_buffer_valid_ = false;
 166     visitor_->OnStreamError(
 167         stream_id, "Received more data than the allocated size.");
 168     return false;
 169   }
 170   memcpy(header_buffer_ + header_buffer_used_, header_data, len);
 171   header_buffer_used_ += len;
 172   return true;
 173 }
 174
 175 void BufferedSpdyFramer::OnDataFrameHeader(SpdyStreamId stream_id,
 176                                            size_t length,
 177                                            bool fin) {
 178   frames_received_++;
 179   header_stream_id_ = stream_id;
 180 }
 181
 182 void BufferedSpdyFramer::OnStreamFrameData(SpdyStreamId stream_id,
 183                                            const char* data,
 184                                            size_t len,
 185                                            bool fin) {
 186   visitor_->OnStreamFrameData(stream_id, data, len, fin);
 187 }
 188
 189 void BufferedSpdyFramer::OnSettings(bool clear_persisted) {
 190   visitor_->OnSettings(clear_persisted);
 191 }
 192
 193 void BufferedSpdyFramer::OnSetting(SpdySettingsIds id,
 194                                    uint8 flags,
 195                                    uint32 value) {
 196   visitor_->OnSetting(id, flags, value);
 197 }
 198
 199 void BufferedSpdyFramer::OnPing(uint32 unique_id) {
 200   visitor_->OnPing(unique_id);
 201 }
 202
 203 void BufferedSpdyFramer::OnRstStream(SpdyStreamId stream_id,
 204                                      SpdyRstStreamStatus status) {
 205   visitor_->OnRstStream(stream_id, status);
 206 }
 207 void BufferedSpdyFramer::OnGoAway(SpdyStreamId last_accepted_stream_id,
 208                                   SpdyGoAwayStatus status) {
 209   visitor_->OnGoAway(last_accepted_stream_id, status);
 210 }
 211
 212 void BufferedSpdyFramer::OnWindowUpdate(SpdyStreamId stream_id,
 213                                         uint32 delta_window_size) {
 214   visitor_->OnWindowUpdate(stream_id, delta_window_size);
 215 }
 216
 217 void BufferedSpdyFramer::OnPushPromise(SpdyStreamId stream_id,
 218                                        SpdyStreamId promised_stream_id) {
 219   visitor_->OnPushPromise(stream_id, promised_stream_id);
 220 }
 221
 222 int BufferedSpdyFramer::protocol_version() {
 223   return spdy_framer_.protocol_version();
 224 }
 225
 226 size_t BufferedSpdyFramer::ProcessInput(const char* data, size_t len) {
 227   return spdy_framer_.ProcessInput(data, len);
 228 }
 229
 230 void BufferedSpdyFramer::Reset() {
 231   spdy_framer_.Reset();
 232 }
 233
 234 SpdyFramer::SpdyError BufferedSpdyFramer::error_code() const {
 235   return spdy_framer_.error_code();
 236 }
 237
 238 SpdyFramer::SpdyState BufferedSpdyFramer::state() const {
 239   return spdy_framer_.state();
 240 }
 241
 242 bool BufferedSpdyFramer::MessageFullyRead() {
 243   return state() == SpdyFramer::SPDY_AUTO_RESET;
 244 }
 245
 246 bool BufferedSpdyFramer::HasError() {
 247   return spdy_framer_.HasError();
 248 }
 249
 250 SpdyFrame* BufferedSpdyFramer::CreateSynStream(
 251     SpdyStreamId stream_id,
 252     SpdyStreamId associated_stream_id,
 253     SpdyPriority priority,
 254     uint8 credential_slot,
 255     SpdyControlFlags flags,
 256     bool compressed,
 257     const SpdyHeaderBlock* headers) {
 258   return spdy_framer_.CreateSynStream(stream_id, associated_stream_id, priority,
 259                                       credential_slot, flags, compressed,
 260                                       headers);
 261 }
 262
 263 SpdyFrame* BufferedSpdyFramer::CreateSynReply(
 264     SpdyStreamId stream_id,
 265     SpdyControlFlags flags,
 266     bool compressed,
 267     const SpdyHeaderBlock* headers) {
 268   return spdy_framer_.CreateSynReply(stream_id, flags, compressed, headers);
 269 }
 270
 271 SpdyFrame* BufferedSpdyFramer::CreateRstStream(
 272     SpdyStreamId stream_id,
 273     SpdyRstStreamStatus status) const {
 274   return spdy_framer_.CreateRstStream(stream_id, status);
 275 }
 276
 277 SpdyFrame* BufferedSpdyFramer::CreateSettings(
 278     const SettingsMap& values) const {
 279   return spdy_framer_.CreateSettings(values);
 280 }
 281
 282 SpdyFrame* BufferedSpdyFramer::CreatePingFrame(
 283     uint32 unique_id) const {
 284   return spdy_framer_.CreatePingFrame(unique_id);
 285 }
 286
 287 SpdyFrame* BufferedSpdyFramer::CreateGoAway(
 288     SpdyStreamId last_accepted_stream_id,
 289     SpdyGoAwayStatus status) const {
 290   return spdy_framer_.CreateGoAway(last_accepted_stream_id, status);
 291 }
 292
 293 SpdyFrame* BufferedSpdyFramer::CreateHeaders(
 294     SpdyStreamId stream_id,
 295     SpdyControlFlags flags,
 296     bool compressed,
 297     const SpdyHeaderBlock* headers) {
 298   return spdy_framer_.CreateHeaders(stream_id, flags, compressed, headers);
 299 }
 300
 301 SpdyFrame* BufferedSpdyFramer::CreateWindowUpdate(
 302     SpdyStreamId stream_id,
 303     uint32 delta_window_size) const {
 304   return spdy_framer_.CreateWindowUpdate(stream_id, delta_window_size);
 305 }
 306
 307 SpdyFrame* BufferedSpdyFramer::CreateCredentialFrame(
 308     const SpdyCredential& credential) const {
 309   return spdy_framer_.CreateCredentialFrame(credential);
 310 }
 311
 312 SpdyFrame* BufferedSpdyFramer::CreateDataFrame(SpdyStreamId stream_id,
 313                                                const char* data,
 314                                                uint32 len,
 315                                                SpdyDataFlags flags) {
 316   return spdy_framer_.CreateDataFrame(stream_id, data, len, flags);
 317 }
 318
 319 SpdyPriority BufferedSpdyFramer::GetHighestPriority() const {
 320   return spdy_framer_.GetHighestPriority();
 321 }
 322
 323 void BufferedSpdyFramer::InitHeaderStreaming(SpdyStreamId stream_id) {
 324   memset(header_buffer_, 0, kHeaderBufferSize);
 325   header_buffer_used_ = 0;
 326   header_buffer_valid_ = true;
 327   header_stream_id_ = stream_id;
 328   DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
 329 }
 330
 331 }  // namespace net