You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
112 lines
4.2 KiB
112 lines
4.2 KiB
// Copyright 2018 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.
|
|
|
|
#ifndef OSP_IMPL_QUIC_QUIC_SERVER_H_
|
|
#define OSP_IMPL_QUIC_QUIC_SERVER_H_
|
|
|
|
#include <cstdint>
|
|
#include <map>
|
|
#include <memory>
|
|
|
|
#include "osp/impl/quic/quic_connection_factory.h"
|
|
#include "osp/impl/quic/quic_service_common.h"
|
|
#include "osp/public/protocol_connection_server.h"
|
|
#include "platform/api/task_runner.h"
|
|
#include "platform/api/time.h"
|
|
#include "platform/base/ip_address.h"
|
|
#include "util/alarm.h"
|
|
|
|
namespace openscreen {
|
|
namespace osp {
|
|
|
|
// This class is the default implementation of ProtocolConnectionServer for the
|
|
// library. It manages connections to other endpoints as well as the lifetime
|
|
// of each incoming and outgoing stream. It works in conjunction with a
|
|
// QuicConnectionFactory implementation and MessageDemuxer.
|
|
// QuicConnectionFactory provides the ability to make a new QUIC
|
|
// connection from packets received on its server sockets. Incoming data is
|
|
// given to the QuicServer by the underlying QUIC implementation (through
|
|
// QuicConnectionFactory) and this is in turn handed to MessageDemuxer for
|
|
// routing CBOR messages.
|
|
class QuicServer final : public ProtocolConnectionServer,
|
|
public QuicConnectionFactory::ServerDelegate,
|
|
public ServiceConnectionDelegate::ServiceDelegate {
|
|
public:
|
|
QuicServer(const ServerConfig& config,
|
|
MessageDemuxer* demuxer,
|
|
std::unique_ptr<QuicConnectionFactory> connection_factory,
|
|
ProtocolConnectionServer::Observer* observer,
|
|
ClockNowFunctionPtr now_function,
|
|
TaskRunner* task_runner);
|
|
~QuicServer() override;
|
|
|
|
// ProtocolConnectionServer overrides.
|
|
bool Start() override;
|
|
bool Stop() override;
|
|
bool Suspend() override;
|
|
bool Resume() override;
|
|
std::unique_ptr<ProtocolConnection> CreateProtocolConnection(
|
|
uint64_t endpoint_id) override;
|
|
|
|
// QuicProtocolConnection::Owner overrides.
|
|
void OnConnectionDestroyed(QuicProtocolConnection* connection) override;
|
|
|
|
// ServiceConnectionDelegate::ServiceDelegate overrides.
|
|
uint64_t OnCryptoHandshakeComplete(ServiceConnectionDelegate* delegate,
|
|
uint64_t connection_id) override;
|
|
void OnIncomingStream(
|
|
std::unique_ptr<QuicProtocolConnection> connection) override;
|
|
void OnConnectionClosed(uint64_t endpoint_id,
|
|
uint64_t connection_id) override;
|
|
void OnDataReceived(uint64_t endpoint_id,
|
|
uint64_t connection_id,
|
|
const uint8_t* data,
|
|
size_t data_size) override;
|
|
|
|
private:
|
|
void CloseAllConnections();
|
|
|
|
// QuicConnectionFactory::ServerDelegate overrides.
|
|
QuicConnection::Delegate* NextConnectionDelegate(
|
|
const IPEndpoint& source) override;
|
|
void OnIncomingConnection(
|
|
std::unique_ptr<QuicConnection> connection) override;
|
|
|
|
// Deletes dead QUIC connections then returns the time interval before this
|
|
// method should be run again.
|
|
void Cleanup();
|
|
|
|
const std::vector<IPEndpoint> connection_endpoints_;
|
|
std::unique_ptr<QuicConnectionFactory> connection_factory_;
|
|
|
|
std::unique_ptr<ServiceConnectionDelegate> pending_connection_delegate_;
|
|
|
|
// Maps an IPEndpoint to a generated endpoint ID. This is used to insulate
|
|
// callers from post-handshake changes to a connections actual peer endpoint.
|
|
std::map<IPEndpoint, uint64_t> endpoint_map_;
|
|
|
|
// Value that will be used for the next new endpoint in a Connect call.
|
|
uint64_t next_endpoint_id_ = 0;
|
|
|
|
// Maps endpoint addresses to data about connections that haven't successfully
|
|
// completed the QUIC handshake.
|
|
std::map<IPEndpoint, ServiceConnectionData> pending_connections_;
|
|
|
|
// Maps endpoint IDs to data about connections that have successfully
|
|
// completed the QUIC handshake.
|
|
std::map<uint64_t, ServiceConnectionData> connections_;
|
|
|
|
// Connections (endpoint IDs) that need to be destroyed, but have to wait for
|
|
// the next event loop due to the underlying QUIC implementation's way of
|
|
// referencing them.
|
|
std::vector<uint64_t> delete_connections_;
|
|
|
|
Alarm cleanup_alarm_;
|
|
};
|
|
|
|
} // namespace osp
|
|
} // namespace openscreen
|
|
|
|
#endif // OSP_IMPL_QUIC_QUIC_SERVER_H_
|