1 files changed, 1134 insertions, 0 deletions

diff --git a/gui/action.cpp b/gui/action.cpp
new file mode 100644
index 000000000..6ca607b34
--- /dev/null
+++ b/gui/action.cpp
@@ -0,0 +1,1134 @@
+// image.cpp - GUIImage object
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <linux/input.h>
+#include <time.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include <string>
+#include <sstream>
+#include "../partitions.hpp"
+
+extern "C" {
+#include "../common.h"
+#include "../roots.h"
+#include "../tw_reboot.h"
+#include "../minuitwrp/minui.h"
+#include "../recovery_ui.h"
+#include "../extra-functions.h"
+#include "../variables.h"
+
+int install_zip_package(const char* zip_path_filename);
+void fix_perms();
+void wipe_dalvik_cache(void);
+int check_backup_name(int show_error);
+void wipe_battery_stats(void);
+void wipe_rotate_data(void);
+int usb_storage_enable(void);
+int usb_storage_disable(void);
+int __system(const char *command);
+FILE * __popen(const char *program, const char *type);
+int __pclose(FILE *iop);
+void run_script(const char *str1, const char *str2, const char *str3, const char *str4, const char *str5, const char *str6, const char *str7, int request_confirm);
+void update_tz_environment_variables();
+void install_htc_dumlock(void);
+void htc_dumlock_restore_original_boot(void);
+void htc_dumlock_reflash_recovery_to_boot(void);
+int check_for_script_file(void);
+int gui_console_only();
+int run_script_file(void);
+int gui_start();
+};
+
+#include "rapidxml.hpp"
+#include "objects.hpp"
+
+
+void curtainClose(void);
+
+GUIAction::GUIAction(xml_node<>* node)
+    : Conditional(node)
+{
+    xml_node<>* child;
+    xml_node<>* actions;
+    xml_attribute<>* attr;
+
+    mKey = 0;
+
+    if (!node)  return;
+
+    // First, get the action
+    actions = node->first_node("actions");
+    if (actions)    child = actions->first_node("action");
+    else            child = node->first_node("action");
+
+    if (!child) return;
+
+    while (child)
+    {
+        Action action;
+
+        attr = child->first_attribute("function");
+        if (!attr)  return;
+    
+        action.mFunction = attr->value();
+        action.mArg = child->value();
+        mActions.push_back(action);
+
+        child = child->next_sibling("action");
+    }
+
+    // Now, let's get either the key or region
+    child = node->first_node("touch");
+    if (child)
+    {
+        attr = child->first_attribute("key");
+        if (attr)
+        {
+            std::string key = attr->value();
+    
+            mKey = getKeyByName(key);
+        }
+        else
+        {
+            attr = child->first_attribute("x");
+            if (!attr)  return;
+            mActionX = atol(attr->value());
+            attr = child->first_attribute("y");
+            if (!attr)  return;
+            mActionY = atol(attr->value());
+            attr = child->first_attribute("w");
+            if (!attr)  return;
+            mActionW = atol(attr->value());
+            attr = child->first_attribute("h");
+            if (!attr)  return;
+            mActionH = atol(attr->value());
+        }
+    }
+}
+
+int GUIAction::NotifyTouch(TOUCH_STATE state, int x, int y)
+{
+    if (state == TOUCH_RELEASE)
+        doActions();
+
+    return 0;
+}
+
+int GUIAction::NotifyKey(int key)
+{
+	if (!mKey || key != mKey)
+		return 1;
+
+	doActions();
+	return 0;
+}
+
+int GUIAction::NotifyVarChange(std::string varName, std::string value)
+{
+    if (varName.empty() && !isConditionValid() && !mKey && !mActionW)
+        doActions();
+
+    // This handles notifying the condition system of page start
+    if (varName.empty() && isConditionValid())
+        NotifyPageSet();
+
+    if ((varName.empty() || IsConditionVariable(varName)) && isConditionValid() && isConditionTrue())
+        doActions();
+
+    return 0;
+}
+
+void GUIAction::simulate_progress_bar(void)
+{
+	ui_print("Simulating actions...\n");
+	for (int i = 0; i < 5; i++)
+	{
+		usleep(500000);
+		DataManager::SetValue("ui_progress", i * 20);
+	}
+}
+
+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", "main"))
+    {
+        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::doActions()
+{
+	if (mActions.size() < 1)    return -1;
+    if (mActions.size() == 1)
+		return doAction(mActions.at(0), 0);
+
+    // For multi-action, we always use a thread
+    pthread_t t;
+    pthread_create(&t, NULL, thread_start, this);
+
+    return 0;
+}
+
+void* GUIAction::thread_start(void *cookie)
+{
+    GUIAction* ourThis = (GUIAction*) cookie;
+
+	DataManager::SetValue(TW_ACTION_BUSY, 1);
+
+    if (ourThis->mActions.size() > 1)
+    {
+        std::vector<Action>::iterator iter;
+        for (iter = ourThis->mActions.begin(); iter != ourThis->mActions.end(); iter++)
+            ourThis->doAction(*iter, 1);
+    }
+    else
+    {
+        ourThis->doAction(ourThis->mActions.at(0), 1);
+    }
+	int check = 0;
+	DataManager::GetValue("tw_background_thread_running", check);
+	if (check == 0)
+		DataManager::SetValue(TW_ACTION_BUSY, 0);
+    return NULL;
+}
+
+void GUIAction::operation_start(const string operation_name)
+{
+	DataManager::SetValue(TW_ACTION_BUSY, 1);
+	DataManager::SetValue("ui_progress", 0);
+	DataManager::SetValue("tw_operation", operation_name);
+	DataManager::SetValue("tw_operation_status", 0);
+	DataManager::SetValue("tw_operation_state", 0);
+}
+
+void GUIAction::operation_end(const int operation_status, const int simulate)
+{
+	int simulate_fail;
+
+	DataManager::SetValue("ui_progress", 100);
+	if (simulate) {
+		DataManager::GetValue(TW_SIMULATE_FAIL, simulate_fail);
+		if (simulate_fail != 0)
+			DataManager::SetValue("tw_operation_status", 1);
+		else
+			DataManager::SetValue("tw_operation_status", 0);
+	} else {
+		if (operation_status != 0)
+			DataManager::SetValue("tw_operation_status", 1);
+		else
+			DataManager::SetValue("tw_operation_status", 0);
+	}
+	DataManager::SetValue("tw_operation_state", 1);
+	DataManager::SetValue(TW_ACTION_BUSY, 0);
+}
+
+int GUIAction::doAction(Action action, int isThreaded /* = 0 */)
+{
+	static string zip_queue[10];
+	static int zip_queue_index;
+	static pthread_t terminal_command;
+	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 (TWPartitionManager::Mount_By_Path(theme_path.c_str(), 1) < 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")
+    {
+		string Restore_Name;
+		DataManager::GetValue("tw_restore", Restore_Name);
+		TWPartitionManager::Set_Restore_Files(Restore_Name);
+        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();
+			TWPartitionManager::Update_System_Details();
+			TWPartitionManager::Mount_Current_Storage();
+		}
+		operation_end(0, simulate);
+	}
+	
+	if (function == "copylog")
+	{
+		operation_start("Copy Log");
+		if (!simulate)
+		{
+			char command[255];
+
+			TWPartitionManager::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);
+		} else if (arg == "external") {
+			DataManager::SetValue(TW_USE_EXTERNAL_STORAGE, 1);
+		}
+		if (TWPartitionManager::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);
+			} else if (arg == "external") {
+				DataManager::SetValue(TW_USE_EXTERNAL_STORAGE, 0);
+			}
+		}
+		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")
+	{
+		operation_start("Sleep");
+		usleep(atoi(arg.c_str()));
+		operation_end(0, simulate);
+		return 0;
+	}
+
+    if (isThreaded)
+    {
+        if (function == "fileexists")
+		{
+			struct stat st;
+			string newpath = arg + "/.";
+
+			operation_start("FileExists");
+			if (stat(arg.c_str(), &st) == 0 || stat(newpath.c_str(), &st) == 0)
+				operation_end(0, simulate);
+			else
+				operation_end(1, simulate);
+		}
+
+		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);
+
+			int ret_val = 0;
+
+			if (simulate) {
+				simulate_progress_bar();
+			} else {
+				if (arg == "data")
+					TWPartitionManager::Factory_Reset();
+				else if (arg == "battery")
+					wipe_battery_stats();
+				else if (arg == "rotate")
+					wipe_rotate_data();
+				else if (arg == "dalvik")
+					wipe_dalvik_cache();
+				else if (arg == "DATAMEDIA") {
+					LOGE("TODO: Implement formatting of datamedia device!\n");
+					ret_val = 1; //format_data_media();
+					int has_datamedia, dual_storage;
+
+					DataManager::GetValue(TW_HAS_DATA_MEDIA, has_datamedia);
+					DataManager::GetValue(TW_HAS_DUAL_STORAGE, dual_storage);
+					if (has_datamedia && !dual_storage) {
+						system("umount /sdcard");
+						system("mount /data/media /sdcard");
+					}
+				} else if (arg == "INTERNAL") {
+					int has_datamedia, dual_storage;
+
+					DataManager::GetValue(TW_HAS_DATA_MEDIA, has_datamedia);
+					if (has_datamedia) {
+						TWPartitionManager::Mount_By_Path("/data", 1);
+						__system("rm -rf /data/media");
+						__system("cd /data && mkdir media && chmod 775 media");
+						DataManager::GetValue(TW_HAS_DUAL_STORAGE, dual_storage);
+						if (!dual_storage) {
+							system("umount /sdcard");
+							system("mount /data/media /sdcard");
+						}
+					} else {
+						ret_val = 0;
+						LOGE("Wipe not implemented yet!\n");
+					}
+				} else if (arg == "EXTERNAL") {
+					ret_val = 0;
+					LOGE("Wipe not implemented yet!\n");
+				} else
+					TWPartitionManager::Wipe_By_Path(arg);
+
+				if (arg == "/sdcard") {
+					TWPartitionManager::Mount_By_Path("/sdcard", 1);
+					mkdir("/sdcard/TWRP", 0777);
+					DataManager::Flush();
+				}
+			}
+			TWPartitionManager::Update_System_Details();
+			if (ret_val != 0)
+				ret_val = 1;
+            operation_end(ret_val, simulate);
+            return 0;
+        }
+		if (function == "refreshsizes")
+		{
+			operation_start("Refreshing Sizes");
+			if (simulate) {
+				simulate_progress_bar();
+			} else
+				TWPartitionManager::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") {
+					string Backup_Name;
+					DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
+					if (Backup_Name == "(Current Date)" || Backup_Name == "0" || Backup_Name == "(" || check_backup_name(1))
+						TWPartitionManager::Run_Backup(Backup_Name);
+					else
+						return -1;
+					DataManager::SetValue(TW_BACKUP_NAME, "(Current Date)");
+				} else if (arg == "restore") {
+					string Restore_Name;
+					DataManager::GetValue("tw_restore", Restore_Name);
+					TWPartitionManager::Run_Restore(Restore_Name);
+				} 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];
+					char mkdir_path[255];
+					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, sd_path;
+					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 ext3 -s > /cache/part.log",ext,swap);
+					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
+#ifdef TW_EXTERNAL_STORAGE_PATH
+					TWPartitionManager::Mount_By_Path(EXPAND(TW_EXTERNAL_STORAGE_PATH));
+					DataManager::GetValue(TW_EXTERNAL_PATH, sd_path);
+					memset(mkdir_path, 0, sizeof(mkdir_path));
+					sprintf(mkdir_path, "%s/TWRP", sd_path.c_str());
+#else
+					TWPartitionManager::Mount_By_Path("/sdcard", 1);
+					strcpy(mkdir_path, "/sdcard/TWRP");
+#endif
+					mkdir(mkdir_path, 0777);
+					DataManager::Flush();
+#ifdef TW_EXTERNAL_STORAGE_PATH
+					DataManager::SetValue(TW_ZIP_EXTERNAL_VAR, EXPAND(TW_EXTERNAL_STORAGE_PATH));
+					if (DataManager::GetIntValue(TW_USE_EXTERNAL_STORAGE) == 1)
+						DataManager::SetValue(TW_ZIP_LOCATION_VAR, EXPAND(TW_EXTERNAL_STORAGE_PATH));
+#else
+					DataManager::SetValue(TW_ZIP_EXTERNAL_VAR, "/sdcard");
+					if (DataManager::GetIntValue(TW_USE_EXTERNAL_STORAGE) == 1)
+						DataManager::SetValue(TW_ZIP_LOCATION_VAR, "/sdcard");
+#endif
+					// This is sometimes needed to make a healthy ext4 partition
+					if (ext > 0 && strcmp(ext_format.c_str(), "ext4") == 0) {
+						char command[256];
+						LOGE("Fix this format command!\n");
+						//sprintf(command, "mke2fs -t ext4 -m 0 %s", sde.blk);
+						ui_print("Formatting sd-ext as ext4...\n");
+						LOGI("Formatting sd-ext after partitioning, command: '%s'\n", command);
+						__system(command);
+						ui_print("DONE\n");
+					}
+
+					TWPartitionManager::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");
+			LOGI("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 == "terminalcommand")
+		{
+			int op_status = 0;
+			string cmdpath, command;
+
+			DataManager::GetValue("tw_terminal_location", cmdpath);
+			operation_start("CommandOutput");
+			ui_print("%s # %s\n", cmdpath.c_str(), arg.c_str());
+			if (simulate) {
+				simulate_progress_bar();
+				operation_end(op_status, simulate);
+			} else {
+				command = "cd \"";
+				command += cmdpath;
+				command += "\" && ";
+				command += arg;
+				LOGI("Actual command is: '%s'\n", command.c_str());
+				DataManager::SetValue("tw_terminal_command_thread", command);
+				DataManager::SetValue("tw_terminal_state", 1);
+				DataManager::SetValue("tw_background_thread_running", 1);
+				op_status = pthread_create(&terminal_command, NULL, command_thread, NULL);
+				if (op_status != 0) {
+					LOGE("Error starting terminal command thread, %i.\n", op_status);
+					DataManager::SetValue("tw_terminal_state", 0);
+					DataManager::SetValue("tw_background_thread_running", 0);
+					operation_end(1, simulate);
+				}
+			}
+			return 0;
+		}
+		if (function == "killterminal")
+		{
+			int op_status = 0;
+
+			LOGI("Sending kill command...\n");
+			operation_start("KillCommand");
+			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;
+		}
+		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;
+		}
+		if (function == "checkbackupname")
+		{
+			int op_status = 0;
+
+			operation_start("CheckBackupName");
+			if (simulate) {
+				simulate_progress_bar();
+			} else {
+				op_status = check_backup_name(1);
+				if (op_status != 0)
+					op_status = 1;
+			}
+
+			operation_end(op_status, simulate);
+			return 0;
+		}
+		if (function == "decrypt")
+		{
+			int op_status = 0;
+
+			operation_start("Decrypt");
+			if (simulate) {
+				simulate_progress_bar();
+			} else {
+				string Password;
+				DataManager::GetValue("tw_crypto_password", Password);
+				op_status = TWPartitionManager::Decrypt_Device(Password);
+				if (op_status != 0)
+					op_status = 1;
+				else {
+					int load_theme = 1;
+
+					DataManager::SetValue(TW_IS_ENCRYPTED, 0);
+					DataManager::ReadSettingsFile();
+
+					if (check_for_script_file()) {
+						ui_print("Processing OpenRecoveryScript file...\n");
+						if (run_script_file() == 0) {
+							usleep(2000000); // Sleep for 2 seconds before rebooting
+							tw_reboot(rb_system);
+							load_theme = 0;
+						}
+					}
+
+					if (load_theme) {
+						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) {
+							struct stat st;
+							int check = 0;
+							std::string theme_path;
+
+							theme_path = DataManager::GetSettingsStoragePath();
+							if (TWPartitionManager::Mount_By_Path(theme_path.c_str(), 1) < 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 && stat(theme_path.c_str(), &st) == 0) {
+								if (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");
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+
+			operation_end(op_status, simulate);
+			return 0;
+		}
+    }
+    else
+    {
+        pthread_t t;
+        pthread_create(&t, NULL, thread_start, this);
+        return 0;
+    }
+    return -1;
+}
+
+int GUIAction::getKeyByName(std::string key)
+{
+    if (key == "home")          return KEY_HOME;
+    else if (key == "menu")     return KEY_MENU;
+    else if (key == "back")     return KEY_BACK;
+    else if (key == "search")   return KEY_SEARCH;
+    else if (key == "voldown")  return KEY_VOLUMEDOWN;
+    else if (key == "volup")    return KEY_VOLUMEUP;
+    else if (key == "power") {
+		int ret_val;
+		DataManager::GetValue(TW_POWER_BUTTON, ret_val);
+		if (!ret_val)
+			return KEY_POWER;
+		else
+			return ret_val;
+	}
+
+    return atol(key.c_str());
+}
+
+void* GUIAction::command_thread(void *cookie)
+{
+	string command;
+	FILE* fp;
+	char line[512];
+
+	DataManager::GetValue("tw_terminal_command_thread", command);
+	fp = __popen(command.c_str(), "r");
+	if (fp == NULL) {
+		LOGE("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
+				bytes_read = read(fd, line, sizeof(line));
+				if (bytes_read > 0)
+					ui_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 NULL;
+}