1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "net/socket/socks_client_socket.h" 6 7 #include "base/memory/scoped_ptr.h" 8 #include "net/base/address_list.h" 9 #include "net/base/net_log.h" 10 #include "net/base/net_log_unittest.h" 11 #include "net/base/test_completion_callback.h" 12 #include "net/base/winsock_init.h" 13 #include "net/dns/host_resolver.h" 14 #include "net/dns/mock_host_resolver.h" 15 #include "net/socket/client_socket_factory.h" 16 #include "net/socket/socket_test_util.h" 17 #include "net/socket/tcp_client_socket.h" 18 #include "testing/gtest/include/gtest/gtest.h" 19 #include "testing/platform_test.h" 20 21 //----------------------------------------------------------------------------- 22 23 namespace net { 24 25 const char kSOCKSOkRequest[] = { 0x04, 0x01, 0x00, 0x50, 127, 0, 0, 1, 0 }; 26 const char kSOCKSOkReply[] = { 0x00, 0x5A, 0x00, 0x00, 0, 0, 0, 0 }; 27 28 class SOCKSClientSocketTest : public PlatformTest { 29 public: 30 SOCKSClientSocketTest(); 31 // Create a SOCKSClientSocket on top of a MockSocket. 32 scoped_ptr<SOCKSClientSocket> BuildMockSocket( 33 MockRead reads[], size_t reads_count, 34 MockWrite writes[], size_t writes_count, 35 HostResolver* host_resolver, 36 const std::string& hostname, int port, 37 NetLog* net_log); 38 virtual void SetUp(); 39 40 protected: 41 scoped_ptr<SOCKSClientSocket> user_sock_; 42 AddressList address_list_; 43 // Filled in by BuildMockSocket() and owned by its return value 44 // (which |user_sock| is set to). 45 StreamSocket* tcp_sock_; 46 TestCompletionCallback callback_; 47 scoped_ptr<MockHostResolver> host_resolver_; 48 scoped_ptr<SocketDataProvider> data_; 49 }; 50 51 SOCKSClientSocketTest::SOCKSClientSocketTest() 52 : host_resolver_(new MockHostResolver) { 53 } 54 55 // Set up platform before every test case 56 void SOCKSClientSocketTest::SetUp() { 57 PlatformTest::SetUp(); 58 } 59 60 scoped_ptr<SOCKSClientSocket> SOCKSClientSocketTest::BuildMockSocket( 61 MockRead reads[], 62 size_t reads_count, 63 MockWrite writes[], 64 size_t writes_count, 65 HostResolver* host_resolver, 66 const std::string& hostname, 67 int port, 68 NetLog* net_log) { 69 70 TestCompletionCallback callback; 71 data_.reset(new StaticSocketDataProvider(reads, reads_count, 72 writes, writes_count)); 73 tcp_sock_ = new MockTCPClientSocket(address_list_, net_log, data_.get()); 74 75 int rv = tcp_sock_->Connect(callback.callback()); 76 EXPECT_EQ(ERR_IO_PENDING, rv); 77 rv = callback.WaitForResult(); 78 EXPECT_EQ(OK, rv); 79 EXPECT_TRUE(tcp_sock_->IsConnected()); 80 81 scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle); 82 // |connection| takes ownership of |tcp_sock_|, but keep a 83 // non-owning pointer to it. 84 connection->SetSocket(scoped_ptr<StreamSocket>(tcp_sock_)); 85 return scoped_ptr<SOCKSClientSocket>(new SOCKSClientSocket( 86 connection.Pass(), 87 HostResolver::RequestInfo(HostPortPair(hostname, port)), 88 DEFAULT_PRIORITY, 89 host_resolver)); 90 } 91 92 // Implementation of HostResolver that never completes its resolve request. 93 // We use this in the test "DisconnectWhileHostResolveInProgress" to make 94 // sure that the outstanding resolve request gets cancelled. 95 class HangingHostResolverWithCancel : public HostResolver { 96 public: 97 HangingHostResolverWithCancel() : outstanding_request_(NULL) {} 98 99 virtual int Resolve(const RequestInfo& info, 100 RequestPriority priority, 101 AddressList* addresses, 102 const CompletionCallback& callback, 103 RequestHandle* out_req, 104 const BoundNetLog& net_log) OVERRIDE { 105 DCHECK(addresses); 106 DCHECK_EQ(false, callback.is_null()); 107 EXPECT_FALSE(HasOutstandingRequest()); 108 outstanding_request_ = reinterpret_cast<RequestHandle>(1); 109 *out_req = outstanding_request_; 110 return ERR_IO_PENDING; 111 } 112 113 virtual int ResolveFromCache(const RequestInfo& info, 114 AddressList* addresses, 115 const BoundNetLog& net_log) OVERRIDE { 116 NOTIMPLEMENTED(); 117 return ERR_UNEXPECTED; 118 } 119 120 virtual void CancelRequest(RequestHandle req) OVERRIDE { 121 EXPECT_TRUE(HasOutstandingRequest()); 122 EXPECT_EQ(outstanding_request_, req); 123 outstanding_request_ = NULL; 124 } 125 126 bool HasOutstandingRequest() { 127 return outstanding_request_ != NULL; 128 } 129 130 private: 131 RequestHandle outstanding_request_; 132 133 DISALLOW_COPY_AND_ASSIGN(HangingHostResolverWithCancel); 134 }; 135 136 // Tests a complete handshake and the disconnection. 137 TEST_F(SOCKSClientSocketTest, CompleteHandshake) { 138 const std::string payload_write = "random data"; 139 const std::string payload_read = "moar random data"; 140 141 MockWrite data_writes[] = { 142 MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)), 143 MockWrite(ASYNC, payload_write.data(), payload_write.size()) }; 144 MockRead data_reads[] = { 145 MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)), 146 MockRead(ASYNC, payload_read.data(), payload_read.size()) }; 147 CapturingNetLog log; 148 149 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), 150 data_writes, arraysize(data_writes), 151 host_resolver_.get(), 152 "localhost", 80, 153 &log); 154 155 // At this state the TCP connection is completed but not the SOCKS handshake. 156 EXPECT_TRUE(tcp_sock_->IsConnected()); 157 EXPECT_FALSE(user_sock_->IsConnected()); 158 159 int rv = user_sock_->Connect(callback_.callback()); 160 EXPECT_EQ(ERR_IO_PENDING, rv); 161 162 CapturingNetLog::CapturedEntryList entries; 163 log.GetEntries(&entries); 164 EXPECT_TRUE( 165 LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT)); 166 EXPECT_FALSE(user_sock_->IsConnected()); 167 168 rv = callback_.WaitForResult(); 169 EXPECT_EQ(OK, rv); 170 EXPECT_TRUE(user_sock_->IsConnected()); 171 log.GetEntries(&entries); 172 EXPECT_TRUE(LogContainsEndEvent( 173 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); 174 175 scoped_refptr<IOBuffer> buffer(new IOBuffer(payload_write.size())); 176 memcpy(buffer->data(), payload_write.data(), payload_write.size()); 177 rv = user_sock_->Write( 178 buffer.get(), payload_write.size(), callback_.callback()); 179 EXPECT_EQ(ERR_IO_PENDING, rv); 180 rv = callback_.WaitForResult(); 181 EXPECT_EQ(static_cast<int>(payload_write.size()), rv); 182 183 buffer = new IOBuffer(payload_read.size()); 184 rv = 185 user_sock_->Read(buffer.get(), payload_read.size(), callback_.callback()); 186 EXPECT_EQ(ERR_IO_PENDING, rv); 187 rv = callback_.WaitForResult(); 188 EXPECT_EQ(static_cast<int>(payload_read.size()), rv); 189 EXPECT_EQ(payload_read, std::string(buffer->data(), payload_read.size())); 190 191 user_sock_->Disconnect(); 192 EXPECT_FALSE(tcp_sock_->IsConnected()); 193 EXPECT_FALSE(user_sock_->IsConnected()); 194 } 195 196 // List of responses from the socks server and the errors they should 197 // throw up are tested here. 198 TEST_F(SOCKSClientSocketTest, HandshakeFailures) { 199 const struct { 200 const char fail_reply[8]; 201 Error fail_code; 202 } tests[] = { 203 // Failure of the server response code 204 { 205 { 0x01, 0x5A, 0x00, 0x00, 0, 0, 0, 0 }, 206 ERR_SOCKS_CONNECTION_FAILED, 207 }, 208 // Failure of the null byte 209 { 210 { 0x00, 0x5B, 0x00, 0x00, 0, 0, 0, 0 }, 211 ERR_SOCKS_CONNECTION_FAILED, 212 }, 213 }; 214 215 //--------------------------------------- 216 217 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) { 218 MockWrite data_writes[] = { 219 MockWrite(SYNCHRONOUS, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; 220 MockRead data_reads[] = { 221 MockRead(SYNCHRONOUS, tests[i].fail_reply, 222 arraysize(tests[i].fail_reply)) }; 223 CapturingNetLog log; 224 225 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), 226 data_writes, arraysize(data_writes), 227 host_resolver_.get(), 228 "localhost", 80, 229 &log); 230 231 int rv = user_sock_->Connect(callback_.callback()); 232 EXPECT_EQ(ERR_IO_PENDING, rv); 233 234 CapturingNetLog::CapturedEntryList entries; 235 log.GetEntries(&entries); 236 EXPECT_TRUE(LogContainsBeginEvent( 237 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); 238 239 rv = callback_.WaitForResult(); 240 EXPECT_EQ(tests[i].fail_code, rv); 241 EXPECT_FALSE(user_sock_->IsConnected()); 242 EXPECT_TRUE(tcp_sock_->IsConnected()); 243 log.GetEntries(&entries); 244 EXPECT_TRUE(LogContainsEndEvent( 245 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); 246 } 247 } 248 249 // Tests scenario when the server sends the handshake response in 250 // more than one packet. 251 TEST_F(SOCKSClientSocketTest, PartialServerReads) { 252 const char kSOCKSPartialReply1[] = { 0x00 }; 253 const char kSOCKSPartialReply2[] = { 0x5A, 0x00, 0x00, 0, 0, 0, 0 }; 254 255 MockWrite data_writes[] = { 256 MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; 257 MockRead data_reads[] = { 258 MockRead(ASYNC, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)), 259 MockRead(ASYNC, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) }; 260 CapturingNetLog log; 261 262 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), 263 data_writes, arraysize(data_writes), 264 host_resolver_.get(), 265 "localhost", 80, 266 &log); 267 268 int rv = user_sock_->Connect(callback_.callback()); 269 EXPECT_EQ(ERR_IO_PENDING, rv); 270 CapturingNetLog::CapturedEntryList entries; 271 log.GetEntries(&entries); 272 EXPECT_TRUE(LogContainsBeginEvent( 273 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); 274 275 rv = callback_.WaitForResult(); 276 EXPECT_EQ(OK, rv); 277 EXPECT_TRUE(user_sock_->IsConnected()); 278 log.GetEntries(&entries); 279 EXPECT_TRUE(LogContainsEndEvent( 280 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); 281 } 282 283 // Tests scenario when the client sends the handshake request in 284 // more than one packet. 285 TEST_F(SOCKSClientSocketTest, PartialClientWrites) { 286 const char kSOCKSPartialRequest1[] = { 0x04, 0x01 }; 287 const char kSOCKSPartialRequest2[] = { 0x00, 0x50, 127, 0, 0, 1, 0 }; 288 289 MockWrite data_writes[] = { 290 MockWrite(ASYNC, arraysize(kSOCKSPartialRequest1)), 291 // simulate some empty writes 292 MockWrite(ASYNC, 0), 293 MockWrite(ASYNC, 0), 294 MockWrite(ASYNC, kSOCKSPartialRequest2, 295 arraysize(kSOCKSPartialRequest2)) }; 296 MockRead data_reads[] = { 297 MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)) }; 298 CapturingNetLog log; 299 300 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), 301 data_writes, arraysize(data_writes), 302 host_resolver_.get(), 303 "localhost", 80, 304 &log); 305 306 int rv = user_sock_->Connect(callback_.callback()); 307 EXPECT_EQ(ERR_IO_PENDING, rv); 308 CapturingNetLog::CapturedEntryList entries; 309 log.GetEntries(&entries); 310 EXPECT_TRUE(LogContainsBeginEvent( 311 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); 312 313 rv = callback_.WaitForResult(); 314 EXPECT_EQ(OK, rv); 315 EXPECT_TRUE(user_sock_->IsConnected()); 316 log.GetEntries(&entries); 317 EXPECT_TRUE(LogContainsEndEvent( 318 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); 319 } 320 321 // Tests the case when the server sends a smaller sized handshake data 322 // and closes the connection. 323 TEST_F(SOCKSClientSocketTest, FailedSocketRead) { 324 MockWrite data_writes[] = { 325 MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; 326 MockRead data_reads[] = { 327 MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply) - 2), 328 // close connection unexpectedly 329 MockRead(SYNCHRONOUS, 0) }; 330 CapturingNetLog log; 331 332 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), 333 data_writes, arraysize(data_writes), 334 host_resolver_.get(), 335 "localhost", 80, 336 &log); 337 338 int rv = user_sock_->Connect(callback_.callback()); 339 EXPECT_EQ(ERR_IO_PENDING, rv); 340 CapturingNetLog::CapturedEntryList entries; 341 log.GetEntries(&entries); 342 EXPECT_TRUE(LogContainsBeginEvent( 343 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); 344 345 rv = callback_.WaitForResult(); 346 EXPECT_EQ(ERR_CONNECTION_CLOSED, rv); 347 EXPECT_FALSE(user_sock_->IsConnected()); 348 log.GetEntries(&entries); 349 EXPECT_TRUE(LogContainsEndEvent( 350 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); 351 } 352 353 // Tries to connect to an unknown hostname. Should fail rather than 354 // falling back to SOCKS4a. 355 TEST_F(SOCKSClientSocketTest, FailedDNS) { 356 const char hostname[] = "unresolved.ipv4.address"; 357 358 host_resolver_->rules()->AddSimulatedFailure(hostname); 359 360 CapturingNetLog log; 361 362 user_sock_ = BuildMockSocket(NULL, 0, 363 NULL, 0, 364 host_resolver_.get(), 365 hostname, 80, 366 &log); 367 368 int rv = user_sock_->Connect(callback_.callback()); 369 EXPECT_EQ(ERR_IO_PENDING, rv); 370 CapturingNetLog::CapturedEntryList entries; 371 log.GetEntries(&entries); 372 EXPECT_TRUE(LogContainsBeginEvent( 373 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); 374 375 rv = callback_.WaitForResult(); 376 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); 377 EXPECT_FALSE(user_sock_->IsConnected()); 378 log.GetEntries(&entries); 379 EXPECT_TRUE(LogContainsEndEvent( 380 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); 381 } 382 383 // Calls Disconnect() while a host resolve is in progress. The outstanding host 384 // resolve should be cancelled. 385 TEST_F(SOCKSClientSocketTest, DisconnectWhileHostResolveInProgress) { 386 scoped_ptr<HangingHostResolverWithCancel> hanging_resolver( 387 new HangingHostResolverWithCancel()); 388 389 // Doesn't matter what the socket data is, we will never use it -- garbage. 390 MockWrite data_writes[] = { MockWrite(SYNCHRONOUS, "", 0) }; 391 MockRead data_reads[] = { MockRead(SYNCHRONOUS, "", 0) }; 392 393 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), 394 data_writes, arraysize(data_writes), 395 hanging_resolver.get(), 396 "foo", 80, 397 NULL); 398 399 // Start connecting (will get stuck waiting for the host to resolve). 400 int rv = user_sock_->Connect(callback_.callback()); 401 EXPECT_EQ(ERR_IO_PENDING, rv); 402 403 EXPECT_FALSE(user_sock_->IsConnected()); 404 EXPECT_FALSE(user_sock_->IsConnectedAndIdle()); 405 406 // The host resolver should have received the resolve request. 407 EXPECT_TRUE(hanging_resolver->HasOutstandingRequest()); 408 409 // Disconnect the SOCKS socket -- this should cancel the outstanding resolve. 410 user_sock_->Disconnect(); 411 412 EXPECT_FALSE(hanging_resolver->HasOutstandingRequest()); 413 414 EXPECT_FALSE(user_sock_->IsConnected()); 415 EXPECT_FALSE(user_sock_->IsConnectedAndIdle()); 416 } 417 418 // Tries to connect to an IPv6 IP. Should fail, as SOCKS4 does not support 419 // IPv6. 420 TEST_F(SOCKSClientSocketTest, NoIPv6) { 421 const char kHostName[] = "::1"; 422 423 user_sock_ = BuildMockSocket(NULL, 0, 424 NULL, 0, 425 host_resolver_.get(), 426 kHostName, 80, 427 NULL); 428 429 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, 430 callback_.GetResult(user_sock_->Connect(callback_.callback()))); 431 } 432 433 // Same as above, but with a real resolver, to protect against regressions. 434 TEST_F(SOCKSClientSocketTest, NoIPv6RealResolver) { 435 const char kHostName[] = "::1"; 436 437 scoped_ptr<HostResolver> host_resolver( 438 HostResolver::CreateSystemResolver(HostResolver::Options(), NULL)); 439 440 user_sock_ = BuildMockSocket(NULL, 0, 441 NULL, 0, 442 host_resolver.get(), 443 kHostName, 80, 444 NULL); 445 446 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, 447 callback_.GetResult(user_sock_->Connect(callback_.callback()))); 448 } 449 450 } // namespace net 451
