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_SERVER_SESSION_H_ 6 #define QUICHE_QUIC_MASQUE_MASQUE_SERVER_SESSION_H_ 7 8 #include <list> 9 #include <memory> 10 11 #include "absl/strings/string_view.h" 12 #include "quiche/quic/core/crypto/quic_compressed_certs_cache.h" 13 #include "quiche/quic/core/crypto/quic_crypto_server_config.h" 14 #include "quiche/quic/core/frames/quic_connection_close_frame.h" 15 #include "quiche/quic/core/http/http_frames.h" 16 #include "quiche/quic/core/http/quic_spdy_session.h" 17 #include "quiche/quic/core/http/quic_spdy_stream.h" 18 #include "quiche/quic/core/io/quic_event_loop.h" 19 #include "quiche/quic/core/quic_config.h" 20 #include "quiche/quic/core/quic_connection.h" 21 #include "quiche/quic/core/quic_crypto_server_stream_base.h" 22 #include "quiche/quic/core/quic_session.h" 23 #include "quiche/quic/core/quic_time.h" 24 #include "quiche/quic/core/quic_types.h" 25 #include "quiche/quic/core/quic_udp_socket.h" 26 #include "quiche/quic/core/quic_versions.h" 27 #include "quiche/quic/masque/masque_server_backend.h" 28 #include "quiche/quic/masque/masque_utils.h" 29 #include "quiche/quic/platform/api/quic_export.h" 30 #include "quiche/quic/platform/api/quic_ip_address.h" 31 #include "quiche/quic/platform/api/quic_socket_address.h" 32 #include "quiche/quic/tools/quic_backend_response.h" 33 #include "quiche/quic/tools/quic_simple_server_backend.h" 34 #include "quiche/quic/tools/quic_simple_server_session.h" 35 #include "quiche/common/capsule.h" 36 #include "quiche/spdy/core/http2_header_block.h" 37 38 namespace quic { 39 40 // QUIC server session for connection to MASQUE proxy. 41 class QUIC_NO_EXPORT MasqueServerSession 42 : public QuicSimpleServerSession, 43 public MasqueServerBackend::BackendClient, 44 public QuicSocketEventListener { 45 public: 46 explicit MasqueServerSession( 47 MasqueMode masque_mode, const QuicConfig& config, 48 const ParsedQuicVersionVector& supported_versions, 49 QuicConnection* connection, QuicSession::Visitor* visitor, 50 QuicEventLoop* event_loop, QuicCryptoServerStreamBase::Helper* helper, 51 const QuicCryptoServerConfig* crypto_config, 52 QuicCompressedCertsCache* compressed_certs_cache, 53 MasqueServerBackend* masque_server_backend); 54 55 // Disallow copy and assign. 56 MasqueServerSession(const MasqueServerSession&) = delete; 57 MasqueServerSession& operator=(const MasqueServerSession&) = delete; 58 59 // From QuicSession. 60 void OnMessageAcked(QuicMessageId message_id, 61 QuicTime receive_timestamp) override; 62 void OnMessageLost(QuicMessageId message_id) override; 63 void OnConnectionClosed(const QuicConnectionCloseFrame& frame, 64 ConnectionCloseSource source) override; 65 void OnStreamClosed(QuicStreamId stream_id) override; 66 67 // From MasqueServerBackend::BackendClient. 68 std::unique_ptr<QuicBackendResponse> HandleMasqueRequest( 69 const spdy::Http2HeaderBlock& request_headers, 70 QuicSimpleServerBackend::RequestHandler* request_handler) override; 71 72 // From QuicSocketEventListener. 73 void OnSocketEvent(QuicEventLoop* event_loop, QuicUdpSocketFd fd, 74 QuicSocketEventMask events) override; 75 event_loop()76 QuicEventLoop* event_loop() const { return event_loop_; } 77 78 private: 79 bool HandleConnectUdpSocketEvent(QuicUdpSocketFd fd, 80 QuicSocketEventMask events); 81 bool HandleConnectIpSocketEvent(QuicUdpSocketFd fd, 82 QuicSocketEventMask events); 83 bool HandleConnectEthernetSocketEvent(QuicUdpSocketFd fd, 84 QuicSocketEventMask events); 85 std::unique_ptr<QuicBackendResponse> MaybeCheckSignatureAuth( 86 const spdy::Http2HeaderBlock& request_headers, 87 absl::string_view authority, absl::string_view scheme, 88 QuicSimpleServerBackend::RequestHandler* request_handler); 89 90 // State that the MasqueServerSession keeps for each CONNECT-UDP request. 91 class QUIC_NO_EXPORT ConnectUdpServerState 92 : public QuicSpdyStream::Http3DatagramVisitor { 93 public: 94 // ConnectUdpServerState takes ownership of |fd|. It will unregister it 95 // from |event_loop| and close the file descriptor when destructed. 96 explicit ConnectUdpServerState( 97 QuicSpdyStream* stream, const QuicSocketAddress& target_server_address, 98 QuicUdpSocketFd fd, MasqueServerSession* masque_session); 99 100 ~ConnectUdpServerState(); 101 102 // Disallow copy but allow move. 103 ConnectUdpServerState(const ConnectUdpServerState&) = delete; 104 ConnectUdpServerState(ConnectUdpServerState&&); 105 ConnectUdpServerState& operator=(const ConnectUdpServerState&) = delete; 106 ConnectUdpServerState& operator=(ConnectUdpServerState&&); 107 stream()108 QuicSpdyStream* stream() const { return stream_; } target_server_address()109 const QuicSocketAddress& target_server_address() const { 110 return target_server_address_; 111 } fd()112 QuicUdpSocketFd fd() const { return fd_; } 113 114 // From QuicSpdyStream::Http3DatagramVisitor. 115 void OnHttp3Datagram(QuicStreamId stream_id, 116 absl::string_view payload) override; OnUnknownCapsule(QuicStreamId,const quiche::UnknownCapsule &)117 void OnUnknownCapsule(QuicStreamId /*stream_id*/, 118 const quiche::UnknownCapsule& /*capsule*/) override {} 119 120 private: 121 QuicSpdyStream* stream_; 122 QuicSocketAddress target_server_address_; 123 QuicUdpSocketFd fd_; // Owned. 124 MasqueServerSession* masque_session_; // Unowned. 125 }; 126 127 // State that the MasqueServerSession keeps for each CONNECT-IP request. 128 class QUIC_NO_EXPORT ConnectIpServerState 129 : public QuicSpdyStream::Http3DatagramVisitor, 130 public QuicSpdyStream::ConnectIpVisitor { 131 public: 132 // ConnectIpServerState takes ownership of |fd|. It will unregister it 133 // from |event_loop| and close the file descriptor when destructed. 134 explicit ConnectIpServerState(QuicIpAddress client_ip, 135 QuicSpdyStream* stream, QuicUdpSocketFd fd, 136 MasqueServerSession* masque_session); 137 138 ~ConnectIpServerState(); 139 140 // Disallow copy but allow move. 141 ConnectIpServerState(const ConnectIpServerState&) = delete; 142 ConnectIpServerState(ConnectIpServerState&&); 143 ConnectIpServerState& operator=(const ConnectIpServerState&) = delete; 144 ConnectIpServerState& operator=(ConnectIpServerState&&); 145 stream()146 QuicSpdyStream* stream() const { return stream_; } fd()147 QuicUdpSocketFd fd() const { return fd_; } 148 149 // From QuicSpdyStream::Http3DatagramVisitor. 150 void OnHttp3Datagram(QuicStreamId stream_id, 151 absl::string_view payload) override; OnUnknownCapsule(QuicStreamId,const quiche::UnknownCapsule &)152 void OnUnknownCapsule(QuicStreamId /*stream_id*/, 153 const quiche::UnknownCapsule& /*capsule*/) override {} 154 155 // From QuicSpdyStream::ConnectIpVisitor. 156 bool OnAddressAssignCapsule( 157 const quiche::AddressAssignCapsule& capsule) override; 158 bool OnAddressRequestCapsule( 159 const quiche::AddressRequestCapsule& capsule) override; 160 bool OnRouteAdvertisementCapsule( 161 const quiche::RouteAdvertisementCapsule& capsule) override; 162 void OnHeadersWritten() override; 163 164 private: 165 QuicIpAddress client_ip_; 166 QuicSpdyStream* stream_; 167 QuicUdpSocketFd fd_; // Owned. 168 MasqueServerSession* masque_session_; // Unowned. 169 }; 170 171 // State that the MasqueServerSession keeps for each CONNECT-ETHERNET request. 172 class QUIC_NO_EXPORT ConnectEthernetServerState 173 : public QuicSpdyStream::Http3DatagramVisitor { 174 public: 175 // ConnectEthernetServerState takes ownership of |fd|. It will unregister it 176 // from |event_loop| and close the file descriptor when destructed. 177 explicit ConnectEthernetServerState(QuicSpdyStream* stream, 178 QuicUdpSocketFd fd, 179 MasqueServerSession* masque_session); 180 181 ~ConnectEthernetServerState(); 182 183 // Disallow copy but allow move. 184 ConnectEthernetServerState(const ConnectEthernetServerState&) = delete; 185 ConnectEthernetServerState(ConnectEthernetServerState&&); 186 ConnectEthernetServerState& operator=(const ConnectEthernetServerState&) = 187 delete; 188 ConnectEthernetServerState& operator=(ConnectEthernetServerState&&); 189 stream()190 QuicSpdyStream* stream() const { return stream_; } fd()191 QuicUdpSocketFd fd() const { return fd_; } 192 193 // From QuicSpdyStream::Http3DatagramVisitor. 194 void OnHttp3Datagram(QuicStreamId stream_id, 195 absl::string_view payload) override; OnUnknownCapsule(QuicStreamId,const quiche::UnknownCapsule &)196 void OnUnknownCapsule(QuicStreamId /*stream_id*/, 197 const quiche::UnknownCapsule& /*capsule*/) override {} 198 199 private: 200 QuicSpdyStream* stream_; 201 QuicUdpSocketFd fd_; // Owned. 202 MasqueServerSession* masque_session_; // Unowned. 203 }; 204 205 // From QuicSpdySession. 206 bool OnSettingsFrame(const SettingsFrame& frame) override; LocalHttpDatagramSupport()207 HttpDatagramSupport LocalHttpDatagramSupport() override { 208 return HttpDatagramSupport::kRfc; 209 } 210 211 MasqueServerBackend* masque_server_backend_; // Unowned. 212 QuicEventLoop* event_loop_; // Unowned. 213 MasqueMode masque_mode_; 214 std::list<ConnectUdpServerState> connect_udp_server_states_; 215 std::list<ConnectIpServerState> connect_ip_server_states_; 216 std::list<ConnectEthernetServerState> connect_ethernet_server_states_; 217 }; 218 219 } // namespace quic 220 221 #endif // QUICHE_QUIC_MASQUE_MASQUE_SERVER_SESSION_H_ 222