am e85bb9eb: Merge change 1823 into donut (28a6f667) · Commits · e / os / android_frameworks_base

include/utils/backup_helpers.h

+62 −3

Original line number	Original line	Diff line number	Diff line
	@@ -25,8 +25,28 @@ namespace android {
	int back_up_files(int oldSnapshotFD, int oldDataStream, int newSnapshotFD,		int back_up_files(int oldSnapshotFD, int oldDataStream, int newSnapshotFD,
	char const* fileBase, char const* const* files, int fileCount);		char const* fileBase, char const* const* files, int fileCount);

			// the sizes of all of these match.
			typedef struct {
			int type; // == APP_MAGIC_V1
			int packageLen; // length of the name of the package that follows, not including the null.
			int cookie;
			} 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
			int cookie;
			} app_footer_v1;


	/**		/**
	* Reads the data.		* Writes the data.
	*		*
	* If an error occurs, it poisons this object and all write calls will fail		* If an error occurs, it poisons this object and all write calls will fail
	* with the error that occurred.		* with the error that occurred.
	@@ -38,12 +58,12 @@ public:
	// does not close fd		// does not close fd
	~BackupDataWriter();		~BackupDataWriter();

	status_t WriteAppHeader(const String8& packageName);		status_t WriteAppHeader(const String8& packageName, int cookie);

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

	status_t WriteAppFooter();		status_t WriteAppFooter(int cookie);

	private:		private:
	explicit BackupDataWriter();		explicit BackupDataWriter();
	@@ -55,6 +75,44 @@ private:
	int m_entityCount;		int m_entityCount;
	};		};

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

			status_t Status();
			status_t ReadNextHeader();

			status_t ReadAppHeader(String8* packageName, int* cookie);
			bool HasEntities();
			status_t ReadEntityHeader(String8* key, size_t* dataSize);
			status_t ReadEntityData(void* data, size_t size);
			status_t ReadAppFooter(int* cookie);

			private:
			explicit BackupDataReader();
			status_t skip_padding();

			int m_fd;
			status_t m_status;
			ssize_t m_pos;
			int m_entityCount;
			union {
			int type;
			app_header_v1 app;
			entity_header_v1 entity;
			app_footer_v1 footer;
			} m_header;
			};

	#define TEST_BACKUP_HELPERS 0		#define TEST_BACKUP_HELPERS 0

	#if TEST_BACKUP_HELPERS		#if TEST_BACKUP_HELPERS
	@@ -62,6 +120,7 @@ int backup_helper_test_empty();
	int backup_helper_test_four();		int backup_helper_test_four();
	int backup_helper_test_files();		int backup_helper_test_files();
	int backup_helper_test_data_writer();		int backup_helper_test_data_writer();
			int backup_helper_test_data_reader();
	#endif		#endif

	} // namespace android		} // namespace android

libs/utils/backup_data.cpp

+210 −18

Original line number	Original line	Diff line number	Diff line
	@@ -14,12 +14,16 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

			#define LOG_TAG "backup_data"

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

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

			#include <cutils/log.h>

	namespace android {		namespace android {

	/*		/*
	@@ -39,22 +43,6 @@ namespace android {
	#define ENTITY_MAGIC_V1 0x61746144 // Data (little endian)		#define ENTITY_MAGIC_V1 0x61746144 // Data (little endian)
	#define FOOTER_MAGIC_V1 0x746f6f46 // Foot (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 };		const static int ROUND_UP[4] = { 0, 3, 2, 1 };

	static inline size_t		static inline size_t
	@@ -102,7 +90,7 @@ BackupDataWriter::write_padding_for(int n)
	}		}

	status_t		status_t
	BackupDataWriter::WriteAppHeader(const String8& packageName)		BackupDataWriter::WriteAppHeader(const String8& packageName, int cookie)
	{		{
	if (m_status != NO_ERROR) {		if (m_status != NO_ERROR) {
	return m_status;		return m_status;
	@@ -122,6 +110,7 @@ BackupDataWriter::WriteAppHeader(const String8& packageName)

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

	amt = write(m_fd, &header, sizeof(app_header_v1));		amt = write(m_fd, &header, sizeof(app_header_v1));
	if (amt != sizeof(app_header_v1)) {		if (amt != sizeof(app_header_v1)) {
	@@ -204,7 +193,7 @@ BackupDataWriter::WriteEntityData(const void* data, size_t size)
	}		}

	status_t		status_t
	BackupDataWriter::WriteAppFooter()		BackupDataWriter::WriteAppFooter(int cookie)
	{		{
	if (m_status != NO_ERROR) {		if (m_status != NO_ERROR) {
	return m_status;		return m_status;
	@@ -222,6 +211,7 @@ BackupDataWriter::WriteAppFooter()

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

	amt = write(m_fd, &footer, sizeof(app_footer_v1));		amt = write(m_fd, &footer, sizeof(app_footer_v1));
	if (amt != sizeof(app_footer_v1)) {		if (amt != sizeof(app_footer_v1)) {
	@@ -233,4 +223,206 @@ BackupDataWriter::WriteAppFooter()
	return NO_ERROR;		return NO_ERROR;
	}		}


			BackupDataReader::BackupDataReader(int fd)
			:m_fd(fd),
			m_status(NO_ERROR),
			m_pos(0),
			m_entityCount(0)
			{
			memset(&m_header, 0, sizeof(m_header));
			}

			BackupDataReader::~BackupDataReader()
			{
			}

			status_t
			BackupDataReader::Status()
			{
			return m_status;
			}

			#define CHECK_SIZE(actual, expected) \
			do { \
			if ((actual) != (expected)) { \
			if ((actual) == 0) { \
			m_status = EIO; \
			} else { \
			m_status = errno; \
			} \
			return m_status; \
			} \
			} while(0)
			#define SKIP_PADDING() \
			do { \
			status_t err = skip_padding(); \
			if (err != NO_ERROR) { \
			m_status = err; \
			return err; \
			} \
			} while(0)

			status_t
			BackupDataReader::ReadNextHeader()
			{
			if (m_status != NO_ERROR) {
			return m_status;
			}

			int amt;

			SKIP_PADDING();
			amt = read(m_fd, &m_header, sizeof(m_header));
			CHECK_SIZE(amt, sizeof(m_header));

			// validate and fix up the fields.
			m_header.type = fromlel(m_header.type);
			switch (m_header.type)
			{
			case APP_MAGIC_V1:
			m_header.app.packageLen = fromlel(m_header.app.packageLen);
			if (m_header.app.packageLen < 0) {
			LOGD("App header at %d has packageLen<0: 0x%08x\n", (int)m_pos,
			(int)m_header.app.packageLen);
			m_status = EINVAL;
			}
			m_header.app.cookie = m_header.app.cookie;
			break;
			case ENTITY_MAGIC_V1:
			m_header.entity.keyLen = fromlel(m_header.entity.keyLen);
			if (m_header.entity.keyLen <= 0) {
			LOGD("Entity header at %d has keyLen<=0: 0x%08x\n", (int)m_pos,
			(int)m_header.entity.keyLen);
			m_status = EINVAL;
			}
			m_header.entity.dataSize = fromlel(m_header.entity.dataSize);
			if (m_header.entity.dataSize < 0) {
			LOGD("Entity header at %d has dataSize<0: 0x%08x\n", (int)m_pos,
			(int)m_header.entity.dataSize);
			m_status = EINVAL;
			}
			m_entityCount++;
			break;
			case FOOTER_MAGIC_V1:
			m_header.footer.entityCount = fromlel(m_header.footer.entityCount);
			if (m_header.footer.entityCount < 0) {
			LOGD("Entity header at %d has entityCount<0: 0x%08x\n", (int)m_pos,
			(int)m_header.footer.entityCount);
			m_status = EINVAL;
			}
			m_header.footer.cookie = m_header.footer.cookie;
			break;
			default:
			LOGD("Chunk header at %d has invalid type: 0x%08x", (int)m_pos, (int)m_header.type);
			m_status = EINVAL;
			}
			m_pos += sizeof(m_header);

			return m_status;
			}

			status_t
			BackupDataReader::ReadAppHeader(String8* packageName, int* cookie)
			{
			if (m_status != NO_ERROR) {
			return m_status;
			}
			if (m_header.type != APP_MAGIC_V1) {
			return EINVAL;
			}
			size_t size = m_header.app.packageLen;
			char* buf = packageName->lockBuffer(size);
			if (packageName == NULL) {
			packageName->unlockBuffer();
			m_status = ENOMEM;
			return m_status;
			}
			int amt = read(m_fd, buf, size+1);
			CHECK_SIZE(amt, (int)size+1);
			packageName->unlockBuffer(size);
			m_pos += size+1;
			*cookie = m_header.app.cookie;
			return NO_ERROR;
			}

			bool
			BackupDataReader::HasEntities()
			{
			return m_status == NO_ERROR && m_header.type == ENTITY_MAGIC_V1;
			}

			status_t
			BackupDataReader::ReadEntityHeader(String8* key, size_t* dataSize)
			{
			if (m_status != NO_ERROR) {
			return m_status;
			}
			if (m_header.type != ENTITY_MAGIC_V1) {
			return EINVAL;
			}
			size_t size = m_header.app.packageLen;
			char* buf = key->lockBuffer(size);
			if (key == NULL) {
			key->unlockBuffer();
			m_status = ENOMEM;
			return m_status;
			}
			int amt = read(m_fd, buf, size+1);
			CHECK_SIZE(amt, (int)size+1);
			key->unlockBuffer(size);
			m_pos += size+1;
			*dataSize = m_header.entity.dataSize;
			SKIP_PADDING();
			return NO_ERROR;
			}

			status_t
			BackupDataReader::ReadEntityData(void* data, size_t size)
			{
			if (m_status != NO_ERROR) {
			return m_status;
			}
			int amt = read(m_fd, data, size);
			CHECK_SIZE(amt, (int)size);
			m_pos += size;
			return NO_ERROR;
			}

			status_t
			BackupDataReader::ReadAppFooter(int* cookie)
			{
			if (m_status != NO_ERROR) {
			return m_status;
			}
			if (m_header.type != FOOTER_MAGIC_V1) {
			return EINVAL;
			}
			if (m_header.footer.entityCount != m_entityCount) {
			LOGD("entity count mismatch actual=%d expected=%d", m_entityCount,
			m_header.footer.entityCount);
			m_status = EINVAL;
			return m_status;
			}
			*cookie = m_header.footer.cookie;
			return NO_ERROR;
			}

			status_t
			BackupDataReader::skip_padding()
			{
			ssize_t amt;
			ssize_t paddingSize;

			paddingSize = padding_extra(m_pos);
			if (paddingSize > 0) {
			uint32_t padding;
			amt = read(m_fd, &padding, paddingSize);
			CHECK_SIZE(amt, paddingSize);
			m_pos += amt;
			}
			return NO_ERROR;
			}


	} // namespace android		} // namespace android

libs/utils/backup_helper_file.cpp

+174 −15

Original line number	Original line	Diff line number	Diff line
	@@ -599,13 +599,14 @@ backup_helper_test_four()
	// hexdump -v -e '" " 8/1 " 0x%02x," "\n"' data_writer.data		// hexdump -v -e '" " 8/1 " 0x%02x," "\n"' data_writer.data
	const unsigned char DATA_GOLDEN_FILE[] = {		const unsigned char DATA_GOLDEN_FILE[] = {
	0x41, 0x70, 0x70, 0x31, 0x0b, 0x00, 0x00, 0x00,		0x41, 0x70, 0x70, 0x31, 0x0b, 0x00, 0x00, 0x00,
	0x6e, 0x6f, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69,		0xdd, 0xcc, 0xbb, 0xaa, 0x6e, 0x6f, 0x5f, 0x70,
	0x6e, 0x67, 0x5f, 0x00, 0x44, 0x61, 0x74, 0x61,		0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x00,
	0x0b, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,		0x44, 0x61, 0x74, 0x61, 0x0b, 0x00, 0x00, 0x00,
	0x6e, 0x6f, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69,		0x0c, 0x00, 0x00, 0x00, 0x6e, 0x6f, 0x5f, 0x70,
	0x6e, 0x67, 0x5f, 0x00, 0x6e, 0x6f, 0x5f, 0x70,
	0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x00,		0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x00,
	0x41, 0x70, 0x70, 0x31, 0x0c, 0x00, 0x00, 0x00,		0x6e, 0x6f, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69,
			0x6e, 0x67, 0x5f, 0x00, 0x41, 0x70, 0x70, 0x31,
			0x0c, 0x00, 0x00, 0x00, 0xdd, 0xcc, 0xbb, 0xaa,
	0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,		0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
	0x6f, 0x5f, 0x5f, 0x33, 0x00, 0xbc, 0xbc, 0xbc,		0x6f, 0x5f, 0x5f, 0x33, 0x00, 0xbc, 0xbc, 0xbc,
	0x44, 0x61, 0x74, 0x61, 0x0c, 0x00, 0x00, 0x00,		0x44, 0x61, 0x74, 0x61, 0x0c, 0x00, 0x00, 0x00,
	@@ -614,15 +615,16 @@ const unsigned char DATA_GOLDEN_FILE[] = {
	0x00, 0xbc, 0xbc, 0xbc, 0x70, 0x61, 0x64, 0x64,		0x00, 0xbc, 0xbc, 0xbc, 0x70, 0x61, 0x64, 0x64,
	0x65, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x5f, 0x33,		0x65, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x5f, 0x33,
	0x00, 0xbc, 0xbc, 0xbc, 0x41, 0x70, 0x70, 0x31,		0x00, 0xbc, 0xbc, 0xbc, 0x41, 0x70, 0x70, 0x31,
	0x0d, 0x00, 0x00, 0x00, 0x70, 0x61, 0x64, 0x64,		0x0d, 0x00, 0x00, 0x00, 0xdd, 0xcc, 0xbb, 0xaa,
	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,		0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
	0x6f, 0x5f, 0x32, 0x5f, 0x5f, 0x00, 0xbc, 0xbc,		0x6f, 0x5f, 0x32, 0x5f, 0x5f, 0x00, 0xbc, 0xbc,
	0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,		0x44, 0x61, 0x74, 0x61, 0x0d, 0x00, 0x00, 0x00,
	0x6f, 0x5f, 0x32, 0x5f, 0x5f, 0x00, 0xbc, 0xbc,		0x0e, 0x00, 0x00, 0x00, 0x70, 0x61, 0x64, 0x64,
	0x41, 0x70, 0x70, 0x31, 0x0a, 0x00, 0x00, 0x00,		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, 0xdd, 0xcc, 0xbb, 0xaa,
	0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,		0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
	0x6f, 0x31, 0x00, 0xbc, 0x44, 0x61, 0x74, 0x61,		0x6f, 0x31, 0x00, 0xbc, 0x44, 0x61, 0x74, 0x61,
	0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,		0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
	@@ -630,6 +632,7 @@ const unsigned char DATA_GOLDEN_FILE[] = {
	0x6f, 0x31, 0x00, 0xbc, 0x70, 0x61, 0x64, 0x64,		0x6f, 0x31, 0x00, 0xbc, 0x70, 0x61, 0x64, 0x64,
	0x65, 0x64, 0x5f, 0x74, 0x6f, 0x31, 0x00, 0xbc,		0x65, 0x64, 0x5f, 0x74, 0x6f, 0x31, 0x00, 0xbc,
	0x46, 0x6f, 0x6f, 0x74, 0x04, 0x00, 0x00, 0x00,		0x46, 0x6f, 0x6f, 0x74, 0x04, 0x00, 0x00, 0x00,
			0x99, 0x99, 0x77, 0x77
	};		};
	const int DATA_GOLDEN_FILE_SIZE = sizeof(DATA_GOLDEN_FILE);		const int DATA_GOLDEN_FILE_SIZE = sizeof(DATA_GOLDEN_FILE);

	@@ -639,7 +642,7 @@ test_write_header_and_entity(BackupDataWriter& writer, const char* str)
	int err;		int err;
	String8 text(str);		String8 text(str);

	err = writer.WriteAppHeader(text);		err = writer.WriteAppHeader(text, 0xaabbccdd);
	if (err != 0) {		if (err != 0) {
	fprintf(stderr, "WriteAppHeader failed with %s\n", strerror(err));		fprintf(stderr, "WriteAppHeader failed with %s\n", strerror(err));
	return err;		return err;
	@@ -685,7 +688,7 @@ backup_helper_test_data_writer()
	err \|= test_write_header_and_entity(writer, "padded_to_2__");		err \|= test_write_header_and_entity(writer, "padded_to_2__");
	err \|= test_write_header_and_entity(writer, "padded_to1");		err \|= test_write_header_and_entity(writer, "padded_to1");

	writer.WriteAppFooter();		writer.WriteAppFooter(0x77779999);

	close(fd);		close(fd);

	@@ -697,6 +700,162 @@ backup_helper_test_data_writer()
	return err;		return err;
	}		}

			int
			test_read_header_and_entity(BackupDataReader& reader, const char* str)
			{
			int err;
			int bufSize = strlen(str)+1;
			char* buf = (char*)malloc(bufSize);
			String8 string;
			int cookie = 0x11111111;
			size_t actualSize;

			// printf("\n\n---------- test_read_header_and_entity -- %s\n\n", str);

			err = reader.ReadNextHeader();
			if (err != 0) {
			fprintf(stderr, "ReadNextHeader (for app header) failed with %s\n", strerror(err));
			goto done;
			}

			err = reader.ReadAppHeader(&string, &cookie);
			if (err != 0) {
			fprintf(stderr, "ReadAppHeader failed with %s\n", strerror(err));
			goto done;
			}
			if (string != str) {
			fprintf(stderr, "ReadAppHeader expected packageName '%s' got '%s'\n", str, string.string());
			err = EINVAL;
			goto done;
			}
			if (cookie != (int)0xaabbccdd) {
			fprintf(stderr, "ReadAppHeader expected cookie 0x%08x got 0x%08x\n", 0xaabbccdd, cookie);
			err = EINVAL;
			goto done;
			}

			err = reader.ReadNextHeader();
			if (err != 0) {
			fprintf(stderr, "ReadNextHeader (for entity header) failed with %s\n", strerror(err));
			goto done;
			}

			err = reader.ReadEntityHeader(&string, &actualSize);
			if (err != 0) {
			fprintf(stderr, "ReadEntityHeader failed with %s\n", strerror(err));
			goto done;
			}
			if (string != str) {
			fprintf(stderr, "ReadEntityHeader expected key '%s' got '%s'\n", str, string.string());
			err = EINVAL;
			goto done;
			}
			if ((int)actualSize != bufSize) {
			fprintf(stderr, "ReadEntityHeader expected dataSize 0x%08x got 0x%08x\n", bufSize,
			actualSize);
			err = EINVAL;
			goto done;
			}

			err = reader.ReadEntityData(buf, bufSize);
			if (err != NO_ERROR) {
			fprintf(stderr, "ReadEntityData failed with %s\n", strerror(err));
			goto done;
			}

			if (0 != memcmp(buf, str, bufSize)) {
			fprintf(stderr, "ReadEntityData expected '%s' but got something starting with "
			"%02x %02x %02x %02x\n", str, buf[0], buf[1], buf[2], buf[3]);
			err = EINVAL;
			goto done;
			}

			// The next read will confirm whether it got the right amount of data.

			done:
			if (err != NO_ERROR) {
			fprintf(stderr, "test_read_header_and_entity failed with %s\n", strerror(err));
			}
			free(buf);
			return err;
			}

			int
			backup_helper_test_data_reader()
			{
			int err;
			int fd;
			const char* filename = SCRATCH_DIR "data_reader.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;
			}

			err = write(fd, DATA_GOLDEN_FILE, DATA_GOLDEN_FILE_SIZE);
			if (err != DATA_GOLDEN_FILE_SIZE) {
			fprintf(stderr, "Error \"%s\" writing golden file %s\n", strerror(errno), filename);
			return errno;
			}

			close(fd);

			fd = open(filename, O_RDONLY);
			if (fd == -1) {
			fprintf(stderr, "Error \"%s\" opening golden file %s for read\n", strerror(errno),
			filename);
			return errno;
			}

			{
			BackupDataReader reader(fd);

			err = 0;

			if (err == NO_ERROR) {
			err = test_read_header_and_entity(reader, "no_padding_");
			}

			if (err == NO_ERROR) {
			err = test_read_header_and_entity(reader, "padded_to__3");
			}

			if (err == NO_ERROR) {
			err = test_read_header_and_entity(reader, "padded_to_2__");
			}

			if (err == NO_ERROR) {
			err = test_read_header_and_entity(reader, "padded_to1");
			}

			if (err == NO_ERROR) {
			err = reader.ReadNextHeader();
			if (err != 0) {
			fprintf(stderr, "ReadNextHeader (for app header) failed with %s\n", strerror(err));
			}

			if (err == NO_ERROR) {
			int cookie;
			err \|= reader.ReadAppFooter(&cookie);
			if (cookie != 0x77779999) {
			fprintf(stderr, "app footer cookie expected=0x%08x actual=0x%08x\n",
			0x77779999, cookie);
			err = EINVAL;
			}
			}
			}
			}

			close(fd);

			return err;
			}

	static int		static int
	get_mod_time(const char* filename, struct timeval times[2])		get_mod_time(const char* filename, struct timeval times[2])
	{		{

tests/backup/backup_helper_test.cpp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -23,6 +23,7 @@ Test TESTS[] = {
	{ "backup_helper_test_four", backup_helper_test_four, 0, false },		{ "backup_helper_test_four", backup_helper_test_four, 0, false },
	{ "backup_helper_test_files", backup_helper_test_files, 0, false },		{ "backup_helper_test_files", backup_helper_test_files, 0, false },
	{ "backup_helper_test_data_writer", backup_helper_test_data_writer, 0, false },		{ "backup_helper_test_data_writer", backup_helper_test_data_writer, 0, false },
			{ "backup_helper_test_data_reader", backup_helper_test_data_reader, 0, false },
	{ 0, NULL, 0, false}		{ 0, NULL, 0, false}
	};		};