void SetDataState(char* operation, char* partition, int errorCode, int done)
{
DataManager_SetStrValue("_operation", operation);
DataManager_SetStrValue("_partition", partition);
DataManager_SetIntValue("_operation_status", errorCode);
DataManager_SetIntValue("_operation_state", done);
}
struct dInfo* findDeviceByBlockDevice(const char* blockDevice)
{
if (!blockDevice) return NULL;
if (strcmp(blockDevice, sys.blk) == 0) return &sys;
if (strcmp(blockDevice, dat.blk) == 0) return &dat;
if (strcmp(blockDevice, datdat.blk) == 0) {
DataManager_SetIntValue(TW_HAS_DATADATA, 1);
return &datdat;
}
if (strcmp(blockDevice, boo.blk) == 0) return &boo;
if (strcmp(blockDevice, rec.blk) == 0) return &rec;
if (strcmp(blockDevice, cac.blk) == 0) return &cac;
if (strcmp(blockDevice, sde.blk) == 0) return &sde;
if (strcmp(blockDevice, sdcext.blk) == 0) return &sdcext;
if (strcmp(blockDevice, sdcint.blk) == 0) return &sdcint;
if (strcmp(blockDevice, sp1.blk) == 0) return &sp1;
if (strcmp(blockDevice, sp2.blk) == 0) return &sp2;
if (strcmp(blockDevice, sp3.blk) == 0) return &sp3;
return NULL;
}
struct dInfo* findDeviceByLabel(const char* label)
{
if (!label) return NULL;
if (strcmp(label, "system") == 0) return &sys;
if (strcmp(label, "userdata") == 0) return &dat;
if (strcmp(label, "data") == 0) return &dat;
if (strcmp(label, "boot") == 0) return &boo;
if (strcmp(label, "recovery") == 0) return &rec;
if (strcmp(label, "cache") == 0) return &cac;
if (strcmp(label, "sd-ext") == 0) return &sde;
if (strcmp(label, "and-sec") == 0) return &ase;
if (strcmp(label, "datadata") == 0) {
DataManager_SetIntValue(TW_HAS_DATADATA, 1);
return &datdat;
}
// New sdcard methods
if (DataManager_GetIntValue(TW_HAS_INTERNAL) == 1) {
if (strcmp(label, DataManager_GetStrValue(TW_EXTERNAL_LABEL)) == 0) return &sdcext;
if (strcmp(label, DataManager_GetStrValue(TW_INTERNAL_LABEL)) == 0) return &sdcint;
if (strcmp(label, "sdcard") == 0) {
if (DataManager_GetIntValue(TW_USE_EXTERNAL_STORAGE) == 0) {
return &sdcint;
} else {
return &sdcext;
}
return 0;
}
} else
if (strcmp(label, DataManager_GetStrValue(TW_EXTERNAL_LABEL)) == 0) return &sdcext;
// Special Partitions (such as WiMAX, efs, and PDS)
if (strcmp(label, EXPAND(SP1_NAME)) == 0) return &sp1;
if (strcmp(label, EXPAND(SP2_NAME)) == 0) return &sp2;
if (strcmp(label, EXPAND(SP3_NAME)) == 0) return &sp3;
return NULL;
}
int decrypt_device(void)
{
#ifdef TW_INCLUDE_CRYPTO
int ret_val, password_len;
char crypto_blkdev[255], password[255];
size_t result;
strcpy(password, DataManager_GetStrValue(TW_CRYPTO_PASSWORD));
property_set("ro.crypto.state", "encrypted");
property_set("ro.crypto.fs_type", CRYPTO_FS_TYPE);
property_set("ro.crypto.fs_real_blkdev", CRYPTO_REAL_BLKDEV);
property_set("ro.crypto.fs_mnt_point", CRYPTO_MNT_POINT);
property_set("ro.crypto.fs_options", CRYPTO_FS_OPTIONS);
property_set("ro.crypto.fs_flags", CRYPTO_FS_FLAGS);
property_set("ro.crypto.keyfile.userdata", CRYPTO_KEY_LOC);
if (cryptfs_check_passwd(password) != 0) {
LOGE("Failed to decrypt data\n");
return -1;
}
property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
if (strcmp(crypto_blkdev, "error") == 0) {
LOGE("Error retrieving decrypted data block device.\n");
} else {
DataManager_SetStrValue(TW_DATA_BLK_DEVICE, dat.blk);
DataManager_SetIntValue(TW_IS_DECRYPTED, 1);
strcpy(dat.blk, crypto_blkdev);
LOGI("Data successfully decrypted, new block device: '%s'\n", crypto_blkdev);
// Sleep for a bit so that the device will be ready
sleep(1);
update_system_details();
}
return 0;
#else
LOGE("No crypto support was compiled into this build.\n");
return -1;
#endif
}
void
nan_backup_menu(int pIdx)
{
tw_total = 0;
char* nan_b_headers[] = { "Nandroid Backup",
"Choose Backup Options:",
NULL };
char* nan_b_items[] = { "--> Backup Naowz!",
nan_img_set(ITEM_NAN_SYSTEM,0),
nan_img_set(ITEM_NAN_DATA,0),
nan_img_set(ITEM_NAN_BOOT,0),
nan_img_set(ITEM_NAN_RECOVERY,0),
nan_img_set(ITEM_NAN_CACHE,0),
nan_img_set(ITEM_NAN_WIMAX,0),
nan_img_set(ITEM_NAN_ANDSEC,0),
nan_img_set(ITEM_NAN_SDEXT,0),
nan_compress(),
"<-- Back To Nandroid Menu",
NULL };
char** headers = prepend_title(nan_b_headers);
inc_menu_loc(ITEM_NAN_BACK);
for (;;) {
int chosen_item = get_menu_selection(headers, nan_b_items, 0, pIdx); // get key presses
pIdx = chosen_item; // remember last selection location
switch (chosen_item) {
case ITEM_NAN_BACKUP:
if (tw_total > 0) {
nandroid_back_exe();
dec_menu_loc();
return;
}
break;
case ITEM_NAN_SYSTEM:
if (DataManager_GetIntValue(TW_NANDROID_SYSTEM_VAR)) {
DataManager_SetIntValue(TW_NANDROID_SYSTEM_VAR, 0); // toggle's value
tw_total--; // keeps count of how many selected
} else {
DataManager_SetIntValue(TW_NANDROID_SYSTEM_VAR, 1);
tw_total++;
}
break;
case ITEM_NAN_DATA:
if (DataManager_GetIntValue(TW_NANDROID_DATA_VAR)) {
DataManager_SetIntValue(TW_NANDROID_DATA_VAR, 0);
tw_total--;
} else {
DataManager_SetIntValue(TW_NANDROID_DATA_VAR, 1);
tw_total++;
}
break;
case ITEM_NAN_BOOT:
if (DataManager_GetIntValue(TW_NANDROID_BOOT_VAR)) {
DataManager_SetIntValue(TW_NANDROID_BOOT_VAR, 0);
tw_total--;
} else {
DataManager_SetIntValue(TW_NANDROID_BOOT_VAR, 1);
tw_total++;
}
break;
case ITEM_NAN_RECOVERY:
if (DataManager_GetIntValue(TW_NANDROID_RECOVERY_VAR)) {
DataManager_SetIntValue(TW_NANDROID_RECOVERY_VAR, 0);
tw_total--;
} else {
DataManager_SetIntValue(TW_NANDROID_RECOVERY_VAR, 1);
tw_total++;
}
break;
case ITEM_NAN_CACHE:
if (DataManager_GetIntValue(TW_NANDROID_CACHE_VAR)) {
DataManager_SetIntValue(TW_NANDROID_CACHE_VAR, 0);
tw_total--;
} else {
DataManager_SetIntValue(TW_NANDROID_CACHE_VAR, 1);
tw_total++;
}
break;
case ITEM_NAN_WIMAX:
if (tw_nan_wimax_x != -1) {
if (DataManager_GetIntValue(TW_NANDROID_WIMAX_VAR)) {
DataManager_SetIntValue(TW_NANDROID_WIMAX_VAR, 0);
tw_total--;
} else {
DataManager_SetIntValue(TW_NANDROID_WIMAX_VAR, 1);
tw_total++;
}
}
break;
case ITEM_NAN_ANDSEC:
if (tw_nan_andsec_x != -1) {
if (DataManager_GetIntValue(TW_NANDROID_ANDSEC_VAR)) {
DataManager_SetIntValue(TW_NANDROID_ANDSEC_VAR, 0);
tw_total--;
} else {
DataManager_SetIntValue(TW_NANDROID_ANDSEC_VAR, 1);
tw_total++;
}
}
break;
case ITEM_NAN_SDEXT:
if (tw_nan_sdext_x != -1) {
if (DataManager_GetIntValue(TW_NANDROID_SDEXT_VAR)) {
DataManager_SetIntValue(TW_NANDROID_SDEXT_VAR, 0);
tw_total--;
} else {
DataManager_SetIntValue(TW_NANDROID_SDEXT_VAR, 1);
tw_total++;
}
}
break;
case ITEM_NAN_COMPRESS:
DataManager_ToggleIntValue(TW_USE_COMPRESSION_VAR);
break;
case ITEM_NAN_BACK:
dec_menu_loc();
return;
}
if (go_home) {
dec_menu_loc();
return;
}
break;
}
ui_end_menu(); // end menu
dec_menu_loc(); // decrease menu location
nan_backup_menu(pIdx); // restart menu (to refresh it)
}
int
main(int argc, char **argv) {
// Recovery needs to install world-readable files, so clear umask
// set by init
umask(0);
time_t start = time(NULL);
// If these fail, there's not really anywhere to complain...
freopen(TEMPORARY_LOG_FILE, "a", stdout); setbuf(stdout, NULL);
freopen(TEMPORARY_LOG_FILE, "a", stderr); setbuf(stderr, NULL);
// If this binary is started with the single argument "--adbd",
// instead of being the normal recovery binary, it turns into kind
// of a stripped-down version of adbd that only supports the
// 'sideload' command. Note this must be a real argument, not
// anything in the command file or bootloader control block; the
// only way recovery should be run with this argument is when it
// starts a copy of itself from the apply_from_adb() function.
if (argc == 3 && strcmp(argv[1], "--adbd") == 0) {
adb_main(argv[2]);
return 0;
}
printf("Starting TWRP %s on %s", TW_VERSION_STR, ctime(&start));
Device* device = make_device();
ui = device->GetUI();
//ui->Init();
//ui->SetBackground(RecoveryUI::NONE);
//load_volume_table();
// Load default values to set DataManager constants and handle ifdefs
DataManager_LoadDefaults();
printf("Starting the UI...");
gui_init();
printf("=> Linking mtab\n");
symlink("/proc/mounts", "/etc/mtab");
printf("=> Processing recovery.fstab\n");
if (!PartitionManager.Process_Fstab("/etc/recovery.fstab", 1)) {
LOGE("Failing out of recovery due to problem with recovery.fstab.\n");
//return -1;
}
PartitionManager.Output_Partition_Logging();
// Load up all the resources
gui_loadResources();
PartitionManager.Mount_By_Path("/cache", true);
get_args(&argc, &argv);
int previous_runs = 0;
const char *send_intent = NULL;
const char *update_package = NULL;
int wipe_data = 0, wipe_cache = 0;
bool just_exit = false;
bool perform_backup = false;
int arg;
while ((arg = getopt_long(argc, argv, "", OPTIONS, NULL)) != -1) {
switch (arg) {
case 'p': previous_runs = atoi(optarg); break;
case 's': send_intent = optarg; break;
case 'u': update_package = optarg; break;
case 'w': wipe_data = wipe_cache = 1; break;
case 'c': wipe_cache = 1; break;
case 't': ui->ShowText(true); break;
case 'x': just_exit = true; break;
case 'n': perform_backup = true; LOGI("nandroid\n"); break;
case '?':
LOGE("Invalid command argument\n");
continue;
}
}
#ifdef HAVE_SELINUX
struct selinux_opt seopts[] = {
{ SELABEL_OPT_PATH, "/file_contexts" }
};
sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);
if (!sehandle) {
fprintf(stderr, "Warning: No file_contexts\n");
ui->Print("Warning: No file_contexts\n");
}
#endif
//device->StartRecovery();
printf("Command:");
for (arg = 0; arg < argc; arg++) {
printf(" \"%s\"", argv[arg]);
}
printf("\n");
if (update_package) {
// For backwards compatibility on the cache partition only, if
// we're given an old 'root' path "CACHE:foo", change it to
// "/cache/foo".
if (strncmp(update_package, "CACHE:", 6) == 0) {
int len = strlen(update_package) + 10;
char* modified_path = (char*)malloc(len);
strlcpy(modified_path, "/cache/", len);
strlcat(modified_path, update_package+6, len);
printf("(replacing path \"%s\" with \"%s\")\n",
update_package, modified_path);
update_package = modified_path;
}
}
printf("\n");
property_list(print_property, NULL);
printf("\n");
// Check for and run startup script if script exists
TWFunc::check_and_run_script("/sbin/runatboot.sh", "boot");
TWFunc::check_and_run_script("/sbin/postrecoveryboot.sh", "boot");
#ifdef TW_INCLUDE_INJECTTWRP
// Back up TWRP Ramdisk if needed:
TWPartition* Boot = PartitionManager.Find_Partition_By_Path("/boot");
string result;
LOGI("Backing up TWRP ramdisk...\n");
if (Boot == NULL || Boot->Current_File_System != "emmc")
TWFunc::Exec_Cmd("injecttwrp --backup /tmp/backup_recovery_ramdisk.img", result);
else {
string injectcmd = "injecttwrp --backup /tmp/backup_recovery_ramdisk.img bd=" + Boot->Actual_Block_Device;
TWFunc::Exec_Cmd(injectcmd, result);
}
LOGI("Backup of TWRP ramdisk done.\n");
#endif
int status = INSTALL_SUCCESS;
string ORSCommand;
if (perform_backup) {
char empt[50];
gui_console_only();
strcpy(empt, "(Current Date)");
DataManager_SetStrValue(TW_BACKUP_NAME, empt);
if (!OpenRecoveryScript::Insert_ORS_Command("backup BSDCAE\n"))
status = INSTALL_ERROR;
}
if (status == INSTALL_SUCCESS) { // Prevent other actions if backup failed
if (update_package != NULL) {
ORSCommand = "install ";
ORSCommand += update_package;
ORSCommand += "\n";
if (OpenRecoveryScript::Insert_ORS_Command(ORSCommand))
status = INSTALL_SUCCESS;
else
status = INSTALL_ERROR;
/*
status = install_package(update_package, &wipe_cache, TEMPORARY_INSTALL_FILE);
if (status == INSTALL_SUCCESS && wipe_cache) {
if (erase_volume("/cache")) {
LOGE("Cache wipe (requested by package) failed.");
}
}
if (status != INSTALL_SUCCESS) ui->Print("Installation aborted.\n");
*/
} else if (wipe_data) {
if (!OpenRecoveryScript::Insert_ORS_Command("wipe data\n"))
status = INSTALL_ERROR;
/*
if (device->WipeData()) status = INSTALL_ERROR;
if (erase_volume("/data")) status = INSTALL_ERROR;
if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;
*/
if (status != INSTALL_SUCCESS) ui->Print("Data wipe failed.\n");
} else if (wipe_cache) {
if (!OpenRecoveryScript::Insert_ORS_Command("wipe cache\n"))
status = INSTALL_ERROR;
if (status != INSTALL_SUCCESS) ui->Print("Cache wipe failed.\n");
} else if (!just_exit) {
status = INSTALL_ERROR; // No command specified
}
}
finish_recovery(NULL);
// Offer to decrypt if the device is encrypted
if (DataManager_GetIntValue(TW_IS_ENCRYPTED) != 0) {
LOGI("Is encrypted, do decrypt page first\n");
if (gui_startPage("decrypt") != 0) {
LOGE("Failed to start decrypt GUI page.\n");
}
}
// Read the settings file
DataManager_ReadSettingsFile();
// Run any outstanding OpenRecoveryScript
if (DataManager_GetIntValue(TW_IS_ENCRYPTED) == 0 && (TWFunc::Path_Exists(SCRIPT_FILE_TMP) || TWFunc::Path_Exists(SCRIPT_FILE_CACHE))) {
OpenRecoveryScript::Run_OpenRecoveryScript();
}
// Launch the main GUI
gui_start();
// Check for su to see if the device is rooted or not
if (PartitionManager.Mount_By_Path("/system", false)) {
// Disable flashing of stock recovery
if (TWFunc::Path_Exists("/system/recovery-from-boot.p")) {
rename("/system/recovery-from-boot.p", "/system/recovery-from-boot.bak");
ui_print("Renamed stock recovery file in /system to prevent\nthe stock ROM from replacing TWRP.\n");
}
if (TWFunc::Path_Exists("/supersu/su") && !TWFunc::Path_Exists("/system/bin/su") && !TWFunc::Path_Exists("/system/xbin/su") && !TWFunc::Path_Exists("/system/bin/.ext/.su")) {
// Device doesn't have su installed
DataManager_SetIntValue("tw_busy", 1);
if (gui_startPage("installsu") != 0) {
LOGE("Failed to start decrypt GUI page.\n");
}
} else if (TWFunc::Check_su_Perms() > 0) {
// su perms are set incorrectly
DataManager_SetIntValue("tw_busy", 1);
if (gui_startPage("fixsu") != 0) {
LOGE("Failed to start decrypt GUI page.\n");
}
}
sync();
PartitionManager.UnMount_By_Path("/system", false);
}
// Otherwise, get ready to boot the main system...
finish_recovery(send_intent);
ui->Print("Rebooting...\n");
char backup_arg_char[50];
strcpy(backup_arg_char, DataManager_GetStrValue("tw_reboot_arg"));
string backup_arg = backup_arg_char;
if (backup_arg == "recovery")
TWFunc::tw_reboot(rb_recovery);
else if (backup_arg == "poweroff")
TWFunc::tw_reboot(rb_poweroff);
else if (backup_arg == "bootloader")
TWFunc::tw_reboot(rb_bootloader);
else if (backup_arg == "download")
TWFunc::tw_reboot(rb_download);
else
TWFunc::tw_reboot(rb_system);
#ifdef ANDROID_RB_RESTART
android_reboot(ANDROID_RB_RESTART, 0, 0);
#else
reboot(RB_AUTOBOOT);
#endif
return EXIT_SUCCESS;
}
void
set_restore_files()
{
const char* nan_dir = DataManager_GetStrValue("_restore");
// Start with the default values
int restore_system = -1;
int restore_data = -1;
int restore_cache = -1;
int restore_recovery = -1;
int restore_boot = -1;
int restore_andsec = -1;
int restore_sdext = -1;
int restore_sp1 = -1;
int restore_sp2 = -1;
int restore_sp3 = -1;
DIR* d;
d = opendir(nan_dir);
if (d == NULL)
{
LOGE("error opening %s\n", nan_dir);
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;
struct dInfo* dev = NULL;
strcpy(str, de->d_name);
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 || strcmp(extn, "win") != 0) continue;
dev = findDeviceByLabel(label);
if (dev == NULL)
{
LOGE(" Unable to locate device by label\n");
continue;
}
strncpy(dev->fnm, de->d_name, 256);
dev->fnm[255] = '\0';
// Now, we just need to find the correct label
if (dev == &sys) restore_system = 1;
if (dev == &dat) restore_data = 1;
if (dev == &boo) restore_boot = 1;
if (dev == &rec) restore_recovery = 1;
if (dev == &cac) restore_cache = 1;
if (dev == &sde) restore_sdext = 1;
if (dev == &sp1) restore_sp1 = 1;
if (dev == &sp2) restore_sp2 = 1;
if (dev == &sp3) restore_sp3 = 1;
if (dev == &ase) restore_andsec = 1;
}
closedir(d);
// Set the final values
DataManager_SetIntValue(VAR_RESTORE_SYSTEM_VAR, restore_system);
DataManager_SetIntValue(VAR_RESTORE_DATA_VAR, restore_data);
DataManager_SetIntValue(VAR_RESTORE_CACHE_VAR, restore_cache);
DataManager_SetIntValue(VAR_RESTORE_RECOVERY_VAR, restore_recovery);
DataManager_SetIntValue(VAR_RESTORE_BOOT_VAR, restore_boot);
DataManager_SetIntValue(VAR_RESTORE_ANDSEC_VAR, restore_andsec);
DataManager_SetIntValue(VAR_RESTORE_SDEXT_VAR, restore_sdext);
DataManager_SetIntValue(VAR_RESTORE_SP1_VAR, restore_sp1);
DataManager_SetIntValue(VAR_RESTORE_SP2_VAR, restore_sp2);
DataManager_SetIntValue(VAR_RESTORE_SP3_VAR, restore_sp3);
return;
}
int
nandroid_back_exe()
{
SetDataState("Starting", "backup", 0, 0);
if (ensure_path_mounted(SDCARD_ROOT) != 0) {
ui_print("-- Could not mount: %s.\n-- Aborting.\n",SDCARD_ROOT);
SetDataState("Unable to mount", "/sdcard", 1, 1);
return 1;
}
// Create backup folder
struct tm *t;
char timestamp[64];
char image_dir[255];
char exe[255];
time_t start, stop;
time_t seconds;
seconds = time(0);
t = localtime(&seconds);
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); // make time stamp
sprintf(image_dir,"%s/%s/%s/", backup_folder, device_id, timestamp); // for backup folder
if (recursive_mkdir(image_dir))
{
LOGE("Unable to create folder: '%s'\n", backup_folder);
SetDataState("Backup failed", image_dir, 1, 1);
return -1;
}
// Record the start time
time(&start);
// Prepare operation
ui_print("\n[BACKUP STARTED]\n");
ui_print(" * Backup Folder: %s\n", backup_folder);
ui_print(" * Verifying filesystems...\n");
verifyFst();
createFstab();
ui_print(" * Verifying partition sizes...\n");
updateUsedSized();
unsigned long long sdc_free = sdcext.sze - sdcext.used;
// Compute totals
int total = 0;
unsigned long long total_img_bytes = 0, total_file_bytes = 0;
CalculateBackupDetails(&total, &total_img_bytes, &total_file_bytes);
unsigned long long total_bytes = total_img_bytes + total_file_bytes;
if (total == 0 || total_bytes == 0)
{
LOGE("Unable to compute target usage (%d partitions, %llu bytes)\n", total, total_bytes);
SetDataState("Backup failed", image_dir, 1, 1);
return -1;
}
ui_print(" * Total number of partition to back up: %d\n", total);
ui_print(" * Total size of all data, in KB: %llu\n", total_bytes / 1024);
ui_print(" * Available space on the SD card, in KB: %llu\n", sdc_free / 1024);
// We can't verify sufficient space on devices where sdcard is a portion of the data partition
#ifndef RECOVERY_SDCARD_ON_DATA
// Verify space
if (sdc_free < (total_bytes + 0x2000000)) // We require at least 32MB of additional space
{
LOGE("Insufficient space on SDCARD. Required space is %lluKB, available %lluKB\n", (total_bytes + 0x2000000) / 1024, sdc_free / 1024);
SetDataState("Backup failed", image_dir, 1, 1);
return -1;
}
#else
ui_print(" * This device does not support verifying available free space.\n");
#endif
// Prepare progress bar...
unsigned long long img_bytes_remaining = total_img_bytes;
unsigned long long file_bytes_remaining = total_file_bytes;
unsigned long img_byte_time = 0, file_byte_time = 0;
struct stat st;
ui_set_progress(0.0);
// SYSTEM
if (phx_do_backup(VAR_BACKUP_SYSTEM_VAR, &sys, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// DATA
if (phx_do_backup(VAR_BACKUP_DATA_VAR, &dat, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// BOOT
if (phx_do_backup(VAR_BACKUP_BOOT_VAR, &boo, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// RECOVERY
if (phx_do_backup(VAR_BACKUP_RECOVERY_VAR, &rec, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// CACHE
if (phx_do_backup(VAR_BACKUP_CACHE_VAR, &cac, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// SP1
if (phx_do_backup(VAR_BACKUP_SP1_VAR, &sp1, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// SP2
if (phx_do_backup(VAR_BACKUP_SP2_VAR, &sp2, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// SP3
if (phx_do_backup(VAR_BACKUP_SP3_VAR, &sp3, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// ANDROID-SECURE
if (stat(ase.dev, &st) ==0)
if (phx_do_backup(VAR_BACKUP_ANDSEC_VAR, &ase, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// SD-EXT
if (stat(sde.dev, &st) ==0)
if (phx_do_backup(VAR_BACKUP_SDEXT_VAR, &sde, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
ui_print(" * Verifying filesystems...\n");
verifyFst();
createFstab();
ui_print(" * Verifying partition sizes...\n");
updateUsedSized();
time(&stop);
// Average BPS
unsigned long int img_bps = total_img_bytes / img_byte_time;
unsigned long int file_bps = total_file_bytes / file_byte_time;
LOGI("img_bps = %lu total_img_bytes = %llu img_byte_time = %lu\n", img_bps, total_img_bytes, img_byte_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)));
if (DataManager_GetIntValue(VAR_SKIP_MD5_GENERATE_VAR) == 1)
{
// If we're skipping MD5 generation, our BPS is faster by about 1.65
file_bps = (unsigned long) (file_bps / 1.65);
img_bps = (unsigned long) (img_bps / 1.65);
}
img_bps += (DataManager_GetIntValue(VAR_BACKUP_AVG_IMG_RATE) * 4);
img_bps /= 5;
if (DataManager_GetIntValue(VAR_USE_COMPRESSION_VAR)) file_bps += (DataManager_GetIntValue(VAR_BACKUP_AVG_FILE_COMP_RATE) * 4);
else file_bps += (DataManager_GetIntValue(VAR_BACKUP_AVG_FILE_RATE) * 4);
file_bps /= 5;
DataManager_SetIntValue(VAR_BACKUP_AVG_IMG_RATE, img_bps);
if (DataManager_GetIntValue(VAR_USE_COMPRESSION_VAR)) DataManager_SetIntValue(VAR_BACKUP_AVG_FILE_COMP_RATE, file_bps);
else DataManager_SetIntValue(VAR_BACKUP_AVG_FILE_RATE, file_bps);
int total_time = (int) difftime(stop, start);
unsigned long long new_sdc_free = (sdcext.sze - sdcext.used) / (1024 * 1024);
sdc_free /= (1024 * 1024);
ui_print("[%lu MB TOTAL BACKED UP TO SDCARD]\n",(unsigned long) (sdc_free - new_sdc_free));
ui_print("[BACKUP COMPLETED IN %d SECONDS]\n\n", total_time); // the end
SetDataState("Backup Succeeded", "", 0, 1);
return 0;
}
void twrp_themes_menu()
{
const char* MENU_THEMES_HEADERS[] = { "twrp Theme Chooser",
"Taste tEh Rainbow:",
NULL };
char* MENU_THEMES[] = { "[RESTART MENU AND APPLY THEME]",
checkTheme(TW_THEME),
checkTheme(CM_THEME),
checkTheme(RED_THEME),
checkTheme(GOOGLE_THEME),
checkTheme(JF_THEME),
checkTheme(HTC_THEME),
checkTheme(FABULOUS_THEME),
checkTheme(PURPLE_SHIFT),
checkTheme(GREYBALLER_THEME),
checkTheme(TRIPPY_THEME),
checkTheme(SHIFTY_BASTARD),
checkTheme(MYN_WARM),
"<-- Back To twrp Settings",
NULL };
char** headers = prepend_title(MENU_THEMES_HEADERS);
inc_menu_loc(THEMES_BACK);
for (;;)
{
int chosen_item = get_menu_selection(headers, MENU_THEMES, 0, 0);
switch (chosen_item)
{
case THEME_REBOOT_RECOVERY:
set_theme(DataManager_GetStrValue(TW_COLOR_THEME_VAR));
go_home = 1;
go_restart = 1;
break;
case TW_THEME:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 0);
break;
case CM_THEME:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 1);
break;
case RED_THEME:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 2);
break;
case GOOGLE_THEME:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 3);
break;
case JF_THEME:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 4);
break;
case HTC_THEME:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 5);
break;
case FABULOUS_THEME:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 6);
break;
case PURPLE_SHIFT:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 7);
break;
case GREYBALLER_THEME:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 8);
break;
case TRIPPY_THEME:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 9);
break;
case SHIFTY_BASTARD:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 10);
break;
case MYN_WARM:
DataManager_SetIntValue(TW_COLOR_THEME_VAR, 11);
break;
case THEMES_BACK:
dec_menu_loc();
return;
}
if (go_home) {
dec_menu_loc();
return;
}
break;
}
ui_end_menu();
dec_menu_loc();
twrp_themes_menu();
}
int getLocations()
{
// This decides if a partition can be mounted and appears in the fstab
sys.mountable = 1;
dat.mountable = 1;
datdat.mountable = 1;
cac.mountable = 1;
sde.mountable = 1;
// boo.mountable = 1; // Boot is detected earlier
rec.mountable = 0;
sdcext.mountable = 1;
sdcint.mountable = 1;
ase.mountable = 0;
sp1.mountable = SP1_MOUNTABLE;
sp2.mountable = SP2_MOUNTABLE;
sp3.mountable = SP3_MOUNTABLE;
sys.is_sub_partition = 0;
dat.is_sub_partition = 0;
datdat.is_sub_partition = 1;
cac.is_sub_partition = 0;
sde.is_sub_partition = 0;
boo.is_sub_partition = 0;
rec.is_sub_partition = 0;
sdcext.is_sub_partition = 0;
sdcint.is_sub_partition = 0;
ase.is_sub_partition = 0;
sp1.is_sub_partition = 0;
sp2.is_sub_partition = 0;
sp3.is_sub_partition = 0;
// This decides how we backup/restore a block
sys.backup = files;
dat.backup = files;
datdat.backup = files;
cac.backup = files;
sde.backup = files;
boo.backup = image;
rec.backup = image;
sdcext.backup = none;
sdcint.backup = none;
ase.backup = files;
sp1.backup = SP1_BACKUP_METHOD;
sp2.backup = SP2_BACKUP_METHOD;
sp3.backup = SP3_BACKUP_METHOD;
sys.is_encrypted = 0;
dat.is_encrypted = 0;
datdat.is_encrypted = 0;
cac.is_encrypted = 0;
sde.is_encrypted = 0;
boo.is_encrypted = 0;
rec.is_encrypted = 0;
sdcext.is_encrypted = 0;
sdcint.is_encrypted = 0;
ase.is_encrypted = 0;
sp1.is_encrypted = 0;
sp2.is_encrypted = 0;
sp3.is_encrypted = 0;
if (getLocationsViaProc("emmc") != 0 && getLocationsViaProc("mtd") != 0 && getLocationsViafstab() != 0)
{
LOGE("E: Unable to get device locations.\n");
return -1;
}
// Handle .android_secure
char path[255];
if (DataManager_GetIntValue(TW_HAS_INTERNAL)) {
sprintf(ase.dev, "%s/.android_secure", DataManager_GetSettingsStoragePath());
strcpy(ase.blk, DataManager_GetSettingsStoragePath());
} else {
sprintf(ase.dev, "%s/.android_secure", DataManager_GetStrValue(TW_EXTERNAL_PATH));
strcpy(ase.blk, DataManager_GetStrValue(TW_EXTERNAL_PATH));
}
strcpy(ase.mnt, ".android_secure");
strcpy(ase.fst, "vfat");
if (strlen(sdcext.blk) > 0)
{
int tmpInt;
char tmpBase[50];
char tmpWildCard[50];
// We make the base via sdcard block
strcpy(sde.mnt, "sd-ext");
strcpy(tmpBase, sdcext.blk);
tmpBase[strlen(tmpBase)-1] = '\0';
sprintf(tmpWildCard,"%s%%d",tmpBase);
sscanf(sdcext.blk, tmpWildCard, &tmpInt); // sdcard block used as sd-ext base
sprintf(sde.blk, "%s%d",tmpBase, tmpInt+1);
}
get_device_id();
update_system_details();
// Now, let's update the data manager...
DataManager_SetIntValue("tw_boot_is_mountable", boo.mountable ? 1 : 0);
DataManager_SetIntValue("tw_system_is_mountable", sys.mountable ? 1 : 0);
DataManager_SetIntValue("tw_data_is_mountable", dat.mountable ? 1 : 0);
DataManager_SetIntValue("tw_cache_is_mountable", cac.mountable ? 1 : 0);
DataManager_SetIntValue("tw_sdcext_is_mountable", sdcext.mountable ? 1 : 0);
DataManager_SetIntValue("tw_sdcint_is_mountable", sdcint.mountable ? 1 : 0);
DataManager_SetIntValue("tw_sd-ext_is_mountable", sde.mountable ? 1 : 0);
DataManager_SetIntValue("tw_sp1_is_mountable", sp1.mountable ? 1 : 0);
DataManager_SetIntValue("tw_sp2_is_mountable", sp2.mountable ? 1 : 0);
DataManager_SetIntValue("tw_sp3_is_mountable", sp3.mountable ? 1 : 0);
listMntInfo(&boo, "boot");
listMntInfo(&sys, "system");
listMntInfo(&dat, "data");
if (DataManager_GetIntValue(TW_HAS_DATADATA) == 1)
listMntInfo(&datdat, "datadata");
listMntInfo(&cac, "cache");
listMntInfo(&rec, "recovery");
listMntInfo(&sdcext, "sdcext");
listMntInfo(&sdcint, "sdcint");
listMntInfo(&sde, "sd-ext");
listMntInfo(&ase, "android_secure");
listMntInfo(&sp1, "special 1");
listMntInfo(&sp2, "special 2");
listMntInfo(&sp3, "special 3");
return 0;
}
void updateUsedSized()
{
updateMntUsedSize(&boo);
updateMntUsedSize(&sys);
updateMntUsedSize(&dat);
if (DataManager_GetIntValue(TW_HAS_DATADATA) == 1)
updateMntUsedSize(&datdat);
updateMntUsedSize(&cac);
updateMntUsedSize(&rec);
updateMntUsedSize(&sdcext);
updateMntUsedSize(&sdcint);
updateMntUsedSize(&sde);
updateMntUsedSize(&ase);
updateMntUsedSize(&sp1);
updateMntUsedSize(&sp2);
updateMntUsedSize(&sp3);
if (boo.used == 0 && boo.sze == 0) {
DataManager_SetIntValue(TW_HAS_BOOT_PARTITION, 0);
DataManager_SetIntValue(TW_BACKUP_BOOT_VAR, 0);
} else
DataManager_SetIntValue(TW_HAS_BOOT_PARTITION, 1);
if (rec.used == 0 && rec.sze == 0) {
DataManager_SetIntValue(TW_HAS_RECOVERY_PARTITION, 0);
DataManager_SetIntValue(TW_BACKUP_RECOVERY_VAR, 0);
} else
DataManager_SetIntValue(TW_HAS_RECOVERY_PARTITION, 1);
if (sde.used == 0 && sde.sze == 0) {
DataManager_SetIntValue(TW_HAS_SDEXT_PARTITION, 0);
DataManager_SetIntValue(TW_BACKUP_SDEXT_VAR, 0);
} else
DataManager_SetIntValue(TW_HAS_SDEXT_PARTITION, 1);
if ((ase.used == 0 && ase.sze == 0) || DataManager_GetIntValue(TW_HAS_DATA_MEDIA) == 1) {
DataManager_SetIntValue(TW_HAS_ANDROID_SECURE, 0);
DataManager_SetIntValue(TW_BACKUP_ANDSEC_VAR, 0);
} else
DataManager_SetIntValue(TW_HAS_ANDROID_SECURE, 1);
// Store sizes in data manager for GUI in MB
DataManager_SetIntValue(TW_BACKUP_SYSTEM_SIZE, (int)(sys.bsze / 1048576LLU));
if (DataManager_GetIntValue(TW_HAS_DATADATA) == 1)
DataManager_SetIntValue(TW_BACKUP_DATA_SIZE, (int)(dat.bsze / 1048576LLU) + (int)(datdat.bsze / 1048576LLU));
else
DataManager_SetIntValue(TW_BACKUP_DATA_SIZE, (int)(dat.bsze / 1048576LLU));
DataManager_SetIntValue(TW_BACKUP_BOOT_SIZE, (int)(boo.bsze / 1048576LLU));
DataManager_SetIntValue(TW_BACKUP_RECOVERY_SIZE, (int)(rec.bsze / 1048576LLU));
DataManager_SetIntValue(TW_BACKUP_CACHE_SIZE, (int)(cac.bsze / 1048576LLU));
DataManager_SetIntValue(TW_BACKUP_ANDSEC_SIZE, (int)(ase.bsze / 1048576LLU));
DataManager_SetIntValue(TW_BACKUP_SDEXT_SIZE, (int)(sde.bsze / 1048576LLU));
DataManager_SetIntValue(TW_BACKUP_SP1_SIZE, (int)(sp1.bsze / 1048576LLU));
DataManager_SetIntValue(TW_BACKUP_SP2_SIZE, (int)(sp2.bsze / 1048576LLU));
DataManager_SetIntValue(TW_BACKUP_SP3_SIZE, (int)(sp3.bsze / 1048576LLU));
if (DataManager_GetIntValue(TW_USE_EXTERNAL_STORAGE) == 1)
DataManager_SetIntValue(TW_STORAGE_FREE_SIZE, (int)((sdcext.sze - sdcext.used) / 1048576LLU));
else if (DataManager_GetIntValue(TW_HAS_DATA_MEDIA) == 1)
DataManager_SetIntValue(TW_STORAGE_FREE_SIZE, (int)((dat.sze - dat.used) / 1048576LLU));
else
DataManager_SetIntValue(TW_STORAGE_FREE_SIZE, (int)((sdcint.sze - sdcint.used) / 1048576LLU));
dumpPartitionTable();
return;
}
