Dees Troy | 3be70a8 | 2013-10-22 14:25:12 +0000 | [diff] [blame] | 1 | /* |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 2 | Copyright 2012 to 2016 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 | |
| 19 | #include <ctype.h> |
| 20 | #include <errno.h> |
| 21 | #include <fcntl.h> |
| 22 | #include <limits.h> |
| 23 | #include <sys/stat.h> |
| 24 | #include <sys/wait.h> |
| 25 | #include <unistd.h> |
| 26 | |
| 27 | #include <string.h> |
| 28 | #include <stdio.h> |
| 29 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 30 | #include "twcommon.h" |
Ethan Yonker | 75bf041 | 2014-11-21 13:54:27 -0600 | [diff] [blame] | 31 | #include "mtdutils/mounts.h" |
| 32 | #include "mtdutils/mtdutils.h" |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 33 | #include "minzip/SysUtil.h" |
| 34 | #include "minzip/Zip.h" |
Ethan Yonker | f117962 | 2016-08-25 15:32:21 -0500 | [diff] [blame] | 35 | #ifdef USE_OLD_VERIFIER |
Ethan Yonker | 4bf259f | 2016-08-29 11:50:34 -0500 | [diff] [blame] | 36 | #include "verifier24/verifier.h" |
Ethan Yonker | f117962 | 2016-08-25 15:32:21 -0500 | [diff] [blame] | 37 | #else |
Ethan Yonker | 75bf041 | 2014-11-21 13:54:27 -0600 | [diff] [blame] | 38 | #include "verifier.h" |
Ethan Yonker | f117962 | 2016-08-25 15:32:21 -0500 | [diff] [blame] | 39 | #endif |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 40 | #include "variables.h" |
| 41 | #include "data.hpp" |
| 42 | #include "partitions.hpp" |
bigbiff bigbiff | cdcfee4 | 2013-02-27 21:11:26 -0500 | [diff] [blame] | 43 | #include "twrpDigest.hpp" |
Dees_Troy | 38bd760 | 2012-09-14 13:33:53 -0400 | [diff] [blame] | 44 | #include "twrp-functions.hpp" |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 45 | #include "gui/gui.hpp" |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 46 | #include "gui/pages.hpp" |
Ethan Yonker | f117962 | 2016-08-25 15:32:21 -0500 | [diff] [blame] | 47 | #include "legacy_property_service.h" |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 48 | extern "C" { |
| 49 | #include "gui/gui.h" |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 50 | } |
| 51 | |
| 52 | static const char* properties_path = "/dev/__properties__"; |
| 53 | static const char* properties_path_renamed = "/dev/__properties_kk__"; |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 54 | static bool legacy_props_env_initd = false; |
| 55 | static bool legacy_props_path_modified = false; |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 56 | |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 57 | // 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] | 58 | static int switch_to_legacy_properties() |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 59 | { |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 60 | if (!legacy_props_env_initd) { |
| 61 | if (legacy_properties_init() != 0) |
| 62 | return -1; |
| 63 | |
| 64 | char tmp[32]; |
| 65 | int propfd, propsz; |
| 66 | legacy_get_property_workspace(&propfd, &propsz); |
| 67 | sprintf(tmp, "%d,%d", dup(propfd), propsz); |
| 68 | setenv("ANDROID_PROPERTY_WORKSPACE", tmp, 1); |
| 69 | legacy_props_env_initd = true; |
| 70 | } |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 71 | |
| 72 | if (TWFunc::Path_Exists(properties_path)) { |
| 73 | // 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] | 74 | if (rename(properties_path, properties_path_renamed) != 0) { |
| 75 | LOGERR("Renaming %s failed: %s\n", properties_path, strerror(errno)); |
| 76 | return -1; |
| 77 | } else { |
| 78 | legacy_props_path_modified = true; |
| 79 | } |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 80 | } |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 81 | |
| 82 | return 0; |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 83 | } |
| 84 | |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 85 | static int switch_to_new_properties() |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 86 | { |
| 87 | if (TWFunc::Path_Exists(properties_path_renamed)) { |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 88 | if (rename(properties_path_renamed, properties_path) != 0) { |
| 89 | LOGERR("Renaming %s failed: %s\n", properties_path_renamed, strerror(errno)); |
| 90 | return -1; |
| 91 | } else { |
| 92 | legacy_props_path_modified = false; |
| 93 | } |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 94 | } |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 95 | |
| 96 | return 0; |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 97 | } |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 98 | |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 99 | static int Install_Theme(const char* path, ZipArchive *Zip) { |
| 100 | #ifdef TW_OEM_BUILD // We don't do custom themes in OEM builds |
| 101 | mzCloseZipArchive(Zip); |
| 102 | return INSTALL_CORRUPT; |
| 103 | #else |
| 104 | const ZipEntry* xml_location = mzFindZipEntry(Zip, "ui.xml"); |
| 105 | |
| 106 | mzCloseZipArchive(Zip); |
| 107 | if (xml_location == NULL) { |
| 108 | return INSTALL_CORRUPT; |
| 109 | } |
| 110 | if (!PartitionManager.Mount_Settings_Storage(true)) |
| 111 | return INSTALL_ERROR; |
| 112 | string theme_path = DataManager::GetSettingsStoragePath(); |
| 113 | theme_path += "/TWRP/theme"; |
| 114 | if (!TWFunc::Path_Exists(theme_path)) { |
| 115 | if (!TWFunc::Recursive_Mkdir(theme_path)) { |
| 116 | return INSTALL_ERROR; |
| 117 | } |
| 118 | } |
| 119 | theme_path += "/ui.zip"; |
| 120 | if (TWFunc::copy_file(path, theme_path, 0644) != 0) { |
| 121 | return INSTALL_ERROR; |
| 122 | } |
| 123 | LOGINFO("Installing custom theme '%s' to '%s'\n", path, theme_path.c_str()); |
| 124 | PageManager::RequestReload(); |
| 125 | return INSTALL_SUCCESS; |
| 126 | #endif |
| 127 | } |
| 128 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 129 | static int Run_Update_Binary(const char *path, ZipArchive *Zip, int* wipe_cache) { |
| 130 | const ZipEntry* binary_location = mzFindZipEntry(Zip, ASSUMED_UPDATE_BINARY_NAME); |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 131 | string Temp_Binary = "/tmp/updater"; // Note: AOSP names it /tmp/update_binary (yes, with "_") |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 132 | int binary_fd, ret_val, pipe_fd[2], status, zip_verify; |
| 133 | char buffer[1024]; |
| 134 | const char** args = (const char**)malloc(sizeof(char*) * 5); |
| 135 | FILE* child_data; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 136 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 137 | if (binary_location == NULL) { |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 138 | return INSTALL_CORRUPT; |
| 139 | } |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 140 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 141 | // Delete any existing updater |
| 142 | if (TWFunc::Path_Exists(Temp_Binary) && unlink(Temp_Binary.c_str()) != 0) { |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 143 | LOGINFO("Unable to unlink '%s': %s\n", Temp_Binary.c_str(), strerror(errno)); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 144 | } |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 145 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 146 | binary_fd = creat(Temp_Binary.c_str(), 0755); |
| 147 | if (binary_fd < 0) { |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 148 | LOGERR("Could not create file for updater extract in '%s': %s\n", Temp_Binary.c_str(), strerror(errno)); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 149 | mzCloseZipArchive(Zip); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 150 | return INSTALL_ERROR; |
| 151 | } |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 152 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 153 | ret_val = mzExtractZipEntryToFile(Zip, binary_location, binary_fd); |
| 154 | close(binary_fd); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 155 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 156 | if (!ret_val) { |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 157 | mzCloseZipArchive(Zip); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 158 | LOGERR("Could not extract '%s'\n", ASSUMED_UPDATE_BINARY_NAME); |
| 159 | return INSTALL_ERROR; |
| 160 | } |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 161 | |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 162 | // If exists, extract file_contexts from the zip file |
| 163 | const ZipEntry* selinx_contexts = mzFindZipEntry(Zip, "file_contexts"); |
| 164 | if (selinx_contexts == NULL) { |
| 165 | mzCloseZipArchive(Zip); |
| 166 | LOGINFO("Zip does not contain SELinux file_contexts file in its root.\n"); |
| 167 | } else { |
| 168 | string output_filename = "/file_contexts"; |
| 169 | LOGINFO("Zip contains SELinux file_contexts file in its root. Extracting to %s\n", output_filename.c_str()); |
| 170 | // Delete any file_contexts |
| 171 | if (TWFunc::Path_Exists(output_filename) && unlink(output_filename.c_str()) != 0) { |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 172 | LOGINFO("Unable to unlink '%s': %s\n", output_filename.c_str(), strerror(errno)); |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 173 | } |
| 174 | |
| 175 | int file_contexts_fd = creat(output_filename.c_str(), 0644); |
| 176 | if (file_contexts_fd < 0) { |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 177 | LOGERR("Could not extract to '%s': %s\n", output_filename.c_str(), strerror(errno)); |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 178 | mzCloseZipArchive(Zip); |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 179 | return INSTALL_ERROR; |
| 180 | } |
| 181 | |
| 182 | ret_val = mzExtractZipEntryToFile(Zip, selinx_contexts, file_contexts_fd); |
| 183 | close(file_contexts_fd); |
| 184 | |
| 185 | if (!ret_val) { |
| 186 | mzCloseZipArchive(Zip); |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 187 | LOGERR("Could not extract '%s'\n", output_filename.c_str()); |
Dees_Troy | 512376c | 2013-09-03 19:39:41 +0000 | [diff] [blame] | 188 | return INSTALL_ERROR; |
| 189 | } |
| 190 | } |
| 191 | mzCloseZipArchive(Zip); |
| 192 | |
Matt Mower | 6883d73 | 2014-03-20 17:28:13 -0500 | [diff] [blame] | 193 | #ifndef TW_NO_LEGACY_PROPS |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 194 | /* Set legacy properties */ |
| 195 | if (switch_to_legacy_properties() != 0) { |
| 196 | LOGERR("Legacy property environment did not initialize successfully. Properties may not be detected.\n"); |
| 197 | } else { |
| 198 | LOGINFO("Legacy property environment initialized.\n"); |
| 199 | } |
Matt Mower | 6883d73 | 2014-03-20 17:28:13 -0500 | [diff] [blame] | 200 | #endif |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 201 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 202 | pipe(pipe_fd); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 203 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 204 | args[0] = Temp_Binary.c_str(); |
| 205 | args[1] = EXPAND(RECOVERY_API_VERSION); |
| 206 | char* temp = (char*)malloc(10); |
| 207 | sprintf(temp, "%d", pipe_fd[1]); |
| 208 | args[2] = temp; |
| 209 | args[3] = (char*)path; |
| 210 | args[4] = NULL; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 211 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 212 | pid_t pid = fork(); |
| 213 | if (pid == 0) { |
| 214 | close(pipe_fd[0]); |
that | 7e303cf | 2014-03-06 07:57:43 +0100 | [diff] [blame] | 215 | execve(Temp_Binary.c_str(), (char* const*)args, environ); |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 216 | printf("E:Can't execute '%s': %s\n", Temp_Binary.c_str(), strerror(errno)); |
Matt Mower | 13a8f0b | 2015-09-26 15:40:03 -0500 | [diff] [blame] | 217 | free(temp); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 218 | _exit(-1); |
| 219 | } |
| 220 | close(pipe_fd[1]); |
Matt Mower | 13a8f0b | 2015-09-26 15:40:03 -0500 | [diff] [blame] | 221 | free(temp); |
| 222 | temp = NULL; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 223 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 224 | *wipe_cache = 0; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 225 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 226 | DataManager::GetValue(TW_SIGNED_ZIP_VERIFY_VAR, zip_verify); |
| 227 | child_data = fdopen(pipe_fd[0], "r"); |
| 228 | while (fgets(buffer, sizeof(buffer), child_data) != NULL) { |
| 229 | char* command = strtok(buffer, " \n"); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 230 | if (command == NULL) { |
| 231 | continue; |
| 232 | } else if (strcmp(command, "progress") == 0) { |
| 233 | char* fraction_char = strtok(NULL, " \n"); |
| 234 | char* seconds_char = strtok(NULL, " \n"); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 235 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 236 | float fraction_float = strtof(fraction_char, NULL); |
| 237 | int seconds_float = strtol(seconds_char, NULL, 10); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 238 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 239 | if (zip_verify) |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 240 | DataManager::ShowProgress(fraction_float * (1 - VERIFICATION_PROGRESS_FRACTION), seconds_float); |
| 241 | else |
| 242 | DataManager::ShowProgress(fraction_float, seconds_float); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 243 | } else if (strcmp(command, "set_progress") == 0) { |
| 244 | char* fraction_char = strtok(NULL, " \n"); |
| 245 | float fraction_float = strtof(fraction_char, NULL); |
| 246 | DataManager::SetProgress(fraction_float); |
| 247 | } else if (strcmp(command, "ui_print") == 0) { |
| 248 | char* display_value = strtok(NULL, "\n"); |
| 249 | if (display_value) { |
| 250 | gui_print("%s", display_value); |
| 251 | } else { |
| 252 | gui_print("\n"); |
| 253 | } |
| 254 | } else if (strcmp(command, "wipe_cache") == 0) { |
| 255 | *wipe_cache = 1; |
| 256 | } else if (strcmp(command, "clear_display") == 0) { |
| 257 | // Do nothing, not supported by TWRP |
Ethan Yonker | 072c8d8 | 2016-08-26 22:22:24 -0500 | [diff] [blame] | 258 | } else if (strcmp(command, "log") == 0) { |
| 259 | printf("%s\n", strtok(NULL, "\n")); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 260 | } else { |
| 261 | LOGERR("unknown command [%s]\n", command); |
| 262 | } |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 263 | } |
| 264 | fclose(child_data); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 265 | |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 266 | int waitrc = TWFunc::Wait_For_Child(pid, &status, "Updater"); |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 267 | |
Matt Mower | 6883d73 | 2014-03-20 17:28:13 -0500 | [diff] [blame] | 268 | #ifndef TW_NO_LEGACY_PROPS |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 269 | /* Unset legacy properties */ |
| 270 | if (legacy_props_path_modified) { |
| 271 | if (switch_to_new_properties() != 0) { |
| 272 | LOGERR("Legacy property environment did not disable successfully. Legacy properties may still be in use.\n"); |
| 273 | } else { |
| 274 | LOGINFO("Legacy property environment disabled.\n"); |
| 275 | } |
| 276 | } |
Matt Mower | 6883d73 | 2014-03-20 17:28:13 -0500 | [diff] [blame] | 277 | #endif |
Matt Mower | cdd3b33 | 2014-03-27 14:38:48 -0500 | [diff] [blame] | 278 | |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 279 | if (waitrc != 0) |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 280 | return INSTALL_ERROR; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 281 | |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 282 | return INSTALL_SUCCESS; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 283 | } |
| 284 | |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 285 | extern "C" int TWinstall_zip(const char* path, int* wipe_cache) { |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 286 | int ret_val, zip_verify = 1; |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 287 | ZipArchive Zip; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 288 | |
Ethan Yonker | 2481342 | 2014-11-07 17:19:07 -0600 | [diff] [blame] | 289 | if (strcmp(path, "error") == 0) { |
| 290 | LOGERR("Failed to get adb sideload file: '%s'\n", path); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 291 | return INSTALL_CORRUPT; |
Matt Mower | d5c1a92 | 2014-04-15 12:50:58 -0500 | [diff] [blame] | 292 | } |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 293 | |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 294 | gui_msg(Msg("installing_zip=Installing zip file '{1}'")(path)); |
Ethan Yonker | 2481342 | 2014-11-07 17:19:07 -0600 | [diff] [blame] | 295 | if (strlen(path) < 9 || strncmp(path, "/sideload", 9) != 0) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 296 | gui_msg("check_for_md5=Checking for MD5 file..."); |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 297 | twrpDigest md5sum; |
| 298 | md5sum.setfn(path); |
James Christopher Adduono | 79ae093 | 2016-10-25 02:18:32 -0400 | [diff] [blame] | 299 | switch (md5sum.verify_md5digest()) { |
| 300 | case MD5_OK: |
| 301 | gui_msg(Msg("md5_matched=MD5 matched for '{1}'.")(path)); |
| 302 | break; |
| 303 | case MD5_NOT_FOUND: |
| 304 | gui_msg("no_md5=Skipping MD5 check: no MD5 file found"); |
| 305 | break; |
| 306 | case MD5_FILE_UNREADABLE: |
| 307 | LOGERR("Skipping MD5 check: MD5 file unreadable\n"); |
| 308 | break; |
| 309 | case MD5_MATCH_FAIL: // md5 did not match |
| 310 | LOGERR("Aborting zip install: MD5 verification failed\n"); |
Ethan Yonker | 2481342 | 2014-11-07 17:19:07 -0600 | [diff] [blame] | 311 | return INSTALL_CORRUPT; |
| 312 | } |
| 313 | } |
| 314 | |
Ethan Yonker | d5801c5 | 2014-04-14 08:59:35 -0500 | [diff] [blame] | 315 | #ifndef TW_OEM_BUILD |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 316 | DataManager::GetValue(TW_SIGNED_ZIP_VERIFY_VAR, zip_verify); |
Ethan Yonker | d5801c5 | 2014-04-14 08:59:35 -0500 | [diff] [blame] | 317 | #endif |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 318 | DataManager::SetProgress(0); |
Ethan Yonker | f96087e | 2014-11-07 10:38:51 -0600 | [diff] [blame] | 319 | |
| 320 | MemMapping map; |
| 321 | if (sysMapFile(path, &map) != 0) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 322 | gui_msg(Msg(msg::kError, "fail_sysmap=Failed to map file '{1}'")(path)); |
that | 5064048 | 2015-08-30 12:08:05 +0200 | [diff] [blame] | 323 | return -1; |
| 324 | } |
Ethan Yonker | f96087e | 2014-11-07 10:38:51 -0600 | [diff] [blame] | 325 | |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 326 | if (zip_verify) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 327 | gui_msg("verify_zip_sig=Verifying zip signature..."); |
Ethan Yonker | f96087e | 2014-11-07 10:38:51 -0600 | [diff] [blame] | 328 | ret_val = verify_file(map.addr, map.length); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 329 | if (ret_val != VERIFY_SUCCESS) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 330 | LOGINFO("Zip signature verification failed: %i\n", ret_val); |
| 331 | gui_err("verify_zip_fail=Zip signature verification failed!"); |
Ethan Yonker | f9796a4 | 2014-11-08 07:28:03 -0600 | [diff] [blame] | 332 | sysReleaseMap(&map); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 333 | return -1; |
Ethan Yonker | 738be7a | 2014-12-10 11:40:43 -0600 | [diff] [blame] | 334 | } else { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 335 | gui_msg("verify_zip_done=Zip signature verified successfully."); |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 336 | } |
| 337 | } |
Ethan Yonker | f96087e | 2014-11-07 10:38:51 -0600 | [diff] [blame] | 338 | ret_val = mzOpenZipArchive(map.addr, map.length, &Zip); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 339 | if (ret_val != 0) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 340 | gui_err("zip_corrupt=Zip file is corrupt!"); |
Ethan Yonker | f9796a4 | 2014-11-08 07:28:03 -0600 | [diff] [blame] | 341 | sysReleaseMap(&map); |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 342 | return INSTALL_CORRUPT; |
| 343 | } |
Ethan Yonker | 072c8d8 | 2016-08-26 22:22:24 -0500 | [diff] [blame] | 344 | time_t start, stop; |
| 345 | time(&start); |
Ethan Yonker | f9796a4 | 2014-11-08 07:28:03 -0600 | [diff] [blame] | 346 | ret_val = Run_Update_Binary(path, &Zip, wipe_cache); |
Ethan Yonker | 072c8d8 | 2016-08-26 22:22:24 -0500 | [diff] [blame] | 347 | time(&stop); |
| 348 | int total_time = (int) difftime(stop, start); |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 349 | if (ret_val == INSTALL_CORRUPT) { |
| 350 | // If no updater binary is found, check for ui.xml |
| 351 | ret_val = Install_Theme(path, &Zip); |
| 352 | if (ret_val == INSTALL_CORRUPT) |
| 353 | gui_msg(Msg(msg::kError, "no_updater_binary=Could not find '{1}' in the zip file.")(ASSUMED_UPDATE_BINARY_NAME)); |
Ethan Yonker | 072c8d8 | 2016-08-26 22:22:24 -0500 | [diff] [blame] | 354 | } else { |
| 355 | LOGINFO("Install took %i second(s).\n", total_time); |
Ethan Yonker | 20eb0bc | 2016-03-22 14:23:28 -0500 | [diff] [blame] | 356 | } |
Ethan Yonker | f9796a4 | 2014-11-08 07:28:03 -0600 | [diff] [blame] | 357 | sysReleaseMap(&map); |
| 358 | return ret_val; |
Dees_Troy | 32c8eb8 | 2012-09-11 15:28:06 -0400 | [diff] [blame] | 359 | } |