Remove defunct secure FS work (35ab3ad6) · Commits · e / os / android_frameworks_base

cmds/installd/commands.c

+22 −93

Original line number	Diff line number	Diff line
		@@ -17,7 +17,7 @@
		#include "installd.h"
		#include <diskusage/dirsize.h>

		int install(const char *pkgname, int encrypted_fs_flag, uid_t uid, gid_t gid)
		int install(const char *pkgname, uid_t uid, gid_t gid)
		{
		char pkgdir[PKG_PATH_MAX];
		char libdir[PKG_PATH_MAX];
		@@ -27,17 +27,10 @@ int install(const char *pkgname, int encrypted_fs_flag, uid_t uid, gid_t gid)
		return -1;
		}

		if (encrypted_fs_flag == USE_UNENCRYPTED_FS) {
		if (create_pkg_path(pkgdir, PKG_DIR_PREFIX, pkgname, PKG_DIR_POSTFIX))
		return -1;
		if (create_pkg_path(libdir, PKG_LIB_PREFIX, pkgname, PKG_LIB_POSTFIX))
		return -1;
		} else {
		if (create_pkg_path(pkgdir, PKG_SEC_DIR_PREFIX, pkgname, PKG_DIR_POSTFIX))
		return -1;
		if (create_pkg_path(libdir, PKG_SEC_LIB_PREFIX, pkgname, PKG_LIB_POSTFIX))
		return -1;
		}

		if (mkdir(pkgdir, 0751) < 0) {
		LOGE("cannot create dir '%s': %s\n", pkgdir, strerror(errno));
		@@ -62,38 +55,26 @@ int install(const char *pkgname, int encrypted_fs_flag, uid_t uid, gid_t gid)
		return 0;
		}

		int uninstall(const char *pkgname, int encrypted_fs_flag)
		int uninstall(const char *pkgname)
		{
		char pkgdir[PKG_PATH_MAX];

		if (encrypted_fs_flag == USE_UNENCRYPTED_FS) {
		if (create_pkg_path(pkgdir, PKG_DIR_PREFIX, pkgname, PKG_DIR_POSTFIX))
		return -1;
		} else {
		if (create_pkg_path(pkgdir, PKG_SEC_DIR_PREFIX, pkgname, PKG_DIR_POSTFIX))
		return -1;
		}

		/* delete contents AND directory, no exceptions */
		return delete_dir_contents(pkgdir, 1, 0);
		}

		int renamepkg(const char oldpkgname, const char newpkgname, int encrypted_fs_flag)
		int renamepkg(const char oldpkgname, const char newpkgname)
		{
		char oldpkgdir[PKG_PATH_MAX];
		char newpkgdir[PKG_PATH_MAX];

		if (encrypted_fs_flag == USE_UNENCRYPTED_FS) {
		if (create_pkg_path(oldpkgdir, PKG_DIR_PREFIX, oldpkgname, PKG_DIR_POSTFIX))
		return -1;
		if (create_pkg_path(newpkgdir, PKG_DIR_PREFIX, newpkgname, PKG_DIR_POSTFIX))
		return -1;
		} else {
		if (create_pkg_path(oldpkgdir, PKG_SEC_DIR_PREFIX, oldpkgname, PKG_DIR_POSTFIX))
		return -1;
		if (create_pkg_path(newpkgdir, PKG_SEC_DIR_PREFIX, newpkgname, PKG_DIR_POSTFIX))
		return -1;
		}

		if (rename(oldpkgdir, newpkgdir) < 0) {
		LOGE("cannot rename dir '%s' to '%s': %s\n", oldpkgdir, newpkgdir, strerror(errno));
		@@ -102,41 +83,28 @@ int renamepkg(const char oldpkgname, const char newpkgname, int encrypted_fs_f
		return 0;
		}

		int delete_user_data(const char *pkgname, int encrypted_fs_flag)
		int delete_user_data(const char *pkgname)
		{
		char pkgdir[PKG_PATH_MAX];

		if (encrypted_fs_flag == USE_UNENCRYPTED_FS) {
		if (create_pkg_path(pkgdir, PKG_DIR_PREFIX, pkgname, PKG_DIR_POSTFIX))
		return -1;
		} else {
		if (create_pkg_path(pkgdir, PKG_SEC_DIR_PREFIX, pkgname, PKG_DIR_POSTFIX))
		return -1;
		}

		/* delete contents, excluding "lib", but not the directory itself */
		return delete_dir_contents(pkgdir, 0, "lib");
		}

		int delete_cache(const char *pkgname, int encrypted_fs_flag)
		int delete_cache(const char *pkgname)
		{
		char cachedir[PKG_PATH_MAX];

		if (encrypted_fs_flag == USE_UNENCRYPTED_FS) {
		if (create_pkg_path(cachedir, CACHE_DIR_PREFIX, pkgname, CACHE_DIR_POSTFIX))
		return -1;
		} else {
		if (create_pkg_path(cachedir, CACHE_SEC_DIR_PREFIX, pkgname, CACHE_DIR_POSTFIX))
		return -1;
		}

		/* delete contents, not the directory, no exceptions */
		return delete_dir_contents(cachedir, 0, 0);
		}

		/* TODO(oam): depending on use case (ecryptfs or dmcrypt)
		* change implementation
		*/
		static int64_t disk_free()
		{
		struct statfs sfs;
		@@ -169,39 +137,6 @@ int free_cache(int64_t free_size)
		LOGI("free_cache(%" PRId64 ") avail %" PRId64 "\n", free_size, avail);
		if (avail >= free_size) return 0;

		/* First try encrypted dir */
		d = opendir(PKG_SEC_DIR_PREFIX);
		if (d == NULL) {
		LOGE("cannot open %s: %s\n", PKG_SEC_DIR_PREFIX, strerror(errno));
		} else {
		dfd = dirfd(d);

		while ((de = readdir(d))) {
		if (de->d_type != DT_DIR) continue;
		name = de->d_name;

		/* always skip "." and ".." */
		if (name[0] == '.') {
		if (name[1] == 0) continue;
		if ((name[1] == '.') && (name[2] == 0)) continue;
		}

		subfd = openat(dfd, name, O_RDONLY \| O_DIRECTORY);
		if (subfd < 0) continue;

		delete_dir_contents_fd(subfd, "cache");
		close(subfd);

		avail = disk_free();
		if (avail >= free_size) {
		closedir(d);
		return 0;
		}
		}
		closedir(d);
		}

		/* Next try unencrypted dir... */
		d = opendir(PKG_DIR_PREFIX);
		if (d == NULL) {
		LOGE("cannot open %s: %s\n", PKG_DIR_PREFIX, strerror(errno));
		@@ -330,7 +265,7 @@ int protect(char *pkgname, gid_t gid)

		int get_size(const char pkgname, const char apkpath,
		const char *fwdlock_apkpath,
		int64_t _codesize, int64_t _datasize, int64_t *_cachesize, int encrypted_fs_flag)
		int64_t _codesize, int64_t _datasize, int64_t *_cachesize)
		{
		DIR *d;
		int dfd;
		@@ -365,15 +300,9 @@ int get_size(const char pkgname, const char apkpath,
		}
		}

		if (encrypted_fs_flag == 0) {
		if (create_pkg_path(path, PKG_DIR_PREFIX, pkgname, PKG_DIR_POSTFIX)) {
		goto done;
		}
		} else {
		if (create_pkg_path(path, PKG_SEC_DIR_PREFIX, pkgname, PKG_DIR_POSTFIX)) {
		goto done;
		}
		}

		d = opendir(path);
		if (d == NULL) {

cmds/installd/installd.c

+12 −12

Original line number	Diff line number	Diff line
		@@ -29,7 +29,7 @@ static int do_ping(char **arg, char reply[REPLY_MAX])

		static int do_install(char **arg, char reply[REPLY_MAX])
		{
		return install(arg[0], atoi(arg[1]), atoi(arg[2]), atoi(arg[3])); /* pkgname, uid, gid */
		return install(arg[0], atoi(arg[1]), atoi(arg[2])); /* pkgname, uid, gid */
		}

		static int do_dexopt(char **arg, char reply[REPLY_MAX])
		@@ -50,12 +50,12 @@ static int do_rm_dex(char **arg, char reply[REPLY_MAX])

		static int do_remove(char **arg, char reply[REPLY_MAX])
		{
		return uninstall(arg[0], atoi(arg[1])); /* pkgname */
		return uninstall(arg[0]); /* pkgname */
		}

		static int do_rename(char **arg, char reply[REPLY_MAX])
		{
		return renamepkg(arg[0], arg[1], atoi(arg[2])); /* oldpkgname, newpkgname */
		return renamepkg(arg[0], arg[1]); /* oldpkgname, newpkgname */
		}

		static int do_free_cache(char *arg, char reply[REPLY_MAX]) / TODO int:free_size */
		@@ -65,7 +65,7 @@ static int do_free_cache(char *arg, char reply[REPLY_MAX]) / TODO int:free_siz

		static int do_rm_cache(char **arg, char reply[REPLY_MAX])
		{
		return delete_cache(arg[0], atoi(arg[1])); /* pkgname */
		return delete_cache(arg[0]); /* pkgname */
		}

		static int do_protect(char **arg, char reply[REPLY_MAX])
		@@ -81,7 +81,7 @@ static int do_get_size(char **arg, char reply[REPLY_MAX])
		int res = 0;

		/* pkgdir, apkpath */
		res = get_size(arg[0], arg[1], arg[2], &codesize, &datasize, &cachesize, atoi(arg[3]));
		res = get_size(arg[0], arg[1], arg[2], &codesize, &datasize, &cachesize);

		/*
		* Each int64_t can take up 22 characters printed out. Make sure it
		@@ -93,7 +93,7 @@ static int do_get_size(char **arg, char reply[REPLY_MAX])

		static int do_rm_user_data(char **arg, char reply[REPLY_MAX])
		{
		return delete_user_data(arg[0], atoi(arg[1])); /* pkgname */
		return delete_user_data(arg[0]); /* pkgname */
		}

		static int do_movefiles(char **arg, char reply[REPLY_MAX])
		@@ -119,17 +119,17 @@ struct cmdinfo {

		struct cmdinfo cmds[] = {
		{ "ping", 0, do_ping },
		{ "install", 4, do_install },
		{ "install", 3, do_install },
		{ "dexopt", 3, do_dexopt },
		{ "movedex", 2, do_move_dex },
		{ "rmdex", 1, do_rm_dex },
		{ "remove", 2, do_remove },
		{ "rename", 3, do_rename },
		{ "remove", 1, do_remove },
		{ "rename", 2, do_rename },
		{ "freecache", 1, do_free_cache },
		{ "rmcache", 2, do_rm_cache },
		{ "rmcache", 1, do_rm_cache },
		{ "protect", 2, do_protect },
		{ "getsize", 4, do_get_size },
		{ "rmuserdata", 2, do_rm_user_data },
		{ "getsize", 3, do_get_size },
		{ "rmuserdata", 1, do_rm_user_data },
		{ "movefiles", 0, do_movefiles },
		{ "linklib", 2, do_linklib },
		{ "unlinklib", 1, do_unlinklib },

cmds/installd/installd.h

+6 −13

Original line number	Diff line number	Diff line
		@@ -50,23 +50,16 @@
		/* elements combined with a valid package name to form paths */

		#define PKG_DIR_PREFIX "/data/data/"
		#define PKG_SEC_DIR_PREFIX "/data/secure/data/"
		#define PKG_DIR_POSTFIX ""

		#define PKG_LIB_PREFIX "/data/data/"
		#define PKG_SEC_LIB_PREFIX "/data/secure/data/"
		#define PKG_LIB_POSTFIX "/lib"

		#define CACHE_DIR_PREFIX "/data/data/"
		#define CACHE_SEC_DIR_PREFIX "/data/secure/data/"
		#define CACHE_DIR_POSTFIX "/cache"

		#define APK_DIR_PREFIX "/data/app/"

		/* Encrypted File SYstems constants */
		#define USE_ENCRYPTED_FS 1
		#define USE_UNENCRYPTED_FS 0

		/* other handy constants */

		#define PROTECTED_DIR_PREFIX "/data/app-private/"
		@@ -98,16 +91,16 @@ int delete_dir_contents_fd(int dfd, const char *name);

		/* commands.c */

		int install(const char *pkgname, int encrypted_fs_flag, uid_t uid, gid_t gid);
		int uninstall(const char *pkgname, int encrypted_fs_flag);
		int renamepkg(const char oldpkgname, const char newpkgname, int encrypted_fs_flag);
		int delete_user_data(const char *pkgname, int encrypted_fs_flag);
		int delete_cache(const char *pkgname, int encrypted_fs_flag);
		int install(const char *pkgname, uid_t uid, gid_t gid);
		int uninstall(const char *pkgname);
		int renamepkg(const char oldpkgname, const char newpkgname);
		int delete_user_data(const char *pkgname);
		int delete_cache(const char *pkgname);
		int move_dex(const char src, const char dst);
		int rm_dex(const char *path);
		int protect(char *pkgname, gid_t gid);
		int get_size(const char pkgname, const char apkpath, const char *fwdlock_apkpath,
		int64_t codesize, int64_t datasize, int64_t *cachesize, int encrypted_fs_flag);
		int64_t codesize, int64_t datasize, int64_t *cachesize);
		int free_cache(int64_t free_size);
		int dexopt(const char *apk_path, uid_t uid, int is_public);
		int movefiles();

services/java/com/android/server/Installer.java

+7 −43

Original line number	Diff line number	Diff line
		@@ -166,17 +166,11 @@ class Installer {
		}
		}

		public int install(String name, boolean useEncryptedFilesystem, int uid, int gid) {
		public int install(String name, int uid, int gid) {
		StringBuilder builder = new StringBuilder("install");
		builder.append(' ');
		builder.append(name);
		builder.append(' ');
		if (useEncryptedFilesystem) {
		builder.append('1');
		} else {
		builder.append('0');
		}
		builder.append(' ');
		builder.append(uid);
		builder.append(' ');
		builder.append(gid);
		@@ -209,57 +203,33 @@ class Installer {
		return execute(builder.toString());
		}

		public int remove(String name, boolean useEncryptedFilesystem) {
		public int remove(String name) {
		StringBuilder builder = new StringBuilder("remove");
		builder.append(' ');
		builder.append(name);
		builder.append(' ');
		if (useEncryptedFilesystem) {
		builder.append('1');
		} else {
		builder.append('0');
		}
		return execute(builder.toString());
		}

		public int rename(String oldname, String newname, boolean useEncryptedFilesystem) {
		public int rename(String oldname, String newname) {
		StringBuilder builder = new StringBuilder("rename");
		builder.append(' ');
		builder.append(oldname);
		builder.append(' ');
		builder.append(newname);
		builder.append(' ');
		if (useEncryptedFilesystem) {
		builder.append('1');
		} else {
		builder.append('0');
		}
		return execute(builder.toString());
		}

		public int deleteCacheFiles(String name, boolean useEncryptedFilesystem) {
		public int deleteCacheFiles(String name) {
		StringBuilder builder = new StringBuilder("rmcache");
		builder.append(' ');
		builder.append(name);
		builder.append(' ');
		if (useEncryptedFilesystem) {
		builder.append('1');
		} else {
		builder.append('0');
		}
		return execute(builder.toString());
		}

		public int clearUserData(String name, boolean useEncryptedFilesystem) {
		public int clearUserData(String name) {
		StringBuilder builder = new StringBuilder("rmuserdata");
		builder.append(' ');
		builder.append(name);
		builder.append(' ');
		if (useEncryptedFilesystem) {
		builder.append('1');
		} else {
		builder.append('0');
		}
		return execute(builder.toString());
		}

		@@ -292,8 +262,8 @@ class Installer {
		return execute(builder.toString());
		}

		public int getSizeInfo(String pkgName, String apkPath,
		String fwdLockApkPath, PackageStats pStats, boolean useEncryptedFilesystem) {
		public int getSizeInfo(String pkgName, String apkPath, String fwdLockApkPath,
		PackageStats pStats) {
		StringBuilder builder = new StringBuilder("getsize");
		builder.append(' ');
		builder.append(pkgName);
		@@ -301,12 +271,6 @@ class Installer {
		builder.append(apkPath);
		builder.append(' ');
		builder.append(fwdLockApkPath != null ? fwdLockApkPath : "!");
		builder.append(' ');
		if (useEncryptedFilesystem) {
		builder.append('1');
		} else {
		builder.append('0');
		}

		String s = transaction(builder.toString());
		String res[] = s.split(" ");

services/java/com/android/server/PackageManagerService.java

+10 −31

Original line number	Diff line number	Diff line
		@@ -216,10 +216,6 @@ class PackageManagerService extends IPackageManager.Stub {
		// This is where all application persistent data goes.
		final File mAppDataDir;

		// If Encrypted File System feature is enabled, all application persistent data
		// should go here instead.
		final File mSecureAppDataDir;

		// This is the object monitoring the framework dir.
		final FileObserver mFrameworkInstallObserver;

		@@ -785,7 +781,6 @@ class PackageManagerService extends IPackageManager.Stub {

		File dataDir = Environment.getDataDirectory();
		mAppDataDir = new File(dataDir, "data");
		mSecureAppDataDir = new File(dataDir, "secure/data");
		mDrmAppPrivateInstallDir = new File(dataDir, "app-private");

		if (mInstaller == null) {
		@@ -795,7 +790,6 @@ class PackageManagerService extends IPackageManager.Stub {
		File miscDir = new File(dataDir, "misc");
		miscDir.mkdirs();
		mAppDataDir.mkdirs();
		mSecureAppDataDir.mkdirs();
		mDrmAppPrivateInstallDir.mkdirs();
		}

		@@ -964,9 +958,7 @@ class PackageManagerService extends IPackageManager.Stub {
		+ " no longer exists; wiping its data";
		reportSettingsProblem(Log.WARN, msg);
		if (mInstaller != null) {
		// XXX how to set useEncryptedFSDir for packages that
		// are not encrypted?
		mInstaller.remove(ps.name, true);
		mInstaller.remove(ps.name);
		}
		}
		}
		@@ -1050,8 +1042,7 @@ class PackageManagerService extends IPackageManager.Stub {
		void cleanupInstallFailedPackage(PackageSetting ps) {
		Slog.i(TAG, "Cleaning up incompletely installed app: " + ps.name);
		if (mInstaller != null) {
		boolean useSecureFS = false;
		int retCode = mInstaller.remove(ps.name, useSecureFS);
		int retCode = mInstaller.remove(ps.name);
		if (retCode < 0) {
		Slog.w(TAG, "Couldn't remove app data directory for package: "
		+ ps.name + ", retcode=" + retCode);
		@@ -2796,13 +2787,7 @@ class PackageManagerService extends IPackageManager.Stub {
		}

		private File getDataPathForPackage(PackageParser.Package pkg) {
		boolean useEncryptedFSDir = false;
		File dataPath;
		if (useEncryptedFSDir) {
		dataPath = new File(mSecureAppDataDir, pkg.packageName);
		} else {
		dataPath = new File(mAppDataDir, pkg.packageName);
		}
		final File dataPath = new File(mAppDataDir, pkg.packageName);
		return dataPath;
		}

		@@ -3132,7 +3117,6 @@ class PackageManagerService extends IPackageManager.Stub {
		pkg.applicationInfo.dataDir = dataPath.getPath();
		} else {
		// This is a normal package, need to make its data directory.
		boolean useEncryptedFSDir = false;
		dataPath = getDataPathForPackage(pkg);

		boolean uidError = false;
		@@ -3149,7 +3133,7 @@ class PackageManagerService extends IPackageManager.Stub {
		// If this is a system app, we can at least delete its
		// current data so the application will still work.
		if (mInstaller != null) {
		int ret = mInstaller.remove(pkgName, useEncryptedFSDir);
		int ret = mInstaller.remove(pkgName);
		if (ret >= 0) {
		// Old data gone!
		String msg = "System package " + pkg.packageName
		@@ -3160,7 +3144,7 @@ class PackageManagerService extends IPackageManager.Stub {
		recovered = true;

		// And now re-install the app.
		ret = mInstaller.install(pkgName, useEncryptedFSDir, pkg.applicationInfo.uid,
		ret = mInstaller.install(pkgName, pkg.applicationInfo.uid,
		pkg.applicationInfo.uid);
		if (ret == -1) {
		// Ack should not happen!
		@@ -3201,7 +3185,7 @@ class PackageManagerService extends IPackageManager.Stub {
		Log.v(TAG, "Want this data dir: " + dataPath);
		//invoke installer to do the actual installation
		if (mInstaller != null) {
		int ret = mInstaller.install(pkgName, useEncryptedFSDir, pkg.applicationInfo.uid,
		int ret = mInstaller.install(pkgName, pkg.applicationInfo.uid,
		pkg.applicationInfo.uid);
		if(ret < 0) {
		// Error from installer
		@@ -6293,9 +6277,8 @@ class PackageManagerService extends IPackageManager.Stub {
		deletedPs = mSettings.mPackages.get(packageName);
		}
		if ((flags&PackageManager.DONT_DELETE_DATA) == 0) {
		boolean useEncryptedFSDir = false;
		if (mInstaller != null) {
		int retCode = mInstaller.remove(packageName, useEncryptedFSDir);
		int retCode = mInstaller.remove(packageName);
		if (retCode < 0) {
		Slog.w(TAG, "Couldn't remove app data or cache directory for package: "
		+ packageName + ", retcode=" + retCode);
		@@ -6535,7 +6518,6 @@ class PackageManagerService extends IPackageManager.Stub {
		p = ps.pkg;
		}
		}
		boolean useEncryptedFSDir = false;

		if (!dataOnly) {
		//need to check this only for fully installed applications
		@@ -6550,7 +6532,7 @@ class PackageManagerService extends IPackageManager.Stub {
		}
		}
		if (mInstaller != null) {
		int retCode = mInstaller.clearUserData(packageName, useEncryptedFSDir);
		int retCode = mInstaller.clearUserData(packageName);
		if (retCode < 0) {
		Slog.w(TAG, "Couldn't remove cache files for package: "
		+ packageName);
		@@ -6601,9 +6583,8 @@ class PackageManagerService extends IPackageManager.Stub {
		Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
		return false;
		}
		boolean useEncryptedFSDir = false;
		if (mInstaller != null) {
		int retCode = mInstaller.deleteCacheFiles(packageName, useEncryptedFSDir);
		int retCode = mInstaller.deleteCacheFiles(packageName);
		if (retCode < 0) {
		Slog.w(TAG, "Couldn't remove cache files for package: "
		+ packageName);
		@@ -6663,10 +6644,8 @@ class PackageManagerService extends IPackageManager.Stub {
		}
		publicSrcDir = isForwardLocked(p) ? applicationInfo.publicSourceDir : null;
		}
		boolean useEncryptedFSDir = false;
		if (mInstaller != null) {
		int res = mInstaller.getSizeInfo(packageName, p.mPath,
		publicSrcDir, pStats, useEncryptedFSDir);
		int res = mInstaller.getSizeInfo(packageName, p.mPath, publicSrcDir, pStats);
		if (res < 0) {
		return false;
		} else {