//custom backup: raw backup through shell (ext4 raw backup not supported in backup_raw_partition())
//ret = 0 if success, else ret = 1
int custom_backup_raw_handler(const char* backup_path, const char* root) {
Volume *vol = volume_for_path(root);
// make sure the volume exists...
if (vol == NULL || vol->fs_type == NULL) {
ui_print("Volume not found! Skipping raw backup of %s...\n", root);
return 0;
}
ui_print("Backing up %s in raw image...\n", root);
int ret = 0;
char tmp[PATH_MAX];
sprintf(tmp, "raw-backup.sh -b %s %s %s", backup_path, vol->device, root);
if (0 != (ret = __system(tmp))) {
ui_print("Failed raw backup of %s...\n", root);
}
//log
char logfile[PATH_MAX];
sprintf(logfile, "%s/log.txt", backup_path);
ui_print_custom_logtail(logfile, 3);
//this can be called outside nandroid_restore()
sync();
return ret;
}
void create_fstab()
{
struct stat info;
__system("touch /etc/mtab");
FILE *file = fopen("/etc/fstab", "w");
if (file == NULL) {
LOGW("Unable to create /etc/fstab!\n");
return;
}
Volume *vol = volume_for_path("/boot");
if (NULL != vol && strcmp(vol->fs_type, "mtd") != 0 && strcmp(vol->fs_type, "emmc") != 0 && strcmp(vol->fs_type, "bml") != 0)
write_fstab_root("/boot", file);
write_fstab_root("/cache", file);
write_fstab_root("/data", file);
write_fstab_root("/datadata", file);
write_fstab_root("/emmc", file);
write_fstab_root("/system", file);
write_fstab_root("/sdcard", file);
write_fstab_root("/sd-ext", file);
write_fstab_root("/external_sd", file);
fclose(file);
LOGI("Completed outputting fstab.\n");
}
int format_volume(const char* volume) {
Volume* v = volume_for_path(volume);
if (v == NULL) {
LOGE("unknown volume \"%s\"\n", volume);
return -1;
}
if (strcmp(v->mount_point, volume) != 0) {
LOGE("can't give path \"%s\" to format_volume\n", volume);
return -1;
}
// Retrieve the fs_type
const char* fs_type = v->fs_type;
if (memcmp(fs_type, "ext", 3) == 0)
{
if (strcmp(v->mount_point,"/system") == 0) fs_type = sys.fst;
else if (strcmp(v->mount_point,"/data") == 0) fs_type = dat.fst;
else if (strcmp(v->mount_point,"/cache") == 0) fs_type = cac.fst;
}
return tw_format(fs_type, v->device);
}
static int tar_compress_wrapper(const char* backup_path, const char* backup_file_image, int callback) {
char tmp[PATH_MAX];
if (strcmp(backup_path, "/data") == 0 && volume_for_path("/sdcard") == NULL)
sprintf(tmp, "cd $(dirname %s) ; tar cvf %s.tar --exclude 'media' $(basename %s) ; exit $?", backup_path, backup_file_image, backup_path);
else
sprintf(tmp, "cd $(dirname %s) ; tar cvf %s.tar $(basename %s) ; exit $?", backup_path, backup_file_image, backup_path);
FILE *fp = __popen(tmp, "r");
if (fp == NULL) {
ui_print("Unable to execute tar.\n");
return -1;
}
gettimeofday(&lastupdate,NULL);
while (fgets(tmp, PATH_MAX, fp) != NULL) {
tmp[PATH_MAX - 1] = NULL;
if (callback)
yaffs_callback(tmp);
}
return __pclose(fp);
}
// custom backup: raw backup through shell (ext4 raw backup not supported in backup_raw_partition())
// for efs partition
// for now called only from nandroid_backup()
// ret = 0 if success, else ret = 1
int dd_raw_backup_handler(const char* backup_path, const char* root) {
Volume *vol = volume_for_path(root);
ui_print("\n>> Backing up %s...\nUsing raw mode...\n", root);
if (vol == NULL || vol->fs_type == NULL) {
LOGE("volume not found! Skipping raw backup of %s\n", root);
return 0;
}
int ret = 0;
char tmp[PATH_MAX];
char* device_mmcblk;
if (strstr(vol->blk_device, "/dev/block/mmcblk") != NULL || strstr(vol->blk_device, "/dev/block/mtdblock") != NULL) {
sprintf(tmp, "raw-backup.sh -b %s %s %s", backup_path, vol->blk_device, vol->mount_point);
}
else if (vol->blk_device2 != NULL &&
(strstr(vol->blk_device2, "/dev/block/mmcblk") != NULL || strstr(vol->blk_device2, "/dev/block/mtdblock") != NULL)) {
sprintf(tmp, "raw-backup.sh -b %s %s %s", backup_path, vol->blk_device2, vol->mount_point);
}
else if ((device_mmcblk = readlink_device_blk(root)) != NULL) {
sprintf(tmp, "raw-backup.sh -b %s %s %s", backup_path, device_mmcblk, vol->mount_point);
free(device_mmcblk);
}
else {
LOGE("invalid device! Skipping raw backup of %s\n", root);
return 0;
}
if (0 != (ret = __system(tmp)))
LOGE("failed raw backup of %s...\n", root);
//log
//finish_nandroid_job();
char logfile[PATH_MAX];
sprintf(logfile, "%s/log.txt", backup_path);
ui_print_custom_logtail(logfile, 3);
return ret;
}
int ensure_path_unmounted(const char* path) {
if ((DataManager_GetIntValue(TW_HAS_DATA_MEDIA) == 1 || DataManager_GetIntValue(TW_HAS_DUAL_STORAGE) == 0) && strncmp(path, "/sdcard", 7) == 0)
return 0; // sdcard is just a symlink
// This is an old, common method for ensuring a flush
sync();
sync();
if (DataManager_GetIntValue(TW_DONT_UNMOUNT_SYSTEM) == 1 && strncmp(path, "/system", 7) == 0)
return 0;
Volume* v = volume_for_path(path);
if (v == NULL) {
LOGE("unknown volume for path [%s]\n", path);
return -1;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// the ramdisk is always mounted; you can't unmount it.
return -1;
}
int result;
result = scan_mounted_volumes();
if (result < 0) {
LOGE("failed to scan mounted volumes\n");
return -1;
}
const MountedVolume* mv =
find_mounted_volume_by_mount_point(v->mount_point);
if (mv == NULL) {
// volume is already unmounted
return 0;
}
return unmount_mounted_volume(mv);
}
static nandroid_backup_handler get_backup_handler(const char *backup_path) {
Volume *v = volume_for_path(backup_path);
if (v == NULL) {
#ifndef USE_CHINESE_FONT
ui_print("Unable to find volume.\n");
#else
ui_print("无法找到卷。\n");
#endif
return NULL;
}
const MountedVolume *mv = find_mounted_volume_by_mount_point(v->mount_point);
if (mv == NULL) {
#ifndef USE_CHINESE_FONT
ui_print("Unable to find mounted volume: %s\n", v->mount_point);
#else
ui_print("无法挂载卷: %s\n", v->mount_point);
#endif
return NULL;
}
if (strcmp(backup_path, "/data") == 0 && is_data_media()) {
return default_backup_handler;
}
if (strlen(forced_backup_format) > 0)
return default_backup_handler;
// Disable tar backups of yaffs2 by default
char prefer_tar[PROPERTY_VALUE_MAX];
property_get("ro.cwm.prefer_tar", prefer_tar, "false");
if (strcmp("yaffs2", mv->filesystem) == 0 && strcmp("false", prefer_tar) == 0) {
return mkyaffs2image_wrapper;
}
return default_backup_handler;
}
int ensure_path_unmounted(const char* path, bool detach) {
fstab_rec* v;
if (memcmp(path, "/storage/", 9) == 0) {
char label[PATH_MAX];
const char* p = path+9;
const char* q = strchr(p, '/');
memset(label, 0, sizeof(label));
if (q) {
memcpy(label, p, q-p);
}
else {
strcpy(label, p);
}
v = volume_for_label(label);
}
else {
v = volume_for_path(path);
}
if (v == NULL) {
LOGE("unknown volume for path [%s]\n", path);
return -1;
}
return ensure_volume_unmounted(v, detach);
}
int nandroid_backup_partition(const char* backup_path, const char* root) {
Volume *vol = volume_for_path(root);
// make sure the volume exists before attempting anything...
if (vol == NULL || vol->fs_type == NULL)
return NULL;
// see if we need a raw backup (mtd)
char tmp[PATH_MAX];
int ret;
if (strcmp(vol->fs_type, "mtd") == 0 ||
strcmp(vol->fs_type, "bml") == 0 ||
strcmp(vol->fs_type, "emmc") == 0) {
const char* name = basename(root);
sprintf(tmp, "%s/%s.img", backup_path, name);
ui_print("Backing up %s image...\n", name);
if (0 != (ret = backup_raw_partition(vol->fs_type, vol->device, tmp))) {
ui_print("Error while backing up %s image!", name);
return ret;
}
return 0;
}
return nandroid_backup_partition_extended(backup_path, root, 1);
}
int ensure_path_unmounted(const char* path) {
// if we are using /data/media, do not ever unmount volumes /data or /sdcard
if (is_data_media_volume_path(path)) {
return ensure_path_unmounted("/data");
}
if (strstr(path, "/data") == path && is_data_media() && !ignore_data_media) {
return 0;
}
Volume* v = volume_for_path(path);
if (v == NULL) {
LOGE("unknown volume for path [%s]\n", path);
return -1;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// the ramdisk is always mounted; you can't unmount it.
return -1;
}
int result;
result = scan_mounted_volumes();
if (result < 0) {
LOGE("failed to scan mounted volumes\n");
return -1;
}
const MountedVolume* mv =
find_mounted_volume_by_mount_point(v->mount_point);
if (mv == NULL) {
// volume is already unmounted
return 0;
}
return unmount_mounted_volume(mv);
}
int set_active_system(int num) {
int i;
char* mount_point;
Volume* system0 = volume_for_path("/system");
Volume* system1 = volume_for_path("/system1");
Volume* boot0 = volume_for_path("/boot");
Volume* boot1 = volume_for_path("/boot1");
Volume* radio0 = volume_for_path("/radio");
Volume* radio1 = volume_for_path("/radio1");
handle_volume_request(system0, system1, num);
handle_volume_request(boot0, boot1, num);
handle_volume_request(radio0, radio1, num);
if(ensure_path_unmounted("/data")!=0) {
LOGE("could not unmount /data!\n");
return -1;
}
selected_dualsystem_mode = num;
return 0;
}
void show_nandroid_menu()
{
static char* headers[] = { "Backup and Restore",
"",
NULL
};
char* list[] = { "backup",
"restore",
"delete",
"advanced restore",
"free unused backup data",
"choose default backup format",
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL
};
char *other_sd = NULL;
if (volume_for_path("/emmc") != NULL) {
other_sd = "/emmc";
list[6] = "backup to internal sdcard";
list[7] = "restore from internal sdcard";
list[8] = "advanced restore from internal sdcard";
list[9] = "delete from internal sdcard";
}
else if (volume_for_path("/external_sd") != NULL) {
other_sd = "/external_sd";
list[6] = "backup to external sdcard";
list[7] = "restore from external sdcard";
list[8] = "advanced restore from external sdcard";
list[9] = "delete from external sdcard";
}
#ifdef RECOVERY_EXTEND_NANDROID_MENU
extend_nandroid_menu(list, 10, sizeof(list) / sizeof(char*));
#endif
for (;;) {
int chosen_item = get_filtered_menu_selection(headers, list, 0, 0, sizeof(list) / sizeof(char*));
if (chosen_item == GO_BACK)
break;
switch (chosen_item)
{
case 0:
{
char backup_path[PATH_MAX];
time_t t = time(NULL);
struct tm *tmp = localtime(&t);
if (tmp == NULL)
{
struct timeval tp;
gettimeofday(&tp, NULL);
sprintf(backup_path, "/sdcard/clockworkmod/backup/%d", tp.tv_sec);
}
else
{
strftime(backup_path, sizeof(backup_path), "/sdcard/clockworkmod/backup/%F.%H.%M.%S", tmp);
}
nandroid_backup(backup_path);
write_recovery_version();
}
break;
case 1:
show_nandroid_restore_menu("/sdcard");
write_recovery_version();
break;
case 2:
show_nandroid_delete_menu("/sdcard");
write_recovery_version();
break;
case 3:
show_nandroid_advanced_restore_menu("/sdcard");
write_recovery_version();
break;
case 4:
run_dedupe_gc(other_sd);
break;
case 5:
choose_default_backup_format();
break;
case 6:
{
char backup_path[PATH_MAX];
time_t t = time(NULL);
struct tm *timeptr = localtime(&t);
if (timeptr == NULL)
{
struct timeval tp;
gettimeofday(&tp, NULL);
if (other_sd != NULL) {
sprintf(backup_path, "%s/clockworkmod/backup/%d", other_sd, tp.tv_sec);
}
else {
break;
}
}
else
{
if (other_sd != NULL) {
char tmp[PATH_MAX];
strftime(tmp, sizeof(tmp), "clockworkmod/backup/%F.%H.%M.%S", timeptr);
// this sprintf results in:
// /emmc/clockworkmod/backup/%F.%H.%M.%S (time values are populated too)
sprintf(backup_path, "%s/%s", other_sd, tmp);
}
else {
break;
}
}
nandroid_backup(backup_path);
}
break;
case 7:
if (other_sd != NULL) {
show_nandroid_restore_menu(other_sd);
}
break;
case 8:
if (other_sd != NULL) {
show_nandroid_advanced_restore_menu(other_sd);
}
break;
case 9:
if (other_sd != NULL) {
show_nandroid_delete_menu(other_sd);
}
break;
default:
#ifdef RECOVERY_EXTEND_NANDROID_MENU
handle_nandroid_menu(10, chosen_item);
#endif
break;
}
}
}
int format_volume(const char* volume) {
if (PartitionManager.Wipe_By_Path(volume))
return 0;
else
return -1;
Volume* v = volume_for_path(volume);
if (v == NULL) {
LOGE("unknown volume \"%s\"\n", volume);
return -1;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// you can't format the ramdisk.
LOGE("can't format_volume \"%s\"", volume);
return -1;
}
if (strcmp(v->mount_point, volume) != 0) {
LOGE("can't give path \"%s\" to format_volume\n", volume);
return -1;
}
if (ensure_path_unmounted(volume) != 0) {
LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point);
return -1;
}
if (strcmp(v->fs_type, "yaffs2") == 0 || strcmp(v->fs_type, "mtd") == 0) {
mtd_scan_partitions();
const MtdPartition* partition = mtd_find_partition_by_name(v->device);
if (partition == NULL) {
LOGE("format_volume: no MTD partition \"%s\"\n", v->device);
return -1;
}
MtdWriteContext *write = mtd_write_partition(partition);
if (write == NULL) {
LOGW("format_volume: can't open MTD \"%s\"\n", v->device);
return -1;
} else if (mtd_erase_blocks(write, -1) == (off_t) -1) {
LOGW("format_volume: can't erase MTD \"%s\"\n", v->device);
mtd_write_close(write);
return -1;
} else if (mtd_write_close(write)) {
LOGW("format_volume: can't close MTD \"%s\"\n", v->device);
return -1;
}
return 0;
}
if (strcmp(v->fs_type, "ext4") == 0) {
#ifdef USE_EXT4
/*
int result = make_ext4fs(v->device, v->length, volume, sehandle);
*/
int result = 0;
#else
int result = 0;
#endif
if (result != 0) {
LOGE("format_volume: make_extf4fs failed on %s\n", v->device);
return -1;
}
return 0;
}
LOGE("format_volume: fs_type \"%s\" unsupported\n", v->fs_type);
return -1;
}
int ensure_path_mounted(const char* path) {
if (PartitionManager.Mount_By_Path(path, true))
return 0;
else
return -1;
Volume* v = volume_for_path(path);
if (v == NULL) {
LOGE("unknown volume for path [%s]\n", path);
return -1;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// the ramdisk is always mounted.
return 0;
}
int result;
result = scan_mounted_volumes();
if (result < 0) {
LOGE("failed to scan mounted volumes\n");
return -1;
}
const MountedVolume* mv =
find_mounted_volume_by_mount_point(v->mount_point);
if (mv) {
// volume is already mounted
return 0;
}
mkdir(v->mount_point, 0755); // in case it doesn't already exist
if (strcmp(v->fs_type, "yaffs2") == 0) {
// mount an MTD partition as a YAFFS2 filesystem.
mtd_scan_partitions();
const MtdPartition* partition;
partition = mtd_find_partition_by_name(v->device);
if (partition == NULL) {
LOGE("failed to find \"%s\" partition to mount at \"%s\"\n",
v->device, v->mount_point);
return -1;
}
return mtd_mount_partition(partition, v->mount_point, v->fs_type, 0);
} else if (strcmp(v->fs_type, "ext4") == 0 ||
strcmp(v->fs_type, "vfat") == 0) {
result = mount(v->device, v->mount_point, v->fs_type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
if (result == 0) return 0;
if (v->device2) {
LOGW("failed to mount %s (%s); trying %s\n",
v->device, strerror(errno), v->device2);
result = mount(v->device2, v->mount_point, v->fs_type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
if (result == 0) return 0;
}
LOGE("failed to mount %s (%s)\n", v->mount_point, strerror(errno));
return -1;
}
LOGE("unknown fs_type \"%s\" for %s\n", v->fs_type, v->mount_point);
return -1;
}
int nandroid_restore(const char* backup_path, int restore_boot, int restore_system, int restore_data, int restore_cache, int restore_sdext, int restore_wimax)
{
ui_set_background(BACKGROUND_ICON_INSTALLING);
ui_show_indeterminate_progress();
if (ensure_path_mounted(backup_path) != 0)
return print_and_error("Can't mount backup path\n");
char tmp[PATH_MAX];
#ifdef PHILZ_TOUCH_RECOVERY
if (enable_md5sum)
#endif
{
ui_print("Checking MD5 sums...\n");
sprintf(tmp, "cd %s && md5sum -c nandroid.md5", backup_path);
if (0 != __system(tmp))
return print_and_error("MD5 mismatch!\n");
}
int ret;
if (restore_boot && NULL != volume_for_path("/boot") && 0 != (ret = nandroid_restore_partition(backup_path, "/boot")))
return ret;
if (backup_recovery && 0 != (ret = nandroid_restore_partition(backup_path, "/recovery")))
return ret;
struct stat s;
Volume *vol = volume_for_path("/wimax");
if (restore_wimax && vol != NULL && 0 == stat(vol->device, &s))
{
char serialno[PROPERTY_VALUE_MAX];
serialno[0] = 0;
property_get("ro.serialno", serialno, "");
sprintf(tmp, "%s/wimax.%s.img", backup_path, serialno);
struct stat st;
if (0 != stat(tmp, &st))
{
ui_print("WARNING: WiMAX partition exists, but nandroid\n");
ui_print(" backup does not contain WiMAX image.\n");
ui_print(" You should create a new backup to\n");
ui_print(" protect your WiMAX keys.\n");
}
else
{
ui_print("Erasing WiMAX before restore...\n");
if (0 != (ret = format_volume("/wimax")))
return print_and_error("Error while formatting wimax!\n");
ui_print("Restoring WiMAX image...\n");
if (0 != (ret = restore_raw_partition(vol->fs_type, vol->device, tmp)))
return ret;
}
}
// restore of raw efs image files (efs_time-stamp.img) is done elsewhere
// as it needs to pass in a filename (instead of a folder) as backup_path
// this could be done here since efs is processed alone, but must be done before md5 checksum!
if (backup_efs == RESTORE_EFS_TAR && 0 != (ret = nandroid_restore_partition(backup_path, "/efs")))
return ret;
if (backup_modem == RAW_IMG_FILE && 0 != (ret = nandroid_restore_partition(backup_path, "/modem")))
return ret;
else if (backup_modem == RAW_BIN_FILE) {
sprintf(tmp, "%s/modem.bin", backup_path);
custom_restore_raw_handler(tmp, "/modem");
}
if (restore_system && 0 != (ret = nandroid_restore_partition(backup_path, "/system")))
return ret;
if (is_custom_backup && backup_preload) {
if (0 != (ret = nandroid_restore_partition(backup_path, "/preload"))) {
ui_print("Failed to restore /preload!\n");
return ret;
}
}
else if (!is_custom_backup
#ifdef PHILZ_TOUCH_RECOVERY
&& nandroid_add_preload
#endif
)
{
if (restore_system && 0 != (ret = nandroid_restore_partition(backup_path, "/preload"))) {
ui_print("Failed to restore preload! Try to disable it.\n");
ui_print("Skipping /preload...\n");
//return ret;
}
}
if (restore_data && 0 != (ret = nandroid_restore_partition(backup_path, "/data")))
return ret;
if (has_datadata()) {
if (restore_data && 0 != (ret = nandroid_restore_partition(backup_path, "/datadata")))
return ret;
}
if (restore_data && 0 != (ret = nandroid_restore_partition_extended(backup_path, "/sdcard/.android_secure", 0)))
return ret;
if (restore_cache && 0 != (ret = nandroid_restore_partition_extended(backup_path, "/cache", 0)))
return ret;
if (restore_sdext && 0 != (ret = nandroid_restore_partition(backup_path, "/sd-ext")))
return ret;
sync();
ui_set_background(BACKGROUND_ICON_NONE);
ui_reset_progress();
ui_print("\nRestore complete!\n");
return 0;
}
int nandroid_restore_partition_extended(const char* backup_path, const char* mount_point, int umount_when_finished) {
int ret = 0;
char* name = basename(mount_point);
nandroid_restore_handler restore_handler = NULL;
const char *filesystems[] = { "yaffs2", "ext2", "ext3", "ext4", "vfat", "rfs", NULL };
const char* backup_filesystem = NULL;
Volume *vol = volume_for_path(mount_point);
const char *device = NULL;
if (vol != NULL)
device = vol->device;
char tmp[PATH_MAX];
sprintf(tmp, "%s/%s.img", backup_path, name);
struct stat file_info;
if (0 != (ret = statfs(tmp, &file_info))) {
// can't find the backup, it may be the new backup format?
// iterate through the backup types
printf("couldn't find old .img format\n");
char *filesystem;
int i = 0;
while ((filesystem = filesystems[i]) != NULL) {
sprintf(tmp, "%s/%s.%s.img", backup_path, name, filesystem);
if (0 == (ret = statfs(tmp, &file_info))) {
backup_filesystem = filesystem;
restore_handler = unyaffs_wrapper;
break;
}
sprintf(tmp, "%s/%s.%s.tar", backup_path, name, filesystem);
if (0 == (ret = statfs(tmp, &file_info))) {
backup_filesystem = filesystem;
restore_handler = tar_extract_wrapper;
break;
}
sprintf(tmp, "%s/%s.%s.dup", backup_path, name, filesystem);
if (0 == (ret = statfs(tmp, &file_info))) {
backup_filesystem = filesystem;
restore_handler = dedupe_extract_wrapper;
break;
}
i++;
}
if (backup_filesystem == NULL || restore_handler == NULL) {
//ui_print("%s.img not found. Skipping restore of %s.\n", name, mount_point);
ui_print("No %s backup found(img, tar, dup). Skipping restore of %s.\n", name, mount_point);
return 0;
}
else {
printf("Found new backup image: %s\n", tmp);
}
// If the fs_type of this volume is "auto" or mount_point is /data
// and is_data_media, let's revert
// to using a rm -rf, rather than trying to do a
// ext3/ext4/whatever format.
// This is because some phones (like DroidX) will freak out if you
// reformat the /system or /data partitions, and not boot due to
// a locked bootloader.
// Other devices, like the Galaxy Nexus, XOOM, and Galaxy Tab 10.1
// have a /sdcard symlinked to /data/media.
// Or of volume does not exist (.android_secure), just rm -rf.
if (vol == NULL || 0 == strcmp(vol->fs_type, "auto"))
backup_filesystem = NULL;
if (0 == strcmp(vol->mount_point, "/data") && is_data_media())
backup_filesystem = NULL;
}
ensure_directory(mount_point);
int callback = stat("/sdcard/clockworkmod/.hidenandroidprogress", &file_info) != 0;
compute_archive_stats(tmp);
ui_print("Restoring %s...\n", name);
if (backup_filesystem == NULL) {
if (0 != (ret = format_volume(mount_point))) {
ui_print("Error while formatting %s!\n", mount_point);
return ret;
}
}
else if (0 != (ret = format_device(device, mount_point, backup_filesystem))) {
ui_print("Error while formatting %s!\n", mount_point);
return ret;
}
if (0 != (ret = ensure_path_mounted(mount_point))) {
ui_print("Can't mount %s!\n", mount_point);
return ret;
}
if (restore_handler == NULL)
restore_handler = get_restore_handler(mount_point);
if (restore_handler == NULL) {
ui_print("Error finding an appropriate restore handler.\n");
return -2;
}
if (0 != (ret = restore_handler(tmp, mount_point, callback))) {
ui_print("Error while restoring %s!\n", mount_point);
return ret;
}
if (umount_when_finished) {
ensure_path_unmounted(mount_point);
}
return 0;
}
int nandroid_backup(const char* backup_path)
{
nandroid_backup_bitfield = 0;
ui_set_background(BACKGROUND_ICON_INSTALLING);
refresh_default_backup_handler();
if (ensure_path_mounted(backup_path) != 0) {
return print_and_error("Can't mount backup path.\n");
}
Volume* volume = volume_for_path(backup_path);
if (NULL == volume)
return print_and_error("Unable to find volume for backup path.\n");
if (is_data_media_volume_path(volume->mount_point))
volume = volume_for_path("/data");
int ret;
struct statfs s;
if (NULL != volume) {
if (0 != (ret = statfs(volume->mount_point, &s)))
return print_and_error("Unable to stat backup path.\n");
uint64_t bavail = s.f_bavail;
uint64_t bsize = s.f_bsize;
uint64_t sdcard_free = bavail * bsize;
uint64_t sdcard_free_mb = sdcard_free / (uint64_t)(1024 * 1024);
ui_print("SD Card space free: %lluMB\n", sdcard_free_mb);
if (sdcard_free_mb < 150)
ui_print("There may not be enough free space to complete backup... continuing...\n");
}
char tmp[PATH_MAX];
ensure_directory(backup_path);
if (backup_boot && 0 != (ret = nandroid_backup_partition(backup_path, "/boot")))
return ret;
if (backup_recovery && 0 != (ret = nandroid_backup_partition(backup_path, "/recovery")))
return ret;
Volume *vol = volume_for_path("/wimax");
if (backup_wimax && vol != NULL && 0 == stat(vol->device, &s))
{
char serialno[PROPERTY_VALUE_MAX];
ui_print("Backing up WiMAX...\n");
serialno[0] = 0;
property_get("ro.serialno", serialno, "");
sprintf(tmp, "%s/wimax.%s.img", backup_path, serialno);
ret = backup_raw_partition(vol->fs_type, vol->device, tmp);
if (0 != ret)
return print_and_error("Error while dumping WiMAX image!\n");
}
//2 copies of efs are made: tarball and raw backup
if (backup_efs) {
//first backup in raw format, returns 0 on success (or if skipped), else 1
if (0 != custom_backup_raw_handler(backup_path, "/efs")) {
ui_print("EFS raw image backup failed! Trying tar backup...\n");
}
//second backup in tar format
sprintf(tmp, "%s/efs_tar", backup_path);
ensure_directory(tmp);
if (0 != (ret = nandroid_backup_partition(tmp, "/efs")))
return ret;
}
if (backup_modem) {
if (0 != (ret = nandroid_backup_partition(backup_path, "/modem")))
return ret;
}
if (backup_system && 0 != (ret = nandroid_backup_partition(backup_path, "/system")))
return ret;
if (is_custom_backup && backup_preload) {
if (0 != (ret = nandroid_backup_partition(backup_path, "/preload"))) {
ui_print("Failed to backup /preload!\n");
return ret;
}
}
else if (!is_custom_backup
#ifdef PHILZ_TOUCH_RECOVERY
&& nandroid_add_preload
#endif
)
{
if (0 != (ret = nandroid_backup_partition(backup_path, "/preload"))) {
ui_print("Failed to backup preload! Try to disable it.\n");
ui_print("Skipping /preload...\n");
//return ret;
}
}
if (backup_data && 0 != (ret = nandroid_backup_partition(backup_path, "/data")))
return ret;
if (has_datadata()) {
if (backup_data && 0 != (ret = nandroid_backup_partition(backup_path, "/datadata")))
return ret;
}
if (is_data_media() || 0 != stat("/sdcard/.android_secure", &s)) {
ui_print("No /sdcard/.android_secure found. Skipping backup of applications on external storage.\n");
}
else {
if (backup_data && 0 != (ret = nandroid_backup_partition_extended(backup_path, "/sdcard/.android_secure", 0)))
return ret;
}
if (backup_cache && 0 != (ret = nandroid_backup_partition_extended(backup_path, "/cache", 0)))
return ret;
if (backup_sdext) {
vol = volume_for_path("/sd-ext");
if (vol == NULL || 0 != stat(vol->device, &s))
{
ui_print("No sd-ext found. Skipping backup of sd-ext.\n");
}
else
{
if (0 != ensure_path_mounted("/sd-ext"))
ui_print("Could not mount sd-ext. sd-ext backup may not be supported on this device. Skipping backup of sd-ext.\n");
else if (0 != (ret = nandroid_backup_partition(backup_path, "/sd-ext")))
return ret;
}
}
#ifdef PHILZ_TOUCH_RECOVERY
if (enable_md5sum)
#endif
{
ui_print("Generating md5 sum...\n");
sprintf(tmp, "nandroid-md5.sh %s", backup_path);
if (0 != (ret = __system(tmp))) {
ui_print("Error while generating md5 sum!\n");
return ret;
}
}
sprintf(tmp, "chmod -R 777 %s ; chmod -R u+r,u+w,g+r,g+w,o+r,o+w /sdcard/clockworkmod ; chmod u+x,g+x,o+x /sdcard/clockworkmod/backup ; chmod u+x,g+x,o+x /sdcard/clockworkmod/blobs", backup_path);
__system(tmp);
sync();
ui_set_background(BACKGROUND_ICON_NONE);
ui_reset_progress();
ui_print("\nBackup complete!\n");
return 0;
}
int nandroid_restore_partition_extended(const char* backup_path, const char* mount_point, int umount_when_finished) {
int ret = 0;
char* name = basename(mount_point);
nandroid_restore_handler restore_handler = NULL;
const char *filesystems[] = { "yaffs2", "ext2", "ext3", "ext4", "vfat", "rfs", NULL };
const char* backup_filesystem = NULL;
Volume *vol = volume_for_path(mount_point);
const char *device = NULL;
if (vol != NULL)
device = vol->device;
char tmp[PATH_MAX];
sprintf(tmp, "%s/%s.img", backup_path, name);
struct stat file_info;
if (strcmp(backup_path, "-") == 0) {
if (vol)
backup_filesystem = vol->fs_type;
restore_handler = tar_extract_wrapper;
strcpy(tmp, "/proc/self/fd/0");
}
else if (0 != (ret = statfs(tmp, &file_info))) {
// can't find the backup, it may be the new backup format?
// iterate through the backup types
printf("找不到默认\n");
char *filesystem;
int i = 0;
while ((filesystem = filesystems[i]) != NULL) {
sprintf(tmp, "%s/%s.%s.img", backup_path, name, filesystem);
if (0 == (ret = statfs(tmp, &file_info))) {
backup_filesystem = filesystem;
restore_handler = unyaffs_wrapper;
break;
}
sprintf(tmp, "%s/%s.%s.tar", backup_path, name, filesystem);
if (0 == (ret = statfs(tmp, &file_info))) {
backup_filesystem = filesystem;
restore_handler = tar_extract_wrapper;
break;
}
sprintf(tmp, "%s/%s.%s.dup", backup_path, name, filesystem);
if (0 == (ret = statfs(tmp, &file_info))) {
backup_filesystem = filesystem;
restore_handler = dedupe_extract_wrapper;
break;
}
i++;
}
if (backup_filesystem == NULL || restore_handler == NULL) {
ui_print("%s.镜像没找到，因此跳过该处恢复. %s.\n", name, mount_point);
return 0;
}
else {
printf("找到新的可恢复镜像: %s\n", tmp);
}
}
// If the fs_type of this volume is "auto" or mount_point is /data
// and is_data_media, let's revert
// to using a rm -rf, rather than trying to do a
// ext3/ext4/whatever format.
// This is because some phones (like DroidX) will freak out if you
// reformat the /system or /data partitions, and not boot due to
// a locked bootloader.
// Other devices, like the Galaxy Nexus, XOOM, and Galaxy Tab 10.1
// have a /sdcard symlinked to /data/media.
// Or of volume does not exist (.android_secure), just rm -rf.
if (vol == NULL || 0 == strcmp(vol->fs_type, "auto"))
backup_filesystem = NULL;
if (0 == strcmp(vol->mount_point, "/data") && is_data_media())
backup_filesystem = NULL;
ensure_directory(mount_point);
int callback = stat("/sdcard/clockworkmod/.hidenandroidprogress", &file_info) != 0;
ui_print("正在恢复 %s...\n", name);
if (backup_filesystem == NULL) {
if (0 != (ret = format_volume(mount_point))) {
ui_print("格式化下列分区失败 %s!\n", mount_point);
return ret;
}
}
else if (0 != (ret = format_device(device, mount_point, backup_filesystem))) {
ui_print("格式化下列分区失败 %s!\n", mount_point);
return ret;
}
if (0 != (ret = ensure_path_mounted(mount_point))) {
ui_print("挂载下列分区失败 %s!\n", mount_point);
return ret;
}
if (restore_handler == NULL)
restore_handler = get_restore_handler(mount_point);
// override restore handler for undump
if (strcmp(backup_path, "-") == 0) {
restore_handler = tar_undump_wrapper;
}
if (restore_handler == NULL) {
ui_print("找不到合适的方案\n");
return -2;
}
if (0 != (ret = restore_handler(tmp, mount_point, callback))) {
ui_print("恢复失败： %s!\n", mount_point);
return ret;
}
if (umount_when_finished) {
ensure_path_unmounted(mount_point);
}
return 0;
}
int nandroid_restore(const char* backup_path, int restore_boot, int restore_system, int restore_data, int restore_cache, int restore_sdext, int restore_wimax)
{
ui_set_background(BACKGROUND_ICON_INSTALLING);
ui_show_indeterminate_progress();
nandroid_files_total = 0;
if (ensure_path_mounted(backup_path) != 0)
return print_and_error("挂载分区失败\n");
char tmp[PATH_MAX];
ui_print("检查MD5 校验值...\n");
sprintf(tmp, "cd %s && md5sum -c nandroid.md5", backup_path);
if (0 != __system(tmp))
return print_and_error("MD5不合法\n");
int ret;
if (restore_boot)
{
if (NULL != volume_for_path("/boot") && 0 != (ret = nandroid_restore_partition(backup_path, "/boot")))
return ret;
if (NULL != volume_for_path("/uboot") && 0 != (ret = nandroid_restore_partition(backup_path, "/uboot")))
return ret;
if (NULL != volume_for_path("/recovery") && 0 != (ret = nandroid_restore_partition(backup_path, "/recovery")))
return ret;
}
struct stat s;
Volume *vol = volume_for_path("/wimax");
if (restore_wimax && vol != NULL && 0 == stat(vol->device, &s))
{
char serialno[PROPERTY_VALUE_MAX];
serialno[0] = 0;
property_get("ro.serialno", serialno, "");
sprintf(tmp, "%s/wimax.%s.img", backup_path, serialno);
struct stat st;
if (0 != stat(tmp, &st))
{
ui_print("警告: WiMAX分区存在，但是\n");
ui_print(" 不存在可恢复的WiMAX 镜像.\n");
ui_print(" 亦需要重新做一个备份 \n");
ui_print(" 来保护你的WiMAX keys.\n");
}
else
{
ui_print("恢复之前先清除WiMAX...\n");
if (0 != (ret = format_volume("/wimax")))
return print_and_error("抹掉wimax失败!\n");
ui_print("恢复WiMAX 镜像...\n");
if (0 != (ret = restore_raw_partition(vol->fs_type, vol->device, tmp)))
return ret;
}
}
if (restore_system && 0 != (ret = nandroid_restore_partition(backup_path, "/system")))
return ret;
if (restore_data && 0 != (ret = nandroid_restore_partition(backup_path, "/data")))
return ret;
if (has_datadata()) {
if (restore_data && 0 != (ret = nandroid_restore_partition(backup_path, "/datadata")))
return ret;
}
if (restore_data && 0 != (ret = nandroid_restore_partition_extended(backup_path, "/sdcard/.android_secure", 0)))
return ret;
if (restore_cache && 0 != (ret = nandroid_restore_partition_extended(backup_path, "/cache", 0)))
return ret;
if (restore_sdext && 0 != (ret = nandroid_restore_partition(backup_path, "/sd-ext")))
return ret;
sync();
ui_set_background(BACKGROUND_ICON_NONE);
ui_reset_progress();
ui_print("\n恢复完成!\n");
return 0;
}
void show_nandroid_menu()
{
static char* headers[] = { "Nandroid",
"",
NULL
};
static char* list[] = { "backup to internal sdcard",
"restore from internal sdcard",
"advanced restore from internal sdcard",
"backup to external sdcard",
"restore from external sdcard",
"advanced restore from external sdcard",
NULL
};
if (volume_for_path("/emmc") == NULL || volume_for_path("/sdcard") == NULL && is_data_media())
list[3] = NULL;
int chosen_item = get_menu_selection(headers, list, 0, 0);
switch (chosen_item)
{
case 0:
{
char backup_path[PATH_MAX];
time_t t = time(NULL);
struct tm *tmp = localtime(&t);
if (tmp == NULL)
{
struct timeval tp;
gettimeofday(&tp, NULL);
sprintf(backup_path, "/emmc/clockworkmod/backup/%d", tp.tv_sec);
}
else
{
strftime(backup_path, sizeof(backup_path), "/emmc/clockworkmod/backup/%F.%H.%M.%S", tmp);
}
nandroid_backup(backup_path);
}
break;
case 1:
show_nandroid_restore_menu("/emmc");
break;
case 2:
show_nandroid_advanced_restore_menu("/emmc");
break;
case 3:
{
char backup_path[PATH_MAX];
time_t t = time(NULL);
struct tm *tmp = localtime(&t);
if (tmp == NULL)
{
struct timeval tp;
gettimeofday(&tp, NULL);
sprintf(backup_path, "/sdcard/clockworkmod/backup/%d", tp.tv_sec);
}
else
{
strftime(backup_path, sizeof(backup_path), "/sdcard/clockworkmod/backup/%F.%H.%M.%S", tmp);
}
nandroid_backup(backup_path);
}
break;
case 4:
show_nandroid_restore_menu("/sdcard");
break;
case 5:
show_nandroid_advanced_restore_menu("/sdcard");
break;
}
}
int nandroid_backup(const char* backup_path)
{
nandroid_backup_bitfield = 0;
ui_set_background(BACKGROUND_ICON_INSTALLING);
refresh_default_backup_handler();
if (ensure_path_mounted(backup_path) != 0) {
return print_and_error("无法挂载备份时需要的存储器.\n");
}
Volume* volume = volume_for_path(backup_path);
if (NULL == volume)
return print_and_error("找不到备份需要的存储器.\n");
if (is_data_media_volume_path(volume->mount_point))
volume = volume_for_path("/data");
int ret;
struct statfs s;
if (NULL != volume) {
if (0 != (ret = statfs(volume->mount_point, &s)))
return print_and_error("找不到备份路径，因此无法开始.\n");
uint64_t bavail = s.f_bavail;
uint64_t bsize = s.f_bsize;
uint64_t sdcard_free = bavail * bsize;
uint64_t sdcard_free_mb = sdcard_free / (uint64_t)(1024 * 1024);
ui_print("SD Card space free: %lluMB\n", sdcard_free_mb);
if (sdcard_free_mb < 150)
ui_print("可能是你的机器空间不足了，继续中...\n");
}
char tmp[PATH_MAX];
ensure_directory(backup_path);
if (0 != (ret = nandroid_backup_partition(backup_path, "/boot")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/uboot")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/recovery")))
return ret;
Volume *vol = volume_for_path("/wimax");
if (vol != NULL && 0 == stat(vol->device, &s))
{
char serialno[PROPERTY_VALUE_MAX];
ui_print("正在备份WiMAX...\n");
serialno[0] = 0;
property_get("ro.serialno", serialno, "");
sprintf(tmp, "%s/wimax.%s.img", backup_path, serialno);
ret = backup_raw_partition(vol->fs_type, vol->device, tmp);
if (0 != ret)
return print_and_error("打包或生成WiMAX镜像失败\n");
}
if (0 != (ret = nandroid_backup_partition(backup_path, "/system")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/data")))
return ret;
if (has_datadata()) {
if (0 != (ret = nandroid_backup_partition(backup_path, "/datadata")))
return ret;
}
if (is_data_media() || 0 != stat("/sdcard/.android_secure", &s)) {
ui_print("没找到 /sdcard/.android_secure. 跳过外部程序备份.\n");
}
else {
if (0 != (ret = nandroid_backup_partition_extended(backup_path, "/sdcard/.android_secure", 0)))
return ret;
}
if (0 != (ret = nandroid_backup_partition_extended(backup_path, "/cache", 0)))
return ret;
vol = volume_for_path("/sd-ext");
if (vol == NULL || 0 != stat(vol->device, &s))
{
ui_print("没找到SD-EXT，因此跳过该处备份.\n");
}
else
{
if (0 != ensure_path_mounted("/sd-ext"))
ui_print("没法挂载SD-EXT，可能是你的机器不支持该选项，跳过该部分的备份\n");
else if (0 != (ret = nandroid_backup_partition(backup_path, "/sd-ext")))
return ret;
}
ui_print("生成md5 校验值...\n");
sprintf(tmp, "nandroid-md5.sh %s", backup_path);
if (0 != (ret = __system(tmp))) {
ui_print("MD5校验值生成失败\n");
return ret;
}
sprintf(tmp, "cp /tmp/recovery.log %s/recovery.log", backup_path);
__system(tmp);
sprintf(tmp, "chmod -R 777 %s ; chmod -R u+r,u+w,g+r,g+w,o+r,o+w /sdcard/clockworkmod ; chmod u+x,g+x,o+x /sdcard/clockworkmod/backup ; chmod u+x,g+x,o+x /sdcard/clockworkmod/blobs", backup_path);
__system(tmp);
sync();
ui_set_background(BACKGROUND_ICON_NONE);
ui_reset_progress();
ui_print("\n备份完成!\n");
return 0;
}
int format_device(const char *device, const char *path, const char *fs_type) {
Volume* v = volume_for_path(path);
if (v == NULL) {
// silent failure for sd-ext
if (strcmp(path, "/sd-ext") == 0)
return -1;
LOGE("unknown volume \"%s\"\n", path);
return -1;
}
if (is_data_media_volume_path(path)) {
return format_unknown_device(NULL, path, NULL);
}
if (strstr(path, "/data") == path && is_data_media()) {
return format_unknown_device(NULL, path, NULL);
}
if (strcmp(fs_type, "ramdisk") == 0) {
// you can't format the ramdisk.
LOGE("can't format_volume \"%s\"", path);
return -1;
}
if (strcmp(fs_type, "rfs") == 0) {
if (ensure_path_unmounted(path) != 0) {
LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point);
return -1;
}
if (0 != format_rfs_device(device, path)) {
LOGE("format_volume: format_rfs_device failed on %s\n", device);
return -1;
}
return 0;
}
if (strcmp(v->mount_point, path) != 0) {
return format_unknown_device(v->device, path, NULL);
}
if (ensure_path_unmounted(path) != 0) {
LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point);
return -1;
}
if (strcmp(fs_type, "yaffs2") == 0 || strcmp(fs_type, "mtd") == 0) {
mtd_scan_partitions();
const MtdPartition* partition = mtd_find_partition_by_name(device);
if (partition == NULL) {
LOGE("format_volume: no MTD partition \"%s\"\n", device);
return -1;
}
MtdWriteContext *write = mtd_write_partition(partition);
if (write == NULL) {
LOGW("format_volume: can't open MTD \"%s\"\n", device);
return -1;
} else if (mtd_erase_blocks(write, -1) == (off_t) -1) {
LOGW("format_volume: can't erase MTD \"%s\"\n", device);
mtd_write_close(write);
return -1;
} else if (mtd_write_close(write)) {
LOGW("format_volume: can't close MTD \"%s\"\n",device);
return -1;
}
return 0;
}
if (strcmp(fs_type, "ext4") == 0) {
int length = 0;
if (strcmp(v->fs_type, "ext4") == 0) {
// Our desired filesystem matches the one in fstab, respect v->length
length = v->length;
}
reset_ext4fs_info();
int result = make_ext4fs(device, length, v->mount_point, sehandle);
if (result != 0) {
LOGE("format_volume: make_extf4fs failed on %s\n", device);
return -1;
}
return 0;
}
return format_unknown_device(device, path, fs_type);
}
void show_mount_usb_storage_menu()
{
int fd, fd2;
Volume *vol = volume_for_path("/sdcard");
if ((fd = open(BOARD_UMS_LUNFILE, O_WRONLY)) < 0) {
LOGE("Unable to open ums lunfile (%s)", strerror(errno));
return -1;
}
if ((write(fd, vol->device, strlen(vol->device)) < 0) &&
(!vol->device2 || (write(fd, vol->device, strlen(vol->device2)) < 0))) {
LOGE("Unable to write to ums lunfile (%s)", strerror(errno));
close(fd);
return -1;
}
#ifdef BOARD_HAS_SDCARD_INTERNAL
vol = volume_for_path("/sdcard-ext");
if ((fd2 = open("/sys/devices/platform/usb_mass_storage/lun1/file", O_WRONLY)) < 0) {
LOGE("Unable to open ums lunfile for secondary SD card (%s)", strerror(errno));
}
if ((write(fd2, vol->device, strlen(vol->device)) < 0) &&
(!vol->device2 || (write(fd2, vol->device, strlen(vol->device2)) < 0))) {
LOGE("Unable to write to ums lunfile for secondary SD card (%s)", strerror(errno));
close(fd2);
}
#endif
static char* headers[] = { "USB Mass Storage device",
"Leaving this menu unmounts",
"all SD cards from your PC.",
"",
NULL
};
static char* list[] = { "Unmount", NULL };
for (;;)
{
int chosen_item = get_menu_selection(headers, list, 0, 0);
if (chosen_item == GO_BACK || chosen_item == 0)
break;
}
char ch = 0;
if ((fd = open(BOARD_UMS_LUNFILE, O_WRONLY)) < 0) {
LOGE("Unable to open ums lunfile (%s)", strerror(errno));
return -1;
}
if (write(fd, &ch, 1) < 0) {
LOGE("Unable to write to ums lunfile (%s)", strerror(errno));
close(fd);
return -1;
}
#ifdef BOARD_HAS_SDCARD_INTERNAL
if ((fd2 = open("/sys/devices/platform/usb_mass_storage/lun1/file", O_WRONLY)) < 0) {
LOGE("Unable to open ums lunfile for secondary SD card (%s)", strerror(errno));
}
if (write(fd2, &ch, 1) < 0) {
LOGE("Unable to write to ums lunfile for secondary SD card (%s)", strerror(errno));
close(fd2);
}
#endif
}
void show_advanced_menu()
{
static char* headers[] = { "Advanced and Debugging Menu",
"",
NULL
};
static char* list[] = { "Reboot Recovery",
"Wipe Dalvik Cache",
"Wipe Battery Stats",
"Report Error",
"Key Test",
#ifndef BOARD_HAS_SMALL_RECOVERY
"Partition SD Card",
"Fix Permissions",
#ifdef BOARD_HAS_SDCARD_INTERNAL
"Partition Internal SD Card",
#endif
#endif
NULL
};
for (;;)
{
int chosen_item = get_menu_selection(headers, list, 0, 0);
if (chosen_item == GO_BACK)
break;
switch (chosen_item)
{
case 0:
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, "recovery");
break;
case 1:
{
if (0 != ensure_path_mounted("/data"))
break;
ensure_path_mounted("/sd-ext");
ensure_path_mounted("/cache");
if (confirm_selection( "Confirm wipe?", "Yes - Wipe Dalvik Cache")) {
__system("rm -r /data/dalvik-cache");
__system("rm -r /cache/dalvik-cache");
__system("rm -r /sd-ext/dalvik-cache");
}
ensure_path_unmounted("/data");
ui_print("Dalvik Cache wiped.\n");
break;
}
case 2:
{
if (confirm_selection( "Confirm wipe?", "Yes - Wipe Battery Stats"))
wipe_battery_stats();
break;
}
case 3:
handle_failure(1);
break;
case 4:
{
ui_print("Outputting key codes.\n");
ui_print("Go back to end debugging.\n");
int key;
int action;
do
{
key = ui_wait_key();
action = device_handle_key(key, 1);
ui_print("Key: %d\n", key);
}
while (action != GO_BACK);
break;
}
case 5:
{
static char* ext_sizes[] = { "128M",
"256M",
"512M",
"1024M",
"2048M",
"4096M",
NULL };
static char* swap_sizes[] = { "0M",
"32M",
"64M",
"128M",
"256M",
NULL };
static char* ext_headers[] = { "Ext Size", "", NULL };
static char* swap_headers[] = { "Swap Size", "", NULL };
int ext_size = get_menu_selection(ext_headers, ext_sizes, 0, 0);
if (ext_size == GO_BACK)
continue;
int swap_size = get_menu_selection(swap_headers, swap_sizes, 0, 0);
if (swap_size == GO_BACK)
continue;
char sddevice[256];
Volume *vol = volume_for_path("/sdcard");
strcpy(sddevice, vol->device);
// we only want the mmcblk, not the partition
sddevice[strlen("/dev/block/mmcblkX")] = NULL;
char cmd[PATH_MAX];
setenv("SDPATH", sddevice, 1);
sprintf(cmd, "sdparted -es %s -ss %s -efs ext3 -s", ext_sizes[ext_size], swap_sizes[swap_size]);
ui_print("Partitioning SD Card... please wait...\n");
if (0 == __system(cmd))
ui_print("Done!\n");
else
ui_print("An error occured while partitioning your SD Card. Please see /tmp/recovery.log for more details.\n");
break;
}
case 6:
{
ensure_path_mounted("/system");
ensure_path_mounted("/data");
ui_print("Fixing permissions...\n");
__system("fix_permissions");
ui_print("Done!\n");
break;
}
case 7:
{
static char* ext_sizes[] = { "128M",
"256M",
"512M",
"1024M",
"2048M",
"4096M",
NULL };
static char* swap_sizes[] = { "0M",
"32M",
"64M",
"128M",
"256M",
NULL };
static char* ext_headers[] = { "Data Size", "", NULL };
static char* swap_headers[] = { "Swap Size", "", NULL };
int ext_size = get_menu_selection(ext_headers, ext_sizes, 0, 0);
if (ext_size == GO_BACK)
continue;
int swap_size = 0;
if (swap_size == GO_BACK)
continue;
char sddevice[256];
Volume *vol = volume_for_path("/emmc");
strcpy(sddevice, vol->device);
// we only want the mmcblk, not the partition
sddevice[strlen("/dev/block/mmcblkX")] = NULL;
char cmd[PATH_MAX];
setenv("SDPATH", sddevice, 1);
sprintf(cmd, "sdparted -es %s -ss %s -efs ext3 -s", ext_sizes[ext_size], swap_sizes[swap_size]);
ui_print("Partitioning Internal SD Card... please wait...\n");
if (0 == __system(cmd))
ui_print("Done!\n");
else
ui_print("An error occured while partitioning your Internal SD Card. Please see /tmp/recovery.log for more details.\n");
break;
}
}
}
}
int format_unknown_device(const char *device, const char* path, const char *fs_type)
{
LOGI("Formatting unknown device.\n");
if (fs_type != NULL && get_flash_type(fs_type) != UNSUPPORTED)
return erase_raw_partition(fs_type, device);
// if this is SDEXT:, don't worry about it if it does not exist.
if (0 == strcmp(path, "/sd-ext"))
{
struct stat st;
Volume *vol = volume_for_path("/sd-ext");
if (vol == NULL || 0 != stat(vol->device, &st))
{
ui_print("No app2sd partition found. Skipping format of /sd-ext.\n");
return 0;
}
}
if (NULL != fs_type) {
if (strcmp("ext3", fs_type) == 0) {
LOGI("Formatting ext3 device.\n");
if (0 != ensure_path_unmounted(path)) {
LOGE("Error while unmounting %s.\n", path);
return -12;
}
return format_ext3_device(device);
}
if (strcmp("ext2", fs_type) == 0) {
LOGI("Formatting ext2 device.\n");
if (0 != ensure_path_unmounted(path)) {
LOGE("Error while unmounting %s.\n", path);
return -12;
}
return format_ext2_device(device);
}
}
if (0 != ensure_path_mounted(path))
{
ui_print("Error mounting %s!\n", path);
ui_print("Skipping format...\n");
return 0;
}
static char tmp[PATH_MAX];
if (strcmp(path, "/data") == 0) {
sprintf(tmp, "cd /data ; for f in $(ls -a | grep -v ^media$); do rm -rf $f; done");
__system(tmp);
}
else {
sprintf(tmp, "rm -rf %s/*", path);
__system(tmp);
sprintf(tmp, "rm -rf %s/.*", path);
__system(tmp);
}
ensure_path_unmounted(path);
return 0;
}
void show_nandroid_advanced_restore_menu(const char* volume)
{
if (ensure_path_mounted(volume) != 0) {
LOGE ("Can't mount %s\n", volume);
return;
}
static char* advancedheaders[] = { "Choose an image to restore",
"",
"Choose an image to restore",
"first. The next menu will",
"give you more options.",
"",
NULL
};
char backup_path[PATH_MAX];
sprintf(backup_path, "%s/clockworkmod/backup/", volume);
char* file = choose_file_menu(backup_path, NULL, advancedheaders);
if (file == NULL)
return;
static char* headers[] = { "Nandroid Advanced Restore",
"",
NULL
};
char* list[] = { "Restore boot",
"Restore system",
"Restore data",
"Restore cache",
"Restore sd-ext",
"Restore wimax",
"Restore webtop",
"Restore PDS",
NULL
};
int num_menu_items = 8;
int webtop = 6, pds = 7;
int webtop_offset = 0, pds_offset = 0;
int i;
char tmp[PATH_MAX];
if (0 != get_partition_device("wimax", tmp)) {
// disable wimax restore option
list[5] = NULL;
webtop_offset--;
pds_offset--;
}
if (volume_for_path("/osh") == NULL) {
// disable webtop restore option
list[6] = NULL;
pds_offset--;
}
if (volume_for_path("/pds") == NULL) {
// disable PDS restore option
list[7] = NULL;
}
for (i = 5; i < num_menu_items; i++)
if ((list[i] == NULL) && (list[i+1] != NULL)) {
list[i] = list[i+1];
list[i+1] = NULL;
}
static char* confirm_restore = "Confirm restore?";
int chosen_item = get_menu_selection(headers, list, 0, 0);
if ((chosen_item >= 0) && (chosen_item <= 4)) {
switch (chosen_item)
{
case 0:
if (confirm_selection(confirm_restore, "Yes - Restore boot"))
nandroid_restore(file, 1, 0, 0, 0, 0, 0, 0, 0);
break;
case 1:
if (confirm_selection(confirm_restore, "Yes - Restore system"))
nandroid_restore(file, 0, 1, 0, 0, 0, 0, 0, 0);
break;
case 2:
if (confirm_selection(confirm_restore, "Yes - Restore data"))
nandroid_restore(file, 0, 0, 1, 0, 0, 0, 0, 0);
break;
case 3:
if (confirm_selection(confirm_restore, "Yes - Restore cache"))
nandroid_restore(file, 0, 0, 0, 1, 0, 0, 0, 0);
break;
case 4:
if (confirm_selection(confirm_restore, "Yes - Restore sd-ext"))
nandroid_restore(file, 0, 0, 0, 0, 1, 0, 0, 0);
break;
}
} else if ((webtop_offset == 0) && (pds_offset == 0) && (chosen_item >= 5) && (chosen_item <= 7)) {
switch (chosen_item)
{
case 5:
if (confirm_selection(confirm_restore, "Yes - Restore wimax"))
nandroid_restore(file, 0, 0, 0, 0, 0, 1, 0, 0);
break;
case 6:
if (confirm_selection(confirm_restore, "Yes - Restore webtop"))
nandroid_restore(file, 0, 0, 0, 0, 0, 0, 1, 0);
break;
case 7:
if (confirm_selection(confirm_restore, "Yes - Restore PDS"))
nandroid_restore(file, 0, 0, 0, 0, 0, 0, 0, 1);
break;
}
} else if ((chosen_item >= 5) && (chosen_item < 7)) {
if (chosen_item == (pds + pds_offset)) {
if (confirm_selection(confirm_restore, "Yes - Restore PDS"))
nandroid_restore(file, 0, 0, 0, 0, 0, 0, 0, 1);
} else if (chosen_item == (webtop + webtop_offset)) {
if (confirm_selection(confirm_restore, "Yes - Restore webtop"))
nandroid_restore(file, 0, 0, 0, 0, 0, 0, 1, 0);
}
}
}
int has_datadata() {
Volume *vol = volume_for_path("/datadata");
return vol != NULL;
}
int nandroid_backup(const char* backup_path)
{
ui_set_background(BACKGROUND_ICON_INSTALLING);
if (ensure_path_mounted("/sdcard") != 0)
return print_and_error("Can't mount /sdcard\n");
int ret;
struct statfs s;
if (0 != (ret = statfs("/sdcard", &s)))
return print_and_error("Unable to stat /sdcard\n");
uint64_t bavail = s.f_bavail;
uint64_t bsize = s.f_bsize;
uint64_t sdcard_free = bavail * bsize;
uint64_t sdcard_free_mb = sdcard_free / (uint64_t)(1024 * 1024);
ui_print("SD Card space free: %lluMB\n", sdcard_free_mb);
if (sdcard_free_mb < 150)
ui_print("There may not be enough free space to complete backup... continuing...\n");
char tmp[PATH_MAX];
sprintf(tmp, "mkdir -p %s", backup_path);
__system(tmp);
if (0 != (ret = nandroid_backup_partition(backup_path, "/boot")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/recovery")))
return ret;
Volume *vol = volume_for_path("/wimax");
if (vol != NULL && 0 == stat(vol->device, &s))
{
char serialno[PROPERTY_VALUE_MAX];
ui_print("Backing up WiMAX...\n");
serialno[0] = 0;
property_get("ro.serialno", serialno, "");
sprintf(tmp, "%s/wimax.%s.img", backup_path, serialno);
ret = backup_raw_partition(vol->fs_type, vol->device, tmp);
if (0 != ret)
return print_and_error("Error while dumping WiMAX image!\n");
}
if (0 != (ret = nandroid_backup_partition(backup_path, "/system")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/data")))
return ret;
if (has_datadata()) {
if (0 != (ret = nandroid_backup_partition(backup_path, "/datadata")))
return ret;
}
if (0 != stat("/sdcard/.android_secure", &s))
{
ui_print("No /sdcard/.android_secure found. Skipping backup of applications on external storage.\n");
}
else
{
if (0 != (ret = nandroid_backup_partition_extended(backup_path, "/sdcard/.android_secure", 0)))
return ret;
}
if (0 != (ret = nandroid_backup_partition_extended(backup_path, "/cache", 0)))
return ret;
#ifdef RECOVERY_HAVE_SD_EXT
vol = volume_for_path("/sd-ext");
if (vol == NULL || 0 != stat(vol->device, &s))
{
ui_print("No sd-ext found. Skipping backup of sd-ext.\n");
}
else
{
if (0 != ensure_path_mounted("/sd-ext"))
ui_print("Could not mount sd-ext. sd-ext backup may not be supported on this device. Skipping backup of sd-ext.\n");
else if (0 != (ret = nandroid_backup_partition(backup_path, "/sd-ext")))
return ret;
}
#endif
ui_print("Generating md5 sum...\n");
sprintf(tmp, "nandroid-md5.sh %s", backup_path);
if (0 != (ret = __system(tmp))) {
ui_print("Error while generating md5 sum!\n");
return ret;
}
sync();
ui_set_background(BACKGROUND_ICON_NONE);
ui_reset_progress();
ui_print("\nBackup complete!\n");
return 0;
}
int format_unknown_device(const char *device, const char* path, const char *fs_type)
{
LOGI("Formatting unknown device.\n");
if (fs_type != NULL && get_flash_type(fs_type) != UNSUPPORTED)
return erase_raw_partition(fs_type, device);
// if this is SDEXT:, don't worry about it if it does not exist.
if (0 == strcmp(path, "/sd-ext"))
{
struct stat st;
Volume *vol = volume_for_path("/sd-ext");
if (vol == NULL || 0 != stat(vol->device, &st))
{
ui_print("No app2sd partition found. Skipping format of /sd-ext.\n");
return 0;
}
}
if (NULL != fs_type) {
if (strcmp("ext3", fs_type) == 0) {
LOGI("Formatting ext3 device.\n");
if (0 != ensure_path_unmounted(path)) {
LOGE("Error while unmounting %s.\n", path);
return -12;
}
return format_ext3_device(device);
}
if (strcmp("ext2", fs_type) == 0) {
LOGI("Formatting ext2 device.\n");
if (0 != ensure_path_unmounted(path)) {
LOGE("Error while unmounting %s.\n", path);
return -12;
}
return format_ext2_device(device);
}
}
if (0 != ensure_path_mounted(path))
{
ui_print("Error mounting %s!\n", path);
ui_print("Skipping format...\n");
return 0;
}
static char tmp[PATH_MAX];
if (strcmp(path, "/data") == 0) {
sprintf(tmp, "cd /data ; for f in $(ls -a | grep -v ^media$); do rm -rf $f; done");
__system(tmp);
// if the /data/media sdcard has already been migrated for android 4.2,
// prevent the migration from happening again by writing the .layout_version
struct stat st;
if (0 == lstat("/data/media/0", &st)) {
char* layout_version = "2";
FILE* f = fopen("/data/.layout_version", "wb");
if (NULL != f) {
fwrite(layout_version, 1, 2, f);
fclose(f);
}
else {
LOGI("error opening /data/.layout_version for write.\n");
}
}
else {
LOGI("/data/media/0 not found. migration may occur.\n");
}
}
else {
sprintf(tmp, "rm -rf %s/*", path);
__system(tmp);
sprintf(tmp, "rm -rf %s/.*", path);
__system(tmp);
}
ensure_path_unmounted(path);
return 0;
}
int nandroid_restore(const char* backup_path, int restore_boot, int restore_system, int restore_data, int restore_cache, int restore_sdext, int restore_wimax)
{
ui_set_background(BACKGROUND_ICON_INSTALLING);
ui_show_indeterminate_progress();
yaffs_files_total = 0;
if (ensure_path_mounted("/sdcard") != 0)
return print_and_error("Can't mount /sdcard\n");
char tmp[PATH_MAX];
ui_print("Checking MD5 sums...\n");
sprintf(tmp, "cd %s && md5sum -c nandroid.md5", backup_path);
if (0 != __system(tmp))
return print_and_error("MD5 mismatch!\n");
int ret;
if (restore_boot && NULL != volume_for_path("/boot") && 0 != (ret = nandroid_restore_partition(backup_path, "/boot")))
return ret;
struct stat s;
Volume *vol = volume_for_path("/wimax");
if (restore_wimax && vol != NULL && 0 == stat(vol->device, &s))
{
char serialno[PROPERTY_VALUE_MAX];
serialno[0] = 0;
property_get("ro.serialno", serialno, "");
sprintf(tmp, "%s/wimax.%s.img", backup_path, serialno);
struct stat st;
if (0 != stat(tmp, &st))
{
ui_print("WARNING: WiMAX partition exists, but nandroid\n");
ui_print(" backup does not contain WiMAX image.\n");
ui_print(" You should create a new backup to\n");
ui_print(" protect your WiMAX keys.\n");
}
else
{
ui_print("Erasing WiMAX before restore...\n");
if (0 != (ret = format_volume("/wimax")))
return print_and_error("Error while formatting wimax!\n");
ui_print("Restoring WiMAX image...\n");
if (0 != (ret = restore_raw_partition(vol->fs_type, vol->device, tmp)))
return ret;
}
}
if (restore_system && 0 != (ret = nandroid_restore_partition(backup_path, "/system")))
return ret;
if (restore_data && 0 != (ret = nandroid_restore_partition(backup_path, "/data")))
return ret;
if (has_datadata()) {
if (restore_data && 0 != (ret = nandroid_restore_partition(backup_path, "/datadata")))
return ret;
}
if (restore_data && 0 != (ret = nandroid_restore_partition_extended(backup_path, "/sdcard/.android_secure", 0)))
return ret;
if (restore_cache && 0 != (ret = nandroid_restore_partition_extended(backup_path, "/cache", 0)))
return ret;
#ifdef RECOVERY_HAVE_SD_EXT
if (restore_sdext && 0 != (ret = nandroid_restore_partition(backup_path, "/sd-ext")))
return ret;
#endif
sync();
ui_set_background(BACKGROUND_ICON_NONE);
ui_reset_progress();
ui_print("\nRestore complete!\n");
return 0;
}
