blob: e6aec4ad61f448f236d18a0670c338c0f0fa84ba [file] [log] [blame]
Tao Bao0c7839a2016-10-10 15:48:37 -07001/*
2 * Copyright (C) 2016 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
Tao Bao9aa7ab52017-01-05 17:27:19 -080017#include <stdio.h>
Tianjie Xu107a34f2017-06-29 17:04:21 -070018#include <stdlib.h>
Tao Bao89929022016-11-08 20:51:31 -080019#include <sys/stat.h>
20#include <sys/types.h>
21#include <unistd.h>
22
Tianjie Xu107a34f2017-06-29 17:04:21 -070023#include <algorithm>
Tianjie Xuc4447322017-03-06 14:44:59 -080024#include <memory>
Tao Bao0c7839a2016-10-10 15:48:37 -070025#include <string>
Tianjie Xu56ebe622017-03-16 00:48:21 -070026#include <vector>
Tao Bao0c7839a2016-10-10 15:48:37 -070027
Tao Bao51d516e2016-11-03 14:49:01 -070028#include <android-base/file.h>
Tao Bao0c7839a2016-10-10 15:48:37 -070029#include <android-base/properties.h>
Tao Bao9aa7ab52017-01-05 17:27:19 -080030#include <android-base/stringprintf.h>
31#include <android-base/strings.h>
Tao Bao51d516e2016-11-03 14:49:01 -070032#include <android-base/test_utils.h>
Tao Baobedf5fc2016-11-18 12:01:26 -080033#include <bootloader_message/bootloader_message.h>
Tianjie Xu107a34f2017-06-29 17:04:21 -070034#include <brotli/encode.h>
Tianjie Xu56ebe622017-03-16 00:48:21 -070035#include <bsdiff.h>
Tao Bao0c7839a2016-10-10 15:48:37 -070036#include <gtest/gtest.h>
Tao Baoef0eb3b2016-11-14 21:29:52 -080037#include <ziparchive/zip_archive.h>
Tianjie Xu56ebe622017-03-16 00:48:21 -070038#include <ziparchive/zip_writer.h>
Tao Bao0c7839a2016-10-10 15:48:37 -070039
Tao Baoef0eb3b2016-11-14 21:29:52 -080040#include "common/test_constants.h"
Tao Bao0c7839a2016-10-10 15:48:37 -070041#include "edify/expr.h"
Tianjie Xu56ebe622017-03-16 00:48:21 -070042#include "otautil/SysUtil.h"
Tao Bao1fc5bf32017-10-06 07:43:41 -070043#include "otautil/error_code.h"
Tao Bao09e468f2017-09-29 14:39:33 -070044#include "otautil/print_sha1.h"
Tianjie Xu56ebe622017-03-16 00:48:21 -070045#include "updater/blockimg.h"
Tao Bao0c7839a2016-10-10 15:48:37 -070046#include "updater/install.h"
Tao Baoef0eb3b2016-11-14 21:29:52 -080047#include "updater/updater.h"
Tao Bao0c7839a2016-10-10 15:48:37 -070048
49struct selabel_handle *sehandle = nullptr;
50
Tao Baoef0eb3b2016-11-14 21:29:52 -080051static void expect(const char* expected, const char* expr_str, CauseCode cause_code,
52 UpdaterInfo* info = nullptr) {
Tianjie Xuc4447322017-03-06 14:44:59 -080053 std::unique_ptr<Expr> e;
Tao Baoef0eb3b2016-11-14 21:29:52 -080054 int error_count = 0;
55 ASSERT_EQ(0, parse_string(expr_str, &e, &error_count));
56 ASSERT_EQ(0, error_count);
Tao Bao0c7839a2016-10-10 15:48:37 -070057
Tao Baoef0eb3b2016-11-14 21:29:52 -080058 State state(expr_str, info);
Tao Bao0c7839a2016-10-10 15:48:37 -070059
Tao Baoef0eb3b2016-11-14 21:29:52 -080060 std::string result;
61 bool status = Evaluate(&state, e, &result);
Tao Bao0c7839a2016-10-10 15:48:37 -070062
Tao Baoef0eb3b2016-11-14 21:29:52 -080063 if (expected == nullptr) {
64 ASSERT_FALSE(status);
65 } else {
66 ASSERT_TRUE(status);
67 ASSERT_STREQ(expected, result.c_str());
68 }
Tao Bao0c7839a2016-10-10 15:48:37 -070069
Tao Baoef0eb3b2016-11-14 21:29:52 -080070 // Error code is set in updater/updater.cpp only, by parsing State.errmsg.
71 ASSERT_EQ(kNoError, state.error_code);
Tao Bao361342c2016-02-08 11:15:50 -080072
Tao Baoef0eb3b2016-11-14 21:29:52 -080073 // Cause code should always be available.
74 ASSERT_EQ(cause_code, state.cause_code);
Tao Bao0c7839a2016-10-10 15:48:37 -070075}
76
Tianjie Xu56ebe622017-03-16 00:48:21 -070077static std::string get_sha1(const std::string& content) {
78 uint8_t digest[SHA_DIGEST_LENGTH];
79 SHA1(reinterpret_cast<const uint8_t*>(content.c_str()), content.size(), digest);
80 return print_sha1(digest);
81}
82
Tao Bao0c7839a2016-10-10 15:48:37 -070083class UpdaterTest : public ::testing::Test {
Tianjie Xu56ebe622017-03-16 00:48:21 -070084 protected:
85 virtual void SetUp() override {
86 RegisterBuiltins();
87 RegisterInstallFunctions();
88 RegisterBlockImageFunctions();
89 }
Tao Bao0c7839a2016-10-10 15:48:37 -070090};
91
92TEST_F(UpdaterTest, getprop) {
93 expect(android::base::GetProperty("ro.product.device", "").c_str(),
94 "getprop(\"ro.product.device\")",
Tao Bao361342c2016-02-08 11:15:50 -080095 kNoCause);
Tao Bao0c7839a2016-10-10 15:48:37 -070096
97 expect(android::base::GetProperty("ro.build.fingerprint", "").c_str(),
98 "getprop(\"ro.build.fingerprint\")",
Tao Bao361342c2016-02-08 11:15:50 -080099 kNoCause);
Tao Bao0c7839a2016-10-10 15:48:37 -0700100
101 // getprop() accepts only one parameter.
Tao Bao361342c2016-02-08 11:15:50 -0800102 expect(nullptr, "getprop()", kArgsParsingFailure);
103 expect(nullptr, "getprop(\"arg1\", \"arg2\")", kArgsParsingFailure);
104}
105
106TEST_F(UpdaterTest, sha1_check) {
107 // sha1_check(data) returns the SHA-1 of the data.
108 expect("81fe8bfe87576c3ecb22426f8e57847382917acf", "sha1_check(\"abcd\")", kNoCause);
109 expect("da39a3ee5e6b4b0d3255bfef95601890afd80709", "sha1_check(\"\")", kNoCause);
110
111 // sha1_check(data, sha1_hex, [sha1_hex, ...]) returns the matched SHA-1.
112 expect("81fe8bfe87576c3ecb22426f8e57847382917acf",
113 "sha1_check(\"abcd\", \"81fe8bfe87576c3ecb22426f8e57847382917acf\")",
114 kNoCause);
115
116 expect("81fe8bfe87576c3ecb22426f8e57847382917acf",
117 "sha1_check(\"abcd\", \"wrong_sha1\", \"81fe8bfe87576c3ecb22426f8e57847382917acf\")",
118 kNoCause);
119
120 // Or "" if there's no match.
121 expect("",
122 "sha1_check(\"abcd\", \"wrong_sha1\")",
123 kNoCause);
124
125 expect("",
126 "sha1_check(\"abcd\", \"wrong_sha1\", \"wrong_sha2\")",
127 kNoCause);
128
129 // sha1_check() expects at least one argument.
130 expect(nullptr, "sha1_check()", kArgsParsingFailure);
Tao Bao0c7839a2016-10-10 15:48:37 -0700131}
Tao Bao51d516e2016-11-03 14:49:01 -0700132
Tao Baodb56eb02017-03-23 06:34:20 -0700133TEST_F(UpdaterTest, apply_patch_check) {
134 // Zero-argument is not valid.
135 expect(nullptr, "apply_patch_check()", kArgsParsingFailure);
136
137 // File not found.
138 expect("", "apply_patch_check(\"/doesntexist\")", kNoCause);
139
140 std::string src_file = from_testdata_base("old.file");
141 std::string src_content;
142 ASSERT_TRUE(android::base::ReadFileToString(src_file, &src_content));
143 size_t src_size = src_content.size();
144 std::string src_hash = get_sha1(src_content);
145
146 // One-argument with EMMC:file:size:sha1 should pass the check.
147 std::string filename = android::base::Join(
148 std::vector<std::string>{ "EMMC", src_file, std::to_string(src_size), src_hash }, ":");
149 std::string cmd = "apply_patch_check(\"" + filename + "\")";
150 expect("t", cmd.c_str(), kNoCause);
151
152 // EMMC:file:(size-1):sha1:(size+1):sha1 should fail the check.
153 std::string filename_bad = android::base::Join(
154 std::vector<std::string>{ "EMMC", src_file, std::to_string(src_size - 1), src_hash,
155 std::to_string(src_size + 1), src_hash },
156 ":");
157 cmd = "apply_patch_check(\"" + filename_bad + "\")";
158 expect("", cmd.c_str(), kNoCause);
159
160 // EMMC:file:(size-1):sha1:size:sha1:(size+1):sha1 should pass the check.
161 filename_bad =
162 android::base::Join(std::vector<std::string>{ "EMMC", src_file, std::to_string(src_size - 1),
163 src_hash, std::to_string(src_size), src_hash,
164 std::to_string(src_size + 1), src_hash },
165 ":");
166 cmd = "apply_patch_check(\"" + filename_bad + "\")";
167 expect("t", cmd.c_str(), kNoCause);
168
169 // Multiple arguments.
170 cmd = "apply_patch_check(\"" + filename + "\", \"wrong_sha1\", \"wrong_sha2\")";
171 expect("", cmd.c_str(), kNoCause);
172
173 cmd = "apply_patch_check(\"" + filename + "\", \"wrong_sha1\", \"" + src_hash +
174 "\", \"wrong_sha2\")";
175 expect("t", cmd.c_str(), kNoCause);
176
177 cmd = "apply_patch_check(\"" + filename_bad + "\", \"wrong_sha1\", \"" + src_hash +
178 "\", \"wrong_sha2\")";
179 expect("t", cmd.c_str(), kNoCause);
180}
181
Tao Bao51d516e2016-11-03 14:49:01 -0700182TEST_F(UpdaterTest, file_getprop) {
183 // file_getprop() expects two arguments.
184 expect(nullptr, "file_getprop()", kArgsParsingFailure);
185 expect(nullptr, "file_getprop(\"arg1\")", kArgsParsingFailure);
186 expect(nullptr, "file_getprop(\"arg1\", \"arg2\", \"arg3\")", kArgsParsingFailure);
187
188 // File doesn't exist.
189 expect(nullptr, "file_getprop(\"/doesntexist\", \"key1\")", kFileGetPropFailure);
190
191 // Reject too large files (current limit = 65536).
192 TemporaryFile temp_file1;
193 std::string buffer(65540, '\0');
194 ASSERT_TRUE(android::base::WriteStringToFile(buffer, temp_file1.path));
195
196 // Read some keys.
197 TemporaryFile temp_file2;
198 std::string content("ro.product.name=tardis\n"
199 "# comment\n\n\n"
200 "ro.product.model\n"
201 "ro.product.board = magic \n");
202 ASSERT_TRUE(android::base::WriteStringToFile(content, temp_file2.path));
203
204 std::string script1("file_getprop(\"" + std::string(temp_file2.path) +
205 "\", \"ro.product.name\")");
206 expect("tardis", script1.c_str(), kNoCause);
207
208 std::string script2("file_getprop(\"" + std::string(temp_file2.path) +
209 "\", \"ro.product.board\")");
210 expect("magic", script2.c_str(), kNoCause);
211
212 // No match.
213 std::string script3("file_getprop(\"" + std::string(temp_file2.path) +
214 "\", \"ro.product.wrong\")");
215 expect("", script3.c_str(), kNoCause);
216
217 std::string script4("file_getprop(\"" + std::string(temp_file2.path) +
218 "\", \"ro.product.name=\")");
219 expect("", script4.c_str(), kNoCause);
220
221 std::string script5("file_getprop(\"" + std::string(temp_file2.path) +
222 "\", \"ro.product.nam\")");
223 expect("", script5.c_str(), kNoCause);
224
225 std::string script6("file_getprop(\"" + std::string(temp_file2.path) +
226 "\", \"ro.product.model\")");
227 expect("", script6.c_str(), kNoCause);
228}
Tao Bao0831d0b2016-11-03 23:25:04 -0700229
Tao Baoef0eb3b2016-11-14 21:29:52 -0800230// TODO: Test extracting to block device.
231TEST_F(UpdaterTest, package_extract_file) {
232 // package_extract_file expects 1 or 2 arguments.
233 expect(nullptr, "package_extract_file()", kArgsParsingFailure);
234 expect(nullptr, "package_extract_file(\"arg1\", \"arg2\", \"arg3\")", kArgsParsingFailure);
235
236 std::string zip_path = from_testdata_base("ziptest_valid.zip");
237 ZipArchiveHandle handle;
238 ASSERT_EQ(0, OpenArchive(zip_path.c_str(), &handle));
239
240 // Need to set up the ziphandle.
241 UpdaterInfo updater_info;
242 updater_info.package_zip = handle;
243
244 // Two-argument version.
245 TemporaryFile temp_file1;
246 std::string script("package_extract_file(\"a.txt\", \"" + std::string(temp_file1.path) + "\")");
247 expect("t", script.c_str(), kNoCause, &updater_info);
248
249 // Verify the extracted entry.
250 std::string data;
251 ASSERT_TRUE(android::base::ReadFileToString(temp_file1.path, &data));
252 ASSERT_EQ(kATxtContents, data);
253
254 // Now extract another entry to the same location, which should overwrite.
255 script = "package_extract_file(\"b.txt\", \"" + std::string(temp_file1.path) + "\")";
256 expect("t", script.c_str(), kNoCause, &updater_info);
257
258 ASSERT_TRUE(android::base::ReadFileToString(temp_file1.path, &data));
259 ASSERT_EQ(kBTxtContents, data);
260
261 // Missing zip entry. The two-argument version doesn't abort.
262 script = "package_extract_file(\"doesntexist\", \"" + std::string(temp_file1.path) + "\")";
263 expect("", script.c_str(), kNoCause, &updater_info);
264
265 // Extract to /dev/full should fail.
266 script = "package_extract_file(\"a.txt\", \"/dev/full\")";
267 expect("", script.c_str(), kNoCause, &updater_info);
268
269 // One-argument version.
270 script = "sha1_check(package_extract_file(\"a.txt\"))";
271 expect(kATxtSha1Sum.c_str(), script.c_str(), kNoCause, &updater_info);
272
273 script = "sha1_check(package_extract_file(\"b.txt\"))";
274 expect(kBTxtSha1Sum.c_str(), script.c_str(), kNoCause, &updater_info);
275
276 // Missing entry. The one-argument version aborts the evaluation.
277 script = "package_extract_file(\"doesntexist\")";
278 expect(nullptr, script.c_str(), kPackageExtractFileFailure, &updater_info);
279
280 CloseArchive(handle);
281}
Tao Baod0f30882016-11-03 23:52:01 -0700282
283TEST_F(UpdaterTest, write_value) {
284 // write_value() expects two arguments.
285 expect(nullptr, "write_value()", kArgsParsingFailure);
286 expect(nullptr, "write_value(\"arg1\")", kArgsParsingFailure);
287 expect(nullptr, "write_value(\"arg1\", \"arg2\", \"arg3\")", kArgsParsingFailure);
288
289 // filename cannot be empty.
290 expect(nullptr, "write_value(\"value\", \"\")", kArgsParsingFailure);
291
292 // Write some value to file.
293 TemporaryFile temp_file;
294 std::string value = "magicvalue";
295 std::string script("write_value(\"" + value + "\", \"" + std::string(temp_file.path) + "\")");
296 expect("t", script.c_str(), kNoCause);
297
298 // Verify the content.
299 std::string content;
300 ASSERT_TRUE(android::base::ReadFileToString(temp_file.path, &content));
301 ASSERT_EQ(value, content);
302
303 // Allow writing empty string.
304 script = "write_value(\"\", \"" + std::string(temp_file.path) + "\")";
305 expect("t", script.c_str(), kNoCause);
306
307 // Verify the content.
308 ASSERT_TRUE(android::base::ReadFileToString(temp_file.path, &content));
309 ASSERT_EQ("", content);
310
311 // It should fail gracefully when write fails.
312 script = "write_value(\"value\", \"/proc/0/file1\")";
313 expect("", script.c_str(), kNoCause);
314}
Tao Baobedf5fc2016-11-18 12:01:26 -0800315
316TEST_F(UpdaterTest, get_stage) {
317 // get_stage() expects one argument.
318 expect(nullptr, "get_stage()", kArgsParsingFailure);
319 expect(nullptr, "get_stage(\"arg1\", \"arg2\")", kArgsParsingFailure);
320 expect(nullptr, "get_stage(\"arg1\", \"arg2\", \"arg3\")", kArgsParsingFailure);
321
322 // Set up a local file as BCB.
323 TemporaryFile tf;
324 std::string temp_file(tf.path);
325 bootloader_message boot;
326 strlcpy(boot.stage, "2/3", sizeof(boot.stage));
327 std::string err;
328 ASSERT_TRUE(write_bootloader_message_to(boot, temp_file, &err));
329
330 // Can read the stage value.
331 std::string script("get_stage(\"" + temp_file + "\")");
332 expect("2/3", script.c_str(), kNoCause);
333
334 // Bad BCB path.
335 script = "get_stage(\"doesntexist\")";
336 expect("", script.c_str(), kNoCause);
337}
338
339TEST_F(UpdaterTest, set_stage) {
340 // set_stage() expects two arguments.
341 expect(nullptr, "set_stage()", kArgsParsingFailure);
342 expect(nullptr, "set_stage(\"arg1\")", kArgsParsingFailure);
343 expect(nullptr, "set_stage(\"arg1\", \"arg2\", \"arg3\")", kArgsParsingFailure);
344
345 // Set up a local file as BCB.
346 TemporaryFile tf;
347 std::string temp_file(tf.path);
348 bootloader_message boot;
349 strlcpy(boot.command, "command", sizeof(boot.command));
350 strlcpy(boot.stage, "2/3", sizeof(boot.stage));
351 std::string err;
352 ASSERT_TRUE(write_bootloader_message_to(boot, temp_file, &err));
353
354 // Write with set_stage().
355 std::string script("set_stage(\"" + temp_file + "\", \"1/3\")");
356 expect(tf.path, script.c_str(), kNoCause);
357
358 // Verify.
359 bootloader_message boot_verify;
360 ASSERT_TRUE(read_bootloader_message_from(&boot_verify, temp_file, &err));
361
362 // Stage should be updated, with command part untouched.
363 ASSERT_STREQ("1/3", boot_verify.stage);
364 ASSERT_STREQ(boot.command, boot_verify.command);
365
366 // Bad BCB path.
367 script = "set_stage(\"doesntexist\", \"1/3\")";
368 expect("", script.c_str(), kNoCause);
369
370 script = "set_stage(\"/dev/full\", \"1/3\")";
371 expect("", script.c_str(), kNoCause);
372}
Tao Bao9aa7ab52017-01-05 17:27:19 -0800373
374TEST_F(UpdaterTest, set_progress) {
375 // set_progress() expects one argument.
376 expect(nullptr, "set_progress()", kArgsParsingFailure);
377 expect(nullptr, "set_progress(\"arg1\", \"arg2\")", kArgsParsingFailure);
378
379 // Invalid progress argument.
380 expect(nullptr, "set_progress(\"arg1\")", kArgsParsingFailure);
381 expect(nullptr, "set_progress(\"3x+5\")", kArgsParsingFailure);
382 expect(nullptr, "set_progress(\".3.5\")", kArgsParsingFailure);
383
384 TemporaryFile tf;
385 UpdaterInfo updater_info;
Tianjie Xu79327ac2017-09-08 17:09:10 -0700386 updater_info.cmd_pipe = fdopen(tf.release(), "w");
Tao Bao9aa7ab52017-01-05 17:27:19 -0800387 expect(".52", "set_progress(\".52\")", kNoCause, &updater_info);
388 fflush(updater_info.cmd_pipe);
389
390 std::string cmd;
391 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &cmd));
392 ASSERT_EQ(android::base::StringPrintf("set_progress %f\n", .52), cmd);
393 // recovery-updater protocol expects 2 tokens ("set_progress <frac>").
394 ASSERT_EQ(2U, android::base::Split(cmd, " ").size());
Tianjie Xu79327ac2017-09-08 17:09:10 -0700395 ASSERT_EQ(0, fclose(updater_info.cmd_pipe));
Tao Bao9aa7ab52017-01-05 17:27:19 -0800396}
397
398TEST_F(UpdaterTest, show_progress) {
399 // show_progress() expects two arguments.
400 expect(nullptr, "show_progress()", kArgsParsingFailure);
401 expect(nullptr, "show_progress(\"arg1\")", kArgsParsingFailure);
402 expect(nullptr, "show_progress(\"arg1\", \"arg2\", \"arg3\")", kArgsParsingFailure);
403
404 // Invalid progress arguments.
405 expect(nullptr, "show_progress(\"arg1\", \"arg2\")", kArgsParsingFailure);
406 expect(nullptr, "show_progress(\"3x+5\", \"10\")", kArgsParsingFailure);
407 expect(nullptr, "show_progress(\".3\", \"5a\")", kArgsParsingFailure);
408
409 TemporaryFile tf;
410 UpdaterInfo updater_info;
Tianjie Xu79327ac2017-09-08 17:09:10 -0700411 updater_info.cmd_pipe = fdopen(tf.release(), "w");
Tao Bao9aa7ab52017-01-05 17:27:19 -0800412 expect(".52", "show_progress(\".52\", \"10\")", kNoCause, &updater_info);
413 fflush(updater_info.cmd_pipe);
414
415 std::string cmd;
416 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &cmd));
417 ASSERT_EQ(android::base::StringPrintf("progress %f %d\n", .52, 10), cmd);
418 // recovery-updater protocol expects 3 tokens ("progress <frac> <secs>").
419 ASSERT_EQ(3U, android::base::Split(cmd, " ").size());
Tianjie Xu79327ac2017-09-08 17:09:10 -0700420 ASSERT_EQ(0, fclose(updater_info.cmd_pipe));
Tao Bao9aa7ab52017-01-05 17:27:19 -0800421}
Tianjie Xu56ebe622017-03-16 00:48:21 -0700422
423TEST_F(UpdaterTest, block_image_update) {
424 // Create a zip file with new_data and patch_data.
425 TemporaryFile zip_file;
Tianjie Xu79327ac2017-09-08 17:09:10 -0700426 FILE* zip_file_ptr = fdopen(zip_file.release(), "wb");
Tianjie Xu56ebe622017-03-16 00:48:21 -0700427 ZipWriter zip_writer(zip_file_ptr);
428
429 // Add a dummy new data.
430 ASSERT_EQ(0, zip_writer.StartEntry("new_data", 0));
431 ASSERT_EQ(0, zip_writer.FinishEntry());
432
433 // Generate and add the patch data.
434 std::string src_content = std::string(4096, 'a') + std::string(4096, 'c');
435 std::string tgt_content = std::string(4096, 'b') + std::string(4096, 'd');
436 TemporaryFile patch_file;
437 ASSERT_EQ(0, bsdiff::bsdiff(reinterpret_cast<const uint8_t*>(src_content.data()),
438 src_content.size(), reinterpret_cast<const uint8_t*>(tgt_content.data()),
439 tgt_content.size(), patch_file.path, nullptr));
440 std::string patch_content;
441 ASSERT_TRUE(android::base::ReadFileToString(patch_file.path, &patch_content));
442 ASSERT_EQ(0, zip_writer.StartEntry("patch_data", 0));
443 ASSERT_EQ(0, zip_writer.WriteBytes(patch_content.data(), patch_content.size()));
444 ASSERT_EQ(0, zip_writer.FinishEntry());
445
446 // Add two transfer lists. The first one contains a bsdiff; and we expect the update to succeed.
447 std::string src_hash = get_sha1(src_content);
448 std::string tgt_hash = get_sha1(tgt_content);
449 std::vector<std::string> transfer_list = {
450 "4",
451 "2",
452 "0",
453 "2",
454 "stash " + src_hash + " 2,0,2",
455 android::base::StringPrintf("bsdiff 0 %zu %s %s 2,0,2 2 - %s:2,0,2", patch_content.size(),
456 src_hash.c_str(), tgt_hash.c_str(), src_hash.c_str()),
457 "free " + src_hash,
458 };
459 ASSERT_EQ(0, zip_writer.StartEntry("transfer_list", 0));
460 std::string commands = android::base::Join(transfer_list, '\n');
461 ASSERT_EQ(0, zip_writer.WriteBytes(commands.data(), commands.size()));
462 ASSERT_EQ(0, zip_writer.FinishEntry());
463
464 // Stash and free some blocks, then fail the 2nd update intentionally.
465 std::vector<std::string> fail_transfer_list = {
466 "4",
467 "2",
468 "0",
469 "2",
470 "stash " + tgt_hash + " 2,0,2",
471 "free " + tgt_hash,
472 "fail",
473 };
474 ASSERT_EQ(0, zip_writer.StartEntry("fail_transfer_list", 0));
475 std::string fail_commands = android::base::Join(fail_transfer_list, '\n');
476 ASSERT_EQ(0, zip_writer.WriteBytes(fail_commands.data(), fail_commands.size()));
477 ASSERT_EQ(0, zip_writer.FinishEntry());
478 ASSERT_EQ(0, zip_writer.Finish());
479 ASSERT_EQ(0, fclose(zip_file_ptr));
480
481 MemMapping map;
Tao Baob656a152017-04-18 23:54:29 -0700482 ASSERT_TRUE(map.MapFile(zip_file.path));
Tianjie Xu56ebe622017-03-16 00:48:21 -0700483 ZipArchiveHandle handle;
484 ASSERT_EQ(0, OpenArchiveFromMemory(map.addr, map.length, zip_file.path, &handle));
485
486 // Set up the handler, command_pipe, patch offset & length.
487 UpdaterInfo updater_info;
488 updater_info.package_zip = handle;
489 TemporaryFile temp_pipe;
Tianjie Xu79327ac2017-09-08 17:09:10 -0700490 updater_info.cmd_pipe = fdopen(temp_pipe.release(), "wbe");
Tianjie Xu56ebe622017-03-16 00:48:21 -0700491 updater_info.package_zip_addr = map.addr;
492 updater_info.package_zip_len = map.length;
493
494 // Execute the commands in the 1st transfer list.
495 TemporaryFile update_file;
496 ASSERT_TRUE(android::base::WriteStringToFile(src_content, update_file.path));
497 std::string script = "block_image_update(\"" + std::string(update_file.path) +
498 R"(", package_extract_file("transfer_list"), "new_data", "patch_data"))";
499 expect("t", script.c_str(), kNoCause, &updater_info);
500 // The update_file should be patched correctly.
501 std::string updated_content;
502 ASSERT_TRUE(android::base::ReadFileToString(update_file.path, &updated_content));
503 ASSERT_EQ(tgt_hash, get_sha1(updated_content));
504
505 // Expect the 2nd update to fail, but expect the stashed blocks to be freed.
506 script = "block_image_update(\"" + std::string(update_file.path) +
507 R"(", package_extract_file("fail_transfer_list"), "new_data", "patch_data"))";
508 expect("", script.c_str(), kNoCause, &updater_info);
509 // Updater generates the stash name based on the input file name.
510 std::string name_digest = get_sha1(update_file.path);
511 std::string stash_base = "/cache/recovery/" + name_digest;
512 ASSERT_EQ(0, access(stash_base.c_str(), F_OK));
513 ASSERT_EQ(-1, access((stash_base + tgt_hash).c_str(), F_OK));
514 ASSERT_EQ(0, rmdir(stash_base.c_str()));
515
516 ASSERT_EQ(0, fclose(updater_info.cmd_pipe));
517 CloseArchive(handle);
518}
Tianjie Xu3a8d98d2017-04-03 20:01:17 -0700519
520TEST_F(UpdaterTest, new_data_short_write) {
521 // Create a zip file with new_data.
522 TemporaryFile zip_file;
Tianjie Xu79327ac2017-09-08 17:09:10 -0700523 FILE* zip_file_ptr = fdopen(zip_file.release(), "wb");
Tianjie Xu3a8d98d2017-04-03 20:01:17 -0700524 ZipWriter zip_writer(zip_file_ptr);
525
526 // Add the empty new data.
527 ASSERT_EQ(0, zip_writer.StartEntry("empty_new_data", 0));
528 ASSERT_EQ(0, zip_writer.FinishEntry());
529 // Add the short written new data.
530 ASSERT_EQ(0, zip_writer.StartEntry("short_new_data", 0));
531 std::string new_data_short = std::string(10, 'a');
532 ASSERT_EQ(0, zip_writer.WriteBytes(new_data_short.data(), new_data_short.size()));
533 ASSERT_EQ(0, zip_writer.FinishEntry());
534 // Add the data of exactly one block.
535 ASSERT_EQ(0, zip_writer.StartEntry("exact_new_data", 0));
536 std::string new_data_exact = std::string(4096, 'a');
537 ASSERT_EQ(0, zip_writer.WriteBytes(new_data_exact.data(), new_data_exact.size()));
538 ASSERT_EQ(0, zip_writer.FinishEntry());
539 // Add a dummy patch data.
540 ASSERT_EQ(0, zip_writer.StartEntry("patch_data", 0));
541 ASSERT_EQ(0, zip_writer.FinishEntry());
542
543 std::vector<std::string> transfer_list = {
544 "4",
545 "1",
546 "0",
547 "0",
548 "new 2,0,1",
549 };
550 ASSERT_EQ(0, zip_writer.StartEntry("transfer_list", 0));
551 std::string commands = android::base::Join(transfer_list, '\n');
552 ASSERT_EQ(0, zip_writer.WriteBytes(commands.data(), commands.size()));
553 ASSERT_EQ(0, zip_writer.FinishEntry());
554 ASSERT_EQ(0, zip_writer.Finish());
555 ASSERT_EQ(0, fclose(zip_file_ptr));
556
557 MemMapping map;
Tao Baob656a152017-04-18 23:54:29 -0700558 ASSERT_TRUE(map.MapFile(zip_file.path));
Tianjie Xu3a8d98d2017-04-03 20:01:17 -0700559 ZipArchiveHandle handle;
560 ASSERT_EQ(0, OpenArchiveFromMemory(map.addr, map.length, zip_file.path, &handle));
561
562 // Set up the handler, command_pipe, patch offset & length.
563 UpdaterInfo updater_info;
564 updater_info.package_zip = handle;
565 TemporaryFile temp_pipe;
Tianjie Xu79327ac2017-09-08 17:09:10 -0700566 updater_info.cmd_pipe = fdopen(temp_pipe.release(), "wbe");
Tianjie Xu3a8d98d2017-04-03 20:01:17 -0700567 updater_info.package_zip_addr = map.addr;
568 updater_info.package_zip_len = map.length;
569
570 // Updater should report the failure gracefully rather than stuck in deadlock.
571 TemporaryFile update_file;
572 std::string script_empty_data = "block_image_update(\"" + std::string(update_file.path) +
573 R"(", package_extract_file("transfer_list"), "empty_new_data", "patch_data"))";
574 expect("", script_empty_data.c_str(), kNoCause, &updater_info);
575
576 std::string script_short_data = "block_image_update(\"" + std::string(update_file.path) +
577 R"(", package_extract_file("transfer_list"), "short_new_data", "patch_data"))";
578 expect("", script_short_data.c_str(), kNoCause, &updater_info);
579
580 // Expect to write 1 block of new data successfully.
581 std::string script_exact_data = "block_image_update(\"" + std::string(update_file.path) +
582 R"(", package_extract_file("transfer_list"), "exact_new_data", "patch_data"))";
583 expect("t", script_exact_data.c_str(), kNoCause, &updater_info);
Tianjie Xu79327ac2017-09-08 17:09:10 -0700584
585 ASSERT_EQ(0, fclose(updater_info.cmd_pipe));
Tianjie Xu107a34f2017-06-29 17:04:21 -0700586 CloseArchive(handle);
587}
588
589TEST_F(UpdaterTest, brotli_new_data) {
590 // Create a zip file with new_data.
591 TemporaryFile zip_file;
Tianjie Xu79327ac2017-09-08 17:09:10 -0700592 FILE* zip_file_ptr = fdopen(zip_file.release(), "wb");
Tianjie Xu107a34f2017-06-29 17:04:21 -0700593 ZipWriter zip_writer(zip_file_ptr);
594
595 // Add a brotli compressed new data entry.
596 ASSERT_EQ(0, zip_writer.StartEntry("new.dat.br", 0));
597
598 auto generator = []() { return rand() % 128; };
Tianjie Xu6ed175d2017-07-18 11:29:40 -0700599 // Generate 100 blocks of random data.
Tianjie Xu107a34f2017-06-29 17:04:21 -0700600 std::string brotli_new_data;
Tianjie Xu6ed175d2017-07-18 11:29:40 -0700601 brotli_new_data.reserve(4096 * 100);
602 generate_n(back_inserter(brotli_new_data), 4096 * 100, generator);
Tianjie Xu107a34f2017-06-29 17:04:21 -0700603
604 size_t encoded_size = BrotliEncoderMaxCompressedSize(brotli_new_data.size());
605 std::vector<uint8_t> encoded_data(encoded_size);
606 ASSERT_TRUE(BrotliEncoderCompress(
607 BROTLI_DEFAULT_QUALITY, BROTLI_DEFAULT_WINDOW, BROTLI_DEFAULT_MODE, brotli_new_data.size(),
608 reinterpret_cast<const uint8_t*>(brotli_new_data.data()), &encoded_size, encoded_data.data()));
609
610 ASSERT_EQ(0, zip_writer.WriteBytes(encoded_data.data(), encoded_size));
611 ASSERT_EQ(0, zip_writer.FinishEntry());
612 // Add a dummy patch data.
613 ASSERT_EQ(0, zip_writer.StartEntry("patch_data", 0));
614 ASSERT_EQ(0, zip_writer.FinishEntry());
615
Tianjie Xu6ed175d2017-07-18 11:29:40 -0700616 // Write a few small chunks of new data, then a large chunk, and finally a few small chunks.
617 // This helps us to catch potential short writes.
Tianjie Xu107a34f2017-06-29 17:04:21 -0700618 std::vector<std::string> transfer_list = {
Tianjie Xu6ed175d2017-07-18 11:29:40 -0700619 "4",
620 "100",
621 "0",
622 "0",
623 "new 2,0,1",
624 "new 2,1,2",
625 "new 4,2,50,50,97",
626 "new 2,97,98",
627 "new 2,98,99",
628 "new 2,99,100",
Tianjie Xu107a34f2017-06-29 17:04:21 -0700629 };
630 ASSERT_EQ(0, zip_writer.StartEntry("transfer_list", 0));
631 std::string commands = android::base::Join(transfer_list, '\n');
632 ASSERT_EQ(0, zip_writer.WriteBytes(commands.data(), commands.size()));
633 ASSERT_EQ(0, zip_writer.FinishEntry());
634 ASSERT_EQ(0, zip_writer.Finish());
635 ASSERT_EQ(0, fclose(zip_file_ptr));
636
637 MemMapping map;
638 ASSERT_TRUE(map.MapFile(zip_file.path));
639 ZipArchiveHandle handle;
640 ASSERT_EQ(0, OpenArchiveFromMemory(map.addr, map.length, zip_file.path, &handle));
641
642 // Set up the handler, command_pipe, patch offset & length.
643 UpdaterInfo updater_info;
644 updater_info.package_zip = handle;
645 TemporaryFile temp_pipe;
Tianjie Xu79327ac2017-09-08 17:09:10 -0700646 updater_info.cmd_pipe = fdopen(temp_pipe.release(), "wb");
Tianjie Xu107a34f2017-06-29 17:04:21 -0700647 updater_info.package_zip_addr = map.addr;
648 updater_info.package_zip_len = map.length;
649
650 // Check if we can decompress the new data correctly.
651 TemporaryFile update_file;
652 std::string script_new_data =
653 "block_image_update(\"" + std::string(update_file.path) +
654 R"(", package_extract_file("transfer_list"), "new.dat.br", "patch_data"))";
655 expect("t", script_new_data.c_str(), kNoCause, &updater_info);
656
657 std::string updated_content;
658 ASSERT_TRUE(android::base::ReadFileToString(update_file.path, &updated_content));
659 ASSERT_EQ(brotli_new_data, updated_content);
Tianjie Xu79327ac2017-09-08 17:09:10 -0700660
661 ASSERT_EQ(0, fclose(updater_info.cmd_pipe));
Tianjie Xu107a34f2017-06-29 17:04:21 -0700662 CloseArchive(handle);
Tianjie Xu3a8d98d2017-04-03 20:01:17 -0700663}