auto import from //depot/cupcake/@135843

1 files changed, 2190 insertions, 0 deletions

diff --git a/android/console.c b/android/console.c
new file mode 100644
index 0000000..3a769c1
--- /dev/null
+++ b/android/console.c
@@ -0,0 +1,2190 @@
+/* Copyright (C) 2007-2008 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+*/
+/*
+ *  Android emulator control console
+ *
+ *  this console is enabled automatically at emulator startup, on port 5554 by default,
+ *  unless some other emulator is already running. See (android_emulation_start in android_sdl.c
+ *  for details)
+ *
+ *  you can telnet to the console, then use commands like 'help' or others to dynamically
+ *  change emulator settings.
+ *
+ */
+
+#include "sockets.h"
+#include "qemu-char.h"
+#include "sysemu.h"
+#include "android/android.h"
+#include "sockets.h"
+#include "cpu.h"
+#include "hw/goldfish_device.h"
+#include "hw/power_supply.h"
+#include "shaper.h"
+#include "modem_driver.h"
+#include "android/gps.h"
+#include "android/globals.h"
+#include "android/utils/bufprint.h"
+#include "android/utils/debug.h"
+#include "android/utils/stralloc.h"
+#include "tcpdump.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include "android/hw-events.h"
+#include "android/skin/keyboard.h"
+
+#if defined(CONFIG_SLIRP)
+#include "libslirp.h"
+#endif
+
+/* set to 1 to use the i/o and event functions
+ * defined in "telephony/sysdeps.h"
+ */
+#define  USE_SYSDEPS  0
+
+#include "sysdeps.h"
+
+#define  DEBUG  1
+
+#if 1
+#  define  D_ACTIVE   VERBOSE_CHECK(console)
+#else
+#  define  D_ACTIVE   DEBUG
+#endif
+
+#if DEBUG
+#  define  D(x)   do { if (D_ACTIVE) ( printf x , fflush(stdout) ); } while (0)
+#else
+#  define  D(x)   do{}while(0)
+#endif
+
+extern int  slirp_inited;  /* in vl.c */
+
+typedef struct ControlGlobalRec_*  ControlGlobal;
+
+typedef struct ControlClientRec_*  ControlClient;
+
+typedef struct {
+    int           host_port;
+    int           host_udp;
+    unsigned int  guest_ip;
+    int           guest_port;
+} RedirRec, *Redir;
+
+
+#if USE_SYSDEPS
+typedef SysChannel  Socket;
+#else /* !USE_SYSDEPS */
+typedef int         Socket;
+#endif /* !USE_SYSDEPS */
+
+
+typedef struct ControlClientRec_
+{
+    struct ControlClientRec_*  next;       /* next client in list           */
+    Socket                     sock;       /* socket used for communication */
+    ControlGlobal              global;
+    char                       finished;
+    char                       buff[ 4096 ];
+    int                        buff_len;
+
+} ControlClientRec;
+
+
+typedef struct ControlGlobalRec_
+{
+    /* listening socket */
+    Socket    listen_fd;
+
+    /* the list of current clients */
+    ControlClient   clients;
+
+    /* the list of redirections currently active */
+    Redir     redirs;
+    int       num_redirs;
+    int       max_redirs;
+
+} ControlGlobalRec;
+
+
+static int
+control_global_add_redir( ControlGlobal  global,
+                          int            host_port,
+                          int            host_udp,
+                          unsigned int   guest_ip,
+                          int            guest_port )
+{
+    Redir  redir;
+
+    if (global->num_redirs >= global->max_redirs)
+    {
+        int  old_max = global->max_redirs;
+        int  new_max = old_max + (old_max >> 1) + 4;
+
+        Redir  new_redirs = realloc( global->redirs, new_max*sizeof(global->redirs[0]) );
+        if (new_redirs == NULL)
+            return -1;
+
+        global->redirs     = new_redirs;
+        global->max_redirs = new_max;
+    }
+
+    redir = &global->redirs[ global->num_redirs++ ];
+
+    redir->host_port  = host_port;
+    redir->host_udp   = host_udp;
+    redir->guest_ip   = guest_ip;
+    redir->guest_port = guest_port;
+
+    return 0;
+}
+
+static int
+control_global_del_redir( ControlGlobal  global,
+                          int            host_port,
+                          int            host_udp )
+{
+    int  nn;
+
+    for (nn = 0; nn < global->num_redirs; nn++)
+    {
+        Redir  redir = &global->redirs[nn];
+
+        if ( redir->host_port == host_port &&
+             redir->host_udp  == host_udp  )
+        {
+            memmove( redir, redir + 1, ((global->num_redirs - nn)-1)*sizeof(*redir) );
+            global->num_redirs -= 1;
+            return 0;
+        }
+    }
+    /* we didn't find it */
+    return -1;
+}
+
+static void
+control_client_destroy( ControlClient  client )
+{
+    ControlGlobal  global = client->global;
+    ControlClient  *pnode = &global->clients;
+
+    D(( "destroying control client %p\n", client ));
+
+#if USE_SYSDEPS
+    sys_channel_on( client->sock, 0, NULL, NULL );
+#else
+    qemu_set_fd_handler( client->sock, NULL, NULL, NULL );
+#endif
+
+    for ( ;; ) {
+        ControlClient  node = *pnode;
+        if ( node == NULL )
+            break;
+        if ( node == client ) {
+            *pnode     = node->next;
+            node->next = NULL;
+            break;
+        }
+        pnode = &node->next;
+    }
+
+#if USE_SYSDEPS
+    sys_channel_close( client->sock );
+    client->sock = NULL;
+#else
+    socket_close( client->sock );
+    client->sock = -1;
+#endif
+
+    free( client );
+}
+
+static void  control_client_read( void*  _client );  /* forward */
+
+
+static void  control_control_write( ControlClient  client, const char*  buff, int  len )
+{
+    int ret;
+
+    if (len < 0)
+        len = strlen(buff);
+
+    while (len > 0) {
+#if USE_SYSDEPS
+        ret = sys_channel_write( client->sock, buff, len );
+#else
+        ret = socket_send( client->sock, buff, len);
+#endif
+        if (ret < 0) {
+            if (errno != EINTR && errno != EWOULDBLOCK)
+                return;
+        } else {
+            buff += ret;
+            len  -= ret;
+        }
+    }
+}
+
+static void  control_write( ControlClient  client, const char*  format, ... )
+{
+    static char  temp[1024];
+    va_list      args;
+
+    va_start(args, format);
+    vsnprintf( temp, sizeof(temp), format, args );
+    va_end(args);
+
+    temp[ sizeof(temp)-1 ] = 0;
+
+    control_control_write( client, temp, -1 );
+}
+
+
+static ControlClient
+control_client_create( Socket         socket,
+                       ControlGlobal  global )
+{
+    ControlClient  client = calloc( sizeof(*client), 1 );
+
+    if (client) {
+#if !USE_SYSDEPS
+        socket_set_nodelay( socket );
+        socket_set_nonblock( socket );
+#endif
+        client->finished = 0;
+        client->global  = global;
+        client->sock    = socket;
+        client->next    = global->clients;
+        global->clients = client;
+
+#if USE_SYSDEPS
+        sys_channel_on( socket, SYS_EVENT_READ,
+                        (SysChannelCallback) control_client_read,
+                        client );
+#else
+        qemu_set_fd_handler( socket, control_client_read, NULL, client );
+#endif
+    }
+    return client;
+}
+
+typedef const struct CommandDefRec_  *CommandDef;
+
+typedef struct CommandDefRec_ {
+    const char*  names;
+    const char*  abstract;
+    const char*  description;
+    void        (*descriptor)( ControlClient  client );
+    int         (*handler)( ControlClient  client, char* args );
+    CommandDef   subcommands;   /* if handler is NULL */
+
+} CommandDefRec;
+
+static const CommandDefRec   main_commands[];  /* forward */
+
+static CommandDef
+find_command( char*  input, CommandDef  commands, char*  *pend, char*  *pargs )
+{
+    int    nn;
+    char*  args = strchr(input, ' ');
+
+    if (args != NULL) {
+        while (*args == ' ')
+            args++;
+
+        if (args[0] == 0)
+            args = NULL;
+    }
+
+    for (nn = 0; commands[nn].names != NULL; nn++)
+    {
+        const char*  name = commands[nn].names;
+        const char*  sep;
+
+        do {
+            int  len, c;
+
+            sep = strchr( name, '|' );
+            if (sep)
+                len = sep - name;
+            else
+                len = strlen(name);
+
+            c = input[len];
+            if ( !memcmp( name, input, len ) && (c == ' ' || c == 0) ) {
+                *pend  = input + len;
+                *pargs = args;
+                return &commands[nn];
+            }
+
+            if (sep)
+                name = sep + 1;
+
+        } while (sep != NULL && *name);
+    }
+    /* NOTE: don't touch *pend and *pargs if no command is found */
+    return NULL;
+}
+
+static void
+dump_help( ControlClient  client,
+           CommandDef     cmd,
+           const char*    prefix )
+{
+    if (cmd->description) {
+        control_write( client, "%s", cmd->description );
+    } else if (cmd->descriptor) {
+        cmd->descriptor( client );
+    } else
+        control_write( client, "%s\r\n", cmd->abstract );
+
+    if (cmd->subcommands) {
+        cmd = cmd->subcommands;
+        control_write( client, "\r\navailable sub-commands:\r\n" );
+        for ( ; cmd->names != NULL; cmd++ ) {
+            control_write( client, "   %s %-15s  %s\r\n", prefix, cmd->names, cmd->abstract );
+        }
+        control_write( client, "\r\n" );
+    }
+}
+
+static void
+control_client_do_command( ControlClient  client )
+{
+    char*       line     = client->buff;
+    char*       args     = NULL;
+    CommandDef  commands = main_commands;
+    char*       cmdend   = client->buff;
+    CommandDef  cmd      = find_command( line, commands, &cmdend, &args );
+
+    if (cmd == NULL) {
+        control_write( client, "KO: unknown command, try 'help'\r\n" );
+        return;
+    }
+
+    for (;;) {
+        CommandDef  subcmd;
+
+        if (cmd->handler) {
+            if ( !cmd->handler( client, args ) )
+                control_write( client, "OK\r\n" );
+            break;
+        }
+
+        /* no handler means we should have sub-commands */
+        if (cmd->subcommands == NULL) {
+            control_write( client, "KO: internal error: buggy command table for '%.*s'\r\n",
+                           cmdend - client->buff, client->buff );
+            break;
+        }
+
+        /* we need a sub-command here */
+        if ( !args ) {
+            dump_help( client, cmd, "" );
+            control_write( client, "KO: missing sub-command\r\n" );
+            break;
+        }
+
+        line     = args;
+        commands = cmd->subcommands;
+        subcmd   = find_command( line, commands, &cmdend, &args );
+        if (subcmd == NULL) {
+            dump_help( client, cmd, "" );
+            control_write( client, "KO:  bad sub-command\r\n" );
+            break;
+        }
+        cmd = subcmd;
+    }
+}
+
+/* implement the 'help' command */
+static int
+do_help( ControlClient  client, char*  args )
+{
+    char*       line;
+    char*       start = args;
+    char*       end   = start;
+    CommandDef  cmd = main_commands;
+
+    /* without arguments, simply dump all commands */
+    if (args == NULL) {
+        control_write( client, "Android console command help:\r\n\r\n" );
+        for ( ; cmd->names != NULL; cmd++ ) {
+            control_write( client, "    %-15s  %s\r\n", cmd->names, cmd->abstract );
+        }
+        control_write( client, "\r\ntry 'help <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 = socket_recv( client->sock, buf, sizeof(buf) );
+#endif
+    if (size < 0) {
+        D(( "size < 0, exiting with %d: %s\n", errno, errno_str ));
+		if (errno != EWOULDBLOCK && errno != EINTR)
+			control_client_destroy( client );
+        return;
+    }
+
+    if (size == 0) {
+        /* end of connection */
+        D(( "end of connection detected !!\n" ));
+        control_client_destroy( client );
+    }
+    else {
+        int  nn;
+#ifdef _WIN32
+#  if DEBUG
+        char  temp[16];
+        int   count = size > sizeof(temp)-1 ? sizeof(temp)-1 : size;
+        for (nn = 0; nn < count; nn++) {
+                int  c = buf[nn];
+                if (c == '\n')
+                        temp[nn] = '!';
+            else if (c < 32)
+                        temp[nn] = '.';
+                else
+                    temp[nn] = (char)c;
+        }
+        temp[nn] = 0;
+        D(( "received %d bytes: %s\n", size, temp ));
+#  endif
+#else
+        D(( "received %.*s\n", size, buf ));
+#endif
+        for (nn = 0; nn < size; nn++) {
+            control_client_read_byte( client, buf[nn] );
+            if (client->finished) {
+                control_client_destroy(client);
+                return;
+            }
+        }
+    }
+}
+
+
+/* this function is called on each new client connection */
+static void
+control_global_accept( void*  _global )
+{
+    ControlGlobal       global = _global;
+    ControlClient       client;
+    Socket              fd;
+
+    D(( "control_global_accept: just in (fd=%p)\n", (void*)global->listen_fd ));
+
+#if USE_SYSDEPS
+    fd = sys_channel_create_tcp_handler( global->listen_fd );
+    if (fd == NULL) {
+        perror("accept");
+        return;
+    }
+#else
+    for(;;) {
+        fd = socket_accept( global->listen_fd, NULL );
+        if (fd < 0 && errno != EINTR) {
+            D(( "problem in accept: %d: %s\n", errno, errno_str ));
+            perror("accept");
+            return;
+        } else if (fd >= 0) {
+            break;
+        }
+        D(( "relooping in accept()\n" ));
+    }
+
+    socket_set_xreuseaddr( fd );
+#endif
+
+    D(( "control_global_accept: creating new client\n" ));
+    client = control_client_create( fd, global );
+    if (client) {
+        D(( "control_global_accept: new client %p\n", client ));
+        control_write( client, "Android Console: type 'help' for a list of commands\r\n" );
+        control_write( client, "OK\r\n" );
+    }
+}
+
+
+static int
+control_global_init( ControlGlobal  global,
+                     int            control_port )
+{
+    Socket  fd;
+#if !USE_SYSDEPS
+    int     ret;
+    SockAddress  sockaddr;
+#endif
+
+    memset( global, 0, sizeof(*global) );
+
+    sys_main_init();
+
+#if USE_SYSDEPS
+    fd = sys_channel_create_tcp_server( control_port );
+    if (fd == NULL) {
+        return -1;
+    }
+
+    D(("global fd=%p\n", fd));
+
+    global->listen_fd = fd;
+    sys_channel_on( fd, SYS_EVENT_READ,
+                    (SysChannelCallback) control_global_accept,
+                    global );
+#else
+    fd = socket_create_inet( SOCKET_STREAM );
+    if (fd < 0) {
+        perror("socket");
+        return -1;
+    }
+
+    socket_set_xreuseaddr( fd );
+
+    sock_address_init_inet( &sockaddr, SOCK_ADDRESS_INET_LOOPBACK, control_port );
+
+    ret = socket_bind(fd, &sockaddr );
+    if (ret < 0) {
+        perror("bind");
+        socket_close( fd );
+        return -1;
+    }
+
+    ret = socket_listen(fd, 0);
+    if (ret < 0) {
+        perror("listen");
+        socket_close( fd );
+        return -1;
+    }
+
+    socket_set_nonblock(fd);
+
+    global->listen_fd = fd;
+
+    qemu_set_fd_handler( fd, control_global_accept, NULL, global );
+#endif
+    return 0;
+}
+
+
+
+static int
+do_quit( ControlClient  client, char*  args )
+{
+    client->finished = 1;
+    return -1;
+}
+
+/********************************************************************************************/
+/********************************************************************************************/
+/*****                                                                                 ******/
+/*****                        N E T W O R K   S E T T I N G S                          ******/
+/*****                                                                                 ******/
+/********************************************************************************************/
+/********************************************************************************************/
+
+static int
+do_network_status( ControlClient  client, char*  args )
+{
+    control_write( client, "Current network status:\r\n" );
+
+    control_write( client, "  download speed:   %8d bits/s (%.1f KB/s)\r\n",
+                   (long)qemu_net_download_speed, qemu_net_download_speed/8192. );
+
+    control_write( client, "  upload speed:     %8d bits/s (%.1f KB/s)\r\n",
+                   (long)qemu_net_upload_speed, qemu_net_upload_speed/8192. );
+
+    control_write( client, "  minimum latency:  %ld ms\r\n", qemu_net_min_latency );
+    control_write( client, "  maximum latency:  %ld ms\r\n", qemu_net_max_latency );
+    return 0;
+}
+
+static void
+dump_network_speeds( ControlClient  client )
+{
+    const NetworkSpeed*  speed = android_netspeeds;
+    const char* const  format = "  %-8s %s\r\n";
+    for ( ; speed->name; speed++ ) {
+        control_write( client, format, speed->name, speed->display );
+    }
+    control_write( client, format, "<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_inited) {
+        slirp_inited = 1;
+        slirp_init();
+    }
+
+    len = redir_parse_proto_port( args, &host_port, &host_proto );
+    if (len == 0 || args[len] != ':')
+        goto BadFormat;
+
+    args += len + 1;
+    len = redir_parse_guest_port( args, &guest_port );
+    if (len == 0 || args[len] != 0)
+        goto BadFormat;
+
+    redir = redir_find( client->global, host_port, host_proto );
+    if ( redir != NULL ) {
+        control_write( client, "KO: host port already active, use 'redir del' to remove first\r\n" );
+        return -1;
+    }
+
+    if (!inet_strtoip("10.0.2.15", &guest_ip)) {
+        control_write( client, "KO: unexpected internal failure when resolving 10.0.2.15\r\n" );
+        return -1;
+    }
+
+    D(("pattern hport=%d gport=%d proto=%d\n", host_port, guest_port, host_proto ));
+    if ( control_global_add_redir( client->global, host_port, host_proto,
+                                   guest_ip, guest_port ) < 0 )
+    {
+        control_write( client, "KO: not enough memory to allocate redirection\r\n" );
+        return -1;
+    }
+
+    if (slirp_redir(host_proto, host_port, guest_ip, guest_port) < 0) {
+        control_write( client, "KO: can't setup redirection, port probably used by another program on host\r\n" );
+        control_global_del_redir( client->global, host_port, host_proto );
+        return -1;
+    }
+
+    return 0;
+
+BadFormat:
+    control_write( client, "KO: bad redirection format, try (tcp|udp):hostport:guestport\r\n", -1 );
+    return -1;
+}
+
+
+static int
+do_redir_del( ControlClient  client, char*  args )
+{
+    int    len, proto, port;
+    Redir  redir;
+
+    if ( !args )
+        goto BadFormat;
+    len = redir_parse_proto_port( args, &port, &proto );
+    if ( len == 0 || args[len] != 0 )
+        goto BadFormat;
+
+    redir = redir_find( client->global, port, proto );
+    if (redir == NULL) {
+        control_write( client, "KO: can't remove unknown redirection (%s:%d)\r\n",
+                        proto ? "udp" : "tcp", port );
+        return -1;
+    }
+
+    slirp_unredir( redir->host_udp, redir->host_port );
+    control_global_del_redir( client->global, port, proto );\
+
+    return 0;
+
+BadFormat:
+    control_write( client, "KO: bad redirection format, try (tcp|udp):hostport\r\n" );
+    return -1;
+}
+
+static const CommandDefRec  redir_commands[] =
+{
+    { "list", "list current redirections",
+    "list current port redirections. use 'redir add' and 'redir del' to add and remove them\r\n", NULL,
+    do_redir_list, NULL },
+
+    { "add",  "add new redirection",
+    "add a new port redirection, arguments must be:\r\n\r\n"
+            "  redir add <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_avd_stop( ControlClient  client, char*  args )
+{
+    if (!vm_running) {
+        control_write( client, "KO: virtual device already stopped\r\n" );
+        return -1;
+    }
+    vm_stop(EXCP_INTERRUPT);
+    return 0;
+}
+
+static int
+do_avd_start( ControlClient  client, char*  args )
+{
+    if (vm_running) {
+        control_write( client, "KO: virtual device already running\r\n" );
+        return -1;
+    }
+    vm_start();
+    return 0;
+}
+
+static int
+do_avd_status( ControlClient  client, char*  args )
+{
+    control_write( client, "virtual device is %s\r\n", vm_running ? "running" : "stopped" );
+    return 0;
+}
+
+static int
+do_avd_name( ControlClient  client, char*  args )
+{
+    control_write( client, "%s\r\n", avdInfo_getName(android_avdInfo) );
+    return 0;
+}
+
+static const CommandDefRec  vm_commands[] =
+{
+    { "stop", "stop the virtual device",
+    "'avd stop' stops the virtual device immediately, use 'avd start' to continue execution\r\n",
+    NULL, do_avd_stop, NULL },
+
+    { "start", "start/restart the virtual device",
+    "'avd start' will start or continue the virtual device, use 'avd stop' to stop it\r\n",
+    NULL, do_avd_start, NULL },
+
+    { "status", "query virtual device status",
+    "'avd status' will indicate wether the virtual device is running or not\r\n",
+    NULL, do_avd_status, NULL },
+
+    { "name", "query virtual device name",
+    "'avd name' will return the name of this virtual device\r\n",
+    NULL, do_avd_name, NULL },
+
+    { NULL, NULL, NULL, NULL, NULL, NULL }
+};
+
+/********************************************************************************************/
+/********************************************************************************************/
+/*****                                                                                 ******/
+/*****                             G E O   C O M M A N D S                             ******/
+/*****                                                                                 ******/
+/********************************************************************************************/
+/********************************************************************************************/
+
+static int
+do_geo_nmea( ControlClient  client, char*  args )
+{
+    if (!args) {
+        control_write( client, "KO: NMEA sentence missing, try 'help geo nmea'\r\n" );
+        return -1;
+    }
+    if (!android_gps_cs) {
+        control_write( client, "KO: no GPS emulation in this virtual device\r\n" );
+        return -1;
+    }
+    android_gps_send_nmea( args );
+    return 0;
+}
+
+static int
+do_geo_fix( ControlClient  client, char*  args )
+{
+#define  MAX_GEO_PARAMS  3
+    char*   p = args;
+    int     n_params = 0;
+    double  params[ MAX_GEO_PARAMS ];
+
+    static  int     last_time = 0;
+    static  double  last_altitude = 0.;
+
+    if (!p)
+        p = "";
+
+    /* tokenize */
+    while (*p) {
+        char*   end;
+        double  val = strtod( p, &end );
+
+        if (end == p) {
+            control_write( client, "KO: argument '%s' is not a number\n", p );
+            return -1;
+        }
+
+        params[n_params++] = val;
+        if (n_params >= MAX_GEO_PARAMS)
+            break;
+
+        p = end;
+        while (*p && (p[0] == ' ' || p[0] == '\t'))
+            p += 1;
+    }
+
+    /* sanity check */
+    if (n_params < 2) {
+        control_write( client, "KO: not enough arguments: see 'help geo fix' for details\r\n" );
+        return -1;
+    }
+
+    /* generate an NMEA sentence for this fix */
+    {
+        STRALLOC_DEFINE(s);
+        double   val;
+        int      deg, min;
+        char     hemi;
+
+        /* first, the time */
+        stralloc_add_format( s, "$GPGGA,%06d", last_time );
+        last_time ++;
+
+        /* then the latitude */
+        hemi = 'N';
+        val  = params[1];
+        if (val < 0) {
+            hemi = 'S';
+            val  = -val;
+        }
+        deg = (int) val;
+        min = 60*(val - deg);
+        val = val - min/60.;
+        stralloc_add_format( s, ",%02d%02d.%04d,%c", deg, min, (int)(val * 10000), hemi );
+
+        /* the longitude */
+        hemi = 'E';
+        val  = params[0];
+        if (val < 0) {
+            hemi = 'W';
+            val  = -val;
+        }
+        deg = (int) val;
+        min = 60*(val - deg);
+        val = val - min/60.;
+        stralloc_add_format( s, ",%02d%02d.%04d,%c", deg, min, (int)(val * 10000), hemi );
+
+        /* bogus fix quality, empty satellite count and dilutions */
+        stralloc_add_str( s, ",1,,,," );
+
+        /* optional altitude */
+        if (n_params >= 3) {
+            stralloc_add_format( s, "%.1g", params[2] );
+            last_altitude = params[2];
+        } else {
+            stralloc_add_str( s, "," );
+        }
+        /* bogus rest and checksum */
+        stralloc_add_str( s, ",,,*47" );
+
+        /* send it, then free */
+        android_gps_send_nmea( stralloc_cstr(s) );
+        stralloc_reset( s );
+    }
+    return 0;
+}
+
+static const CommandDefRec  geo_commands[] =
+{
+    { "nmea", "send an GPS NMEA sentence",
+    "'geo nema <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>]' 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 to change battery and AC power status\r\n", NULL,
+      NULL, power_commands },
+
+    { "quit|exit", "quit control session", NULL, NULL,
+      do_quit, NULL },
+
+    { "redir",    "manage port redirections",
+      "allows you to add, list and remove UDP and/or PORT redirection from the host to the device\r\n"
+      "as an example, 'redir  tcp:5000:6000' will route any packet sent to the host's TCP port 5000\r\n"
+      "to TCP port 6000 of the emulated device\r\n", NULL,
+      NULL, redir_commands },
+
+    { "sms", "SMS related commands",
+      "allows you to simulate an inbound SMS\r\n", NULL,
+      NULL, sms_commands },
+
+    { "avd", "manager virtual device state",
+    "allows to change (e.g. start/stop) the virtual device state\r\n", NULL,
+    NULL, vm_commands },
+
+    { "window", "manage emulator window",
+    "allows you to modify the emulator window\r\n", NULL,
+    NULL, window_commands },
+
+    { NULL, NULL, NULL, NULL, NULL, NULL }
+};
+
+
+static ControlGlobalRec  _g_global;
+
+int
+control_console_start( int  port )
+{
+    return control_global_init( &_g_global, port );
+}