blob: 31606bb1a7c457d294e02f7d8336bc1b4500c910 [file] [log] [blame]
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001/*
2 * Copyright (C) 2007 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
Doug Zongkerb2ee9202009-06-04 10:24:53 -070017#include <ctype.h>
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080018#include <errno.h>
19#include <fcntl.h>
20#include <limits.h>
Elliott Hughes26dbad22015-01-28 12:09:05 -080021#include <string.h>
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080022#include <sys/stat.h>
Doug Zongkerb2ee9202009-06-04 10:24:53 -070023#include <sys/wait.h>
24#include <unistd.h>
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080025
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080026#include "common.h"
27#include "install.h"
28#include "mincrypt/rsa.h"
29#include "minui/minui.h"
30#include "minzip/SysUtil.h"
31#include "minzip/Zip.h"
32#include "mtdutils/mounts.h"
33#include "mtdutils/mtdutils.h"
34#include "roots.h"
35#include "verifier.h"
Doug Zongker10e418d2011-10-28 10:33:05 -070036#include "ui.h"
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080037
Doug Zongker74406302011-10-28 15:13:10 -070038extern RecoveryUI* ui;
39
Doug Zongkerb2ee9202009-06-04 10:24:53 -070040#define ASSUMED_UPDATE_BINARY_NAME "META-INF/com/google/android/update-binary"
Doug Zongkerd1b19b92009-04-01 15:48:46 -070041#define PUBLIC_KEYS_FILE "/res/keys"
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080042
Doug Zongker74406302011-10-28 15:13:10 -070043// Default allocation of progress bar segments to operations
44static const int VERIFICATION_PROGRESS_TIME = 60;
45static const float VERIFICATION_PROGRESS_FRACTION = 0.25;
46static const float DEFAULT_FILES_PROGRESS_FRACTION = 0.4;
47static const float DEFAULT_IMAGE_PROGRESS_FRACTION = 0.1;
48
Doug Zongkerb2ee9202009-06-04 10:24:53 -070049// If the package contains an update binary, extract it and run it.
50static int
Doug Zongkerd0181b82011-10-19 10:51:12 -070051try_update_binary(const char *path, ZipArchive *zip, int* wipe_cache) {
Doug Zongkerb2ee9202009-06-04 10:24:53 -070052 const ZipEntry* binary_entry =
53 mzFindZipEntry(zip, ASSUMED_UPDATE_BINARY_NAME);
54 if (binary_entry == NULL) {
Doug Zongker8e5e4da2010-09-14 18:06:55 -070055 mzCloseZipArchive(zip);
Doug Zongkerb2ee9202009-06-04 10:24:53 -070056 return INSTALL_CORRUPT;
57 }
58
Doug Zongker10e418d2011-10-28 10:33:05 -070059 const char* binary = "/tmp/update_binary";
Doug Zongkerb2ee9202009-06-04 10:24:53 -070060 unlink(binary);
61 int fd = creat(binary, 0755);
62 if (fd < 0) {
Doug Zongker8e5e4da2010-09-14 18:06:55 -070063 mzCloseZipArchive(zip);
Doug Zongkerb2ee9202009-06-04 10:24:53 -070064 LOGE("Can't make %s\n", binary);
Doug Zongkerd0181b82011-10-19 10:51:12 -070065 return INSTALL_ERROR;
Doug Zongkerb2ee9202009-06-04 10:24:53 -070066 }
67 bool ok = mzExtractZipEntryToFile(zip, binary_entry, fd);
68 close(fd);
Doug Zongker8e5e4da2010-09-14 18:06:55 -070069 mzCloseZipArchive(zip);
Doug Zongkerb2ee9202009-06-04 10:24:53 -070070
71 if (!ok) {
72 LOGE("Can't copy %s\n", ASSUMED_UPDATE_BINARY_NAME);
Doug Zongkerd0181b82011-10-19 10:51:12 -070073 return INSTALL_ERROR;
Doug Zongkerb2ee9202009-06-04 10:24:53 -070074 }
75
76 int pipefd[2];
77 pipe(pipefd);
78
79 // When executing the update binary contained in the package, the
80 // arguments passed are:
81 //
Doug Zongkerfb2e3af2009-06-17 17:29:40 -070082 // - the version number for this interface
Doug Zongkerb2ee9202009-06-04 10:24:53 -070083 //
84 // - an fd to which the program can write in order to update the
85 // progress bar. The program can write single-line commands:
86 //
87 // progress <frac> <secs>
Doug Zongkerfbf3c102009-06-24 09:36:20 -070088 // fill up the next <frac> part of of the progress bar
89 // over <secs> seconds. If <secs> is zero, use
90 // set_progress commands to manually control the
91 // progress of this segment of the bar
92 //
93 // set_progress <frac>
94 // <frac> should be between 0.0 and 1.0; sets the
95 // progress bar within the segment defined by the most
96 // recent progress command.
Doug Zongkerb2ee9202009-06-04 10:24:53 -070097 //
98 // firmware <"hboot"|"radio"> <filename>
99 // arrange to install the contents of <filename> in the
Doug Zongkere08991e2010-02-02 13:09:52 -0800100 // given partition on reboot.
101 //
102 // (API v2: <filename> may start with "PACKAGE:" to
103 // indicate taking a file from the OTA package.)
104 //
105 // (API v3: this command no longer exists.)
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700106 //
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700107 // ui_print <string>
108 // display <string> on the screen.
109 //
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700110 // - the name of the package zip file.
111 //
112
Doug Zongker10e418d2011-10-28 10:33:05 -0700113 const char** args = (const char**)malloc(sizeof(char*) * 5);
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700114 args[0] = binary;
Doug Zongkerfb2e3af2009-06-17 17:29:40 -0700115 args[1] = EXPAND(RECOVERY_API_VERSION); // defined in Android.mk
Doug Zongker10e418d2011-10-28 10:33:05 -0700116 char* temp = (char*)malloc(10);
117 sprintf(temp, "%d", pipefd[1]);
118 args[2] = temp;
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700119 args[3] = (char*)path;
120 args[4] = NULL;
121
122 pid_t pid = fork();
123 if (pid == 0) {
Alistair Strachan027429a2013-07-17 10:41:49 -0700124 umask(022);
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700125 close(pipefd[0]);
Doug Zongker10e418d2011-10-28 10:33:05 -0700126 execv(binary, (char* const*)args);
Doug Zongker56c51052010-07-01 09:18:44 -0700127 fprintf(stdout, "E:Can't run %s (%s)\n", binary, strerror(errno));
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700128 _exit(-1);
129 }
130 close(pipefd[1]);
131
Doug Zongkerd0181b82011-10-19 10:51:12 -0700132 *wipe_cache = 0;
133
Doug Zongker64893cc2009-07-14 16:31:56 -0700134 char buffer[1024];
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700135 FILE* from_child = fdopen(pipefd[0], "r");
136 while (fgets(buffer, sizeof(buffer), from_child) != NULL) {
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700137 char* command = strtok(buffer, " \n");
138 if (command == NULL) {
139 continue;
140 } else if (strcmp(command, "progress") == 0) {
141 char* fraction_s = strtok(NULL, " \n");
142 char* seconds_s = strtok(NULL, " \n");
143
144 float fraction = strtof(fraction_s, NULL);
145 int seconds = strtol(seconds_s, NULL, 10);
146
Doug Zongker74406302011-10-28 15:13:10 -0700147 ui->ShowProgress(fraction * (1-VERIFICATION_PROGRESS_FRACTION), seconds);
Doug Zongkerfbf3c102009-06-24 09:36:20 -0700148 } else if (strcmp(command, "set_progress") == 0) {
149 char* fraction_s = strtok(NULL, " \n");
150 float fraction = strtof(fraction_s, NULL);
Doug Zongker74406302011-10-28 15:13:10 -0700151 ui->SetProgress(fraction);
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700152 } else if (strcmp(command, "ui_print") == 0) {
153 char* str = strtok(NULL, "\n");
154 if (str) {
Doug Zongker74406302011-10-28 15:13:10 -0700155 ui->Print("%s", str);
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700156 } else {
Doug Zongker74406302011-10-28 15:13:10 -0700157 ui->Print("\n");
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700158 }
Doug Zongkerfafc85b2013-07-09 12:29:45 -0700159 fflush(stdout);
Doug Zongkerd0181b82011-10-19 10:51:12 -0700160 } else if (strcmp(command, "wipe_cache") == 0) {
161 *wipe_cache = 1;
Doug Zongkere5d5ac72012-04-12 11:01:22 -0700162 } else if (strcmp(command, "clear_display") == 0) {
163 ui->SetBackground(RecoveryUI::NONE);
Doug Zongkerc704e062014-05-23 08:40:35 -0700164 } else if (strcmp(command, "enable_reboot") == 0) {
165 // packages can explicitly request that they want the user
166 // to be able to reboot during installation (useful for
167 // debugging packages that don't exit).
168 ui->SetEnableReboot(true);
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700169 } else {
170 LOGE("unknown command [%s]\n", command);
171 }
172 }
173 fclose(from_child);
174
175 int status;
176 waitpid(pid, &status, 0);
177 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700178 LOGE("Error in %s\n(Status %d)\n", path, WEXITSTATUS(status));
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700179 return INSTALL_ERROR;
180 }
181
Doug Zongkere08991e2010-02-02 13:09:52 -0800182 return INSTALL_SUCCESS;
Doug Zongkerb2ee9202009-06-04 10:24:53 -0700183}
184
Doug Zongker469243e2011-04-12 09:28:10 -0700185static int
Doug Zongker075ad802014-06-26 15:35:51 -0700186really_install_package(const char *path, int* wipe_cache, bool needs_mount)
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800187{
Doug Zongker02ec6b82012-08-22 17:26:40 -0700188 ui->SetBackground(RecoveryUI::INSTALLING_UPDATE);
Doug Zongker74406302011-10-28 15:13:10 -0700189 ui->Print("Finding update package...\n");
Doug Zongker239ac6a2013-08-20 16:03:25 -0700190 // Give verification half the progress bar...
191 ui->SetProgressType(RecoveryUI::DETERMINATE);
192 ui->ShowProgress(VERIFICATION_PROGRESS_FRACTION, VERIFICATION_PROGRESS_TIME);
Doug Zongkercc8cd3f2010-09-20 12:16:13 -0700193 LOGI("Update location: %s\n", path);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800194
Doug Zongker99916f02014-01-13 14:16:58 -0800195 // Map the update package into memory.
196 ui->Print("Opening update package...\n");
197
Doug Zongker075ad802014-06-26 15:35:51 -0700198 if (path && needs_mount) {
Doug Zongker99916f02014-01-13 14:16:58 -0800199 if (path[0] == '@') {
200 ensure_path_mounted(path+1);
201 } else {
202 ensure_path_mounted(path);
203 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800204 }
205
Doug Zongker99916f02014-01-13 14:16:58 -0800206 MemMapping map;
207 if (sysMapFile(path, &map) != 0) {
208 LOGE("failed to map file\n");
209 return INSTALL_CORRUPT;
210 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800211
Doug Zongkerd1b19b92009-04-01 15:48:46 -0700212 int numKeys;
Doug Zongkerbac7fba2013-04-10 11:32:17 -0700213 Certificate* loadedKeys = load_keys(PUBLIC_KEYS_FILE, &numKeys);
Doug Zongkerd1b19b92009-04-01 15:48:46 -0700214 if (loadedKeys == NULL) {
215 LOGE("Failed to load keys\n");
216 return INSTALL_CORRUPT;
217 }
218 LOGI("%d key(s) loaded from %s\n", numKeys, PUBLIC_KEYS_FILE);
219
Doug Zongker74406302011-10-28 15:13:10 -0700220 ui->Print("Verifying update package...\n");
Doug Zongker60151a22009-08-12 18:30:03 -0700221
222 int err;
Doug Zongker99916f02014-01-13 14:16:58 -0800223 err = verify_file(map.addr, map.length, loadedKeys, numKeys);
Doug Zongker60151a22009-08-12 18:30:03 -0700224 free(loadedKeys);
225 LOGI("verify_file returned %d\n", err);
226 if (err != VERIFY_SUCCESS) {
227 LOGE("signature verification failed\n");
Doug Zongker99916f02014-01-13 14:16:58 -0800228 sysReleaseMap(&map);
Doug Zongker60151a22009-08-12 18:30:03 -0700229 return INSTALL_CORRUPT;
230 }
231
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800232 /* Try to open the package.
233 */
234 ZipArchive zip;
Doug Zongker99916f02014-01-13 14:16:58 -0800235 err = mzOpenZipArchive(map.addr, map.length, &zip);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800236 if (err != 0) {
237 LOGE("Can't open %s\n(%s)\n", path, err != -1 ? strerror(err) : "bad");
Doug Zongker99916f02014-01-13 14:16:58 -0800238 sysReleaseMap(&map);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800239 return INSTALL_CORRUPT;
240 }
241
242 /* Verify and install the contents of the package.
243 */
Doug Zongker74406302011-10-28 15:13:10 -0700244 ui->Print("Installing update...\n");
Doug Zongkerc704e062014-05-23 08:40:35 -0700245 ui->SetEnableReboot(false);
Doug Zongker99916f02014-01-13 14:16:58 -0800246 int result = try_update_binary(path, &zip, wipe_cache);
Doug Zongkerc704e062014-05-23 08:40:35 -0700247 ui->SetEnableReboot(true);
Doug Zongker075ad802014-06-26 15:35:51 -0700248 ui->Print("\n");
Doug Zongker99916f02014-01-13 14:16:58 -0800249
250 sysReleaseMap(&map);
251
252 return result;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800253}
Doug Zongker469243e2011-04-12 09:28:10 -0700254
255int
Doug Zongker075ad802014-06-26 15:35:51 -0700256install_package(const char* path, int* wipe_cache, const char* install_file,
257 bool needs_mount)
Doug Zongker469243e2011-04-12 09:28:10 -0700258{
Doug Zongkerd0181b82011-10-19 10:51:12 -0700259 FILE* install_log = fopen_path(install_file, "w");
Doug Zongker469243e2011-04-12 09:28:10 -0700260 if (install_log) {
261 fputs(path, install_log);
262 fputc('\n', install_log);
263 } else {
264 LOGE("failed to open last_install: %s\n", strerror(errno));
265 }
Doug Zongker239ac6a2013-08-20 16:03:25 -0700266 int result;
267 if (setup_install_mounts() != 0) {
268 LOGE("failed to set up expected mounts for install; aborting\n");
269 result = INSTALL_ERROR;
270 } else {
Doug Zongker075ad802014-06-26 15:35:51 -0700271 result = really_install_package(path, wipe_cache, needs_mount);
Doug Zongker239ac6a2013-08-20 16:03:25 -0700272 }
Doug Zongker469243e2011-04-12 09:28:10 -0700273 if (install_log) {
274 fputc(result == INSTALL_SUCCESS ? '1' : '0', install_log);
275 fputc('\n', install_log);
276 fclose(install_log);
Doug Zongker469243e2011-04-12 09:28:10 -0700277 }
278 return result;
279}