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_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_
    163