You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
134 lines
4.8 KiB
134 lines
4.8 KiB
// 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 "third_party/zlib/google/compression_utils.h"
|
|
|
|
#include "base/bit_cast.h"
|
|
#include "base/check_op.h"
|
|
#include "base/process/memory.h"
|
|
#include "base/sys_byteorder.h"
|
|
|
|
#include "third_party/zlib/google/compression_utils_portable.h"
|
|
|
|
namespace compression {
|
|
|
|
bool GzipCompress(base::span<const char> input,
|
|
char* output_buffer,
|
|
size_t output_buffer_size,
|
|
size_t* compressed_size,
|
|
void* (*malloc_fn)(size_t),
|
|
void (*free_fn)(void*)) {
|
|
static_assert(sizeof(Bytef) == 1, "");
|
|
|
|
// uLongf can be larger than size_t.
|
|
uLongf compressed_size_long = static_cast<uLongf>(output_buffer_size);
|
|
if (zlib_internal::GzipCompressHelper(
|
|
bit_cast<Bytef*>(output_buffer), &compressed_size_long,
|
|
bit_cast<const Bytef*>(input.data()),
|
|
static_cast<uLongf>(input.size()), malloc_fn, free_fn) != Z_OK) {
|
|
return false;
|
|
}
|
|
// No overflow, as compressed_size_long <= output.size() which is a size_t.
|
|
*compressed_size = static_cast<size_t>(compressed_size_long);
|
|
return true;
|
|
}
|
|
|
|
bool GzipCompress(base::span<const char> input, std::string* output) {
|
|
return GzipCompress(base::as_bytes(input), output);
|
|
}
|
|
|
|
bool GzipCompress(base::span<const uint8_t> input, std::string* output) {
|
|
// Not using std::vector<> because allocation failures are recoverable,
|
|
// which is hidden by std::vector<>.
|
|
static_assert(sizeof(Bytef) == 1, "");
|
|
const uLongf input_size = static_cast<uLongf>(input.size());
|
|
|
|
uLongf compressed_data_size =
|
|
zlib_internal::GzipExpectedCompressedSize(input_size);
|
|
|
|
Bytef* compressed_data;
|
|
if (!base::UncheckedMalloc(compressed_data_size,
|
|
reinterpret_cast<void**>(&compressed_data))) {
|
|
return false;
|
|
}
|
|
|
|
if (zlib_internal::GzipCompressHelper(compressed_data, &compressed_data_size,
|
|
bit_cast<const Bytef*>(input.data()),
|
|
input_size, nullptr, nullptr) != Z_OK) {
|
|
free(compressed_data);
|
|
return false;
|
|
}
|
|
|
|
Bytef* resized_data =
|
|
reinterpret_cast<Bytef*>(realloc(compressed_data, compressed_data_size));
|
|
if (!resized_data) {
|
|
free(compressed_data);
|
|
return false;
|
|
}
|
|
output->assign(resized_data, resized_data + compressed_data_size);
|
|
DCHECK_EQ(input_size, GetUncompressedSize(*output));
|
|
|
|
free(resized_data);
|
|
return true;
|
|
}
|
|
|
|
bool GzipUncompress(const std::string& input, std::string* output) {
|
|
std::string uncompressed_output;
|
|
uLongf uncompressed_size = static_cast<uLongf>(GetUncompressedSize(input));
|
|
if (uncompressed_size > uncompressed_output.max_size())
|
|
return false;
|
|
|
|
uncompressed_output.resize(uncompressed_size);
|
|
if (zlib_internal::GzipUncompressHelper(
|
|
bit_cast<Bytef*>(uncompressed_output.data()), &uncompressed_size,
|
|
bit_cast<const Bytef*>(input.data()),
|
|
static_cast<uLongf>(input.length())) == Z_OK) {
|
|
output->swap(uncompressed_output);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool GzipUncompress(base::span<const char> input,
|
|
base::span<const char> output) {
|
|
return GzipUncompress(base::as_bytes(input), base::as_bytes(output));
|
|
}
|
|
|
|
bool GzipUncompress(base::span<const uint8_t> input,
|
|
base::span<const uint8_t> output) {
|
|
uLongf uncompressed_size = GetUncompressedSize(input);
|
|
if (uncompressed_size > output.size())
|
|
return false;
|
|
return zlib_internal::GzipUncompressHelper(
|
|
bit_cast<Bytef*>(output.data()), &uncompressed_size,
|
|
bit_cast<const Bytef*>(input.data()),
|
|
static_cast<uLongf>(input.size())) == Z_OK;
|
|
}
|
|
|
|
bool GzipUncompress(base::span<const char> input, std::string* output) {
|
|
return GzipUncompress(base::as_bytes(input), output);
|
|
}
|
|
|
|
bool GzipUncompress(base::span<const uint8_t> input, std::string* output) {
|
|
// Disallow in-place usage, i.e., |input| using |*output| as underlying data.
|
|
DCHECK_NE(reinterpret_cast<const char*>(input.data()), output->data());
|
|
uLongf uncompressed_size = GetUncompressedSize(input);
|
|
output->resize(uncompressed_size);
|
|
return zlib_internal::GzipUncompressHelper(
|
|
bit_cast<Bytef*>(output->data()), &uncompressed_size,
|
|
bit_cast<const Bytef*>(input.data()),
|
|
static_cast<uLongf>(input.size())) == Z_OK;
|
|
}
|
|
|
|
uint32_t GetUncompressedSize(base::span<const char> compressed_data) {
|
|
return GetUncompressedSize(base::as_bytes(compressed_data));
|
|
}
|
|
|
|
uint32_t GetUncompressedSize(base::span<const uint8_t> compressed_data) {
|
|
return zlib_internal::GetGzipUncompressedSize(
|
|
bit_cast<Bytef*>(compressed_data.data()), compressed_data.size());
|
|
}
|
|
|
|
} // namespace compression
|