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 #define LOG_TAG "backup_data"
18
19 #include <androidfw/BackupHelpers.h>
20 #include <utils/ByteOrder.h>
21
22 #include <stdio.h>
23 #include <string.h>
24 #include <unistd.h>
25
26 #include <cutils/log.h>
27
28 namespace android {
29
30 static const bool DEBUG = false;
31
32 /*
33 * File Format (v1):
34 *
35 * All ints are stored little-endian.
36 *
37 * - An app_header_v1 struct.
38 * - The name of the package, utf-8, null terminated, padded to 4-byte boundary.
39 * - A sequence of zero or more key/value paires (entities), each with
40 * - A entity_header_v1 struct
41 * - The key, utf-8, null terminated, padded to 4-byte boundary.
42 * - The value, padded to 4 byte boundary
43 */
44
45 const static int ROUND_UP[4] = { 0, 3, 2, 1 };
46
47 static inline size_t
round_up(size_t n)48 round_up(size_t n)
49 {
50 return n + ROUND_UP[n % 4];
51 }
52
53 static inline size_t
padding_extra(size_t n)54 padding_extra(size_t n)
55 {
56 return ROUND_UP[n % 4];
57 }
58
BackupDataWriter(int fd)59 BackupDataWriter::BackupDataWriter(int fd)
60 :m_fd(fd),
61 m_status(NO_ERROR),
62 m_pos(0),
63 m_entityCount(0)
64 {
65 }
66
~BackupDataWriter()67 BackupDataWriter::~BackupDataWriter()
68 {
69 }
70
71 // Pad out anything they've previously written to the next 4 byte boundary.
72 status_t
write_padding_for(int n)73 BackupDataWriter::write_padding_for(int n)
74 {
75 ssize_t amt;
76 ssize_t paddingSize;
77
78 paddingSize = padding_extra(n);
79 if (paddingSize > 0) {
80 uint32_t padding = 0xbcbcbcbc;
81 if (DEBUG) ALOGI("writing %d padding bytes for %d", paddingSize, n);
82 amt = write(m_fd, &padding, paddingSize);
83 if (amt != paddingSize) {
84 m_status = errno;
85 return m_status;
86 }
87 m_pos += amt;
88 }
89 return NO_ERROR;
90 }
91
92 status_t
WriteEntityHeader(const String8 & key,size_t dataSize)93 BackupDataWriter::WriteEntityHeader(const String8& key, size_t dataSize)
94 {
95 if (m_status != NO_ERROR) {
96 return m_status;
97 }
98
99 ssize_t amt;
100
101 amt = write_padding_for(m_pos);
102 if (amt != 0) {
103 return amt;
104 }
105
106 String8 k;
107 if (m_keyPrefix.length() > 0) {
108 k = m_keyPrefix;
109 k += ":";
110 k += key;
111 } else {
112 k = key;
113 }
114 if (DEBUG) {
115 ALOGD("Writing header: prefix='%s' key='%s' dataSize=%d", m_keyPrefix.string(),
116 key.string(), dataSize);
117 }
118
119 entity_header_v1 header;
120 ssize_t keyLen;
121
122 keyLen = k.length();
123
124 header.type = tolel(BACKUP_HEADER_ENTITY_V1);
125 header.keyLen = tolel(keyLen);
126 header.dataSize = tolel(dataSize);
127
128 if (DEBUG) ALOGI("writing entity header, %d bytes", sizeof(entity_header_v1));
129 amt = write(m_fd, &header, sizeof(entity_header_v1));
130 if (amt != sizeof(entity_header_v1)) {
131 m_status = errno;
132 return m_status;
133 }
134 m_pos += amt;
135
136 if (DEBUG) ALOGI("writing entity header key, %d bytes", keyLen+1);
137 amt = write(m_fd, k.string(), keyLen+1);
138 if (amt != keyLen+1) {
139 m_status = errno;
140 return m_status;
141 }
142 m_pos += amt;
143
144 amt = write_padding_for(keyLen+1);
145
146 m_entityCount++;
147
148 return amt;
149 }
150
151 status_t
WriteEntityData(const void * data,size_t size)152 BackupDataWriter::WriteEntityData(const void* data, size_t size)
153 {
154 if (DEBUG) ALOGD("Writing data: size=%lu", (unsigned long) size);
155
156 if (m_status != NO_ERROR) {
157 if (DEBUG) {
158 ALOGD("Not writing data - stream in error state %d (%s)", m_status, strerror(m_status));
159 }
160 return m_status;
161 }
162
163 // We don't write padding here, because they're allowed to call this several
164 // times with smaller buffers. We write it at the end of WriteEntityHeader
165 // instead.
166 ssize_t amt = write(m_fd, data, size);
167 if (amt != (ssize_t)size) {
168 m_status = errno;
169 if (DEBUG) ALOGD("write returned error %d (%s)", m_status, strerror(m_status));
170 return m_status;
171 }
172 m_pos += amt;
173 return NO_ERROR;
174 }
175
176 void
SetKeyPrefix(const String8 & keyPrefix)177 BackupDataWriter::SetKeyPrefix(const String8& keyPrefix)
178 {
179 m_keyPrefix = keyPrefix;
180 }
181
182
BackupDataReader(int fd)183 BackupDataReader::BackupDataReader(int fd)
184 :m_fd(fd),
185 m_done(false),
186 m_status(NO_ERROR),
187 m_pos(0),
188 m_entityCount(0)
189 {
190 memset(&m_header, 0, sizeof(m_header));
191 }
192
~BackupDataReader()193 BackupDataReader::~BackupDataReader()
194 {
195 }
196
197 status_t
Status()198 BackupDataReader::Status()
199 {
200 return m_status;
201 }
202
203 #define CHECK_SIZE(actual, expected) \
204 do { \
205 if ((actual) != (expected)) { \
206 if ((actual) == 0) { \
207 m_status = EIO; \
208 m_done = true; \
209 } else { \
210 m_status = errno; \
211 ALOGD("CHECK_SIZE(a=%ld e=%ld) failed at line %d m_status='%s'", \
212 long(actual), long(expected), __LINE__, strerror(m_status)); \
213 } \
214 return m_status; \
215 } \
216 } while(0)
217 #define SKIP_PADDING() \
218 do { \
219 status_t err = skip_padding(); \
220 if (err != NO_ERROR) { \
221 ALOGD("SKIP_PADDING FAILED at line %d", __LINE__); \
222 m_status = err; \
223 return err; \
224 } \
225 } while(0)
226
227 status_t
ReadNextHeader(bool * done,int * type)228 BackupDataReader::ReadNextHeader(bool* done, int* type)
229 {
230 *done = m_done;
231 if (m_status != NO_ERROR) {
232 return m_status;
233 }
234
235 int amt;
236
237 amt = skip_padding();
238 if (amt == EIO) {
239 *done = m_done = true;
240 return NO_ERROR;
241 }
242 else if (amt != NO_ERROR) {
243 return amt;
244 }
245 amt = read(m_fd, &m_header, sizeof(m_header));
246 *done = m_done = (amt == 0);
247 if (*done) {
248 return NO_ERROR;
249 }
250 CHECK_SIZE(amt, sizeof(m_header));
251 m_pos += sizeof(m_header);
252 if (type) {
253 *type = m_header.type;
254 }
255
256 // validate and fix up the fields.
257 m_header.type = fromlel(m_header.type);
258 switch (m_header.type)
259 {
260 case BACKUP_HEADER_ENTITY_V1:
261 {
262 m_header.entity.keyLen = fromlel(m_header.entity.keyLen);
263 if (m_header.entity.keyLen <= 0) {
264 ALOGD("Entity header at %d has keyLen<=0: 0x%08x\n", (int)m_pos,
265 (int)m_header.entity.keyLen);
266 m_status = EINVAL;
267 }
268 m_header.entity.dataSize = fromlel(m_header.entity.dataSize);
269 m_entityCount++;
270
271 // read the rest of the header (filename)
272 size_t size = m_header.entity.keyLen;
273 char* buf = m_key.lockBuffer(size);
274 if (buf == NULL) {
275 m_status = ENOMEM;
276 return m_status;
277 }
278 int amt = read(m_fd, buf, size+1);
279 CHECK_SIZE(amt, (int)size+1);
280 m_key.unlockBuffer(size);
281 m_pos += size+1;
282 SKIP_PADDING();
283 m_dataEndPos = m_pos + m_header.entity.dataSize;
284
285 break;
286 }
287 default:
288 ALOGD("Chunk header at %d has invalid type: 0x%08x",
289 (int)(m_pos - sizeof(m_header)), (int)m_header.type);
290 m_status = EINVAL;
291 }
292
293 return m_status;
294 }
295
296 bool
HasEntities()297 BackupDataReader::HasEntities()
298 {
299 return m_status == NO_ERROR && m_header.type == BACKUP_HEADER_ENTITY_V1;
300 }
301
302 status_t
ReadEntityHeader(String8 * key,size_t * dataSize)303 BackupDataReader::ReadEntityHeader(String8* key, size_t* dataSize)
304 {
305 if (m_status != NO_ERROR) {
306 return m_status;
307 }
308 if (m_header.type != BACKUP_HEADER_ENTITY_V1) {
309 return EINVAL;
310 }
311 *key = m_key;
312 *dataSize = m_header.entity.dataSize;
313 return NO_ERROR;
314 }
315
316 status_t
SkipEntityData()317 BackupDataReader::SkipEntityData()
318 {
319 if (m_status != NO_ERROR) {
320 return m_status;
321 }
322 if (m_header.type != BACKUP_HEADER_ENTITY_V1) {
323 return EINVAL;
324 }
325 if (m_header.entity.dataSize > 0) {
326 int pos = lseek(m_fd, m_dataEndPos, SEEK_SET);
327 if (pos == -1) {
328 return errno;
329 }
330 m_pos = pos;
331 }
332 SKIP_PADDING();
333 return NO_ERROR;
334 }
335
336 ssize_t
ReadEntityData(void * data,size_t size)337 BackupDataReader::ReadEntityData(void* data, size_t size)
338 {
339 if (m_status != NO_ERROR) {
340 return -1;
341 }
342 int remaining = m_dataEndPos - m_pos;
343 //ALOGD("ReadEntityData size=%d m_pos=0x%x m_dataEndPos=0x%x remaining=%d\n",
344 // size, m_pos, m_dataEndPos, remaining);
345 if (remaining <= 0) {
346 return 0;
347 }
348 if (((int)size) > remaining) {
349 size = remaining;
350 }
351 //ALOGD(" reading %d bytes", size);
352 int amt = read(m_fd, data, size);
353 if (amt < 0) {
354 m_status = errno;
355 return -1;
356 }
357 if (amt == 0) {
358 m_status = EIO;
359 m_done = true;
360 }
361 m_pos += amt;
362 return amt;
363 }
364
365 status_t
skip_padding()366 BackupDataReader::skip_padding()
367 {
368 ssize_t amt;
369 ssize_t paddingSize;
370
371 paddingSize = padding_extra(m_pos);
372 if (paddingSize > 0) {
373 uint32_t padding;
374 amt = read(m_fd, &padding, paddingSize);
375 CHECK_SIZE(amt, paddingSize);
376 m_pos += amt;
377 }
378 return NO_ERROR;
379 }
380
381
382 } // namespace android
383