int GUIAction::decrypt(std::string arg) { int op_status = 0; operation_start("Decrypt"); if (simulate) { simulate_progress_bar(); } else { string Password; DataManager::GetValue("tw_crypto_password", Password); op_status = PartitionManager.Decrypt_Device(Password); if (op_status != 0) op_status = 1; else { DataManager::SetValue(TW_IS_ENCRYPTED, 0); int has_datamedia; // Check for a custom theme and load it if exists DataManager::GetValue(TW_HAS_DATA_MEDIA, has_datamedia); if (has_datamedia != 0) { if (tw_get_default_metadata(DataManager::GetSettingsStoragePath().c_str()) != 0) { LOGINFO("Failed to get default contexts and file mode for storage files.\n"); } else { LOGINFO("Got default contexts and file mode for storage files.\n"); } } } } operation_end(op_status); return 0; }
int GUIAction::refreshsizes(std::string arg) { operation_start("Refreshing Sizes"); if (simulate) { simulate_progress_bar(); } else PartitionManager.Update_System_Details(); operation_end(0); return 0; }
int GUIAction::htcdumlockreflashrecovery(std::string arg) { operation_start("HTC Dumlock Reflash Recovery"); if (simulate) { simulate_progress_bar(); } else TWFunc::htc_dumlock_reflash_recovery_to_boot(); operation_end(0); return 0; }
int GUIAction::htcdumlockrestoreboot(std::string arg) { operation_start("HTC Dumlock Restore Boot"); if (simulate) { simulate_progress_bar(); } else TWFunc::htc_dumlock_restore_original_boot(); operation_end(0); return 0; }
int GUIAction::installhtcdumlock(std::string arg) { operation_start("Install HTC Dumlock"); if (simulate) { simulate_progress_bar(); } else TWFunc::install_htc_dumlock(); operation_end(0); return 0; }
int GUIAction::dd(std::string arg) { operation_start("imaging"); if (simulate) { simulate_progress_bar(); } else { string cmd = "dd " + arg; TWFunc::Exec_Cmd(cmd); } operation_end(0); return 0; }
int GUIAction::adbsideload(std::string arg) { operation_start("Sideload"); if (simulate) { simulate_progress_bar(); operation_end(0); } else { gui_print("Starting ADB sideload feature...\n"); bool mtp_was_enabled = TWFunc::Toggle_MTP(false); // wait for the adb connection int ret = apply_from_adb("/", &sideload_child_pid); DataManager::SetValue("tw_has_cancel", 0); // Remove cancel button from gui now that the zip install is going to start if (ret != 0) { if (ret == -2) gui_print("You need adb 1.0.32 or newer to sideload to this device.\n"); ret = 1; // failure } else { int wipe_cache = 0; int wipe_dalvik = 0; DataManager::GetValue("tw_wipe_dalvik", wipe_dalvik); if (TWinstall_zip(FUSE_SIDELOAD_HOST_PATHNAME, &wipe_cache) == 0) { if (wipe_cache || DataManager::GetIntValue("tw_wipe_cache")) PartitionManager.Wipe_By_Path("/cache"); if (wipe_dalvik) PartitionManager.Wipe_Dalvik_Cache(); } else { ret = 1; // failure } } if (sideload_child_pid) { LOGINFO("Signaling child sideload process to exit.\n"); struct stat st; // Calling stat() on this magic filename signals the minadbd // subprocess to shut down. stat(FUSE_SIDELOAD_HOST_EXIT_PATHNAME, &st); int status; LOGINFO("Waiting for child sideload process to exit.\n"); waitpid(sideload_child_pid, &status, 0); } property_set("ctl.start", "adbd"); TWFunc::Toggle_MTP(mtp_was_enabled); reinject_after_flash(); operation_end(ret); } return 0; }
int GUIAction::installsu(std::string arg) { int op_status = 0; operation_start("Install SuperSU"); if (simulate) { simulate_progress_bar(); } else { if (!TWFunc::Install_SuperSU()) op_status = 1; } operation_end(op_status); return 0; }
int GUIAction::fixsu(std::string arg) { int op_status = 0; operation_start("Fixing Superuser Permissions"); if (simulate) { simulate_progress_bar(); } else { LOGERR("Fixing su permissions was deprecated from TWRP.\n"); LOGERR("4.3+ ROMs with SELinux will always lose su perms.\n"); } operation_end(op_status); return 0; }
int GUIAction::reinjecttwrp(std::string arg) { int op_status = 0; operation_start("ReinjectTWRP"); gui_print("Injecting TWRP into boot image...\n"); if (simulate) { simulate_progress_bar(); } else { TWFunc::Exec_Cmd("injecttwrp --dump /tmp/backup_recovery_ramdisk.img /tmp/injected_boot.img --flash"); gui_print("TWRP injection complete.\n"); } operation_end(op_status); return 0; }
int GUIAction::nandroid(std::string arg) { if (simulate) { PartitionManager.stop_backup.set_value(0); DataManager::SetValue("tw_partition", "Simulation"); simulate_progress_bar(); operation_end(0); } else { operation_start("Nandroid"); int ret = 0; if (arg == "backup") { string Backup_Name; DataManager::GetValue(TW_BACKUP_NAME, Backup_Name); if (Backup_Name == "(Auto Generate)" || Backup_Name == "(Current Date)" || Backup_Name == "0" || Backup_Name == "(" || PartitionManager.Check_Backup_Name(true) == 0) { ret = PartitionManager.Run_Backup(); } else { operation_end(1); return -1; } DataManager::SetValue(TW_BACKUP_NAME, "(Auto Generate)"); } else if (arg == "restore") { string Restore_Name; DataManager::GetValue("tw_restore", Restore_Name); ret = PartitionManager.Run_Restore(Restore_Name); } else { operation_end(1); return -1; } DataManager::SetValue("tw_encrypt_backup", 0); if (!PartitionManager.stop_backup.get_value()) { if (ret == false) ret = 1; // 1 for failure else ret = 0; // 0 for success DataManager::SetValue("tw_cancel_backup", 0); } else { DataManager::SetValue("tw_cancel_backup", 1); gui_print("Backup Canceled.\n"); ret = 0; } operation_end(ret); return ret; } return 0; }
int GUIAction::checkbackupname(std::string arg) { int op_status = 0; operation_start("CheckBackupName"); if (simulate) { simulate_progress_bar(); } else { op_status = PartitionManager.Check_Backup_Name(true); if (op_status != 0) op_status = 1; } operation_end(op_status); return 0; }
int GUIAction::fixpermissions(std::string arg) { int op_status = 0; operation_start("Fix Permissions"); LOGINFO("fix permissions started!\n"); if (simulate) { simulate_progress_bar(); } else { op_status = PartitionManager.Fix_Permissions(); if (op_status != 0) op_status = 1; // failure } operation_end(op_status); return 0; }
int GUIAction::cmd(std::string arg) { int op_status = 0; operation_start("Command"); LOGINFO("Running command: '%s'\n", arg.c_str()); if (simulate) { simulate_progress_bar(); } else { op_status = TWFunc::Exec_Cmd(arg); if (op_status != 0) op_status = 1; } operation_end(op_status); return 0; }
int GUIAction::copylog(std::string arg) { operation_start("Copy Log"); if (!simulate) { string dst; PartitionManager.Mount_Current_Storage(true); dst = DataManager::GetCurrentStoragePath() + "/recovery.log"; TWFunc::copy_file("/tmp/recovery.log", dst.c_str(), 0755); tw_set_default_metadata(dst.c_str()); sync(); gui_print("Copied recovery log to %s.\n", DataManager::GetCurrentStoragePath().c_str()); } else simulate_progress_bar(); operation_end(0); return 0; }
void GUIAction::reinject_after_flash() { if (DataManager::GetIntValue(TW_HAS_INJECTTWRP) == 1 && DataManager::GetIntValue(TW_INJECT_AFTER_ZIP) == 1) { gui_print("Injecting TWRP into boot image...\n"); if (simulate) { simulate_progress_bar(); } else { TWPartition* Boot = PartitionManager.Find_Partition_By_Path("/boot"); if (Boot == NULL || Boot->Current_File_System != "emmc") TWFunc::Exec_Cmd("injecttwrp --dump /tmp/backup_recovery_ramdisk.img /tmp/injected_boot.img --flash"); else { string injectcmd = "injecttwrp --dump /tmp/backup_recovery_ramdisk.img /tmp/injected_boot.img --flash bd=" + Boot->Actual_Block_Device; TWFunc::Exec_Cmd(injectcmd); } gui_print("TWRP injection complete.\n"); } } }
int GUIAction::openrecoveryscript(std::string arg) { int op_status = 1; operation_start("OpenRecoveryScript"); if (simulate) { simulate_progress_bar(); operation_end(0); } else { // Check for the SCRIPT_FILE_TMP first as these are AOSP recovery commands // that we converted to ORS commands during boot in recovery.cpp. // Run those first. int reboot = 0; if (TWFunc::Path_Exists(SCRIPT_FILE_TMP)) { gui_print("Processing AOSP recovery commands...\n"); if (OpenRecoveryScript::run_script_file() == 0) { reboot = 1; op_status = 0; } } // Check for the ORS file in /cache and attempt to run those commands. if (OpenRecoveryScript::check_for_script_file()) { gui_print("Processing OpenRecoveryScript file...\n"); if (OpenRecoveryScript::run_script_file() == 0) { reboot = 1; op_status = 0; } } if (reboot) { // Disable stock recovery reflashing TWFunc::Disable_Stock_Recovery_Replace(); usleep(2000000); // Sleep for 2 seconds before rebooting TWFunc::tw_reboot(rb_system); usleep(5000000); // Sleep for 5 seconds to allow reboot to occur } else { DataManager::SetValue("tw_page_done", 1); } operation_end(op_status); } return 0; }
int GUIAction::resize(std::string arg) { int op_status = 0; operation_start("Resize Partition"); if (simulate) { simulate_progress_bar(); } else { string part_path; DataManager::GetValue("tw_partition_mount_point", part_path); if (PartitionManager.Resize_By_Path(part_path, true)) { op_status = 0; // success } else { LOGERR("Error resizing file system.\n"); op_status = 1; // fail } } operation_end(op_status); return 0; }
int GUIAction::partitionsd(std::string arg) { operation_start("Partition SD Card"); int ret_val = 0; if (simulate) { simulate_progress_bar(); } else { int allow_partition; DataManager::GetValue(TW_ALLOW_PARTITION_SDCARD, allow_partition); if (allow_partition == 0) { gui_print("This device does not have a real SD Card!\nAborting!\n"); } else { if (!PartitionManager.Partition_SDCard()) ret_val = 1; // failed } } operation_end(ret_val); return 0; }
int GUIAction::flash_zip(std::string filename, int* wipe_cache) { int ret_val = 0; DataManager::SetValue("ui_progress", 0); if (filename.empty()) { LOGERR("No file specified.\n"); return -1; } if (!PartitionManager.Mount_By_Path(filename, true)) return -1; if (simulate) { simulate_progress_bar(); } else { ret_val = TWinstall_zip(filename.c_str(), wipe_cache); // Now, check if we need to ensure TWRP remains installed... struct stat st; if (stat("/sbin/installTwrp", &st) == 0) { DataManager::SetValue("tw_operation", "Configuring TWRP"); DataManager::SetValue("tw_partition", ""); gui_print("Configuring TWRP...\n"); if (TWFunc::Exec_Cmd("/sbin/installTwrp reinstall") < 0) { gui_print("Unable to configure TWRP with this kernel.\n"); } } } // Done DataManager::SetValue("ui_progress", 100); DataManager::SetValue("ui_progress", 0); return ret_val; }
int GUIAction::changefilesystem(std::string arg) { int op_status = 0; operation_start("Change File System"); if (simulate) { simulate_progress_bar(); } else { string part_path, file_system; DataManager::GetValue("tw_partition_mount_point", part_path); DataManager::GetValue("tw_action_new_file_system", file_system); if (PartitionManager.Wipe_By_Path(part_path, file_system)) { op_status = 0; // success } else { LOGERR("Error changing file system.\n"); op_status = 1; // fail } } PartitionManager.Update_System_Details(); operation_end(op_status); return 0; }
int GUIAction::decrypt_backup(std::string arg) { int op_status = 0; operation_start("Try Restore Decrypt"); if (simulate) { simulate_progress_bar(); } else { string Restore_Path, Filename, Password; DataManager::GetValue("tw_restore", Restore_Path); Restore_Path += "/"; DataManager::GetValue("tw_restore_password", Password); TWFunc::SetPerformanceMode(true); if (TWFunc::Try_Decrypting_Backup(Restore_Path, Password)) op_status = 0; // success else op_status = 1; // fail TWFunc::SetPerformanceMode(false); } operation_end(op_status); return 0; }
int GUIAction::flash_zip(std::string filename, std::string pageName, const int simulate) { int ret_val = 0; DataManager::SetValue("ui_progress", 0); if (filename.empty()) { LOGE("No file specified.\n"); return -1; } // We're going to jump to this page first, like a loading page gui_changePage(pageName); int fd = -1; ZipArchive zip; if (mzOpenZipArchive(filename.c_str(), &zip)) { LOGE("Unable to open zip file.\n"); return -1; } // Check the zip to see if it has a custom installer theme const ZipEntry* twrp = mzFindZipEntry(&zip, "META-INF/teamwin/twrp.zip"); if (twrp != NULL) { unlink("/tmp/twrp.zip"); fd = creat("/tmp/twrp.zip", 0666); } if (fd >= 0 && twrp != NULL && mzExtractZipEntryToFile(&zip, twrp, fd) && !PageManager::LoadPackage("install", "/tmp/twrp.zip")) { mzCloseZipArchive(&zip); PageManager::SelectPackage("install"); gui_changePage("main"); } else { // In this case, we just use the default page mzCloseZipArchive(&zip); gui_changePage(pageName); } if (fd >= 0) close(fd); if (simulate) { simulate_progress_bar(); } else { ret_val = install_zip_package(filename.c_str()); // Now, check if we need to ensure TWRP remains installed... struct stat st; if (stat("/sbin/installTwrp", &st) == 0) { DataManager::SetValue("tw_operation", "Configuring TWRP"); DataManager::SetValue("tw_partition", ""); ui_print("Configuring TWRP...\n"); if (__system("/sbin/installTwrp reinstall") < 0) { ui_print("Unable to configure TWRP with this kernel.\n"); } } } // Done DataManager::SetValue("ui_progress", 100); DataManager::SetValue("ui_progress", 0); return ret_val; }
int GUIAction::wipe(std::string arg) { operation_start("Format"); DataManager::SetValue("tw_partition", arg); int ret_val = false; if (simulate) { simulate_progress_bar(); } else { if (arg == "data") ret_val = PartitionManager.Factory_Reset(); else if (arg == "battery") ret_val = PartitionManager.Wipe_Battery_Stats(); else if (arg == "rotate") ret_val = PartitionManager.Wipe_Rotate_Data(); else if (arg == "dalvik") ret_val = PartitionManager.Wipe_Dalvik_Cache(); else if (arg == "DATAMEDIA") { ret_val = PartitionManager.Format_Data(); } else if (arg == "INTERNAL") { int has_datamedia, dual_storage; DataManager::GetValue(TW_HAS_DATA_MEDIA, has_datamedia); if (has_datamedia) { ret_val = PartitionManager.Wipe_Media_From_Data(); } else { ret_val = PartitionManager.Wipe_By_Path(DataManager::GetSettingsStoragePath()); } } else if (arg == "EXTERNAL") { string External_Path; DataManager::GetValue(TW_EXTERNAL_PATH, External_Path); ret_val = PartitionManager.Wipe_By_Path(External_Path); } else if (arg == "ANDROIDSECURE") { ret_val = PartitionManager.Wipe_Android_Secure(); } else if (arg == "LIST") { string Wipe_List, wipe_path; bool skip = false; ret_val = true; TWPartition* wipe_part = NULL; DataManager::GetValue("tw_wipe_list", Wipe_List); LOGINFO("wipe list '%s'\n", Wipe_List.c_str()); if (!Wipe_List.empty()) { size_t start_pos = 0, end_pos = Wipe_List.find(";", start_pos); while (end_pos != string::npos && start_pos < Wipe_List.size()) { wipe_path = Wipe_List.substr(start_pos, end_pos - start_pos); LOGINFO("wipe_path '%s'\n", wipe_path.c_str()); if (wipe_path == "/and-sec") { if (!PartitionManager.Wipe_Android_Secure()) { LOGERR("Unable to wipe android secure\n"); ret_val = false; break; } else { skip = true; } } else if (wipe_path == "DALVIK") { if (!PartitionManager.Wipe_Dalvik_Cache()) { LOGERR("Failed to wipe dalvik\n"); ret_val = false; break; } else { skip = true; } } else if (wipe_path == "INTERNAL") { if (!PartitionManager.Wipe_Media_From_Data()) { ret_val = false; break; } else { skip = true; } } if (!skip) { if (!PartitionManager.Wipe_By_Path(wipe_path)) { LOGERR("Unable to wipe '%s'\n", wipe_path.c_str()); ret_val = false; break; } else if (wipe_path == DataManager::GetSettingsStoragePath()) { arg = wipe_path; } } else { skip = false; } start_pos = end_pos + 1; end_pos = Wipe_List.find(";", start_pos); } } } else ret_val = PartitionManager.Wipe_By_Path(arg); #ifndef TW_OEM_BUILD if (arg == DataManager::GetSettingsStoragePath()) { // If we wiped the settings storage path, recreate the TWRP folder and dump the settings string Storage_Path = DataManager::GetSettingsStoragePath(); if (PartitionManager.Mount_By_Path(Storage_Path, true)) { LOGINFO("Making TWRP folder and saving settings.\n"); Storage_Path += "/TWRP"; mkdir(Storage_Path.c_str(), 0777); DataManager::Flush(); } else { LOGERR("Unable to recreate TWRP folder and save settings.\n"); } } #endif } PartitionManager.Update_System_Details(); if (ret_val) ret_val = 0; // 0 is success else ret_val = 1; // 1 is failure operation_end(ret_val); return 0; }
int GUIAction::terminalcommand(std::string arg) { int op_status = 0; string cmdpath, command; DataManager::GetValue("tw_terminal_location", cmdpath); operation_start("CommandOutput"); gui_print("%s # %s\n", cmdpath.c_str(), arg.c_str()); if (simulate) { simulate_progress_bar(); operation_end(op_status); } else if (arg == "exit") { LOGINFO("Exiting terminal\n"); operation_end(op_status); page("main"); } else { command = "cd \"" + cmdpath + "\" && " + arg + " 2>&1";; LOGINFO("Actual command is: '%s'\n", command.c_str()); DataManager::SetValue("tw_terminal_state", 1); DataManager::SetValue("tw_background_thread_running", 1); FILE* fp; char line[512]; fp = popen(command.c_str(), "r"); if (fp == NULL) { LOGERR("Error opening command to run.\n"); } else { int fd = fileno(fp), has_data = 0, check = 0, keep_going = -1, bytes_read = 0; struct timeval timeout; fd_set fdset; while(keep_going) { FD_ZERO(&fdset); FD_SET(fd, &fdset); timeout.tv_sec = 0; timeout.tv_usec = 400000; has_data = select(fd+1, &fdset, NULL, NULL, &timeout); if (has_data == 0) { // Timeout reached DataManager::GetValue("tw_terminal_state", check); if (check == 0) { keep_going = 0; } } else if (has_data < 0) { // End of execution keep_going = 0; } else { // Try to read output if(fgets(line, sizeof(line), fp) != NULL) gui_print("%s", line); // Display output else keep_going = 0; // Done executing } } fclose(fp); } DataManager::SetValue("tw_operation_status", 0); DataManager::SetValue("tw_operation_state", 1); DataManager::SetValue("tw_terminal_state", 0); DataManager::SetValue("tw_background_thread_running", 0); DataManager::SetValue(TW_ACTION_BUSY, 0); } return 0; }
int GUIAction::doAction(Action action, int isThreaded /* = 0 */) { static string zip_queue[10]; static int zip_queue_index; int simulate; std::string arg = gui_parse_text(action.mArg); std::string function = gui_parse_text(action.mFunction); DataManager::GetValue(TW_SIMULATE_ACTIONS, simulate); if (function == "reboot") { //curtainClose(); this sometimes causes a crash sync(); if (arg == "recovery") tw_reboot(rb_recovery); else if (arg == "poweroff") tw_reboot(rb_poweroff); else if (arg == "bootloader") tw_reboot(rb_bootloader); else if (arg == "download") tw_reboot(rb_download); else tw_reboot(rb_system); // This should never occur return -1; } if (function == "home") { PageManager::SelectPackage("TWRP"); gui_changePage("main"); return 0; } if (function == "key") { PageManager::NotifyKey(getKeyByName(arg)); return 0; } if (function == "page") { std::string page_name = gui_parse_text(arg); return gui_changePage(page_name); } if (function == "reload") { int check = 0, ret_val = 0; std::string theme_path; operation_start("Reload Theme"); theme_path = DataManager::GetSettingsStoragePath(); if (ensure_path_mounted(theme_path.c_str()) < 0) { LOGE("Unable to mount %s during reload function startup.\n", theme_path.c_str()); check = 1; } theme_path += "/TWRP/theme/ui.zip"; if (check != 0 || PageManager::ReloadPackage("TWRP", theme_path) != 0) { // Loading the custom theme failed - try loading the stock theme LOGI("Attempting to reload stock theme...\n"); if (PageManager::ReloadPackage("TWRP", "/res/ui.xml")) { LOGE("Failed to load base packages.\n"); ret_val = 1; } } operation_end(ret_val, simulate); } if (function == "readBackup") { set_restore_files(); return 0; } if (function == "set") { if (arg.find('=') != string::npos) { string varName = arg.substr(0, arg.find('=')); string value = arg.substr(arg.find('=') + 1, string::npos); DataManager::GetValue(value, value); DataManager::SetValue(varName, value); } else DataManager::SetValue(arg, "1"); return 0; } if (function == "clear") { DataManager::SetValue(arg, "0"); return 0; } if (function == "mount") { if (arg == "usb") { DataManager::SetValue(TW_ACTION_BUSY, 1); if (!simulate) usb_storage_enable(); else ui_print("Simulating actions...\n"); } else if (!simulate) { string cmd; if (arg == "EXTERNAL") cmd = "mount " + DataManager::GetStrValue(TW_EXTERNAL_MOUNT); else if (arg == "INTERNAL") cmd = "mount " + DataManager::GetStrValue(TW_INTERNAL_MOUNT); else cmd = "mount " + arg; __system(cmd.c_str()); if (arg == "/data" && DataManager::GetIntValue(TW_HAS_DATADATA) == 1) __system("mount /datadata"); } else ui_print("Simulating actions...\n"); return 0; } if (function == "umount" || function == "unmount") { if (arg == "usb") { if (!simulate) usb_storage_disable(); else ui_print("Simulating actions...\n"); DataManager::SetValue(TW_ACTION_BUSY, 0); } else if (!simulate) { string cmd; if (arg == "EXTERNAL") cmd = "umount " + DataManager::GetStrValue(TW_EXTERNAL_MOUNT); else if (arg == "INTERNAL") cmd = "umount " + DataManager::GetStrValue(TW_INTERNAL_MOUNT); else if (DataManager::GetIntValue(TW_DONT_UNMOUNT_SYSTEM) == 1 && (arg == "system" || arg == "/system")) return 0; else cmd = "umount " + arg; __system(cmd.c_str()); if (arg == "/data" && DataManager::GetIntValue(TW_HAS_DATADATA) == 1) __system("umount /datadata"); } else ui_print("Simulating actions...\n"); return 0; } if (function == "restoredefaultsettings") { operation_start("Restore Defaults"); if (simulate) // Simulated so that people don't accidently wipe out the "simulation is on" setting ui_print("Simulating actions...\n"); else { DataManager::ResetDefaults(); mount_current_storage(); } operation_end(0, simulate); } if (function == "copylog") { operation_start("Copy Log"); if (!simulate) { char command[255]; mount_current_storage(); sprintf(command, "cp /tmp/recovery.log %s", DataManager::GetCurrentStoragePath().c_str()); __system(command); sync(); ui_print("Copied recovery log to %s.\n", DataManager::GetCurrentStoragePath().c_str()); } else simulate_progress_bar(); operation_end(0, simulate); return 0; } if (function == "compute" || function == "addsubtract") { if (arg.find("+") != string::npos) { string varName = arg.substr(0, arg.find('+')); string string_to_add = arg.substr(arg.find('+') + 1, string::npos); int amount_to_add = atoi(string_to_add.c_str()); int value; DataManager::GetValue(varName, value); DataManager::SetValue(varName, value + amount_to_add); return 0; } if (arg.find("-") != string::npos) { string varName = arg.substr(0, arg.find('-')); string string_to_subtract = arg.substr(arg.find('-') + 1, string::npos); int amount_to_subtract = atoi(string_to_subtract.c_str()); int value; DataManager::GetValue(varName, value); value -= amount_to_subtract; if (value <= 0) value = 0; DataManager::SetValue(varName, value); return 0; } } if (function == "setguitimezone") { string SelectedZone; DataManager::GetValue(TW_TIME_ZONE_GUISEL, SelectedZone); // read the selected time zone into SelectedZone string Zone = SelectedZone.substr(0, SelectedZone.find(';')); // parse to get time zone string DSTZone = SelectedZone.substr(SelectedZone.find(';') + 1, string::npos); // parse to get DST component int dst; DataManager::GetValue(TW_TIME_ZONE_GUIDST, dst); // check wether user chose to use DST string offset; DataManager::GetValue(TW_TIME_ZONE_GUIOFFSET, offset); // pull in offset string NewTimeZone = Zone; if (offset != "0") NewTimeZone += ":" + offset; if (dst != 0) NewTimeZone += DSTZone; DataManager::SetValue(TW_TIME_ZONE_VAR, NewTimeZone); update_tz_environment_variables(); return 0; } if (function == "togglestorage") { if (arg == "internal") { DataManager::SetValue(TW_USE_EXTERNAL_STORAGE, 0); DataManager::SetValue(TW_STORAGE_FREE_SIZE, (int)((sdcint.sze - sdcint.used) / 1048576LLU)); } else if (arg == "external") { DataManager::SetValue(TW_USE_EXTERNAL_STORAGE, 1); DataManager::SetValue(TW_STORAGE_FREE_SIZE, (int)((sdcext.sze - sdcext.used) / 1048576LLU)); } if (mount_current_storage() == 0) { if (arg == "internal") { // Save the current zip location to the external variable DataManager::SetValue(TW_ZIP_EXTERNAL_VAR, DataManager::GetStrValue(TW_ZIP_LOCATION_VAR)); // Change the current zip location to the internal variable DataManager::SetValue(TW_ZIP_LOCATION_VAR, DataManager::GetStrValue(TW_ZIP_INTERNAL_VAR)); } else if (arg == "external") { // Save the current zip location to the internal variable DataManager::SetValue(TW_ZIP_INTERNAL_VAR, DataManager::GetStrValue(TW_ZIP_LOCATION_VAR)); // Change the current zip location to the external variable DataManager::SetValue(TW_ZIP_LOCATION_VAR, DataManager::GetStrValue(TW_ZIP_EXTERNAL_VAR)); } } else { // We weren't able to toggle for some reason, restore original setting if (arg == "internal") { DataManager::SetValue(TW_USE_EXTERNAL_STORAGE, 1); DataManager::SetValue(TW_STORAGE_FREE_SIZE, (int)((sdcext.sze - sdcext.used) / 1048576LLU)); } else if (arg == "external") { DataManager::SetValue(TW_USE_EXTERNAL_STORAGE, 0); DataManager::SetValue(TW_STORAGE_FREE_SIZE, (int)((sdcint.sze - sdcint.used) / 1048576LLU)); } } return 0; } if (function == "overlay") return gui_changeOverlay(arg); if (function == "queuezip") { if (zip_queue_index >= 10) { ui_print("Maximum zip queue reached!\n"); return 0; } DataManager::GetValue("tw_filename", zip_queue[zip_queue_index]); if (strlen(zip_queue[zip_queue_index].c_str()) > 0) { zip_queue_index++; DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index); } return 0; } if (function == "cancelzip") { if (zip_queue_index <= 0) { ui_print("Minimum zip queue reached!\n"); return 0; } else { zip_queue_index--; DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index); } return 0; } if (function == "queueclear") { zip_queue_index = 0; DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index); return 0; } if (function == "sleep") { usleep(atoi(arg.c_str())); return 0; } if (isThreaded) { if (function == "flash") { int i, ret_val = 0; for (i=0; i<zip_queue_index; i++) { operation_start("Flashing"); DataManager::SetValue("tw_filename", zip_queue[i]); DataManager::SetValue(TW_ZIP_INDEX, (i + 1)); ret_val = flash_zip(zip_queue[i], arg, simulate); if (ret_val != 0) { ui_print("Error flashing zip '%s'\n", zip_queue[i].c_str()); i = 10; // Error flashing zip - exit queue ret_val = 1; } } zip_queue_index = 0; DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index); if (DataManager::GetIntValue(TW_HAS_INJECTTWRP) == 1 && DataManager::GetIntValue(TW_INJECT_AFTER_ZIP) == 1) { operation_start("ReinjectTWRP"); ui_print("Injecting TWRP into boot image...\n"); if (simulate) { simulate_progress_bar(); } else { __system("injecttwrp --dump /tmp/backup_recovery_ramdisk.img /tmp/injected_boot.img --flash"); ui_print("TWRP injection complete.\n"); } } operation_end(ret_val, simulate); return 0; } if (function == "wipe") { operation_start("Format"); DataManager::SetValue("tw_partition", arg); if (simulate) { simulate_progress_bar(); } else { if (arg == "data") wipe_data(0); else if (arg == "battery") wipe_battery_stats(); else if (arg == "rotate") wipe_rotate_data(); else if (arg == "dalvik") wipe_dalvik_cache(); else erase_volume(arg.c_str()); if (arg == "/sdcard") { ensure_path_mounted(SDCARD_ROOT); mkdir("/sdcard/TWRP", 0777); DataManager::Flush(); } } update_system_details(); operation_end(0, simulate); return 0; } if (function == "refreshsizes") { operation_start("Refreshing Sizes"); if (simulate) { simulate_progress_bar(); } else update_system_details(); operation_end(0, simulate); } if (function == "nandroid") { operation_start("Nandroid"); if (simulate) { DataManager::SetValue("tw_partition", "Simulation"); simulate_progress_bar(); } else { if (arg == "backup") nandroid_back_exe(); else if (arg == "restore") nandroid_rest_exe(); else { operation_end(1, simulate); return -1; } } operation_end(0, simulate); return 0; } if (function == "fixpermissions") { operation_start("Fix Permissions"); LOGI("fix permissions started!\n"); if (simulate) { simulate_progress_bar(); } else fix_perms(); LOGI("fix permissions DONE!\n"); operation_end(0, simulate); return 0; } if (function == "dd") { operation_start("imaging"); if (simulate) { simulate_progress_bar(); } else { char cmd[512]; sprintf(cmd, "dd %s", arg.c_str()); __system(cmd); } operation_end(0, simulate); return 0; } if (function == "partitionsd") { operation_start("Partition SD Card"); if (simulate) { simulate_progress_bar(); } else { int allow_partition; DataManager::GetValue(TW_ALLOW_PARTITION_SDCARD, allow_partition); if (allow_partition == 0) { ui_print("This device does not have a real SD Card!\nAborting!\n"); } else { // Below seen in Koush's recovery char sddevice[256]; Volume *vol = volume_for_path("/sdcard"); strcpy(sddevice, vol->device); // Just need block not whole partition sddevice[strlen("/dev/block/mmcblkX")] = NULL; char es[64]; std::string ext_format; int ext, swap; DataManager::GetValue("tw_sdext_size", ext); DataManager::GetValue("tw_swap_size", swap); DataManager::GetValue("tw_sdpart_file_system", ext_format); sprintf(es, "/sbin/sdparted -es %dM -ss %dM -efs %s -s > /cache/part.log",ext,swap,ext_format.c_str()); LOGI("\nrunning script: %s\n", es); run_script("\nContinue partitioning?", "\nPartitioning sdcard : ", es, "\nunable to execute parted!\n(%s)\n", "\nOops... something went wrong!\nPlease check the recovery log!\n", "\nPartitioning complete!\n\n", "\nPartitioning aborted!\n\n", 0); // recreate TWRP folder and rewrite settings - these will be gone after sdcard is partitioned ensure_path_mounted(SDCARD_ROOT); mkdir("/sdcard/TWRP", 0777); DataManager::Flush(); DataManager::SetValue(TW_ZIP_EXTERNAL_VAR, "/sdcard"); if (DataManager::GetIntValue(TW_USE_EXTERNAL_STORAGE) == 1) DataManager::SetValue(TW_ZIP_LOCATION_VAR, "/sdcard"); update_system_details(); } } operation_end(0, simulate); return 0; } if (function == "installhtcdumlock") { operation_start("Install HTC Dumlock"); if (simulate) { simulate_progress_bar(); } else install_htc_dumlock(); operation_end(0, simulate); return 0; } if (function == "htcdumlockrestoreboot") { operation_start("HTC Dumlock Restore Boot"); if (simulate) { simulate_progress_bar(); } else htc_dumlock_restore_original_boot(); operation_end(0, simulate); return 0; } if (function == "htcdumlockreflashrecovery") { operation_start("HTC Dumlock Reflash Recovery"); if (simulate) { simulate_progress_bar(); } else htc_dumlock_reflash_recovery_to_boot(); operation_end(0, simulate); return 0; } if (function == "cmd") { int op_status = 0; operation_start("Command"); ui_print("Running command: '%s'\n", arg.c_str()); if (simulate) { simulate_progress_bar(); } else { op_status = __system(arg.c_str()); if (op_status != 0) op_status = 1; } operation_end(op_status, simulate); return 0; } if (function == "reinjecttwrp") { int op_status = 0; operation_start("ReinjectTWRP"); ui_print("Injecting TWRP into boot image...\n"); if (simulate) { simulate_progress_bar(); } else { __system("injecttwrp --dump /tmp/backup_recovery_ramdisk.img /tmp/injected_boot.img --flash"); ui_print("TWRP injection complete.\n"); } operation_end(op_status, simulate); return 0; } } else { pthread_t t; pthread_create(&t, NULL, thread_start, this); return 0; } return -1; }