tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Change tzdatacheck to account for bundle format changes

Browse source 
Change tzdatacheck to account for bundle format changes:
The update bundle now contains a bundle_version file to enable
us to detect changes to the format of the files in addition to
just checking the IANA rules version. The version will be
incremented as we make incompatible changes to the structure
of the bundle (e.g. the files present or their names), the
file formats or the file contents.

The old assumption was that a system image would typically
contain newer rules than had been pushed via ConfigUpdater
and we'd never get rid of the tzdata file from the bundle
content.

If Android makes rule updates routinely or makes substantial
changes to the timezone data files between major releases
then this assumption becomes (even more) untenable.

The bundle_version file in the bundle is expected to contain
the ASCII bytes for "001". This could be extended
in a future version to include minor versioning information
(e.g. "002.001") and so the code here only reads the first
three bytes. This allows for a future change to add the minor
version suffix and optionally increment the major version if
required.

Some error conditions that were previously treated as fatal
are now handled more elegantly. Generally if things are not
as expected with the installed bundle in /data tzdatacheck
will attempt to delete it. The return code of the binary is
used to distinguish between failure cases, which will be
used in a future automated test.

Some of the ConfigUpdater deletion code has been temporarily
retained (with a TODO) so the v2 of the installer code can be
used with ConfigUpdater/ConfigInstaller and keep something
like the existing process working until we have replaced it
with some thing better.

Using the v2 installer code with ConfigInstaller is one
possible fallback if the new distribution approach is not
completed in time.

Bug: 31008728
Test: Manual testing
Change-Id: Ib253f7d4c9cd72d3e392754f4b787a98ec22bc53
This commit is contained in:
Neil Fuller 2016-12-13 16:26:02 +00:00
parent 4bf9c82857
commit eec2bfb53b
1 changed files with 210 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

282
tzdatacheck/tzdatacheck.cpp
View file

@ -14,6 +14,7 @@
* limitations under the License.
*/
#include <ctype.h>
#include <errno.h>
#include <ftw.h>
#include <libgen.h>
@ -29,47 +30,105 @@
#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";
// tzdata file header (as much as we need for the version):
// byte[11] tzdata_version -- e.g. "tzdata2012f"
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() {
std::cerr << "Usage: tzdatacheck SYSTEM_TZ_DIR DATA_TZ_DIR\n"
"\n"
"Compares the headers of two tzdata files. If the one in SYSTEM_TZ_DIR is the\n"
"same or a higher version than the one in DATA_TZ_DIR the DATA_TZ_DIR is renamed\n"
"and then deleted.\n";
"Checks whether any timezone update bundle in DATA_TZ_DIR is compatible with the\n"
"current Android release and better than or the same as base system timezone rules in\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);
}
/*
* Opens a file and fills headerBytes with the first byteCount bytes from the file. It is a fatal
* error if the file is too small or cannot be opened. If the file does not exist false is returned.
* Opens a file and fills buffer with the first byteCount bytes from the file.
* 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.
*/
static bool readHeader(const std::string& tzDataFileName, char* headerBytes, size_t byteCount) {
FILE* tzDataFile = fopen(tzDataFileName.c_str(), "r");
if (tzDataFile == nullptr) {
if (errno == ENOENT) {
return false;
} else {
PLOG(FATAL) << "Error opening tzdata file " << tzDataFileName;
static bool readBytes(const std::string& fileName, char* buffer, size_t byteCount) {
FILE* file = fopen(fileName.c_str(), "r");
if (file == nullptr) {
if (errno != ENOENT) {
PLOG(WARNING) << "Error opening file " << fileName;
}
return false;
}
size_t bytesRead = fread(headerBytes, 1, byteCount, tzDataFile);
size_t bytesRead = fread(buffer, 1, byteCount, file);
fclose(file);
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;
}
/* 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) {
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. */
@ -103,9 +162,24 @@ static int deleteFn(const char* fpath, const struct stat*, int typeflag, struct
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
* 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
* 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) {
// Check whether the dir exists.
struct stat buf;
if (stat(dirToDelete.c_str(), &buf) == 0) {
if (!S_ISDIR(buf.st_mode)) {
LOG(WARNING) << dirToDelete << " is not a directory";
int pathStatus = checkPath(dirToDelete);
if (pathStatus == NONE) {
LOG(INFO) << "Path " << dirToDelete << " does not exist";
return true;
}
if (pathStatus != IS_DIR) {
LOG(WARNING) << "Path " << dirToDelete << " failed to stat() or is not a directory.";
return false;
}
} else {
if (errno == ENOENT) {
PLOG(INFO) << "Directory does not exist: " << dirToDelete;
return true;
} else {
PLOG(WARNING) << "Unable to stat " << dirToDelete;
return false;
}
}
// First, rename dirToDelete.
std::string tempDirNameTemplate = getParentDir(dirToDelete);
tempDirNameTemplate += "/tempXXXXXX";
@ -142,7 +211,7 @@ static bool deleteDir(const std::string& dirToDelete) {
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]);
if (rc == -1) {
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.
rc = nftw(&tempDirName[0], deleteFn, 10 /* openFiles */,
FTW_DEPTH | FTW_MOUNT | FTW_PHYS);
if (rc == -1) {
@ -159,10 +229,37 @@ static bool deleteDir(const std::string& dirToDelete) {
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
* 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
* 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[]) {
if (argc != 3) {
usage();
return 1;
}
const char* systemZoneInfoDir = argv[1];
const char* dataZoneInfoDir = argv[2];
// Check the bundle directory exists. If it does not, exit quickly: nothing to do.
std::string dataCurrentDirName(dataZoneInfoDir);
dataCurrentDirName += "/current";
std::string dataTzDataFileName(dataCurrentDirName);
dataTzDataFileName += TZDATA_FILENAME;
std::vector<char> dataTzDataHeader;
dataTzDataHeader.reserve(TZ_HEADER_LENGTH);
bool dataFileExists = readHeader(dataTzDataFileName, dataTzDataHeader.data(), TZ_HEADER_LENGTH);
if (!dataFileExists) {
LOG(INFO) << "tzdata file " << dataTzDataFileName << " does not exist. No action required.";
int dataCurrentDirStatus = checkPath(dataCurrentDirName);
if (dataCurrentDirStatus == NONE) {
LOG(INFO) << "timezone bundle dir " << dataCurrentDirName
<< " does not exist. No action required.";
return 0;
}
checkValidHeader(dataTzDataFileName, dataTzDataHeader.data());
// 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;
}
// Check the installed bundle version.
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;
}
if (!checkValidBundleVersion(bundleVersion.data())) {
LOG(WARNING) << "bundle version file " << bundleVersionFileName
<< " is not valid. Deleting bundle dir.";
// Implies the contents of the data partition is corrupt in some way. Try to clean up.
deleteConfigUpdaterMetadataDir(dataZoneInfoDir);
deleteUpdateBundleDir(dataCurrentDirName);
return 4;
}
// 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);
systemTzDataFileName += TZDATA_FILENAME;
std::vector<char> systemTzDataHeader;
systemTzDataHeader.reserve(TZ_HEADER_LENGTH);
bool systemFileExists =
readHeader(systemTzDataFileName, systemTzDataHeader.data(), TZ_HEADER_LENGTH);
readBytes(systemTzDataFileName, systemTzDataHeader.data(), TZ_HEADER_LENGTH);
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 (strncmp(&systemTzDataHeader[0], &dataTzDataHeader[0], TZ_HEADER_LENGTH) < 0) {
LOG(INFO) << "tzdata file " << dataTzDataFileName << " is the newer than "
<< 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
LOG(INFO) << "Removing: " << dataCurrentDirName;
deleted = deleteDir(dataCurrentDirName);
if (!deleted) {
LOG(WARNING) << "Deletion of tzdata " << dataCurrentDirName << " was not successful";
}
if (!checkValidTzDataHeader(systemTzDataFileName, systemTzDataHeader.data())) {
// Implies the contents of the system partition is corrupt in some way. Nothing we can do.
LOG(WARNING) << systemTzDataFileName << " does not have a valid header.";
return 7;
}
// Compare the bundle rules version against the system rules version.
if (strncmp(
&systemTzDataHeader[TZ_DATA_HEADER_PREFIX_LEN],
&bundleVersion[BUNDLE_VERSION_RULES_IDX],
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;
}