src/net/socket/socks_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/socks_client_socket.h"


            #include "net/base/address_list.h"

            
            #include "net/base/net_log.h"

            
            #include "net/base/net_log_unittest.h"

            
            #include "net/base/mock_host_resolver.h"

            
            #include "net/base/test_completion_callback.h"

            
            #include "net/socket/client_socket_factory.h"

            
            #include "net/socket/tcp_client_socket.h"

            
            #include "net/socket/socket_test_util.h"

            
            #include "testing/gtest/include/gtest/gtest.h"

            
            #include "testing/platform_test.h"


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


            namespace net {


            const char kSOCKSOkRequest[] = { 0x04, 0x01, 0x00, 0x50, 127, 0, 0, 1, 0 };

            
            const char kSOCKSOkReply[] = { 0x00, 0x5A, 0x00, 0x00, 0, 0, 0, 0 };


            class SOCKSClientSocketTest : public PlatformTest {

            
             public:

            
              SOCKSClientSocketTest();

            
              // Create a SOCKSClientSocket on top of a MockSocket.

            
              SOCKSClientSocket* BuildMockSocket(MockRead reads[], size_t reads_count,

            
                                                 MockWrite writes[], size_t writes_count,

            
                                                 HostResolver* host_resolver,

            
                                                 const std::string& hostname, int port,

            
                                                 NetLog* net_log);

            
              virtual void SetUp();


             protected:

            
              scoped_ptr<SOCKSClientSocket> user_sock_;

            
              AddressList address_list_;

            
              StreamSocket* tcp_sock_;

            
              TestCompletionCallback callback_;

            
              scoped_ptr<MockHostResolver> host_resolver_;

            
              scoped_ptr<SocketDataProvider> data_;

            
            };


            SOCKSClientSocketTest::SOCKSClientSocketTest()

            
              : host_resolver_(new MockHostResolver) {

            
            }


            // Set up platform before every test case

            
            void SOCKSClientSocketTest::SetUp() {

            
              PlatformTest::SetUp();

            
            }


            SOCKSClientSocket* SOCKSClientSocketTest::BuildMockSocket(

            
                MockRead reads[],

            
                size_t reads_count,

            
                MockWrite writes[],

            
                size_t writes_count,

            
                HostResolver* host_resolver,

            
                const std::string& hostname,

            
                int port,

            
                NetLog* net_log) {


              TestCompletionCallback callback;

            
              data_.reset(new StaticSocketDataProvider(reads, reads_count,

            
                                                       writes, writes_count));

            
              tcp_sock_ = new MockTCPClientSocket(address_list_, net_log, data_.get());


              int rv = tcp_sock_->Connect(callback.callback());

            
              EXPECT_EQ(ERR_IO_PENDING, rv);

            
              rv = callback.WaitForResult();

            
              EXPECT_EQ(OK, rv);

            
              EXPECT_TRUE(tcp_sock_->IsConnected());


              return new SOCKSClientSocket(tcp_sock_,

            
                  HostResolver::RequestInfo(HostPortPair(hostname, port)),

            
                  host_resolver);

            
            }


            // Implementation of HostResolver that never completes its resolve request.

            
            // We use this in the test "DisconnectWhileHostResolveInProgress" to make

            
            // sure that the outstanding resolve request gets cancelled.

            
            class HangingHostResolverWithCancel : public HostResolver {

            
             public:

            
              HangingHostResolverWithCancel() : outstanding_request_(NULL) {}


              virtual int Resolve(const RequestInfo& info,

            
                                  AddressList* addresses,

            
                                  const CompletionCallback& callback,

            
                                  RequestHandle* out_req,

            
                                  const BoundNetLog& net_log) OVERRIDE {

            
                DCHECK(addresses);

            
                DCHECK_EQ(false, callback.is_null());

            
                EXPECT_FALSE(HasOutstandingRequest());

            
                outstanding_request_ = reinterpret_cast<RequestHandle>(1);

            
                *out_req = outstanding_request_;

            
                return ERR_IO_PENDING;

            
              }


              virtual int ResolveFromCache(const RequestInfo& info,

            
                                           AddressList* addresses,

            
                                           const BoundNetLog& net_log) OVERRIDE {

            
                NOTIMPLEMENTED();

            
                return ERR_UNEXPECTED;

            
              }


              virtual void CancelRequest(RequestHandle req) OVERRIDE {

            
                EXPECT_TRUE(HasOutstandingRequest());

            
                EXPECT_EQ(outstanding_request_, req);

            
                outstanding_request_ = NULL;

            
              }


              bool HasOutstandingRequest() {

            
                return outstanding_request_ != NULL;

            
              }


             private:

            
              RequestHandle outstanding_request_;


              DISALLOW_COPY_AND_ASSIGN(HangingHostResolverWithCancel);

            
            };


            // Tests a complete handshake and the disconnection.

            
            TEST_F(SOCKSClientSocketTest, CompleteHandshake) {

            
              const std::string payload_write = "random data";

            
              const std::string payload_read = "moar random data";


              MockWrite data_writes[] = {

            
                  MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)),

            
                  MockWrite(ASYNC, payload_write.data(), payload_write.size()) };

            
              MockRead data_reads[] = {

            
                  MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)),

            
                  MockRead(ASYNC, payload_read.data(), payload_read.size()) };

            
              CapturingNetLog log;


              user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),

            
                                               data_writes, arraysize(data_writes),

            
                                               host_resolver_.get(),

            
                                               "localhost", 80,

            
                                               &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_EQ(ERR_IO_PENDING, rv);


              CapturingNetLog::CapturedEntryList entries;

            
              log.GetEntries(&entries);

            
              EXPECT_TRUE(

            
                  LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));

            
              EXPECT_FALSE(user_sock_->IsConnected());


              rv = callback_.WaitForResult();

            
              EXPECT_EQ(OK, rv);

            
              EXPECT_TRUE(user_sock_->IsConnected());

            
              log.GetEntries(&entries);

            
              EXPECT_TRUE(LogContainsEndEvent(

            
                  entries, -1, NetLog::TYPE_SOCKS_CONNECT));


              scoped_refptr<IOBuffer> buffer(new IOBuffer(payload_write.size()));

            
              memcpy(buffer->data(), payload_write.data(), payload_write.size());

            
              rv = user_sock_->Write(buffer, payload_write.size(), callback_.callback());

            
              EXPECT_EQ(ERR_IO_PENDING, rv);

            
              rv = callback_.WaitForResult();

            
              EXPECT_EQ(static_cast<int>(payload_write.size()), rv);


              buffer = new IOBuffer(payload_read.size());

            
              rv = user_sock_->Read(buffer, payload_read.size(), callback_.callback());

            
              EXPECT_EQ(ERR_IO_PENDING, rv);

            
              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());

            
            }


            // List of responses from the socks server and the errors they should

            
            // throw up are tested here.

            
            TEST_F(SOCKSClientSocketTest, HandshakeFailures) {

            
              const struct {

            
                const char fail_reply[8];

            
                Error fail_code;

            
              } tests[] = {

            
                // Failure of the server response code

            
                {

            
                  { 0x01, 0x5A, 0x00, 0x00, 0, 0, 0, 0 },

            
                  ERR_SOCKS_CONNECTION_FAILED,

            
                },

            
                // Failure of the null byte

            
                {

            
                  { 0x00, 0x5B, 0x00, 0x00, 0, 0, 0, 0 },

            
                  ERR_SOCKS_CONNECTION_FAILED,

            
                },

            
              };


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


              for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {

            
                MockWrite data_writes[] = {

            
                    MockWrite(SYNCHRONOUS, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };

            
                MockRead data_reads[] = {

            
                    MockRead(SYNCHRONOUS, tests[i].fail_reply,

            
                             arraysize(tests[i].fail_reply)) };

            
                CapturingNetLog log;


                user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),

            
                                                 data_writes, arraysize(data_writes),

            
                                                 host_resolver_.get(),

            
                                                 "localhost", 80,

            
                                                 &log));


                int rv = user_sock_->Connect(callback_.callback());

            
                EXPECT_EQ(ERR_IO_PENDING, rv);


                CapturingNetLog::CapturedEntryList entries;

            
                log.GetEntries(&entries);

            
                EXPECT_TRUE(LogContainsBeginEvent(

            
                    entries, 0, NetLog::TYPE_SOCKS_CONNECT));


                rv = callback_.WaitForResult();

            
                EXPECT_EQ(tests[i].fail_code, rv);

            
                EXPECT_FALSE(user_sock_->IsConnected());

            
                EXPECT_TRUE(tcp_sock_->IsConnected());

            
                log.GetEntries(&entries);

            
                EXPECT_TRUE(LogContainsEndEvent(

            
                    entries, -1, NetLog::TYPE_SOCKS_CONNECT));

            
              }

            
            }


            // Tests scenario when the server sends the handshake response in

            
            // more than one packet.

            
            TEST_F(SOCKSClientSocketTest, PartialServerReads) {

            
              const char kSOCKSPartialReply1[] = { 0x00 };

            
              const char kSOCKSPartialReply2[] = { 0x5A, 0x00, 0x00, 0, 0, 0, 0 };


              MockWrite data_writes[] = {

            
                  MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };

            
              MockRead data_reads[] = {

            
                  MockRead(ASYNC, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)),

            
                  MockRead(ASYNC, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) };

            
              CapturingNetLog log;


              user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),

            
                                               data_writes, arraysize(data_writes),

            
                                               host_resolver_.get(),

            
                                               "localhost", 80,

            
                                               &log));


              int rv = user_sock_->Connect(callback_.callback());

            
              EXPECT_EQ(ERR_IO_PENDING, rv);

            
              CapturingNetLog::CapturedEntryList entries;

            
              log.GetEntries(&entries);

            
              EXPECT_TRUE(LogContainsBeginEvent(

            
                  entries, 0, NetLog::TYPE_SOCKS_CONNECT));


              rv = callback_.WaitForResult();

            
              EXPECT_EQ(OK, rv);

            
              EXPECT_TRUE(user_sock_->IsConnected());

            
              log.GetEntries(&entries);

            
              EXPECT_TRUE(LogContainsEndEvent(

            
                  entries, -1, NetLog::TYPE_SOCKS_CONNECT));

            
            }


            // Tests scenario when the client sends the handshake request in

            
            // more than one packet.

            
            TEST_F(SOCKSClientSocketTest, PartialClientWrites) {

            
              const char kSOCKSPartialRequest1[] = { 0x04, 0x01 };

            
              const char kSOCKSPartialRequest2[] = { 0x00, 0x50, 127, 0, 0, 1, 0 };


              MockWrite data_writes[] = {

            
                  MockWrite(ASYNC, arraysize(kSOCKSPartialRequest1)),

            
                  // simulate some empty writes

            
                  MockWrite(ASYNC, 0),

            
                  MockWrite(ASYNC, 0),

            
                  MockWrite(ASYNC, kSOCKSPartialRequest2,

            
                            arraysize(kSOCKSPartialRequest2)) };

            
              MockRead data_reads[] = {

            
                  MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)) };

            
              CapturingNetLog log;


              user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),

            
                                               data_writes, arraysize(data_writes),

            
                                               host_resolver_.get(),

            
                                               "localhost", 80,

            
                                               &log));


              int rv = user_sock_->Connect(callback_.callback());

            
              EXPECT_EQ(ERR_IO_PENDING, rv);

            
              CapturingNetLog::CapturedEntryList entries;

            
              log.GetEntries(&entries);

            
              EXPECT_TRUE(LogContainsBeginEvent(

            
                  entries, 0, NetLog::TYPE_SOCKS_CONNECT));


              rv = callback_.WaitForResult();

            
              EXPECT_EQ(OK, rv);

            
              EXPECT_TRUE(user_sock_->IsConnected());

            
              log.GetEntries(&entries);

            
              EXPECT_TRUE(LogContainsEndEvent(

            
                  entries, -1, NetLog::TYPE_SOCKS_CONNECT));

            
            }


            // Tests the case when the server sends a smaller sized handshake data

            
            // and closes the connection.

            
            TEST_F(SOCKSClientSocketTest, FailedSocketRead) {

            
              MockWrite data_writes[] = {

            
                  MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };

            
              MockRead data_reads[] = {

            
                  MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply) - 2),

            
                  // close connection unexpectedly

            
                  MockRead(SYNCHRONOUS, 0) };

            
              CapturingNetLog log;


              user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),

            
                                               data_writes, arraysize(data_writes),

            
                                               host_resolver_.get(),

            
                                               "localhost", 80,

            
                                               &log));


              int rv = user_sock_->Connect(callback_.callback());

            
              EXPECT_EQ(ERR_IO_PENDING, rv);

            
              CapturingNetLog::CapturedEntryList entries;

            
              log.GetEntries(&entries);

            
              EXPECT_TRUE(LogContainsBeginEvent(

            
                  entries, 0, NetLog::TYPE_SOCKS_CONNECT));


              rv = callback_.WaitForResult();

            
              EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);

            
              EXPECT_FALSE(user_sock_->IsConnected());

            
              log.GetEntries(&entries);

            
              EXPECT_TRUE(LogContainsEndEvent(

            
                  entries, -1, NetLog::TYPE_SOCKS_CONNECT));

            
            }


            // Tries to connect to an unknown hostname. Should fail rather than

            
            // falling back to SOCKS4a.

            
            TEST_F(SOCKSClientSocketTest, FailedDNS) {

            
              const char hostname[] = "unresolved.ipv4.address";


              host_resolver_->rules()->AddSimulatedFailure(hostname);


              CapturingNetLog log;


              user_sock_.reset(BuildMockSocket(NULL, 0,

            
                                               NULL, 0,

            
                                               host_resolver_.get(),

            
                                               hostname, 80,

            
                                               &log));


              int rv = user_sock_->Connect(callback_.callback());

            
              EXPECT_EQ(ERR_IO_PENDING, rv);

            
              CapturingNetLog::CapturedEntryList entries;

            
              log.GetEntries(&entries);

            
              EXPECT_TRUE(LogContainsBeginEvent(

            
                  entries, 0, NetLog::TYPE_SOCKS_CONNECT));


              rv = callback_.WaitForResult();

            
              EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);

            
              EXPECT_FALSE(user_sock_->IsConnected());

            
              log.GetEntries(&entries);

            
              EXPECT_TRUE(LogContainsEndEvent(

            
                  entries, -1, NetLog::TYPE_SOCKS_CONNECT));

            
            }


            // Calls Disconnect() while a host resolve is in progress. The outstanding host

            
            // resolve should be cancelled.

            
            TEST_F(SOCKSClientSocketTest, DisconnectWhileHostResolveInProgress) {

            
              scoped_ptr<HangingHostResolverWithCancel> hanging_resolver(

            
                new HangingHostResolverWithCancel());


              // Doesn't matter what the socket data is, we will never use it -- garbage.

            
              MockWrite data_writes[] = { MockWrite(SYNCHRONOUS, "", 0) };

            
              MockRead data_reads[] = { MockRead(SYNCHRONOUS, "", 0) };


              user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),

            
                                               data_writes, arraysize(data_writes),

            
                                               hanging_resolver.get(),

            
                                               "foo", 80,

            
                                               NULL));


              // Start connecting (will get stuck waiting for the host to resolve).

            
              int rv = user_sock_->Connect(callback_.callback());

            
              EXPECT_EQ(ERR_IO_PENDING, rv);


              EXPECT_FALSE(user_sock_->IsConnected());

            
              EXPECT_FALSE(user_sock_->IsConnectedAndIdle());


              // The host resolver should have received the resolve request.

            
              EXPECT_TRUE(hanging_resolver->HasOutstandingRequest());


              // Disconnect the SOCKS socket -- this should cancel the outstanding resolve.

            
              user_sock_->Disconnect();


              EXPECT_FALSE(hanging_resolver->HasOutstandingRequest());


              EXPECT_FALSE(user_sock_->IsConnected());

            
              EXPECT_FALSE(user_sock_->IsConnectedAndIdle());

            
            }


            }  // 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/socks_client_socket.h"

	#include "net/base/address_list.h"
	#include "net/base/net_log.h"
	#include "net/base/net_log_unittest.h"
	#include "net/base/mock_host_resolver.h"
	#include "net/base/test_completion_callback.h"
	#include "net/socket/client_socket_factory.h"
	#include "net/socket/tcp_client_socket.h"
	#include "net/socket/socket_test_util.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "testing/platform_test.h"

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

	namespace net {

	const char kSOCKSOkRequest[] = { 0x04, 0x01, 0x00, 0x50, 127, 0, 0, 1, 0 };
	const char kSOCKSOkReply[] = { 0x00, 0x5A, 0x00, 0x00, 0, 0, 0, 0 };

	class SOCKSClientSocketTest : public PlatformTest {
	public:
	SOCKSClientSocketTest();
	// Create a SOCKSClientSocket on top of a MockSocket.
	SOCKSClientSocket* BuildMockSocket(MockRead reads[], size_t reads_count,
	MockWrite writes[], size_t writes_count,
	HostResolver* host_resolver,
	const std::string& hostname, int port,
	NetLog* net_log);
	virtual void SetUp();

	protected:
	scoped_ptr<SOCKSClientSocket> user_sock_;
	AddressList address_list_;
	StreamSocket* tcp_sock_;
	TestCompletionCallback callback_;
	scoped_ptr<MockHostResolver> host_resolver_;
	scoped_ptr<SocketDataProvider> data_;
	};

	SOCKSClientSocketTest::SOCKSClientSocketTest()
	: host_resolver_(new MockHostResolver) {
	}

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

	SOCKSClientSocket* SOCKSClientSocketTest::BuildMockSocket(
	MockRead reads[],
	size_t reads_count,
	MockWrite writes[],
	size_t writes_count,
	HostResolver* host_resolver,
	const std::string& hostname,
	int port,
	NetLog* net_log) {

	TestCompletionCallback callback;
	data_.reset(new StaticSocketDataProvider(reads, reads_count,
	writes, writes_count));
	tcp_sock_ = new MockTCPClientSocket(address_list_, net_log, data_.get());

	int rv = tcp_sock_->Connect(callback.callback());
	EXPECT_EQ(ERR_IO_PENDING, rv);
	rv = callback.WaitForResult();
	EXPECT_EQ(OK, rv);
	EXPECT_TRUE(tcp_sock_->IsConnected());

	return new SOCKSClientSocket(tcp_sock_,
	HostResolver::RequestInfo(HostPortPair(hostname, port)),
	host_resolver);
	}

	// Implementation of HostResolver that never completes its resolve request.
	// We use this in the test "DisconnectWhileHostResolveInProgress" to make
	// sure that the outstanding resolve request gets cancelled.
	class HangingHostResolverWithCancel : public HostResolver {
	public:
	HangingHostResolverWithCancel() : outstanding_request_(NULL) {}

	virtual int Resolve(const RequestInfo& info,
	AddressList* addresses,
	const CompletionCallback& callback,
	RequestHandle* out_req,
	const BoundNetLog& net_log) OVERRIDE {
	DCHECK(addresses);
	DCHECK_EQ(false, callback.is_null());
	EXPECT_FALSE(HasOutstandingRequest());
	outstanding_request_ = reinterpret_cast<RequestHandle>(1);
	*out_req = outstanding_request_;
	return ERR_IO_PENDING;
	}

	virtual int ResolveFromCache(const RequestInfo& info,
	AddressList* addresses,
	const BoundNetLog& net_log) OVERRIDE {
	NOTIMPLEMENTED();
	return ERR_UNEXPECTED;
	}

	virtual void CancelRequest(RequestHandle req) OVERRIDE {
	EXPECT_TRUE(HasOutstandingRequest());
	EXPECT_EQ(outstanding_request_, req);
	outstanding_request_ = NULL;
	}

	bool HasOutstandingRequest() {
	return outstanding_request_ != NULL;
	}

	private:
	RequestHandle outstanding_request_;

	DISALLOW_COPY_AND_ASSIGN(HangingHostResolverWithCancel);
	};

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

	MockWrite data_writes[] = {
	MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)),
	MockWrite(ASYNC, payload_write.data(), payload_write.size()) };
	MockRead data_reads[] = {
	MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)),
	MockRead(ASYNC, payload_read.data(), payload_read.size()) };
	CapturingNetLog log;

	user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
	data_writes, arraysize(data_writes),
	host_resolver_.get(),
	"localhost", 80,
	&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_EQ(ERR_IO_PENDING, rv);

	CapturingNetLog::CapturedEntryList entries;
	log.GetEntries(&entries);
	EXPECT_TRUE(
	LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));
	EXPECT_FALSE(user_sock_->IsConnected());

	rv = callback_.WaitForResult();
	EXPECT_EQ(OK, rv);
	EXPECT_TRUE(user_sock_->IsConnected());
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsEndEvent(
	entries, -1, NetLog::TYPE_SOCKS_CONNECT));

	scoped_refptr<IOBuffer> buffer(new IOBuffer(payload_write.size()));
	memcpy(buffer->data(), payload_write.data(), payload_write.size());
	rv = user_sock_->Write(buffer, payload_write.size(), callback_.callback());
	EXPECT_EQ(ERR_IO_PENDING, rv);
	rv = callback_.WaitForResult();
	EXPECT_EQ(static_cast<int>(payload_write.size()), rv);

	buffer = new IOBuffer(payload_read.size());
	rv = user_sock_->Read(buffer, payload_read.size(), callback_.callback());
	EXPECT_EQ(ERR_IO_PENDING, rv);
	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());
	}

	// List of responses from the socks server and the errors they should
	// throw up are tested here.
	TEST_F(SOCKSClientSocketTest, HandshakeFailures) {
	const struct {
	const char fail_reply[8];
	Error fail_code;
	} tests[] = {
	// Failure of the server response code
	{
	{ 0x01, 0x5A, 0x00, 0x00, 0, 0, 0, 0 },
	ERR_SOCKS_CONNECTION_FAILED,
	},
	// Failure of the null byte
	{
	{ 0x00, 0x5B, 0x00, 0x00, 0, 0, 0, 0 },
	ERR_SOCKS_CONNECTION_FAILED,
	},
	};

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

	for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
	MockWrite data_writes[] = {
	MockWrite(SYNCHRONOUS, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
	MockRead data_reads[] = {
	MockRead(SYNCHRONOUS, tests[i].fail_reply,
	arraysize(tests[i].fail_reply)) };
	CapturingNetLog log;

	user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
	data_writes, arraysize(data_writes),
	host_resolver_.get(),
	"localhost", 80,
	&log));

	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_EQ(ERR_IO_PENDING, rv);

	CapturingNetLog::CapturedEntryList entries;
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsBeginEvent(
	entries, 0, NetLog::TYPE_SOCKS_CONNECT));

	rv = callback_.WaitForResult();
	EXPECT_EQ(tests[i].fail_code, rv);
	EXPECT_FALSE(user_sock_->IsConnected());
	EXPECT_TRUE(tcp_sock_->IsConnected());
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsEndEvent(
	entries, -1, NetLog::TYPE_SOCKS_CONNECT));
	}
	}

	// Tests scenario when the server sends the handshake response in
	// more than one packet.
	TEST_F(SOCKSClientSocketTest, PartialServerReads) {
	const char kSOCKSPartialReply1[] = { 0x00 };
	const char kSOCKSPartialReply2[] = { 0x5A, 0x00, 0x00, 0, 0, 0, 0 };

	MockWrite data_writes[] = {
	MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
	MockRead data_reads[] = {
	MockRead(ASYNC, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)),
	MockRead(ASYNC, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) };
	CapturingNetLog log;

	user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
	data_writes, arraysize(data_writes),
	host_resolver_.get(),
	"localhost", 80,
	&log));

	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_EQ(ERR_IO_PENDING, rv);
	CapturingNetLog::CapturedEntryList entries;
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsBeginEvent(
	entries, 0, NetLog::TYPE_SOCKS_CONNECT));

	rv = callback_.WaitForResult();
	EXPECT_EQ(OK, rv);
	EXPECT_TRUE(user_sock_->IsConnected());
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsEndEvent(
	entries, -1, NetLog::TYPE_SOCKS_CONNECT));
	}

	// Tests scenario when the client sends the handshake request in
	// more than one packet.
	TEST_F(SOCKSClientSocketTest, PartialClientWrites) {
	const char kSOCKSPartialRequest1[] = { 0x04, 0x01 };
	const char kSOCKSPartialRequest2[] = { 0x00, 0x50, 127, 0, 0, 1, 0 };

	MockWrite data_writes[] = {
	MockWrite(ASYNC, arraysize(kSOCKSPartialRequest1)),
	// simulate some empty writes
	MockWrite(ASYNC, 0),
	MockWrite(ASYNC, 0),
	MockWrite(ASYNC, kSOCKSPartialRequest2,
	arraysize(kSOCKSPartialRequest2)) };
	MockRead data_reads[] = {
	MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)) };
	CapturingNetLog log;

	user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
	data_writes, arraysize(data_writes),
	host_resolver_.get(),
	"localhost", 80,
	&log));

	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_EQ(ERR_IO_PENDING, rv);
	CapturingNetLog::CapturedEntryList entries;
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsBeginEvent(
	entries, 0, NetLog::TYPE_SOCKS_CONNECT));

	rv = callback_.WaitForResult();
	EXPECT_EQ(OK, rv);
	EXPECT_TRUE(user_sock_->IsConnected());
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsEndEvent(
	entries, -1, NetLog::TYPE_SOCKS_CONNECT));
	}

	// Tests the case when the server sends a smaller sized handshake data
	// and closes the connection.
	TEST_F(SOCKSClientSocketTest, FailedSocketRead) {
	MockWrite data_writes[] = {
	MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
	MockRead data_reads[] = {
	MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply) - 2),
	// close connection unexpectedly
	MockRead(SYNCHRONOUS, 0) };
	CapturingNetLog log;

	user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
	data_writes, arraysize(data_writes),
	host_resolver_.get(),
	"localhost", 80,
	&log));

	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_EQ(ERR_IO_PENDING, rv);
	CapturingNetLog::CapturedEntryList entries;
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsBeginEvent(
	entries, 0, NetLog::TYPE_SOCKS_CONNECT));

	rv = callback_.WaitForResult();
	EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
	EXPECT_FALSE(user_sock_->IsConnected());
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsEndEvent(
	entries, -1, NetLog::TYPE_SOCKS_CONNECT));
	}

	// Tries to connect to an unknown hostname. Should fail rather than
	// falling back to SOCKS4a.
	TEST_F(SOCKSClientSocketTest, FailedDNS) {
	const char hostname[] = "unresolved.ipv4.address";

	host_resolver_->rules()->AddSimulatedFailure(hostname);

	CapturingNetLog log;

	user_sock_.reset(BuildMockSocket(NULL, 0,
	NULL, 0,
	host_resolver_.get(),
	hostname, 80,
	&log));

	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_EQ(ERR_IO_PENDING, rv);
	CapturingNetLog::CapturedEntryList entries;
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsBeginEvent(
	entries, 0, NetLog::TYPE_SOCKS_CONNECT));

	rv = callback_.WaitForResult();
	EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
	EXPECT_FALSE(user_sock_->IsConnected());
	log.GetEntries(&entries);
	EXPECT_TRUE(LogContainsEndEvent(
	entries, -1, NetLog::TYPE_SOCKS_CONNECT));
	}

	// Calls Disconnect() while a host resolve is in progress. The outstanding host
	// resolve should be cancelled.
	TEST_F(SOCKSClientSocketTest, DisconnectWhileHostResolveInProgress) {
	scoped_ptr<HangingHostResolverWithCancel> hanging_resolver(
	new HangingHostResolverWithCancel());

	// Doesn't matter what the socket data is, we will never use it -- garbage.
	MockWrite data_writes[] = { MockWrite(SYNCHRONOUS, "", 0) };
	MockRead data_reads[] = { MockRead(SYNCHRONOUS, "", 0) };

	user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
	data_writes, arraysize(data_writes),
	hanging_resolver.get(),
	"foo", 80,
	NULL));

	// Start connecting (will get stuck waiting for the host to resolve).
	int rv = user_sock_->Connect(callback_.callback());
	EXPECT_EQ(ERR_IO_PENDING, rv);

	EXPECT_FALSE(user_sock_->IsConnected());
	EXPECT_FALSE(user_sock_->IsConnectedAndIdle());

	// The host resolver should have received the resolve request.
	EXPECT_TRUE(hanging_resolver->HasOutstandingRequest());

	// Disconnect the SOCKS socket -- this should cancel the outstanding resolve.
	user_sock_->Disconnect();

	EXPECT_FALSE(hanging_resolver->HasOutstandingRequest());

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

	} // namespace net