/* * libjingle * Copyright 2013 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/test/peerconnectiontestwrapper.h" #include "talk/app/webrtc/test/mockpeerconnectionobservers.h" #include "webrtc/base/gunit.h" #include "webrtc/base/logging.h" #include "webrtc/base/ssladapter.h" #include "webrtc/base/sslstreamadapter.h" #include "webrtc/base/stringencode.h" #include "webrtc/base/stringutils.h" #define MAYBE_SKIP_TEST(feature) \ if (!(feature())) { \ LOG(LS_INFO) << "Feature disabled... skipping"; \ return; \ } using webrtc::DataChannelInterface; using webrtc::FakeConstraints; using webrtc::MediaConstraintsInterface; using webrtc::MediaStreamInterface; using webrtc::PeerConnectionInterface; namespace { const char kExternalGiceUfrag[] = "1234567890123456"; const char kExternalGicePwd[] = "123456789012345678901234"; const size_t kMaxWait = 10000; void RemoveLinesFromSdp(const std::string& line_start, std::string* sdp) { const char kSdpLineEnd[] = "\r\n"; size_t ssrc_pos = 0; while ((ssrc_pos = sdp->find(line_start, ssrc_pos)) != std::string::npos) { size_t end_ssrc = sdp->find(kSdpLineEnd, ssrc_pos); sdp->erase(ssrc_pos, end_ssrc - ssrc_pos + strlen(kSdpLineEnd)); } } // Add |newlines| to the |message| after |line|. void InjectAfter(const std::string& line, const std::string& newlines, std::string* message) { const std::string tmp = line + newlines; rtc::replace_substrs(line.c_str(), line.length(), tmp.c_str(), tmp.length(), message); } void Replace(const std::string& line, const std::string& newlines, std::string* message) { rtc::replace_substrs(line.c_str(), line.length(), newlines.c_str(), newlines.length(), message); } void UseExternalSdes(std::string* sdp) { // Remove current crypto specification. RemoveLinesFromSdp("a=crypto", sdp); RemoveLinesFromSdp("a=fingerprint", sdp); // Add external crypto. const char kAudioSdes[] = "a=crypto:1 AES_CM_128_HMAC_SHA1_80 " "inline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR\r\n"; const char kVideoSdes[] = "a=crypto:1 AES_CM_128_HMAC_SHA1_80 " "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj\r\n"; const char kDataSdes[] = "a=crypto:1 AES_CM_128_HMAC_SHA1_80 " "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj\r\n"; InjectAfter("a=mid:audio\r\n", kAudioSdes, sdp); InjectAfter("a=mid:video\r\n", kVideoSdes, sdp); InjectAfter("a=mid:data\r\n", kDataSdes, sdp); } void UseGice(std::string* sdp) { InjectAfter("t=0 0\r\n", "a=ice-options:google-ice\r\n", sdp); std::string ufragline = "a=ice-ufrag:"; std::string pwdline = "a=ice-pwd:"; RemoveLinesFromSdp(ufragline, sdp); RemoveLinesFromSdp(pwdline, sdp); ufragline.append(kExternalGiceUfrag); ufragline.append("\r\n"); pwdline.append(kExternalGicePwd); pwdline.append("\r\n"); const std::string ufrag_pwd = ufragline + pwdline; InjectAfter("a=mid:audio\r\n", ufrag_pwd, sdp); InjectAfter("a=mid:video\r\n", ufrag_pwd, sdp); InjectAfter("a=mid:data\r\n", ufrag_pwd, sdp); } void RemoveBundle(std::string* sdp) { RemoveLinesFromSdp("a=group:BUNDLE", sdp); } } // namespace class PeerConnectionEndToEndTest : public sigslot::has_slots<>, public testing::Test { public: typedef std::vector > DataChannelList; PeerConnectionEndToEndTest() : caller_(new rtc::RefCountedObject( "caller")), callee_(new rtc::RefCountedObject( "callee")) { } void CreatePcs() { CreatePcs(NULL); } void CreatePcs(const MediaConstraintsInterface* pc_constraints) { EXPECT_TRUE(caller_->CreatePc(pc_constraints)); EXPECT_TRUE(callee_->CreatePc(pc_constraints)); PeerConnectionTestWrapper::Connect(caller_.get(), callee_.get()); caller_->SignalOnDataChannel.connect( this, &PeerConnectionEndToEndTest::OnCallerAddedDataChanel); callee_->SignalOnDataChannel.connect( this, &PeerConnectionEndToEndTest::OnCalleeAddedDataChannel); } void GetAndAddUserMedia() { FakeConstraints audio_constraints; FakeConstraints video_constraints; GetAndAddUserMedia(true, audio_constraints, true, video_constraints); } void GetAndAddUserMedia(bool audio, FakeConstraints audio_constraints, bool video, FakeConstraints video_constraints) { caller_->GetAndAddUserMedia(audio, audio_constraints, video, video_constraints); callee_->GetAndAddUserMedia(audio, audio_constraints, video, video_constraints); } void Negotiate() { caller_->CreateOffer(NULL); } void WaitForCallEstablished() { caller_->WaitForCallEstablished(); callee_->WaitForCallEstablished(); } void WaitForConnection() { caller_->WaitForConnection(); callee_->WaitForConnection(); } void SetupLegacySdpConverter() { caller_->SignalOnSdpCreated.connect( this, &PeerConnectionEndToEndTest::ConvertToLegacySdp); callee_->SignalOnSdpCreated.connect( this, &PeerConnectionEndToEndTest::ConvertToLegacySdp); } void ConvertToLegacySdp(std::string* sdp) { UseExternalSdes(sdp); UseGice(sdp); RemoveBundle(sdp); LOG(LS_INFO) << "ConvertToLegacySdp: " << *sdp; } void SetupGiceConverter() { caller_->SignalOnIceCandidateCreated.connect( this, &PeerConnectionEndToEndTest::AddGiceCredsToCandidate); callee_->SignalOnIceCandidateCreated.connect( this, &PeerConnectionEndToEndTest::AddGiceCredsToCandidate); } void AddGiceCredsToCandidate(std::string* sdp) { std::string gice_creds = " username "; gice_creds.append(kExternalGiceUfrag); gice_creds.append(" password "); gice_creds.append(kExternalGicePwd); gice_creds.append("\r\n"); Replace("\r\n", gice_creds, sdp); LOG(LS_INFO) << "AddGiceCredsToCandidate: " << *sdp; } void OnCallerAddedDataChanel(DataChannelInterface* dc) { caller_signaled_data_channels_.push_back(dc); } void OnCalleeAddedDataChannel(DataChannelInterface* dc) { callee_signaled_data_channels_.push_back(dc); } // Tests that |dc1| and |dc2| can send to and receive from each other. void TestDataChannelSendAndReceive( DataChannelInterface* dc1, DataChannelInterface* dc2) { rtc::scoped_ptr dc1_observer( new webrtc::MockDataChannelObserver(dc1)); rtc::scoped_ptr dc2_observer( new webrtc::MockDataChannelObserver(dc2)); static const std::string kDummyData = "abcdefg"; webrtc::DataBuffer buffer(kDummyData); EXPECT_TRUE(dc1->Send(buffer)); EXPECT_EQ_WAIT(kDummyData, dc2_observer->last_message(), kMaxWait); EXPECT_TRUE(dc2->Send(buffer)); EXPECT_EQ_WAIT(kDummyData, dc1_observer->last_message(), kMaxWait); EXPECT_EQ(1U, dc1_observer->received_message_count()); EXPECT_EQ(1U, dc2_observer->received_message_count()); } void WaitForDataChannelsToOpen(DataChannelInterface* local_dc, const DataChannelList& remote_dc_list, size_t remote_dc_index) { EXPECT_EQ_WAIT(DataChannelInterface::kOpen, local_dc->state(), kMaxWait); EXPECT_TRUE_WAIT(remote_dc_list.size() > remote_dc_index, kMaxWait); EXPECT_EQ_WAIT(DataChannelInterface::kOpen, remote_dc_list[remote_dc_index]->state(), kMaxWait); EXPECT_EQ(local_dc->id(), remote_dc_list[remote_dc_index]->id()); } void CloseDataChannels(DataChannelInterface* local_dc, const DataChannelList& remote_dc_list, size_t remote_dc_index) { local_dc->Close(); EXPECT_EQ_WAIT(DataChannelInterface::kClosed, local_dc->state(), kMaxWait); EXPECT_EQ_WAIT(DataChannelInterface::kClosed, remote_dc_list[remote_dc_index]->state(), kMaxWait); } protected: rtc::scoped_refptr caller_; rtc::scoped_refptr callee_; DataChannelList caller_signaled_data_channels_; DataChannelList callee_signaled_data_channels_; }; // Disable for TSan v2, see // https://code.google.com/p/webrtc/issues/detail?id=1205 for details. #if !defined(THREAD_SANITIZER) // Flaky on Windows. Disabled per issue 4464. #ifdef WEBRTC_WIN #define MAYBE_Call DISABLED_Call #else #define MAYBE_Call Call #endif TEST_F(PeerConnectionEndToEndTest, MAYBE_Call) { CreatePcs(); GetAndAddUserMedia(); Negotiate(); WaitForCallEstablished(); } // Disabled per b/14899892 TEST_F(PeerConnectionEndToEndTest, DISABLED_CallWithLegacySdp) { FakeConstraints pc_constraints; pc_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, false); CreatePcs(&pc_constraints); SetupLegacySdpConverter(); SetupGiceConverter(); GetAndAddUserMedia(); Negotiate(); WaitForCallEstablished(); } // Verifies that a DataChannel created before the negotiation can transition to // "OPEN" and transfer data. TEST_F(PeerConnectionEndToEndTest, CreateDataChannelBeforeNegotiate) { MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); CreatePcs(); webrtc::DataChannelInit init; rtc::scoped_refptr caller_dc( caller_->CreateDataChannel("data", init)); rtc::scoped_refptr callee_dc( callee_->CreateDataChannel("data", init)); Negotiate(); WaitForConnection(); WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 0); WaitForDataChannelsToOpen(callee_dc, caller_signaled_data_channels_, 0); TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[0]); TestDataChannelSendAndReceive(callee_dc, caller_signaled_data_channels_[0]); CloseDataChannels(caller_dc, callee_signaled_data_channels_, 0); CloseDataChannels(callee_dc, caller_signaled_data_channels_, 0); } // Verifies that a DataChannel created after the negotiation can transition to // "OPEN" and transfer data. #if defined(MEMORY_SANITIZER) // Fails under MemorySanitizer: // See https://code.google.com/p/webrtc/issues/detail?id=3980. #define MAYBE_CreateDataChannelAfterNegotiate DISABLED_CreateDataChannelAfterNegotiate #else #define MAYBE_CreateDataChannelAfterNegotiate CreateDataChannelAfterNegotiate #endif TEST_F(PeerConnectionEndToEndTest, MAYBE_CreateDataChannelAfterNegotiate) { MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); CreatePcs(); webrtc::DataChannelInit init; // This DataChannel is for creating the data content in the negotiation. rtc::scoped_refptr dummy( caller_->CreateDataChannel("data", init)); Negotiate(); WaitForConnection(); // Creates new DataChannels after the negotiation and verifies their states. rtc::scoped_refptr caller_dc( caller_->CreateDataChannel("hello", init)); rtc::scoped_refptr callee_dc( callee_->CreateDataChannel("hello", init)); WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 1); WaitForDataChannelsToOpen(callee_dc, caller_signaled_data_channels_, 0); TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[1]); TestDataChannelSendAndReceive(callee_dc, caller_signaled_data_channels_[0]); CloseDataChannels(caller_dc, callee_signaled_data_channels_, 1); CloseDataChannels(callee_dc, caller_signaled_data_channels_, 0); } // Verifies that DataChannel IDs are even/odd based on the DTLS roles. TEST_F(PeerConnectionEndToEndTest, DataChannelIdAssignment) { MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); CreatePcs(); webrtc::DataChannelInit init; rtc::scoped_refptr caller_dc_1( caller_->CreateDataChannel("data", init)); rtc::scoped_refptr callee_dc_1( callee_->CreateDataChannel("data", init)); Negotiate(); WaitForConnection(); EXPECT_EQ(1U, caller_dc_1->id() % 2); EXPECT_EQ(0U, callee_dc_1->id() % 2); rtc::scoped_refptr caller_dc_2( caller_->CreateDataChannel("data", init)); rtc::scoped_refptr callee_dc_2( callee_->CreateDataChannel("data", init)); EXPECT_EQ(1U, caller_dc_2->id() % 2); EXPECT_EQ(0U, callee_dc_2->id() % 2); } // Verifies that the message is received by the right remote DataChannel when // there are multiple DataChannels. TEST_F(PeerConnectionEndToEndTest, MessageTransferBetweenTwoPairsOfDataChannels) { MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); CreatePcs(); webrtc::DataChannelInit init; rtc::scoped_refptr caller_dc_1( caller_->CreateDataChannel("data", init)); rtc::scoped_refptr caller_dc_2( caller_->CreateDataChannel("data", init)); Negotiate(); WaitForConnection(); WaitForDataChannelsToOpen(caller_dc_1, callee_signaled_data_channels_, 0); WaitForDataChannelsToOpen(caller_dc_2, callee_signaled_data_channels_, 1); rtc::scoped_ptr dc_1_observer( new webrtc::MockDataChannelObserver(callee_signaled_data_channels_[0])); rtc::scoped_ptr dc_2_observer( new webrtc::MockDataChannelObserver(callee_signaled_data_channels_[1])); const std::string message_1 = "hello 1"; const std::string message_2 = "hello 2"; caller_dc_1->Send(webrtc::DataBuffer(message_1)); EXPECT_EQ_WAIT(message_1, dc_1_observer->last_message(), kMaxWait); caller_dc_2->Send(webrtc::DataBuffer(message_2)); EXPECT_EQ_WAIT(message_2, dc_2_observer->last_message(), kMaxWait); EXPECT_EQ(1U, dc_1_observer->received_message_count()); EXPECT_EQ(1U, dc_2_observer->received_message_count()); } #endif // if !defined(THREAD_SANITIZER)