Land Recent QUIC changes.

net/tools/quic/end_to_end_test.cc

 // 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 <stddef.h>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/simple_thread.h"
 #include "net/base/ip_endpoint.h"
 // TODO(rtenneti): Delete this when NSS is supported.
 #include "net/quic/crypto/aes_128_gcm_encrypter.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_creator.h"
 #include "net/quic/quic_protocol.h"
+#include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
+#include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_in_memory_cache.h"
 #include "net/tools/quic/quic_server.h"
+#include "net/tools/quic/quic_socket_utils.h"
 #include "net/tools/quic/test_tools/http_message_test_utils.h"
+#include "net/tools/quic/test_tools/quic_client_peer.h"
+#include "net/tools/quic/test_tools/quic_epoll_connection_helper_peer.h"
 #include "net/tools/quic/test_tools/quic_test_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using base::WaitableEvent;
+using net::test::QuicConnectionPeer;
 using net::test::QuicSessionPeer;
 using net::test::ReliableQuicStreamPeer;
 using std::string;
 
 namespace net {
 namespace tools {
 namespace test {
 namespace {
 
 const char* kFooResponseBody = "Artichoke hearts make me happy.";
@@ skipping 162 matching lines @@
 TEST_F(EndToEndTest, SimpleRequestResponse) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 }
 
 TEST_F(EndToEndTest, SimpleRequestResponsev6) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   IPAddressNumber ip;
-  CHECK(net::ParseIPLiteralToNumber("::", &ip));
+  CHECK(net::ParseIPLiteralToNumber("::1", &ip));
   server_address_ = IPEndPoint(ip, server_address_.port());
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 }
 
 TEST_F(EndToEndTest, SeparateFinPacket) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   ASSERT_TRUE(Initialize());
 
   HTTPMessage request(HttpConstants::HTTP_1_1,
                       HttpConstants::POST, "/foo");
   request.set_has_complete_message(false);
 
   client_->SendMessage(request);
 
   client_->SendData(std::string(), true);
 
   client_->WaitForResponse();
   EXPECT_EQ(kFooResponseBody, client_->response_body());
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 
   request.AddBody("foo", true);
 
   client_->SendMessage(request);
   client_->SendData(std::string(), true);
   client_->WaitForResponse();
   EXPECT_EQ(kFooResponseBody, client_->response_body());
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 }
 
 TEST_F(EndToEndTest, MultipleRequestResponse) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 }
 
 TEST_F(EndToEndTest, MultipleClients) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   ASSERT_TRUE(Initialize());
   scoped_ptr<QuicTestClient> client2(CreateQuicClient());
 
   HTTPMessage request(HttpConstants::HTTP_1_1,
                       HttpConstants::POST, "/foo");
   request.AddHeader("content-length", "3");
   request.set_has_complete_message(false);
 
   client_->SendMessage(request);
   client2->SendMessage(request);
 
   client_->SendData("bar", true);
   client_->WaitForResponse();
   EXPECT_EQ(kFooResponseBody, client_->response_body());
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 
   client2->SendData("eep", true);
   client2->WaitForResponse();
   EXPECT_EQ(kFooResponseBody, client2->response_body());
-  EXPECT_EQ(200ul, client2->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client2->response_headers()->parsed_response_code());
 }
 
 TEST_F(EndToEndTest, RequestOverMultiplePackets) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   ASSERT_TRUE(Initialize());
   // Set things up so we have a small payload, to guarantee fragmentation.
   // A congestion feedback frame can't be split into multiple packets, make sure
   // that our packet have room for at least this amount after the normal headers
   // are added.
 
   // TODO(rch) handle this better when we have different encryption options.
   size_t stream_data = 3;
   size_t stream_payload_size = QuicFramer::GetMinStreamFrameSize() +
       stream_data;
   size_t min_payload_size =
       std::max(kCongestionFeedbackFrameSize, stream_payload_size);
   size_t ciphertext_size = NullEncrypter().GetCiphertextSize(min_payload_size);
   // TODO(satyashekhar): Fix this when versioning is implemented.
   client_->options()->max_packet_length =
       GetPacketHeaderSize(!kIncludeVersion) + ciphertext_size;
 
   // Make sure our request is too large to fit in one packet.
   EXPECT_GT(strlen(kLargeRequest), min_payload_size);
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest(kLargeRequest));
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 }
 
 TEST_F(EndToEndTest, MultipleFramesRandomOrder) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   ASSERT_TRUE(Initialize());
@@ skipping 10 matching lines @@
       std::max(kCongestionFeedbackFrameSize, stream_payload_size);
   size_t ciphertext_size = NullEncrypter().GetCiphertextSize(min_payload_size);
   // TODO(satyashekhar): Fix this when versioning is implemented.
   client_->options()->max_packet_length =
       GetPacketHeaderSize(!kIncludeVersion) + ciphertext_size;
   client_->options()->random_reorder = true;
 
   // Make sure our request is too large to fit in one packet.
   EXPECT_GT(strlen(kLargeRequest), min_payload_size);
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest(kLargeRequest));
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 }
 
 TEST_F(EndToEndTest, PostMissingBytes) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   ASSERT_TRUE(Initialize());
 
   // Add a content length header with no body.
   HTTPMessage request(HttpConstants::HTTP_1_1,
                       HttpConstants::POST, "/foo");
   request.AddHeader("content-length", "3");
   request.set_skip_message_validation(true);
 
   // This should be detected as stream fin without complete request,
   // triggering an error response.
   client_->SendCustomSynchronousRequest(request);
   EXPECT_EQ("bad", client_->response_body());
-  EXPECT_EQ(500ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(500u, client_->response_headers()->parsed_response_code());
 }
 
 TEST_F(EndToEndTest, LargePost) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   // FLAGS_fake_packet_loss_percentage = 30;
@@ skipping 57 matching lines @@
   ASSERT_TRUE(Initialize());
 
   string body;
   GenerateBody(&body, kMaxPacketSize);
 
   HTTPMessage request(HttpConstants::HTTP_1_1,
                       HttpConstants::POST, "/foo");
   request.AddBody(body, true);
   // Force the client to write with a stream ID belonging to a nonexistant
   // server-side stream.
-  QuicSessionPeer::SetNextStreamId(2, client_->client()->session());
+  QuicSessionPeer::SetNextStreamId(client_->client()->session(), 2);
 
   client_->SendCustomSynchronousRequest(request);
 //  EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_PACKET_FOR_NONEXISTENT_STREAM, client_->connection_error());
 }
 
 TEST_F(EndToEndTest, MultipleTermination) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
@@ skipping 24 matching lines @@
   EXPECT_DEBUG_DEATH({
     client_->SendData("eep", true);
     client_->WaitForResponse();
     EXPECT_EQ(QUIC_MULTIPLE_TERMINATION_OFFSETS, client_->stream_error());
   },
   "Check failed: !fin_buffered_");
 }
 
 /*TEST_F(EndToEndTest, Timeout) {
   config_.set_idle_connection_state_lifetime(
+      QuicTime::Delta::FromMicroseconds(500),
       QuicTime::Delta::FromMicroseconds(500));
   // Note: we do NOT ASSERT_TRUE: we may time out during initial handshake:
   // that's enough to validate timeout in this case.
   Initialize();
   while (client_->client()->connected()) {
     client_->client()->WaitForEvents();
   }
 }*/
 
 TEST_F(EndToEndTest, ResetConnection) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   client_->ResetConnection();
   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
-  EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
+}
+
+class WrongAddressWriter : public QuicPacketWriter {
+ public:
+  explicit WrongAddressWriter(int fd) : fd_(fd) {
+    IPAddressNumber ip;
+    CHECK(net::ParseIPLiteralToNumber("127.0.0.2", &ip));
+    self_address_ = IPEndPoint(ip, 0);
+  }
+
+  virtual int WritePacket(const char* buffer, size_t buf_len,
+                          const IPAddressNumber& real_self_address,
+                          const IPEndPoint& peer_address,
+                          QuicBlockedWriterInterface* blocked_writer,
+                          int* error) OVERRIDE {
+    return QuicSocketUtils::WritePacket(fd_, buffer, buf_len,
+                                        self_address_.address(), peer_address,
+                                        error);
+  }
+
+  IPEndPoint self_address_;
+  int fd_;
+};
+
+TEST_F(EndToEndTest, ConnectionMigration) {
+  // TODO(rtenneti): Delete this when NSS is supported.
+  if (!Aes128GcmEncrypter::IsSupported()) {
+    LOG(INFO) << "AES GCM not supported. Test skipped.";
+    return;
+  }
+
+  ASSERT_TRUE(Initialize());
+
+  EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
+
+  WrongAddressWriter writer(QuicClientPeer::GetFd(client_->client()));
+  QuicEpollConnectionHelper* helper =
+      reinterpret_cast<QuicEpollConnectionHelper*>(
+          QuicConnectionPeer::GetHelper(
+              client_->client()->session()->connection()));
+  QuicEpollConnectionHelperPeer::SetWriter(helper, &writer);
+
+  client_->SendSynchronousRequest("/bar");
+  QuicEpollConnectionHelperPeer::SetWriter(helper, NULL);
+
+  EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
+  EXPECT_EQ(QUIC_ERROR_MIGRATING_ADDRESS, client_->connection_error());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net