OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 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/spdy/spdy_proxy_client_socket.h" | 5 #include "net/spdy/spdy_proxy_client_socket.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 8 #include "base/bind_helpers.h" |
9 #include "base/utf_string_conversions.h" | 9 #include "base/utf_string_conversions.h" |
10 #include "net/base/address_list.h" | 10 #include "net/base/address_list.h" |
11 #include "net/base/net_log.h" | 11 #include "net/base/net_log.h" |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
61 | 61 |
62 virtual void TearDown(); | 62 virtual void TearDown(); |
63 | 63 |
64 protected: | 64 protected: |
65 void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes, | 65 void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes, |
66 size_t writes_count); | 66 size_t writes_count); |
67 spdy::SpdyFrame* ConstructConnectRequestFrame(); | 67 spdy::SpdyFrame* ConstructConnectRequestFrame(); |
68 spdy::SpdyFrame* ConstructConnectAuthRequestFrame(); | 68 spdy::SpdyFrame* ConstructConnectAuthRequestFrame(); |
69 spdy::SpdyFrame* ConstructConnectReplyFrame(); | 69 spdy::SpdyFrame* ConstructConnectReplyFrame(); |
70 spdy::SpdyFrame* ConstructConnectAuthReplyFrame(); | 70 spdy::SpdyFrame* ConstructConnectAuthReplyFrame(); |
71 spdy::SpdyFrame* ConstructConnectNtlmAuthReplyFrame(); | |
72 spdy::SpdyFrame* ConstructConnectErrorReplyFrame(); | 71 spdy::SpdyFrame* ConstructConnectErrorReplyFrame(); |
73 spdy::SpdyFrame* ConstructBodyFrame(const char* data, int length); | 72 spdy::SpdyFrame* ConstructBodyFrame(const char* data, int length); |
74 scoped_refptr<IOBufferWithSize> CreateBuffer(const char* data, int size); | 73 scoped_refptr<IOBufferWithSize> CreateBuffer(const char* data, int size); |
75 void AssertConnectSucceeds(); | 74 void AssertConnectSucceeds(); |
76 void AssertConnectFails(int result); | 75 void AssertConnectFails(int result); |
77 void AssertConnectionEstablished(); | 76 void AssertConnectionEstablished(); |
78 void AssertSyncReadEquals(const char* data, int len); | 77 void AssertSyncReadEquals(const char* data, int len); |
79 void AssertAsyncReadEquals(const char* data, int len); | 78 void AssertAsyncReadEquals(const char* data, int len); |
80 void AssertReadStarts(const char* data, int len); | 79 void AssertReadStarts(const char* data, int len); |
81 void AssertReadReturns(const char* data, int len); | 80 void AssertReadReturns(const char* data, int len); |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
193 // Create the SPDY Stream | 192 // Create the SPDY Stream |
194 ASSERT_EQ( | 193 ASSERT_EQ( |
195 OK, | 194 OK, |
196 spdy_session_->CreateStream(url_, LOWEST, &spdy_stream_, BoundNetLog(), | 195 spdy_session_->CreateStream(url_, LOWEST, &spdy_stream_, BoundNetLog(), |
197 CompletionCallback())); | 196 CompletionCallback())); |
198 | 197 |
199 // Create the SpdyProxyClientSocket | 198 // Create the SpdyProxyClientSocket |
200 sock_.reset( | 199 sock_.reset( |
201 new SpdyProxyClientSocket(spdy_stream_, user_agent_, | 200 new SpdyProxyClientSocket(spdy_stream_, user_agent_, |
202 endpoint_host_port_pair_, url_, | 201 endpoint_host_port_pair_, url_, |
203 proxy_host_port_, | 202 proxy_host_port_, session_->http_auth_cache(), |
204 new HttpAuthController( | 203 session_->http_auth_handler_factory())); |
205 HttpAuth::AUTH_PROXY, | |
206 GURL(kProxyUrl), | |
207 session_->http_auth_cache(), | |
208 session_->http_auth_handler_factory()))); | |
209 } | 204 } |
210 | 205 |
211 scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketTest::CreateBuffer( | 206 scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketTest::CreateBuffer( |
212 const char* data, int size) { | 207 const char* data, int size) { |
213 scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(size)); | 208 scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(size)); |
214 memcpy(buf->data(), data, size); | 209 memcpy(buf->data(), data, size); |
215 return buf; | 210 return buf; |
216 } | 211 } |
217 | 212 |
218 void SpdyProxyClientSocketTest::AssertConnectSucceeds() { | 213 void SpdyProxyClientSocketTest::AssertConnectSucceeds() { |
(...skipping 169 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
388 0, | 383 0, |
389 false, | 384 false, |
390 kStreamId, | 385 kStreamId, |
391 LOWEST, | 386 LOWEST, |
392 spdy::SYN_REPLY, | 387 spdy::SYN_REPLY, |
393 spdy::CONTROL_FLAG_NONE, | 388 spdy::CONTROL_FLAG_NONE, |
394 kStandardReplyHeaders, | 389 kStandardReplyHeaders, |
395 arraysize(kStandardReplyHeaders)); | 390 arraysize(kStandardReplyHeaders)); |
396 } | 391 } |
397 | 392 |
398 // Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT. | |
399 spdy::SpdyFrame* | |
400 SpdyProxyClientSocketTest::ConstructConnectNtlmAuthReplyFrame() { | |
401 const char* const kStandardReplyHeaders[] = { | |
402 "status", "407 Proxy Authentication Required", | |
403 "version", "HTTP/1.1", | |
404 "proxy-authenticate", "NTLM" | |
405 }; | |
406 | |
407 return ConstructSpdyControlFrame(NULL, | |
408 0, | |
409 false, | |
410 kStreamId, | |
411 LOWEST, | |
412 spdy::SYN_REPLY, | |
413 spdy::CONTROL_FLAG_NONE, | |
414 kStandardReplyHeaders, | |
415 arraysize(kStandardReplyHeaders)); | |
416 } | |
417 | |
418 // Constructs a SPDY SYN_REPLY frame with an HTTP 500 error. | 393 // Constructs a SPDY SYN_REPLY frame with an HTTP 500 error. |
419 spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectErrorReplyFrame() { | 394 spdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectErrorReplyFrame() { |
420 const char* const kStandardReplyHeaders[] = { | 395 const char* const kStandardReplyHeaders[] = { |
421 "status", "500 Internal Server Error", | 396 "status", "500 Internal Server Error", |
422 "version", "HTTP/1.1", | 397 "version", "HTTP/1.1", |
423 }; | 398 }; |
424 | 399 |
425 return ConstructSpdyControlFrame(NULL, | 400 return ConstructSpdyControlFrame(NULL, |
426 0, | 401 0, |
427 false, | 402 false, |
(...skipping 26 matching lines...) Expand all Loading... |
454 | 429 |
455 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 430 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
456 | 431 |
457 ASSERT_FALSE(sock_->IsConnected()); | 432 ASSERT_FALSE(sock_->IsConnected()); |
458 | 433 |
459 AssertConnectSucceeds(); | 434 AssertConnectSucceeds(); |
460 | 435 |
461 AssertConnectionEstablished(); | 436 AssertConnectionEstablished(); |
462 } | 437 } |
463 | 438 |
464 TEST_F(SpdyProxyClientSocketTest, ConnectWithUnsupportedAuthScheme) { | 439 TEST_F(SpdyProxyClientSocketTest, ConnectWithAuthRequested) { |
465 scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); | 440 scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); |
466 MockWrite writes[] = { | 441 MockWrite writes[] = { |
467 CreateMockWrite(*conn, 0, false), | 442 CreateMockWrite(*conn, 0, false), |
468 }; | 443 }; |
469 | 444 |
470 scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectNtlmAuthReplyFrame()); | 445 scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectAuthReplyFrame()); |
471 MockRead reads[] = { | 446 MockRead reads[] = { |
472 CreateMockRead(*resp, 1, true), | 447 CreateMockRead(*resp, 1, true), |
473 MockRead(true, 0, 3), // EOF | 448 MockRead(true, 0, 3), // EOF |
474 }; | 449 }; |
475 | 450 |
476 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 451 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
477 | 452 |
478 AssertConnectFails(ERR_PROXY_AUTH_UNSUPPORTED); | 453 AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED); |
| 454 |
| 455 const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); |
| 456 ASSERT_TRUE(response != NULL); |
| 457 ASSERT_EQ(407, response->headers->response_code()); |
| 458 ASSERT_EQ("Proxy Authentication Required", |
| 459 response->headers->GetStatusText()); |
479 } | 460 } |
480 | 461 |
481 TEST_F(SpdyProxyClientSocketTest, ConnectWithAuthCredentials) { | 462 TEST_F(SpdyProxyClientSocketTest, ConnectWithAuthCredentials) { |
482 scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectAuthRequestFrame()); | 463 scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectAuthRequestFrame()); |
483 MockWrite writes[] = { | 464 MockWrite writes[] = { |
484 CreateMockWrite(*conn, 0, false), | 465 CreateMockWrite(*conn, 0, false), |
485 }; | 466 }; |
486 | 467 |
487 scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); | 468 scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); |
488 MockRead reads[] = { | 469 MockRead reads[] = { |
489 CreateMockRead(*resp, 1, true), | 470 CreateMockRead(*resp, 1, true), |
490 MockRead(true, 0, 3), // EOF | 471 MockRead(true, 0, 3), // EOF |
491 }; | 472 }; |
492 | 473 |
493 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 474 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
494 AddAuthToCache(); | 475 AddAuthToCache(); |
495 | 476 |
496 AssertConnectSucceeds(); | 477 AssertConnectSucceeds(); |
497 | 478 |
498 AssertConnectionEstablished(); | 479 AssertConnectionEstablished(); |
499 } | 480 } |
500 | 481 |
501 TEST_F(SpdyProxyClientSocketTest, ConnectWithAuthRestart) { | |
502 scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); | |
503 scoped_ptr<spdy::SpdyFrame> auth(ConstructConnectAuthRequestFrame()); | |
504 MockWrite writes[] = { | |
505 CreateMockWrite(*conn, 0, false), | |
506 }; | |
507 | |
508 scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectAuthReplyFrame()); | |
509 scoped_ptr<spdy::SpdyFrame> auth_resp(ConstructConnectReplyFrame()); | |
510 MockRead reads[] = { | |
511 CreateMockRead(*resp, 1, true), | |
512 MockRead(true, 0, 3), // EOF | |
513 }; | |
514 | |
515 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
516 | |
517 AssertConnectFails(ERR_PROXY_AUTH_REQUESTED); | |
518 | |
519 const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); | |
520 ASSERT_TRUE(response != NULL); | |
521 ASSERT_EQ(407, response->headers->response_code()); | |
522 ASSERT_EQ("Proxy Authentication Required", | |
523 response->headers->GetStatusText()); | |
524 | |
525 AddAuthToCache(); | |
526 | |
527 ASSERT_EQ(ERR_NO_KEEP_ALIVE_ON_AUTH_RESTART, | |
528 sock_->RestartWithAuth(read_callback_.callback())); | |
529 // A SpdyProxyClientSocket sits on a single SPDY stream which can | |
530 // only be used for a single request/response. | |
531 ASSERT_FALSE(sock_->IsConnectedAndIdle()); | |
532 } | |
533 | |
534 TEST_F(SpdyProxyClientSocketTest, ConnectFails) { | 482 TEST_F(SpdyProxyClientSocketTest, ConnectFails) { |
535 scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); | 483 scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); |
536 MockWrite writes[] = { | 484 MockWrite writes[] = { |
537 CreateMockWrite(*conn, 0, false), | 485 CreateMockWrite(*conn, 0, false), |
538 }; | 486 }; |
539 | 487 |
540 scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); | 488 scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); |
541 MockRead reads[] = { | 489 MockRead reads[] = { |
542 MockRead(true, 0, 1), // EOF | 490 MockRead(true, 0, 1), // EOF |
543 }; | 491 }; |
(...skipping 332 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
876 scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); | 824 scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); |
877 MockRead reads[] = { | 825 MockRead reads[] = { |
878 CreateMockRead(*resp, 1, true), | 826 CreateMockRead(*resp, 1, true), |
879 CreateMockRead(*msg1, 2, true), | 827 CreateMockRead(*msg1, 2, true), |
880 CreateMockRead(*msg2, 3, true), | 828 CreateMockRead(*msg2, 3, true), |
881 MockRead(true, 0, 4), // EOF | 829 MockRead(true, 0, 4), // EOF |
882 }; | 830 }; |
883 | 831 |
884 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 832 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
885 | 833 |
886 AssertConnectFails(ERR_PROXY_AUTH_REQUESTED); | 834 AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED); |
887 | 835 |
888 Run(2); // SpdySession consumes the next two reads and sends then to | 836 Run(2); // SpdySession consumes the next two reads and sends then to |
889 // sock_ to be buffered. | 837 // sock_ to be buffered. |
890 AssertSyncReadEquals(kMsg1, kLen1); | 838 AssertSyncReadEquals(kMsg1, kLen1); |
891 AssertSyncReadEquals(kMsg2, kLen2); | 839 AssertSyncReadEquals(kMsg2, kLen2); |
892 } | 840 } |
893 | 841 |
894 TEST_F(SpdyProxyClientSocketTest, ReadErrorResponseBody) { | 842 TEST_F(SpdyProxyClientSocketTest, ReadErrorResponseBody) { |
895 scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); | 843 scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); |
896 MockWrite writes[] = { | 844 MockWrite writes[] = { |
(...skipping 446 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1343 write_callback_.callback())); | 1291 write_callback_.callback())); |
1344 | 1292 |
1345 Run(2); | 1293 Run(2); |
1346 | 1294 |
1347 EXPECT_FALSE(sock_.get()); | 1295 EXPECT_FALSE(sock_.get()); |
1348 EXPECT_TRUE(read_callback.have_result()); | 1296 EXPECT_TRUE(read_callback.have_result()); |
1349 EXPECT_FALSE(write_callback_.have_result()); | 1297 EXPECT_FALSE(write_callback_.have_result()); |
1350 } | 1298 } |
1351 | 1299 |
1352 } // namespace net | 1300 } // namespace net |
OLD | NEW |