blob: 2fe3228c0a1671e4378e45b765a80dad176b904a [file] [log] [blame]
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <arpa/inet.h> // in_addr_t
#include <time.h>
#include <list>
#include <string>
#include "base/compiler_specific.h"
#include "net/spdy/spdy_protocol.h"
#include "net/tools/epoll_server/epoll_server.h"
#include "net/tools/flip_server/create_listener.h"
#include "net/tools/flip_server/mem_cache.h"
#include "net/tools/flip_server/ring_buffer.h"
#include "net/tools/flip_server/sm_interface.h"
#include "openssl/ssl.h"
namespace net {
class FlipAcceptor;
class MemoryCache;
struct SSLState;
class SpdySM;
// A frame of data to be sent.
class DataFrame {
const char* data;
size_t size;
bool delete_when_done;
size_t index;
DataFrame() : data(NULL), size(0), delete_when_done(false), index(0) {}
virtual ~DataFrame();
typedef std::list<DataFrame*> OutputList;
class SMConnection : public SMConnectionInterface,
public EpollCallbackInterface,
public NotifierInterface {
virtual ~SMConnection();
static SMConnection* NewSMConnection(EpollServer* epoll_server,
SSLState* ssl_state,
MemoryCache* memory_cache,
FlipAcceptor* acceptor,
std::string log_prefix);
// TODO(mbelshe): Make these private.
time_t last_read_time_;
std::string server_ip_;
std::string server_port_;
virtual EpollServer* epoll_server() OVERRIDE;
OutputList* output_list() { return &output_list_; }
MemoryCache* memory_cache() { return memory_cache_; }
virtual void ReadyToSend() OVERRIDE;
void EnqueueDataFrame(DataFrame* df);
int fd() const { return fd_; }
bool initialized() const { return initialized_; }
std::string client_ip() const { return client_ip_; }
virtual void InitSMConnection(SMConnectionPoolInterface* connection_pool,
SMInterface* sm_interface,
EpollServer* epoll_server,
int fd,
std::string server_ip,
std::string server_port,
std::string remote_ip,
bool use_ssl);
void CorkSocket();
void UncorkSocket();
int Send(const char* data, int len, int flags);
// EpollCallbackInterface interface.
virtual void OnRegistration(EpollServer* eps,
int fd,
int event_mask) OVERRIDE;
virtual void OnModification(int fd, int event_mask) OVERRIDE {}
virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE;
virtual void OnUnregistration(int fd, bool replaced) OVERRIDE;
virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE;
// NotifierInterface interface.
virtual void Notify() OVERRIDE {}
void Cleanup(const char* cleanup);
// Flag indicating if we should force spdy on all connections.
static bool force_spdy() { return force_spdy_; }
static void set_force_spdy(bool value) { force_spdy_ = value; }
// Decide if SPDY was negotiated.
bool WasSpdyNegotiated(SpdyMajorVersion* version_negotiated);
// Initialize the protocol interfaces we'll need for this connection.
// Returns true if successful, false otherwise.
bool SetupProtocolInterfaces();
bool DoRead();
bool DoWrite();
bool DoConsumeReadData();
void Reset();
void HandleEvents();
void HandleResponseFullyRead();
friend std::ostream& operator<<(std::ostream& os, const SMConnection& c) {
os << &c << "\n";
return os;
SMConnection(EpollServer* epoll_server,
SSLState* ssl_state,
MemoryCache* memory_cache,
FlipAcceptor* acceptor,
std::string log_prefix);
int fd_;
int events_;
bool registered_in_epoll_server_;
bool initialized_;
bool protocol_detected_;
bool connection_complete_;
SMConnectionPoolInterface* connection_pool_;
EpollServer* epoll_server_;
SSLState* ssl_state_;
MemoryCache* memory_cache_;
FlipAcceptor* acceptor_;
std::string client_ip_;
RingBuffer read_buffer_;
OutputList output_list_;
SpdySM* sm_spdy_interface_;
SMInterface* sm_http_interface_;
SMInterface* sm_streamer_interface_;
SMInterface* sm_interface_;
std::string log_prefix_;
size_t max_bytes_sent_per_dowrite_;
SSL* ssl_;
static bool force_spdy_;
} // namespace net