1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "ziparchive/zip_writer.h"
18 #include "ziparchive/zip_archive.h"
19
20 #include <android-base/test_utils.h>
21 #include <gtest/gtest.h>
22 #include <time.h>
23 #include <memory>
24 #include <vector>
25
26 static ::testing::AssertionResult AssertFileEntryContentsEq(const std::string& expected,
27 ZipArchiveHandle handle,
28 ZipEntry* zip_entry);
29
30 struct zipwriter : public ::testing::Test {
31 TemporaryFile* temp_file_;
32 int fd_;
33 FILE* file_;
34
SetUpzipwriter35 void SetUp() override {
36 temp_file_ = new TemporaryFile();
37 fd_ = temp_file_->fd;
38 file_ = fdopen(fd_, "w");
39 ASSERT_NE(file_, nullptr);
40 }
41
TearDownzipwriter42 void TearDown() override {
43 fclose(file_);
44 delete temp_file_;
45 }
46 };
47
TEST_F(zipwriter,WriteUncompressedZipWithOneFile)48 TEST_F(zipwriter, WriteUncompressedZipWithOneFile) {
49 ZipWriter writer(file_);
50
51 const char* expected = "hello";
52
53 ASSERT_EQ(0, writer.StartEntry("file.txt", 0));
54 ASSERT_EQ(0, writer.WriteBytes("he", 2));
55 ASSERT_EQ(0, writer.WriteBytes("llo", 3));
56 ASSERT_EQ(0, writer.FinishEntry());
57 ASSERT_EQ(0, writer.Finish());
58
59 ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
60
61 ZipArchiveHandle handle;
62 ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
63
64 ZipEntry data;
65 ASSERT_EQ(0, FindEntry(handle, ZipString("file.txt"), &data));
66 EXPECT_EQ(kCompressStored, data.method);
67 EXPECT_EQ(0u, data.has_data_descriptor);
68 EXPECT_EQ(strlen(expected), data.compressed_length);
69 ASSERT_EQ(strlen(expected), data.uncompressed_length);
70 ASSERT_TRUE(AssertFileEntryContentsEq(expected, handle, &data));
71
72 CloseArchive(handle);
73 }
74
TEST_F(zipwriter,WriteUncompressedZipWithMultipleFiles)75 TEST_F(zipwriter, WriteUncompressedZipWithMultipleFiles) {
76 ZipWriter writer(file_);
77
78 ASSERT_EQ(0, writer.StartEntry("file.txt", 0));
79 ASSERT_EQ(0, writer.WriteBytes("he", 2));
80 ASSERT_EQ(0, writer.FinishEntry());
81
82 ASSERT_EQ(0, writer.StartEntry("file/file.txt", 0));
83 ASSERT_EQ(0, writer.WriteBytes("llo", 3));
84 ASSERT_EQ(0, writer.FinishEntry());
85
86 ASSERT_EQ(0, writer.StartEntry("file/file2.txt", 0));
87 ASSERT_EQ(0, writer.FinishEntry());
88
89 ASSERT_EQ(0, writer.Finish());
90
91 ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
92
93 ZipArchiveHandle handle;
94 ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
95
96 ZipEntry data;
97
98 ASSERT_EQ(0, FindEntry(handle, ZipString("file.txt"), &data));
99 EXPECT_EQ(kCompressStored, data.method);
100 EXPECT_EQ(2u, data.compressed_length);
101 ASSERT_EQ(2u, data.uncompressed_length);
102 ASSERT_TRUE(AssertFileEntryContentsEq("he", handle, &data));
103
104 ASSERT_EQ(0, FindEntry(handle, ZipString("file/file.txt"), &data));
105 EXPECT_EQ(kCompressStored, data.method);
106 EXPECT_EQ(3u, data.compressed_length);
107 ASSERT_EQ(3u, data.uncompressed_length);
108 ASSERT_TRUE(AssertFileEntryContentsEq("llo", handle, &data));
109
110 ASSERT_EQ(0, FindEntry(handle, ZipString("file/file2.txt"), &data));
111 EXPECT_EQ(kCompressStored, data.method);
112 EXPECT_EQ(0u, data.compressed_length);
113 EXPECT_EQ(0u, data.uncompressed_length);
114
115 CloseArchive(handle);
116 }
117
TEST_F(zipwriter,WriteUncompressedZipFileWithAlignedFlag)118 TEST_F(zipwriter, WriteUncompressedZipFileWithAlignedFlag) {
119 ZipWriter writer(file_);
120
121 ASSERT_EQ(0, writer.StartEntry("align.txt", ZipWriter::kAlign32));
122 ASSERT_EQ(0, writer.WriteBytes("he", 2));
123 ASSERT_EQ(0, writer.FinishEntry());
124 ASSERT_EQ(0, writer.Finish());
125
126 ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
127
128 ZipArchiveHandle handle;
129 ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
130
131 ZipEntry data;
132 ASSERT_EQ(0, FindEntry(handle, ZipString("align.txt"), &data));
133 EXPECT_EQ(0, data.offset & 0x03);
134
135 CloseArchive(handle);
136 }
137
MakeTm()138 static struct tm MakeTm() {
139 struct tm tm;
140 memset(&tm, 0, sizeof(struct tm));
141 tm.tm_year = 2001 - 1900;
142 tm.tm_mon = 1;
143 tm.tm_mday = 12;
144 tm.tm_hour = 18;
145 tm.tm_min = 30;
146 tm.tm_sec = 20;
147 return tm;
148 }
149
TEST_F(zipwriter,WriteUncompressedZipFileWithAlignedFlagAndTime)150 TEST_F(zipwriter, WriteUncompressedZipFileWithAlignedFlagAndTime) {
151 ZipWriter writer(file_);
152
153 struct tm tm = MakeTm();
154 time_t time = mktime(&tm);
155 ASSERT_EQ(0, writer.StartEntryWithTime("align.txt", ZipWriter::kAlign32, time));
156 ASSERT_EQ(0, writer.WriteBytes("he", 2));
157 ASSERT_EQ(0, writer.FinishEntry());
158 ASSERT_EQ(0, writer.Finish());
159
160 ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
161
162 ZipArchiveHandle handle;
163 ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
164
165 ZipEntry data;
166 ASSERT_EQ(0, FindEntry(handle, ZipString("align.txt"), &data));
167 EXPECT_EQ(0, data.offset & 0x03);
168
169 struct tm mod = data.GetModificationTime();
170 EXPECT_EQ(tm.tm_sec, mod.tm_sec);
171 EXPECT_EQ(tm.tm_min, mod.tm_min);
172 EXPECT_EQ(tm.tm_hour, mod.tm_hour);
173 EXPECT_EQ(tm.tm_mday, mod.tm_mday);
174 EXPECT_EQ(tm.tm_mon, mod.tm_mon);
175 EXPECT_EQ(tm.tm_year, mod.tm_year);
176
177 CloseArchive(handle);
178 }
179
TEST_F(zipwriter,WriteUncompressedZipFileWithAlignedValue)180 TEST_F(zipwriter, WriteUncompressedZipFileWithAlignedValue) {
181 ZipWriter writer(file_);
182
183 ASSERT_EQ(0, writer.StartAlignedEntry("align.txt", 0, 4096));
184 ASSERT_EQ(0, writer.WriteBytes("he", 2));
185 ASSERT_EQ(0, writer.FinishEntry());
186 ASSERT_EQ(0, writer.Finish());
187
188 ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
189
190 ZipArchiveHandle handle;
191 ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
192
193 ZipEntry data;
194 ASSERT_EQ(0, FindEntry(handle, ZipString("align.txt"), &data));
195 EXPECT_EQ(0, data.offset & 0xfff);
196
197 CloseArchive(handle);
198 }
199
TEST_F(zipwriter,WriteUncompressedZipFileWithAlignedValueAndTime)200 TEST_F(zipwriter, WriteUncompressedZipFileWithAlignedValueAndTime) {
201 ZipWriter writer(file_);
202
203 struct tm tm = MakeTm();
204 time_t time = mktime(&tm);
205 ASSERT_EQ(0, writer.StartAlignedEntryWithTime("align.txt", 0, time, 4096));
206 ASSERT_EQ(0, writer.WriteBytes("he", 2));
207 ASSERT_EQ(0, writer.FinishEntry());
208 ASSERT_EQ(0, writer.Finish());
209
210 ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
211
212 ZipArchiveHandle handle;
213 ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
214
215 ZipEntry data;
216 ASSERT_EQ(0, FindEntry(handle, ZipString("align.txt"), &data));
217 EXPECT_EQ(0, data.offset & 0xfff);
218
219 struct tm mod = data.GetModificationTime();
220 EXPECT_EQ(tm.tm_sec, mod.tm_sec);
221 EXPECT_EQ(tm.tm_min, mod.tm_min);
222 EXPECT_EQ(tm.tm_hour, mod.tm_hour);
223 EXPECT_EQ(tm.tm_mday, mod.tm_mday);
224 EXPECT_EQ(tm.tm_mon, mod.tm_mon);
225 EXPECT_EQ(tm.tm_year, mod.tm_year);
226
227 CloseArchive(handle);
228 }
229
TEST_F(zipwriter,WriteCompressedZipWithOneFile)230 TEST_F(zipwriter, WriteCompressedZipWithOneFile) {
231 ZipWriter writer(file_);
232
233 ASSERT_EQ(0, writer.StartEntry("file.txt", ZipWriter::kCompress));
234 ASSERT_EQ(0, writer.WriteBytes("helo", 4));
235 ASSERT_EQ(0, writer.FinishEntry());
236 ASSERT_EQ(0, writer.Finish());
237
238 ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
239
240 ZipArchiveHandle handle;
241 ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
242
243 ZipEntry data;
244 ASSERT_EQ(0, FindEntry(handle, ZipString("file.txt"), &data));
245 EXPECT_EQ(kCompressDeflated, data.method);
246 ASSERT_EQ(4u, data.uncompressed_length);
247 ASSERT_TRUE(AssertFileEntryContentsEq("helo", handle, &data));
248
249 CloseArchive(handle);
250 }
251
TEST_F(zipwriter,WriteCompressedZipFlushFull)252 TEST_F(zipwriter, WriteCompressedZipFlushFull) {
253 // This exact data will cause the Finish() to require multiple calls
254 // to deflate() because the ZipWriter buffer isn't big enough to hold
255 // the entire compressed data buffer.
256 constexpr size_t kBufSize = 10000000;
257 std::vector<uint8_t> buffer(kBufSize);
258 size_t prev = 1;
259 for (size_t i = 0; i < kBufSize; i++) {
260 buffer[i] = i + prev;
261 prev = i;
262 }
263
264 ZipWriter writer(file_);
265 ASSERT_EQ(0, writer.StartEntry("file.txt", ZipWriter::kCompress));
266 ASSERT_EQ(0, writer.WriteBytes(buffer.data(), buffer.size()));
267 ASSERT_EQ(0, writer.FinishEntry());
268 ASSERT_EQ(0, writer.Finish());
269
270 ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
271
272 ZipArchiveHandle handle;
273 ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
274
275 ZipEntry data;
276 ASSERT_EQ(0, FindEntry(handle, ZipString("file.txt"), &data));
277 EXPECT_EQ(kCompressDeflated, data.method);
278 EXPECT_EQ(kBufSize, data.uncompressed_length);
279
280 std::vector<uint8_t> decompress(kBufSize);
281 memset(decompress.data(), 0, kBufSize);
282 ASSERT_EQ(0, ExtractToMemory(handle, &data, decompress.data(), decompress.size()));
283 EXPECT_EQ(0, memcmp(decompress.data(), buffer.data(), kBufSize))
284 << "Input buffer and output buffer are different.";
285
286 CloseArchive(handle);
287 }
288
TEST_F(zipwriter,CheckStartEntryErrors)289 TEST_F(zipwriter, CheckStartEntryErrors) {
290 ZipWriter writer(file_);
291
292 ASSERT_EQ(-5, writer.StartAlignedEntry("align.txt", ZipWriter::kAlign32, 4096));
293 ASSERT_EQ(-6, writer.StartAlignedEntry("align.txt", 0, 3));
294 }
295
TEST_F(zipwriter,BackupRemovesTheLastFile)296 TEST_F(zipwriter, BackupRemovesTheLastFile) {
297 ZipWriter writer(file_);
298
299 const char* kKeepThis = "keep this";
300 const char* kDropThis = "drop this";
301 const char* kReplaceWithThis = "replace with this";
302
303 ZipWriter::FileEntry entry;
304 EXPECT_LT(writer.GetLastEntry(&entry), 0);
305
306 ASSERT_EQ(0, writer.StartEntry("keep.txt", 0));
307 ASSERT_EQ(0, writer.WriteBytes(kKeepThis, strlen(kKeepThis)));
308 ASSERT_EQ(0, writer.FinishEntry());
309
310 ASSERT_EQ(0, writer.GetLastEntry(&entry));
311 EXPECT_EQ("keep.txt", entry.path);
312
313 ASSERT_EQ(0, writer.StartEntry("drop.txt", 0));
314 ASSERT_EQ(0, writer.WriteBytes(kDropThis, strlen(kDropThis)));
315 ASSERT_EQ(0, writer.FinishEntry());
316
317 ASSERT_EQ(0, writer.GetLastEntry(&entry));
318 EXPECT_EQ("drop.txt", entry.path);
319
320 ASSERT_EQ(0, writer.DiscardLastEntry());
321
322 ASSERT_EQ(0, writer.GetLastEntry(&entry));
323 EXPECT_EQ("keep.txt", entry.path);
324
325 ASSERT_EQ(0, writer.StartEntry("replace.txt", 0));
326 ASSERT_EQ(0, writer.WriteBytes(kReplaceWithThis, strlen(kReplaceWithThis)));
327 ASSERT_EQ(0, writer.FinishEntry());
328
329 ASSERT_EQ(0, writer.GetLastEntry(&entry));
330 EXPECT_EQ("replace.txt", entry.path);
331
332 ASSERT_EQ(0, writer.Finish());
333
334 // Verify that "drop.txt" does not exist.
335
336 ASSERT_GE(0, lseek(fd_, 0, SEEK_SET));
337
338 ZipArchiveHandle handle;
339 ASSERT_EQ(0, OpenArchiveFd(fd_, "temp", &handle, false));
340
341 ZipEntry data;
342 ASSERT_EQ(0, FindEntry(handle, ZipString("keep.txt"), &data));
343 ASSERT_TRUE(AssertFileEntryContentsEq(kKeepThis, handle, &data));
344
345 ASSERT_NE(0, FindEntry(handle, ZipString("drop.txt"), &data));
346
347 ASSERT_EQ(0, FindEntry(handle, ZipString("replace.txt"), &data));
348 ASSERT_TRUE(AssertFileEntryContentsEq(kReplaceWithThis, handle, &data));
349
350 CloseArchive(handle);
351 }
352
TEST_F(zipwriter,TruncateFileAfterBackup)353 TEST_F(zipwriter, TruncateFileAfterBackup) {
354 ZipWriter writer(file_);
355
356 const char* kSmall = "small";
357
358 ASSERT_EQ(0, writer.StartEntry("small.txt", 0));
359 ASSERT_EQ(0, writer.WriteBytes(kSmall, strlen(kSmall)));
360 ASSERT_EQ(0, writer.FinishEntry());
361
362 ASSERT_EQ(0, writer.StartEntry("large.txt", 0));
363 std::vector<uint8_t> data;
364 data.resize(1024 * 1024, 0xef);
365 ASSERT_EQ(0, writer.WriteBytes(data.data(), data.size()));
366 ASSERT_EQ(0, writer.FinishEntry());
367
368 off_t before_len = ftello(file_);
369
370 ZipWriter::FileEntry entry;
371 ASSERT_EQ(0, writer.GetLastEntry(&entry));
372 ASSERT_EQ(0, writer.DiscardLastEntry());
373
374 ASSERT_EQ(0, writer.Finish());
375
376 off_t after_len = ftello(file_);
377
378 ASSERT_GT(before_len, after_len);
379 }
380
AssertFileEntryContentsEq(const std::string & expected,ZipArchiveHandle handle,ZipEntry * zip_entry)381 static ::testing::AssertionResult AssertFileEntryContentsEq(const std::string& expected,
382 ZipArchiveHandle handle,
383 ZipEntry* zip_entry) {
384 if (expected.size() != zip_entry->uncompressed_length) {
385 return ::testing::AssertionFailure()
386 << "uncompressed entry size " << zip_entry->uncompressed_length
387 << " does not match expected size " << expected.size();
388 }
389
390 std::string actual;
391 actual.resize(expected.size());
392
393 uint8_t* buffer = reinterpret_cast<uint8_t*>(&*actual.begin());
394 if (ExtractToMemory(handle, zip_entry, buffer, actual.size()) != 0) {
395 return ::testing::AssertionFailure() << "failed to extract entry";
396 }
397
398 if (expected != actual) {
399 return ::testing::AssertionFailure() << "actual zip_entry data '" << actual
400 << "' does not match expected '" << expected << "'";
401 }
402 return ::testing::AssertionSuccess();
403 }
404