PawletOS/android_bootable_recovery
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c1bb76ea742575c555b79ba55bcef89abdab37ae
android_bootable_recovery/twinstall.cpp
bigbiff ad58e1bfae repack: move sbin to /system ramdisk and update repacking 
for android-10

This will support updating the ramdisk to a different
compression format and co-exist with magisk.

We are also cleaning up and removing non android-10
api makefile actions.

We are also moving twrp repacking to its own class. We
check the new ramdisk format and if it's different
we have magisk compress using the new ramdisk format.

Change-Id: I770030aae7797e75817178b2f0fccd9f39dc23af
2020-09-08 10:08:33 -04:00

487 lines
14 KiB
C++
Executable File
Raw Blame History

/*
Copyright 2012 to 2017 bigbiff/Dees_Troy TeamWin
This file is part of TWRP/TeamWin Recovery Project.
TWRP is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
TWRP is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with TWRP. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mount.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <cutils/properties.h>
#include "twcommon.h"
#include "mtdutils/mounts.h"
#include "mtdutils/mtdutils.h"
#ifdef USE_MINZIP
#include "minzip/SysUtil.h"
#else
#include "otautil/sysutil.h"
#include <ziparchive/zip_archive.h>
#endif
#include "zipwrap.hpp"
#ifdef USE_OLD_VERIFIER
#include "verifier24/verifier.h"
#elif USE_28_VERIFIER
#include "verifier28/verifier.h"
#else
#include "install/verifier.h"
#endif
#include "variables.h"
#include "data.hpp"
#include "partitions.hpp"
#include "twrpDigestDriver.hpp"
#include "twrpDigest/twrpDigest.hpp"
#include "twrpDigest/twrpMD5.hpp"
#include "twrp-functions.hpp"
#include "gui/gui.hpp"
#include "gui/pages.hpp"
#include "legacy_property_service.h"
#include "twinstall.h"
#include "installcommand.h"
extern "C" {
#include "gui/gui.h"
}
#define AB_OTA "payload_properties.txt"
#ifndef TW_NO_LEGACY_PROPS
static const char* properties_path = "/dev/__properties__";
static const char* properties_path_renamed = "/dev/__properties_kk__";
static bool legacy_props_env_initd = false;
static bool legacy_props_path_modified = false;
#endif
enum zip_type {
UNKNOWN_ZIP_TYPE = 0,
UPDATE_BINARY_ZIP_TYPE,
AB_OTA_ZIP_TYPE,
TWRP_THEME_ZIP_TYPE
};
#ifndef TW_NO_LEGACY_PROPS
// to support pre-KitKat update-binaries that expect properties in the legacy format
static int switch_to_legacy_properties()
{
if (!legacy_props_env_initd) {
if (legacy_properties_init() != 0)
return -1;
char tmp[32];
int propfd, propsz;
legacy_get_property_workspace(&propfd, &propsz);
sprintf(tmp, "%d,%d", dup(propfd), propsz);
setenv("ANDROID_PROPERTY_WORKSPACE", tmp, 1);
legacy_props_env_initd = true;
}
if (TWFunc::Path_Exists(properties_path)) {
// hide real properties so that the updater uses the envvar to find the legacy format properties
if (rename(properties_path, properties_path_renamed) != 0) {
LOGERR("Renaming %s failed: %s\n", properties_path, strerror(errno));
return -1;
} else {
legacy_props_path_modified = true;
}
}
return 0;
}
static int switch_to_new_properties()
{
if (TWFunc::Path_Exists(properties_path_renamed)) {
if (rename(properties_path_renamed, properties_path) != 0) {
LOGERR("Renaming %s failed: %s\n", properties_path_renamed, strerror(errno));
return -1;
} else {
legacy_props_path_modified = false;
}
}
return 0;
}
#endif
static int Install_Theme(const char* path, ZipWrap *Zip) {
#ifdef TW_OEM_BUILD // We don't do custom themes in OEM builds
Zip->Close();
return INSTALL_CORRUPT;
#else
if (!Zip->EntryExists("ui.xml")) {
return INSTALL_CORRUPT;
}
Zip->Close();
if (!PartitionManager.Mount_Settings_Storage(true))
return INSTALL_ERROR;
string theme_path = DataManager::GetSettingsStoragePath();
theme_path += "/TWRP/theme";
if (!TWFunc::Path_Exists(theme_path)) {
if (!TWFunc::Recursive_Mkdir(theme_path)) {
return INSTALL_ERROR;
}
}
theme_path += "/ui.zip";
if (TWFunc::copy_file(path, theme_path, 0644) != 0) {
return INSTALL_ERROR;
}
LOGINFO("Installing custom theme '%s' to '%s'\n", path, theme_path.c_str());
PageManager::RequestReload();
return INSTALL_SUCCESS;
#endif
}
static int Prepare_Update_Binary(const char *path, ZipWrap *Zip, int* wipe_cache) {
char arches[PATH_MAX];
std::string binary_name = ASSUMED_UPDATE_BINARY_NAME;
property_get("ro.product.cpu.abilist", arches, "error");
if (strcmp(arches, "error") == 0)
property_get("ro.product.cpu.abi", arches, "error");
vector<string> split = TWFunc::split_string(arches, ',', true);
std::vector<string>::iterator arch;
std::string base_name = binary_name;
base_name += "-";
for (arch = split.begin(); arch != split.end(); arch++) {
std::string temp = base_name + *arch;
if (Zip->EntryExists(temp)) {
binary_name = temp;
break;
}
}
LOGINFO("Extracting updater binary '%s'\n", binary_name.c_str());
if (!Zip->ExtractEntry(binary_name.c_str(), TMP_UPDATER_BINARY_PATH, 0755)) {
Zip->Close();
LOGERR("Could not extract '%s'\n", ASSUMED_UPDATE_BINARY_NAME);
return INSTALL_ERROR;
}
// If exists, extract file_contexts from the zip file
if (!Zip->EntryExists("file_contexts")) {
Zip->Close();
LOGINFO("Zip does not contain SELinux file_contexts file in its root.\n");
} else {
const string output_filename = "/file_contexts";
LOGINFO("Zip contains SELinux file_contexts file in its root. Extracting to %s\n", output_filename.c_str());
if (!Zip->ExtractEntry("file_contexts", output_filename, 0644)) {
Zip->Close();
LOGERR("Could not extract '%s'\n", output_filename.c_str());
return INSTALL_ERROR;
}
}
Zip->Close();
return INSTALL_SUCCESS;
}
#ifndef TW_NO_LEGACY_PROPS
static bool update_binary_has_legacy_properties(const char *binary) {
const char str_to_match[] = "ANDROID_PROPERTY_WORKSPACE";
int len_to_match = sizeof(str_to_match) - 1;
bool found = false;
int fd = open(binary, O_RDONLY);
if (fd < 0) {
LOGINFO("has_legacy_properties: Could not open %s: %s!\n", binary, strerror(errno));
return false;
}
struct stat finfo;
if (fstat(fd, &finfo) < 0) {
LOGINFO("has_legacy_properties: Could not fstat %d: %s!\n", fd, strerror(errno));
close(fd);
return false;
}
void *data = mmap(NULL, finfo.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (data == MAP_FAILED) {
LOGINFO("has_legacy_properties: mmap (size=%zu) failed: %s!\n", (size_t)finfo.st_size, strerror(errno));
} else {
if (memmem(data, finfo.st_size, str_to_match, len_to_match)) {
LOGINFO("has_legacy_properties: Found legacy property match!\n");
found = true;
}
munmap(data, finfo.st_size);
}
close(fd);
return found;
}
#endif
static int Run_Update_Binary(const char *path, ZipWrap *Zip, int* wipe_cache, zip_type ztype) {
int ret_val, pipe_fd[2], status, zip_verify;
char buffer[1024];
FILE* child_data;
#ifndef TW_NO_LEGACY_PROPS
if (!update_binary_has_legacy_properties(TMP_UPDATER_BINARY_PATH)) {
LOGINFO("Legacy property environment not used in updater.\n");
} else if (switch_to_legacy_properties() != 0) { /* Set legacy properties */
LOGERR("Legacy property environment did not initialize successfully. Properties may not be detected.\n");
} else {
LOGINFO("Legacy property environment initialized.\n");
}
#endif
pipe(pipe_fd);
std::vector<std::string> args;
if (ztype == UPDATE_BINARY_ZIP_TYPE) {
ret_val = update_binary_command(path, 0, pipe_fd[1], &args);
} else if (ztype == AB_OTA_ZIP_TYPE) {
ret_val = abupdate_binary_command(path, Zip, 0, pipe_fd[1], &args);
} else {
LOGERR("Unknown zip type %i\n", ztype);
ret_val = INSTALL_CORRUPT;
}
if (ret_val) {
close(pipe_fd[0]);
close(pipe_fd[1]);
return ret_val;
}
// Convert the vector to a NULL-terminated char* array suitable for execv.
const char* chr_args[args.size() + 1];
chr_args[args.size()] = NULL;
for (size_t i = 0; i < args.size(); i++)
chr_args[i] = args[i].c_str();
pid_t pid = fork();
if (pid == 0) {
close(pipe_fd[0]);
execve(chr_args[0], const_cast<char**>(chr_args), environ);
printf("E:Can't execute '%s': %s\n", chr_args[0], strerror(errno));
_exit(-1);
}
close(pipe_fd[1]);
*wipe_cache = 0;
DataManager::GetValue(TW_SIGNED_ZIP_VERIFY_VAR, zip_verify);
child_data = fdopen(pipe_fd[0], "r");
while (fgets(buffer, sizeof(buffer), child_data) != NULL) {
char* command = strtok(buffer, " \n");
if (command == NULL) {
continue;
} else if (strcmp(command, "progress") == 0) {
char* fraction_char = strtok(NULL, " \n");
char* seconds_char = strtok(NULL, " \n");
float fraction_float = strtof(fraction_char, NULL);
int seconds_float = strtol(seconds_char, NULL, 10);
if (zip_verify)
DataManager::ShowProgress(fraction_float * (1 - VERIFICATION_PROGRESS_FRAC), seconds_float);
else
DataManager::ShowProgress(fraction_float, seconds_float);
} else if (strcmp(command, "set_progress") == 0) {
char* fraction_char = strtok(NULL, " \n");
float fraction_float = strtof(fraction_char, NULL);
DataManager::_SetProgress(fraction_float);
} else if (strcmp(command, "ui_print") == 0) {
char* display_value = strtok(NULL, "\n");
if (display_value) {
gui_print("%s", display_value);
} else {
gui_print("\n");
}
} else if (strcmp(command, "wipe_cache") == 0) {
*wipe_cache = 1;
} else if (strcmp(command, "clear_display") == 0) {
// Do nothing, not supported by TWRP
} else if (strcmp(command, "log") == 0) {
printf("%s\n", strtok(NULL, "\n"));
} else {
LOGERR("unknown command [%s]\n", command);
}
}
fclose(child_data);
int waitrc = TWFunc::Wait_For_Child(pid, &status, "Updater");
#ifndef TW_NO_LEGACY_PROPS
/* Unset legacy properties */
if (legacy_props_path_modified) {
if (switch_to_new_properties() != 0) {
LOGERR("Legacy property environment did not disable successfully. Legacy properties may still be in use.\n");
} else {
LOGINFO("Legacy property environment disabled.\n");
}
}
#endif
if (waitrc != 0)
return INSTALL_ERROR;
return INSTALL_SUCCESS;
}
int TWinstall_zip(const char* path, int* wipe_cache) {
int ret_val, zip_verify = 1, unmount_system = 1;
if (strcmp(path, "error") == 0) {
LOGERR("Failed to get adb sideload file: '%s'\n", path);
return INSTALL_CORRUPT;
}
gui_msg(Msg("installing_zip=Installing zip file '{1}'")(path));
if (strlen(path) < 9 || strncmp(path, "/sideload", 9) != 0) {
string digest_str;
string Full_Filename = path;
gui_msg("check_for_digest=Checking for Digest file...");
if (*path != '@' && !twrpDigestDriver::Check_File_Digest(Full_Filename)) {
LOGERR("Aborting zip install: Digest verification failed\n");
return INSTALL_CORRUPT;
}
}
DataManager::GetValue(TW_UNMOUNT_SYSTEM, unmount_system);
#ifndef TW_OEM_BUILD
DataManager::GetValue(TW_SIGNED_ZIP_VERIFY_VAR, zip_verify);
#endif
DataManager::SetProgress(0);
MemMapping map;
#ifdef USE_MINZIP
if (sysMapFile(path, &map) != 0) {
#else
if (!map.MapFile(path)) {
#endif
gui_msg(Msg(msg::kError, "fail_sysmap=Failed to map file '{1}'")(path));
return -1;
}
if (zip_verify) {
gui_msg("verify_zip_sig=Verifying zip signature...");
#ifdef USE_OLD_VERIFIER
ret_val = verify_file(map.addr, map.length);
#else
std::vector<Certificate> loadedKeys;
if (!load_keys("/res/keys", loadedKeys)) {
LOGINFO("Failed to load keys");
gui_err("verify_zip_fail=Zip signature verification failed!");
#ifdef USE_MINZIP
sysReleaseMap(&map);
#endif
return -1;
}
ret_val = verify_file(map.addr, map.length, loadedKeys, std::bind(&DataManager::SetProgress, std::placeholders::_1));
#endif
if (ret_val != VERIFY_SUCCESS) {
LOGINFO("Zip signature verification failed: %i\n", ret_val);
gui_err("verify_zip_fail=Zip signature verification failed!");
#ifdef USE_MINZIP
sysReleaseMap(&map);
#endif
return -1;
} else {
gui_msg("verify_zip_done=Zip signature verified successfully.");
}
}
ZipWrap Zip;
if (!Zip.Open(path, &map)) {
gui_err("zip_corrupt=Zip file is corrupt!");
#ifdef USE_MINZIP
sysReleaseMap(&map);
#endif
return INSTALL_CORRUPT;
}
if (unmount_system) {
gui_msg("unmount_system=Unmounting System...");
if(!PartitionManager.UnMount_By_Path(PartitionManager.Get_Android_Root_Path(), true)) {
gui_err("unmount_system_err=Failed unmounting System");
return -1;
}
unlink("/system");
mkdir("/system", 0755);
}
time_t start, stop;
time(&start);
if (Zip.EntryExists(ASSUMED_UPDATE_BINARY_NAME)) {
LOGINFO("Update binary zip\n");
// Additionally verify the compatibility of the package.
if (!verify_package_compatibility(&Zip)) {
gui_err("zip_compatible_err=Zip Treble compatibility error!");
Zip.Close();
#ifdef USE_MINZIP
sysReleaseMap(&map);
#endif
ret_val = INSTALL_CORRUPT;
} else {
ret_val = Prepare_Update_Binary(path, &Zip, wipe_cache);
if (ret_val == INSTALL_SUCCESS)
ret_val = Run_Update_Binary(path, &Zip, wipe_cache, UPDATE_BINARY_ZIP_TYPE);
}
} else {
if (Zip.EntryExists(AB_OTA)) {
LOGINFO("AB zip\n");
gui_msg(Msg(msg::kHighlight, "flash_ab_inactive=Flashing A/B zip to inactive slot: {1}")(PartitionManager.Get_Active_Slot_Display()=="A"?"B":"A"));
// We need this so backuptool can do its magic
bool system_mount_state = PartitionManager.Is_Mounted_By_Path(PartitionManager.Get_Android_Root_Path());
bool vendor_mount_state = PartitionManager.Is_Mounted_By_Path("/vendor");
PartitionManager.Mount_By_Path(PartitionManager.Get_Android_Root_Path(), true);
PartitionManager.Mount_By_Path("/vendor", true);
TWFunc::Exec_Cmd("cp -f /system/bin/sh /tmp/sh");
mount("/tmp/sh", "/system/bin/sh", "auto", MS_BIND, NULL);
ret_val = Run_Update_Binary(path, &Zip, wipe_cache, AB_OTA_ZIP_TYPE);
umount("/system/bin/sh");
unlink("/tmp/sh");
if (!vendor_mount_state)
PartitionManager.UnMount_By_Path("/vendor", true);
if (!system_mount_state)
PartitionManager.UnMount_By_Path(PartitionManager.Get_Android_Root_Path(), true);
gui_warn("flash_ab_reboot=To flash additional zips, please reboot recovery to switch to the updated slot.");
} else {
if (Zip.EntryExists("ui.xml")) {
LOGINFO("TWRP theme zip\n");
ret_val = Install_Theme(path, &Zip);
} else {
Zip.Close();
ret_val = INSTALL_CORRUPT;
}
}
}
time(&stop);
int total_time = (int) difftime(stop, start);
if (ret_val == INSTALL_CORRUPT) {
gui_err("invalid_zip_format=Invalid zip file format!");
} else {
LOGINFO("Install took %i second(s).\n", total_time);
}
#ifdef USE_MINZIP
sysReleaseMap(&map);
#endif
return ret_val;
}
Reference in New Issue View Git Blame Copy Permalink