blob: db7530be983dcef851fc428bf7d50d6d5047a388 [file] [log] [blame]
Doug Zongker512536a2010-02-17 16:11:44 -08001/*
2 * Copyright (C) 2008 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 Bao8fce75a2016-11-10 12:33:41 -080017#include "applypatch/applypatch.h"
18
Doug Zongker512536a2010-02-17 16:11:44 -080019#include <errno.h>
Tao Baoba9a42a2015-06-23 23:23:33 -070020#include <fcntl.h>
Doug Zongker512536a2010-02-17 16:11:44 -080021#include <libgen.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25#include <sys/stat.h>
26#include <sys/statfs.h>
27#include <sys/types.h>
Doug Zongker512536a2010-02-17 16:11:44 -080028#include <unistd.h>
29
Tao Baoc0e1c462017-02-01 10:20:10 -080030#include <functional>
Yabin Cuid483c202016-02-03 17:08:52 -080031#include <memory>
32#include <string>
Tao Bao8fce75a2016-11-10 12:33:41 -080033#include <utility>
34#include <vector>
Yabin Cuid483c202016-02-03 17:08:52 -080035
Tao Bao40e144d2017-03-15 01:10:58 -070036#include <android-base/logging.h>
Tao Bao8fce75a2016-11-10 12:33:41 -080037#include <android-base/parseint.h>
Elliott Hughes4b166f02015-12-04 15:30:20 -080038#include <android-base/strings.h>
Tao Bao8fce75a2016-11-10 12:33:41 -080039#include <openssl/sha.h>
Tao Baoaca8e892015-07-17 11:47:44 -070040
Doug Zongkerc4351c72010-02-22 14:46:32 -080041#include "edify/expr.h"
Tao Baod33b2f82017-09-28 21:29:11 -070042#include "otafault/ota_io.h"
Tianjie Xu3bbb20f2018-02-27 15:56:11 -080043#include "otautil/cache_location.h"
Tao Bao09e468f2017-09-29 14:39:33 -070044#include "otautil/print_sha1.h"
Doug Zongker512536a2010-02-17 16:11:44 -080045
Tao Bao8fce75a2016-11-10 12:33:41 -080046static int LoadPartitionContents(const std::string& filename, FileContents* file);
Tao Baoc0e1c462017-02-01 10:20:10 -080047static size_t FileSink(const unsigned char* data, size_t len, int fd);
Tao Bao40e144d2017-03-15 01:10:58 -070048static int GenerateTarget(const FileContents& source_file, const std::unique_ptr<Value>& patch,
49 const std::string& target_filename,
50 const uint8_t target_sha1[SHA_DIGEST_LENGTH], const Value* bonus_data);
Doug Zongker512536a2010-02-17 16:11:44 -080051
Tao Bao8fce75a2016-11-10 12:33:41 -080052// Read a file into memory; store the file contents and associated metadata in *file.
Hristo Bojinovdb314d62010-08-02 10:29:49 -070053// Return 0 on success.
Doug Zongkera1bc1482014-02-13 15:18:19 -080054int LoadFileContents(const char* filename, FileContents* file) {
Tao Bao8fce75a2016-11-10 12:33:41 -080055 // A special 'filename' beginning with "EMMC:" means to load the contents of a partition.
56 if (strncmp(filename, "EMMC:", 5) == 0) {
57 return LoadPartitionContents(filename, file);
58 }
Doug Zongker512536a2010-02-17 16:11:44 -080059
Tao Bao47e5a8d2017-12-01 10:53:34 -080060 struct stat sb;
61 if (stat(filename, &sb) == -1) {
Tao Bao8fce75a2016-11-10 12:33:41 -080062 printf("failed to stat \"%s\": %s\n", filename, strerror(errno));
63 return -1;
64 }
Doug Zongkerc4351c72010-02-22 14:46:32 -080065
Tao Bao47e5a8d2017-12-01 10:53:34 -080066 std::vector<unsigned char> data(sb.st_size);
Tao Bao358c2ec2016-11-28 11:48:43 -080067 unique_file f(ota_fopen(filename, "rb"));
Tao Bao8fce75a2016-11-10 12:33:41 -080068 if (!f) {
69 printf("failed to open \"%s\": %s\n", filename, strerror(errno));
70 return -1;
71 }
Doug Zongkerc4351c72010-02-22 14:46:32 -080072
Tao Bao8fce75a2016-11-10 12:33:41 -080073 size_t bytes_read = ota_fread(data.data(), 1, data.size(), f.get());
74 if (bytes_read != data.size()) {
75 printf("short read of \"%s\" (%zu bytes of %zu)\n", filename, bytes_read, data.size());
76 return -1;
77 }
78 file->data = std::move(data);
79 SHA1(file->data.data(), file->data.size(), file->sha1);
80 return 0;
Doug Zongker512536a2010-02-17 16:11:44 -080081}
82
Elliott Hughes63a31922016-06-09 17:41:22 -070083// Load the contents of an EMMC partition into the provided
Doug Zongker512536a2010-02-17 16:11:44 -080084// FileContents. filename should be a string of the form
Elliott Hughes63a31922016-06-09 17:41:22 -070085// "EMMC:<partition_device>:...". The smallest size_n bytes for
Doug Zongkerf291d852010-07-07 13:55:25 -070086// which that prefix of the partition contents has the corresponding
87// sha1 hash will be loaded. It is acceptable for a size value to be
88// repeated with different sha1s. Will return 0 on success.
Doug Zongker512536a2010-02-17 16:11:44 -080089//
90// This complexity is needed because if an OTA installation is
91// interrupted, the partition might contain either the source or the
92// target data, which might be of different lengths. We need to know
Doug Zongkerf291d852010-07-07 13:55:25 -070093// the length in order to read from a partition (there is no
94// "end-of-file" marker), so the caller must specify the possible
95// lengths and the hash of the data, and we'll do the load expecting
96// to find one of those hashes.
Tao Bao8fce75a2016-11-10 12:33:41 -080097static int LoadPartitionContents(const std::string& filename, FileContents* file) {
98 std::vector<std::string> pieces = android::base::Split(filename, ":");
99 if (pieces.size() < 4 || pieces.size() % 2 != 0 || pieces[0] != "EMMC") {
100 printf("LoadPartitionContents called with bad filename \"%s\"\n", filename.c_str());
101 return -1;
102 }
103
104 size_t pair_count = (pieces.size() - 2) / 2; // # of (size, sha1) pairs in filename
105 std::vector<std::pair<size_t, std::string>> pairs;
106 for (size_t i = 0; i < pair_count; ++i) {
107 size_t size;
108 if (!android::base::ParseUint(pieces[i * 2 + 2], &size) || size == 0) {
109 printf("LoadPartitionContents called with bad size \"%s\"\n", pieces[i * 2 + 2].c_str());
110 return -1;
111 }
112 pairs.push_back({ size, pieces[i * 2 + 3] });
113 }
114
115 // Sort the pairs array so that they are in order of increasing size.
116 std::sort(pairs.begin(), pairs.end());
117
118 const char* partition = pieces[1].c_str();
Tao Bao358c2ec2016-11-28 11:48:43 -0800119 unique_file dev(ota_fopen(partition, "rb"));
Tao Bao8fce75a2016-11-10 12:33:41 -0800120 if (!dev) {
121 printf("failed to open emmc partition \"%s\": %s\n", partition, strerror(errno));
122 return -1;
123 }
124
125 SHA_CTX sha_ctx;
126 SHA1_Init(&sha_ctx);
127
128 // Allocate enough memory to hold the largest size.
129 std::vector<unsigned char> buffer(pairs[pair_count - 1].first);
130 unsigned char* buffer_ptr = buffer.data();
131 size_t buffer_size = 0; // # bytes read so far
132 bool found = false;
133
134 for (const auto& pair : pairs) {
135 size_t current_size = pair.first;
136 const std::string& current_sha1 = pair.second;
137
138 // Read enough additional bytes to get us up to the next size. (Again,
139 // we're trying the possibilities in order of increasing size).
140 size_t next = current_size - buffer_size;
141 if (next > 0) {
142 size_t read = ota_fread(buffer_ptr, 1, next, dev.get());
143 if (next != read) {
144 printf("short read (%zu bytes of %zu) for partition \"%s\"\n", read, next, partition);
Tao Baoaca8e892015-07-17 11:47:44 -0700145 return -1;
Tao Bao8fce75a2016-11-10 12:33:41 -0800146 }
147 SHA1_Update(&sha_ctx, buffer_ptr, read);
148 buffer_size += read;
149 buffer_ptr += read;
Tao Baoaca8e892015-07-17 11:47:44 -0700150 }
Doug Zongkerf291d852010-07-07 13:55:25 -0700151
Tao Bao8fce75a2016-11-10 12:33:41 -0800152 // Duplicate the SHA context and finalize the duplicate so we can
153 // check it against this pair's expected hash.
154 SHA_CTX temp_ctx;
155 memcpy(&temp_ctx, &sha_ctx, sizeof(SHA_CTX));
156 uint8_t sha_so_far[SHA_DIGEST_LENGTH];
157 SHA1_Final(sha_so_far, &temp_ctx);
Doug Zongker512536a2010-02-17 16:11:44 -0800158
Sen Jiangc48cb5e2016-02-04 16:23:21 +0800159 uint8_t parsed_sha[SHA_DIGEST_LENGTH];
Tao Bao8fce75a2016-11-10 12:33:41 -0800160 if (ParseSha1(current_sha1.c_str(), parsed_sha) != 0) {
161 printf("failed to parse SHA-1 %s in %s\n", current_sha1.c_str(), filename.c_str());
162 return -1;
Doug Zongkerc4351c72010-02-22 14:46:32 -0800163 }
164
Tao Bao8fce75a2016-11-10 12:33:41 -0800165 if (memcmp(sha_so_far, parsed_sha, SHA_DIGEST_LENGTH) == 0) {
166 // We have a match. Stop reading the partition; we'll return the data we've read so far.
167 printf("partition read matched size %zu SHA-1 %s\n", current_size, current_sha1.c_str());
168 found = true;
169 break;
Doug Zongker512536a2010-02-17 16:11:44 -0800170 }
Tao Bao8fce75a2016-11-10 12:33:41 -0800171 }
Doug Zongker512536a2010-02-17 16:11:44 -0800172
Tao Bao8fce75a2016-11-10 12:33:41 -0800173 if (!found) {
174 // Ran off the end of the list of (size, sha1) pairs without finding a match.
175 printf("contents of partition \"%s\" didn't match %s\n", partition, filename.c_str());
176 return -1;
177 }
Doug Zongker512536a2010-02-17 16:11:44 -0800178
Tao Bao8fce75a2016-11-10 12:33:41 -0800179 SHA1_Final(file->sha1, &sha_ctx);
Doug Zongker512536a2010-02-17 16:11:44 -0800180
Tao Bao8fce75a2016-11-10 12:33:41 -0800181 buffer.resize(buffer_size);
182 file->data = std::move(buffer);
Tao Bao8fce75a2016-11-10 12:33:41 -0800183
184 return 0;
Doug Zongker512536a2010-02-17 16:11:44 -0800185}
186
Doug Zongker512536a2010-02-17 16:11:44 -0800187// Save the contents of the given FileContents object under the given
188// filename. Return 0 on success.
Doug Zongker1c43c972012-02-28 11:07:09 -0800189int SaveFileContents(const char* filename, const FileContents* file) {
Tao Bao6e02ea92016-11-17 11:24:07 -0800190 unique_fd fd(ota_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_SYNC, S_IRUSR | S_IWUSR));
191 if (fd == -1) {
192 printf("failed to open \"%s\" for write: %s\n", filename, strerror(errno));
193 return -1;
194 }
Doug Zongker512536a2010-02-17 16:11:44 -0800195
Tao Baoc0e1c462017-02-01 10:20:10 -0800196 size_t bytes_written = FileSink(file->data.data(), file->data.size(), fd);
Tao Baof7eb7602017-03-27 15:12:48 -0700197 if (bytes_written != file->data.size()) {
Tao Bao6e02ea92016-11-17 11:24:07 -0800198 printf("short write of \"%s\" (%zd bytes of %zu): %s\n", filename, bytes_written,
199 file->data.size(), strerror(errno));
200 return -1;
201 }
202 if (ota_fsync(fd) != 0) {
203 printf("fsync of \"%s\" failed: %s\n", filename, strerror(errno));
204 return -1;
205 }
Tao Bao3dc14cb2016-11-22 11:37:13 -0800206 if (ota_close(fd) != 0) {
Tao Bao6e02ea92016-11-17 11:24:07 -0800207 printf("close of \"%s\" failed: %s\n", filename, strerror(errno));
208 return -1;
209 }
Doug Zongker512536a2010-02-17 16:11:44 -0800210
Tao Bao6e02ea92016-11-17 11:24:07 -0800211 return 0;
Doug Zongker512536a2010-02-17 16:11:44 -0800212}
213
Doug Zongkerf291d852010-07-07 13:55:25 -0700214// Write a memory buffer to 'target' partition, a string of the form
Elliott Hughes63a31922016-06-09 17:41:22 -0700215// "EMMC:<partition_device>[:...]". The target name
Tao Bao1ce7a2a2015-07-24 15:29:12 -0700216// might contain multiple colons, but WriteToPartition() only uses the first
217// two and ignores the rest. Return 0 on success.
Tao Bao6e02ea92016-11-17 11:24:07 -0800218int WriteToPartition(const unsigned char* data, size_t len, const std::string& target) {
219 std::vector<std::string> pieces = android::base::Split(target, ":");
Tao Bao8fce75a2016-11-10 12:33:41 -0800220 if (pieces.size() < 2 || pieces[0] != "EMMC") {
Tao Bao6e02ea92016-11-17 11:24:07 -0800221 printf("WriteToPartition called with bad target (%s)\n", target.c_str());
Tao Bao8fce75a2016-11-10 12:33:41 -0800222 return -1;
223 }
224
225 const char* partition = pieces[1].c_str();
Tao Bao6e02ea92016-11-17 11:24:07 -0800226 unique_fd fd(ota_open(partition, O_RDWR));
227 if (fd == -1) {
Tao Bao8fce75a2016-11-10 12:33:41 -0800228 printf("failed to open %s: %s\n", partition, strerror(errno));
229 return -1;
230 }
231
Tao Bao6e02ea92016-11-17 11:24:07 -0800232 size_t start = 0;
233 bool success = false;
Tao Bao8fce75a2016-11-10 12:33:41 -0800234 for (size_t attempt = 0; attempt < 2; ++attempt) {
235 if (TEMP_FAILURE_RETRY(lseek(fd, start, SEEK_SET)) == -1) {
236 printf("failed seek on %s: %s\n", partition, strerror(errno));
237 return -1;
238 }
239 while (start < len) {
240 size_t to_write = len - start;
241 if (to_write > 1 << 20) to_write = 1 << 20;
242
243 ssize_t written = TEMP_FAILURE_RETRY(ota_write(fd, data + start, to_write));
244 if (written == -1) {
245 printf("failed write writing to %s: %s\n", partition, strerror(errno));
Tao Baoaca8e892015-07-17 11:47:44 -0700246 return -1;
Tao Bao8fce75a2016-11-10 12:33:41 -0800247 }
248 start += written;
Tao Baoaca8e892015-07-17 11:47:44 -0700249 }
Doug Zongkerf291d852010-07-07 13:55:25 -0700250
Tao Bao8fce75a2016-11-10 12:33:41 -0800251 if (ota_fsync(fd) != 0) {
Tao Bao6e02ea92016-11-17 11:24:07 -0800252 printf("failed to sync to %s: %s\n", partition, strerror(errno));
Tao Bao8fce75a2016-11-10 12:33:41 -0800253 return -1;
Doug Zongkerf291d852010-07-07 13:55:25 -0700254 }
Tao Bao3dc14cb2016-11-22 11:37:13 -0800255 if (ota_close(fd) != 0) {
Tao Bao6e02ea92016-11-17 11:24:07 -0800256 printf("failed to close %s: %s\n", partition, strerror(errno));
Tao Bao8fce75a2016-11-10 12:33:41 -0800257 return -1;
Elliott Hughes63a31922016-06-09 17:41:22 -0700258 }
Tao Bao8fce75a2016-11-10 12:33:41 -0800259
Tao Bao6e02ea92016-11-17 11:24:07 -0800260 fd.reset(ota_open(partition, O_RDONLY));
261 if (fd == -1) {
262 printf("failed to reopen %s for verify: %s\n", partition, strerror(errno));
Tao Bao8fce75a2016-11-10 12:33:41 -0800263 return -1;
264 }
265
266 // Drop caches so our subsequent verification read won't just be reading the cache.
Elliott Hughes63a31922016-06-09 17:41:22 -0700267 sync();
Tao Bao6e02ea92016-11-17 11:24:07 -0800268 unique_fd dc(ota_open("/proc/sys/vm/drop_caches", O_WRONLY));
Tao Bao8fce75a2016-11-10 12:33:41 -0800269 if (TEMP_FAILURE_RETRY(ota_write(dc, "3\n", 2)) == -1) {
270 printf("write to /proc/sys/vm/drop_caches failed: %s\n", strerror(errno));
271 } else {
272 printf(" caches dropped\n");
273 }
Tao Bao3dc14cb2016-11-22 11:37:13 -0800274 ota_close(dc);
Tao Bao8fce75a2016-11-10 12:33:41 -0800275 sleep(1);
Elliott Hughes63a31922016-06-09 17:41:22 -0700276
Tao Bao6e02ea92016-11-17 11:24:07 -0800277 // Verify.
Tao Bao8fce75a2016-11-10 12:33:41 -0800278 if (TEMP_FAILURE_RETRY(lseek(fd, 0, SEEK_SET)) == -1) {
279 printf("failed to seek back to beginning of %s: %s\n", partition, strerror(errno));
280 return -1;
281 }
282
283 unsigned char buffer[4096];
284 start = len;
285 for (size_t p = 0; p < len; p += sizeof(buffer)) {
286 size_t to_read = len - p;
287 if (to_read > sizeof(buffer)) {
288 to_read = sizeof(buffer);
289 }
290
291 size_t so_far = 0;
292 while (so_far < to_read) {
293 ssize_t read_count = TEMP_FAILURE_RETRY(ota_read(fd, buffer + so_far, to_read - so_far));
294 if (read_count == -1) {
295 printf("verify read error %s at %zu: %s\n", partition, p, strerror(errno));
296 return -1;
297 } else if (read_count == 0) {
298 printf("verify read reached unexpected EOF, %s at %zu\n", partition, p);
299 return -1;
300 }
301 if (static_cast<size_t>(read_count) < to_read) {
Tao Bao6e02ea92016-11-17 11:24:07 -0800302 printf("short verify read %s at %zu: %zd %zu\n", partition, p, read_count, to_read);
Tao Bao8fce75a2016-11-10 12:33:41 -0800303 }
304 so_far += read_count;
305 }
306
307 if (memcmp(buffer, data + p, to_read) != 0) {
308 printf("verification failed starting at %zu\n", p);
309 start = p;
310 break;
311 }
312 }
313
314 if (start == len) {
315 printf("verification read succeeded (attempt %zu)\n", attempt + 1);
316 success = true;
317 break;
318 }
katao9a6f5202016-12-19 11:22:30 +0800319
320 if (ota_close(fd) != 0) {
321 printf("failed to close %s: %s\n", partition, strerror(errno));
322 return -1;
323 }
324
325 fd.reset(ota_open(partition, O_RDWR));
326 if (fd == -1) {
327 printf("failed to reopen %s for retry write && verify: %s\n", partition, strerror(errno));
328 return -1;
329 }
Tao Bao8fce75a2016-11-10 12:33:41 -0800330 }
331
332 if (!success) {
333 printf("failed to verify after all attempts\n");
334 return -1;
335 }
336
Tao Bao3dc14cb2016-11-22 11:37:13 -0800337 if (ota_close(fd) == -1) {
Tao Bao6e02ea92016-11-17 11:24:07 -0800338 printf("error closing %s: %s\n", partition, strerror(errno));
Tao Bao8fce75a2016-11-10 12:33:41 -0800339 return -1;
340 }
341 sync();
342
343 return 0;
Doug Zongker512536a2010-02-17 16:11:44 -0800344}
345
Doug Zongker512536a2010-02-17 16:11:44 -0800346// Take a string 'str' of 40 hex digits and parse it into the 20
347// byte array 'digest'. 'str' may contain only the digest or be of
348// the form "<digest>:<anything>". Return 0 on success, -1 on any
349// error.
350int ParseSha1(const char* str, uint8_t* digest) {
Doug Zongkerc4351c72010-02-22 14:46:32 -0800351 const char* ps = str;
352 uint8_t* pd = digest;
Sen Jiangc48cb5e2016-02-04 16:23:21 +0800353 for (int i = 0; i < SHA_DIGEST_LENGTH * 2; ++i, ++ps) {
Doug Zongkerc4351c72010-02-22 14:46:32 -0800354 int digit;
355 if (*ps >= '0' && *ps <= '9') {
356 digit = *ps - '0';
357 } else if (*ps >= 'a' && *ps <= 'f') {
358 digit = *ps - 'a' + 10;
359 } else if (*ps >= 'A' && *ps <= 'F') {
360 digit = *ps - 'A' + 10;
361 } else {
362 return -1;
363 }
364 if (i % 2 == 0) {
365 *pd = digit << 4;
366 } else {
367 *pd |= digit;
368 ++pd;
369 }
Doug Zongker512536a2010-02-17 16:11:44 -0800370 }
Doug Zongkerc4351c72010-02-22 14:46:32 -0800371 if (*ps != '\0') return -1;
372 return 0;
Doug Zongker512536a2010-02-17 16:11:44 -0800373}
374
Doug Zongkerc4351c72010-02-22 14:46:32 -0800375// Search an array of sha1 strings for one matching the given sha1.
376// Return the index of the match on success, or -1 if no match is
377// found.
Tao Baoc8e79342016-12-28 10:11:22 -0800378static int FindMatchingPatch(uint8_t* sha1, const std::vector<std::string>& patch_sha1_str) {
Tao Bao8fce75a2016-11-10 12:33:41 -0800379 for (size_t i = 0; i < patch_sha1_str.size(); ++i) {
380 uint8_t patch_sha1[SHA_DIGEST_LENGTH];
381 if (ParseSha1(patch_sha1_str[i].c_str(), patch_sha1) == 0 &&
382 memcmp(patch_sha1, sha1, SHA_DIGEST_LENGTH) == 0) {
383 return i;
Doug Zongker512536a2010-02-17 16:11:44 -0800384 }
Tao Bao8fce75a2016-11-10 12:33:41 -0800385 }
386 return -1;
Doug Zongker512536a2010-02-17 16:11:44 -0800387}
388
389// Returns 0 if the contents of the file (argv[2]) or the cached file
390// match any of the sha1's on the command line (argv[3:]). Returns
391// nonzero otherwise.
Tianjie Xuaced5d92016-10-12 10:55:04 -0700392int applypatch_check(const char* filename, const std::vector<std::string>& patch_sha1_str) {
Tao Bao8fce75a2016-11-10 12:33:41 -0800393 FileContents file;
Doug Zongker512536a2010-02-17 16:11:44 -0800394
Tao Bao8fce75a2016-11-10 12:33:41 -0800395 // It's okay to specify no sha1s; the check will pass if the
396 // LoadFileContents is successful. (Useful for reading
397 // partitions, where the filename encodes the sha1s; no need to
398 // check them twice.)
399 if (LoadFileContents(filename, &file) != 0 ||
400 (!patch_sha1_str.empty() && FindMatchingPatch(file.sha1, patch_sha1_str) < 0)) {
401 printf("file \"%s\" doesn't have any of expected sha1 sums; checking cache\n", filename);
Doug Zongker512536a2010-02-17 16:11:44 -0800402
Tianjie Xua88cc542017-10-25 13:16:54 -0700403 // If the source file is missing or corrupted, it might be because we were killed in the middle
404 // of patching it. A copy of it should have been made in cache_temp_source. If that file
405 // exists and matches the sha1 we're looking for, the check still passes.
Tianjie Xu3bbb20f2018-02-27 15:56:11 -0800406 if (LoadFileContents(CacheLocation::location().cache_temp_source().c_str(), &file) != 0) {
Tao Bao8fce75a2016-11-10 12:33:41 -0800407 printf("failed to load cache file\n");
408 return 1;
Doug Zongkerc4351c72010-02-22 14:46:32 -0800409 }
Tao Bao8fce75a2016-11-10 12:33:41 -0800410
411 if (FindMatchingPatch(file.sha1, patch_sha1_str) < 0) {
412 printf("cache bits don't match any sha1 for \"%s\"\n", filename);
413 return 1;
414 }
415 }
416 return 0;
Doug Zongker512536a2010-02-17 16:11:44 -0800417}
418
419int ShowLicenses() {
Doug Zongkerc4351c72010-02-22 14:46:32 -0800420 ShowBSDiffLicense();
421 return 0;
Doug Zongker512536a2010-02-17 16:11:44 -0800422}
423
Tao Baoc0e1c462017-02-01 10:20:10 -0800424static size_t FileSink(const unsigned char* data, size_t len, int fd) {
Tao Baof7eb7602017-03-27 15:12:48 -0700425 size_t done = 0;
426 while (done < len) {
427 ssize_t wrote = TEMP_FAILURE_RETRY(ota_write(fd, data + done, len - done));
428 if (wrote == -1) {
429 printf("error writing %zd bytes: %s\n", (len - done), strerror(errno));
430 return done;
Doug Zongker512536a2010-02-17 16:11:44 -0800431 }
Tao Baof7eb7602017-03-27 15:12:48 -0700432 done += wrote;
433 }
434 return done;
Doug Zongker512536a2010-02-17 16:11:44 -0800435}
436
Doug Zongker512536a2010-02-17 16:11:44 -0800437// Return the amount of free space (in bytes) on the filesystem
438// containing filename. filename must exist. Return -1 on error.
Tianjie Xud5fbcc12018-04-11 14:38:09 -0700439size_t FreeSpaceForFile(const std::string& filename) {
440 struct statfs sf;
441 if (statfs(filename.c_str(), &sf) != 0) {
442 printf("failed to statfs %s: %s\n", filename.c_str(), strerror(errno));
443 return -1;
444 }
445 return sf.f_bsize * sf.f_bavail;
Doug Zongker512536a2010-02-17 16:11:44 -0800446}
447
Doug Zongkerc4351c72010-02-22 14:46:32 -0800448int CacheSizeCheck(size_t bytes) {
449 if (MakeFreeSpaceOnCache(bytes) < 0) {
Chih-Hung Hsieh54a27472016-04-18 11:30:55 -0700450 printf("unable to make %zu bytes available on /cache\n", bytes);
Doug Zongkerc4351c72010-02-22 14:46:32 -0800451 return 1;
Doug Zongkerc4351c72010-02-22 14:46:32 -0800452 }
Tianjie Xue40c80d2018-02-03 17:20:56 -0800453 return 0;
Doug Zongkerc4351c72010-02-22 14:46:32 -0800454}
455
Tao Bao40e144d2017-03-15 01:10:58 -0700456// This function applies binary patches to EMMC target files in a way that is safe (the original
457// file is not touched until we have the desired replacement for it) and idempotent (it's okay to
458// run this program multiple times).
Doug Zongker512536a2010-02-17 16:11:44 -0800459//
Tao Bao40e144d2017-03-15 01:10:58 -0700460// - If the SHA-1 hash of <target_filename> is <target_sha1_string>, does nothing and exits
461// successfully.
Doug Zongker512536a2010-02-17 16:11:44 -0800462//
Tao Bao40e144d2017-03-15 01:10:58 -0700463// - Otherwise, if the SHA-1 hash of <source_filename> is one of the entries in <patch_sha1_str>,
464// the corresponding patch from <patch_data> (which must be a VAL_BLOB) is applied to produce a
465// new file (the type of patch is automatically detected from the blob data). If that new file
466// has SHA-1 hash <target_sha1_str>, moves it to replace <target_filename>, and exits
467// successfully. Note that if <source_filename> and <target_filename> are not the same,
468// <source_filename> is NOT deleted on success. <target_filename> may be the string "-" to mean
469// "the same as <source_filename>".
Doug Zongker512536a2010-02-17 16:11:44 -0800470//
Tao Bao40e144d2017-03-15 01:10:58 -0700471// - Otherwise, or if any error is encountered, exits with non-zero status.
Doug Zongker512536a2010-02-17 16:11:44 -0800472//
Tao Bao40e144d2017-03-15 01:10:58 -0700473// <source_filename> must refer to an EMMC partition to read the source data. See the comments for
474// the LoadPartitionContents() function above for the format of such a filename. <target_size> has
475// become obsolete since we have dropped the support for patching non-EMMC targets (EMMC targets
476// have the size embedded in the filename).
477int applypatch(const char* source_filename, const char* target_filename,
Tianjie Xue40c80d2018-02-03 17:20:56 -0800478 const char* target_sha1_str, size_t /* target_size */,
Tianjie Xuaced5d92016-10-12 10:55:04 -0700479 const std::vector<std::string>& patch_sha1_str,
Tao Bao40e144d2017-03-15 01:10:58 -0700480 const std::vector<std::unique_ptr<Value>>& patch_data, const Value* bonus_data) {
481 printf("patch %s: ", source_filename);
Doug Zongker512536a2010-02-17 16:11:44 -0800482
Tao Bao40e144d2017-03-15 01:10:58 -0700483 if (target_filename[0] == '-' && target_filename[1] == '\0') {
484 target_filename = source_filename;
485 }
486
487 if (strncmp(target_filename, "EMMC:", 5) != 0) {
488 printf("Supporting patching EMMC targets only.\n");
489 return 1;
490 }
491
492 uint8_t target_sha1[SHA_DIGEST_LENGTH];
493 if (ParseSha1(target_sha1_str, target_sha1) != 0) {
494 printf("failed to parse tgt-sha1 \"%s\"\n", target_sha1_str);
495 return 1;
496 }
497
498 // We try to load the target file into the source_file object.
499 FileContents source_file;
500 if (LoadFileContents(target_filename, &source_file) == 0) {
501 if (memcmp(source_file.sha1, target_sha1, SHA_DIGEST_LENGTH) == 0) {
502 // The early-exit case: the patch was already applied, this file has the desired hash, nothing
503 // for us to do.
504 printf("already %s\n", short_sha1(target_sha1).c_str());
505 return 0;
Doug Zongker512536a2010-02-17 16:11:44 -0800506 }
Tao Bao40e144d2017-03-15 01:10:58 -0700507 }
Doug Zongker512536a2010-02-17 16:11:44 -0800508
Tao Bao40e144d2017-03-15 01:10:58 -0700509 if (source_file.data.empty() ||
510 (target_filename != source_filename && strcmp(target_filename, source_filename) != 0)) {
511 // Need to load the source file: either we failed to load the target file, or we did but it's
512 // different from the expected.
513 source_file.data.clear();
514 LoadFileContents(source_filename, &source_file);
515 }
516
517 if (!source_file.data.empty()) {
518 int to_use = FindMatchingPatch(source_file.sha1, patch_sha1_str);
519 if (to_use != -1) {
520 return GenerateTarget(source_file, patch_data[to_use], target_filename, target_sha1,
521 bonus_data);
Doug Zongkerc4351c72010-02-22 14:46:32 -0800522 }
Tao Bao40e144d2017-03-15 01:10:58 -0700523 }
Doug Zongker512536a2010-02-17 16:11:44 -0800524
Tao Bao40e144d2017-03-15 01:10:58 -0700525 printf("source file is bad; trying copy\n");
Doug Zongker512536a2010-02-17 16:11:44 -0800526
Tao Bao40e144d2017-03-15 01:10:58 -0700527 FileContents copy_file;
Tianjie Xu3bbb20f2018-02-27 15:56:11 -0800528 if (LoadFileContents(CacheLocation::location().cache_temp_source().c_str(), &copy_file) < 0) {
Tao Bao40e144d2017-03-15 01:10:58 -0700529 printf("failed to read copy file\n");
530 return 1;
531 }
Doug Zongker512536a2010-02-17 16:11:44 -0800532
Tao Bao40e144d2017-03-15 01:10:58 -0700533 int to_use = FindMatchingPatch(copy_file.sha1, patch_sha1_str);
534 if (to_use == -1) {
535 printf("copy file doesn't match source SHA-1s either\n");
536 return 1;
537 }
Doug Zongkerc4351c72010-02-22 14:46:32 -0800538
Tao Bao40e144d2017-03-15 01:10:58 -0700539 return GenerateTarget(copy_file, patch_data[to_use], target_filename, target_sha1, bonus_data);
Doug Zongker1c43c972012-02-28 11:07:09 -0800540}
541
Tao Baoabba55b2015-07-17 18:11:12 -0700542/*
543 * This function flashes a given image to the target partition. It verifies
544 * the target cheksum first, and will return if target has the desired hash.
545 * It checks the checksum of the given source image before flashing, and
546 * verifies the target partition afterwards. The function is idempotent.
547 * Returns zero on success.
548 */
549int applypatch_flash(const char* source_filename, const char* target_filename,
550 const char* target_sha1_str, size_t target_size) {
Tao Bao6e02ea92016-11-17 11:24:07 -0800551 printf("flash %s: ", target_filename);
Tao Baoabba55b2015-07-17 18:11:12 -0700552
Tao Bao6e02ea92016-11-17 11:24:07 -0800553 uint8_t target_sha1[SHA_DIGEST_LENGTH];
554 if (ParseSha1(target_sha1_str, target_sha1) != 0) {
555 printf("failed to parse tgt-sha1 \"%s\"\n", target_sha1_str);
556 return 1;
557 }
Tao Baoabba55b2015-07-17 18:11:12 -0700558
Tao Bao6e02ea92016-11-17 11:24:07 -0800559 std::string target_str(target_filename);
560 std::vector<std::string> pieces = android::base::Split(target_str, ":");
561 if (pieces.size() != 2 || pieces[0] != "EMMC") {
562 printf("invalid target name \"%s\"", target_filename);
563 return 1;
564 }
Tao Baoabba55b2015-07-17 18:11:12 -0700565
Tao Bao6e02ea92016-11-17 11:24:07 -0800566 // Load the target into the source_file object to see if already applied.
567 pieces.push_back(std::to_string(target_size));
568 pieces.push_back(target_sha1_str);
569 std::string fullname = android::base::Join(pieces, ':');
570 FileContents source_file;
571 if (LoadPartitionContents(fullname, &source_file) == 0 &&
572 memcmp(source_file.sha1, target_sha1, SHA_DIGEST_LENGTH) == 0) {
573 // The early-exit case: the image was already applied, this partition
574 // has the desired hash, nothing for us to do.
575 printf("already %s\n", short_sha1(target_sha1).c_str());
Tao Baoabba55b2015-07-17 18:11:12 -0700576 return 0;
Tao Bao6e02ea92016-11-17 11:24:07 -0800577 }
578
579 if (LoadFileContents(source_filename, &source_file) == 0) {
580 if (memcmp(source_file.sha1, target_sha1, SHA_DIGEST_LENGTH) != 0) {
581 // The source doesn't have desired checksum.
582 printf("source \"%s\" doesn't have expected sha1 sum\n", source_filename);
583 printf("expected: %s, found: %s\n", short_sha1(target_sha1).c_str(),
584 short_sha1(source_file.sha1).c_str());
585 return 1;
586 }
587 }
588
589 if (WriteToPartition(source_file.data.data(), target_size, target_filename) != 0) {
590 printf("write of copied data to %s failed\n", target_filename);
591 return 1;
592 }
593 return 0;
Tao Baoabba55b2015-07-17 18:11:12 -0700594}
595
Tao Bao40e144d2017-03-15 01:10:58 -0700596static int GenerateTarget(const FileContents& source_file, const std::unique_ptr<Value>& patch,
597 const std::string& target_filename,
598 const uint8_t target_sha1[SHA_DIGEST_LENGTH], const Value* bonus_data) {
Tao Bao6e02ea92016-11-17 11:24:07 -0800599 if (patch->type != VAL_BLOB) {
600 printf("patch is not a blob\n");
601 return 1;
602 }
Yabin Cuid483c202016-02-03 17:08:52 -0800603
Tao Bao6e02ea92016-11-17 11:24:07 -0800604 const char* header = &patch->data[0];
605 size_t header_bytes_read = patch->data.size();
606 bool use_bsdiff = false;
607 if (header_bytes_read >= 8 && memcmp(header, "BSDIFF40", 8) == 0) {
608 use_bsdiff = true;
609 } else if (header_bytes_read >= 8 && memcmp(header, "IMGDIFF2", 8) == 0) {
610 use_bsdiff = false;
611 } else {
612 printf("Unknown patch file format\n");
613 return 1;
614 }
Doug Zongker512536a2010-02-17 16:11:44 -0800615
Tao Bao40e144d2017-03-15 01:10:58 -0700616 CHECK(android::base::StartsWith(target_filename, "EMMC:"));
Doug Zongkerc4351c72010-02-22 14:46:32 -0800617
Tao Bao40e144d2017-03-15 01:10:58 -0700618 // We still write the original source to cache, in case the partition write is interrupted.
619 if (MakeFreeSpaceOnCache(source_file.data.size()) < 0) {
620 printf("not enough free space on /cache\n");
621 return 1;
622 }
Tianjie Xu3bbb20f2018-02-27 15:56:11 -0800623 if (SaveFileContents(CacheLocation::location().cache_temp_source().c_str(), &source_file) < 0) {
Tao Bao40e144d2017-03-15 01:10:58 -0700624 printf("failed to back up source file\n");
625 return 1;
626 }
627
628 // We store the decoded output in memory.
Tao Bao6e02ea92016-11-17 11:24:07 -0800629 std::string memory_sink_str; // Don't need to reserve space.
Tao Bao8b0b0f12018-04-19 21:02:13 -0700630 SHA_CTX ctx;
631 SHA1_Init(&ctx);
632 SinkFn sink = [&memory_sink_str, &ctx](const unsigned char* data, size_t len) {
Tianjie Xuffed57a2018-04-23 17:51:45 -0700633 if (len != 0) {
634 uint8_t digest[SHA_DIGEST_LENGTH];
635 SHA1(data, len, digest);
636 LOG(DEBUG) << "Appending " << len << " bytes data, sha1: " << short_sha1(digest);
637 }
Tao Bao8b0b0f12018-04-19 21:02:13 -0700638 SHA1_Update(&ctx, data, len);
Tao Baoc0e1c462017-02-01 10:20:10 -0800639 memory_sink_str.append(reinterpret_cast<const char*>(data), len);
640 return len;
641 };
Doug Zongkerc4351c72010-02-22 14:46:32 -0800642
Tao Bao40e144d2017-03-15 01:10:58 -0700643 int result;
644 if (use_bsdiff) {
Tao Bao8b0b0f12018-04-19 21:02:13 -0700645 result = ApplyBSDiffPatch(source_file.data.data(), source_file.data.size(), *patch, 0, sink);
Tao Bao40e144d2017-03-15 01:10:58 -0700646 } else {
Tao Bao8b0b0f12018-04-19 21:02:13 -0700647 result =
648 ApplyImagePatch(source_file.data.data(), source_file.data.size(), *patch, sink, bonus_data);
Tao Bao40e144d2017-03-15 01:10:58 -0700649 }
Tao Bao6e02ea92016-11-17 11:24:07 -0800650
Tao Bao40e144d2017-03-15 01:10:58 -0700651 if (result != 0) {
652 printf("applying patch failed\n");
653 return 1;
654 }
Tao Bao6e02ea92016-11-17 11:24:07 -0800655
656 uint8_t current_target_sha1[SHA_DIGEST_LENGTH];
657 SHA1_Final(current_target_sha1, &ctx);
658 if (memcmp(current_target_sha1, target_sha1, SHA_DIGEST_LENGTH) != 0) {
Tao Bao4f834302018-04-19 12:35:14 -0700659 printf("patch did not produce expected sha1 of %s\n", short_sha1(target_sha1).c_str());
660
661 printf("target size %zu sha1 %s\n", memory_sink_str.size(),
662 short_sha1(current_target_sha1).c_str());
663 printf("source size %zu sha1 %s\n", source_file.data.size(),
664 short_sha1(source_file.sha1).c_str());
665
666 uint8_t patch_digest[SHA_DIGEST_LENGTH];
667 SHA1(reinterpret_cast<const uint8_t*>(patch->data.data()), patch->data.size(), patch_digest);
668 printf("patch size %zu sha1 %s\n", patch->data.size(), short_sha1(patch_digest).c_str());
669
670 uint8_t bonus_digest[SHA_DIGEST_LENGTH];
671 SHA1(reinterpret_cast<const uint8_t*>(bonus_data->data.data()), bonus_data->data.size(),
672 bonus_digest);
673 printf("bonus size %zu sha1 %s\n", bonus_data->data.size(), short_sha1(bonus_digest).c_str());
674
Tao Bao6e02ea92016-11-17 11:24:07 -0800675 return 1;
676 } else {
677 printf("now %s\n", short_sha1(target_sha1).c_str());
678 }
679
Tao Bao40e144d2017-03-15 01:10:58 -0700680 // Write back the temp file to the partition.
681 if (WriteToPartition(reinterpret_cast<const unsigned char*>(memory_sink_str.c_str()),
682 memory_sink_str.size(), target_filename) != 0) {
683 printf("write of patched data to %s failed\n", target_filename.c_str());
684 return 1;
Tao Bao6e02ea92016-11-17 11:24:07 -0800685 }
686
Tao Bao40e144d2017-03-15 01:10:58 -0700687 // Delete the backup copy of the source.
Tianjie Xu3bbb20f2018-02-27 15:56:11 -0800688 unlink(CacheLocation::location().cache_temp_source().c_str());
Tao Bao6e02ea92016-11-17 11:24:07 -0800689
690 // Success!
691 return 0;
Doug Zongker512536a2010-02-17 16:11:44 -0800692}