From 8b23a6c7e1aee255004dd19098d4c2462b61b849 Mon Sep 17 00:00:00 2001 From: The Android Open Source Project Date: Tue, 3 Mar 2009 19:30:32 -0800 Subject: auto import from //depot/cupcake/@135843 --- android/console.c | 2190 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2190 insertions(+) create mode 100644 android/console.c (limited to 'android/console.c') diff --git a/android/console.c b/android/console.c new file mode 100644 index 0000000..3a769c1 --- /dev/null +++ b/android/console.c @@ -0,0 +1,2190 @@ +/* Copyright (C) 2007-2008 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. +*/ +/* + * Android emulator control console + * + * this console is enabled automatically at emulator startup, on port 5554 by default, + * unless some other emulator is already running. See (android_emulation_start in android_sdl.c + * for details) + * + * you can telnet to the console, then use commands like 'help' or others to dynamically + * change emulator settings. + * + */ + +#include "sockets.h" +#include "qemu-char.h" +#include "sysemu.h" +#include "android/android.h" +#include "sockets.h" +#include "cpu.h" +#include "hw/goldfish_device.h" +#include "hw/power_supply.h" +#include "shaper.h" +#include "modem_driver.h" +#include "android/gps.h" +#include "android/globals.h" +#include "android/utils/bufprint.h" +#include "android/utils/debug.h" +#include "android/utils/stralloc.h" +#include "tcpdump.h" + +#include +#include +#include +#include +#include +#include +#include "android/hw-events.h" +#include "android/skin/keyboard.h" + +#if defined(CONFIG_SLIRP) +#include "libslirp.h" +#endif + +/* set to 1 to use the i/o and event functions + * defined in "telephony/sysdeps.h" + */ +#define USE_SYSDEPS 0 + +#include "sysdeps.h" + +#define DEBUG 1 + +#if 1 +# define D_ACTIVE VERBOSE_CHECK(console) +#else +# define D_ACTIVE DEBUG +#endif + +#if DEBUG +# define D(x) do { if (D_ACTIVE) ( printf x , fflush(stdout) ); } while (0) +#else +# define D(x) do{}while(0) +#endif + +extern int slirp_inited; /* in vl.c */ + +typedef struct ControlGlobalRec_* ControlGlobal; + +typedef struct ControlClientRec_* ControlClient; + +typedef struct { + int host_port; + int host_udp; + unsigned int guest_ip; + int guest_port; +} RedirRec, *Redir; + + +#if USE_SYSDEPS +typedef SysChannel Socket; +#else /* !USE_SYSDEPS */ +typedef int Socket; +#endif /* !USE_SYSDEPS */ + + +typedef struct ControlClientRec_ +{ + struct ControlClientRec_* next; /* next client in list */ + Socket sock; /* socket used for communication */ + ControlGlobal global; + char finished; + char buff[ 4096 ]; + int buff_len; + +} ControlClientRec; + + +typedef struct ControlGlobalRec_ +{ + /* listening socket */ + Socket listen_fd; + + /* the list of current clients */ + ControlClient clients; + + /* the list of redirections currently active */ + Redir redirs; + int num_redirs; + int max_redirs; + +} ControlGlobalRec; + + +static int +control_global_add_redir( ControlGlobal global, + int host_port, + int host_udp, + unsigned int guest_ip, + int guest_port ) +{ + Redir redir; + + if (global->num_redirs >= global->max_redirs) + { + int old_max = global->max_redirs; + int new_max = old_max + (old_max >> 1) + 4; + + Redir new_redirs = realloc( global->redirs, new_max*sizeof(global->redirs[0]) ); + if (new_redirs == NULL) + return -1; + + global->redirs = new_redirs; + global->max_redirs = new_max; + } + + redir = &global->redirs[ global->num_redirs++ ]; + + redir->host_port = host_port; + redir->host_udp = host_udp; + redir->guest_ip = guest_ip; + redir->guest_port = guest_port; + + return 0; +} + +static int +control_global_del_redir( ControlGlobal global, + int host_port, + int host_udp ) +{ + int nn; + + for (nn = 0; nn < global->num_redirs; nn++) + { + Redir redir = &global->redirs[nn]; + + if ( redir->host_port == host_port && + redir->host_udp == host_udp ) + { + memmove( redir, redir + 1, ((global->num_redirs - nn)-1)*sizeof(*redir) ); + global->num_redirs -= 1; + return 0; + } + } + /* we didn't find it */ + return -1; +} + +static void +control_client_destroy( ControlClient client ) +{ + ControlGlobal global = client->global; + ControlClient *pnode = &global->clients; + + D(( "destroying control client %p\n", client )); + +#if USE_SYSDEPS + sys_channel_on( client->sock, 0, NULL, NULL ); +#else + qemu_set_fd_handler( client->sock, NULL, NULL, NULL ); +#endif + + for ( ;; ) { + ControlClient node = *pnode; + if ( node == NULL ) + break; + if ( node == client ) { + *pnode = node->next; + node->next = NULL; + break; + } + pnode = &node->next; + } + +#if USE_SYSDEPS + sys_channel_close( client->sock ); + client->sock = NULL; +#else + socket_close( client->sock ); + client->sock = -1; +#endif + + free( client ); +} + +static void control_client_read( void* _client ); /* forward */ + + +static void control_control_write( ControlClient client, const char* buff, int len ) +{ + int ret; + + if (len < 0) + len = strlen(buff); + + while (len > 0) { +#if USE_SYSDEPS + ret = sys_channel_write( client->sock, buff, len ); +#else + ret = socket_send( client->sock, buff, len); +#endif + if (ret < 0) { + if (errno != EINTR && errno != EWOULDBLOCK) + return; + } else { + buff += ret; + len -= ret; + } + } +} + +static void control_write( ControlClient client, const char* format, ... ) +{ + static char temp[1024]; + va_list args; + + va_start(args, format); + vsnprintf( temp, sizeof(temp), format, args ); + va_end(args); + + temp[ sizeof(temp)-1 ] = 0; + + control_control_write( client, temp, -1 ); +} + + +static ControlClient +control_client_create( Socket socket, + ControlGlobal global ) +{ + ControlClient client = calloc( sizeof(*client), 1 ); + + if (client) { +#if !USE_SYSDEPS + socket_set_nodelay( socket ); + socket_set_nonblock( socket ); +#endif + client->finished = 0; + client->global = global; + client->sock = socket; + client->next = global->clients; + global->clients = client; + +#if USE_SYSDEPS + sys_channel_on( socket, SYS_EVENT_READ, + (SysChannelCallback) control_client_read, + client ); +#else + qemu_set_fd_handler( socket, control_client_read, NULL, client ); +#endif + } + return client; +} + +typedef const struct CommandDefRec_ *CommandDef; + +typedef struct CommandDefRec_ { + const char* names; + const char* abstract; + const char* description; + void (*descriptor)( ControlClient client ); + int (*handler)( ControlClient client, char* args ); + CommandDef subcommands; /* if handler is NULL */ + +} CommandDefRec; + +static const CommandDefRec main_commands[]; /* forward */ + +static CommandDef +find_command( char* input, CommandDef commands, char* *pend, char* *pargs ) +{ + int nn; + char* args = strchr(input, ' '); + + if (args != NULL) { + while (*args == ' ') + args++; + + if (args[0] == 0) + args = NULL; + } + + for (nn = 0; commands[nn].names != NULL; nn++) + { + const char* name = commands[nn].names; + const char* sep; + + do { + int len, c; + + sep = strchr( name, '|' ); + if (sep) + len = sep - name; + else + len = strlen(name); + + c = input[len]; + if ( !memcmp( name, input, len ) && (c == ' ' || c == 0) ) { + *pend = input + len; + *pargs = args; + return &commands[nn]; + } + + if (sep) + name = sep + 1; + + } while (sep != NULL && *name); + } + /* NOTE: don't touch *pend and *pargs if no command is found */ + return NULL; +} + +static void +dump_help( ControlClient client, + CommandDef cmd, + const char* prefix ) +{ + if (cmd->description) { + control_write( client, "%s", cmd->description ); + } else if (cmd->descriptor) { + cmd->descriptor( client ); + } else + control_write( client, "%s\r\n", cmd->abstract ); + + if (cmd->subcommands) { + cmd = cmd->subcommands; + control_write( client, "\r\navailable sub-commands:\r\n" ); + for ( ; cmd->names != NULL; cmd++ ) { + control_write( client, " %s %-15s %s\r\n", prefix, cmd->names, cmd->abstract ); + } + control_write( client, "\r\n" ); + } +} + +static void +control_client_do_command( ControlClient client ) +{ + char* line = client->buff; + char* args = NULL; + CommandDef commands = main_commands; + char* cmdend = client->buff; + CommandDef cmd = find_command( line, commands, &cmdend, &args ); + + if (cmd == NULL) { + control_write( client, "KO: unknown command, try 'help'\r\n" ); + return; + } + + for (;;) { + CommandDef subcmd; + + if (cmd->handler) { + if ( !cmd->handler( client, args ) ) + control_write( client, "OK\r\n" ); + break; + } + + /* no handler means we should have sub-commands */ + if (cmd->subcommands == NULL) { + control_write( client, "KO: internal error: buggy command table for '%.*s'\r\n", + cmdend - client->buff, client->buff ); + break; + } + + /* we need a sub-command here */ + if ( !args ) { + dump_help( client, cmd, "" ); + control_write( client, "KO: missing sub-command\r\n" ); + break; + } + + line = args; + commands = cmd->subcommands; + subcmd = find_command( line, commands, &cmdend, &args ); + if (subcmd == NULL) { + dump_help( client, cmd, "" ); + control_write( client, "KO: bad sub-command\r\n" ); + break; + } + cmd = subcmd; + } +} + +/* implement the 'help' command */ +static int +do_help( ControlClient client, char* args ) +{ + char* line; + char* start = args; + char* end = start; + CommandDef cmd = main_commands; + + /* without arguments, simply dump all commands */ + if (args == NULL) { + control_write( client, "Android console command help:\r\n\r\n" ); + for ( ; cmd->names != NULL; cmd++ ) { + control_write( client, " %-15s %s\r\n", cmd->names, cmd->abstract ); + } + control_write( client, "\r\ntry 'help ' for command-specific help\r\n" ); + return 0; + } + + /* with an argument, find the corresponding command */ + for (;;) { + CommandDef subcmd; + + line = args; + subcmd = find_command( line, cmd, &end, &args ); + if (subcmd == NULL) { + control_write( client, "try one of these instead:\r\n\r\n" ); + for ( ; cmd->names != NULL; cmd++ ) { + control_write( client, " %.*s %s\r\n", + end - start, start, cmd->names ); + } + control_write( client, "\r\nKO: unknown command\r\n" ); + return -1; + } + + if ( !args || !subcmd->subcommands ) { + dump_help( client, subcmd, start ); + return 0; + } + cmd = subcmd->subcommands; + } +} + + +static void +control_client_read_byte( ControlClient client, unsigned char ch ) +{ + if (ch == '\r') + { + /* filter them out */ + } + else if (ch == '\n') + { + client->buff[ client->buff_len ] = 0; + control_client_do_command( client ); + if (client->finished) + return; + + client->buff_len = 0; + } + else + { + if (client->buff_len >= sizeof(client->buff)-1) + client->buff_len = 0; + + client->buff[ client->buff_len++ ] = ch; + } +} + +static void +control_client_read( void* _client ) +{ + ControlClient client = _client; + unsigned char buf[4096]; + int size; + + D(( "in control_client read: " )); +#if USE_SYSDEPS + size = sys_channel_read( client->sock, buf, sizeof(buf) ); +#else + size = socket_recv( client->sock, buf, sizeof(buf) ); +#endif + if (size < 0) { + D(( "size < 0, exiting with %d: %s\n", errno, errno_str )); + if (errno != EWOULDBLOCK && errno != EINTR) + control_client_destroy( client ); + return; + } + + if (size == 0) { + /* end of connection */ + D(( "end of connection detected !!\n" )); + control_client_destroy( client ); + } + else { + int nn; +#ifdef _WIN32 +# if DEBUG + char temp[16]; + int count = size > sizeof(temp)-1 ? sizeof(temp)-1 : size; + for (nn = 0; nn < count; nn++) { + int c = buf[nn]; + if (c == '\n') + temp[nn] = '!'; + else if (c < 32) + temp[nn] = '.'; + else + temp[nn] = (char)c; + } + temp[nn] = 0; + D(( "received %d bytes: %s\n", size, temp )); +# endif +#else + D(( "received %.*s\n", size, buf )); +#endif + for (nn = 0; nn < size; nn++) { + control_client_read_byte( client, buf[nn] ); + if (client->finished) { + control_client_destroy(client); + return; + } + } + } +} + + +/* this function is called on each new client connection */ +static void +control_global_accept( void* _global ) +{ + ControlGlobal global = _global; + ControlClient client; + Socket fd; + + D(( "control_global_accept: just in (fd=%p)\n", (void*)global->listen_fd )); + +#if USE_SYSDEPS + fd = sys_channel_create_tcp_handler( global->listen_fd ); + if (fd == NULL) { + perror("accept"); + return; + } +#else + for(;;) { + fd = socket_accept( global->listen_fd, NULL ); + if (fd < 0 && errno != EINTR) { + D(( "problem in accept: %d: %s\n", errno, errno_str )); + perror("accept"); + return; + } else if (fd >= 0) { + break; + } + D(( "relooping in accept()\n" )); + } + + socket_set_xreuseaddr( fd ); +#endif + + D(( "control_global_accept: creating new client\n" )); + client = control_client_create( fd, global ); + if (client) { + D(( "control_global_accept: new client %p\n", client )); + control_write( client, "Android Console: type 'help' for a list of commands\r\n" ); + control_write( client, "OK\r\n" ); + } +} + + +static int +control_global_init( ControlGlobal global, + int control_port ) +{ + Socket fd; +#if !USE_SYSDEPS + int ret; + SockAddress sockaddr; +#endif + + memset( global, 0, sizeof(*global) ); + + sys_main_init(); + +#if USE_SYSDEPS + fd = sys_channel_create_tcp_server( control_port ); + if (fd == NULL) { + return -1; + } + + D(("global fd=%p\n", fd)); + + global->listen_fd = fd; + sys_channel_on( fd, SYS_EVENT_READ, + (SysChannelCallback) control_global_accept, + global ); +#else + fd = socket_create_inet( SOCKET_STREAM ); + if (fd < 0) { + perror("socket"); + return -1; + } + + socket_set_xreuseaddr( fd ); + + sock_address_init_inet( &sockaddr, SOCK_ADDRESS_INET_LOOPBACK, control_port ); + + ret = socket_bind(fd, &sockaddr ); + if (ret < 0) { + perror("bind"); + socket_close( fd ); + return -1; + } + + ret = socket_listen(fd, 0); + if (ret < 0) { + perror("listen"); + socket_close( fd ); + return -1; + } + + socket_set_nonblock(fd); + + global->listen_fd = fd; + + qemu_set_fd_handler( fd, control_global_accept, NULL, global ); +#endif + return 0; +} + + + +static int +do_quit( ControlClient client, char* args ) +{ + client->finished = 1; + return -1; +} + +/********************************************************************************************/ +/********************************************************************************************/ +/***** ******/ +/***** N E T W O R K S E T T I N G S ******/ +/***** ******/ +/********************************************************************************************/ +/********************************************************************************************/ + +static int +do_network_status( ControlClient client, char* args ) +{ + control_write( client, "Current network status:\r\n" ); + + control_write( client, " download speed: %8d bits/s (%.1f KB/s)\r\n", + (long)qemu_net_download_speed, qemu_net_download_speed/8192. ); + + control_write( client, " upload speed: %8d bits/s (%.1f KB/s)\r\n", + (long)qemu_net_upload_speed, qemu_net_upload_speed/8192. ); + + control_write( client, " minimum latency: %ld ms\r\n", qemu_net_min_latency ); + control_write( client, " maximum latency: %ld ms\r\n", qemu_net_max_latency ); + return 0; +} + +static void +dump_network_speeds( ControlClient client ) +{ + const NetworkSpeed* speed = android_netspeeds; + const char* const format = " %-8s %s\r\n"; + for ( ; speed->name; speed++ ) { + control_write( client, format, speed->name, speed->display ); + } + control_write( client, format, "", "selects both upload and download speed" ); + control_write( client, format, ":", "select individual upload/download speeds" ); +} + + +static int +do_network_speed( ControlClient client, char* args ) +{ + if ( !args ) { + control_write( client, "KO: missing argument, see 'help network speed'\r\n" ); + return -1; + } + if ( android_parse_network_speed( args ) < 0 ) { + control_write( client, "KO: invalid argument, see 'help network speed' for valid values\r\n" ); + return -1; + } + + netshaper_set_rate( slirp_shaper_in, qemu_net_download_speed ); + netshaper_set_rate( slirp_shaper_out, qemu_net_upload_speed ); + + if (android_modem) { + amodem_set_data_network_type( android_modem, + android_parse_network_type( args ) ); + } + return 0; +} + +static void +describe_network_speed( ControlClient client ) +{ + control_write( client, + "'network speed ' allows you to dynamically change the speed of the emulated\r\n" + "network on the device, where is one of the following:\r\n\r\n" ); + dump_network_speeds( client ); +} + +static int +do_network_delay( ControlClient client, char* args ) +{ + if ( !args ) { + control_write( client, "KO: missing argument, see 'help network delay'\r\n" ); + return -1; + } + if ( android_parse_network_latency( args ) < 0 ) { + control_write( client, "KO: invalid argument, see 'help network delay' for valid values\r\n" ); + return -1; + } + netdelay_set_latency( slirp_delay_in, qemu_net_min_latency, qemu_net_max_latency ); + return 0; +} + +static void +describe_network_delay( ControlClient client ) +{ + control_write( client, + "'network delay ' allows you to dynamically change the latency of the emulated\r\n" + "network on the device, where is one of the following:\r\n\r\n" ); + /* XXX: TODO */ +} + +static int +do_network_capture_start( ControlClient client, char* args ) +{ + if ( !args ) { + control_write( client, "KO: missing argument, see 'help network capture start'\r\n" ); + return -1; + } + if ( qemu_tcpdump_start(args) < 0) { + control_write( client, "KO: could not start capture: %s", strerror(errno) ); + return -1; + } + return 0; +} + +static int +do_network_capture_stop( ControlClient client, char* args ) +{ + /* no need to return an error here */ + qemu_tcpdump_stop(); + return 0; +} + +static const CommandDefRec network_capture_commands[] = +{ + { "start", "start network capture", + "'network capture start ' starts a new capture of network packets\r\n" + "into a specific . This will stop any capture already in progress.\r\n" + "the capture file can later be analyzed by tools like WireShark. It uses\r\n" + "the libpcap file format.\r\n\r\n" + "you can stop the capture anytime with 'network capture stop'\r\n", NULL, + do_network_capture_start, NULL }, + + { "stop", "stop network capture", + "'network capture stop' stops a currently running packet capture, if any.\r\n" + "you can start one with 'network capture start '\r\n", NULL, + do_network_capture_stop, NULL }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + +static const CommandDefRec network_commands[] = +{ + { "status", "dump network status", NULL, NULL, + do_network_status, NULL }, + + { "speed", "change network speed", NULL, describe_network_speed, + do_network_speed, NULL }, + + { "delay", "change network latency", NULL, describe_network_delay, + do_network_delay, NULL }, + + { "capture", "dump network packets to file", + "allows to start/stop capture of network packets to a file for later analysis\r\n", NULL, + NULL, network_capture_commands }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + +/********************************************************************************************/ +/********************************************************************************************/ +/***** ******/ +/***** P O R T R E D I R E C T I O N S ******/ +/***** ******/ +/********************************************************************************************/ +/********************************************************************************************/ + +static int +do_redir_list( ControlClient client, char* args ) +{ + ControlGlobal global = client->global; + + if (global->num_redirs == 0) + control_write( client, "no active redirections\r\n" ); + else { + int nn; + for (nn = 0; nn < global->num_redirs; nn++) { + Redir redir = &global->redirs[nn]; + control_write( client, "%s:%-5d => %-5d\r\n", + redir->host_udp ? "udp" : "tcp", + redir->host_port, + redir->guest_port ); + } + } + return 0; +} + +/* parse a protocol:port specification */ +static int +redir_parse_proto_port( char* args, int *pport, int *pproto ) +{ + int proto = -1; + int len = 0; + char* end; + + if ( !memcmp( args, "tcp:", 4 ) ) { + proto = 0; + len = 4; + } + else if ( !memcmp( args, "udp:", 4 ) ) { + proto = 1; + len = 4; + } + else + return 0; + + args += len; + *pproto = proto; + *pport = strtol( args, &end, 10 ); + if (end == args) + return 0; + + len += end - args; + return len; +} + +static int +redir_parse_guest_port( char* arg, int *pport ) +{ + char* end; + + *pport = strtoul( arg, &end, 10 ); + if (end == arg) + return 0; + + return end - arg; +} + +static Redir +redir_find( ControlGlobal global, int port, int isudp ) +{ + int nn; + + for (nn = 0; nn < global->num_redirs; nn++) { + Redir redir = &global->redirs[nn]; + + if (redir->host_port == port && redir->host_udp == isudp) + return redir; + } + return NULL; +} + + +static int +do_redir_add( ControlClient client, char* args ) +{ + int len, host_proto, host_port, guest_port; + uint32_t guest_ip; + Redir redir; + + if ( !args ) + goto BadFormat; + + if (!slirp_inited) { + slirp_inited = 1; + slirp_init(); + } + + len = redir_parse_proto_port( args, &host_port, &host_proto ); + if (len == 0 || args[len] != ':') + goto BadFormat; + + args += len + 1; + len = redir_parse_guest_port( args, &guest_port ); + if (len == 0 || args[len] != 0) + goto BadFormat; + + redir = redir_find( client->global, host_port, host_proto ); + if ( redir != NULL ) { + control_write( client, "KO: host port already active, use 'redir del' to remove first\r\n" ); + return -1; + } + + if (!inet_strtoip("10.0.2.15", &guest_ip)) { + control_write( client, "KO: unexpected internal failure when resolving 10.0.2.15\r\n" ); + return -1; + } + + D(("pattern hport=%d gport=%d proto=%d\n", host_port, guest_port, host_proto )); + if ( control_global_add_redir( client->global, host_port, host_proto, + guest_ip, guest_port ) < 0 ) + { + control_write( client, "KO: not enough memory to allocate redirection\r\n" ); + return -1; + } + + if (slirp_redir(host_proto, host_port, guest_ip, guest_port) < 0) { + control_write( client, "KO: can't setup redirection, port probably used by another program on host\r\n" ); + control_global_del_redir( client->global, host_port, host_proto ); + return -1; + } + + return 0; + +BadFormat: + control_write( client, "KO: bad redirection format, try (tcp|udp):hostport:guestport\r\n", -1 ); + return -1; +} + + +static int +do_redir_del( ControlClient client, char* args ) +{ + int len, proto, port; + Redir redir; + + if ( !args ) + goto BadFormat; + len = redir_parse_proto_port( args, &port, &proto ); + if ( len == 0 || args[len] != 0 ) + goto BadFormat; + + redir = redir_find( client->global, port, proto ); + if (redir == NULL) { + control_write( client, "KO: can't remove unknown redirection (%s:%d)\r\n", + proto ? "udp" : "tcp", port ); + return -1; + } + + slirp_unredir( redir->host_udp, redir->host_port ); + control_global_del_redir( client->global, port, proto );\ + + return 0; + +BadFormat: + control_write( client, "KO: bad redirection format, try (tcp|udp):hostport\r\n" ); + return -1; +} + +static const CommandDefRec redir_commands[] = +{ + { "list", "list current redirections", + "list current port redirections. use 'redir add' and 'redir del' to add and remove them\r\n", NULL, + do_redir_list, NULL }, + + { "add", "add new redirection", + "add a new port redirection, arguments must be:\r\n\r\n" + " redir add ::\r\n\r\n" + "where: is either 'tcp' or 'udp'\r\n" + " a number indicating which port on the host to open\r\n" + " a number indicating which port to route to on the device\r\n" + "\r\nas an example, 'redir tcp:5000:6000' will allow any packets sent to\r\n" + "the host's TCP port 5000 to be routed to TCP port 6000 of the emulated device\r\n", NULL, + do_redir_add, NULL }, + + { "del", "remove existing redirection", + "remove a port redirecion that was created with 'redir add', arguments must be:\r\n\r\n" + " redir del :\r\n\r\n" + "see the 'help redir add' for the meaning of and \r\n", NULL, + do_redir_del, NULL }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + + + +/********************************************************************************************/ +/********************************************************************************************/ +/***** ******/ +/***** G S M M O D E M ******/ +/***** ******/ +/********************************************************************************************/ +/********************************************************************************************/ + +static const struct { + const char* name; + const char* display; + ARegistrationState state; +} _gsm_states[] = { + { "unregistered", "no network available", A_REGISTRATION_UNREGISTERED }, + { "home", "on local network, non-roaming", A_REGISTRATION_HOME }, + { "roaming", "on roaming network", A_REGISTRATION_ROAMING }, + { "searching", "searching networks", A_REGISTRATION_SEARCHING }, + { "denied", "emergency calls only", A_REGISTRATION_DENIED }, + { "off", "same as 'unregistered'", A_REGISTRATION_UNREGISTERED }, + { "on", "same as 'home'", A_REGISTRATION_HOME }, + { NULL, NULL, A_REGISTRATION_UNREGISTERED } +}; + +static const char* +gsm_state_to_string( ARegistrationState state ) +{ + int nn; + for (nn = 0; _gsm_states[nn].name != NULL; nn++) { + if (state == _gsm_states[nn].state) + return _gsm_states[nn].name; + } + return ""; +} + +static int +do_gsm_status( ControlClient client, char* args ) +{ + if (args) { + control_write( client, "KO: no argument required\r\n" ); + return -1; + } + if (!android_modem) { + control_write( client, "KO: modem emulation not running\r\n" ); + return -1; + } + control_write( client, "gsm voice state: %s\r\n", + gsm_state_to_string( + amodem_get_voice_registration(android_modem) ) ); + control_write( client, "gsm data state: %s\r\n", + gsm_state_to_string( + amodem_get_data_registration(android_modem) ) ); + return 0; +} + + +static void +help_gsm_data( ControlClient client ) +{ + int nn; + control_write( client, + "the 'gsm data ' allows you to change the state of your GPRS connection\r\n" + "valid values for are the following:\r\n\r\n" ); + for (nn = 0; ; nn++) { + const char* name = _gsm_states[nn].name; + const char* display = _gsm_states[nn].display; + + if (!name) + break; + + control_write( client, " %-15s %s\r\n", name, display ); + } + control_write( client, "\r\n" ); +} + + +static int +do_gsm_data( ControlClient client, char* args ) +{ + int nn; + + if (!args) { + control_write( client, "KO: missing argument, try 'gsm data '\r\n" ); + return -1; + } + + for (nn = 0; ; nn++) { + const char* name = _gsm_states[nn].name; + ARegistrationState state = _gsm_states[nn].state; + + if (!name) + break; + + if ( !strcmp( args, name ) ) { + if (!android_modem) { + control_write( client, "KO: modem emulation not running\r\n" ); + return -1; + } + amodem_set_data_registration( android_modem, state ); + qemu_net_disable = (state != A_REGISTRATION_HOME && + state != A_REGISTRATION_ROAMING ); + return 0; + } + } + control_write( client, "KO: bad GSM data state name, try 'help gsm data' for list of valid values\r\n" ); + return -1; +} + +static void +help_gsm_voice( ControlClient client ) +{ + int nn; + control_write( client, + "the 'gsm voice ' allows you to change the state of your GPRS connection\r\n" + "valid values for are the following:\r\n\r\n" ); + for (nn = 0; ; nn++) { + const char* name = _gsm_states[nn].name; + const char* display = _gsm_states[nn].display; + + if (!name) + break; + + control_write( client, " %-15s %s\r\n", name, display ); + } + control_write( client, "\r\n" ); +} + + +static int +do_gsm_voice( ControlClient client, char* args ) +{ + int nn; + + if (!args) { + control_write( client, "KO: missing argument, try 'gsm voice '\r\n" ); + return -1; + } + + for (nn = 0; ; nn++) { + const char* name = _gsm_states[nn].name; + ARegistrationState state = _gsm_states[nn].state; + + if (!name) + break; + + if ( !strcmp( args, name ) ) { + if (!android_modem) { + control_write( client, "KO: modem emulation not running\r\n" ); + return -1; + } + amodem_set_voice_registration( android_modem, state ); + return 0; + } + } + control_write( client, "KO: bad GSM data state name, try 'help gsm voice' for list of valid values\r\n" ); + return -1; +} + + +static int +gsm_check_number( char* args ) +{ + int nn; + + for (nn = 0; args[nn] != 0; nn++) { + int c = args[nn]; + if ( !isdigit(c) && c != '+' && c != '#' ) { + return -1; + } + } + if (nn == 0) + return -1; + + return 0; +} + +static int +do_gsm_call( ControlClient client, char* args ) +{ + /* check that we have a phone number made of digits */ + if (!args) { + control_write( client, "KO: missing argument, try 'gsm call '\r\n" ); + return -1; + } + + if (gsm_check_number(args)) { + control_write( client, "KO: bad phone number format, use digits, # and + only\r\n" ); + return -1; + } + + if (!android_modem) { + control_write( client, "KO: modem emulation not running\r\n" ); + return -1; + } + amodem_add_inbound_call( android_modem, args ); + return 0; +} + +static int +do_gsm_cancel( ControlClient client, char* args ) +{ + if (!args) { + control_write( client, "KO: missing argument, try 'gsm call '\r\n" ); + return -1; + } + if (gsm_check_number(args)) { + control_write( client, "KO: bad phone number format, use digits, # and + only\r\n" ); + return -1; + } + if (!android_modem) { + control_write( client, "KO: modem emulation not running\r\n" ); + return -1; + } + if ( amodem_disconnect_call( android_modem, args ) < 0 ) { + control_write( client, "KO: could not cancel this number\r\n" ); + return -1; + } + return 0; +} + + +static const char* +call_state_to_string( ACallState state ) +{ + switch (state) { + case A_CALL_ACTIVE: return "active"; + case A_CALL_HELD: return "held"; + case A_CALL_ALERTING: return "ringing"; + case A_CALL_WAITING: return "waiting"; + case A_CALL_INCOMING: return "incoming"; + default: return "unknown"; + } +} + +static int +do_gsm_list( ControlClient client, char* args ) +{ + /* check that we have a phone number made of digits */ + int count = amodem_get_call_count( android_modem ); + int nn; + for (nn = 0; nn < count; nn++) { + ACall call = amodem_get_call( android_modem, nn ); + const char* dir; + + if (call == NULL) + continue; + + if (call->dir == A_CALL_OUTBOUND) + dir = "outbound to "; + else + dir = "inbound from"; + + control_write( client, "%s %-10s : %s\r\n", dir, + call->number, call_state_to_string(call->state) ); + } + return 0; +} + +static int +do_gsm_busy( ControlClient client, char* args ) +{ + ACall call; + + if (!args) { + control_write( client, "KO: missing argument, try 'gsm busy '\r\n" ); + return -1; + } + call = amodem_find_call_by_number( android_modem, args ); + if (call == NULL || call->dir != A_CALL_OUTBOUND) { + control_write( client, "KO: no current outbound call to number '%s' (call %p)\r\n", args, call ); + return -1; + } + if ( amodem_disconnect_call( android_modem, args ) < 0 ) { + control_write( client, "KO: could not cancel this number\r\n" ); + return -1; + } + return 0; +} + +static int +do_gsm_hold( ControlClient client, char* args ) +{ + ACall call; + + if (!args) { + control_write( client, "KO: missing argument, try 'gsm out hold '\r\n" ); + return -1; + } + call = amodem_find_call_by_number( android_modem, args ); + if (call == NULL) { + control_write( client, "KO: no current call to/from number '%s'\r\n", args ); + return -1; + } + if ( amodem_update_call( android_modem, args, A_CALL_HELD ) < 0 ) { + control_write( client, "KO: could put this call on hold\r\n" ); + return -1; + } + return 0; +} + + +static int +do_gsm_accept( ControlClient client, char* args ) +{ + ACall call; + + if (!args) { + control_write( client, "KO: missing argument, try 'gsm accept '\r\n" ); + return -1; + } + call = amodem_find_call_by_number( android_modem, args ); + if (call == NULL) { + control_write( client, "KO: no current call to/from number '%s'\r\n", args ); + return -1; + } + if ( amodem_update_call( android_modem, args, A_CALL_ACTIVE ) < 0 ) { + control_write( client, "KO: could not activate this call\r\n" ); + return -1; + } + return 0; +} + + +#if 0 +static const CommandDefRec gsm_in_commands[] = +{ + { "new", "create a new 'waiting' inbound call", + "'gsm in create ' creates a new inbound phone call, placed in\r\n" + "the 'waiting' state by default, until the system answers/holds/closes it\r\n", NULL + do_gsm_in_create, NULL }, + + { "hold", "change the state of an oubtound call to 'held'", + "change the state of an outbound call to 'held'. this is only possible\r\n" + "if the call in the 'waiting' or 'active' state\r\n", NULL, + do_gsm_out_hold, NULL }, + + { "accept", "change the state of an outbound call to 'active'", + "change the state of an outbound call to 'active'. this is only possible\r\n" + "if the call is in the 'waiting' or 'held' state\r\n", NULL, + do_gsm_out_accept, NULL }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; +#endif + + +static const CommandDefRec gsm_commands[] = +{ + { "list", "list current phone calls", + "'gsm list' lists all inbound and outbound calls and their state\r\n", NULL, + do_gsm_list, NULL }, + + { "call", "create inbound phone call", + "'gsm call ' allows you to simulate a new inbound call\r\n", NULL, + do_gsm_call, NULL }, + + { "busy", "close waiting outbound call as busy", + "'gsm busy ' closes an outbound call, reporting\r\n" + "the remote phone as busy. only possible if the call is 'waiting'.\r\n", NULL, + do_gsm_busy, NULL }, + + { "hold", "change the state of an oubtound call to 'held'", + "'gsm hold ' change the state of a call to 'held'. this is only possible\r\n" + "if the call in the 'waiting' or 'active' state\r\n", NULL, + do_gsm_hold, NULL }, + + { "accept", "change the state of an outbound call to 'active'", + "'gsm accept ' change the state of a call to 'active'. this is only possible\r\n" + "if the call is in the 'waiting' or 'held' state\r\n", NULL, + do_gsm_accept, NULL }, + + { "cancel", "disconnect an inbound or outbound phone call", + "'gsm cancel ' allows you to simulate the end of an inbound or outbound call\r\n", NULL, + do_gsm_cancel, NULL }, + + { "data", "modify data connection state", NULL, help_gsm_data, + do_gsm_data, NULL }, + + { "voice", "modify voice connection state", NULL, help_gsm_voice, + do_gsm_voice, NULL }, + + { "status", "display GSM status", + "'gsm status' displays the current state of the GSM emulation\r\n", NULL, + do_gsm_status, NULL }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + +/********************************************************************************************/ +/********************************************************************************************/ +/***** ******/ +/***** S M S C O M M A N D ******/ +/***** ******/ +/********************************************************************************************/ +/********************************************************************************************/ + +static int +do_sms_send( ControlClient client, char* args ) +{ + char* p; + int textlen; + SmsAddressRec sender; + SmsPDU* pdus; + int nn; + + /* check that we have a phone number made of digits */ + if (!args) { + MissingArgument: + control_write( client, "KO: missing argument, try 'sms send '\r\n" ); + return -1; + } + p = strchr( args, ' ' ); + if (!p) { + goto MissingArgument; + } + + if ( sms_address_from_str( &sender, args, p - args ) < 0 ) { + control_write( client, "KO: bad phone number format, must be [+](0-9)*\r\n" ); + return -1; + } + + + /* un-secape message text into proper utf-8 (conversion happens in-site) */ + p += 1; + textlen = strlen(p); + textlen = sms_utf8_from_message_str( p, textlen, (unsigned char*)p, textlen ); + if (textlen < 0) { + control_write( client, "message must be utf8 and can use the following escapes:\r\n" + " \\n for a newline\r\n" + " \\xNN where NN are two hexadecimal numbers\r\n" + " \\uNNNN where NNNN are four hexadecimal numbers\r\n" + " \\\\ to send a '\\' character\r\n\r\n" + " anything else is an error\r\n" + "KO: badly formatted text\r\n" ); + return -1; + } + + if (!android_modem) { + control_write( client, "KO: modem emulation not running\r\n" ); + return -1; + } + + /* create a list of SMS PDUs, then send them */ + pdus = smspdu_create_deliver_utf8( (cbytes_t)p, textlen, &sender, NULL ); + if (pdus == NULL) { + control_write( client, "KO: internal error when creating SMS-DELIVER PDUs\n" ); + return -1; + } + + for (nn = 0; pdus[nn] != NULL; nn++) + amodem_receive_sms( android_modem, pdus[nn] ); + + smspdu_free_list( pdus ); + return 0; +} + +static int +do_sms_sendpdu( ControlClient client, char* args ) +{ + SmsPDU pdu; + + /* check that we have a phone number made of digits */ + if (!args) { + control_write( client, "KO: missing argument, try 'sms sendpdu '\r\n" ); + return -1; + } + + if (!android_modem) { + control_write( client, "KO: modem emulation not running\r\n" ); + return -1; + } + + pdu = smspdu_create_from_hex( args, strlen(args) ); + if (pdu == NULL) { + control_write( client, "KO: badly formatted \r\n" ); + return -1; + } + + amodem_receive_sms( android_modem, pdu ); + smspdu_free( pdu ); + return 0; +} + +static const CommandDefRec sms_commands[] = +{ + { "send", "send inbound SMS text message", + "'sms send ' allows you to simulate a new inbound sms message\r\n", NULL, + do_sms_send, NULL }, + + { "pdu", "send inbound SMS PDU", + "'sms pdu ' allows you to simulate a new inbound sms PDU\r\n" + "(used internally when one emulator sends SMS messages to another instance).\r\n" + "you probably don't want to play with this at all\r\n", NULL, + do_sms_sendpdu, NULL }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + +static void +do_control_write(void* data, const char* string) +{ + control_write((ControlClient)data, string); +} + +static int +do_power_display( ControlClient client, char* args ) +{ + goldfish_battery_display(do_control_write, client); + return 0; +} + +static int +do_ac_state( ControlClient client, char* args ) +{ + if (args) { + if (strcasecmp(args, "on") == 0) { + goldfish_battery_set_prop(1, POWER_SUPPLY_PROP_ONLINE, 1); + return 0; + } + if (strcasecmp(args, "off") == 0) { + goldfish_battery_set_prop(1, POWER_SUPPLY_PROP_ONLINE, 0); + return 0; + } + } + + control_write( client, "KO: Usage: \"ac on\" or \"ac off\"\n" ); + return -1; +} + +static int +do_battery_status( ControlClient client, char* args ) +{ + if (args) { + if (strcasecmp(args, "unknown") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_STATUS_UNKNOWN); + return 0; + } + if (strcasecmp(args, "charging") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_STATUS_CHARGING); + return 0; + } + if (strcasecmp(args, "discharging") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_STATUS_DISCHARGING); + return 0; + } + if (strcasecmp(args, "not-charging") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_STATUS_NOT_CHARGING); + return 0; + } + if (strcasecmp(args, "full") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_STATUS_FULL); + return 0; + } + } + + control_write( client, "KO: Usage: \"status unknown|charging|discharging|not-charging|full\"\n" ); + return -1; +} + +static int +do_battery_present( ControlClient client, char* args ) +{ + if (args) { + if (strcasecmp(args, "true") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_PRESENT, 1); + return 0; + } + if (strcasecmp(args, "false") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_PRESENT, 0); + return 0; + } + } + + control_write( client, "KO: Usage: \"present true\" or \"present false\"\n" ); + return -1; +} + +static int +do_battery_health( ControlClient client, char* args ) +{ + if (args) { + if (strcasecmp(args, "unknown") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_HEALTH_UNKNOWN); + return 0; + } + if (strcasecmp(args, "good") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_HEALTH_GOOD); + return 0; + } + if (strcasecmp(args, "overheat") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_HEALTH_OVERHEAT); + return 0; + } + if (strcasecmp(args, "dead") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_HEALTH_DEAD); + return 0; + } + if (strcasecmp(args, "overvoltage") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_HEALTH_OVERVOLTAGE); + return 0; + } + if (strcasecmp(args, "failure") == 0) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_HEALTH_UNSPEC_FAILURE); + return 0; + } + } + + control_write( client, "KO: Usage: \"health unknown|good|overheat|dead|overvoltage|failure\"\n" ); + return -1; +} + +static int +do_battery_capacity( ControlClient client, char* args ) +{ + if (args) { + int capacity; + + if (sscanf(args, "%d", &capacity) == 1 && capacity >= 0 && capacity <= 100) { + goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_CAPACITY, capacity); + return 0; + } + } + + control_write( client, "KO: Usage: \"capacity \"\n" ); + return -1; +} + + +static const CommandDefRec power_commands[] = +{ + { "display", "display battery and charger state", + "display battery and charger state\r\n", NULL, + do_power_display, NULL }, + + { "ac", "set AC charging state", + "'ac on|off' allows you to set the AC charging state to on or off\r\n", NULL, + do_ac_state, NULL }, + + { "status", "set battery status", + "'status unknown|charging|discharging|not-charging|full' allows you to set battery status\r\n", NULL, + do_battery_status, NULL }, + + { "present", "set battery present state", + "'present true|false' allows you to set battery present state to true or false\r\n", NULL, + do_battery_present, NULL }, + + { "health", "set battery health state", + "'health unknown|good|overheat|dead|overvoltage|failure' allows you to set battery health state\r\n", NULL, + do_battery_health, NULL }, + + { "capacity", "set battery capacity state", + "'capacity ' allows you to set battery capacity to a value 0 - 100\r\n", NULL, + do_battery_capacity, NULL }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + +/********************************************************************************************/ +/********************************************************************************************/ +/***** ******/ +/***** E V E N T C O M M A N D S ******/ +/***** ******/ +/********************************************************************************************/ +/********************************************************************************************/ + + +static int +do_event_send( ControlClient client, char* args ) +{ + char* p; + + if (!args) { + control_write( client, "KO: Usage: event send :: ...\r\n" ); + return -1; + } + + p = args; + while (*p) { + char* q; + int type, code, value, ret; + + p += strspn( args, " \t" ); /* skip spaces */ + if (*p == 0) + break; + + q = p + strcspn( p, " \t" ); + + if (q == p) + break; + + ret = android_event_from_str( p, &type, &code, &value ); + if (ret < 0) { + if (ret == -1) { + control_write( client, + "KO: invalid event type in '%.*s', try 'event list types' for valid values\r\n", + q-p, p ); + } else if (ret == -2) { + control_write( client, + "KO: invalid event code in '%.*s', try 'event list codes ' for valid values\r\n", + q-p, p ); + } else { + control_write( client, + "KO: invalid event value in '%.*s', must be an integer\r\n", + q-p, p); + } + return -1; + } + + kbd_generic_event( type, code, value ); + p = q; + } + return 0; +} + +static int +do_event_types( ControlClient client, char* args ) +{ + int count = android_event_get_type_count(); + int nn; + + control_write( client, "event can be an integer or one of the following aliases\r\n" ); + for (nn = 0; nn < count; nn++) { + char tmp[16]; + char* p = tmp; + char* end = p + sizeof(tmp); + int count2 = android_event_get_code_count( nn );; + + p = android_event_bufprint_type_str( p, end, nn ); + + control_write( client, " %-8s", tmp ); + if (count2 > 0) + control_write( client, " (%d code aliases)", count2 ); + + control_write( client, "\r\n" ); + } + return 0; +} + +static int +do_event_codes( ControlClient client, char* args ) +{ + int count; + int nn, type, dummy; + + if (!args) { + control_write( client, "KO: argument missing, try 'event codes '\r\n" ); + return -1; + } + + if ( android_event_from_str( args, &type, &dummy, &dummy ) < 0 ) { + control_write( client, "KO: bad argument, see 'event types' for valid values\r\n" ); + return -1; + } + + count = android_event_get_code_count( type ); + if (count == 0) { + control_write( client, "no code aliases defined for this type\r\n" ); + } else { + control_write( client, "type '%s' accepts the following aliases:\r\n", + args ); + for (nn = 0; nn < count; nn++) { + char temp[20], *p = temp, *end = p + sizeof(temp); + android_event_bufprint_code_str( p, end, type, nn ); + control_write( client, " %-12s\r\n", temp ); + } + } + + return 0; +} + +static __inline__ int +utf8_next( unsigned char* *pp, unsigned char* end ) +{ + unsigned char* p = *pp; + int result = -1; + + if (p < end) { + int c= *p++; + if (c >= 128) { + if ((c & 0xe0) == 0xc0) + c &= 0x1f; + else if ((c & 0xf0) == 0xe0) + c &= 0x0f; + else + c &= 0x07; + + while (p < end && (p[0] & 0xc0) == 0x80) { + c = (c << 6) | (p[0] & 0x3f); + } + } + result = c; + *pp = p; + } + return result; +} + +static int +do_event_text( ControlClient client, char* args ) +{ + SkinKeyboard* keyboard; + unsigned char* p = (unsigned char*) args; + unsigned char* end = p + strlen(args); + int textlen; + + if (!args) { + control_write( client, "KO: argument missing, try 'event text '\r\n" ); + return -1; + } + keyboard = android_emulator_get_keyboard(); + if (keyboard == NULL) { + control_write( client, "KO: no keyboard active in current device layout/config\r\n" ); + return -1; + } + + /* un-secape message text into proper utf-8 (conversion happens in-site) */ + textlen = strlen((char*)p); + textlen = sms_utf8_from_message_str( args, textlen, (unsigned char*)p, textlen ); + if (textlen < 0) { + control_write( client, "message must be utf8 and can use the following escapes:\r\n" + " \\n for a newline\r\n" + " \\xNN where NN are two hexadecimal numbers\r\n" + " \\uNNNN where NNNN are four hexadecimal numbers\r\n" + " \\\\ to send a '\\' character\r\n\r\n" + " anything else is an error\r\n" + "KO: badly formatted text\r\n" ); + return -1; + } + + end = p + textlen; + while (p < end) { + int c = utf8_next( &p, end ); + if (c <= 0) + break; + + skin_keyboard_process_unicode_event( keyboard, (unsigned)c, 1 ); + skin_keyboard_process_unicode_event( keyboard, (unsigned)c, 0 ); + skin_keyboard_flush( keyboard ); + } + + return 0; +} + +static const CommandDefRec event_commands[] = +{ + { "send", "send a series of events to the kernel", + "'event send :: ...' allows your to send one or more hardware events\r\n" + "to the Android kernel. you can use text names or integers for and \r\n", NULL, + do_event_send, NULL }, + + { "types", "list all aliases", + "'event types' list all string aliases supported by the 'event' subcommands\r\n", + NULL, do_event_types, NULL }, + + { "codes", "list all aliases for a given ", + "'event codes ' lists all string aliases for a given event \r\n", + NULL, do_event_codes, NULL }, + + { "text", "simulate keystrokes from a given text", + "'event text ' allows you to simulate keypresses to generate a given text\r\n" + "message. must be an utf-8 string. Unicode points will be reverse-mapped\r\n" + "according to the current device keyboard. unsupported characters will be discarded\r\n" + "silently\r\n", NULL, do_event_text, NULL }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + + +/********************************************************************************************/ +/********************************************************************************************/ +/***** ******/ +/***** V M C O M M A N D S ******/ +/***** ******/ +/********************************************************************************************/ +/********************************************************************************************/ + +static int +do_avd_stop( ControlClient client, char* args ) +{ + if (!vm_running) { + control_write( client, "KO: virtual device already stopped\r\n" ); + return -1; + } + vm_stop(EXCP_INTERRUPT); + return 0; +} + +static int +do_avd_start( ControlClient client, char* args ) +{ + if (vm_running) { + control_write( client, "KO: virtual device already running\r\n" ); + return -1; + } + vm_start(); + return 0; +} + +static int +do_avd_status( ControlClient client, char* args ) +{ + control_write( client, "virtual device is %s\r\n", vm_running ? "running" : "stopped" ); + return 0; +} + +static int +do_avd_name( ControlClient client, char* args ) +{ + control_write( client, "%s\r\n", avdInfo_getName(android_avdInfo) ); + return 0; +} + +static const CommandDefRec vm_commands[] = +{ + { "stop", "stop the virtual device", + "'avd stop' stops the virtual device immediately, use 'avd start' to continue execution\r\n", + NULL, do_avd_stop, NULL }, + + { "start", "start/restart the virtual device", + "'avd start' will start or continue the virtual device, use 'avd stop' to stop it\r\n", + NULL, do_avd_start, NULL }, + + { "status", "query virtual device status", + "'avd status' will indicate wether the virtual device is running or not\r\n", + NULL, do_avd_status, NULL }, + + { "name", "query virtual device name", + "'avd name' will return the name of this virtual device\r\n", + NULL, do_avd_name, NULL }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + +/********************************************************************************************/ +/********************************************************************************************/ +/***** ******/ +/***** G E O C O M M A N D S ******/ +/***** ******/ +/********************************************************************************************/ +/********************************************************************************************/ + +static int +do_geo_nmea( ControlClient client, char* args ) +{ + if (!args) { + control_write( client, "KO: NMEA sentence missing, try 'help geo nmea'\r\n" ); + return -1; + } + if (!android_gps_cs) { + control_write( client, "KO: no GPS emulation in this virtual device\r\n" ); + return -1; + } + android_gps_send_nmea( args ); + return 0; +} + +static int +do_geo_fix( ControlClient client, char* args ) +{ +#define MAX_GEO_PARAMS 3 + char* p = args; + int n_params = 0; + double params[ MAX_GEO_PARAMS ]; + + static int last_time = 0; + static double last_altitude = 0.; + + if (!p) + p = ""; + + /* tokenize */ + while (*p) { + char* end; + double val = strtod( p, &end ); + + if (end == p) { + control_write( client, "KO: argument '%s' is not a number\n", p ); + return -1; + } + + params[n_params++] = val; + if (n_params >= MAX_GEO_PARAMS) + break; + + p = end; + while (*p && (p[0] == ' ' || p[0] == '\t')) + p += 1; + } + + /* sanity check */ + if (n_params < 2) { + control_write( client, "KO: not enough arguments: see 'help geo fix' for details\r\n" ); + return -1; + } + + /* generate an NMEA sentence for this fix */ + { + STRALLOC_DEFINE(s); + double val; + int deg, min; + char hemi; + + /* first, the time */ + stralloc_add_format( s, "$GPGGA,%06d", last_time ); + last_time ++; + + /* then the latitude */ + hemi = 'N'; + val = params[1]; + if (val < 0) { + hemi = 'S'; + val = -val; + } + deg = (int) val; + min = 60*(val - deg); + val = val - min/60.; + stralloc_add_format( s, ",%02d%02d.%04d,%c", deg, min, (int)(val * 10000), hemi ); + + /* the longitude */ + hemi = 'E'; + val = params[0]; + if (val < 0) { + hemi = 'W'; + val = -val; + } + deg = (int) val; + min = 60*(val - deg); + val = val - min/60.; + stralloc_add_format( s, ",%02d%02d.%04d,%c", deg, min, (int)(val * 10000), hemi ); + + /* bogus fix quality, empty satellite count and dilutions */ + stralloc_add_str( s, ",1,,,," ); + + /* optional altitude */ + if (n_params >= 3) { + stralloc_add_format( s, "%.1g", params[2] ); + last_altitude = params[2]; + } else { + stralloc_add_str( s, "," ); + } + /* bogus rest and checksum */ + stralloc_add_str( s, ",,,*47" ); + + /* send it, then free */ + android_gps_send_nmea( stralloc_cstr(s) ); + stralloc_reset( s ); + } + return 0; +} + +static const CommandDefRec geo_commands[] = +{ + { "nmea", "send an GPS NMEA sentence", + "'geo nema ' sends a NMEA 0183 sentence to the emulated device, as\r\n" + "if it came from an emulated GPS modem. must begin with '$GP'. only\r\n" + "'$GPGGA' and '$GPRCM' sentences are supported at the moment.\r\n", + NULL, do_geo_nmea, NULL }, + + { "fix", "send a simple GPS fix", + "'geo fix []' allows you to send a\r\n" + "simple GPS fix to the emulated system. the parameters are:\r\n\r\n" + " longitude, in decimal degrees\r\n" + " latitude, in decimal degrees\r\n" + " optional altitude in meters\r\n" + "\r\n", + NULL, do_geo_fix, NULL }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + + +/********************************************************************************************/ +/********************************************************************************************/ +/***** ******/ +/***** M A I N C O M M A N D S ******/ +/***** ******/ +/********************************************************************************************/ +/********************************************************************************************/ + +extern void android_emulator_set_window_scale( double, int ); + +static int +do_window_scale( ControlClient client, char* args ) +{ + double scale; + int is_dpi = 0; + char* end; + + if (!args) { + control_write( client, "KO: argument missing, try 'window scale '\r\n" ); + return -1; + } + + scale = strtol( args, &end, 10 ); + if (end > args && !memcmp( end, "dpi", 4 )) { + is_dpi = 1; + } + else { + scale = strtod( args, &end ); + if (end == args || end[0]) { + control_write( client, "KO: argument must be a real number, or an integer followed by 'dpi'\r\n" ); + return -1; + } + } + + android_emulator_set_window_scale( scale, is_dpi ); + return 0; +} + +static const CommandDefRec window_commands[] = +{ + { "scale", "change the window scale", + "'window scale ' allows you to change the scale of the emulator window at runtime\r\n" + " must be either a real number between 0.1 and 3.0, or an integer followed by\r\n" + "the 'dpi' prefix (as in '120dpi')\r\n", + NULL, do_window_scale, NULL }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + +/********************************************************************************************/ +/********************************************************************************************/ +/***** ******/ +/***** M A I N C O M M A N D S ******/ +/***** ******/ +/********************************************************************************************/ +/********************************************************************************************/ + +static int +do_kill( ControlClient client, char* args ) +{ + control_write( client, "OK: killing emulator, bye bye\r\n" ); + exit(0); +} + +static const CommandDefRec main_commands[] = +{ + { "help|h|?", "print a list of commands", NULL, NULL, do_help, NULL }, + + { "event", "simulate hardware events", + "allows you to send fake hardware events to the kernel\r\n", NULL, + NULL, event_commands }, + + { "geo", "Geo-location commands", + "allows you to change Geo-related settings, or to send GPS NMEA sentences\r\n", NULL, + NULL, geo_commands }, + + { "gsm", "GSM related commands", + "allows you to change GSM-related settings, or to make a new inbound phone call\r\n", NULL, + NULL, gsm_commands }, + + { "kill", "kill the emulator instance", NULL, NULL, + do_kill, NULL }, + + { "network", "manage network settings", + "allows you to manage the settings related to the network data connection of the\r\n" + "emulated device.\r\n", NULL, + NULL, network_commands }, + + { "power", "power related commands", + "allows to change battery and AC power status\r\n", NULL, + NULL, power_commands }, + + { "quit|exit", "quit control session", NULL, NULL, + do_quit, NULL }, + + { "redir", "manage port redirections", + "allows you to add, list and remove UDP and/or PORT redirection from the host to the device\r\n" + "as an example, 'redir tcp:5000:6000' will route any packet sent to the host's TCP port 5000\r\n" + "to TCP port 6000 of the emulated device\r\n", NULL, + NULL, redir_commands }, + + { "sms", "SMS related commands", + "allows you to simulate an inbound SMS\r\n", NULL, + NULL, sms_commands }, + + { "avd", "manager virtual device state", + "allows to change (e.g. start/stop) the virtual device state\r\n", NULL, + NULL, vm_commands }, + + { "window", "manage emulator window", + "allows you to modify the emulator window\r\n", NULL, + NULL, window_commands }, + + { NULL, NULL, NULL, NULL, NULL, NULL } +}; + + +static ControlGlobalRec _g_global; + +int +control_console_start( int port ) +{ + return control_global_init( &_g_global, port ); +} -- cgit v1.1