1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// Copyright (c) 2017 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 NET_QUIC_QUARTC_QUARTC_SESSION_H_
#define NET_QUIC_QUARTC_QUARTC_SESSION_H_
#include "net/quic/core/quic_crypto_client_stream.h"
#include "net/quic/core/quic_crypto_server_stream.h"
#include "net/quic/core/quic_crypto_stream.h"
#include "net/quic/core/quic_session.h"
#include "net/quic/quartc/quartc_clock_interface.h"
#include "net/quic/quartc/quartc_session_interface.h"
#include "net/quic/quartc/quartc_stream.h"
namespace net {
// A helper class is used by the QuicCryptoServerStream.
class QuartcCryptoServerStreamHelper : public QuicCryptoServerStream::Helper {
public:
QuicConnectionId GenerateConnectionIdForReject(
QuicConnectionId connection_id) const override;
bool CanAcceptClientHello(const CryptoHandshakeMessage& message,
const QuicSocketAddress& self_address,
std::string* error_details) const override;
};
class QuartcSession : public QuicSession,
public QuartcSessionInterface,
public QuicCryptoClientStream::ProofHandler {
public:
QuartcSession(std::unique_ptr<QuicConnection> connection,
const QuicConfig& config,
const std::string& unique_remote_server_id,
Perspective perspective,
QuicConnectionHelperInterface* helper,
QuicClock* clock);
~QuartcSession() override;
// QuicSession overrides.
QuicCryptoStream* GetMutableCryptoStream() override;
const QuicCryptoStream* GetCryptoStream() const override;
QuartcStream* CreateOutgoingDynamicStream(SpdyPriority priority) override;
void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
void CloseStream(QuicStreamId stream_id) override;
// QuicConnectionVisitorInterface overrides.
void OnConnectionClosed(QuicErrorCode error,
const std::string& error_details,
ConnectionCloseSource source) override;
// QuartcSessionInterface overrides
void StartCryptoHandshake() override;
bool ExportKeyingMaterial(const std::string& label,
const uint8_t* context,
size_t context_len,
bool used_context,
uint8_t* result,
size_t result_len) override;
QuartcStreamInterface* CreateOutgoingStream(
const OutgoingStreamParameters& param) override;
void SetDelegate(QuartcSessionInterface::Delegate* session_delegate) override;
void OnTransportCanWrite() override;
// Decrypts an incoming QUIC packet to a data stream.
bool OnTransportReceived(const char* data, size_t data_len) override;
// ProofHandler overrides.
void OnProofValid(const QuicCryptoClientConfig::CachedState& cached) override;
// Called by the client crypto handshake when proof verification details
// become available, either because proof verification is complete, or when
// cached details are used.
void OnProofVerifyDetailsAvailable(
const ProofVerifyDetails& verify_details) override;
// Override the default crypto configuration.
// The session will take the ownership of the configurations.
void SetClientCryptoConfig(QuicCryptoClientConfig* client_config);
void SetServerCryptoConfig(QuicCryptoServerConfig* server_config);
protected:
// QuicSession override.
QuicStream* CreateIncomingDynamicStream(QuicStreamId id) override;
std::unique_ptr<QuicStream> CreateStream(QuicStreamId id) override;
QuartcStream* CreateDataStream(QuicStreamId id, SpdyPriority priority);
private:
// For crypto handshake.
std::unique_ptr<QuicCryptoStream> crypto_stream_;
const std::string unique_remote_server_id_;
Perspective perspective_;
// Take the ownership of the QuicConnection.
std::unique_ptr<QuicConnection> connection_;
// Not owned by QuartcSession. From the QuartcFactory.
QuicConnectionHelperInterface* helper_;
// For recording packet receipt time
QuicClock* clock_;
// Not owned by QuartcSession.
QuartcSessionInterface::Delegate* session_delegate_ = nullptr;
// Used by QUIC crypto server stream to track most recently compressed certs.
std::unique_ptr<QuicCompressedCertsCache> quic_compressed_certs_cache_;
// This helper is needed when create QuicCryptoServerStream.
QuartcCryptoServerStreamHelper stream_helper_;
// Config for QUIC crypto client stream, used by the client.
std::unique_ptr<QuicCryptoClientConfig> quic_crypto_client_config_;
// Config for QUIC crypto server stream, used by the server.
std::unique_ptr<QuicCryptoServerConfig> quic_crypto_server_config_;
DISALLOW_COPY_AND_ASSIGN(QuartcSession);
};
} // namespace net
#endif // NET_QUIC_QUARTC_QUARTC_SESSION_H_
|
