From 1038bad3850f18717a048a4d5c0f8110e54ee172 Mon Sep 17 00:00:00 2001 From: Romain Vimont Date: Mon, 12 Mar 2018 08:35:51 +0100 Subject: [PATCH] Make it work over tcpip "adb reverse" currently does not work over tcpip (i.e. on a device connected by "adb connect"): To work around the problem, if the call to "adb reverse" fails, then fallback to "adb forward", and reverse the client/server roles. Keep the "adb reverse" mode as the default because it does not involve connection retries: when using "adb forward", the client must try to connect successively until the server listens. Due to the tunnel, every connect() will succeed, so the client must attempt to read() to detect a connection failure. For this purpose, when using the "adb forward" mode, the server initially writes a dummy byte, read by the client. Fixes . --- app/src/command.c | 7 + app/src/command.h | 1 + app/src/net.c | 20 +++ app/src/net.h | 1 + app/src/server.c | 131 ++++++++++++++---- app/src/server.h | 10 +- .../genymobile/scrcpy/DesktopConnection.java | 17 ++- .../java/com/genymobile/scrcpy/Options.java | 9 ++ .../java/com/genymobile/scrcpy/Server.java | 10 +- 9 files changed, 174 insertions(+), 32 deletions(-) diff --git a/app/src/command.c b/app/src/command.c index 6a5a38e4..246d1515 100644 --- a/app/src/command.c +++ b/app/src/command.c @@ -45,6 +45,13 @@ process_t adb_forward(const char *serial, uint16_t local_port, const char *devic return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd)); } +process_t adb_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)); +} + process_t adb_reverse(const char *serial, const char *device_socket_name, uint16_t local_port) { char local[4 + 5 + 1]; // tcp:PORT char remote[108 + 14 + 1]; // localabstract:NAME diff --git a/app/src/command.h b/app/src/command.h index 5308aa6a..ed7d5faf 100644 --- a/app/src/command.h +++ b/app/src/command.h @@ -39,6 +39,7 @@ SDL_bool cmd_simple_wait(process_t pid, exit_code_t *exit_code); process_t adb_execute(const char *serial, const char *const adb_cmd[], int len); process_t adb_forward(const char *serial, uint16_t local_port, const char *device_socket_name); +process_t adb_forward_remove(const char *serial, uint16_t local_port); process_t adb_reverse(const char *serial, const char *device_socket_name, uint16_t local_port); process_t adb_reverse_remove(const char *serial, const char *device_socket_name); process_t adb_push(const char *serial, const char *local, const char *remote); diff --git a/app/src/net.c b/app/src/net.c index 60fb3988..1d68f068 100644 --- a/app/src/net.c +++ b/app/src/net.c @@ -18,6 +18,26 @@ typedef struct in_addr IN_ADDR; #endif +socket_t net_connect(Uint32 addr, Uint16 port) { + socket_t sock = socket(AF_INET, SOCK_STREAM, 0); + if (sock == INVALID_SOCKET) { + perror("socket"); + return INVALID_SOCKET; + } + + SOCKADDR_IN sin; + sin.sin_family = AF_INET; + sin.sin_addr.s_addr = htonl(addr); + sin.sin_port = htons(port); + + if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) { + perror("connect"); + return INVALID_SOCKET; + } + + return sock; +} + socket_t net_listen(Uint32 addr, Uint16 port, int backlog) { socket_t sock = socket(AF_INET, SOCK_STREAM, 0); if (sock == INVALID_SOCKET) { diff --git a/app/src/net.h b/app/src/net.h index 03ad8c39..52a1e9a4 100644 --- a/app/src/net.h +++ b/app/src/net.h @@ -21,6 +21,7 @@ SDL_bool net_init(void); void net_cleanup(void); +socket_t net_connect(Uint32 addr, Uint16 port); socket_t net_listen(Uint32 addr, Uint16 port, int backlog); socket_t net_accept(socket_t server_socket); diff --git a/app/src/server.c b/app/src/server.c index 1e1c95bd..33f25b55 100644 --- a/app/src/server.c +++ b/app/src/server.c @@ -4,6 +4,7 @@ #include #include #include +#include #include "config.h" #include "log.h" @@ -37,17 +38,45 @@ static SDL_bool remove_server(const char *serial) { return process_check_success(process, "adb shell rm"); } -static SDL_bool enable_tunnel(const char *serial, Uint16 local_port) { +static SDL_bool enable_tunnel_reverse(const char *serial, Uint16 local_port) { process_t process = adb_reverse(serial, SOCKET_NAME, local_port); return process_check_success(process, "adb reverse"); } -static SDL_bool disable_tunnel(const char *serial) { +static SDL_bool disable_tunnel_reverse(const char *serial) { process_t process = adb_reverse_remove(serial, SOCKET_NAME); return process_check_success(process, "adb reverse --remove"); } -static process_t execute_server(const char *serial, Uint16 max_size, Uint32 bit_rate) { +static SDL_bool enable_tunnel_forward(const char *serial, Uint16 local_port) { + process_t process = adb_forward(serial, local_port, SOCKET_NAME); + return process_check_success(process, "adb forward"); +} + +static SDL_bool disable_tunnel_forward(const char *serial, Uint16 local_port) { + process_t process = adb_forward_remove(serial, local_port); + return process_check_success(process, "adb forward --remove"); +} + +static SDL_bool enable_tunnel(struct server *server) { + if (enable_tunnel_reverse(server->serial, server->local_port)) { + return SDL_TRUE; + } + + LOGW("'adb reverse' failed, fallback to 'adb forward'"); + server->tunnel_forward = SDL_TRUE; + return enable_tunnel_forward(server->serial, server->local_port); +} + +static SDL_bool disable_tunnel(struct server *server) { + if (server->tunnel_forward) { + return disable_tunnel_forward(server->serial, server->local_port); + } + return disable_tunnel_reverse(server->serial); +} + +static process_t execute_server(const char *serial, + Uint16 max_size, Uint32 bit_rate, SDL_bool tunnel_forward) { char max_size_string[6]; char bit_rate_string[11]; sprintf(max_size_string, "%"PRIu16, max_size); @@ -60,15 +89,48 @@ static process_t execute_server(const char *serial, Uint16 max_size, Uint32 bit_ "com.genymobile.scrcpy.Server", max_size_string, bit_rate_string, + tunnel_forward ? "true" : "false", }; return adb_execute(serial, cmd, sizeof(cmd) / sizeof(cmd[0])); } -static socket_t listen_on_port(Uint16 port) { #define IPV4_LOCALHOST 0x7F000001 + +static socket_t listen_on_port(Uint16 port) { return net_listen(IPV4_LOCALHOST, port, 1); } +static socket_t connect_and_read_byte(Uint16 port) { + socket_t socket = net_connect(IPV4_LOCALHOST, port); + if (socket == INVALID_SOCKET) { + return INVALID_SOCKET; + } + + char byte; + // the connection may succeed even if the server behind the "adb tunnel" + // is not listening, so read one byte to detect a working connection + if (net_recv_all(socket, &byte, 1) != 1) { + // the server is not listening yet behind the adb tunnel + return INVALID_SOCKET; + } + return socket; +} + +static socket_t connect_to_server(Uint16 port, Uint32 attempts, Uint32 delay) { + do { + LOGD("Remaining connection attempts: %d", (int) attempts); + socket_t socket = connect_and_read_byte(port); + if (socket != INVALID_SOCKET) { + // it worked! + return socket; + } + if (attempts) { + SDL_Delay(delay); + } + } while (--attempts > 0); + return INVALID_SOCKET; +} + static void close_socket(socket_t *socket) { SDL_assert(*socket != INVALID_SOCKET); net_shutdown(*socket, SHUT_RDWR); @@ -85,6 +147,8 @@ void server_init(struct server *server) { SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port, Uint16 max_size, Uint32 bit_rate) { + server->local_port = local_port; + if (serial) { server->serial = SDL_strdup(serial); } @@ -95,52 +159,67 @@ SDL_bool server_start(struct server *server, const char *serial, Uint16 local_po server->server_copied_to_device = SDL_TRUE; - if (!enable_tunnel(serial, local_port)) { + if (!enable_tunnel(server)) { return SDL_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. + // if "adb reverse" does not work (e.g. over "adb connect"), it fallbacks to + // "adb forward", so the app socket is the client + if (!server->tunnel_forward) { + // 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. - server->server_socket = listen_on_port(local_port); - if (server->server_socket == INVALID_SOCKET) { - LOGE("Could not listen on port %" PRIu16, local_port); - disable_tunnel(serial); - return SDL_FALSE; + server->server_socket = listen_on_port(local_port); + if (server->server_socket == INVALID_SOCKET) { + LOGE("Could not listen on port %" PRIu16, local_port); + disable_tunnel(server); + return SDL_FALSE; + } } // server will connect to our server socket - server->process = execute_server(serial, max_size, bit_rate); + server->process = execute_server(serial, max_size, bit_rate, server->tunnel_forward); if (server->process == PROCESS_NONE) { - close_socket(&server->server_socket); - disable_tunnel(serial); + if (!server->tunnel_forward) { + close_socket(&server->server_socket); + } + disable_tunnel(server); return SDL_FALSE; } - server->adb_reverse_enabled = SDL_TRUE; + server->tunnel_enabled = SDL_TRUE; return SDL_TRUE; } socket_t server_connect_to(struct server *server, Uint32 timeout_ms) { - server->device_socket = net_accept(server->server_socket); + if (!server->tunnel_forward) { + server->device_socket = net_accept(server->server_socket); + } else { + Uint32 attempts = 10; + Uint32 delay = 100; // ms + server->device_socket = connect_to_server(server->local_port, attempts, delay); + } + if (server->device_socket == INVALID_SOCKET) { return INVALID_SOCKET; } - // we don't need the server socket anymore - close_socket(&server->server_socket); + if (!server->tunnel_forward) { + // we don't need the server socket anymore + close_socket(&server->server_socket); + } // the server is started, we can clean up the jar from the temporary folder remove_server(server->serial); // ignore failure server->server_copied_to_device = SDL_FALSE; // we don't need the adb tunnel anymore - disable_tunnel(server->serial); // ignore failure - server->adb_reverse_enabled = SDL_FALSE; + disable_tunnel(server); // ignore failure + server->tunnel_enabled = SDL_FALSE; return server->device_socket; } @@ -155,9 +234,9 @@ void server_stop(struct server *server) { cmd_simple_wait(server->process, NULL); // ignore exit code LOGD("Server terminated"); - if (server->adb_reverse_enabled) { + if (server->tunnel_enabled) { // ignore failure - disable_tunnel(server->serial); + disable_tunnel(server); } if (server->server_copied_to_device) { diff --git a/app/src/server.h b/app/src/server.h index 63547343..fcd44b8d 100644 --- a/app/src/server.h +++ b/app/src/server.h @@ -7,9 +7,11 @@ struct server { const char *serial; process_t process; - socket_t server_socket; + socket_t server_socket; // only used if !tunnel_forward socket_t device_socket; - SDL_bool adb_reverse_enabled; + Uint16 local_port; + SDL_bool tunnel_enabled; + SDL_bool tunnel_forward; // use "adb forward" instead of "adb reverse" SDL_bool server_copied_to_device; }; @@ -18,7 +20,9 @@ struct server { .process = PROCESS_NONE, \ .server_socket = INVALID_SOCKET, \ .device_socket = INVALID_SOCKET, \ - .adb_reverse_enabled = SDL_FALSE, \ + .local_port = 0, \ + .tunnel_enabled = SDL_FALSE, \ + .tunnel_forward = SDL_FALSE, \ .server_copied_to_device = SDL_FALSE, \ } diff --git a/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java b/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java index 203ecc9b..24735f78 100644 --- a/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java +++ b/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java @@ -1,5 +1,6 @@ package com.genymobile.scrcpy; +import android.net.LocalServerSocket; import android.net.LocalSocket; import android.net.LocalSocketAddress; @@ -33,8 +34,20 @@ public final class DesktopConnection implements Closeable { return localSocket; } - public static DesktopConnection open(Device device) throws IOException { - LocalSocket socket = connect(SOCKET_NAME); + private static LocalSocket listenAndAccept(String abstractName) throws IOException { + LocalServerSocket localServerSocket = new LocalServerSocket(abstractName); + return localServerSocket.accept(); + } + + public static DesktopConnection open(Device device, boolean tunnelForward) throws IOException { + LocalSocket socket; + if (tunnelForward) { + socket = listenAndAccept(SOCKET_NAME); + // send one byte so the client may read() to detect a connection error + socket.getOutputStream().write(0); + } else { + socket = connect(SOCKET_NAME); + } DesktopConnection connection = new DesktopConnection(socket); Size videoSize = device.getScreenInfo().getVideoSize(); diff --git a/server/src/main/java/com/genymobile/scrcpy/Options.java b/server/src/main/java/com/genymobile/scrcpy/Options.java index 6ab2f694..332463e6 100644 --- a/server/src/main/java/com/genymobile/scrcpy/Options.java +++ b/server/src/main/java/com/genymobile/scrcpy/Options.java @@ -3,6 +3,7 @@ package com.genymobile.scrcpy; public class Options { private int maxSize; private int bitRate; + private boolean tunnelForward; public int getMaxSize() { return maxSize; @@ -19,4 +20,12 @@ public class Options { public void setBitRate(int bitRate) { this.bitRate = bitRate; } + + public boolean isTunnelForward() { + return tunnelForward; + } + + public void setTunnelForward(boolean tunnelForward) { + this.tunnelForward = tunnelForward; + } } diff --git a/server/src/main/java/com/genymobile/scrcpy/Server.java b/server/src/main/java/com/genymobile/scrcpy/Server.java index 5df436d1..d7294ae0 100644 --- a/server/src/main/java/com/genymobile/scrcpy/Server.java +++ b/server/src/main/java/com/genymobile/scrcpy/Server.java @@ -10,7 +10,8 @@ public final class Server { private static void scrcpy(Options options) throws IOException { final Device device = new Device(options); - try (DesktopConnection connection = DesktopConnection.open(device)) { + boolean tunnelForward = options.isTunnelForward(); + try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward)) { ScreenEncoder screenEncoder = new ScreenEncoder(options.getBitRate()); // asynchronous @@ -55,6 +56,13 @@ public final class Server { int bitRate = Integer.parseInt(args[1]); options.setBitRate(bitRate); + if (args.length < 3) { + return options; + } + // use "adb forward" instead of "adb tunnel"? (so the server must listen) + boolean tunnelForward = Boolean.parseBoolean(args[2]); + options.setTunnelForward(tunnelForward); + return options; }