blob: fc557c418145e0a1c9294c3771c12c956262a509 [file] [log] [blame]
// Copyright (c) 2012 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.
// A server side dispatcher which dispatches a given client's data to their
// stream.
#include <list>
#include "base/basictypes.h"
#include "base/containers/hash_tables.h"
#include "base/memory/scoped_ptr.h"
#include "net/base/ip_endpoint.h"
#include "net/base/linked_hash_map.h"
#include "net/quic/quic_blocked_writer_interface.h"
#include "net/quic/quic_protocol.h"
#include "net/tools/quic/quic_server_session.h"
#include "net/tools/quic/quic_time_wait_list_manager.h"
namespace net {
class EpollServer;
class QuicConfig;
class QuicCryptoServerConfig;
class QuicSession;
namespace tools {
class DeleteSessionsAlarm;
class QuicEpollConnectionHelper;
class QuicPacketWriterWrapper;
namespace test {
class QuicDispatcherPeer;
} // namespace test
class ProcessPacketInterface {
virtual ~ProcessPacketInterface() {}
virtual void ProcessPacket(const IPEndPoint& server_address,
const IPEndPoint& client_address,
const QuicEncryptedPacket& packet) = 0;
class QuicDispatcher : public QuicServerSessionVisitor,
public ProcessPacketInterface {
// Creates per-connection packet writers out of the QuicDispatcher's shared
// QuicPacketWriter. The per-connection writers' IsWriteBlocked() state must
// always be the same as the shared writer's IsWriteBlocked(), or else the
// QuicDispatcher::OnCanWrite logic will not work. (This will hopefully be
// cleaned up for bug 16950226.)
class PacketWriterFactory {
virtual ~PacketWriterFactory() {}
virtual QuicPacketWriter* Create(QuicPacketWriter* writer,
QuicConnection* connection) = 0;
// Creates ordinary QuicPerConnectionPacketWriter instances.
class DefaultPacketWriterFactory : public PacketWriterFactory {
~DefaultPacketWriterFactory() override {}
QuicPacketWriter* Create(QuicPacketWriter* writer,
QuicConnection* connection) override;
// Ideally we'd have a linked_hash_set: the boolean is unused.
typedef linked_hash_map<QuicBlockedWriterInterface*, bool> WriteBlockedList;
// Due to the way delete_sessions_closure_ is registered, the Dispatcher must
// live until epoll_server Shutdown. |supported_versions| specifies the list
// of supported QUIC versions. Takes ownership of |packet_writer_factory|,
// which is used to create per-connection writers.
QuicDispatcher(const QuicConfig& config,
const QuicCryptoServerConfig& crypto_config,
const QuicVersionVector& supported_versions,
PacketWriterFactory* packet_writer_factory,
EpollServer* epoll_server);
~QuicDispatcher() override;
virtual void Initialize(int fd);
// Process the incoming packet by creating a new session, passing it to
// an existing session, or passing it to the TimeWaitListManager.
void ProcessPacket(const IPEndPoint& server_address,
const IPEndPoint& client_address,
const QuicEncryptedPacket& packet) override;
// Called when the socket becomes writable to allow queued writes to happen.
virtual void OnCanWrite();
// Returns true if there's anything in the blocked writer list.
virtual bool HasPendingWrites() const;
// Sends ConnectionClose frames to all connected clients.
void Shutdown();
// QuicServerSessionVisitor interface implementation:
// Ensure that the closed connection is cleaned up asynchronously.
void OnConnectionClosed(QuicConnectionId connection_id,
QuicErrorCode error) override;
// Queues the blocked writer for later resumption.
void OnWriteBlocked(QuicBlockedWriterInterface* blocked_writer) override;
typedef base::hash_map<QuicConnectionId, QuicSession*> SessionMap;
// Deletes all sessions on the closed session list and clears the list.
void DeleteSessions();
const SessionMap& session_map() const { return session_map_; }
// Instantiates a new low-level packet writer. Caller takes ownership of the
// returned object.
virtual QuicPacketWriter* CreateWriter(int fd);
virtual QuicSession* CreateQuicSession(QuicConnectionId connection_id,
const IPEndPoint& server_address,
const IPEndPoint& client_address);
virtual QuicConnection* CreateQuicConnection(
QuicConnectionId connection_id,
const IPEndPoint& server_address,
const IPEndPoint& client_address);
// Called by |framer_visitor_| when the public header has been parsed.
virtual bool OnUnauthenticatedPublicHeader(
const QuicPacketPublicHeader& header);
// Create and return the time wait list manager for this dispatcher, which
// will be owned by the dispatcher as time_wait_list_manager_
virtual QuicTimeWaitListManager* CreateQuicTimeWaitListManager();
// Replaces the packet writer with |writer|. Takes ownership of |writer|.
void set_writer(QuicPacketWriter* writer) {
QuicTimeWaitListManager* time_wait_list_manager() {
return time_wait_list_manager_.get();
EpollServer* epoll_server() { return epoll_server_; }
const QuicVersionVector& supported_versions() const {
return supported_versions_;
const IPEndPoint& current_server_address() {
return current_server_address_;
const IPEndPoint& current_client_address() {
return current_client_address_;
const QuicEncryptedPacket& current_packet() {
return *current_packet_;
const QuicConfig& config() const { return config_; }
const QuicCryptoServerConfig& crypto_config() const { return crypto_config_; }
QuicFramer* framer() { return &framer_; }
QuicEpollConnectionHelper* helper() { return helper_.get(); }
QuicPacketWriter* writer() { return writer_.get(); }
const QuicConnection::PacketWriterFactory& connection_writer_factory() {
return connection_writer_factory_;
class QuicFramerVisitor;
friend class net::tools::test::QuicDispatcherPeer;
// An adapter that creates packet writers using the dispatcher's
// PacketWriterFactory and shared writer. Essentially, it just curries the
// writer argument away from QuicDispatcher::PacketWriterFactory.
class PacketWriterFactoryAdapter :
public QuicConnection::PacketWriterFactory {
PacketWriterFactoryAdapter(QuicDispatcher* dispatcher);
~PacketWriterFactoryAdapter() override;
QuicPacketWriter* Create(QuicConnection* connection) const override;
QuicDispatcher* dispatcher_;
// Called by |framer_visitor_| when the private header has been parsed
// of a data packet that is destined for the time wait manager.
void OnUnauthenticatedHeader(const QuicPacketHeader& header);
// Removes the session from the session map and write blocked list, and
// adds the ConnectionId to the time-wait list.
void CleanUpSession(SessionMap::iterator it);
bool HandlePacketForTimeWait(const QuicPacketPublicHeader& header);
const QuicConfig& config_;
const QuicCryptoServerConfig& crypto_config_;
// The list of connections waiting to write.
WriteBlockedList write_blocked_list_;
SessionMap session_map_;
// Entity that manages connection_ids in time wait state.
scoped_ptr<QuicTimeWaitListManager> time_wait_list_manager_;
// An alarm which deletes closed sessions.
scoped_ptr<DeleteSessionsAlarm> delete_sessions_alarm_;
// The list of closed but not-yet-deleted sessions.
std::list<QuicSession*> closed_session_list_;
EpollServer* epoll_server_; // Owned by the server.
// The helper used for all connections.
scoped_ptr<QuicEpollConnectionHelper> helper_;
// The writer to write to the socket with.
scoped_ptr<QuicPacketWriter> writer_;
// Used to create per-connection packet writers, not |writer_| itself.
scoped_ptr<PacketWriterFactory> packet_writer_factory_;
// Passed in to QuicConnection for it to create the per-connection writers
PacketWriterFactoryAdapter connection_writer_factory_;
// This vector contains QUIC versions which we currently support.
// This should be ordered such that the highest supported version is the first
// element, with subsequent elements in descending order (versions can be
// skipped as necessary).
const QuicVersionVector supported_versions_;
// Information about the packet currently being handled.
IPEndPoint current_client_address_;
IPEndPoint current_server_address_;
const QuicEncryptedPacket* current_packet_;
QuicFramer framer_;
scoped_ptr<QuicFramerVisitor> framer_visitor_;
} // namespace tools
} // namespace net