blob: 2cd264e09e334186e377ddbc69bed16a5fc59313 [file] [log] [blame]
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +00001/*
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#ifndef WEBRTC_P2P_BASE_PORT_H_
12#define WEBRTC_P2P_BASE_PORT_H_
13
14#include <map>
kwiberg3ec46792016-04-27 07:22:53 -070015#include <memory>
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +000016#include <set>
17#include <string>
18#include <vector>
19
20#include "webrtc/p2p/base/candidate.h"
Honghai Zhangcc411c02016-03-29 17:27:21 -070021#include "webrtc/p2p/base/candidatepairinterface.h"
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +000022#include "webrtc/p2p/base/packetsocketfactory.h"
23#include "webrtc/p2p/base/portinterface.h"
24#include "webrtc/p2p/base/stun.h"
25#include "webrtc/p2p/base/stunrequest.h"
26#include "webrtc/p2p/base/transport.h"
27#include "webrtc/base/asyncpacketsocket.h"
28#include "webrtc/base/network.h"
29#include "webrtc/base/proxyinfo.h"
30#include "webrtc/base/ratetracker.h"
31#include "webrtc/base/sigslot.h"
32#include "webrtc/base/socketaddress.h"
33#include "webrtc/base/thread.h"
34
35namespace cricket {
36
37class Connection;
38class ConnectionRequest;
39
40extern const char LOCAL_PORT_TYPE[];
41extern const char STUN_PORT_TYPE[];
42extern const char PRFLX_PORT_TYPE[];
43extern const char RELAY_PORT_TYPE[];
44
45extern const char UDP_PROTOCOL_NAME[];
46extern const char TCP_PROTOCOL_NAME[];
47extern const char SSLTCP_PROTOCOL_NAME[];
48
49// RFC 6544, TCP candidate encoding rules.
50extern const int DISCARD_PORT;
51extern const char TCPTYPE_ACTIVE_STR[];
52extern const char TCPTYPE_PASSIVE_STR[];
53extern const char TCPTYPE_SIMOPEN_STR[];
54
Honghai Zhang2b342bf2015-09-30 09:51:58 -070055// The minimum time we will wait before destroying a connection after creating
56// it.
honghaiz34b11eb2016-03-16 08:55:44 -070057static const int MIN_CONNECTION_LIFETIME = 10 * 1000; // 10 seconds.
Peter Thatcher04ac81f2015-09-21 11:48:28 -070058
Honghai Zhang2cd7afe2015-11-12 11:14:33 -080059// A connection will be declared dead if it has not received anything for this
60// long.
honghaiz34b11eb2016-03-16 08:55:44 -070061static const int DEAD_CONNECTION_RECEIVE_TIMEOUT = 30 * 1000; // 30 seconds.
Honghai Zhang2cd7afe2015-11-12 11:14:33 -080062
Peter Thatcher04ac81f2015-09-21 11:48:28 -070063// The timeout duration when a connection does not receive anything.
honghaiz34b11eb2016-03-16 08:55:44 -070064static const int WEAK_CONNECTION_RECEIVE_TIMEOUT = 2500; // 2.5 seconds
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +000065
66// The length of time we wait before timing out writability on a connection.
honghaiz34b11eb2016-03-16 08:55:44 -070067static const int CONNECTION_WRITE_TIMEOUT = 15 * 1000; // 15 seconds
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +000068
69// The length of time we wait before we become unwritable.
honghaiz34b11eb2016-03-16 08:55:44 -070070static const int CONNECTION_WRITE_CONNECT_TIMEOUT = 5 * 1000; // 5 seconds
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +000071
72// This is the length of time that we wait for a ping response to come back.
honghaiz34b11eb2016-03-16 08:55:44 -070073static const int CONNECTION_RESPONSE_TIMEOUT = 5 * 1000; // 5 seconds
74
75// The number of pings that must fail to respond before we become unwritable.
76static const uint32_t CONNECTION_WRITE_CONNECT_FAILURES = 5;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +000077
78enum RelayType {
79 RELAY_GTURN, // Legacy google relay service.
80 RELAY_TURN // Standard (TURN) relay service.
81};
82
83enum IcePriorityValue {
84 // The reason we are choosing Relay preference 2 is because, we can run
85 // Relay from client to server on UDP/TCP/TLS. To distinguish the transport
86 // protocol, we prefer UDP over TCP over TLS.
87 // For UDP ICE_TYPE_PREFERENCE_RELAY will be 2.
88 // For TCP ICE_TYPE_PREFERENCE_RELAY will be 1.
89 // For TLS ICE_TYPE_PREFERENCE_RELAY will be 0.
90 // Check turnport.cc for setting these values.
91 ICE_TYPE_PREFERENCE_RELAY = 2,
92 ICE_TYPE_PREFERENCE_HOST_TCP = 90,
93 ICE_TYPE_PREFERENCE_SRFLX = 100,
94 ICE_TYPE_PREFERENCE_PRFLX = 110,
95 ICE_TYPE_PREFERENCE_HOST = 126
96};
97
98const char* ProtoToString(ProtocolType proto);
99bool StringToProto(const char* value, ProtocolType* proto);
100
101struct ProtocolAddress {
102 rtc::SocketAddress address;
103 ProtocolType proto;
104 bool secure;
105
106 ProtocolAddress(const rtc::SocketAddress& a, ProtocolType p)
107 : address(a), proto(p), secure(false) { }
108 ProtocolAddress(const rtc::SocketAddress& a, ProtocolType p, bool sec)
109 : address(a), proto(p), secure(sec) { }
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700110
111 bool operator==(const ProtocolAddress& o) const {
112 return address == o.address && proto == o.proto && secure == o.secure;
113 }
114 bool operator!=(const ProtocolAddress& o) const { return !(*this == o); }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000115};
116
117typedef std::set<rtc::SocketAddress> ServerAddresses;
118
119// Represents a local communication mechanism that can be used to create
120// connections to similar mechanisms of the other client. Subclasses of this
121// one add support for specific mechanisms like local UDP ports.
122class Port : public PortInterface, public rtc::MessageHandler,
123 public sigslot::has_slots<> {
124 public:
pkasting@chromium.org332331f2014-11-06 20:19:22 +0000125 Port(rtc::Thread* thread,
Honghai Zhangd00c0572016-06-28 09:44:47 -0700126 const std::string& type,
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000127 rtc::PacketSocketFactory* factory,
pkasting@chromium.org332331f2014-11-06 20:19:22 +0000128 rtc::Network* network,
129 const rtc::IPAddress& ip,
130 const std::string& username_fragment,
131 const std::string& password);
132 Port(rtc::Thread* thread,
133 const std::string& type,
134 rtc::PacketSocketFactory* factory,
135 rtc::Network* network,
136 const rtc::IPAddress& ip,
Peter Boström0c4e06b2015-10-07 12:23:21 +0200137 uint16_t min_port,
138 uint16_t max_port,
pkasting@chromium.org332331f2014-11-06 20:19:22 +0000139 const std::string& username_fragment,
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000140 const std::string& password);
141 virtual ~Port();
142
143 virtual const std::string& Type() const { return type_; }
144 virtual rtc::Network* Network() const { return network_; }
145
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000146 // Methods to set/get ICE role and tiebreaker values.
147 IceRole GetIceRole() const { return ice_role_; }
148 void SetIceRole(IceRole role) { ice_role_ = role; }
149
Peter Boström0c4e06b2015-10-07 12:23:21 +0200150 void SetIceTiebreaker(uint64_t tiebreaker) { tiebreaker_ = tiebreaker; }
151 uint64_t IceTiebreaker() const { return tiebreaker_; }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000152
153 virtual bool SharedSocket() const { return shared_socket_; }
154 void ResetSharedSocket() { shared_socket_ = false; }
155
156 // The thread on which this port performs its I/O.
157 rtc::Thread* thread() { return thread_; }
158
159 // The factory used to create the sockets of this port.
160 rtc::PacketSocketFactory* socket_factory() const { return factory_; }
161 void set_socket_factory(rtc::PacketSocketFactory* factory) {
162 factory_ = factory;
163 }
164
165 // For debugging purposes.
166 const std::string& content_name() const { return content_name_; }
167 void set_content_name(const std::string& content_name) {
168 content_name_ = content_name;
169 }
170
171 int component() const { return component_; }
172 void set_component(int component) { component_ = component; }
173
174 bool send_retransmit_count_attribute() const {
175 return send_retransmit_count_attribute_;
176 }
177 void set_send_retransmit_count_attribute(bool enable) {
178 send_retransmit_count_attribute_ = enable;
179 }
180
181 // Identifies the generation that this port was created in.
deadbeef14f97f52016-06-22 17:14:15 -0700182 uint32_t generation() const { return generation_; }
Peter Boström0c4e06b2015-10-07 12:23:21 +0200183 void set_generation(uint32_t generation) { generation_ = generation; }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000184
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000185 const std::string username_fragment() const;
186 const std::string& password() const { return password_; }
187
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700188 // May be called when this port was initially created by a pooled
189 // PortAllocatorSession, and is now being assigned to an ICE transport.
190 // Updates the information for candidates as well.
191 void SetIceParameters(int component,
192 const std::string& username_fragment,
193 const std::string& password);
194
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000195 // Fired when candidates are discovered by the port. When all candidates
196 // are discovered that belong to port SignalAddressReady is fired.
197 sigslot::signal2<Port*, const Candidate&> SignalCandidateReady;
198
199 // Provides all of the above information in one handy object.
200 virtual const std::vector<Candidate>& Candidates() const {
201 return candidates_;
202 }
203
204 // SignalPortComplete is sent when port completes the task of candidates
205 // allocation.
206 sigslot::signal1<Port*> SignalPortComplete;
207 // This signal sent when port fails to allocate candidates and this port
208 // can't be used in establishing the connections. When port is in shared mode
209 // and port fails to allocate one of the candidates, port shouldn't send
210 // this signal as other candidates might be usefull in establishing the
211 // connection.
212 sigslot::signal1<Port*> SignalPortError;
213
214 // Returns a map containing all of the connections of this port, keyed by the
215 // remote address.
216 typedef std::map<rtc::SocketAddress, Connection*> AddressMap;
217 const AddressMap& connections() { return connections_; }
218
219 // Returns the connection to the given address or NULL if none exists.
220 virtual Connection* GetConnection(
221 const rtc::SocketAddress& remote_addr);
222
223 // Called each time a connection is created.
224 sigslot::signal2<Port*, Connection*> SignalConnectionCreated;
225
226 // In a shared socket mode each port which shares the socket will decide
227 // to accept the packet based on the |remote_addr|. Currently only UDP
228 // port implemented this method.
229 // TODO(mallinath) - Make it pure virtual.
230 virtual bool HandleIncomingPacket(
231 rtc::AsyncPacketSocket* socket, const char* data, size_t size,
232 const rtc::SocketAddress& remote_addr,
233 const rtc::PacketTime& packet_time) {
234 ASSERT(false);
235 return false;
236 }
237
238 // Sends a response message (normal or error) to the given request. One of
239 // these methods should be called as a response to SignalUnknownAddress.
240 // NOTE: You MUST call CreateConnection BEFORE SendBindingResponse.
241 virtual void SendBindingResponse(StunMessage* request,
242 const rtc::SocketAddress& addr);
243 virtual void SendBindingErrorResponse(
244 StunMessage* request, const rtc::SocketAddress& addr,
245 int error_code, const std::string& reason);
246
247 void set_proxy(const std::string& user_agent,
248 const rtc::ProxyInfo& proxy) {
249 user_agent_ = user_agent;
250 proxy_ = proxy;
251 }
252 const std::string& user_agent() { return user_agent_; }
253 const rtc::ProxyInfo& proxy() { return proxy_; }
254
255 virtual void EnablePortPackets();
256
257 // Called if the port has no connections and is no longer useful.
258 void Destroy();
259
260 virtual void OnMessage(rtc::Message *pmsg);
261
262 // Debugging description of this port
263 virtual std::string ToString() const;
pthatcher@webrtc.org0ba15332015-01-10 00:47:02 +0000264 const rtc::IPAddress& ip() const { return ip_; }
Peter Boström0c4e06b2015-10-07 12:23:21 +0200265 uint16_t min_port() { return min_port_; }
266 uint16_t max_port() { return max_port_; }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000267
268 // Timeout shortening function to speed up unit tests.
269 void set_timeout_delay(int delay) { timeout_delay_ = delay; }
270
271 // This method will return local and remote username fragements from the
272 // stun username attribute if present.
273 bool ParseStunUsername(const StunMessage* stun_msg,
274 std::string* local_username,
Peter Thatcher7cbd1882015-09-17 18:54:52 -0700275 std::string* remote_username) const;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000276 void CreateStunUsername(const std::string& remote_username,
277 std::string* stun_username_attr_str) const;
278
279 bool MaybeIceRoleConflict(const rtc::SocketAddress& addr,
280 IceMessage* stun_msg,
281 const std::string& remote_ufrag);
282
stefanc1aeaf02015-10-15 07:26:07 -0700283 // Called when a packet has been sent to the socket.
Stefan Holmer55674ff2016-01-14 15:49:16 +0100284 // This is made pure virtual to notify subclasses of Port that they MUST
285 // listen to AsyncPacketSocket::SignalSentPacket and then call
286 // PortInterface::OnSentPacket.
287 virtual void OnSentPacket(rtc::AsyncPacketSocket* socket,
288 const rtc::SentPacket& sent_packet) = 0;
stefanc1aeaf02015-10-15 07:26:07 -0700289
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000290 // Called when the socket is currently able to send.
291 void OnReadyToSend();
292
293 // Called when the Connection discovers a local peer reflexive candidate.
294 // Returns the index of the new local candidate.
295 size_t AddPrflxCandidate(const Candidate& local);
296
honghaiza0c44ea2016-03-23 16:07:48 -0700297 int16_t network_cost() const { return network_cost_; }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000298
299 protected:
300 enum {
honghaizd0b31432015-09-30 12:42:17 -0700301 MSG_DEAD = 0,
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000302 MSG_FIRST_AVAILABLE
303 };
304
Honghai Zhang351d77b2016-05-20 15:08:29 -0700305 virtual void UpdateNetworkCost();
306
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000307 void set_type(const std::string& type) { type_ = type; }
308
309 void AddAddress(const rtc::SocketAddress& address,
310 const rtc::SocketAddress& base_address,
311 const rtc::SocketAddress& related_address,
Guo-wei Shieh3d564c12015-08-19 16:51:15 -0700312 const std::string& protocol,
313 const std::string& relay_protocol,
314 const std::string& tcptype,
315 const std::string& type,
Peter Boström0c4e06b2015-10-07 12:23:21 +0200316 uint32_t type_preference,
317 uint32_t relay_preference,
Guo-wei Shieh3d564c12015-08-19 16:51:15 -0700318 bool final);
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000319
honghaiz36f50e82016-06-01 15:57:03 -0700320 // Adds the given connection to the map keyed by the remote candidate address.
321 // If an existing connection has the same address, the existing one will be
322 // replaced and destroyed.
323 void AddOrReplaceConnection(Connection* conn);
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000324
325 // Called when a packet is received from an unknown address that is not
326 // currently a connection. If this is an authenticated STUN binding request,
327 // then we will signal the client.
328 void OnReadPacket(const char* data, size_t size,
329 const rtc::SocketAddress& addr,
330 ProtocolType proto);
331
332 // If the given data comprises a complete and correct STUN message then the
333 // return value is true, otherwise false. If the message username corresponds
334 // with this port's username fragment, msg will contain the parsed STUN
335 // message. Otherwise, the function may send a STUN response internally.
336 // remote_username contains the remote fragment of the STUN username.
kwiberg6baec032016-03-15 11:09:39 -0700337 bool GetStunMessage(const char* data,
338 size_t size,
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000339 const rtc::SocketAddress& addr,
kwiberg3ec46792016-04-27 07:22:53 -0700340 std::unique_ptr<IceMessage>* out_msg,
kwiberg6baec032016-03-15 11:09:39 -0700341 std::string* out_username);
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000342
343 // Checks if the address in addr is compatible with the port's ip.
344 bool IsCompatibleAddress(const rtc::SocketAddress& addr);
345
346 // Returns default DSCP value.
347 rtc::DiffServCodePoint DefaultDscpValue() const {
348 // No change from what MediaChannel set.
349 return rtc::DSCP_NO_CHANGE;
350 }
351
honghaiz36f50e82016-06-01 15:57:03 -0700352 // Extra work to be done in subclasses when a connection is destroyed.
353 virtual void HandleConnectionDestroyed(Connection* conn) {}
354
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000355 private:
356 void Construct();
357 // Called when one of our connections deletes itself.
358 void OnConnectionDestroyed(Connection* conn);
359
honghaizd0b31432015-09-30 12:42:17 -0700360 // Whether this port is dead, and hence, should be destroyed on the controlled
361 // side.
362 bool dead() const {
363 return ice_role_ == ICEROLE_CONTROLLED && connections_.empty();
364 }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000365
honghaize3c6c822016-02-17 13:00:28 -0800366 void OnNetworkInactive(const rtc::Network* network);
367
Honghai Zhang351d77b2016-05-20 15:08:29 -0700368 void OnNetworkTypeChanged(const rtc::Network* network);
369
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000370 rtc::Thread* thread_;
371 rtc::PacketSocketFactory* factory_;
372 std::string type_;
373 bool send_retransmit_count_attribute_;
374 rtc::Network* network_;
375 rtc::IPAddress ip_;
Peter Boström0c4e06b2015-10-07 12:23:21 +0200376 uint16_t min_port_;
377 uint16_t max_port_;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000378 std::string content_name_;
379 int component_;
Peter Boström0c4e06b2015-10-07 12:23:21 +0200380 uint32_t generation_;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000381 // In order to establish a connection to this Port (so that real data can be
382 // sent through), the other side must send us a STUN binding request that is
383 // authenticated with this username_fragment and password.
384 // PortAllocatorSession will provide these username_fragment and password.
385 //
386 // Note: we should always use username_fragment() instead of using
387 // |ice_username_fragment_| directly. For the details see the comment on
388 // username_fragment().
389 std::string ice_username_fragment_;
390 std::string password_;
391 std::vector<Candidate> candidates_;
392 AddressMap connections_;
393 int timeout_delay_;
394 bool enable_port_packets_;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000395 IceRole ice_role_;
Peter Boström0c4e06b2015-10-07 12:23:21 +0200396 uint64_t tiebreaker_;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000397 bool shared_socket_;
398 // Information to use when going through a proxy.
399 std::string user_agent_;
400 rtc::ProxyInfo proxy_;
401
honghaize1a0c942016-02-16 14:54:56 -0800402 // A virtual cost perceived by the user, usually based on the network type
403 // (WiFi. vs. Cellular). It takes precedence over the priority when
404 // comparing two connections.
honghaiza0c44ea2016-03-23 16:07:48 -0700405 uint16_t network_cost_;
honghaize1a0c942016-02-16 14:54:56 -0800406
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000407 friend class Connection;
408};
409
410// Represents a communication link between a port on the local client and a
411// port on the remote client.
Honghai Zhangcc411c02016-03-29 17:27:21 -0700412class Connection : public CandidatePairInterface,
413 public rtc::MessageHandler,
414 public sigslot::has_slots<> {
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000415 public:
Peter Thatcher1cf6f812015-05-15 10:40:45 -0700416 struct SentPing {
honghaiz34b11eb2016-03-16 08:55:44 -0700417 SentPing(const std::string id, int64_t sent_time)
Peter Boström0c4e06b2015-10-07 12:23:21 +0200418 : id(id), sent_time(sent_time) {}
Peter Thatcher1cf6f812015-05-15 10:40:45 -0700419
420 std::string id;
honghaiz34b11eb2016-03-16 08:55:44 -0700421 int64_t sent_time;
Peter Thatcher1cf6f812015-05-15 10:40:45 -0700422 };
423
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000424 // States are from RFC 5245. http://tools.ietf.org/html/rfc5245#section-5.7.4
425 enum State {
426 STATE_WAITING = 0, // Check has not been performed, Waiting pair on CL.
427 STATE_INPROGRESS, // Check has been sent, transaction is in progress.
428 STATE_SUCCEEDED, // Check already done, produced a successful result.
429 STATE_FAILED // Check for this connection failed.
430 };
431
432 virtual ~Connection();
433
434 // The local port where this connection sends and receives packets.
435 Port* port() { return port_; }
436 const Port* port() const { return port_; }
437
Honghai Zhangcc411c02016-03-29 17:27:21 -0700438 // Implementation of virtual methods in CandidatePairInterface.
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000439 // Returns the description of the local port
440 virtual const Candidate& local_candidate() const;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000441 // Returns the description of the remote port to which we communicate.
Honghai Zhangcc411c02016-03-29 17:27:21 -0700442 virtual const Candidate& remote_candidate() const;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000443
444 // Returns the pair priority.
Peter Boström0c4e06b2015-10-07 12:23:21 +0200445 uint64_t priority() const;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000446
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000447 enum WriteState {
448 STATE_WRITABLE = 0, // we have received ping responses recently
449 STATE_WRITE_UNRELIABLE = 1, // we have had a few ping failures
450 STATE_WRITE_INIT = 2, // we have yet to receive a ping response
451 STATE_WRITE_TIMEOUT = 3, // we have had a large number of ping failures
452 };
453
454 WriteState write_state() const { return write_state_; }
455 bool writable() const { return write_state_ == STATE_WRITABLE; }
Peter Thatcher04ac81f2015-09-21 11:48:28 -0700456 bool receiving() const { return receiving_; }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000457
458 // Determines whether the connection has finished connecting. This can only
459 // be false for TCP connections.
460 bool connected() const { return connected_; }
Honghai Zhang2b342bf2015-09-30 09:51:58 -0700461 bool weak() const { return !(writable() && receiving() && connected()); }
462 bool active() const {
Honghai Zhang2b342bf2015-09-30 09:51:58 -0700463 return write_state_ != STATE_WRITE_TIMEOUT;
464 }
honghaiz059e1832016-06-24 11:03:55 -0700465
Honghai Zhang2b342bf2015-09-30 09:51:58 -0700466 // A connection is dead if it can be safely deleted.
honghaiz34b11eb2016-03-16 08:55:44 -0700467 bool dead(int64_t now) const;
honghaiz89374372015-09-24 13:14:47 -0700468
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000469 // Estimate of the round-trip time over this connection.
honghaiz34b11eb2016-03-16 08:55:44 -0700470 int rtt() const { return rtt_; }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000471
zhihuang5ecf16c2016-06-01 17:09:15 -0700472 ConnectionInfo stats();
473
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000474 sigslot::signal1<Connection*> SignalStateChange;
475
476 // Sent when the connection has decided that it is no longer of value. It
477 // will delete itself immediately after this call.
478 sigslot::signal1<Connection*> SignalDestroyed;
479
480 // The connection can send and receive packets asynchronously. This matches
481 // the interface of AsyncPacketSocket, which may use UDP or TCP under the
482 // covers.
483 virtual int Send(const void* data, size_t size,
484 const rtc::PacketOptions& options) = 0;
485
486 // Error if Send() returns < 0
487 virtual int GetError() = 0;
488
Peter Thatcher04ac81f2015-09-21 11:48:28 -0700489 sigslot::signal4<Connection*, const char*, size_t, const rtc::PacketTime&>
490 SignalReadPacket;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000491
492 sigslot::signal1<Connection*> SignalReadyToSend;
493
494 // Called when a packet is received on this connection.
495 void OnReadPacket(const char* data, size_t size,
496 const rtc::PacketTime& packet_time);
497
498 // Called when the socket is currently able to send.
499 void OnReadyToSend();
500
501 // Called when a connection is determined to be no longer useful to us. We
502 // still keep it around in case the other side wants to use it. But we can
503 // safely stop pinging on it and we can allow it to time out if the other
504 // side stops using it as well.
505 bool pruned() const { return pruned_; }
506 void Prune();
507
508 bool use_candidate_attr() const { return use_candidate_attr_; }
509 void set_use_candidate_attr(bool enable);
510
honghaiz5a3acd82015-08-20 15:53:17 -0700511 bool nominated() const { return nominated_; }
512 void set_nominated(bool nominated) { nominated_ = nominated; }
513
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000514 void set_remote_ice_mode(IceMode mode) {
515 remote_ice_mode_ = mode;
516 }
517
honghaiz34b11eb2016-03-16 08:55:44 -0700518 void set_receiving_timeout(int64_t receiving_timeout_ms) {
Peter Thatcher04ac81f2015-09-21 11:48:28 -0700519 receiving_timeout_ = receiving_timeout_ms;
520 }
521
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000522 // Makes the connection go away.
523 void Destroy();
524
deadbeef376e1232015-11-25 09:00:08 -0800525 // Makes the connection go away, in a failed state.
526 void FailAndDestroy();
527
honghaiz079a7a12016-06-22 16:26:29 -0700528 // Prunes the connection and sets its state to STATE_FAILED,
529 // It will not be used or send pings although it can still receive packets.
530 void FailAndPrune();
531
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000532 // Checks that the state of this connection is up-to-date. The argument is
533 // the current time, which is compared against various timeouts.
honghaiz34b11eb2016-03-16 08:55:44 -0700534 void UpdateState(int64_t now);
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000535
536 // Called when this connection should try checking writability again.
honghaiz34b11eb2016-03-16 08:55:44 -0700537 int64_t last_ping_sent() const { return last_ping_sent_; }
538 void Ping(int64_t now);
zhihuang435264a2016-06-21 11:28:38 -0700539 void ReceivedPingResponse(int rtt);
honghaiz34b11eb2016-03-16 08:55:44 -0700540 int64_t last_ping_response_received() const {
Honghai Zhang381b4212015-12-04 12:24:03 -0800541 return last_ping_response_received_;
542 }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000543
544 // Called whenever a valid ping is received on this connection. This is
545 // public because the connection intercepts the first ping for us.
honghaiz34b11eb2016-03-16 08:55:44 -0700546 int64_t last_ping_received() const { return last_ping_received_; }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000547 void ReceivedPing();
honghaiz9b5ee9c2015-11-11 13:19:17 -0800548 // Handles the binding request; sends a response if this is a valid request.
549 void HandleBindingRequest(IceMessage* msg);
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000550
Honghai Zhang572b0942016-06-23 12:26:57 -0700551 int64_t last_data_received() const { return last_data_received_; }
552
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000553 // Debugging description of this connection
guoweis@webrtc.org8c9ff202014-12-04 07:56:02 +0000554 std::string ToDebugId() const;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000555 std::string ToString() const;
556 std::string ToSensitiveString() const;
Peter Thatcher1cf6f812015-05-15 10:40:45 -0700557 // Prints pings_since_last_response_ into a string.
558 void PrintPingsSinceLastResponse(std::string* pings, size_t max);
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000559
560 bool reported() const { return reported_; }
561 void set_reported(bool reported) { reported_ = reported;}
562
honghaiz5a3acd82015-08-20 15:53:17 -0700563 // This signal will be fired if this connection is nominated by the
564 // controlling side.
565 sigslot::signal1<Connection*> SignalNominated;
Peter Thatcher54360512015-07-08 11:08:35 -0700566
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000567 // Invoked when Connection receives STUN error response with 487 code.
568 void HandleRoleConflictFromPeer();
569
570 State state() const { return state_; }
571
honghaiz524ecc22016-05-25 12:48:31 -0700572 int num_pings_sent() const { return num_pings_sent_; }
573
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000574 IceMode remote_ice_mode() const { return remote_ice_mode_; }
575
honghaize1a0c942016-02-16 14:54:56 -0800576 uint32_t ComputeNetworkCost() const;
577
Taylor Brandstetter0a1bc532016-04-19 18:03:26 -0700578 // Update the ICE password and/or generation of the remote candidate if a
579 // ufrag in |remote_ice_parameters| matches the candidate's ufrag, and the
580 // candidate's password and/or ufrag has not been set.
581 // |remote_ice_parameters| should be a list of known ICE parameters ordered
582 // by generation.
583 void MaybeSetRemoteIceCredentialsAndGeneration(const std::string& ice_ufrag,
584 const std::string& ice_pwd,
585 int generation);
jiayl@webrtc.orgdacdd942015-01-23 17:33:34 +0000586
587 // If |remote_candidate_| is peer reflexive and is equivalent to
588 // |new_candidate| except the type, update |remote_candidate_| to
589 // |new_candidate|.
590 void MaybeUpdatePeerReflexiveCandidate(const Candidate& new_candidate);
591
Peter Thatcher54360512015-07-08 11:08:35 -0700592 // Returns the last received time of any data, stun request, or stun
593 // response in milliseconds
honghaiz34b11eb2016-03-16 08:55:44 -0700594 int64_t last_received() const;
Peter Thatcher54360512015-07-08 11:08:35 -0700595
Taylor Brandstetterb825aee2016-06-29 13:07:16 -0700596 bool stable(int64_t now) const;
zhihuang435264a2016-06-21 11:28:38 -0700597
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000598 protected:
Guo-wei Shiehbe508a12015-04-06 12:48:47 -0700599 enum { MSG_DELETE = 0, MSG_FIRST_AVAILABLE };
600
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000601 // Constructs a new connection to the given remote port.
602 Connection(Port* port, size_t index, const Candidate& candidate);
603
604 // Called back when StunRequestManager has a stun packet to send
605 void OnSendStunPacket(const void* data, size_t size, StunRequest* req);
606
607 // Callbacks from ConnectionRequest
Guo-wei Shiehbe508a12015-04-06 12:48:47 -0700608 virtual void OnConnectionRequestResponse(ConnectionRequest* req,
609 StunMessage* response);
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000610 void OnConnectionRequestErrorResponse(ConnectionRequest* req,
611 StunMessage* response);
612 void OnConnectionRequestTimeout(ConnectionRequest* req);
Peter Thatcher1cf6f812015-05-15 10:40:45 -0700613 void OnConnectionRequestSent(ConnectionRequest* req);
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000614
Taylor Brandstetterb825aee2016-06-29 13:07:16 -0700615 bool rtt_converged() const;
zhihuang435264a2016-06-21 11:28:38 -0700616
617 // If the response is not received within 2 * RTT, the response is assumed to
618 // be missing.
Taylor Brandstetterb825aee2016-06-29 13:07:16 -0700619 bool missing_responses(int64_t now) const;
zhihuang435264a2016-06-21 11:28:38 -0700620
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000621 // Changes the state and signals if necessary.
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000622 void set_write_state(WriteState value);
Peter Thatcher04ac81f2015-09-21 11:48:28 -0700623 void set_receiving(bool value);
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000624 void set_state(State state);
625 void set_connected(bool value);
626
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000627 void OnMessage(rtc::Message *pmsg);
628
629 Port* port_;
630 size_t local_candidate_index_;
631 Candidate remote_candidate_;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000632 WriteState write_state_;
Peter Thatcher04ac81f2015-09-21 11:48:28 -0700633 bool receiving_;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000634 bool connected_;
635 bool pruned_;
636 // By default |use_candidate_attr_| flag will be true,
honghaiz5a3acd82015-08-20 15:53:17 -0700637 // as we will be using aggressive nomination.
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000638 // But when peer is ice-lite, this flag "must" be initialized to false and
639 // turn on when connection becomes "best connection".
640 bool use_candidate_attr_;
honghaiz5a3acd82015-08-20 15:53:17 -0700641 // Whether this connection has been nominated by the controlling side via
642 // the use_candidate attribute.
643 bool nominated_;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000644 IceMode remote_ice_mode_;
645 StunRequestManager requests_;
honghaiz34b11eb2016-03-16 08:55:44 -0700646 int rtt_;
zhihuang435264a2016-06-21 11:28:38 -0700647 int rtt_samples_ = 0;
honghaiz34b11eb2016-03-16 08:55:44 -0700648 int64_t last_ping_sent_; // last time we sent a ping to the other side
649 int64_t last_ping_received_; // last time we received a ping from the other
650 // side
651 int64_t last_data_received_;
652 int64_t last_ping_response_received_;
Peter Thatcher1cf6f812015-05-15 10:40:45 -0700653 std::vector<SentPing> pings_since_last_response_;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000654
655 rtc::RateTracker recv_rate_tracker_;
656 rtc::RateTracker send_rate_tracker_;
zhihuang5ecf16c2016-06-01 17:09:15 -0700657
658 ConnectionInfo stats_;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000659
660 private:
661 void MaybeAddPrflxCandidate(ConnectionRequest* request,
662 StunMessage* response);
663
664 bool reported_;
665 State state_;
Peter Thatcher04ac81f2015-09-21 11:48:28 -0700666 // Time duration to switch from receiving to not receiving.
honghaiz34b11eb2016-03-16 08:55:44 -0700667 int receiving_timeout_;
668 int64_t time_created_ms_;
honghaiz524ecc22016-05-25 12:48:31 -0700669 int num_pings_sent_ = 0;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000670
671 friend class Port;
672 friend class ConnectionRequest;
673};
674
deadbeef376e1232015-11-25 09:00:08 -0800675// ProxyConnection defers all the interesting work to the port.
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000676class ProxyConnection : public Connection {
677 public:
deadbeef376e1232015-11-25 09:00:08 -0800678 ProxyConnection(Port* port, size_t index, const Candidate& remote_candidate);
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000679
deadbeef376e1232015-11-25 09:00:08 -0800680 int Send(const void* data,
681 size_t size,
682 const rtc::PacketOptions& options) override;
683 int GetError() override { return error_; }
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000684
685 private:
deadbeef376e1232015-11-25 09:00:08 -0800686 int error_ = 0;
henrike@webrtc.org269fb4b2014-10-28 22:20:11 +0000687};
688
689} // namespace cricket
690
691#endif // WEBRTC_P2P_BASE_PORT_H_