summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--Android.mk6
-rw-r--r--adb_install.cpp4
-rw-r--r--gui/action.cpp43
-rwxr-xr-xgui/devices/800x1280/res/ui.xml15
-rw-r--r--partition.cpp266
-rw-r--r--partitionmanager.cpp471
-rw-r--r--partitions.hpp9
-rw-r--r--prebuilt/Android.mk1
-rw-r--r--twrp-functions.cpp71
-rw-r--r--twrp-functions.hpp15
10 files changed, 773 insertions, 128 deletions
diff --git a/Android.mk b/Android.mk
index 304e60727..caa6b09ed 100644
--- a/Android.mk
+++ b/Android.mk
@@ -66,14 +66,14 @@ LOCAL_STATIC_LIBRARIES :=
LOCAL_SHARED_LIBRARIES :=
LOCAL_STATIC_LIBRARIES += libmtdutils
-LOCAL_STATIC_LIBRARIES += libext4_utils libminadbd libminzip libunz
+LOCAL_STATIC_LIBRARIES += libminadbd libminzip libunz
LOCAL_STATIC_LIBRARIES += libminuitwrp libpixelflinger_static libpng libjpegtwrp libgui
-LOCAL_SHARED_LIBRARIES += libz libc libstlport libcutils libstdc++ libmincrypt
+LOCAL_SHARED_LIBRARIES += libz libc libstlport libcutils libstdc++ libmincrypt libext4_utils
ifeq ($(TARGET_USERIMAGES_USE_EXT4), true)
LOCAL_CFLAGS += -DUSE_EXT4
LOCAL_C_INCLUDES += system/extras/ext4_utils
- LOCAL_STATIC_LIBRARIES += libext4_utils
+ #LOCAL_STATIC_LIBRARIES += libext4_utils
endif
ifeq ($(HAVE_SELINUX), true)
diff --git a/adb_install.cpp b/adb_install.cpp
index a226ea571..12bce1cca 100644
--- a/adb_install.cpp
+++ b/adb_install.cpp
@@ -32,6 +32,8 @@
#include "adb_install.h"
extern "C" {
#include "minadbd/adb.h"
+#include "twinstall.h"
+int TWinstall_zip(const char* path, int* wipe_cache);
}
static RecoveryUI* ui = NULL;
@@ -106,5 +108,5 @@ apply_from_adb(RecoveryUI* ui_, int* wipe_cache, const char* install_file) {
}
return INSTALL_ERROR;
}
- return install_package(ADB_SIDELOAD_FILENAME, wipe_cache, install_file);
+ return TWinstall_zip(ADB_SIDELOAD_FILENAME, wipe_cache);
}
diff --git a/gui/action.cpp b/gui/action.cpp
index b050febd0..3d6c9ebaa 100644
--- a/gui/action.cpp
+++ b/gui/action.cpp
@@ -21,6 +21,9 @@
#include "../partitions.hpp"
#include "../twrp-functions.hpp"
+#include "../ui.h"
+#include "../adb_install.h"
+
extern "C" {
#include "../common.h"
#include "../roots.h"
@@ -31,6 +34,8 @@ extern "C" {
#include "../variables.h"
#include "../twinstall.h"
+#include "../minadbd/adb.h"
+
int TWinstall_zip(const char* path, int* wipe_cache);
void wipe_dalvik_cache(void);
int check_backup_name(int show_error);
@@ -55,6 +60,8 @@ int gui_start();
#include "rapidxml.hpp"
#include "objects.hpp"
+extern RecoveryUI* ui;
+
void curtainClose(void);
GUIAction::GUIAction(xml_node<>* node)
@@ -733,6 +740,7 @@ int GUIAction::doAction(Action action, int isThreaded /* = 0 */)
if (function == "nandroid")
{
operation_start("Nandroid");
+ int ret = 0;
if (simulate) {
DataManager::SetValue("tw_partition", "Simulation");
@@ -741,21 +749,27 @@ int GUIAction::doAction(Action action, int isThreaded /* = 0 */)
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))
- PartitionManager.Run_Backup(Backup_Name);
- else
+ if (Backup_Name == "(Current Date)" || Backup_Name == "0" || Backup_Name == "(" || check_backup_name(1) == 0)
+ ret = PartitionManager.Run_Backup();
+ else {
+ operation_end(1, simulate);
return -1;
+ }
DataManager::SetValue(TW_BACKUP_NAME, "(Current Date)");
} else if (arg == "restore") {
string Restore_Name;
DataManager::GetValue("tw_restore", Restore_Name);
- PartitionManager.Run_Restore(Restore_Name);
+ ret = PartitionManager.Run_Restore(Restore_Name);
} else {
operation_end(1, simulate);
return -1;
}
}
- operation_end(0, simulate);
+ if (ret == false)
+ ret = 1; // 1 for failure
+ else
+ ret = 0; // 0 for success
+ operation_end(ret, simulate);
return 0;
}
if (function == "fixpermissions")
@@ -1048,6 +1062,25 @@ LOGE("TODO: Implement ORS support\n");
operation_end(op_status, simulate);
return 0;
}
+ if (function == "adbsideload")
+ {
+ int ret = 0;
+
+ operation_start("Sideload");
+ if (simulate) {
+ simulate_progress_bar();
+ } else {
+ int wipe_cache = 0;
+ ui_print("Starting ADB sideload feature...\n");
+ __system("touch /tmp/update.zip");
+ ret = apply_from_adb(ui, &wipe_cache, "/tmp/last_install");
+ LOGI("Result was: %i\n", ret);
+ if (ret != 0)
+ ret = 1;
+ }
+ operation_end(ret, simulate);
+ return 0;
+ }
}
else
{
diff --git a/gui/devices/800x1280/res/ui.xml b/gui/devices/800x1280/res/ui.xml
index 94468d8c0..decfcad55 100755
--- a/gui/devices/800x1280/res/ui.xml
+++ b/gui/devices/800x1280/res/ui.xml
@@ -2541,6 +2541,21 @@
</object>
<object type="button">
+ <placement x="%col1_x%" y="%row4_y%" />
+ <font resource="font" color="%button_text_color%" />
+ <text>ADB Sideload</text>
+ <image resource="main_button" />
+ <actions>
+ <action function="set">tw_action=adbsideload</action>
+ <action function="set">tw_action_text1=ADB Sideload</action>
+ <action function="set">tw_action_text2=Usage: adb sideload filename.zip</action>
+ <action function="set">tw_complete_text1=ADB Sideload Complete</action>
+ <action function="set">tw_slider_text=Swipe to Wipe</action>
+ <action function="page">action_page</action>
+ </actions>
+ </object>
+
+ <object type="button">
<condition var1="tw_show_dumlock" var2="1" />
<placement x="%col2_x%" y="%row4_y%" />
<font resource="font" color="%button_text_color%" />
diff --git a/partition.cpp b/partition.cpp
index f4fa0d86e..521722774 100644
--- a/partition.cpp
+++ b/partition.cpp
@@ -37,11 +37,11 @@
#include "common.h"
#include "partitions.hpp"
#include "data.hpp"
+#include "twrp-functions.hpp"
extern "C" {
#include "mtdutils/mtdutils.h"
#include "mtdutils/mounts.h"
- #include "extra-functions.h"
- int __system(const char *command);
+ #include "makelist.h"
}
TWPartition::TWPartition(void) {
@@ -333,7 +333,7 @@ bool TWPartition::Is_Image(string File_System) {
}
bool TWPartition::Make_Dir(string Path, bool Display_Error) {
- if (!Path_Exists(Path)) {
+ if (!TWFunc::Path_Exists(Path)) {
if (mkdir(Path.c_str(), 0777) == -1) {
if (Display_Error)
LOGE("Can not create '%s' folder.\n", Path.c_str());
@@ -479,7 +479,7 @@ bool TWPartition::Get_Size_Via_df(bool Display_Error) {
min_len = Actual_Block_Device.size() + 2;
sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
- __system(command);
+ system(command);
fp = fopen("/tmp/dfoutput.txt", "rt");
if (fp == NULL) {
LOGI("Unable to open /tmp/dfoutput.txt.\n");
@@ -518,46 +518,6 @@ bool TWPartition::Get_Size_Via_df(bool Display_Error) {
return true;
}
-unsigned long long TWPartition::Get_Folder_Size(string Path, bool Display_Error) {
- DIR* d;
- struct dirent* de;
- struct stat st;
- char path2[1024], filename[1024];
- unsigned long long dusize = 0;
-
- // Make a copy of path in case the data in the pointer gets overwritten later
- strcpy(path2, Path.c_str());
-
- d = opendir(path2);
- if (d == NULL)
- {
- LOGE("error opening '%s'\n", path2);
- return 0;
- }
-
- while ((de = readdir(d)) != NULL)
- {
- if (de->d_type == DT_DIR && strcmp(de->d_name, ".") != 0 && strcmp(de->d_name, "..") != 0)
- {
- strcpy(filename, path2);
- strcat(filename, "/");
- strcat(filename, de->d_name);
- dusize += Get_Folder_Size(filename, Display_Error);
- }
- else if (de->d_type == DT_REG)
- {
- strcpy(filename, path2);
- strcat(filename, "/");
- strcat(filename, de->d_name);
- stat(filename, &st);
- dusize += (unsigned long long)(st.st_size);
- }
- }
- closedir(d);
-
- return dusize;
-}
-
bool TWPartition::Find_Partition_Size(void) {
FILE* fp;
char line[512];
@@ -590,16 +550,6 @@ bool TWPartition::Find_Partition_Size(void) {
return false;
}
-bool TWPartition::Path_Exists(string Path) {
- // Check to see if the Path exists
- struct statfs st;
-
- if (statfs(Path.c_str(), &st) != 0)
- return false;
- else
- return true;
-}
-
void TWPartition::Flip_Block_Device(void) {
string temp;
@@ -655,7 +605,7 @@ bool TWPartition::Mount(bool Display_Error) {
string Command;
Command = "mount " + Symlink_Path + " " + Symlink_Mount_Point;
- __system(Command.c_str());
+ system(Command.c_str());
}
return true;
}
@@ -727,7 +677,38 @@ bool TWPartition::Backup(string backup_folder) {
return false;
}
+bool TWPartition::Check_MD5(string restore_folder) {
+ string Full_Filename;
+ char split_filename[512];
+ int index = 0;
+
+ Full_Filename = restore_folder + "/" + Backup_FileName;
+ LOGI("Full_Filename: '%s'\n", Full_Filename.c_str());
+ if (!TWFunc::Path_Exists(Full_Filename)) {
+ // This is a split archive, we presume
+ sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
+ while (index < 1000 && TWFunc::Path_Exists(split_filename)) {
+ if (TWFunc::Check_MD5(split_filename) == 0) {
+ LOGE("MD5 failed to match on '%s'.\n", split_filename);
+ return false;
+ }
+ index++;
+ sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
+ LOGI("Full_Filename: '%s'\n", Full_Filename.c_str());
+ }
+ } else {
+ // Single file archive
+ if (TWFunc::Check_MD5(Full_Filename) == 0) {
+ LOGE("MD5 failed to match on '%s'.\n", split_filename);
+ return false;
+ } else
+ return true;
+ }
+ return false;
+}
+
bool TWPartition::Restore(string restore_folder) {
+ ui_print("Restoring %s...\n", Display_Name.c_str());
if (Backup_Method == FILES)
return Restore_Tar(restore_folder);
else if (Backup_Method == DD)
@@ -797,7 +778,7 @@ void TWPartition::Check_FS_Type() {
Find_Actual_Block_Device();
blkCommand = "blkid " + Actual_Block_Device + " > /tmp/blkidoutput.txt";
- __system(blkCommand.c_str());
+ system(blkCommand.c_str());
fp = fopen("/tmp/blkidoutput.txt", "rt");
while (fgets(blkOutput, sizeof(blkOutput), fp) != NULL)
{
@@ -847,7 +828,7 @@ void TWPartition::Check_FS_Type() {
Current_File_System = arg;
}
}
- __pclose(fp);
+ fclose(fp);
return;
}
@@ -855,14 +836,14 @@ bool TWPartition::Wipe_EXT23() {
if (!UnMount(true))
return false;
- if (Path_Exists("/sbin/mke2fs")) {
+ if (TWFunc::Path_Exists("/sbin/mke2fs")) {
char command[512];
ui_print("Formatting %s using mke2fs...\n", Display_Name.c_str());
Find_Actual_Block_Device();
sprintf(command, "mke2fs -t %s -m 0 %s", Current_File_System.c_str(), Actual_Block_Device.c_str());
LOGI("mke2fs command: %s\n", command);
- if (__system(command) == 0) {
+ if (system(command) == 0) {
ui_print("Done.\n");
return true;
} else {
@@ -879,7 +860,7 @@ bool TWPartition::Wipe_EXT4() {
if (!UnMount(true))
return false;
- if (Path_Exists("/sbin/make_ext4fs")) {
+ if (TWFunc::Path_Exists("/sbin/make_ext4fs")) {
string Command;
ui_print("Formatting %s using make_ext4fs...\n", Display_Name.c_str());
@@ -894,7 +875,7 @@ bool TWPartition::Wipe_EXT4() {
}
Command += " " + Actual_Block_Device;
LOGI("make_ext4fs command: %s\n", Command.c_str());
- if (__system(Command.c_str()) == 0) {
+ if (system(Command.c_str()) == 0) {
ui_print("Done.\n");
return true;
} else {
@@ -913,14 +894,14 @@ bool TWPartition::Wipe_FAT() {
if (Backup_Name == "and-sec") // Don't format if it's android secure
return Wipe_RMRF();
- if (Path_Exists("/sbin/mkdosfs")) {
+ if (TWFunc::Path_Exists("/sbin/mkdosfs")) {
if (!UnMount(true))
return false;
ui_print("Formatting %s using mkdosfs...\n", Display_Name.c_str());
Find_Actual_Block_Device();
sprintf(command,"mkdosfs %s", Actual_Block_Device.c_str()); // use mkdosfs to format it
- if (__system(command) == 0) {
+ if (system(command) == 0) {
ui_print("Done.\n");
return true;
} else {
@@ -981,7 +962,7 @@ bool TWPartition::Wipe_RMRF() {
}
LOGI("rm -rf command is: '%s'\n", cmd);
- __system(cmd);
+ system(cmd);
return true;
}
@@ -993,8 +974,8 @@ bool TWPartition::Wipe_Data_Without_Wiping_Media() {
return false;
ui_print("Wiping data without wiping /data/media ...\n");
- __system("rm -f /data/*");
- __system("rm -f /data/.*");
+ system("rm -f /data/*");
+ system("rm -f /data/.*");
DIR* d;
d = opendir("/data");
@@ -1005,7 +986,7 @@ bool TWPartition::Wipe_Data_Without_Wiping_Media() {
if (strcmp(de->d_name, "media") == 0) continue;
sprintf(cmd, "rm -fr /data/%s", de->d_name);
- __system(cmd);
+ system(cmd);
}
closedir(d);
}
@@ -1014,34 +995,142 @@ bool TWPartition::Wipe_Data_Without_Wiping_Media() {
}
bool TWPartition::Backup_Tar(string backup_folder) {
- LOGI("STUB TWPartition::Backup_Tar, backup_folder: '%s'\n", backup_folder.c_str());
- return 1;
+ char back_name[255];
+ string Full_FileName, Tar_Args, Command;
+ int use_compression;
+
+ if (!Mount(true))
+ return false;
+
+ ui_print("Backing up %s...\n", Display_Name.c_str());
+
+ DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression);
+ if (use_compression)
+ Tar_Args = "-cz";
+ else
+ Tar_Args = "-c";
+
+ sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
+ Backup_FileName = back_name;
+
+ Full_FileName = backup_folder + "/" + Backup_FileName;
+ if (Backup_Size > MAX_ARCHIVE_SIZE) {
+ // This backup needs to be split into multiple archives
+ LOGE("Multiple archive splitting is not implemented yet!\n");
+ return false;
+ } else {
+ if (Has_Data_Media)
+ Command = "cd " + Mount_Point + " && tar " + Tar_Args + " ./ --exclude='media*' -f '" + Full_FileName + "'";
+ else
+ Command = "cd " + Mount_Point + " && tar " + Tar_Args + " -f '" + Full_FileName + "' ./*";
+ LOGI("Backup command: '%s'\n", Command.c_str());
+ system(Command.c_str());
+ }
+ return true;
}
bool TWPartition::Backup_DD(string backup_folder) {
- LOGI("STUB TWPartition::Backup_DD, backup_folder: '%s'\n", backup_folder.c_str());
- return 1;
+ char back_name[255];
+ string Full_FileName, Command;
+ int use_compression;
+
+ ui_print("Backing up %s...\n", Display_Name.c_str());
+
+ sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
+ Backup_FileName = back_name;
+
+ Full_FileName = backup_folder + "/" + Backup_FileName;
+
+ Command = "dd if=" + Actual_Block_Device + " of='" + Full_FileName + "'";
+ LOGI("Backup command: '%s'\n", Command.c_str());
+ system(Command.c_str());
+ return true;
}
bool TWPartition::Backup_Dump_Image(string backup_folder) {
- LOGI("STUB TWPartition::Backup_Dump_Image, backup_folder: '%s'\n", backup_folder.c_str());
- return 1;
+ char back_name[255];
+ string Full_FileName, Command;
+ int use_compression;
+
+ ui_print("Backing up %s...\n", Display_Name.c_str());
+
+ sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
+ Backup_FileName = back_name;
+
+ Full_FileName = backup_folder + "/" + Backup_FileName;
+
+ Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
+ LOGI("Backup command: '%s'\n", Command.c_str());
+ system(Command.c_str());
+ return true;
}
bool TWPartition::Restore_Tar(string restore_folder) {
- LOGI("STUB TWPartition::Restore_Tar, backup_folder: '%s'\n", restore_folder.c_str());
- return 1;
+ size_t first_period, second_period;
+ string Restore_File_System, Full_FileName, Command;
+
+ LOGI("Restore filename is: %s\n", Backup_FileName.c_str());
+
+ // Parse backup filename to extract the file system before wiping
+ first_period = Backup_FileName.find(".");
+ if (first_period == string::npos) {
+ LOGE("Unable to find file system (first period).\n");
+ return false;
+ }
+ Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
+ second_period = Restore_File_System.find(".");
+ if (second_period == string::npos) {
+ LOGE("Unable to find file system (second period).\n");
+ return false;
+ }
+ Restore_File_System.resize(second_period);
+ LOGI("Restore file system is: '%s'.\n", Restore_File_System.c_str());
+ Current_File_System = Restore_File_System;
+ ui_print("Wiping %s...\n", Display_Name.c_str());
+ if (!Wipe())
+ return false;
+
+ if (!Mount(true))
+ return false;
+
+ Full_FileName = restore_folder + "/" + Backup_FileName;
+ ui_print("Restoring %s...\n", Display_Name.c_str());
+ if (!TWFunc::Path_Exists(Full_FileName)) {
+ // This backup is multiple archives
+ LOGE("Multiple archive not implemented yet.\n");
+ return false;
+ } else {
+ Command = "cd " + Mount_Point + " && tar -xf '" + Full_FileName + "'";
+ LOGI("Restore command: '%s'\n", Command.c_str());
+ system(Command.c_str());
+ }
+ return true;
}
bool TWPartition::Restore_DD(string restore_folder) {
- LOGI("STUB TWPartition::Restore_DD, backup_folder: '%s'\n", restore_folder.c_str());
- return 1;
+ string Full_FileName, Command;
+
+ ui_print("Restoring %s...\n", Display_Name.c_str());
+ Full_FileName = restore_folder + "/" + Backup_FileName;
+ Command = "dd bs=4096 if='" + Full_FileName + "' of=" + Actual_Block_Device;
+ LOGI("Restore command: '%s'\n", Command.c_str());
+ system(Command.c_str());
+ return true;
}
bool TWPartition::Restore_Flash_Image(string restore_folder) {
- LOGI("STUB TWPartition::Restore_Flash_Image, backup_folder: '%s'\n", restore_folder.c_str());
- // might erase image first just to ensure that it flashes
- return 1;
+ string Full_FileName, Command;
+
+ ui_print("Restoring %s...\n", Display_Name.c_str());
+ Full_FileName = restore_folder + "/" + Backup_FileName;
+ // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
+ Command = "erase_image " + MTD_Name;
+ LOGI("Erase command: '%s'\n", Command.c_str());
+ system(Command.c_str());
+ Command = "flash_image " + MTD_Name + " '" + Full_FileName + "'";
+ LOGI("Restore command: '%s'\n", Command.c_str());
+ system(Command.c_str());
+ return true;
}
bool TWPartition::Update_Size(bool Display_Error) {
@@ -1064,7 +1153,8 @@ bool TWPartition::Update_Size(bool Display_Error) {
if (Has_Data_Media) {
if (Mount(Display_Error)) {
unsigned long long data_media_used, actual_data;
- data_media_used = Get_Folder_Size("/data/media", Display_Error);
+ Used = TWFunc::Get_Folder_Size("/data", Display_Error);
+ data_media_used = TWFunc::Get_Folder_Size("/data/media", Display_Error);
actual_data = Used - data_media_used;
Backup_Size = actual_data;
int bak = (int)(Backup_Size / 1048576LLU);
@@ -1082,12 +1172,12 @@ bool TWPartition::Update_Size(bool Display_Error) {
void TWPartition::Find_Actual_Block_Device(void) {
if (Is_Decrypted) {
Actual_Block_Device = Decrypted_Block_Device;
- if (Path_Exists(Primary_Block_Device))
+ if (TWFunc::Path_Exists(Primary_Block_Device))
Is_Present = true;
- } else if (Path_Exists(Primary_Block_Device)) {
+ } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Is_Present = true;
Actual_Block_Device = Primary_Block_Device;
- } else if (!Alternate_Block_Device.empty() && Path_Exists(Alternate_Block_Device)) {
+ } else if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Flip_Block_Device();
Actual_Block_Device = Primary_Block_Device;
Is_Present = true;
@@ -1102,10 +1192,10 @@ void TWPartition::Recreate_Media_Folder(void) {
LOGE("Unable to recreate /data/media folder.\n");
} else {
LOGI("Recreating /data/media folder.\n");
- __system("cd /data && mkdir media && chmod 755 media");
+ system("cd /data && mkdir media && chmod 755 media");
Command = "umount " + Symlink_Mount_Point;
- __system(Command.c_str());
+ system(Command.c_str());
Command = "mount " + Symlink_Path + " " + Symlink_Mount_Point;
- __system(Command.c_str());
+ system(Command.c_str());
}
-} \ No newline at end of file
+}
diff --git a/partitionmanager.cpp b/partitionmanager.cpp
index 7ff5e8e05..a16678307 100644
--- a/partitionmanager.cpp
+++ b/partitionmanager.cpp
@@ -117,6 +117,9 @@ int TWPartitionManager::Mount_By_Path(string Path, bool Display_Error) {
bool found = false;
string Local_Path = TWFunc::Get_Root_Path(Path);
+ if (Local_Path == "/tmp")
+ return true;
+
// Iterate through all partitions
for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
@@ -326,17 +329,443 @@ TWPartition* TWPartitionManager::Find_Partition_By_Name(string Name) {
return NULL;
}
-int TWPartitionManager::Run_Backup(string Backup_Name) {
- LOGI("STUB TWPartitionManager::Run_Backup, Backup_Name: '%s'\n", Backup_Name.c_str());
- return 1;
+bool TWPartitionManager::Make_MD5(bool generate_md5, string Backup_Folder, string Backup_Filename)
+{
+ char command[512];
+ string Full_File = Backup_Folder + Backup_Filename;
+
+ if (!generate_md5) {
+ LOGI("MD5 disabled\n");
+ return true;
+ }
+
+ ui_print(" * Generating md5...\n");
+
+ if (TWFunc::Path_Exists(Full_File)) {
+ sprintf(command, "cd '%s' && md5sum %s > %s.md5",Backup_Folder.c_str(), Backup_Filename.c_str(), Backup_Filename.c_str());
+ LOGI("MD5 command is: '%s'\n", command);
+ if (system(command) == 0) {
+ ui_print("....MD5 Created.\n");
+ return true;
+ } else {
+ ui_print("....MD5 Error.\n");
+ return false;
+ }
+ } else {
+ char filename[512];
+ int index = 0;
+
+ sprintf(filename, "%s%03i", Full_File.c_str(), index);
+ while (TWFunc::Path_Exists(filename)) {
+ sprintf(command, "cd '%s' && md5sum %s%03i > %s%03i.md5",Backup_Folder.c_str(), Backup_Filename.c_str(), index, Backup_Filename.c_str(), index);
+ LOGI("MD5 command is: '%s'\n", command);
+ if (system(command) == 0) {
+ ui_print("....MD5 Created.\n");
+ } else {
+ ui_print("....MD5 Error.\n");
+ return false;
+ }
+ index++;
+ }
+ if (index == 0) {
+ LOGE("Backup file: '%s' not found!\n", filename);
+ return false;
+ }
+ }
+ return true;
+}
+
+bool TWPartitionManager::Backup_Partition(TWPartition* Part, string Backup_Folder, bool generate_md5, unsigned long long* img_bytes_remaining, unsigned long long* file_bytes_remaining, unsigned long *img_time, unsigned long *file_time) {
+ time_t start, stop;
+
+ if (Part == NULL)
+ return true;
+
+ time(&start);
+
+ if (Part->Backup(Backup_Folder)) {
+ time(&stop);
+ if (Part->Backup_Method == 1) {
+ *file_bytes_remaining -= Part->Backup_Size;
+ *file_time += (int) difftime(stop, start);
+ } else {
+ *img_bytes_remaining -= Part->Backup_Size;
+ *img_time += (int) difftime(stop, start);
+ }
+ return Make_MD5(generate_md5, Backup_Folder, Part->Backup_FileName);
+ } else {
+ return false;
+ }
+}
+
+int TWPartitionManager::Run_Backup(void) {
+ int check, do_md5, partition_count = 0;
+ string Backup_Folder, Backup_Name, Full_Backup_Path;
+ unsigned long long total_bytes = 0, file_bytes = 0, img_bytes = 0, free_space = 0, img_bytes_remaining, file_bytes_remaining;
+ unsigned long img_time = 0, file_time = 0;
+ TWPartition* backup_sys = NULL;
+ TWPartition* backup_data = NULL;
+ TWPartition* backup_cache = NULL;
+ TWPartition* backup_recovery = NULL;
+ TWPartition* backup_boot = NULL;
+ TWPartition* backup_andsec = NULL;
+ TWPartition* backup_sdext = NULL;
+ TWPartition* backup_sp1 = NULL;
+ TWPartition* backup_sp2 = NULL;
+ TWPartition* backup_sp3 = NULL;
+ TWPartition* storage = NULL;
+ struct tm *t;
+ time_t start, stop, seconds, total_start, total_stop;
+ seconds = time(0);
+ t = localtime(&seconds);
+
+ time(&total_start);
+
+ Update_System_Details();
+
+ if (!Mount_Current_Storage(true))
+ return false;
+
+ DataManager::GetValue(TW_SKIP_MD5_GENERATE_VAR, do_md5);
+ if (do_md5 != 0) {
+ LOGI("MD5 creation enabled.\n");
+ do_md5 = true;
+ }
+ DataManager::GetValue(TW_BACKUPS_FOLDER_VAR, Backup_Folder);
+ DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
+ if (Backup_Name == "(Current Date)" || Backup_Name == "0") {
+ char timestamp[255];
+ sprintf(timestamp,"%04d-%02d-%02d--%02d-%02d-%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec);
+ Backup_Name = timestamp;
+ }
+ LOGI("Backup Name is: '%s'\n", Backup_Name.c_str());
+ Full_Backup_Path = Backup_Folder + "/" + Backup_Name + "/";
+ LOGI("Full_Backup_Path is: '%s'\n", Full_Backup_Path.c_str());
+
+ ui_print("\n[BACKUP STARTED]\n");
+ ui_print(" * Backup Folder: %s\n", Full_Backup_Path.c_str());
+ if (!TWFunc::Recursive_Mkdir(Full_Backup_Path)) {
+ LOGE("Failed to make backup folder.\n");
+ return false;
+ }
+
+ LOGI("Calculating backup details...\n");
+ DataManager::GetValue(TW_BACKUP_SYSTEM_VAR, check);
+ if (check) {
+ backup_sys = Find_Partition_By_Path("/system");
+ if (backup_sys != NULL) {
+ partition_count++;
+ if (backup_sys->Backup_Method == 1)
+ file_bytes += backup_sys->Backup_Size;
+ else
+ img_bytes += backup_sys->Backup_Size;
+ } else {
+ LOGE("Unable to locate system partition.\n");
+ return false;
+ }
+ }
+ DataManager::GetValue(TW_BACKUP_DATA_VAR, check);
+ if (check) {
+ backup_data = Find_Partition_By_Path("/data");
+ if (backup_data != NULL) {
+ partition_count++;
+ if (backup_data->Backup_Method == 1)
+ file_bytes += backup_data->Backup_Size;
+ else
+ img_bytes += backup_data->Backup_Size;
+ } else {
+ LOGE("Unable to locate data partition.\n");
+ return false;
+ }
+ }
+ DataManager::GetValue(TW_BACKUP_CACHE_VAR, check);
+ if (check) {
+ backup_cache = Find_Partition_By_Path("/cache");
+ if (backup_cache != NULL) {
+ partition_count++;
+ if (backup_cache->Backup_Method == 1)
+ file_bytes += backup_cache->Backup_Size;
+ else
+ img_bytes += backup_cache->Backup_Size;
+ } else {
+ LOGE("Unable to locate cache partition.\n");
+ return false;
+ }
+ }
+ DataManager::GetValue(TW_BACKUP_RECOVERY_VAR, check);
+ if (check) {
+ backup_recovery = Find_Partition_By_Path("/recovery");
+ if (backup_recovery != NULL) {
+ partition_count++;
+ if (backup_recovery->Backup_Method == 1)
+ file_bytes += backup_recovery->Backup_Size;
+ else
+ img_bytes += backup_recovery->Backup_Size;
+ } else {
+ LOGE("Unable to locate recovery partition.\n");
+ return false;
+ }
+ }
+ DataManager::GetValue(TW_BACKUP_BOOT_VAR, check);
+ if (check) {
+ backup_boot = Find_Partition_By_Path("/boot");
+ if (backup_boot != NULL) {
+ partition_count++;
+ if (backup_boot->Backup_Method == 1)
+ file_bytes += backup_boot->Backup_Size;
+ else
+ img_bytes += backup_boot->Backup_Size;
+ } else {
+ LOGE("Unable to locate boot partition.\n");
+ return false;
+ }
+ }
+ DataManager::GetValue(TW_BACKUP_ANDSEC_VAR, check);
+ if (check) {
+ backup_andsec = Find_Partition_By_Path("/and-sec");
+ if (backup_andsec != NULL) {
+ partition_count++;
+ if (backup_andsec->Backup_Method == 1)
+ file_bytes += backup_andsec->Backup_Size;
+ else
+ img_bytes += backup_andsec->Backup_Size;
+ } else {
+ LOGE("Unable to locate android secure partition.\n");
+ return false;
+ }
+ }
+ DataManager::GetValue(TW_BACKUP_SDEXT_VAR, check);
+ if (check) {
+ backup_sdext = Find_Partition_By_Path("/sd-ext");
+ if (backup_sdext != NULL) {
+ partition_count++;
+ if (backup_sdext->Backup_Method == 1)
+ file_bytes += backup_sdext->Backup_Size;
+ else
+ img_bytes += backup_sdext->Backup_Size;
+ } else {
+ LOGE("Unable to locate sd-ext partition.\n");
+ return false;
+ }
+ }
+#ifdef SP1_NAME
+ DataManager::GetValue(TW_BACKUP_SP1_VAR, check);
+ if (check) {
+ backup_sp1 = Find_Partition_By_Path(SP1_NAME);
+ if (backup_sp1 != NULL) {
+ partition_count++;
+ if (backup_sp1->Backup_Method == 1)
+ file_bytes += backup_sp1->Backup_Size;
+ else
+ img_bytes += backup_sp1->Backup_Size;
+ } else {
+ LOGE("Unable to locate %s partition.\n", SP1_NAME);
+ return false;
+ }
+ }
+#endif
+#ifdef SP2_NAME
+ DataManager::GetValue(TW_BACKUP_SP2_VAR, check);
+ if (check) {
+ backup_sp2 = Find_Partition_By_Path(SP2_NAME);
+ if (backup_sp2 != NULL) {
+ partition_count++;
+ if (backup_sp2->Backup_Method == 1)
+ file_bytes += backup_sp2->Backup_Size;
+ else
+ img_bytes += backup_sp2->Backup_Size;
+ } else {
+ LOGE("Unable to locate %s partition.\n", SP2_NAME);
+ return false;
+ }
+ }
+#endif
+#ifdef SP3_NAME
+ DataManager::GetValue(TW_BACKUP_SP3_VAR, check);
+ if (check) {
+ backup_sp3 = Find_Partition_By_Path(SP3_NAME);
+ if (backup_sp3 != NULL) {
+ partition_count++;
+ if (backup_sp3->Backup_Method == 1)
+ file_bytes += backup_sp3->Backup_Size;
+ else
+ img_bytes += backup_sp3->Backup_Size;
+ } else {
+ LOGE("Unable to locate %s partition.\n", SP3_NAME);
+ return false;
+ }
+ }
+#endif
+
+ if (partition_count == 0) {
+ ui_print("No partitions selected for backup.\n");
+ return false;
+ }
+ total_bytes = file_bytes + img_bytes;
+ ui_print(" * Total number of partitions to back up: %d\n", partition_count);
+ ui_print(" * Total size of all data: %lluMB\n", total_bytes / 1024 / 1024);
+ storage = Find_Partition_By_Path(DataManager::GetCurrentStoragePath());
+ if (storage != NULL) {
+ free_space = storage->Free;
+ ui_print(" * Available space: %lluMB\n", free_space / 1024 / 1024);
+ } else {
+ LOGE("Unable to locate storage device.\n");
+ return false;
+ }
+ if (free_space + (32 * 1024 * 1024) < total_bytes) {
+ // We require an extra 32MB just in case
+ LOGE("Not enough free space on storage.\n");
+ return false;
+ }
+ img_bytes_remaining = img_bytes;
+ file_bytes_remaining = file_bytes;
+
+ if (!Backup_Partition(backup_sys, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time))
+ return false;
+ if (!Backup_Partition(backup_data, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time))
+ return false;
+ if (!Backup_Partition(backup_cache, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time))
+ return false;
+ if (!Backup_Partition(backup_recovery, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time))
+ return false;
+ if (!Backup_Partition(backup_boot, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time))
+ return false;
+ if (!Backup_Partition(backup_andsec, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time))
+ return false;
+ if (!Backup_Partition(backup_sdext, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time))
+ return false;
+ if (!Backup_Partition(backup_sp1, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time))
+ return false;
+ if (!Backup_Partition(backup_sp2, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time))
+ return false;
+ if (!Backup_Partition(backup_sp3, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time))
+ return false;
+
+ // Average BPS
+ if (img_time == 0)
+ img_time = 1;
+ if (file_time == 0)
+ file_time = 1;
+ unsigned long int img_bps = img_bytes / img_time;
+ unsigned long int file_bps = file_bytes / file_time;
+
+ ui_print("Average backup rate for file systems: %lu MB/sec\n", (file_bps / (1024 * 1024)));
+ ui_print("Average backup rate for imaged drives: %lu MB/sec\n", (img_bps / (1024 * 1024)));
+
+ time(&total_stop);
+ int total_time = (int) difftime(total_stop, total_start);
+ unsigned long long actual_backup_size = TWFunc::Get_Folder_Size(Full_Backup_Path, true);
+ actual_backup_size /= (1024LLU * 1024LLU);
+
+ ui_print("[%llu MB TOTAL BACKED UP]\n", actual_backup_size);
+ Update_System_Details();
+ ui_print("[BACKUP COMPLETED IN %d SECONDS]\n\n", total_time); // the end
+ return true;
}
int TWPartitionManager::Run_Restore(string Restore_Name) {
- int check;
+ int check, restore_sys, restore_data, restore_cache, restore_boot, restore_andsec, restore_sdext, restore_sp1, restore_sp2, restore_sp3;
TWPartition* Part;
-LOGE("TO DO: Check MD5 of all partitions before restoring ANY partitions.\n");
- DataManager::GetValue(TW_RESTORE_SYSTEM_VAR, check);
+
+ DataManager::GetValue(TW_SKIP_MD5_CHECK_VAR, check);
+ DataManager::GetValue(TW_RESTORE_SYSTEM_VAR, restore_sys);
+ DataManager::GetValue(TW_RESTORE_DATA_VAR, restore_data);
+ DataManager::GetValue(TW_RESTORE_CACHE_VAR, restore_cache);
+ DataManager::GetValue(TW_RESTORE_BOOT_VAR, restore_boot);
+ DataManager::GetValue(TW_RESTORE_ANDSEC_VAR, restore_andsec);
+ DataManager::GetValue(TW_RESTORE_SDEXT_VAR, restore_sdext);
+ DataManager::GetValue(TW_RESTORE_SP1_VAR, restore_sp1);
+ DataManager::GetValue(TW_RESTORE_SP2_VAR, restore_sp2);
+ DataManager::GetValue(TW_RESTORE_SP3_VAR, restore_sp3);
+
if (check > 0) {
+ // Check MD5 files first before restoring to ensure that all of them match before starting a restore
+ if (restore_sys > 0) {
+ Part = Find_Partition_By_Path("/system");
+ if (Part) {
+ if (!Part->Check_MD5(Restore_Name))
+ return false;
+ } else
+ LOGE("Restore: Unable to locate system partition.\n");
+ }
+
+ if (restore_data > 0) {
+ Part = Find_Partition_By_Path("/data");
+ if (Part) {
+ if (!Part->Check_MD5(Restore_Name))
+ return false;
+ } else
+ LOGE("Restore: Unable to locate data partition.\n");
+ }
+
+ if (restore_cache > 0) {
+ Part = Find_Partition_By_Path("/cache");
+ if (Part) {
+ if (!Part->Check_MD5(Restore_Name))
+ return false;
+ } else
+ LOGE("Restore: Unable to locate cache partition.\n");
+ }
+
+ if (restore_boot > 0) {
+ Part = Find_Partition_By_Path("/boot");
+ if (Part) {
+ if (!Part->Check_MD5(Restore_Name))
+ return false;
+ } else
+ LOGE("Restore: Unable to locate boot partition.\n");
+ }
+
+ if (restore_andsec > 0) {
+ Part = Find_Partition_By_Path("/.android_secure");
+ if (Part) {
+ if (!Part->Check_MD5(Restore_Name))
+ return false;
+ } else
+ LOGE("Restore: Unable to locate android_secure partition.\n");
+ }
+
+ if (restore_sdext > 0) {
+ Part = Find_Partition_By_Path("/sd-ext");
+ if (Part) {
+ if (!Part->Check_MD5(Restore_Name))
+ return false;
+ } else
+ LOGE("Restore: Unable to locate sd-ext partition.\n");
+ }
+#ifdef SP1_NAME
+ if (restore_sp1 > 0) {
+ Part = Find_Partition_By_Path(TWFunc::Get_Root_Path(SP1_NAME));
+ if (Part) {
+ if (!Part->Check_MD5(Restore_Name))
+ return false;
+ } else
+ LOGE("Restore: Unable to locate %s partition.\n", SP1_NAME);
+ }
+#endif
+#ifdef SP2_NAME
+ if (restore_sp2 > 0) {
+ Part = Find_Partition_By_Path(TWFunc::Get_Root_Path(SP2_NAME));
+ if (Part) {
+ if (!Part->Check_MD5(Restore_Name))
+ return false;
+ } else
+ LOGE("Restore: Unable to locate %s partition.\n", SP2_NAME);
+ }
+#endif
+#ifdef SP3_NAME
+ if (restore_sp3 > 0) {
+ Part = Find_Partition_By_Path(TWFunc::Get_Root_Path(SP3_NAME));
+ if (Part) {
+ if (!Part->Check_MD5(Restore_Name))
+ return false;
+ } else
+ LOGE("Restore: Unable to locate %s partition.\n", SP3_NAME);
+ }
+#endif
+ }
+
+ if (restore_sys > 0) {
Part = Find_Partition_By_Path("/system");
if (Part) {
if (!Part->Restore(Restore_Name))
@@ -344,8 +773,8 @@ LOGE("TO DO: Check MD5 of all partitions before restoring ANY partitions.\n");
} else
LOGE("Restore: Unable to locate system partition.\n");
}
- DataManager::GetValue(TW_RESTORE_DATA_VAR, check);
- if (check > 0) {
+
+ if (restore_data > 0) {
Part = Find_Partition_By_Path("/data");
if (Part) {
if (!Part->Restore(Restore_Name))
@@ -353,8 +782,8 @@ LOGE("TO DO: Check MD5 of all partitions before restoring ANY partitions.\n");
} else
LOGE("Restore: Unable to locate data partition.\n");
}
- DataManager::GetValue(TW_RESTORE_CACHE_VAR, check);
- if (check > 0) {
+
+ if (restore_cache > 0) {
Part = Find_Partition_By_Path("/cache");
if (Part) {
if (!Part->Restore(Restore_Name))
@@ -362,8 +791,8 @@ LOGE("TO DO: Check MD5 of all partitions before restoring ANY partitions.\n");
} else
LOGE("Restore: Unable to locate cache partition.\n");
}
- DataManager::GetValue(TW_RESTORE_BOOT_VAR, check);
- if (check > 0) {
+
+ if (restore_boot > 0) {
Part = Find_Partition_By_Path("/boot");
if (Part) {
if (!Part->Restore(Restore_Name))
@@ -371,8 +800,8 @@ LOGE("TO DO: Check MD5 of all partitions before restoring ANY partitions.\n");
} else
LOGE("Restore: Unable to locate boot partition.\n");
}
- DataManager::GetValue(TW_RESTORE_ANDSEC_VAR, check);
- if (check > 0) {
+
+ if (restore_andsec > 0) {
Part = Find_Partition_By_Path("/.android_secure");
if (Part) {
if (!Part->Restore(Restore_Name))
@@ -380,8 +809,8 @@ LOGE("TO DO: Check MD5 of all partitions before restoring ANY partitions.\n");
} else
LOGE("Restore: Unable to locate android_secure partition.\n");
}
- DataManager::GetValue(TW_RESTORE_SDEXT_VAR, check);
- if (check > 0) {
+
+ if (restore_sdext > 0) {
Part = Find_Partition_By_Path("/sd-ext");
if (Part) {
if (!Part->Restore(Restore_Name))
@@ -390,8 +819,7 @@ LOGE("TO DO: Check MD5 of all partitions before restoring ANY partitions.\n");
LOGE("Restore: Unable to locate sd-ext partition.\n");
}
#ifdef SP1_NAME
- DataManager::GetValue(TW_RESTORE_SP1_VAR, check);
- if (check > 0) {
+ if (restore_sp1 > 0) {
Part = Find_Partition_By_Path(TWFunc::Get_Root_Path(SP1_NAME));
if (Part) {
if (!Part->Restore(Restore_Name))
@@ -401,8 +829,7 @@ LOGE("TO DO: Check MD5 of all partitions before restoring ANY partitions.\n");
}
#endif
#ifdef SP2_NAME
- DataManager::GetValue(TW_RESTORE_SP2_VAR, check);
- if (check > 0) {
+ if (restore_sp2 > 0) {
Part = Find_Partition_By_Path(TWFunc::Get_Root_Path(SP2_NAME));
if (Part) {
if (!Part->Restore(Restore_Name))
@@ -412,8 +839,7 @@ LOGE("TO DO: Check MD5 of all partitions before restoring ANY partitions.\n");
}
#endif
#ifdef SP3_NAME
- DataManager::GetValue(TW_RESTORE_SP3_VAR, check);
- if (check > 0) {
+ if (restore_sp3 > 0) {
Part = Find_Partition_By_Path(TWFunc::Get_Root_Path(SP3_NAME));
if (Part) {
if (!Part->Restore(Restore_Name))
@@ -422,6 +848,7 @@ LOGE("TO DO: Check MD5 of all partitions before restoring ANY partitions.\n");
LOGE("Restore: Unable to locate %s partition.\n", SP3_NAME);
}
#endif
+ Update_System_Details();
return true;
}
diff --git a/partitions.hpp b/partitions.hpp
index 5b7dc6df9..36138d102 100644
--- a/partitions.hpp
+++ b/partitions.hpp
@@ -51,6 +51,7 @@ public:
virtual bool UnMount(bool Display_Error); // Unmounts the partition if it is mounted
virtual bool Wipe(); // Wipes the partition
virtual bool Backup(string backup_folder); // Backs up the partition to the folder specified
+ virtual bool Check_MD5(string restore_folder); // Checks MD5 of a backup
virtual bool Restore(string restore_folder); // Restores the partition using the backup folder provided
virtual string Backup_Method_By_Name(); // Returns a string of the backup method for human readable output
virtual bool Decrypt(string Password); // Decrypts the partition, return 0 for failure and -1 for success
@@ -106,7 +107,6 @@ private:
bool Is_Image(string File_System); // Checks to see if the file system given is considered an image
void Setup_File_System(bool Display_Error); // Sets defaults for a file system partition
void Setup_Image(bool Display_Error); // Sets defaults for an image partition
- bool Path_Exists(string Path); // Checks to see if the Path exists in the file system
void Find_Real_Block_Device(string& Block_Device, bool Display_Error); // Checks the block device given and follows symlinks until it gets to the real block device
bool Find_Partition_Size(); // Finds the partition size from /proc/partitions
unsigned long long Get_Size_Via_du(string Path, bool Display_Error); // Uses du to get sizes
@@ -125,7 +125,6 @@ private:
bool Restore_Flash_Image(string restore_folder); // Restore using flash_image for MTD memory types
bool Get_Size_Via_statfs(bool Display_Error); // Get Partition size, used, and free space using statfs
bool Get_Size_Via_df(bool Display_Error); // Get Partition size, used, and free space using df command
- unsigned long long Get_Folder_Size(string Path, bool Display_Error); // Gets the size of the files in a folder and all of its subfolders
bool Make_Dir(string Path, bool Display_Error); // Creates a directory if it doesn't already exist
bool Find_MTD_Block_Device(string MTD_Name); // Finds the mtd block device based on the name from the fstab
@@ -155,7 +154,7 @@ public:
TWPartition* Find_Partition_By_Path(string Path); // Returns a pointer to a partition based on path
TWPartition* Find_Partition_By_Block(string Block); // Returns a pointer to a partition based on block device
TWPartition* Find_Partition_By_Name(string Block); // Returns a pointer to a partition based on name
- virtual int Run_Backup(string Backup_Name); // Initiates a backup in the current storage
+ virtual int Run_Backup(); // Initiates a backup in the current storage
virtual int Run_Restore(string Restore_Name); // Restores a backup
virtual void Set_Restore_Files(string Restore_Name); // Used to gather a list of available backup partitions for the user to select for a restore
virtual int Wipe_By_Path(string Path); // Wipes a partition based on path
@@ -173,6 +172,10 @@ public:
virtual int Fix_Permissions(); // Fixes permissions in /system and /data
private:
+ bool Make_MD5(bool generate_md5, string Backup_Folder, string Backup_Filename); // Generates an MD5 after a backup is made
+ bool Backup_Partition(TWPartition* Part, string Backup_Folder, bool generate_md5, unsigned long long* img_bytes_remaining, unsigned long long* file_bytes_remaining, unsigned long *img_time, unsigned long *file_time);
+
+private:
std::vector<TWPartition*> Partitions; // Vector list of all partitions
};
diff --git a/prebuilt/Android.mk b/prebuilt/Android.mk
index 17e2d4aca..650a6a057 100644
--- a/prebuilt/Android.mk
+++ b/prebuilt/Android.mk
@@ -39,6 +39,7 @@ RELINK_SOURCE_FILES += $(TARGET_OUT_SHARED_LIBRARIES)/libbmlutils.so
RELINK_SOURCE_FILES += $(TARGET_OUT_SHARED_LIBRARIES)/libflashutils.so
RELINK_SOURCE_FILES += $(TARGET_OUT_SHARED_LIBRARIES)/libstlport.so
RELINK_SOURCE_FILES += $(TARGET_OUT_SHARED_LIBRARIES)/libmincrypt.so
+RELINK_SOURCE_FILES += $(TARGET_OUT_SHARED_LIBRARIES)/libext4_utils.so
ifeq ($(TW_INCLUDE_BLOBPACK), true)
RELINK_SOURCE_FILES += $(TARGET_RECOVERY_ROOT_OUT)/sbin/blobpack
endif
diff --git a/twrp-functions.cpp b/twrp-functions.cpp
index ccf0540a1..b393f2b03 100644
--- a/twrp-functions.cpp
+++ b/twrp-functions.cpp
@@ -7,6 +7,7 @@
#include <vector>
#include <dirent.h>
#include <time.h>
+#include <errno.h>
#include "twrp-functions.hpp"
#include "partitions.hpp"
@@ -162,3 +163,73 @@ void TWFunc::htc_dumlock_reflash_recovery_to_boot(void) {
__system("htcdumlock recovery noreboot");
ui_print("Recovery is flashed to boot.\n");
}
+
+int TWFunc::Recursive_Mkdir(string Path) {
+ string pathCpy = Path;
+ string wholePath;
+ size_t pos = pathCpy.find("/", 2);
+
+ while (pos != string::npos)
+ {
+ wholePath = pathCpy.substr(0, pos);
+ if (mkdir(wholePath.c_str(), 0777) && errno != EEXIST) {
+ LOGE("Unable to create folder: %s (errno=%d)\n", wholePath.c_str(), errno);
+ return false;
+ }
+
+ pos = pathCpy.find("/", pos + 1);
+ }
+ if (mkdir(wholePath.c_str(), 0777) && errno != EEXIST)
+ return false;
+ return true;
+}
+
+unsigned long long TWFunc::Get_Folder_Size(string Path, bool Display_Error) {
+ DIR* d;
+ struct dirent* de;
+ struct stat st;
+ char path2[1024], filename[1024];
+ unsigned long long dusize = 0;
+
+ // Make a copy of path in case the data in the pointer gets overwritten later
+ strcpy(path2, Path.c_str());
+
+ d = opendir(path2);
+ if (d == NULL)
+ {
+ LOGE("error opening '%s'\n", path2);
+ return 0;
+ }
+
+ while ((de = readdir(d)) != NULL)
+ {
+ if (de->d_type == DT_DIR && strcmp(de->d_name, ".") != 0 && strcmp(de->d_name, "..") != 0)
+ {
+ strcpy(filename, path2);
+ strcat(filename, "/");
+ strcat(filename, de->d_name);
+ dusize += Get_Folder_Size(filename, Display_Error);
+ }
+ else if (de->d_type == DT_REG)
+ {
+ strcpy(filename, path2);
+ strcat(filename, "/");
+ strcat(filename, de->d_name);
+ stat(filename, &st);
+ dusize += (unsigned long long)(st.st_size);
+ }
+ }
+ closedir(d);
+
+ return dusize;
+}
+
+bool TWFunc::Path_Exists(string Path) {
+ // Check to see if the Path exists
+ struct statfs st;
+
+ if (statfs(Path.c_str(), &st) != 0)
+ return false;
+ else
+ return true;
+} \ No newline at end of file
diff --git a/twrp-functions.hpp b/twrp-functions.hpp
index 19f8eec66..b619239b8 100644
--- a/twrp-functions.hpp
+++ b/twrp-functions.hpp
@@ -10,13 +10,16 @@ class TWFunc
{
public:
static int Check_MD5(string File);
- static string Get_Root_Path(string Path); // Trims any trailing folders or filenames from the path, also adds a leading / if not present
- static string Get_Path(string Path); // Trims everything after the last / in the string
- static string Get_Filename(string Path); // Trims the path off of a filename
+ static string Get_Root_Path(string Path); // Trims any trailing folders or filenames from the path, also adds a leading / if not present
+ static string Get_Path(string Path); // Trims everything after the last / in the string
+ static string Get_Filename(string Path); // Trims the path off of a filename
- static void install_htc_dumlock(void); // Installs HTC Dumlock
- static void htc_dumlock_restore_original_boot(void); // Restores the backup of boot from HTC Dumlock
- static void htc_dumlock_reflash_recovery_to_boot(void); // Reflashes the current recovery to boot
+ static void install_htc_dumlock(void); // Installs HTC Dumlock
+ static void htc_dumlock_restore_original_boot(void); // Restores the backup of boot from HTC Dumlock
+ static void htc_dumlock_reflash_recovery_to_boot(void); // Reflashes the current recovery to boot
+ static int Recursive_Mkdir(string Path); // Recursively makes the entire path
+ static unsigned long long Get_Folder_Size(string Path, bool Display_Error); // Gets the size of a folder and all of its subfolders using dirent and stat
+ static bool Path_Exists(string Path); // Returns true if the path exists
};