| /* |
| * Copyright 2004 The WebRTC Project Authors. All rights reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include <memory> |
| #include <string> |
| |
| #include "webrtc/p2p/base/relayserver.h" |
| #include "webrtc/rtc_base/gunit.h" |
| #include "webrtc/rtc_base/helpers.h" |
| #include "webrtc/rtc_base/logging.h" |
| #include "webrtc/rtc_base/ptr_util.h" |
| #include "webrtc/rtc_base/socketaddress.h" |
| #include "webrtc/rtc_base/ssladapter.h" |
| #include "webrtc/rtc_base/testclient.h" |
| #include "webrtc/rtc_base/thread.h" |
| #include "webrtc/rtc_base/virtualsocketserver.h" |
| |
| using rtc::SocketAddress; |
| using namespace cricket; |
| |
| static const uint32_t LIFETIME = 4; // seconds |
| static const SocketAddress server_int_addr("127.0.0.1", 5000); |
| static const SocketAddress server_ext_addr("127.0.0.1", 5001); |
| static const SocketAddress client1_addr("127.0.0.1", 6000 + (rand() % 1000)); |
| static const SocketAddress client2_addr("127.0.0.1", 7000 + (rand() % 1000)); |
| static const char* bad = "this is a completely nonsensical message whose only " |
| "purpose is to make the parser go 'ack'. it doesn't " |
| "look anything like a normal stun message"; |
| static const char* msg1 = "spamspamspamspamspamspamspambakedbeansspam"; |
| static const char* msg2 = "Lobster Thermidor a Crevette with a mornay sauce..."; |
| |
| class RelayServerTest : public testing::Test { |
| public: |
| RelayServerTest() |
| : ss_(new rtc::VirtualSocketServer()), |
| thread_(ss_.get()), |
| username_(rtc::CreateRandomString(12)), |
| password_(rtc::CreateRandomString(12)) {} |
| |
| protected: |
| virtual void SetUp() { |
| server_.reset(new RelayServer(rtc::Thread::Current())); |
| |
| server_->AddInternalSocket( |
| rtc::AsyncUDPSocket::Create(ss_.get(), server_int_addr)); |
| server_->AddExternalSocket( |
| rtc::AsyncUDPSocket::Create(ss_.get(), server_ext_addr)); |
| |
| client1_.reset(new rtc::TestClient( |
| WrapUnique(rtc::AsyncUDPSocket::Create(ss_.get(), client1_addr)))); |
| client2_.reset(new rtc::TestClient( |
| WrapUnique(rtc::AsyncUDPSocket::Create(ss_.get(), client2_addr)))); |
| } |
| |
| void Allocate() { |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST)); |
| AddUsernameAttr(req.get(), username_); |
| AddLifetimeAttr(req.get(), LIFETIME); |
| Send1(req.get()); |
| delete Receive1(); |
| } |
| void Bind() { |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST)); |
| AddUsernameAttr(req.get(), username_); |
| Send2(req.get()); |
| delete Receive1(); |
| } |
| |
| void Send1(const StunMessage* msg) { |
| rtc::ByteBufferWriter buf; |
| msg->Write(&buf); |
| SendRaw1(buf.Data(), static_cast<int>(buf.Length())); |
| } |
| void Send2(const StunMessage* msg) { |
| rtc::ByteBufferWriter buf; |
| msg->Write(&buf); |
| SendRaw2(buf.Data(), static_cast<int>(buf.Length())); |
| } |
| void SendRaw1(const char* data, int len) { |
| return Send(client1_.get(), data, len, server_int_addr); |
| } |
| void SendRaw2(const char* data, int len) { |
| return Send(client2_.get(), data, len, server_ext_addr); |
| } |
| void Send(rtc::TestClient* client, const char* data, |
| int len, const SocketAddress& addr) { |
| client->SendTo(data, len, addr); |
| } |
| |
| bool Receive1Fails() { |
| return client1_.get()->CheckNoPacket(); |
| } |
| bool Receive2Fails() { |
| return client2_.get()->CheckNoPacket(); |
| } |
| |
| StunMessage* Receive1() { |
| return Receive(client1_.get()); |
| } |
| StunMessage* Receive2() { |
| return Receive(client2_.get()); |
| } |
| std::string ReceiveRaw1() { |
| return ReceiveRaw(client1_.get()); |
| } |
| std::string ReceiveRaw2() { |
| return ReceiveRaw(client2_.get()); |
| } |
| StunMessage* Receive(rtc::TestClient* client) { |
| StunMessage* msg = NULL; |
| std::unique_ptr<rtc::TestClient::Packet> packet = |
| client->NextPacket(rtc::TestClient::kTimeoutMs); |
| if (packet) { |
| rtc::ByteBufferWriter buf(packet->buf, packet->size); |
| rtc::ByteBufferReader read_buf(buf); |
| msg = new RelayMessage(); |
| msg->Read(&read_buf); |
| } |
| return msg; |
| } |
| std::string ReceiveRaw(rtc::TestClient* client) { |
| std::string raw; |
| std::unique_ptr<rtc::TestClient::Packet> packet = |
| client->NextPacket(rtc::TestClient::kTimeoutMs); |
| if (packet) { |
| raw = std::string(packet->buf, packet->size); |
| } |
| return raw; |
| } |
| |
| static StunMessage* CreateStunMessage(int type) { |
| StunMessage* msg = new RelayMessage(); |
| msg->SetType(type); |
| msg->SetTransactionID( |
| rtc::CreateRandomString(kStunTransactionIdLength)); |
| return msg; |
| } |
| static void AddMagicCookieAttr(StunMessage* msg) { |
| auto attr = StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE); |
| attr->CopyBytes(TURN_MAGIC_COOKIE_VALUE, sizeof(TURN_MAGIC_COOKIE_VALUE)); |
| msg->AddAttribute(std::move(attr)); |
| } |
| static void AddUsernameAttr(StunMessage* msg, const std::string& val) { |
| auto attr = StunAttribute::CreateByteString(STUN_ATTR_USERNAME); |
| attr->CopyBytes(val.c_str(), val.size()); |
| msg->AddAttribute(std::move(attr)); |
| } |
| static void AddLifetimeAttr(StunMessage* msg, int val) { |
| auto attr = StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME); |
| attr->SetValue(val); |
| msg->AddAttribute(std::move(attr)); |
| } |
| static void AddDestinationAttr(StunMessage* msg, const SocketAddress& addr) { |
| auto attr = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS); |
| attr->SetIP(addr.ipaddr()); |
| attr->SetPort(addr.port()); |
| msg->AddAttribute(std::move(attr)); |
| } |
| |
| std::unique_ptr<rtc::VirtualSocketServer> ss_; |
| rtc::AutoSocketServerThread thread_; |
| std::unique_ptr<RelayServer> server_; |
| std::unique_ptr<rtc::TestClient> client1_; |
| std::unique_ptr<rtc::TestClient> client2_; |
| std::string username_; |
| std::string password_; |
| }; |
| |
| // Send a complete nonsense message and verify that it is eaten. |
| TEST_F(RelayServerTest, TestBadRequest) { |
| SendRaw1(bad, static_cast<int>(strlen(bad))); |
| ASSERT_TRUE(Receive1Fails()); |
| } |
| |
| // Send an allocate request without a username and verify it is rejected. |
| TEST_F(RelayServerTest, TestAllocateNoUsername) { |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST)), |
| res; |
| |
| Send1(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_ALLOCATE_ERROR_RESPONSE, res->type()); |
| EXPECT_EQ(req->transaction_id(), res->transaction_id()); |
| |
| const StunErrorCodeAttribute* err = res->GetErrorCode(); |
| ASSERT_TRUE(err != NULL); |
| EXPECT_EQ(4, err->eclass()); |
| EXPECT_EQ(32, err->number()); |
| EXPECT_EQ("Missing Username", err->reason()); |
| } |
| |
| // Send a binding request and verify that it is rejected. |
| TEST_F(RelayServerTest, TestBindingRequest) { |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST)), |
| res; |
| AddUsernameAttr(req.get(), username_); |
| |
| Send1(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, res->type()); |
| EXPECT_EQ(req->transaction_id(), res->transaction_id()); |
| |
| const StunErrorCodeAttribute* err = res->GetErrorCode(); |
| ASSERT_TRUE(err != NULL); |
| EXPECT_EQ(6, err->eclass()); |
| EXPECT_EQ(0, err->number()); |
| EXPECT_EQ("Operation Not Supported", err->reason()); |
| } |
| |
| // Send an allocate request and verify that it is accepted. |
| TEST_F(RelayServerTest, TestAllocate) { |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST)), |
| res; |
| AddUsernameAttr(req.get(), username_); |
| AddLifetimeAttr(req.get(), LIFETIME); |
| |
| Send1(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_ALLOCATE_RESPONSE, res->type()); |
| EXPECT_EQ(req->transaction_id(), res->transaction_id()); |
| |
| const StunAddressAttribute* mapped_addr = |
| res->GetAddress(STUN_ATTR_MAPPED_ADDRESS); |
| ASSERT_TRUE(mapped_addr != NULL); |
| EXPECT_EQ(1, mapped_addr->family()); |
| EXPECT_EQ(server_ext_addr.port(), mapped_addr->port()); |
| EXPECT_EQ(server_ext_addr.ipaddr(), mapped_addr->ipaddr()); |
| |
| const StunUInt32Attribute* res_lifetime_attr = |
| res->GetUInt32(STUN_ATTR_LIFETIME); |
| ASSERT_TRUE(res_lifetime_attr != NULL); |
| EXPECT_EQ(LIFETIME, res_lifetime_attr->value()); |
| } |
| |
| // Send a second allocate request and verify that it is also accepted, though |
| // the lifetime should be ignored. |
| TEST_F(RelayServerTest, TestReallocate) { |
| Allocate(); |
| |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST)), |
| res; |
| AddMagicCookieAttr(req.get()); |
| AddUsernameAttr(req.get(), username_); |
| |
| Send1(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_ALLOCATE_RESPONSE, res->type()); |
| EXPECT_EQ(req->transaction_id(), res->transaction_id()); |
| |
| const StunAddressAttribute* mapped_addr = |
| res->GetAddress(STUN_ATTR_MAPPED_ADDRESS); |
| ASSERT_TRUE(mapped_addr != NULL); |
| EXPECT_EQ(1, mapped_addr->family()); |
| EXPECT_EQ(server_ext_addr.port(), mapped_addr->port()); |
| EXPECT_EQ(server_ext_addr.ipaddr(), mapped_addr->ipaddr()); |
| |
| const StunUInt32Attribute* lifetime_attr = |
| res->GetUInt32(STUN_ATTR_LIFETIME); |
| ASSERT_TRUE(lifetime_attr != NULL); |
| EXPECT_EQ(LIFETIME, lifetime_attr->value()); |
| } |
| |
| // Send a request from another client and see that it arrives at the first |
| // client in the binding. |
| TEST_F(RelayServerTest, TestRemoteBind) { |
| Allocate(); |
| |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST)), |
| res; |
| AddUsernameAttr(req.get(), username_); |
| |
| Send2(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_DATA_INDICATION, res->type()); |
| |
| const StunByteStringAttribute* recv_data = |
| res->GetByteString(STUN_ATTR_DATA); |
| ASSERT_TRUE(recv_data != NULL); |
| |
| rtc::ByteBufferReader buf(recv_data->bytes(), recv_data->length()); |
| std::unique_ptr<StunMessage> res2(new StunMessage()); |
| EXPECT_TRUE(res2->Read(&buf)); |
| EXPECT_EQ(STUN_BINDING_REQUEST, res2->type()); |
| EXPECT_EQ(req->transaction_id(), res2->transaction_id()); |
| |
| const StunAddressAttribute* src_addr = |
| res->GetAddress(STUN_ATTR_SOURCE_ADDRESS2); |
| ASSERT_TRUE(src_addr != NULL); |
| EXPECT_EQ(1, src_addr->family()); |
| EXPECT_EQ(client2_addr.ipaddr(), src_addr->ipaddr()); |
| EXPECT_EQ(client2_addr.port(), src_addr->port()); |
| |
| EXPECT_TRUE(Receive2Fails()); |
| } |
| |
| // Send a complete nonsense message to the established connection and verify |
| // that it is dropped by the server. |
| TEST_F(RelayServerTest, TestRemoteBadRequest) { |
| Allocate(); |
| Bind(); |
| |
| SendRaw1(bad, static_cast<int>(strlen(bad))); |
| EXPECT_TRUE(Receive1Fails()); |
| EXPECT_TRUE(Receive2Fails()); |
| } |
| |
| // Send a send request without a username and verify it is rejected. |
| TEST_F(RelayServerTest, TestSendRequestMissingUsername) { |
| Allocate(); |
| Bind(); |
| |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res; |
| AddMagicCookieAttr(req.get()); |
| |
| Send1(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type()); |
| EXPECT_EQ(req->transaction_id(), res->transaction_id()); |
| |
| const StunErrorCodeAttribute* err = res->GetErrorCode(); |
| ASSERT_TRUE(err != NULL); |
| EXPECT_EQ(4, err->eclass()); |
| EXPECT_EQ(32, err->number()); |
| EXPECT_EQ("Missing Username", err->reason()); |
| } |
| |
| // Send a send request with the wrong username and verify it is rejected. |
| TEST_F(RelayServerTest, TestSendRequestBadUsername) { |
| Allocate(); |
| Bind(); |
| |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res; |
| AddMagicCookieAttr(req.get()); |
| AddUsernameAttr(req.get(), "foobarbizbaz"); |
| |
| Send1(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type()); |
| EXPECT_EQ(req->transaction_id(), res->transaction_id()); |
| |
| const StunErrorCodeAttribute* err = res->GetErrorCode(); |
| ASSERT_TRUE(err != NULL); |
| EXPECT_EQ(4, err->eclass()); |
| EXPECT_EQ(30, err->number()); |
| EXPECT_EQ("Stale Credentials", err->reason()); |
| } |
| |
| // Send a send request without a destination address and verify that it is |
| // rejected. |
| TEST_F(RelayServerTest, TestSendRequestNoDestinationAddress) { |
| Allocate(); |
| Bind(); |
| |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res; |
| AddMagicCookieAttr(req.get()); |
| AddUsernameAttr(req.get(), username_); |
| |
| Send1(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type()); |
| EXPECT_EQ(req->transaction_id(), res->transaction_id()); |
| |
| const StunErrorCodeAttribute* err = res->GetErrorCode(); |
| ASSERT_TRUE(err != NULL); |
| EXPECT_EQ(4, err->eclass()); |
| EXPECT_EQ(0, err->number()); |
| EXPECT_EQ("Bad Request", err->reason()); |
| } |
| |
| // Send a send request without data and verify that it is rejected. |
| TEST_F(RelayServerTest, TestSendRequestNoData) { |
| Allocate(); |
| Bind(); |
| |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res; |
| AddMagicCookieAttr(req.get()); |
| AddUsernameAttr(req.get(), username_); |
| AddDestinationAttr(req.get(), client2_addr); |
| |
| Send1(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type()); |
| EXPECT_EQ(req->transaction_id(), res->transaction_id()); |
| |
| const StunErrorCodeAttribute* err = res->GetErrorCode(); |
| ASSERT_TRUE(err != NULL); |
| EXPECT_EQ(4, err->eclass()); |
| EXPECT_EQ(00, err->number()); |
| EXPECT_EQ("Bad Request", err->reason()); |
| } |
| |
| // Send a binding request after an allocate and verify that it is rejected. |
| TEST_F(RelayServerTest, TestSendRequestWrongType) { |
| Allocate(); |
| Bind(); |
| |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST)), |
| res; |
| AddMagicCookieAttr(req.get()); |
| AddUsernameAttr(req.get(), username_); |
| |
| Send1(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, res->type()); |
| EXPECT_EQ(req->transaction_id(), res->transaction_id()); |
| |
| const StunErrorCodeAttribute* err = res->GetErrorCode(); |
| ASSERT_TRUE(err != NULL); |
| EXPECT_EQ(6, err->eclass()); |
| EXPECT_EQ(0, err->number()); |
| EXPECT_EQ("Operation Not Supported", err->reason()); |
| } |
| |
| // Verify that we can send traffic back and forth between the clients after a |
| // successful allocate and bind. |
| TEST_F(RelayServerTest, TestSendRaw) { |
| Allocate(); |
| Bind(); |
| |
| for (int i = 0; i < 10; i++) { |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res; |
| AddMagicCookieAttr(req.get()); |
| AddUsernameAttr(req.get(), username_); |
| AddDestinationAttr(req.get(), client2_addr); |
| |
| auto send_data = StunAttribute::CreateByteString(STUN_ATTR_DATA); |
| send_data->CopyBytes(msg1); |
| req->AddAttribute(std::move(send_data)); |
| |
| Send1(req.get()); |
| EXPECT_EQ(msg1, ReceiveRaw2()); |
| SendRaw2(msg2, static_cast<int>(strlen(msg2))); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res); |
| EXPECT_EQ(STUN_DATA_INDICATION, res->type()); |
| |
| const StunAddressAttribute* src_addr = |
| res->GetAddress(STUN_ATTR_SOURCE_ADDRESS2); |
| ASSERT_TRUE(src_addr != NULL); |
| EXPECT_EQ(1, src_addr->family()); |
| EXPECT_EQ(client2_addr.ipaddr(), src_addr->ipaddr()); |
| EXPECT_EQ(client2_addr.port(), src_addr->port()); |
| |
| const StunByteStringAttribute* recv_data = |
| res->GetByteString(STUN_ATTR_DATA); |
| ASSERT_TRUE(recv_data != NULL); |
| EXPECT_EQ(strlen(msg2), recv_data->length()); |
| EXPECT_EQ(0, memcmp(msg2, recv_data->bytes(), recv_data->length())); |
| } |
| } |
| |
| // Verify that a binding expires properly, and rejects send requests. |
| // Flaky, see https://code.google.com/p/webrtc/issues/detail?id=4134 |
| TEST_F(RelayServerTest, DISABLED_TestExpiration) { |
| Allocate(); |
| Bind(); |
| |
| // Wait twice the lifetime to make sure the server has expired the binding. |
| rtc::Thread::Current()->ProcessMessages((LIFETIME * 2) * 1000); |
| |
| std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res; |
| AddMagicCookieAttr(req.get()); |
| AddUsernameAttr(req.get(), username_); |
| AddDestinationAttr(req.get(), client2_addr); |
| |
| auto data_attr = StunAttribute::CreateByteString(STUN_ATTR_DATA); |
| data_attr->CopyBytes(msg1); |
| req->AddAttribute(std::move(data_attr)); |
| |
| Send1(req.get()); |
| res.reset(Receive1()); |
| |
| ASSERT_TRUE(res.get() != NULL); |
| EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type()); |
| |
| const StunErrorCodeAttribute* err = res->GetErrorCode(); |
| ASSERT_TRUE(err != NULL); |
| EXPECT_EQ(6, err->eclass()); |
| EXPECT_EQ(0, err->number()); |
| EXPECT_EQ("Operation Not Supported", err->reason()); |
| |
| // Also verify that traffic from the external client is ignored. |
| SendRaw2(msg2, static_cast<int>(strlen(msg2))); |
| EXPECT_TRUE(ReceiveRaw1().empty()); |
| } |