deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 The WebRTC Project Authors. All rights reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
| 11 | #include "webrtc/p2p/base/transportcontroller.h" |
| 12 | |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 13 | #include <algorithm> |
jbauch | 555604a | 2016-04-26 03:13:22 -0700 | [diff] [blame] | 14 | #include <memory> |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 15 | |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 16 | #include "webrtc/p2p/base/port.h" |
Edward Lemur | c20978e | 2017-07-06 19:44:34 +0200 | [diff] [blame] | 17 | #include "webrtc/rtc_base/bind.h" |
| 18 | #include "webrtc/rtc_base/checks.h" |
| 19 | #include "webrtc/rtc_base/thread.h" |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 20 | |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 21 | namespace { |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 22 | |
| 23 | enum { |
| 24 | MSG_ICECONNECTIONSTATE, |
| 25 | MSG_RECEIVING, |
| 26 | MSG_ICEGATHERINGSTATE, |
| 27 | MSG_CANDIDATESGATHERED, |
| 28 | }; |
| 29 | |
| 30 | struct CandidatesData : public rtc::MessageData { |
| 31 | CandidatesData(const std::string& transport_name, |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 32 | const cricket::Candidates& candidates) |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 33 | : transport_name(transport_name), candidates(candidates) {} |
| 34 | |
| 35 | std::string transport_name; |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 36 | cricket::Candidates candidates; |
| 37 | }; |
| 38 | |
| 39 | } // namespace { |
| 40 | |
| 41 | namespace cricket { |
| 42 | |
| 43 | // This class groups the DTLS and ICE channels, and helps keep track of |
| 44 | // how many external objects (BaseChannels) reference each channel. |
| 45 | class TransportController::ChannelPair { |
| 46 | public: |
| 47 | // TODO(deadbeef): Change the types of |dtls| and |ice| to |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 48 | // DtlsTransport and P2PTransportChannelWrapper, once TransportChannelImpl is |
| 49 | // removed. |
| 50 | ChannelPair(DtlsTransportInternal* dtls, IceTransportInternal* ice) |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 51 | : ice_(ice), dtls_(dtls) {} |
| 52 | |
| 53 | // Currently, all ICE-related calls still go through this DTLS channel. But |
| 54 | // that will change once we get rid of TransportChannelImpl, and the DTLS |
| 55 | // channel interface no longer includes ICE-specific methods. |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 56 | const DtlsTransportInternal* dtls() const { return dtls_.get(); } |
| 57 | DtlsTransportInternal* dtls() { return dtls_.get(); } |
zhihuang | d06adf6 | 2017-01-12 15:58:31 -0800 | [diff] [blame] | 58 | const IceTransportInternal* ice() const { return ice_.get(); } |
| 59 | IceTransportInternal* ice() { return ice_.get(); } |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 60 | |
| 61 | private: |
zhihuang | d06adf6 | 2017-01-12 15:58:31 -0800 | [diff] [blame] | 62 | std::unique_ptr<IceTransportInternal> ice_; |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 63 | std::unique_ptr<DtlsTransportInternal> dtls_; |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 64 | |
| 65 | RTC_DISALLOW_COPY_AND_ASSIGN(ChannelPair); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 66 | }; |
| 67 | |
deadbeef | 7914b8c | 2017-04-21 03:23:33 -0700 | [diff] [blame] | 68 | TransportController::TransportController( |
| 69 | rtc::Thread* signaling_thread, |
| 70 | rtc::Thread* network_thread, |
| 71 | PortAllocator* port_allocator, |
| 72 | bool redetermine_role_on_ice_restart, |
| 73 | const rtc::CryptoOptions& crypto_options) |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 74 | : signaling_thread_(signaling_thread), |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 75 | network_thread_(network_thread), |
Taylor Brandstetter | f0bb360 | 2016-08-26 20:59:24 -0700 | [diff] [blame] | 76 | port_allocator_(port_allocator), |
deadbeef | 7914b8c | 2017-04-21 03:23:33 -0700 | [diff] [blame] | 77 | redetermine_role_on_ice_restart_(redetermine_role_on_ice_restart), |
| 78 | crypto_options_(crypto_options) {} |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 79 | |
| 80 | TransportController::~TransportController() { |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 81 | // Channel destructors may try to send packets, so this needs to happen on |
| 82 | // the network thread. |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 83 | network_thread_->Invoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 84 | RTC_FROM_HERE, |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 85 | rtc::Bind(&TransportController::DestroyAllChannels_n, this)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 86 | } |
| 87 | |
| 88 | bool TransportController::SetSslMaxProtocolVersion( |
| 89 | rtc::SSLProtocolVersion version) { |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 90 | return network_thread_->Invoke<bool>( |
| 91 | RTC_FROM_HERE, rtc::Bind(&TransportController::SetSslMaxProtocolVersion_n, |
| 92 | this, version)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 93 | } |
| 94 | |
honghaiz | 1f429e3 | 2015-09-28 07:57:34 -0700 | [diff] [blame] | 95 | void TransportController::SetIceConfig(const IceConfig& config) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 96 | network_thread_->Invoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 97 | RTC_FROM_HERE, |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 98 | rtc::Bind(&TransportController::SetIceConfig_n, this, config)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 99 | } |
| 100 | |
| 101 | void TransportController::SetIceRole(IceRole ice_role) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 102 | network_thread_->Invoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 103 | RTC_FROM_HERE, |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 104 | rtc::Bind(&TransportController::SetIceRole_n, this, ice_role)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 105 | } |
| 106 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 107 | void TransportController::SetNeedsIceRestartFlag() { |
| 108 | for (auto& kv : transports_) { |
| 109 | kv.second->SetNeedsIceRestartFlag(); |
| 110 | } |
| 111 | } |
| 112 | |
| 113 | bool TransportController::NeedsIceRestart( |
| 114 | const std::string& transport_name) const { |
| 115 | const JsepTransport* transport = GetJsepTransport(transport_name); |
| 116 | if (!transport) { |
| 117 | return false; |
| 118 | } |
| 119 | return transport->NeedsIceRestart(); |
| 120 | } |
| 121 | |
Taylor Brandstetter | f475d36 | 2016-01-08 15:35:57 -0800 | [diff] [blame] | 122 | bool TransportController::GetSslRole(const std::string& transport_name, |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 123 | rtc::SSLRole* role) const { |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 124 | return network_thread_->Invoke<bool>( |
| 125 | RTC_FROM_HERE, rtc::Bind(&TransportController::GetSslRole_n, this, |
| 126 | transport_name, role)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 127 | } |
| 128 | |
| 129 | bool TransportController::SetLocalCertificate( |
| 130 | const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) { |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 131 | return network_thread_->Invoke<bool>( |
| 132 | RTC_FROM_HERE, rtc::Bind(&TransportController::SetLocalCertificate_n, |
| 133 | this, certificate)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | bool TransportController::GetLocalCertificate( |
| 137 | const std::string& transport_name, |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 138 | rtc::scoped_refptr<rtc::RTCCertificate>* certificate) const { |
hbos | df6075a | 2016-12-19 04:58:02 -0800 | [diff] [blame] | 139 | if (network_thread_->IsCurrent()) { |
| 140 | return GetLocalCertificate_n(transport_name, certificate); |
| 141 | } |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 142 | return network_thread_->Invoke<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 143 | RTC_FROM_HERE, rtc::Bind(&TransportController::GetLocalCertificate_n, |
| 144 | this, transport_name, certificate)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 145 | } |
| 146 | |
jbauch | 555604a | 2016-04-26 03:13:22 -0700 | [diff] [blame] | 147 | std::unique_ptr<rtc::SSLCertificate> |
kwiberg | b4d01c4 | 2016-04-06 05:15:06 -0700 | [diff] [blame] | 148 | TransportController::GetRemoteSSLCertificate( |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 149 | const std::string& transport_name) const { |
hbos | df6075a | 2016-12-19 04:58:02 -0800 | [diff] [blame] | 150 | if (network_thread_->IsCurrent()) { |
| 151 | return GetRemoteSSLCertificate_n(transport_name); |
| 152 | } |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 153 | return network_thread_->Invoke<std::unique_ptr<rtc::SSLCertificate>>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 154 | RTC_FROM_HERE, rtc::Bind(&TransportController::GetRemoteSSLCertificate_n, |
| 155 | this, transport_name)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 156 | } |
| 157 | |
| 158 | bool TransportController::SetLocalTransportDescription( |
| 159 | const std::string& transport_name, |
| 160 | const TransportDescription& tdesc, |
| 161 | ContentAction action, |
| 162 | std::string* err) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 163 | return network_thread_->Invoke<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 164 | RTC_FROM_HERE, |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 165 | rtc::Bind(&TransportController::SetLocalTransportDescription_n, this, |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 166 | transport_name, tdesc, action, err)); |
| 167 | } |
| 168 | |
| 169 | bool TransportController::SetRemoteTransportDescription( |
| 170 | const std::string& transport_name, |
| 171 | const TransportDescription& tdesc, |
| 172 | ContentAction action, |
| 173 | std::string* err) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 174 | return network_thread_->Invoke<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 175 | RTC_FROM_HERE, |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 176 | rtc::Bind(&TransportController::SetRemoteTransportDescription_n, this, |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 177 | transport_name, tdesc, action, err)); |
| 178 | } |
| 179 | |
| 180 | void TransportController::MaybeStartGathering() { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 181 | network_thread_->Invoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 182 | RTC_FROM_HERE, |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 183 | rtc::Bind(&TransportController::MaybeStartGathering_n, this)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 184 | } |
| 185 | |
| 186 | bool TransportController::AddRemoteCandidates(const std::string& transport_name, |
| 187 | const Candidates& candidates, |
| 188 | std::string* err) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 189 | return network_thread_->Invoke<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 190 | RTC_FROM_HERE, rtc::Bind(&TransportController::AddRemoteCandidates_n, |
| 191 | this, transport_name, candidates, err)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 192 | } |
| 193 | |
Honghai Zhang | 7fb69db | 2016-03-14 11:59:18 -0700 | [diff] [blame] | 194 | bool TransportController::RemoveRemoteCandidates(const Candidates& candidates, |
| 195 | std::string* err) { |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 196 | return network_thread_->Invoke<bool>( |
| 197 | RTC_FROM_HERE, rtc::Bind(&TransportController::RemoveRemoteCandidates_n, |
| 198 | this, candidates, err)); |
Honghai Zhang | 7fb69db | 2016-03-14 11:59:18 -0700 | [diff] [blame] | 199 | } |
| 200 | |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 201 | bool TransportController::ReadyForRemoteCandidates( |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 202 | const std::string& transport_name) const { |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 203 | return network_thread_->Invoke<bool>( |
| 204 | RTC_FROM_HERE, rtc::Bind(&TransportController::ReadyForRemoteCandidates_n, |
| 205 | this, transport_name)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 206 | } |
| 207 | |
| 208 | bool TransportController::GetStats(const std::string& transport_name, |
| 209 | TransportStats* stats) { |
hbos | df6075a | 2016-12-19 04:58:02 -0800 | [diff] [blame] | 210 | if (network_thread_->IsCurrent()) { |
| 211 | return GetStats_n(transport_name, stats); |
| 212 | } |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 213 | return network_thread_->Invoke<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 214 | RTC_FROM_HERE, |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 215 | rtc::Bind(&TransportController::GetStats_n, this, transport_name, stats)); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 216 | } |
| 217 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 218 | void TransportController::SetMetricsObserver( |
| 219 | webrtc::MetricsObserverInterface* metrics_observer) { |
| 220 | return network_thread_->Invoke<void>( |
| 221 | RTC_FROM_HERE, rtc::Bind(&TransportController::SetMetricsObserver_n, this, |
| 222 | metrics_observer)); |
| 223 | } |
| 224 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 225 | DtlsTransportInternal* TransportController::CreateDtlsTransport( |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 226 | const std::string& transport_name, |
| 227 | int component) { |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 228 | return network_thread_->Invoke<DtlsTransportInternal*>( |
| 229 | RTC_FROM_HERE, rtc::Bind(&TransportController::CreateDtlsTransport_n, |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 230 | this, transport_name, component)); |
| 231 | } |
| 232 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 233 | DtlsTransportInternal* TransportController::CreateDtlsTransport_n( |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 234 | const std::string& transport_name, |
| 235 | int component) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 236 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 237 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 238 | RefCountedChannel* existing_channel = GetChannel_n(transport_name, component); |
| 239 | if (existing_channel) { |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 240 | // Channel already exists; increment reference count and return. |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 241 | existing_channel->AddRef(); |
| 242 | return existing_channel->dtls(); |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 243 | } |
| 244 | |
| 245 | // Need to create a new channel. |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 246 | JsepTransport* transport = GetOrCreateJsepTransport(transport_name); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 247 | |
| 248 | // Create DTLS channel wrapping ICE channel, and configure it. |
zhihuang | d06adf6 | 2017-01-12 15:58:31 -0800 | [diff] [blame] | 249 | IceTransportInternal* ice = |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 250 | CreateIceTransportChannel_n(transport_name, component); |
| 251 | // TODO(deadbeef): To support QUIC, would need to create a |
| 252 | // QuicTransportChannel here. What is "dtls" in this file would then become |
| 253 | // "dtls or quic". |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 254 | DtlsTransportInternal* dtls = |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 255 | CreateDtlsTransportChannel_n(transport_name, component, ice); |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 256 | dtls->ice_transport()->SetMetricsObserver(metrics_observer_); |
| 257 | dtls->ice_transport()->SetIceRole(ice_role_); |
| 258 | dtls->ice_transport()->SetIceTiebreaker(ice_tiebreaker_); |
| 259 | dtls->ice_transport()->SetIceConfig(ice_config_); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 260 | |
| 261 | // Connect to signals offered by the channels. Currently, the DTLS channel |
| 262 | // forwards signals from the ICE channel, so we only need to connect to the |
| 263 | // DTLS channel. In the future this won't be the case. |
| 264 | dtls->SignalWritableState.connect( |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 265 | this, &TransportController::OnChannelWritableState_n); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 266 | dtls->SignalReceivingState.connect( |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 267 | this, &TransportController::OnChannelReceivingState_n); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 268 | dtls->SignalDtlsHandshakeError.connect( |
zhihuang | d82eee0 | 2016-08-26 11:25:05 -0700 | [diff] [blame] | 269 | this, &TransportController::OnDtlsHandshakeError); |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 270 | dtls->ice_transport()->SignalGatheringState.connect( |
| 271 | this, &TransportController::OnChannelGatheringState_n); |
| 272 | dtls->ice_transport()->SignalCandidateGathered.connect( |
| 273 | this, &TransportController::OnChannelCandidateGathered_n); |
| 274 | dtls->ice_transport()->SignalCandidatesRemoved.connect( |
| 275 | this, &TransportController::OnChannelCandidatesRemoved_n); |
| 276 | dtls->ice_transport()->SignalRoleConflict.connect( |
| 277 | this, &TransportController::OnChannelRoleConflict_n); |
| 278 | dtls->ice_transport()->SignalStateChanged.connect( |
| 279 | this, &TransportController::OnChannelStateChanged_n); |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 280 | RefCountedChannel* new_pair = new RefCountedChannel(dtls, ice); |
| 281 | new_pair->AddRef(); |
| 282 | channels_.insert(channels_.end(), new_pair); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 283 | bool channel_added = transport->AddChannel(dtls, component); |
| 284 | RTC_DCHECK(channel_added); |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 285 | // Adding a channel could cause aggregate state to change. |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 286 | UpdateAggregateStates_n(); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 287 | return dtls; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 288 | } |
| 289 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 290 | void TransportController::DestroyDtlsTransport( |
deadbeef | bad5dad | 2017-01-17 18:32:35 -0800 | [diff] [blame] | 291 | const std::string& transport_name, |
| 292 | int component) { |
| 293 | network_thread_->Invoke<void>( |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 294 | RTC_FROM_HERE, rtc::Bind(&TransportController::DestroyDtlsTransport_n, |
deadbeef | bad5dad | 2017-01-17 18:32:35 -0800 | [diff] [blame] | 295 | this, transport_name, component)); |
| 296 | } |
| 297 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 298 | void TransportController::DestroyDtlsTransport_n( |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 299 | const std::string& transport_name, |
| 300 | int component) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 301 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 302 | auto it = GetChannelIterator_n(transport_name, component); |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 303 | if (it == channels_.end()) { |
| 304 | LOG(LS_WARNING) << "Attempting to delete " << transport_name |
| 305 | << " TransportChannel " << component |
| 306 | << ", which doesn't exist."; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 307 | return; |
| 308 | } |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 309 | if ((*it)->Release() > 0) { |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 310 | return; |
| 311 | } |
deadbeef | 57fd726 | 2016-12-06 15:28:55 -0800 | [diff] [blame] | 312 | channels_.erase(it); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 313 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 314 | JsepTransport* t = GetJsepTransport(transport_name); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 315 | bool channel_removed = t->RemoveChannel(component); |
| 316 | RTC_DCHECK(channel_removed); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 317 | // Just as we create a Transport when its first channel is created, |
| 318 | // we delete it when its last channel is deleted. |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 319 | if (!t->HasChannels()) { |
| 320 | transports_.erase(transport_name); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 321 | } |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 322 | // Removing a channel could cause aggregate state to change. |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 323 | UpdateAggregateStates_n(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 324 | } |
| 325 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 326 | std::vector<std::string> TransportController::transport_names_for_testing() { |
| 327 | std::vector<std::string> ret; |
| 328 | for (const auto& kv : transports_) { |
| 329 | ret.push_back(kv.first); |
mikescarlett | e774867 | 2016-04-29 20:20:54 -0700 | [diff] [blame] | 330 | } |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 331 | return ret; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 332 | } |
| 333 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 334 | std::vector<DtlsTransportInternal*> |
| 335 | TransportController::channels_for_testing() { |
| 336 | std::vector<DtlsTransportInternal*> ret; |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 337 | for (RefCountedChannel* channel : channels_) { |
| 338 | ret.push_back(channel->dtls()); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 339 | } |
| 340 | return ret; |
| 341 | } |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 342 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 343 | DtlsTransportInternal* TransportController::get_channel_for_testing( |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 344 | const std::string& transport_name, |
| 345 | int component) { |
| 346 | RefCountedChannel* ch = GetChannel_n(transport_name, component); |
| 347 | return ch ? ch->dtls() : nullptr; |
| 348 | } |
| 349 | |
zhihuang | d06adf6 | 2017-01-12 15:58:31 -0800 | [diff] [blame] | 350 | IceTransportInternal* TransportController::CreateIceTransportChannel_n( |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 351 | const std::string& transport_name, |
| 352 | int component) { |
| 353 | return new P2PTransportChannel(transport_name, component, port_allocator_); |
| 354 | } |
| 355 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 356 | DtlsTransportInternal* TransportController::CreateDtlsTransportChannel_n( |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 357 | const std::string&, |
| 358 | int, |
zhihuang | d06adf6 | 2017-01-12 15:58:31 -0800 | [diff] [blame] | 359 | IceTransportInternal* ice) { |
deadbeef | 7914b8c | 2017-04-21 03:23:33 -0700 | [diff] [blame] | 360 | DtlsTransport* dtls = new DtlsTransport(ice, crypto_options_); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 361 | dtls->SetSslMaxProtocolVersion(ssl_max_version_); |
| 362 | return dtls; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 363 | } |
| 364 | |
| 365 | void TransportController::OnMessage(rtc::Message* pmsg) { |
| 366 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
| 367 | |
| 368 | switch (pmsg->message_id) { |
| 369 | case MSG_ICECONNECTIONSTATE: { |
| 370 | rtc::TypedMessageData<IceConnectionState>* data = |
| 371 | static_cast<rtc::TypedMessageData<IceConnectionState>*>(pmsg->pdata); |
| 372 | SignalConnectionState(data->data()); |
| 373 | delete data; |
| 374 | break; |
| 375 | } |
| 376 | case MSG_RECEIVING: { |
| 377 | rtc::TypedMessageData<bool>* data = |
| 378 | static_cast<rtc::TypedMessageData<bool>*>(pmsg->pdata); |
| 379 | SignalReceiving(data->data()); |
| 380 | delete data; |
| 381 | break; |
| 382 | } |
| 383 | case MSG_ICEGATHERINGSTATE: { |
| 384 | rtc::TypedMessageData<IceGatheringState>* data = |
| 385 | static_cast<rtc::TypedMessageData<IceGatheringState>*>(pmsg->pdata); |
| 386 | SignalGatheringState(data->data()); |
| 387 | delete data; |
| 388 | break; |
| 389 | } |
| 390 | case MSG_CANDIDATESGATHERED: { |
| 391 | CandidatesData* data = static_cast<CandidatesData*>(pmsg->pdata); |
| 392 | SignalCandidatesGathered(data->transport_name, data->candidates); |
| 393 | delete data; |
| 394 | break; |
| 395 | } |
| 396 | default: |
nisse | c80e741 | 2017-01-11 05:56:46 -0800 | [diff] [blame] | 397 | RTC_NOTREACHED(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 398 | } |
| 399 | } |
| 400 | |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 401 | std::vector<TransportController::RefCountedChannel*>::iterator |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 402 | TransportController::GetChannelIterator_n(const std::string& transport_name, |
| 403 | int component) { |
| 404 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 405 | return std::find_if(channels_.begin(), channels_.end(), |
| 406 | [transport_name, component](RefCountedChannel* channel) { |
| 407 | return channel->dtls()->transport_name() == |
| 408 | transport_name && |
| 409 | channel->dtls()->component() == component; |
| 410 | }); |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 411 | } |
| 412 | |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 413 | std::vector<TransportController::RefCountedChannel*>::const_iterator |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 414 | TransportController::GetChannelIterator_n(const std::string& transport_name, |
| 415 | int component) const { |
| 416 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 417 | return std::find_if( |
| 418 | channels_.begin(), channels_.end(), |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 419 | [transport_name, component](const RefCountedChannel* channel) { |
| 420 | return channel->dtls()->transport_name() == transport_name && |
| 421 | channel->dtls()->component() == component; |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 422 | }); |
| 423 | } |
| 424 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 425 | const JsepTransport* TransportController::GetJsepTransport( |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 426 | const std::string& transport_name) const { |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 427 | auto it = transports_.find(transport_name); |
| 428 | return (it == transports_.end()) ? nullptr : it->second.get(); |
| 429 | } |
| 430 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 431 | JsepTransport* TransportController::GetJsepTransport( |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 432 | const std::string& transport_name) { |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 433 | auto it = transports_.find(transport_name); |
| 434 | return (it == transports_.end()) ? nullptr : it->second.get(); |
| 435 | } |
| 436 | |
| 437 | const TransportController::RefCountedChannel* TransportController::GetChannel_n( |
| 438 | const std::string& transport_name, |
| 439 | int component) const { |
| 440 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 441 | auto it = GetChannelIterator_n(transport_name, component); |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 442 | return (it == channels_.end()) ? nullptr : *it; |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 443 | } |
| 444 | |
| 445 | TransportController::RefCountedChannel* TransportController::GetChannel_n( |
| 446 | const std::string& transport_name, |
| 447 | int component) { |
| 448 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 449 | auto it = GetChannelIterator_n(transport_name, component); |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 450 | return (it == channels_.end()) ? nullptr : *it; |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 451 | } |
| 452 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 453 | JsepTransport* TransportController::GetOrCreateJsepTransport( |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 454 | const std::string& transport_name) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 455 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 456 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 457 | JsepTransport* transport = GetJsepTransport(transport_name); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 458 | if (transport) { |
| 459 | return transport; |
| 460 | } |
| 461 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 462 | transport = new JsepTransport(transport_name, certificate_); |
| 463 | transports_[transport_name] = std::unique_ptr<JsepTransport>(transport); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 464 | return transport; |
| 465 | } |
| 466 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 467 | void TransportController::DestroyAllChannels_n() { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 468 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 469 | transports_.clear(); |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 470 | for (RefCountedChannel* channel : channels_) { |
| 471 | // Even though these objects are normally ref-counted, if |
| 472 | // TransportController is deleted while they still have references, just |
| 473 | // remove all references. |
| 474 | while (channel->Release() > 0) { |
| 475 | } |
| 476 | } |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 477 | channels_.clear(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 478 | } |
| 479 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 480 | bool TransportController::SetSslMaxProtocolVersion_n( |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 481 | rtc::SSLProtocolVersion version) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 482 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 483 | |
| 484 | // Max SSL version can only be set before transports are created. |
| 485 | if (!transports_.empty()) { |
| 486 | return false; |
| 487 | } |
| 488 | |
| 489 | ssl_max_version_ = version; |
| 490 | return true; |
| 491 | } |
| 492 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 493 | void TransportController::SetIceConfig_n(const IceConfig& config) { |
| 494 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 495 | |
honghaiz | 1f429e3 | 2015-09-28 07:57:34 -0700 | [diff] [blame] | 496 | ice_config_ = config; |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 497 | for (auto& channel : channels_) { |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 498 | channel->dtls()->ice_transport()->SetIceConfig(ice_config_); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 499 | } |
| 500 | } |
| 501 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 502 | void TransportController::SetIceRole_n(IceRole ice_role) { |
| 503 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 504 | |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 505 | ice_role_ = ice_role; |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 506 | for (auto& channel : channels_) { |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 507 | channel->dtls()->ice_transport()->SetIceRole(ice_role_); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 508 | } |
| 509 | } |
| 510 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 511 | bool TransportController::GetSslRole_n(const std::string& transport_name, |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 512 | rtc::SSLRole* role) const { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 513 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 514 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 515 | const JsepTransport* t = GetJsepTransport(transport_name); |
Taylor Brandstetter | f475d36 | 2016-01-08 15:35:57 -0800 | [diff] [blame] | 516 | if (!t) { |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 517 | return false; |
| 518 | } |
deadbeef | d8cfa1a | 2017-03-27 10:33:26 -0700 | [diff] [blame] | 519 | rtc::Optional<rtc::SSLRole> current_role = t->GetSslRole(); |
| 520 | if (!current_role) { |
| 521 | return false; |
| 522 | } |
| 523 | *role = *current_role; |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 524 | return true; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 525 | } |
| 526 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 527 | bool TransportController::SetLocalCertificate_n( |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 528 | const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 529 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 530 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 531 | // Can't change a certificate, or set a null certificate. |
| 532 | if (certificate_ || !certificate) { |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 533 | return false; |
| 534 | } |
| 535 | certificate_ = certificate; |
| 536 | |
deadbeef | 8662f94 | 2017-01-20 21:20:51 -0800 | [diff] [blame] | 537 | // Set certificate for JsepTransport, which verifies it matches the |
| 538 | // fingerprint in SDP, and only applies it to the DTLS transport if a |
| 539 | // fingerprint attribute is present in SDP. This is used for fallback from |
| 540 | // DTLS to SDES. |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 541 | for (auto& kv : transports_) { |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 542 | kv.second->SetLocalCertificate(certificate_); |
| 543 | } |
| 544 | return true; |
| 545 | } |
| 546 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 547 | bool TransportController::GetLocalCertificate_n( |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 548 | const std::string& transport_name, |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 549 | rtc::scoped_refptr<rtc::RTCCertificate>* certificate) const { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 550 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 551 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 552 | const JsepTransport* t = GetJsepTransport(transport_name); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 553 | if (!t) { |
| 554 | return false; |
| 555 | } |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 556 | return t->GetLocalCertificate(certificate); |
| 557 | } |
| 558 | |
jbauch | 555604a | 2016-04-26 03:13:22 -0700 | [diff] [blame] | 559 | std::unique_ptr<rtc::SSLCertificate> |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 560 | TransportController::GetRemoteSSLCertificate_n( |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 561 | const std::string& transport_name) const { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 562 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 563 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 564 | // Get the certificate from the RTP channel's DTLS handshake. Should be |
| 565 | // identical to the RTCP channel's, since they were given the same remote |
| 566 | // fingerprint. |
| 567 | const RefCountedChannel* ch = GetChannel_n(transport_name, 1); |
| 568 | if (!ch) { |
kwiberg | b4d01c4 | 2016-04-06 05:15:06 -0700 | [diff] [blame] | 569 | return nullptr; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 570 | } |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 571 | return ch->dtls()->GetRemoteSSLCertificate(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 572 | } |
| 573 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 574 | bool TransportController::SetLocalTransportDescription_n( |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 575 | const std::string& transport_name, |
| 576 | const TransportDescription& tdesc, |
| 577 | ContentAction action, |
| 578 | std::string* err) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 579 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 580 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 581 | JsepTransport* transport = GetJsepTransport(transport_name); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 582 | if (!transport) { |
| 583 | // If we didn't find a transport, that's not an error; |
| 584 | // it could have been deleted as a result of bundling. |
| 585 | // TODO(deadbeef): Make callers smarter so they won't attempt to set a |
| 586 | // description on a deleted transport. |
| 587 | return true; |
| 588 | } |
| 589 | |
deadbeef | 91042f8 | 2016-07-15 17:48:13 -0700 | [diff] [blame] | 590 | // Older versions of Chrome expect the ICE role to be re-determined when an |
| 591 | // ICE restart occurs, and also don't perform conflict resolution correctly, |
Taylor Brandstetter | f0bb360 | 2016-08-26 20:59:24 -0700 | [diff] [blame] | 592 | // so for now we can't safely stop doing this, unless the application opts in |
| 593 | // by setting |redetermine_role_on_ice_restart_| to false. |
deadbeef | 91042f8 | 2016-07-15 17:48:13 -0700 | [diff] [blame] | 594 | // See: https://bugs.chromium.org/p/chromium/issues/detail?id=628676 |
| 595 | // TODO(deadbeef): Remove this when these old versions of Chrome reach a low |
| 596 | // enough population. |
Taylor Brandstetter | f0bb360 | 2016-08-26 20:59:24 -0700 | [diff] [blame] | 597 | if (redetermine_role_on_ice_restart_ && transport->local_description() && |
deadbeef | 91042f8 | 2016-07-15 17:48:13 -0700 | [diff] [blame] | 598 | IceCredentialsChanged(transport->local_description()->ice_ufrag, |
| 599 | transport->local_description()->ice_pwd, |
deadbeef | 897d08e | 2017-04-20 00:57:25 -0700 | [diff] [blame] | 600 | tdesc.ice_ufrag, tdesc.ice_pwd) && |
| 601 | // Don't change the ICE role if the remote endpoint is ICE lite; we |
| 602 | // should always be controlling in that case. |
| 603 | (!transport->remote_description() || |
| 604 | transport->remote_description()->ice_mode != ICEMODE_LITE)) { |
deadbeef | 91042f8 | 2016-07-15 17:48:13 -0700 | [diff] [blame] | 605 | IceRole new_ice_role = |
| 606 | (action == CA_OFFER) ? ICEROLE_CONTROLLING : ICEROLE_CONTROLLED; |
| 607 | SetIceRole(new_ice_role); |
| 608 | } |
| 609 | |
Honghai Zhang | 9ecb085 | 2016-09-15 16:41:04 -0700 | [diff] [blame] | 610 | LOG(LS_INFO) << "Set local transport description on " << transport_name; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 611 | return transport->SetLocalTransportDescription(tdesc, action, err); |
| 612 | } |
| 613 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 614 | bool TransportController::SetRemoteTransportDescription_n( |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 615 | const std::string& transport_name, |
| 616 | const TransportDescription& tdesc, |
| 617 | ContentAction action, |
| 618 | std::string* err) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 619 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 620 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 621 | // If our role is ICEROLE_CONTROLLED and the remote endpoint supports only |
| 622 | // ice_lite, this local endpoint should take the CONTROLLING role. |
| 623 | // TODO(deadbeef): This is a session-level attribute, so it really shouldn't |
| 624 | // be in a TransportDescription in the first place... |
| 625 | if (ice_role_ == ICEROLE_CONTROLLED && tdesc.ice_mode == ICEMODE_LITE) { |
| 626 | SetIceRole_n(ICEROLE_CONTROLLING); |
| 627 | } |
| 628 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 629 | JsepTransport* transport = GetJsepTransport(transport_name); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 630 | if (!transport) { |
| 631 | // If we didn't find a transport, that's not an error; |
| 632 | // it could have been deleted as a result of bundling. |
| 633 | // TODO(deadbeef): Make callers smarter so they won't attempt to set a |
| 634 | // description on a deleted transport. |
| 635 | return true; |
| 636 | } |
| 637 | |
Honghai Zhang | 9ecb085 | 2016-09-15 16:41:04 -0700 | [diff] [blame] | 638 | LOG(LS_INFO) << "Set remote transport description on " << transport_name; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 639 | return transport->SetRemoteTransportDescription(tdesc, action, err); |
| 640 | } |
| 641 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 642 | void TransportController::MaybeStartGathering_n() { |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 643 | for (auto& channel : channels_) { |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 644 | channel->dtls()->ice_transport()->MaybeStartGathering(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 645 | } |
| 646 | } |
| 647 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 648 | bool TransportController::AddRemoteCandidates_n( |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 649 | const std::string& transport_name, |
| 650 | const Candidates& candidates, |
| 651 | std::string* err) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 652 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 653 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 654 | // Verify each candidate before passing down to the transport layer. |
| 655 | if (!VerifyCandidates(candidates, err)) { |
| 656 | return false; |
| 657 | } |
| 658 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 659 | JsepTransport* transport = GetJsepTransport(transport_name); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 660 | if (!transport) { |
| 661 | // If we didn't find a transport, that's not an error; |
| 662 | // it could have been deleted as a result of bundling. |
| 663 | return true; |
| 664 | } |
| 665 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 666 | for (const Candidate& candidate : candidates) { |
| 667 | RefCountedChannel* channel = |
| 668 | GetChannel_n(transport_name, candidate.component()); |
| 669 | if (!channel) { |
| 670 | *err = "Candidate has an unknown component: " + candidate.ToString() + |
| 671 | " for content: " + transport_name; |
| 672 | return false; |
| 673 | } |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 674 | channel->dtls()->ice_transport()->AddRemoteCandidate(candidate); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 675 | } |
| 676 | return true; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 677 | } |
| 678 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 679 | bool TransportController::RemoveRemoteCandidates_n(const Candidates& candidates, |
Honghai Zhang | 7fb69db | 2016-03-14 11:59:18 -0700 | [diff] [blame] | 680 | std::string* err) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 681 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 682 | |
| 683 | // Verify each candidate before passing down to the transport layer. |
| 684 | if (!VerifyCandidates(candidates, err)) { |
| 685 | return false; |
| 686 | } |
| 687 | |
Honghai Zhang | 7fb69db | 2016-03-14 11:59:18 -0700 | [diff] [blame] | 688 | std::map<std::string, Candidates> candidates_by_transport_name; |
| 689 | for (const Candidate& cand : candidates) { |
| 690 | RTC_DCHECK(!cand.transport_name().empty()); |
| 691 | candidates_by_transport_name[cand.transport_name()].push_back(cand); |
| 692 | } |
| 693 | |
| 694 | bool result = true; |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 695 | for (const auto& kv : candidates_by_transport_name) { |
| 696 | const std::string& transport_name = kv.first; |
| 697 | const Candidates& candidates = kv.second; |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 698 | JsepTransport* transport = GetJsepTransport(transport_name); |
Honghai Zhang | 7fb69db | 2016-03-14 11:59:18 -0700 | [diff] [blame] | 699 | if (!transport) { |
| 700 | // If we didn't find a transport, that's not an error; |
| 701 | // it could have been deleted as a result of bundling. |
| 702 | continue; |
| 703 | } |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 704 | for (const Candidate& candidate : candidates) { |
| 705 | RefCountedChannel* channel = |
| 706 | GetChannel_n(transport_name, candidate.component()); |
| 707 | if (channel) { |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 708 | channel->dtls()->ice_transport()->RemoveRemoteCandidate(candidate); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 709 | } |
| 710 | } |
Honghai Zhang | 7fb69db | 2016-03-14 11:59:18 -0700 | [diff] [blame] | 711 | } |
| 712 | return result; |
| 713 | } |
| 714 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 715 | bool TransportController::ReadyForRemoteCandidates_n( |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 716 | const std::string& transport_name) const { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 717 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 718 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 719 | const JsepTransport* transport = GetJsepTransport(transport_name); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 720 | if (!transport) { |
| 721 | return false; |
| 722 | } |
| 723 | return transport->ready_for_remote_candidates(); |
| 724 | } |
| 725 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 726 | bool TransportController::GetStats_n(const std::string& transport_name, |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 727 | TransportStats* stats) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 728 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 729 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 730 | JsepTransport* transport = GetJsepTransport(transport_name); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 731 | if (!transport) { |
| 732 | return false; |
| 733 | } |
| 734 | return transport->GetStats(stats); |
| 735 | } |
| 736 | |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 737 | void TransportController::SetMetricsObserver_n( |
| 738 | webrtc::MetricsObserverInterface* metrics_observer) { |
| 739 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 740 | metrics_observer_ = metrics_observer; |
| 741 | for (auto& channel : channels_) { |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 742 | channel->dtls()->ice_transport()->SetMetricsObserver(metrics_observer); |
deadbeef | 49f34fd | 2016-12-06 16:22:06 -0800 | [diff] [blame] | 743 | } |
| 744 | } |
| 745 | |
johan | d89ab14 | 2016-10-25 10:50:32 -0700 | [diff] [blame] | 746 | void TransportController::OnChannelWritableState_n( |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 747 | rtc::PacketTransportInternal* transport) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 748 | RTC_DCHECK(network_thread_->IsCurrent()); |
johan | d89ab14 | 2016-10-25 10:50:32 -0700 | [diff] [blame] | 749 | LOG(LS_INFO) << " TransportChannel " << transport->debug_name() |
| 750 | << " writability changed to " << transport->writable() << "."; |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 751 | UpdateAggregateStates_n(); |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 752 | } |
| 753 | |
johan | 15ca8f6 | 2016-11-01 01:47:41 -0700 | [diff] [blame] | 754 | void TransportController::OnChannelReceivingState_n( |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 755 | rtc::PacketTransportInternal* transport) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 756 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 757 | UpdateAggregateStates_n(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 758 | } |
| 759 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 760 | void TransportController::OnChannelGatheringState_n( |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 761 | IceTransportInternal* channel) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 762 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 763 | UpdateAggregateStates_n(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 764 | } |
| 765 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 766 | void TransportController::OnChannelCandidateGathered_n( |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 767 | IceTransportInternal* channel, |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 768 | const Candidate& candidate) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 769 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 770 | |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 771 | // We should never signal peer-reflexive candidates. |
| 772 | if (candidate.type() == PRFLX_PORT_TYPE) { |
nisse | eb4ca4e | 2017-01-12 02:24:27 -0800 | [diff] [blame] | 773 | RTC_NOTREACHED(); |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 774 | return; |
| 775 | } |
| 776 | std::vector<Candidate> candidates; |
| 777 | candidates.push_back(candidate); |
| 778 | CandidatesData* data = |
| 779 | new CandidatesData(channel->transport_name(), candidates); |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 780 | signaling_thread_->Post(RTC_FROM_HERE, this, MSG_CANDIDATESGATHERED, data); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 781 | } |
| 782 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 783 | void TransportController::OnChannelCandidatesRemoved_n( |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 784 | IceTransportInternal* channel, |
Honghai Zhang | 7fb69db | 2016-03-14 11:59:18 -0700 | [diff] [blame] | 785 | const Candidates& candidates) { |
| 786 | invoker_.AsyncInvoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 787 | RTC_FROM_HERE, signaling_thread_, |
Honghai Zhang | 7fb69db | 2016-03-14 11:59:18 -0700 | [diff] [blame] | 788 | rtc::Bind(&TransportController::OnChannelCandidatesRemoved, this, |
| 789 | candidates)); |
| 790 | } |
| 791 | |
| 792 | void TransportController::OnChannelCandidatesRemoved( |
| 793 | const Candidates& candidates) { |
| 794 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
| 795 | SignalCandidatesRemoved(candidates); |
| 796 | } |
| 797 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 798 | void TransportController::OnChannelRoleConflict_n( |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 799 | IceTransportInternal* channel) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 800 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | 1c20610 | 2016-05-27 13:34:37 -0700 | [diff] [blame] | 801 | // Note: since the role conflict is handled entirely on the network thread, |
| 802 | // we don't need to worry about role conflicts occurring on two ports at once. |
| 803 | // The first one encountered should immediately reverse the role. |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 804 | IceRole reversed_role = (ice_role_ == ICEROLE_CONTROLLING) |
| 805 | ? ICEROLE_CONTROLLED |
| 806 | : ICEROLE_CONTROLLING; |
deadbeef | 1c20610 | 2016-05-27 13:34:37 -0700 | [diff] [blame] | 807 | LOG(LS_INFO) << "Got role conflict; switching to " |
| 808 | << (reversed_role == ICEROLE_CONTROLLING ? "controlling" |
| 809 | : "controlled") |
| 810 | << " role."; |
| 811 | SetIceRole_n(reversed_role); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 812 | } |
| 813 | |
Honghai Zhang | 1590c39 | 2016-05-24 13:15:02 -0700 | [diff] [blame] | 814 | void TransportController::OnChannelStateChanged_n( |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 815 | IceTransportInternal* channel) { |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 816 | RTC_DCHECK(network_thread_->IsCurrent()); |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 817 | LOG(LS_INFO) << channel->transport_name() << " TransportChannel " |
| 818 | << channel->component() |
Honghai Zhang | 1590c39 | 2016-05-24 13:15:02 -0700 | [diff] [blame] | 819 | << " state changed. Check if state is complete."; |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 820 | UpdateAggregateStates_n(); |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 821 | } |
| 822 | |
Danil Chapovalov | 7f216b7 | 2016-05-12 09:20:31 +0200 | [diff] [blame] | 823 | void TransportController::UpdateAggregateStates_n() { |
| 824 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 825 | |
| 826 | IceConnectionState new_connection_state = kIceConnectionConnecting; |
| 827 | IceGatheringState new_gathering_state = kIceGatheringNew; |
| 828 | bool any_receiving = false; |
| 829 | bool any_failed = false; |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 830 | bool all_connected = !channels_.empty(); |
| 831 | bool all_completed = !channels_.empty(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 832 | bool any_gathering = false; |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 833 | bool all_done_gathering = !channels_.empty(); |
| 834 | for (const auto& channel : channels_) { |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 835 | any_receiving = any_receiving || channel->dtls()->receiving(); |
zhihuang | d06adf6 | 2017-01-12 15:58:31 -0800 | [diff] [blame] | 836 | any_failed = any_failed || |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 837 | channel->dtls()->ice_transport()->GetState() == |
| 838 | IceTransportState::STATE_FAILED; |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 839 | all_connected = all_connected && channel->dtls()->writable(); |
Taylor Brandstetter | c4d3a5d | 2015-09-30 10:32:59 -0700 | [diff] [blame] | 840 | all_completed = |
deadbeef | 62802a1 | 2016-12-13 16:38:36 -0800 | [diff] [blame] | 841 | all_completed && channel->dtls()->writable() && |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 842 | channel->dtls()->ice_transport()->GetState() == |
| 843 | IceTransportState::STATE_COMPLETED && |
| 844 | channel->dtls()->ice_transport()->GetIceRole() == ICEROLE_CONTROLLING && |
| 845 | channel->dtls()->ice_transport()->gathering_state() == |
| 846 | kIceGatheringComplete; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 847 | any_gathering = |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 848 | any_gathering || |
| 849 | channel->dtls()->ice_transport()->gathering_state() != kIceGatheringNew; |
| 850 | all_done_gathering = all_done_gathering && |
| 851 | channel->dtls()->ice_transport()->gathering_state() == |
| 852 | kIceGatheringComplete; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 853 | } |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 854 | if (any_failed) { |
| 855 | new_connection_state = kIceConnectionFailed; |
| 856 | } else if (all_completed) { |
| 857 | new_connection_state = kIceConnectionCompleted; |
| 858 | } else if (all_connected) { |
| 859 | new_connection_state = kIceConnectionConnected; |
| 860 | } |
| 861 | if (connection_state_ != new_connection_state) { |
| 862 | connection_state_ = new_connection_state; |
| 863 | signaling_thread_->Post( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 864 | RTC_FROM_HERE, this, MSG_ICECONNECTIONSTATE, |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 865 | new rtc::TypedMessageData<IceConnectionState>(new_connection_state)); |
| 866 | } |
| 867 | |
| 868 | if (receiving_ != any_receiving) { |
| 869 | receiving_ = any_receiving; |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 870 | signaling_thread_->Post(RTC_FROM_HERE, this, MSG_RECEIVING, |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 871 | new rtc::TypedMessageData<bool>(any_receiving)); |
| 872 | } |
| 873 | |
| 874 | if (all_done_gathering) { |
| 875 | new_gathering_state = kIceGatheringComplete; |
| 876 | } else if (any_gathering) { |
| 877 | new_gathering_state = kIceGatheringGathering; |
| 878 | } |
| 879 | if (gathering_state_ != new_gathering_state) { |
| 880 | gathering_state_ = new_gathering_state; |
| 881 | signaling_thread_->Post( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 882 | RTC_FROM_HERE, this, MSG_ICEGATHERINGSTATE, |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 883 | new rtc::TypedMessageData<IceGatheringState>(new_gathering_state)); |
| 884 | } |
| 885 | } |
| 886 | |
zhihuang | d82eee0 | 2016-08-26 11:25:05 -0700 | [diff] [blame] | 887 | void TransportController::OnDtlsHandshakeError(rtc::SSLHandshakeError error) { |
| 888 | SignalDtlsHandshakeError(error); |
| 889 | } |
| 890 | |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 891 | } // namespace cricket |