feat(root): refactor root access

app/build.gradle.kts

@@ -28,6 +28,7 @@ dependencies {
     implementation(libs.guava)
     implementation(libs.jbcrypt)
     implementation(libs.kotlinx.serialization.core)
+    implementation(libs.libsuperuser)
     implementation(libs.lingala.zip4j)
     implementation(libs.localbroadcastmanager)
     implementation(libs.navigation3.runtime)

app/src/main/java/com/nutomic/syncthingandroid/receiver/BootReceiver.java

@@ -9,6 +9,8 @@
 import com.nutomic.syncthingandroid.service.AppPrefs;
 import com.nutomic.syncthingandroid.service.Constants;
 import com.nutomic.syncthingandroid.service.SyncthingService;
+import com.nutomic.syncthingandroid.root.RootAccess;
+import com.nutomic.syncthingandroid.util.Util;
 
 import java.lang.SecurityException;
 
@@ -28,6 +30,16 @@ public void onReceive(Context context, Intent intent) {
             return;
         }
 
+        if (packageReplaced) {
+            if (AppPrefs.getUseRoot(context) && RootAccess.isRootAvailableBlocking()) {
+                /**
+                 * In Root mode, there will be a SyncthingNative process left running after app update.
+                 */
+                Log.d(TAG, "ACTION_MY_PACKAGE_REPLACED: Killing leftover SyncthingNative instance if present ...");
+                Util.killProcess(Constants.FILENAME_SYNCTHING_BINARY, true);
+            }
+        }
+
         // Check if we should (re)start now.
         if (!AppPrefs.getStartServiceOnBoot(context)) {
             return;

app/src/main/java/com/nutomic/syncthingandroid/root/RootAccess.java

@@ -0,0 +1,13 @@
+package com.nutomic.syncthingandroid.root;
+
+import eu.chainfire.libsuperuser.Shell;
+
+public final class RootAccess {
+
+    private RootAccess() {
+    }
+
+    public static boolean isRootAvailableBlocking() {
+        return Shell.SU.available();
+    }
+}

app/src/main/java/com/nutomic/syncthingandroid/service/AppPrefs.java

@@ -34,4 +34,9 @@ public static final boolean getStartServiceOnBoot(Context context) {
         SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
         return sp.getBoolean(Constants.PREF_START_SERVICE_ON_BOOT, false);
     }
+
+    public static final boolean getUseRoot(Context context) {
+        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
+        return sp.getBoolean(Constants.PREF_USE_ROOT, false);
+    }
 }

app/src/main/java/com/nutomic/syncthingandroid/service/Constants.java

@@ -50,6 +50,7 @@ private PowerSource() { }
     // Preferences - Behaviour
     public static final String PREF_START_SERVICE_ON_BOOT       = "always_run_in_background";
     public static final String PREF_BROADCAST_SERVICE_CONTROL   = "broadcast_service_control";
+    public static final String PREF_USE_ROOT                    = "use_root";
     public static final String PREF_ALLOW_OVERWRITE_FILES       = "allow_overwrite_files";
 
     // Preferences - Syncthing Options

app/src/main/java/com/nutomic/syncthingandroid/service/RestApi.java

@@ -613,7 +613,7 @@ public void sendConfig() {
     public void shutdown() {
         hasShutdown = true;
         executorService.shutdownNow();
-        Util.killProcess("find");
+        Util.killProcess("find", AppPrefs.getUseRoot(mContext));
         new PostRequest(mContext, mUrl, PostRequest.URI_SYSTEM_SHUTDOWN, mApiKey,
                 null, null, null);
     }
@@ -1252,7 +1252,7 @@ public void setRemoteCompletionInfo(final String deviceId,
                 // Check for ".sync-conflict-YYYYMMDD-HHMMSS-DEVICEI*" files.
                 mLocalCompletion.setDiscoveredConflictFiles(
                         folderId,
-                        Util.getSyncConflictFiles(folder.path)
+                        Util.getSyncConflictFiles(folder.path, AppPrefs.getUseRoot(mContext))
                 );
             }
 

app/src/main/java/com/nutomic/syncthingandroid/service/SyncthingRunnable.java

@@ -17,10 +17,12 @@
 import com.google.common.io.Files;
 import com.nutomic.syncthingandroid.R;
 import com.nutomic.syncthingandroid.SyncthingApp;
+import com.nutomic.syncthingandroid.root.RootAccess;
 import com.nutomic.syncthingandroid.util.FileUtils;
 import com.nutomic.syncthingandroid.util.Util;
 
 import java.io.BufferedReader;
+import java.io.DataOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
@@ -59,6 +61,7 @@ public class SyncthingRunnable implements Runnable {
     private final File mSyncthingBinary;
     private String[] mCommand;
     private final File mSyncthingLogFile;
+    private final boolean mUseRoot;
 
     @Inject
     SharedPreferences mPreferences;
@@ -88,6 +91,7 @@ public SyncthingRunnable(Context context, Command command) {
         mSyncthingLogFile = Constants.getSyncthingLogFile(mContext);
 
         // Get preferences relevant to starting syncthing core.
+        mUseRoot = mPreferences.getBoolean(Constants.PREF_USE_ROOT, false) && RootAccess.isRootAvailableBlocking();
         switch (command) {
             case deviceid:
                 mCommand = new String[]{mSyncthingBinary.getPath(), "device-id"};
@@ -436,9 +440,30 @@ private Process setupAndLaunch(HashMap<String, String> env) throws IOException,
                 throw new ExecutableNotFoundException(mCommand[0]);
             }
         }
-        ProcessBuilder pb = new ProcessBuilder(mCommand);
-        pb.environment().putAll(env);
-        return pb.start();
+
+        if (mUseRoot) {
+            ProcessBuilder pb = new ProcessBuilder("su");
+            Process process = pb.start();
+            // The su binary prohibits the inheritance of environment variables.
+            // Even with --preserve-environment the environment gets messed up.
+            // We therefore start a root shell, and set all the environment variables manually.
+            DataOutputStream suOut = new DataOutputStream(process.getOutputStream());
+            for (Map.Entry<String, String> entry : env.entrySet()) {
+                suOut.writeBytes(String.format("export %s=\"%s\"\n", entry.getKey(), entry.getValue()));
+            }
+            suOut.flush();
+            // Exec will replace the su process image by Syncthing as execlp in C does.
+            // Without using exec, the process will drop to the root shell as soon as Syncthing terminates like a normal shell does.
+            // If we did not use exec, we would wait infinitely for the process to terminate (ret = process.waitFor(); in run()).
+            // With exec the whole process terminates when Syncthing exits.
+            suOut.writeBytes("exec " + TextUtils.join(" ", mCommand) + "\n");
+            suOut.flush();
+            return process;
+        } else {
+            ProcessBuilder pb = new ProcessBuilder(mCommand);
+            pb.environment().putAll(env);
+            return pb.start();
+        }
     }
 
     public class ExecutableNotFoundException extends Exception {

app/src/main/java/com/nutomic/syncthingandroid/service/SyncthingService.java

@@ -584,7 +584,7 @@ private void launchStartupTask(SyncthingRunnable.Command srCommand) {
          * Check if an old syncthing instance is still running.
          * This happens after an in-place app upgrade. If so, end it.
          */
-        Util.killProcess(Constants.FILENAME_SYNCTHING_BINARY);
+        Util.killProcess(Constants.FILENAME_SYNCTHING_BINARY, AppPrefs.getUseRoot(this));
 
         // Start the syncthing binary in a separate thread.
         Thread.UncaughtExceptionHandler syncthingRunnableThreadExceptionHandler = new Thread.UncaughtExceptionHandler() {
@@ -712,7 +712,7 @@ private void shutdown(State newState) {
         }
 
         if (mSyncthingRunnable != null) {
-            Util.killProcess(Constants.FILENAME_SYNCTHING_BINARY);
+            Util.killProcess(Constants.FILENAME_SYNCTHING_BINARY, AppPrefs.getUseRoot(this));
             if (mSyncthingRunnableThread != null) {
                 LogV("Waiting for mSyncthingRunnableThread to finish after killProcess(Syncthing) ...");
                 try {
@@ -1383,7 +1383,6 @@ private boolean importConfigSharedPrefs(final File file) {
                         case "pref_current_language":
                         case "restartOnWakeup":
                         case "wakelock_while_binary_running":
-                        case "use_root":
                         case "important_news_shown_version":
                             LogV("importConfig: Ignoring deprecated pref \"" + prefKey + "\".");
                             break;

app/src/main/java/com/nutomic/syncthingandroid/settings/SettingsBehaviorScreen.kt

@@ -1,11 +1,21 @@
 package com.nutomic.syncthingandroid.settings
 
+import android.content.Intent
+import android.widget.Toast
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.navigation3.runtime.EntryProviderScope
 import com.nutomic.syncthingandroid.R
+import com.nutomic.syncthingandroid.root.RootAccess
 import com.nutomic.syncthingandroid.service.Constants
+import com.nutomic.syncthingandroid.service.SyncthingService
+import com.nutomic.syncthingandroid.util.LocalActivityScope
+import com.nutomic.syncthingandroid.util.Util
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import me.zhanghai.compose.preference.SwitchPreference
 import me.zhanghai.compose.preference.rememberPreferenceState
 
@@ -19,10 +29,48 @@ fun EntryProviderScope<SettingsRoute>.settingsBehaviorEntry() {
 
 @Composable
 fun SettingsBehaviorScreen() {
+    val context = LocalContext.current
+    val scope = LocalActivityScope.current
 
     val autoStart = rememberPreferenceState(Constants.PREF_START_SERVICE_ON_BOOT, false)
     val broadcast = rememberPreferenceState(Constants.PREF_BROADCAST_SERVICE_CONTROL, false)
     val overwrite = rememberPreferenceState(Constants.PREF_ALLOW_OVERWRITE_FILES, false)
+    val useRoot = rememberPreferenceState(Constants.PREF_USE_ROOT, false)
+
+    val restartSt = {
+        val intent = Intent(context, SyncthingService::class.java).apply {
+            action = SyncthingService.ACTION_RESTART
+        }
+        context.startService(intent)
+    }
+
+    val toggleRoot = { enabled: Boolean ->
+        scope.launch(Dispatchers.IO) {
+            if (enabled) {
+                if (RootAccess.isRootAvailableBlocking()) {
+                    withContext(Dispatchers.Main) {
+                        useRoot.value = true
+                    }
+                    // restart after enabling root
+                    restartSt()
+                } else {
+                    withContext(Dispatchers.Main) {
+                        Toast.makeText(
+                            context,
+                            R.string.toast_root_denied,
+                            Toast.LENGTH_LONG
+                        ).show()
+                    }
+                }
+            } else {
+                Util.fixAppDataPermissions(context)
+                withContext(Dispatchers.Main) {
+                    useRoot.value = false
+                }
+                restartSt()
+            }
+        }
+    }
 
     SettingsScaffold(
         title = stringResource(R.string.category_behaviour),
@@ -48,5 +96,15 @@ fun SettingsBehaviorScreen() {
                 state = overwrite,
             )
         }
+        item {
+            SwitchPreference(
+                title = { Text(stringResource(R.string.use_root_title)) },
+                summary = { Text(stringResource(R.string.use_root_summary)) },
+                value = useRoot.value,
+                onValueChange = {
+                    toggleRoot(it)
+                },
+            )
+        }
     }
 }

app/src/main/java/com/nutomic/syncthingandroid/util/ConfigXml.java

@@ -225,7 +225,7 @@ private String getLocalDeviceIDandStoreToPref() throws SyncthingRunnable.Executa
     }
 
     private void parseConfig() {
-        if (!mConfigFile.canRead()) {
+        if (!mConfigFile.canRead() && !Util.fixAppDataPermissions(mContext)) {
             Log.w(TAG, "Failed to open config file '" + mConfigFile + "'");
             throw new OpenConfigException();
         }
@@ -1261,7 +1261,7 @@ private boolean addSyncthingCameraFolder() {
      * Writes updated mConfig back to file.
      */
     public void saveChanges() {
-        if (!mConfigFile.canWrite()) {
+        if (!mConfigFile.canWrite() && !Util.fixAppDataPermissions(mContext)) {
             Log.w(TAG, "Failed to save updated config. Cannot change the owner of the config file.");
             return;
         }