sm_connection.h revision 4e180b6a0b4720a9b8e9e959a882386f690f08ff 
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/epoll_server/epoll_server.h"
16#include "net/tools/flip_server/create_listener.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
22namespace net {
23
24class FlipAcceptor;
25class MemoryCache;
26struct SSLState;
27
28// A frame of data to be sent.
29class 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
39typedef std::list<DataFrame*> OutputList;
40
41class 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  virtual 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  SMConnection(EpollServer* epoll_server,
123               SSLState* ssl_state,
124               MemoryCache* memory_cache,
125               FlipAcceptor* acceptor,
126               std::string log_prefix);
127 private:
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