Home | History | Annotate | Download | only in flip_server
      1 // Copyright (c) 2011 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_STREAMER_INTERFACE_H_
      6 #define NET_TOOLS_FLIP_SERVER_STREAMER_INTERFACE_H_
      7 
      8 #include <string>
      9 
     10 #include "base/compiler_specific.h"
     11 #include "net/tools/balsa/balsa_headers.h"
     12 #include "net/tools/balsa/balsa_visitor_interface.h"
     13 #include "net/tools/flip_server/sm_interface.h"
     14 
     15 namespace net {
     16 
     17 class BalsaFrame;
     18 class FlipAcceptor;
     19 class MemCacheIter;
     20 class SMConnection;
     21 class EpollServer;
     22 
     23 class StreamerSM : public BalsaVisitorInterface, public SMInterface {
     24  public:
     25   StreamerSM(SMConnection* connection,
     26              SMInterface* sm_other_interface,
     27              EpollServer* epoll_server,
     28              FlipAcceptor* acceptor);
     29   virtual ~StreamerSM();
     30 
     31   void AddToOutputOrder(const MemCacheIter& mci) {}
     32 
     33   virtual void InitSMInterface(SMInterface* sm_other_interface,
     34                                int32 server_idx) OVERRIDE;
     35   virtual void InitSMConnection(SMConnectionPoolInterface* connection_pool,
     36                                 SMInterface* sm_interface,
     37                                 EpollServer* epoll_server,
     38                                 int fd,
     39                                 std::string server_ip,
     40                                 std::string server_port,
     41                                 std::string remote_ip,
     42                                 bool use_ssl) OVERRIDE;
     43 
     44   virtual size_t ProcessReadInput(const char* data, size_t len) OVERRIDE;
     45   virtual size_t ProcessWriteInput(const char* data, size_t len) OVERRIDE;
     46   virtual bool MessageFullyRead() const OVERRIDE;
     47   virtual void SetStreamID(uint32 stream_id) OVERRIDE {}
     48   virtual bool Error() const OVERRIDE;
     49   virtual const char* ErrorAsString() const OVERRIDE;
     50   virtual void Reset() OVERRIDE;
     51   virtual void ResetForNewInterface(int32 server_idx) OVERRIDE {}
     52   virtual void ResetForNewConnection() OVERRIDE;
     53   virtual void Cleanup() OVERRIDE;
     54   virtual int PostAcceptHook() OVERRIDE;
     55   virtual void NewStream(uint32 stream_id,
     56                          uint32 priority,
     57                          const std::string& filename) OVERRIDE {}
     58   virtual void SendEOF(uint32 stream_id) OVERRIDE {}
     59   virtual void SendErrorNotFound(uint32 stream_id) OVERRIDE {}
     60   virtual void SendOKResponse(uint32 stream_id, std::string output) {}
     61   virtual size_t SendSynStream(uint32 stream_id,
     62                                const BalsaHeaders& headers) OVERRIDE;
     63   virtual size_t SendSynReply(uint32 stream_id,
     64                               const BalsaHeaders& headers) OVERRIDE;
     65   virtual void SendDataFrame(uint32 stream_id,
     66                              const char* data,
     67                              int64 len,
     68                              uint32 flags,
     69                              bool compress) OVERRIDE {}
     70   virtual void set_is_request() OVERRIDE;
     71   static std::string forward_ip_header() { return forward_ip_header_; }
     72   static void set_forward_ip_header(std::string value) {
     73     forward_ip_header_ = value;
     74   }
     75 
     76  private:
     77   void SendEOFImpl(uint32 stream_id) {}
     78   void SendErrorNotFoundImpl(uint32 stream_id) {}
     79   void SendOKResponseImpl(uint32 stream_id, std::string* output) {}
     80   size_t SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers) {
     81     return 0;
     82   }
     83   size_t SendSynStreamImpl(uint32 stream_id, const BalsaHeaders& headers) {
     84     return 0;
     85   }
     86   void SendDataFrameImpl(uint32 stream_id,
     87                          const char* data,
     88                          int64 len,
     89                          uint32 flags,
     90                          bool compress) {}
     91   virtual void GetOutput() OVERRIDE {}
     92 
     93   virtual void ProcessBodyInput(const char* input, size_t size) OVERRIDE;
     94   virtual void MessageDone() OVERRIDE;
     95   virtual void ProcessHeaders(const BalsaHeaders& headers) OVERRIDE;
     96   virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE {}
     97   virtual void ProcessHeaderInput(const char* input, size_t size) OVERRIDE {}
     98   virtual void ProcessTrailerInput(const char* input, size_t size) OVERRIDE {}
     99   virtual void ProcessRequestFirstLine(const char* line_input,
    100                                        size_t line_length,
    101                                        const char* method_input,
    102                                        size_t method_length,
    103                                        const char* request_uri_input,
    104                                        size_t request_uri_length,
    105                                        const char* version_input,
    106                                        size_t version_length) OVERRIDE {}
    107   virtual void ProcessResponseFirstLine(const char* line_input,
    108                                         size_t line_length,
    109                                         const char* version_input,
    110                                         size_t version_length,
    111                                         const char* status_input,
    112                                         size_t status_length,
    113                                         const char* reason_input,
    114                                         size_t reason_length) OVERRIDE {}
    115   virtual void ProcessChunkLength(size_t chunk_length) OVERRIDE {}
    116   virtual void ProcessChunkExtensions(const char* input, size_t size) OVERRIDE {
    117   }
    118   virtual void HeaderDone() OVERRIDE {}
    119   virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE;
    120   virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE {}
    121   virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE;
    122   virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE;
    123   void HandleError();
    124 
    125   SMConnection* connection_;
    126   SMInterface* sm_other_interface_;
    127   EpollServer* epoll_server_;
    128   FlipAcceptor* acceptor_;
    129   bool is_request_;
    130   BalsaFrame* http_framer_;
    131   BalsaHeaders headers_;
    132   static std::string forward_ip_header_;
    133 };
    134 
    135 }  // namespace net
    136 
    137 #endif  // NET_TOOLS_FLIP_SERVER_STREAMER_INTERFACE_H_
    138