1// Copyright 2009 The Android Open Source Project
2
3#include <stdio.h>
4#include <stdlib.h>
5#include <stdarg.h>
6#include <string.h>
7#include <unistd.h>
8#include <fcntl.h>
9#include <time.h>
10#include <dirent.h>
11#include <errno.h>
12#include <assert.h>
13#include <ctype.h>
14#include <utime.h>
15#include <sys/stat.h>
16#include <sys/types.h>
17#include <stdint.h>
18
19#include <cutils/properties.h>
20
21#include <private/android_filesystem_config.h>
22
23#ifndef PATH_MAX
24#define PATH_MAX 4096
25#endif
26
27// First version.
28#define FILE_VERSION_1 0xffff0001
29
30// Introduces backup all option to header.
31#define FILE_VERSION_2 0xffff0002
32
33#define FILE_VERSION FILE_VERSION_2
34
35namespace android {
36
37static char nameBuffer[PATH_MAX];
38static struct stat statBuffer;
39
40static char copyBuffer[8192];
41static char *backupFilePath = NULL;
42
43static uint32_t inputFileVersion;
44
45static int opt_backupAll;
46
47#define SPECIAL_NO_TOUCH 0
48#define SPECIAL_NO_BACKUP 1
49
50struct special_dir {
51    const char* path;
52    int type;
53};
54
55/* Directory paths that we will not backup/restore */
56static const struct special_dir SKIP_PATHS[] = {
57    { "/data/misc", SPECIAL_NO_TOUCH },
58    { "/data/system/batterystats.bin", SPECIAL_NO_TOUCH },
59    { "/data/system/location", SPECIAL_NO_TOUCH },
60    { "/data/dalvik-cache", SPECIAL_NO_BACKUP },
61    { NULL, 0 },
62};
63
64/* This is just copied from the shell's built-in wipe command. */
65static int wipe (const char *path)
66{
67    DIR *dir;
68    struct dirent *de;
69    int ret;
70    int i;
71
72    dir = opendir(path);
73
74    if (dir == NULL) {
75        fprintf (stderr, "Error opendir'ing %s: %s\n",
76                    path, strerror(errno));
77        return 0;
78    }
79
80    char *filenameOffset;
81
82    strcpy(nameBuffer, path);
83    strcat(nameBuffer, "/");
84
85    filenameOffset = nameBuffer + strlen(nameBuffer);
86
87    for (;;) {
88        de = readdir(dir);
89
90        if (de == NULL) {
91            break;
92        }
93
94        if (0 == strcmp(de->d_name, ".")
95                || 0 == strcmp(de->d_name, "..")
96                || 0 == strcmp(de->d_name, "lost+found")
97        ) {
98            continue;
99        }
100
101        strcpy(filenameOffset, de->d_name);
102        bool noBackup = false;
103
104        /* See if this is a path we should skip. */
105        for (i = 0; SKIP_PATHS[i].path; i++) {
106            if (strcmp(SKIP_PATHS[i].path, nameBuffer) == 0) {
107                if (opt_backupAll || SKIP_PATHS[i].type == SPECIAL_NO_BACKUP) {
108                    // In this case we didn't back up the directory --
109                    // we do want to wipe its contents, but not the
110                    // directory itself, since the restore file won't
111                    // contain the directory.
112                    noBackup = true;
113                }
114                break;
115            }
116        }
117
118        if (!noBackup && SKIP_PATHS[i].path != NULL) {
119            // This is a SPECIAL_NO_TOUCH directory.
120            continue;
121        }
122
123        ret = lstat (nameBuffer, &statBuffer);
124
125        if (ret != 0) {
126            fprintf(stderr, "warning -- stat() error on '%s': %s\n",
127                    nameBuffer, strerror(errno));
128            continue;
129        }
130
131        if(S_ISDIR(statBuffer.st_mode)) {
132            int i;
133            char *newpath;
134
135            newpath = strdup(nameBuffer);
136            if (wipe(newpath) == 0) {
137                free(newpath);
138                closedir(dir);
139                return 0;
140            }
141
142            if (!noBackup) {
143                ret = rmdir(newpath);
144                if (ret != 0) {
145                    fprintf(stderr, "warning -- rmdir() error on '%s': %s\n",
146                        newpath, strerror(errno));
147                }
148            }
149
150            free(newpath);
151
152            strcpy(nameBuffer, path);
153            strcat(nameBuffer, "/");
154
155        } else {
156            // Don't delete the backup file
157            if (backupFilePath && strcmp(backupFilePath, nameBuffer) == 0) {
158                continue;
159            }
160            ret = unlink(nameBuffer);
161
162            if (ret != 0) {
163                fprintf(stderr, "warning -- unlink() error on '%s': %s\n",
164                    nameBuffer, strerror(errno));
165            }
166        }
167    }
168
169    closedir(dir);
170
171    return 1;
172}
173
174static int write_int32(FILE* fh, int32_t val)
175{
176    int res = fwrite(&val, 1, sizeof(val), fh);
177    if (res != sizeof(val)) {
178        fprintf(stderr, "unable to write int32 (%d bytes): %s\n", res, strerror(errno));
179        return 0;
180    }
181
182    return 1;
183}
184
185static int write_int64(FILE* fh, int64_t val)
186{
187    int res = fwrite(&val, 1, sizeof(val), fh);
188    if (res != sizeof(val)) {
189        fprintf(stderr, "unable to write int64 (%d bytes): %s\n", res, strerror(errno));
190        return 0;
191    }
192
193    return 1;
194}
195
196static int copy_file(FILE* dest, FILE* src, off_t size, const char* destName,
197        const char* srcName)
198{
199    errno = 0;
200
201    off_t origSize = size;
202
203    while (size > 0) {
204        int amt = size > (off_t)sizeof(copyBuffer) ? sizeof(copyBuffer) : (int)size;
205        int readLen = fread(copyBuffer, 1, amt, src);
206        if (readLen <= 0) {
207            if (srcName != NULL) {
208                fprintf(stderr, "unable to read source (%d of %ld bytes) file '%s': %s\n",
209                    amt, origSize, srcName, errno != 0 ? strerror(errno) : "unexpected EOF");
210            } else {
211                fprintf(stderr, "unable to read buffer (%d of %ld bytes): %s\n",
212                    amt, origSize, errno != 0 ? strerror(errno) : "unexpected EOF");
213            }
214            return 0;
215        }
216        int writeLen = fwrite(copyBuffer, 1, readLen, dest);
217        if (writeLen != readLen) {
218            if (destName != NULL) {
219                fprintf(stderr, "unable to write file (%d of %d bytes) '%s': '%s'\n",
220                    writeLen, readLen, destName, strerror(errno));
221            } else {
222                fprintf(stderr, "unable to write buffer (%d of %d bytes): '%s'\n",
223                    writeLen, readLen, strerror(errno));
224            }
225            return 0;
226        }
227        size -= readLen;
228    }
229    return 1;
230}
231
232#define TYPE_END 0
233#define TYPE_DIR 1
234#define TYPE_FILE 2
235
236static int write_header(FILE* fh, int type, const char* path, const struct stat* st)
237{
238    int pathLen = strlen(path);
239    if (!write_int32(fh, type)) return 0;
240    if (!write_int32(fh, pathLen)) return 0;
241    if (fwrite(path, 1, pathLen, fh) != (size_t)pathLen) {
242        fprintf(stderr, "unable to write: %s\n", strerror(errno));
243        return 0;
244    }
245
246    if (!write_int32(fh, st->st_uid)) return 0;
247    if (!write_int32(fh, st->st_gid)) return 0;
248    if (!write_int32(fh, st->st_mode)) return 0;
249    if (!write_int64(fh, ((int64_t)st->st_atime)*1000*1000*1000)) return 0;
250    if (!write_int64(fh, ((int64_t)st->st_mtime)*1000*1000*1000)) return 0;
251    if (!write_int64(fh, ((int64_t)st->st_ctime)*1000*1000*1000)) return 0;
252
253    return 1;
254}
255
256static int backup_dir(FILE* fh, const char* srcPath)
257{
258    DIR *dir;
259    struct dirent *de;
260    char* fullPath = NULL;
261    int srcLen = strlen(srcPath);
262    int result = 1;
263    int i;
264
265    dir = opendir(srcPath);
266
267    if (dir == NULL) {
268        fprintf (stderr, "error opendir'ing '%s': %s\n",
269                    srcPath, strerror(errno));
270        return 0;
271    }
272
273    for (;;) {
274        de = readdir(dir);
275
276        if (de == NULL) {
277            break;
278        }
279
280        if (0 == strcmp(de->d_name, ".")
281                || 0 == strcmp(de->d_name, "..")
282                || 0 == strcmp(de->d_name, "lost+found")
283        ) {
284            continue;
285        }
286
287        if (fullPath != NULL) {
288            free(fullPath);
289        }
290        fullPath = (char*)malloc(srcLen + strlen(de->d_name) + 2);
291        strcpy(fullPath, srcPath);
292        fullPath[srcLen] = '/';
293        strcpy(fullPath+srcLen+1, de->d_name);
294
295        /* See if this is a path we should skip. */
296        if (!opt_backupAll) {
297            for (i = 0; SKIP_PATHS[i].path; i++) {
298                if (strcmp(SKIP_PATHS[i].path, fullPath) == 0) {
299                    break;
300                }
301            }
302            if (SKIP_PATHS[i].path != NULL) {
303                continue;
304            }
305        }
306
307        int ret = lstat(fullPath, &statBuffer);
308
309        if (ret != 0) {
310            fprintf(stderr, "stat() error on '%s': %s\n",
311                    fullPath, strerror(errno));
312            result = 0;
313            goto done;
314        }
315
316        if(S_ISDIR(statBuffer.st_mode)) {
317            printf("Saving dir %s...\n", fullPath);
318
319            if (write_header(fh, TYPE_DIR, fullPath, &statBuffer) == 0) {
320                result = 0;
321                goto done;
322            }
323            if (backup_dir(fh, fullPath) == 0) {
324                result = 0;
325                goto done;
326            }
327        } else if (S_ISREG(statBuffer.st_mode)) {
328            // Skip the backup file
329            if (backupFilePath && strcmp(fullPath, backupFilePath) == 0) {
330                printf("Skipping backup file %s...\n", backupFilePath);
331                continue;
332            } else {
333                printf("Saving file %s...\n", fullPath);
334            }
335            if (write_header(fh, TYPE_FILE, fullPath, &statBuffer) == 0) {
336                result = 0;
337                goto done;
338            }
339
340            off_t size = statBuffer.st_size;
341            if (!write_int64(fh, size)) {
342                result = 0;
343                goto done;
344            }
345
346            FILE* src = fopen(fullPath, "r");
347            if (src == NULL) {
348                fprintf(stderr, "unable to open source file '%s': %s\n",
349                    fullPath, strerror(errno));
350                result = 0;
351                goto done;
352            }
353
354            int copyres = copy_file(fh, src, size, NULL, fullPath);
355            fclose(src);
356            if (!copyres) {
357                result = 0;
358                goto done;
359            }
360        }
361    }
362
363done:
364    if (fullPath != NULL) {
365        free(fullPath);
366    }
367
368    closedir(dir);
369
370    return result;
371}
372
373static int backup_data(const char* destPath)
374{
375    int res = -1;
376
377    FILE* fh = fopen(destPath, "w");
378    if (fh == NULL) {
379        fprintf(stderr, "unable to open destination '%s': %s\n",
380                destPath, strerror(errno));
381        return -1;
382    }
383
384    printf("Backing up /data to %s...\n", destPath);
385
386    // The path that shouldn't be backed up
387    backupFilePath = strdup(destPath);
388
389    if (!write_int32(fh, FILE_VERSION)) goto done;
390    if (!write_int32(fh, opt_backupAll)) goto done;
391    if (!backup_dir(fh, "/data")) goto done;
392    if (!write_int32(fh, 0)) goto done;
393
394    res = 0;
395
396done:
397    if (fflush(fh) != 0) {
398        fprintf(stderr, "error flushing destination '%s': %s\n",
399            destPath, strerror(errno));
400        res = -1;
401        goto donedone;
402    }
403    if (fsync(fileno(fh)) != 0) {
404        fprintf(stderr, "error syncing destination '%s': %s\n",
405            destPath, strerror(errno));
406        res = -1;
407        goto donedone;
408    }
409    fclose(fh);
410    sync();
411
412donedone:
413    return res;
414}
415
416static int32_t read_int32(FILE* fh, int32_t defVal)
417{
418    int32_t val;
419    if (fread(&val, 1, sizeof(val), fh) != sizeof(val)) {
420        fprintf(stderr, "unable to read: %s\n", strerror(errno));
421        return defVal;
422    }
423
424    return val;
425}
426
427static int64_t read_int64(FILE* fh, int64_t defVal)
428{
429    int64_t val;
430    if (fread(&val, 1, sizeof(val), fh) != sizeof(val)) {
431        fprintf(stderr, "unable to read: %s\n", strerror(errno));
432        return defVal;
433    }
434
435    return val;
436}
437
438static int read_header(FILE* fh, int* type, char** path, struct stat* st)
439{
440    *type = read_int32(fh, -1);
441    if (*type == TYPE_END) {
442        return 1;
443    }
444
445    if (*type < 0) {
446        fprintf(stderr, "bad token %d in restore file\n", *type);
447        return 0;
448    }
449
450    int32_t pathLen = read_int32(fh, -1);
451    if (pathLen <= 0) {
452        fprintf(stderr, "bad path length %d in restore file\n", pathLen);
453        return 0;
454    }
455    char* readPath = (char*)malloc(pathLen+1);
456    if (fread(readPath, 1, pathLen, fh) != (size_t)pathLen) {
457        fprintf(stderr, "truncated path in restore file\n");
458        free(readPath);
459        return 0;
460    }
461    readPath[pathLen] = 0;
462    *path = readPath;
463
464    st->st_uid = read_int32(fh, -1);
465    if (st->st_uid == (uid_t)-1) {
466        fprintf(stderr, "bad uid in restore file at '%s'\n", readPath);
467        return 0;
468    }
469    st->st_gid = read_int32(fh, -1);
470    if (st->st_gid == (gid_t)-1) {
471        fprintf(stderr, "bad gid in restore file at '%s'\n", readPath);
472        return 0;
473    }
474    st->st_mode = read_int32(fh, -1);
475    if (st->st_mode == (mode_t)-1) {
476        fprintf(stderr, "bad mode in restore file at '%s'\n", readPath);
477        return 0;
478    }
479    int64_t ltime = read_int64(fh, -1);
480    if (ltime < 0) {
481        fprintf(stderr, "bad atime in restore file at '%s'\n", readPath);
482        return 0;
483    }
484    st->st_atime = (time_t)(ltime/1000/1000/1000);
485    ltime = read_int64(fh, -1);
486    if (ltime < 0) {
487        fprintf(stderr, "bad mtime in restore file at '%s'\n", readPath);
488        return 0;
489    }
490    st->st_mtime = (time_t)(ltime/1000/1000/1000);
491    ltime = read_int64(fh, -1);
492    if (ltime < 0) {
493        fprintf(stderr, "bad ctime in restore file at '%s'\n", readPath);
494        return 0;
495    }
496    st->st_ctime = (time_t)(ltime/1000/1000/1000);
497
498    st->st_mode &= (S_IRWXU|S_IRWXG|S_IRWXO);
499
500    return 1;
501}
502
503static int restore_data(const char* srcPath)
504{
505    int res = -1;
506
507    FILE* fh = fopen(srcPath, "r");
508    if (fh == NULL) {
509        fprintf(stderr, "Unable to open source '%s': %s\n",
510                srcPath, strerror(errno));
511        return -1;
512    }
513
514    inputFileVersion = read_int32(fh, 0);
515    if (inputFileVersion < FILE_VERSION_1 || inputFileVersion > FILE_VERSION) {
516        fprintf(stderr, "Restore file has bad version: 0x%x\n", inputFileVersion);
517        goto done;
518    }
519
520    if (inputFileVersion >= FILE_VERSION_2) {
521        opt_backupAll = read_int32(fh, 0);
522    } else {
523        opt_backupAll = 0;
524    }
525
526    // The path that shouldn't be deleted
527    backupFilePath = strdup(srcPath);
528
529    printf("Wiping contents of /data...\n");
530    if (!wipe("/data")) {
531        goto done;
532    }
533
534    printf("Restoring from %s to /data...\n", srcPath);
535
536    while (1) {
537        int type;
538        char* path = NULL;
539        if (read_header(fh, &type, &path, &statBuffer) == 0) {
540            goto done;
541        }
542        if (type == 0) {
543            break;
544        }
545
546        const char* typeName = "?";
547
548        if (type == TYPE_DIR) {
549            typeName = "dir";
550
551            printf("Restoring dir %s...\n", path);
552
553            if (mkdir(path, statBuffer.st_mode) != 0) {
554                if (errno != EEXIST) {
555                    fprintf(stderr, "unable to create directory '%s': %s\n",
556                        path, strerror(errno));
557                    free(path);
558                    goto done;
559                }
560            }
561
562        } else if (type == TYPE_FILE) {
563            typeName = "file";
564            off_t size = read_int64(fh, -1);
565            if (size < 0) {
566                fprintf(stderr, "bad file size %ld in restore file\n", size);
567                free(path);
568                goto done;
569            }
570
571            printf("Restoring file %s...\n", path);
572
573            FILE* dest = fopen(path, "w");
574            if (dest == NULL) {
575                fprintf(stderr, "unable to open destination file '%s': %s\n",
576                    path, strerror(errno));
577                free(path);
578                goto done;
579            }
580
581            int copyres = copy_file(dest, fh, size, path, NULL);
582            fclose(dest);
583            if (!copyres) {
584                free(path);
585                goto done;
586            }
587
588        } else {
589            fprintf(stderr, "unknown node type %d\n", type);
590            goto done;
591        }
592
593        // Do this even for directories, since the dir may have already existed
594        // so we need to make sure it gets the correct mode.
595        if (chmod(path, statBuffer.st_mode&(S_IRWXU|S_IRWXG|S_IRWXO)) != 0) {
596            fprintf(stderr, "unable to chmod destination %s '%s' to 0x%x: %s\n",
597                typeName, path, statBuffer.st_mode, strerror(errno));
598            free(path);
599            goto done;
600        }
601
602        if (chown(path, statBuffer.st_uid, statBuffer.st_gid) != 0) {
603            fprintf(stderr, "unable to chown destination %s '%s' to uid %d / gid %d: %s\n",
604                typeName, path, (int)statBuffer.st_uid, (int)statBuffer.st_gid, strerror(errno));
605            free(path);
606            goto done;
607        }
608
609        struct utimbuf timbuf;
610        timbuf.actime = statBuffer.st_atime;
611        timbuf.modtime = statBuffer.st_mtime;
612        if (utime(path, &timbuf) != 0) {
613            fprintf(stderr, "unable to utime destination %s '%s': %s\n",
614                typeName, path, strerror(errno));
615            free(path);
616            goto done;
617        }
618
619
620        free(path);
621    }
622
623    res = 0;
624
625done:
626    fclose(fh);
627
628    return res;
629}
630
631static void show_help(const char *cmd)
632{
633    fprintf(stderr,"Usage: %s COMMAND [options] [backup-file-path]\n", cmd);
634
635    fprintf(stderr, "commands are:\n"
636                    "  help            Show this help text.\n"
637                    "  backup          Perform a backup of /data.\n"
638                    "  restore         Perform a restore of /data.\n");
639    fprintf(stderr, "options include:\n"
640                    "  -h              Show this help text.\n"
641                    "  -a              Backup all files.\n");
642    fprintf(stderr, "\n backup-file-path Defaults to /sdcard/backup.dat .\n"
643                    "                  On devices that emulate the sdcard, you will need to\n"
644                    "                  explicitly specify the directory it is mapped to,\n"
645                    "                  to avoid recursive backup or deletion of the backup file\n"
646                    "                  during restore.\n\n"
647                    "                  Eg. /data/media/0/backup.dat\n");
648    fprintf(stderr, "\nThe %s command allows you to perform low-level\n"
649                    "backup and restore of the /data partition.  This is\n"
650                    "where all user data is kept, allowing for a fairly\n"
651                    "complete restore of a device's state.  Note that\n"
652                    "because this is low-level, it will only work across\n"
653                    "builds of the same (or very similar) device software.\n",
654                    cmd);
655}
656
657} /* namespace android */
658
659int main (int argc, char **argv)
660{
661    int restore = 0;
662
663    if (getuid() != AID_ROOT) {
664        fprintf(stderr, "error -- %s must run as root\n", argv[0]);
665        exit(-1);
666    }
667
668    if (argc < 2) {
669        fprintf(stderr, "No command specified.\n");
670        android::show_help(argv[0]);
671        exit(-1);
672    }
673
674    if (0 == strcmp(argv[1], "restore")) {
675        restore = 1;
676    } else if (0 == strcmp(argv[1], "help")) {
677        android::show_help(argv[0]);
678        exit(0);
679    } else if (0 != strcmp(argv[1], "backup")) {
680        fprintf(stderr, "Unknown command: %s\n", argv[1]);
681        android::show_help(argv[0]);
682        exit(-1);
683    }
684
685    android::opt_backupAll = 0;
686
687    optind = 2;
688
689    for (;;) {
690        int ret;
691
692        ret = getopt(argc, argv, "ah");
693
694        if (ret < 0) {
695            break;
696        }
697
698        switch(ret) {
699            case 'a':
700                android::opt_backupAll = 1;
701                if (restore) fprintf(stderr, "Warning: -a option ignored on restore\n");
702                break;
703            case 'h':
704                android::show_help(argv[0]);
705                exit(0);
706            break;
707
708            default:
709                fprintf(stderr,"Unrecognized Option\n");
710                android::show_help(argv[0]);
711                exit(-1);
712            break;
713        }
714    }
715
716    const char* backupFile = "/sdcard/backup.dat";
717
718    if (argc > optind) {
719        backupFile = argv[optind];
720        optind++;
721        if (argc != optind) {
722            fprintf(stderr, "Too many arguments\n");
723            android::show_help(argv[0]);
724            exit(-1);
725        }
726    }
727
728    printf("Stopping system...\n");
729    property_set("ctl.stop", "runtime");
730    property_set("ctl.stop", "zygote");
731    sleep(1);
732
733    int res;
734    if (restore) {
735        res = android::restore_data(backupFile);
736        if (res != 0) {
737            // Don't restart system, since the data partition is hosed.
738            return res;
739        }
740        printf("Restore complete!  Restarting system, cross your fingers...\n");
741    } else {
742        res = android::backup_data(backupFile);
743        if (res == 0) {
744            printf("Backup complete!  Restarting system...\n");
745        } else {
746            printf("Restarting system...\n");
747        }
748    }
749
750    property_set("ctl.start", "zygote");
751    property_set("ctl.start", "runtime");
752}
753