Merge "Change tzdatacheck to account for bundle format changes" (6540dfef) · Commits · e / os / android_system_core

tzdatacheck/tzdatacheck.cpp

+209 −71

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

			#include <ctype.h>
	#include <errno.h>		#include <errno.h>
	#include <ftw.h>		#include <ftw.h>
	#include <libgen.h>		#include <libgen.h>
	@@ -29,47 +30,105 @@

	#include "android-base/logging.h"		#include "android-base/logging.h"

			static const char* BUNDLE_VERSION_FILENAME = "/bundle_version";
			// bundle_version is an ASCII file consisting of 17 bytes in the form: AAA.BBB\|CCCCC\|DDD
			// AAA.BBB is the major/minor version of the bundle format (e.g. 001.001),
			// CCCCC is the rules version (e.g. 2016g)
			// DDD is the android revision for this rules version to allow for bundle corrections (e.g. 001)
			// We only need the first 13 to determine if it is suitable for the device.
			static const int BUNDLE_VERSION_LENGTH = 13;
			// The major version of the bundle format supported by this code as a null-terminated char[].
			static const char REQUIRED_BUNDLE_VERSION[] = "001";
			static const size_t REQUIRED_BUNDLE_VERSION_LEN = sizeof(REQUIRED_BUNDLE_VERSION) - 1; // exclude \0
			// The length of the IANA rules version bytes. e.g. 2016a
			static const size_t RULES_VERSION_LEN = 5;
			// Bundle version bytes are: AAA.BBB\|CCCCC - the rules version is CCCCC
			static const size_t BUNDLE_VERSION_RULES_IDX = 8;

	static const char* TZDATA_FILENAME = "/tzdata";		static const char* TZDATA_FILENAME = "/tzdata";
	// tzdata file header (as much as we need for the version):		// tzdata file header (as much as we need for the version):
	// byte[11] tzdata_version -- e.g. "tzdata2012f"		// byte[11] tzdata_version -- e.g. "tzdata2012f"
	static const int TZ_HEADER_LENGTH = 11;		static const int TZ_HEADER_LENGTH = 11;
			// The major version of the bundle format supported by this code as a null-terminated char[].
			static const char TZ_DATA_HEADER_PREFIX[] = "tzdata";
			static const size_t TZ_DATA_HEADER_PREFIX_LEN = sizeof(TZ_DATA_HEADER_PREFIX) - 1; // exclude \0


	static void usage() {		static void usage() {
	std::cerr << "Usage: tzdatacheck SYSTEM_TZ_DIR DATA_TZ_DIR\n"		std::cerr << "Usage: tzdatacheck SYSTEM_TZ_DIR DATA_TZ_DIR\n"
	"\n"		"\n"
	"Compares the headers of two tzdata files. If the one in SYSTEM_TZ_DIR is the\n"		"Checks whether any timezone update bundle in DATA_TZ_DIR is compatible with the\n"
	"same or a higher version than the one in DATA_TZ_DIR the DATA_TZ_DIR is renamed\n"		"current Android release and better than or the same as base system timezone rules in\n"
	"and then deleted.\n";		"SYSTEM_TZ_DIR. If the timezone rules in SYSTEM_TZ_DIR are a higher version than the\n"
			"one in DATA_TZ_DIR the DATA_TZ_DIR is renamed and then deleted.\n";
	exit(1);		exit(1);
	}		}

	/*		/*
	* Opens a file and fills headerBytes with the first byteCount bytes from the file. It is a fatal		* Opens a file and fills buffer with the first byteCount bytes from the file.
	* error if the file is too small or cannot be opened. If the file does not exist false is returned.		* If the file does not exist or cannot be opened or is too short then false is returned.
	* If the bytes were read successfully then true is returned.		* If the bytes were read successfully then true is returned.
	*/		*/
	static bool readHeader(const std::string& tzDataFileName, char* headerBytes, size_t byteCount) {		static bool readBytes(const std::string& fileName, char* buffer, size_t byteCount) {
	FILE* tzDataFile = fopen(tzDataFileName.c_str(), "r");		FILE* file = fopen(fileName.c_str(), "r");
	if (tzDataFile == nullptr) {		if (file == nullptr) {
	if (errno == ENOENT) {		if (errno != ENOENT) {
	return false;		PLOG(WARNING) << "Error opening file " << fileName;
	} else {
	PLOG(FATAL) << "Error opening tzdata file " << tzDataFileName;
	}		}
			return false;
	}		}
	size_t bytesRead = fread(headerBytes, 1, byteCount, tzDataFile);		size_t bytesRead = fread(buffer, 1, byteCount, file);
			fclose(file);
	if (bytesRead != byteCount) {		if (bytesRead != byteCount) {
	LOG(FATAL) << tzDataFileName << " is too small. " << byteCount << " bytes required";		LOG(WARNING) << fileName << " is too small. " << byteCount << " bytes required";
			return false;
	}		}
	fclose(tzDataFile);
	return true;		return true;
	}		}

	/* Checks the contents of headerBytes. It is a fatal error if it not a tzdata header. */		/*
	static void checkValidHeader(const std::string& fileName, char* headerBytes) {		* Checks the contents of headerBytes. Returns true if it is valid (starts with "tzdata"), false
			* otherwise.
			*/
			static bool checkValidTzDataHeader(const std::string& fileName, const char* headerBytes) {
	if (strncmp("tzdata", headerBytes, 6) != 0) {		if (strncmp("tzdata", headerBytes, 6) != 0) {
	LOG(FATAL) << fileName << " does not start with the expected bytes (tzdata)";		LOG(WARNING) << fileName << " does not start with the expected bytes (tzdata)";
			return false;
			}
			return true;
			}

			static bool checkDigits(const char* buffer, const size_t count, size_t* i) {
			for (size_t j = 0; j < count; j++) {
			char toCheck = buffer[(*i)++];
			if (!isdigit(toCheck)) {
			return false;
			}
			}
			return true;
			}

			static bool checkValidBundleVersion(const char* buffer) {
			// See BUNDLE_VERSION_LENGTH comments above for a description of the format.
			size_t i = 0;
			if (!checkDigits(buffer, 3, &i)) {
			return false;
			}
			if (buffer[i++] != '.') {
			return false;
	}		}
			if (!checkDigits(buffer, 3, &i)) {
			return false;
			}
			if (buffer[i++] != '\|') {
			return false;
			}
			if (!checkDigits(buffer, 4, &i)) {
			return false;
			}
			// Ignore the last character. It is assumed to be a letter but we don't check because it's not
			// obvious what would happen at 'z'.
			return true;
	}		}

	/* Return the parent directory of dirName. */		/* Return the parent directory of dirName. */
	@@ -103,9 +162,24 @@ static int deleteFn(const char* fpath, const struct stat*, int typeflag, struct
	return 0;		return 0;
	}		}

			enum PathStatus { ERR, NONE, IS_DIR, NOT_DIR };

			static PathStatus checkPath(const std::string& path) {
			struct stat buf;
			if (stat(path.c_str(), &buf) != 0) {
			if (errno != ENOENT) {
			PLOG(WARNING) << "Unable to stat " << path;
			return ERR;
			}
			return NONE;
			}
			return S_ISDIR(buf.st_mode) ? IS_DIR : NOT_DIR;
			}

	/*		/*
	* Deletes dirToDelete and returns true if it is successful in removing or moving the directory out		* Deletes dirToDelete and returns true if it is successful in removing or moving the directory out
	* of the way. If dirToDelete does not exist this function does nothing and returns true.		* of the way. If dirToDelete does not exist this function does nothing and returns true. If
			* dirToDelete is not a directory or cannot be accessed this method returns false.
	*		*
	* During deletion, this function first renames the directory to a temporary name. If the temporary		* During deletion, this function first renames the directory to a temporary name. If the temporary
	* directory cannot be created, or the directory cannot be renamed, false is returned. After the		* directory cannot be created, or the directory cannot be renamed, false is returned. After the
	@@ -114,23 +188,18 @@ static int deleteFn(const char* fpath, const struct stat*, int typeflag, struct
	*/		*/
	static bool deleteDir(const std::string& dirToDelete) {		static bool deleteDir(const std::string& dirToDelete) {
	// Check whether the dir exists.		// Check whether the dir exists.
	struct stat buf;		int pathStatus = checkPath(dirToDelete);
	if (stat(dirToDelete.c_str(), &buf) == 0) {		if (pathStatus == NONE) {
	if (!S_ISDIR(buf.st_mode)) {		LOG(INFO) << "Path " << dirToDelete << " does not exist";
	LOG(WARNING) << dirToDelete << " is not a directory";
	return false;
	}
	} else {
	if (errno == ENOENT) {
	PLOG(INFO) << "Directory does not exist: " << dirToDelete;
	return true;		return true;
	} else {
	PLOG(WARNING) << "Unable to stat " << dirToDelete;
	return false;
	}		}
			if (pathStatus != IS_DIR) {
			LOG(WARNING) << "Path " << dirToDelete << " failed to stat() or is not a directory.";
			return false;
	}		}

	// First, rename dirToDelete.		// First, rename dirToDelete.

	std::string tempDirNameTemplate = getParentDir(dirToDelete);		std::string tempDirNameTemplate = getParentDir(dirToDelete);
	tempDirNameTemplate += "/tempXXXXXX";		tempDirNameTemplate += "/tempXXXXXX";

	@@ -142,7 +211,7 @@ static bool deleteDir(const std::string& dirToDelete) {
	return false;		return false;
	}		}

	// Rename dirToDelete to tempDirName.		// Rename dirToDelete to tempDirName (replacing the empty tempDirName directory created above).
	int rc = rename(dirToDelete.c_str(), &tempDirName[0]);		int rc = rename(dirToDelete.c_str(), &tempDirName[0]);
	if (rc == -1) {		if (rc == -1) {
	PLOG(WARNING) << "Unable to rename directory from " << dirToDelete << " to "		PLOG(WARNING) << "Unable to rename directory from " << dirToDelete << " to "
	@@ -151,6 +220,7 @@ static bool deleteDir(const std::string& dirToDelete) {
	}		}

	// Recursively delete contents of tempDirName.		// Recursively delete contents of tempDirName.

	rc = nftw(&tempDirName[0], deleteFn, 10 /* openFiles */,		rc = nftw(&tempDirName[0], deleteFn, 10 /* openFiles */,
	FTW_DEPTH \| FTW_MOUNT \| FTW_PHYS);		FTW_DEPTH \| FTW_MOUNT \| FTW_PHYS);
	if (rc == -1) {		if (rc == -1) {
	@@ -159,10 +229,37 @@ static bool deleteDir(const std::string& dirToDelete) {
	return true;		return true;
	}		}

			/*
			* Deletes the ConfigInstaller metadata directory.
			* TODO(nfuller). http://b/31008728 Remove this when ConfigInstaller is no longer used.
			*/
			static void deleteConfigUpdaterMetadataDir(const char* dataZoneInfoDir) {
			// Delete the update metadata
			std::string dataUpdatesDirName(dataZoneInfoDir);
			dataUpdatesDirName += "/updates";
			LOG(INFO) << "Removing: " << dataUpdatesDirName;
			bool deleted = deleteDir(dataUpdatesDirName);
			if (!deleted) {
			LOG(WARNING) << "Deletion of install metadata " << dataUpdatesDirName
			<< " was not successful";
			}
			}

			/*
			* Deletes the timezone update bundle directory.
			*/
			static void deleteUpdateBundleDir(std::string& bundleDirName) {
			LOG(INFO) << "Removing: " << bundleDirName;
			bool deleted = deleteDir(bundleDirName);
			if (!deleted) {
			LOG(WARNING) << "Deletion of bundle dir " << bundleDirName << " was not successful";
			}
			}

	/*		/*
	* After a platform update it is likely that timezone data found on the system partition will be		* After a platform update it is likely that timezone data found on the system partition will be
	* newer than the version found in the data partition. This tool detects this case and removes the		* newer than the version found in the data partition. This tool detects this case and removes the
	* version in /data along with any update metadata.		* version in /data.
	*		*
	* Note: This code is related to code in com.android.server.updates.TzDataInstallReceiver. The		* Note: This code is related to code in com.android.server.updates.TzDataInstallReceiver. The
	* paths for the metadata and current timezone data must match.		* paths for the metadata and current timezone data must match.
	@@ -175,62 +272,103 @@ static bool deleteDir(const std::string& dirToDelete) {
	int main(int argc, char* argv[]) {		int main(int argc, char* argv[]) {
	if (argc != 3) {		if (argc != 3) {
	usage();		usage();
			return 1;
	}		}

	const char* systemZoneInfoDir = argv[1];		const char* systemZoneInfoDir = argv[1];
	const char* dataZoneInfoDir = argv[2];		const char* dataZoneInfoDir = argv[2];

			// Check the bundle directory exists. If it does not, exit quickly: nothing to do.
	std::string dataCurrentDirName(dataZoneInfoDir);		std::string dataCurrentDirName(dataZoneInfoDir);
	dataCurrentDirName += "/current";		dataCurrentDirName += "/current";
	std::string dataTzDataFileName(dataCurrentDirName);		int dataCurrentDirStatus = checkPath(dataCurrentDirName);
	dataTzDataFileName += TZDATA_FILENAME;		if (dataCurrentDirStatus == NONE) {
			LOG(INFO) << "timezone bundle dir " << dataCurrentDirName
			<< " does not exist. No action required.";
			return 0;
			}
			// If the bundle directory path is not a directory or we can't stat() the path, exit with a
			// warning: either there's a problem accessing storage or the world is not as it should be;
			// nothing to do.
			if (dataCurrentDirStatus != IS_DIR) {
			LOG(WARNING) << "Current bundle dir " << dataCurrentDirName
			<< " could not be accessed or is not a directory. result=" << dataCurrentDirStatus;
			return 2;
			}

	std::vector<char> dataTzDataHeader;		// Check the installed bundle version.
	dataTzDataHeader.reserve(TZ_HEADER_LENGTH);		std::string bundleVersionFileName(dataCurrentDirName);
			bundleVersionFileName += BUNDLE_VERSION_FILENAME;
			std::vector<char> bundleVersion;
			bundleVersion.reserve(BUNDLE_VERSION_LENGTH);
			bool bundleVersionReadOk =
			readBytes(bundleVersionFileName, bundleVersion.data(), BUNDLE_VERSION_LENGTH);
			if (!bundleVersionReadOk) {
			LOG(WARNING) << "bundle version file " << bundleVersionFileName
			<< " does not exist or is too short. Deleting bundle dir.";
			// Implies the contents of the data partition is corrupt in some way. Try to clean up.
			deleteConfigUpdaterMetadataDir(dataZoneInfoDir);
			deleteUpdateBundleDir(dataCurrentDirName);
			return 3;
			}

	bool dataFileExists = readHeader(dataTzDataFileName, dataTzDataHeader.data(), TZ_HEADER_LENGTH);		if (!checkValidBundleVersion(bundleVersion.data())) {
	if (!dataFileExists) {		LOG(WARNING) << "bundle version file " << bundleVersionFileName
	LOG(INFO) << "tzdata file " << dataTzDataFileName << " does not exist. No action required.";		<< " is not valid. Deleting bundle dir.";
	return 0;		// Implies the contents of the data partition is corrupt in some way. Try to clean up.
			deleteConfigUpdaterMetadataDir(dataZoneInfoDir);
			deleteUpdateBundleDir(dataCurrentDirName);
			return 4;
	}		}
	checkValidHeader(dataTzDataFileName, dataTzDataHeader.data());

			// Check the first 3 bytes of the bundleVersionHeader: these are the major version (e.g. 001).
			// It must match exactly to be ok. The minor version is currently ignored.
			if (strncmp(&bundleVersion[0], REQUIRED_BUNDLE_VERSION, REQUIRED_BUNDLE_VERSION_LEN) != 0) {
			LOG(INFO) << "bundle version file " << bundleVersionFileName
			<< " is not the required version " << REQUIRED_BUNDLE_VERSION
			<< ". Deleting bundle dir.";
			// This shouldn't happen with 001, but it in future, this will imply there has been an OTA
			// and the installed bundle is not compatible with the new version of Android. Remove the
			// installed bundle.
			deleteConfigUpdaterMetadataDir(dataZoneInfoDir);
			deleteUpdateBundleDir(dataCurrentDirName);
			return 5;
			}

			// Read the system rules version out of the /system tzdata file.
	std::string systemTzDataFileName(systemZoneInfoDir);		std::string systemTzDataFileName(systemZoneInfoDir);
	systemTzDataFileName += TZDATA_FILENAME;		systemTzDataFileName += TZDATA_FILENAME;
	std::vector<char> systemTzDataHeader;		std::vector<char> systemTzDataHeader;
	systemTzDataHeader.reserve(TZ_HEADER_LENGTH);		systemTzDataHeader.reserve(TZ_HEADER_LENGTH);
	bool systemFileExists =		bool systemFileExists =
	readHeader(systemTzDataFileName, systemTzDataHeader.data(), TZ_HEADER_LENGTH);		readBytes(systemTzDataFileName, systemTzDataHeader.data(), TZ_HEADER_LENGTH);
	if (!systemFileExists) {		if (!systemFileExists) {
	LOG(FATAL) << systemTzDataFileName << " does not exist or could not be opened";		// Implies the contents of the system partition is corrupt in some way. Nothing we can do.
			LOG(WARNING) << systemTzDataFileName << " does not exist or could not be opened";
			return 6;
	}		}
	checkValidHeader(systemTzDataFileName, systemTzDataHeader.data());		if (!checkValidTzDataHeader(systemTzDataFileName, systemTzDataHeader.data())) {
			// Implies the contents of the system partition is corrupt in some way. Nothing we can do.
	if (strncmp(&systemTzDataHeader[0], &dataTzDataHeader[0], TZ_HEADER_LENGTH) < 0) {		LOG(WARNING) << systemTzDataFileName << " does not have a valid header.";
	LOG(INFO) << "tzdata file " << dataTzDataFileName << " is the newer than "		return 7;
	<< systemTzDataFileName << ". No action required.";
	} else {
	// We have detected the case this tool is intended to prevent. Go fix it.
	LOG(INFO) << "tzdata file " << dataTzDataFileName << " is the same as or older than "
	<< systemTzDataFileName << "; fixing...";

	// Delete the update metadata
	std::string dataUpdatesDirName(dataZoneInfoDir);
	dataUpdatesDirName += "/updates";
	LOG(INFO) << "Removing: " << dataUpdatesDirName;
	bool deleted = deleteDir(dataUpdatesDirName);
	if (!deleted) {
	LOG(WARNING) << "Deletion of install metadata " << dataUpdatesDirName
	<< " was not successful";
	}		}

	// Delete the TZ data		// Compare the bundle rules version against the system rules version.
	LOG(INFO) << "Removing: " << dataCurrentDirName;		if (strncmp(
	deleted = deleteDir(dataCurrentDirName);		&systemTzDataHeader[TZ_DATA_HEADER_PREFIX_LEN],
	if (!deleted) {		&bundleVersion[BUNDLE_VERSION_RULES_IDX],
	LOG(WARNING) << "Deletion of tzdata " << dataCurrentDirName << " was not successful";		RULES_VERSION_LEN) <= 0) {
	}		LOG(INFO) << "Found an installed bundle but it is valid. No action taken.";
			// Implies there is an installed update, but it is good.
			return 0;
	}		}

			// Implies there has been an OTA and the system version of the timezone rules is now newer
			// than the version installed in /data. Remove the installed bundle.
			LOG(INFO) << "timezone bundle in " << dataCurrentDirName << " is older than data in "
			<< systemTzDataFileName << "; fixing...";

			deleteConfigUpdaterMetadataDir(dataZoneInfoDir);
			deleteUpdateBundleDir(dataCurrentDirName);
	return 0;		return 0;
	}		}