Use flags for adb commands

Explicitly indicate, for each adb call, if stdout and stderr must be
inherited.

PR #2827 <https://github.com/Genymobile/scrcpy/pull/2827>

app/src/adb.c

@@ -173,16 +173,26 @@ adb_create_argv(const char *serial, const char *const adb_cmd[], size_t len) {
 
 static sc_pid
 adb_execute_p(const char *serial, const char *const adb_cmd[], size_t len,
-              sc_pipe *pout) {
+              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, 0, NULL, pout, NULL);
+        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;
     }
@@ -192,61 +202,63 @@ adb_execute_p(const char *serial, const char *const adb_cmd[], size_t len,
 }
 
 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,
-    return adb_execute_p(serial, adb_cmd, len, NULL);
+            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) {
+            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));
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
     return process_check_success_intr(intr, pid, "adb forward");
 }
 
 bool
 adb_forward_remove(struct sc_intr *intr, const char *serial,
-                   uint16_t local_port) {
+                   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));
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
     return process_check_success_intr(intr, pid, "adb forward --remove");
 }
 
 bool
 adb_reverse(struct sc_intr *intr, const char *serial,
-            const char *device_socket_name, uint16_t local_port) {
+            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));
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
     return process_check_success_intr(intr, pid, "adb reverse");
 }
 
 bool
 adb_reverse_remove(struct sc_intr *intr, const char *serial,
-                   const char *device_socket_name) {
+                   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));
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
     return process_check_success_intr(intr, pid, "adb reverse --remove");
 }
 
 bool
 adb_push(struct sc_intr *intr, const char *serial, const char *local,
-         const char *remote) {
+         const char *remote, unsigned flags) {
 #ifdef __WINDOWS__
     // Windows will parse the string, so the paths must be quoted
     // (see sys/win/command.c)
@@ -262,7 +274,7 @@ adb_push(struct sc_intr *intr, const char *serial, const char *local,
 #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), flags);
 
 #ifdef __WINDOWS__
     free((void *) remote);
@@ -273,7 +285,8 @@ adb_push(struct sc_intr *intr, const char *serial, const char *local,
 }
 
 bool
-adb_install(struct sc_intr *intr, const char *serial, const char *local) {
+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)
@@ -284,7 +297,7 @@ adb_install(struct sc_intr *intr, 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), flags);
 
 #ifdef __WINDOWS__
     free((void *) local);
@@ -294,11 +307,11 @@ adb_install(struct sc_intr *intr, const char *serial, const char *local) {
 }
 
 char *
-adb_get_serialno(struct sc_intr *intr) {
+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), &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;

app/src/adb.h

@@ -8,31 +8,37 @@
 
 #include "util/intr.h"
 
+#define SC_ADB_NO_STDOUT (1 << 0)
+#define SC_ADB_NO_STDERR (1 << 1)
+
 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 flags);
 
 bool
 adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
-            const char *device_socket_name);
+            const char *device_socket_name, unsigned flags);
 
 bool
 adb_forward_remove(struct sc_intr *intr, const char *serial,
-                   uint16_t local_port);
+                   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);
+            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);
+                   const char *device_socket_name, unsigned flags);
 
 bool
 adb_push(struct sc_intr *intr, const char *serial, const char *local,
-         const char *remote);
+         const char *remote, unsigned flags);
 
 bool
-adb_install(struct sc_intr *intr, const char *serial, const char *local);
+adb_install(struct sc_intr *intr, const char *serial, const char *local,
+            unsigned flags);
 
 /**
  * Execute `adb get-serialno`
@@ -40,6 +46,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);
+adb_get_serialno(struct sc_intr *intr, unsigned flags);
 
 #endif

app/src/adb_tunnel.c

@@ -20,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 (!adb_reverse(intr, serial, SC_SOCKET_NAME, port)) {
+        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;
         }
@@ -51,7 +52,8 @@ 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)) {
+        if (!adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+                                SC_ADB_NO_STDOUT)) {
             LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
         }
 
@@ -81,7 +83,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)) {
+        if (adb_forward(intr, serial, port, SC_SOCKET_NAME, SC_ADB_NO_STDOUT)) {
             // success
             tunnel->local_port = port;
             tunnel->enabled = true;
@@ -146,9 +148,11 @@ 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);
+        ret = adb_forward_remove(intr, serial, tunnel->local_port,
+                                 SC_ADB_NO_STDOUT);
     } else {
-        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME);
+        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)) {

app/src/file_handler.c

@@ -128,7 +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);
+            bool ok = adb_install(intr, serial, req.file, 0);
             if (ok) {
                 LOGI("%s successfully installed", req.file);
             } else {
@@ -136,7 +136,7 @@ run_file_handler(void *data) {
             }
         } else {
             LOGI("Pushing %s...", req.file);
-            bool ok = adb_push(intr, serial, req.file, push_target);
+            bool ok = adb_push(intr, serial, req.file, push_target, 0);
             if (ok) {
                 LOGI("%s successfully pushed to %s", req.file, push_target);
             } else {

app/src/server.c

@@ -112,7 +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);
+    bool ok = adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH, 0);
     free(server_path);
     return ok;
 }
@@ -234,7 +234,8 @@ execute_server(struct sc_server *server,
     //     Port: 5005
     // Then click on "Debug"
 #endif
-    pid = adb_execute(params->serial, cmd, count);
+    // Inherit both stdout and stderr (all server logs are printed to stdout)
+    pid = adb_execute(params->serial, cmd, count, 0);
 
 end:
     for (unsigned i = dyn_idx; i < count; ++i) {
@@ -482,7 +483,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);
+        server->params.serial = adb_get_serialno(&server->intr, 0);
         if (!server->params.serial) {
             LOGE("Could not get device serial");
             return false;