HttpChunkedDecoder: Support chunks longer than 2^31-1 bytes.

net/http/http_chunked_decoder_unittest.cc

 // Copyright (c) 2006-2008 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 "net/http/http_chunked_decoder.h"
 
 #include <memory>
+#include <string>
+#include <vector>
 
+#include "base/format_macros.h"
+#include "base/strings/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::test::IsError;
 using net::test::IsOk;
 
 namespace net {
 
@@ skipping 265 matching lines @@
 
 TEST(HttpChunkedDecoderTest, InvalidConsecutiveCRLFs) {
   const char* const inputs[] = {
     "5\r\nhello\r\n",
     "\r\n\r\n\r\n\r\n",
     "0\r\n\r\n"
   };
   RunTestUntilFailure(inputs, arraysize(inputs), 1);
 }
 
+TEST(HttpChunkedDecoderTest, ReallyBigChunks) {
+  // Number of bytes sent through the chunked decoder per loop iteration. To
+  // minimize runtime, should be the square root of the chunk lengths, below.
+  const int64_t kWrittenBytesPerIteration = 0x10000;
+
+  // Length of chunks to test. Must be multiples of kWrittenBytesPerIteration.
+  int64_t kChunkLengths[] = {
+      // Overflows when cast to a signed int32.
+      0x0c0000000,
+      // Overflows when cast to an unsigned int32.
+      0x100000000,
+  };
+
+  for (int64_t chunk_length : kChunkLengths) {
+    HttpChunkedDecoder decoder;
+    EXPECT_FALSE(decoder.reached_eof());
+
+    // Feed just the header to the decode.
+    std::string chunk_header =
+        base::StringPrintf("%" PRIx64 "\r\n", chunk_length);
+    std::vector<char> data(chunk_header.begin(), chunk_header.end());
+    EXPECT_EQ(OK, decoder.FilterBuf(data.data(), data.size()));
+    EXPECT_FALSE(decoder.reached_eof());
+
+    // Set |data| to be kWrittenBytesPerIteration long, and have a repeating
+    // pattern.
+    data.clear();
+    data.reserve(kWrittenBytesPerIteration);
+    for (size_t i = 0; i < kWrittenBytesPerIteration; i++) {
+      data.push_back(static_cast<char>(i));
+    }
+
+    // Repeatedly feed the data to the chunked decoder. Since the data doesn't
+    // include any chunk lengths, the decode will never have to move the data,
+    // and should run fairly quickly.
+    for (int64_t total_written = 0; total_written < chunk_length;
+         total_written += kWrittenBytesPerIteration) {
+      EXPECT_EQ(kWrittenBytesPerIteration,
+                decoder.FilterBuf(data.data(), kWrittenBytesPerIteration));
+      EXPECT_FALSE(decoder.reached_eof());
+    }
+
+    // Chunk terminator and the final chunk.
+    char final_chunk[] = "\r\n0\r\n\r\n";
+    EXPECT_EQ(OK, decoder.FilterBuf(final_chunk, arraysize(final_chunk)));
+    EXPECT_TRUE(decoder.reached_eof());
+
+    // Since |data| never included any chunk headers, it should not have been
+    // modified.
+    for (size_t i = 0; i < kWrittenBytesPerIteration; i++) {
+      EXPECT_EQ(static_cast<char>(i), data[i]);
+    }
+  }
+}
+
 TEST(HttpChunkedDecoderTest, ExcessiveChunkLen) {
-  const char* const inputs[] = {
-    "c0000000\r\nhello\r\n"
-  };
+  // Smallest number that can't be represented as a signed int64.
+  const char* const inputs[] = {"8000000000000000\r\nhello\r\n"};
   RunTestUntilFailure(inputs, arraysize(inputs), 0);
 }
 
+TEST(HttpChunkedDecoderTest, ExcessiveChunkLen2) {
+  // Smallest number that can't be represented as an unsigned int64.
+  const char* const inputs[] = {"10000000000000000\r\nhello\r\n"};
+  RunTestUntilFailure(inputs, arraysize(inputs), 0);
+}
+
 TEST(HttpChunkedDecoderTest, BasicExtraData) {
   const char* const inputs[] = {
     "5\r\nhello\r\n0\r\n\r\nextra bytes"
   };
   RunTest(inputs, arraysize(inputs), "hello", true, 11);
 }
 
 TEST(HttpChunkedDecoderTest, IncrementalExtraData) {
   const char* const inputs[] = {
     "5",
@@ skipping 42 matching lines @@
   const char* const inputs[] = {
     "5;",
     big_chunk.get()
   };
   RunTestUntilFailure(inputs, arraysize(inputs), 1);
 }
 
 }  // namespace
 
 }  // namespace net