include/androidfw/BackupHelpers.h

   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 <sys/stat.h>
  21
  22 #include <utils/Errors.h>
  23 #include <utils/String8.h>
  24 #include <utils/KeyedVector.h>
  25
  26 namespace android {
  27
  28 enum {
  29     BACKUP_HEADER_ENTITY_V1 = 0x61746144, // Data (little endian)
  30 };
  31
  32 typedef struct {
  33     int type; // BACKUP_HEADER_ENTITY_V1
  34     int keyLen; // length of the key name, not including the null terminator
  35     int dataSize; // size of the data, not including the padding, -1 means delete
  36 } entity_header_v1;
  37
  38 struct SnapshotHeader {
  39     int magic0;
  40     int fileCount;
  41     int magic1;
  42     int totalSize;
  43 };
  44
  45 struct FileState {
  46     int modTime_sec;
  47     int modTime_nsec;
  48     int mode;
  49     int size;
  50     int crc32;
  51     int nameLen;
  52 };
  53
  54 struct FileRec {
  55     String8 file;
  56     bool deleted;
  57     FileState s;
  58 };
  59
  60
  61 /**
  62  * Writes the data.
  63  *
  64  * If an error occurs, it poisons this object and all write calls will fail
  65  * with the error that occurred.
  66  */
  67 class BackupDataWriter
  68 {
  69 public:
  70     BackupDataWriter(int fd);
  71     // does not close fd
  72     ~BackupDataWriter();
  73
  74     status_t WriteEntityHeader(const String8& key, size_t dataSize);
  75
  76     /* Note: WriteEntityData will write arbitrary data into the file without
  77      * validation or a previously-supplied header.  The full backup implementation
  78      * uses it this way to generate a controlled binary stream that is not
  79      * entity-structured.  If the implementation here is changed, either this
  80      * use case must remain valid, or the full backup implementation should be
  81      * adjusted to use some other appropriate mechanism.
  82      */
  83     status_t WriteEntityData(const void* data, size_t size);
  84
  85     void SetKeyPrefix(const String8& keyPrefix);
  86
  87 private:
  88     explicit BackupDataWriter();
  89     status_t write_padding_for(int n);
  90
  91     int m_fd;
  92     status_t m_status;
  93     ssize_t m_pos;
  94     int m_entityCount;
  95     String8 m_keyPrefix;
  96 };
  97
  98 /**
  99  * Reads the data.
 100  *
 101  * If an error occurs, it poisons this object and all write calls will fail
 102  * with the error that occurred.
 103  */
 104 class BackupDataReader
 105 {
 106 public:
 107     BackupDataReader(int fd);
 108     // does not close fd
 109     ~BackupDataReader();
 110
 111     status_t Status();
 112     status_t ReadNextHeader(bool* done, int* type);
 113
 114     bool HasEntities();
 115     status_t ReadEntityHeader(String8* key, size_t* dataSize);
 116     status_t SkipEntityData(); // must be called with the pointer at the beginning of the data.
 117     ssize_t ReadEntityData(void* data, size_t size);
 118
 119 private:
 120     explicit BackupDataReader();
 121     status_t skip_padding();
 122
 123     int m_fd;
 124     bool m_done;
 125     status_t m_status;
 126     ssize_t m_pos;
 127     ssize_t m_dataEndPos;
 128     int m_entityCount;
 129     union {
 130         int type;
 131         entity_header_v1 entity;
 132     } m_header;
 133     String8 m_key;
 134 };
 135
 136 int back_up_files(int oldSnapshotFD, BackupDataWriter* dataStream, int newSnapshotFD,
 137         char const* const* files, char const* const *keys, int fileCount);
 138
 139 int write_tarfile(const String8& packageName, const String8& domain,
 140         const String8& rootPath, const String8& filePath, off_t* outSize,
 141         BackupDataWriter* outputStream);
 142
 143 class RestoreHelperBase
 144 {
 145 public:
 146     RestoreHelperBase();
 147     ~RestoreHelperBase();
 148
 149     status_t WriteFile(const String8& filename, BackupDataReader* in);
 150     status_t WriteSnapshot(int fd);
 151
 152 private:
 153     void* m_buf;
 154     bool m_loggedUnknownMetadata;
 155     KeyedVector<String8,FileRec> m_files;
 156 };
 157
 158 //#define TEST_BACKUP_HELPERS 1
 159
 160 #if TEST_BACKUP_HELPERS
 161 int backup_helper_test_empty();
 162 int backup_helper_test_four();
 163 int backup_helper_test_files();
 164 int backup_helper_test_null_base();
 165 int backup_helper_test_missing_file();
 166 int backup_helper_test_data_writer();
 167 int backup_helper_test_data_reader();
 168 #endif
 169
 170 } // namespace android
 171
 172 #endif // _UTILS_BACKUP_HELPERS_H