diff --git a/tzdatacheck/tzdatacheck.cpp b/tzdatacheck/tzdatacheck.cpp index c1ab2ac47..fb5c84bb6 100644 --- a/tzdatacheck/tzdatacheck.cpp +++ b/tzdatacheck/tzdatacheck.cpp @@ -14,6 +14,7 @@ * limitations under the License. */ +#include #include #include #include @@ -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 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 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 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; }