1 // Copyright 2018 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 OSP_IMPL_QUIC_QUIC_SERVICE_COMMON_H_ 6 #define OSP_IMPL_QUIC_QUIC_SERVICE_COMMON_H_ 7 8 #include <cstdint> 9 #include <map> 10 #include <memory> 11 #include <vector> 12 13 #include "osp/impl/quic/quic_connection.h" 14 #include "osp/public/protocol_connection.h" 15 16 namespace openscreen { 17 namespace osp { 18 19 class ServiceConnectionDelegate; 20 21 class QuicProtocolConnection final : public ProtocolConnection { 22 public: 23 class Owner { 24 public: 25 virtual ~Owner() = default; 26 27 // Called right before |connection| is destroyed (destructor runs). 28 virtual void OnConnectionDestroyed(QuicProtocolConnection* connection) = 0; 29 }; 30 31 static std::unique_ptr<QuicProtocolConnection> FromExisting( 32 Owner* owner, 33 QuicConnection* connection, 34 ServiceConnectionDelegate* delegate, 35 uint64_t endpoint_id); 36 37 QuicProtocolConnection(Owner* owner, 38 uint64_t endpoint_id, 39 uint64_t connection_id); 40 ~QuicProtocolConnection() override; 41 42 // ProtocolConnection overrides. 43 void Write(const uint8_t* data, size_t data_size) override; 44 void CloseWriteEnd() override; 45 stream()46 QuicStream* stream() { return stream_; } set_stream(QuicStream * stream)47 void set_stream(QuicStream* stream) { stream_ = stream; } 48 49 void OnClose(); 50 51 private: 52 Owner* const owner_; 53 QuicStream* stream_ = nullptr; 54 }; 55 56 struct ServiceStreamPair { 57 ServiceStreamPair(std::unique_ptr<QuicStream> stream, 58 QuicProtocolConnection* protocol_connection); 59 ~ServiceStreamPair(); 60 ServiceStreamPair(ServiceStreamPair&&) noexcept; 61 ServiceStreamPair& operator=(ServiceStreamPair&&) noexcept; 62 63 std::unique_ptr<QuicStream> stream; 64 uint64_t connection_id; 65 QuicProtocolConnection* protocol_connection; 66 }; 67 68 class ServiceConnectionDelegate final : public QuicConnection::Delegate, 69 public QuicStream::Delegate { 70 public: 71 class ServiceDelegate : public QuicProtocolConnection::Owner { 72 public: 73 ~ServiceDelegate() override = default; 74 75 virtual uint64_t OnCryptoHandshakeComplete( 76 ServiceConnectionDelegate* delegate, 77 uint64_t connection_id) = 0; 78 virtual void OnIncomingStream( 79 std::unique_ptr<QuicProtocolConnection> connection) = 0; 80 virtual void OnConnectionClosed(uint64_t endpoint_id, 81 uint64_t connection_id) = 0; 82 virtual void OnDataReceived(uint64_t endpoint_id, 83 uint64_t connection_id, 84 const uint8_t* data, 85 size_t data_size) = 0; 86 }; 87 88 ServiceConnectionDelegate(ServiceDelegate* parent, 89 const IPEndpoint& endpoint); 90 ~ServiceConnectionDelegate() override; 91 92 void AddStreamPair(ServiceStreamPair&& stream_pair); 93 void DropProtocolConnection(QuicProtocolConnection* connection); 94 95 // This should be called at the end of each event loop that effects this 96 // connection so streams that were closed by the other endpoint can be 97 // destroyed properly. 98 void DestroyClosedStreams(); 99 endpoint()100 const IPEndpoint& endpoint() const { return endpoint_; } 101 has_streams()102 bool has_streams() const { return !streams_.empty(); } 103 104 // QuicConnection::Delegate overrides. 105 void OnCryptoHandshakeComplete(uint64_t connection_id) override; 106 void OnIncomingStream(uint64_t connection_id, 107 std::unique_ptr<QuicStream> stream) override; 108 void OnConnectionClosed(uint64_t connection_id) override; 109 QuicStream::Delegate* NextStreamDelegate(uint64_t connection_id, 110 uint64_t stream_id) override; 111 112 // QuicStream::Delegate overrides. 113 void OnReceived(QuicStream* stream, 114 const char* data, 115 size_t data_size) override; 116 void OnClose(uint64_t stream_id) override; 117 118 private: 119 ServiceDelegate* const parent_; 120 IPEndpoint endpoint_; 121 uint64_t endpoint_id_; 122 std::unique_ptr<QuicProtocolConnection> pending_connection_; 123 std::map<uint64_t, ServiceStreamPair> streams_; 124 std::vector<ServiceStreamPair> closed_streams_; 125 }; 126 127 struct ServiceConnectionData { 128 explicit ServiceConnectionData( 129 std::unique_ptr<QuicConnection> connection, 130 std::unique_ptr<ServiceConnectionDelegate> delegate); 131 ServiceConnectionData(ServiceConnectionData&&) noexcept; 132 ~ServiceConnectionData(); 133 ServiceConnectionData& operator=(ServiceConnectionData&&) noexcept; 134 135 std::unique_ptr<QuicConnection> connection; 136 std::unique_ptr<ServiceConnectionDelegate> delegate; 137 }; 138 139 } // namespace osp 140 } // namespace openscreen 141 142 #endif // OSP_IMPL_QUIC_QUIC_SERVICE_COMMON_H_ 143