net/tools/flip_server/sm_connection.h

   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_SM_CONNECTION_H_
   6 #define NET_TOOLS_FLIP_SERVER_SM_CONNECTION_H_
   7
   8 #include <arpa/inet.h>  // in_addr_t
   9 #include <time.h>
  10
  11 #include <list>
  12 #include <string>
  13
  14 #include "base/compiler_specific.h"
  15 #include "net/tools/flip_server/create_listener.h"
  16 #include "net/tools/flip_server/epoll_server.h"
  17 #include "net/tools/flip_server/mem_cache.h"
  18 #include "net/tools/flip_server/ring_buffer.h"
  19 #include "net/tools/flip_server/sm_interface.h"
  20 #include "openssl/ssl.h"
  21
  22 namespace net {
  23
  24 class FlipAcceptor;
  25 class MemoryCache;
  26 struct SSLState;
  27
  28 // A frame of data to be sent.
  29 class DataFrame {
  30  public:
  31   const char* data;
  32   size_t size;
  33   bool delete_when_done;
  34   size_t index;
  35   DataFrame() : data(NULL), size(0), delete_when_done(false), index(0) {}
  36   virtual ~DataFrame();
  37 };
  38
  39 typedef std::list<DataFrame*> OutputList;
  40
  41 class SMConnection : public SMConnectionInterface,
  42                      public EpollCallbackInterface,
  43                      public NotifierInterface {
  44  public:
  45   virtual ~SMConnection();
  46
  47   static SMConnection* NewSMConnection(EpollServer* epoll_server,
  48                                        SSLState *ssl_state,
  49                                        MemoryCache* memory_cache,
  50                                        FlipAcceptor *acceptor,
  51                                        std::string log_prefix);
  52
  53   // TODO(mbelshe): Make these private.
  54   time_t last_read_time_;
  55   std::string server_ip_;
  56   std::string server_port_;
  57
  58   virtual EpollServer* epoll_server() OVERRIDE;
  59   OutputList* output_list() { return &output_list_; }
  60   MemoryCache* memory_cache() { return memory_cache_; }
  61   virtual void ReadyToSend() OVERRIDE;
  62   void EnqueueDataFrame(DataFrame* df);
  63
  64   int fd() const { return fd_; }
  65   bool initialized() const { return initialized_; }
  66   std::string client_ip() const { return client_ip_; }
  67
  68   void InitSMConnection(SMConnectionPoolInterface* connection_pool,
  69                         SMInterface* sm_interface,
  70                         EpollServer* epoll_server,
  71                         int fd,
  72                         std::string server_ip,
  73                         std::string server_port,
  74                         std::string remote_ip,
  75                         bool use_ssl);
  76
  77   void CorkSocket();
  78   void UncorkSocket();
  79
  80   int Send(const char* data, int len, int flags);
  81
  82   // EpollCallbackInterface interface.
  83   virtual void OnRegistration(EpollServer* eps,
  84                               int fd,
  85                               int event_mask) OVERRIDE;
  86   virtual void OnModification(int fd, int event_mask) OVERRIDE {}
  87   virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE;
  88   virtual void OnUnregistration(int fd, bool replaced) OVERRIDE;
  89   virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE;
  90
  91   // NotifierInterface interface.
  92   virtual void Notify() OVERRIDE {}
  93
  94   void Cleanup(const char* cleanup);
  95
  96   // Flag indicating if we should force spdy on all connections.
  97   static bool force_spdy() { return force_spdy_; }
  98   static void set_force_spdy(bool value) { force_spdy_ = value; }
  99
 100  private:
 101   // Decide if SPDY was negotiated.
 102   bool WasSpdyNegotiated();
 103
 104   // Initialize the protocol interfaces we'll need for this connection.
 105   // Returns true if successful, false otherwise.
 106   bool SetupProtocolInterfaces();
 107
 108   bool DoRead();
 109   bool DoWrite();
 110   bool DoConsumeReadData();
 111   void Reset();
 112
 113   void HandleEvents();
 114   void HandleResponseFullyRead();
 115
 116  protected:
 117   friend std::ostream& operator<<(std::ostream& os, const SMConnection& c) {
 118     os << &c << "\n";
 119     return os;
 120   }
 121
 122  private:
 123   SMConnection(EpollServer* epoll_server,
 124                SSLState* ssl_state,
 125                MemoryCache* memory_cache,
 126                FlipAcceptor* acceptor,
 127                std::string log_prefix);
 128   int fd_;
 129   int events_;
 130
 131   bool registered_in_epoll_server_;
 132   bool initialized_;
 133   bool protocol_detected_;
 134   bool connection_complete_;
 135
 136   SMConnectionPoolInterface* connection_pool_;
 137
 138   EpollServer *epoll_server_;
 139   SSLState *ssl_state_;
 140   MemoryCache* memory_cache_;
 141   FlipAcceptor *acceptor_;
 142   std::string client_ip_;
 143
 144   RingBuffer read_buffer_;
 145
 146   OutputList output_list_;
 147   SMInterface* sm_spdy_interface_;
 148   SMInterface* sm_http_interface_;
 149   SMInterface* sm_streamer_interface_;
 150   SMInterface* sm_interface_;
 151   std::string log_prefix_;
 152
 153   size_t max_bytes_sent_per_dowrite_;
 154
 155   SSL* ssl_;
 156
 157   static bool force_spdy_;
 158 };
 159
 160 }  // namespace net
 161
 162 #endif  // NET_TOOLS_FLIP_SERVER_SM_CONNECTION_H_