From 63c8df756bec611dfb3c28e481d74351c609d63a Mon Sep 17 00:00:00 2001 From: Dees_Troy Date: Mon, 10 Sep 2012 14:02:05 -0400 Subject: More Partition Manager functionality --- partition.cpp | 28 +++-- partitionmanager.cpp | 290 ++++++++++++++++++++++++++++++++++++++++++++++++--- partitions.hpp | 1 + 3 files changed, 297 insertions(+), 22 deletions(-) diff --git a/partition.cpp b/partition.cpp index 017af8829..081487e79 100644 --- a/partition.cpp +++ b/partition.cpp @@ -63,6 +63,7 @@ TWPartition::TWPartition(void) { Decrypted_Block_Device = ""; Display_Name = ""; Backup_Name = ""; + Backup_FileName = ""; Backup_Method = NONE; Has_Data_Media = false; Is_Storage = false; @@ -236,6 +237,15 @@ bool TWPartition::Process_Flags(string Flags, bool Display_Error) { Removable = true; } else if (strcmp(ptr, "storage") == 0) { Is_Storage = true; + } else if (strcmp(ptr, "canbewiped") == 0) { + Can_Be_Wiped = true; + } else if (strcmp(ptr, "wipeingui") == 0) { + Can_Be_Wiped = true; + Wipe_Available_in_GUI = true; + } else if (strcmp(ptr, "wipeduringfactoryreset") == 0) { + Can_Be_Wiped = true; + Wipe_Available_in_GUI = true; + Wipe_During_Factory_Reset = true; } else if (strlen(ptr) > 15 && strncmp(ptr, "subpartitionof=", 15) == 0) { ptr += 13; Is_SubPartition = true; @@ -266,7 +276,7 @@ bool TWPartition::Process_Flags(string Flags, bool Display_Error) { bool TWPartition::Is_File_System(string File_System) { if (File_System == "ext2" || - File_System == "ext3" || + File_System == "ext3" || File_System == "ext4" || File_System == "vfat" || File_System == "ntfs" || @@ -279,7 +289,7 @@ bool TWPartition::Is_File_System(string File_System) { bool TWPartition::Is_Image(string File_System) { if (File_System == "emmc" || - File_System == "mtd") + File_System == "mtd") return true; else return false; @@ -480,7 +490,7 @@ unsigned long long TWPartition::Get_Folder_Size(string Path, bool Display_Error) } closedir(d); - return dusize; + return dusize; } bool TWPartition::Find_Partition_Size(void) { @@ -499,7 +509,7 @@ bool TWPartition::Find_Partition_Size(void) { char device[512]; char tmpString[64]; - if (strlen(line) < 7 || line[0] == 'm') continue; + if (strlen(line) < 7 || line[0] == 'm') continue; sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device); tmpdevice = "/dev/block/"; @@ -685,19 +695,19 @@ void TWPartition::Check_FS_Type() { { blk = blkOutput; ptr = blkOutput; - while (*ptr > 32 && *ptr != ':') ptr++; - if (*ptr == 0) continue; + while (*ptr > 32 && *ptr != ':') ptr++; + if (*ptr == 0) continue; *ptr = 0; // Increment by two, but verify that we don't hit a NULL ptr++; - if (*ptr != 0) ptr++; + if (*ptr != 0) ptr++; // Now, find the TYPE field while (1) { arg = ptr; - while (*ptr > 32) ptr++; + while (*ptr > 32) ptr++; if (*ptr != 0) { *ptr = 0; @@ -724,7 +734,7 @@ void TWPartition::Check_FS_Type() { else continue; - if (strcmp(Current_File_System.c_str(), arg) != 0) { + if (strcmp(Current_File_System.c_str(), arg) != 0) { LOGI("'%s' was '%s' now set to '%s'\n", Mount_Point.c_str(), Current_File_System.c_str(), arg); Current_File_System = arg; } diff --git a/partitionmanager.cpp b/partitionmanager.cpp index b30e3b729..3509c4c3e 100644 --- a/partitionmanager.cpp +++ b/partitionmanager.cpp @@ -27,6 +27,8 @@ #include #include #include +#include +#include #include "variables.h" #include "common.h" @@ -82,10 +84,10 @@ int TWPartitionManager::Write_Fstab(void) { fp = fopen("/etc/fstab", "w"); if (fp == NULL) { - LOGI("Can not open /etc/fstab.\n"); + LOGI("Can not open /etc/fstab.\n"); return false; } - for (iter = Partitions.begin(); iter != Partitions.end(); iter++) { + for (iter = Partitions.begin(); iter != Partitions.end(); iter++) { if ((*iter)->Can_Be_Mounted) { if ((*iter)->Is_Decrypted) Line = (*iter)->Decrypted_Block_Device + " " + (*iter)->Mount_Point + " " + (*iter)->Current_File_System + " rw\n"; @@ -327,33 +329,295 @@ int TWPartitionManager::Run_Backup(string Backup_Name) { } int TWPartitionManager::Run_Restore(string Restore_Name) { - LOGI("STUB TWPartitionManager::Run_Restore, Restore_Name: '%s'\n", Restore_Name.c_str()); - return 1; + int check; + TWPartition* Part; + + DataManager::GetValue(TW_RESTORE_SYSTEM_VAR, check); + if (check > 0) { + Part = Find_Partition_By_Path("/system"); + if (Part) { + if (!Part->Restore(Restore_Name)) + return false; + } else + LOGE("Restore: Unable to locate system partition.\n"); + } + DataManager::GetValue(TW_RESTORE_DATA_VAR, check); + if (check > 0) { + Part = Find_Partition_By_Path("/data"); + if (Part) { + if (!Part->Restore(Restore_Name)) + return false; + } else + LOGE("Restore: Unable to locate data partition.\n"); + } + DataManager::GetValue(TW_RESTORE_CACHE_VAR, check); + if (check > 0) { + Part = Find_Partition_By_Path("/cache"); + if (Part) { + if (!Part->Restore(Restore_Name)) + return false; + } else + LOGE("Restore: Unable to locate cache partition.\n"); + } + DataManager::GetValue(TW_RESTORE_BOOT_VAR, check); + if (check > 0) { + Part = Find_Partition_By_Path("/boot"); + if (Part) { + if (!Part->Restore(Restore_Name)) + return false; + } else + LOGE("Restore: Unable to locate boot partition.\n"); + } + DataManager::GetValue(TW_RESTORE_ANDSEC_VAR, check); + if (check > 0) { + Part = Find_Partition_By_Path("/.android_secure"); + if (Part) { + if (!Part->Restore(Restore_Name)) + return false; + } else + LOGE("Restore: Unable to locate android_secure partition.\n"); + } + DataManager::GetValue(TW_RESTORE_SDEXT_VAR, check); + if (check > 0) { + Part = Find_Partition_By_Path("/sd-ext"); + if (Part) { + if (!Part->Restore(Restore_Name)) + return false; + } else + LOGE("Restore: Unable to locate sd-ext partition.\n"); + } +#ifdef SP1_NAME + DataManager::GetValue(TW_RESTORE_SP1_VAR, check); + if (check > 0) { + Part = Find_Partition_By_Path(Get_Root_Path(SP1_NAME)); + if (Part) { + if (!Part->Restore(Restore_Name)) + return false; + } else + LOGE("Restore: Unable to locate %s partition.\n", SP1_NAME); + } +#endif +#ifdef SP2_NAME + DataManager::GetValue(TW_RESTORE_SP2_VAR, check); + if (check > 0) { + Part = Find_Partition_By_Path(Get_Root_Path(SP2_NAME)); + if (Part) { + if (!Part->Restore(Restore_Name)) + return false; + } else + LOGE("Restore: Unable to locate %s partition.\n", SP2_NAME); + } +#endif +#ifdef SP3_NAME + DataManager::GetValue(TW_RESTORE_SP3_VAR, check); + if (check > 0) { + Part = Find_Partition_By_Path(Get_Root_Path(SP3_NAME)); + if (Part) { + if (!Part->Restore(Restore_Name)) + return false; + } else + LOGE("Restore: Unable to locate %s partition.\n", SP3_NAME); + } +#endif + return true; } void TWPartitionManager::Set_Restore_Files(string Restore_Name) { - LOGI("STUB TWPartitionManager::Set_Restore_Files\n"); + // Start with the default values + int tw_restore_system = -1; + int tw_restore_data = -1; + int tw_restore_cache = -1; + int tw_restore_recovery = -1; + int tw_restore_boot = -1; + int tw_restore_andsec = -1; + int tw_restore_sdext = -1; + int tw_restore_sp1 = -1; + int tw_restore_sp2 = -1; + int tw_restore_sp3 = -1; + bool get_date = true; + + DIR* d; + d = opendir(Restore_Name.c_str()); + if (d == NULL) + { + LOGE("Error opening %s\n", Restore_Name.c_str()); + return; + } + + struct dirent* de; + while ((de = readdir(d)) != NULL) + { + // Strip off three components + char str[256]; + char* label; + char* fstype = NULL; + char* extn = NULL; + char* ptr; + + strcpy(str, de->d_name); + if (strlen(str) <= 2) + continue; + + if (get_date) { + char file_path[255]; + struct stat st; + + strcpy(file_path, Restore_Name.c_str()); + strcat(file_path, "/"); + strcat(file_path, str); + stat(file_path, &st); + string backup_date = ctime((const time_t*)(&st.st_mtime)); + DataManager::SetValue(TW_RESTORE_FILE_DATE, backup_date); + get_date = false; + } + + label = str; + ptr = label; + while (*ptr && *ptr != '.') ptr++; + if (*ptr == '.') + { + *ptr = 0x00; + ptr++; + fstype = ptr; + } + while (*ptr && *ptr != '.') ptr++; + if (*ptr == '.') + { + *ptr = 0x00; + ptr++; + extn = ptr; + } + + if (extn == NULL || (strlen(extn) >= 3 && strncmp(extn, "win", 3) != 0)) continue; + + TWPartition* Part = Find_Partition_By_Path(label); + if (Part == NULL) + { + LOGE(" Unable to locate partition by backup name: '%s'\n", label); + continue; + } + + Part->Backup_FileName = de->d_name; + if (strlen(extn) > 3) { + Part->Backup_FileName.resize(Part->Backup_FileName.size() - strlen(extn) + 3); + } + + // Now, we just need to find the correct label + if (Part->Mount_Point == "/system") + tw_restore_system = 1; + if (Part->Mount_Point == "/data") + tw_restore_data = 1; + if (Part->Mount_Point == "/cache") + tw_restore_cache = 1; + if (Part->Mount_Point == "/recovery") + tw_restore_recovery = 1; + if (Part->Mount_Point == "/boot") + tw_restore_boot = 1; + if (Part->Mount_Point == "/.android_secure") + tw_restore_andsec = 1; + if (Part->Mount_Point == "/sd-ext") + tw_restore_sdext = 1; +#ifdef SP1_NAME + if (Part->Mount_Point == Get_Root_Path(SP1_Name)) + tw_restore_sp1 = 1; +#endif +#ifdef SP2_NAME + if (Part->Mount_Point == Get_Root_Path(SP2_Name)) + tw_restore_sp2 = 1; +#endif +#ifdef SP3_NAME + if (Part->Mount_Point == Get_Root_Path(SP3_Name)) + tw_restore_sp3 = 1; +#endif + } + closedir(d); + + // Set the final values + DataManager::SetValue(TW_RESTORE_SYSTEM_VAR, tw_restore_system); + DataManager::SetValue(TW_RESTORE_DATA_VAR, tw_restore_data); + DataManager::SetValue(TW_RESTORE_CACHE_VAR, tw_restore_cache); + DataManager::SetValue(TW_RESTORE_RECOVERY_VAR, tw_restore_recovery); + DataManager::SetValue(TW_RESTORE_BOOT_VAR, tw_restore_boot); + DataManager::SetValue(TW_RESTORE_ANDSEC_VAR, tw_restore_andsec); + DataManager::SetValue(TW_RESTORE_SDEXT_VAR, tw_restore_sdext); + DataManager::SetValue(TW_RESTORE_SP1_VAR, tw_restore_sp1); + DataManager::SetValue(TW_RESTORE_SP2_VAR, tw_restore_sp2); + DataManager::SetValue(TW_RESTORE_SP3_VAR, tw_restore_sp3); + return; } int TWPartitionManager::Wipe_By_Path(string Path) { - LOGI("STUB TWPartitionManager::Wipe_By_Path, Path: '%s'\n", Path.c_str()); - return 1; + std::vector::iterator iter; + int ret = false; + bool found = false; + string Local_Path = Get_Root_Path(Path); + + // Iterate through all partitions + for (iter = Partitions.begin(); iter != Partitions.end(); iter++) { + if ((*iter)->Mount_Point == Local_Path) { + ret = (*iter)->Wipe(); + found = true; + } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) { + (*iter)->Wipe(); + } + } + if (found) { + return ret; + } else + LOGE("Wipe: Unable to find partition for path '%s'\n", Local_Path.c_str()); + return false; } int TWPartitionManager::Wipe_By_Block(string Block) { - LOGI("STUB TWPartitionManager::Wipe_By_Block, Block: '%s'\n", Block.c_str()); - return 1; + TWPartition* Part = Find_Partition_By_Block(Block); + + if (Part) { + if (Part->Has_SubPartition) { + std::vector::iterator subpart; + + for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) { + if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == Part->Mount_Point) + (*subpart)->Wipe(); + } + return Part->Wipe(); + } else + return Part->Wipe(); + } + LOGE("Wipe: Unable to find partition for block '%s'\n", Block.c_str()); + return false; } int TWPartitionManager::Wipe_By_Name(string Name) { - LOGI("STUB TWPartitionManager::Wipe_By_Name, Name: '%s'\n", Name.c_str()); - return 1; + TWPartition* Part = Find_Partition_By_Name(Name); + + if (Part) { + if (Part->Has_SubPartition) { + std::vector::iterator subpart; + + for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) { + if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == Part->Mount_Point) + (*subpart)->Wipe(); + } + return Part->Wipe(); + } else + return Part->Wipe(); + } + LOGE("Wipe: Unable to find partition for name '%s'\n", Name.c_str()); + return false; } int TWPartitionManager::Factory_Reset(void) { - LOGI("STUB TWPartitionManager::Factory_Reset\n"); - return 1; + std::vector::iterator iter; + int ret = true; + + for (iter = Partitions.begin(); iter != Partitions.end(); iter++) { + if ((*iter)->Wipe_During_Factory_Reset) { + if (!(*iter)->Wipe()) + ret = false; + } + } + return ret; } void TWPartitionManager::Refresh_Sizes(void) { diff --git a/partitions.hpp b/partitions.hpp index 5ed723c95..0609712cb 100644 --- a/partitions.hpp +++ b/partitions.hpp @@ -87,6 +87,7 @@ protected: string Decrypted_Block_Device; // Decrypted block device available after decryption string Display_Name; // Display name for the GUI string Backup_Name; // Backup name -- used for backup filenames + string Backup_FileName; // Actual backup filename Backup_Method_enum Backup_Method; // Method used for backup bool Has_Data_Media; // Indicates presence of /data/media, may affect wiping and backup methods bool Is_Storage; // Indicates if this partition is used for storage for backup, restore, and installing zips -- cgit v1.2.3