自学教程：C++ volume_for_path函数代码示例

//custom backup: raw backup through shell (ext4 raw backup not supported in backup_raw_partition())//ret = 0 if success, else ret = 1int 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 = 1int 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;                        }                    }//.........这里部分代码省略.........

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;    }//.........这里部分代码省略.........

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;    }//.........这里部分代码省略.........

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)) {//.........这里部分代码省略.........

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;//.........这里部分代码省略.........

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);//.........这里部分代码省略.........

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}

//.........这里部分代码省略.........                }                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 };

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"))//.........这里部分代码省略.........

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;}