blob: 2f11e28a9fbbfa24e8ae215137984fca0a94fcfe [file] [log] [blame]
// Copyright 2014 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 <fstream>
#include <ostream>
#include "base/files/file_util.h"
#include "base/memory/scoped_ptr.h"
#include "base/path_service.h"
#include "net/base/io_buffer.h"
#include "net/filter/gzip_filter.h"
#include "net/filter/mock_filter_context.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
#include "third_party/zlib/zlib.h"
namespace {
const int kDefaultBufferSize = 4096;
const int kSmallBufferSize = 128;
// The GZIP header (see RFC 1952):
// +---+---+---+---+---+---+---+---+---+---+
// |ID1|ID2|CM |FLG| MTIME |XFL|OS |
// +---+---+---+---+---+---+---+---+---+---+
// ID1 \037
// ID2 \213
// CM \010 (compression method == DEFLATE)
// FLG \000 (special flags that we do not support)
// MTIME Unix format modification time (0 means not available)
// XFL 2-4? DEFLATE flags
// OS ???? Operating system indicator (255 means unknown)
//
// Header value we generate:
const char kGZipHeader[] = { '\037', '\213', '\010', '\000', '\000',
'\000', '\000', '\000', '\002', '\377' };
enum EncodeMode {
ENCODE_GZIP, // Wrap the deflate with a GZip header.
ENCODE_DEFLATE // Raw deflate.
};
} // namespace
namespace net {
// These tests use the path service, which uses autoreleased objects on the
// Mac, so this needs to be a PlatformTest.
class GZipUnitTest : public PlatformTest {
protected:
void SetUp() override {
PlatformTest::SetUp();
deflate_encode_buffer_ = NULL;
gzip_encode_buffer_ = NULL;
// Get the path of source data file.
base::FilePath file_path;
PathService::Get(base::DIR_SOURCE_ROOT, &file_path);
file_path = file_path.AppendASCII("net");
file_path = file_path.AppendASCII("data");
file_path = file_path.AppendASCII("filter_unittests");
file_path = file_path.AppendASCII("google.txt");
// Read data from the file into buffer.
ASSERT_TRUE(base::ReadFileToString(file_path, &source_buffer_));
// Encode the data with deflate
deflate_encode_buffer_ = new char[kDefaultBufferSize];
ASSERT_TRUE(deflate_encode_buffer_ != NULL);
deflate_encode_len_ = kDefaultBufferSize;
int code = CompressAll(ENCODE_DEFLATE , source_buffer(), source_len(),
deflate_encode_buffer_, &deflate_encode_len_);
ASSERT_TRUE(code == Z_STREAM_END);
ASSERT_GT(deflate_encode_len_, 0);
ASSERT_TRUE(deflate_encode_len_ <= kDefaultBufferSize);
// Encode the data with gzip
gzip_encode_buffer_ = new char[kDefaultBufferSize];
ASSERT_TRUE(gzip_encode_buffer_ != NULL);
gzip_encode_len_ = kDefaultBufferSize;
code = CompressAll(ENCODE_GZIP, source_buffer(), source_len(),
gzip_encode_buffer_, &gzip_encode_len_);
ASSERT_TRUE(code == Z_STREAM_END);
ASSERT_GT(gzip_encode_len_, 0);
ASSERT_TRUE(gzip_encode_len_ <= kDefaultBufferSize);
}
void TearDown() override {
delete[] deflate_encode_buffer_;
deflate_encode_buffer_ = NULL;
delete[] gzip_encode_buffer_;
gzip_encode_buffer_ = NULL;
PlatformTest::TearDown();
}
// Compress the data in source with deflate encoding and write output to the
// buffer provided by dest. The function returns Z_OK if success, and returns
// other zlib error code if fail.
// The parameter mode specifies the encoding mechanism.
// The dest buffer should be large enough to hold all the output data.
int CompressAll(EncodeMode mode, const char* source, int source_size,
char* dest, int* dest_len) {
z_stream zlib_stream;
memset(&zlib_stream, 0, sizeof(zlib_stream));
int code;
// Initialize zlib
if (mode == ENCODE_GZIP) {
code = deflateInit2(&zlib_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
-MAX_WBITS,
8, // DEF_MEM_LEVEL
Z_DEFAULT_STRATEGY);
} else {
code = deflateInit(&zlib_stream, Z_DEFAULT_COMPRESSION);
}
if (code != Z_OK)
return code;
// Fill in zlib control block
zlib_stream.next_in = bit_cast<Bytef*>(source);
zlib_stream.avail_in = source_size;
zlib_stream.next_out = bit_cast<Bytef*>(dest);
zlib_stream.avail_out = *dest_len;
// Write header if needed
if (mode == ENCODE_GZIP) {
if (zlib_stream.avail_out < sizeof(kGZipHeader))
return Z_BUF_ERROR;
memcpy(zlib_stream.next_out, kGZipHeader, sizeof(kGZipHeader));
zlib_stream.next_out += sizeof(kGZipHeader);
zlib_stream.avail_out -= sizeof(kGZipHeader);
}
// Do deflate
code = deflate(&zlib_stream, Z_FINISH);
*dest_len = *dest_len - zlib_stream.avail_out;
deflateEnd(&zlib_stream);
return code;
}
// Use filter to decode compressed data, and compare the decoding result with
// the orginal Data.
// Parameters: Source and source_len are original data and its size.
// Encoded_source and encoded_source_len are compressed data and its size.
// Output_buffer_size specifies the size of buffer to read out data from
// filter.
void DecodeAndCompareWithFilter(Filter* filter,
const char* source,
int source_len,
const char* encoded_source,
int encoded_source_len,
int output_buffer_size) {
// Make sure we have enough space to hold the decoding output.
ASSERT_TRUE(source_len <= kDefaultBufferSize);
ASSERT_TRUE(output_buffer_size <= kDefaultBufferSize);
char decode_buffer[kDefaultBufferSize];
char* decode_next = decode_buffer;
int decode_avail_size = kDefaultBufferSize;
const char* encode_next = encoded_source;
int encode_avail_size = encoded_source_len;
int code = Filter::FILTER_OK;
while (code != Filter::FILTER_DONE) {
int encode_data_len;
encode_data_len = std::min(encode_avail_size,
filter->stream_buffer_size());
memcpy(filter->stream_buffer()->data(), encode_next, encode_data_len);
filter->FlushStreamBuffer(encode_data_len);
encode_next += encode_data_len;
encode_avail_size -= encode_data_len;
while (1) {
int decode_data_len = std::min(decode_avail_size, output_buffer_size);
code = filter->ReadData(decode_next, &decode_data_len);
decode_next += decode_data_len;
decode_avail_size -= decode_data_len;
ASSERT_TRUE(code != Filter::FILTER_ERROR);
if (code == Filter::FILTER_NEED_MORE_DATA ||
code == Filter::FILTER_DONE) {
break;
}
}
}
// Compare the decoding result with source data
int decode_total_data_len = kDefaultBufferSize - decode_avail_size;
EXPECT_TRUE(decode_total_data_len == source_len);
EXPECT_EQ(memcmp(source, decode_buffer, source_len), 0);
}
// Unsafe function to use filter to decode compressed data.
// Parameters: Source and source_len are compressed data and its size.
// Dest is the buffer for decoding results. Upon entry, *dest_len is the size
// of the dest buffer. Upon exit, *dest_len is the number of chars written
// into the buffer.
int DecodeAllWithFilter(Filter* filter, const char* source, int source_len,
char* dest, int* dest_len) {
memcpy(filter->stream_buffer()->data(), source, source_len);
filter->FlushStreamBuffer(source_len);
return filter->ReadData(dest, dest_len);
}
void InitFilter(Filter::FilterType type) {
std::vector<Filter::FilterType> filter_types;
filter_types.push_back(type);
filter_.reset(Filter::Factory(filter_types, filter_context_));
ASSERT_TRUE(filter_.get());
ASSERT_GE(filter_->stream_buffer_size(), kDefaultBufferSize);
}
void InitFilterWithBufferSize(Filter::FilterType type, int buffer_size) {
std::vector<Filter::FilterType> filter_types;
filter_types.push_back(type);
filter_.reset(Filter::FactoryForTests(filter_types, filter_context_,
buffer_size));
ASSERT_TRUE(filter_.get());
}
const char* source_buffer() const { return source_buffer_.data(); }
int source_len() const { return static_cast<int>(source_buffer_.size()); }
scoped_ptr<Filter> filter_;
std::string source_buffer_;
char* deflate_encode_buffer_;
int deflate_encode_len_;
char* gzip_encode_buffer_;
int gzip_encode_len_;
private:
MockFilterContext filter_context_;
};
// Basic scenario: decoding deflate data with big enough buffer.
TEST_F(GZipUnitTest, DecodeDeflate) {
// Decode the compressed data with filter
InitFilter(Filter::FILTER_TYPE_DEFLATE);
memcpy(filter_->stream_buffer()->data(), deflate_encode_buffer_,
deflate_encode_len_);
filter_->FlushStreamBuffer(deflate_encode_len_);
char deflate_decode_buffer[kDefaultBufferSize];
int deflate_decode_size = kDefaultBufferSize;
filter_->ReadData(deflate_decode_buffer, &deflate_decode_size);
// Compare the decoding result with source data
EXPECT_TRUE(deflate_decode_size == source_len());
EXPECT_EQ(memcmp(source_buffer(), deflate_decode_buffer, source_len()), 0);
}
// Basic scenario: decoding gzip data with big enough buffer.
TEST_F(GZipUnitTest, DecodeGZip) {
// Decode the compressed data with filter
InitFilter(Filter::FILTER_TYPE_GZIP);
memcpy(filter_->stream_buffer()->data(), gzip_encode_buffer_,
gzip_encode_len_);
filter_->FlushStreamBuffer(gzip_encode_len_);
char gzip_decode_buffer[kDefaultBufferSize];
int gzip_decode_size = kDefaultBufferSize;
filter_->ReadData(gzip_decode_buffer, &gzip_decode_size);
// Compare the decoding result with source data
EXPECT_TRUE(gzip_decode_size == source_len());
EXPECT_EQ(memcmp(source_buffer(), gzip_decode_buffer, source_len()), 0);
}
// Tests we can call filter repeatedly to get all the data decoded.
// To do that, we create a filter with a small buffer that can not hold all
// the input data.
TEST_F(GZipUnitTest, DecodeWithSmallBuffer) {
InitFilterWithBufferSize(Filter::FILTER_TYPE_DEFLATE, kSmallBufferSize);
EXPECT_EQ(kSmallBufferSize, filter_->stream_buffer_size());
DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
deflate_encode_buffer_, deflate_encode_len_,
kDefaultBufferSize);
}
// Tests we can still decode with just 1 byte buffer in the filter.
// The purpose of this tests are two: (1) Verify filter can parse partial GZip
// header correctly. (2) Sometimes the filter will consume input without
// generating output. Verify filter can handle it correctly.
TEST_F(GZipUnitTest, DecodeWithOneByteBuffer) {
InitFilterWithBufferSize(Filter::FILTER_TYPE_GZIP, 1);
EXPECT_EQ(1, filter_->stream_buffer_size());
DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
gzip_encode_buffer_, gzip_encode_len_,
kDefaultBufferSize);
}
// Tests we can decode when caller has small buffer to read out from filter.
TEST_F(GZipUnitTest, DecodeWithSmallOutputBuffer) {
InitFilter(Filter::FILTER_TYPE_DEFLATE);
DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
deflate_encode_buffer_, deflate_encode_len_,
kSmallBufferSize);
}
// Tests we can still decode with just 1 byte buffer in the filter and just 1
// byte buffer in the caller.
TEST_F(GZipUnitTest, DecodeWithOneByteInputAndOutputBuffer) {
InitFilterWithBufferSize(Filter::FILTER_TYPE_GZIP, 1);
EXPECT_EQ(1, filter_->stream_buffer_size());
DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
gzip_encode_buffer_, gzip_encode_len_, 1);
}
// Decoding deflate stream with corrupted data.
TEST_F(GZipUnitTest, DecodeCorruptedData) {
char corrupt_data[kDefaultBufferSize];
int corrupt_data_len = deflate_encode_len_;
memcpy(corrupt_data, deflate_encode_buffer_, deflate_encode_len_);
int pos = corrupt_data_len / 2;
corrupt_data[pos] = !corrupt_data[pos];
// Decode the corrupted data with filter
InitFilter(Filter::FILTER_TYPE_DEFLATE);
char corrupt_decode_buffer[kDefaultBufferSize];
int corrupt_decode_size = kDefaultBufferSize;
int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
corrupt_decode_buffer, &corrupt_decode_size);
// Expect failures
EXPECT_TRUE(code == Filter::FILTER_ERROR);
}
// Decoding deflate stream with missing data.
TEST_F(GZipUnitTest, DecodeMissingData) {
char corrupt_data[kDefaultBufferSize];
int corrupt_data_len = deflate_encode_len_;
memcpy(corrupt_data, deflate_encode_buffer_, deflate_encode_len_);
int pos = corrupt_data_len / 2;
int len = corrupt_data_len - pos - 1;
memmove(&corrupt_data[pos], &corrupt_data[pos+1], len);
--corrupt_data_len;
// Decode the corrupted data with filter
InitFilter(Filter::FILTER_TYPE_DEFLATE);
char corrupt_decode_buffer[kDefaultBufferSize];
int corrupt_decode_size = kDefaultBufferSize;
int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
corrupt_decode_buffer, &corrupt_decode_size);
// Expect failures
EXPECT_EQ(Filter::FILTER_ERROR, code);
}
// Decoding gzip stream with corrupted header.
TEST_F(GZipUnitTest, DecodeCorruptedHeader) {
char corrupt_data[kDefaultBufferSize];
int corrupt_data_len = gzip_encode_len_;
memcpy(corrupt_data, gzip_encode_buffer_, gzip_encode_len_);
corrupt_data[2] = !corrupt_data[2];
// Decode the corrupted data with filter
InitFilter(Filter::FILTER_TYPE_GZIP);
char corrupt_decode_buffer[kDefaultBufferSize];
int corrupt_decode_size = kDefaultBufferSize;
int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
corrupt_decode_buffer, &corrupt_decode_size);
// Expect failures
EXPECT_TRUE(code == Filter::FILTER_ERROR);
}
} // namespace net