/* 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 "vl.h"
#include "android.h"
#include "sockets.h"
#include "hw/goldfish_device.h"
#include "hw/power_supply.h"
#include "shaper.h"
#include "modem_driver.h"
#include "android_gps.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include "android_events.h"
#include "skin_keyboard.h"
#if defined(CONFIG_SLIRP)
#include "libslirp.h"
#endif
/* set to 1 to use the i/o and event functions
* defined in "telephony/sysdeps.h"
*/
#define USE_SYSDEPS 0
#include "sysdeps.h"
#define DEBUG 1
#if 1
# define D_ACTIVE VERBOSE_CHECK(console)
#else
# define D_ACTIVE DEBUG
#endif
#if DEBUG
# define D(x) do { if (D_ACTIVE) ( printf x , fflush(stdout) ); } while (0)
#else
# define D(x) do{}while(0)
#endif
extern int slirp_inited; /* in vl.c */
typedef struct ControlGlobalRec_* ControlGlobal;
typedef struct ControlClientRec_* ControlClient;
typedef struct {
int host_port;
int host_udp;
unsigned int guest_addr;
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_addr,
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_addr = guest_addr;
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 = send( client->sock, buff, len, 0);
#endif
if (ret < 0) {
if (socket_errno != EINTR && socket_errno != EWOULDBLOCK)
return;
} else {
buff += ret;
len -= ret;
}
}
}
static void control_write( ControlClient client, const char* format, ... )
{
static char temp[1024];
va_list args;
va_start(args, format);
vsnprintf( temp, sizeof(temp), format, args );
va_end(args);
temp[ sizeof(temp)-1 ] = 0;
control_control_write( client, temp, -1 );
}
static ControlClient
control_client_create( Socket socket,
ControlGlobal global )
{
ControlClient client = calloc( sizeof(*client), 1 );
if (client) {
#if !USE_SYSDEPS
socket_set_lowlatency( 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 <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: " ));
#if USE_SYSDEPS
size = sys_channel_read( client->sock, buf, sizeof(buf) );
#else
size = recv( client->sock, buf, sizeof(buf), 0 );
#endif
if (size < 0) {
D(( "size < 0, exiting with %d: %s\n", socket_errno, socket_errstr() ));
if (socket_errno != EWOULDBLOCK && socket_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(;;) {
struct sockaddr_in sockaddr;
socklen_t len = sizeof(sockaddr);
fd = accept( global->listen_fd, (struct sockaddr *)&sockaddr, &len);
if (fd < 0 && socket_errno != EINTR) {
D(( "problem in accept: %d: %s\n", socket_errno, socket_errstr() ));
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;
struct sockaddr_in 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(PF_INET, SOCK_STREAM, 0);
if (fd < 0) {
perror("socket");
return -1;
}
socket_set_xreuseaddr( fd );
memset( &sockaddr, 0, sizeof(sockaddr) );
sockaddr.sin_family = AF_INET;
sockaddr.sin_port = htons(control_port);
sockaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
if (ret < 0) {
perror("bind");
close( fd );
return -1;
}
ret = listen(fd, 0);
if (ret < 0) {
perror("listen");
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, "<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 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 },
{ 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;
struct in_addr guest_addr;
Redir redir;
if ( !args )
goto BadFormat;
if (!slirp_inited) {
slirp_inited = 1;
slirp_init();
}
len = redir_parse_proto_port( args, &host_port, &host_proto );
if (len == 0 || args[len] != ':')
goto BadFormat;
args += len + 1;
len = redir_parse_guest_port( args, &guest_port );
if (len == 0 || args[len] != 0)
goto BadFormat;
redir = redir_find( client->global, host_port, host_proto );
if ( redir != NULL ) {
control_write( client, "KO: host port already active, use 'redir del' to remove first\r\n" );
return -1;
}
if (!inet_aton("10.0.2.15", &guest_addr)) {
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_addr.s_addr, 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_addr, 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;
}
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 <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 )
{
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 <message>'\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 <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_vm_stop( ControlClient client, char* args )
{
if (!vm_running) {
control_write( client, "KO: virtual machine already stopped\r\n" );
return -1;
}
vm_stop(EXCP_INTERRUPT);
return 0;
}
static int
do_vm_start( ControlClient client, char* args )
{
if (vm_running) {
control_write( client, "KO: virtual machine already running\r\n" );
return -1;
}
vm_start();
return 0;
}
static int
do_vm_status( ControlClient client, char* args )
{
control_write( client, "virtual machine is %s\r\n", vm_running ? "running" : "stopped" );
return 0;
}
static const CommandDefRec vm_commands[] =
{
{ "stop", "stop the virtual machine",
"'vm stop' stops the virtual machine immediately, use 'vm start' to continue execution\r\n",
NULL, do_vm_stop, NULL },
{ "start", "start/restart the virtual machine",
"'vm start' will start or continue the virtual machine, use 'vm stop' to stop it\r\n",
NULL, do_vm_start, NULL },
{ "status", "query virtual machine status",
"'vm status' will indicate wether the virtual machine is running or not\r\n",
NULL, do_vm_status, 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 <sentence>' sends a NMEA 0183 sentence to the emulated machine, 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>]' 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"
"\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 <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_emulator_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 }
};
/********************************************************************************************/
/********************************************************************************************/
/***** ******/
/***** 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 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 },
{ "vm", "manager virtual machine state",
"allows to change (e.g. start/stop) the virtual machine 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 );
}
syntax highlighted by Code2HTML, v. 0.9.1