Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / external / qemu / afb0f8ee7ecec8000aa6f6e0d80e8c8cbfddac0e / . / android / console.c
blob: d341d715d8ae86c195023d5d66063d7a44f586c3 [file] [log] [blame]
/* 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 "monitor.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include "android/hw-events.h"
#include "user-events.h"
#include "android/keycode-array.h"
#include "android/charmap.h"
#include "android/core-ui-protocol.h"
#if defined(CONFIG_SLIRP)
#include "libslirp.h"
#endif
#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;
typedef int Socket;
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;
}
/* Detach the socket descriptor from a given ControlClient
* and return its value. This is useful either when destroying
* the client, or redirecting the socket to another service.
*
* NOTE: this does not close the socket.
*/
static int
control_client_detach( ControlClient client )
{
int result;
if (client->sock < 0)
return -1;
qemu_set_fd_handler( client->sock, NULL, NULL, NULL );
result = client->sock;
client->sock = -1;
return result;
}
static void control_client_read( void* _client ); /* forward */
/* Reattach a control client to a given socket.
* Return the old socket descriptor for the client.
*/
static int
control_client_reattach( ControlClient client, int fd )
{
int result = control_client_detach(client);
client->sock = fd;
qemu_set_fd_handler( fd, control_client_read, NULL, client );
return result;
}
static void
control_client_destroy( ControlClient client )
{
ControlGlobal global = client->global;
ControlClient *pnode = &global->clients;
int sock;
D(( "destroying control client %p\n", client ));
sock = control_client_detach( client );
if (sock >= 0)
socket_close(sock);
for ( ;; ) {
ControlClient node = *pnode;
if ( node == NULL )
break;
if ( node == client ) {
*pnode = node->next;
node->next = NULL;
break;
}
pnode = &node->next;
}
free( client );
}
static void control_control_write( ControlClient client, const char* buff, int len )
{
int ret;
if (len < 0)
len = strlen(buff);
while (len > 0) {
ret = socket_send( client->sock, buff, len);
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) {
socket_set_nodelay( socket );
socket_set_nonblock( socket );
client->finished = 0;
client->global = global;
client->sock = socket;
client->next = global->clients;
global->clients = client;
qemu_set_fd_handler( socket, control_client_read, NULL, client );
}
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 <command>' 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: " ));
size = socket_recv( client->sock, buf, sizeof(buf) );
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 ));
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 );
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;
int ret;
SockAddress sockaddr;
memset( global, 0, sizeof(*global) );
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 );
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, "<num>", "selects both upload and download speed" );
control_write( client, format, "<up>:<down>", "select individual upload/download speeds" );
}
static int
do_network_speed( ControlClient client, char* args )
{
if ( !args ) {
control_write( client, "KO: missing <speed> argument, see 'help network speed'\r\n" );
return -1;
}
if ( android_parse_network_speed( args ) < 0 ) {
control_write( client, "KO: invalid <speed> 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 <speed>' allows you to dynamically change the speed of the emulated\r\n"
"network on the device, where <speed> 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 <delay> argument, see 'help network delay'\r\n" );
return -1;
}
if ( android_parse_network_latency( args ) < 0 ) {
control_write( client, "KO: invalid <delay> 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 <latency>' allows you to dynamically change the latency of the emulated\r\n"
"network on the device, where <latency> 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 <file> 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 <file>' starts a new capture of network packets\r\n"
"into a specific <file>. 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 <file>'\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 <protocol>:<host-port>:<guest-port>\r\n\r\n"
"where: <protocol> is either 'tcp' or 'udp'\r\n"
" <host-port> a number indicating which port on the host to open\r\n"
" <guest-port> 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 <protocol>:<host-port>\r\n\r\n"
"see the 'help redir add' for the meaning of <protocol> and <host-port>\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 "<unknown>";
}
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 <state>' allows you to change the state of your GPRS connection\r\n"
"valid values for <state> 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 <state>'\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 <state>' allows you to change the state of your GPRS connection\r\n"
"valid values for <state> 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 <state>'\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 <phonenumber>'\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 <phonenumber>'\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 <phonenumber>'\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 <phonenumber>'\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 <phonenumber>'\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 <phonenumber>' 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 <phonenumber>' allows you to simulate a new inbound call\r\n", NULL,
do_gsm_call, NULL },
{ "busy", "close waiting outbound call as busy",
"'gsm busy <remoteNumber>' 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 <remoteNumber>' 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 <remoteNumber>' 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 <phonenumber>' 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 <phonenumber> <text message>'\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 <hexstring>'\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 <hexstring>\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 <phonenumber> <message>' allows you to simulate a new inbound sms message\r\n", NULL,
do_sms_send, NULL },
{ "pdu", "send inbound SMS PDU",
"'sms pdu <hexstring>' 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 <percentage>\"\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 <percentage>' 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 <type>:<code>:<value> ...\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 <type>' 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;
}
user_event_generic( 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 <type> 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 <type>'\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 <code> 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 )
{
AKeycodeBuffer keycodes;
unsigned char* p = (unsigned char*) args;
unsigned char* end = p + strlen(args);
int textlen;
const AKeyCharmap* charmap;
if (!args) {
control_write( client, "KO: argument missing, try 'event text <message>'\r\n" );
return -1;
}
/* Get default charmap. */
charmap = android_get_default_charmap();
if (charmap == NULL) {
control_write( client, "KO: no character map active in current device layout/config\r\n" );
return -1;
}
keycodes.keycode_count = 0;
/* 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;
android_charmap_reverse_map_unicode( NULL, (unsigned)c, 1, &keycodes );
android_charmap_reverse_map_unicode( NULL, (unsigned)c, 0, &keycodes );
android_keycodes_flush( &keycodes );
}
return 0;
}
static const CommandDefRec event_commands[] =
{
{ "send", "send a series of events to the kernel",
"'event send <type>:<code>:<value> ...' allows your to send one or more hardware events\r\n"
"to the Android kernel. you can use text names or integers for <type> and <code>\r\n", NULL,
do_event_send, NULL },
{ "types", "list all <type> aliases",
"'event types' list all <type> string aliases supported by the 'event' subcommands\r\n",
NULL, do_event_types, NULL },
{ "codes", "list all <code> aliases for a given <type>",
"'event codes <type>' lists all <code> string aliases for a given event <type>\r\n",
NULL, do_event_codes, NULL },
{ "text", "simulate keystrokes from a given text",
"'event text <message>' allows you to simulate keypresses to generate a given text\r\n"
"message. <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 5
char* p = args;
int n_params = 0;
double params[ MAX_GEO_PARAMS ];
int n_satellites = 1;
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;
}
/* check number of satellites, must be between 1 and 12 */
if (n_params >= 4) {
n_satellites = (int) params[4];
if (n_satellites != params[4] || n_satellites < 1 || n_satellites > 12) {
control_write( client, "KO: invalid number of satellites. Must be an integer between 1 and 12\r\n");
return -1;
}
}
/* generate an NMEA sentence for this fix */
{
STRALLOC_DEFINE(s);
double val;
int deg, min;
char hemi;
/* format overview:
* time of fix 123519 12:35:19 UTC
* latitude 4807.038 48 degrees, 07.038 minutes
* north/south N or S
* longitude 01131.000 11 degrees, 31. minutes
* east/west E or W
* fix quality 1 standard GPS fix
* satellites 1 to 12 number of satellites being tracked
* HDOP <dontcare> horizontal dilution
* altitude 546. altitude above sea-level
* altitude units M to indicate meters
* diff <dontcare> height of sea-level above ellipsoid
* diff units M to indicate meters (should be <dontcare>)
* dgps age <dontcare> time in seconds since last DGPS fix
* dgps sid <dontcare> DGPS station id
*/
/* 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;
val = 60*(val - deg);
min = (int) val;
val = 1000*(val - min);
stralloc_add_format( s, ",%02d%02d.%04d,%c", deg, min, (int)val, hemi );
/* the longitude */
hemi = 'E';
val = params[0];
if (val < 0) {
hemi = 'W';
val = -val;
}
deg = (int) val;
val = 60*(val - deg);
min = (int) val;
val = 1000*(val - min);
stralloc_add_format( s, ",%02d%02d.%04d,%c", deg, min, (int)val, hemi );
/* bogus fix quality, satellite count and dilution */
stralloc_add_format( s, ",1,%02d,", n_satellites );
/* optional altitude + bogus diff */
if (n_params >= 3) {
stralloc_add_format( s, ",%.1g,M,0.,M", 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 <sentence>' sends a NMEA 0183 sentence to the emulated device, as\r\n"
"if it came from an emulated GPS modem. <sentence> 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 <longitude> <latitude> [<altitude> [<satellites>]]' allows you to send a\r\n"
"simple GPS fix to the emulated system. the parameters are:\r\n\r\n"
" <longitude> longitude, in decimal degrees\r\n"
" <latitude> latitude, in decimal degrees\r\n"
" <altitude> optional altitude in meters\r\n"
" <satellites> number of satellites being tracked (1-12)\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 ******/
/***** ******/
/********************************************************************************************/
/********************************************************************************************/
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 <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 <scale> must be a real number, or an integer followed by 'dpi'\r\n" );
return -1;
}
}
android_ui_set_window_scale( scale, is_dpi );
return 0;
}
static const CommandDefRec window_commands[] =
{
{ "scale", "change the window scale",
"'window scale <scale>' allows you to change the scale of the emulator window at runtime\r\n"
"<scale> 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 }
};
/********************************************************************************************/
/********************************************************************************************/
/***** ******/
/***** Q E M U C O M M A N D S ******/
/***** ******/
/********************************************************************************************/
/********************************************************************************************/
static int
do_qemu_monitor( ControlClient client, char* args )
{
char socketname[32];
int fd;
CharDriverState* cs;
if (args != NULL) {
control_write( client, "KO: no argument for 'qemu monitor'\r\n" );
return -1;
}
/* Detach the client socket, and re-attach it to a monitor */
fd = control_client_detach(client);
snprintf(socketname, sizeof socketname, "tcp:socket=%d", fd);
cs = qemu_chr_open("monitor", socketname, NULL);
if (cs == NULL) {
control_client_reattach(client, fd);
control_write( client, "KO: internal error: could not detach from console !\r\n" );
return -1;
}
monitor_init(cs, MONITOR_USE_READLINE|MONITOR_QUIT_DOESNT_EXIT);
control_client_destroy(client);
return 0;
}
static const CommandDefRec qemu_commands[] =
{
{ "monitor", "enter QEMU monitor",
"Enter the QEMU virtual machine monitor\r\n",
NULL, do_qemu_monitor, 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 },
{ "qemu", "QEMU-specific commands",
"allows to connect to the QEMU virtual machine monitor\r\n", NULL,
NULL, qemu_commands },
{ NULL, NULL, NULL, NULL, NULL, NULL }
};
static ControlGlobalRec _g_global;
int
control_console_start( int port )
{
return control_global_init( &_g_global, port );
}