/* * Copyright (C) 2009 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define LOG_TAG "file_backup_helper" #include #include #include #include #include #include #include #include #include // for utimes #include #include #include #include #include #include #include namespace android { #define MAGIC0 0x70616e53 // Snap #define MAGIC1 0x656c6946 // File /* * File entity data format (v1): * * - 4-byte version number of the metadata, little endian (0x00000001 for v1) * - 12 bytes of metadata * - the file data itself * * i.e. a 16-byte metadata header followed by the raw file data. If the * restore code does not recognize the metadata version, it can still * interpret the file data itself correctly. * * file_metadata_v1: * * - 4 byte version number === 0x00000001 (little endian) * - 4-byte access mode (little-endian) * - undefined (8 bytes) */ struct file_metadata_v1 { int version; int mode; int undefined_1; int undefined_2; }; const static int CURRENT_METADATA_VERSION = 1; // auto-free buffer management object class StAutoFree { public: StAutoFree(void* buffer) { mBuf = buffer; } ~StAutoFree() { free(mBuf); } private: void* mBuf; }; #if 1 // TEST_BACKUP_HELPERS #define LOGP(f, x...) printf(f "\n", x) #else #define LOGP(x...) LOGD(x) #endif const static int ROUND_UP[4] = { 0, 3, 2, 1 }; static inline int round_up(int n) { return n + ROUND_UP[n % 4]; } static int read_snapshot_file(int fd, KeyedVector* snapshot) { int bytesRead = 0; int amt; SnapshotHeader header; amt = read(fd, &header, sizeof(header)); if (amt != sizeof(header)) { return errno; } bytesRead += amt; if (header.magic0 != MAGIC0 || header.magic1 != MAGIC1) { LOGW("read_snapshot_file header.magic0=0x%08x magic1=0x%08x", header.magic0, header.magic1); return 1; } for (int i=0; iadd(String8(filename, file.nameLen), file); } bytesRead += amt; if (filename != filenameBuf) { free(filename); } if (amt != nameBufSize) { LOGW("read_snapshot_file filename truncated/error with read at %d bytes\n", bytesRead); return 1; } } if (header.totalSize != bytesRead) { LOGW("read_snapshot_file length mismatch: header.totalSize=%d bytesRead=%d\n", header.totalSize, bytesRead); return 1; } return 0; } static int write_snapshot_file(int fd, const KeyedVector& snapshot) { int fileCount = 0; int bytesWritten = sizeof(SnapshotHeader); // preflight size const int N = snapshot.size(); for (int i=0; iWriteEntityHeader(key, -1); } static int write_update_file(BackupDataWriter* dataStream, int fd, int mode, const String8& key, char const* realFilename) { LOGP("write_update_file %s (%s) : mode 0%o\n", realFilename, key.string(), mode); const int bufsize = 4*1024; int err; int amt; int fileSize; int bytesLeft; file_metadata_v1 metadata; char* buf = (char*)malloc(bufsize); StAutoFree _autoFree(buf); int crc = crc32(0L, Z_NULL, 0); fileSize = lseek(fd, 0, SEEK_END); lseek(fd, 0, SEEK_SET); if (sizeof(metadata) != 16) { LOGE("ERROR: metadata block is the wrong size!"); } bytesLeft = fileSize + sizeof(metadata); err = dataStream->WriteEntityHeader(key, bytesLeft); if (err != 0) { return err; } // store the file metadata first metadata.version = tolel(CURRENT_METADATA_VERSION); metadata.mode = tolel(mode); metadata.undefined_1 = metadata.undefined_2 = 0; err = dataStream->WriteEntityData(&metadata, sizeof(metadata)); if (err != 0) { return err; } bytesLeft -= sizeof(metadata); // bytesLeft should == fileSize now // now store the file content while ((amt = read(fd, buf, bufsize)) != 0 && bytesLeft > 0) { bytesLeft -= amt; if (bytesLeft < 0) { amt += bytesLeft; // Plus a negative is minus. Don't write more than we promised. } err = dataStream->WriteEntityData(buf, amt); if (err != 0) { return err; } } if (bytesLeft != 0) { if (bytesLeft > 0) { // Pad out the space we promised in the buffer. We can't corrupt the buffer, // even though the data we're sending is probably bad. memset(buf, 0, bufsize); while (bytesLeft > 0) { amt = bytesLeft < bufsize ? bytesLeft : bufsize; bytesLeft -= amt; err = dataStream->WriteEntityData(buf, amt); if (err != 0) { return err; } } } LOGE("write_update_file size mismatch for %s. expected=%d actual=%d." " You aren't doing proper locking!", realFilename, fileSize, fileSize-bytesLeft); } return NO_ERROR; } static int write_update_file(BackupDataWriter* dataStream, const String8& key, char const* realFilename) { int err; struct stat st; err = stat(realFilename, &st); if (err < 0) { return errno; } int fd = open(realFilename, O_RDONLY); if (fd == -1) { return errno; } err = write_update_file(dataStream, fd, st.st_mode, key, realFilename); close(fd); return err; } static int compute_crc32(int fd) { const int bufsize = 4*1024; int amt; char* buf = (char*)malloc(bufsize); StAutoFree _autoFree(buf); int crc = crc32(0L, Z_NULL, 0); lseek(fd, 0, SEEK_SET); while ((amt = read(fd, buf, bufsize)) != 0) { crc = crc32(crc, (Bytef*)buf, amt); } return crc; } int back_up_files(int oldSnapshotFD, BackupDataWriter* dataStream, int newSnapshotFD, char const* const* files, char const* const* keys, int fileCount) { int err; KeyedVector oldSnapshot; KeyedVector newSnapshot; if (oldSnapshotFD != -1) { err = read_snapshot_file(oldSnapshotFD, &oldSnapshot); if (err != 0) { // On an error, treat this as a full backup. oldSnapshot.clear(); } } for (int i=0; i= 0) { LOGP("back_up_files key already in use '%s'", key.string()); return -1; } } newSnapshot.add(key, r); } int n = 0; int N = oldSnapshot.size(); int m = 0; while (nWriteEntityHeader(p, -1); n++; } else if (cmp > 0) { // file added LOGP("file added: %s", g.file.string()); write_update_file(dataStream, q, g.file.string()); m++; } else { // both files exist, check them const FileState& f = oldSnapshot.valueAt(n); int fd = open(g.file.string(), O_RDONLY); if (fd < 0) { // We can't open the file. Don't report it as a delete either. Let the // server keep the old version. Maybe they'll be able to deal with it // on restore. LOGP("Unable to open file %s - skipping", g.file.string()); } else { g.s.crc32 = compute_crc32(fd); LOGP("%s", q.string()); LOGP(" new: modTime=%d,%d mode=%04o size=%-3d crc32=0x%08x", f.modTime_sec, f.modTime_nsec, f.mode, f.size, f.crc32); LOGP(" old: modTime=%d,%d mode=%04o size=%-3d crc32=0x%08x", g.s.modTime_sec, g.s.modTime_nsec, g.s.mode, g.s.size, g.s.crc32); if (f.modTime_sec != g.s.modTime_sec || f.modTime_nsec != g.s.modTime_nsec || f.mode != g.s.mode || f.size != g.s.size || f.crc32 != g.s.crc32) { write_update_file(dataStream, fd, g.s.mode, p, g.file.string()); } close(fd); } n++; m++; } } // these were deleted while (nWriteEntityHeader(oldSnapshot.keyAt(n), -1); n++; } // these were added while (mReadEntityHeader(&key, &dataSize); if (err != NO_ERROR) { return err; } // Get the metadata block off the head of the file entity and use that to // set up the output file file_metadata_v1 metadata; amt = in->ReadEntityData(&metadata, sizeof(metadata)); if (amt != sizeof(metadata)) { LOGW("Could not read metadata for %s -- %ld / %s", filename.string(), (long)amt, strerror(errno)); return EIO; } metadata.version = fromlel(metadata.version); metadata.mode = fromlel(metadata.mode); if (metadata.version > CURRENT_METADATA_VERSION) { LOGW("Restoring file with unsupported metadata version %d (currently %d)", metadata.version, CURRENT_METADATA_VERSION); } mode = metadata.mode; // Write the file and compute the crc crc = crc32(0L, Z_NULL, 0); fd = open(filename.string(), O_CREAT|O_RDWR|O_TRUNC, mode); if (fd == -1) { LOGW("Could not open file %s -- %s", filename.string(), strerror(errno)); return errno; } while ((amt = in->ReadEntityData(buf, RESTORE_BUF_SIZE)) > 0) { err = write(fd, buf, amt); if (err != amt) { close(fd); LOGW("Error '%s' writing '%s'", strerror(errno), filename.string()); return errno; } crc = crc32(crc, (Bytef*)buf, amt); } close(fd); // Record for the snapshot err = stat(filename.string(), &st); if (err != 0) { LOGW("Error stating file that we just created %s", filename.string()); return errno; } r.file = filename; r.deleted = false; r.s.modTime_sec = st.st_mtime; r.s.modTime_nsec = 0; // workaround sim breakage //r.s.modTime_nsec = st.st_mtime_nsec; r.s.mode = st.st_mode; r.s.size = st.st_size; r.s.crc32 = crc; m_files.add(key, r); return NO_ERROR; } status_t RestoreHelperBase::WriteSnapshot(int fd) { return write_snapshot_file(fd, m_files);; } #if TEST_BACKUP_HELPERS #define SCRATCH_DIR "/data/backup_helper_test/" static int write_text_file(const char* path, const char* data) { int amt; int fd; int len; fd = creat(path, 0666); if (fd == -1) { fprintf(stderr, "creat %s failed\n", path); return errno; } len = strlen(data); amt = write(fd, data, len); if (amt != len) { fprintf(stderr, "error (%s) writing to file %s\n", strerror(errno), path); return errno; } close(fd); return 0; } static int compare_file(const char* path, const unsigned char* data, int len) { int fd; int amt; fd = open(path, O_RDONLY); if (fd == -1) { fprintf(stderr, "compare_file error (%s) opening %s\n", strerror(errno), path); return errno; } unsigned char* contents = (unsigned char*)malloc(len); if (contents == NULL) { fprintf(stderr, "malloc(%d) failed\n", len); return ENOMEM; } StAutoFree _autoFree(contents); bool sizesMatch = true; amt = lseek(fd, 0, SEEK_END); if (amt != len) { fprintf(stderr, "compare_file file length should be %d, was %d\n", len, amt); sizesMatch = false; } lseek(fd, 0, SEEK_SET); int readLen = amt < len ? amt : len; amt = read(fd, contents, readLen); if (amt != readLen) { fprintf(stderr, "compare_file read expected %d bytes but got %d\n", len, amt); } bool contentsMatch = true; for (int i=0; i snapshot; const char* filename = SCRATCH_DIR "backup_helper_test_empty.snap"; system("rm -r " SCRATCH_DIR); mkdir(SCRATCH_DIR, 0777); // write fd = creat(filename, 0666); if (fd == -1) { fprintf(stderr, "error creating %s\n", filename); return 1; } err = write_snapshot_file(fd, snapshot); close(fd); if (err != 0) { fprintf(stderr, "write_snapshot_file reported error %d (%s)\n", err, strerror(err)); return err; } static const unsigned char correct_data[] = { 0x53, 0x6e, 0x61, 0x70, 0x00, 0x00, 0x00, 0x00, 0x46, 0x69, 0x6c, 0x65, 0x10, 0x00, 0x00, 0x00 }; err = compare_file(filename, correct_data, sizeof(correct_data)); if (err != 0) { return err; } // read fd = open(filename, O_RDONLY); if (fd == -1) { fprintf(stderr, "error opening for read %s\n", filename); return 1; } KeyedVector readSnapshot; err = read_snapshot_file(fd, &readSnapshot); if (err != 0) { fprintf(stderr, "read_snapshot_file failed %d\n", err); return err; } if (readSnapshot.size() != 0) { fprintf(stderr, "readSnapshot should be length 0\n"); return 1; } return 0; } int backup_helper_test_four() { int err; int fd; KeyedVector snapshot; const char* filename = SCRATCH_DIR "backup_helper_test_four.snap"; system("rm -r " SCRATCH_DIR); mkdir(SCRATCH_DIR, 0777); // write fd = creat(filename, 0666); if (fd == -1) { fprintf(stderr, "error opening %s\n", filename); return 1; } String8 filenames[4]; FileState states[4]; FileRec r; r.deleted = false; states[0].modTime_sec = 0xfedcba98; states[0].modTime_nsec = 0xdeadbeef; states[0].mode = 0777; // decimal 511, hex 0x000001ff states[0].size = 0xababbcbc; states[0].crc32 = 0x12345678; states[0].nameLen = -12; r.s = states[0]; filenames[0] = String8("bytes_of_padding"); snapshot.add(filenames[0], r); states[1].modTime_sec = 0x93400031; states[1].modTime_nsec = 0xdeadbeef; states[1].mode = 0666; // decimal 438, hex 0x000001b6 states[1].size = 0x88557766; states[1].crc32 = 0x22334422; states[1].nameLen = -1; r.s = states[1]; filenames[1] = String8("bytes_of_padding3"); snapshot.add(filenames[1], r); states[2].modTime_sec = 0x33221144; states[2].modTime_nsec = 0xdeadbeef; states[2].mode = 0744; // decimal 484, hex 0x000001e4 states[2].size = 0x11223344; states[2].crc32 = 0x01122334; states[2].nameLen = 0; r.s = states[2]; filenames[2] = String8("bytes_of_padding_2"); snapshot.add(filenames[2], r); states[3].modTime_sec = 0x33221144; states[3].modTime_nsec = 0xdeadbeef; states[3].mode = 0755; // decimal 493, hex 0x000001ed states[3].size = 0x11223344; states[3].crc32 = 0x01122334; states[3].nameLen = 0; r.s = states[3]; filenames[3] = String8("bytes_of_padding__1"); snapshot.add(filenames[3], r); err = write_snapshot_file(fd, snapshot); close(fd); if (err != 0) { fprintf(stderr, "write_snapshot_file reported error %d (%s)\n", err, strerror(err)); return err; } static const unsigned char correct_data[] = { // header 0x53, 0x6e, 0x61, 0x70, 0x04, 0x00, 0x00, 0x00, 0x46, 0x69, 0x6c, 0x65, 0xbc, 0x00, 0x00, 0x00, // bytes_of_padding 0x98, 0xba, 0xdc, 0xfe, 0xef, 0xbe, 0xad, 0xde, 0xff, 0x01, 0x00, 0x00, 0xbc, 0xbc, 0xab, 0xab, 0x78, 0x56, 0x34, 0x12, 0x10, 0x00, 0x00, 0x00, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, 0x6f, 0x66, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, // bytes_of_padding3 0x31, 0x00, 0x40, 0x93, 0xef, 0xbe, 0xad, 0xde, 0xb6, 0x01, 0x00, 0x00, 0x66, 0x77, 0x55, 0x88, 0x22, 0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, 0x6f, 0x66, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x33, 0xab, 0xab, 0xab, // bytes of padding2 0x44, 0x11, 0x22, 0x33, 0xef, 0xbe, 0xad, 0xde, 0xe4, 0x01, 0x00, 0x00, 0x44, 0x33, 0x22, 0x11, 0x34, 0x23, 0x12, 0x01, 0x12, 0x00, 0x00, 0x00, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, 0x6f, 0x66, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x32, 0xab, 0xab, // bytes of padding3 0x44, 0x11, 0x22, 0x33, 0xef, 0xbe, 0xad, 0xde, 0xed, 0x01, 0x00, 0x00, 0x44, 0x33, 0x22, 0x11, 0x34, 0x23, 0x12, 0x01, 0x13, 0x00, 0x00, 0x00, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, 0x6f, 0x66, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x5f, 0x31, 0xab }; err = compare_file(filename, correct_data, sizeof(correct_data)); if (err != 0) { return err; } // read fd = open(filename, O_RDONLY); if (fd == -1) { fprintf(stderr, "error opening for read %s\n", filename); return 1; } KeyedVector readSnapshot; err = read_snapshot_file(fd, &readSnapshot); if (err != 0) { fprintf(stderr, "read_snapshot_file failed %d\n", err); return err; } if (readSnapshot.size() != 4) { fprintf(stderr, "readSnapshot should be length 4 is %d\n", readSnapshot.size()); return 1; } bool matched = true; for (size_t i=0; i