mirror of https://github.com/topjohnwu/Magisk
304 lines
10 KiB
Java
304 lines
10 KiB
Java
package com.topjohnwu.magisk;
|
|
|
|
import android.content.ContentProvider;
|
|
import android.content.ContentValues;
|
|
import android.content.Context;
|
|
import android.content.pm.ProviderInfo;
|
|
import android.database.Cursor;
|
|
import android.database.MatrixCursor;
|
|
import android.net.Uri;
|
|
import android.os.Environment;
|
|
import android.os.ParcelFileDescriptor;
|
|
import android.provider.OpenableColumns;
|
|
import android.text.TextUtils;
|
|
import android.webkit.MimeTypeMap;
|
|
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
|
|
import io.michaelrocks.paranoid.Obfuscate;
|
|
|
|
/**
|
|
* Modified from androidx.core.content.FileProvider
|
|
*/
|
|
@Obfuscate
|
|
public class FileProvider extends ContentProvider {
|
|
private static final String[] COLUMNS = {OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE};
|
|
|
|
private static final File DEVICE_ROOT = new File("/");
|
|
|
|
private static final HashMap<String, PathStrategy> sCache = new HashMap<>();
|
|
|
|
private PathStrategy mStrategy;
|
|
|
|
@Override
|
|
public boolean onCreate() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void attachInfo(Context context, ProviderInfo info) {
|
|
super.attachInfo(context, info);
|
|
|
|
if (info.exported) {
|
|
throw new SecurityException("Provider must not be exported");
|
|
}
|
|
if (!info.grantUriPermissions) {
|
|
throw new SecurityException("Provider must grant uri permissions");
|
|
}
|
|
|
|
mStrategy = getPathStrategy(context, info.authority.split(";")[0]);
|
|
}
|
|
|
|
public static Uri getUriForFile(Context context, String authority, File file) {
|
|
final PathStrategy strategy = getPathStrategy(context, authority);
|
|
return strategy.getUriForFile(file);
|
|
}
|
|
|
|
@Override
|
|
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
|
|
final File file = mStrategy.getFileForUri(uri);
|
|
|
|
if (projection == null) {
|
|
projection = COLUMNS;
|
|
}
|
|
|
|
String[] cols = new String[projection.length];
|
|
Object[] values = new Object[projection.length];
|
|
int i = 0;
|
|
for (String col : projection) {
|
|
if (OpenableColumns.DISPLAY_NAME.equals(col)) {
|
|
cols[i] = OpenableColumns.DISPLAY_NAME;
|
|
values[i++] = file.getName();
|
|
} else if (OpenableColumns.SIZE.equals(col)) {
|
|
cols[i] = OpenableColumns.SIZE;
|
|
values[i++] = file.length();
|
|
}
|
|
}
|
|
|
|
cols = copyOf(cols, i);
|
|
values = copyOf(values, i);
|
|
|
|
final MatrixCursor cursor = new MatrixCursor(cols, 1);
|
|
cursor.addRow(values);
|
|
return cursor;
|
|
}
|
|
|
|
@Override
|
|
public String getType(Uri uri) {
|
|
final File file = mStrategy.getFileForUri(uri);
|
|
|
|
final int lastDot = file.getName().lastIndexOf('.');
|
|
if (lastDot >= 0) {
|
|
final String extension = file.getName().substring(lastDot + 1);
|
|
final String mime = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
|
|
if (mime != null) {
|
|
return mime;
|
|
}
|
|
}
|
|
|
|
return "application/octet-stream";
|
|
}
|
|
|
|
@Override
|
|
public Uri insert(Uri uri, ContentValues values) {
|
|
throw new UnsupportedOperationException("No external inserts");
|
|
}
|
|
|
|
@Override
|
|
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
|
|
throw new UnsupportedOperationException("No external updates");
|
|
}
|
|
|
|
@Override
|
|
public int delete(Uri uri, String selection, String[] selectionArgs) {
|
|
final File file = mStrategy.getFileForUri(uri);
|
|
return file.delete() ? 1 : 0;
|
|
}
|
|
|
|
@Override
|
|
public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
|
|
final File file = mStrategy.getFileForUri(uri);
|
|
final int fileMode = modeToMode(mode);
|
|
return ParcelFileDescriptor.open(file, fileMode);
|
|
}
|
|
|
|
private static PathStrategy getPathStrategy(Context context, String authority) {
|
|
PathStrategy strat;
|
|
synchronized (sCache) {
|
|
strat = sCache.get(authority);
|
|
if (strat == null) {
|
|
strat = createPathStrategy(context, authority);
|
|
sCache.put(authority, strat);
|
|
}
|
|
}
|
|
return strat;
|
|
}
|
|
|
|
private static PathStrategy createPathStrategy(Context context, String authority) {
|
|
final SimplePathStrategy strat = new SimplePathStrategy(authority);
|
|
|
|
strat.addRoot("root_files", buildPath(DEVICE_ROOT, "."));
|
|
strat.addRoot("internal_files", buildPath(context.getFilesDir(), "."));
|
|
strat.addRoot("cache_files", buildPath(context.getCacheDir(), "."));
|
|
strat.addRoot("external_files", buildPath(Environment.getExternalStorageDirectory(), "."));
|
|
|
|
File[] externalFilesDirs = context.getExternalFilesDirs(null);
|
|
if (externalFilesDirs.length > 0) {
|
|
strat.addRoot("external_file_files", buildPath(externalFilesDirs[0], "."));
|
|
}
|
|
File[] externalCacheDirs = context.getExternalCacheDirs();
|
|
if (externalCacheDirs.length > 0) {
|
|
strat.addRoot("external_cache_files", buildPath(externalCacheDirs[0], "."));
|
|
}
|
|
File[] externalMediaDirs = context.getExternalMediaDirs();
|
|
if (externalMediaDirs.length > 0) {
|
|
strat.addRoot("external_media_files", buildPath(externalMediaDirs[0], "."));
|
|
}
|
|
|
|
return strat;
|
|
}
|
|
|
|
interface PathStrategy {
|
|
Uri getUriForFile(File file);
|
|
|
|
File getFileForUri(Uri uri);
|
|
}
|
|
|
|
static class SimplePathStrategy implements PathStrategy {
|
|
private final String mAuthority;
|
|
private final HashMap<String, File> mRoots = new HashMap<>();
|
|
|
|
SimplePathStrategy(String authority) {
|
|
mAuthority = authority;
|
|
}
|
|
|
|
void addRoot(String name, File root) {
|
|
if (TextUtils.isEmpty(name)) {
|
|
throw new IllegalArgumentException("Name must not be empty");
|
|
}
|
|
|
|
try {
|
|
root = root.getCanonicalFile();
|
|
} catch (IOException e) {
|
|
throw new IllegalArgumentException(
|
|
"Failed to resolve canonical path for " + root, e);
|
|
}
|
|
|
|
mRoots.put(name, root);
|
|
}
|
|
|
|
@Override
|
|
public Uri getUriForFile(File file) {
|
|
String path;
|
|
try {
|
|
path = file.getCanonicalPath();
|
|
} catch (IOException e) {
|
|
throw new IllegalArgumentException("Failed to resolve canonical path for " + file);
|
|
}
|
|
|
|
Map.Entry<String, File> mostSpecific = null;
|
|
for (Map.Entry<String, File> root : mRoots.entrySet()) {
|
|
final String rootPath = root.getValue().getPath();
|
|
if (path.startsWith(rootPath) && (mostSpecific == null
|
|
|| rootPath.length() > mostSpecific.getValue().getPath().length())) {
|
|
mostSpecific = root;
|
|
}
|
|
}
|
|
|
|
if (mostSpecific == null) {
|
|
throw new IllegalArgumentException(
|
|
"Failed to find configured root that contains " + path);
|
|
}
|
|
|
|
final String rootPath = mostSpecific.getValue().getPath();
|
|
if (rootPath.endsWith("/")) {
|
|
path = path.substring(rootPath.length());
|
|
} else {
|
|
path = path.substring(rootPath.length() + 1);
|
|
}
|
|
|
|
path = Uri.encode(mostSpecific.getKey()) + '/' + Uri.encode(path, "/");
|
|
return new Uri.Builder().scheme("content")
|
|
.authority(mAuthority).encodedPath(path).build();
|
|
}
|
|
|
|
@Override
|
|
public File getFileForUri(Uri uri) {
|
|
String path = uri.getEncodedPath();
|
|
|
|
final int splitIndex = path.indexOf('/', 1);
|
|
final String tag = Uri.decode(path.substring(1, splitIndex));
|
|
path = Uri.decode(path.substring(splitIndex + 1));
|
|
|
|
final File root = mRoots.get(tag);
|
|
if (root == null) {
|
|
throw new IllegalArgumentException("Unable to find configured root for " + uri);
|
|
}
|
|
|
|
File file = new File(root, path);
|
|
try {
|
|
file = file.getCanonicalFile();
|
|
} catch (IOException e) {
|
|
throw new IllegalArgumentException("Failed to resolve canonical path for " + file);
|
|
}
|
|
|
|
if (!file.getPath().startsWith(root.getPath())) {
|
|
throw new SecurityException("Resolved path jumped beyond configured root");
|
|
}
|
|
|
|
return file;
|
|
}
|
|
}
|
|
|
|
private static int modeToMode(String mode) {
|
|
int modeBits;
|
|
if ("r".equals(mode)) {
|
|
modeBits = ParcelFileDescriptor.MODE_READ_ONLY;
|
|
} else if ("w".equals(mode) || "wt".equals(mode)) {
|
|
modeBits = ParcelFileDescriptor.MODE_WRITE_ONLY
|
|
| ParcelFileDescriptor.MODE_CREATE
|
|
| ParcelFileDescriptor.MODE_TRUNCATE;
|
|
} else if ("wa".equals(mode)) {
|
|
modeBits = ParcelFileDescriptor.MODE_WRITE_ONLY
|
|
| ParcelFileDescriptor.MODE_CREATE
|
|
| ParcelFileDescriptor.MODE_APPEND;
|
|
} else if ("rw".equals(mode)) {
|
|
modeBits = ParcelFileDescriptor.MODE_READ_WRITE
|
|
| ParcelFileDescriptor.MODE_CREATE;
|
|
} else if ("rwt".equals(mode)) {
|
|
modeBits = ParcelFileDescriptor.MODE_READ_WRITE
|
|
| ParcelFileDescriptor.MODE_CREATE
|
|
| ParcelFileDescriptor.MODE_TRUNCATE;
|
|
} else {
|
|
throw new IllegalArgumentException("Invalid mode: " + mode);
|
|
}
|
|
return modeBits;
|
|
}
|
|
|
|
private static File buildPath(File base, String... segments) {
|
|
File cur = base;
|
|
for (String segment : segments) {
|
|
if (segment != null) {
|
|
cur = new File(cur, segment);
|
|
}
|
|
}
|
|
return cur;
|
|
}
|
|
|
|
private static String[] copyOf(String[] original, int newLength) {
|
|
final String[] result = new String[newLength];
|
|
System.arraycopy(original, 0, result, 0, newLength);
|
|
return result;
|
|
}
|
|
|
|
private static Object[] copyOf(Object[] original, int newLength) {
|
|
final Object[] result = new Object[newLength];
|
|
System.arraycopy(original, 0, result, 0, newLength);
|
|
return result;
|
|
}
|
|
}
|