diff options
Diffstat (limited to 'talk/app/webrtc/webrtcsession.cc')
| -rw-r--r-- | talk/app/webrtc/webrtcsession.cc | 2204 |
1 files changed, 2204 insertions, 0 deletions
diff --git a/talk/app/webrtc/webrtcsession.cc b/talk/app/webrtc/webrtcsession.cc new file mode 100644 index 0000000000..95abeab77a --- /dev/null +++ b/talk/app/webrtc/webrtcsession.cc @@ -0,0 +1,2204 @@ +/* + * libjingle + * Copyright 2012 Google Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO + * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "talk/app/webrtc/webrtcsession.h" + +#include <limits.h> + +#include <algorithm> +#include <vector> +#include <set> + +#include "talk/app/webrtc/jsepicecandidate.h" +#include "talk/app/webrtc/jsepsessiondescription.h" +#include "talk/app/webrtc/mediaconstraintsinterface.h" +#include "talk/app/webrtc/mediastreamsignaling.h" +#include "talk/app/webrtc/peerconnectioninterface.h" +#include "talk/app/webrtc/sctputils.h" +#include "talk/app/webrtc/webrtcsessiondescriptionfactory.h" +#include "talk/media/base/constants.h" +#include "talk/media/base/videocapturer.h" +#include "talk/session/media/channel.h" +#include "talk/session/media/channelmanager.h" +#include "talk/session/media/mediasession.h" +#include "webrtc/base/basictypes.h" +#include "webrtc/base/checks.h" +#include "webrtc/base/helpers.h" +#include "webrtc/base/logging.h" +#include "webrtc/base/stringencode.h" +#include "webrtc/base/stringutils.h" +#include "webrtc/call.h" +#include "webrtc/p2p/base/portallocator.h" +#include "webrtc/p2p/base/transportchannel.h" + +using cricket::ContentInfo; +using cricket::ContentInfos; +using cricket::MediaContentDescription; +using cricket::SessionDescription; +using cricket::TransportInfo; + +using cricket::LOCAL_PORT_TYPE; +using cricket::STUN_PORT_TYPE; +using cricket::RELAY_PORT_TYPE; +using cricket::PRFLX_PORT_TYPE; + +namespace webrtc { + +// Error messages +const char kBundleWithoutRtcpMux[] = "RTCP-MUX must be enabled when BUNDLE " + "is enabled."; +const char kCreateChannelFailed[] = "Failed to create channels."; +const char kInvalidCandidates[] = "Description contains invalid candidates."; +const char kInvalidSdp[] = "Invalid session description."; +const char kMlineMismatch[] = + "Offer and answer descriptions m-lines are not matching. Rejecting answer."; +const char kPushDownTDFailed[] = + "Failed to push down transport description:"; +const char kSdpWithoutDtlsFingerprint[] = + "Called with SDP without DTLS fingerprint."; +const char kSdpWithoutSdesCrypto[] = + "Called with SDP without SDES crypto."; +const char kSdpWithoutIceUfragPwd[] = + "Called with SDP without ice-ufrag and ice-pwd."; +const char kSessionError[] = "Session error code: "; +const char kSessionErrorDesc[] = "Session error description: "; +const char kDtlsSetupFailureRtp[] = + "Couldn't set up DTLS-SRTP on RTP channel."; +const char kDtlsSetupFailureRtcp[] = + "Couldn't set up DTLS-SRTP on RTCP channel."; +const char kEnableBundleFailed[] = "Failed to enable BUNDLE."; +const int kMaxUnsignalledRecvStreams = 20; + +IceCandidatePairType GetIceCandidatePairCounter( + const cricket::Candidate& local, + const cricket::Candidate& remote) { + const auto& l = local.type(); + const auto& r = remote.type(); + const auto& host = LOCAL_PORT_TYPE; + const auto& srflx = STUN_PORT_TYPE; + const auto& relay = RELAY_PORT_TYPE; + const auto& prflx = PRFLX_PORT_TYPE; + if (l == host && r == host) { + bool local_private = IPIsPrivate(local.address().ipaddr()); + bool remote_private = IPIsPrivate(remote.address().ipaddr()); + if (local_private) { + if (remote_private) { + return kIceCandidatePairHostPrivateHostPrivate; + } else { + return kIceCandidatePairHostPrivateHostPublic; + } + } else { + if (remote_private) { + return kIceCandidatePairHostPublicHostPrivate; + } else { + return kIceCandidatePairHostPublicHostPublic; + } + } + } + if (l == host && r == srflx) + return kIceCandidatePairHostSrflx; + if (l == host && r == relay) + return kIceCandidatePairHostRelay; + if (l == host && r == prflx) + return kIceCandidatePairHostPrflx; + if (l == srflx && r == host) + return kIceCandidatePairSrflxHost; + if (l == srflx && r == srflx) + return kIceCandidatePairSrflxSrflx; + if (l == srflx && r == relay) + return kIceCandidatePairSrflxRelay; + if (l == srflx && r == prflx) + return kIceCandidatePairSrflxPrflx; + if (l == relay && r == host) + return kIceCandidatePairRelayHost; + if (l == relay && r == srflx) + return kIceCandidatePairRelaySrflx; + if (l == relay && r == relay) + return kIceCandidatePairRelayRelay; + if (l == relay && r == prflx) + return kIceCandidatePairRelayPrflx; + if (l == prflx && r == host) + return kIceCandidatePairPrflxHost; + if (l == prflx && r == srflx) + return kIceCandidatePairPrflxSrflx; + if (l == prflx && r == relay) + return kIceCandidatePairPrflxRelay; + return kIceCandidatePairMax; +} + +// Compares |answer| against |offer|. Comparision is done +// for number of m-lines in answer against offer. If matches true will be +// returned otherwise false. +static bool VerifyMediaDescriptions( + const SessionDescription* answer, const SessionDescription* offer) { + if (offer->contents().size() != answer->contents().size()) + return false; + + for (size_t i = 0; i < offer->contents().size(); ++i) { + if ((offer->contents()[i].name) != answer->contents()[i].name) { + return false; + } + const MediaContentDescription* offer_mdesc = + static_cast<const MediaContentDescription*>( + offer->contents()[i].description); + const MediaContentDescription* answer_mdesc = + static_cast<const MediaContentDescription*>( + answer->contents()[i].description); + if (offer_mdesc->type() != answer_mdesc->type()) { + return false; + } + } + return true; +} + +// Checks that each non-rejected content has SDES crypto keys or a DTLS +// fingerprint. Mismatches, such as replying with a DTLS fingerprint to SDES +// keys, will be caught in Transport negotiation, and backstopped by Channel's +// |secure_required| check. +static bool VerifyCrypto(const SessionDescription* desc, + bool dtls_enabled, + std::string* error) { + const ContentInfos& contents = desc->contents(); + for (size_t index = 0; index < contents.size(); ++index) { + const ContentInfo* cinfo = &contents[index]; + if (cinfo->rejected) { + continue; + } + + // If the content isn't rejected, crypto must be present. + const MediaContentDescription* media = + static_cast<const MediaContentDescription*>(cinfo->description); + const TransportInfo* tinfo = desc->GetTransportInfoByName(cinfo->name); + if (!media || !tinfo) { + // Something is not right. + LOG(LS_ERROR) << kInvalidSdp; + *error = kInvalidSdp; + return false; + } + if (dtls_enabled) { + if (!tinfo->description.identity_fingerprint) { + LOG(LS_WARNING) << + "Session description must have DTLS fingerprint if DTLS enabled."; + *error = kSdpWithoutDtlsFingerprint; + return false; + } + } else { + if (media->cryptos().empty()) { + LOG(LS_WARNING) << + "Session description must have SDES when DTLS disabled."; + *error = kSdpWithoutSdesCrypto; + return false; + } + } + } + + return true; +} + +// Checks that each non-rejected content has ice-ufrag and ice-pwd set. +static bool VerifyIceUfragPwdPresent(const SessionDescription* desc) { + const ContentInfos& contents = desc->contents(); + for (size_t index = 0; index < contents.size(); ++index) { + const ContentInfo* cinfo = &contents[index]; + if (cinfo->rejected) { + continue; + } + + // If the content isn't rejected, ice-ufrag and ice-pwd must be present. + const TransportInfo* tinfo = desc->GetTransportInfoByName(cinfo->name); + if (!tinfo) { + // Something is not right. + LOG(LS_ERROR) << kInvalidSdp; + return false; + } + if (tinfo->description.ice_ufrag.empty() || + tinfo->description.ice_pwd.empty()) { + LOG(LS_ERROR) << "Session description must have ice ufrag and pwd."; + return false; + } + } + return true; +} + +// Forces |sdesc->crypto_required| to the appropriate state based on the +// current security policy, to ensure a failure occurs if there is an error +// in crypto negotiation. +// Called when processing the local session description. +static void UpdateSessionDescriptionSecurePolicy(cricket::CryptoType type, + SessionDescription* sdesc) { + if (!sdesc) { + return; + } + + // Updating the |crypto_required_| in MediaContentDescription to the + // appropriate state based on the current security policy. + for (cricket::ContentInfos::iterator iter = sdesc->contents().begin(); + iter != sdesc->contents().end(); ++iter) { + if (cricket::IsMediaContent(&*iter)) { + MediaContentDescription* mdesc = + static_cast<MediaContentDescription*> (iter->description); + if (mdesc) { + mdesc->set_crypto_required(type); + } + } + } +} + +static bool GetAudioSsrcByTrackId(const SessionDescription* session_description, + const std::string& track_id, + uint32_t* ssrc) { + const cricket::ContentInfo* audio_info = + cricket::GetFirstAudioContent(session_description); + if (!audio_info) { + LOG(LS_ERROR) << "Audio not used in this call"; + return false; + } + + const cricket::MediaContentDescription* audio_content = + static_cast<const cricket::MediaContentDescription*>( + audio_info->description); + const cricket::StreamParams* stream = + cricket::GetStreamByIds(audio_content->streams(), "", track_id); + if (!stream) { + return false; + } + + *ssrc = stream->first_ssrc(); + return true; +} + +static bool GetTrackIdBySsrc(const SessionDescription* session_description, + uint32_t ssrc, + std::string* track_id) { + ASSERT(track_id != NULL); + + const cricket::ContentInfo* audio_info = + cricket::GetFirstAudioContent(session_description); + if (audio_info) { + const cricket::MediaContentDescription* audio_content = + static_cast<const cricket::MediaContentDescription*>( + audio_info->description); + + const auto* found = + cricket::GetStreamBySsrc(audio_content->streams(), ssrc); + if (found) { + *track_id = found->id; + return true; + } + } + + const cricket::ContentInfo* video_info = + cricket::GetFirstVideoContent(session_description); + if (video_info) { + const cricket::MediaContentDescription* video_content = + static_cast<const cricket::MediaContentDescription*>( + video_info->description); + + const auto* found = + cricket::GetStreamBySsrc(video_content->streams(), ssrc); + if (found) { + *track_id = found->id; + return true; + } + } + return false; +} + +static bool BadSdp(const std::string& source, + const std::string& type, + const std::string& reason, + std::string* err_desc) { + std::ostringstream desc; + desc << "Failed to set " << source; + if (!type.empty()) { + desc << " " << type; + } + desc << " sdp: " << reason; + + if (err_desc) { + *err_desc = desc.str(); + } + LOG(LS_ERROR) << desc.str(); + return false; +} + +static bool BadSdp(cricket::ContentSource source, + const std::string& type, + const std::string& reason, + std::string* err_desc) { + if (source == cricket::CS_LOCAL) { + return BadSdp("local", type, reason, err_desc); + } else { + return BadSdp("remote", type, reason, err_desc); + } +} + +static bool BadLocalSdp(const std::string& type, + const std::string& reason, + std::string* err_desc) { + return BadSdp(cricket::CS_LOCAL, type, reason, err_desc); +} + +static bool BadRemoteSdp(const std::string& type, + const std::string& reason, + std::string* err_desc) { + return BadSdp(cricket::CS_REMOTE, type, reason, err_desc); +} + +static bool BadOfferSdp(cricket::ContentSource source, + const std::string& reason, + std::string* err_desc) { + return BadSdp(source, SessionDescriptionInterface::kOffer, reason, err_desc); +} + +static bool BadPranswerSdp(cricket::ContentSource source, + const std::string& reason, + std::string* err_desc) { + return BadSdp(source, SessionDescriptionInterface::kPrAnswer, + reason, err_desc); +} + +static bool BadAnswerSdp(cricket::ContentSource source, + const std::string& reason, + std::string* err_desc) { + return BadSdp(source, SessionDescriptionInterface::kAnswer, reason, err_desc); +} + +#define GET_STRING_OF_STATE(state) \ + case webrtc::WebRtcSession::state: \ + result = #state; \ + break; + +static std::string GetStateString(webrtc::WebRtcSession::State state) { + std::string result; + switch (state) { + GET_STRING_OF_STATE(STATE_INIT) + GET_STRING_OF_STATE(STATE_SENTOFFER) + GET_STRING_OF_STATE(STATE_RECEIVEDOFFER) + GET_STRING_OF_STATE(STATE_SENTPRANSWER) + GET_STRING_OF_STATE(STATE_RECEIVEDPRANSWER) + GET_STRING_OF_STATE(STATE_INPROGRESS) + GET_STRING_OF_STATE(STATE_CLOSED) + default: + ASSERT(false); + break; + } + return result; +} + +#define GET_STRING_OF_ERROR_CODE(err) \ + case webrtc::WebRtcSession::err: \ + result = #err; \ + break; + +static std::string GetErrorCodeString(webrtc::WebRtcSession::Error err) { + std::string result; + switch (err) { + GET_STRING_OF_ERROR_CODE(ERROR_NONE) + GET_STRING_OF_ERROR_CODE(ERROR_CONTENT) + GET_STRING_OF_ERROR_CODE(ERROR_TRANSPORT) + default: + RTC_DCHECK(false); + break; + } + return result; +} + +static std::string MakeErrorString(const std::string& error, + const std::string& desc) { + std::ostringstream ret; + ret << error << " " << desc; + return ret.str(); +} + +static std::string MakeTdErrorString(const std::string& desc) { + return MakeErrorString(kPushDownTDFailed, desc); +} + +// Set |option| to the highest-priority value of |key| in the optional +// constraints if the key is found and has a valid value. +template<typename T> +static void SetOptionFromOptionalConstraint( + const MediaConstraintsInterface* constraints, + const std::string& key, cricket::Settable<T>* option) { + if (!constraints) { + return; + } + std::string string_value; + T value; + if (constraints->GetOptional().FindFirst(key, &string_value)) { + if (rtc::FromString(string_value, &value)) { + option->Set(value); + } + } +} + +uint32_t ConvertIceTransportTypeToCandidateFilter( + PeerConnectionInterface::IceTransportsType type) { + switch (type) { + case PeerConnectionInterface::kNone: + return cricket::CF_NONE; + case PeerConnectionInterface::kRelay: + return cricket::CF_RELAY; + case PeerConnectionInterface::kNoHost: + return (cricket::CF_ALL & ~cricket::CF_HOST); + case PeerConnectionInterface::kAll: + return cricket::CF_ALL; + default: ASSERT(false); + } + return cricket::CF_NONE; +} + +// Help class used to remember if a a remote peer has requested ice restart by +// by sending a description with new ice ufrag and password. +class IceRestartAnswerLatch { + public: + IceRestartAnswerLatch() : ice_restart_(false) { } + + // Returns true if CheckForRemoteIceRestart has been called with a new session + // description where ice password and ufrag has changed since last time + // Reset() was called. + bool Get() const { + return ice_restart_; + } + + void Reset() { + if (ice_restart_) { + ice_restart_ = false; + } + } + + bool CheckForRemoteIceRestart(const SessionDescriptionInterface* old_desc, + const SessionDescriptionInterface* new_desc) { + if (!old_desc || new_desc->type() != SessionDescriptionInterface::kOffer) { + return false; + } + const SessionDescription* new_sd = new_desc->description(); + const SessionDescription* old_sd = old_desc->description(); + const ContentInfos& contents = new_sd->contents(); + for (size_t index = 0; index < contents.size(); ++index) { + const ContentInfo* cinfo = &contents[index]; + if (cinfo->rejected) { + continue; + } + // If the content isn't rejected, check if ufrag and password has + // changed. + const cricket::TransportDescription* new_transport_desc = + new_sd->GetTransportDescriptionByName(cinfo->name); + const cricket::TransportDescription* old_transport_desc = + old_sd->GetTransportDescriptionByName(cinfo->name); + if (!new_transport_desc || !old_transport_desc) { + // No transport description exist. This is not an ice restart. + continue; + } + if (cricket::IceCredentialsChanged(old_transport_desc->ice_ufrag, + old_transport_desc->ice_pwd, + new_transport_desc->ice_ufrag, + new_transport_desc->ice_pwd)) { + LOG(LS_INFO) << "Remote peer request ice restart."; + ice_restart_ = true; + return true; + } + } + return false; + } + + private: + bool ice_restart_; +}; + +WebRtcSession::WebRtcSession(webrtc::MediaControllerInterface* media_controller, + rtc::Thread* signaling_thread, + rtc::Thread* worker_thread, + cricket::PortAllocator* port_allocator) + : signaling_thread_(signaling_thread), + worker_thread_(worker_thread), + port_allocator_(port_allocator), + // RFC 3264: The numeric value of the session id and version in the + // o line MUST be representable with a "64 bit signed integer". + // Due to this constraint session id |sid_| is max limited to LLONG_MAX. + sid_(rtc::ToString(rtc::CreateRandomId64() & LLONG_MAX)), + transport_controller_(new cricket::TransportController(signaling_thread, + worker_thread, + port_allocator)), + media_controller_(media_controller), + channel_manager_(media_controller_->channel_manager()), + ice_observer_(NULL), + ice_connection_state_(PeerConnectionInterface::kIceConnectionNew), + ice_connection_receiving_(true), + older_version_remote_peer_(false), + dtls_enabled_(false), + data_channel_type_(cricket::DCT_NONE), + ice_restart_latch_(new IceRestartAnswerLatch), + metrics_observer_(NULL) { + transport_controller_->SetIceRole(cricket::ICEROLE_CONTROLLED); + transport_controller_->SignalConnectionState.connect( + this, &WebRtcSession::OnTransportControllerConnectionState); + transport_controller_->SignalReceiving.connect( + this, &WebRtcSession::OnTransportControllerReceiving); + transport_controller_->SignalGatheringState.connect( + this, &WebRtcSession::OnTransportControllerGatheringState); + transport_controller_->SignalCandidatesGathered.connect( + this, &WebRtcSession::OnTransportControllerCandidatesGathered); +} + +WebRtcSession::~WebRtcSession() { + ASSERT(signaling_thread()->IsCurrent()); + // Destroy video_channel_ first since it may have a pointer to the + // voice_channel_. + if (video_channel_) { + SignalVideoChannelDestroyed(); + channel_manager_->DestroyVideoChannel(video_channel_.release()); + } + if (voice_channel_) { + SignalVoiceChannelDestroyed(); + channel_manager_->DestroyVoiceChannel(voice_channel_.release()); + } + if (data_channel_) { + SignalDataChannelDestroyed(); + channel_manager_->DestroyDataChannel(data_channel_.release()); + } + + LOG(LS_INFO) << "Session: " << id() << " is destroyed."; +} + +bool WebRtcSession::Initialize( + const PeerConnectionFactoryInterface::Options& options, + const MediaConstraintsInterface* constraints, + rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store, + const PeerConnectionInterface::RTCConfiguration& rtc_configuration) { + bundle_policy_ = rtc_configuration.bundle_policy; + rtcp_mux_policy_ = rtc_configuration.rtcp_mux_policy; + transport_controller_->SetSslMaxProtocolVersion(options.ssl_max_version); + + // Obtain a certificate from RTCConfiguration if any were provided (optional). + rtc::scoped_refptr<rtc::RTCCertificate> certificate; + if (!rtc_configuration.certificates.empty()) { + // TODO(hbos,torbjorng): Decide on certificate-selection strategy instead of + // just picking the first one. The decision should be made based on the DTLS + // handshake. The DTLS negotiations need to know about all certificates. + certificate = rtc_configuration.certificates[0]; + } + + SetIceConfig(ParseIceConfig(rtc_configuration)); + + // TODO(perkj): Take |constraints| into consideration. Return false if not all + // mandatory constraints can be fulfilled. Note that |constraints| + // can be null. + bool value; + + if (options.disable_encryption) { + dtls_enabled_ = false; + } else { + // Enable DTLS by default if we have an identity store or a certificate. + dtls_enabled_ = (dtls_identity_store || certificate); + // |constraints| can override the default |dtls_enabled_| value. + if (FindConstraint(constraints, MediaConstraintsInterface::kEnableDtlsSrtp, + &value, nullptr)) { + dtls_enabled_ = value; + } + } + + // Enable creation of RTP data channels if the kEnableRtpDataChannels is set. + // It takes precendence over the disable_sctp_data_channels + // PeerConnectionFactoryInterface::Options. + if (FindConstraint( + constraints, MediaConstraintsInterface::kEnableRtpDataChannels, + &value, NULL) && value) { + LOG(LS_INFO) << "Allowing RTP data engine."; + data_channel_type_ = cricket::DCT_RTP; + } else { + // DTLS has to be enabled to use SCTP. + if (!options.disable_sctp_data_channels && dtls_enabled_) { + LOG(LS_INFO) << "Allowing SCTP data engine."; + data_channel_type_ = cricket::DCT_SCTP; + } + } + + // Find DSCP constraint. + if (FindConstraint( + constraints, + MediaConstraintsInterface::kEnableDscp, + &value, NULL)) { + audio_options_.dscp.Set(value); + video_options_.dscp.Set(value); + } + + // Find Suspend Below Min Bitrate constraint. + if (FindConstraint( + constraints, + MediaConstraintsInterface::kEnableVideoSuspendBelowMinBitrate, + &value, + NULL)) { + video_options_.suspend_below_min_bitrate.Set(value); + } + + SetOptionFromOptionalConstraint(constraints, + MediaConstraintsInterface::kScreencastMinBitrate, + &video_options_.screencast_min_bitrate); + + // Find constraints for cpu overuse detection. + SetOptionFromOptionalConstraint(constraints, + MediaConstraintsInterface::kCpuUnderuseThreshold, + &video_options_.cpu_underuse_threshold); + SetOptionFromOptionalConstraint(constraints, + MediaConstraintsInterface::kCpuOveruseThreshold, + &video_options_.cpu_overuse_threshold); + SetOptionFromOptionalConstraint(constraints, + MediaConstraintsInterface::kCpuOveruseDetection, + &video_options_.cpu_overuse_detection); + SetOptionFromOptionalConstraint(constraints, + MediaConstraintsInterface::kCpuOveruseEncodeUsage, + &video_options_.cpu_overuse_encode_usage); + SetOptionFromOptionalConstraint(constraints, + MediaConstraintsInterface::kCpuUnderuseEncodeRsdThreshold, + &video_options_.cpu_underuse_encode_rsd_threshold); + SetOptionFromOptionalConstraint(constraints, + MediaConstraintsInterface::kCpuOveruseEncodeRsdThreshold, + &video_options_.cpu_overuse_encode_rsd_threshold); + + SetOptionFromOptionalConstraint(constraints, + MediaConstraintsInterface::kNumUnsignalledRecvStreams, + &video_options_.unsignalled_recv_stream_limit); + if (video_options_.unsignalled_recv_stream_limit.IsSet()) { + int stream_limit; + video_options_.unsignalled_recv_stream_limit.Get(&stream_limit); + stream_limit = std::min(kMaxUnsignalledRecvStreams, stream_limit); + stream_limit = std::max(0, stream_limit); + video_options_.unsignalled_recv_stream_limit.Set(stream_limit); + } + + SetOptionFromOptionalConstraint(constraints, + MediaConstraintsInterface::kHighStartBitrate, + &video_options_.video_start_bitrate); + + SetOptionFromOptionalConstraint(constraints, + MediaConstraintsInterface::kCombinedAudioVideoBwe, + &audio_options_.combined_audio_video_bwe); + + audio_options_.audio_jitter_buffer_max_packets.Set( + rtc_configuration.audio_jitter_buffer_max_packets); + + audio_options_.audio_jitter_buffer_fast_accelerate.Set( + rtc_configuration.audio_jitter_buffer_fast_accelerate); + + const cricket::VideoCodec default_codec( + JsepSessionDescription::kDefaultVideoCodecId, + JsepSessionDescription::kDefaultVideoCodecName, + JsepSessionDescription::kMaxVideoCodecWidth, + JsepSessionDescription::kMaxVideoCodecHeight, + JsepSessionDescription::kDefaultVideoCodecFramerate, + JsepSessionDescription::kDefaultVideoCodecPreference); + channel_manager_->SetDefaultVideoEncoderConfig( + cricket::VideoEncoderConfig(default_codec)); + + if (!dtls_enabled_) { + // Construct with DTLS disabled. + webrtc_session_desc_factory_.reset(new WebRtcSessionDescriptionFactory( + signaling_thread(), channel_manager_, this, id())); + } else { + // Construct with DTLS enabled. + if (!certificate) { + // Use the |dtls_identity_store| to generate a certificate. + RTC_DCHECK(dtls_identity_store); + webrtc_session_desc_factory_.reset(new WebRtcSessionDescriptionFactory( + signaling_thread(), channel_manager_, dtls_identity_store.Pass(), + this, id())); + } else { + // Use the already generated certificate. + webrtc_session_desc_factory_.reset(new WebRtcSessionDescriptionFactory( + signaling_thread(), channel_manager_, certificate, this, id())); + } + } + + webrtc_session_desc_factory_->SignalCertificateReady.connect( + this, &WebRtcSession::OnCertificateReady); + + if (options.disable_encryption) { + webrtc_session_desc_factory_->SetSdesPolicy(cricket::SEC_DISABLED); + } + port_allocator()->set_candidate_filter( + ConvertIceTransportTypeToCandidateFilter(rtc_configuration.type)); + + if (rtc_configuration.enable_localhost_ice_candidate) { + port_allocator()->set_flags( + port_allocator()->flags() | + cricket::PORTALLOCATOR_ENABLE_LOCALHOST_CANDIDATE); + } + + return true; +} + +void WebRtcSession::Close() { + SetState(STATE_CLOSED); + RemoveUnusedChannels(nullptr); + ASSERT(!voice_channel_); + ASSERT(!video_channel_); + ASSERT(!data_channel_); +} + +void WebRtcSession::SetSdesPolicy(cricket::SecurePolicy secure_policy) { + webrtc_session_desc_factory_->SetSdesPolicy(secure_policy); +} + +cricket::SecurePolicy WebRtcSession::SdesPolicy() const { + return webrtc_session_desc_factory_->SdesPolicy(); +} + +bool WebRtcSession::GetSslRole(rtc::SSLRole* role) { + if (!local_desc_ || !remote_desc_) { + LOG(LS_INFO) << "Local and Remote descriptions must be applied to get " + << "SSL Role of the session."; + return false; + } + + return transport_controller_->GetSslRole(role); +} + +void WebRtcSession::CreateOffer( + CreateSessionDescriptionObserver* observer, + const PeerConnectionInterface::RTCOfferAnswerOptions& options, + const cricket::MediaSessionOptions& session_options) { + webrtc_session_desc_factory_->CreateOffer(observer, options, session_options); +} + +void WebRtcSession::CreateAnswer( + CreateSessionDescriptionObserver* observer, + const MediaConstraintsInterface* constraints, + const cricket::MediaSessionOptions& session_options) { + webrtc_session_desc_factory_->CreateAnswer(observer, constraints, + session_options); +} + +bool WebRtcSession::SetLocalDescription(SessionDescriptionInterface* desc, + std::string* err_desc) { + ASSERT(signaling_thread()->IsCurrent()); + + // Takes the ownership of |desc| regardless of the result. + rtc::scoped_ptr<SessionDescriptionInterface> desc_temp(desc); + + // Validate SDP. + if (!ValidateSessionDescription(desc, cricket::CS_LOCAL, err_desc)) { + return false; + } + + // Update the initial_offerer flag if this session is the initial_offerer. + Action action = GetAction(desc->type()); + if (state() == STATE_INIT && action == kOffer) { + initial_offerer_ = true; + transport_controller_->SetIceRole(cricket::ICEROLE_CONTROLLING); + } + + cricket::SecurePolicy sdes_policy = + webrtc_session_desc_factory_->SdesPolicy(); + cricket::CryptoType crypto_required = dtls_enabled_ ? + cricket::CT_DTLS : (sdes_policy == cricket::SEC_REQUIRED ? + cricket::CT_SDES : cricket::CT_NONE); + // Update the MediaContentDescription crypto settings as per the policy set. + UpdateSessionDescriptionSecurePolicy(crypto_required, desc->description()); + + local_desc_.reset(desc_temp.release()); + + // Transport and Media channels will be created only when offer is set. + if (action == kOffer && !CreateChannels(local_desc_->description())) { + // TODO(mallinath) - Handle CreateChannel failure, as new local description + // is applied. Restore back to old description. + return BadLocalSdp(desc->type(), kCreateChannelFailed, err_desc); + } + + // Remove unused channels if MediaContentDescription is rejected. + RemoveUnusedChannels(local_desc_->description()); + + if (!UpdateSessionState(action, cricket::CS_LOCAL, err_desc)) { + return false; + } + + if (remote_desc_) { + // Now that we have a local description, we can push down remote candidates. + UseCandidatesInSessionDescription(remote_desc_.get()); + } + + if (error() != ERROR_NONE) { + return BadLocalSdp(desc->type(), GetSessionErrorMsg(), err_desc); + } + return true; +} + +bool WebRtcSession::SetRemoteDescription(SessionDescriptionInterface* desc, + std::string* err_desc) { + ASSERT(signaling_thread()->IsCurrent()); + + // Takes the ownership of |desc| regardless of the result. + rtc::scoped_ptr<SessionDescriptionInterface> desc_temp(desc); + + // Validate SDP. + if (!ValidateSessionDescription(desc, cricket::CS_REMOTE, err_desc)) { + return false; + } + + rtc::scoped_ptr<SessionDescriptionInterface> old_remote_desc( + remote_desc_.release()); + remote_desc_.reset(desc_temp.release()); + + // Transport and Media channels will be created only when offer is set. + Action action = GetAction(desc->type()); + if (action == kOffer && !CreateChannels(desc->description())) { + // TODO(mallinath) - Handle CreateChannel failure, as new local description + // is applied. Restore back to old description. + return BadRemoteSdp(desc->type(), kCreateChannelFailed, err_desc); + } + + // Remove unused channels if MediaContentDescription is rejected. + RemoveUnusedChannels(desc->description()); + + // NOTE: Candidates allocation will be initiated only when SetLocalDescription + // is called. + if (!UpdateSessionState(action, cricket::CS_REMOTE, err_desc)) { + return false; + } + + if (local_desc_ && !UseCandidatesInSessionDescription(desc)) { + return BadRemoteSdp(desc->type(), kInvalidCandidates, err_desc); + } + + // Check if this new SessionDescription contains new ice ufrag and password + // that indicates the remote peer requests ice restart. + bool ice_restart = + ice_restart_latch_->CheckForRemoteIceRestart(old_remote_desc.get(), desc); + // We retain all received candidates only if ICE is not restarted. + // When ICE is restarted, all previous candidates belong to an old generation + // and should not be kept. + // TODO(deadbeef): This goes against the W3C spec which says the remote + // description should only contain candidates from the last set remote + // description plus any candidates added since then. We should remove this + // once we're sure it won't break anything. + if (!ice_restart) { + WebRtcSessionDescriptionFactory::CopyCandidatesFromSessionDescription( + old_remote_desc.get(), desc); + } + + if (error() != ERROR_NONE) { + return BadRemoteSdp(desc->type(), GetSessionErrorMsg(), err_desc); + } + + // Set the the ICE connection state to connecting since the connection may + // become writable with peer reflexive candidates before any remote candidate + // is signaled. + // TODO(pthatcher): This is a short-term solution for crbug/446908. A real fix + // is to have a new signal the indicates a change in checking state from the + // transport and expose a new checking() member from transport that can be + // read to determine the current checking state. The existing SignalConnecting + // actually means "gathering candidates", so cannot be be used here. + if (desc->type() != SessionDescriptionInterface::kOffer && + ice_connection_state_ == PeerConnectionInterface::kIceConnectionNew) { + SetIceConnectionState(PeerConnectionInterface::kIceConnectionChecking); + } + return true; +} + +void WebRtcSession::LogState(State old_state, State new_state) { + LOG(LS_INFO) << "Session:" << id() + << " Old state:" << GetStateString(old_state) + << " New state:" << GetStateString(new_state); +} + +void WebRtcSession::SetState(State state) { + ASSERT(signaling_thread_->IsCurrent()); + if (state != state_) { + LogState(state_, state); + state_ = state; + SignalState(this, state_); + } +} + +void WebRtcSession::SetError(Error error, const std::string& error_desc) { + ASSERT(signaling_thread_->IsCurrent()); + if (error != error_) { + error_ = error; + error_desc_ = error_desc; + } +} + +bool WebRtcSession::UpdateSessionState( + Action action, cricket::ContentSource source, + std::string* err_desc) { + ASSERT(signaling_thread()->IsCurrent()); + + // If there's already a pending error then no state transition should happen. + // But all call-sites should be verifying this before calling us! + ASSERT(error() == ERROR_NONE); + std::string td_err; + if (action == kOffer) { + if (!PushdownTransportDescription(source, cricket::CA_OFFER, &td_err)) { + return BadOfferSdp(source, MakeTdErrorString(td_err), err_desc); + } + SetState(source == cricket::CS_LOCAL ? STATE_SENTOFFER + : STATE_RECEIVEDOFFER); + if (!PushdownMediaDescription(cricket::CA_OFFER, source, err_desc)) { + SetError(ERROR_CONTENT, *err_desc); + } + if (error() != ERROR_NONE) { + return BadOfferSdp(source, GetSessionErrorMsg(), err_desc); + } + } else if (action == kPrAnswer) { + if (!PushdownTransportDescription(source, cricket::CA_PRANSWER, &td_err)) { + return BadPranswerSdp(source, MakeTdErrorString(td_err), err_desc); + } + EnableChannels(); + SetState(source == cricket::CS_LOCAL ? STATE_SENTPRANSWER + : STATE_RECEIVEDPRANSWER); + if (!PushdownMediaDescription(cricket::CA_PRANSWER, source, err_desc)) { + SetError(ERROR_CONTENT, *err_desc); + } + if (error() != ERROR_NONE) { + return BadPranswerSdp(source, GetSessionErrorMsg(), err_desc); + } + } else if (action == kAnswer) { + if (!PushdownTransportDescription(source, cricket::CA_ANSWER, &td_err)) { + return BadAnswerSdp(source, MakeTdErrorString(td_err), err_desc); + } + const cricket::ContentGroup* local_bundle = + local_desc_->description()->GetGroupByName(cricket::GROUP_TYPE_BUNDLE); + const cricket::ContentGroup* remote_bundle = + remote_desc_->description()->GetGroupByName(cricket::GROUP_TYPE_BUNDLE); + if (local_bundle && remote_bundle) { + // The answerer decides the transport to bundle on + const cricket::ContentGroup* answer_bundle = + (source == cricket::CS_LOCAL ? local_bundle : remote_bundle); + if (!EnableBundle(*answer_bundle)) { + LOG(LS_WARNING) << "Failed to enable BUNDLE."; + return BadAnswerSdp(source, kEnableBundleFailed, err_desc); + } + } + EnableChannels(); + SetState(STATE_INPROGRESS); + if (!PushdownMediaDescription(cricket::CA_ANSWER, source, err_desc)) { + SetError(ERROR_CONTENT, *err_desc); + } + if (error() != ERROR_NONE) { + return BadAnswerSdp(source, GetSessionErrorMsg(), err_desc); + } + } + return true; +} + +WebRtcSession::Action WebRtcSession::GetAction(const std::string& type) { + if (type == SessionDescriptionInterface::kOffer) { + return WebRtcSession::kOffer; + } else if (type == SessionDescriptionInterface::kPrAnswer) { + return WebRtcSession::kPrAnswer; + } else if (type == SessionDescriptionInterface::kAnswer) { + return WebRtcSession::kAnswer; + } + ASSERT(false && "unknown action type"); + return WebRtcSession::kOffer; +} + +bool WebRtcSession::PushdownMediaDescription( + cricket::ContentAction action, + cricket::ContentSource source, + std::string* err) { + auto set_content = [this, action, source, err](cricket::BaseChannel* ch) { + if (!ch) { + return true; + } else if (source == cricket::CS_LOCAL) { + return ch->PushdownLocalDescription(local_desc_->description(), action, + err); + } else { + return ch->PushdownRemoteDescription(remote_desc_->description(), action, + err); + } + }; + + return (set_content(voice_channel()) && + set_content(video_channel()) && + set_content(data_channel())); +} + +bool WebRtcSession::PushdownTransportDescription(cricket::ContentSource source, + cricket::ContentAction action, + std::string* error_desc) { + RTC_DCHECK(signaling_thread()->IsCurrent()); + + if (source == cricket::CS_LOCAL) { + return PushdownLocalTransportDescription(local_desc_->description(), action, + error_desc); + } + return PushdownRemoteTransportDescription(remote_desc_->description(), action, + error_desc); +} + +bool WebRtcSession::PushdownLocalTransportDescription( + const SessionDescription* sdesc, + cricket::ContentAction action, + std::string* err) { + RTC_DCHECK(signaling_thread()->IsCurrent()); + + if (!sdesc) { + return false; + } + + for (const TransportInfo& tinfo : sdesc->transport_infos()) { + if (!transport_controller_->SetLocalTransportDescription( + tinfo.content_name, tinfo.description, action, err)) { + return false; + } + } + + return true; +} + +bool WebRtcSession::PushdownRemoteTransportDescription( + const SessionDescription* sdesc, + cricket::ContentAction action, + std::string* err) { + RTC_DCHECK(signaling_thread()->IsCurrent()); + + if (!sdesc) { + return false; + } + + for (const TransportInfo& tinfo : sdesc->transport_infos()) { + if (!transport_controller_->SetRemoteTransportDescription( + tinfo.content_name, tinfo.description, action, err)) { + return false; + } + } + + return true; +} + +bool WebRtcSession::GetTransportDescription( + const SessionDescription* description, + const std::string& content_name, + cricket::TransportDescription* tdesc) { + if (!description || !tdesc) { + return false; + } + const TransportInfo* transport_info = + description->GetTransportInfoByName(content_name); + if (!transport_info) { + return false; + } + *tdesc = transport_info->description; + return true; +} + +bool WebRtcSession::GetTransportStats(SessionStats* stats) { + ASSERT(signaling_thread()->IsCurrent()); + return (GetChannelTransportStats(voice_channel(), stats) && + GetChannelTransportStats(video_channel(), stats) && + GetChannelTransportStats(data_channel(), stats)); +} + +bool WebRtcSession::GetChannelTransportStats(cricket::BaseChannel* ch, + SessionStats* stats) { + ASSERT(signaling_thread()->IsCurrent()); + if (!ch) { + // Not using this channel. + return true; + } + + const std::string& content_name = ch->content_name(); + const std::string& transport_name = ch->transport_name(); + stats->proxy_to_transport[content_name] = transport_name; + if (stats->transport_stats.find(transport_name) != + stats->transport_stats.end()) { + // Transport stats already done for this transport. + return true; + } + + cricket::TransportStats tstats; + if (!transport_controller_->GetStats(transport_name, &tstats)) { + return false; + } + + stats->transport_stats[transport_name] = tstats; + return true; +} + +bool WebRtcSession::GetLocalCertificate( + const std::string& transport_name, + rtc::scoped_refptr<rtc::RTCCertificate>* certificate) { + ASSERT(signaling_thread()->IsCurrent()); + return transport_controller_->GetLocalCertificate(transport_name, + certificate); +} + +bool WebRtcSession::GetRemoteSSLCertificate(const std::string& transport_name, + rtc::SSLCertificate** cert) { + ASSERT(signaling_thread()->IsCurrent()); + return transport_controller_->GetRemoteSSLCertificate(transport_name, cert); +} + +cricket::BaseChannel* WebRtcSession::GetChannel( + const std::string& content_name) { + if (voice_channel() && voice_channel()->content_name() == content_name) { + return voice_channel(); + } + if (video_channel() && video_channel()->content_name() == content_name) { + return video_channel(); + } + if (data_channel() && data_channel()->content_name() == content_name) { + return data_channel(); + } + return nullptr; +} + +bool WebRtcSession::EnableBundle(const cricket::ContentGroup& bundle) { + const std::string* first_content_name = bundle.FirstContentName(); + if (!first_content_name) { + LOG(LS_WARNING) << "Tried to BUNDLE with no contents."; + return false; + } + const std::string& transport_name = *first_content_name; + cricket::BaseChannel* first_channel = GetChannel(transport_name); + + auto maybe_set_transport = [this, bundle, transport_name, + first_channel](cricket::BaseChannel* ch) { + if (!ch || !bundle.HasContentName(ch->content_name())) { + return true; + } + + if (ch->transport_name() == transport_name) { + LOG(LS_INFO) << "BUNDLE already enabled for " << ch->content_name() + << " on " << transport_name << "."; + return true; + } + + if (!ch->SetTransport(transport_name)) { + LOG(LS_WARNING) << "Failed to enable BUNDLE for " << ch->content_name(); + return false; + } + LOG(LS_INFO) << "Enabled BUNDLE for " << ch->content_name() << " on " + << transport_name << "."; + return true; + }; + + if (!maybe_set_transport(voice_channel()) || + !maybe_set_transport(video_channel()) || + !maybe_set_transport(data_channel())) { + return false; + } + + return true; +} + +bool WebRtcSession::ProcessIceMessage(const IceCandidateInterface* candidate) { + if (!remote_desc_) { + LOG(LS_ERROR) << "ProcessIceMessage: ICE candidates can't be added " + << "without any remote session description."; + return false; + } + + if (!candidate) { + LOG(LS_ERROR) << "ProcessIceMessage: Candidate is NULL."; + return false; + } + + bool valid = false; + bool ready = ReadyToUseRemoteCandidate(candidate, NULL, &valid); + if (!valid) { + return false; + } + + // Add this candidate to the remote session description. + if (!remote_desc_->AddCandidate(candidate)) { + LOG(LS_ERROR) << "ProcessIceMessage: Candidate cannot be used."; + return false; + } + + if (ready) { + return UseCandidate(candidate); + } else { + LOG(LS_INFO) << "ProcessIceMessage: Not ready to use candidate."; + return true; + } +} + +bool WebRtcSession::SetIceTransports( + PeerConnectionInterface::IceTransportsType type) { + return port_allocator()->set_candidate_filter( + ConvertIceTransportTypeToCandidateFilter(type)); +} + +cricket::IceConfig WebRtcSession::ParseIceConfig( + const PeerConnectionInterface::RTCConfiguration& config) const { + cricket::IceConfig ice_config; + ice_config.receiving_timeout_ms = config.ice_connection_receiving_timeout; + ice_config.gather_continually = (config.continual_gathering_policy == + PeerConnectionInterface::GATHER_CONTINUALLY); + return ice_config; +} + +void WebRtcSession::SetIceConfig(const cricket::IceConfig& config) { + transport_controller_->SetIceConfig(config); +} + +void WebRtcSession::MaybeStartGathering() { + transport_controller_->MaybeStartGathering(); +} + +bool WebRtcSession::GetLocalTrackIdBySsrc(uint32_t ssrc, + std::string* track_id) { + if (!local_desc_) { + return false; + } + return webrtc::GetTrackIdBySsrc(local_desc_->description(), ssrc, track_id); +} + +bool WebRtcSession::GetRemoteTrackIdBySsrc(uint32_t ssrc, + std::string* track_id) { + if (!remote_desc_) { + return false; + } + return webrtc::GetTrackIdBySsrc(remote_desc_->description(), ssrc, track_id); +} + +std::string WebRtcSession::BadStateErrMsg(State state) { + std::ostringstream desc; + desc << "Called in wrong state: " << GetStateString(state); + return desc.str(); +} + +void WebRtcSession::SetAudioPlayout(uint32_t ssrc, bool enable) { + ASSERT(signaling_thread()->IsCurrent()); + if (!voice_channel_) { + LOG(LS_ERROR) << "SetAudioPlayout: No audio channel exists."; + return; + } + if (!voice_channel_->SetOutputVolume(ssrc, enable ? 1 : 0)) { + // Allow that SetOutputVolume fail if |enable| is false but assert + // otherwise. This in the normal case when the underlying media channel has + // already been deleted. + ASSERT(enable == false); + } +} + +void WebRtcSession::SetAudioSend(uint32_t ssrc, + bool enable, + const cricket::AudioOptions& options, + cricket::AudioRenderer* renderer) { + ASSERT(signaling_thread()->IsCurrent()); + if (!voice_channel_) { + LOG(LS_ERROR) << "SetAudioSend: No audio channel exists."; + return; + } + if (!voice_channel_->SetAudioSend(ssrc, enable, &options, renderer)) { + LOG(LS_ERROR) << "SetAudioSend: ssrc is incorrect: " << ssrc; + } +} + +void WebRtcSession::SetAudioPlayoutVolume(uint32_t ssrc, double volume) { + ASSERT(signaling_thread()->IsCurrent()); + ASSERT(volume >= 0 && volume <= 10); + if (!voice_channel_) { + LOG(LS_ERROR) << "SetAudioPlayoutVolume: No audio channel exists."; + return; + } + + if (!voice_channel_->SetOutputVolume(ssrc, volume)) { + ASSERT(false); + } +} + +bool WebRtcSession::SetCaptureDevice(uint32_t ssrc, + cricket::VideoCapturer* camera) { + ASSERT(signaling_thread()->IsCurrent()); + + if (!video_channel_) { + // |video_channel_| doesnt't exist. Probably because the remote end doesnt't + // support video. + LOG(LS_WARNING) << "Video not used in this call."; + return false; + } + if (!video_channel_->SetCapturer(ssrc, camera)) { + // Allow that SetCapturer fail if |camera| is NULL but assert otherwise. + // This in the normal case when the underlying media channel has already + // been deleted. + ASSERT(camera == NULL); + return false; + } + return true; +} + +void WebRtcSession::SetVideoPlayout(uint32_t ssrc, + bool enable, + cricket::VideoRenderer* renderer) { + ASSERT(signaling_thread()->IsCurrent()); + if (!video_channel_) { + LOG(LS_WARNING) << "SetVideoPlayout: No video channel exists."; + return; + } + if (!video_channel_->SetRenderer(ssrc, enable ? renderer : NULL)) { + // Allow that SetRenderer fail if |renderer| is NULL but assert otherwise. + // This in the normal case when the underlying media channel has already + // been deleted. + ASSERT(renderer == NULL); + } +} + +void WebRtcSession::SetVideoSend(uint32_t ssrc, + bool enable, + const cricket::VideoOptions* options) { + ASSERT(signaling_thread()->IsCurrent()); + if (!video_channel_) { + LOG(LS_WARNING) << "SetVideoSend: No video channel exists."; + return; + } + if (!video_channel_->SetVideoSend(ssrc, enable, options)) { + // Allow that MuteStream fail if |enable| is false but assert otherwise. + // This in the normal case when the underlying media channel has already + // been deleted. + ASSERT(enable == false); + } +} + +bool WebRtcSession::CanInsertDtmf(const std::string& track_id) { + ASSERT(signaling_thread()->IsCurrent()); + if (!voice_channel_) { + LOG(LS_ERROR) << "CanInsertDtmf: No audio channel exists."; + return false; + } + uint32_t send_ssrc = 0; + // The Dtmf is negotiated per channel not ssrc, so we only check if the ssrc + // exists. + if (!local_desc_ || + !GetAudioSsrcByTrackId(local_desc_->description(), track_id, + &send_ssrc)) { + LOG(LS_ERROR) << "CanInsertDtmf: Track does not exist: " << track_id; + return false; + } + return voice_channel_->CanInsertDtmf(); +} + +bool WebRtcSession::InsertDtmf(const std::string& track_id, + int code, int duration) { + ASSERT(signaling_thread()->IsCurrent()); + if (!voice_channel_) { + LOG(LS_ERROR) << "InsertDtmf: No audio channel exists."; + return false; + } + uint32_t send_ssrc = 0; + if (!VERIFY(local_desc_ && GetAudioSsrcByTrackId(local_desc_->description(), + track_id, &send_ssrc))) { + LOG(LS_ERROR) << "InsertDtmf: Track does not exist: " << track_id; + return false; + } + if (!voice_channel_->InsertDtmf(send_ssrc, code, duration, + cricket::DF_SEND)) { + LOG(LS_ERROR) << "Failed to insert DTMF to channel."; + return false; + } + return true; +} + +sigslot::signal0<>* WebRtcSession::GetOnDestroyedSignal() { + return &SignalVoiceChannelDestroyed; +} + +bool WebRtcSession::SendData(const cricket::SendDataParams& params, + const rtc::Buffer& payload, + cricket::SendDataResult* result) { + if (!data_channel_) { + LOG(LS_ERROR) << "SendData called when data_channel_ is NULL."; + return false; + } + return data_channel_->SendData(params, payload, result); +} + +bool WebRtcSession::ConnectDataChannel(DataChannel* webrtc_data_channel) { + if (!data_channel_) { + LOG(LS_ERROR) << "ConnectDataChannel called when data_channel_ is NULL."; + return false; + } + data_channel_->SignalReadyToSendData.connect(webrtc_data_channel, + &DataChannel::OnChannelReady); + data_channel_->SignalDataReceived.connect(webrtc_data_channel, + &DataChannel::OnDataReceived); + data_channel_->SignalStreamClosedRemotely.connect( + webrtc_data_channel, &DataChannel::OnStreamClosedRemotely); + return true; +} + +void WebRtcSession::DisconnectDataChannel(DataChannel* webrtc_data_channel) { + if (!data_channel_) { + LOG(LS_ERROR) << "DisconnectDataChannel called when data_channel_ is NULL."; + return; + } + data_channel_->SignalReadyToSendData.disconnect(webrtc_data_channel); + data_channel_->SignalDataReceived.disconnect(webrtc_data_channel); + data_channel_->SignalStreamClosedRemotely.disconnect(webrtc_data_channel); +} + +void WebRtcSession::AddSctpDataStream(int sid) { + if (!data_channel_) { + LOG(LS_ERROR) << "AddDataChannelStreams called when data_channel_ is NULL."; + return; + } + data_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(sid)); + data_channel_->AddSendStream(cricket::StreamParams::CreateLegacy(sid)); +} + +void WebRtcSession::RemoveSctpDataStream(int sid) { + if (!data_channel_) { + LOG(LS_ERROR) << "RemoveDataChannelStreams called when data_channel_ is " + << "NULL."; + return; + } + data_channel_->RemoveRecvStream(sid); + data_channel_->RemoveSendStream(sid); +} + +bool WebRtcSession::ReadyToSendData() const { + return data_channel_ && data_channel_->ready_to_send_data(); +} + +cricket::DataChannelType WebRtcSession::data_channel_type() const { + return data_channel_type_; +} + +bool WebRtcSession::IceRestartPending() const { + return ice_restart_latch_->Get(); +} + +void WebRtcSession::ResetIceRestartLatch() { + ice_restart_latch_->Reset(); +} + +void WebRtcSession::OnCertificateReady( + const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) { + transport_controller_->SetLocalCertificate(certificate); +} + +bool WebRtcSession::waiting_for_certificate_for_testing() const { + return webrtc_session_desc_factory_->waiting_for_certificate_for_testing(); +} + +const rtc::scoped_refptr<rtc::RTCCertificate>& +WebRtcSession::certificate_for_testing() { + return transport_controller_->certificate_for_testing(); +} + +void WebRtcSession::SetIceConnectionState( + PeerConnectionInterface::IceConnectionState state) { + if (ice_connection_state_ == state) { + return; + } + + // ASSERT that the requested transition is allowed. Note that + // WebRtcSession does not implement "kIceConnectionClosed" (that is handled + // within PeerConnection). This switch statement should compile away when + // ASSERTs are disabled. + LOG(LS_INFO) << "Changing IceConnectionState " << ice_connection_state_ + << " => " << state; + switch (ice_connection_state_) { + case PeerConnectionInterface::kIceConnectionNew: + ASSERT(state == PeerConnectionInterface::kIceConnectionChecking); + break; + case PeerConnectionInterface::kIceConnectionChecking: + ASSERT(state == PeerConnectionInterface::kIceConnectionFailed || + state == PeerConnectionInterface::kIceConnectionConnected); + break; + case PeerConnectionInterface::kIceConnectionConnected: + ASSERT(state == PeerConnectionInterface::kIceConnectionDisconnected || + state == PeerConnectionInterface::kIceConnectionChecking || + state == PeerConnectionInterface::kIceConnectionCompleted); + break; + case PeerConnectionInterface::kIceConnectionCompleted: + ASSERT(state == PeerConnectionInterface::kIceConnectionConnected || + state == PeerConnectionInterface::kIceConnectionDisconnected); + break; + case PeerConnectionInterface::kIceConnectionFailed: + ASSERT(state == PeerConnectionInterface::kIceConnectionNew); + break; + case PeerConnectionInterface::kIceConnectionDisconnected: + ASSERT(state == PeerConnectionInterface::kIceConnectionChecking || + state == PeerConnectionInterface::kIceConnectionConnected || + state == PeerConnectionInterface::kIceConnectionCompleted || + state == PeerConnectionInterface::kIceConnectionFailed); + break; + case PeerConnectionInterface::kIceConnectionClosed: + ASSERT(false); + break; + default: + ASSERT(false); + break; + } + + ice_connection_state_ = state; + if (ice_observer_) { + ice_observer_->OnIceConnectionChange(ice_connection_state_); + } +} + +void WebRtcSession::OnTransportControllerConnectionState( + cricket::IceConnectionState state) { + switch (state) { + case cricket::kIceConnectionConnecting: + // If the current state is Connected or Completed, then there were + // writable channels but now there are not, so the next state must + // be Disconnected. + // kIceConnectionConnecting is currently used as the default, + // un-connected state by the TransportController, so its only use is + // detecting disconnections. + if (ice_connection_state_ == + PeerConnectionInterface::kIceConnectionConnected || + ice_connection_state_ == + PeerConnectionInterface::kIceConnectionCompleted) { + SetIceConnectionState( + PeerConnectionInterface::kIceConnectionDisconnected); + } + break; + case cricket::kIceConnectionFailed: + SetIceConnectionState(PeerConnectionInterface::kIceConnectionFailed); + break; + case cricket::kIceConnectionConnected: + LOG(LS_INFO) << "Changing to ICE connected state because " + << "all transports are writable."; + SetIceConnectionState(PeerConnectionInterface::kIceConnectionConnected); + break; + case cricket::kIceConnectionCompleted: + LOG(LS_INFO) << "Changing to ICE completed state because " + << "all transports are complete."; + if (ice_connection_state_ != + PeerConnectionInterface::kIceConnectionConnected) { + // If jumping directly from "checking" to "connected", + // signal "connected" first. + SetIceConnectionState(PeerConnectionInterface::kIceConnectionConnected); + } + SetIceConnectionState(PeerConnectionInterface::kIceConnectionCompleted); + if (metrics_observer_) { + ReportTransportStats(); + } + break; + default: + ASSERT(false); + } +} + +void WebRtcSession::OnTransportControllerReceiving(bool receiving) { + SetIceConnectionReceiving(receiving); +} + +void WebRtcSession::SetIceConnectionReceiving(bool receiving) { + if (ice_connection_receiving_ == receiving) { + return; + } + ice_connection_receiving_ = receiving; + if (ice_observer_) { + ice_observer_->OnIceConnectionReceivingChange(receiving); + } +} + +void WebRtcSession::OnTransportControllerCandidatesGathered( + const std::string& transport_name, + const cricket::Candidates& candidates) { + ASSERT(signaling_thread()->IsCurrent()); + int sdp_mline_index; + if (!GetLocalCandidateMediaIndex(transport_name, &sdp_mline_index)) { + LOG(LS_ERROR) << "OnTransportControllerCandidatesGathered: content name " + << transport_name << " not found"; + return; + } + + for (cricket::Candidates::const_iterator citer = candidates.begin(); + citer != candidates.end(); ++citer) { + // Use transport_name as the candidate media id. + JsepIceCandidate candidate(transport_name, sdp_mline_index, *citer); + if (ice_observer_) { + ice_observer_->OnIceCandidate(&candidate); + } + if (local_desc_) { + local_desc_->AddCandidate(&candidate); + } + } +} + +// Enabling voice and video channel. +void WebRtcSession::EnableChannels() { + if (voice_channel_ && !voice_channel_->enabled()) + voice_channel_->Enable(true); + + if (video_channel_ && !video_channel_->enabled()) + video_channel_->Enable(true); + + if (data_channel_ && !data_channel_->enabled()) + data_channel_->Enable(true); +} + +// Returns the media index for a local ice candidate given the content name. +bool WebRtcSession::GetLocalCandidateMediaIndex(const std::string& content_name, + int* sdp_mline_index) { + if (!local_desc_ || !sdp_mline_index) { + return false; + } + + bool content_found = false; + const ContentInfos& contents = local_desc_->description()->contents(); + for (size_t index = 0; index < contents.size(); ++index) { + if (contents[index].name == content_name) { + *sdp_mline_index = static_cast<int>(index); + content_found = true; + break; + } + } + return content_found; +} + +bool WebRtcSession::UseCandidatesInSessionDescription( + const SessionDescriptionInterface* remote_desc) { + if (!remote_desc) { + return true; + } + bool ret = true; + + for (size_t m = 0; m < remote_desc->number_of_mediasections(); ++m) { + const IceCandidateCollection* candidates = remote_desc->candidates(m); + for (size_t n = 0; n < candidates->count(); ++n) { + const IceCandidateInterface* candidate = candidates->at(n); + bool valid = false; + if (!ReadyToUseRemoteCandidate(candidate, remote_desc, &valid)) { + if (valid) { + LOG(LS_INFO) << "UseCandidatesInSessionDescription: Not ready to use " + << "candidate."; + } + continue; + } + ret = UseCandidate(candidate); + if (!ret) { + break; + } + } + } + return ret; +} + +bool WebRtcSession::UseCandidate( + const IceCandidateInterface* candidate) { + + size_t mediacontent_index = static_cast<size_t>(candidate->sdp_mline_index()); + size_t remote_content_size = remote_desc_->description()->contents().size(); + if (mediacontent_index >= remote_content_size) { + LOG(LS_ERROR) + << "UseRemoteCandidateInSession: Invalid candidate media index."; + return false; + } + + cricket::ContentInfo content = + remote_desc_->description()->contents()[mediacontent_index]; + std::vector<cricket::Candidate> candidates; + candidates.push_back(candidate->candidate()); + // Invoking BaseSession method to handle remote candidates. + std::string error; + if (transport_controller_->AddRemoteCandidates(content.name, candidates, + &error)) { + // Candidates successfully submitted for checking. + if (ice_connection_state_ == PeerConnectionInterface::kIceConnectionNew || + ice_connection_state_ == + PeerConnectionInterface::kIceConnectionDisconnected) { + // If state is New, then the session has just gotten its first remote ICE + // candidates, so go to Checking. + // If state is Disconnected, the session is re-using old candidates or + // receiving additional ones, so go to Checking. + // If state is Connected, stay Connected. + // TODO(bemasc): If state is Connected, and the new candidates are for a + // newly added transport, then the state actually _should_ move to + // checking. Add a way to distinguish that case. + SetIceConnectionState(PeerConnectionInterface::kIceConnectionChecking); + } + // TODO(bemasc): If state is Completed, go back to Connected. + } else { + if (!error.empty()) { + LOG(LS_WARNING) << error; + } + } + return true; +} + +void WebRtcSession::RemoveUnusedChannels(const SessionDescription* desc) { + // Destroy video_channel_ first since it may have a pointer to the + // voice_channel_. + const cricket::ContentInfo* video_info = + cricket::GetFirstVideoContent(desc); + if ((!video_info || video_info->rejected) && video_channel_) { + SignalVideoChannelDestroyed(); + const std::string content_name = video_channel_->content_name(); + channel_manager_->DestroyVideoChannel(video_channel_.release()); + } + + const cricket::ContentInfo* voice_info = + cricket::GetFirstAudioContent(desc); + if ((!voice_info || voice_info->rejected) && voice_channel_) { + SignalVoiceChannelDestroyed(); + const std::string content_name = voice_channel_->content_name(); + channel_manager_->DestroyVoiceChannel(voice_channel_.release()); + } + + const cricket::ContentInfo* data_info = + cricket::GetFirstDataContent(desc); + if ((!data_info || data_info->rejected) && data_channel_) { + SignalDataChannelDestroyed(); + const std::string content_name = data_channel_->content_name(); + channel_manager_->DestroyDataChannel(data_channel_.release()); + } +} + +// TODO(mallinath) - Add a correct error code if the channels are not created +// due to BUNDLE is enabled but rtcp-mux is disabled. +bool WebRtcSession::CreateChannels(const SessionDescription* desc) { + // Creating the media channels and transport proxies. + const cricket::ContentInfo* voice = cricket::GetFirstAudioContent(desc); + if (voice && !voice->rejected && !voice_channel_) { + if (!CreateVoiceChannel(voice)) { + LOG(LS_ERROR) << "Failed to create voice channel."; + return false; + } + } + + const cricket::ContentInfo* video = cricket::GetFirstVideoContent(desc); + if (video && !video->rejected && !video_channel_) { + if (!CreateVideoChannel(video)) { + LOG(LS_ERROR) << "Failed to create video channel."; + return false; + } + } + + const cricket::ContentInfo* data = cricket::GetFirstDataContent(desc); + if (data_channel_type_ != cricket::DCT_NONE && + data && !data->rejected && !data_channel_) { + if (!CreateDataChannel(data)) { + LOG(LS_ERROR) << "Failed to create data channel."; + return false; + } + } + + if (rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire) { + if (voice_channel()) { + voice_channel()->ActivateRtcpMux(); + } + if (video_channel()) { + video_channel()->ActivateRtcpMux(); + } + if (data_channel()) { + data_channel()->ActivateRtcpMux(); + } + } + + // Enable BUNDLE immediately when kBundlePolicyMaxBundle is in effect. + if (bundle_policy_ == PeerConnectionInterface::kBundlePolicyMaxBundle) { + const cricket::ContentGroup* bundle_group = desc->GetGroupByName( + cricket::GROUP_TYPE_BUNDLE); + if (!bundle_group) { + LOG(LS_WARNING) << "max-bundle specified without BUNDLE specified"; + return false; + } + if (!EnableBundle(*bundle_group)) { + LOG(LS_WARNING) << "max-bundle failed to enable bundling."; + return false; + } + } + + return true; +} + +bool WebRtcSession::CreateVoiceChannel(const cricket::ContentInfo* content) { + voice_channel_.reset(channel_manager_->CreateVoiceChannel( + media_controller_, transport_controller_.get(), content->name, true, + audio_options_)); + if (!voice_channel_) { + return false; + } + + voice_channel_->SignalDtlsSetupFailure.connect( + this, &WebRtcSession::OnDtlsSetupFailure); + + SignalVoiceChannelCreated(); + voice_channel_->transport_channel()->SignalSentPacket.connect( + this, &WebRtcSession::OnSentPacket_w); + return true; +} + +bool WebRtcSession::CreateVideoChannel(const cricket::ContentInfo* content) { + video_channel_.reset(channel_manager_->CreateVideoChannel( + media_controller_, transport_controller_.get(), content->name, true, + video_options_)); + if (!video_channel_) { + return false; + } + + video_channel_->SignalDtlsSetupFailure.connect( + this, &WebRtcSession::OnDtlsSetupFailure); + + SignalVideoChannelCreated(); + video_channel_->transport_channel()->SignalSentPacket.connect( + this, &WebRtcSession::OnSentPacket_w); + return true; +} + +bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content) { + bool sctp = (data_channel_type_ == cricket::DCT_SCTP); + data_channel_.reset(channel_manager_->CreateDataChannel( + transport_controller_.get(), content->name, !sctp, data_channel_type_)); + if (!data_channel_) { + return false; + } + + if (sctp) { + data_channel_->SignalDataReceived.connect( + this, &WebRtcSession::OnDataChannelMessageReceived); + } + + data_channel_->SignalDtlsSetupFailure.connect( + this, &WebRtcSession::OnDtlsSetupFailure); + + SignalDataChannelCreated(); + data_channel_->transport_channel()->SignalSentPacket.connect( + this, &WebRtcSession::OnSentPacket_w); + return true; +} + +void WebRtcSession::OnDtlsSetupFailure(cricket::BaseChannel*, bool rtcp) { + SetError(ERROR_TRANSPORT, + rtcp ? kDtlsSetupFailureRtcp : kDtlsSetupFailureRtp); +} + +void WebRtcSession::OnDataChannelMessageReceived( + cricket::DataChannel* channel, + const cricket::ReceiveDataParams& params, + const rtc::Buffer& payload) { + RTC_DCHECK(data_channel_type_ == cricket::DCT_SCTP); + if (params.type == cricket::DMT_CONTROL && IsOpenMessage(payload)) { + // Received OPEN message; parse and signal that a new data channel should + // be created. + std::string label; + InternalDataChannelInit config; + config.id = params.ssrc; + if (!ParseDataChannelOpenMessage(payload, &label, &config)) { + LOG(LS_WARNING) << "Failed to parse the OPEN message for sid " + << params.ssrc; + return; + } + config.open_handshake_role = InternalDataChannelInit::kAcker; + SignalDataChannelOpenMessage(label, config); + } + // Otherwise ignore the message. +} + +// Returns false if bundle is enabled and rtcp_mux is disabled. +bool WebRtcSession::ValidateBundleSettings(const SessionDescription* desc) { + bool bundle_enabled = desc->HasGroup(cricket::GROUP_TYPE_BUNDLE); + if (!bundle_enabled) + return true; + + const cricket::ContentGroup* bundle_group = + desc->GetGroupByName(cricket::GROUP_TYPE_BUNDLE); + ASSERT(bundle_group != NULL); + + const cricket::ContentInfos& contents = desc->contents(); + for (cricket::ContentInfos::const_iterator citer = contents.begin(); + citer != contents.end(); ++citer) { + const cricket::ContentInfo* content = (&*citer); + ASSERT(content != NULL); + if (bundle_group->HasContentName(content->name) && + !content->rejected && content->type == cricket::NS_JINGLE_RTP) { + if (!HasRtcpMuxEnabled(content)) + return false; + } + } + // RTCP-MUX is enabled in all the contents. + return true; +} + +bool WebRtcSession::HasRtcpMuxEnabled( + const cricket::ContentInfo* content) { + const cricket::MediaContentDescription* description = + static_cast<cricket::MediaContentDescription*>(content->description); + return description->rtcp_mux(); +} + +bool WebRtcSession::ValidateSessionDescription( + const SessionDescriptionInterface* sdesc, + cricket::ContentSource source, std::string* err_desc) { + std::string type; + if (error() != ERROR_NONE) { + return BadSdp(source, type, GetSessionErrorMsg(), err_desc); + } + + if (!sdesc || !sdesc->description()) { + return BadSdp(source, type, kInvalidSdp, err_desc); + } + + type = sdesc->type(); + Action action = GetAction(sdesc->type()); + if (source == cricket::CS_LOCAL) { + if (!ExpectSetLocalDescription(action)) + return BadLocalSdp(type, BadStateErrMsg(state()), err_desc); + } else { + if (!ExpectSetRemoteDescription(action)) + return BadRemoteSdp(type, BadStateErrMsg(state()), err_desc); + } + + // Verify crypto settings. + std::string crypto_error; + if ((webrtc_session_desc_factory_->SdesPolicy() == cricket::SEC_REQUIRED || + dtls_enabled_) && + !VerifyCrypto(sdesc->description(), dtls_enabled_, &crypto_error)) { + return BadSdp(source, type, crypto_error, err_desc); + } + + // Verify ice-ufrag and ice-pwd. + if (!VerifyIceUfragPwdPresent(sdesc->description())) { + return BadSdp(source, type, kSdpWithoutIceUfragPwd, err_desc); + } + + if (!ValidateBundleSettings(sdesc->description())) { + return BadSdp(source, type, kBundleWithoutRtcpMux, err_desc); + } + + // Verify m-lines in Answer when compared against Offer. + if (action == kAnswer) { + const cricket::SessionDescription* offer_desc = + (source == cricket::CS_LOCAL) ? remote_desc_->description() + : local_desc_->description(); + if (!VerifyMediaDescriptions(sdesc->description(), offer_desc)) { + return BadAnswerSdp(source, kMlineMismatch, err_desc); + } + } + + return true; +} + +bool WebRtcSession::ExpectSetLocalDescription(Action action) { + return ((action == kOffer && state() == STATE_INIT) || + // update local offer + (action == kOffer && state() == STATE_SENTOFFER) || + // update the current ongoing session. + (action == kOffer && state() == STATE_INPROGRESS) || + // accept remote offer + (action == kAnswer && state() == STATE_RECEIVEDOFFER) || + (action == kAnswer && state() == STATE_SENTPRANSWER) || + (action == kPrAnswer && state() == STATE_RECEIVEDOFFER) || + (action == kPrAnswer && state() == STATE_SENTPRANSWER)); +} + +bool WebRtcSession::ExpectSetRemoteDescription(Action action) { + return ((action == kOffer && state() == STATE_INIT) || + // update remote offer + (action == kOffer && state() == STATE_RECEIVEDOFFER) || + // update the current ongoing session + (action == kOffer && state() == STATE_INPROGRESS) || + // accept local offer + (action == kAnswer && state() == STATE_SENTOFFER) || + (action == kAnswer && state() == STATE_RECEIVEDPRANSWER) || + (action == kPrAnswer && state() == STATE_SENTOFFER) || + (action == kPrAnswer && state() == STATE_RECEIVEDPRANSWER)); +} + +std::string WebRtcSession::GetSessionErrorMsg() { + std::ostringstream desc; + desc << kSessionError << GetErrorCodeString(error()) << ". "; + desc << kSessionErrorDesc << error_desc() << "."; + return desc.str(); +} + +// We need to check the local/remote description for the Transport instead of +// the session, because a new Transport added during renegotiation may have +// them unset while the session has them set from the previous negotiation. +// Not doing so may trigger the auto generation of transport description and +// mess up DTLS identity information, ICE credential, etc. +bool WebRtcSession::ReadyToUseRemoteCandidate( + const IceCandidateInterface* candidate, + const SessionDescriptionInterface* remote_desc, + bool* valid) { + *valid = true;; + + const SessionDescriptionInterface* current_remote_desc = + remote_desc ? remote_desc : remote_desc_.get(); + + if (!current_remote_desc) { + return false; + } + + size_t mediacontent_index = + static_cast<size_t>(candidate->sdp_mline_index()); + size_t remote_content_size = + current_remote_desc->description()->contents().size(); + if (mediacontent_index >= remote_content_size) { + LOG(LS_ERROR) + << "ReadyToUseRemoteCandidate: Invalid candidate media index."; + + *valid = false; + return false; + } + + cricket::ContentInfo content = + current_remote_desc->description()->contents()[mediacontent_index]; + cricket::BaseChannel* channel = GetChannel(content.name); + if (!channel) { + return false; + } + + return transport_controller_->ReadyForRemoteCandidates( + channel->transport_name()); +} + +void WebRtcSession::OnTransportControllerGatheringState( + cricket::IceGatheringState state) { + ASSERT(signaling_thread()->IsCurrent()); + if (state == cricket::kIceGatheringGathering) { + if (ice_observer_) { + ice_observer_->OnIceGatheringChange( + PeerConnectionInterface::kIceGatheringGathering); + } + } else if (state == cricket::kIceGatheringComplete) { + if (ice_observer_) { + ice_observer_->OnIceGatheringChange( + PeerConnectionInterface::kIceGatheringComplete); + ice_observer_->OnIceComplete(); + } + } +} + +void WebRtcSession::ReportTransportStats() { + // Use a set so we don't report the same stats twice if two channels share + // a transport. + std::set<std::string> transport_names; + if (voice_channel()) { + transport_names.insert(voice_channel()->transport_name()); + } + if (video_channel()) { + transport_names.insert(video_channel()->transport_name()); + } + if (data_channel()) { + transport_names.insert(data_channel()->transport_name()); + } + for (const auto& name : transport_names) { + cricket::TransportStats stats; + if (transport_controller_->GetStats(name, &stats)) { + ReportBestConnectionState(stats); + ReportNegotiatedCiphers(stats); + } + } +} +// Walk through the ConnectionInfos to gather best connection usage +// for IPv4 and IPv6. +void WebRtcSession::ReportBestConnectionState( + const cricket::TransportStats& stats) { + RTC_DCHECK(metrics_observer_ != NULL); + for (cricket::TransportChannelStatsList::const_iterator it = + stats.channel_stats.begin(); + it != stats.channel_stats.end(); ++it) { + for (cricket::ConnectionInfos::const_iterator it_info = + it->connection_infos.begin(); + it_info != it->connection_infos.end(); ++it_info) { + if (!it_info->best_connection) { + continue; + } + + PeerConnectionEnumCounterType type = kPeerConnectionEnumCounterMax; + const cricket::Candidate& local = it_info->local_candidate; + const cricket::Candidate& remote = it_info->remote_candidate; + + // Increment the counter for IceCandidatePairType. + if (local.protocol() == cricket::TCP_PROTOCOL_NAME || + (local.type() == RELAY_PORT_TYPE && + local.relay_protocol() == cricket::TCP_PROTOCOL_NAME)) { + type = kEnumCounterIceCandidatePairTypeTcp; + } else if (local.protocol() == cricket::UDP_PROTOCOL_NAME) { + type = kEnumCounterIceCandidatePairTypeUdp; + } else { + RTC_CHECK(0); + } + metrics_observer_->IncrementEnumCounter( + type, GetIceCandidatePairCounter(local, remote), + kIceCandidatePairMax); + + // Increment the counter for IP type. + if (local.address().family() == AF_INET) { + metrics_observer_->IncrementEnumCounter( + kEnumCounterAddressFamily, kBestConnections_IPv4, + kPeerConnectionAddressFamilyCounter_Max); + + } else if (local.address().family() == AF_INET6) { + metrics_observer_->IncrementEnumCounter( + kEnumCounterAddressFamily, kBestConnections_IPv6, + kPeerConnectionAddressFamilyCounter_Max); + } else { + RTC_CHECK(0); + } + + return; + } + } +} + +void WebRtcSession::ReportNegotiatedCiphers( + const cricket::TransportStats& stats) { + RTC_DCHECK(metrics_observer_ != NULL); + if (!dtls_enabled_ || stats.channel_stats.empty()) { + return; + } + + const std::string& srtp_cipher = stats.channel_stats[0].srtp_cipher; + int ssl_cipher = stats.channel_stats[0].ssl_cipher; + if (srtp_cipher.empty() && !ssl_cipher) { + return; + } + + PeerConnectionEnumCounterType srtp_counter_type; + PeerConnectionEnumCounterType ssl_counter_type; + if (stats.transport_name == cricket::CN_AUDIO) { + srtp_counter_type = kEnumCounterAudioSrtpCipher; + ssl_counter_type = kEnumCounterAudioSslCipher; + } else if (stats.transport_name == cricket::CN_VIDEO) { + srtp_counter_type = kEnumCounterVideoSrtpCipher; + ssl_counter_type = kEnumCounterVideoSslCipher; + } else if (stats.transport_name == cricket::CN_DATA) { + srtp_counter_type = kEnumCounterDataSrtpCipher; + ssl_counter_type = kEnumCounterDataSslCipher; + } else { + RTC_NOTREACHED(); + return; + } + + if (!srtp_cipher.empty()) { + metrics_observer_->IncrementSparseEnumCounter( + srtp_counter_type, rtc::GetSrtpCryptoSuiteFromName(srtp_cipher)); + } + if (ssl_cipher) { + metrics_observer_->IncrementSparseEnumCounter(ssl_counter_type, ssl_cipher); + } +} + +void WebRtcSession::OnSentPacket_w(cricket::TransportChannel* channel, + const rtc::SentPacket& sent_packet) { + RTC_DCHECK(worker_thread()->IsCurrent()); + media_controller_->call_w()->OnSentPacket(sent_packet); +} + +} // namespace webrtc |