Add convenience script to deploy coverage agent through adb

Author: ammaraskar

.gitignore

@@ -13,3 +13,4 @@
 .externalNativeBuild
 .cxx
 local.properties
+deployer/build

.idea/.name

@@ -27,5 +27,21 @@ gradlew.bat assemble
 ### Linux
 
 ```bash
-ANDROID_SDK_ROOT=/path/to/sdk gradlew.bat assemble
+ANDROID_SDK_ROOT=/path/to/sdk ./gradlew assemble
 ```
+
+
+## Pushing to Device
+
+The `deployer` folder in this project contains a convenience application to push the CoverageAgent
+to an Android device using `adb`.
+
+In order to instrument apps that don't have the `android:debuggable` attribute set, you must ensure
+you have root access on the device and `ro.debuggable` is set.
+
+```bash
+gradle run --args="your.android.package.name"
+```
+
+It will locate the app's data directory and push the coverage agent into the
+`DATA_DIR/code_cache/startup_agents` directory.

.idea/compiler.xml

@@ -0,0 +1,31 @@
+plugins {
+    id 'org.jetbrains.kotlin.jvm' version '1.5.32'
+    id 'application'
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.1'
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+application {
+    mainClass.set('com.ammaraskar.coverageagent.DeployerKt')
+}
+
+tasks.named('test') {
+    useJUnitPlatform()
+}
+
+// Depend on runtime_cpp so that the jvmti agent is built when we are invoked.
+tasks.named('run') {
+    dependsOn(':runtime_cpp:externalNativeBuildDebug')
+    workingDir = rootProject.projectDir
+}

.idea/gradle.xml

@@ -0,0 +1,108 @@
+package com.ammaraskar.coverageagent
+
+import java.io.File
+import java.util.*
+import java.util.concurrent.TimeUnit
+
+class Deployer {
+
+    private val soName = "libcoverage_instrumenting_agent.so"
+
+    fun deploy(packageName: String, adbDeviceName: String?) {
+        println("Instrumenting app $packageName with coverage agent.")
+        // Get the architecture of the device.
+        val architecture = getDeviceArchitecture(adbDeviceName)
+        println("[i] device architecture=${architecture}")
+
+
+        val library = File("runtime_cpp/build/intermediates/merged_native_libs/debug/out/lib/${architecture}/${soName}")
+        println("[i] Using library: ${library.absolutePath}")
+
+        runAdbCommand(adbDeviceName, "push", library.absolutePath, "/data/local/tmp/")
+        println("[+] Pushed library to /data/local/tmp/${soName}")
+
+        println("[i] Trying to use run-as to copy to startup_agents")
+        val copyDestinationWithRunAs = tryToCopyLibraryWithRunAs(packageName, adbDeviceName)
+        if (copyDestinationWithRunAs.isPresent) {
+            println("[+] Library copied to ${copyDestinationWithRunAs.get()}")
+            return
+        }
+
+        println("[x] run-as failed, using su permissions instead.")
+
+        // Use dumpsys package to figure out the data directory and user id of the application.
+        val dumpSysOutput = runAdbCommand(adbDeviceName, "shell", "dumpsys", "package", packageName)
+
+        var dataDir: String? = null
+        var userId: String? = null
+        for (line in dumpSysOutput.lines()) {
+            if (line.contains("dataDir=")) dataDir = line.split("=")[1].trim()
+            if (line.contains("userId=")) userId = line.split("=")[1].trim()
+        }
+
+        if (dataDir == null || userId == null) {
+            println("[!] UNABLE to find app's dataDir or userId. (dataDir=$dataDir, userId=$userId)")
+            return
+        }
+        println("[i] Grabbed app's dataDir=$dataDir and userId=$userId")
+
+        runAdbCommand(adbDeviceName,
+                "shell", "su", userId, "\"mkdir -p $dataDir/code_cache/startup_agents/\"")
+        runAdbCommand(adbDeviceName,
+                "shell", "su", userId, "\"cp /data/local/tmp/${soName} $dataDir/code_cache/startup_agents/\"")
+        println("[+] Library copied to $dataDir/code_cache/startup_agents/")
+    }
+
+    private fun getDeviceArchitecture(adbDeviceName: String?): String {
+        return runAdbCommand(adbDeviceName, "shell", "getprop", "ro.product.cpu.abi").trim()
+    }
+
+    private fun tryToCopyLibraryWithRunAs(packageName: String, adbDeviceName: String?): Optional<String> {
+        return try {
+            runAdbCommand(adbDeviceName, "shell", "run-as", packageName, "mkdir -p code_cache/startup_agents/")
+            runAdbCommand(adbDeviceName, "shell", "run-as", packageName, "cp /data/local/tmp/${soName} code_cache/startup_agents/")
+
+            Optional.of(runAdbCommand(adbDeviceName, "shell", "run-as", packageName, "pwd"))
+        } catch (e: RuntimeException) {
+            Optional.empty()
+        }
+    }
+
+    private fun runAdbCommand(adbDeviceName: String?, vararg command: String): String {
+        val adbCommand = mutableListOf("adb")
+        if (adbDeviceName != null) {
+            adbCommand.add("-s")
+            adbCommand.add(adbDeviceName)
+        }
+        adbCommand.addAll(command)
+        return runCommandAndGetOutput(adbCommand)
+    }
+
+    private fun runCommandAndGetOutput(command: List<String>): String {
+        println("> ${command.joinToString(" ")}")
+        val proc = ProcessBuilder(command)
+                .redirectError(ProcessBuilder.Redirect.PIPE)
+                .redirectOutput(ProcessBuilder.Redirect.PIPE)
+                .start()
+
+        val output = proc.inputStream.bufferedReader().readText()
+        proc.waitFor(20, TimeUnit.SECONDS)
+
+        if (proc.exitValue() != 0) {
+            print(output)
+            print(proc.errorStream.bufferedReader().readText())
+            throw RuntimeException("${command.joinToString(" ")} returned exit code ${proc.exitValue()}")
+        }
+        return output
+    }
+
+}
+
+fun main(args: Array<String>) {
+    if (args.isEmpty()) {
+        println("Usage: Deployer <android-package-name> [adb-device-name]")
+        return
+    }
+
+    Deployer().deploy(packageName = args[0], adbDeviceName = args.getOrNull(1))
+}

.idea/misc.xml

@@ -1,3 +1,4 @@
 rootProject.name = "CoverageAgent"
 include ':runtime_java'
 include ':runtime_cpp'
+include ':deployer'