| // Copyright 2019 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 "net/third_party/quiche/src/quic/masque/masque_dispatcher.h" |
| #include "net/third_party/quiche/src/quic/masque/masque_server_session.h" |
| |
| namespace quic { |
| |
| MasqueDispatcher::MasqueDispatcher( |
| const QuicConfig* config, |
| const QuicCryptoServerConfig* crypto_config, |
| QuicVersionManager* version_manager, |
| std::unique_ptr<QuicConnectionHelperInterface> helper, |
| std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper, |
| std::unique_ptr<QuicAlarmFactory> alarm_factory, |
| MasqueServerBackend* masque_server_backend, |
| uint8_t expected_server_connection_id_length) |
| : QuicSimpleDispatcher(config, |
| crypto_config, |
| version_manager, |
| std::move(helper), |
| std::move(session_helper), |
| std::move(alarm_factory), |
| masque_server_backend, |
| expected_server_connection_id_length), |
| masque_server_backend_(masque_server_backend) {} |
| |
| std::unique_ptr<QuicSession> MasqueDispatcher::CreateQuicSession( |
| QuicConnectionId connection_id, |
| const QuicSocketAddress& self_address, |
| const QuicSocketAddress& peer_address, |
| absl::string_view /*alpn*/, |
| const ParsedQuicVersion& version) { |
| // The MasqueServerSession takes ownership of |connection| below. |
| QuicConnection* connection = |
| new QuicConnection(connection_id, self_address, peer_address, helper(), |
| alarm_factory(), writer(), |
| /*owns_writer=*/false, Perspective::IS_SERVER, |
| ParsedQuicVersionVector{version}); |
| |
| auto session = std::make_unique<MasqueServerSession>( |
| config(), GetSupportedVersions(), connection, this, this, |
| session_helper(), crypto_config(), compressed_certs_cache(), |
| masque_server_backend_); |
| session->Initialize(); |
| return session; |
| } |
| |
| bool MasqueDispatcher::OnFailedToDispatchPacket( |
| const ReceivedPacketInfo& packet_info) { |
| auto connection_id_registration = client_connection_id_registrations_.find( |
| packet_info.destination_connection_id); |
| if (connection_id_registration == client_connection_id_registrations_.end()) { |
| QUIC_DLOG(INFO) << "MasqueDispatcher failed to dispatch " << packet_info; |
| return false; |
| } |
| MasqueServerSession* masque_server_session = |
| connection_id_registration->second; |
| masque_server_session->HandlePacketFromServer(packet_info); |
| return true; |
| } |
| |
| void MasqueDispatcher::RegisterClientConnectionId( |
| QuicConnectionId client_connection_id, |
| MasqueServerSession* masque_server_session) { |
| QUIC_DLOG(INFO) << "Registering encapsulated " << client_connection_id |
| << " to MASQUE session " |
| << masque_server_session->connection_id(); |
| |
| // Make sure we don't try to overwrite an existing registration with a |
| // different session. |
| QUIC_BUG_IF(client_connection_id_registrations_.find(client_connection_id) != |
| client_connection_id_registrations_.end() && |
| client_connection_id_registrations_[client_connection_id] != |
| masque_server_session) |
| << "Overwriting existing registration for " << client_connection_id; |
| client_connection_id_registrations_[client_connection_id] = |
| masque_server_session; |
| } |
| |
| void MasqueDispatcher::UnregisterClientConnectionId( |
| QuicConnectionId client_connection_id) { |
| QUIC_DLOG(INFO) << "Unregistering " << client_connection_id; |
| client_connection_id_registrations_.erase(client_connection_id); |
| } |
| |
| } // namespace quic |