/* 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 "net.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 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 && errno != EAGAIN) 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 != EAGAIN && 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_is_inited()) { control_write( client, "KO: network emulation disabled\r\n"); return -1; } 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) < 0) { 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 ); }