Home | History | Annotate | Download | only in flip_server 
      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_TOOLS_FLIP_SERVER_SPDY_INTERFACE_H_
      6 #define NET_TOOLS_FLIP_SERVER_SPDY_INTERFACE_H_
      7 
      8 #include <map>
      9 #include <string>
     10 #include <vector>
     11 
     12 #include "base/compiler_specific.h"
     13 #include "base/memory/scoped_ptr.h"
     14 #include "net/spdy/buffered_spdy_framer.h"
     15 #include "net/spdy/spdy_protocol.h"
     16 #include "net/tools/balsa/balsa_headers.h"
     17 #include "net/tools/balsa/balsa_visitor_interface.h"
     18 #include "net/tools/flip_server/output_ordering.h"
     19 #include "net/tools/flip_server/sm_connection.h"
     20 #include "net/tools/flip_server/sm_interface.h"
     21 
     22 namespace net {
     23 
     24 class FlipAcceptor;
     25 class MemoryCache;
     26 
     27 class SpdySM : public BufferedSpdyFramerVisitorInterface, public SMInterface {
     28  public:
     29   SpdySM(SMConnection* connection,
     30          SMInterface* sm_http_interface,
     31          EpollServer* epoll_server,
     32          MemoryCache* memory_cache,
     33          FlipAcceptor* acceptor,
     34          SpdyMajorVersion spdy_version);
     35   virtual ~SpdySM();
     36 
     37   virtual void InitSMInterface(SMInterface* sm_http_interface,
     38                                int32 server_idx) OVERRIDE {}
     39 
     40   virtual void InitSMConnection(SMConnectionPoolInterface* connection_pool,
     41                                 SMInterface* sm_interface,
     42                                 EpollServer* epoll_server,
     43                                 int fd,
     44                                 std::string server_ip,
     45                                 std::string server_port,
     46                                 std::string remote_ip,
     47                                 bool use_ssl) OVERRIDE;
     48 
     49   // Create new SPDY framer after reusing SpdySM and negotiating new version
     50   void CreateFramer(SpdyMajorVersion spdy_version);
     51 
     52  private:
     53   virtual void set_is_request() OVERRIDE {}
     54   SMInterface* NewConnectionInterface();
     55   // virtual for tests
     56   virtual SMInterface* FindOrMakeNewSMConnectionInterface(
     57       const std::string& server_ip,
     58       const std::string& server_port);
     59   int SpdyHandleNewStream(SpdyStreamId stream_id,
     60                           SpdyPriority priority,
     61                           const SpdyHeaderBlock& headers,
     62                           std::string& http_data,
     63                           bool* is_https_scheme);
     64 
     65   // BufferedSpdyFramerVisitorInterface:
     66   virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {}
     67   virtual void OnStreamError(SpdyStreamId stream_id,
     68                              const std::string& description) OVERRIDE {}
     69   // Called after all the header data for SYN_STREAM control frame is received.
     70   virtual void OnSynStream(SpdyStreamId stream_id,
     71                            SpdyStreamId associated_stream_id,
     72                            SpdyPriority priority,
     73                            bool fin,
     74                            bool unidirectional,
     75                            const SpdyHeaderBlock& headers) OVERRIDE;
     76 
     77   // Called after all the header data for SYN_REPLY control frame is received.
     78   virtual void OnSynReply(SpdyStreamId stream_id,
     79                           bool fin,
     80                           const SpdyHeaderBlock& headers) OVERRIDE;
     81 
     82   // Called after all the header data for HEADERS control frame is received.
     83   virtual void OnHeaders(SpdyStreamId stream_id,
     84                          bool fin,
     85                          const SpdyHeaderBlock& headers) OVERRIDE;
     86 
     87   // Called when data frame header is received.
     88   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
     89                                  size_t length,
     90                                  bool fin) OVERRIDE {}
     91 
     92   // Called when data is received.
     93   // |stream_id| The stream receiving data.
     94   // |data| A buffer containing the data received.
     95   // |len| The length of the data buffer.
     96   // When the other side has finished sending data on this stream,
     97   // this method will be called with a zero-length buffer.
     98   virtual void OnStreamFrameData(SpdyStreamId stream_id,
     99                                  const char* data,
    100                                  size_t len,
    101                                  bool fin) OVERRIDE;
    102 
    103   // Called when a SETTINGS frame is received.
    104   // |clear_persisted| True if the respective flag is set on the SETTINGS frame.
    105   virtual void OnSettings(bool clear_persisted) OVERRIDE {}
    106 
    107   // Called when an individual setting within a SETTINGS frame has been parsed
    108   // and validated.
    109   virtual void OnSetting(SpdySettingsIds id,
    110                          uint8 flags,
    111                          uint32 value) OVERRIDE {}
    112 
    113   // Called when a PING frame has been parsed.
    114   virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {}
    115 
    116   // Called when a RST_STREAM frame has been parsed.
    117   virtual void OnRstStream(SpdyStreamId stream_id,
    118                            SpdyRstStreamStatus status) OVERRIDE;
    119 
    120   // Called when a GOAWAY frame has been parsed.
    121   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
    122                         SpdyGoAwayStatus status) OVERRIDE {}
    123 
    124   // Called when a WINDOW_UPDATE frame has been parsed.
    125   virtual void OnWindowUpdate(SpdyStreamId stream_id,
    126                               uint32 delta_window_size) OVERRIDE {}
    127 
    128   // Called when a PUSH_PROMISE frame has been parsed.
    129   virtual void OnPushPromise(SpdyStreamId stream_id,
    130                              SpdyStreamId promised_stream_id,
    131                              const SpdyHeaderBlock& headers) OVERRIDE {}
    132 
    133   virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE;
    134 
    135  public:
    136   virtual size_t ProcessReadInput(const char* data, size_t len) OVERRIDE;
    137   virtual size_t ProcessWriteInput(const char* data, size_t len) OVERRIDE;
    138   virtual bool MessageFullyRead() const OVERRIDE;
    139   virtual void SetStreamID(uint32 stream_id) OVERRIDE {}
    140   virtual bool Error() const OVERRIDE;
    141   virtual const char* ErrorAsString() const OVERRIDE;
    142   virtual void Reset() OVERRIDE {}
    143   virtual void ResetForNewInterface(int32 server_idx) OVERRIDE;
    144   virtual void ResetForNewConnection() OVERRIDE;
    145   // SMInterface's Cleanup is currently only called by SMConnection after a
    146   // protocol message as been fully read. Spdy's SMInterface does not need
    147   // to do any cleanup at this time.
    148   // TODO(klindsay) This method is probably not being used properly and
    149   // some logic review and method renaming is probably in order.
    150   virtual void Cleanup() OVERRIDE {}
    151   // Send a settings frame
    152   virtual int PostAcceptHook() OVERRIDE;
    153   virtual void NewStream(uint32 stream_id,
    154                          uint32 priority,
    155                          const std::string& filename) OVERRIDE;
    156   void AddToOutputOrder(const MemCacheIter& mci);
    157   virtual void SendEOF(uint32 stream_id) OVERRIDE;
    158   virtual void SendErrorNotFound(uint32 stream_id) OVERRIDE;
    159   virtual size_t SendSynStream(uint32 stream_id,
    160                                const BalsaHeaders& headers) OVERRIDE;
    161   virtual size_t SendSynReply(uint32 stream_id,
    162                               const BalsaHeaders& headers) OVERRIDE;
    163   virtual void SendDataFrame(uint32 stream_id,
    164                              const char* data,
    165                              int64 len,
    166                              uint32 flags,
    167                              bool compress) OVERRIDE;
    168   BufferedSpdyFramer* spdy_framer() { return buffered_spdy_framer_.get(); }
    169 
    170   const OutputOrdering& output_ordering() const {
    171     return client_output_ordering_;
    172   }
    173 
    174   static std::string forward_ip_header() { return forward_ip_header_; }
    175   static void set_forward_ip_header(const std::string& value) {
    176     forward_ip_header_ = value;
    177   }
    178   SpdyMajorVersion spdy_version() const {
    179     DCHECK(buffered_spdy_framer_);
    180     return buffered_spdy_framer_->protocol_version();
    181   }
    182 
    183  private:
    184   void SendEOFImpl(uint32 stream_id);
    185   void SendErrorNotFoundImpl(uint32 stream_id);
    186   void KillStream(uint32 stream_id);
    187   void CopyHeaders(SpdyHeaderBlock& dest, const BalsaHeaders& headers);
    188   size_t SendSynStreamImpl(uint32 stream_id, const BalsaHeaders& headers);
    189   size_t SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers);
    190   void SendDataFrameImpl(uint32 stream_id,
    191                          const char* data,
    192                          int64 len,
    193                          SpdyDataFlags flags,
    194                          bool compress);
    195   void EnqueueDataFrame(DataFrame* df);
    196   virtual void GetOutput() OVERRIDE;
    197 
    198  private:
    199   scoped_ptr<BufferedSpdyFramer> buffered_spdy_framer_;
    200   bool valid_spdy_session_;  // True if we have seen valid data on this session.
    201                              // Use this to fail fast when junk is sent to our
    202                              // port.
    203 
    204   SMConnection* connection_;
    205   OutputList* client_output_list_;
    206   OutputOrdering client_output_ordering_;
    207   uint32 next_outgoing_stream_id_;
    208   EpollServer* epoll_server_;
    209   FlipAcceptor* acceptor_;
    210   MemoryCache* memory_cache_;
    211   std::vector<SMInterface*> server_interface_list;
    212   std::vector<int32> unused_server_interface_list;
    213   typedef std::map<uint32, SMInterface*> StreamToSmif;
    214   StreamToSmif stream_to_smif_;
    215   bool close_on_error_;
    216 
    217   static std::string forward_ip_header_;
    218 };
    219 
    220 }  // namespace net
    221 
    222 #endif  // NET_TOOLS_FLIP_SERVER_SPDY_INTERFACE_H_
    223