Dees Troy | 3be70a8 | 2013-10-22 14:25:12 +0000 | [diff] [blame] | 1 | /* |
bigbiff bigbiff | 19fb79c | 2016-09-05 21:04:51 -0400 | [diff] [blame] | 2 | Copyright 2012 to 2017 bigbiff/Dees_Troy TeamWin |
Dees Troy | 3be70a8 | 2013-10-22 14:25:12 +0000 | [diff] [blame] | 3 | This file is part of TWRP/TeamWin Recovery Project. |
| 4 | |
| 5 | TWRP is free software: you can redistribute it and/or modify |
| 6 | it under the terms of the GNU General Public License as published by |
| 7 | the Free Software Foundation, either version 3 of the License, or |
| 8 | (at your option) any later version. |
| 9 | |
| 10 | TWRP is distributed in the hope that it will be useful, |
| 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 | GNU General Public License for more details. |
| 14 | |
| 15 | You should have received a copy of the GNU General Public License |
| 16 | along with TWRP. If not, see <http://www.gnu.org/licenses/>. |
| 17 | */ |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 18 | |
nkk71 | b4c3591 | 2017-10-11 23:39:10 +0300 | [diff] [blame] | 19 | |
| 20 | #ifndef _GNU_SOURCE |
| 21 | #define _GNU_SOURCE |
| 22 | #endif |
| 23 | |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 24 | #include <ctype.h> |
| 25 | #include <errno.h> |
| 26 | #include <fcntl.h> |
| 27 | #include <limits.h> |
nkk71 | b4c3591 | 2017-10-11 23:39:10 +0300 | [diff] [blame] | 28 | #include <sys/mman.h> |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 29 | #include <sys/stat.h> |
| 30 | #include <sys/wait.h> |
| 31 | #include <unistd.h> |
| 32 | |
| 33 | #include <string.h> |
| 34 | #include <stdio.h> |
| 35 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 36 | #include "twcommon.h" |
Ethan Yonker | 75bf041 | 2014-11-21 13:54:27 -0600 | [diff] [blame] | 37 | #include "mtdutils/mounts.h" |
| 38 | #include "mtdutils/mtdutils.h" |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 39 | |
| 40 | #ifdef USE_MINZIP |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 41 | #include "minzip/SysUtil.h" |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 42 | #else |
| 43 | #include "otautil/SysUtil.h" |
| 44 | #include <ziparchive/zip_archive.h> |
| 45 | #endif |
| 46 | #include "zipwrap.hpp" |
Ethan Yonker | f117962 | 2016-08-25 15:32:21 -0500 | [diff] [blame] | 47 | #ifdef USE_OLD_VERIFIER |
Ethan Yonker | 4bf259f | 2016-08-29 11:50:34 -0500 | [diff] [blame] | 48 | #include "verifier24/verifier.h" |
Ethan Yonker | f117962 | 2016-08-25 15:32:21 -0500 | [diff] [blame] | 49 | #else |
Ethan Yonker | 75bf041 | 2014-11-21 13:54:27 -0600 | [diff] [blame] | 50 | #include "verifier.h" |
Ethan Yonker | f117962 | 2016-08-25 15:32:21 -0500 | [diff] [blame] | 51 | #endif |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 52 | #include "variables.h" |
| 53 | #include "data.hpp" |
| 54 | #include "partitions.hpp" |
bigbiff bigbiff | 56cf564 | 2016-08-19 17:43:45 -0400 | [diff] [blame] | 55 | #include "twrpDigestDriver.hpp" |
| 56 | #include "twrpDigest/twrpDigest.hpp" |
| 57 | #include "twrpDigest/twrpMD5.hpp" |
Dees_Troy | 38bd760 | 2012-09-14 13:33:53 -0400 | [diff] [blame] | 58 | #include "twrp-functions.hpp" |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 59 | #include "gui/gui.hpp" |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 60 | #include "gui/pages.hpp" |
Ethan Yonker | f117962 | 2016-08-25 15:32:21 -0500 | [diff] [blame] | 61 | #include "legacy_property_service.h" |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 62 | #include "twinstall.h" |
| 63 | #include "installcommand.h" |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 64 | extern "C" { |
| 65 | #include "gui/gui.h" |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 66 | } |
| 67 | |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 68 | #define AB_OTA "payload_properties.txt" |
| 69 | |
lambdadroid | c4faea8 | 2018-09-26 22:56:51 +0200 | [diff] [blame] | 70 | #ifndef TW_NO_LEGACY_PROPS |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 71 | static const char* properties_path = "/dev/__properties__"; |
| 72 | static const char* properties_path_renamed = "/dev/__properties_kk__"; |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 73 | static bool legacy_props_env_initd = false; |
| 74 | static bool legacy_props_path_modified = false; |
lambdadroid | c4faea8 | 2018-09-26 22:56:51 +0200 | [diff] [blame] | 75 | #endif |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 76 | |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 77 | enum zip_type { |
| 78 | UNKNOWN_ZIP_TYPE = 0, |
| 79 | UPDATE_BINARY_ZIP_TYPE, |
| 80 | AB_OTA_ZIP_TYPE, |
| 81 | TWRP_THEME_ZIP_TYPE |
| 82 | }; |
| 83 | |
lambdadroid | c4faea8 | 2018-09-26 22:56:51 +0200 | [diff] [blame] | 84 | #ifndef TW_NO_LEGACY_PROPS |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 85 | // to support pre-KitKat update-binaries that expect properties in the legacy format |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 86 | static int switch_to_legacy_properties() |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 87 | { |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 88 | if (!legacy_props_env_initd) { |
| 89 | if (legacy_properties_init() != 0) |
| 90 | return -1; |
| 91 | |
| 92 | char tmp[32]; |
| 93 | int propfd, propsz; |
| 94 | legacy_get_property_workspace(&propfd, &propsz); |
| 95 | sprintf(tmp, "%d,%d", dup(propfd), propsz); |
| 96 | setenv("ANDROID_PROPERTY_WORKSPACE", tmp, 1); |
| 97 | legacy_props_env_initd = true; |
| 98 | } |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 99 | |
| 100 | if (TWFunc::Path_Exists(properties_path)) { |
| 101 | // hide real properties so that the updater uses the envvar to find the legacy format properties |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 102 | if (rename(properties_path, properties_path_renamed) != 0) { |
| 103 | LOGERR("Renaming %s failed: %s\n", properties_path, strerror(errno)); |
| 104 | return -1; |
| 105 | } else { |
| 106 | legacy_props_path_modified = true; |
| 107 | } |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 108 | } |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 109 | |
| 110 | return 0; |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 111 | } |
| 112 | |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 113 | static int switch_to_new_properties() |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 114 | { |
| 115 | if (TWFunc::Path_Exists(properties_path_renamed)) { |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 116 | if (rename(properties_path_renamed, properties_path) != 0) { |
| 117 | LOGERR("Renaming %s failed: %s\n", properties_path_renamed, strerror(errno)); |
| 118 | return -1; |
| 119 | } else { |
| 120 | legacy_props_path_modified = false; |
| 121 | } |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 122 | } |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 123 | |
| 124 | return 0; |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 125 | } |
lambdadroid | c4faea8 | 2018-09-26 22:56:51 +0200 | [diff] [blame] | 126 | #endif |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 127 | |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 128 | static int Install_Theme(const char* path, ZipWrap *Zip) { |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 129 | #ifdef TW_OEM_BUILD // We don't do custom themes in OEM builds |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 130 | Zip->Close(); |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 131 | return INSTALL_CORRUPT; |
| 132 | #else |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 133 | if (!Zip->EntryExists("ui.xml")) { |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 134 | return INSTALL_CORRUPT; |
| 135 | } |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 136 | Zip->Close(); |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 137 | if (!PartitionManager.Mount_Settings_Storage(true)) |
| 138 | return INSTALL_ERROR; |
| 139 | string theme_path = DataManager::GetSettingsStoragePath(); |
| 140 | theme_path += "/TWRP/theme"; |
| 141 | if (!TWFunc::Path_Exists(theme_path)) { |
| 142 | if (!TWFunc::Recursive_Mkdir(theme_path)) { |
| 143 | return INSTALL_ERROR; |
| 144 | } |
| 145 | } |
| 146 | theme_path += "/ui.zip"; |
| 147 | if (TWFunc::copy_file(path, theme_path, 0644) != 0) { |
| 148 | return INSTALL_ERROR; |
| 149 | } |
| 150 | LOGINFO("Installing custom theme '%s' to '%s'\n", path, theme_path.c_str()); |
| 151 | PageManager::RequestReload(); |
| 152 | return INSTALL_SUCCESS; |
| 153 | #endif |
| 154 | } |
| 155 | |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 156 | static int Prepare_Update_Binary(const char *path, ZipWrap *Zip, int* wipe_cache) { |
| 157 | if (!Zip->ExtractEntry(ASSUMED_UPDATE_BINARY_NAME, TMP_UPDATER_BINARY_PATH, 0755)) { |
| 158 | Zip->Close(); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 159 | LOGERR("Could not extract '%s'\n", ASSUMED_UPDATE_BINARY_NAME); |
| 160 | return INSTALL_ERROR; |
| 161 | } |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 162 | |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 163 | // If exists, extract file_contexts from the zip file |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 164 | if (!Zip->EntryExists("file_contexts")) { |
| 165 | Zip->Close(); |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 166 | LOGINFO("Zip does not contain SELinux file_contexts file in its root.\n"); |
| 167 | } else { |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 168 | const string output_filename = "/file_contexts"; |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 169 | LOGINFO("Zip contains SELinux file_contexts file in its root. Extracting to %s\n", output_filename.c_str()); |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 170 | if (!Zip->ExtractEntry("file_contexts", output_filename, 0644)) { |
| 171 | Zip->Close(); |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 172 | LOGERR("Could not extract '%s'\n", output_filename.c_str()); |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 173 | return INSTALL_ERROR; |
| 174 | } |
| 175 | } |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 176 | Zip->Close(); |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 177 | return INSTALL_SUCCESS; |
| 178 | } |
| 179 | |
lambdadroid | c4faea8 | 2018-09-26 22:56:51 +0200 | [diff] [blame] | 180 | #ifndef TW_NO_LEGACY_PROPS |
nkk71 | b4c3591 | 2017-10-11 23:39:10 +0300 | [diff] [blame] | 181 | static bool update_binary_has_legacy_properties(const char *binary) { |
| 182 | const char str_to_match[] = "ANDROID_PROPERTY_WORKSPACE"; |
| 183 | int len_to_match = sizeof(str_to_match) - 1; |
| 184 | bool found = false; |
| 185 | |
| 186 | int fd = open(binary, O_RDONLY); |
| 187 | if (fd < 0) { |
| 188 | LOGINFO("has_legacy_properties: Could not open %s: %s!\n", binary, strerror(errno)); |
| 189 | return false; |
| 190 | } |
| 191 | |
| 192 | struct stat finfo; |
| 193 | if (fstat(fd, &finfo) < 0) { |
| 194 | LOGINFO("has_legacy_properties: Could not fstat %d: %s!\n", fd, strerror(errno)); |
| 195 | close(fd); |
| 196 | return false; |
| 197 | } |
| 198 | |
| 199 | void *data = mmap(NULL, finfo.st_size, PROT_READ, MAP_PRIVATE, fd, 0); |
| 200 | if (data == MAP_FAILED) { |
Simon Shi | 8ae2b0d | 2019-03-09 13:01:55 +0800 | [diff] [blame] | 201 | LOGINFO("has_legacy_properties: mmap (size=%zu) failed: %s!\n", (size_t)finfo.st_size, strerror(errno)); |
nkk71 | b4c3591 | 2017-10-11 23:39:10 +0300 | [diff] [blame] | 202 | } else { |
| 203 | if (memmem(data, finfo.st_size, str_to_match, len_to_match)) { |
| 204 | LOGINFO("has_legacy_properties: Found legacy property match!\n"); |
| 205 | found = true; |
| 206 | } |
| 207 | munmap(data, finfo.st_size); |
| 208 | } |
| 209 | close(fd); |
| 210 | |
| 211 | return found; |
| 212 | } |
lambdadroid | c4faea8 | 2018-09-26 22:56:51 +0200 | [diff] [blame] | 213 | #endif |
nkk71 | b4c3591 | 2017-10-11 23:39:10 +0300 | [diff] [blame] | 214 | |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 215 | static int Run_Update_Binary(const char *path, ZipWrap *Zip, int* wipe_cache, zip_type ztype) { |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 216 | int ret_val, pipe_fd[2], status, zip_verify; |
| 217 | char buffer[1024]; |
| 218 | FILE* child_data; |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 219 | |
Matt Mower | 6883d73 | 2014-03-20 17:28:13 -0500 | [diff] [blame] | 220 | #ifndef TW_NO_LEGACY_PROPS |
nkk71 | b4c3591 | 2017-10-11 23:39:10 +0300 | [diff] [blame] | 221 | if (!update_binary_has_legacy_properties(TMP_UPDATER_BINARY_PATH)) { |
| 222 | LOGINFO("Legacy property environment not used in updater.\n"); |
| 223 | } else if (switch_to_legacy_properties() != 0) { /* Set legacy properties */ |
| 224 | LOGERR("Legacy property environment did not initialize successfully. Properties may not be detected.\n"); |
| 225 | } else { |
| 226 | LOGINFO("Legacy property environment initialized.\n"); |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 227 | } |
Matt Mower | 6883d73 | 2014-03-20 17:28:13 -0500 | [diff] [blame] | 228 | #endif |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 229 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 230 | pipe(pipe_fd); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 231 | |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 232 | std::vector<std::string> args; |
| 233 | if (ztype == UPDATE_BINARY_ZIP_TYPE) { |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 234 | ret_val = update_binary_command(path, 0, pipe_fd[1], &args); |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 235 | } else if (ztype == AB_OTA_ZIP_TYPE) { |
| 236 | ret_val = abupdate_binary_command(path, Zip, 0, pipe_fd[1], &args); |
| 237 | } else { |
| 238 | LOGERR("Unknown zip type %i\n", ztype); |
| 239 | ret_val = INSTALL_CORRUPT; |
| 240 | } |
| 241 | if (ret_val) { |
| 242 | close(pipe_fd[0]); |
| 243 | close(pipe_fd[1]); |
| 244 | return ret_val; |
| 245 | } |
| 246 | |
| 247 | // Convert the vector to a NULL-terminated char* array suitable for execv. |
| 248 | const char* chr_args[args.size() + 1]; |
| 249 | chr_args[args.size()] = NULL; |
| 250 | for (size_t i = 0; i < args.size(); i++) |
| 251 | chr_args[i] = args[i].c_str(); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 252 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 253 | pid_t pid = fork(); |
| 254 | if (pid == 0) { |
| 255 | close(pipe_fd[0]); |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 256 | execve(chr_args[0], const_cast<char**>(chr_args), environ); |
| 257 | printf("E:Can't execute '%s': %s\n", chr_args[0], strerror(errno)); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 258 | _exit(-1); |
| 259 | } |
| 260 | close(pipe_fd[1]); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 261 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 262 | *wipe_cache = 0; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 263 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 264 | DataManager::GetValue(TW_SIGNED_ZIP_VERIFY_VAR, zip_verify); |
| 265 | child_data = fdopen(pipe_fd[0], "r"); |
| 266 | while (fgets(buffer, sizeof(buffer), child_data) != NULL) { |
| 267 | char* command = strtok(buffer, " \n"); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 268 | if (command == NULL) { |
| 269 | continue; |
| 270 | } else if (strcmp(command, "progress") == 0) { |
| 271 | char* fraction_char = strtok(NULL, " \n"); |
| 272 | char* seconds_char = strtok(NULL, " \n"); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 273 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 274 | float fraction_float = strtof(fraction_char, NULL); |
| 275 | int seconds_float = strtol(seconds_char, NULL, 10); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 276 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 277 | if (zip_verify) |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 278 | DataManager::ShowProgress(fraction_float * (1 - VERIFICATION_PROGRESS_FRAC), seconds_float); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 279 | else |
| 280 | DataManager::ShowProgress(fraction_float, seconds_float); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 281 | } else if (strcmp(command, "set_progress") == 0) { |
| 282 | char* fraction_char = strtok(NULL, " \n"); |
| 283 | float fraction_float = strtof(fraction_char, NULL); |
| 284 | DataManager::SetProgress(fraction_float); |
| 285 | } else if (strcmp(command, "ui_print") == 0) { |
| 286 | char* display_value = strtok(NULL, "\n"); |
| 287 | if (display_value) { |
| 288 | gui_print("%s", display_value); |
| 289 | } else { |
| 290 | gui_print("\n"); |
| 291 | } |
| 292 | } else if (strcmp(command, "wipe_cache") == 0) { |
| 293 | *wipe_cache = 1; |
| 294 | } else if (strcmp(command, "clear_display") == 0) { |
| 295 | // Do nothing, not supported by TWRP |
Ethan Yonker | 072c8d8 | 2016-08-26 22:22:24 -0500 | [diff] [blame] | 296 | } else if (strcmp(command, "log") == 0) { |
| 297 | printf("%s\n", strtok(NULL, "\n")); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 298 | } else { |
| 299 | LOGERR("unknown command [%s]\n", command); |
| 300 | } |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 301 | } |
| 302 | fclose(child_data); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 303 | |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 304 | int waitrc = TWFunc::Wait_For_Child(pid, &status, "Updater"); |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 305 | |
Matt Mower | 6883d73 | 2014-03-20 17:28:13 -0500 | [diff] [blame] | 306 | #ifndef TW_NO_LEGACY_PROPS |
nkk71 | b4c3591 | 2017-10-11 23:39:10 +0300 | [diff] [blame] | 307 | /* Unset legacy properties */ |
| 308 | if (legacy_props_path_modified) { |
| 309 | if (switch_to_new_properties() != 0) { |
| 310 | LOGERR("Legacy property environment did not disable successfully. Legacy properties may still be in use.\n"); |
| 311 | } else { |
| 312 | LOGINFO("Legacy property environment disabled.\n"); |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 313 | } |
| 314 | } |
Matt Mower | 6883d73 | 2014-03-20 17:28:13 -0500 | [diff] [blame] | 315 | #endif |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 316 | |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 317 | if (waitrc != 0) |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 318 | return INSTALL_ERROR; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 319 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 320 | return INSTALL_SUCCESS; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 321 | } |
| 322 | |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 323 | int TWinstall_zip(const char* path, int* wipe_cache) { |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 324 | int ret_val, zip_verify = 1; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 325 | |
Ethan Yonker | 2481342 | 2014-11-07 17:19:07 -0600 | [diff] [blame] | 326 | if (strcmp(path, "error") == 0) { |
| 327 | LOGERR("Failed to get adb sideload file: '%s'\n", path); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 328 | return INSTALL_CORRUPT; |
Matt Mower | d5c1a92 | 2014-04-15 12:50:58 -0500 | [diff] [blame] | 329 | } |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 330 | |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 331 | gui_msg(Msg("installing_zip=Installing zip file '{1}'")(path)); |
Ethan Yonker | 2481342 | 2014-11-07 17:19:07 -0600 | [diff] [blame] | 332 | if (strlen(path) < 9 || strncmp(path, "/sideload", 9) != 0) { |
bigbiff bigbiff | 56cf564 | 2016-08-19 17:43:45 -0400 | [diff] [blame] | 333 | string digest_str; |
| 334 | string Full_Filename = path; |
| 335 | string digest_file = path; |
steadfasterX | 10d7475 | 2018-07-06 15:40:39 +0200 | [diff] [blame] | 336 | string defmd5file = digest_file + ".md5sum"; |
| 337 | |
| 338 | if (TWFunc::Path_Exists(defmd5file)) { |
| 339 | digest_file += ".md5sum"; |
| 340 | } |
| 341 | else { |
| 342 | digest_file += ".md5"; |
| 343 | } |
bigbiff bigbiff | 56cf564 | 2016-08-19 17:43:45 -0400 | [diff] [blame] | 344 | |
| 345 | gui_msg("check_for_digest=Checking for Digest file..."); |
| 346 | if (!TWFunc::Path_Exists(digest_file)) { |
| 347 | gui_msg("no_digest=Skipping Digest check: no Digest file found"); |
| 348 | } |
| 349 | else { |
| 350 | if (TWFunc::read_file(digest_file, digest_str) != 0) { |
| 351 | LOGERR("Skipping MD5 check: MD5 file unreadable\n"); |
| 352 | } |
| 353 | else { |
| 354 | twrpDigest *digest = new twrpMD5(); |
| 355 | if (!twrpDigestDriver::stream_file_to_digest(Full_Filename, digest)) { |
| 356 | delete digest; |
| 357 | return INSTALL_CORRUPT; |
| 358 | } |
| 359 | string digest_check = digest->return_digest_string(); |
| 360 | if (digest_str == digest_check) { |
| 361 | gui_msg(Msg("digest_matched=Digest matched for '{1}'.")(path)); |
| 362 | } |
| 363 | else { |
| 364 | LOGERR("Aborting zip install: Digest verification failed\n"); |
| 365 | delete digest; |
| 366 | return INSTALL_CORRUPT; |
| 367 | } |
| 368 | delete digest; |
| 369 | } |
Ethan Yonker | 2481342 | 2014-11-07 17:19:07 -0600 | [diff] [blame] | 370 | } |
| 371 | } |
| 372 | |
Ethan Yonker | d5801c5 | 2014-04-14 08:59:35 -0500 | [diff] [blame] | 373 | #ifndef TW_OEM_BUILD |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 374 | DataManager::GetValue(TW_SIGNED_ZIP_VERIFY_VAR, zip_verify); |
Ethan Yonker | d5801c5 | 2014-04-14 08:59:35 -0500 | [diff] [blame] | 375 | #endif |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 376 | DataManager::SetProgress(0); |
Ethan Yonker | f96087e | 2014-11-07 10:38:51 -0600 | [diff] [blame] | 377 | |
| 378 | MemMapping map; |
Ethan Yonker | ecbd3e8 | 2017-12-14 14:43:59 -0600 | [diff] [blame] | 379 | #ifdef USE_MINZIP |
Ethan Yonker | f96087e | 2014-11-07 10:38:51 -0600 | [diff] [blame] | 380 | if (sysMapFile(path, &map) != 0) { |
Ethan Yonker | ecbd3e8 | 2017-12-14 14:43:59 -0600 | [diff] [blame] | 381 | #else |
| 382 | if (!map.MapFile(path)) { |
| 383 | #endif |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 384 | gui_msg(Msg(msg::kError, "fail_sysmap=Failed to map file '{1}'")(path)); |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 385 | return -1; |
| 386 | } |
Ethan Yonker | f96087e | 2014-11-07 10:38:51 -0600 | [diff] [blame] | 387 | |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 388 | if (zip_verify) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 389 | gui_msg("verify_zip_sig=Verifying zip signature..."); |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 390 | #ifdef USE_OLD_VERIFIER |
Ethan Yonker | f96087e | 2014-11-07 10:38:51 -0600 | [diff] [blame] | 391 | ret_val = verify_file(map.addr, map.length); |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 392 | #else |
| 393 | std::vector<Certificate> loadedKeys; |
| 394 | if (!load_keys("/res/keys", loadedKeys)) { |
| 395 | LOGINFO("Failed to load keys"); |
| 396 | gui_err("verify_zip_fail=Zip signature verification failed!"); |
Ethan Yonker | ecbd3e8 | 2017-12-14 14:43:59 -0600 | [diff] [blame] | 397 | #ifdef USE_MINZIP |
| 398 | sysReleaseMap(&map); |
| 399 | #endif |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 400 | return -1; |
| 401 | } |
| 402 | ret_val = verify_file(map.addr, map.length, loadedKeys, std::bind(&DataManager::SetProgress, std::placeholders::_1)); |
| 403 | #endif |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 404 | if (ret_val != VERIFY_SUCCESS) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 405 | LOGINFO("Zip signature verification failed: %i\n", ret_val); |
| 406 | gui_err("verify_zip_fail=Zip signature verification failed!"); |
Ethan Yonker | ecbd3e8 | 2017-12-14 14:43:59 -0600 | [diff] [blame] | 407 | #ifdef USE_MINZIP |
Ethan Yonker | f9796a4 | 2014-11-08 07:28:03 -0600 | [diff] [blame] | 408 | sysReleaseMap(&map); |
Ethan Yonker | ecbd3e8 | 2017-12-14 14:43:59 -0600 | [diff] [blame] | 409 | #endif |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 410 | return -1; |
Ethan Yonker | 738be7a | 2014-12-10 11:40:43 -0600 | [diff] [blame] | 411 | } else { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 412 | gui_msg("verify_zip_done=Zip signature verified successfully."); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 413 | } |
| 414 | } |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 415 | ZipWrap Zip; |
| 416 | if (!Zip.Open(path, &map)) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 417 | gui_err("zip_corrupt=Zip file is corrupt!"); |
Ethan Yonker | ecbd3e8 | 2017-12-14 14:43:59 -0600 | [diff] [blame] | 418 | #ifdef USE_MINZIP |
| 419 | sysReleaseMap(&map); |
| 420 | #endif |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 421 | return INSTALL_CORRUPT; |
| 422 | } |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 423 | |
Ethan Yonker | 072c8d8 | 2016-08-26 22:22:24 -0500 | [diff] [blame] | 424 | time_t start, stop; |
| 425 | time(&start); |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 426 | if (Zip.EntryExists(ASSUMED_UPDATE_BINARY_NAME)) { |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 427 | LOGINFO("Update binary zip\n"); |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 428 | // Additionally verify the compatibility of the package. |
| 429 | if (!verify_package_compatibility(&Zip)) { |
| 430 | gui_err("zip_compatible_err=Zip Treble compatibility error!"); |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 431 | Zip.Close(); |
Ethan Yonker | ecbd3e8 | 2017-12-14 14:43:59 -0600 | [diff] [blame] | 432 | #ifdef USE_MINZIP |
| 433 | sysReleaseMap(&map); |
| 434 | #endif |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 435 | ret_val = INSTALL_CORRUPT; |
| 436 | } else { |
| 437 | ret_val = Prepare_Update_Binary(path, &Zip, wipe_cache); |
| 438 | if (ret_val == INSTALL_SUCCESS) |
| 439 | ret_val = Run_Update_Binary(path, &Zip, wipe_cache, UPDATE_BINARY_ZIP_TYPE); |
| 440 | } |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 441 | } else { |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 442 | if (Zip.EntryExists(AB_OTA)) { |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 443 | LOGINFO("AB zip\n"); |
| 444 | ret_val = Run_Update_Binary(path, &Zip, wipe_cache, AB_OTA_ZIP_TYPE); |
| 445 | } else { |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 446 | if (Zip.EntryExists("ui.xml")) { |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 447 | LOGINFO("TWRP theme zip\n"); |
| 448 | ret_val = Install_Theme(path, &Zip); |
| 449 | } else { |
Ethan Yonker | 8373cfe | 2017-09-08 06:50:54 -0500 | [diff] [blame] | 450 | Zip.Close(); |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 451 | ret_val = INSTALL_CORRUPT; |
| 452 | } |
| 453 | } |
| 454 | } |
Ethan Yonker | 072c8d8 | 2016-08-26 22:22:24 -0500 | [diff] [blame] | 455 | time(&stop); |
| 456 | int total_time = (int) difftime(stop, start); |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 457 | if (ret_val == INSTALL_CORRUPT) { |
Ethan Yonker | 941a899 | 2016-12-05 09:04:30 -0600 | [diff] [blame] | 458 | gui_err("invalid_zip_format=Invalid zip file format!"); |
Ethan Yonker | 072c8d8 | 2016-08-26 22:22:24 -0500 | [diff] [blame] | 459 | } else { |
| 460 | LOGINFO("Install took %i second(s).\n", total_time); |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 461 | } |
Ethan Yonker | ecbd3e8 | 2017-12-14 14:43:59 -0600 | [diff] [blame] | 462 | #ifdef USE_MINZIP |
Ethan Yonker | f9796a4 | 2014-11-08 07:28:03 -0600 | [diff] [blame] | 463 | sysReleaseMap(&map); |
Ethan Yonker | ecbd3e8 | 2017-12-14 14:43:59 -0600 | [diff] [blame] | 464 | #endif |
Ethan Yonker | f9796a4 | 2014-11-08 07:28:03 -0600 | [diff] [blame] | 465 | return ret_val; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 466 | } |