am 4535e405: Implement the C++ class to write the backed up file data. (26a87a8e) · Commits · e / os / platform_frameworks_native

include/utils/ByteOrder.h

+22 −10

Original line number	Diff line number	Diff line
		@@ -38,6 +38,16 @@
		* intent is to allow us to avoid byte swapping on the device.
		*/

		static inline uint32_t android_swap_long(uint32_t v)
		{
		return (v<<24) \| ((v<<8)&0x00FF0000) \| ((v>>8)&0x0000FF00) \| (v>>24);
		}

		static inline uint16_t android_swap_short(uint16_t v)
		{
		return (v<<8) \| (v>>8);
		}

		#define DEVICE_BYTE_ORDER LITTLE_ENDIAN

		#if BYTE_ORDER == DEVICE_BYTE_ORDER
		@@ -49,16 +59,6 @@

		#else

		static inline uint32_t android_swap_long(uint32_t v)
		{
		return (v<<24) \| ((v<<8)&0x00FF0000) \| ((v>>8)&0x0000FF00) \| (v>>24);
		}

		static inline uint16_t android_swap_short(uint16_t v)
		{
		return (v<<8) \| (v>>8);
		}

		#define dtohl(x) (android_swap_long(x))
		#define dtohs(x) (android_swap_short(x))
		#define htodl(x) (android_swap_long(x))
		@@ -66,4 +66,16 @@ static inline uint16_t android_swap_short(uint16_t v)

		#endif

		#if BYTE_ORDER == LITTLE_ENDIAN
		#define fromlel(x) (x)
		#define fromles(x) (x)
		#define tolel(x) (x)
		#define toles(x) (x)
		#else
		#define fromlel(x) (android_swap_long(x))
		#define fromles(x) (android_swap_short(x))
		#define tolel(x) (android_swap_long(x))
		#define toles(x) (android_swap_short(x))
		#endif

		#endif // _LIBS_UTILS_BYTE_ORDER_H

include/utils/backup_helpers.h

+54 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#ifndef _UTILS_BACKUP_HELPERS_H
		#define _UTILS_BACKUP_HELPERS_H

		#include <utils/Errors.h>
		#include <utils/String8.h>

		namespace android {

		int back_up_files(int oldSnapshotFD, int oldDataStream, int newSnapshotFD,
		char const* fileBase, char const* const* files, int fileCount);

		/**
		* Reads the data.
		*
		* If an error occurs, it poisons this object and all write calls will fail
		* with the error that occurred.
		*/
		class BackupDataWriter
		{
		public:
		BackupDataWriter(int fd);
		// does not close fd
		~BackupDataWriter();

		status_t WriteAppHeader(const String8& packageName);

		status_t WriteEntityHeader(const String8& key, size_t dataSize);
		status_t WriteEntityData(const void* data, size_t size);

		status_t WriteAppFooter();

		private:
		explicit BackupDataWriter();
		status_t write_padding_for(int n);

		int m_fd;
		status_t m_status;
		ssize_t m_pos;
		int m_entityCount;
		};

		#define TEST_BACKUP_HELPERS 0

		#if TEST_BACKUP_HELPERS
		int backup_helper_test_empty();
		int backup_helper_test_four();
		int backup_helper_test_files();
		int backup_helper_test_data_writer();
		#endif

		} // namespace android

		#endif // _UTILS_BACKUP_HELPERS_H

libs/utils/Android.mk

+2 −1

Original line number	Diff line number	Diff line
		@@ -117,7 +117,8 @@ LOCAL_SRC_FILES:= \
		IPermissionController.cpp \
		IServiceManager.cpp \
		Unicode.cpp \
		file_backup_helper.cpp
		backup_data.cpp \
		backup_helper_file.cpp

		ifeq ($(TARGET_SIMULATOR),true)
		LOCAL_SRC_FILES += $(hostSources)

libs/utils/backup_data.cpp

0 → 100644

+236 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#include <utils/backup_helpers.h>
		#include <utils/ByteOrder.h>

		#include <stdio.h>
		#include <unistd.h>

		namespace android {

		/*
		* File Format (v1):
		*
		* All ints are stored little-endian.
		*
		* - An app_header_v1 struct.
		* - The name of the package, utf-8, null terminated, padded to 4-byte boundary.
		* - A sequence of zero or more key/value paires (entities), each with
		* - A entity_header_v1 struct
		* - The key, utf-8, null terminated, padded to 4-byte boundary.
		* - The value, padded to 4 byte boundary
		*/

		#define APP_MAGIC_V1 0x31707041 // App1 (little endian)
		#define ENTITY_MAGIC_V1 0x61746144 // Data (little endian)
		#define FOOTER_MAGIC_V1 0x746f6f46 // Foot (little endian)

		typedef struct {
		int type; // == APP_MAGIC_V1
		int packageLen; // length of the name of the package that follows, not including the null.
		} app_header_v1;

		typedef struct {
		int type; // ENTITY_MAGIC_V1
		int keyLen; // length of the key name, not including the null terminator
		int dataSize; // size of the data, not including the padding
		} entity_header_v1;

		typedef struct {
		int type; // FOOTER_MAGIC_V1
		int entityCount; // the number of entities that were written
		} app_footer_v1;

		const static int ROUND_UP[4] = { 0, 3, 2, 1 };

		static inline size_t
		round_up(size_t n)
		{
		return n + ROUND_UP[n % 4];
		}

		static inline size_t
		padding_extra(size_t n)
		{
		return ROUND_UP[n % 4];
		}

		BackupDataWriter::BackupDataWriter(int fd)
		:m_fd(fd),
		m_status(NO_ERROR),
		m_pos(0),
		m_entityCount(0)
		{
		}

		BackupDataWriter::~BackupDataWriter()
		{
		}

		// Pad out anything they've previously written to the next 4 byte boundary.
		status_t
		BackupDataWriter::write_padding_for(int n)
		{
		ssize_t amt;
		ssize_t paddingSize;

		paddingSize = padding_extra(n);
		if (paddingSize > 0) {
		uint32_t padding = 0xbcbcbcbc;
		amt = write(m_fd, &padding, paddingSize);
		if (amt != paddingSize) {
		m_status = errno;
		return m_status;
		}
		m_pos += amt;
		}
		return NO_ERROR;
		}

		status_t
		BackupDataWriter::WriteAppHeader(const String8& packageName)
		{
		if (m_status != NO_ERROR) {
		return m_status;
		}

		ssize_t amt;

		amt = write_padding_for(m_pos);
		if (amt != 0) {
		return amt;
		}

		app_header_v1 header;
		ssize_t nameLen;

		nameLen = packageName.length();

		header.type = tolel(APP_MAGIC_V1);
		header.packageLen = tolel(nameLen);

		amt = write(m_fd, &header, sizeof(app_header_v1));
		if (amt != sizeof(app_header_v1)) {
		m_status = errno;
		return m_status;
		}
		m_pos += amt;

		amt = write(m_fd, packageName.string(), nameLen+1);
		if (amt != nameLen+1) {
		m_status = errno;
		return m_status;
		}
		m_pos += amt;

		return NO_ERROR;
		}

		status_t
		BackupDataWriter::WriteEntityHeader(const String8& key, size_t dataSize)
		{
		if (m_status != NO_ERROR) {
		return m_status;
		}

		ssize_t amt;

		amt = write_padding_for(m_pos);
		if (amt != 0) {
		return amt;
		}

		entity_header_v1 header;
		ssize_t keyLen;

		keyLen = key.length();

		header.type = tolel(ENTITY_MAGIC_V1);
		header.keyLen = tolel(keyLen);
		header.dataSize = tolel(dataSize);

		amt = write(m_fd, &header, sizeof(entity_header_v1));
		if (amt != sizeof(entity_header_v1)) {
		m_status = errno;
		return m_status;
		}
		m_pos += amt;

		amt = write(m_fd, key.string(), keyLen+1);
		if (amt != keyLen+1) {
		m_status = errno;
		return m_status;
		}
		m_pos += amt;

		amt = write_padding_for(keyLen+1);

		m_entityCount++;

		return amt;
		}

		status_t
		BackupDataWriter::WriteEntityData(const void* data, size_t size)
		{
		if (m_status != NO_ERROR) {
		return m_status;
		}

		// We don't write padding here, because they're allowed to call this several
		// times with smaller buffers. We write it at the end of WriteEntityHeader
		// instead.
		ssize_t amt = write(m_fd, data, size);
		if (amt != (ssize_t)size) {
		m_status = errno;
		return m_status;
		}
		m_pos += amt;
		return NO_ERROR;
		}

		status_t
		BackupDataWriter::WriteAppFooter()
		{
		if (m_status != NO_ERROR) {
		return m_status;
		}

		ssize_t amt;

		amt = write_padding_for(m_pos);
		if (amt != 0) {
		return amt;
		}

		app_footer_v1 footer;
		ssize_t nameLen;

		footer.type = tolel(FOOTER_MAGIC_V1);
		footer.entityCount = tolel(m_entityCount);

		amt = write(m_fd, &footer, sizeof(app_footer_v1));
		if (amt != sizeof(app_footer_v1)) {
		m_status = errno;
		return m_status;
		}
		m_pos += amt;

		return NO_ERROR;
		}

		} // namespace android

libs/utils/file_backup_helper.cpp→libs/utils/backup_helper_file.cpp

+147 −6

Original line number	Diff line number	Diff line
		/*
		* 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 <utils/backup_helpers.h>
		@@ -19,13 +35,16 @@

		#include <cutils/log.h>

		using namespace android;
		namespace android {

		#define MAGIC0 0x70616e53 // Snap
		#define MAGIC1 0x656c6946 // File

		#if TEST_BACKUP_HELPERS
		#define LOGP(x...) printf(x)
		#else
		#define LOGP(x...) LOGD(x)
		//#define LOGP(x...) printf(x)
		#endif

		struct SnapshotHeader {
		int magic0;
		@@ -118,6 +137,8 @@ write_snapshot_file(int fd, const KeyedVector<String8,FileState>& snapshot)
		bytesWritten += sizeof(FileState) + round_up(name.length());
		}

		LOGP("write_snapshot_file fd=%d\n", fd);

		int amt;
		SnapshotHeader header = { MAGIC0, N, MAGIC1, bytesWritten };

		@@ -248,11 +269,13 @@ back_up_files(int oldSnapshotFD, int oldDataStream, int newSnapshotFD,
		// file added
		String8 realFilename(base);
		realFilename.appendPath(q);
		LOGP("file added: %s\n", realFilename.string());
		write_update_file(realFilename, q);
		m++;
		}
		else if (cmp < 0) {
		// file removed
		LOGP("file removed: %s\n", p.string());
		write_delete_file(p);
		n++;
		}
		@@ -573,6 +596,107 @@ backup_helper_test_four()
		return matched ? 0 : 1;
		}

		// hexdump -v -e '" " 8/1 " 0x%02x," "\n"' data_writer.data
		const unsigned char DATA_GOLDEN_FILE[] = {
		0x41, 0x70, 0x70, 0x31, 0x0b, 0x00, 0x00, 0x00,
		0x6e, 0x6f, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69,
		0x6e, 0x67, 0x5f, 0x00, 0x44, 0x61, 0x74, 0x61,
		0x0b, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
		0x6e, 0x6f, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69,
		0x6e, 0x67, 0x5f, 0x00, 0x6e, 0x6f, 0x5f, 0x70,
		0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x00,
		0x41, 0x70, 0x70, 0x31, 0x0c, 0x00, 0x00, 0x00,
		0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
		0x6f, 0x5f, 0x5f, 0x33, 0x00, 0xbc, 0xbc, 0xbc,
		0x44, 0x61, 0x74, 0x61, 0x0c, 0x00, 0x00, 0x00,
		0x0d, 0x00, 0x00, 0x00, 0x70, 0x61, 0x64, 0x64,
		0x65, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x5f, 0x33,
		0x00, 0xbc, 0xbc, 0xbc, 0x70, 0x61, 0x64, 0x64,
		0x65, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x5f, 0x33,
		0x00, 0xbc, 0xbc, 0xbc, 0x41, 0x70, 0x70, 0x31,
		0x0d, 0x00, 0x00, 0x00, 0x70, 0x61, 0x64, 0x64,
		0x65, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x32, 0x5f,
		0x5f, 0x00, 0xbc, 0xbc, 0x44, 0x61, 0x74, 0x61,
		0x0d, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
		0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
		0x6f, 0x5f, 0x32, 0x5f, 0x5f, 0x00, 0xbc, 0xbc,
		0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
		0x6f, 0x5f, 0x32, 0x5f, 0x5f, 0x00, 0xbc, 0xbc,
		0x41, 0x70, 0x70, 0x31, 0x0a, 0x00, 0x00, 0x00,
		0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
		0x6f, 0x31, 0x00, 0xbc, 0x44, 0x61, 0x74, 0x61,
		0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
		0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
		0x6f, 0x31, 0x00, 0xbc, 0x70, 0x61, 0x64, 0x64,
		0x65, 0x64, 0x5f, 0x74, 0x6f, 0x31, 0x00, 0xbc,
		0x46, 0x6f, 0x6f, 0x74, 0x04, 0x00, 0x00, 0x00,
		};
		const int DATA_GOLDEN_FILE_SIZE = sizeof(DATA_GOLDEN_FILE);

		static int
		test_write_header_and_entity(BackupDataWriter& writer, const char* str)
		{
		int err;
		String8 text(str);

		err = writer.WriteAppHeader(text);
		if (err != 0) {
		fprintf(stderr, "WriteAppHeader failed with %s\n", strerror(err));
		return err;
		}

		err = writer.WriteEntityHeader(text, text.length()+1);
		if (err != 0) {
		fprintf(stderr, "WriteEntityHeader failed with %s\n", strerror(err));
		return err;
		}

		err = writer.WriteEntityData(text.string(), text.length()+1);
		if (err != 0) {
		fprintf(stderr, "write failed for data '%s'\n", text.string());
		return errno;
		}

		return err;
		}

		int
		backup_helper_test_data_writer()
		{
		int err;
		int fd;
		const char* filename = SCRATCH_DIR "data_writer.data";

		system("rm -r " SCRATCH_DIR);
		mkdir(SCRATCH_DIR, 0777);
		mkdir(SCRATCH_DIR "data", 0777);

		fd = creat(filename, 0666);
		if (fd == -1) {
		fprintf(stderr, "error creating: %s\n", strerror(errno));
		return errno;
		}

		BackupDataWriter writer(fd);

		err = 0;
		err \|= test_write_header_and_entity(writer, "no_padding_");
		err \|= test_write_header_and_entity(writer, "padded_to__3");
		err \|= test_write_header_and_entity(writer, "padded_to_2__");
		err \|= test_write_header_and_entity(writer, "padded_to1");

		writer.WriteAppFooter();

		close(fd);

		err = compare_file(filename, DATA_GOLDEN_FILE, DATA_GOLDEN_FILE_SIZE);
		if (err != 0) {
		return err;
		}

		return err;
		}

		static int
		get_mod_time(const char* filename, struct timeval times[2])
		{
		@@ -594,8 +718,9 @@ int
		backup_helper_test_files()
		{
		int err;
		int newSnapshotFD;
		int oldSnapshotFD;
		int dataStreamFD;
		int newSnapshotFD;

		system("rm -r " SCRATCH_DIR);
		mkdir(SCRATCH_DIR, 0777);
		@@ -616,17 +741,24 @@ backup_helper_test_files()
		"data/f"
		};

		dataStreamFD = creat(SCRATCH_DIR "1.data", 0666);
		if (dataStreamFD == -1) {
		fprintf(stderr, "error creating: %s\n", strerror(errno));
		return errno;
		}

		newSnapshotFD = creat(SCRATCH_DIR "before.snap", 0666);
		if (newSnapshotFD == -1) {
		fprintf(stderr, "error creating: %s\n", strerror(errno));
		return errno;
		}

		err = back_up_files(-1, newSnapshotFD, 0, SCRATCH_DIR, files_before, 5);
		err = back_up_files(-1, dataStreamFD, newSnapshotFD, SCRATCH_DIR, files_before, 5);
		if (err != 0) {
		return err;
		}

		close(dataStreamFD);
		close(newSnapshotFD);

		sleep(3);
		@@ -665,21 +797,30 @@ backup_helper_test_files()
		return errno;
		}

		dataStreamFD = creat(SCRATCH_DIR "2.data", 0666);
		if (dataStreamFD == -1) {
		fprintf(stderr, "error creating: %s\n", strerror(errno));
		return errno;
		}

		newSnapshotFD = creat(SCRATCH_DIR "after.snap", 0666);
		if (newSnapshotFD == -1) {
		fprintf(stderr, "error creating: %s\n", strerror(errno));
		return errno;
		}

		err = back_up_files(oldSnapshotFD, newSnapshotFD, 0, SCRATCH_DIR, files_after, 6);
		err = back_up_files(oldSnapshotFD, dataStreamFD, newSnapshotFD, SCRATCH_DIR, files_after, 6);
		if (err != 0) {
		return err;
		}

		close(oldSnapshotFD);
		close(dataStreamFD);
		close(newSnapshotFD);

		return 0;
		}

		#endif // TEST_BACKUP_HELPERS

		}