blob: 0aaab4534bb5a0db3481c41e5762da57f7f2a581 [file] [log] [blame]
/*
Copyright 2012 to 2016 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 <unistd.h>
#include <string.h>
#include <stdio.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"
extern "C" {
#include "gui/gui.h"
}
#define AB_OTA "payload_properties.txt"
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;
enum zip_type {
UNKNOWN_ZIP_TYPE = 0,
UPDATE_BINARY_ZIP_TYPE,
AB_OTA_ZIP_TYPE,
TWRP_THEME_ZIP_TYPE
};
// 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;
}
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) {
if (!Zip->ExtractEntry(ASSUMED_UPDATE_BINARY_NAME, 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;
}
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=%lld) failed: %s!\n", 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;
}
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;
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;
string digest_file = path;
digest_file += ".md5";
gui_msg("check_for_digest=Checking for Digest file...");
if (!TWFunc::Path_Exists(digest_file)) {
gui_msg("no_digest=Skipping Digest check: no Digest file found");
}
else {
if (TWFunc::read_file(digest_file, digest_str) != 0) {
LOGERR("Skipping MD5 check: MD5 file unreadable\n");
}
else {
twrpDigest *digest = new twrpMD5();
if (!twrpDigestDriver::stream_file_to_digest(Full_Filename, digest)) {
delete digest;
return INSTALL_CORRUPT;
}
string digest_check = digest->return_digest_string();
if (digest_str == digest_check) {
gui_msg(Msg("digest_matched=Digest matched for '{1}'.")(path));
}
else {
LOGERR("Aborting zip install: Digest verification failed\n");
delete digest;
return INSTALL_CORRUPT;
}
delete digest;
}
}
}
#ifndef TW_OEM_BUILD
DataManager::GetValue(TW_SIGNED_ZIP_VERIFY_VAR, zip_verify);
#endif
DataManager::SetProgress(0);
MemMapping map;
if (sysMapFile(path, &map) != 0) {
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!");
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!");
sysReleaseMap(&map);
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!");
sysReleaseMap(&map);
return INSTALL_CORRUPT;
}
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!");
sysReleaseMap(&map);
Zip.Close();
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");
ret_val = Run_Update_Binary(path, &Zip, wipe_cache, AB_OTA_ZIP_TYPE);
} 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);
}
sysReleaseMap(&map);
return ret_val;
}