1 // Copyright (c) 2011 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/tcp_client_socket.h" 6 7 #include "base/basictypes.h" 8 #include "net/base/address_list.h" 9 #include "net/base/host_resolver.h" 10 #include "net/base/io_buffer.h" 11 #include "net/base/listen_socket.h" 12 #include "net/base/net_log.h" 13 #include "net/base/net_log_unittest.h" 14 #include "net/base/net_errors.h" 15 #include "net/base/test_completion_callback.h" 16 #include "net/base/winsock_init.h" 17 #include "net/socket/client_socket_factory.h" 18 #include "testing/gtest/include/gtest/gtest.h" 19 #include "testing/platform_test.h" 20 21 namespace net { 22 23 namespace { 24 25 const char kServerReply[] = "HTTP/1.1 404 Not Found"; 26 27 enum ClientSocketTestTypes { 28 TCP, 29 SCTP 30 }; 31 32 class TransportClientSocketTest 33 : public ListenSocket::ListenSocketDelegate, 34 public ::testing::TestWithParam<ClientSocketTestTypes> { 35 public: 36 TransportClientSocketTest() 37 : listen_port_(0), 38 net_log_(CapturingNetLog::kUnbounded), 39 socket_factory_(ClientSocketFactory::GetDefaultFactory()), 40 close_server_socket_on_next_send_(false) { 41 } 42 43 ~TransportClientSocketTest() { 44 } 45 46 // Implement ListenSocketDelegate methods 47 virtual void DidAccept(ListenSocket* server, ListenSocket* connection) { 48 connected_sock_ = connection; 49 } 50 virtual void DidRead(ListenSocket*, const char* str, int len) { 51 // TODO(dkegel): this might not be long enough to tickle some bugs. 52 connected_sock_->Send(kServerReply, arraysize(kServerReply) - 1, 53 false /* Don't append line feed */); 54 if (close_server_socket_on_next_send_) 55 CloseServerSocket(); 56 } 57 virtual void DidClose(ListenSocket* sock) {} 58 59 // Testcase hooks 60 virtual void SetUp(); 61 62 void CloseServerSocket() { 63 // delete the connected_sock_, which will close it. 64 connected_sock_ = NULL; 65 } 66 67 void PauseServerReads() { 68 connected_sock_->PauseReads(); 69 } 70 71 void ResumeServerReads() { 72 connected_sock_->ResumeReads(); 73 } 74 75 int DrainClientSocket(IOBuffer* buf, 76 uint32 buf_len, 77 uint32 bytes_to_read, 78 TestCompletionCallback* callback); 79 80 void SendClientRequest(); 81 82 void set_close_server_socket_on_next_send(bool close) { 83 close_server_socket_on_next_send_ = close; 84 } 85 86 protected: 87 int listen_port_; 88 CapturingNetLog net_log_; 89 ClientSocketFactory* const socket_factory_; 90 scoped_ptr<ClientSocket> sock_; 91 92 private: 93 scoped_refptr<ListenSocket> listen_sock_; 94 scoped_refptr<ListenSocket> connected_sock_; 95 bool close_server_socket_on_next_send_; 96 }; 97 98 void TransportClientSocketTest::SetUp() { 99 ::testing::TestWithParam<ClientSocketTestTypes>::SetUp(); 100 101 // Find a free port to listen on 102 ListenSocket *sock = NULL; 103 int port; 104 // Range of ports to listen on. Shouldn't need to try many. 105 const int kMinPort = 10100; 106 const int kMaxPort = 10200; 107 #if defined(OS_WIN) 108 EnsureWinsockInit(); 109 #endif 110 for (port = kMinPort; port < kMaxPort; port++) { 111 sock = ListenSocket::Listen("127.0.0.1", port, this); 112 if (sock) 113 break; 114 } 115 ASSERT_TRUE(sock != NULL); 116 listen_sock_ = sock; 117 listen_port_ = port; 118 119 AddressList addr; 120 scoped_ptr<HostResolver> resolver( 121 CreateSystemHostResolver(HostResolver::kDefaultParallelism, 122 NULL, NULL)); 123 HostResolver::RequestInfo info(HostPortPair("localhost", listen_port_)); 124 int rv = resolver->Resolve(info, &addr, NULL, NULL, BoundNetLog()); 125 CHECK_EQ(rv, OK); 126 sock_.reset( 127 socket_factory_->CreateTransportClientSocket(addr, 128 &net_log_, 129 NetLog::Source())); 130 } 131 132 int TransportClientSocketTest::DrainClientSocket( 133 IOBuffer* buf, uint32 buf_len, 134 uint32 bytes_to_read, TestCompletionCallback* callback) { 135 int rv = OK; 136 uint32 bytes_read = 0; 137 138 while (bytes_read < bytes_to_read) { 139 rv = sock_->Read(buf, buf_len, callback); 140 EXPECT_TRUE(rv >= 0 || rv == ERR_IO_PENDING); 141 142 if (rv == ERR_IO_PENDING) 143 rv = callback->WaitForResult(); 144 145 EXPECT_GE(rv, 0); 146 bytes_read += rv; 147 } 148 149 return static_cast<int>(bytes_read); 150 } 151 152 void TransportClientSocketTest::SendClientRequest() { 153 const char request_text[] = "GET / HTTP/1.0\r\n\r\n"; 154 scoped_refptr<IOBuffer> request_buffer( 155 new IOBuffer(arraysize(request_text) - 1)); 156 TestCompletionCallback callback; 157 int rv; 158 159 memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1); 160 rv = sock_->Write(request_buffer, arraysize(request_text) - 1, &callback); 161 EXPECT_TRUE(rv >= 0 || rv == ERR_IO_PENDING); 162 163 if (rv == ERR_IO_PENDING) { 164 rv = callback.WaitForResult(); 165 EXPECT_EQ(rv, static_cast<int>(arraysize(request_text) - 1)); 166 } 167 } 168 169 // TODO(leighton): Add SCTP to this list when it is ready. 170 INSTANTIATE_TEST_CASE_P(ClientSocket, 171 TransportClientSocketTest, 172 ::testing::Values(TCP)); 173 174 TEST_P(TransportClientSocketTest, Connect) { 175 TestCompletionCallback callback; 176 EXPECT_FALSE(sock_->IsConnected()); 177 178 int rv = sock_->Connect(&callback); 179 180 net::CapturingNetLog::EntryList net_log_entries; 181 net_log_.GetEntries(&net_log_entries); 182 EXPECT_TRUE(net::LogContainsBeginEvent( 183 net_log_entries, 0, net::NetLog::TYPE_SOCKET_ALIVE)); 184 EXPECT_TRUE(net::LogContainsBeginEvent( 185 net_log_entries, 1, net::NetLog::TYPE_TCP_CONNECT)); 186 if (rv != OK) { 187 ASSERT_EQ(rv, ERR_IO_PENDING); 188 rv = callback.WaitForResult(); 189 EXPECT_EQ(rv, OK); 190 } 191 192 EXPECT_TRUE(sock_->IsConnected()); 193 net_log_.GetEntries(&net_log_entries); 194 EXPECT_TRUE(net::LogContainsEndEvent( 195 net_log_entries, -1, net::NetLog::TYPE_TCP_CONNECT)); 196 197 sock_->Disconnect(); 198 EXPECT_FALSE(sock_->IsConnected()); 199 } 200 201 TEST_P(TransportClientSocketTest, IsConnected) { 202 scoped_refptr<IOBuffer> buf(new IOBuffer(4096)); 203 TestCompletionCallback callback; 204 uint32 bytes_read; 205 206 EXPECT_FALSE(sock_->IsConnected()); 207 EXPECT_FALSE(sock_->IsConnectedAndIdle()); 208 int rv = sock_->Connect(&callback); 209 if (rv != OK) { 210 ASSERT_EQ(rv, ERR_IO_PENDING); 211 rv = callback.WaitForResult(); 212 EXPECT_EQ(rv, OK); 213 } 214 EXPECT_TRUE(sock_->IsConnected()); 215 EXPECT_TRUE(sock_->IsConnectedAndIdle()); 216 217 // Send the request and wait for the server to respond. 218 SendClientRequest(); 219 220 // Drain a single byte so we know we've received some data. 221 bytes_read = DrainClientSocket(buf, 1, 1, &callback); 222 ASSERT_EQ(bytes_read, 1u); 223 224 // Socket should be considered connected, but not idle, due to 225 // pending data. 226 EXPECT_TRUE(sock_->IsConnected()); 227 EXPECT_FALSE(sock_->IsConnectedAndIdle()); 228 229 bytes_read = DrainClientSocket(buf, 4096, arraysize(kServerReply) - 2, 230 &callback); 231 ASSERT_EQ(bytes_read, arraysize(kServerReply) - 2); 232 233 // After draining the data, the socket should be back to connected 234 // and idle. 235 EXPECT_TRUE(sock_->IsConnected()); 236 EXPECT_TRUE(sock_->IsConnectedAndIdle()); 237 238 // This time close the server socket immediately after the server response. 239 set_close_server_socket_on_next_send(true); 240 SendClientRequest(); 241 242 bytes_read = DrainClientSocket(buf, 1, 1, &callback); 243 ASSERT_EQ(bytes_read, 1u); 244 245 // As above because of data. 246 EXPECT_TRUE(sock_->IsConnected()); 247 EXPECT_FALSE(sock_->IsConnectedAndIdle()); 248 249 bytes_read = DrainClientSocket(buf, 4096, arraysize(kServerReply) - 2, 250 &callback); 251 ASSERT_EQ(bytes_read, arraysize(kServerReply) - 2); 252 253 // Once the data is drained, the socket should now be seen as 254 // closed. 255 EXPECT_FALSE(sock_->IsConnected()); 256 EXPECT_FALSE(sock_->IsConnectedAndIdle()); 257 } 258 259 TEST_P(TransportClientSocketTest, Read) { 260 TestCompletionCallback callback; 261 int rv = sock_->Connect(&callback); 262 if (rv != OK) { 263 ASSERT_EQ(rv, ERR_IO_PENDING); 264 265 rv = callback.WaitForResult(); 266 EXPECT_EQ(rv, OK); 267 } 268 SendClientRequest(); 269 270 scoped_refptr<IOBuffer> buf(new IOBuffer(4096)); 271 uint32 bytes_read = DrainClientSocket(buf, 4096, arraysize(kServerReply) - 1, 272 &callback); 273 ASSERT_EQ(bytes_read, arraysize(kServerReply) - 1); 274 275 // All data has been read now. Read once more to force an ERR_IO_PENDING, and 276 // then close the server socket, and note the close. 277 278 rv = sock_->Read(buf, 4096, &callback); 279 ASSERT_EQ(ERR_IO_PENDING, rv); 280 CloseServerSocket(); 281 EXPECT_EQ(0, callback.WaitForResult()); 282 } 283 284 TEST_P(TransportClientSocketTest, Read_SmallChunks) { 285 TestCompletionCallback callback; 286 int rv = sock_->Connect(&callback); 287 if (rv != OK) { 288 ASSERT_EQ(rv, ERR_IO_PENDING); 289 290 rv = callback.WaitForResult(); 291 EXPECT_EQ(rv, OK); 292 } 293 SendClientRequest(); 294 295 scoped_refptr<IOBuffer> buf(new IOBuffer(1)); 296 uint32 bytes_read = 0; 297 while (bytes_read < arraysize(kServerReply) - 1) { 298 rv = sock_->Read(buf, 1, &callback); 299 EXPECT_TRUE(rv >= 0 || rv == ERR_IO_PENDING); 300 301 if (rv == ERR_IO_PENDING) 302 rv = callback.WaitForResult(); 303 304 ASSERT_EQ(1, rv); 305 bytes_read += rv; 306 } 307 308 // All data has been read now. Read once more to force an ERR_IO_PENDING, and 309 // then close the server socket, and note the close. 310 311 rv = sock_->Read(buf, 1, &callback); 312 ASSERT_EQ(ERR_IO_PENDING, rv); 313 CloseServerSocket(); 314 EXPECT_EQ(0, callback.WaitForResult()); 315 } 316 317 TEST_P(TransportClientSocketTest, Read_Interrupted) { 318 TestCompletionCallback callback; 319 int rv = sock_->Connect(&callback); 320 if (rv != OK) { 321 ASSERT_EQ(ERR_IO_PENDING, rv); 322 323 rv = callback.WaitForResult(); 324 EXPECT_EQ(rv, OK); 325 } 326 SendClientRequest(); 327 328 // Do a partial read and then exit. This test should not crash! 329 scoped_refptr<IOBuffer> buf(new IOBuffer(16)); 330 rv = sock_->Read(buf, 16, &callback); 331 EXPECT_TRUE(rv >= 0 || rv == ERR_IO_PENDING); 332 333 if (rv == ERR_IO_PENDING) 334 rv = callback.WaitForResult(); 335 336 EXPECT_NE(0, rv); 337 } 338 339 TEST_P(TransportClientSocketTest, DISABLED_FullDuplex_ReadFirst) { 340 TestCompletionCallback callback; 341 int rv = sock_->Connect(&callback); 342 if (rv != OK) { 343 ASSERT_EQ(rv, ERR_IO_PENDING); 344 345 rv = callback.WaitForResult(); 346 EXPECT_EQ(rv, OK); 347 } 348 349 // Read first. There's no data, so it should return ERR_IO_PENDING. 350 const int kBufLen = 4096; 351 scoped_refptr<IOBuffer> buf(new IOBuffer(kBufLen)); 352 rv = sock_->Read(buf, kBufLen, &callback); 353 EXPECT_EQ(ERR_IO_PENDING, rv); 354 355 PauseServerReads(); 356 const int kWriteBufLen = 64 * 1024; 357 scoped_refptr<IOBuffer> request_buffer(new IOBuffer(kWriteBufLen)); 358 char* request_data = request_buffer->data(); 359 memset(request_data, 'A', kWriteBufLen); 360 TestCompletionCallback write_callback; 361 362 while (true) { 363 rv = sock_->Write(request_buffer, kWriteBufLen, &write_callback); 364 ASSERT_TRUE(rv >= 0 || rv == ERR_IO_PENDING); 365 366 if (rv == ERR_IO_PENDING) { 367 ResumeServerReads(); 368 rv = write_callback.WaitForResult(); 369 break; 370 } 371 } 372 373 // At this point, both read and write have returned ERR_IO_PENDING, and the 374 // write callback has executed. We wait for the read callback to run now to 375 // make sure that the socket can handle full duplex communications. 376 377 rv = callback.WaitForResult(); 378 EXPECT_GE(rv, 0); 379 } 380 381 TEST_P(TransportClientSocketTest, DISABLED_FullDuplex_WriteFirst) { 382 TestCompletionCallback callback; 383 int rv = sock_->Connect(&callback); 384 if (rv != OK) { 385 ASSERT_EQ(ERR_IO_PENDING, rv); 386 387 rv = callback.WaitForResult(); 388 EXPECT_EQ(OK, rv); 389 } 390 391 PauseServerReads(); 392 const int kWriteBufLen = 64 * 1024; 393 scoped_refptr<IOBuffer> request_buffer(new IOBuffer(kWriteBufLen)); 394 char* request_data = request_buffer->data(); 395 memset(request_data, 'A', kWriteBufLen); 396 TestCompletionCallback write_callback; 397 398 while (true) { 399 rv = sock_->Write(request_buffer, kWriteBufLen, &write_callback); 400 ASSERT_TRUE(rv >= 0 || rv == ERR_IO_PENDING); 401 402 if (rv == ERR_IO_PENDING) 403 break; 404 } 405 406 // Now we have the Write() blocked on ERR_IO_PENDING. It's time to force the 407 // Read() to block on ERR_IO_PENDING too. 408 409 const int kBufLen = 4096; 410 scoped_refptr<IOBuffer> buf(new IOBuffer(kBufLen)); 411 while (true) { 412 rv = sock_->Read(buf, kBufLen, &callback); 413 ASSERT_TRUE(rv >= 0 || rv == ERR_IO_PENDING); 414 if (rv == ERR_IO_PENDING) 415 break; 416 } 417 418 // At this point, both read and write have returned ERR_IO_PENDING. Now we 419 // run the write and read callbacks to make sure they can handle full duplex 420 // communications. 421 422 ResumeServerReads(); 423 rv = write_callback.WaitForResult(); 424 EXPECT_GE(rv, 0); 425 426 // It's possible the read is blocked because it's already read all the data. 427 // Close the server socket, so there will at least be a 0-byte read. 428 CloseServerSocket(); 429 430 rv = callback.WaitForResult(); 431 EXPECT_GE(rv, 0); 432 } 433 434 } // namespace 435 436 } // namespace net 437
