1 // Copyright 2019 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 QUICHE_QUIC_MASQUE_MASQUE_ENCAPSULATED_CLIENT_SESSION_H_ 6 #define QUICHE_QUIC_MASQUE_MASQUE_ENCAPSULATED_CLIENT_SESSION_H_ 7 8 #include <string> 9 10 #include "absl/strings/string_view.h" 11 #include "quiche/quic/core/crypto/quic_crypto_client_config.h" 12 #include "quiche/quic/core/frames/quic_connection_close_frame.h" 13 #include "quiche/quic/core/http/quic_spdy_client_session.h" 14 #include "quiche/quic/core/quic_config.h" 15 #include "quiche/quic/core/quic_error_codes.h" 16 #include "quiche/quic/core/quic_types.h" 17 #include "quiche/quic/core/quic_versions.h" 18 #include "quiche/quic/masque/masque_client_session.h" 19 #include "quiche/quic/platform/api/quic_export.h" 20 #include "quiche/quic/platform/api/quic_ip_address.h" 21 #include "quiche/quic/platform/api/quic_socket_address.h" 22 #include "quiche/common/capsule.h" 23 24 namespace quic { 25 26 // QUIC client session for QUIC encapsulated in MASQUE. This client session is 27 // maintained end-to-end between the client and the web-server (the MASQUE 28 // session does not have access to the cryptographic keys for the end-to-end 29 // session), but its packets are sent encapsulated inside DATAGRAM frames in a 30 // MASQUE session, as opposed to regular QUIC packets. Multiple encapsulated 31 // sessions can coexist inside a MASQUE session. 32 class QUIC_NO_EXPORT MasqueEncapsulatedClientSession 33 : public QuicSpdyClientSession, 34 public MasqueClientSession::EncapsulatedClientSession, 35 public MasqueClientSession::EncapsulatedIpSession { 36 public: 37 // Takes ownership of |connection|, but not of |crypto_config| or 38 // |masque_client_session|. All pointers must be non-null. Caller must ensure 39 // that |masque_client_session| stays valid for the lifetime of the newly 40 // created MasqueEncapsulatedClientSession. 41 MasqueEncapsulatedClientSession( 42 const QuicConfig& config, 43 const ParsedQuicVersionVector& supported_versions, 44 QuicConnection* connection, const QuicServerId& server_id, 45 QuicCryptoClientConfig* crypto_config, 46 MasqueClientSession* masque_client_session); 47 48 // Disallow copy and assign. 49 MasqueEncapsulatedClientSession(const MasqueEncapsulatedClientSession&) = 50 delete; 51 MasqueEncapsulatedClientSession& operator=( 52 const MasqueEncapsulatedClientSession&) = delete; 53 54 // From MasqueClientSession::EncapsulatedClientSession. 55 void ProcessPacket(absl::string_view packet, 56 QuicSocketAddress server_address) override; 57 void CloseConnection( 58 QuicErrorCode error, const std::string& details, 59 ConnectionCloseBehavior connection_close_behavior) override; 60 61 // From MasqueClientSession::EncapsulatedIpSession. 62 void ProcessIpPacket(absl::string_view packet) override; 63 void CloseIpSession(const std::string& details) override; 64 bool OnAddressAssignCapsule( 65 const quiche::AddressAssignCapsule& capsule) override; 66 bool OnAddressRequestCapsule( 67 const quiche::AddressRequestCapsule& capsule) override; 68 bool OnRouteAdvertisementCapsule( 69 const quiche::RouteAdvertisementCapsule& capsule) override; 70 71 // From QuicSession. 72 void OnConnectionClosed(const QuicConnectionCloseFrame& frame, 73 ConnectionCloseSource source) override; 74 75 // For CONNECT-IP. local_v4_address()76 QuicIpAddress local_v4_address() const { return local_v4_address_; } local_v6_address()77 QuicIpAddress local_v6_address() const { return local_v6_address_; } 78 79 private: 80 MasqueClientSession* masque_client_session_; // Unowned. 81 // For CONNECT-IP. 82 QuicIpAddress local_v4_address_; 83 QuicIpAddress local_v6_address_; 84 }; 85 86 } // namespace quic 87 88 #endif // QUICHE_QUIC_MASQUE_MASQUE_ENCAPSULATED_CLIENT_SESSION_H_ 89