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

Remove cricket::DtlsTransportState.

Browse Source 
Bug: webrtc:12762
Change-Id: I7a6535f7ce57b1d521364f3c62086377f5aebf57
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/218600
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34087}
This commit is contained in:
Mirko Bonadei
2021-05-21 20:46:09 +02:00
committed by WebRTC LUCI CQ
parent e976f75c1d
commit 9f6808b13c
18 changed files with 133 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
p2p/base/dtls_transport.cc
View File

@ -15,6 +15,7 @@
#include <utility>
#include "absl/memory/memory.h"
#include "api/dtls_transport_interface.h"
#include "api/rtc_event_log/rtc_event_log.h"
#include "logging/rtc_event_log/events/rtc_event_dtls_transport_state.h"
#include "logging/rtc_event_log/events/rtc_event_dtls_writable_state.h"
@ -148,7 +149,7 @@ DtlsTransport::DtlsTransport(IceTransportInternal* ice_transport,
DtlsTransport::~DtlsTransport() = default;
DtlsTransportState DtlsTransport::dtls_state() const {
webrtc::DtlsTransportState DtlsTransport::dtls_state() const {
return dtls_state_;
}
@ -218,7 +219,7 @@ bool DtlsTransport::GetDtlsRole(rtc::SSLRole* role) const {
}
bool DtlsTransport::GetSslCipherSuite(int* cipher) {
if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
return false;
}
@ -276,7 +277,7 @@ bool DtlsTransport::SetRemoteFingerprint(const std::string& digest_alg,
remote_fingerprint_value_.size(), &err)) {
RTC_LOG(LS_ERROR) << ToString()
<< ": Couldn't set DTLS certificate digest.";
set_dtls_state(DTLS_TRANSPORT_FAILED);
set_dtls_state(webrtc::DtlsTransportState::kFailed);
// If the error is "verification failed", don't return false, because
// this means the fingerprint was formatted correctly but didn't match
// the certificate from the DTLS handshake. Thus the DTLS state should go
@ -290,12 +291,12 @@ bool DtlsTransport::SetRemoteFingerprint(const std::string& digest_alg,
// create a new one, resetting our state.
if (dtls_ && fingerprint_changing) {
dtls_.reset(nullptr);
set_dtls_state(DTLS_TRANSPORT_NEW);
set_dtls_state(webrtc::DtlsTransportState::kNew);
set_writable(false);
}
if (!SetupDtls()) {
set_dtls_state(DTLS_TRANSPORT_FAILED);
set_dtls_state(webrtc::DtlsTransportState::kFailed);
return false;
}
@ -373,7 +374,7 @@ bool DtlsTransport::SetupDtls() {
}
bool DtlsTransport::GetSrtpCryptoSuite(int* cipher) {
if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
return false;
}
@ -381,7 +382,7 @@ bool DtlsTransport::GetSrtpCryptoSuite(int* cipher) {
}
bool DtlsTransport::GetSslVersionBytes(int* version) const {
if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
return false;
}
@ -399,14 +400,14 @@ int DtlsTransport::SendPacket(const char* data,
}
switch (dtls_state()) {
case DTLS_TRANSPORT_NEW:
case webrtc::DtlsTransportState::kNew:
// Can't send data until the connection is active.
// TODO(ekr@rtfm.com): assert here if dtls_ is NULL?
return -1;
case DTLS_TRANSPORT_CONNECTING:
case webrtc::DtlsTransportState::kConnecting:
// Can't send data until the connection is active.
return -1;
case DTLS_TRANSPORT_CONNECTED:
case webrtc::DtlsTransportState::kConnected:
if (flags & PF_SRTP_BYPASS) {
RTC_DCHECK(!srtp_ciphers_.empty());
if (!IsRtpPacket(data, size)) {
@ -419,17 +420,17 @@ int DtlsTransport::SendPacket(const char* data,
? static_cast<int>(size)
: -1;
}
case DTLS_TRANSPORT_FAILED:
case webrtc::DtlsTransportState::kFailed:
// Can't send anything when we're failed.
RTC_LOG(LS_ERROR)
<< ToString()
<< ": Couldn't send packet due to DTLS_TRANSPORT_FAILED.";
RTC_LOG(LS_ERROR) << ToString()
<< ": Couldn't send packet due to "
"webrtc::DtlsTransportState::kFailed.";
return -1;
case DTLS_TRANSPORT_CLOSED:
case webrtc::DtlsTransportState::kClosed:
// Can't send anything when we're closed.
RTC_LOG(LS_ERROR)
<< ToString()
<< ": Couldn't send packet due to DTLS_TRANSPORT_CLOSED.";
RTC_LOG(LS_ERROR) << ToString()
<< ": Couldn't send packet due to "
"webrtc::DtlsTransportState::kClosed.";
return -1;
default:
RTC_NOTREACHED();
@ -508,27 +509,30 @@ void DtlsTransport::OnWritableState(rtc::PacketTransportInternal* transport) {
}
switch (dtls_state()) {
case DTLS_TRANSPORT_NEW:
case webrtc::DtlsTransportState::kNew:
MaybeStartDtls();
break;
case DTLS_TRANSPORT_CONNECTED:
case webrtc::DtlsTransportState::kConnected:
// Note: SignalWritableState fired by set_writable.
set_writable(ice_transport_->writable());
break;
case DTLS_TRANSPORT_CONNECTING:
case webrtc::DtlsTransportState::kConnecting:
// Do nothing.
break;
case DTLS_TRANSPORT_FAILED:
case webrtc::DtlsTransportState::kFailed:
// Should not happen. Do nothing.
RTC_LOG(LS_ERROR)
<< ToString()
<< ": OnWritableState() called in state DTLS_TRANSPORT_FAILED.";
RTC_LOG(LS_ERROR) << ToString()
<< ": OnWritableState() called in state "
"webrtc::DtlsTransportState::kFailed.";
break;
case DTLS_TRANSPORT_CLOSED:
case webrtc::DtlsTransportState::kClosed:
// Should not happen. Do nothing.
RTC_LOG(LS_ERROR)
<< ToString()
<< ": OnWritableState() called in state DTLS_TRANSPORT_CLOSED.";
RTC_LOG(LS_ERROR) << ToString()
<< ": OnWritableState() called in state "
"webrtc::DtlsTransportState::kClosed.";
break;
case webrtc::DtlsTransportState::kNumValues:
RTC_NOTREACHED();
break;
}
}
@ -540,7 +544,7 @@ void DtlsTransport::OnReceivingState(rtc::PacketTransportInternal* transport) {
<< ": ice_transport "
"receiving state changed to "
<< ice_transport_->receiving();
if (!dtls_active_ || dtls_state() == DTLS_TRANSPORT_CONNECTED) {
if (!dtls_active_ || dtls_state() == webrtc::DtlsTransportState::kConnected) {
// Note: SignalReceivingState fired by set_receiving.
set_receiving(ice_transport_->receiving());
}
@ -562,7 +566,7 @@ void DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
}
switch (dtls_state()) {
case DTLS_TRANSPORT_NEW:
case webrtc::DtlsTransportState::kNew:
if (dtls_) {
RTC_LOG(LS_INFO) << ToString()
<< ": Packet received before DTLS started.";
@ -591,8 +595,8 @@ void DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
}
break;
case DTLS_TRANSPORT_CONNECTING:
case DTLS_TRANSPORT_CONNECTED:
case webrtc::DtlsTransportState::kConnecting:
case webrtc::DtlsTransportState::kConnected:
// We should only get DTLS or SRTP packets; STUN's already been demuxed.
// Is this potentially a DTLS packet?
if (IsDtlsPacket(data, size)) {
@ -602,7 +606,7 @@ void DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
}
} else {
// Not a DTLS packet; our handshake should be complete by now.
if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
RTC_LOG(LS_ERROR) << ToString()
<< ": Received non-DTLS packet before DTLS "
"complete.";
@ -623,8 +627,9 @@ void DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
SignalReadPacket(this, data, size, packet_time_us, PF_SRTP_BYPASS);
}
break;
case DTLS_TRANSPORT_FAILED:
case DTLS_TRANSPORT_CLOSED:
case webrtc::DtlsTransportState::kFailed:
case webrtc::DtlsTransportState::kClosed:
case webrtc::DtlsTransportState::kNumValues:
// This shouldn't be happening. Drop the packet.
break;
}
@ -652,7 +657,7 @@ void DtlsTransport::OnDtlsEvent(rtc::StreamInterface* dtls, int sig, int err) {
if (dtls_->GetState() == rtc::SS_OPEN) {
// The check for OPEN shouldn't be necessary but let's make
// sure we don't accidentally frob the state if it's closed.
set_dtls_state(DTLS_TRANSPORT_CONNECTED);
set_dtls_state(webrtc::DtlsTransportState::kConnected);
set_writable(true);
}
}
@ -671,7 +676,7 @@ void DtlsTransport::OnDtlsEvent(rtc::StreamInterface* dtls, int sig, int err) {
// Remote peer shut down the association with no error.
RTC_LOG(LS_INFO) << ToString() << ": DTLS transport closed by remote";
set_writable(false);
set_dtls_state(DTLS_TRANSPORT_CLOSED);
set_dtls_state(webrtc::DtlsTransportState::kClosed);
SignalClosed(this);
} else if (ret == rtc::SR_ERROR) {
// Remote peer shut down the association with an error.
@ -680,7 +685,7 @@ void DtlsTransport::OnDtlsEvent(rtc::StreamInterface* dtls, int sig, int err) {
<< ": Closed by remote with DTLS transport error, code="
<< read_error;
set_writable(false);
set_dtls_state(DTLS_TRANSPORT_FAILED);
set_dtls_state(webrtc::DtlsTransportState::kFailed);
SignalClosed(this);
}
} while (ret == rtc::SR_SUCCESS);
@ -690,10 +695,10 @@ void DtlsTransport::OnDtlsEvent(rtc::StreamInterface* dtls, int sig, int err) {
set_writable(false);
if (!err) {
RTC_LOG(LS_INFO) << ToString() << ": DTLS transport closed";
set_dtls_state(DTLS_TRANSPORT_CLOSED);
set_dtls_state(webrtc::DtlsTransportState::kClosed);
} else {
RTC_LOG(LS_INFO) << ToString() << ": DTLS transport error, code=" << err;
set_dtls_state(DTLS_TRANSPORT_FAILED);
set_dtls_state(webrtc::DtlsTransportState::kFailed);
}
}
}
@ -717,11 +722,11 @@ void DtlsTransport::MaybeStartDtls() {
// configuration and therefore are our fault.
RTC_NOTREACHED() << "StartSSL failed.";
RTC_LOG(LS_ERROR) << ToString() << ": Couldn't start DTLS handshake";
set_dtls_state(DTLS_TRANSPORT_FAILED);
set_dtls_state(webrtc::DtlsTransportState::kFailed);
return;
}
RTC_LOG(LS_INFO) << ToString() << ": DtlsTransport: Started DTLS handshake";
set_dtls_state(DTLS_TRANSPORT_CONNECTING);
set_dtls_state(webrtc::DtlsTransportState::kConnecting);
// Now that the handshake has started, we can process a cached ClientHello
// (if one exists).
if (cached_client_hello_.size()) {
@ -789,16 +794,17 @@ void DtlsTransport::set_writable(bool writable) {
SignalWritableState(this);
}
void DtlsTransport::set_dtls_state(DtlsTransportState state) {
void DtlsTransport::set_dtls_state(webrtc::DtlsTransportState state) {
if (dtls_state_ == state) {
return;
}
if (event_log_) {
event_log_->Log(std::make_unique<webrtc::RtcEventDtlsTransportState>(
ConvertDtlsTransportState(state)));
event_log_->Log(
std::make_unique<webrtc::RtcEventDtlsTransportState>(state));
}
RTC_LOG(LS_VERBOSE) << ToString() << ": set_dtls_state from:" << dtls_state_
<< " to " << state;
RTC_LOG(LS_VERBOSE) << ToString() << ": set_dtls_state from:"
<< static_cast<int>(dtls_state_) << " to "
<< static_cast<int>(state);
dtls_state_ = state;
SendDtlsState(this, state);
}

7
p2p/base/dtls_transport.h
View File

@ -16,6 +16,7 @@
#include <vector>
#include "api/crypto/crypto_options.h"
#include "api/dtls_transport_interface.h"
#include "api/sequence_checker.h"
#include "p2p/base/dtls_transport_internal.h"
#include "p2p/base/ice_transport_internal.h"
@ -109,7 +110,7 @@ class DtlsTransport : public DtlsTransportInternal {
~DtlsTransport() override;
DtlsTransportState dtls_state() const override;
webrtc::DtlsTransportState dtls_state() const override;
const std::string& transport_name() const override;
int component() const override;
@ -219,12 +220,12 @@ class DtlsTransport : public DtlsTransportInternal {
void set_receiving(bool receiving);
void set_writable(bool writable);
// Sets the DTLS state, signaling if necessary.
void set_dtls_state(DtlsTransportState state);
void set_dtls_state(webrtc::DtlsTransportState state);
webrtc::SequenceChecker thread_checker_;
const int component_;
DtlsTransportState dtls_state_ = DTLS_TRANSPORT_NEW;
webrtc::DtlsTransportState dtls_state_ = webrtc::DtlsTransportState::kNew;
// Underlying ice_transport, not owned by this class.
IceTransportInternal* const ice_transport_;
std::unique_ptr<rtc::SSLStreamAdapter> dtls_; // The DTLS stream

18
p2p/base/dtls_transport_internal.cc
View File

@ -16,22 +16,4 @@ DtlsTransportInternal::DtlsTransportInternal() = default;
DtlsTransportInternal::~DtlsTransportInternal() = default;
webrtc::DtlsTransportState ConvertDtlsTransportState(
cricket::DtlsTransportState cricket_state) {
switch (cricket_state) {
case DtlsTransportState::DTLS_TRANSPORT_NEW:
return webrtc::DtlsTransportState::kNew;
case DtlsTransportState::DTLS_TRANSPORT_CONNECTING:
return webrtc::DtlsTransportState::kConnecting;
case DtlsTransportState::DTLS_TRANSPORT_CONNECTED:
return webrtc::DtlsTransportState::kConnected;
case DtlsTransportState::DTLS_TRANSPORT_CLOSED:
return webrtc::DtlsTransportState::kClosed;
case DtlsTransportState::DTLS_TRANSPORT_FAILED:
return webrtc::DtlsTransportState::kFailed;
}
RTC_NOTREACHED();
return webrtc::DtlsTransportState::kNew;
}
} // namespace cricket

45
p2p/base/dtls_transport_internal.h
View File

@ -32,24 +32,6 @@
namespace cricket {
enum DtlsTransportState {
// Haven't started negotiating.
DTLS_TRANSPORT_NEW = static_cast<int>(webrtc::DtlsTransportState::kNew),
// Have started negotiating.
DTLS_TRANSPORT_CONNECTING =
static_cast<int>(webrtc::DtlsTransportState::kConnecting),
// Negotiated, and has a secure connection.
DTLS_TRANSPORT_CONNECTED =
static_cast<int>(webrtc::DtlsTransportState::kConnected),
// Transport is closed.
DTLS_TRANSPORT_CLOSED = static_cast<int>(webrtc::DtlsTransportState::kClosed),
// Failed due to some error in the handshake process.
DTLS_TRANSPORT_FAILED = static_cast<int>(webrtc::DtlsTransportState::kFailed),
};
webrtc::DtlsTransportState ConvertDtlsTransportState(
cricket::DtlsTransportState cricket_state);
enum PacketFlags {
PF_NORMAL = 0x00, // A normal packet.
PF_SRTP_BYPASS = 0x01, // An encrypted SRTP packet; bypass any additional
@ -66,7 +48,7 @@ class DtlsTransportInternal : public rtc::PacketTransportInternal {
public:
~DtlsTransportInternal() override;
virtual DtlsTransportState dtls_state() const = 0;
virtual webrtc::DtlsTransportState dtls_state() const = 0;
virtual int component() const = 0;
@ -117,21 +99,6 @@ class DtlsTransportInternal : public rtc::PacketTransportInternal {
// Expose the underneath IceTransport.
virtual IceTransportInternal* ice_transport() = 0;
// F: void(DtlsTransportInternal*, const DtlsTransportState)
template <typename F>
void SubscribeDtlsState(F&& callback) {
dtls_state_callback_list_.AddReceiver(std::forward<F>(callback));
}
template <typename F>
void SubscribeDtlsState(const void* id, F&& callback) {
dtls_state_callback_list_.AddReceiver(id, std::forward<F>(callback));
}
// Unsubscribe the subscription with given id.
void UnsubscribeDtlsState(const void* id) {
dtls_state_callback_list_.RemoveReceivers(id);
}
// F: void(DtlsTransportInternal*, const webrtc::DtlsTransportState)
template <typename F>
void SubscribeDtlsTransportState(F&& callback) {
@ -149,10 +116,8 @@ class DtlsTransportInternal : public rtc::PacketTransportInternal {
}
void SendDtlsState(DtlsTransportInternal* transport,
DtlsTransportState state) {
dtls_state_callback_list_.Send(transport, state);
dtls_transport_state_callback_list_.Send(transport,
ConvertDtlsTransportState(state));
webrtc::DtlsTransportState state) {
dtls_transport_state_callback_list_.Send(transport, state);
}
// Emitted whenever the Dtls handshake failed on some transport channel.
@ -173,10 +138,6 @@ class DtlsTransportInternal : public rtc::PacketTransportInternal {
RTC_DISALLOW_COPY_AND_ASSIGN(DtlsTransportInternal);
webrtc::CallbackList<const rtc::SSLHandshakeError>
dtls_handshake_error_callback_list_;
// TODO(bugs.webrtc.org/12762): Remove in favor of
// dtls_transport_state_callback_list_.
webrtc::CallbackList<DtlsTransportInternal*, const DtlsTransportState>
dtls_state_callback_list_;
webrtc::CallbackList<DtlsTransportInternal*, const webrtc::DtlsTransportState>
dtls_transport_state_callback_list_;
};

10
p2p/base/dtls_transport_unittest.cc
View File

@ -15,6 +15,7 @@
#include <set>
#include <utility>
#include "api/dtls_transport_interface.h"
#include "p2p/base/fake_ice_transport.h"
#include "p2p/base/packet_transport_internal.h"
#include "rtc_base/checks.h"
@ -668,18 +669,19 @@ class DtlsEventOrderingTest
// Sanity check that the handshake hasn't already finished.
EXPECT_FALSE(client1_.dtls_transport()->IsDtlsConnected() ||
client1_.dtls_transport()->dtls_state() ==
DTLS_TRANSPORT_FAILED);
webrtc::DtlsTransportState::kFailed);
EXPECT_TRUE_SIMULATED_WAIT(
client1_.dtls_transport()->IsDtlsConnected() ||
client1_.dtls_transport()->dtls_state() ==
DTLS_TRANSPORT_FAILED,
webrtc::DtlsTransportState::kFailed,
kTimeout, fake_clock_);
break;
}
}
DtlsTransportState expected_final_state =
valid_fingerprint ? DTLS_TRANSPORT_CONNECTED : DTLS_TRANSPORT_FAILED;
webrtc::DtlsTransportState expected_final_state =
valid_fingerprint ? webrtc::DtlsTransportState::kConnected
: webrtc::DtlsTransportState::kFailed;
EXPECT_EQ_SIMULATED_WAIT(expected_final_state,
client1_.dtls_transport()->dtls_state(), kTimeout,
fake_clock_);

9
p2p/base/fake_dtls_transport.h
View File

@ -17,6 +17,7 @@
#include <vector>
#include "api/crypto/crypto_options.h"
#include "api/dtls_transport_interface.h"
#include "p2p/base/dtls_transport_internal.h"
#include "p2p/base/fake_ice_transport.h"
#include "rtc_base/fake_ssl_identity.h"
@ -89,7 +90,7 @@ class FakeDtlsTransport : public DtlsTransportInternal {
ice_transport_->SetReceiving(receiving);
set_receiving(receiving);
}
void SetDtlsState(DtlsTransportState state) {
void SetDtlsState(webrtc::DtlsTransportState state) {
dtls_state_ = state;
SendDtlsState(this, dtls_state_);
}
@ -121,7 +122,7 @@ class FakeDtlsTransport : public DtlsTransportInternal {
if (!dtls_role_) {
dtls_role_ = std::move(rtc::SSL_CLIENT);
}
SetDtlsState(DTLS_TRANSPORT_CONNECTED);
SetDtlsState(webrtc::DtlsTransportState::kConnected);
ice_transport_->SetDestination(
static_cast<FakeIceTransport*>(dest->ice_transport()), asymmetric);
} else {
@ -133,7 +134,7 @@ class FakeDtlsTransport : public DtlsTransportInternal {
}
// Fake DtlsTransportInternal implementation.
DtlsTransportState dtls_state() const override { return dtls_state_; }
webrtc::DtlsTransportState dtls_state() const override { return dtls_state_; }
const std::string& transport_name() const override { return transport_name_; }
int component() const override { return component_; }
const rtc::SSLFingerprint& dtls_fingerprint() const {
@ -295,7 +296,7 @@ class FakeDtlsTransport : public DtlsTransportInternal {
int crypto_suite_ = rtc::SRTP_AES128_CM_SHA1_80;
absl::optional<int> ssl_cipher_suite_;
DtlsTransportState dtls_state_ = DTLS_TRANSPORT_NEW;
webrtc::DtlsTransportState dtls_state_ = webrtc::DtlsTransportState::kNew;
bool receiving_ = false;
bool writable_ = false;

21
pc/dtls_srtp_transport.cc
View File

@ -15,6 +15,7 @@
#include <string>
#include <utility>
#include "api/dtls_transport_interface.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/ssl_stream_adapter.h"
@ -114,10 +115,9 @@ bool DtlsSrtpTransport::IsDtlsConnected() {
auto rtcp_dtls_transport =
rtcp_mux_enabled() ? nullptr : rtcp_dtls_transport_;
return (rtp_dtls_transport_ &&
rtp_dtls_transport_->dtls_state() ==
cricket::DTLS_TRANSPORT_CONNECTED &&
rtp_dtls_transport_->dtls_state() == DtlsTransportState::kConnected &&
(!rtcp_dtls_transport || rtcp_dtls_transport->dtls_state() ==
cricket::DTLS_TRANSPORT_CONNECTED));
DtlsTransportState::kConnected));
}
bool DtlsSrtpTransport::IsDtlsWritable() {
@ -275,17 +275,16 @@ void DtlsSrtpTransport::SetDtlsTransport(
}
if (*old_dtls_transport) {
(*old_dtls_transport)->UnsubscribeDtlsState(this);
(*old_dtls_transport)->UnsubscribeDtlsTransportState(this);
}
*old_dtls_transport = new_dtls_transport;
if (new_dtls_transport) {
new_dtls_transport->SubscribeDtlsState(
this, [this](cricket::DtlsTransportInternal* transport,
cricket::DtlsTransportState state) {
OnDtlsState(transport, state);
});
new_dtls_transport->SubscribeDtlsTransportState(
this,
[this](cricket::DtlsTransportInternal* transport,
DtlsTransportState state) { OnDtlsState(transport, state); });
}
}
@ -300,7 +299,7 @@ void DtlsSrtpTransport::SetRtcpDtlsTransport(
}
void DtlsSrtpTransport::OnDtlsState(cricket::DtlsTransportInternal* transport,
cricket::DtlsTransportState state) {
DtlsTransportState state) {
RTC_DCHECK(transport == rtp_dtls_transport_ ||
transport == rtcp_dtls_transport_);
@ -308,7 +307,7 @@ void DtlsSrtpTransport::OnDtlsState(cricket::DtlsTransportInternal* transport,
on_dtls_state_change_();
}
if (state != cricket::DTLS_TRANSPORT_CONNECTED) {
if (state != DtlsTransportState::kConnected) {
ResetParams();
return;
}

3
pc/dtls_srtp_transport.h
View File

@ -16,6 +16,7 @@
#include "absl/types/optional.h"
#include "api/crypto_params.h"
#include "api/dtls_transport_interface.h"
#include "api/rtc_error.h"
#include "p2p/base/dtls_transport_internal.h"
#include "p2p/base/packet_transport_internal.h"
@ -82,7 +83,7 @@ class DtlsSrtpTransport : public SrtpTransport {
cricket::DtlsTransportInternal* rtcp_dtls_transport);
void OnDtlsState(cricket::DtlsTransportInternal* dtls_transport,
cricket::DtlsTransportState state);
DtlsTransportState state);
// Override the SrtpTransport::OnWritableState.
void OnWritableState(rtc::PacketTransportInternal* packet_transport) override;

40
pc/dtls_transport.cc
View File

@ -13,6 +13,7 @@
#include <utility>
#include "absl/types/optional.h"
#include "api/dtls_transport_interface.h"
#include "api/sequence_checker.h"
#include "pc/ice_transport.h"
#include "rtc_base/checks.h"
@ -22,26 +23,6 @@
namespace webrtc {
namespace {
DtlsTransportState TranslateState(cricket::DtlsTransportState internal_state) {
switch (internal_state) {
case cricket::DTLS_TRANSPORT_NEW:
return DtlsTransportState::kNew;
case cricket::DTLS_TRANSPORT_CONNECTING:
return DtlsTransportState::kConnecting;
case cricket::DTLS_TRANSPORT_CONNECTED:
return DtlsTransportState::kConnected;
case cricket::DTLS_TRANSPORT_CLOSED:
return DtlsTransportState::kClosed;
case cricket::DTLS_TRANSPORT_FAILED:
return DtlsTransportState::kFailed;
}
RTC_CHECK_NOTREACHED();
}
} // namespace
// Implementation of DtlsTransportInterface
DtlsTransport::DtlsTransport(
std::unique_ptr<cricket::DtlsTransportInternal> internal)
@ -51,9 +32,9 @@ DtlsTransport::DtlsTransport(
ice_transport_(rtc::make_ref_counted<IceTransportWithPointer>(
internal_dtls_transport_->ice_transport())) {
RTC_DCHECK(internal_dtls_transport_.get());
internal_dtls_transport_->SubscribeDtlsState(
internal_dtls_transport_->SubscribeDtlsTransportState(
[this](cricket::DtlsTransportInternal* transport,
cricket::DtlsTransportState state) {
DtlsTransportState state) {
OnInternalDtlsState(transport, state);
});
UpdateInformation();
@ -90,7 +71,7 @@ void DtlsTransport::Clear() {
RTC_DCHECK_RUN_ON(owner_thread_);
RTC_DCHECK(internal());
bool must_send_event =
(internal()->dtls_state() != cricket::DTLS_TRANSPORT_CLOSED);
(internal()->dtls_state() != DtlsTransportState::kClosed);
// The destructor of cricket::DtlsTransportInternal calls back
// into DtlsTransport, so we can't hold the lock while releasing.
std::unique_ptr<cricket::DtlsTransportInternal> transport_to_release;
@ -107,7 +88,7 @@ void DtlsTransport::Clear() {
void DtlsTransport::OnInternalDtlsState(
cricket::DtlsTransportInternal* transport,
cricket::DtlsTransportState state) {
DtlsTransportState state) {
RTC_DCHECK_RUN_ON(owner_thread_);
RTC_DCHECK(transport == internal());
RTC_DCHECK(state == internal()->dtls_state());
@ -122,7 +103,7 @@ void DtlsTransport::UpdateInformation() {
MutexLock lock(&lock_);
if (internal_dtls_transport_) {
if (internal_dtls_transport_->dtls_state() ==
cricket::DTLS_TRANSPORT_CONNECTED) {
DtlsTransportState::kConnected) {
bool success = true;
int ssl_cipher_suite;
int tls_version;
@ -132,20 +113,19 @@ void DtlsTransport::UpdateInformation() {
success &= internal_dtls_transport_->GetSrtpCryptoSuite(&srtp_cipher);
if (success) {
info_ = DtlsTransportInformation(
TranslateState(internal_dtls_transport_->dtls_state()), tls_version,
internal_dtls_transport_->dtls_state(), tls_version,
ssl_cipher_suite, srtp_cipher,
internal_dtls_transport_->GetRemoteSSLCertChain());
} else {
RTC_LOG(LS_ERROR) << "DtlsTransport in connected state has incomplete "
"TLS information";
info_ = DtlsTransportInformation(
TranslateState(internal_dtls_transport_->dtls_state()),
absl::nullopt, absl::nullopt, absl::nullopt,
internal_dtls_transport_->dtls_state(), absl::nullopt,
absl::nullopt, absl::nullopt,
internal_dtls_transport_->GetRemoteSSLCertChain());
}
} else {
info_ = DtlsTransportInformation(
TranslateState(internal_dtls_transport_->dtls_state()));
info_ = DtlsTransportInformation(internal_dtls_transport_->dtls_state());
}
} else {
info_ = DtlsTransportInformation(DtlsTransportState::kClosed);

2
pc/dtls_transport.h
View File

@ -60,7 +60,7 @@ class DtlsTransport : public DtlsTransportInterface {
private:
void OnInternalDtlsState(cricket::DtlsTransportInternal* transport,
cricket::DtlsTransportState state);
DtlsTransportState state);
void UpdateInformation();
DtlsTransportObserverInterface* observer_ = nullptr;

16
pc/jsep_transport_controller.cc
View File

@ -17,6 +17,7 @@
#include <utility>
#include "absl/algorithm/container.h"
#include "api/dtls_transport_interface.h"
#include "api/rtp_parameters.h"
#include "api/sequence_checker.h"
#include "api/transport/enums.h"
@ -1291,7 +1292,7 @@ void JsepTransportController::UpdateAggregateStates_n() {
bool all_done_gathering = !dtls_transports.empty();
std::map<IceTransportState, int> ice_state_counts;
std::map<cricket::DtlsTransportState, int> dtls_state_counts;
std::map<DtlsTransportState, int> dtls_state_counts;
for (const auto& dtls : dtls_transports) {
any_failed = any_failed || dtls->ice_transport()->GetState() ==
@ -1393,16 +1394,15 @@ void JsepTransportController::UpdateAggregateStates_n() {
// Note that "connecting" is only a valid state for DTLS transports while
// "checking", "completed" and "disconnected" are only valid for ICE
// transports.
int total_connected = total_ice_connected +
dtls_state_counts[cricket::DTLS_TRANSPORT_CONNECTED];
int total_connected =
total_ice_connected + dtls_state_counts[DtlsTransportState::kConnected];
int total_dtls_connecting =
dtls_state_counts[cricket::DTLS_TRANSPORT_CONNECTING];
dtls_state_counts[DtlsTransportState::kConnecting];
int total_failed =
total_ice_failed + dtls_state_counts[cricket::DTLS_TRANSPORT_FAILED];
total_ice_failed + dtls_state_counts[DtlsTransportState::kFailed];
int total_closed =
total_ice_closed + dtls_state_counts[cricket::DTLS_TRANSPORT_CLOSED];
int total_new =
total_ice_new + dtls_state_counts[cricket::DTLS_TRANSPORT_NEW];
total_ice_closed + dtls_state_counts[DtlsTransportState::kClosed];
int total_new = total_ice_new + dtls_state_counts[DtlsTransportState::kNew];
int total_transports = total_ice * 2;
if (total_failed > 0) {

11
pc/jsep_transport_controller_unittest.cc
View File

@ -13,6 +13,7 @@
#include <map>
#include <memory>
#include "api/dtls_transport_interface.h"
#include "p2p/base/dtls_transport_factory.h"
#include "p2p/base/fake_dtls_transport.h"
#include "p2p/base/fake_ice_transport.h"
@ -693,8 +694,8 @@ TEST_F(JsepTransportControllerTest,
combined_connection_state_, kTimeout);
EXPECT_EQ(2, combined_connection_state_signal_count_);
fake_audio_dtls->SetDtlsState(cricket::DTLS_TRANSPORT_CONNECTED);
fake_video_dtls->SetDtlsState(cricket::DTLS_TRANSPORT_CONNECTED);
fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
fake_video_dtls->SetDtlsState(DtlsTransportState::kConnected);
// Set the connection count to be 2 and the cricket::FakeIceTransport will set
// the transport state to be STATE_CONNECTING.
fake_video_dtls->fake_ice_transport()->SetConnectionCount(2);
@ -750,8 +751,8 @@ TEST_F(JsepTransportControllerTest, SignalConnectionStateComplete) {
combined_connection_state_, kTimeout);
EXPECT_EQ(2, combined_connection_state_signal_count_);
fake_audio_dtls->SetDtlsState(cricket::DTLS_TRANSPORT_CONNECTED);
fake_video_dtls->SetDtlsState(cricket::DTLS_TRANSPORT_CONNECTED);
fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
fake_video_dtls->SetDtlsState(DtlsTransportState::kConnected);
// Set the connection count to be 1 and the cricket::FakeIceTransport will set
// the transport state to be STATE_COMPLETED.
fake_video_dtls->fake_ice_transport()->SetTransportState(
@ -839,7 +840,7 @@ TEST_F(JsepTransportControllerTest,
fake_audio_dtls->SetWritable(true);
fake_audio_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
fake_audio_dtls->fake_ice_transport()->SetConnectionCount(1);
fake_audio_dtls->SetDtlsState(cricket::DTLS_TRANSPORT_CONNECTED);
fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
EXPECT_EQ(1, gathering_state_signal_count_);
// Set the remote description and enable the bundle.

14
pc/rtc_stats_collector.cc
View File

@ -209,20 +209,20 @@ const char* IceCandidatePairStateToRTCStatsIceCandidatePairState(
}
const char* DtlsTransportStateToRTCDtlsTransportState(
cricket::DtlsTransportState state) {
DtlsTransportState state) {
switch (state) {
case cricket::DTLS_TRANSPORT_NEW:
case DtlsTransportState::kNew:
return RTCDtlsTransportState::kNew;
case cricket::DTLS_TRANSPORT_CONNECTING:
case DtlsTransportState::kConnecting:
return RTCDtlsTransportState::kConnecting;
case cricket::DTLS_TRANSPORT_CONNECTED:
case DtlsTransportState::kConnected:
return RTCDtlsTransportState::kConnected;
case cricket::DTLS_TRANSPORT_CLOSED:
case DtlsTransportState::kClosed:
return RTCDtlsTransportState::kClosed;
case cricket::DTLS_TRANSPORT_FAILED:
case DtlsTransportState::kFailed:
return RTCDtlsTransportState::kFailed;
default:
RTC_NOTREACHED();
RTC_CHECK_NOTREACHED();
return nullptr;
}
}

11
pc/rtc_stats_collector_unittest.cc
View File

@ -22,6 +22,7 @@
#include "absl/memory/memory.h"
#include "absl/strings/str_replace.h"
#include "api/dtls_transport_interface.h"
#include "api/media_stream_track.h"
#include "api/rtp_parameters.h"
#include "api/stats/rtc_stats_report.h"
@ -2322,7 +2323,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCTransportStats) {
rtp_transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
rtp_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
rtp_connection_info);
rtp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_NEW;
rtp_transport_channel_stats.dtls_state = DtlsTransportState::kNew;
rtp_transport_channel_stats.ice_transport_stats
.selected_candidate_pair_changes = 1;
pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats});
@ -2360,7 +2361,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCTransportStats) {
cricket::ICE_CANDIDATE_COMPONENT_RTCP;
rtcp_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
rtcp_connection_info);
rtcp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_CONNECTING;
rtcp_transport_channel_stats.dtls_state = DtlsTransportState::kConnecting;
pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats,
rtcp_transport_channel_stats});
@ -2476,7 +2477,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCTransportStatsWithCrypto) {
rtp_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
rtp_connection_info);
// The state must be connected in order for crypto parameters to show up.
rtp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_CONNECTED;
rtp_transport_channel_stats.dtls_state = DtlsTransportState::kConnected;
rtp_transport_channel_stats.ice_transport_stats
.selected_candidate_pair_changes = 1;
rtp_transport_channel_stats.ssl_version_bytes = 0x0203;
@ -2963,11 +2964,11 @@ TEST_P(RTCStatsCollectorTestWithParamKind,
cricket::TransportChannelStats rtp_transport_channel_stats;
rtp_transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
rtp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_NEW;
rtp_transport_channel_stats.dtls_state = DtlsTransportState::kNew;
cricket::TransportChannelStats rtcp_transport_channel_stats;
rtcp_transport_channel_stats.component =
cricket::ICE_CANDIDATE_COMPONENT_RTCP;
rtcp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_NEW;
rtcp_transport_channel_stats.dtls_state = DtlsTransportState::kNew;
pc_->SetTransportStats("TransportName", {rtp_transport_channel_stats,
rtcp_transport_channel_stats});
AddSenderInfoAndMediaChannel("TransportName", {report_block_data},

11
pc/sctp_transport.cc
View File

@ -14,6 +14,7 @@
#include <utility>
#include "absl/types/optional.h"
#include "api/dtls_transport_interface.h"
#include "api/sequence_checker.h"
#include "rtc_base/checks.h"
#include "rtc_base/location.h"
@ -95,9 +96,9 @@ void SctpTransport::SetDtlsTransport(
if (transport) {
internal_sctp_transport_->SetDtlsTransport(transport->internal());
transport->internal()->SubscribeDtlsState(
transport->internal()->SubscribeDtlsTransportState(
[this](cricket::DtlsTransportInternal* transport,
cricket::DtlsTransportState state) {
DtlsTransportState state) {
OnDtlsStateChange(transport, state);
});
if (info_.state() == SctpTransportState::kNew) {
@ -159,11 +160,11 @@ void SctpTransport::OnAssociationChangeCommunicationUp() {
}
void SctpTransport::OnDtlsStateChange(cricket::DtlsTransportInternal* transport,
cricket::DtlsTransportState state) {
DtlsTransportState state) {
RTC_DCHECK_RUN_ON(owner_thread_);
RTC_CHECK(transport == dtls_transport_->internal());
if (state == cricket::DTLS_TRANSPORT_CLOSED ||
state == cricket::DTLS_TRANSPORT_FAILED) {
if (state == DtlsTransportState::kClosed ||
state == DtlsTransportState::kFailed) {
UpdateInformation(SctpTransportState::kClosed);
// TODO(http://bugs.webrtc.org/11090): Close all the data channels
}

2
pc/sctp_transport.h
View File

@ -71,7 +71,7 @@ class SctpTransport : public SctpTransportInterface,
void OnInternalClosingProcedureStartedRemotely(int sid);
void OnInternalClosingProcedureComplete(int sid);
void OnDtlsStateChange(cricket::DtlsTransportInternal* transport,
cricket::DtlsTransportState state);
DtlsTransportState state);
// NOTE: |owner_thread_| is the thread that the SctpTransport object is
// constructed on. In the context of PeerConnection, it's the network thread.

3
pc/sctp_transport_unittest.cc
View File

@ -14,6 +14,7 @@
#include <vector>
#include "absl/memory/memory.h"
#include "api/dtls_transport_interface.h"
#include "p2p/base/fake_dtls_transport.h"
#include "pc/dtls_transport.h"
#include "rtc_base/gunit.h"
@ -204,7 +205,7 @@ TEST_F(SctpTransportTest, CloseWhenTransportCloses) {
ASSERT_EQ_WAIT(SctpTransportState::kConnected, observer_.State(),
kDefaultTimeout);
static_cast<cricket::FakeDtlsTransport*>(dtls_transport_->internal())
->SetDtlsState(cricket::DTLS_TRANSPORT_CLOSED);
->SetDtlsState(DtlsTransportState::kClosed);
ASSERT_EQ_WAIT(SctpTransportState::kClosed, observer_.State(),
kDefaultTimeout);
}

3
pc/transport_stats.h
View File

@ -14,6 +14,7 @@
#include <string>
#include <vector>
#include "api/dtls_transport_interface.h"
#include "p2p/base/dtls_transport_internal.h"
#include "p2p/base/ice_transport_internal.h"
#include "p2p/base/port.h"
@ -30,7 +31,7 @@ struct TransportChannelStats {
int ssl_version_bytes = 0;
int srtp_crypto_suite = rtc::SRTP_INVALID_CRYPTO_SUITE;
int ssl_cipher_suite = rtc::TLS_NULL_WITH_NULL_NULL;
DtlsTransportState dtls_state = DTLS_TRANSPORT_NEW;
webrtc::DtlsTransportState dtls_state = webrtc::DtlsTransportState::kNew;
IceTransportStats ice_transport_stats;
};