net/socket/socks5_client_socket_unittest.cc - cobalt - Git at Google

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "net/socket/socks5_client_socket.h"

 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <utility>

 #include "base/containers/span.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/sys_byteorder.h"
 #include "build/build_config.h"
 #include "net/base/address_list.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/winsock_init.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/test/gtest_util.h"
 #include "net/test/test_with_scoped_task_environment.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "starboard/memory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"

 using net::test::IsError;
 using net::test::IsOk;

 //-----------------------------------------------------------------------------

 namespace net {

 class NetLog;

 namespace {

 // Base class to test SOCKS5ClientSocket
 class SOCKS5ClientSocketTest : public PlatformTest,
                                public WithScopedTaskEnvironment {
  public:
   SOCKS5ClientSocketTest();
   // Create a SOCKSClientSocket on top of a MockSocket.
   std::unique_ptr<SOCKS5ClientSocket> BuildMockSocket(
       base::span<const MockRead> reads,
       base::span<const MockWrite> writes,
       const std::string& hostname,
       int port,
       NetLog* net_log);

   void SetUp() override;

  protected:
   const uint16_t kNwPort;
   TestNetLog net_log_;
   std::unique_ptr<SOCKS5ClientSocket> user_sock_;
   AddressList address_list_;
   // Filled in by BuildMockSocket() and owned by its return value
   // (which |user_sock| is set to).
   StreamSocket* tcp_sock_;
   TestCompletionCallback callback_;
   std::unique_ptr<MockHostResolver> host_resolver_;
   std::unique_ptr<SocketDataProvider> data_;

  private:
   DISALLOW_COPY_AND_ASSIGN(SOCKS5ClientSocketTest);
 };

 SOCKS5ClientSocketTest::SOCKS5ClientSocketTest()
   : kNwPort(base::HostToNet16(80)),
     host_resolver_(new MockHostResolver) {
 }

 // Set up platform before every test case
 void SOCKS5ClientSocketTest::SetUp() {
   PlatformTest::SetUp();

   // Resolve the "localhost" AddressList used by the TCP connection to connect.
   HostResolver::RequestInfo info(HostPortPair("www.socks-proxy.com", 1080));
   TestCompletionCallback callback;
   std::unique_ptr<HostResolver::Request> request;
   int rv = host_resolver_->Resolve(info, DEFAULT_PRIORITY, &address_list_,
                                    callback.callback(), &request,
                                    NetLogWithSource());
   ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
   ASSERT_THAT(rv, IsOk());
 }

 std::unique_ptr<SOCKS5ClientSocket> SOCKS5ClientSocketTest::BuildMockSocket(
     base::span<const MockRead> reads,
     base::span<const MockWrite> writes,
     const std::string& hostname,
     int port,
     NetLog* net_log) {
   TestCompletionCallback callback;
   data_.reset(new StaticSocketDataProvider(reads, writes));
   tcp_sock_ = new MockTCPClientSocket(address_list_, net_log, data_.get());

   int rv = tcp_sock_->Connect(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
   EXPECT_TRUE(tcp_sock_->IsConnected());

   std::unique_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
   // |connection| takes ownership of |tcp_sock_|, but keep a
   // non-owning pointer to it.
   connection->SetSocket(std::unique_ptr<StreamSocket>(tcp_sock_));
   return std::unique_ptr<SOCKS5ClientSocket>(new SOCKS5ClientSocket(
       std::move(connection),
       HostResolver::RequestInfo(HostPortPair(hostname, port)),
       TRAFFIC_ANNOTATION_FOR_TESTS));
 }

 // Tests a complete SOCKS5 handshake and the disconnection.
 TEST_F(SOCKS5ClientSocketTest, CompleteHandshake) {
   const std::string payload_write = "random data";
   const std::string payload_read = "moar random data";

   const char kOkRequest[] = {
     0x05,  // Version
     0x01,  // Command (CONNECT)
     0x00,  // Reserved.
     0x03,  // Address type (DOMAINNAME).
     0x09,  // Length of domain (9)
     // Domain string:
     'l', 'o', 'c', 'a', 'l', 'h', 'o', 's', 't',
     0x00, 0x50,  // 16-bit port (80)
   };

   MockWrite data_writes[] = {
       MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
       MockWrite(ASYNC, kOkRequest, base::size(kOkRequest)),
       MockWrite(ASYNC, payload_write.data(), payload_write.size())};
   MockRead data_reads[] = {
       MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength),
       MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength),
       MockRead(ASYNC, payload_read.data(), payload_read.size()) };

   user_sock_ =
       BuildMockSocket(data_reads, data_writes, "localhost", 80, &net_log_);

   // At this state the TCP connection is completed but not the SOCKS handshake.
   EXPECT_TRUE(tcp_sock_->IsConnected());
   EXPECT_FALSE(user_sock_->IsConnected());

   int rv = user_sock_->Connect(callback_.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_FALSE(user_sock_->IsConnected());

   TestNetLogEntry::List net_log_entries;
   net_log_.GetEntries(&net_log_entries);
   EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
                                     NetLogEventType::SOCKS5_CONNECT));

   rv = callback_.WaitForResult();

   EXPECT_THAT(rv, IsOk());
   EXPECT_TRUE(user_sock_->IsConnected());

   net_log_.GetEntries(&net_log_entries);
   EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
                                   NetLogEventType::SOCKS5_CONNECT));

   scoped_refptr<IOBuffer> buffer =
       base::MakeRefCounted<IOBuffer>(payload_write.size());
   memcpy(buffer->data(), payload_write.data(), payload_write.size());
   rv = user_sock_->Write(buffer.get(), payload_write.size(),
                          callback_.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback_.WaitForResult();
   EXPECT_EQ(static_cast<int>(payload_write.size()), rv);

   buffer = base::MakeRefCounted<IOBuffer>(payload_read.size());
   rv =
       user_sock_->Read(buffer.get(), payload_read.size(), callback_.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback_.WaitForResult();
   EXPECT_EQ(static_cast<int>(payload_read.size()), rv);
   EXPECT_EQ(payload_read, std::string(buffer->data(), payload_read.size()));

   user_sock_->Disconnect();
   EXPECT_FALSE(tcp_sock_->IsConnected());
   EXPECT_FALSE(user_sock_->IsConnected());
 }

 // Test that you can call Connect() again after having called Disconnect().
 TEST_F(SOCKS5ClientSocketTest, ConnectAndDisconnectTwice) {
   const std::string hostname = "my-host-name";
   const char kSOCKS5DomainRequest[] = {
       0x05,  // VER
       0x01,  // CMD
       0x00,  // RSV
       0x03,  // ATYPE
   };

   std::string request(kSOCKS5DomainRequest, base::size(kSOCKS5DomainRequest));
   request.push_back(static_cast<char>(hostname.size()));
   request.append(hostname);
   request.append(reinterpret_cast<const char*>(&kNwPort), sizeof(kNwPort));

   for (int i = 0; i < 2; ++i) {
     MockWrite data_writes[] = {
         MockWrite(SYNCHRONOUS, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
         MockWrite(SYNCHRONOUS, request.data(), request.size())
     };
     MockRead data_reads[] = {
         MockRead(SYNCHRONOUS, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength),
         MockRead(SYNCHRONOUS, kSOCKS5OkResponse, kSOCKS5OkResponseLength)
     };

     user_sock_ = BuildMockSocket(data_reads, data_writes, hostname, 80, NULL);

     int rv = user_sock_->Connect(callback_.callback());
     EXPECT_THAT(rv, IsOk());
     EXPECT_TRUE(user_sock_->IsConnected());

     user_sock_->Disconnect();
     EXPECT_FALSE(user_sock_->IsConnected());
   }
 }

 // Test that we fail trying to connect to a hosname longer than 255 bytes.
 TEST_F(SOCKS5ClientSocketTest, LargeHostNameFails) {
   // Create a string of length 256, where each character is 'x'.
   std::string large_host_name;
   std::fill_n(std::back_inserter(large_host_name), 256, 'x');

   // Create a SOCKS socket, with mock transport socket.
   MockWrite data_writes[] = {MockWrite()};
   MockRead data_reads[] = {MockRead()};
   user_sock_ =
       BuildMockSocket(data_reads, data_writes, large_host_name, 80, NULL);

   // Try to connect -- should fail (without having read/written anything to
   // the transport socket first) because the hostname is too long.
   TestCompletionCallback callback;
   int rv = user_sock_->Connect(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_SOCKS_CONNECTION_FAILED));
 }

 TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
   const std::string hostname = "www.google.com";

   const char kOkRequest[] = {
     0x05,  // Version
     0x01,  // Command (CONNECT)
     0x00,  // Reserved.
     0x03,  // Address type (DOMAINNAME).
     0x0E,  // Length of domain (14)
     // Domain string:
     'w', 'w', 'w', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'c', 'o', 'm',
     0x00, 0x50,  // 16-bit port (80)
   };

   // Test for partial greet request write
   {
     const char partial1[] = { 0x05, 0x01 };
     const char partial2[] = { 0x00 };
     MockWrite data_writes[] = {
         MockWrite(ASYNC, partial1, base::size(partial1)),
         MockWrite(ASYNC, partial2, base::size(partial2)),
         MockWrite(ASYNC, kOkRequest, base::size(kOkRequest))};
     MockRead data_reads[] = {
         MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength),
         MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength) };
     user_sock_ =
         BuildMockSocket(data_reads, data_writes, hostname, 80, &net_log_);
     int rv = user_sock_->Connect(callback_.callback());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

     TestNetLogEntry::List net_log_entries;
     net_log_.GetEntries(&net_log_entries);
     EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
                                       NetLogEventType::SOCKS5_CONNECT));

     rv = callback_.WaitForResult();
     EXPECT_THAT(rv, IsOk());
     EXPECT_TRUE(user_sock_->IsConnected());

     net_log_.GetEntries(&net_log_entries);
     EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
                                     NetLogEventType::SOCKS5_CONNECT));
   }

   // Test for partial greet response read
   {
     const char partial1[] = { 0x05 };
     const char partial2[] = { 0x00 };
     MockWrite data_writes[] = {
         MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
         MockWrite(ASYNC, kOkRequest, base::size(kOkRequest))};
     MockRead data_reads[] = {
         MockRead(ASYNC, partial1, base::size(partial1)),
         MockRead(ASYNC, partial2, base::size(partial2)),
         MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength)};
     user_sock_ =
         BuildMockSocket(data_reads, data_writes, hostname, 80, &net_log_);
     int rv = user_sock_->Connect(callback_.callback());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

     TestNetLogEntry::List net_log_entries;
     net_log_.GetEntries(&net_log_entries);
     EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
                                       NetLogEventType::SOCKS5_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_THAT(rv, IsOk());
     EXPECT_TRUE(user_sock_->IsConnected());
     net_log_.GetEntries(&net_log_entries);
     EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
                                     NetLogEventType::SOCKS5_CONNECT));
   }

   // Test for partial handshake request write.
   {
     const int kSplitPoint = 3;  // Break handshake write into two parts.
     MockWrite data_writes[] = {
         MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
         MockWrite(ASYNC, kOkRequest, kSplitPoint),
         MockWrite(ASYNC, kOkRequest + kSplitPoint,
                   base::size(kOkRequest) - kSplitPoint)};
     MockRead data_reads[] = {
         MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength),
         MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength) };
     user_sock_ =
         BuildMockSocket(data_reads, data_writes, hostname, 80, &net_log_);
     int rv = user_sock_->Connect(callback_.callback());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     TestNetLogEntry::List net_log_entries;
     net_log_.GetEntries(&net_log_entries);
     EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
                                       NetLogEventType::SOCKS5_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_THAT(rv, IsOk());
     EXPECT_TRUE(user_sock_->IsConnected());
     net_log_.GetEntries(&net_log_entries);
     EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
                                     NetLogEventType::SOCKS5_CONNECT));
   }

   // Test for partial handshake response read
   {
     const int kSplitPoint = 6;  // Break the handshake read into two parts.
     MockWrite data_writes[] = {
         MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
         MockWrite(ASYNC, kOkRequest, base::size(kOkRequest))};
     MockRead data_reads[] = {
         MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength),
         MockRead(ASYNC, kSOCKS5OkResponse, kSplitPoint),
         MockRead(ASYNC, kSOCKS5OkResponse + kSplitPoint,
                  kSOCKS5OkResponseLength - kSplitPoint)
     };

     user_sock_ =
         BuildMockSocket(data_reads, data_writes, hostname, 80, &net_log_);
     int rv = user_sock_->Connect(callback_.callback());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     TestNetLogEntry::List net_log_entries;
     net_log_.GetEntries(&net_log_entries);
     EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
                                       NetLogEventType::SOCKS5_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_THAT(rv, IsOk());
     EXPECT_TRUE(user_sock_->IsConnected());
     net_log_.GetEntries(&net_log_entries);
     EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
                                     NetLogEventType::SOCKS5_CONNECT));
   }
 }

 TEST_F(SOCKS5ClientSocketTest, Tag) {
   StaticSocketDataProvider data;
   TestNetLog log;
   MockTaggingStreamSocket* tagging_sock =
       new MockTaggingStreamSocket(std::unique_ptr<StreamSocket>(
           new MockTCPClientSocket(address_list_, &log, &data)));

   std::unique_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
   // |connection| takes ownership of |tagging_sock|, but keep a
   // non-owning pointer to it.
   connection->SetSocket(std::unique_ptr<StreamSocket>(tagging_sock));
   SOCKS5ClientSocket socket(
       std::move(connection),
       HostResolver::RequestInfo(HostPortPair("localhost", 80)),
       TRAFFIC_ANNOTATION_FOR_TESTS);

   EXPECT_EQ(tagging_sock->tag(), SocketTag());
 #if defined(OS_ANDROID)
   SocketTag tag(0x12345678, 0x87654321);
   socket.ApplySocketTag(tag);
   EXPECT_EQ(tagging_sock->tag(), tag);
 #endif  // OS_ANDROID
 }

 }  // namespace

 }  // namespace net
	// Copyright (c) 2012 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "net/socket/socks5_client_socket.h"

	#include <algorithm>
	#include <iterator>
	#include <map>
	#include <utility>

	#include "base/containers/span.h"
	#include "base/macros.h"
	#include "base/stl_util.h"
	#include "base/sys_byteorder.h"
	#include "build/build_config.h"
	#include "net/base/address_list.h"
	#include "net/base/test_completion_callback.h"
	#include "net/base/winsock_init.h"
	#include "net/dns/mock_host_resolver.h"
	#include "net/log/net_log_event_type.h"
	#include "net/log/test_net_log.h"
	#include "net/log/test_net_log_entry.h"
	#include "net/log/test_net_log_util.h"
	#include "net/socket/client_socket_factory.h"
	#include "net/socket/socket_test_util.h"
	#include "net/socket/tcp_client_socket.h"
	#include "net/test/gtest_util.h"
	#include "net/test/test_with_scoped_task_environment.h"
	#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
	#include "starboard/memory.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "testing/platform_test.h"

	using net::test::IsError;
	using net::test::IsOk;

	//-----------------------------------------------------------------------------

	namespace net {

	class NetLog;

	namespace {

	// Base class to test SOCKS5ClientSocket
	class SOCKS5ClientSocketTest : public PlatformTest,
	public WithScopedTaskEnvironment {
	public:
	SOCKS5ClientSocketTest();
	// Create a SOCKSClientSocket on top of a MockSocket.
	std::unique_ptr<SOCKS5ClientSocket> BuildMockSocket(
	base::span<const MockRead> reads,
	base::span<const MockWrite> writes,
	const std::string& hostname,
	int port,
	NetLog* net_log);

	void SetUp() override;

	protected:
	const uint16_t kNwPort;
	TestNetLog net_log_;
	std::unique_ptr<SOCKS5ClientSocket> user_sock_;
	AddressList address_list_;
	// Filled in by BuildMockSocket() and owned by its return value
	// (which \|user_sock\| is set to).
	StreamSocket* tcp_sock_;
	TestCompletionCallback callback_;
	std::unique_ptr<MockHostResolver> host_resolver_;
	std::unique_ptr<SocketDataProvider> data_;

	private:
	DISALLOW_COPY_AND_ASSIGN(SOCKS5ClientSocketTest);
	};

	SOCKS5ClientSocketTest::SOCKS5ClientSocketTest()
	: kNwPort(base::HostToNet16(80)),
	host_resolver_(new MockHostResolver) {
	}

	// Set up platform before every test case
	void SOCKS5ClientSocketTest::SetUp() {
	PlatformTest::SetUp();

	// Resolve the "localhost" AddressList used by the TCP connection to connect.
	HostResolver::RequestInfo info(HostPortPair("www.socks-proxy.com", 1080));
	TestCompletionCallback callback;
	std::unique_ptr<HostResolver::Request> request;
	int rv = host_resolver_->Resolve(info, DEFAULT_PRIORITY, &address_list_,
	callback.callback(), &request,
	NetLogWithSource());
	ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
	rv = callback.WaitForResult();
	ASSERT_THAT(rv, IsOk());
	}

	std::unique_ptr<SOCKS5ClientSocket> SOCKS5ClientSocketTest::BuildMockSocket(
	base::span<const MockRead> reads,
	base::span<const MockWrite> writes,
	const std::string& hostname,
	int port,
	NetLog* net_log) {
	TestCompletionCallback callback;
	data_.reset(new StaticSocketDataProvider(reads, writes));
	tcp_sock_ = new MockTCPClientSocket(address_list_, net_log, data_.get());

	int rv = tcp_sock_->Connect(callback.callback());
	EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
	rv = callback.WaitForResult();
	EXPECT_THAT(rv, IsOk());
	EXPECT_TRUE(tcp_sock_->IsConnected());

	std::unique_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
	// \|connection\| takes ownership of \|tcp_sock_\|, but keep a
	// non-owning pointer to it.
	connection->SetSocket(std::unique_ptr<StreamSocket>(tcp_sock_));
	return std::unique_ptr<SOCKS5ClientSocket>(new SOCKS5ClientSocket(
	std::move(connection),
	HostResolver::RequestInfo(HostPortPair(hostname, port)),
	TRAFFIC_ANNOTATION_FOR_TESTS));
	}

	// Tests a complete SOCKS5 handshake and the disconnection.
	TEST_F(SOCKS5ClientSocketTest, CompleteHandshake) {
	const std::string payload_write = "random data";
	const std::string payload_read = "moar random data";

	const char kOkRequest[] = {
	0x05, // Version
	0x01, // Command (CONNECT)
	0x00, // Reserved.
	0x03, // Address type (DOMAINNAME).
	0x09, // Length of domain (9)
	// Domain string:
	'l', 'o', 'c', 'a', 'l', 'h', 'o', 's', 't',
	0x00, 0x50, // 16-bit port (80)
	};

	MockWrite data_writes[] = {
	MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
	MockWrite(ASYNC, kOkRequest, base::size(kOkRequest)),
	MockWrite(ASYNC, payload_write.data(), payload_write.size())};
	MockRead data_reads[] = {
	MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength),
	MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength),
	MockRead(ASYNC, payload_read.data(), payload_read.size()) };

	user_sock_ =
	BuildMockSocket(data_reads, data_writes, "localhost", 80, &net_log_);

	// At this state the TCP connection is completed but not the SOCKS handshake.
	EXPECT_TRUE(tcp_sock_->IsConnected());
	EXPECT_FALSE(user_sock_->IsConnected());

	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
	EXPECT_FALSE(user_sock_->IsConnected());

	TestNetLogEntry::List net_log_entries;
	net_log_.GetEntries(&net_log_entries);
	EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
	NetLogEventType::SOCKS5_CONNECT));

	rv = callback_.WaitForResult();

	EXPECT_THAT(rv, IsOk());
	EXPECT_TRUE(user_sock_->IsConnected());

	net_log_.GetEntries(&net_log_entries);
	EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
	NetLogEventType::SOCKS5_CONNECT));

	scoped_refptr<IOBuffer> buffer =
	base::MakeRefCounted<IOBuffer>(payload_write.size());
	memcpy(buffer->data(), payload_write.data(), payload_write.size());
	rv = user_sock_->Write(buffer.get(), payload_write.size(),
	callback_.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
	EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
	rv = callback_.WaitForResult();
	EXPECT_EQ(static_cast<int>(payload_write.size()), rv);

	buffer = base::MakeRefCounted<IOBuffer>(payload_read.size());
	rv =
	user_sock_->Read(buffer.get(), payload_read.size(), callback_.callback());
	EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
	rv = callback_.WaitForResult();
	EXPECT_EQ(static_cast<int>(payload_read.size()), rv);
	EXPECT_EQ(payload_read, std::string(buffer->data(), payload_read.size()));

	user_sock_->Disconnect();
	EXPECT_FALSE(tcp_sock_->IsConnected());
	EXPECT_FALSE(user_sock_->IsConnected());
	}

	// Test that you can call Connect() again after having called Disconnect().
	TEST_F(SOCKS5ClientSocketTest, ConnectAndDisconnectTwice) {
	const std::string hostname = "my-host-name";
	const char kSOCKS5DomainRequest[] = {
	0x05, // VER
	0x01, // CMD
	0x00, // RSV
	0x03, // ATYPE
	};

	std::string request(kSOCKS5DomainRequest, base::size(kSOCKS5DomainRequest));
	request.push_back(static_cast<char>(hostname.size()));
	request.append(hostname);
	request.append(reinterpret_cast<const char*>(&kNwPort), sizeof(kNwPort));

	for (int i = 0; i < 2; ++i) {
	MockWrite data_writes[] = {
	MockWrite(SYNCHRONOUS, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
	MockWrite(SYNCHRONOUS, request.data(), request.size())
	};
	MockRead data_reads[] = {
	MockRead(SYNCHRONOUS, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength),
	MockRead(SYNCHRONOUS, kSOCKS5OkResponse, kSOCKS5OkResponseLength)
	};

	user_sock_ = BuildMockSocket(data_reads, data_writes, hostname, 80, NULL);

	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_THAT(rv, IsOk());
	EXPECT_TRUE(user_sock_->IsConnected());

	user_sock_->Disconnect();
	EXPECT_FALSE(user_sock_->IsConnected());
	}
	}

	// Test that we fail trying to connect to a hosname longer than 255 bytes.
	TEST_F(SOCKS5ClientSocketTest, LargeHostNameFails) {
	// Create a string of length 256, where each character is 'x'.
	std::string large_host_name;
	std::fill_n(std::back_inserter(large_host_name), 256, 'x');

	// Create a SOCKS socket, with mock transport socket.
	MockWrite data_writes[] = {MockWrite()};
	MockRead data_reads[] = {MockRead()};
	user_sock_ =
	BuildMockSocket(data_reads, data_writes, large_host_name, 80, NULL);

	// Try to connect -- should fail (without having read/written anything to
	// the transport socket first) because the hostname is too long.
	TestCompletionCallback callback;
	int rv = user_sock_->Connect(callback.callback());
	EXPECT_THAT(rv, IsError(ERR_SOCKS_CONNECTION_FAILED));
	}

	TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
	const std::string hostname = "www.google.com";

	const char kOkRequest[] = {
	0x05, // Version
	0x01, // Command (CONNECT)
	0x00, // Reserved.
	0x03, // Address type (DOMAINNAME).
	0x0E, // Length of domain (14)
	// Domain string:
	'w', 'w', 'w', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'c', 'o', 'm',
	0x00, 0x50, // 16-bit port (80)
	};

	// Test for partial greet request write
	{
	const char partial1[] = { 0x05, 0x01 };
	const char partial2[] = { 0x00 };
	MockWrite data_writes[] = {
	MockWrite(ASYNC, partial1, base::size(partial1)),
	MockWrite(ASYNC, partial2, base::size(partial2)),
	MockWrite(ASYNC, kOkRequest, base::size(kOkRequest))};
	MockRead data_reads[] = {
	MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength),
	MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength) };
	user_sock_ =
	BuildMockSocket(data_reads, data_writes, hostname, 80, &net_log_);
	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

	TestNetLogEntry::List net_log_entries;
	net_log_.GetEntries(&net_log_entries);
	EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
	NetLogEventType::SOCKS5_CONNECT));

	rv = callback_.WaitForResult();
	EXPECT_THAT(rv, IsOk());
	EXPECT_TRUE(user_sock_->IsConnected());

	net_log_.GetEntries(&net_log_entries);
	EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
	NetLogEventType::SOCKS5_CONNECT));
	}

	// Test for partial greet response read
	{
	const char partial1[] = { 0x05 };
	const char partial2[] = { 0x00 };
	MockWrite data_writes[] = {
	MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
	MockWrite(ASYNC, kOkRequest, base::size(kOkRequest))};
	MockRead data_reads[] = {
	MockRead(ASYNC, partial1, base::size(partial1)),
	MockRead(ASYNC, partial2, base::size(partial2)),
	MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength)};
	user_sock_ =
	BuildMockSocket(data_reads, data_writes, hostname, 80, &net_log_);
	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

	TestNetLogEntry::List net_log_entries;
	net_log_.GetEntries(&net_log_entries);
	EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
	NetLogEventType::SOCKS5_CONNECT));
	rv = callback_.WaitForResult();
	EXPECT_THAT(rv, IsOk());
	EXPECT_TRUE(user_sock_->IsConnected());
	net_log_.GetEntries(&net_log_entries);
	EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
	NetLogEventType::SOCKS5_CONNECT));
	}

	// Test for partial handshake request write.
	{
	const int kSplitPoint = 3; // Break handshake write into two parts.
	MockWrite data_writes[] = {
	MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
	MockWrite(ASYNC, kOkRequest, kSplitPoint),
	MockWrite(ASYNC, kOkRequest + kSplitPoint,
	base::size(kOkRequest) - kSplitPoint)};
	MockRead data_reads[] = {
	MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength),
	MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength) };
	user_sock_ =
	BuildMockSocket(data_reads, data_writes, hostname, 80, &net_log_);
	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
	TestNetLogEntry::List net_log_entries;
	net_log_.GetEntries(&net_log_entries);
	EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
	NetLogEventType::SOCKS5_CONNECT));
	rv = callback_.WaitForResult();
	EXPECT_THAT(rv, IsOk());
	EXPECT_TRUE(user_sock_->IsConnected());
	net_log_.GetEntries(&net_log_entries);
	EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
	NetLogEventType::SOCKS5_CONNECT));
	}

	// Test for partial handshake response read
	{
	const int kSplitPoint = 6; // Break the handshake read into two parts.
	MockWrite data_writes[] = {
	MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
	MockWrite(ASYNC, kOkRequest, base::size(kOkRequest))};
	MockRead data_reads[] = {
	MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength),
	MockRead(ASYNC, kSOCKS5OkResponse, kSplitPoint),
	MockRead(ASYNC, kSOCKS5OkResponse + kSplitPoint,
	kSOCKS5OkResponseLength - kSplitPoint)
	};

	user_sock_ =
	BuildMockSocket(data_reads, data_writes, hostname, 80, &net_log_);
	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
	TestNetLogEntry::List net_log_entries;
	net_log_.GetEntries(&net_log_entries);
	EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
	NetLogEventType::SOCKS5_CONNECT));
	rv = callback_.WaitForResult();
	EXPECT_THAT(rv, IsOk());
	EXPECT_TRUE(user_sock_->IsConnected());
	net_log_.GetEntries(&net_log_entries);
	EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
	NetLogEventType::SOCKS5_CONNECT));
	}
	}

	TEST_F(SOCKS5ClientSocketTest, Tag) {
	StaticSocketDataProvider data;
	TestNetLog log;
	MockTaggingStreamSocket* tagging_sock =
	new MockTaggingStreamSocket(std::unique_ptr<StreamSocket>(
	new MockTCPClientSocket(address_list_, &log, &data)));

	std::unique_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
	// \|connection\| takes ownership of \|tagging_sock\|, but keep a
	// non-owning pointer to it.
	connection->SetSocket(std::unique_ptr<StreamSocket>(tagging_sock));
	SOCKS5ClientSocket socket(
	std::move(connection),
	HostResolver::RequestInfo(HostPortPair("localhost", 80)),
	TRAFFIC_ANNOTATION_FOR_TESTS);

	EXPECT_EQ(tagging_sock->tag(), SocketTag());
	#if defined(OS_ANDROID)
	SocketTag tag(0x12345678, 0x87654321);
	socket.ApplySocketTag(tag);
	EXPECT_EQ(tagging_sock->tag(), tag);
	#endif // OS_ANDROID
	}

	} // namespace

	} // namespace net