1 /* 2 * Copyright 2004 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 // P2PTransportChannel wraps up the state management of the connection between 12 // two P2P clients. Clients have candidate ports for connecting, and 13 // connections which are combinations of candidates from each end (Alice and 14 // Bob each have candidates, one candidate from Alice and one candidate from 15 // Bob are used to make a connection, repeat to make many connections). 16 // 17 // When all of the available connections become invalid (non-writable), we 18 // kick off a process of determining more candidates and more connections. 19 // 20 #ifndef WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_ 21 #define WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_ 22 23 #include <map> 24 #include <string> 25 #include <vector> 26 #include "webrtc/p2p/base/candidate.h" 27 #include "webrtc/p2p/base/p2ptransport.h" 28 #include "webrtc/p2p/base/portallocator.h" 29 #include "webrtc/p2p/base/portinterface.h" 30 #include "webrtc/p2p/base/transport.h" 31 #include "webrtc/p2p/base/transportchannelimpl.h" 32 #include "webrtc/base/asyncpacketsocket.h" 33 #include "webrtc/base/sigslot.h" 34 35 namespace cricket { 36 37 extern const uint32_t WEAK_PING_DELAY; 38 39 struct IceParameters { 40 std::string ufrag; 41 std::string pwd; IceParametersIceParameters42 IceParameters(const std::string& ice_ufrag, const std::string& ice_pwd) 43 : ufrag(ice_ufrag), pwd(ice_pwd) {} 44 45 bool operator==(const IceParameters& other) { 46 return ufrag == other.ufrag && pwd == other.pwd; 47 } 48 bool operator!=(const IceParameters& other) { return !(*this == other); } 49 }; 50 51 // Adds the port on which the candidate originated. 52 class RemoteCandidate : public Candidate { 53 public: RemoteCandidate(const Candidate & c,PortInterface * origin_port)54 RemoteCandidate(const Candidate& c, PortInterface* origin_port) 55 : Candidate(c), origin_port_(origin_port) {} 56 origin_port()57 PortInterface* origin_port() { return origin_port_; } 58 59 private: 60 PortInterface* origin_port_; 61 }; 62 63 // P2PTransportChannel manages the candidates and connection process to keep 64 // two P2P clients connected to each other. 65 class P2PTransportChannel : public TransportChannelImpl, 66 public rtc::MessageHandler { 67 public: 68 P2PTransportChannel(const std::string& transport_name, 69 int component, 70 P2PTransport* transport, 71 PortAllocator* allocator); 72 virtual ~P2PTransportChannel(); 73 74 // From TransportChannelImpl: GetTransport()75 Transport* GetTransport() override { return transport_; } 76 TransportChannelState GetState() const override; 77 void SetIceRole(IceRole role) override; GetIceRole()78 IceRole GetIceRole() const override { return ice_role_; } 79 void SetIceTiebreaker(uint64_t tiebreaker) override; 80 void SetIceCredentials(const std::string& ice_ufrag, 81 const std::string& ice_pwd) override; 82 void SetRemoteIceCredentials(const std::string& ice_ufrag, 83 const std::string& ice_pwd) override; 84 void SetRemoteIceMode(IceMode mode) override; 85 void Connect() override; 86 void MaybeStartGathering() override; gathering_state()87 IceGatheringState gathering_state() const override { 88 return gathering_state_; 89 } 90 void AddRemoteCandidate(const Candidate& candidate) override; 91 // Sets the receiving timeout and gather_continually. 92 // This also sets the check_receiving_delay proportionally. 93 void SetIceConfig(const IceConfig& config) override; 94 95 // From TransportChannel: 96 int SendPacket(const char* data, 97 size_t len, 98 const rtc::PacketOptions& options, 99 int flags) override; 100 int SetOption(rtc::Socket::Option opt, int value) override; 101 bool GetOption(rtc::Socket::Option opt, int* value) override; GetError()102 int GetError() override { return error_; } 103 bool GetStats(std::vector<ConnectionInfo>* stats) override; 104 best_connection()105 const Connection* best_connection() const { return best_connection_; } set_incoming_only(bool value)106 void set_incoming_only(bool value) { incoming_only_ = value; } 107 108 // Note: This is only for testing purpose. 109 // |ports_| should not be changed from outside. ports()110 const std::vector<PortInterface*>& ports() { return ports_; } 111 remote_ice_mode()112 IceMode remote_ice_mode() const { return remote_ice_mode_; } 113 114 // DTLS methods. IsDtlsActive()115 bool IsDtlsActive() const override { return false; } 116 117 // Default implementation. GetSslRole(rtc::SSLRole * role)118 bool GetSslRole(rtc::SSLRole* role) const override { return false; } 119 SetSslRole(rtc::SSLRole role)120 bool SetSslRole(rtc::SSLRole role) override { return false; } 121 122 // Set up the ciphers to use for DTLS-SRTP. SetSrtpCryptoSuites(const std::vector<int> & ciphers)123 bool SetSrtpCryptoSuites(const std::vector<int>& ciphers) override { 124 return false; 125 } 126 127 // Find out which DTLS-SRTP cipher was negotiated. GetSrtpCryptoSuite(int * cipher)128 bool GetSrtpCryptoSuite(int* cipher) override { return false; } 129 130 // Find out which DTLS cipher was negotiated. GetSslCipherSuite(int * cipher)131 bool GetSslCipherSuite(int* cipher) override { return false; } 132 133 // Returns null because the channel is not encrypted by default. GetLocalCertificate()134 rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate() const override { 135 return nullptr; 136 } 137 GetRemoteSSLCertificate(rtc::SSLCertificate ** cert)138 bool GetRemoteSSLCertificate(rtc::SSLCertificate** cert) const override { 139 return false; 140 } 141 142 // Allows key material to be extracted for external encryption. ExportKeyingMaterial(const std::string & label,const uint8_t * context,size_t context_len,bool use_context,uint8_t * result,size_t result_len)143 bool ExportKeyingMaterial(const std::string& label, 144 const uint8_t* context, 145 size_t context_len, 146 bool use_context, 147 uint8_t* result, 148 size_t result_len) override { 149 return false; 150 } 151 SetLocalCertificate(const rtc::scoped_refptr<rtc::RTCCertificate> & certificate)152 bool SetLocalCertificate( 153 const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) override { 154 return false; 155 } 156 157 // Set DTLS Remote fingerprint. Must be after local identity set. SetRemoteFingerprint(const std::string & digest_alg,const uint8_t * digest,size_t digest_len)158 bool SetRemoteFingerprint(const std::string& digest_alg, 159 const uint8_t* digest, 160 size_t digest_len) override { 161 return false; 162 } 163 receiving_timeout()164 int receiving_timeout() const { return receiving_timeout_; } check_receiving_delay()165 int check_receiving_delay() const { return check_receiving_delay_; } 166 167 // Helper method used only in unittest. 168 rtc::DiffServCodePoint DefaultDscpValue() const; 169 170 // Public for unit tests. 171 Connection* FindNextPingableConnection(); 172 173 // Public for unit tests. connections()174 const std::vector<Connection*>& connections() const { return connections_; } 175 176 // Public for unit tests. allocator_session()177 PortAllocatorSession* allocator_session() { 178 return allocator_sessions_.back(); 179 } 180 181 // Public for unit tests. remote_candidates()182 const std::vector<RemoteCandidate>& remote_candidates() const { 183 return remote_candidates_; 184 } 185 186 private: thread()187 rtc::Thread* thread() { return worker_thread_; } IsGettingPorts()188 bool IsGettingPorts() { return allocator_session()->IsGettingPorts(); } 189 190 // A transport channel is weak if the current best connection is either 191 // not receiving or not writable, or if there is no best connection at all. 192 bool weak() const; 193 void UpdateConnectionStates(); 194 void RequestSort(); 195 void SortConnections(); 196 void SwitchBestConnectionTo(Connection* conn); 197 void UpdateState(); 198 void HandleAllTimedOut(); 199 void MaybeStopPortAllocatorSessions(); 200 TransportChannelState ComputeState() const; 201 202 Connection* GetBestConnectionOnNetwork(rtc::Network* network) const; 203 bool CreateConnections(const Candidate& remote_candidate, 204 PortInterface* origin_port); 205 bool CreateConnection(PortInterface* port, 206 const Candidate& remote_candidate, 207 PortInterface* origin_port); 208 bool FindConnection(cricket::Connection* connection) const; 209 210 uint32_t GetRemoteCandidateGeneration(const Candidate& candidate); 211 bool IsDuplicateRemoteCandidate(const Candidate& candidate); 212 void RememberRemoteCandidate(const Candidate& remote_candidate, 213 PortInterface* origin_port); 214 bool IsPingable(Connection* conn, uint32_t now); 215 void PingConnection(Connection* conn); 216 void AddAllocatorSession(PortAllocatorSession* session); 217 void AddConnection(Connection* connection); 218 219 void OnPortReady(PortAllocatorSession *session, PortInterface* port); 220 void OnCandidatesReady(PortAllocatorSession *session, 221 const std::vector<Candidate>& candidates); 222 void OnCandidatesAllocationDone(PortAllocatorSession* session); 223 void OnUnknownAddress(PortInterface* port, 224 const rtc::SocketAddress& addr, 225 ProtocolType proto, 226 IceMessage* stun_msg, 227 const std::string& remote_username, 228 bool port_muxed); 229 void OnPortDestroyed(PortInterface* port); 230 void OnRoleConflict(PortInterface* port); 231 232 void OnConnectionStateChange(Connection* connection); 233 void OnReadPacket(Connection *connection, const char *data, size_t len, 234 const rtc::PacketTime& packet_time); 235 void OnSentPacket(const rtc::SentPacket& sent_packet); 236 void OnReadyToSend(Connection* connection); 237 void OnConnectionDestroyed(Connection *connection); 238 239 void OnNominated(Connection* conn); 240 241 void OnMessage(rtc::Message* pmsg) override; 242 void OnSort(); 243 void OnCheckAndPing(); 244 245 void PruneConnections(); 246 Connection* best_nominated_connection() const; 247 bool IsBackupConnection(Connection* conn) const; 248 249 // Returns the latest remote ICE parameters or nullptr if there are no remote 250 // ICE parameters yet. remote_ice()251 IceParameters* remote_ice() { 252 return remote_ice_parameters_.empty() ? nullptr 253 : &remote_ice_parameters_.back(); 254 } 255 // Returns the remote IceParameters and generation that match |ufrag| 256 // if found, and returns nullptr otherwise. 257 const IceParameters* FindRemoteIceFromUfrag(const std::string& ufrag, 258 uint32_t* generation); 259 // Returns the index of the latest remote ICE parameters, or 0 if no remote 260 // ICE parameters have been received. remote_ice_generation()261 uint32_t remote_ice_generation() { 262 return remote_ice_parameters_.empty() 263 ? 0 264 : static_cast<uint32_t>(remote_ice_parameters_.size() - 1); 265 } 266 267 P2PTransport* transport_; 268 PortAllocator* allocator_; 269 rtc::Thread* worker_thread_; 270 bool incoming_only_; 271 int error_; 272 std::vector<PortAllocatorSession*> allocator_sessions_; 273 std::vector<PortInterface *> ports_; 274 std::vector<Connection *> connections_; 275 Connection* best_connection_; 276 // Connection selected by the controlling agent. This should be used only 277 // at controlled side when protocol type is RFC5245. 278 Connection* pending_best_connection_; 279 std::vector<RemoteCandidate> remote_candidates_; 280 bool sort_dirty_; // indicates whether another sort is needed right now 281 bool had_connection_ = false; // if connections_ has ever been nonempty 282 typedef std::map<rtc::Socket::Option, int> OptionMap; 283 OptionMap options_; 284 std::string ice_ufrag_; 285 std::string ice_pwd_; 286 std::vector<IceParameters> remote_ice_parameters_; 287 IceMode remote_ice_mode_; 288 IceRole ice_role_; 289 uint64_t tiebreaker_; 290 IceGatheringState gathering_state_; 291 292 int check_receiving_delay_; 293 int receiving_timeout_; 294 int backup_connection_ping_interval_; 295 uint32_t last_ping_sent_ms_ = 0; 296 bool gather_continually_ = false; 297 int weak_ping_delay_ = WEAK_PING_DELAY; 298 TransportChannelState state_ = TransportChannelState::STATE_INIT; 299 300 RTC_DISALLOW_COPY_AND_ASSIGN(P2PTransportChannel); 301 }; 302 303 } // namespace cricket 304 305 #endif // WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_ 306