1 // Copyright 2014 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "third_party/zlib/google/compression_utils.h"
6
7 #include "base/check_op.h"
8 #include "base/process/memory.h"
9
10 #include "third_party/zlib/google/compression_utils_portable.h"
11
12 namespace compression {
13
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 *))14 bool GzipCompress(base::span<const char> input,
15 char* output_buffer,
16 size_t output_buffer_size,
17 size_t* compressed_size,
18 void* (*malloc_fn)(size_t),
19 void (*free_fn)(void*)) {
20 static_assert(sizeof(Bytef) == 1, "");
21
22 // uLongf can be larger than size_t.
23 uLongf compressed_size_long = static_cast<uLongf>(output_buffer_size);
24 if (zlib_internal::GzipCompressHelper(
25 reinterpret_cast<Bytef*>(output_buffer), &compressed_size_long,
26 reinterpret_cast<const Bytef*>(input.data()),
27 static_cast<uLongf>(input.size()), malloc_fn, free_fn) != Z_OK) {
28 return false;
29 }
30 // No overflow, as compressed_size_long <= output.size() which is a size_t.
31 *compressed_size = static_cast<size_t>(compressed_size_long);
32 return true;
33 }
34
GzipCompress(base::span<const char> input,std::string * output)35 bool GzipCompress(base::span<const char> input, std::string* output) {
36 return GzipCompress(base::as_bytes(input), output);
37 }
38
GzipCompress(base::span<const uint8_t> input,std::string * output)39 bool GzipCompress(base::span<const uint8_t> input, std::string* output) {
40 // Not using std::vector<> because allocation failures are recoverable,
41 // which is hidden by std::vector<>.
42 static_assert(sizeof(Bytef) == 1, "");
43 const uLongf input_size = static_cast<uLongf>(input.size());
44
45 uLongf compressed_data_size =
46 zlib_internal::GzipExpectedCompressedSize(input_size);
47
48 Bytef* compressed_data;
49 if (!base::UncheckedMalloc(compressed_data_size,
50 reinterpret_cast<void**>(&compressed_data))) {
51 return false;
52 }
53
54 if (zlib_internal::GzipCompressHelper(
55 compressed_data, &compressed_data_size,
56 reinterpret_cast<const Bytef*>(input.data()), input_size, nullptr,
57 nullptr) != Z_OK) {
58 free(compressed_data);
59 return false;
60 }
61
62 Bytef* resized_data =
63 reinterpret_cast<Bytef*>(realloc(compressed_data, compressed_data_size));
64 if (!resized_data) {
65 free(compressed_data);
66 return false;
67 }
68 output->assign(resized_data, resized_data + compressed_data_size);
69 DCHECK_EQ(input_size, GetUncompressedSize(*output));
70
71 free(resized_data);
72 return true;
73 }
74
GzipUncompress(const std::string & input,std::string * output)75 bool GzipUncompress(const std::string& input, std::string* output) {
76 std::string uncompressed_output;
77 uLongf uncompressed_size = static_cast<uLongf>(GetUncompressedSize(input));
78 if (size_t{uncompressed_size} > uncompressed_output.max_size())
79 return false;
80
81 uncompressed_output.resize(uncompressed_size);
82 if (zlib_internal::GzipUncompressHelper(
83 reinterpret_cast<Bytef*>(uncompressed_output.data()),
84 &uncompressed_size, reinterpret_cast<const Bytef*>(input.data()),
85 static_cast<uLongf>(input.length())) == Z_OK) {
86 output->swap(uncompressed_output);
87 return true;
88 }
89 return false;
90 }
91
GzipUncompress(base::span<const char> input,base::span<const char> output)92 bool GzipUncompress(base::span<const char> input,
93 base::span<const char> output) {
94 return GzipUncompress(base::as_bytes(input), base::as_bytes(output));
95 }
96
GzipUncompress(base::span<const uint8_t> input,base::span<const uint8_t> output)97 bool GzipUncompress(base::span<const uint8_t> input,
98 base::span<const uint8_t> output) {
99 uLongf uncompressed_size = GetUncompressedSize(input);
100 if (uncompressed_size > output.size())
101 return false;
102 return zlib_internal::GzipUncompressHelper(
103 reinterpret_cast<Bytef*>(const_cast<uint8_t*>(output.data())),
104 &uncompressed_size, reinterpret_cast<const Bytef*>(input.data()),
105 static_cast<uLongf>(input.size())) == Z_OK;
106 }
107
GzipUncompress(base::span<const char> input,std::string * output)108 bool GzipUncompress(base::span<const char> input, std::string* output) {
109 return GzipUncompress(base::as_bytes(input), output);
110 }
111
GzipUncompress(base::span<const uint8_t> input,std::string * output)112 bool GzipUncompress(base::span<const uint8_t> input, std::string* output) {
113 // Disallow in-place usage, i.e., |input| using |*output| as underlying data.
114 DCHECK_NE(reinterpret_cast<const char*>(input.data()), output->data());
115 uLongf uncompressed_size = GetUncompressedSize(input);
116 output->resize(uncompressed_size);
117 return zlib_internal::GzipUncompressHelper(
118 reinterpret_cast<Bytef*>(output->data()), &uncompressed_size,
119 reinterpret_cast<const Bytef*>(input.data()),
120 static_cast<uLongf>(input.size())) == Z_OK;
121 }
122
GetUncompressedSize(base::span<const char> compressed_data)123 uint32_t GetUncompressedSize(base::span<const char> compressed_data) {
124 return GetUncompressedSize(base::as_bytes(compressed_data));
125 }
126
GetUncompressedSize(base::span<const uint8_t> compressed_data)127 uint32_t GetUncompressedSize(base::span<const uint8_t> compressed_data) {
128 return zlib_internal::GetGzipUncompressedSize(
129 reinterpret_cast<const Bytef*>(compressed_data.data()),
130 compressed_data.size());
131 }
132
133 } // namespace compression
134