net/spdy/buffered_spdy_framer.h

   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 #ifndef NET_SPDY_BUFFERED_SPDY_FRAMER_H_
   6 #define NET_SPDY_BUFFERED_SPDY_FRAMER_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/gtest_prod_util.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "net/base/net_export.h"
  14 #include "net/socket/next_proto.h"
  15 #include "net/spdy/spdy_framer.h"
  16 #include "net/spdy/spdy_header_block.h"
  17 #include "net/spdy/spdy_protocol.h"
  18
  19 namespace net {
  20
  21 // Returns the SPDY major version corresponding to the given NextProto
  22 // value, which must represent a SPDY-like protocol.
  23 NET_EXPORT_PRIVATE SpdyMajorVersion NextProtoToSpdyMajorVersion(
  24     NextProto next_proto);
  25
  26 class NET_EXPORT_PRIVATE BufferedSpdyFramerVisitorInterface {
  27  public:
  28   BufferedSpdyFramerVisitorInterface() {}
  29
  30   // Called if an error is detected in the SpdyFrame protocol.
  31   virtual void OnError(SpdyFramer::SpdyError error_code) = 0;
  32
  33   // Called if an error is detected in a SPDY stream.
  34   virtual void OnStreamError(SpdyStreamId stream_id,
  35                              const std::string& description) = 0;
  36
  37   // Called after all the header data for SYN_STREAM control frame is received.
  38   virtual void OnSynStream(SpdyStreamId stream_id,
  39                            SpdyStreamId associated_stream_id,
  40                            SpdyPriority priority,
  41                            bool fin,
  42                            bool unidirectional,
  43                            const SpdyHeaderBlock& headers) = 0;
  44
  45   // Called after all the header data for SYN_REPLY control frame is received.
  46   virtual void OnSynReply(SpdyStreamId stream_id,
  47                           bool fin,
  48                           const SpdyHeaderBlock& headers) = 0;
  49
  50   // Called after all the header data for HEADERS control frame is received.
  51   virtual void OnHeaders(SpdyStreamId stream_id,
  52                          bool fin,
  53                          const SpdyHeaderBlock& headers) = 0;
  54
  55   // Called when a data frame header is received.
  56   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
  57                                  size_t length,
  58                                  bool fin) = 0;
  59
  60   // Called when data is received.
  61   // |stream_id| The stream receiving data.
  62   // |data| A buffer containing the data received.
  63   // |len| The length of the data buffer (at most 2^24 - 1 for SPDY/3,
  64   // but 2^16 - 1 - 8 for SPDY/4).
  65   // When the other side has finished sending data on this stream,
  66   // this method will be called with a zero-length buffer.
  67   virtual void OnStreamFrameData(SpdyStreamId stream_id,
  68                                  const char* data,
  69                                  size_t len,
  70                                  bool fin) = 0;
  71
  72   // Called when a SETTINGS frame is received.
  73   // |clear_persisted| True if the respective flag is set on the SETTINGS frame.
  74   virtual void OnSettings(bool clear_persisted) = 0;
  75
  76   // Called when an individual setting within a SETTINGS frame has been parsed
  77   // and validated.
  78   virtual void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) = 0;
  79
  80   // Called when a SETTINGS frame is received with the ACK flag set.
  81   virtual void OnSettingsAck() {}
  82
  83   // Called at the completion of parsing SETTINGS id and value tuples.
  84   virtual void OnSettingsEnd() {}
  85
  86   // Called when a PING frame has been parsed.
  87   virtual void OnPing(SpdyPingId unique_id, bool is_ack) = 0;
  88
  89   // Called when a RST_STREAM frame has been parsed.
  90   virtual void OnRstStream(SpdyStreamId stream_id,
  91                            SpdyRstStreamStatus status) = 0;
  92
  93   // Called when a GOAWAY frame has been parsed.
  94   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
  95                         SpdyGoAwayStatus status) = 0;
  96
  97   // Called when a WINDOW_UPDATE frame has been parsed.
  98   virtual void OnWindowUpdate(SpdyStreamId stream_id,
  99                               uint32 delta_window_size) = 0;
 100
 101   // Called when a PUSH_PROMISE frame has been parsed.
 102   virtual void OnPushPromise(SpdyStreamId stream_id,
 103                              SpdyStreamId promised_stream_id,
 104                              const SpdyHeaderBlock& headers) = 0;
 105
 106   // Called when a frame type we don't recognize is received.
 107   // Return true if this appears to be a valid extension frame, false otherwise.
 108   // We distinguish between extension frames and nonsense by checking
 109   // whether the stream id is valid.
 110   virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) = 0;
 111
 112  protected:
 113   virtual ~BufferedSpdyFramerVisitorInterface() {}
 114
 115  private:
 116   DISALLOW_COPY_AND_ASSIGN(BufferedSpdyFramerVisitorInterface);
 117 };
 118
 119 class NET_EXPORT_PRIVATE BufferedSpdyFramer
 120     : public SpdyFramerVisitorInterface {
 121  public:
 122   BufferedSpdyFramer(SpdyMajorVersion version,
 123                      bool enable_compression);
 124   virtual ~BufferedSpdyFramer();
 125
 126   // Sets callbacks to be called from the buffered spdy framer.  A visitor must
 127   // be set, or else the framer will likely crash.  It is acceptable for the
 128   // visitor to do nothing.  If this is called multiple times, only the last
 129   // visitor will be used.
 130   void set_visitor(BufferedSpdyFramerVisitorInterface* visitor);
 131
 132   // Set debug callbacks to be called from the framer. The debug visitor is
 133   // completely optional and need not be set in order for normal operation.
 134   // If this is called multiple times, only the last visitor will be used.
 135   void set_debug_visitor(SpdyFramerDebugVisitorInterface* debug_visitor);
 136
 137   // SpdyFramerVisitorInterface
 138   virtual void OnError(SpdyFramer* spdy_framer) OVERRIDE;
 139   virtual void OnSynStream(SpdyStreamId stream_id,
 140                            SpdyStreamId associated_stream_id,
 141                            SpdyPriority priority,
 142                            bool fin,
 143                            bool unidirectional) OVERRIDE;
 144   virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE;
 145   virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) OVERRIDE;
 146   virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
 147                                         const char* header_data,
 148                                         size_t len) OVERRIDE;
 149   virtual void OnStreamFrameData(SpdyStreamId stream_id,
 150                                  const char* data,
 151                                  size_t len,
 152                                  bool fin) OVERRIDE;
 153   virtual void OnSettings(bool clear_persisted) OVERRIDE;
 154   virtual void OnSetting(
 155       SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE;
 156   virtual void OnSettingsAck() OVERRIDE;
 157   virtual void OnSettingsEnd() OVERRIDE;
 158   virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE;
 159   virtual void OnRstStream(SpdyStreamId stream_id,
 160                            SpdyRstStreamStatus status) OVERRIDE;
 161   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
 162                         SpdyGoAwayStatus status) OVERRIDE;
 163   virtual void OnWindowUpdate(SpdyStreamId stream_id,
 164                               uint32 delta_window_size) OVERRIDE;
 165   virtual void OnPushPromise(SpdyStreamId stream_id,
 166                              SpdyStreamId promised_stream_id,
 167                              bool end) OVERRIDE;
 168   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
 169                                  size_t length,
 170                                  bool fin) OVERRIDE;
 171   virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE;
 172   virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE;
 173
 174   // SpdyFramer methods.
 175   size_t ProcessInput(const char* data, size_t len);
 176   SpdyMajorVersion protocol_version();
 177   void Reset();
 178   SpdyFramer::SpdyError error_code() const;
 179   SpdyFramer::SpdyState state() const;
 180   bool MessageFullyRead();
 181   bool HasError();
 182   SpdyFrame* CreateSynStream(SpdyStreamId stream_id,
 183                              SpdyStreamId associated_stream_id,
 184                              SpdyPriority priority,
 185                              SpdyControlFlags flags,
 186                              const SpdyHeaderBlock* headers);
 187   SpdyFrame* CreateSynReply(SpdyStreamId stream_id,
 188                             SpdyControlFlags flags,
 189                             const SpdyHeaderBlock* headers);
 190   SpdyFrame* CreateRstStream(SpdyStreamId stream_id,
 191                              SpdyRstStreamStatus status) const;
 192   SpdyFrame* CreateSettings(const SettingsMap& values) const;
 193   SpdyFrame* CreatePingFrame(uint32 unique_id, bool is_ack) const;
 194   SpdyFrame* CreateGoAway(
 195       SpdyStreamId last_accepted_stream_id,
 196       SpdyGoAwayStatus status) const;
 197   SpdyFrame* CreateHeaders(SpdyStreamId stream_id,
 198                            SpdyControlFlags flags,
 199                            const SpdyHeaderBlock* headers);
 200   SpdyFrame* CreateWindowUpdate(
 201       SpdyStreamId stream_id,
 202       uint32 delta_window_size) const;
 203   SpdyFrame* CreateDataFrame(SpdyStreamId stream_id,
 204                              const char* data,
 205                              uint32 len,
 206                              SpdyDataFlags flags);
 207   SpdyFrame* CreatePushPromise(SpdyStreamId stream_id,
 208                                SpdyStreamId promised_stream_id,
 209                                const SpdyHeaderBlock* headers);
 210
 211   // Serialize a frame of unknown type.
 212   SpdySerializedFrame* SerializeFrame(const SpdyFrameIR& frame) {
 213     return spdy_framer_.SerializeFrame(frame);
 214   }
 215
 216   SpdyPriority GetHighestPriority() const;
 217
 218   size_t GetDataFrameMinimumSize() const {
 219     return spdy_framer_.GetDataFrameMinimumSize();
 220   }
 221
 222   size_t GetControlFrameHeaderSize() const {
 223     return spdy_framer_.GetControlFrameHeaderSize();
 224   }
 225
 226   size_t GetSynStreamMinimumSize() const {
 227     return spdy_framer_.GetSynStreamMinimumSize();
 228   }
 229
 230   size_t GetFrameMinimumSize() const {
 231     return spdy_framer_.GetFrameMinimumSize();
 232   }
 233
 234   size_t GetFrameMaximumSize() const {
 235     return spdy_framer_.GetFrameMaximumSize();
 236   }
 237
 238   size_t GetDataFrameMaximumPayload() const {
 239     return spdy_framer_.GetDataFrameMaximumPayload();
 240   }
 241
 242   int frames_received() const { return frames_received_; }
 243
 244  private:
 245   // The size of the header_buffer_.
 246   enum { kHeaderBufferSize = 32 * 1024 };
 247
 248   void InitHeaderStreaming(SpdyStreamId stream_id);
 249
 250   SpdyFramer spdy_framer_;
 251   BufferedSpdyFramerVisitorInterface* visitor_;
 252
 253   // Header block streaming state:
 254   char header_buffer_[kHeaderBufferSize];
 255   size_t header_buffer_used_;
 256   bool header_buffer_valid_;
 257   SpdyStreamId header_stream_id_;
 258   int frames_received_;
 259
 260   // Collection of fields from control frames that we need to
 261   // buffer up from the spdy framer.
 262   struct ControlFrameFields {
 263     SpdyFrameType type;
 264     SpdyStreamId stream_id;
 265     SpdyStreamId associated_stream_id;
 266     SpdyStreamId promised_stream_id;
 267     SpdyPriority priority;
 268     uint8 credential_slot;
 269     bool fin;
 270     bool unidirectional;
 271   };
 272   scoped_ptr<ControlFrameFields> control_frame_fields_;
 273
 274   DISALLOW_COPY_AND_ASSIGN(BufferedSpdyFramer);
 275 };
 276
 277 }  // namespace net
 278
 279 #endif  // NET_SPDY_BUFFERED_SPDY_FRAMER_H_