1 /* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef _UTILS_BACKUP_HELPERS_H 18 #define _UTILS_BACKUP_HELPERS_H 19 20 #include <utils/Errors.h> 21 #include <utils/String8.h> 22 #include <utils/KeyedVector.h> 23 24 namespace android { 25 26 enum { 27 BACKUP_HEADER_ENTITY_V1 = 0x61746144, // Data (little endian) 28 }; 29 30 typedef struct { 31 int type; // BACKUP_HEADER_ENTITY_V1 32 int keyLen; // length of the key name, not including the null terminator 33 int dataSize; // size of the data, not including the padding, -1 means delete 34 } entity_header_v1; 35 36 struct SnapshotHeader { 37 int magic0; 38 int fileCount; 39 int magic1; 40 int totalSize; 41 }; 42 43 struct FileState { 44 int modTime_sec; 45 int modTime_nsec; 46 int mode; 47 int size; 48 int crc32; 49 int nameLen; 50 }; 51 52 struct FileRec { 53 String8 file; 54 bool deleted; 55 FileState s; 56 }; 57 58 59 /** 60 * Writes the data. 61 * 62 * If an error occurs, it poisons this object and all write calls will fail 63 * with the error that occurred. 64 */ 65 class BackupDataWriter 66 { 67 public: 68 BackupDataWriter(int fd); 69 // does not close fd 70 ~BackupDataWriter(); 71 72 status_t WriteEntityHeader(const String8& key, size_t dataSize); 73 status_t WriteEntityData(const void* data, size_t size); 74 75 void SetKeyPrefix(const String8& keyPrefix); 76 77 private: 78 explicit BackupDataWriter(); 79 status_t write_padding_for(int n); 80 81 int m_fd; 82 status_t m_status; 83 ssize_t m_pos; 84 int m_entityCount; 85 String8 m_keyPrefix; 86 }; 87 88 /** 89 * Reads the data. 90 * 91 * If an error occurs, it poisons this object and all write calls will fail 92 * with the error that occurred. 93 */ 94 class BackupDataReader 95 { 96 public: 97 BackupDataReader(int fd); 98 // does not close fd 99 ~BackupDataReader(); 100 101 status_t Status(); 102 status_t ReadNextHeader(bool* done, int* type); 103 104 bool HasEntities(); 105 status_t ReadEntityHeader(String8* key, size_t* dataSize); 106 status_t SkipEntityData(); // must be called with the pointer at the begining of the data. 107 ssize_t ReadEntityData(void* data, size_t size); 108 109 private: 110 explicit BackupDataReader(); 111 status_t skip_padding(); 112 113 int m_fd; 114 bool m_done; 115 status_t m_status; 116 ssize_t m_pos; 117 ssize_t m_dataEndPos; 118 int m_entityCount; 119 union { 120 int type; 121 entity_header_v1 entity; 122 } m_header; 123 String8 m_key; 124 }; 125 126 int back_up_files(int oldSnapshotFD, BackupDataWriter* dataStream, int newSnapshotFD, 127 char const* const* files, char const* const *keys, int fileCount); 128 129 class RestoreHelperBase 130 { 131 public: 132 RestoreHelperBase(); 133 ~RestoreHelperBase(); 134 135 status_t WriteFile(const String8& filename, BackupDataReader* in); 136 status_t WriteSnapshot(int fd); 137 138 private: 139 void* m_buf; 140 bool m_loggedUnknownMetadata; 141 KeyedVector<String8,FileRec> m_files; 142 }; 143 144 #define TEST_BACKUP_HELPERS 1 145 146 #if TEST_BACKUP_HELPERS 147 int backup_helper_test_empty(); 148 int backup_helper_test_four(); 149 int backup_helper_test_files(); 150 int backup_helper_test_null_base(); 151 int backup_helper_test_missing_file(); 152 int backup_helper_test_data_writer(); 153 int backup_helper_test_data_reader(); 154 #endif 155 156 } // namespace android 157 158 #endif // _UTILS_BACKUP_HELPERS_H 159