auto import from //depot/cupcake/@135843

1 files changed, 0 insertions, 2190 deletions

diff --git a/android/console.c b/android/console.c
deleted file mode 100644
index 3a769c1..0000000
--- a/android/console.c
+++ /dev/null
@@ -1,2190 +0,0 @@
-/* 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 );
-}