Home | History | Annotate | Download | only in flip_server 
      1 // Copyright (c) 2009 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 "net/tools/flip_server/create_listener.h"
     15 #include "net/tools/flip_server/epoll_server.h"
     16 #include "net/tools/flip_server/mem_cache.h"
     17 #include "net/tools/flip_server/ring_buffer.h"
     18 #include "net/tools/flip_server/sm_interface.h"
     19 #include "openssl/ssl.h"
     20 
     21 namespace net {
     22 
     23 class FlipAcceptor;
     24 class MemoryCache;
     25 struct SSLState;
     26 
     27 // A frame of data to be sent.
     28 class DataFrame {
     29  public:
     30   const char* data;
     31   size_t size;
     32   bool delete_when_done;
     33   size_t index;
     34   DataFrame() : data(NULL), size(0), delete_when_done(false), index(0) {}
     35   virtual ~DataFrame() {
     36     if (delete_when_done)
     37       delete[] data;
     38   }
     39 };
     40 
     41 typedef std::list<DataFrame*> OutputList;
     42 
     43 class SMConnection : public SMConnectionInterface,
     44                      public EpollCallbackInterface,
     45                      public NotifierInterface {
     46  public:
     47   virtual ~SMConnection();
     48 
     49   static SMConnection* NewSMConnection(EpollServer* epoll_server,
     50                                        SSLState *ssl_state,
     51                                        MemoryCache* memory_cache,
     52                                        FlipAcceptor *acceptor,
     53                                        std::string log_prefix);
     54 
     55   // TODO(mbelshe): Make these private.
     56   time_t last_read_time_;
     57   std::string server_ip_;
     58   std::string server_port_;
     59 
     60   virtual EpollServer* epoll_server();
     61   OutputList* output_list() { return &output_list_; }
     62   MemoryCache* memory_cache() { return memory_cache_; }
     63   virtual void ReadyToSend();
     64   void EnqueueDataFrame(DataFrame* df);
     65 
     66   int fd() const { return fd_; }
     67   bool initialized() const { return initialized_; }
     68   std::string client_ip() const { return client_ip_; }
     69 
     70   void InitSMConnection(SMConnectionPoolInterface* connection_pool,
     71                         SMInterface* sm_interface,
     72                         EpollServer* epoll_server,
     73                         int fd,
     74                         std::string server_ip,
     75                         std::string server_port,
     76                         std::string remote_ip,
     77                         bool use_ssl);
     78 
     79   void CorkSocket();
     80   void UncorkSocket();
     81 
     82   int Send(const char* data, int len, int flags);
     83 
     84   // EpollCallbackInterface interface.
     85   virtual void OnRegistration(EpollServer* eps, int fd, int event_mask);
     86   virtual void OnModification(int fd, int event_mask) {}
     87   virtual void OnEvent(int fd, EpollEvent* event);
     88   virtual void OnUnregistration(int fd, bool replaced);
     89   virtual void OnShutdown(EpollServer* eps, int fd);
     90 
     91   // NotifierInterface interface.
     92   virtual void Notify() {}
     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 
    164