Cache cleanup methods

Chainfire · Chainfire · commit 2f0431964f00 · 2018-12-19T15:19:23.000+01:00
diff --git a/librootjava/README.md b/librootjava/README.md
@@ -263,6 +263,18 @@ non-root code.
 (See the [example project](../librootjava_example) for a more elaborate
 example for this entire process)
 
+#### Cleanup
+
+To execute our code as root, files may need to be created in our app's
+cache directory. While the library does its best to clean up after
+itself, there are situations (such as a reboot mid-process) where some
+files may not automatically be removed.
+
+It is recommended to periodically call ```RootJava.cleanupCache()```
+to remove these leftover files. This method will cleanup all of our
+files in the cache directory that predate the current boot. As I/O is
+performed, this method should not be called from the main UI thread.
+
 #### Debugging
 
 Debugging is supported since version 1.1.0, but disabled by default.
diff --git a/librootjava/src/main/java/eu/chainfire/librootjava/RootJava.java b/librootjava/src/main/java/eu/chainfire/librootjava/RootJava.java
@@ -21,8 +21,10 @@
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.os.Build;
+import android.os.SystemClock;
 
 import java.io.File;
+import java.io.FilenameFilter;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
@@ -247,6 +249,69 @@ public static List<String> getLaunchScript(Context context, Class<?> clazz, Stri
         return script;
     }
 
+    /** Prefixes of filename to remove from the app's cache directory */
+    public static final String[] CLEANUP_CACHE_PREFIXES = new String[] { ".app_process32_", ".app_process64_" };
+
+    /**
+     * Clean up leftover files from our cache directory.<br>
+     * <br>
+     * In ideal circumstances no files should be left dangling, but in practise it happens sooner
+     * or later anyway. Periodically (once per app launch or per boot) calling this method is
+     * advised.<br>
+     * <br>
+     * This method should be called from a background thread, as it performs disk i/o.<br>
+     * <br>
+     * It is difficult to determine which of these files may actually be in use, especially in
+     * daemon mode. We try to determine device boot time, and wipe everything from before that
+     * time. For safety we explicitly keep files using our current UUID.
+     *
+     * @param context Context to retrieve cache directory from
+     */
+    public static void cleanupCache(Context context) {
+        cleanupCache(context, CLEANUP_CACHE_PREFIXES);
+    }
+
+    /**
+     * Clean up leftover files from our cache directory.<br>
+     * <br>
+     * This version is for internal use, see {@link #cleanupCache(Context)} instead.
+     *
+     * @param context Context to retrieve cache directory from
+     * @param prefixes List of prefixes to scrub
+     */
+    public static void cleanupCache(Context context, final String[] prefixes) {
+        try {
+            File cacheDir = context.getCacheDir();
+            if (cacheDir.exists()) {
+                // determine time of last boot
+                long boot = System.currentTimeMillis() - SystemClock.elapsedRealtime();
+
+                // find our files
+                for (File file : cacheDir.listFiles(new FilenameFilter() {
+                    @Override
+                    public boolean accept(File dir, String name) {
+                        boolean accept = false;
+                        for (String prefix : prefixes) {
+                            // just in case: don't return files that contain our current uuid
+                            if (name.startsWith(prefix) && !name.endsWith(AppProcess.UUID)) {
+                                accept = true;
+                                break;
+                            }
+                        }
+                        return accept;
+                    }
+                })) {
+                    if (file.lastModified() < boot) {
+                        //noinspection ResultOfMethodCallIgnored
+                        file.delete();
+                    }
+                }
+            }
+        } catch (Exception e) {
+            Logger.ex(e);
+        }
+    }
+
     // ------------------------ calls for root ------------------------
 
     /**
diff --git a/librootjava_example/src/main/java/eu/chainfire/librootjava_example/MainActivity.java b/librootjava_example/src/main/java/eu/chainfire/librootjava_example/MainActivity.java
@@ -34,6 +34,7 @@
 
 import eu.chainfire.librootjava.Logger;
 import eu.chainfire.librootjava.RootIPCReceiver;
+import eu.chainfire.librootjava.RootJava;
 import eu.chainfire.librootjava_example.root.IIPC;
 import eu.chainfire.librootjava_example.root.IPingCallback;
 import eu.chainfire.librootjava_example.root.PassedData;
@@ -80,6 +81,15 @@ it inside a method (in this example), the context passed to its constructor is a
            wrapper. We need to update it to a proper context, so we may actually receive the Binder
            object from our root code. */
         ipcReceiver.setContext(this);
+
+        /* Cleanup leftover files from our cache directory. This is not exactly an elegant way to
+           do it, but it illustrates that this should be done off of the main UI thread. */
+        (new Thread(new Runnable() {
+            @Override
+            public void run() {
+                RootJava.cleanupCache(MainActivity.this);
+            }
+        })).start();
     }
 
     @Override
diff --git a/librootjavadaemon/README.md b/librootjavadaemon/README.md
@@ -126,6 +126,16 @@ non-root end when called through IPC.
 See the [example project](../librootjavadaemon_example) for further
 details.
 
+#### Cleanup
+
+As with running code as root in normal (non-daemon) mode, files may need
+to be created in our app's cache directory. The chances of leftover
+files are actually higher in daemon mode, and the number of files is
+higher too.
+
+To clean up, call ```RootDaemon.cleanupCache()``` instead of
+```RootJava.cleanupCache()```. It is *not* needed to call both.
+
 ## abiFilters
 
 This library includes native code for all platforms the NDK supports.
diff --git a/librootjavadaemon/src/main/java/eu/chainfire/librootjavadaemon/RootDaemon.java b/librootjavadaemon/src/main/java/eu/chainfire/librootjavadaemon/RootDaemon.java
@@ -117,6 +117,23 @@ public static List<String> getLaunchScript(Context context, Class<?> clazz, Stri
         return patchLaunchScript(context, RootJava.getLaunchScript(context, clazz, app_process, relocate_path, params, niceName));
     }
 
+    /** Prefixes of filename to remove from the app's cache directory */
+    public static final String[] CLEANUP_CACHE_PREFIXES = new String[] { ".daemonize_" };
+
+    /**
+     * Clean up leftover files from our cache directory.<br>
+     * <br>
+     * Call this method instead of (not in addition to) RootJava#cleanupCache(Context).
+     *
+     * @param context Context to retrieve cache directory from
+     */
+    public static void cleanupCache(Context context) {
+        String[] prefixes = new String[RootJava.CLEANUP_CACHE_PREFIXES.length + CLEANUP_CACHE_PREFIXES.length];
+        System.arraycopy(RootJava.CLEANUP_CACHE_PREFIXES, 0, prefixes, 0, RootJava.CLEANUP_CACHE_PREFIXES.length);
+        System.arraycopy(CLEANUP_CACHE_PREFIXES, 0, prefixes, RootJava.CLEANUP_CACHE_PREFIXES.length, CLEANUP_CACHE_PREFIXES.length);
+        RootJava.cleanupCache(context, prefixes);
+    }
+
     // ------------------------ calls for root ------------------------
 
     /** Registered interfaces */
@@ -183,7 +200,7 @@ public static void daemonize(String packageName, int code, boolean surviveFramew
                 } else {
                     Logger.dp(LOG_PREFIX, "Service already running, requesting re-broadcast and aborting");
                     ipc.broadcast();
-                    System.exit(0);
+                    exit();
                 }
             }
 
@@ -327,6 +344,16 @@ not clean up our relocated app_process binary after executing (which might preve
             if (app_process.exists() && !app_process.getAbsolutePath().startsWith("/system/bin/")) {
                 //noinspection ResultOfMethodCallIgnored
                 app_process.delete();
+
+                // See if we can also find a copy of the daemonize binary
+                String daemonize_path = app_process.getAbsolutePath();
+                daemonize_path = daemonize_path.replace(".app_process32_", ".daemonize_");
+                daemonize_path = daemonize_path.replace(".app_process64_", ".daemonize_");
+                File daemonize = new File(daemonize_path);
+                if (daemonize.exists()) {
+                    //noinspection ResultOfMethodCallIgnored
+                    daemonize.delete();
+                }
             }
         } catch (IOException e) {
             // should never actually happen
diff --git a/librootjavadaemon_example/src/main/java/eu/chainfire/librootjavadaemon_example/MainActivity.java b/librootjavadaemon_example/src/main/java/eu/chainfire/librootjavadaemon_example/MainActivity.java
@@ -28,6 +28,7 @@
 
 import eu.chainfire.librootjava.Logger;
 import eu.chainfire.librootjava.RootIPCReceiver;
+import eu.chainfire.librootjavadaemon.RootDaemon;
 import eu.chainfire.librootjavadaemon_example.root.IIPC;
 import eu.chainfire.librootjavadaemon_example.root.RootMain;
 import eu.chainfire.libsuperuser.Debug;
@@ -70,6 +71,12 @@ protected void onCreate(Bundle savedInstanceState) {
         textView.setHorizontallyScrolling(true);
         textView.setMovementMethod(new ScrollingMovementMethod());
         ipcReceiver.setContext(this);
+        (new Thread(new Runnable() {
+            @Override
+            public void run() {
+                RootDaemon.cleanupCache(MainActivity.this);
+            }
+        })).start();
     }
 
     @Override
