| /* Copyright (C) 2006-2015 The Android Open Source Project |
| ** |
| ** This software is licensed under the terms of the GNU General Public |
| ** License version 2, as published by the Free Software Foundation, and |
| ** may be copied, distributed, and modified under those terms. |
| ** |
| ** This program is distributed in the hope that it will be useful, |
| ** but WITHOUT ANY WARRANTY; without even the implied warranty of |
| ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| ** GNU General Public License for more details. |
| */ |
| |
| #include "android/console.h" |
| #include "android/constants.h" |
| #include "android/adb-server.h" |
| #include "android/android.h" |
| #include "android/cmdline-option.h" |
| #include "android/clipboard-pipe.h" |
| #include "android/console.h" |
| #include "android/emulation/android_pipe_pingpong.h" |
| #include "android/emulation/android_pipe_throttle.h" |
| #include "android/emulation/android_pipe_unix.h" |
| #include "android/emulation/android_pipe_zero.h" |
| #include "android/globals.h" |
| #include "android/hw-fingerprint.h" |
| #include "android/hw-sensors.h" |
| #include "android/opengles-pipe.h" |
| #include "android/proxy/proxy_setup.h" |
| #include "android/utils/debug.h" |
| #include "android/utils/ipaddr.h" |
| #include "android/utils/path.h" |
| #include "android/utils/sockets.h" |
| #include "android/utils/system.h" |
| #include "android/utils/bufprint.h" |
| #include "android/version.h" |
| |
| |
| #include <stdbool.h> |
| |
| #define D(...) do { if (VERBOSE_CHECK(init)) dprint(__VA_ARGS__); } while (0) |
| |
| /* Contains arguments for -android-ports option. */ |
| char* android_op_ports = NULL; |
| /* Contains the parsed numbers from android_op_ports */ |
| int android_op_ports_numbers[2] = {-1, -1}; |
| /* Contains arguments for -android-port option. */ |
| char* android_op_port = NULL; |
| /* Contains the parsed number from android_op_port */ |
| int android_op_port_number = -1; |
| /* Contains arguments for -android-report-console option. */ |
| char* android_op_report_console = NULL; |
| /* Contains arguments for -http-proxy option. */ |
| char* op_http_proxy = NULL; |
| /* Base port for the emulated system. */ |
| int android_base_port; |
| /* ADB port */ |
| int android_adb_port = 5037; // Default |
| /* The device "serial number" is "emulator-<this number>" */ |
| int android_serial_number_port; |
| |
| // The following code is used to support the -report-console option, |
| // which takes a parameter in one of the following formats: |
| // |
| // tcp:<port>[,<options>] |
| // unix:<path>[,<options>] |
| // |
| // Where <options> is a comma-separated list of options which can be |
| // server - Enable server mode (waits for client connection). |
| // max=<count> - Set maximum connection attempts (client mode only). |
| // ipv6 - Use IPv6 localhost (::1) instead of (127.0.0.1) |
| // |
| |
| // bit flags returned by get_report_console_options() below. |
| enum { |
| REPORT_CONSOLE_SERVER = (1 << 0), |
| REPORT_CONSOLE_MAX = (1 << 1), |
| REPORT_CONSOLE_IPV6 = (1 << 2), |
| }; |
| |
| // Look at |end| for a comma-separated list of -report-console options |
| // and return a set of corresponding bit flags. Return -1 on failure. |
| // On success, if REPORT_CONSOLE_MAX is set in the result, |*maxtries| |
| // will be updated with the <count> parameter of the max= option. |
| static int get_report_console_options(char* end, int* maxtries) { |
| int flags = 0; |
| |
| if (end == NULL || *end == 0) { |
| return 0; |
| } |
| |
| if (end[0] != ',') { |
| derror("socket port/path can be followed by [,<option>]+ only"); |
| return -1; |
| } |
| end += 1; |
| while (*end) { |
| char* p = strchr(end, ','); |
| if (p == NULL) |
| p = end + strlen(end); |
| |
| if ((p - end) == strlen("server") && !memcmp(end, "server", p - end)) { |
| flags |= REPORT_CONSOLE_SERVER; |
| } else if (memcmp( end, "max=", 4) == 0) { |
| end += 4; |
| *maxtries = strtol( end, NULL, 10 ); |
| flags |= REPORT_CONSOLE_MAX; |
| } else if ((p - end) == strlen("ipv6") && |
| !memcmp(end, "ipv6", p - end)) { |
| flags |= REPORT_CONSOLE_IPV6; |
| } else { |
| derror("socket port/path can be followed by " |
| "[,server][,max=<count>][,ipv6] only"); |
| return -1; |
| } |
| |
| end = p; |
| if (*end) |
| end += 1; |
| } |
| return flags; |
| } |
| |
| // Implement -report-console option. |proto_port| is the option's parameter |
| // as described above (e.g. 'tcp:<port>,server'). And |console_port| is |
| // the emulator's console port to report. Return 0 on success, -1 on failure. |
| static int report_console(const char* proto_port, int console_port) { |
| int s = -1, s2; |
| int maxtries = 10; |
| int flags = 0; |
| signal_state_t sigstate; |
| |
| disable_sigalrm( &sigstate ); |
| |
| if ( !strncmp( proto_port, "tcp:", 4) ) { |
| char* end; |
| long port = strtol(proto_port + 4, &end, 10); |
| |
| flags = get_report_console_options( end, &maxtries ); |
| if (flags < 0) { |
| return -1; |
| } |
| |
| if (flags & REPORT_CONSOLE_SERVER) { |
| // TODO: Listen on both IPv6 and IPv4 interfaces at the same time? |
| if (flags & REPORT_CONSOLE_IPV6) { |
| s = socket_loopback6_server( port, SOCKET_STREAM ); |
| } else { |
| s = socket_loopback4_server( port, SOCKET_STREAM ); |
| } |
| if (s < 0) { |
| derror("could not create server socket on TCP:%ld: %s", port, |
| errno_str); |
| return -1; |
| } |
| } else { |
| for ( ; maxtries > 0; maxtries-- ) { |
| D("trying to find console-report client on tcp:%d", port); |
| if (flags & REPORT_CONSOLE_IPV6) { |
| s = socket_loopback6_client( port, SOCKET_STREAM ); |
| } else { |
| s = socket_loopback4_client( port, SOCKET_STREAM ); |
| } |
| if (s >= 0) |
| break; |
| |
| sleep_ms(1000); |
| } |
| if (s < 0) { |
| derror("could not connect to server on TCP:%ld: %s", port, |
| errno_str); |
| return -1; |
| } |
| } |
| } else if ( !strncmp( proto_port, "unix:", 5) ) { |
| #ifdef _WIN32 |
| derror("sorry, the unix: protocol is not supported on Win32"); |
| return -1; |
| #else |
| char* path = strdup(proto_port+5); |
| char* end = strchr(path, ','); |
| if (end != NULL) { |
| flags = get_report_console_options( end, &maxtries ); |
| if (flags < 0) { |
| free(path); |
| return -1; |
| } |
| *end = 0; |
| } |
| if (flags & REPORT_CONSOLE_SERVER) { |
| s = socket_unix_server( path, SOCKET_STREAM ); |
| if (s < 0) { |
| derror("could not bind unix socket on '%s': %s", proto_port + 5, |
| errno_str); |
| return -1; |
| } |
| } else { |
| for ( ; maxtries > 0; maxtries-- ) { |
| s = socket_unix_client( path, SOCKET_STREAM ); |
| if (s >= 0) |
| break; |
| |
| sleep_ms(1000); |
| } |
| if (s < 0) { |
| derror("could not connect to unix socket on '%s': %s", path, |
| errno_str); |
| return -1; |
| } |
| } |
| free(path); |
| #endif |
| } else { |
| derror("-report-console must be followed by a 'tcp:<port>' or " |
| "'unix:<path>'"); |
| return -1; |
| } |
| |
| if (flags & REPORT_CONSOLE_SERVER) { |
| int tries = 3; |
| D( "waiting for console-reporting client" ); |
| do { |
| s2 = socket_accept(s, NULL); |
| } while (s2 < 0 && --tries > 0); |
| |
| if (s2 < 0) { |
| derror("could not accept console-reporting client connection: %s", |
| errno_str); |
| return -1; |
| } |
| |
| socket_close(s); |
| s = s2; |
| } |
| |
| /* simply send the console port in text */ |
| { |
| char temp[12]; |
| snprintf( temp, sizeof(temp), "%d", console_port ); |
| |
| if (socket_send(s, temp, strlen(temp)) < 0) { |
| derror("could not send console number report: %d: %s", errno, |
| errno_str); |
| return -1; |
| } |
| socket_close(s); |
| } |
| D( "console port number sent to remote. resuming boot" ); |
| |
| restore_sigalrm (&sigstate); |
| return 0; |
| } |
| |
| static int qemu_android_console_start(int port, |
| const AndroidConsoleAgents* agents) { |
| return android_console_start(port, agents); |
| } |
| |
| // Try to bind to specific |console_port| and |adb_port| on the localhost |
| // interface. |legacy_adb| is true iff the legacy ADB network redirection |
| // through guest:tcp:5555 must also be setup. |
| // |
| // Returns true on success, false otherwise. Note that failure is clean, i.e. |
| // it won't leave ports bound by mistake. |
| static bool setup_console_and_adb_ports(int console_port, |
| int adb_port, |
| bool legacy_adb, |
| const AndroidConsoleAgents* agents) { |
| bool register_adb_service = false; |
| // The guest IP that ADB listens to in legacy mode. |
| uint32_t guest_ip; |
| inet_strtoip("10.0.2.15", &guest_ip); |
| |
| if (legacy_adb) { |
| agents->net->slirpRedir(false, adb_port, guest_ip, 5555); |
| } else { |
| if (android_adb_server_init(adb_port) < 0) { |
| return false; |
| } |
| register_adb_service = true; |
| } |
| if (qemu_android_console_start(console_port, agents) < 0) { |
| if (legacy_adb) { |
| agents->net->slirpUnredir(false, adb_port); |
| } else { |
| register_adb_service = false; |
| android_adb_server_undo_init(); |
| } |
| return false; |
| } |
| if (register_adb_service) { |
| android_adb_service_init(); |
| } |
| return true; |
| } |
| |
| /* this function is called from qemu_main() once all arguments have been parsed |
| * it should be used to setup any Android-specific items in the emulation before the |
| * main loop runs |
| */ |
| bool android_emulation_setup(const AndroidConsoleAgents* agents) { |
| |
| // Register Android pipe services. |
| android_pipe_add_type_zero(); |
| android_pipe_add_type_pingpong(); |
| android_pipe_add_type_throttle(); |
| |
| android_unix_pipes_init(); |
| android_init_opengles_pipe(); |
| android_init_clipboard_pipe(); |
| |
| if (android_op_port && android_op_ports) { |
| derror("options -port and -ports cannot be used together."); |
| return false; |
| } |
| |
| int tries = MAX_ANDROID_EMULATORS; |
| int success = 0; |
| int adb_port = -1; |
| int base_port = ANDROID_CONSOLE_BASEPORT; |
| int legacy_adb = avdInfo_getAdbdCommunicationMode(android_avdInfo) ? 0 : 1; |
| |
| if (android_op_ports) { |
| int console_port = -1; |
| if (!android_parse_ports_option(android_op_ports, |
| &console_port, |
| &adb_port)) { |
| return false; |
| } |
| |
| setup_console_and_adb_ports(console_port, adb_port, legacy_adb, |
| agents); |
| |
| base_port = console_port; |
| } else { |
| if (android_op_port) { |
| if (!android_parse_port_option(android_op_port, &base_port, |
| &adb_port)) { |
| return false; |
| } |
| tries = 1; |
| } |
| |
| // TODO(pprabhu): Is this loop lying? |
| for ( ; tries > 0; tries--, base_port += 2 ) { |
| |
| /* setup first redirection for ADB, the Android Debug Bridge */ |
| adb_port = base_port + 1; |
| |
| if (!setup_console_and_adb_ports(base_port, adb_port, |
| legacy_adb, agents)) { |
| continue; |
| } |
| |
| D( "control console listening on port %d, ADB on port %d", base_port, adb_port ); |
| success = 1; |
| break; |
| } |
| |
| if (!success) { |
| derror("It seems too many emulator instances are running on " |
| "this machine. Aborting."); |
| return false; |
| } |
| } |
| |
| /* Save base port and ADB port. */ |
| android_base_port = base_port; |
| android_serial_number_port = adb_port - 1; |
| |
| /* send a simple message to the ADB host server to tell it we just started. |
| * it should be listening on port 5037. if we can't reach it, don't bother |
| */ |
| android_adb_server_notify(adb_port); |
| |
| android_validate_ports(base_port, adb_port); |
| |
| if (android_op_report_console) { |
| if (report_console(android_op_report_console, android_base_port) < 0) { |
| return false; |
| } |
| } |
| |
| |
| agents->telephony->initModem(android_base_port); |
| |
| /* setup the http proxy, if any */ |
| if (!op_http_proxy) { |
| op_http_proxy = getenv("http_proxy"); |
| } |
| android_http_proxy_setup(op_http_proxy, VERBOSE_CHECK(proxy)); |
| |
| /* initialize sensors, this must be done here due to timer issues */ |
| android_hw_sensors_init(); |
| |
| /* initilize fingperprint here */ |
| android_hw_fingerprint_init(); |
| |
| return true; |
| } |
