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
21namespace net {
22
23class FlipAcceptor;
24class MemoryCache;
25struct SSLState;
26
27// A frame of data to be sent.
28class 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
41typedef std::list<DataFrame*> OutputList;
42
43class 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