1269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org/* 2269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org * Copyright 2004 The WebRTC Project Authors. All rights reserved. 3269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org * 4269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org * Use of this source code is governed by a BSD-style license 5269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org * that can be found in the LICENSE file in the root of the source 6269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org * tree. An additional intellectual property rights grant can be found 7269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org * in the file PATENTS. All contributing project authors may 8269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org * be found in the AUTHORS file in the root of the source tree. 9269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org */ 10269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 11269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#ifndef WEBRTC_P2P_BASE_PORT_H_ 12269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#define WEBRTC_P2P_BASE_PORT_H_ 13269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 14269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include <map> 15269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include <set> 16269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include <string> 17269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include <vector> 18269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 19269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/p2p/base/candidate.h" 20269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/p2p/base/packetsocketfactory.h" 21269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/p2p/base/portinterface.h" 22269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/p2p/base/stun.h" 23269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/p2p/base/stunrequest.h" 24269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/p2p/base/transport.h" 25269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/base/asyncpacketsocket.h" 26269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/base/network.h" 27269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/base/proxyinfo.h" 28269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/base/ratetracker.h" 29269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/base/sigslot.h" 30269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/base/socketaddress.h" 31269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#include "webrtc/base/thread.h" 32269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 33269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgnamespace cricket { 34269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 35269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgclass Connection; 36269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgclass ConnectionRequest; 37269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 38269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const char LOCAL_PORT_TYPE[]; 39269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const char STUN_PORT_TYPE[]; 40269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const char PRFLX_PORT_TYPE[]; 41269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const char RELAY_PORT_TYPE[]; 42269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 43269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const char UDP_PROTOCOL_NAME[]; 44269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const char TCP_PROTOCOL_NAME[]; 45269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const char SSLTCP_PROTOCOL_NAME[]; 46269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 47269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org// RFC 6544, TCP candidate encoding rules. 48269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const int DISCARD_PORT; 49269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const char TCPTYPE_ACTIVE_STR[]; 50269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const char TCPTYPE_PASSIVE_STR[]; 51269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgextern const char TCPTYPE_SIMOPEN_STR[]; 52269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 532b342bf99c9578247940929c02a41ef9ccec6d6eHonghai Zhang// The minimum time we will wait before destroying a connection after creating 542b342bf99c9578247940929c02a41ef9ccec6d6eHonghai Zhang// it. 550c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boströmconst uint32_t MIN_CONNECTION_LIFETIME = 10 * 1000; // 10 seconds. 5604ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher 572cd7afe7e2dc011ab00bdbc131039b16aa8fbdebHonghai Zhang// A connection will be declared dead if it has not received anything for this 582cd7afe7e2dc011ab00bdbc131039b16aa8fbdebHonghai Zhang// long. 592cd7afe7e2dc011ab00bdbc131039b16aa8fbdebHonghai Zhangconst uint32_t DEAD_CONNECTION_RECEIVE_TIMEOUT = 30 * 1000; // 30 seconds. 602cd7afe7e2dc011ab00bdbc131039b16aa8fbdebHonghai Zhang 6104ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher// The timeout duration when a connection does not receive anything. 620c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boströmconst uint32_t WEAK_CONNECTION_RECEIVE_TIMEOUT = 2500; // 2.5 seconds 63269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 64269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org// The length of time we wait before timing out writability on a connection. 650c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boströmconst uint32_t CONNECTION_WRITE_TIMEOUT = 15 * 1000; // 15 seconds 66269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 67269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org// The length of time we wait before we become unwritable. 680c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boströmconst uint32_t CONNECTION_WRITE_CONNECT_TIMEOUT = 5 * 1000; // 5 seconds 69269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 70269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org// The number of pings that must fail to respond before we become unwritable. 710c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boströmconst uint32_t CONNECTION_WRITE_CONNECT_FAILURES = 5; 72269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 73269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org// This is the length of time that we wait for a ping response to come back. 74269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgconst int CONNECTION_RESPONSE_TIMEOUT = 5 * 1000; // 5 seconds 75269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 76269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgenum RelayType { 77269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org RELAY_GTURN, // Legacy google relay service. 78269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org RELAY_TURN // Standard (TURN) relay service. 79269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org}; 80269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 81269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgenum IcePriorityValue { 82269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // The reason we are choosing Relay preference 2 is because, we can run 83269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Relay from client to server on UDP/TCP/TLS. To distinguish the transport 84269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // protocol, we prefer UDP over TCP over TLS. 85269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // For UDP ICE_TYPE_PREFERENCE_RELAY will be 2. 86269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // For TCP ICE_TYPE_PREFERENCE_RELAY will be 1. 87269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // For TLS ICE_TYPE_PREFERENCE_RELAY will be 0. 88269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Check turnport.cc for setting these values. 89269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org ICE_TYPE_PREFERENCE_RELAY = 2, 90269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org ICE_TYPE_PREFERENCE_HOST_TCP = 90, 91269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org ICE_TYPE_PREFERENCE_SRFLX = 100, 92269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org ICE_TYPE_PREFERENCE_PRFLX = 110, 93269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org ICE_TYPE_PREFERENCE_HOST = 126 94269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org}; 95269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 96269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgconst char* ProtoToString(ProtocolType proto); 97269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgbool StringToProto(const char* value, ProtocolType* proto); 98269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 99269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgstruct ProtocolAddress { 100269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::SocketAddress address; 101269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org ProtocolType proto; 102269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool secure; 103269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 104269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org ProtocolAddress(const rtc::SocketAddress& a, ProtocolType p) 105269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org : address(a), proto(p), secure(false) { } 106269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org ProtocolAddress(const rtc::SocketAddress& a, ProtocolType p, bool sec) 107269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org : address(a), proto(p), secure(sec) { } 108269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org}; 109269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 110269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgtypedef std::set<rtc::SocketAddress> ServerAddresses; 111269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 112269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org// Represents a local communication mechanism that can be used to create 113269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org// connections to similar mechanisms of the other client. Subclasses of this 114269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org// one add support for specific mechanisms like local UDP ports. 115269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgclass Port : public PortInterface, public rtc::MessageHandler, 116269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org public sigslot::has_slots<> { 117269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org public: 118332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org Port(rtc::Thread* thread, 119269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::PacketSocketFactory* factory, 120332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org rtc::Network* network, 121332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org const rtc::IPAddress& ip, 122332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org const std::string& username_fragment, 123332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org const std::string& password); 124332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org Port(rtc::Thread* thread, 125332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org const std::string& type, 126332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org rtc::PacketSocketFactory* factory, 127332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org rtc::Network* network, 128332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org const rtc::IPAddress& ip, 1290c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint16_t min_port, 1300c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint16_t max_port, 131332331fb01f8a316ac6d61cf4572478610fb3472pkasting@chromium.org const std::string& username_fragment, 132269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const std::string& password); 133269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual ~Port(); 134269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 135269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual const std::string& Type() const { return type_; } 136269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual rtc::Network* Network() const { return network_; } 137269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 138269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Methods to set/get ICE role and tiebreaker values. 139269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org IceRole GetIceRole() const { return ice_role_; } 140269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void SetIceRole(IceRole role) { ice_role_ = role; } 141269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 1420c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström void SetIceTiebreaker(uint64_t tiebreaker) { tiebreaker_ = tiebreaker; } 1430c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint64_t IceTiebreaker() const { return tiebreaker_; } 144269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 145269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual bool SharedSocket() const { return shared_socket_; } 146269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void ResetSharedSocket() { shared_socket_ = false; } 147269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 148269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // The thread on which this port performs its I/O. 149269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::Thread* thread() { return thread_; } 150269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 151269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // The factory used to create the sockets of this port. 152269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::PacketSocketFactory* socket_factory() const { return factory_; } 153269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_socket_factory(rtc::PacketSocketFactory* factory) { 154269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org factory_ = factory; 155269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org } 156269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 157269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // For debugging purposes. 158269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const std::string& content_name() const { return content_name_; } 159269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_content_name(const std::string& content_name) { 160269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org content_name_ = content_name; 161269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org } 162269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 163269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org int component() const { return component_; } 164269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_component(int component) { component_ = component; } 165269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 166269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool send_retransmit_count_attribute() const { 167269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org return send_retransmit_count_attribute_; 168269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org } 169269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_send_retransmit_count_attribute(bool enable) { 170269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org send_retransmit_count_attribute_ = enable; 171269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org } 172269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 173269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Identifies the generation that this port was created in. 1740c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t generation() { return generation_; } 1750c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström void set_generation(uint32_t generation) { generation_ = generation; } 176269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 177269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // ICE requires a single username/password per content/media line. So the 178269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // |ice_username_fragment_| of the ports that belongs to the same content will 179269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // be the same. However this causes a small complication with our relay 180269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // server, which expects different username for RTP and RTCP. 181269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // 182269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // To resolve this problem, we implemented the username_fragment(), 183269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // which returns a different username (calculated from 184269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // |ice_username_fragment_|) for RTCP in the case of ICEPROTO_GOOGLE. And the 185269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // username_fragment() simply returns |ice_username_fragment_| when running 186269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // in ICEPROTO_RFC5245. 187269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // 188269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // As a result the ICEPROTO_GOOGLE will use different usernames for RTP and 189269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // RTCP. And the ICEPROTO_RFC5245 will use same username for both RTP and 190269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // RTCP. 191269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const std::string username_fragment() const; 192269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const std::string& password() const { return password_; } 193269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 194269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Fired when candidates are discovered by the port. When all candidates 195269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // are discovered that belong to port SignalAddressReady is fired. 196269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org sigslot::signal2<Port*, const Candidate&> SignalCandidateReady; 197269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 198269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Provides all of the above information in one handy object. 199269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual const std::vector<Candidate>& Candidates() const { 200269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org return candidates_; 201269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org } 202269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 203269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // SignalPortComplete is sent when port completes the task of candidates 204269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // allocation. 205269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org sigslot::signal1<Port*> SignalPortComplete; 206269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // This signal sent when port fails to allocate candidates and this port 207269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // can't be used in establishing the connections. When port is in shared mode 208269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // and port fails to allocate one of the candidates, port shouldn't send 209269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // this signal as other candidates might be usefull in establishing the 210269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // connection. 211269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org sigslot::signal1<Port*> SignalPortError; 212269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 213269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Returns a map containing all of the connections of this port, keyed by the 214269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // remote address. 215269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org typedef std::map<rtc::SocketAddress, Connection*> AddressMap; 216269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const AddressMap& connections() { return connections_; } 217269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 218269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Returns the connection to the given address or NULL if none exists. 219269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual Connection* GetConnection( 220269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::SocketAddress& remote_addr); 221269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 222269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called each time a connection is created. 223269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org sigslot::signal2<Port*, Connection*> SignalConnectionCreated; 224269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 225269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // In a shared socket mode each port which shares the socket will decide 226269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // to accept the packet based on the |remote_addr|. Currently only UDP 227269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // port implemented this method. 228269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // TODO(mallinath) - Make it pure virtual. 229269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual bool HandleIncomingPacket( 230269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::AsyncPacketSocket* socket, const char* data, size_t size, 231269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::SocketAddress& remote_addr, 232269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::PacketTime& packet_time) { 233269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org ASSERT(false); 234269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org return false; 235269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org } 236269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 237269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Sends a response message (normal or error) to the given request. One of 238269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // these methods should be called as a response to SignalUnknownAddress. 239269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // NOTE: You MUST call CreateConnection BEFORE SendBindingResponse. 240269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual void SendBindingResponse(StunMessage* request, 241269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::SocketAddress& addr); 242269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual void SendBindingErrorResponse( 243269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org StunMessage* request, const rtc::SocketAddress& addr, 244269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org int error_code, const std::string& reason); 245269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 246269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_proxy(const std::string& user_agent, 247269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::ProxyInfo& proxy) { 248269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org user_agent_ = user_agent; 249269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org proxy_ = proxy; 250269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org } 251269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const std::string& user_agent() { return user_agent_; } 252269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::ProxyInfo& proxy() { return proxy_; } 253269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 254269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual void EnablePortPackets(); 255269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 256269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called if the port has no connections and is no longer useful. 257269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void Destroy(); 258269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 259269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual void OnMessage(rtc::Message *pmsg); 260269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 261269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Debugging description of this port 262269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual std::string ToString() const; 2630ba1533fdbe4a098723da8262f1374d71c3a1806pthatcher@webrtc.org const rtc::IPAddress& ip() const { return ip_; } 2640c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint16_t min_port() { return min_port_; } 2650c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint16_t max_port() { return max_port_; } 266269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 267269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Timeout shortening function to speed up unit tests. 268269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_timeout_delay(int delay) { timeout_delay_ = delay; } 269269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 270269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // This method will return local and remote username fragements from the 271269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // stun username attribute if present. 272269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool ParseStunUsername(const StunMessage* stun_msg, 273269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org std::string* local_username, 2747cbd188c5ed7df80bb737bd4ada94422730e2d89Peter Thatcher std::string* remote_username) const; 275269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void CreateStunUsername(const std::string& remote_username, 276269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org std::string* stun_username_attr_str) const; 277269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 278269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool MaybeIceRoleConflict(const rtc::SocketAddress& addr, 279269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org IceMessage* stun_msg, 280269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const std::string& remote_ufrag); 281269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 282c1aeaf0dc37d96f31c92f893f4e30e7a5f7cc2b7stefan // Called when a packet has been sent to the socket. 28355674ffb32307c6f3efaab442340d3c5c075073bStefan Holmer // This is made pure virtual to notify subclasses of Port that they MUST 28455674ffb32307c6f3efaab442340d3c5c075073bStefan Holmer // listen to AsyncPacketSocket::SignalSentPacket and then call 28555674ffb32307c6f3efaab442340d3c5c075073bStefan Holmer // PortInterface::OnSentPacket. 28655674ffb32307c6f3efaab442340d3c5c075073bStefan Holmer virtual void OnSentPacket(rtc::AsyncPacketSocket* socket, 28755674ffb32307c6f3efaab442340d3c5c075073bStefan Holmer const rtc::SentPacket& sent_packet) = 0; 288c1aeaf0dc37d96f31c92f893f4e30e7a5f7cc2b7stefan 289269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called when the socket is currently able to send. 290269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void OnReadyToSend(); 291269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 292269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called when the Connection discovers a local peer reflexive candidate. 293269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Returns the index of the new local candidate. 294269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org size_t AddPrflxCandidate(const Candidate& local); 295269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 2960c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström void set_candidate_filter(uint32_t candidate_filter) { 297269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org candidate_filter_ = candidate_filter; 298269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org } 299269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 300269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org protected: 301269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org enum { 302d0b3143f0e37f5f5e0578e88cf740dd839b50c24honghaiz MSG_DEAD = 0, 303269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org MSG_FIRST_AVAILABLE 304269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org }; 305269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 306269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_type(const std::string& type) { type_ = type; } 307269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 308269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void AddAddress(const rtc::SocketAddress& address, 309269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::SocketAddress& base_address, 310269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::SocketAddress& related_address, 3113d564c10157d7de1d2d4236f4e2a13ff1363d52bGuo-wei Shieh const std::string& protocol, 3123d564c10157d7de1d2d4236f4e2a13ff1363d52bGuo-wei Shieh const std::string& relay_protocol, 3133d564c10157d7de1d2d4236f4e2a13ff1363d52bGuo-wei Shieh const std::string& tcptype, 3143d564c10157d7de1d2d4236f4e2a13ff1363d52bGuo-wei Shieh const std::string& type, 3150c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t type_preference, 3160c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t relay_preference, 3173d564c10157d7de1d2d4236f4e2a13ff1363d52bGuo-wei Shieh bool final); 318269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 319269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Adds the given connection to the list. (Deleting removes them.) 320269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void AddConnection(Connection* conn); 321269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 322269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called when a packet is received from an unknown address that is not 323269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // currently a connection. If this is an authenticated STUN binding request, 324269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // then we will signal the client. 325269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void OnReadPacket(const char* data, size_t size, 326269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::SocketAddress& addr, 327269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org ProtocolType proto); 328269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 329269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // If the given data comprises a complete and correct STUN message then the 330269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // return value is true, otherwise false. If the message username corresponds 331269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // with this port's username fragment, msg will contain the parsed STUN 332269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // message. Otherwise, the function may send a STUN response internally. 333269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // remote_username contains the remote fragment of the STUN username. 334269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool GetStunMessage(const char* data, size_t size, 335269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::SocketAddress& addr, 336269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org IceMessage** out_msg, std::string* out_username); 337269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 338269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Checks if the address in addr is compatible with the port's ip. 339269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool IsCompatibleAddress(const rtc::SocketAddress& addr); 340269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 341269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Returns default DSCP value. 342269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::DiffServCodePoint DefaultDscpValue() const { 343269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // No change from what MediaChannel set. 344269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org return rtc::DSCP_NO_CHANGE; 345269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org } 346269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 3470c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t candidate_filter() { return candidate_filter_; } 348269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 349269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org private: 350269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void Construct(); 351269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called when one of our connections deletes itself. 352269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void OnConnectionDestroyed(Connection* conn); 353269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 354d0b3143f0e37f5f5e0578e88cf740dd839b50c24honghaiz // Whether this port is dead, and hence, should be destroyed on the controlled 355d0b3143f0e37f5f5e0578e88cf740dd839b50c24honghaiz // side. 356d0b3143f0e37f5f5e0578e88cf740dd839b50c24honghaiz bool dead() const { 357d0b3143f0e37f5f5e0578e88cf740dd839b50c24honghaiz return ice_role_ == ICEROLE_CONTROLLED && connections_.empty(); 358d0b3143f0e37f5f5e0578e88cf740dd839b50c24honghaiz } 359269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 360269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::Thread* thread_; 361269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::PacketSocketFactory* factory_; 362269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org std::string type_; 363269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool send_retransmit_count_attribute_; 364269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::Network* network_; 365269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::IPAddress ip_; 3660c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint16_t min_port_; 3670c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint16_t max_port_; 368269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org std::string content_name_; 369269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org int component_; 3700c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t generation_; 371269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // In order to establish a connection to this Port (so that real data can be 372269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // sent through), the other side must send us a STUN binding request that is 373269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // authenticated with this username_fragment and password. 374269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // PortAllocatorSession will provide these username_fragment and password. 375269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // 376269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Note: we should always use username_fragment() instead of using 377269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // |ice_username_fragment_| directly. For the details see the comment on 378269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // username_fragment(). 379269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org std::string ice_username_fragment_; 380269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org std::string password_; 381269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org std::vector<Candidate> candidates_; 382269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org AddressMap connections_; 383269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org int timeout_delay_; 384269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool enable_port_packets_; 385269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org IceRole ice_role_; 3860c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint64_t tiebreaker_; 387269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool shared_socket_; 388269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Information to use when going through a proxy. 389269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org std::string user_agent_; 390269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::ProxyInfo proxy_; 391269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 392269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Candidate filter is pushed down to Port such that each Port could 393269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // make its own decision on how to create candidates. For example, 394269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // when IceTransportsType is set to relay, both RelayPort and 395269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // TurnPort will hide raddr to avoid local address leakage. 3960c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t candidate_filter_; 397269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 398269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org friend class Connection; 399269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org}; 400269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 401269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org// Represents a communication link between a port on the local client and a 402269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org// port on the remote client. 403269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgclass Connection : public rtc::MessageHandler, 404269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org public sigslot::has_slots<> { 405269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org public: 4061cf6f8101ae9db517332783e99c98e14ff4c47e1Peter Thatcher struct SentPing { 4070c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström SentPing(const std::string id, uint32_t sent_time) 4080c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström : id(id), sent_time(sent_time) {} 4091cf6f8101ae9db517332783e99c98e14ff4c47e1Peter Thatcher 4101cf6f8101ae9db517332783e99c98e14ff4c47e1Peter Thatcher std::string id; 4110c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t sent_time; 4121cf6f8101ae9db517332783e99c98e14ff4c47e1Peter Thatcher }; 4131cf6f8101ae9db517332783e99c98e14ff4c47e1Peter Thatcher 414269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // States are from RFC 5245. http://tools.ietf.org/html/rfc5245#section-5.7.4 415269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org enum State { 416269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org STATE_WAITING = 0, // Check has not been performed, Waiting pair on CL. 417269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org STATE_INPROGRESS, // Check has been sent, transaction is in progress. 418269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org STATE_SUCCEEDED, // Check already done, produced a successful result. 419269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org STATE_FAILED // Check for this connection failed. 420269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org }; 421269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 422269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual ~Connection(); 423269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 424269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // The local port where this connection sends and receives packets. 425269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org Port* port() { return port_; } 426269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const Port* port() const { return port_; } 427269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 428269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Returns the description of the local port 429269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual const Candidate& local_candidate() const; 430269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 431269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Returns the description of the remote port to which we communicate. 432269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const Candidate& remote_candidate() const { return remote_candidate_; } 433269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 434269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Returns the pair priority. 4350c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint64_t priority() const; 436269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 437269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org enum WriteState { 438269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org STATE_WRITABLE = 0, // we have received ping responses recently 439269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org STATE_WRITE_UNRELIABLE = 1, // we have had a few ping failures 440269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org STATE_WRITE_INIT = 2, // we have yet to receive a ping response 441269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org STATE_WRITE_TIMEOUT = 3, // we have had a large number of ping failures 442269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org }; 443269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 444269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org WriteState write_state() const { return write_state_; } 445269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool writable() const { return write_state_ == STATE_WRITABLE; } 44604ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher bool receiving() const { return receiving_; } 447269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 448269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Determines whether the connection has finished connecting. This can only 449269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // be false for TCP connections. 450269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool connected() const { return connected_; } 4512b342bf99c9578247940929c02a41ef9ccec6d6eHonghai Zhang bool weak() const { return !(writable() && receiving() && connected()); } 4522b342bf99c9578247940929c02a41ef9ccec6d6eHonghai Zhang bool active() const { 4532b342bf99c9578247940929c02a41ef9ccec6d6eHonghai Zhang return write_state_ != STATE_WRITE_TIMEOUT; 4542b342bf99c9578247940929c02a41ef9ccec6d6eHonghai Zhang } 4552b342bf99c9578247940929c02a41ef9ccec6d6eHonghai Zhang // A connection is dead if it can be safely deleted. 4560c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström bool dead(uint32_t now) const; 4578937437872d8ff5b30866ae4de4abf005afc7539honghaiz 458269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Estimate of the round-trip time over this connection. 4590c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t rtt() const { return rtt_; } 460269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 461269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org size_t sent_total_bytes(); 462269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org size_t sent_bytes_second(); 463930e004a817ed346a99ac8e56575326ca75e72aaguoweis@webrtc.org // Used to track how many packets are discarded in the application socket due 464930e004a817ed346a99ac8e56575326ca75e72aaguoweis@webrtc.org // to errors. 465930e004a817ed346a99ac8e56575326ca75e72aaguoweis@webrtc.org size_t sent_discarded_packets(); 466930e004a817ed346a99ac8e56575326ca75e72aaguoweis@webrtc.org size_t sent_total_packets(); 467269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org size_t recv_total_bytes(); 468269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org size_t recv_bytes_second(); 469269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org sigslot::signal1<Connection*> SignalStateChange; 470269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 471269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Sent when the connection has decided that it is no longer of value. It 472269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // will delete itself immediately after this call. 473269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org sigslot::signal1<Connection*> SignalDestroyed; 474269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 475269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // The connection can send and receive packets asynchronously. This matches 476269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // the interface of AsyncPacketSocket, which may use UDP or TCP under the 477269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // covers. 478269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual int Send(const void* data, size_t size, 479269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::PacketOptions& options) = 0; 480269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 481269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Error if Send() returns < 0 482269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org virtual int GetError() = 0; 483269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 48404ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher sigslot::signal4<Connection*, const char*, size_t, const rtc::PacketTime&> 48504ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher SignalReadPacket; 486269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 487269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org sigslot::signal1<Connection*> SignalReadyToSend; 488269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 489269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called when a packet is received on this connection. 490269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void OnReadPacket(const char* data, size_t size, 491269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org const rtc::PacketTime& packet_time); 492269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 493269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called when the socket is currently able to send. 494269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void OnReadyToSend(); 495269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 496269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called when a connection is determined to be no longer useful to us. We 497269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // still keep it around in case the other side wants to use it. But we can 498269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // safely stop pinging on it and we can allow it to time out if the other 499269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // side stops using it as well. 500269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool pruned() const { return pruned_; } 501269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void Prune(); 502269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 503269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool use_candidate_attr() const { return use_candidate_attr_; } 504269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_use_candidate_attr(bool enable); 505269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 5065a3acd89648e7cff7e1b76b2da710be041be54a0honghaiz bool nominated() const { return nominated_; } 5075a3acd89648e7cff7e1b76b2da710be041be54a0honghaiz void set_nominated(bool nominated) { nominated_ = nominated; } 5085a3acd89648e7cff7e1b76b2da710be041be54a0honghaiz 509269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_remote_ice_mode(IceMode mode) { 510269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org remote_ice_mode_ = mode; 511269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org } 512269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 5130c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström void set_receiving_timeout(uint32_t receiving_timeout_ms) { 51404ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher receiving_timeout_ = receiving_timeout_ms; 51504ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher } 51604ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher 517269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Makes the connection go away. 518269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void Destroy(); 519269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 520376e1235c7b602e86afe9f36eb81289e42643718deadbeef // Makes the connection go away, in a failed state. 521376e1235c7b602e86afe9f36eb81289e42643718deadbeef void FailAndDestroy(); 522376e1235c7b602e86afe9f36eb81289e42643718deadbeef 523269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Checks that the state of this connection is up-to-date. The argument is 524269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // the current time, which is compared against various timeouts. 5250c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström void UpdateState(uint32_t now); 526269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 527269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called when this connection should try checking writability again. 5280c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t last_ping_sent() const { return last_ping_sent_; } 5290c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström void Ping(uint32_t now); 5301fe120a6b9371819515f2f05beaf62ddcc9c9f30Peter Thatcher void ReceivedPingResponse(); 531381b4217cb36f434c56e399a852a0a15522a9596Honghai Zhang uint32_t last_ping_response_received() const { 532381b4217cb36f434c56e399a852a0a15522a9596Honghai Zhang return last_ping_response_received_; 533381b4217cb36f434c56e399a852a0a15522a9596Honghai Zhang } 534269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 535269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called whenever a valid ping is received on this connection. This is 536269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // public because the connection intercepts the first ping for us. 5370c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t last_ping_received() const { return last_ping_received_; } 538269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void ReceivedPing(); 5399b5ee9c0d988b1d0dc64920937448e301dd45bd9honghaiz // Handles the binding request; sends a response if this is a valid request. 5409b5ee9c0d988b1d0dc64920937448e301dd45bd9honghaiz void HandleBindingRequest(IceMessage* msg); 541269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 542269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Debugging description of this connection 5438c9ff203c5f3c87891b46067ef6ec21b37d2dde4guoweis@webrtc.org std::string ToDebugId() const; 544269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org std::string ToString() const; 545269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org std::string ToSensitiveString() const; 5461cf6f8101ae9db517332783e99c98e14ff4c47e1Peter Thatcher // Prints pings_since_last_response_ into a string. 5471cf6f8101ae9db517332783e99c98e14ff4c47e1Peter Thatcher void PrintPingsSinceLastResponse(std::string* pings, size_t max); 548269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 549269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool reported() const { return reported_; } 550269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_reported(bool reported) { reported_ = reported;} 551269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 5525a3acd89648e7cff7e1b76b2da710be041be54a0honghaiz // This signal will be fired if this connection is nominated by the 5535a3acd89648e7cff7e1b76b2da710be041be54a0honghaiz // controlling side. 5545a3acd89648e7cff7e1b76b2da710be041be54a0honghaiz sigslot::signal1<Connection*> SignalNominated; 55554360510ff9b7c61fc906d3ed360b06a5824bbf1Peter Thatcher 556269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Invoked when Connection receives STUN error response with 487 code. 557269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void HandleRoleConflictFromPeer(); 558269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 559269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org State state() const { return state_; } 560269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 561269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org IceMode remote_ice_mode() const { return remote_ice_mode_; } 562269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 563dacdd9403d30cdb13ab2de645841edd2ae76950djiayl@webrtc.org // Update the ICE password of the remote candidate if |ice_ufrag| matches 564dacdd9403d30cdb13ab2de645841edd2ae76950djiayl@webrtc.org // the candidate's ufrag, and the candidate's passwrod has not been set. 565dacdd9403d30cdb13ab2de645841edd2ae76950djiayl@webrtc.org void MaybeSetRemoteIceCredentials(const std::string& ice_ufrag, 566dacdd9403d30cdb13ab2de645841edd2ae76950djiayl@webrtc.org const std::string& ice_pwd); 567dacdd9403d30cdb13ab2de645841edd2ae76950djiayl@webrtc.org 568dacdd9403d30cdb13ab2de645841edd2ae76950djiayl@webrtc.org // If |remote_candidate_| is peer reflexive and is equivalent to 569dacdd9403d30cdb13ab2de645841edd2ae76950djiayl@webrtc.org // |new_candidate| except the type, update |remote_candidate_| to 570dacdd9403d30cdb13ab2de645841edd2ae76950djiayl@webrtc.org // |new_candidate|. 571dacdd9403d30cdb13ab2de645841edd2ae76950djiayl@webrtc.org void MaybeUpdatePeerReflexiveCandidate(const Candidate& new_candidate); 572dacdd9403d30cdb13ab2de645841edd2ae76950djiayl@webrtc.org 57354360510ff9b7c61fc906d3ed360b06a5824bbf1Peter Thatcher // Returns the last received time of any data, stun request, or stun 57454360510ff9b7c61fc906d3ed360b06a5824bbf1Peter Thatcher // response in milliseconds 5752cd7afe7e2dc011ab00bdbc131039b16aa8fbdebHonghai Zhang uint32_t last_received() const; 57654360510ff9b7c61fc906d3ed360b06a5824bbf1Peter Thatcher 577269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org protected: 578be508a1d3634ce63b64cd740c44600453e3c3a6bGuo-wei Shieh enum { MSG_DELETE = 0, MSG_FIRST_AVAILABLE }; 579be508a1d3634ce63b64cd740c44600453e3c3a6bGuo-wei Shieh 580269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Constructs a new connection to the given remote port. 581269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org Connection(Port* port, size_t index, const Candidate& candidate); 582269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 583269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Called back when StunRequestManager has a stun packet to send 584269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void OnSendStunPacket(const void* data, size_t size, StunRequest* req); 585269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 586269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Callbacks from ConnectionRequest 587be508a1d3634ce63b64cd740c44600453e3c3a6bGuo-wei Shieh virtual void OnConnectionRequestResponse(ConnectionRequest* req, 588be508a1d3634ce63b64cd740c44600453e3c3a6bGuo-wei Shieh StunMessage* response); 589269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void OnConnectionRequestErrorResponse(ConnectionRequest* req, 590269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org StunMessage* response); 591269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void OnConnectionRequestTimeout(ConnectionRequest* req); 5921cf6f8101ae9db517332783e99c98e14ff4c47e1Peter Thatcher void OnConnectionRequestSent(ConnectionRequest* req); 593269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 594269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // Changes the state and signals if necessary. 595269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_write_state(WriteState value); 59604ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher void set_receiving(bool value); 597269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_state(State state); 598269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void set_connected(bool value); 599269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 600269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void OnMessage(rtc::Message *pmsg); 601269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 602269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org Port* port_; 603269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org size_t local_candidate_index_; 604269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org Candidate remote_candidate_; 605269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org WriteState write_state_; 60604ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher bool receiving_; 607269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool connected_; 608269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool pruned_; 609269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // By default |use_candidate_attr_| flag will be true, 6105a3acd89648e7cff7e1b76b2da710be041be54a0honghaiz // as we will be using aggressive nomination. 611269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // But when peer is ice-lite, this flag "must" be initialized to false and 612269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org // turn on when connection becomes "best connection". 613269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool use_candidate_attr_; 6145a3acd89648e7cff7e1b76b2da710be041be54a0honghaiz // Whether this connection has been nominated by the controlling side via 6155a3acd89648e7cff7e1b76b2da710be041be54a0honghaiz // the use_candidate attribute. 6165a3acd89648e7cff7e1b76b2da710be041be54a0honghaiz bool nominated_; 617269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org IceMode remote_ice_mode_; 618269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org StunRequestManager requests_; 6190c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t rtt_; 6200c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t last_ping_sent_; // last time we sent a ping to the other side 6210c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t last_ping_received_; // last time we received a ping from the other 6220c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström // side 6230c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t last_data_received_; 6240c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t last_ping_response_received_; 6251cf6f8101ae9db517332783e99c98e14ff4c47e1Peter Thatcher std::vector<SentPing> pings_since_last_response_; 626269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 627269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::RateTracker recv_rate_tracker_; 628269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org rtc::RateTracker send_rate_tracker_; 6290c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t sent_packets_discarded_; 6300c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t sent_packets_total_; 631269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 632269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org private: 633269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org void MaybeAddPrflxCandidate(ConnectionRequest* request, 634269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org StunMessage* response); 635269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 636269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org bool reported_; 637269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org State state_; 63804ac81f2fd8ef6680522438fac1894db5415a0ecPeter Thatcher // Time duration to switch from receiving to not receiving. 6390c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t receiving_timeout_; 6400c4e06b4c6107a1b94f764e279e4fb4161e905b0Peter Boström uint32_t time_created_ms_; 641269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 642269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org friend class Port; 643269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org friend class ConnectionRequest; 644269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org}; 645269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 646376e1235c7b602e86afe9f36eb81289e42643718deadbeef// ProxyConnection defers all the interesting work to the port. 647269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.orgclass ProxyConnection : public Connection { 648269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org public: 649376e1235c7b602e86afe9f36eb81289e42643718deadbeef ProxyConnection(Port* port, size_t index, const Candidate& remote_candidate); 650269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 651376e1235c7b602e86afe9f36eb81289e42643718deadbeef int Send(const void* data, 652376e1235c7b602e86afe9f36eb81289e42643718deadbeef size_t size, 653376e1235c7b602e86afe9f36eb81289e42643718deadbeef const rtc::PacketOptions& options) override; 654376e1235c7b602e86afe9f36eb81289e42643718deadbeef int GetError() override { return error_; } 655269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 656269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org private: 657376e1235c7b602e86afe9f36eb81289e42643718deadbeef int error_ = 0; 658269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org}; 659269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 660269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org} // namespace cricket 661269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org 662269fb4bc90b79bebbb8311da0110ccd6803fd0a8henrike@webrtc.org#endif // WEBRTC_P2P_BASE_PORT_H_ 663