diff options
| -rw-r--r-- | Android.mk | 6 | ||||
| -rw-r--r-- | adb_install.cpp | 4 | ||||
| -rw-r--r-- | gui/action.cpp | 43 | ||||
| -rwxr-xr-x | gui/devices/800x1280/res/ui.xml | 15 | ||||
| -rw-r--r-- | partition.cpp | 266 | ||||
| -rw-r--r-- | partitionmanager.cpp | 471 | ||||
| -rw-r--r-- | partitions.hpp | 9 | ||||
| -rw-r--r-- | prebuilt/Android.mk | 1 | ||||
| -rw-r--r-- | twrp-functions.cpp | 71 | ||||
| -rw-r--r-- | twrp-functions.hpp | 15 |
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 }; |