// 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/base/winsock_init.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 user_sock_; AddressList address_list_; StreamSocket* tcp_sock_; TestCompletionCallback callback_; scoped_ptr host_resolver_; scoped_ptr 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(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 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(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(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 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