OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/socket/socks_client_socket.h" | 5 #include "net/socket/socks_client_socket.h" |
6 | 6 |
7 #include "base/memory/scoped_ptr.h" | 7 #include "base/memory/scoped_ptr.h" |
8 #include "net/base/address_list.h" | 8 #include "net/base/address_list.h" |
9 #include "net/base/test_completion_callback.h" | 9 #include "net/base/test_completion_callback.h" |
10 #include "net/base/winsock_init.h" | 10 #include "net/base/winsock_init.h" |
(...skipping 126 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
137 TEST_F(SOCKSClientSocketTest, CompleteHandshake) { | 137 TEST_F(SOCKSClientSocketTest, CompleteHandshake) { |
138 const std::string payload_write = "random data"; | 138 const std::string payload_write = "random data"; |
139 const std::string payload_read = "moar random data"; | 139 const std::string payload_read = "moar random data"; |
140 | 140 |
141 MockWrite data_writes[] = { | 141 MockWrite data_writes[] = { |
142 MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)), | 142 MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)), |
143 MockWrite(ASYNC, payload_write.data(), payload_write.size()) }; | 143 MockWrite(ASYNC, payload_write.data(), payload_write.size()) }; |
144 MockRead data_reads[] = { | 144 MockRead data_reads[] = { |
145 MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)), | 145 MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)), |
146 MockRead(ASYNC, payload_read.data(), payload_read.size()) }; | 146 MockRead(ASYNC, payload_read.data(), payload_read.size()) }; |
147 CapturingNetLog log; | 147 TestNetLog log; |
148 | 148 |
149 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), | 149 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), |
150 data_writes, arraysize(data_writes), | 150 data_writes, arraysize(data_writes), |
151 host_resolver_.get(), | 151 host_resolver_.get(), |
152 "localhost", 80, | 152 "localhost", 80, |
153 &log); | 153 &log); |
154 | 154 |
155 // At this state the TCP connection is completed but not the SOCKS handshake. | 155 // At this state the TCP connection is completed but not the SOCKS handshake. |
156 EXPECT_TRUE(tcp_sock_->IsConnected()); | 156 EXPECT_TRUE(tcp_sock_->IsConnected()); |
157 EXPECT_FALSE(user_sock_->IsConnected()); | 157 EXPECT_FALSE(user_sock_->IsConnected()); |
158 | 158 |
159 int rv = user_sock_->Connect(callback_.callback()); | 159 int rv = user_sock_->Connect(callback_.callback()); |
160 EXPECT_EQ(ERR_IO_PENDING, rv); | 160 EXPECT_EQ(ERR_IO_PENDING, rv); |
161 | 161 |
162 CapturingNetLog::CapturedEntryList entries; | 162 TestNetLog::CapturedEntryList entries; |
163 log.GetEntries(&entries); | 163 log.GetEntries(&entries); |
164 EXPECT_TRUE( | 164 EXPECT_TRUE( |
165 LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT)); | 165 LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT)); |
166 EXPECT_FALSE(user_sock_->IsConnected()); | 166 EXPECT_FALSE(user_sock_->IsConnected()); |
167 | 167 |
168 rv = callback_.WaitForResult(); | 168 rv = callback_.WaitForResult(); |
169 EXPECT_EQ(OK, rv); | 169 EXPECT_EQ(OK, rv); |
170 EXPECT_TRUE(user_sock_->IsConnected()); | 170 EXPECT_TRUE(user_sock_->IsConnected()); |
171 log.GetEntries(&entries); | 171 log.GetEntries(&entries); |
172 EXPECT_TRUE(LogContainsEndEvent( | 172 EXPECT_TRUE(LogContainsEndEvent( |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
213 }; | 213 }; |
214 | 214 |
215 //--------------------------------------- | 215 //--------------------------------------- |
216 | 216 |
217 for (size_t i = 0; i < arraysize(tests); ++i) { | 217 for (size_t i = 0; i < arraysize(tests); ++i) { |
218 MockWrite data_writes[] = { | 218 MockWrite data_writes[] = { |
219 MockWrite(SYNCHRONOUS, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; | 219 MockWrite(SYNCHRONOUS, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; |
220 MockRead data_reads[] = { | 220 MockRead data_reads[] = { |
221 MockRead(SYNCHRONOUS, tests[i].fail_reply, | 221 MockRead(SYNCHRONOUS, tests[i].fail_reply, |
222 arraysize(tests[i].fail_reply)) }; | 222 arraysize(tests[i].fail_reply)) }; |
223 CapturingNetLog log; | 223 TestNetLog log; |
224 | 224 |
225 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), | 225 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), |
226 data_writes, arraysize(data_writes), | 226 data_writes, arraysize(data_writes), |
227 host_resolver_.get(), | 227 host_resolver_.get(), |
228 "localhost", 80, | 228 "localhost", 80, |
229 &log); | 229 &log); |
230 | 230 |
231 int rv = user_sock_->Connect(callback_.callback()); | 231 int rv = user_sock_->Connect(callback_.callback()); |
232 EXPECT_EQ(ERR_IO_PENDING, rv); | 232 EXPECT_EQ(ERR_IO_PENDING, rv); |
233 | 233 |
234 CapturingNetLog::CapturedEntryList entries; | 234 TestNetLog::CapturedEntryList entries; |
235 log.GetEntries(&entries); | 235 log.GetEntries(&entries); |
236 EXPECT_TRUE(LogContainsBeginEvent( | 236 EXPECT_TRUE(LogContainsBeginEvent( |
237 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); | 237 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); |
238 | 238 |
239 rv = callback_.WaitForResult(); | 239 rv = callback_.WaitForResult(); |
240 EXPECT_EQ(tests[i].fail_code, rv); | 240 EXPECT_EQ(tests[i].fail_code, rv); |
241 EXPECT_FALSE(user_sock_->IsConnected()); | 241 EXPECT_FALSE(user_sock_->IsConnected()); |
242 EXPECT_TRUE(tcp_sock_->IsConnected()); | 242 EXPECT_TRUE(tcp_sock_->IsConnected()); |
243 log.GetEntries(&entries); | 243 log.GetEntries(&entries); |
244 EXPECT_TRUE(LogContainsEndEvent( | 244 EXPECT_TRUE(LogContainsEndEvent( |
245 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); | 245 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); |
246 } | 246 } |
247 } | 247 } |
248 | 248 |
249 // Tests scenario when the server sends the handshake response in | 249 // Tests scenario when the server sends the handshake response in |
250 // more than one packet. | 250 // more than one packet. |
251 TEST_F(SOCKSClientSocketTest, PartialServerReads) { | 251 TEST_F(SOCKSClientSocketTest, PartialServerReads) { |
252 const char kSOCKSPartialReply1[] = { 0x00 }; | 252 const char kSOCKSPartialReply1[] = { 0x00 }; |
253 const char kSOCKSPartialReply2[] = { 0x5A, 0x00, 0x00, 0, 0, 0, 0 }; | 253 const char kSOCKSPartialReply2[] = { 0x5A, 0x00, 0x00, 0, 0, 0, 0 }; |
254 | 254 |
255 MockWrite data_writes[] = { | 255 MockWrite data_writes[] = { |
256 MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; | 256 MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; |
257 MockRead data_reads[] = { | 257 MockRead data_reads[] = { |
258 MockRead(ASYNC, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)), | 258 MockRead(ASYNC, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)), |
259 MockRead(ASYNC, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) }; | 259 MockRead(ASYNC, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) }; |
260 CapturingNetLog log; | 260 TestNetLog log; |
261 | 261 |
262 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), | 262 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), |
263 data_writes, arraysize(data_writes), | 263 data_writes, arraysize(data_writes), |
264 host_resolver_.get(), | 264 host_resolver_.get(), |
265 "localhost", 80, | 265 "localhost", 80, |
266 &log); | 266 &log); |
267 | 267 |
268 int rv = user_sock_->Connect(callback_.callback()); | 268 int rv = user_sock_->Connect(callback_.callback()); |
269 EXPECT_EQ(ERR_IO_PENDING, rv); | 269 EXPECT_EQ(ERR_IO_PENDING, rv); |
270 CapturingNetLog::CapturedEntryList entries; | 270 TestNetLog::CapturedEntryList entries; |
271 log.GetEntries(&entries); | 271 log.GetEntries(&entries); |
272 EXPECT_TRUE(LogContainsBeginEvent( | 272 EXPECT_TRUE(LogContainsBeginEvent( |
273 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); | 273 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); |
274 | 274 |
275 rv = callback_.WaitForResult(); | 275 rv = callback_.WaitForResult(); |
276 EXPECT_EQ(OK, rv); | 276 EXPECT_EQ(OK, rv); |
277 EXPECT_TRUE(user_sock_->IsConnected()); | 277 EXPECT_TRUE(user_sock_->IsConnected()); |
278 log.GetEntries(&entries); | 278 log.GetEntries(&entries); |
279 EXPECT_TRUE(LogContainsEndEvent( | 279 EXPECT_TRUE(LogContainsEndEvent( |
280 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); | 280 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); |
281 } | 281 } |
282 | 282 |
283 // Tests scenario when the client sends the handshake request in | 283 // Tests scenario when the client sends the handshake request in |
284 // more than one packet. | 284 // more than one packet. |
285 TEST_F(SOCKSClientSocketTest, PartialClientWrites) { | 285 TEST_F(SOCKSClientSocketTest, PartialClientWrites) { |
286 const char kSOCKSPartialRequest1[] = { 0x04, 0x01 }; | 286 const char kSOCKSPartialRequest1[] = { 0x04, 0x01 }; |
287 const char kSOCKSPartialRequest2[] = { 0x00, 0x50, 127, 0, 0, 1, 0 }; | 287 const char kSOCKSPartialRequest2[] = { 0x00, 0x50, 127, 0, 0, 1, 0 }; |
288 | 288 |
289 MockWrite data_writes[] = { | 289 MockWrite data_writes[] = { |
290 MockWrite(ASYNC, kSOCKSPartialRequest1, arraysize(kSOCKSPartialRequest1)), | 290 MockWrite(ASYNC, kSOCKSPartialRequest1, arraysize(kSOCKSPartialRequest1)), |
291 // simulate some empty writes | 291 // simulate some empty writes |
292 MockWrite(ASYNC, 0), | 292 MockWrite(ASYNC, 0), |
293 MockWrite(ASYNC, 0), | 293 MockWrite(ASYNC, 0), |
294 MockWrite(ASYNC, kSOCKSPartialRequest2, arraysize(kSOCKSPartialRequest2)), | 294 MockWrite(ASYNC, kSOCKSPartialRequest2, arraysize(kSOCKSPartialRequest2)), |
295 }; | 295 }; |
296 MockRead data_reads[] = { | 296 MockRead data_reads[] = { |
297 MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)) }; | 297 MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)) }; |
298 CapturingNetLog log; | 298 TestNetLog log; |
299 | 299 |
300 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), | 300 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), |
301 data_writes, arraysize(data_writes), | 301 data_writes, arraysize(data_writes), |
302 host_resolver_.get(), | 302 host_resolver_.get(), |
303 "localhost", 80, | 303 "localhost", 80, |
304 &log); | 304 &log); |
305 | 305 |
306 int rv = user_sock_->Connect(callback_.callback()); | 306 int rv = user_sock_->Connect(callback_.callback()); |
307 EXPECT_EQ(ERR_IO_PENDING, rv); | 307 EXPECT_EQ(ERR_IO_PENDING, rv); |
308 CapturingNetLog::CapturedEntryList entries; | 308 TestNetLog::CapturedEntryList entries; |
309 log.GetEntries(&entries); | 309 log.GetEntries(&entries); |
310 EXPECT_TRUE(LogContainsBeginEvent( | 310 EXPECT_TRUE(LogContainsBeginEvent( |
311 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); | 311 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); |
312 | 312 |
313 rv = callback_.WaitForResult(); | 313 rv = callback_.WaitForResult(); |
314 EXPECT_EQ(OK, rv); | 314 EXPECT_EQ(OK, rv); |
315 EXPECT_TRUE(user_sock_->IsConnected()); | 315 EXPECT_TRUE(user_sock_->IsConnected()); |
316 log.GetEntries(&entries); | 316 log.GetEntries(&entries); |
317 EXPECT_TRUE(LogContainsEndEvent( | 317 EXPECT_TRUE(LogContainsEndEvent( |
318 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); | 318 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); |
319 } | 319 } |
320 | 320 |
321 // Tests the case when the server sends a smaller sized handshake data | 321 // Tests the case when the server sends a smaller sized handshake data |
322 // and closes the connection. | 322 // and closes the connection. |
323 TEST_F(SOCKSClientSocketTest, FailedSocketRead) { | 323 TEST_F(SOCKSClientSocketTest, FailedSocketRead) { |
324 MockWrite data_writes[] = { | 324 MockWrite data_writes[] = { |
325 MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; | 325 MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; |
326 MockRead data_reads[] = { | 326 MockRead data_reads[] = { |
327 MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply) - 2), | 327 MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply) - 2), |
328 // close connection unexpectedly | 328 // close connection unexpectedly |
329 MockRead(SYNCHRONOUS, 0) }; | 329 MockRead(SYNCHRONOUS, 0) }; |
330 CapturingNetLog log; | 330 TestNetLog log; |
331 | 331 |
332 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), | 332 user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads), |
333 data_writes, arraysize(data_writes), | 333 data_writes, arraysize(data_writes), |
334 host_resolver_.get(), | 334 host_resolver_.get(), |
335 "localhost", 80, | 335 "localhost", 80, |
336 &log); | 336 &log); |
337 | 337 |
338 int rv = user_sock_->Connect(callback_.callback()); | 338 int rv = user_sock_->Connect(callback_.callback()); |
339 EXPECT_EQ(ERR_IO_PENDING, rv); | 339 EXPECT_EQ(ERR_IO_PENDING, rv); |
340 CapturingNetLog::CapturedEntryList entries; | 340 TestNetLog::CapturedEntryList entries; |
341 log.GetEntries(&entries); | 341 log.GetEntries(&entries); |
342 EXPECT_TRUE(LogContainsBeginEvent( | 342 EXPECT_TRUE(LogContainsBeginEvent( |
343 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); | 343 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); |
344 | 344 |
345 rv = callback_.WaitForResult(); | 345 rv = callback_.WaitForResult(); |
346 EXPECT_EQ(ERR_CONNECTION_CLOSED, rv); | 346 EXPECT_EQ(ERR_CONNECTION_CLOSED, rv); |
347 EXPECT_FALSE(user_sock_->IsConnected()); | 347 EXPECT_FALSE(user_sock_->IsConnected()); |
348 log.GetEntries(&entries); | 348 log.GetEntries(&entries); |
349 EXPECT_TRUE(LogContainsEndEvent( | 349 EXPECT_TRUE(LogContainsEndEvent( |
350 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); | 350 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); |
351 } | 351 } |
352 | 352 |
353 // Tries to connect to an unknown hostname. Should fail rather than | 353 // Tries to connect to an unknown hostname. Should fail rather than |
354 // falling back to SOCKS4a. | 354 // falling back to SOCKS4a. |
355 TEST_F(SOCKSClientSocketTest, FailedDNS) { | 355 TEST_F(SOCKSClientSocketTest, FailedDNS) { |
356 const char hostname[] = "unresolved.ipv4.address"; | 356 const char hostname[] = "unresolved.ipv4.address"; |
357 | 357 |
358 host_resolver_->rules()->AddSimulatedFailure(hostname); | 358 host_resolver_->rules()->AddSimulatedFailure(hostname); |
359 | 359 |
360 CapturingNetLog log; | 360 TestNetLog log; |
361 | 361 |
362 user_sock_ = BuildMockSocket(NULL, 0, | 362 user_sock_ = BuildMockSocket(NULL, 0, |
363 NULL, 0, | 363 NULL, 0, |
364 host_resolver_.get(), | 364 host_resolver_.get(), |
365 hostname, 80, | 365 hostname, 80, |
366 &log); | 366 &log); |
367 | 367 |
368 int rv = user_sock_->Connect(callback_.callback()); | 368 int rv = user_sock_->Connect(callback_.callback()); |
369 EXPECT_EQ(ERR_IO_PENDING, rv); | 369 EXPECT_EQ(ERR_IO_PENDING, rv); |
370 CapturingNetLog::CapturedEntryList entries; | 370 TestNetLog::CapturedEntryList entries; |
371 log.GetEntries(&entries); | 371 log.GetEntries(&entries); |
372 EXPECT_TRUE(LogContainsBeginEvent( | 372 EXPECT_TRUE(LogContainsBeginEvent( |
373 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); | 373 entries, 0, NetLog::TYPE_SOCKS_CONNECT)); |
374 | 374 |
375 rv = callback_.WaitForResult(); | 375 rv = callback_.WaitForResult(); |
376 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); | 376 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); |
377 EXPECT_FALSE(user_sock_->IsConnected()); | 377 EXPECT_FALSE(user_sock_->IsConnected()); |
378 log.GetEntries(&entries); | 378 log.GetEntries(&entries); |
379 EXPECT_TRUE(LogContainsEndEvent( | 379 EXPECT_TRUE(LogContainsEndEvent( |
380 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); | 380 entries, -1, NetLog::TYPE_SOCKS_CONNECT)); |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
441 NULL, 0, | 441 NULL, 0, |
442 host_resolver.get(), | 442 host_resolver.get(), |
443 kHostName, 80, | 443 kHostName, 80, |
444 NULL); | 444 NULL); |
445 | 445 |
446 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, | 446 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, |
447 callback_.GetResult(user_sock_->Connect(callback_.callback()))); | 447 callback_.GetResult(user_sock_->Connect(callback_.callback()))); |
448 } | 448 } |
449 | 449 |
450 } // namespace net | 450 } // namespace net |
OLD | NEW |