Document remote ADB server in README

Refs #2807 <https://github.com/Genymobile/scrcpy/pull/2807>

README.md

@@ -412,12 +412,47 @@ autoadb scrcpy -s '{}'
 
 [AutoAdb]: https://github.com/rom1v/autoadb
 
-#### SSH tunnel
+#### Tunnels
 
 To connect to a remote device, it is possible to connect a local `adb` client to
 a remote `adb` server (provided they use the same version of the _adb_
 protocol).
 
+##### Remote ADB server
+
+To connect to a remote ADB server, make the server listen on all interfaces:
+
+```bash
+adb kill-server
+adb -a nodaemon server start
+# keep this open
+```
+
+**Warning: all communications between clients and ADB server are unencrypted.**
+
+Suppose that this server is accessible at 192.168.1.2. Then, from another
+terminal, run scrcpy:
+
+```bash
+export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
+scrcpy --tunnel-host=192.168.1.2
+```
+
+By default, scrcpy uses the local port used for `adb forward` tunnel
+establishment (typically `27183`, see `--port`). It is also possible to force a
+different tunnel port (it may be useful in more complex situations, when more
+redirections are involved):
+
+```
+scrcpy --tunnel-port=1234
+```
+
+
+##### SSH tunnel
+
+To communicate with a remote ADB server securely, it is preferable to use a SSH
+tunnel.
+
 First, make sure the ADB server is running on the remote computer:
 
 ```bash

app/meson.build

@@ -199,6 +199,7 @@ if get_option('buildtype') == 'debug'
             'tests/test_cli.c',
             'src/cli.c',
             'src/options.c',
+            'src/util/net.c',
             'src/util/str.c',
             'src/util/strbuf.c',
             'src/util/term.c',

app/scrcpy.1

@@ -203,6 +203,18 @@ Enable "show touches" on start, restore the initial value on exit.
 
 It only shows physical touches (not clicks from scrcpy).
 
+.TP
+.BI "\-\-tunnel\-host " ip
+Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
+
+Default is localhost.
+
+.TP
+.BI "\-\-tunnel\-port " port
+Set the TCP port of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
+
+Default is 0 (not forced): the local port used for establishing the tunnel will be used.
+
 .TP
 .BI "\-\-v4l2-sink " /dev/videoN
 Output to v4l2loopback device.

app/src/adb.c

@@ -112,7 +112,7 @@ show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
 
 static sc_pid
 adb_execute_p(const char *serial, const char *const adb_cmd[],
-              size_t len, unsigned inherit, sc_pipe *pout) {
+              size_t len, sc_pipe *pout) {
     int i;
     sc_pid pid;
 
@@ -133,7 +133,7 @@ adb_execute_p(const char *serial, const char *const adb_cmd[],
     memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
     argv[len + i] = NULL;
     enum sc_process_result r =
-        sc_process_execute_p(argv, &pid, inherit, NULL, pout, NULL);
+        sc_process_execute_p(argv, &pid, NULL, pout, NULL);
     if (r != SC_PROCESS_SUCCESS) {
         show_adb_err_msg(r, argv);
         pid = SC_PROCESS_NONE;
@@ -144,54 +144,50 @@ adb_execute_p(const char *serial, const char *const adb_cmd[],
 }
 
 sc_pid
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
-            unsigned inherit) {
-    return adb_execute_p(serial, adb_cmd, len, inherit, NULL);
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
+    return adb_execute_p(serial, adb_cmd, len, NULL);
 }
 
 static sc_pid
 adb_exec_forward(const char *serial, uint16_t local_port,
-                 const char *device_socket_name, unsigned inherit) {
+                 const char *device_socket_name) {
     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};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
 static sc_pid
-adb_exec_forward_remove(const char *serial, uint16_t local_port,
-                        unsigned inherit) {
+adb_exec_forward_remove(const char *serial, uint16_t local_port) {
     char local[4 + 5 + 1]; // tcp:PORT
     sprintf(local, "tcp:%" PRIu16, local_port);
     const char *const adb_cmd[] = {"forward", "--remove", local};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
 static sc_pid
 adb_exec_reverse(const char *serial, const char *device_socket_name,
-                 uint16_t local_port, unsigned inherit) {
+                 uint16_t local_port) {
     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};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
 static sc_pid
-adb_exec_reverse_remove(const char *serial, const char *device_socket_name,
-                        unsigned inherit) {
+adb_exec_reverse_remove(const char *serial, const char *device_socket_name) {
     char remote[108 + 14 + 1]; // localabstract:NAME
     snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
     const char *const adb_cmd[] = {"reverse", "--remove", remote};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
 static sc_pid
-adb_exec_push(const char *serial, const char *local, const char *remote,
-              unsigned inherit) {
+adb_exec_push(const char *serial, const char *local, const char *remote) {
 #ifdef __WINDOWS__
     // Windows will parse the string, so the paths must be quoted
     // (see sys/win/command.c)
@@ -207,7 +203,7 @@ adb_exec_push(const char *serial, const char *local, const char *remote,
 #endif
 
     const char *const adb_cmd[] = {"push", local, remote};
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 
 #ifdef __WINDOWS__
     free((void *) remote);
@@ -218,7 +214,7 @@ adb_exec_push(const char *serial, const char *local, const char *remote,
 }
 
 static sc_pid
-adb_exec_install(const char *serial, const char *local, unsigned inherit) {
+adb_exec_install(const char *serial, const char *local) {
 #ifdef __WINDOWS__
     // Windows will parse the string, so the local name must be quoted
     // (see sys/win/command.c)
@@ -229,7 +225,7 @@ adb_exec_install(const char *serial, const char *local, unsigned inherit) {
 #endif
 
     const char *const adb_cmd[] = {"install", "-r", local};
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 
 #ifdef __WINDOWS__
     free((void *) local);
@@ -239,62 +235,58 @@ adb_exec_install(const char *serial, const char *local, unsigned inherit) {
 }
 
 static sc_pid
-adb_exec_get_serialno(unsigned inherit, sc_pipe *pout) {
+adb_exec_get_serialno(sc_pipe *pout) {
     const char *const adb_cmd[] = {"get-serialno"};
-    return adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), inherit, pout);
+    return adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), pout);
 }
 
 bool
 adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
-            const char *device_socket_name, unsigned inherit) {
-    sc_pid pid =
-        adb_exec_forward(serial, local_port, device_socket_name, inherit);
+            const char *device_socket_name) {
+    sc_pid pid = adb_exec_forward(serial, local_port, device_socket_name);
     return sc_process_check_success_intr(intr, pid, "adb forward", true);
 }
 
 bool
 adb_forward_remove(struct sc_intr *intr, const char *serial,
-                   uint16_t local_port, unsigned inherit) {
-    sc_pid pid = adb_exec_forward_remove(serial, local_port, inherit);
+                   uint16_t local_port) {
+    sc_pid pid = adb_exec_forward_remove(serial, local_port);
     return sc_process_check_success_intr(intr, pid, "adb forward --remove",
                                          true);
 }
 
 bool
 adb_reverse(struct sc_intr *intr, const char *serial,
-            const char *device_socket_name, uint16_t local_port,
-            unsigned inherit) {
-    sc_pid pid =
-        adb_exec_reverse(serial, device_socket_name, local_port, inherit);
+            const char *device_socket_name, uint16_t local_port) {
+    sc_pid pid = adb_exec_reverse(serial, device_socket_name, local_port);
     return sc_process_check_success_intr(intr, pid, "adb reverse", true);
 }
 
 bool
 adb_reverse_remove(struct sc_intr *intr, const char *serial,
-                   const char *device_socket_name, unsigned inherit) {
-    sc_pid pid = adb_exec_reverse_remove(serial, device_socket_name, inherit);
+                   const char *device_socket_name) {
+    sc_pid pid = adb_exec_reverse_remove(serial, device_socket_name);
     return sc_process_check_success_intr(intr, pid, "adb reverse --remove",
                                          true);
 }
 
 bool
 adb_push(struct sc_intr *intr, const char *serial, const char *local,
-         const char *remote, unsigned inherit) {
-    sc_pid pid = adb_exec_push(serial, local, remote, inherit);
+         const char *remote) {
+    sc_pid pid = adb_exec_push(serial, local, remote);
     return sc_process_check_success_intr(intr, pid, "adb push", true);
 }
 
 bool
-adb_install(struct sc_intr *intr, const char *serial, const char *local,
-            unsigned inherit) {
-    sc_pid pid = adb_exec_install(serial, local, inherit);
+adb_install(struct sc_intr *intr, const char *serial, const char *local) {
+    sc_pid pid = adb_exec_install(serial, local);
     return sc_process_check_success_intr(intr, pid, "adb install", true);
 }
 
 char *
-adb_get_serialno(struct sc_intr *intr, unsigned inherit) {
+adb_get_serialno(struct sc_intr *intr) {
     sc_pipe pout;
-    sc_pid pid = adb_exec_get_serialno(inherit, &pout);
+    sc_pid pid = adb_exec_get_serialno(&pout);
     if (pid == SC_PROCESS_NONE) {
         LOGE("Could not execute \"adb get-serialno\"");
         return NULL;

app/src/adb.h

@@ -9,33 +9,30 @@
 #include "util/intr.h"
 
 sc_pid
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
-            unsigned inherit);
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
 
 bool
 adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
-            const char *device_socket_name, unsigned inherit);
+            const char *device_socket_name);
 
 bool
 adb_forward_remove(struct sc_intr *intr, const char *serial,
-                   uint16_t local_port, unsigned inherit);
+                   uint16_t local_port);
 
 bool
 adb_reverse(struct sc_intr *intr, const char *serial,
-            const char *device_socket_name, uint16_t local_port,
-            unsigned inherit);
+            const char *device_socket_name, uint16_t local_port);
 
 bool
 adb_reverse_remove(struct sc_intr *intr, const char *serial,
-                   const char *device_socket_name, unsigned inherit);
+                   const char *device_socket_name);
 
 bool
 adb_push(struct sc_intr *intr, const char *serial, const char *local,
-         const char *remote, unsigned inherit);
+         const char *remote);
 
 bool
-adb_install(struct sc_intr *intr, const char *serial, const char *local,
-            unsigned inherit);
+adb_install(struct sc_intr *intr, const char *serial, const char *local);
 
 /**
  * Execute `adb get-serialno`
@@ -43,6 +40,6 @@ adb_install(struct sc_intr *intr, const char *serial, const char *local,
  * Return the result, to be freed by the caller, or NULL on error.
  */
 char *
-adb_get_serialno(struct sc_intr *intr, unsigned inherit);
+adb_get_serialno(struct sc_intr *intr);
 
 #endif

app/src/adb_tunnel.c

@@ -20,7 +20,7 @@ enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
                                struct sc_port_range port_range) {
     uint16_t port = port_range.first;
     for (;;) {
-        if (!adb_reverse(intr, serial, SC_SOCKET_NAME, port, SC_STDERR)) {
+        if (!adb_reverse(intr, serial, SC_SOCKET_NAME, port)) {
             // the command itself failed, it will fail on any port
             return false;
         }
@@ -51,7 +51,7 @@ enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
         }
 
         // failure, disable tunnel and try another port
-        if (!adb_reverse_remove(intr, serial, SC_SOCKET_NAME, SC_STDERR)) {
+        if (!adb_reverse_remove(intr, serial, SC_SOCKET_NAME)) {
             LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
         }
 
@@ -81,7 +81,7 @@ enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
 
     uint16_t port = port_range.first;
     for (;;) {
-        if (adb_forward(intr, serial, port, SC_SOCKET_NAME, SC_STDERR)) {
+        if (adb_forward(intr, serial, port, SC_SOCKET_NAME)) {
             // success
             tunnel->local_port = port;
             tunnel->enabled = true;
@@ -146,9 +146,9 @@ sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
 
     bool ret;
     if (tunnel->forward) {
-        ret = adb_forward_remove(intr, serial, tunnel->local_port, SC_STDERR);
+        ret = adb_forward_remove(intr, serial, tunnel->local_port);
     } else {
-        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME, SC_STDERR);
+        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME);
 
         assert(tunnel->server_socket != SC_SOCKET_NONE);
         if (!net_close(tunnel->server_socket)) {

app/src/cli.c

@@ -9,6 +9,7 @@
 
 #include "options.h"
 #include "util/log.h"
+#include "util/net.h"
 #include "util/str.h"
 #include "util/strbuf.h"
 #include "util/term.h"
@@ -46,6 +47,8 @@
 #define OPT_V4L2_SINK              1027
 #define OPT_DISPLAY_BUFFER         1028
 #define OPT_V4L2_BUFFER            1029
+#define OPT_TUNNEL_HOST            1030
+#define OPT_TUNNEL_PORT            1031
 
 struct sc_option {
     char shortopt;
@@ -330,6 +333,25 @@ static const struct sc_option options[] = {
                 "on exit.\n"
                 "It only shows physical touches (not clicks from scrcpy).",
     },
+    {
+        .longopt_id = OPT_TUNNEL_HOST,
+        .longopt = "tunnel-host",
+        .argdesc = "ip",
+        .text = "Set the IP address of the adb tunnel to reach the scrcpy "
+                "server. This option automatically enables "
+                "--force-adb-forward.\n"
+                "Default is localhost.",
+    },
+    {
+        .longopt_id = OPT_TUNNEL_PORT,
+        .longopt = "tunnel-port",
+        .argdesc = "port",
+        .text = "Set the TCP port of the adb tunnel to reach the scrcpy "
+                "server. This option automatically enables "
+                "--force-adb-forward.\n"
+                "Default is 0 (not forced): the local port used for "
+                "establishing the tunnel will be used.",
+    },
 #ifdef HAVE_V4L2
     {
         .longopt_id = OPT_V4L2_SINK,
@@ -1127,6 +1149,21 @@ parse_record_format(const char *optarg, enum sc_record_format *format) {
     return false;
 }
 
+static bool
+parse_ip(const char *optarg, uint32_t *ipv4) {
+    return net_parse_ipv4(optarg, ipv4);
+}
+
+static bool
+parse_port(const char *optarg, uint16_t *port) {
+    long value;
+    if (!parse_integer_arg(optarg, &value, false, 0, 0xFFFF, "port")) {
+        return false;
+    }
+    *port = (uint16_t) value;
+    return true;
+}
+
 static enum sc_record_format
 guess_record_format(const char *filename) {
     size_t len = strlen(filename);
@@ -1199,6 +1236,16 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                     return false;
                 }
                 break;
+            case OPT_TUNNEL_HOST:
+                if (!parse_ip(optarg, &opts->tunnel_host)) {
+                    return false;
+                }
+                break;
+            case OPT_TUNNEL_PORT:
+                if (!parse_port(optarg, &opts->tunnel_port)) {
+                    return false;
+                }
+                break;
             case 'n':
                 opts->control = false;
                 break;
@@ -1358,6 +1405,12 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
     }
 #endif
 
+    if ((opts->tunnel_host || opts->tunnel_port) && !opts->force_adb_forward) {
+        LOGI("Tunnel host/port is set, "
+             "--force-adb-forward automatically enabled.");
+        opts->force_adb_forward = true;
+    }
+
     int index = optind;
     if (index < argc) {
         LOGE("Unexpected additional argument: %s", argv[index]);

app/src/file_handler.c

@@ -128,8 +128,7 @@ run_file_handler(void *data) {
 
         if (req.action == ACTION_INSTALL_APK) {
             LOGI("Installing %s...", req.file);
-            bool ok =
-                adb_install(intr, serial, req.file, SC_STDOUT | SC_STDERR);
+            bool ok = adb_install(intr, serial, req.file);
             if (ok) {
                 LOGI("%s successfully installed", req.file);
             } else {
@@ -137,8 +136,7 @@ run_file_handler(void *data) {
             }
         } else {
             LOGI("Pushing %s...", req.file);
-            bool ok = adb_push(intr, serial, req.file, push_target,
-                               SC_STDOUT | SC_STDERR);
+            bool ok = adb_push(intr, serial, req.file, push_target);
             if (ok) {
                 LOGI("%s successfully pushed to %s", req.file, push_target);
             } else {

app/src/options.c

@@ -19,6 +19,8 @@ const struct scrcpy_options scrcpy_options_default = {
         .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
         .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
     },
+    .tunnel_host = 0,
+    .tunnel_port = 0,
     .shortcut_mods = {
         .data = {SC_MOD_LALT, SC_MOD_LSUPER},
         .count = 2,

app/src/options.h

@@ -77,6 +77,8 @@ struct scrcpy_options {
     enum sc_record_format record_format;
     enum sc_keyboard_input_mode keyboard_input_mode;
     struct sc_port_range port_range;
+    uint32_t tunnel_host;
+    uint16_t tunnel_port;
     struct sc_shortcut_mods shortcut_mods;
     uint16_t max_size;
     uint32_t bit_rate;

app/src/scrcpy.c

@@ -345,6 +345,8 @@ scrcpy(struct scrcpy_options *options) {
         .log_level = options->log_level,
         .crop = options->crop,
         .port_range = options->port_range,
+        .tunnel_host = options->tunnel_host,
+        .tunnel_port = options->tunnel_port,
         .max_size = options->max_size,
         .bit_rate = options->bit_rate,
         .max_fps = options->max_fps,

app/src/server.c

@@ -112,8 +112,7 @@ push_server(struct sc_intr *intr, const char *serial) {
         free(server_path);
         return false;
     }
-    bool ok = adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH,
-                       SC_STDERR);
+    bool ok = adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH);
     free(server_path);
     return ok;
 }
@@ -199,13 +198,13 @@ execute_server(struct sc_server *server,
     //     Port: 5005
     // Then click on "Debug"
 #endif
-    // Inherit both stdout and stderr (all server logs are printed to stdout)
-    return adb_execute(serial, cmd, ARRAY_LEN(cmd), SC_STDOUT | SC_STDERR);
+    return adb_execute(serial, cmd, ARRAY_LEN(cmd));
 }
 
 static bool
-connect_and_read_byte(struct sc_intr *intr, sc_socket socket, uint16_t port) {
-    bool ok = net_connect_intr(intr, socket, IPV4_LOCALHOST, port);
+connect_and_read_byte(struct sc_intr *intr, sc_socket socket,
+                      uint32_t tunnel_host, uint16_t tunnel_port) {
+    bool ok = net_connect_intr(intr, socket, tunnel_host, tunnel_port);
     if (!ok) {
         return false;
     }
@@ -222,13 +221,13 @@ connect_and_read_byte(struct sc_intr *intr, sc_socket socket, uint16_t port) {
 }
 
 static sc_socket
-connect_to_server(struct sc_server *server, uint32_t attempts, sc_tick delay) {
-    uint16_t port = server->tunnel.local_port;
+connect_to_server(struct sc_server *server, uint32_t attempts, sc_tick delay,
+                  uint32_t host, uint16_t port) {
     do {
         LOGD("Remaining connection attempts: %d", (int) attempts);
         sc_socket socket = net_socket();
         if (socket != SC_SOCKET_NONE) {
-            bool ok = connect_and_read_byte(&server->intr, socket, port);
+            bool ok = connect_and_read_byte(&server->intr, socket, host, port);
             if (ok) {
                 // it worked!
                 return socket;
@@ -354,9 +353,20 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
             goto fail;
         }
     } else {
+        uint32_t tunnel_host = server->params.tunnel_host;
+        if (!tunnel_host) {
+            tunnel_host = IPV4_LOCALHOST;
+        }
+
+        uint16_t tunnel_port = server->params.tunnel_port;
+        if (!tunnel_port) {
+            tunnel_port = tunnel->local_port;
+        }
+
         uint32_t attempts = 100;
         sc_tick delay = SC_TICK_FROM_MS(100);
-        video_socket = connect_to_server(server, attempts, delay);
+        video_socket = connect_to_server(server, attempts, delay, tunnel_host,
+                                         tunnel_port);
         if (video_socket == SC_SOCKET_NONE) {
             goto fail;
         }
@@ -366,8 +376,8 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
         if (control_socket == SC_SOCKET_NONE) {
             goto fail;
         }
-        bool ok = net_connect_intr(&server->intr, control_socket,
-                                   IPV4_LOCALHOST, tunnel->local_port);
+        bool ok = net_connect_intr(&server->intr, control_socket, tunnel_host,
+                                   tunnel_port);
         if (!ok) {
             goto fail;
         }
@@ -432,7 +442,7 @@ sc_server_fill_serial(struct sc_server *server) {
     // device/emulator" error)
     if (!server->params.serial) {
         // The serial is owned by sc_server_params, and will be freed on destroy
-        server->params.serial = adb_get_serialno(&server->intr, SC_STDERR);
+        server->params.serial = adb_get_serialno(&server->intr);
         if (!server->params.serial) {
             LOGE("Could not get device serial");
             return false;
@@ -459,8 +469,6 @@ run_server(void *data) {
         goto error_connection_failed;
     }
 
-    LOGI("Server pushed");
-
     ok = sc_adb_tunnel_open(&server->tunnel, &server->intr, params->serial,
                             params->port_range, params->force_adb_forward);
     if (!ok) {

app/src/server.h

@@ -29,6 +29,8 @@ struct sc_server_params {
     const char *codec_options;
     const char *encoder_name;
     struct sc_port_range port_range;
+    uint32_t tunnel_host;
+    uint16_t tunnel_port;
     uint16_t max_size;
     uint32_t bit_rate;
     uint16_t max_fps;

app/src/sys/unix/process.c

@@ -11,16 +11,8 @@
 #include "util/log.h"
 
 enum sc_process_result
-sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned inherit,
+sc_process_execute_p(const char *const argv[], sc_pid *pid,
                      int *pin, int *pout, int *perr) {
-    bool inherit_stdout = inherit & SC_STDOUT;
-    bool inherit_stderr = inherit & SC_STDERR;
-
-    // If pout is defined, then inherit MUST NOT contain SC_STDOUT.
-    assert(!pout || !inherit_stdout);
-    // If perr is defined, then inherit MUST NOT contain SC_STDERR.
-    assert(!perr || !inherit_stderr);
-
     int in[2];
     int out[2];
     int err[2];
@@ -98,31 +90,20 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned inherit,
             }
             close(in[1]);
         }
-        // Do not close stdin in the child process, this makes adb fail on
-        // Linux
-
         if (pout) {
             if (out[1] != STDOUT_FILENO) {
                 dup2(out[1], STDOUT_FILENO);
                 close(out[1]);
             }
             close(out[0]);
-        } else if (!inherit_stdout) {
-            // Close stdout in the child process
-            close(STDOUT_FILENO);
         }
-
         if (perr) {
             if (err[1] != STDERR_FILENO) {
                 dup2(err[1], STDERR_FILENO);
                 close(err[1]);
             }
             close(err[0]);
-        } else if (!inherit_stderr) {
-            // Close stderr in the child process
-            close(STDERR_FILENO);
         }
-
         close(internal[0]);
         enum sc_process_result err;
         if (fcntl(internal[1], F_SETFD, FD_CLOEXEC) == 0) {

app/src/sys/win/process.c

@@ -27,22 +27,12 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
 }
 
 enum sc_process_result
-sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned inherit,
+sc_process_execute_p(const char *const argv[], HANDLE *handle,
                      HANDLE *pin, HANDLE *pout, HANDLE *perr) {
-    bool inherit_stdout = inherit & SC_STDOUT;
-    bool inherit_stderr = inherit & SC_STDERR;
-
-    // If pout is defined, then inherit MUST NOT contain SC_STDOUT.
-    assert(!pout || !inherit_stdout);
-    // If perr is defined, then inherit MUST NOT contain SC_STDERR.
-    assert(!perr || !inherit_stderr);
+    enum sc_process_result ret = SC_PROCESS_ERROR_GENERIC;
 
     // Add 1 per non-NULL pointer
-    unsigned handle_count = !!pin
-                          + (pout || inherit_stdout)
-                          + (perr || inherit_stderr);
-
-    enum sc_process_result ret = SC_PROCESS_ERROR_GENERIC;
+    unsigned handle_count = !!pin + !!pout + !!perr;
 
     SECURITY_ATTRIBUTES sa;
     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
@@ -92,20 +82,14 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned inherit,
     LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList = NULL;
     if (handle_count) {
         si.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
-        unsigned i = 0;
         if (pin) {
             si.StartupInfo.hStdInput = stdin_read_handle;
-            handles[i++] = si.StartupInfo.hStdInput;
         }
-        if (pout || inherit_stdout) {
-            si.StartupInfo.hStdOutput = pout ? stdout_write_handle
-                                             : GetStdHandle(STD_OUTPUT_HANDLE);
-            handles[i++] = si.StartupInfo.hStdOutput;
+        if (pout) {
+            si.StartupInfo.hStdOutput = stdout_write_handle;
         }
-        if (perr || inherit_stderr) {
-            si.StartupInfo.hStdError = perr ? stderr_write_handle
-                                            : GetStdHandle(STD_ERROR_HANDLE);
-            handles[i++] = si.StartupInfo.hStdError;
+        if (perr) {
+            si.StartupInfo.hStdError = stderr_write_handle;
         }
 
         SIZE_T size;
@@ -128,6 +112,17 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned inherit,
             goto error_close_stderr;
         }
 
+        // Explicitly pass the HANDLEs that must be inherited
+        unsigned i = 0;
+        if (pin) {
+            handles[i++] = stdin_read_handle;
+        }
+        if (pout) {
+            handles[i++] = stdout_write_handle;
+        }
+        if (perr) {
+            handles[i++] = stderr_write_handle;
+        }
         ok = UpdateProcThreadAttribute(lpAttributeList, 0,
                                        PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
                                        handles, handle_count * sizeof(HANDLE),
@@ -152,9 +147,7 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned inherit,
     }
 
     BOOL bInheritHandles = handle_count > 0;
-    // DETACHED_PROCESS to disable stdin, stdout and stderr
-    DWORD dwCreationFlags = handle_count == 0 ? DETACHED_PROCESS
-                                              : EXTENDED_STARTUPINFO_PRESENT;
+    DWORD dwCreationFlags = handle_count > 0 ? EXTENDED_STARTUPINFO_PRESENT : 0;
     BOOL ok = CreateProcessW(NULL, wide, NULL, NULL, bInheritHandles,
                              dwCreationFlags, NULL, NULL, &si.StartupInfo, &pi);
     free(wide);

app/src/util/net.c

@@ -1,3 +1,7 @@
+// For inet_pton() on Windows
+#define _WIN32_WINNT 0x0600
+#define WINVER 0x0600
+
 #include "net.h"
 
 #include <assert.h>
@@ -7,6 +11,7 @@
 #include "log.h"
 
 #ifdef __WINDOWS__
+# include <ws2tcpip.h>
   typedef int socklen_t;
   typedef SOCKET sc_raw_socket;
 #else
@@ -225,3 +230,15 @@ net_close(sc_socket socket) {
     return !close(raw_sock);
 #endif
 }
+
+bool
+net_parse_ipv4(const char *s, uint32_t *ipv4) {
+    struct in_addr addr;
+    if (!inet_pton(AF_INET, s, &addr)) {
+        LOGE("Invalid IPv4 address: %s", s);
+        return false;
+    }
+
+    *ipv4 = ntohl(addr.s_addr);
+    return true;
+}

app/src/util/net.h

@@ -68,4 +68,10 @@ net_interrupt(sc_socket socket);
 bool
 net_close(sc_socket socket);
 
+/**
+ * Parse `ip` "xxx.xxx.xxx.xxx" to an IPv4 host representation
+ */
+bool
+net_parse_ipv4(const char *ip, uint32_t *ipv4);
+
 #endif

app/src/util/process.c

@@ -5,8 +5,8 @@
 #include "log.h"
 
 enum sc_process_result
-sc_process_execute(const char *const argv[], sc_pid *pid, unsigned inherit) {
-    return sc_process_execute_p(argv, pid, inherit, NULL, NULL, NULL);
+sc_process_execute(const char *const argv[], sc_pid *pid) {
+    return sc_process_execute_p(argv, pid, NULL, NULL, NULL);
 }
 
 bool

app/src/util/process.h

@@ -67,31 +67,20 @@ enum sc_process_result {
     SC_PROCESS_ERROR_MISSING_BINARY,
 };
 
-#define SC_STDOUT (1 << 0)
-#define SC_STDERR (1 << 1)
-
 /**
  * Execute the command and write the process id to `pid`
- *
- * The parameter `inherit` is a OR of any of SC_STDOUT and SC_STDERR. It
- * indicates if stdout and stderr must be inherited from the scrcpy process (in
- * other words, if the process must output to the scrcpy console).
  */
 enum sc_process_result
-sc_process_execute(const char *const argv[], sc_pid *pid, unsigned inherit);
+sc_process_execute(const char *const argv[], sc_pid *pid);
 
 /**
  * Execute the command and write the process id to `pid`
  *
  * If not NULL, provide a pipe for stdin (`pin`), stdout (`pout`) and stderr
  * (`perr`).
- *
- * The parameter `inherit` has the same semantics as in `sc_process_execute()`.
- * If `pout` is not NULL, then `inherit` MUST NOT contain SC_STDOUT.
- * If `perr` is not NULL, then `inherit` MUST NOT contain SC_STDERR.
  */
 enum sc_process_result
-sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned inherit,
+sc_process_execute_p(const char *const argv[], sc_pid *pid,
                      sc_pipe *pin, sc_pipe *pout, sc_pipe *perr);
 
 /**