Move ADB code to adb/

app/src/adb/adb.c

@@ -0,0 +1,471 @@
+#include "adb.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "adb_parser.h"
+#include "util/file.h"
+#include "util/log.h"
+#include "util/process_intr.h"
+#include "util/str.h"
+
+static const char *adb_command;
+
+static inline const char *
+get_adb_command(void) {
+    if (!adb_command) {
+        adb_command = getenv("ADB");
+        if (!adb_command)
+            adb_command = "adb";
+    }
+    return adb_command;
+}
+
+// serialize argv to string "[arg1], [arg2], [arg3]"
+static size_t
+argv_to_string(const char *const *argv, char *buf, size_t bufsize) {
+    size_t idx = 0;
+    bool first = true;
+    while (*argv) {
+        const char *arg = *argv;
+        size_t len = strlen(arg);
+        // count space for "[], ...\0"
+        if (idx + len + 8 >= bufsize) {
+            // not enough space, truncate
+            assert(idx < bufsize - 4);
+            memcpy(&buf[idx], "...", 3);
+            idx += 3;
+            break;
+        }
+        if (first) {
+            first = false;
+        } else {
+            buf[idx++] = ',';
+            buf[idx++] = ' ';
+        }
+        buf[idx++] = '[';
+        memcpy(&buf[idx], arg, len);
+        idx += len;
+        buf[idx++] = ']';
+        argv++;
+    }
+    assert(idx < bufsize);
+    buf[idx] = '\0';
+    return idx;
+}
+
+static void
+show_adb_installation_msg() {
+#ifndef __WINDOWS__
+    static const struct {
+        const char *binary;
+        const char *command;
+    } pkg_managers[] = {
+        {"apt", "apt install adb"},
+        {"apt-get", "apt-get install adb"},
+        {"brew", "brew cask install android-platform-tools"},
+        {"dnf", "dnf install android-tools"},
+        {"emerge", "emerge dev-util/android-tools"},
+        {"pacman", "pacman -S android-tools"},
+    };
+    for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
+        if (sc_file_executable_exists(pkg_managers[i].binary)) {
+            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
+            return;
+        }
+    }
+#endif
+
+    LOGI("You may download and install 'adb' from "
+         "https://developer.android.com/studio/releases/platform-tools");
+}
+
+static void
+show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
+#define MAX_COMMAND_STRING_LEN 1024
+    char *buf = malloc(MAX_COMMAND_STRING_LEN);
+    if (!buf) {
+        LOG_OOM();
+        LOGE("Failed to execute");
+        return;
+    }
+
+    switch (err) {
+        case SC_PROCESS_ERROR_GENERIC:
+            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
+            LOGE("Failed to execute: %s", buf);
+            break;
+        case SC_PROCESS_ERROR_MISSING_BINARY:
+            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
+            LOGE("Command not found: %s", buf);
+            LOGE("(make 'adb' accessible from your PATH or define its full"
+                 "path in the ADB environment variable)");
+            show_adb_installation_msg();
+            break;
+        case SC_PROCESS_SUCCESS:
+            // do nothing
+            break;
+    }
+
+    free(buf);
+}
+
+static bool
+process_check_success_internal(sc_pid pid, const char *name, bool close,
+                               unsigned flags) {
+    bool log_errors = !(flags & SC_ADB_NO_LOGERR);
+
+    if (pid == SC_PROCESS_NONE) {
+        if (log_errors) {
+            LOGE("Could not execute \"%s\"", name);
+        }
+        return false;
+    }
+    sc_exit_code exit_code = sc_process_wait(pid, close);
+    if (exit_code) {
+        if (log_errors) {
+            if (exit_code != SC_EXIT_CODE_NONE) {
+                LOGE("\"%s\" returned with value %" SC_PRIexitcode, name,
+                     exit_code);
+            } else {
+                LOGE("\"%s\" exited unexpectedly", name);
+            }
+        }
+        return false;
+    }
+    return true;
+}
+
+static bool
+process_check_success_intr(struct sc_intr *intr, sc_pid pid, const char *name,
+                           unsigned flags) {
+    if (!sc_intr_set_process(intr, pid)) {
+        // Already interrupted
+        return false;
+    }
+
+    // Always pass close=false, interrupting would be racy otherwise
+    bool ret = process_check_success_internal(pid, name, false, flags);
+
+    sc_intr_set_process(intr, SC_PROCESS_NONE);
+
+    // Close separately
+    sc_process_close(pid);
+
+    return ret;
+}
+
+static const char **
+adb_create_argv(const char *serial, const char *const adb_cmd[], size_t len) {
+    const char **argv = malloc((len + 4) * sizeof(*argv));
+    if (!argv) {
+        LOG_OOM();
+        return NULL;
+    }
+
+    argv[0] = get_adb_command();
+    int i;
+    if (serial) {
+        argv[1] = "-s";
+        argv[2] = serial;
+        i = 3;
+    } else {
+        i = 1;
+    }
+
+    memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
+    argv[len + i] = NULL;
+    return argv;
+}
+
+static sc_pid
+adb_execute_p(const char *serial, const char *const adb_cmd[], size_t len,
+              unsigned flags, sc_pipe *pout) {
+    const char **argv = adb_create_argv(serial, adb_cmd, len);
+    if (!argv) {
+        return SC_PROCESS_NONE;
+    }
+
+    unsigned process_flags = 0;
+    if (flags & SC_ADB_NO_STDOUT) {
+        process_flags |= SC_PROCESS_NO_STDOUT;
+    }
+    if (flags & SC_ADB_NO_STDERR) {
+        process_flags |= SC_PROCESS_NO_STDERR;
+    }
+
+    sc_pid pid;
+    enum sc_process_result r =
+        sc_process_execute_p(argv, &pid, process_flags, NULL, pout, NULL);
+    if (r != SC_PROCESS_SUCCESS) {
+        // If the execution itself failed (not the command exit code), log the
+        // error in all cases
+        show_adb_err_msg(r, argv);
+        pid = SC_PROCESS_NONE;
+    }
+
+    free(argv);
+    return pid;
+}
+
+sc_pid
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
+            unsigned flags) {
+    return adb_execute_p(serial, adb_cmd, len, flags, NULL);
+}
+
+bool
+adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
+            const char *device_socket_name, unsigned flags) {
+    char local[4 + 5 + 1]; // tcp:PORT
+    char remote[108 + 14 + 1]; // localabstract:NAME
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
+    const char *const adb_cmd[] = {"forward", local, remote};
+
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
+    return process_check_success_intr(intr, pid, "adb forward", flags);
+}
+
+bool
+adb_forward_remove(struct sc_intr *intr, const char *serial,
+                   uint16_t local_port, unsigned flags) {
+    char local[4 + 5 + 1]; // tcp:PORT
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    const char *const adb_cmd[] = {"forward", "--remove", local};
+
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
+    return process_check_success_intr(intr, pid, "adb forward --remove", flags);
+}
+
+bool
+adb_reverse(struct sc_intr *intr, const char *serial,
+            const char *device_socket_name, uint16_t local_port,
+            unsigned flags) {
+    char local[4 + 5 + 1]; // tcp:PORT
+    char remote[108 + 14 + 1]; // localabstract:NAME
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
+    const char *const adb_cmd[] = {"reverse", remote, local};
+
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
+    return process_check_success_intr(intr, pid, "adb reverse", flags);
+}
+
+bool
+adb_reverse_remove(struct sc_intr *intr, const char *serial,
+                   const char *device_socket_name, unsigned flags) {
+    char remote[108 + 14 + 1]; // localabstract:NAME
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
+    const char *const adb_cmd[] = {"reverse", "--remove", remote};
+
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
+    return process_check_success_intr(intr, pid, "adb reverse --remove", flags);
+}
+
+bool
+adb_push(struct sc_intr *intr, const char *serial, const char *local,
+         const char *remote, unsigned flags) {
+#ifdef __WINDOWS__
+    // Windows will parse the string, so the paths must be quoted
+    // (see sys/win/command.c)
+    local = sc_str_quote(local);
+    if (!local) {
+        return SC_PROCESS_NONE;
+    }
+    remote = sc_str_quote(remote);
+    if (!remote) {
+        free((void *) local);
+        return SC_PROCESS_NONE;
+    }
+#endif
+
+    const char *const adb_cmd[] = {"push", local, remote};
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
+
+#ifdef __WINDOWS__
+    free((void *) remote);
+    free((void *) local);
+#endif
+
+    return process_check_success_intr(intr, pid, "adb push", flags);
+}
+
+bool
+adb_install(struct sc_intr *intr, const char *serial, const char *local,
+            unsigned flags) {
+#ifdef __WINDOWS__
+    // Windows will parse the string, so the local name must be quoted
+    // (see sys/win/command.c)
+    local = sc_str_quote(local);
+    if (!local) {
+        return SC_PROCESS_NONE;
+    }
+#endif
+
+    const char *const adb_cmd[] = {"install", "-r", local};
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
+
+#ifdef __WINDOWS__
+    free((void *) local);
+#endif
+
+    return process_check_success_intr(intr, pid, "adb install", flags);
+}
+
+bool
+adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
+          unsigned flags) {
+    char port_string[5 + 1];
+    sprintf(port_string, "%" PRIu16, port);
+    const char *const adb_cmd[] = {"tcpip", port_string};
+
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
+    return process_check_success_intr(intr, pid, "adb tcpip", flags);
+}
+
+bool
+adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
+    const char *const adb_cmd[] = {"connect", ip_port};
+
+    sc_pipe pout;
+    sc_pid pid = adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), flags, &pout);
+    if (pid == SC_PROCESS_NONE) {
+        LOGE("Could not execute \"adb connect\"");
+        return false;
+    }
+
+    // "adb connect" always returns successfully (with exit code 0), even in
+    // case of failure. As a workaround, check if its output starts with
+    // "connected".
+    char buf[128];
+    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
+    sc_pipe_close(pout);
+
+    bool ok = process_check_success_intr(intr, pid, "adb connect", flags);
+    if (!ok) {
+        return false;
+    }
+
+    if (r == -1) {
+        return false;
+    }
+
+    ok = !strncmp("connected", buf, sizeof("connected") - 1);
+    if (!ok && !(flags & SC_ADB_NO_STDERR)) {
+        // "adb connect" also prints errors to stdout. Since we capture it,
+        // re-print the error to stderr.
+        sc_str_truncate(buf, r, "\r\n");
+        fprintf(stderr, "%s\n", buf);
+    }
+    return ok;
+}
+
+bool
+adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
+    const char *const adb_cmd[] = {"disconnect", ip_port};
+    size_t len = ip_port ? ARRAY_LEN(adb_cmd)
+                         : ARRAY_LEN(adb_cmd) - 1;
+
+    sc_pid pid = adb_execute(NULL, adb_cmd, len, flags);
+    return process_check_success_intr(intr, pid, "adb disconnect", flags);
+}
+
+char *
+adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
+            unsigned flags) {
+    const char *const adb_cmd[] = {"shell", "getprop", prop};
+
+    sc_pipe pout;
+    sc_pid pid =
+        adb_execute_p(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags, &pout);
+    if (pid == SC_PROCESS_NONE) {
+        LOGE("Could not execute \"adb getprop\"");
+        return NULL;
+    }
+
+    char buf[128];
+    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
+    sc_pipe_close(pout);
+
+    bool ok = process_check_success_intr(intr, pid, "adb getprop", flags);
+    if (!ok) {
+        return NULL;
+    }
+
+    if (r == -1) {
+        return NULL;
+    }
+
+    sc_str_truncate(buf, r, " \r\n");
+
+    return strdup(buf);
+}
+
+char *
+adb_get_serialno(struct sc_intr *intr, unsigned flags) {
+    const char *const adb_cmd[] = {"get-serialno"};
+
+    sc_pipe pout;
+    sc_pid pid = adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), flags, &pout);
+    if (pid == SC_PROCESS_NONE) {
+        LOGE("Could not execute \"adb get-serialno\"");
+        return NULL;
+    }
+
+    char buf[128];
+    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
+    sc_pipe_close(pout);
+
+    bool ok = process_check_success_intr(intr, pid, "adb get-serialno", flags);
+    if (!ok) {
+        return NULL;
+    }
+
+    if (r == -1) {
+        return NULL;
+    }
+
+    sc_str_truncate(buf, r, " \r\n");
+
+    return strdup(buf);
+}
+
+char *
+adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
+    const char *const cmd[] = {"shell", "ip", "route"};
+
+    sc_pipe pout;
+    sc_pid pid = adb_execute_p(serial, cmd, ARRAY_LEN(cmd), flags, &pout);
+    if (pid == SC_PROCESS_NONE) {
+        LOGD("Could not execute \"ip route\"");
+        return NULL;
+    }
+
+    // "adb shell ip route" output should contain only a few lines
+    char buf[1024];
+    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
+    sc_pipe_close(pout);
+
+    bool ok = process_check_success_intr(intr, pid, "ip route", flags);
+    if (!ok) {
+        return NULL;
+    }
+
+    if (r == -1) {
+        return NULL;
+    }
+
+    assert((size_t) r <= sizeof(buf));
+    if (r == sizeof(buf) && buf[sizeof(buf) - 1] != '\0')  {
+        // The implementation assumes that the output of "ip route" fits in the
+        // buffer in a single pass
+        LOGW("Result of \"ip route\" does not fit in 1Kb. "
+             "Please report an issue.\n");
+        return NULL;
+    }
+
+    return sc_adb_parse_device_ip_from_output(buf, r);
+}

app/src/adb/adb.h

@@ -0,0 +1,94 @@
+#ifndef SC_ADB_H
+#define SC_ADB_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <inttypes.h>
+
+#include "util/intr.h"
+
+#define SC_ADB_NO_STDOUT (1 << 0)
+#define SC_ADB_NO_STDERR (1 << 1)
+#define SC_ADB_NO_LOGERR (1 << 2)
+
+#define SC_ADB_SILENT (SC_ADB_NO_STDOUT | SC_ADB_NO_STDERR | SC_ADB_NO_LOGERR)
+
+sc_pid
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
+            unsigned flags);
+
+bool
+adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
+            const char *device_socket_name, unsigned flags);
+
+bool
+adb_forward_remove(struct sc_intr *intr, const char *serial,
+                   uint16_t local_port, unsigned flags);
+
+bool
+adb_reverse(struct sc_intr *intr, const char *serial,
+            const char *device_socket_name, uint16_t local_port,
+            unsigned flags);
+
+bool
+adb_reverse_remove(struct sc_intr *intr, const char *serial,
+                   const char *device_socket_name, unsigned flags);
+
+bool
+adb_push(struct sc_intr *intr, const char *serial, const char *local,
+         const char *remote, unsigned flags);
+
+bool
+adb_install(struct sc_intr *intr, const char *serial, const char *local,
+            unsigned flags);
+
+/**
+ * Execute `adb tcpip <port>`
+ */
+bool
+adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
+          unsigned flags);
+
+/**
+ * Execute `adb connect <ip_port>`
+ *
+ * `ip_port` may not be NULL.
+ */
+bool
+adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags);
+
+/**
+ * Execute `adb disconnect [<ip_port>]`
+ *
+ * If `ip_port` is NULL, execute `adb disconnect`.
+ * Otherwise, execute `adb disconnect <ip_port>`.
+ */
+bool
+adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags);
+
+/**
+ * Execute `adb getprop <prop>`
+ */
+char *
+adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
+            unsigned flags);
+
+/**
+ * Execute `adb get-serialno`
+ *
+ * Return the result, to be freed by the caller, or NULL on error.
+ */
+char *
+adb_get_serialno(struct sc_intr *intr, unsigned flags);
+
+/**
+ * Attempt to retrieve the device IP
+ *
+ * Return the IP as a string of the form "xxx.xxx.xxx.xxx", to be freed by the
+ * caller, or NULL on error.
+ */
+char *
+adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags);
+
+#endif

app/src/adb/adb_parser.c

@@ -0,0 +1,65 @@
+#include "adb_parser.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "util/log.h"
+#include "util/str.h"
+
+static char *
+sc_adb_parse_device_ip_from_line(char *line, size_t len) {
+    // One line from "ip route" looks like:
+    // "192.168.1.0/24 dev wlan0  proto kernel  scope link  src 192.168.1.x"
+
+    // Get the location of the device name (index of "wlan0" in the example)
+    ssize_t idx_dev_name = sc_str_index_of_column(line, 2, " ");
+    if (idx_dev_name == -1) {
+        return NULL;
+    }
+
+    // Get the location of the ip address (column 8, but column 6 if we start
+    // from column 2). Must be computed before truncating individual columns.
+    ssize_t idx_ip = sc_str_index_of_column(&line[idx_dev_name], 6, " ");
+    if (idx_ip == -1) {
+        return NULL;
+    }
+    // idx_ip is searched from &line[idx_dev_name]
+    idx_ip += idx_dev_name;
+
+    char *dev_name = &line[idx_dev_name];
+    sc_str_truncate(dev_name, len - idx_dev_name + 1, " \t");
+
+    char *ip = &line[idx_ip];
+    sc_str_truncate(ip, len - idx_ip + 1, " \t");
+
+    // Only consider lines where the device name starts with "wlan"
+    if (strncmp(dev_name, "wlan", sizeof("wlan") - 1)) {
+        LOGD("Device ip lookup: ignoring %s (%s)", ip, dev_name);
+        return NULL;
+    }
+
+    return strdup(ip);
+}
+
+char *
+sc_adb_parse_device_ip_from_output(char *buf, size_t buf_len) {
+    size_t idx_line = 0;
+    while (idx_line < buf_len && buf[idx_line] != '\0') {
+        char *line = &buf[idx_line];
+        size_t len = sc_str_truncate(line, buf_len - idx_line, "\n");
+
+        // The same, but without any trailing '\r'
+        size_t line_len = sc_str_remove_trailing_cr(line, len);
+
+        char *ip = sc_adb_parse_device_ip_from_line(line, line_len);
+        if (ip) {
+            // Found
+            return ip;
+        }
+
+        // The next line starts after the '\n' (replaced by `\0`)
+        idx_line += len + 1;
+    }
+
+    return NULL;
+}

app/src/adb/adb_parser.h

@@ -0,0 +1,16 @@
+#ifndef SC_ADB_PARSER_H
+#define SC_ADB_PARSER_H
+
+#include "common.h"
+
+#include <stddef.h>
+
+/**
+ * Parse the ip from the output of `adb shell ip route`
+ *
+ * Warning: this function modifies the buffer for optimization purposes.
+ */
+char *
+sc_adb_parse_device_ip_from_output(char *buf, size_t buf_len);
+
+#endif

app/src/adb/adb_tunnel.c

@@ -0,0 +1,169 @@
+#include "adb_tunnel.h"
+
+#include <assert.h>
+
+#include "adb.h"
+#include "util/log.h"
+#include "util/net_intr.h"
+#include "util/process_intr.h"
+
+#define SC_SOCKET_NAME "scrcpy"
+
+static bool
+listen_on_port(struct sc_intr *intr, sc_socket socket, uint16_t port) {
+    return net_listen_intr(intr, socket, IPV4_LOCALHOST, port, 1);
+}
+
+static bool
+enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
+                               struct sc_intr *intr, const char *serial,
+                               struct sc_port_range port_range) {
+    uint16_t port = port_range.first;
+    for (;;) {
+        if (!adb_reverse(intr, serial, SC_SOCKET_NAME, port,
+                         SC_ADB_NO_STDOUT)) {
+            // the command itself failed, it will fail on any port
+            return false;
+        }
+
+        // At the application level, the device part is "the server" because it
+        // serves video stream and control. However, at the network level, the
+        // client listens and the server connects to the client. That way, the
+        // client can listen before starting the server app, so there is no
+        // need to try to connect until the server socket is listening on the
+        // device.
+        sc_socket server_socket = net_socket();
+        if (server_socket != SC_SOCKET_NONE) {
+            bool ok = listen_on_port(intr, server_socket, port);
+            if (ok) {
+                // success
+                tunnel->server_socket = server_socket;
+                tunnel->local_port = port;
+                tunnel->enabled = true;
+                return true;
+            }
+
+            net_close(server_socket);
+        }
+
+        if (sc_intr_is_interrupted(intr)) {
+            // Stop immediately
+            return false;
+        }
+
+        // failure, disable tunnel and try another port
+        if (!adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+                                SC_ADB_NO_STDOUT)) {
+            LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
+        }
+
+        // check before incrementing to avoid overflow on port 65535
+        if (port < port_range.last) {
+            LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
+                 port, (uint16_t) (port + 1));
+            port++;
+            continue;
+        }
+
+        if (port_range.first == port_range.last) {
+            LOGE("Could not listen on port %" PRIu16, port_range.first);
+        } else {
+            LOGE("Could not listen on any port in range %" PRIu16 ":%" PRIu16,
+                 port_range.first, port_range.last);
+        }
+        return false;
+    }
+}
+
+static bool
+enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
+                               struct sc_intr *intr, const char *serial,
+                               struct sc_port_range port_range) {
+    tunnel->forward = true;
+
+    uint16_t port = port_range.first;
+    for (;;) {
+        if (adb_forward(intr, serial, port, SC_SOCKET_NAME, SC_ADB_NO_STDOUT)) {
+            // success
+            tunnel->local_port = port;
+            tunnel->enabled = true;
+            return true;
+        }
+
+        if (sc_intr_is_interrupted(intr)) {
+            // Stop immediately
+            return false;
+        }
+
+        if (port < port_range.last) {
+            LOGW("Could not forward port %" PRIu16", retrying on %" PRIu16,
+                 port, (uint16_t) (port + 1));
+            port++;
+            continue;
+        }
+
+        if (port_range.first == port_range.last) {
+            LOGE("Could not forward port %" PRIu16, port_range.first);
+        } else {
+            LOGE("Could not forward any port in range %" PRIu16 ":%" PRIu16,
+                 port_range.first, port_range.last);
+        }
+        return false;
+    }
+}
+
+void
+sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel) {
+    tunnel->enabled = false;
+    tunnel->forward = false;
+    tunnel->server_socket = SC_SOCKET_NONE;
+    tunnel->local_port = 0;
+}
+
+bool
+sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
+                   const char *serial, struct sc_port_range port_range,
+                   bool force_adb_forward) {
+    assert(!tunnel->enabled);
+
+    if (!force_adb_forward) {
+        // Attempt to use "adb reverse"
+        if (enable_tunnel_reverse_any_port(tunnel, intr, serial, port_range)) {
+            return true;
+        }
+
+        // if "adb reverse" does not work (e.g. over "adb connect"), it
+        // fallbacks to "adb forward", so the app socket is the client
+
+        LOGW("'adb reverse' failed, fallback to 'adb forward'");
+    }
+
+    return enable_tunnel_forward_any_port(tunnel, intr, serial, port_range);
+}
+
+bool
+sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
+                    const char *serial) {
+    assert(tunnel->enabled);
+
+    bool ret;
+    if (tunnel->forward) {
+        ret = adb_forward_remove(intr, serial, tunnel->local_port,
+                                 SC_ADB_NO_STDOUT);
+    } else {
+        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+                                 SC_ADB_NO_STDOUT);
+
+        assert(tunnel->server_socket != SC_SOCKET_NONE);
+        if (!net_close(tunnel->server_socket)) {
+            LOGW("Could not close server socket");
+        }
+
+        // server_socket is never used anymore
+    }
+
+    // Consider tunnel disabled even if the command failed
+    tunnel->enabled = false;
+
+    return ret;
+}

app/src/adb/adb_tunnel.h

@@ -0,0 +1,47 @@
+#ifndef SC_ADB_TUNNEL_H
+#define SC_ADB_TUNNEL_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "options.h"
+#include "util/intr.h"
+#include "util/net.h"
+
+struct sc_adb_tunnel {
+    bool enabled;
+    bool forward; // use "adb forward" instead of "adb reverse"
+    sc_socket server_socket; // only used if !forward
+    uint16_t local_port;
+};
+
+/**
+ * Initialize the adb tunnel struct to default values
+ */
+void
+sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel);
+
+/**
+ * Open a tunnel
+ *
+ * Blocking calls may be interrupted asynchronously via `intr`.
+ *
+ * If `force_adb_forward` is not set, then attempts to set up an "adb reverse"
+ * tunnel first. Only if it fails (typical on old Android version connected via
+ * TCP/IP), use "adb forward".
+ */
+bool
+sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
+                   const char *serial, struct sc_port_range port_range,
+                   bool force_adb_forward);
+
+/**
+ * Close the tunnel
+ */
+bool
+sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
+                    const char *serial);
+
+#endif