zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update QuicTransportChannel to latest version of libquic (Chromium: f03d2c62)

Browse Source 
These changes are necessary to incorporate the latest
changes to QUIC sessions and the QUIC crypto handshake.

BUG=

Review-Url: https://codereview.webrtc.org/1910633003
Cr-Commit-Position: refs/heads/master@{#12571}
This commit is contained in:
mikescarlett
2016-04-29 15:35:00 -07:00
committed by Commit bot
parent f3569c8a8f
commit 8d37d2941e
7 changed files with 49 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
webrtc/p2p/quic/quicconnectionhelper_unittest.cc
View File

@ -53,10 +53,7 @@ class MockAlarmDelegate : public QuicAlarm::Delegate {
public:
MockAlarmDelegate() : fired_(false) {}
QuicTime OnAlarm() override {
fired_ = true;
return QuicTime::Zero();
}
void OnAlarm() override { fired_ = true; }
bool fired() const { return fired_; }
void Clear() { fired_ = false; }

23
webrtc/p2p/quic/quicsession.cc
View File

@ -46,7 +46,7 @@ void QuicSession::SetCryptoStream(net::QuicCryptoStream* crypto_stream) {
bool QuicSession::ExportKeyingMaterial(base::StringPiece label,
base::StringPiece context,
size_t result_len,
string* result) {
std::string* result) {
return crypto_stream_->ExportKeyingMaterial(label, context, result_len,
result);
}
@ -73,11 +73,7 @@ ReliableQuicStream* QuicSession::CreateIncomingDynamicStream(
ReliableQuicStream* QuicSession::CreateOutgoingDynamicStream(
net::SpdyPriority priority) {
ReliableQuicStream* stream = CreateDataStream(GetNextOutgoingStreamId());
if (stream) {
ActivateStream(stream); // QuicSession owns the stream.
}
return stream;
return CreateDataStream(GetNextOutgoingStreamId());
}
ReliableQuicStream* QuicSession::CreateDataStream(net::QuicStreamId id) {
@ -85,20 +81,25 @@ ReliableQuicStream* QuicSession::CreateDataStream(net::QuicStreamId id) {
// Encryption not active so no stream created
return nullptr;
}
return new ReliableQuicStream(id, this);
ReliableQuicStream* stream = new ReliableQuicStream(id, this);
if (stream) {
ActivateStream(stream); // QuicSession owns the stream.
}
return stream;
}
void QuicSession::OnConnectionClosed(net::QuicErrorCode error,
const std::string& error_details,
net::ConnectionCloseSource source) {
net::QuicSession::OnConnectionClosed(error, source);
net::QuicSession::OnConnectionClosed(error, error_details, source);
SignalConnectionClosed(error,
source == net::ConnectionCloseSource::FROM_PEER);
}
bool QuicSession::OnReadPacket(const char* data, size_t data_len) {
net::QuicEncryptedPacket packet(data, data_len);
connection()->ProcessUdpPacket(connection()->self_address(),
connection()->peer_address(), packet);
net::QuicReceivedPacket packet(data, data_len, clock_.Now());
ProcessUdpPacket(connection()->self_address(), connection()->peer_address(),
packet);
return true;
}

4
webrtc/p2p/quic/quicsession.h
View File

@ -52,13 +52,14 @@ class QuicSession : public net::QuicSession, public sigslot::has_slots<> {
// QuicConnectionVisitorInterface overrides.
void OnConnectionClosed(net::QuicErrorCode error,
const std::string& error_details,
net::ConnectionCloseSource source) override;
// Exports keying material for SRTP.
bool ExportKeyingMaterial(base::StringPiece label,
base::StringPiece context,
size_t result_len,
string* result);
std::string* result);
// Decrypts an incoming QUIC packet to a data stream.
bool OnReadPacket(const char* data, size_t data_len);
@ -84,6 +85,7 @@ class QuicSession : public net::QuicSession, public sigslot::has_slots<> {
private:
std::unique_ptr<net::QuicCryptoStream> crypto_stream_;
net::QuicClock clock_; // For recording packet receipt time
RTC_DISALLOW_COPY_AND_ASSIGN(QuicSession);
};

21
webrtc/p2p/quic/quicsession_unittest.cc
View File

@ -37,6 +37,7 @@ using net::ProofVerifyContext;
using net::ProofVerifyDetails;
using net::QuicByteCount;
using net::QuicClock;
using net::QuicCompressedCertsCache;
using net::QuicConfig;
using net::QuicConnection;
using net::QuicCryptoClientConfig;
@ -112,11 +113,14 @@ class FakeProofVerifier : public net::ProofVerifier {
// ProofVerifier override
net::QuicAsyncStatus VerifyProof(
const std::string& hostname,
const uint16_t port,
const std::string& server_config,
net::QuicVersion quic_version,
base::StringPiece chlo_hash,
const std::vector<std::string>& certs,
const std::string& cert_sct,
const std::string& signature,
const net::ProofVerifyContext* verify_context,
const ProofVerifyContext* context,
std::string* error_details,
std::unique_ptr<net::ProofVerifyDetails>* verify_details,
net::ProofVerifierCallback* callback) override {
@ -231,7 +235,10 @@ class QuicSessionForTest : public QuicSession {
class QuicSessionTest : public ::testing::Test,
public QuicCryptoClientStream::ProofHandler {
public:
QuicSessionTest() : quic_helper_(rtc::Thread::Current()) {}
QuicSessionTest()
: quic_helper_(rtc::Thread::Current()),
quic_compressed_certs_cache_(
QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {}
// Instantiates |client_peer_| and |server_peer_|.
void CreateClientAndServerSessions();
@ -268,6 +275,7 @@ class QuicSessionTest : public ::testing::Test,
QuicConnectionHelper quic_helper_;
QuicConfig config_;
QuicClock clock_;
QuicCompressedCertsCache quic_compressed_certs_cache_;
std::unique_ptr<QuicSessionForTest> client_peer_;
std::unique_ptr<QuicSessionForTest> server_peer_;
@ -324,7 +332,10 @@ QuicCryptoServerStream* QuicSessionTest::CreateCryptoServerStream(
QuicServerConfigProtobuf* primary_config = server_config->GenerateConfig(
QuicRandom::GetInstance(), &clock_, options);
server_config->AddConfig(primary_config, clock_.WallNow());
return new QuicCryptoServerStream(server_config, session);
bool use_stateless_rejects_if_peer_supported = false;
return new QuicCryptoServerStream(
server_config, &quic_compressed_certs_cache_,
use_stateless_rejects_if_peer_supported, session);
}
std::unique_ptr<QuicConnection> QuicSessionTest::CreateConnection(
@ -358,8 +369,8 @@ void QuicSessionTest::TestStreamConnection(QuicSessionForTest* from_session,
ASSERT_TRUE(from_session->IsEncryptionEstablished());
ASSERT_TRUE(to_session->IsEncryptionEstablished());
string from_key;
string to_key;
std::string from_key;
std::string to_key;
bool from_success = from_session->ExportKeyingMaterial(
kExporterLabel, kExporterContext, kExporterContextLen, &from_key);

11
webrtc/p2p/quic/quictransportchannel.cc
View File

@ -104,11 +104,14 @@ class InsecureProofVerifier : public net::ProofVerifier {
// ProofVerifier override.
net::QuicAsyncStatus VerifyProof(
const std::string& hostname,
const uint16_t port,
const std::string& server_config,
net::QuicVersion quic_version,
base::StringPiece chlo_hash,
const std::vector<std::string>& certs,
const std::string& cert_sct,
const std::string& signature,
const net::ProofVerifyContext* verify_context,
const net::ProofVerifyContext* context,
std::string* error_details,
std::unique_ptr<net::ProofVerifyDetails>* verify_details,
net::ProofVerifierCallback* callback) override {
@ -485,8 +488,14 @@ bool QuicTransportChannel::StartQuicHandshake() {
net::QuicCryptoServerConfig::ConfigOptions options;
quic_crypto_server_config_->AddDefaultConfig(helper_.GetRandomGenerator(),
helper_.GetClock(), options);
quic_compressed_certs_cache_.reset(new net::QuicCompressedCertsCache(
net::QuicCompressedCertsCache::kQuicCompressedCertsCacheSize));
// TODO(mikescarlett): Add support for stateless rejects.
bool use_stateless_rejects_if_peer_supported = false;
net::QuicCryptoServerStream* crypto_stream =
new net::QuicCryptoServerStream(quic_crypto_server_config_.get(),
quic_compressed_certs_cache_.get(),
use_stateless_rejects_if_peer_supported,
quic_.get());
quic_->StartServerHandshake(crypto_stream);
LOG_J(LS_INFO, this) << "QuicTransportChannel: Started server handshake.";

2
webrtc/p2p/quic/quictransportchannel.h
View File

@ -292,6 +292,8 @@ class QuicTransportChannel : public TransportChannelImpl,
std::unique_ptr<net::QuicCryptoClientConfig> quic_crypto_client_config_;
// Config for QUIC crypto server stream, used when |ssl_role_| is SSL_SERVER.
std::unique_ptr<net::QuicCryptoServerConfig> quic_crypto_server_config_;
// Used by QUIC crypto server stream to track most recently compressed certs.
std::unique_ptr<net::QuicCompressedCertsCache> quic_compressed_certs_cache_;
// This peer's certificate.
rtc::scoped_refptr<rtc::RTCCertificate> local_certificate_;
// Fingerprint of the remote peer. This must be set before we start QUIC.

12
webrtc/p2p/quic/reliablequicstream_unittest.cc
View File

@ -26,7 +26,6 @@
using cricket::QuicConnectionHelper;
using cricket::ReliableQuicStream;
using net::FecProtection;
using net::IPAddress;
using net::IPEndPoint;
using net::PerPacketOptions;
@ -66,7 +65,6 @@ class MockQuicSession : public QuicSession {
QuicIOVector iovector,
QuicStreamOffset offset,
bool fin,
FecProtection fec_protection,
QuicAckListenerInterface* ack_notifier_delegate) override {
if (!writable_) {
return QuicConsumedData(0, false);
@ -118,11 +116,11 @@ class DummyPacketWriter : public QuicPacketWriter {
DummyPacketWriter() {}
// QuicPacketWriter overrides.
virtual net::WriteResult WritePacket(const char* buffer,
size_t buf_len,
const IPAddress& self_address,
const IPEndPoint& peer_address,
PerPacketOptions* options) {
net::WriteResult WritePacket(const char* buffer,
size_t buf_len,
const IPAddress& self_address,
const IPEndPoint& peer_address,
PerPacketOptions* options) override {
return net::WriteResult(net::WRITE_STATUS_ERROR, 0);
}