Log server pushed

Now that "adb push" stdout is disabled, add a log to notify server
pushed.

README.md

@@ -416,17 +416,27 @@ autoadb scrcpy -s '{}'
 
 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):
+protocol).
+
+First, make sure the ADB server is running on the remote computer:
 
 ```bash
-adb kill-server    # kill the local adb server on 5037
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
+adb start-server
+```
+
+Then, establish a SSH tunnel:
+
+```bash
+# local  5038 --> remote  5037
+# local 27183 <-- remote 27183
+ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 
-From another terminal:
+From another terminal, run scrcpy:
 
 ```bash
+export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
 
@@ -434,14 +444,16 @@ To avoid enabling remote port forwarding, you could force a forward connection
 instead (notice the `-L` instead of `-R`):
 
 ```bash
-adb kill-server    # kill the local adb server on 5037
-ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
+# local  5038 --> remote  5037
+# local 27183 --> remote 27183
+ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 
-From another terminal:
+From another terminal, run scrcpy:
 
 ```bash
+export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
 

app/src/adb.c

@@ -7,6 +7,7 @@
 
 #include "util/file.h"
 #include "util/log.h"
+#include "util/process_intr.h"
 #include "util/str.h"
 
 static const char *adb_command;
@@ -109,9 +110,9 @@ show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
     free(buf);
 }
 
-sc_pid
+static sc_pid
 adb_execute_p(const char *serial, const char *const adb_cmd[],
-              size_t len, sc_pipe *pin, sc_pipe *pout, sc_pipe *perr) {
+              size_t len, unsigned inherit, sc_pipe *pout) {
     int i;
     sc_pid pid;
 
@@ -132,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, pin, pout, perr);
+        sc_process_execute_p(argv, &pid, inherit, NULL, pout, NULL);
     if (r != SC_PROCESS_SUCCESS) {
         show_adb_err_msg(r, argv);
         pid = SC_PROCESS_NONE;
@@ -143,50 +144,54 @@ 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) {
-    return adb_execute_p(serial, adb_cmd, len, NULL, NULL, NULL);
+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);
 }
 
-sc_pid
-adb_forward(const char *serial, uint16_t local_port,
-            const char *device_socket_name) {
+static sc_pid
+adb_exec_forward(const char *serial, uint16_t local_port,
+                 const char *device_socket_name, unsigned inherit) {
     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));
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 }
 
-sc_pid
-adb_forward_remove(const char *serial, uint16_t local_port) {
+static sc_pid
+adb_exec_forward_remove(const char *serial, uint16_t local_port,
+                        unsigned inherit) {
     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));
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 }
 
-sc_pid
-adb_reverse(const char *serial, const char *device_socket_name,
-            uint16_t local_port) {
+static sc_pid
+adb_exec_reverse(const char *serial, const char *device_socket_name,
+                 uint16_t local_port, unsigned inherit) {
     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));
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 }
 
-sc_pid
-adb_reverse_remove(const char *serial, const char *device_socket_name) {
+static sc_pid
+adb_exec_reverse_remove(const char *serial, const char *device_socket_name,
+                        unsigned inherit) {
     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));
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 }
 
-sc_pid
-adb_push(const char *serial, const char *local, const char *remote) {
+static sc_pid
+adb_exec_push(const char *serial, const char *local, const char *remote,
+              unsigned inherit) {
 #ifdef __WINDOWS__
     // Windows will parse the string, so the paths must be quoted
     // (see sys/win/command.c)
@@ -202,7 +207,7 @@ adb_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));
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 
 #ifdef __WINDOWS__
     free((void *) remote);
@@ -212,8 +217,8 @@ adb_push(const char *serial, const char *local, const char *remote) {
     return pid;
 }
 
-sc_pid
-adb_install(const char *serial, const char *local) {
+static sc_pid
+adb_exec_install(const char *serial, const char *local, unsigned inherit) {
 #ifdef __WINDOWS__
     // Windows will parse the string, so the local name must be quoted
     // (see sys/win/command.c)
@@ -224,7 +229,7 @@ adb_install(const char *serial, const char *local) {
 #endif
 
     const char *const adb_cmd[] = {"install", "-r", local};
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 
 #ifdef __WINDOWS__
     free((void *) local);
@@ -233,45 +238,79 @@ adb_install(const char *serial, const char *local) {
     return pid;
 }
 
-static ssize_t
-adb_execute_for_output(const char *serial, const char *const adb_cmd[],
-                       size_t adb_cmd_len, char *buf, size_t buf_len,
-                       const char *name) {
-    sc_pipe pout;
-    sc_pid pid = adb_execute_p(serial, adb_cmd, adb_cmd_len, NULL, &pout, NULL);
-
-    ssize_t r = sc_pipe_read_all(pout, buf, buf_len);
-    sc_pipe_close(pout);
-
-    if (!sc_process_check_success(pid, name, true)) {
-        return -1;
-    }
-
-    return r;
+static sc_pid
+adb_exec_get_serialno(unsigned inherit, sc_pipe *pout) {
+    const char *const adb_cmd[] = {"get-serialno"};
+    return adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), inherit, pout);
 }
 
-static size_t
-truncate_first_line(char *data, size_t len) {
-    data[len - 1] = '\0';
-    char *eol = strpbrk(data, "\r\n");
-    if (eol) {
-        *eol = '\0';
-        len = eol - data;
-    }
-    return len;
+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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    return sc_process_check_success_intr(intr, pid, "adb install", true);
 }
 
 char *
-adb_get_serialno(void) {
-    char buf[128];
-
-    const char *const adb_cmd[] = {"get-serialno"};
-    ssize_t r = adb_execute_for_output(NULL, adb_cmd, ARRAY_LEN(adb_cmd),
-                                       buf, sizeof(buf), "get-serialno");
-    if (r <= 0) {
+adb_get_serialno(struct sc_intr *intr, unsigned inherit) {
+    sc_pipe pout;
+    sc_pid pid = adb_exec_get_serialno(inherit, &pout);
+    if (pid == SC_PROCESS_NONE) {
+        LOGE("Could not execute \"adb get-serialno\"");
         return NULL;
     }
 
-    truncate_first_line(buf, r);
+    char buf[128];
+    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
+    sc_pipe_close(pout);
+
+    bool ok =
+        sc_process_check_success_intr(intr, pid, "adb get-serialno", true);
+    if (!ok) {
+        return NULL;
+    }
+
+    sc_str_truncate(buf, r, " \r\n");
+
     return strdup(buf);
 }

app/src/adb.h

@@ -6,37 +6,43 @@
 #include <stdbool.h>
 #include <inttypes.h>
 
-#include "util/process.h"
+#include "util/intr.h"
 
 sc_pid
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
+            unsigned inherit);
 
-sc_pid
-adb_execute_p(const char *serial, const char *const adb_cmd[],
-              size_t len, sc_pipe *pin, sc_pipe *pout, sc_pipe *perr);
+bool
+adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
+            const char *device_socket_name, unsigned inherit);
 
-sc_pid
-adb_forward(const char *serial, uint16_t local_port,
-            const char *device_socket_name);
+bool
+adb_forward_remove(struct sc_intr *intr, const char *serial,
+                   uint16_t local_port, unsigned inherit);
 
-sc_pid
-adb_forward_remove(const char *serial, 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);
 
-sc_pid
-adb_reverse(const char *serial, 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);
 
-sc_pid
-adb_reverse_remove(const char *serial, const char *device_socket_name);
+bool
+adb_push(struct sc_intr *intr, const char *serial, const char *local,
+         const char *remote, unsigned inherit);
 
-sc_pid
-adb_push(const char *serial, const char *local, const char *remote);
+bool
+adb_install(struct sc_intr *intr, const char *serial, const char *local,
+            unsigned inherit);
 
-sc_pid
-adb_install(const char *serial, const char *local);
-
-// Return the result of "adb get-serialno".
+/**
+ * Execute `adb get-serialno`
+ *
+ * Return the result, to be freed by the caller, or NULL on error.
+ */
 char *
-adb_get_serialno(void);
+adb_get_serialno(struct sc_intr *intr, unsigned inherit);
 
 #endif

app/src/adb_tunnel.c

@@ -9,33 +9,6 @@
 
 #define SC_SOCKET_NAME "scrcpy"
 
-static bool
-enable_tunnel_reverse(struct sc_intr *intr, const char *serial,
-                      uint16_t local_port) {
-    sc_pid pid = adb_reverse(serial, SC_SOCKET_NAME, local_port);
-    return sc_process_check_success_intr(intr, pid, "adb reverse");
-}
-
-static bool
-disable_tunnel_reverse(struct sc_intr *intr, const char *serial) {
-    sc_pid pid = adb_reverse_remove(serial, SC_SOCKET_NAME);
-    return sc_process_check_success_intr(intr, pid, "adb reverse --remove");
-}
-
-static bool
-enable_tunnel_forward(struct sc_intr *intr, const char *serial,
-                      uint16_t local_port) {
-    sc_pid pid = adb_forward(serial, local_port, SC_SOCKET_NAME);
-    return sc_process_check_success_intr(intr, pid, "adb forward");
-}
-
-static bool
-disable_tunnel_forward(struct sc_intr *intr, const char *serial,
-                       uint16_t local_port) {
-    sc_pid pid = adb_forward_remove(serial, local_port);
-    return sc_process_check_success_intr(intr, pid, "adb forward --remove");
-}
-
 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);
@@ -47,7 +20,8 @@ enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
                                struct sc_port_range port_range) {
     uint16_t port = port_range.first;
     for (;;) {
-        if (!enable_tunnel_reverse(intr, serial, port)) {
+        if (!adb_reverse(intr, serial, SC_SOCKET_NAME, port,
+                         SC_INHERIT_STDERR)) {
             // the command itself failed, it will fail on any port
             return false;
         }
@@ -78,7 +52,8 @@ enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
         }
 
         // failure, disable tunnel and try another port
-        if (!disable_tunnel_reverse(intr, serial)) {
+        if (!adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+                                SC_INHERIT_STDERR)) {
             LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
         }
 
@@ -108,7 +83,8 @@ enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
 
     uint16_t port = port_range.first;
     for (;;) {
-        if (enable_tunnel_forward(intr, serial, port)) {
+        if (adb_forward(intr, serial, port, SC_SOCKET_NAME,
+                        SC_INHERIT_STDERR)) {
             // success
             tunnel->local_port = port;
             tunnel->enabled = true;
@@ -173,9 +149,11 @@ sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
 
     bool ret;
     if (tunnel->forward) {
-        ret = disable_tunnel_forward(intr, serial, tunnel->local_port);
+        ret = adb_forward_remove(intr, serial, tunnel->local_port,
+                                 SC_INHERIT_STDERR);
     } else {
-        ret = disable_tunnel_reverse(intr, serial);
+        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+                                 SC_INHERIT_STDERR);
 
         assert(tunnel->server_socket != SC_SOCKET_NONE);
         if (!net_close(tunnel->server_socket)) {

app/src/cli.c

@@ -569,6 +569,10 @@ sc_getopt_adapter_create_longopts(void) {
     size_t out_idx = 0;
     for (size_t i = 0; i < ARRAY_LEN(options); ++i) {
         const struct sc_option *in = &options[i];
+
+        // If longopt_id is set, then longopt must be set
+        assert(!in->longopt_id || in->longopt);
+
         if (!in->longopt) {
             // The longopts array must only contain long options
             continue;
@@ -671,12 +675,12 @@ print_option_usage_header(const struct sc_option *opt) {
         }
     }
 
-    fprintf(stderr, "\n    %s\n", buf.s);
+    printf("\n    %s\n", buf.s);
     free(buf.s);
     return;
 
 error:
-    fprintf(stderr, "<ERROR>\n");
+    printf("<ERROR>\n");
 }
 
 static void
@@ -692,11 +696,11 @@ print_option_usage(const struct sc_option *opt, unsigned cols) {
 
     char *text = sc_str_wrap_lines(opt->text, cols, 8);
     if (!text) {
-        fprintf(stderr, "<ERROR>\n");
+        printf("<ERROR>\n");
         return;
     }
 
-    fprintf(stderr, "%s\n", text);
+    printf("%s\n", text);
     free(text);
 }
 
@@ -707,11 +711,11 @@ print_shortcuts_intro(unsigned cols) {
         "(left) Alt or (left) Super, but it can be configured by "
         "--shortcut-mod (see above).", cols, 4);
     if (!intro) {
-        fprintf(stderr, "<ERROR>\n");
+        printf("<ERROR>\n");
         return;
     }
 
-    fprintf(stderr, "%s\n", intro);
+    printf("%s\n", intro);
     free(intro);
 }
 
@@ -721,21 +725,21 @@ print_shortcut(const struct sc_shortcut *shortcut, unsigned cols) {
     assert(shortcut->shortcuts[0]); // At least one shortcut
     assert(shortcut->text);
 
-    fprintf(stderr, "\n");
+    printf("\n");
 
     unsigned i = 0;
     while (shortcut->shortcuts[i]) {
-        fprintf(stderr, "    %s\n", shortcut->shortcuts[i]);
+        printf("    %s\n", shortcut->shortcuts[i]);
         ++i;
     };
 
     char *text = sc_str_wrap_lines(shortcut->text, cols, 8);
     if (!text) {
-        fprintf(stderr, "<ERROR>\n");
+        printf("<ERROR>\n");
         return;
     }
 
-    fprintf(stderr, "%s\n", text);
+    printf("%s\n", text);
     free(text);
 }
 
@@ -759,14 +763,14 @@ scrcpy_print_usage(const char *arg0) {
         }
     }
 
-    fprintf(stderr, "Usage: %s [options]\n\n"
-                    "Options:\n", arg0);
+    printf("Usage: %s [options]\n\n"
+            "Options:\n", arg0);
     for (size_t i = 0; i < ARRAY_LEN(options); ++i) {
         print_option_usage(&options[i], cols);
     }
 
     // Print shortcuts section
-    fprintf(stderr, "\nShortcuts:\n\n");
+    printf("\nShortcuts:\n\n");
     print_shortcuts_intro(cols);
     for (size_t i = 0; i < ARRAY_LEN(shortcuts); ++i) {
         print_shortcut(&shortcuts[i], cols);

app/src/file_handler.c

@@ -5,6 +5,7 @@
 
 #include "adb.h"
 #include "util/log.h"
+#include "util/process_intr.h"
 
 #define DEFAULT_PUSH_TARGET "/sdcard/Download/"
 
@@ -16,6 +17,7 @@ file_handler_request_destroy(struct file_handler_request *req) {
 bool
 file_handler_init(struct file_handler *file_handler, const char *serial,
                   const char *push_target) {
+    assert(serial);
 
     cbuf_init(&file_handler->queue);
 
@@ -30,23 +32,26 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
         return false;
     }
 
-    if (serial) {
-        file_handler->serial = strdup(serial);
-        if (!file_handler->serial) {
-            LOGW("Could not strdup serial");
-            sc_cond_destroy(&file_handler->event_cond);
-            sc_mutex_destroy(&file_handler->mutex);
-            return false;
-        }
-    } else {
-        file_handler->serial = NULL;
+    ok = sc_intr_init(&file_handler->intr);
+    if (!ok) {
+        LOGE("Could not create intr");
+        sc_cond_destroy(&file_handler->event_cond);
+        sc_mutex_destroy(&file_handler->mutex);
+    }
+
+    file_handler->serial = strdup(serial);
+    if (!file_handler->serial) {
+        LOGE("Could not strdup serial");
+        sc_intr_destroy(&file_handler->intr);
+        sc_cond_destroy(&file_handler->event_cond);
+        sc_mutex_destroy(&file_handler->mutex);
+        return false;
     }
 
     // lazy initialization
     file_handler->initialized = false;
 
     file_handler->stopped = false;
-    file_handler->current_process = SC_PROCESS_NONE;
 
     file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
 
@@ -57,6 +62,7 @@ void
 file_handler_destroy(struct file_handler *file_handler) {
     sc_cond_destroy(&file_handler->event_cond);
     sc_mutex_destroy(&file_handler->mutex);
+    sc_intr_destroy(&file_handler->intr);
     free(file_handler->serial);
 
     struct file_handler_request req;
@@ -65,16 +71,6 @@ file_handler_destroy(struct file_handler *file_handler) {
     }
 }
 
-static sc_pid
-install_apk(const char *serial, const char *file) {
-    return adb_install(serial, file);
-}
-
-static sc_pid
-push_file(const char *serial, const char *file, const char *push_target) {
-    return adb_push(serial, file, push_target);
-}
-
 bool
 file_handler_request(struct file_handler *file_handler,
                      file_handler_action_t action, char *file) {
@@ -106,10 +102,16 @@ file_handler_request(struct file_handler *file_handler,
 static int
 run_file_handler(void *data) {
     struct file_handler *file_handler = data;
+    struct sc_intr *intr = &file_handler->intr;
+
+    const char *serial = file_handler->serial;
+    assert(serial);
+
+    const char *push_target = file_handler->push_target;
+    assert(push_target);
 
     for (;;) {
         sc_mutex_lock(&file_handler->mutex);
-        file_handler->current_process = SC_PROCESS_NONE;
         while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
             sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
         }
@@ -122,43 +124,28 @@ run_file_handler(void *data) {
         bool non_empty = cbuf_take(&file_handler->queue, &req);
         assert(non_empty);
         (void) non_empty;
-
-        sc_pid pid;
-        if (req.action == ACTION_INSTALL_APK) {
-            LOGI("Installing %s...", req.file);
-            pid = install_apk(file_handler->serial, req.file);
-        } else {
-            LOGI("Pushing %s...", req.file);
-            pid = push_file(file_handler->serial, req.file,
-                            file_handler->push_target);
-        }
-        file_handler->current_process = pid;
         sc_mutex_unlock(&file_handler->mutex);
 
         if (req.action == ACTION_INSTALL_APK) {
-            if (sc_process_check_success(pid, "adb install", false)) {
+            LOGI("Installing %s...", req.file);
+            bool ok = adb_install(intr, serial, req.file,
+                                  SC_INHERIT_STDOUT | SC_INHERIT_STDERR);
+            if (ok) {
                 LOGI("%s successfully installed", req.file);
             } else {
                 LOGE("Failed to install %s", req.file);
             }
         } else {
-            if (sc_process_check_success(pid, "adb push", false)) {
-                LOGI("%s successfully pushed to %s", req.file,
-                                                     file_handler->push_target);
+            LOGI("Pushing %s...", req.file);
+            bool ok = adb_push(intr, serial, req.file, push_target,
+                               SC_INHERIT_STDOUT | SC_INHERIT_STDERR);
+            if (ok) {
+                LOGI("%s successfully pushed to %s", req.file, push_target);
             } else {
-                LOGE("Failed to push %s to %s", req.file,
-                                                file_handler->push_target);
+                LOGE("Failed to push %s to %s", req.file, push_target);
             }
         }
 
-        sc_mutex_lock(&file_handler->mutex);
-        // Close the process (it is necessarily already terminated)
-        // Execute this call with mutex locked to avoid race conditions with
-        // file_handler_stop()
-        sc_process_close(file_handler->current_process);
-        file_handler->current_process = SC_PROCESS_NONE;
-        sc_mutex_unlock(&file_handler->mutex);
-
         file_handler_request_destroy(&req);
     }
     return 0;
@@ -183,11 +170,7 @@ file_handler_stop(struct file_handler *file_handler) {
     sc_mutex_lock(&file_handler->mutex);
     file_handler->stopped = true;
     sc_cond_signal(&file_handler->event_cond);
-    if (file_handler->current_process != SC_PROCESS_NONE) {
-        if (!sc_process_terminate(file_handler->current_process)) {
-            LOGW("Could not terminate push/install process");
-        }
-    }
+    sc_intr_interrupt(&file_handler->intr);
     sc_mutex_unlock(&file_handler->mutex);
 }
 

app/src/file_handler.h

@@ -8,6 +8,7 @@
 #include "adb.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
+#include "util/intr.h"
 
 typedef enum {
     ACTION_INSTALL_APK,
@@ -29,8 +30,9 @@ struct file_handler {
     sc_cond event_cond;
     bool stopped;
     bool initialized;
-    sc_pid current_process;
     struct file_handler_request_queue queue;
+
+    struct sc_intr intr;
 };
 
 bool

app/src/main.c

@@ -47,6 +47,9 @@ main(int argc, char *argv[]) {
     setbuf(stderr, NULL);
 #endif
 
+    printf("scrcpy " SCRCPY_VERSION
+           " <https://github.com/Genymobile/scrcpy>\n");
+
     struct scrcpy_cli_args args = {
         .opts = scrcpy_options_default,
         .help = false,
@@ -73,8 +76,6 @@ main(int argc, char *argv[]) {
         return 0;
     }
 
-    LOGI("scrcpy " SCRCPY_VERSION " <https://github.com/Genymobile/scrcpy>");
-
 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
     av_register_all();
 #endif

app/src/scrcpy.c

@@ -394,8 +394,11 @@ scrcpy(struct scrcpy_options *options) {
     // It is necessarily initialized here, since the device is connected
     struct sc_server_info *info = &s->server.info;
 
+    const char *serial = s->server.params.serial;
+    assert(serial);
+
     if (options->display && options->control) {
-        if (!file_handler_init(&s->file_handler, options->serial,
+        if (!file_handler_init(&s->file_handler, serial,
                                options->push_target)) {
             goto end;
         }
@@ -516,21 +519,7 @@ scrcpy(struct scrcpy_options *options) {
 #ifdef HAVE_AOA_HID
             bool aoa_hid_ok = false;
 
-            char *serialno = NULL;
-
-            const char *serial = options->serial;
-            if (!serial) {
-                serialno = adb_get_serialno();
-                if (!serialno) {
-                    LOGE("Could not get device serial");
-                    goto aoa_hid_end;
-                }
-                serial = serialno;
-                LOGI("Device serial: %s", serial);
-            }
-
             bool ok = sc_aoa_init(&s->aoa, serial);
-            free(serialno);
             if (!ok) {
                 goto aoa_hid_end;
             }

app/src/server.c

@@ -112,9 +112,10 @@ push_server(struct sc_intr *intr, const char *serial) {
         free(server_path);
         return false;
     }
-    sc_pid pid = adb_push(serial, server_path, SC_DEVICE_SERVER_PATH);
+    bool ok = adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH,
+                       SC_INHERIT_STDERR);
     free(server_path);
-    return sc_process_check_success_intr(intr, pid, "adb push");
+    return ok;
 }
 
 static const char *
@@ -198,7 +199,9 @@ execute_server(struct sc_server *server,
     //     Port: 5005
     // Then click on "Debug"
 #endif
-    return adb_execute(serial, cmd, ARRAY_LEN(cmd));
+    // Inherit both stdout and stderr (all server logs are printed to stdout)
+    return adb_execute(serial, cmd, ARRAY_LEN(cmd),
+                       SC_INHERIT_STDOUT | SC_INHERIT_STDERR);
 }
 
 static bool
@@ -422,17 +425,44 @@ sc_server_on_terminated(void *userdata) {
     LOGD("Server terminated");
 }
 
+static bool
+sc_server_fill_serial(struct sc_server *server) {
+    // Retrieve the actual device immediately if not provided, so that all
+    // future adb commands are executed for this specific device, even if other
+    // devices are connected afterwards (without "more than one
+    // 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_INHERIT_STDERR);
+        if (!server->params.serial) {
+            LOGE("Could not get device serial");
+            return false;
+        }
+    }
+
+    return true;
+}
+
 static int
 run_server(void *data) {
     struct sc_server *server = data;
 
+    if (!sc_server_fill_serial(server)) {
+        goto error_connection_failed;
+    }
+
     const struct sc_server_params *params = &server->params;
 
+    LOGD("Device serial: %s", params->serial);
+
     bool ok = push_server(&server->intr, params->serial);
     if (!ok) {
         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/sys/unix/process.c

@@ -11,8 +11,16 @@
 #include "util/log.h"
 
 enum sc_process_result
-sc_process_execute_p(const char *const argv[], sc_pid *pid,
+sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned inherit,
                      int *pin, int *pout, int *perr) {
+    bool inherit_stdout = inherit & SC_INHERIT_STDOUT;
+    bool inherit_stderr = inherit & SC_INHERIT_STDERR;
+
+    // If pout is defined, then inherit MUST NOT contain SC_INHERIT_STDOUT.
+    assert(!pout || !inherit_stdout);
+    // If perr is defined, then inherit MUST NOT contain SC_INHERIT_STDERR.
+    assert(!perr || !inherit_stderr);
+
     int in[2];
     int out[2];
     int err[2];
@@ -90,20 +98,31 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid,
             }
             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,12 +27,17 @@ 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,
+sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned inherit,
                      HANDLE *pin, HANDLE *pout, HANDLE *perr) {
-    enum sc_process_result ret = SC_PROCESS_ERROR_GENERIC;
+    bool inherit_stdout = inherit & SC_INHERIT_STDOUT;
+    bool inherit_stderr = inherit & SC_INHERIT_STDERR;
 
-    // Add 1 per non-NULL pointer
-    unsigned handle_count = !!pin + !!pout + !!perr;
+    // If pout is defined, then inherit MUST NOT contain SC_INHERIT_STDOUT.
+    assert(!pout || !inherit_stdout);
+    // If perr is defined, then inherit MUST NOT contain SC_INHERIT_STDERR.
+    assert(!perr || !inherit_stderr);
+
+    enum sc_process_result ret = SC_PROCESS_ERROR_GENERIC;
 
     SECURITY_ATTRIBUTES sa;
     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
@@ -80,59 +85,52 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle,
     HANDLE handles[3];
 
     LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList = NULL;
-    if (handle_count) {
-        si.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
-        if (pin) {
-            si.StartupInfo.hStdInput = stdin_read_handle;
-        }
-        if (pout) {
-            si.StartupInfo.hStdOutput = stdout_write_handle;
-        }
-        if (perr) {
-            si.StartupInfo.hStdError = stderr_write_handle;
-        }
+    si.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
 
-        SIZE_T size;
-        // Call it once to know the required buffer size
-        BOOL ok =
-            InitializeProcThreadAttributeList(NULL, 1, 0, &size)
-                || GetLastError() == ERROR_INSUFFICIENT_BUFFER;
-        if (!ok) {
-            goto error_close_stderr;
-        }
-
-        lpAttributeList = malloc(size);
-        if (!lpAttributeList) {
-            goto error_close_stderr;
-        }
-
-        ok = InitializeProcThreadAttributeList(lpAttributeList, 1, 0, &size);
-        if (!ok) {
-            free(lpAttributeList);
-            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),
-                                       NULL, NULL);
-        if (!ok) {
-            goto error_free_attribute_list;
-        }
-
-        si.lpAttributeList = lpAttributeList;
+    unsigned handle_count = 0;
+    if (pin) {
+        si.StartupInfo.hStdInput = stdin_read_handle;
+        handles[handle_count++] = si.StartupInfo.hStdInput;
     }
+    if (pout || inherit_stdout) {
+        si.StartupInfo.hStdOutput = pout ? stdout_write_handle
+                                         : GetStdHandle(STD_OUTPUT_HANDLE);
+        handles[handle_count++] = si.StartupInfo.hStdOutput;
+    }
+    if (perr || inherit_stderr) {
+        si.StartupInfo.hStdError = perr ? stderr_write_handle
+                                        : GetStdHandle(STD_ERROR_HANDLE);
+        handles[handle_count++] = si.StartupInfo.hStdError;
+    }
+
+    SIZE_T size;
+    // Call it once to know the required buffer size
+    BOOL ok =
+        InitializeProcThreadAttributeList(NULL, 1, 0, &size)
+            || GetLastError() == ERROR_INSUFFICIENT_BUFFER;
+    if (!ok) {
+        goto error_close_stderr;
+    }
+
+    lpAttributeList = malloc(size);
+    if (!lpAttributeList) {
+        goto error_close_stderr;
+    }
+
+    ok = InitializeProcThreadAttributeList(lpAttributeList, 1, 0, &size);
+    if (!ok) {
+        free(lpAttributeList);
+        goto error_close_stderr;
+    }
+
+    ok = UpdateProcThreadAttribute(lpAttributeList, 0,
+                                   PROC_THREAD_ATTRIBUTE_HANDLE_LIST, handles,
+                                   handle_count * sizeof(HANDLE), NULL, NULL);
+    if (!ok) {
+        goto error_free_attribute_list;
+    }
+
+    si.lpAttributeList = lpAttributeList;
 
     char *cmd = malloc(CMD_MAX_LEN);
     if (!cmd || !build_cmd(cmd, CMD_MAX_LEN, argv)) {
@@ -146,10 +144,9 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle,
         goto error_free_attribute_list;
     }
 
-    BOOL bInheritHandles = handle_count > 0;
-    DWORD dwCreationFlags = handle_count > 0 ? EXTENDED_STARTUPINFO_PRESENT : 0;
-    BOOL ok = CreateProcessW(NULL, wide, NULL, NULL, bInheritHandles,
-                             dwCreationFlags, NULL, NULL, &si.StartupInfo, &pi);
+    ok = CreateProcessW(NULL, wide, NULL, NULL, TRUE,
+                        EXTENDED_STARTUPINFO_PRESENT, NULL, NULL,
+                        &si.StartupInfo, &pi);
     free(wide);
     if (!ok) {
         if (GetLastError() == ERROR_FILE_NOT_FOUND) {

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) {
-    return sc_process_execute_p(argv, pid, NULL, NULL, NULL);
+sc_process_execute(const char *const argv[], sc_pid *pid, unsigned inherit) {
+    return sc_process_execute_p(argv, pid, inherit, NULL, NULL, NULL);
 }
 
 bool

app/src/util/process.h

@@ -67,20 +67,32 @@ enum sc_process_result {
     SC_PROCESS_ERROR_MISSING_BINARY,
 };
 
+#define SC_INHERIT_NONE    0
+#define SC_INHERIT_STDOUT (1 << 0)
+#define SC_INHERIT_STDERR (1 << 1)
+
 /**
  * Execute the command and write the process id to `pid`
+ *
+ * The parameter `inherit` is a ORed value of SC_INHERIT_* flags. 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);
+sc_process_execute(const char *const argv[], sc_pid *pid, unsigned inherit);
 
 /**
  * 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_INHERIT_STDOUT.
+ * If `perr` is not NULL, then `inherit` MUST NOT contain SC_INHERIT_STDERR.
  */
 enum sc_process_result
-sc_process_execute_p(const char *const argv[], sc_pid *pid,
+sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned inherit,
                      sc_pipe *pin, sc_pipe *pout, sc_pipe *perr);
 
 /**

app/src/util/process_intr.c

@@ -2,7 +2,7 @@
 
 bool
 sc_process_check_success_intr(struct sc_intr *intr, sc_pid pid,
-                              const char *name) {
+                              const char *name, bool close) {
     if (!sc_intr_set_process(intr, pid)) {
         // Already interrupted
         return false;
@@ -11,6 +11,40 @@ sc_process_check_success_intr(struct sc_intr *intr, sc_pid pid,
     // Always pass close=false, interrupting would be racy otherwise
     bool ret = sc_process_check_success(pid, name, false);
 
+    sc_intr_set_process(intr, SC_PROCESS_NONE);
+
+    if (close) {
+        // Close separately
+        sc_process_close(pid);
+    }
+
+    return ret;
+}
+
+ssize_t
+sc_pipe_read_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe, char *data,
+                  size_t len) {
+    if (!sc_intr_set_process(intr, pid)) {
+        // Already interrupted
+        return false;
+    }
+
+    ssize_t ret = sc_pipe_read(pipe, data, len);
+
+    sc_intr_set_process(intr, SC_PROCESS_NONE);
+    return ret;
+}
+
+ssize_t
+sc_pipe_read_all_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe,
+                      char *data, size_t len) {
+    if (!sc_intr_set_process(intr, pid)) {
+        // Already interrupted
+        return false;
+    }
+
+    ssize_t ret = sc_pipe_read_all(pipe, data, len);
+
     sc_intr_set_process(intr, SC_PROCESS_NONE);
     return ret;
 }

app/src/util/process_intr.h

@@ -8,6 +8,14 @@
 
 bool
 sc_process_check_success_intr(struct sc_intr *intr, sc_pid pid,
-                              const char *name);
+                              const char *name, bool close);
+
+ssize_t
+sc_pipe_read_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe, char *data,
+                  size_t len);
+
+ssize_t
+sc_pipe_read_all_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe,
+                      char *data, size_t len);
 
 #endif

app/src/util/str.c

@@ -291,3 +291,11 @@ error:
     free(buf.s);
     return NULL;
 }
+
+size_t
+sc_str_truncate(char *data, size_t len, const char *endchars) {
+    data[len - 1] = '\0';
+    size_t idx = strcspn(data, endchars);
+    data[idx] = '\0';
+    return idx;
+}

app/src/util/str.h

@@ -103,4 +103,15 @@ sc_str_from_wchars(const wchar_t *s);
 char *
 sc_str_wrap_lines(const char *input, unsigned columns, unsigned indent);
 
+/**
+ * Truncate the data after any of the characters from `endchars`
+ *
+ * An '\0' is always written at the end of the data, even if no newline
+ * character is encountered.
+ *
+ * Return the size of the resulting line.
+ */
+size_t
+sc_str_truncate(char *data, size_t len, const char *endchars);
+
 #endif

app/tests/test_str.c

@@ -337,6 +337,32 @@ static void test_wrap_lines(void) {
     free(formatted);
 }
 
+static void test_truncate(void) {
+    char s[] = "hello\nworld\n!";
+    size_t len = sc_str_truncate(s, sizeof(s), "\n");
+
+    assert(len == 5);
+    assert(!strcmp("hello", s));
+
+    char s2[] = "hello\r\nworkd\r\n!";
+    len = sc_str_truncate(s2, sizeof(s2), "\n\r");
+
+    assert(len == 5);
+    assert(!strcmp("hello", s));
+
+    char s3[] = "hello world\n!";
+    len = sc_str_truncate(s3, sizeof(s3), " \n\r");
+
+    assert(len == 5);
+    assert(!strcmp("hello", s3));
+
+    char s4[] = "hello ";
+    len = sc_str_truncate(s4, sizeof(s4), " \n\r");
+
+    assert(len == 5);
+    assert(!strcmp("hello", s4));
+}
+
 int main(int argc, char *argv[]) {
     (void) argc;
     (void) argv;
@@ -356,5 +382,6 @@ int main(int argc, char *argv[]) {
     test_parse_integer_with_suffix();
     test_strlist_contains();
     test_wrap_lines();
+    test_truncate();
     return 0;
 }