twinstall.cpp - android_bootable_recovery - Gitiles

 /*
 	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"
 #else
 #include "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"
 #include "twrpRepacker.hpp"
 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, bool check_for_digest) {
 	int ret_val, zip_verify = 1, unmount_system = 1, reflashtwrp = 0;

 	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;

 		if (check_for_digest) {
 			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 /sbin/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.");
 			DataManager::GetValue(TW_AUTO_REFLASHTWRP_VAR, reflashtwrp);
 			if (reflashtwrp) {
 			twrpRepacker repacker;
 			repacker.Flash_Current_Twrp();
 			}
 		} 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;
 }
	/*
	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"
	#else
	#include "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"
	#include "twrpRepacker.hpp"
	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, bool check_for_digest) {
	int ret_val, zip_verify = 1, unmount_system = 1, reflashtwrp = 0;

	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;

	if (check_for_digest) {
	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 /sbin/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.");
	DataManager::GetValue(TW_AUTO_REFLASHTWRP_VAR, reflashtwrp);
	if (reflashtwrp) {
	twrpRepacker repacker;
	repacker.Flash_Current_Twrp();
	}
	} 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;
	}