diff options
9 files changed, 974 insertions, 248 deletions
diff --git a/core/java/com/android/server/AppWidgetBackupBridge.java b/core/java/com/android/server/AppWidgetBackupBridge.java index 2ea2f794dac9..7d82d355e3eb 100644 --- a/core/java/com/android/server/AppWidgetBackupBridge.java +++ b/core/java/com/android/server/AppWidgetBackupBridge.java @@ -16,6 +16,8 @@ package com.android.server; +import android.annotation.Nullable; + import java.util.List; /** @@ -37,6 +39,8 @@ public class AppWidgetBackupBridge { : null; } + /** Returns a byte array of widget data for the specified package or {@code null}. */ + @Nullable public static byte[] getWidgetState(String packageName, int userId) { return (sAppWidgetService != null) ? sAppWidgetService.getWidgetState(packageName, userId) diff --git a/services/backup/java/com/android/server/backup/KeyValueAdbBackupEngine.java b/services/backup/java/com/android/server/backup/KeyValueAdbBackupEngine.java index 30ec8ab711b6..125c2250d7d1 100644 --- a/services/backup/java/com/android/server/backup/KeyValueAdbBackupEngine.java +++ b/services/backup/java/com/android/server/backup/KeyValueAdbBackupEngine.java @@ -9,9 +9,9 @@ import static com.android.server.backup.BackupManagerService.OP_TYPE_BACKUP_WAIT import android.app.ApplicationThreadConstants; import android.app.IBackupAgent; -import android.app.backup.IBackupCallback; import android.app.backup.FullBackup; import android.app.backup.FullBackupDataOutput; +import android.app.backup.IBackupCallback; import android.content.pm.ApplicationInfo; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; @@ -21,6 +21,7 @@ import android.os.SELinux; import android.util.Slog; import com.android.internal.util.Preconditions; +import com.android.server.backup.fullbackup.AppMetadataBackupWriter; import com.android.server.backup.remote.ServiceBackupCallback; import com.android.server.backup.utils.FullBackupUtils; @@ -202,16 +203,20 @@ public class KeyValueAdbBackupEngine { public void run() { try { FullBackupDataOutput output = new FullBackupDataOutput(mPipe); + AppMetadataBackupWriter writer = + new AppMetadataBackupWriter(output, mPackageManager); if (DEBUG) { Slog.d(TAG, "Writing manifest for " + mPackage.packageName); } - FullBackupUtils.writeAppManifest( - mPackage, mPackageManager, mManifestFile, false, false); - FullBackup.backupToTar(mPackage.packageName, FullBackup.KEY_VALUE_DATA_TOKEN, null, - mDataDir.getAbsolutePath(), - mManifestFile.getAbsolutePath(), - output); + + writer.backupManifest( + mPackage, + mManifestFile, + mDataDir, + FullBackup.KEY_VALUE_DATA_TOKEN, + /* linkDomain */ null, + /* withApk */ false); mManifestFile.delete(); if (DEBUG) { diff --git a/services/backup/java/com/android/server/backup/fullbackup/AppMetadataBackupWriter.java b/services/backup/java/com/android/server/backup/fullbackup/AppMetadataBackupWriter.java new file mode 100644 index 000000000000..94365d7dc02d --- /dev/null +++ b/services/backup/java/com/android/server/backup/fullbackup/AppMetadataBackupWriter.java @@ -0,0 +1,283 @@ +package com.android.server.backup.fullbackup; + +import static com.android.server.backup.BackupManagerService.BACKUP_MANIFEST_VERSION; +import static com.android.server.backup.BackupManagerService.BACKUP_METADATA_VERSION; +import static com.android.server.backup.BackupManagerService.BACKUP_WIDGET_METADATA_TOKEN; +import static com.android.server.backup.BackupManagerService.MORE_DEBUG; +import static com.android.server.backup.BackupManagerService.TAG; + +import android.annotation.Nullable; +import android.app.backup.FullBackup; +import android.app.backup.FullBackupDataOutput; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.content.pm.Signature; +import android.content.pm.SigningInfo; +import android.os.Build; +import android.os.Environment; +import android.os.UserHandle; +import android.util.Log; +import android.util.StringBuilderPrinter; + +import com.android.internal.util.Preconditions; + +import java.io.BufferedOutputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; + +/** + * Writes the backup of app-specific metadata to {@link FullBackupDataOutput}. This data is not + * backed up by the app's backup agent and is written before the agent writes its own data. This + * includes the app's: + * + * <ul> + * <li>manifest + * <li>widget data + * <li>apk + * <li>obb content + * </ul> + */ +// TODO(b/113807190): Fix or remove apk and obb implementation (only used for adb). +public class AppMetadataBackupWriter { + private final FullBackupDataOutput mOutput; + private final PackageManager mPackageManager; + + /** The destination of the backup is specified by {@code output}. */ + public AppMetadataBackupWriter(FullBackupDataOutput output, PackageManager packageManager) { + mOutput = output; + mPackageManager = packageManager; + } + + /** + * Back up the app's manifest without specifying a pseudo-directory for the TAR stream. + * + * @see #backupManifest(PackageInfo, File, File, String, String, boolean) + */ + public void backupManifest( + PackageInfo packageInfo, File manifestFile, File filesDir, boolean withApk) + throws IOException { + backupManifest( + packageInfo, + manifestFile, + filesDir, + /* domain */ null, + /* linkDomain */ null, + withApk); + } + + /** + * Back up the app's manifest. + * + * <ol> + * <li>Write the app's manifest data to the specified temporary file {@code manifestFile}. + * <li>Backup the file in TAR format to the backup destination {@link #mOutput}. + * </ol> + * + * <p>Note: {@code domain} and {@code linkDomain} are only used by adb to specify a + * pseudo-directory for the TAR stream. + */ + // TODO(b/113806991): Look into streaming the backup data directly. + public void backupManifest( + PackageInfo packageInfo, + File manifestFile, + File filesDir, + @Nullable String domain, + @Nullable String linkDomain, + boolean withApk) + throws IOException { + byte[] manifestBytes = getManifestBytes(packageInfo, withApk); + FileOutputStream outputStream = new FileOutputStream(manifestFile); + outputStream.write(manifestBytes); + outputStream.close(); + + // We want the manifest block in the archive stream to be constant each time we generate + // a backup stream for the app. However, the underlying TAR mechanism sees it as a file and + // will propagate its last modified time. We pin the last modified time to zero to prevent + // the TAR header from varying. + manifestFile.setLastModified(0); + + FullBackup.backupToTar( + packageInfo.packageName, + domain, + linkDomain, + filesDir.getAbsolutePath(), + manifestFile.getAbsolutePath(), + mOutput); + } + + /** + * Gets the app's manifest as a byte array. All data are strings ending in LF. + * + * <p>The manifest format is: + * + * <pre> + * BACKUP_MANIFEST_VERSION + * package name + * package version code + * platform version code + * installer package name (can be empty) + * boolean (1 if archive includes .apk, otherwise 0) + * # of signatures N + * N* (signature byte array in ascii format per Signature.toCharsString()) + * </pre> + */ + private byte[] getManifestBytes(PackageInfo packageInfo, boolean withApk) { + String packageName = packageInfo.packageName; + StringBuilder builder = new StringBuilder(4096); + StringBuilderPrinter printer = new StringBuilderPrinter(builder); + + printer.println(Integer.toString(BACKUP_MANIFEST_VERSION)); + printer.println(packageName); + printer.println(Long.toString(packageInfo.getLongVersionCode())); + printer.println(Integer.toString(Build.VERSION.SDK_INT)); + + String installerName = mPackageManager.getInstallerPackageName(packageName); + printer.println((installerName != null) ? installerName : ""); + + printer.println(withApk ? "1" : "0"); + + // Write the signature block. + SigningInfo signingInfo = packageInfo.signingInfo; + if (signingInfo == null) { + printer.println("0"); + } else { + // Retrieve the newest signatures to write. + // TODO (b/73988180) use entire signing history in case of rollbacks. + Signature[] signatures = signingInfo.getApkContentsSigners(); + printer.println(Integer.toString(signatures.length)); + for (Signature sig : signatures) { + printer.println(sig.toCharsString()); + } + } + return builder.toString().getBytes(); + } + + /** + * Backup specified widget data. The widget data is prefaced by a metadata header. + * + * <ol> + * <li>Write a metadata header to the specified temporary file {@code metadataFile}. + * <li>Write widget data bytes to the same file. + * <li>Backup the file in TAR format to the backup destination {@link #mOutput}. + * </ol> + * + * @throws IllegalArgumentException if the widget data provided is empty. + */ + // TODO(b/113806991): Look into streaming the backup data directly. + public void backupWidget( + PackageInfo packageInfo, File metadataFile, File filesDir, byte[] widgetData) + throws IOException { + Preconditions.checkArgument(widgetData.length > 0, "Can't backup widget with no data."); + + String packageName = packageInfo.packageName; + FileOutputStream fileOutputStream = new FileOutputStream(metadataFile); + BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream); + DataOutputStream dataOutputStream = new DataOutputStream(bufferedOutputStream); + + byte[] metadata = getMetadataBytes(packageName); + bufferedOutputStream.write(metadata); // bypassing DataOutputStream + writeWidgetData(dataOutputStream, widgetData); + bufferedOutputStream.flush(); + dataOutputStream.close(); + + // As with the manifest file, guarantee consistency of the archive metadata for the widget + // block by using a fixed last modified time on the metadata file. + metadataFile.setLastModified(0); + + FullBackup.backupToTar( + packageName, + /* domain */ null, + /* linkDomain */ null, + filesDir.getAbsolutePath(), + metadataFile.getAbsolutePath(), + mOutput); + } + + /** + * Gets the app's metadata as a byte array. All entries are strings ending in LF. + * + * <p>The metadata format is: + * + * <pre> + * BACKUP_METADATA_VERSION + * package name + * </pre> + */ + private byte[] getMetadataBytes(String packageName) { + StringBuilder builder = new StringBuilder(512); + StringBuilderPrinter printer = new StringBuilderPrinter(builder); + printer.println(Integer.toString(BACKUP_METADATA_VERSION)); + printer.println(packageName); + return builder.toString().getBytes(); + } + + /** + * Write a byte array of widget data to the specified output stream. All integers are binary in + * network byte order. + * + * <p>The widget data format: + * + * <pre> + * 4 : Integer token identifying the widget data blob. + * 4 : Integer size of the widget data. + * N : Raw bytes of the widget data. + * </pre> + */ + private void writeWidgetData(DataOutputStream out, byte[] widgetData) throws IOException { + out.writeInt(BACKUP_WIDGET_METADATA_TOKEN); + out.writeInt(widgetData.length); + out.write(widgetData); + } + + /** + * Backup the app's .apk to the backup destination {@link #mOutput}. Currently only used for + * 'adb backup'. + */ + // TODO(b/113807190): Investigate and potentially remove. + public void backupApk(PackageInfo packageInfo) { + // TODO: handle backing up split APKs + String appSourceDir = packageInfo.applicationInfo.getBaseCodePath(); + String apkDir = new File(appSourceDir).getParent(); + FullBackup.backupToTar( + packageInfo.packageName, + FullBackup.APK_TREE_TOKEN, + /* linkDomain */ null, + apkDir, + appSourceDir, + mOutput); + } + + /** + * Backup the app's .obb files to the backup destination {@link #mOutput}. Currently only used + * for 'adb backup'. + */ + // TODO(b/113807190): Investigate and potentially remove. + public void backupObb(PackageInfo packageInfo) { + // TODO: migrate this to SharedStorageBackup, since AID_SYSTEM doesn't have access to + // external storage. + // TODO: http://b/22388012 + Environment.UserEnvironment userEnv = + new Environment.UserEnvironment(UserHandle.USER_SYSTEM); + File obbDir = userEnv.buildExternalStorageAppObbDirs(packageInfo.packageName)[0]; + if (obbDir != null) { + if (MORE_DEBUG) { + Log.i(TAG, "obb dir: " + obbDir.getAbsolutePath()); + } + File[] obbFiles = obbDir.listFiles(); + if (obbFiles != null) { + String obbDirName = obbDir.getAbsolutePath(); + for (File obb : obbFiles) { + FullBackup.backupToTar( + packageInfo.packageName, + FullBackup.OBB_TREE_TOKEN, + /* linkDomain */ null, + obbDirName, + obb.getAbsolutePath(), + mOutput); + } + } + } + } +} diff --git a/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java b/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java index 16906f74c8a8..c9f72181bcaf 100644 --- a/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java +++ b/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java @@ -18,8 +18,6 @@ package com.android.server.backup.fullbackup; import static com.android.server.backup.BackupManagerService.BACKUP_MANIFEST_FILENAME; import static com.android.server.backup.BackupManagerService.BACKUP_METADATA_FILENAME; -import static com.android.server.backup.BackupManagerService.BACKUP_METADATA_VERSION; -import static com.android.server.backup.BackupManagerService.BACKUP_WIDGET_METADATA_TOKEN; import static com.android.server.backup.BackupManagerService.DEBUG; import static com.android.server.backup.BackupManagerService.MORE_DEBUG; import static com.android.server.backup.BackupManagerService.OP_TYPE_BACKUP_WAIT; @@ -29,17 +27,14 @@ import static com.android.server.backup.BackupManagerService.TAG; import android.app.ApplicationThreadConstants; import android.app.IBackupAgent; import android.app.backup.BackupTransport; -import android.app.backup.FullBackup; import android.app.backup.FullBackupDataOutput; import android.content.pm.ApplicationInfo; import android.content.pm.PackageInfo; -import android.os.Environment.UserEnvironment; +import android.content.pm.PackageManager; import android.os.ParcelFileDescriptor; import android.os.RemoteException; import android.os.UserHandle; -import android.util.Log; import android.util.Slog; -import android.util.StringBuilderPrinter; import com.android.internal.util.Preconditions; import com.android.server.AppWidgetBackupBridge; @@ -49,27 +44,20 @@ import com.android.server.backup.BackupRestoreTask; import com.android.server.backup.remote.RemoteCall; import com.android.server.backup.utils.FullBackupUtils; -import java.io.BufferedOutputStream; -import java.io.DataOutputStream; import java.io.File; -import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; /** - * Core logic for performing one package's full backup, gathering the tarball from the - * application and emitting it to the designated OutputStream. + * Core logic for performing one package's full backup, gathering the tarball from the application + * and emitting it to the designated OutputStream. */ public class FullBackupEngine { - private BackupManagerService backupManagerService; OutputStream mOutput; FullBackupPreflight mPreflightHook; BackupRestoreTask mTimeoutMonitor; IBackupAgent mAgent; - File mFilesDir; - File mManifestFile; - File mMetadataFile; boolean mIncludeApks; PackageInfo mPkg; private final long mQuota; @@ -78,79 +66,91 @@ public class FullBackupEngine { private final BackupAgentTimeoutParameters mAgentTimeoutParameters; class FullBackupRunner implements Runnable { - - PackageInfo mPackage; - byte[] mWidgetData; - IBackupAgent mAgent; - ParcelFileDescriptor mPipe; - int mToken; - boolean mSendApk; - boolean mWriteManifest; - - FullBackupRunner(PackageInfo pack, IBackupAgent agent, ParcelFileDescriptor pipe, - int token, boolean sendApk, boolean writeManifest, byte[] widgetData) + private final PackageManager mPackageManager; + private final PackageInfo mPackage; + private final IBackupAgent mAgent; + private final ParcelFileDescriptor mPipe; + private final int mToken; + private final boolean mIncludeApks; + private final File mFilesDir; + + FullBackupRunner( + PackageInfo packageInfo, + IBackupAgent agent, + ParcelFileDescriptor pipe, + int token, + boolean includeApks) throws IOException { - mPackage = pack; - mWidgetData = widgetData; + mPackageManager = backupManagerService.getPackageManager(); + mPackage = packageInfo; mAgent = agent; mPipe = ParcelFileDescriptor.dup(pipe.getFileDescriptor()); mToken = token; - mSendApk = sendApk; - mWriteManifest = writeManifest; + mIncludeApks = includeApks; + mFilesDir = new File("/data/system"); } @Override public void run() { try { - FullBackupDataOutput output = new FullBackupDataOutput( - mPipe, -1, mTransportFlags); + FullBackupDataOutput output = + new FullBackupDataOutput(mPipe, /* quota */ -1, mTransportFlags); + AppMetadataBackupWriter appMetadataBackupWriter = + new AppMetadataBackupWriter(output, mPackageManager); + + String packageName = mPackage.packageName; + boolean isSharedStorage = SHARED_BACKUP_AGENT_PACKAGE.equals(packageName); + boolean writeApk = + shouldWriteApk(mPackage.applicationInfo, mIncludeApks, isSharedStorage); - if (mWriteManifest) { - final boolean writeWidgetData = mWidgetData != null; + if (!isSharedStorage) { if (MORE_DEBUG) { - Slog.d(TAG, "Writing manifest for " + mPackage.packageName); + Slog.d(TAG, "Writing manifest for " + packageName); } - FullBackupUtils - .writeAppManifest(mPackage, backupManagerService.getPackageManager(), - mManifestFile, mSendApk, - writeWidgetData); - FullBackup.backupToTar(mPackage.packageName, null, null, - mFilesDir.getAbsolutePath(), - mManifestFile.getAbsolutePath(), - output); - mManifestFile.delete(); - // We only need to write a metadata file if we have widget data to stash - if (writeWidgetData) { - writeMetadata(mPackage, mMetadataFile, mWidgetData); - FullBackup.backupToTar(mPackage.packageName, null, null, - mFilesDir.getAbsolutePath(), - mMetadataFile.getAbsolutePath(), - output); - mMetadataFile.delete(); + File manifestFile = new File(mFilesDir, BACKUP_MANIFEST_FILENAME); + appMetadataBackupWriter.backupManifest( + mPackage, manifestFile, mFilesDir, writeApk); + manifestFile.delete(); + + // Write widget data. + // TODO: http://b/22388012 + byte[] widgetData = + AppWidgetBackupBridge.getWidgetState( + packageName, UserHandle.USER_SYSTEM); + if (widgetData != null && widgetData.length > 0) { + File metadataFile = new File(mFilesDir, BACKUP_METADATA_FILENAME); + appMetadataBackupWriter.backupWidget( + mPackage, metadataFile, mFilesDir, widgetData); + metadataFile.delete(); } } - if (mSendApk) { - writeApkToBackup(mPackage, output); + // TODO(b/113807190): Look into removing, only used for 'adb backup'. + if (writeApk) { + appMetadataBackupWriter.backupApk(mPackage); + appMetadataBackupWriter.backupObb(mPackage); } - final boolean isSharedStorage = - mPackage.packageName.equals(SHARED_BACKUP_AGENT_PACKAGE); - final long timeout = isSharedStorage ? - mAgentTimeoutParameters.getSharedBackupAgentTimeoutMillis() : - mAgentTimeoutParameters.getFullBackupAgentTimeoutMillis(); - if (DEBUG) { - Slog.d(TAG, "Calling doFullBackup() on " + mPackage.packageName); + Slog.d(TAG, "Calling doFullBackup() on " + packageName); } - backupManagerService - .prepareOperationTimeout(mToken, - timeout, - mTimeoutMonitor /* in parent class */, - OP_TYPE_BACKUP_WAIT); - mAgent.doFullBackup(mPipe, mQuota, mToken, - backupManagerService.getBackupManagerBinder(), mTransportFlags); + + long timeout = + isSharedStorage + ? mAgentTimeoutParameters.getSharedBackupAgentTimeoutMillis() + : mAgentTimeoutParameters.getFullBackupAgentTimeoutMillis(); + backupManagerService.prepareOperationTimeout( + mToken, + timeout, + mTimeoutMonitor /* in parent class */, + OP_TYPE_BACKUP_WAIT); + mAgent.doFullBackup( + mPipe, + mQuota, + mToken, + backupManagerService.getBackupManagerBinder(), + mTransportFlags); } catch (IOException e) { Slog.e(TAG, "Error running full backup for " + mPackage.packageName); } catch (RemoteException e) { @@ -162,12 +162,33 @@ public class FullBackupEngine { } } } + + /** + * Don't write apks for forward-locked apps or system-bundled apps that are not upgraded. + */ + private boolean shouldWriteApk( + ApplicationInfo applicationInfo, boolean includeApks, boolean isSharedStorage) { + boolean isForwardLocked = + (applicationInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_FORWARD_LOCK) != 0; + boolean isSystemApp = (applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0; + boolean isUpdatedSystemApp = + (applicationInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0; + return includeApks + && !isSharedStorage + && !isForwardLocked + && (!isSystemApp || isUpdatedSystemApp); + } } - public FullBackupEngine(BackupManagerService backupManagerService, + public FullBackupEngine( + BackupManagerService backupManagerService, OutputStream output, - FullBackupPreflight preflightHook, PackageInfo pkg, - boolean alsoApks, BackupRestoreTask timeoutMonitor, long quota, int opToken, + FullBackupPreflight preflightHook, + PackageInfo pkg, + boolean alsoApks, + BackupRestoreTask timeoutMonitor, + long quota, + int opToken, int transportFlags) { this.backupManagerService = backupManagerService; mOutput = output; @@ -175,15 +196,13 @@ public class FullBackupEngine { mPkg = pkg; mIncludeApks = alsoApks; mTimeoutMonitor = timeoutMonitor; - mFilesDir = new File("/data/system"); - mManifestFile = new File(mFilesDir, BACKUP_MANIFEST_FILENAME); - mMetadataFile = new File(mFilesDir, BACKUP_METADATA_FILENAME); mQuota = quota; mOpToken = opToken; mTransportFlags = transportFlags; - mAgentTimeoutParameters = Preconditions.checkNotNull( - backupManagerService.getAgentTimeoutParameters(), - "Timeout parameters cannot be null"); + mAgentTimeoutParameters = + Preconditions.checkNotNull( + backupManagerService.getAgentTimeoutParameters(), + "Timeout parameters cannot be null"); } public int preflightCheck() throws RemoteException { @@ -213,27 +232,13 @@ public class FullBackupEngine { try { pipes = ParcelFileDescriptor.createPipe(); - ApplicationInfo app = mPkg.applicationInfo; - final boolean isSharedStorage = - mPkg.packageName.equals(SHARED_BACKUP_AGENT_PACKAGE); - final boolean sendApk = mIncludeApks - && !isSharedStorage - && ((app.privateFlags & ApplicationInfo.PRIVATE_FLAG_FORWARD_LOCK) == 0) - && ((app.flags & ApplicationInfo.FLAG_SYSTEM) == 0 || - (app.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0); - - // TODO: http://b/22388012 - byte[] widgetBlob = AppWidgetBackupBridge.getWidgetState(mPkg.packageName, - UserHandle.USER_SYSTEM); - - FullBackupRunner runner = new FullBackupRunner(mPkg, mAgent, pipes[1], - mOpToken, sendApk, !isSharedStorage, widgetBlob); - pipes[1].close(); // the runner has dup'd it + FullBackupRunner runner = + new FullBackupRunner(mPkg, mAgent, pipes[1], mOpToken, mIncludeApks); + pipes[1].close(); // the runner has dup'd it pipes[1] = null; Thread t = new Thread(runner, "app-data-runner"); t.start(); - // Now pull data from the app and stuff it into the output FullBackupUtils.routeSocketDataToOutput(pipes[0], mOutput); if (!backupManagerService.waitUntilOperationComplete(mOpToken)) { @@ -288,84 +293,13 @@ public class FullBackupEngine { if (MORE_DEBUG) { Slog.d(TAG, "Binding to full backup agent : " + mPkg.packageName); } - mAgent = backupManagerService.bindToAgentSynchronous(mPkg.applicationInfo, - ApplicationThreadConstants.BACKUP_MODE_FULL); + mAgent = + backupManagerService.bindToAgentSynchronous( + mPkg.applicationInfo, ApplicationThreadConstants.BACKUP_MODE_FULL); } return mAgent != null; } - private void writeApkToBackup(PackageInfo pkg, FullBackupDataOutput output) { - // Forward-locked apps, system-bundled .apks, etc are filtered out before we get here - // TODO: handle backing up split APKs - final String appSourceDir = pkg.applicationInfo.getBaseCodePath(); - final String apkDir = new File(appSourceDir).getParent(); - FullBackup.backupToTar(pkg.packageName, FullBackup.APK_TREE_TOKEN, null, - apkDir, appSourceDir, output); - - // TODO: migrate this to SharedStorageBackup, since AID_SYSTEM - // doesn't have access to external storage. - - // Save associated .obb content if it exists and we did save the apk - // check for .obb and save those too - // TODO: http://b/22388012 - final UserEnvironment userEnv = new UserEnvironment(UserHandle.USER_SYSTEM); - final File obbDir = userEnv.buildExternalStorageAppObbDirs(pkg.packageName)[0]; - if (obbDir != null) { - if (MORE_DEBUG) { - Log.i(TAG, "obb dir: " + obbDir.getAbsolutePath()); - } - File[] obbFiles = obbDir.listFiles(); - if (obbFiles != null) { - final String obbDirName = obbDir.getAbsolutePath(); - for (File obb : obbFiles) { - FullBackup.backupToTar(pkg.packageName, FullBackup.OBB_TREE_TOKEN, null, - obbDirName, obb.getAbsolutePath(), output); - } - } - } - } - - // Widget metadata format. All header entries are strings ending in LF: - // - // Version 1 header: - // BACKUP_METADATA_VERSION, currently "1" - // package name - // - // File data (all integers are binary in network byte order) - // *N: 4 : integer token identifying which metadata blob - // 4 : integer size of this blob = N - // N : raw bytes of this metadata blob - // - // Currently understood blobs (always in network byte order): - // - // widgets : metadata token = 0x01FFED01 (BACKUP_WIDGET_METADATA_TOKEN) - // - // Unrecognized blobs are *ignored*, not errors. - private void writeMetadata(PackageInfo pkg, File destination, byte[] widgetData) - throws IOException { - StringBuilder b = new StringBuilder(512); - StringBuilderPrinter printer = new StringBuilderPrinter(b); - printer.println(Integer.toString(BACKUP_METADATA_VERSION)); - printer.println(pkg.packageName); - - FileOutputStream fout = new FileOutputStream(destination); - BufferedOutputStream bout = new BufferedOutputStream(fout); - DataOutputStream out = new DataOutputStream(bout); - bout.write(b.toString().getBytes()); // bypassing DataOutputStream - - if (widgetData != null && widgetData.length > 0) { - out.writeInt(BACKUP_WIDGET_METADATA_TOKEN); - out.writeInt(widgetData.length); - out.write(widgetData); - } - bout.flush(); - out.close(); - - // As with the manifest file, guarantee idempotence of the archive metadata - // for the widget block by using a fixed mtime on the transient file. - destination.setLastModified(0); - } - private void tearDown() { if (mPkg != null) { backupManagerService.tearDownAgentAndKill(mPkg.applicationInfo); diff --git a/services/backup/java/com/android/server/backup/utils/FullBackupUtils.java b/services/backup/java/com/android/server/backup/utils/FullBackupUtils.java index a3d56011272f..dbe3cd9225b5 100644 --- a/services/backup/java/com/android/server/backup/utils/FullBackupUtils.java +++ b/services/backup/java/com/android/server/backup/utils/FullBackupUtils.java @@ -16,23 +16,14 @@ package com.android.server.backup.utils; -import static com.android.server.backup.BackupManagerService.BACKUP_MANIFEST_VERSION; import static com.android.server.backup.BackupManagerService.TAG; -import android.content.pm.PackageInfo; -import android.content.pm.PackageManager; -import android.content.pm.Signature; -import android.content.pm.SigningInfo; -import android.os.Build; import android.os.ParcelFileDescriptor; import android.util.Slog; -import android.util.StringBuilderPrinter; import java.io.DataInputStream; import java.io.EOFException; -import java.io.File; import java.io.FileInputStream; -import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; @@ -68,67 +59,4 @@ public class FullBackupUtils { } } } - - /** - * Writes app manifest to the given manifest file. - * - * @param pkg - app package, which manifest to write. - * @param packageManager - {@link PackageManager} instance. - * @param manifestFile - target manifest file. - * @param withApk - whether include apk or not. - * @param withWidgets - whether to write widgets data. - * @throws IOException - in case of an error. - */ - // TODO: withWidgets is not used, decide whether it is needed. - public static void writeAppManifest(PackageInfo pkg, PackageManager packageManager, - File manifestFile, boolean withApk, boolean withWidgets) throws IOException { - // Manifest format. All data are strings ending in LF: - // BACKUP_MANIFEST_VERSION, currently 1 - // - // Version 1: - // package name - // package's versionCode - // platform versionCode - // getInstallerPackageName() for this package (maybe empty) - // boolean: "1" if archive includes .apk; any other string means not - // number of signatures == N - // N*: signature byte array in ascii format per Signature.toCharsString() - StringBuilder builder = new StringBuilder(4096); - StringBuilderPrinter printer = new StringBuilderPrinter(builder); - - printer.println(Integer.toString(BACKUP_MANIFEST_VERSION)); - printer.println(pkg.packageName); - printer.println(Long.toString(pkg.getLongVersionCode())); - printer.println(Integer.toString(Build.VERSION.SDK_INT)); - - String installerName = packageManager.getInstallerPackageName(pkg.packageName); - printer.println((installerName != null) ? installerName : ""); - - printer.println(withApk ? "1" : "0"); - - // write the signature block - SigningInfo signingInfo = pkg.signingInfo; - if (signingInfo == null) { - printer.println("0"); - } else { - // retrieve the newest sigs to write - // TODO (b/73988180) use entire signing history in case of rollbacks - Signature[] signatures = signingInfo.getApkContentsSigners(); - printer.println(Integer.toString(signatures.length)); - for (Signature sig : signatures) { - printer.println(sig.toCharsString()); - } - } - - FileOutputStream outstream = new FileOutputStream(manifestFile); - outstream.write(builder.toString().getBytes()); - outstream.close(); - - // We want the manifest block in the archive stream to be idempotent: - // each time we generate a backup stream for the app, we want the manifest - // block to be identical. The underlying tar mechanism sees it as a file, - // though, and will propagate its mtime, causing the tar header to vary. - // Avoid this problem by pinning the mtime to zero. - manifestFile.setLastModified(0); - } } diff --git a/services/robotests/Android.mk b/services/robotests/Android.mk index 3d7fdbdd7436..2691701f79af 100644 --- a/services/robotests/Android.mk +++ b/services/robotests/Android.mk @@ -63,7 +63,9 @@ LOCAL_SRC_FILES := \ $(call all-Iaidl-files-under, ../../core/java/android/app/backup) \ ../../core/java/android/content/pm/PackageInfo.java \ ../../core/java/android/app/IBackupAgent.aidl \ - ../../core/java/android/util/KeyValueSettingObserver.java + ../../core/java/android/util/KeyValueSettingObserver.java \ + ../../core/java/android/content/pm/PackageParser.java \ + ../../core/java/android/content/pm/SigningInfo.java LOCAL_AIDL_INCLUDES := \ $(call all-Iaidl-files-under, $(INTERNAL_BACKUP)) \ diff --git a/services/robotests/src/com/android/server/backup/fullbackup/AppMetadataBackupWriterTest.java b/services/robotests/src/com/android/server/backup/fullbackup/AppMetadataBackupWriterTest.java new file mode 100644 index 000000000000..112e1e385fed --- /dev/null +++ b/services/robotests/src/com/android/server/backup/fullbackup/AppMetadataBackupWriterTest.java @@ -0,0 +1,495 @@ +package com.android.server.backup.fullbackup; + +import static com.android.server.backup.BackupManagerService.BACKUP_MANIFEST_FILENAME; +import static com.android.server.backup.BackupManagerService.BACKUP_MANIFEST_VERSION; +import static com.android.server.backup.BackupManagerService.BACKUP_METADATA_FILENAME; +import static com.android.server.backup.BackupManagerService.BACKUP_METADATA_VERSION; +import static com.android.server.backup.BackupManagerService.BACKUP_WIDGET_METADATA_TOKEN; + +import static com.google.common.truth.Truth.assertThat; +import static org.robolectric.Shadows.shadowOf; +import static org.testng.Assert.expectThrows; + +import android.annotation.Nullable; +import android.app.Application; +import android.app.backup.BackupDataInput; +import android.app.backup.FullBackupDataOutput; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.content.pm.PackageParser.SigningDetails; +import android.content.pm.Signature; +import android.content.pm.SigningInfo; +import android.os.Build; +import android.os.Build.VERSION_CODES; +import android.os.Environment; +import android.os.ParcelFileDescriptor; +import android.os.UserHandle; + +import com.android.server.testing.FrameworkRobolectricTestRunner; +import com.android.server.testing.SystemLoaderClasses; +import com.android.server.testing.SystemLoaderPackages; +import com.android.server.testing.shadows.ShadowBackupDataInput; +import com.android.server.testing.shadows.ShadowBackupDataOutput; +import com.android.server.testing.shadows.ShadowFullBackup; +import java.io.ByteArrayOutputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.attribute.FileTime; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RuntimeEnvironment; +import org.robolectric.annotation.Config; +import org.robolectric.shadows.ShadowApplicationPackageManager; +import org.robolectric.shadows.ShadowEnvironment; + +@RunWith(FrameworkRobolectricTestRunner.class) +@Config( + manifest = Config.NONE, + sdk = 26, + shadows = { + ShadowBackupDataInput.class, + ShadowBackupDataOutput.class, + ShadowEnvironment.class, + ShadowFullBackup.class, + }) +@SystemLoaderPackages({"com.android.server.backup", "android.app.backup"}) +@SystemLoaderClasses({PackageInfo.class, SigningInfo.class}) +public class AppMetadataBackupWriterTest { + private static final String TEST_PACKAGE = "com.test.package"; + private static final String TEST_PACKAGE_INSTALLER = "com.test.package.installer"; + private static final Long TEST_PACKAGE_VERSION_CODE = 100L; + + private ShadowApplicationPackageManager mShadowPackageManager; + private File mFilesDir; + private File mBackupDataOutputFile; + private AppMetadataBackupWriter mBackupWriter; + + @Before + public void setUp() throws Exception { + Application application = RuntimeEnvironment.application; + + PackageManager packageManager = application.getPackageManager(); + mShadowPackageManager = (ShadowApplicationPackageManager) shadowOf(packageManager); + + mFilesDir = RuntimeEnvironment.application.getFilesDir(); + mBackupDataOutputFile = new File(mFilesDir, "output"); + mBackupDataOutputFile.createNewFile(); + ParcelFileDescriptor pfd = + ParcelFileDescriptor.open( + mBackupDataOutputFile, ParcelFileDescriptor.MODE_READ_WRITE); + FullBackupDataOutput output = + new FullBackupDataOutput(pfd, /* quota */ -1, /* transportFlags */ 0); + mBackupWriter = new AppMetadataBackupWriter(output, packageManager); + } + + @After + public void tearDown() throws Exception { + mBackupDataOutputFile.delete(); + } + + /** + * The manifest format is: + * + * <pre> + * BACKUP_MANIFEST_VERSION + * package name + * package version code + * platform version code + * installer package name (can be empty) + * boolean (1 if archive includes .apk, otherwise 0) + * # of signatures N + * N* (signature byte array in ascii format per Signature.toCharsString()) + * </pre> + */ + @Test + public void testBackupManifest_withoutApkOrSignatures_writesCorrectData() throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + File manifestFile = createFile(BACKUP_MANIFEST_FILENAME); + + mBackupWriter.backupManifest(packageInfo, manifestFile, mFilesDir, /* withApk */ false); + + byte[] manifestBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ false); + String[] manifest = new String(manifestBytes, StandardCharsets.UTF_8).split("\n"); + assertThat(manifest.length).isEqualTo(7); + assertThat(manifest[0]).isEqualTo(Integer.toString(BACKUP_MANIFEST_VERSION)); + assertThat(manifest[1]).isEqualTo(TEST_PACKAGE); + assertThat(manifest[2]).isEqualTo(Long.toString(TEST_PACKAGE_VERSION_CODE)); + assertThat(manifest[3]).isEqualTo(Integer.toString(Build.VERSION.SDK_INT)); + assertThat(manifest[4]).isEqualTo(TEST_PACKAGE_INSTALLER); + assertThat(manifest[5]).isEqualTo("0"); // withApk + assertThat(manifest[6]).isEqualTo("0"); // signatures + manifestFile.delete(); + } + + /** + * The manifest format is: + * + * <pre> + * BACKUP_MANIFEST_VERSION + * package name + * package version code + * platform version code + * installer package name (can be empty) + * boolean (1 if archive includes .apk, otherwise 0) + * # of signatures N + * N* (signature byte array in ascii format per Signature.toCharsString()) + * </pre> + */ + @Test + public void testBackupManifest_withApk_writesApk() throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + File manifestFile = createFile(BACKUP_MANIFEST_FILENAME); + + mBackupWriter.backupManifest(packageInfo, manifestFile, mFilesDir, /* withApk */ true); + + byte[] manifestBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ false); + String[] manifest = new String(manifestBytes, StandardCharsets.UTF_8).split("\n"); + assertThat(manifest.length).isEqualTo(7); + assertThat(manifest[5]).isEqualTo("1"); // withApk + manifestFile.delete(); + } + + /** + * The manifest format is: + * + * <pre> + * BACKUP_MANIFEST_VERSION + * package name + * package version code + * platform version code + * installer package name (can be empty) + * boolean (1 if archive includes .apk, otherwise 0) + * # of signatures N + * N* (signature byte array in ascii format per Signature.toCharsString()) + * </pre> + */ + @Test + public void testBackupManifest_withSignatures_writesCorrectSignatures() throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + packageInfo.signingInfo = + new SigningInfo( + new SigningDetails( + new Signature[] {new Signature("1234"), new Signature("5678")}, + SigningDetails.SignatureSchemeVersion.SIGNING_BLOCK_V3, + null, + null, + null)); + File manifestFile = createFile(BACKUP_MANIFEST_FILENAME); + + mBackupWriter.backupManifest(packageInfo, manifestFile, mFilesDir, /* withApk */ false); + + byte[] manifestBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ false); + String[] manifest = new String(manifestBytes, StandardCharsets.UTF_8).split("\n"); + assertThat(manifest.length).isEqualTo(9); + assertThat(manifest[6]).isEqualTo("2"); // # of signatures + assertThat(manifest[7]).isEqualTo("1234"); // first signature + assertThat(manifest[8]).isEqualTo("5678"); // second signature + manifestFile.delete(); + } + + /** + * The manifest format is: + * + * <pre> + * BACKUP_MANIFEST_VERSION + * package name + * package version code + * platform version code + * installer package name (can be empty) + * boolean (1 if archive includes .apk, otherwise 0) + * # of signatures N + * N* (signature byte array in ascii format per Signature.toCharsString()) + * </pre> + */ + @Config(sdk = VERSION_CODES.O) + @Test + public void testBackupManifest_whenApiO_writesCorrectApi() throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + File manifestFile = createFile(BACKUP_MANIFEST_FILENAME); + + mBackupWriter.backupManifest(packageInfo, manifestFile, mFilesDir, /* withApk */ false); + + byte[] manifestBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ false); + String[] manifest = new String(manifestBytes, StandardCharsets.UTF_8).split("\n"); + assertThat(manifest.length).isEqualTo(7); + assertThat(manifest[3]).isEqualTo(Integer.toString(VERSION_CODES.O)); // platform version + manifestFile.delete(); + } + + /** + * The manifest format is: + * + * <pre> + * BACKUP_MANIFEST_VERSION + * package name + * package version code + * platform version code + * installer package name (can be empty) + * boolean (1 if archive includes .apk, otherwise 0) + * # of signatures N + * N* (signature byte array in ascii format per Signature.toCharsString()) + * </pre> + */ + @Test + public void testBackupManifest_withoutInstallerPackage_writesEmptyInstaller() throws Exception { + PackageInfo packageInfo = createPackageInfo(TEST_PACKAGE, null, TEST_PACKAGE_VERSION_CODE); + File manifestFile = createFile(BACKUP_MANIFEST_FILENAME); + + mBackupWriter.backupManifest(packageInfo, manifestFile, mFilesDir, /* withApk */ false); + + byte[] manifestBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ false); + String[] manifest = new String(manifestBytes, StandardCharsets.UTF_8).split("\n"); + assertThat(manifest.length).isEqualTo(7); + assertThat(manifest[4]).isEqualTo(""); // installer package name + manifestFile.delete(); + } + + @Test + public void testBackupManifest_whenRunPreviouslyWithSameData_producesSameBytesOnSecondRun() + throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + File manifestFile = createFile(BACKUP_MANIFEST_FILENAME); + mBackupWriter.backupManifest(packageInfo, manifestFile, mFilesDir, /* withApk */ false); + byte[] firstRunBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ true); + // Simulate modifying the manifest file to ensure that file metadata does not change the + // backup bytes produced. + modifyFileMetadata(manifestFile); + + mBackupWriter.backupManifest(packageInfo, manifestFile, mFilesDir, /* withApk */ false); + + byte[] secondRunBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ true); + assertThat(firstRunBytes).isEqualTo(secondRunBytes); + manifestFile.delete(); + } + + /** + * The widget data format with metadata is: + * + * <pre> + * BACKUP_METADATA_VERSION + * package name + * 4 : Integer token identifying the widget data blob. + * 4 : Integer size of the widget data. + * N : Raw bytes of the widget data. + * </pre> + */ + @Test + public void testBackupWidget_writesCorrectData() throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + File metadataFile = createFile(BACKUP_METADATA_FILENAME); + byte[] widgetBytes = "widget".getBytes(); + + mBackupWriter.backupWidget(packageInfo, metadataFile, mFilesDir, widgetBytes); + + byte[] writtenBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ false); + String[] widgetData = new String(writtenBytes, StandardCharsets.UTF_8).split("\n"); + assertThat(widgetData.length).isEqualTo(3); + // Metadata header + assertThat(widgetData[0]).isEqualTo(Integer.toString(BACKUP_METADATA_VERSION)); + assertThat(widgetData[1]).isEqualTo(packageInfo.packageName); + // Widget data + ByteArrayOutputStream expectedBytes = new ByteArrayOutputStream(); + DataOutputStream stream = new DataOutputStream(expectedBytes); + stream.writeInt(BACKUP_WIDGET_METADATA_TOKEN); + stream.writeInt(widgetBytes.length); + stream.write(widgetBytes); + stream.flush(); + assertThat(widgetData[2]).isEqualTo(expectedBytes.toString()); + metadataFile.delete(); + } + + @Test + public void testBackupWidget_withNullWidgetData_throwsNullPointerException() throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + File metadataFile = createFile(BACKUP_METADATA_FILENAME); + + expectThrows( + NullPointerException.class, + () -> + mBackupWriter.backupWidget( + packageInfo, metadataFile, mFilesDir, /* widgetData */ null)); + + metadataFile.delete(); + } + + @Test + public void testBackupWidget_withEmptyWidgetData_throwsIllegalArgumentException() + throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + File metadataFile = createFile(BACKUP_METADATA_FILENAME); + + expectThrows( + IllegalArgumentException.class, + () -> + mBackupWriter.backupWidget( + packageInfo, metadataFile, mFilesDir, new byte[0])); + + metadataFile.delete(); + } + + @Test + public void testBackupWidget_whenRunPreviouslyWithSameData_producesSameBytesOnSecondRun() + throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + File metadataFile = createFile(BACKUP_METADATA_FILENAME); + byte[] widgetBytes = "widget".getBytes(); + mBackupWriter.backupWidget(packageInfo, metadataFile, mFilesDir, widgetBytes); + byte[] firstRunBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ true); + // Simulate modifying the metadata file to ensure that file metadata does not change the + // backup bytes produced. + modifyFileMetadata(metadataFile); + + mBackupWriter.backupWidget(packageInfo, metadataFile, mFilesDir, widgetBytes); + + byte[] secondRunBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ true); + assertThat(firstRunBytes).isEqualTo(secondRunBytes); + metadataFile.delete(); + } + + @Test + public void testBackupApk_writesCorrectBytesToOutput() throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + byte[] apkBytes = "apk".getBytes(); + File apkFile = createApkFileAndWrite(apkBytes); + packageInfo.applicationInfo = new ApplicationInfo(); + packageInfo.applicationInfo.sourceDir = apkFile.getPath(); + + mBackupWriter.backupApk(packageInfo); + + byte[] writtenBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ false); + assertThat(writtenBytes).isEqualTo(apkBytes); + apkFile.delete(); + } + + @Test + public void testBackupObb_withObbData_writesCorrectBytesToOutput() throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + File obbDir = createObbDirForPackage(packageInfo.packageName); + byte[] obbBytes = "obb".getBytes(); + File obbFile = createObbFileAndWrite(obbDir, obbBytes); + + mBackupWriter.backupObb(packageInfo); + + byte[] writtenBytes = getWrittenBytes(mBackupDataOutputFile, /* includeTarHeader */ false); + assertThat(writtenBytes).isEqualTo(obbBytes); + obbFile.delete(); + } + + @Test + public void testBackupObb_withNoObbData_doesNotWriteBytesToOutput() throws Exception { + PackageInfo packageInfo = + createPackageInfo(TEST_PACKAGE, TEST_PACKAGE_INSTALLER, TEST_PACKAGE_VERSION_CODE); + File obbDir = createObbDirForPackage(packageInfo.packageName); + // No obb file created. + + mBackupWriter.backupObb(packageInfo); + + assertThat(mBackupDataOutputFile.length()).isEqualTo(0); + } + + /** + * Creates a test package and registers it with the package manager. Also sets the installer + * package name if not {@code null}. + */ + private PackageInfo createPackageInfo( + String packageName, @Nullable String installerPackageName, long versionCode) { + PackageInfo packageInfo = new PackageInfo(); + packageInfo.packageName = packageName; + packageInfo.setLongVersionCode(versionCode); + mShadowPackageManager.addPackage(packageInfo); + if (installerPackageName != null) { + mShadowPackageManager.setInstallerPackageName(packageName, installerPackageName); + } + return packageInfo; + } + + /** + * Reads backup data written to the {@code file} by {@link ShadowBackupDataOutput}. Uses {@link + * ShadowBackupDataInput} to parse the data. Follows the format used by {@link + * ShadowFullBackup#backupToTar(String, String, String, String, String, FullBackupDataOutput)}. + * + * @param includeTarHeader If {@code true}, returns the TAR header and data bytes combined. + * Otherwise, only returns the data bytes. + */ + private byte[] getWrittenBytes(File file, boolean includeTarHeader) throws IOException { + BackupDataInput input = new BackupDataInput(new FileInputStream(file).getFD()); + input.readNextHeader(); + int dataSize = input.getDataSize(); + + byte[] bytes; + if (includeTarHeader) { + bytes = new byte[dataSize + 512]; + input.readEntityData(bytes, 0, dataSize + 512); + } else { + input.readEntityData(new byte[512], 0, 512); // skip TAR header + bytes = new byte[dataSize]; + input.readEntityData(bytes, 0, dataSize); + } + + return bytes; + } + + private File createFile(String fileName) throws IOException { + File file = new File(mFilesDir, fileName); + file.createNewFile(); + return file; + } + + /** + * Sets the last modified time of the {@code file} to the current time to edit the file's + * metadata. + */ + private void modifyFileMetadata(File file) throws IOException { + Files.setLastModifiedTime(file.toPath(), FileTime.fromMillis(System.currentTimeMillis())); + } + + private File createApkFileAndWrite(byte[] data) throws IOException { + File apkFile = new File(mFilesDir, "apk"); + apkFile.createNewFile(); + Files.write(apkFile.toPath(), data); + return apkFile; + } + + /** Creates an .obb file in the input directory. */ + private File createObbFileAndWrite(File obbDir, byte[] data) throws IOException { + File obbFile = new File(obbDir, "obb"); + obbFile.createNewFile(); + Files.write(obbFile.toPath(), data); + return obbFile; + } + + /** + * Creates a package specific obb data directory since the backup method checks for obb data + * there. See {@link Environment#buildExternalStorageAppObbDirs(String)}. + */ + private File createObbDirForPackage(String packageName) { + ShadowEnvironment.addExternalDir("test"); + Environment.UserEnvironment userEnv = + new Environment.UserEnvironment(UserHandle.USER_SYSTEM); + File obbDir = + new File( + userEnv.getExternalDirs()[0], + Environment.DIR_ANDROID + "/obb/" + packageName); + obbDir.mkdirs(); + return obbDir; + } +} diff --git a/services/robotests/src/com/android/server/testing/shadows/ShadowBackupDataOutput.java b/services/robotests/src/com/android/server/testing/shadows/ShadowBackupDataOutput.java index ca0400832345..5812c3c85a58 100644 --- a/services/robotests/src/com/android/server/testing/shadows/ShadowBackupDataOutput.java +++ b/services/robotests/src/com/android/server/testing/shadows/ShadowBackupDataOutput.java @@ -55,6 +55,11 @@ public class ShadowBackupDataOutput { return mTransportFlags; } + public ObjectOutputStream getOutputStream() { + ensureOutput(); + return mOutput; + } + @Implementation public int writeEntityHeader(String key, int dataSize) throws IOException { ensureOutput(); diff --git a/services/robotests/src/com/android/server/testing/shadows/ShadowFullBackup.java b/services/robotests/src/com/android/server/testing/shadows/ShadowFullBackup.java new file mode 100644 index 000000000000..3c913e317375 --- /dev/null +++ b/services/robotests/src/com/android/server/testing/shadows/ShadowFullBackup.java @@ -0,0 +1,70 @@ +package com.android.server.testing.shadows; + +import android.app.backup.BackupDataOutput; +import android.app.backup.FullBackup; +import android.app.backup.FullBackupDataOutput; + +import org.robolectric.annotation.Implementation; +import org.robolectric.annotation.Implements; +import org.robolectric.shadow.api.Shadow; + +import java.io.IOException; +import java.io.ObjectOutputStream; +import java.nio.ByteBuffer; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; + +/** + * Shadow for {@link FullBackup}. Used to emulate the native method {@link + * FullBackup#backupToTar(String, String, String, String, String, FullBackupDataOutput)}. Relies on + * the shadow {@link ShadowBackupDataOutput}, which must be included in tests that use this shadow. + */ +@Implements(FullBackup.class) +public class ShadowFullBackup { + /** + * Reads data from the specified file at {@code path} and writes it to the {@code output}. Does + * not match the native implementation, and only partially simulates TAR format. Used solely for + * passing backup data for testing purposes. + * + * <p>Note: Only handles the {@code path} denoting a file and not a directory like the real + * implementation. + */ + @Implementation + public static int backupToTar( + String packageName, + String domain, + String linkdomain, + String rootpath, + String path, + FullBackupDataOutput output) { + BackupDataOutput backupDataOutput = output.getData(); + try { + Path file = Paths.get(path); + byte[] data = Files.readAllBytes(file); + backupDataOutput.writeEntityHeader("key", data.length); + + // Partially simulate TAR header (not all fields included). We use a 512 byte block for + // the header to follow the TAR convention and to have a consistent size block to help + // with separating the header from the data. + ByteBuffer tarBlock = ByteBuffer.wrap(new byte[512]); + String tarPath = "apps/" + packageName + (domain == null ? "" : "/" + domain) + path; + tarBlock.put(tarPath.getBytes()); // file path + tarBlock.putInt(0x1ff); // file mode + tarBlock.putLong(Files.size(file)); // file size + tarBlock.putLong(Files.getLastModifiedTime(file).toMillis()); // last modified time + tarBlock.putInt(0); // file type + + // Write TAR header directly to the BackupDataOutput's output stream. + ShadowBackupDataOutput shadowBackupDataOutput = Shadow.extract(backupDataOutput); + ObjectOutputStream outputStream = shadowBackupDataOutput.getOutputStream(); + outputStream.write(tarBlock.array()); + outputStream.flush(); + + backupDataOutput.writeEntityData(data, data.length); + } catch (IOException e) { + throw new AssertionError(e); + } + return 0; + } +} |