| /* |
| * Copyright (C) 2017 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. |
| */ |
| |
| package com.android.server.timezone; |
| |
| import com.android.internal.util.FastXmlSerializer; |
| |
| import org.xmlpull.v1.XmlPullParser; |
| import org.xmlpull.v1.XmlPullParserException; |
| import org.xmlpull.v1.XmlSerializer; |
| |
| import android.util.AtomicFile; |
| import android.util.Slog; |
| import android.util.Xml; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.nio.charset.StandardCharsets; |
| import java.text.ParseException; |
| import java.io.PrintWriter; |
| |
| import static com.android.server.timezone.PackageStatus.CHECK_COMPLETED_FAILURE; |
| import static com.android.server.timezone.PackageStatus.CHECK_COMPLETED_SUCCESS; |
| import static com.android.server.timezone.PackageStatus.CHECK_STARTED; |
| import static org.xmlpull.v1.XmlPullParser.END_DOCUMENT; |
| import static org.xmlpull.v1.XmlPullParser.START_TAG; |
| |
| /** |
| * Storage logic for accessing/mutating the Android system's persistent state related to time zone |
| * update checking. There is expected to be a single instance. All non-private methods are thread |
| * safe. |
| */ |
| final class PackageStatusStorage { |
| |
| private static final String LOG_TAG = "timezone.PackageStatusStorage"; |
| |
| private static final String TAG_PACKAGE_STATUS = "PackageStatus"; |
| |
| /** |
| * Attribute that stores a monotonically increasing lock ID, used to detect concurrent update |
| * issues without on-line locks. Incremented on every write. |
| */ |
| private static final String ATTRIBUTE_OPTIMISTIC_LOCK_ID = "optimisticLockId"; |
| |
| /** |
| * Attribute that stores the current "check status" of the time zone update application |
| * packages. |
| */ |
| private static final String ATTRIBUTE_CHECK_STATUS = "checkStatus"; |
| |
| /** |
| * Attribute that stores the version of the time zone rules update application being checked |
| * / last checked. |
| */ |
| private static final String ATTRIBUTE_UPDATE_APP_VERSION = "updateAppPackageVersion"; |
| |
| /** |
| * Attribute that stores the version of the time zone rules data application being checked |
| * / last checked. |
| */ |
| private static final String ATTRIBUTE_DATA_APP_VERSION = "dataAppPackageVersion"; |
| |
| private static final int UNKNOWN_PACKAGE_VERSION = -1; |
| |
| private final AtomicFile mPackageStatusFile; |
| |
| PackageStatusStorage(File storageDir) { |
| mPackageStatusFile = new AtomicFile(new File(storageDir, "packageStatus.xml")); |
| if (!mPackageStatusFile.getBaseFile().exists()) { |
| try { |
| insertInitialPackageStatus(); |
| } catch (IOException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| } |
| |
| void deleteFileForTests() { |
| synchronized(this) { |
| mPackageStatusFile.delete(); |
| } |
| } |
| |
| /** |
| * Obtain the current check status of the application packages. Returns {@code null} the first |
| * time it is called, or after {@link #resetCheckState()}. |
| */ |
| PackageStatus getPackageStatus() { |
| synchronized (this) { |
| try { |
| return getPackageStatusInternal(); |
| } catch (ParseException e) { |
| // This means that data exists in the file but it was bad. |
| Slog.e(LOG_TAG, "Package status invalid, resetting and retrying", e); |
| |
| // Reset the storage so it is in a good state again. |
| recoverFromBadData(e); |
| try { |
| return getPackageStatusInternal(); |
| } catch (ParseException e2) { |
| throw new IllegalStateException("Recovery from bad file failed", e2); |
| } |
| } |
| } |
| } |
| |
| private PackageStatus getPackageStatusInternal() throws ParseException { |
| try (FileInputStream fis = mPackageStatusFile.openRead()) { |
| XmlPullParser parser = parseToPackageStatusTag(fis); |
| Integer checkStatus = getNullableIntAttribute(parser, ATTRIBUTE_CHECK_STATUS); |
| if (checkStatus == null) { |
| return null; |
| } |
| int updateAppVersion = getIntAttribute(parser, ATTRIBUTE_UPDATE_APP_VERSION); |
| int dataAppVersion = getIntAttribute(parser, ATTRIBUTE_DATA_APP_VERSION); |
| return new PackageStatus(checkStatus, |
| new PackageVersions(updateAppVersion, dataAppVersion)); |
| } catch (IOException e) { |
| ParseException e2 = new ParseException("Error reading package status", 0); |
| e2.initCause(e); |
| throw e2; |
| } |
| } |
| |
| // Callers should be synchronized(this). |
| private int recoverFromBadData(Exception cause) { |
| mPackageStatusFile.delete(); |
| try { |
| return insertInitialPackageStatus(); |
| } catch (IOException e) { |
| IllegalStateException fatal = new IllegalStateException(e); |
| fatal.addSuppressed(cause); |
| throw fatal; |
| } |
| } |
| |
| /** Insert the initial data, returning the optimistic lock ID */ |
| private int insertInitialPackageStatus() throws IOException { |
| // Doesn't matter what it is, but we avoid the obvious starting value each time the data |
| // is reset to ensure that old tokens are unlikely to work. |
| final int initialOptimisticLockId = (int) System.currentTimeMillis(); |
| |
| writePackageStatusInternal(null /* status */, initialOptimisticLockId, |
| null /* packageVersions */); |
| return initialOptimisticLockId; |
| } |
| |
| /** |
| * Generate a new {@link CheckToken} that can be passed to the time zone rules update |
| * application. |
| */ |
| CheckToken generateCheckToken(PackageVersions currentInstalledVersions) { |
| if (currentInstalledVersions == null) { |
| throw new NullPointerException("currentInstalledVersions == null"); |
| } |
| |
| synchronized (this) { |
| int optimisticLockId; |
| try { |
| optimisticLockId = getCurrentOptimisticLockId(); |
| } catch (ParseException e) { |
| Slog.w(LOG_TAG, "Unable to find optimistic lock ID from package status"); |
| |
| // Recover. |
| optimisticLockId = recoverFromBadData(e); |
| } |
| |
| int newOptimisticLockId = optimisticLockId + 1; |
| try { |
| boolean statusUpdated = writePackageStatusWithOptimisticLockCheck( |
| optimisticLockId, newOptimisticLockId, CHECK_STARTED, |
| currentInstalledVersions); |
| if (!statusUpdated) { |
| throw new IllegalStateException("Unable to update status to CHECK_STARTED." |
| + " synchronization failure?"); |
| } |
| return new CheckToken(newOptimisticLockId, currentInstalledVersions); |
| } catch (IOException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| } |
| |
| /** |
| * Reset the current device state to "unknown". |
| */ |
| void resetCheckState() { |
| synchronized(this) { |
| int optimisticLockId; |
| try { |
| optimisticLockId = getCurrentOptimisticLockId(); |
| } catch (ParseException e) { |
| Slog.w(LOG_TAG, "resetCheckState: Unable to find optimistic lock ID from package" |
| + " status"); |
| // Attempt to recover the storage state. |
| optimisticLockId = recoverFromBadData(e); |
| } |
| |
| int newOptimisticLockId = optimisticLockId + 1; |
| try { |
| if (!writePackageStatusWithOptimisticLockCheck(optimisticLockId, |
| newOptimisticLockId, null /* status */, null /* packageVersions */)) { |
| throw new IllegalStateException("resetCheckState: Unable to reset package" |
| + " status, newOptimisticLockId=" + newOptimisticLockId); |
| } |
| } catch (IOException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| } |
| |
| /** |
| * Update the current device state if possible. Returns true if the update was successful. |
| * {@code false} indicates the storage has been changed since the {@link CheckToken} was |
| * generated and the update was discarded. |
| */ |
| boolean markChecked(CheckToken checkToken, boolean succeeded) { |
| synchronized (this) { |
| int optimisticLockId = checkToken.mOptimisticLockId; |
| int newOptimisticLockId = optimisticLockId + 1; |
| int status = succeeded ? CHECK_COMPLETED_SUCCESS : CHECK_COMPLETED_FAILURE; |
| try { |
| return writePackageStatusWithOptimisticLockCheck(optimisticLockId, |
| newOptimisticLockId, status, checkToken.mPackageVersions); |
| } catch (IOException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| } |
| |
| // Caller should be synchronized(this). |
| private int getCurrentOptimisticLockId() throws ParseException { |
| try (FileInputStream fis = mPackageStatusFile.openRead()) { |
| XmlPullParser parser = parseToPackageStatusTag(fis); |
| return getIntAttribute(parser, ATTRIBUTE_OPTIMISTIC_LOCK_ID); |
| } catch (IOException e) { |
| ParseException e2 = new ParseException("Unable to read file", 0); |
| e2.initCause(e); |
| throw e2; |
| } |
| } |
| |
| /** Returns a parser or throws ParseException, never returns null. */ |
| private static XmlPullParser parseToPackageStatusTag(FileInputStream fis) |
| throws ParseException { |
| try { |
| XmlPullParser parser = Xml.newPullParser(); |
| parser.setInput(fis, StandardCharsets.UTF_8.name()); |
| int type; |
| while ((type = parser.next()) != END_DOCUMENT) { |
| final String tag = parser.getName(); |
| if (type == START_TAG && TAG_PACKAGE_STATUS.equals(tag)) { |
| return parser; |
| } |
| } |
| throw new ParseException("Unable to find " + TAG_PACKAGE_STATUS + " tag", 0); |
| } catch (XmlPullParserException e) { |
| throw new IllegalStateException("Unable to configure parser", e); |
| } catch (IOException e) { |
| ParseException e2 = new ParseException("Error reading XML", 0); |
| e.initCause(e); |
| throw e2; |
| } |
| } |
| |
| // Caller should be synchronized(this). |
| private boolean writePackageStatusWithOptimisticLockCheck(int optimisticLockId, |
| int newOptimisticLockId, Integer status, PackageVersions packageVersions) |
| throws IOException { |
| |
| int currentOptimisticLockId; |
| try { |
| currentOptimisticLockId = getCurrentOptimisticLockId(); |
| if (currentOptimisticLockId != optimisticLockId) { |
| return false; |
| } |
| } catch (ParseException e) { |
| recoverFromBadData(e); |
| return false; |
| } |
| |
| writePackageStatusInternal(status, newOptimisticLockId, packageVersions); |
| return true; |
| } |
| |
| // Caller should be synchronized(this). |
| private void writePackageStatusInternal(Integer status, int optimisticLockId, |
| PackageVersions packageVersions) throws IOException { |
| if ((status == null) != (packageVersions == null)) { |
| throw new IllegalArgumentException( |
| "Provide both status and packageVersions, or neither."); |
| } |
| |
| FileOutputStream fos = null; |
| try { |
| fos = mPackageStatusFile.startWrite(); |
| XmlSerializer serializer = new FastXmlSerializer(); |
| serializer.setOutput(fos, StandardCharsets.UTF_8.name()); |
| serializer.startDocument(null /* encoding */, true /* standalone */); |
| final String namespace = null; |
| serializer.startTag(namespace, TAG_PACKAGE_STATUS); |
| String statusAttributeValue = status == null ? "" : Integer.toString(status); |
| serializer.attribute(namespace, ATTRIBUTE_CHECK_STATUS, statusAttributeValue); |
| serializer.attribute(namespace, ATTRIBUTE_OPTIMISTIC_LOCK_ID, |
| Integer.toString(optimisticLockId)); |
| int updateAppVersion = status == null |
| ? UNKNOWN_PACKAGE_VERSION : packageVersions.mUpdateAppVersion; |
| serializer.attribute(namespace, ATTRIBUTE_UPDATE_APP_VERSION, |
| Integer.toString(updateAppVersion)); |
| int dataAppVersion = status == null |
| ? UNKNOWN_PACKAGE_VERSION : packageVersions.mDataAppVersion; |
| serializer.attribute(namespace, ATTRIBUTE_DATA_APP_VERSION, |
| Integer.toString(dataAppVersion)); |
| serializer.endTag(namespace, TAG_PACKAGE_STATUS); |
| serializer.endDocument(); |
| serializer.flush(); |
| mPackageStatusFile.finishWrite(fos); |
| } catch (IOException e) { |
| if (fos != null) { |
| mPackageStatusFile.failWrite(fos); |
| } |
| throw e; |
| } |
| |
| } |
| |
| /** Only used during tests to force a known table state. */ |
| public void forceCheckStateForTests(int checkStatus, PackageVersions packageVersions) { |
| synchronized (this) { |
| try { |
| int optimisticLockId = getCurrentOptimisticLockId(); |
| writePackageStatusWithOptimisticLockCheck(optimisticLockId, optimisticLockId, |
| checkStatus, packageVersions); |
| } catch (IOException | ParseException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| } |
| |
| private static Integer getNullableIntAttribute(XmlPullParser parser, String attributeName) |
| throws ParseException { |
| String attributeValue = parser.getAttributeValue(null, attributeName); |
| try { |
| if (attributeValue == null) { |
| throw new ParseException("Attribute " + attributeName + " missing", 0); |
| } else if (attributeValue.isEmpty()) { |
| return null; |
| } |
| return Integer.parseInt(attributeValue); |
| } catch (NumberFormatException e) { |
| throw new ParseException( |
| "Bad integer for attributeName=" + attributeName + ": " + attributeValue, 0); |
| } |
| } |
| |
| private static int getIntAttribute(XmlPullParser parser, String attributeName) |
| throws ParseException { |
| Integer value = getNullableIntAttribute(parser, attributeName); |
| if (value == null) { |
| throw new ParseException("Missing attribute " + attributeName, 0); |
| } |
| return value; |
| } |
| |
| public void dump(PrintWriter printWriter) { |
| printWriter.println("Package status: " + getPackageStatus()); |
| } |
| } |