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