p2p/base/relayserver_unittest.cc - src/webrtc - Git at Google

 /*
  *  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());
 }
	/*
	* 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());
	}