simulator/wrapsim/SimMgr.c - fp2-dev/platform/development - Gitiles

 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Simulator interactions.
  *
  * TODO: for multi-process we probably need to switch to a new process
  * group if we are the first process (could be runtime, could be gdb),
  * rather than wait for the simulator to tell us to switch.
  */
 #include "Common.h"

 #include <stdlib.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
 #include <sys/sem.h>
 #include <sys/un.h>
 #include <signal.h>
 #include <assert.h>

 // fwd
 static int connectToSim(void);
 static void listenToSim(void);

 /*
  * Env var to restrict who tries to talk to the front end.
  */
 #define kWrapSimConnectedEnv    "WRAP_SIM_CONNECTED"


 /*
  * Signal the main thread that we're ready to continue.
  */
 static void signalMainThread(void)
 {
     int cc;

     cc = pthread_mutex_lock(&gWrapSim.startLock);
     assert(cc == 0);

     gWrapSim.startReady = 1;

     cc = pthread_cond_signal(&gWrapSim.startCond);
     assert(cc == 0);

     cc = pthread_mutex_unlock(&gWrapSim.startLock);
     assert(cc == 0);
 }


 /*
  * Entry point for the sim management thread.
  *
  * Once we have established a connection to the simulator and are ready
  * for other threads to send messages, we signal the main thread.
  */
 static void* simThreadEntry(void* arg)
 {
     wsLog("--- sim manager thread started\n");

     /*
      * Establish a connection to the simulator front-end.  If we can't do
      * that, we have no access to input or output devices, and we might
      * as well give up.
      */
     if (connectToSim() != 0) {
         signalMainThread();
         return NULL;
     }

     /* success! */
     wsLog("--- sim manager thread ready\n");
     gWrapSim.simulatorInitFailed = 0;
     signalMainThread();

     listenToSim();

     wsLog("--- sim manager thread exiting\n");

     return NULL;
 }

 /*
  * If we think we're not yet connected to the sim, do so now.  We only
  * want to do this once per process *group*, so we control access with
  * an environment variable.
  */
 int wsSimConnect(void)
 {
     /*
      * If the environment variable hasn't been set, assume we're the first
      * to get here, and should attach to the simulator.  We set the env
      * var here whether or not we succeed in connecting to the sim.
      *
      * (For correctness we should wrap the getenv/setenv in a semaphore.)
      */
     if (getenv(kWrapSimConnectedEnv) == NULL) {
         pthread_attr_t threadAttr;
         pthread_t threadHandle;
         int cc;

         gWrapSim.simulatorInitFailed = 1;
         setenv(kWrapSimConnectedEnv, "1", 1);

         cc = pthread_mutex_lock(&gWrapSim.startLock);
         assert(cc == 0);

         pthread_attr_init(&threadAttr);
         pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED);
         cc = pthread_create(&threadHandle, &threadAttr, simThreadEntry, NULL);
         if (cc != 0) {
             wsLog("Unable to create new thread: %s\n", strerror(errno));
             abort();
         }

         while (!gWrapSim.startReady) {
             cc = pthread_cond_wait(&gWrapSim.startCond, &gWrapSim.startLock);
             assert(cc == 0);
         }

         cc = pthread_mutex_unlock(&gWrapSim.startLock);
         assert(cc == 0);

         if (gWrapSim.simulatorInitFailed) {
             wsLog("Simulator initialization failed, bailing\n");

             /* this *should* be okay to do */
             fprintf(stderr, "Fatal error:"
                 " unable to connect to sim front-end (not running?)\n");
             abort();
         }
     }

     wsLog("+++ continuing\n");
     return 0;
 }


 /*
  * ===========================================================================
  *      Message / MessageStream
  * ===========================================================================
  */

 /*
  * This is a quick & dirty rewrite of the C++ Message and MessageStream
  * classes, ported to C, reduced in generality, with syscalls stubbed
  * where necessary.  I didn't fix the API to make it more sensible in C
  * (which lacks destructors), so some of this is a little fragile or
  * awkward.
  */

 /* values for message type byte; must match android::Message constants */
 typedef enum MessageType {
     kTypeUnknown = 0,
     kTypeRaw,           // chunk of raw data
     kTypeConfig,        // send a name=value pair to peer
     kTypeCommand,       // simple command w/arg
     kTypeCommandExt,    // slightly more complicated command
     kTypeLogBundle,     // multi-part log message
 } MessageType;

 /*
  * Reusable message object.
  */
 typedef struct Message {
     MessageType     mType;
     unsigned char*  mData;
     int             mLength;
 } Message;

 /* magic init messages; must match android::MessageStream constants */
 enum {
     kHelloMsg       = 0x4e303047,       // 'N00G'
     kHelloAckMsg    = 0x31455221,       // '1ER!'
 };


 /*
  * Clear out a Message.
  */
 static void Message_clear(Message* msg)
 {
     memset(msg, 0, sizeof(Message));
 }

 /*
  * Keep reading until we get all bytes or hit EOF/error.  "fd" is expected
  * to be in blocking mode.
  *
  * Returns 0 on success.
  */
 static int readAll(int fd, void* buf, size_t count)
 {
     ssize_t actual;
     ssize_t have;

     have = 0;
     while (have != (ssize_t) count) {
         actual = _ws_read(fd, ((char*) buf) + have, count - have);
         if (actual < 0) {
             if (errno == EINTR)
                 continue;
             wsLog("read %d failed: %s\n", fd, strerror(errno));
         } else if (actual == 0) {
             wsLog("early EOF on %d\n", fd);
             return -1;
         } else {
             have += actual;
         }

         assert(have <= (ssize_t)count);
     }

     return 0;
 }

 #if 0
 /*
  * Keep writing until we put all bytes or hit an error.  "fd" is expected
  * to be in blocking mode.
  *
  * Returns 0 on success.
  */
 static int writeAll(int fd, const void* buf, size_t count)
 {
     ssize_t actual;
     ssize_t have;

     have = 0;
     while (have != count) {
         actual = _ws_write(fd, ((const char*) buf) + have, count - have);
         if (actual < 0) {
             if (errno == EINTR)
                 continue;
             wsLog("write %d failed: %s\n", fd, strerror(errno));
         } else if (actual == 0) {
             wsLog("wrote zero on %d\n", fd);
             return -1;
         } else {
             have += actual;
         }

         assert(have <= count);
     }

     return 0;
 }
 #endif

 /*
  * Read a message from the specified file descriptor.
  *
  * The caller must Message_release(&msg).
  *
  * We guarantee 32-bit alignment for msg->mData.
  */
 static int Message_read(Message* msg, int fd)
 {
     unsigned char header[4];

     readAll(fd, header, 4);

     msg->mType = (MessageType) header[2];
     msg->mLength = header[0] | header[1] << 8;
     msg->mLength -= 2;   // we already read two of them in the header

     if (msg->mLength > 0) {
         int actual;

         /* Linux malloc guarantees at least 32-bit alignment */
         msg->mData = (unsigned char*) malloc(msg->mLength);
         if (msg->mData == NULL) {
             wsLog("alloc %d failed\n", msg->mLength);
             return -1;
         }

         if (readAll(fd, msg->mData, msg->mLength) != 0) {
             wsLog("failed reading message body (wanted %d)\n", msg->mLength);
             return -1;
         }
     } else {
         msg->mData = NULL;
     }

     return 0;
 }

 /*
  * Write a message to the specified file descriptor.
  *
  * The caller must Message_release(&msg).
  */
 static int Message_write(Message* msg, int fd)
 {
     struct iovec writeVec[2];
     unsigned char header[4];
     int len, numVecs;
     ssize_t actual;

     len = msg->mLength + 2;
     header[0] = len & 0xff;
     header[1] = (len >> 8) & 0xff;
     header[2] = msg->mType;
     header[3] = 0;
     writeVec[0].iov_base = header;
     writeVec[0].iov_len = 4;
     numVecs = 1;

     if (msg->mLength > 0) {
         assert(msg->mData != NULL);
         writeVec[1].iov_base = msg->mData;
         writeVec[1].iov_len = msg->mLength;
         numVecs++;
     }

     /* write it all in one shot; not worrying about partial writes for now */
     actual = _ws_writev(fd, writeVec, numVecs);
     if (actual != len+2) {
         wsLog("failed writing message to fd %d: %d of %d %s\n",
             fd, actual, len+2, strerror(errno));
         return -1;
     }

     return 0;
 }

 /*
  * Release storage associated with a Message.
  */
 static void Message_release(Message* msg)
 {
     free(msg->mData);
     msg->mData = NULL;
 }

 /*
  * Extract a name/value pair from a message.
  */
 static int getConfig(const Message* msg, const char** name, const char** val)
 {
     if (msg->mLength < 2) {
         wsLog("message len (%d) is too short\n", msg->mLength);
         return -1;
     }
     const char* ptr = (const char*) msg->mData;

     *name = (const char*) ptr;
     *val = (const char*) (ptr + strlen((char*)ptr) +1);
     return 0;
 }

 /*
  * Extract a command from a message.
  */
 static int getCommand(const Message* msg, int* pCmd, int* pArg)
 {
     if (msg->mLength != sizeof(int) * 2) {
         wsLog("message len (%d) is wrong for cmd (%d)\n",
             msg->mLength, sizeof(int) * 2);
         return -1;
     }

     /* this assumes 32-bit alignment on mData */
     const int* ptr = (const int*) msg->mData;

     *pCmd = ptr[0];
     *pArg = ptr[1];

     return 0;
 }

 /*
  * Extract an extended command from a message.
  */
 static int getCommandExt(const Message* msg, int* pCmd, int* pArg0,
     int* pArg1, int* pArg2)
 {
     if (msg->mLength != sizeof(int) * 4) {
         wsLog("message len (%d) is wrong for cmd (%d)\n",
             msg->mLength, sizeof(int) * 4);
         return -1;
     }

     /* this assumes 32-bit alignment on mData */
     const int* ptr = (const int*) msg->mData;

     *pCmd = ptr[0];
     *pArg0 = ptr[1];
     *pArg1 = ptr[2];
     *pArg2 = ptr[3];

     return 0;
 }

 /*
  * Attach 8 bytes of data with "cmd" and "arg" to "msg".
  *
  * "msg->mData" will need to be freed by the caller.  (This approach made
  * more sense when C++ destructors were available, but it's just not worth
  * reworking it.)
  */
 static int setCommand(Message* msg, int cmd, int arg)
 {
     Message_clear(msg);

     msg->mLength = 8;
     msg->mData = malloc(msg->mLength);
     msg->mType = kTypeCommand;

     /* assumes 32-bit alignment on malloc blocks */
     int* pInt = (int*) msg->mData;
     pInt[0] = cmd;
     pInt[1] = arg;

     return 0;
 }

 /*
  * Construct the full path.  The caller must free() the return value.
  */
 static char* makeFilename(const char* name)
 {
     static const char* kBasePath = "/tmp/android-";
     char* fileName;

     assert(name != NULL && name[0] != '\0');

     fileName = (char*) malloc(strlen(kBasePath) + strlen(name) + 1);
     strcpy(fileName, kBasePath);
     strcat(fileName, name);

     return fileName;
 }

 /*
  * Attach to a SysV shared memory segment.
  */
 static int attachToShmem(int key, int* pShmid, void** pAddr, long* pLength)
 {
     int shmid;

     shmid = shmget(key, 0, 0);
     if (shmid == -1) {
         wsLog("ERROR: failed to find shmem key=%d\n", key);
         return -1;
     }

     void* addr = shmat(shmid, NULL, 0);
     if (addr == (void*) -1) {
         wsLog("ERROR: could not attach to key=%d shmid=%d\n", key, shmid);
         return -1;
     }

     struct shmid_ds shmids;
     int cc;

     cc = shmctl(shmid, IPC_STAT, &shmids);
     if (cc != 0) {
         wsLog("ERROR: could not IPC_STAT shmid=%d\n", shmid);
         return -1;
     }
     *pLength = shmids.shm_segsz;

     *pAddr = addr;
     *pShmid = shmid;
     return 0;
 }

 /*
  * Attach to a SysV semaphore.
  */
 static int attachToSem(int key, int* pSemid)
 {
     int semid;

     semid = semget(key, 0, 0);
     if (semid == -1) {
         wsLog("ERROR: failed to attach to semaphore key=%d\n", key);
         return -1;
     }

     *pSemid = semid;
     return 0;
 }

 /*
  * "Adjust" a semaphore.
  */
 static int adjustSem(int semid, int adj)
 {
     const int wait = 1;
     struct sembuf op;
     int cc;

     op.sem_num = 0;
     op.sem_op = adj;
     op.sem_flg = SEM_UNDO;
     if (!wait)
         op.sem_flg |= IPC_NOWAIT;

     cc = semop(semid, &op, 1);
     if (cc != 0) {
         if (wait || errno != EAGAIN) {
             wsLog("Warning:"
                 " semaphore adjust by %d failed for semid=%d (errno=%d)\n",
                 adj, semid, errno);
         }
         return -1;
     }

     return 0;
 }

 /*
  * Acquire the semaphore associated with a display.
  */
 void wsLockDisplay(int displayIdx)
 {
     assert(displayIdx >= 0 && displayIdx < gWrapSim.numDisplays);
     int semid = gWrapSim.display[displayIdx].semid;

     (void) adjustSem(semid, -1);
 }

 /*
  * Acquire the semaphore associated with a display.
  */
 void wsUnlockDisplay(int displayIdx)
 {
     assert(displayIdx >= 0 && displayIdx < gWrapSim.numDisplays);
     int semid = gWrapSim.display[displayIdx].semid;

     (void) adjustSem(semid, 1);
 }

 /*
  * Process the display config from the simulator
  *
  * Right now this is a blob of raw data that looks like this:
  *  +00 magic number
  *  +04 #of displays
  *  +08 display 0:
  *      +00 width
  *      +04 height
  *      +08 format
  *      +0c refresh rate
  *      +10 shmem key
  *  +1c display 1...
  */
 static int handleDisplayConfig(const int* pData, int length)
 {
     int numDisplays;

     if (length < 8) {
         wsLog("Bad display config: length is %d\n", length);
         return -1;
     }
     assert(*pData == kDisplayConfigMagic);

     /*
      * Pull out the #of displays.  If it looks valid, configure the runtime.
      */
     pData++;        // skip over magic
     numDisplays = *pData++;

     if (numDisplays <= 0 || numDisplays > kMaxDisplays) {
         wsLog("Bizarre display count %d\n", numDisplays);
         return -1;
     }
     if (length != 8 + numDisplays * kValuesPerDisplay * (int)sizeof(int)) {
         wsLog("Bad display config: length is %d (expected %d)\n",
             length, 8 + numDisplays * kValuesPerDisplay * (int)sizeof(int));
         return -1;
     }

     /*
      * Extract the config values.
      *
      * The runtime doesn't support multiple devices, so we don't either.
      */
     int i;
     for (i = 0; i < numDisplays; i++) {
         gWrapSim.display[i].width = pData[0];
         gWrapSim.display[i].height = pData[1];
         gWrapSim.display[i].shmemKey = pData[4];
         /* format/refresh no longer needed */

         void* addr;
         int shmid, semid;
         long length;
         if (attachToShmem(gWrapSim.display[i].shmemKey, &shmid, &addr,
                 &length) != 0)
         {
             wsLog("Unable to connect to shared memory\n");
             return -1;
         }

         if (attachToSem(gWrapSim.display[i].shmemKey, &semid) != 0) {
             wsLog("Unable to attach to sempahore\n");
             return -1;
         }

         gWrapSim.display[i].shmid = shmid;
         gWrapSim.display[i].addr = addr;
         gWrapSim.display[i].length = length;
         gWrapSim.display[i].semid = semid;

         wsLog("Display %d: width=%d height=%d\n",
             i,
             gWrapSim.display[i].width,
             gWrapSim.display[i].height);
         wsLog("  shmem=0x%08x addr=%p len=%ld semid=%d\n",
             gWrapSim.display[i].shmemKey,
             gWrapSim.display[i].addr,
             gWrapSim.display[i].length,
             gWrapSim.display[i].semid);

         pData += kValuesPerDisplay;
     }
     gWrapSim.numDisplays = numDisplays;

     return 0;
 }


 /*
  * Initialize our connection to the simulator, which will be listening on
  * a UNIX domain socket.
  *
  * On success, this configures gWrapSim.simulatorFd and returns 0.
  */
 static int openSimConnection(const char* name)
 {
     int result = -1;
     char* fileName = NULL;
     int sock = -1;
     int cc;

     assert(gWrapSim.simulatorFd == -1);

     fileName = makeFilename(name);

     struct sockaddr_un addr;

     sock = socket(AF_UNIX, SOCK_STREAM, 0);
     if (sock < 0) {
         wsLog("UNIX domain socket create failed (errno=%d)\n", errno);
         goto bail;
     }

     /* connect to socket; fails if file doesn't exist */
     strcpy(addr.sun_path, fileName);    // max 108 bytes
     addr.sun_family = AF_UNIX;
     cc = connect(sock, (struct sockaddr*) &addr, SUN_LEN(&addr));
     if (cc < 0) {
         // ENOENT means socket file doesn't exist
         // ECONNREFUSED means socket exists but nobody is listening
         wsLog("AF_UNIX connect failed for '%s': %s\n",
             fileName, strerror(errno));
         goto bail;
     }

     gWrapSim.simulatorFd = sock;
     sock = -1;

     result = 0;
     wsLog("+++ connected to '%s'\n", fileName);

 bail:
     if (sock >= 0)
         _ws_close(sock);
     free(fileName);
     return result;
 }

 /*
  * Prepare communication with the front end.  We wait for a "hello" from
  * the other side, and respond in kind.
  */
 static int prepSimConnection(void)
 {
     /* NOTE: this is endian-specific; we're x86 Linux only, so no problem */
     static const unsigned int hello = kHelloMsg;
     static const unsigned int helloAck = kHelloAckMsg;
     Message msg;

     if (Message_read(&msg, gWrapSim.simulatorFd) != 0) {
         wsLog("hello read failed\n");
         return -1;
     }

     if (memcmp(msg.mData, &hello, 4) != 0) {
         wsLog("Got bad hello from peer\n");
         return -1;
     }

     Message_release(&msg);

     msg.mType = kTypeRaw;
     msg.mData = (unsigned char*) &helloAck;
     msg.mLength = 4;

     if (Message_write(&msg, gWrapSim.simulatorFd) != 0) {
         wsLog("hello ack write failed\n");
         return -1;
     }

     return 0;
 }

 /*
  * Get the sim front-end configuration.  We loop here until the sim claims
  * to be done with us.
  */
 static int getSimConfig(void)
 {
     Message msg;
     int joinNewGroup, grabTerminal, done;
     int result = -1;

     joinNewGroup = grabTerminal = done = 0;
     Message_clear(&msg);        // clear out msg->mData

     wsLog("+++ awaiting hardware configuration\n");
     while (!done) {
         if (Message_read(&msg, gWrapSim.simulatorFd) != 0) {
             wsLog("failed receiving config from parent\n");
             goto bail;
         }

         if (msg.mType == kTypeCommand) {
             int cmd, arg;

             if (getCommand(&msg, &cmd, &arg) != 0)
                 goto bail;

             switch (cmd) {
             case kCommandGoAway:
                 wsLog("Simulator front-end is busy\n");
                 goto bail;
             case kCommandNewPGroup:
                 joinNewGroup = 1;
                 grabTerminal = (arg != 0);
                 wsLog("Simulator wants us to be in a new pgrp (term=%d)\n",
                     grabTerminal);
                 break;
             case kCommandConfigDone:
                 done = 1;
                 break;
             default:
                 wsLog("Got unexpected command %d/%d\n", cmd, arg);
                 break;
             }
         } else if (msg.mType == kTypeRaw) {
             /* assumes 32-bit alignment and identical byte ordering */
             int* pData = (int*) msg.mData;
             if (msg.mLength >= 4 && *pData == kDisplayConfigMagic) {
                 if (handleDisplayConfig(pData, msg.mLength) != 0)
                     goto bail;
             }
         } else if (msg.mType == kTypeConfig) {
             const char *name;
             const char *val;
             getConfig(&msg, &name, &val);
             if(strcmp(name, "keycharmap") == 0) {
                 free((void*)gWrapSim.keyMap);
                 gWrapSim.keyMap = strdup(val);
             }
         } else {
             wsLog("Unexpected msg type %d during startup\n", msg.mType);
             goto bail;
         }

         /* clear out the data field if necessary */
         Message_release(&msg);
     }

     wsLog("Configuration received from simulator\n");

     if (joinNewGroup) {
         /* set pgid to pid */
         pid_t pgid = getpid();
         setpgid(0, pgid);

         /*
          * Put our pgrp in the foreground.
          * tcsetpgrp() from background process causes us to get a SIGTTOU,
          * which is mostly harmless but makes tcsetpgrp() fail with EINTR.
          */
         signal(SIGTTOU, SIG_IGN);
         if (grabTerminal) {
             if (tcsetpgrp(fileno(stdin), getpgrp()) != 0) {
                 wsLog("tcsetpgrp(%d, %d) failed (errno=%d)\n",
                     fileno(stdin), getpgrp(), errno);
             }
             wsLog("Set pgrp %d as foreground\n", (int) getpgrp());
         }

         /* tell the sim where we're at */
         Message msg;
         setCommand(&msg, kCommandNewPGroupCreated, pgid);
         Message_write(&msg, gWrapSim.simulatorFd);
         Message_release(&msg);
     }

     result = 0;

 bail:
     /* make sure the data was freed */
     Message_release(&msg);
     //wsLog("bailing, result=%d\n", result);
     return result;
 }

 /*
  * Connect to the simulator and exchange pleasantries.
  *
  * Returns 0 on success.
  */
 static int connectToSim(void)
 {
     if (openSimConnection(kAndroidPipeName) != 0)
         return -1;

     if (prepSimConnection() != 0)
         return -1;

     if (getSimConfig() != 0)
         return -1;

     wsLog("+++ sim is ready to go\n");

     return 0;
 }

 /*
  * Listen to the sim forever or until the front end shuts down, whichever
  * comes first.
  *
  * All we're really getting here are key events.
  */
 static void listenToSim(void)
 {
     wsLog("--- listening for input events from front end\n");

     while (1) {
         Message msg;

         Message_clear(&msg);
         if (Message_read(&msg, gWrapSim.simulatorFd) != 0) {
             wsLog("--- sim message read failed\n");
             return;
         }

         if (msg.mType == kTypeCommand) {
             int cmd, arg;

             if (getCommand(&msg, &cmd, &arg) != 0) {
                 wsLog("bad command from sim?\n");
                 continue;
             }

             switch (cmd) {
             case kCommandQuit:
                 wsLog("--- sim sent us a QUIT message\n");
                 return;
             case kCommandKeyDown:
                 wsLog("KEY DOWN: %d\n", arg);
                 wsSendSimKeyEvent(arg, 1);
                 break;
             case kCommandKeyUp:
                 wsLog("KEY UP: %d\n", arg);
                 wsSendSimKeyEvent(arg, 0);
                 break;
             default:
                 wsLog("--- sim sent unrecognized command %d\n", cmd);
                 break;
             }

             Message_release(&msg);
         } else if (msg.mType == kTypeCommandExt) {
             int cmd, arg0, arg1, arg2;

             if (getCommandExt(&msg, &cmd, &arg0, &arg1, &arg2) != 0) {
                 wsLog("bad ext-command from sim?\n");
                 continue;
             }

             switch (cmd) {
             case kCommandTouch:
                 wsSendSimTouchEvent(arg0, arg1, arg2);
                 break;
             }

             Message_release(&msg);
         } else {
             wsLog("--- sim sent non-command message, type=%d\n", msg.mType);
         }
     }

     assert(0);      // not reached
 }


 /*
  * Tell the simulator front-end that the display has been updated.
  */
 void wsPostDisplayUpdate(int displayIdx)
 {
     if (gWrapSim.simulatorFd < 0) {
         wsLog("Not posting display update -- sim not ready\n");
         return;
     }

     Message msg;

     setCommand(&msg, kCommandUpdateDisplay, displayIdx);
     Message_write(&msg, gWrapSim.simulatorFd);
     Message_release(&msg);
 }

 /*
  * Send a log message to the front-end.
  */
 void wsPostLogMessage(int logPrio, const char* tag, const char* message)
 {
     if (gWrapSim.simulatorFd < 0) {
         wsLog("Not posting log message -- sim not ready\n");
         return;
     }

     time_t when = time(NULL);
     int pid = (int) getpid();
     int tagLen, messageLen, totalLen;

     tagLen = strlen(tag) +1;
     messageLen = strlen(message) +1;
     totalLen = sizeof(int) * 3 + tagLen + messageLen;
     unsigned char outBuf[totalLen];
     unsigned char* cp = outBuf;

     /* See Message::set/getLogBundle() in simulator/MessageStream.cpp. */
     memcpy(cp, &when, sizeof(int));
     cp += sizeof(int);
     memcpy(cp, &logPrio, sizeof(int));
     cp += sizeof(int);
     memcpy(cp, &pid, sizeof(int));
     cp += sizeof(int);
     memcpy(cp, tag, tagLen);
     cp += tagLen;
     memcpy(cp, message, messageLen);
     cp += messageLen;

     assert(cp - outBuf == totalLen);

     Message msg;
     msg.mType = kTypeLogBundle;
     msg.mData = outBuf;
     msg.mLength = totalLen;
     Message_write(&msg, gWrapSim.simulatorFd);

     msg.mData = NULL;       // don't free
     Message_release(&msg);
 }

 /*
  * Turn the vibrating notification device on or off.
  */
 void wsEnableVibration(int vibrateOn)
 {
     if (gWrapSim.simulatorFd < 0) {
         wsLog("Not posting vibrator update -- sim not ready\n");
         return;
     }

     Message msg;

     //wsLog("+++ sending vibrate:%d\n", vibrateOn);

     setCommand(&msg, kCommandVibrate, vibrateOn);
     Message_write(&msg, gWrapSim.simulatorFd);
     Message_release(&msg);
 }
	/*
	* Copyright 2007 The Android Open Source Project
	*
	* Simulator interactions.
	*
	* TODO: for multi-process we probably need to switch to a new process
	* group if we are the first process (could be runtime, could be gdb),
	* rather than wait for the simulator to tell us to switch.
	*/
	#include "Common.h"

	#include <stdlib.h>
	#include <stdio.h>
	#include <stdint.h>
	#include <sys/types.h>
	#include <sys/socket.h>
	#include <sys/ipc.h>
	#include <sys/shm.h>
	#include <sys/sem.h>
	#include <sys/un.h>
	#include <signal.h>
	#include <assert.h>

	// fwd
	static int connectToSim(void);
	static void listenToSim(void);

	/*
	* Env var to restrict who tries to talk to the front end.
	*/
	#define kWrapSimConnectedEnv "WRAP_SIM_CONNECTED"


	/*
	* Signal the main thread that we're ready to continue.
	*/
	static void signalMainThread(void)
	{
	int cc;

	cc = pthread_mutex_lock(&gWrapSim.startLock);
	assert(cc == 0);

	gWrapSim.startReady = 1;

	cc = pthread_cond_signal(&gWrapSim.startCond);
	assert(cc == 0);

	cc = pthread_mutex_unlock(&gWrapSim.startLock);
	assert(cc == 0);
	}


	/*
	* Entry point for the sim management thread.
	*
	* Once we have established a connection to the simulator and are ready
	* for other threads to send messages, we signal the main thread.
	*/
	static void* simThreadEntry(void* arg)
	{
	wsLog("--- sim manager thread started\n");

	/*
	* Establish a connection to the simulator front-end. If we can't do
	* that, we have no access to input or output devices, and we might
	* as well give up.
	*/
	if (connectToSim() != 0) {
	signalMainThread();
	return NULL;
	}

	/* success! */
	wsLog("--- sim manager thread ready\n");
	gWrapSim.simulatorInitFailed = 0;
	signalMainThread();

	listenToSim();

	wsLog("--- sim manager thread exiting\n");

	return NULL;
	}

	/*
	* If we think we're not yet connected to the sim, do so now. We only
	* want to do this once per process group, so we control access with
	* an environment variable.
	*/
	int wsSimConnect(void)
	{
	/*
	* If the environment variable hasn't been set, assume we're the first
	* to get here, and should attach to the simulator. We set the env
	* var here whether or not we succeed in connecting to the sim.
	*
	* (For correctness we should wrap the getenv/setenv in a semaphore.)
	*/
	if (getenv(kWrapSimConnectedEnv) == NULL) {
	pthread_attr_t threadAttr;
	pthread_t threadHandle;
	int cc;

	gWrapSim.simulatorInitFailed = 1;
	setenv(kWrapSimConnectedEnv, "1", 1);

	cc = pthread_mutex_lock(&gWrapSim.startLock);
	assert(cc == 0);

	pthread_attr_init(&threadAttr);
	pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED);
	cc = pthread_create(&threadHandle, &threadAttr, simThreadEntry, NULL);
	if (cc != 0) {
	wsLog("Unable to create new thread: %s\n", strerror(errno));
	abort();
	}

	while (!gWrapSim.startReady) {
	cc = pthread_cond_wait(&gWrapSim.startCond, &gWrapSim.startLock);
	assert(cc == 0);
	}

	cc = pthread_mutex_unlock(&gWrapSim.startLock);
	assert(cc == 0);

	if (gWrapSim.simulatorInitFailed) {
	wsLog("Simulator initialization failed, bailing\n");

	/* this should be okay to do */
	fprintf(stderr, "Fatal error:"
	" unable to connect to sim front-end (not running?)\n");
	abort();
	}
	}

	wsLog("+++ continuing\n");
	return 0;
	}


	/*
	* ===========================================================================
	* Message / MessageStream
	* ===========================================================================
	*/

	/*
	* This is a quick & dirty rewrite of the C++ Message and MessageStream
	* classes, ported to C, reduced in generality, with syscalls stubbed
	* where necessary. I didn't fix the API to make it more sensible in C
	* (which lacks destructors), so some of this is a little fragile or
	* awkward.
	*/

	/* values for message type byte; must match android::Message constants */
	typedef enum MessageType {
	kTypeUnknown = 0,
	kTypeRaw, // chunk of raw data
	kTypeConfig, // send a name=value pair to peer
	kTypeCommand, // simple command w/arg
	kTypeCommandExt, // slightly more complicated command
	kTypeLogBundle, // multi-part log message
	} MessageType;

	/*
	* Reusable message object.
	*/
	typedef struct Message {
	MessageType mType;
	unsigned char* mData;
	int mLength;
	} Message;

	/* magic init messages; must match android::MessageStream constants */
	enum {
	kHelloMsg = 0x4e303047, // 'N00G'
	kHelloAckMsg = 0x31455221, // '1ER!'
	};


	/*
	* Clear out a Message.
	*/
	static void Message_clear(Message* msg)
	{
	memset(msg, 0, sizeof(Message));
	}

	/*
	* Keep reading until we get all bytes or hit EOF/error. "fd" is expected
	* to be in blocking mode.
	*
	* Returns 0 on success.
	*/
	static int readAll(int fd, void* buf, size_t count)
	{
	ssize_t actual;
	ssize_t have;

	have = 0;
	while (have != (ssize_t) count) {
	actual = _ws_read(fd, ((char*) buf) + have, count - have);
	if (actual < 0) {
	if (errno == EINTR)
	continue;
	wsLog("read %d failed: %s\n", fd, strerror(errno));
	} else if (actual == 0) {
	wsLog("early EOF on %d\n", fd);
	return -1;
	} else {
	have += actual;
	}

	assert(have <= (ssize_t)count);
	}

	return 0;
	}

	#if 0
	/*
	* Keep writing until we put all bytes or hit an error. "fd" is expected
	* to be in blocking mode.
	*
	* Returns 0 on success.
	*/
	static int writeAll(int fd, const void* buf, size_t count)
	{
	ssize_t actual;
	ssize_t have;

	have = 0;
	while (have != count) {
	actual = _ws_write(fd, ((const char*) buf) + have, count - have);
	if (actual < 0) {
	if (errno == EINTR)
	continue;
	wsLog("write %d failed: %s\n", fd, strerror(errno));
	} else if (actual == 0) {
	wsLog("wrote zero on %d\n", fd);
	return -1;
	} else {
	have += actual;
	}

	assert(have <= count);
	}

	return 0;
	}
	#endif

	/*
	* Read a message from the specified file descriptor.
	*
	* The caller must Message_release(&msg).
	*
	* We guarantee 32-bit alignment for msg->mData.
	*/
	static int Message_read(Message* msg, int fd)
	{
	unsigned char header[4];

	readAll(fd, header, 4);

	msg->mType = (MessageType) header[2];
	msg->mLength = header[0] \| header[1] << 8;
	msg->mLength -= 2; // we already read two of them in the header

	if (msg->mLength > 0) {
	int actual;

	/* Linux malloc guarantees at least 32-bit alignment */
	msg->mData = (unsigned char*) malloc(msg->mLength);
	if (msg->mData == NULL) {
	wsLog("alloc %d failed\n", msg->mLength);
	return -1;
	}

	if (readAll(fd, msg->mData, msg->mLength) != 0) {
	wsLog("failed reading message body (wanted %d)\n", msg->mLength);
	return -1;
	}
	} else {
	msg->mData = NULL;
	}

	return 0;
	}

	/*
	* Write a message to the specified file descriptor.
	*
	* The caller must Message_release(&msg).
	*/
	static int Message_write(Message* msg, int fd)
	{
	struct iovec writeVec[2];
	unsigned char header[4];
	int len, numVecs;
	ssize_t actual;

	len = msg->mLength + 2;
	header[0] = len & 0xff;
	header[1] = (len >> 8) & 0xff;
	header[2] = msg->mType;
	header[3] = 0;
	writeVec[0].iov_base = header;
	writeVec[0].iov_len = 4;
	numVecs = 1;

	if (msg->mLength > 0) {
	assert(msg->mData != NULL);
	writeVec[1].iov_base = msg->mData;
	writeVec[1].iov_len = msg->mLength;
	numVecs++;
	}

	/* write it all in one shot; not worrying about partial writes for now */
	actual = _ws_writev(fd, writeVec, numVecs);
	if (actual != len+2) {
	wsLog("failed writing message to fd %d: %d of %d %s\n",
	fd, actual, len+2, strerror(errno));
	return -1;
	}

	return 0;
	}

	/*
	* Release storage associated with a Message.
	*/
	static void Message_release(Message* msg)
	{
	free(msg->mData);
	msg->mData = NULL;
	}

	/*
	* Extract a name/value pair from a message.
	*/
	static int getConfig(const Message* msg, const char name, const char val)
	{
	if (msg->mLength < 2) {
	wsLog("message len (%d) is too short\n", msg->mLength);
	return -1;
	}
	const char* ptr = (const char*) msg->mData;

	name = (const char) ptr;
	val = (const char) (ptr + strlen((char*)ptr) +1);
	return 0;
	}

	/*
	* Extract a command from a message.
	*/
	static int getCommand(const Message* msg, int* pCmd, int* pArg)
	{
	if (msg->mLength != sizeof(int) * 2) {
	wsLog("message len (%d) is wrong for cmd (%d)\n",
	msg->mLength, sizeof(int) * 2);
	return -1;
	}

	/* this assumes 32-bit alignment on mData */
	const int* ptr = (const int*) msg->mData;

	*pCmd = ptr[0];
	*pArg = ptr[1];

	return 0;
	}

	/*
	* Extract an extended command from a message.
	*/
	static int getCommandExt(const Message* msg, int* pCmd, int* pArg0,
	int* pArg1, int* pArg2)
	{
	if (msg->mLength != sizeof(int) * 4) {
	wsLog("message len (%d) is wrong for cmd (%d)\n",
	msg->mLength, sizeof(int) * 4);
	return -1;
	}

	/* this assumes 32-bit alignment on mData */
	const int* ptr = (const int*) msg->mData;

	*pCmd = ptr[0];
	*pArg0 = ptr[1];
	*pArg1 = ptr[2];
	*pArg2 = ptr[3];

	return 0;
	}

	/*
	* Attach 8 bytes of data with "cmd" and "arg" to "msg".
	*
	* "msg->mData" will need to be freed by the caller. (This approach made
	* more sense when C++ destructors were available, but it's just not worth
	* reworking it.)
	*/
	static int setCommand(Message* msg, int cmd, int arg)
	{
	Message_clear(msg);

	msg->mLength = 8;
	msg->mData = malloc(msg->mLength);
	msg->mType = kTypeCommand;

	/* assumes 32-bit alignment on malloc blocks */
	int* pInt = (int*) msg->mData;
	pInt[0] = cmd;
	pInt[1] = arg;

	return 0;
	}

	/*
	* Construct the full path. The caller must free() the return value.
	*/
	static char* makeFilename(const char* name)
	{
	static const char* kBasePath = "/tmp/android-";
	char* fileName;

	assert(name != NULL && name[0] != '\0');

	fileName = (char*) malloc(strlen(kBasePath) + strlen(name) + 1);
	strcpy(fileName, kBasePath);
	strcat(fileName, name);

	return fileName;
	}

	/*
	* Attach to a SysV shared memory segment.
	*/
	static int attachToShmem(int key, int* pShmid, void** pAddr, long* pLength)
	{
	int shmid;

	shmid = shmget(key, 0, 0);
	if (shmid == -1) {
	wsLog("ERROR: failed to find shmem key=%d\n", key);
	return -1;
	}

	void* addr = shmat(shmid, NULL, 0);
	if (addr == (void*) -1) {
	wsLog("ERROR: could not attach to key=%d shmid=%d\n", key, shmid);
	return -1;
	}

	struct shmid_ds shmids;
	int cc;

	cc = shmctl(shmid, IPC_STAT, &shmids);
	if (cc != 0) {
	wsLog("ERROR: could not IPC_STAT shmid=%d\n", shmid);
	return -1;
	}
	*pLength = shmids.shm_segsz;

	*pAddr = addr;
	*pShmid = shmid;
	return 0;
	}

	/*
	* Attach to a SysV semaphore.
	*/
	static int attachToSem(int key, int* pSemid)
	{
	int semid;

	semid = semget(key, 0, 0);
	if (semid == -1) {
	wsLog("ERROR: failed to attach to semaphore key=%d\n", key);
	return -1;
	}

	*pSemid = semid;
	return 0;
	}

	/*
	* "Adjust" a semaphore.
	*/
	static int adjustSem(int semid, int adj)
	{
	const int wait = 1;
	struct sembuf op;
	int cc;

	op.sem_num = 0;
	op.sem_op = adj;
	op.sem_flg = SEM_UNDO;
	if (!wait)
	op.sem_flg \|= IPC_NOWAIT;

	cc = semop(semid, &op, 1);
	if (cc != 0) {
	if (wait \|\| errno != EAGAIN) {
	wsLog("Warning:"
	" semaphore adjust by %d failed for semid=%d (errno=%d)\n",
	adj, semid, errno);
	}
	return -1;
	}

	return 0;
	}

	/*
	* Acquire the semaphore associated with a display.
	*/
	void wsLockDisplay(int displayIdx)
	{
	assert(displayIdx >= 0 && displayIdx < gWrapSim.numDisplays);
	int semid = gWrapSim.display[displayIdx].semid;

	(void) adjustSem(semid, -1);
	}

	/*
	* Acquire the semaphore associated with a display.
	*/
	void wsUnlockDisplay(int displayIdx)
	{
	assert(displayIdx >= 0 && displayIdx < gWrapSim.numDisplays);
	int semid = gWrapSim.display[displayIdx].semid;

	(void) adjustSem(semid, 1);
	}

	/*
	* Process the display config from the simulator
	*
	* Right now this is a blob of raw data that looks like this:
	* +00 magic number
	* +04 #of displays
	* +08 display 0:
	* +00 width
	* +04 height
	* +08 format
	* +0c refresh rate
	* +10 shmem key
	* +1c display 1...
	*/
	static int handleDisplayConfig(const int* pData, int length)
	{
	int numDisplays;

	if (length < 8) {
	wsLog("Bad display config: length is %d\n", length);
	return -1;
	}
	assert(*pData == kDisplayConfigMagic);

	/*
	* Pull out the #of displays. If it looks valid, configure the runtime.
	*/
	pData++; // skip over magic
	numDisplays = *pData++;

	if (numDisplays <= 0 \|\| numDisplays > kMaxDisplays) {
	wsLog("Bizarre display count %d\n", numDisplays);
	return -1;
	}
	if (length != 8 + numDisplays * kValuesPerDisplay * (int)sizeof(int)) {
	wsLog("Bad display config: length is %d (expected %d)\n",
	length, 8 + numDisplays * kValuesPerDisplay * (int)sizeof(int));
	return -1;
	}

	/*
	* Extract the config values.
	*
	* The runtime doesn't support multiple devices, so we don't either.
	*/
	int i;
	for (i = 0; i < numDisplays; i++) {
	gWrapSim.display[i].width = pData[0];
	gWrapSim.display[i].height = pData[1];
	gWrapSim.display[i].shmemKey = pData[4];
	/* format/refresh no longer needed */

	void* addr;
	int shmid, semid;
	long length;
	if (attachToShmem(gWrapSim.display[i].shmemKey, &shmid, &addr,
	&length) != 0)
	{
	wsLog("Unable to connect to shared memory\n");
	return -1;
	}

	if (attachToSem(gWrapSim.display[i].shmemKey, &semid) != 0) {
	wsLog("Unable to attach to sempahore\n");
	return -1;
	}

	gWrapSim.display[i].shmid = shmid;
	gWrapSim.display[i].addr = addr;
	gWrapSim.display[i].length = length;
	gWrapSim.display[i].semid = semid;

	wsLog("Display %d: width=%d height=%d\n",
	i,
	gWrapSim.display[i].width,
	gWrapSim.display[i].height);
	wsLog(" shmem=0x%08x addr=%p len=%ld semid=%d\n",
	gWrapSim.display[i].shmemKey,
	gWrapSim.display[i].addr,
	gWrapSim.display[i].length,
	gWrapSim.display[i].semid);

	pData += kValuesPerDisplay;
	}
	gWrapSim.numDisplays = numDisplays;

	return 0;
	}


	/*
	* Initialize our connection to the simulator, which will be listening on
	* a UNIX domain socket.
	*
	* On success, this configures gWrapSim.simulatorFd and returns 0.
	*/
	static int openSimConnection(const char* name)
	{
	int result = -1;
	char* fileName = NULL;
	int sock = -1;
	int cc;

	assert(gWrapSim.simulatorFd == -1);

	fileName = makeFilename(name);

	struct sockaddr_un addr;

	sock = socket(AF_UNIX, SOCK_STREAM, 0);
	if (sock < 0) {
	wsLog("UNIX domain socket create failed (errno=%d)\n", errno);
	goto bail;
	}

	/* connect to socket; fails if file doesn't exist */
	strcpy(addr.sun_path, fileName); // max 108 bytes
	addr.sun_family = AF_UNIX;
	cc = connect(sock, (struct sockaddr*) &addr, SUN_LEN(&addr));
	if (cc < 0) {
	// ENOENT means socket file doesn't exist
	// ECONNREFUSED means socket exists but nobody is listening
	wsLog("AF_UNIX connect failed for '%s': %s\n",
	fileName, strerror(errno));
	goto bail;
	}

	gWrapSim.simulatorFd = sock;
	sock = -1;

	result = 0;
	wsLog("+++ connected to '%s'\n", fileName);

	bail:
	if (sock >= 0)
	_ws_close(sock);
	free(fileName);
	return result;
	}

	/*
	* Prepare communication with the front end. We wait for a "hello" from
	* the other side, and respond in kind.
	*/
	static int prepSimConnection(void)
	{
	/* NOTE: this is endian-specific; we're x86 Linux only, so no problem */
	static const unsigned int hello = kHelloMsg;
	static const unsigned int helloAck = kHelloAckMsg;
	Message msg;

	if (Message_read(&msg, gWrapSim.simulatorFd) != 0) {
	wsLog("hello read failed\n");
	return -1;
	}

	if (memcmp(msg.mData, &hello, 4) != 0) {
	wsLog("Got bad hello from peer\n");
	return -1;
	}

	Message_release(&msg);

	msg.mType = kTypeRaw;
	msg.mData = (unsigned char*) &helloAck;
	msg.mLength = 4;

	if (Message_write(&msg, gWrapSim.simulatorFd) != 0) {
	wsLog("hello ack write failed\n");
	return -1;
	}

	return 0;
	}

	/*
	* Get the sim front-end configuration. We loop here until the sim claims
	* to be done with us.
	*/
	static int getSimConfig(void)
	{
	Message msg;
	int joinNewGroup, grabTerminal, done;
	int result = -1;

	joinNewGroup = grabTerminal = done = 0;
	Message_clear(&msg); // clear out msg->mData

	wsLog("+++ awaiting hardware configuration\n");
	while (!done) {
	if (Message_read(&msg, gWrapSim.simulatorFd) != 0) {
	wsLog("failed receiving config from parent\n");
	goto bail;
	}

	if (msg.mType == kTypeCommand) {
	int cmd, arg;

	if (getCommand(&msg, &cmd, &arg) != 0)
	goto bail;

	switch (cmd) {
	case kCommandGoAway:
	wsLog("Simulator front-end is busy\n");
	goto bail;
	case kCommandNewPGroup:
	joinNewGroup = 1;
	grabTerminal = (arg != 0);
	wsLog("Simulator wants us to be in a new pgrp (term=%d)\n",
	grabTerminal);
	break;
	case kCommandConfigDone:
	done = 1;
	break;
	default:
	wsLog("Got unexpected command %d/%d\n", cmd, arg);
	break;
	}
	} else if (msg.mType == kTypeRaw) {
	/* assumes 32-bit alignment and identical byte ordering */
	int* pData = (int*) msg.mData;
	if (msg.mLength >= 4 && *pData == kDisplayConfigMagic) {
	if (handleDisplayConfig(pData, msg.mLength) != 0)
	goto bail;
	}
	} else if (msg.mType == kTypeConfig) {
	const char *name;
	const char *val;
	getConfig(&msg, &name, &val);
	if(strcmp(name, "keycharmap") == 0) {
	free((void*)gWrapSim.keyMap);
	gWrapSim.keyMap = strdup(val);
	}
	} else {
	wsLog("Unexpected msg type %d during startup\n", msg.mType);
	goto bail;
	}

	/* clear out the data field if necessary */
	Message_release(&msg);
	}

	wsLog("Configuration received from simulator\n");

	if (joinNewGroup) {
	/* set pgid to pid */
	pid_t pgid = getpid();
	setpgid(0, pgid);

	/*
	* Put our pgrp in the foreground.
	* tcsetpgrp() from background process causes us to get a SIGTTOU,
	* which is mostly harmless but makes tcsetpgrp() fail with EINTR.
	*/
	signal(SIGTTOU, SIG_IGN);
	if (grabTerminal) {
	if (tcsetpgrp(fileno(stdin), getpgrp()) != 0) {
	wsLog("tcsetpgrp(%d, %d) failed (errno=%d)\n",
	fileno(stdin), getpgrp(), errno);
	}
	wsLog("Set pgrp %d as foreground\n", (int) getpgrp());
	}

	/* tell the sim where we're at */
	Message msg;
	setCommand(&msg, kCommandNewPGroupCreated, pgid);
	Message_write(&msg, gWrapSim.simulatorFd);
	Message_release(&msg);
	}

	result = 0;

	bail:
	/* make sure the data was freed */
	Message_release(&msg);
	//wsLog("bailing, result=%d\n", result);
	return result;
	}

	/*
	* Connect to the simulator and exchange pleasantries.
	*
	* Returns 0 on success.
	*/
	static int connectToSim(void)
	{
	if (openSimConnection(kAndroidPipeName) != 0)
	return -1;

	if (prepSimConnection() != 0)
	return -1;

	if (getSimConfig() != 0)
	return -1;

	wsLog("+++ sim is ready to go\n");

	return 0;
	}

	/*
	* Listen to the sim forever or until the front end shuts down, whichever
	* comes first.
	*
	* All we're really getting here are key events.
	*/
	static void listenToSim(void)
	{
	wsLog("--- listening for input events from front end\n");

	while (1) {
	Message msg;

	Message_clear(&msg);
	if (Message_read(&msg, gWrapSim.simulatorFd) != 0) {
	wsLog("--- sim message read failed\n");
	return;
	}

	if (msg.mType == kTypeCommand) {
	int cmd, arg;

	if (getCommand(&msg, &cmd, &arg) != 0) {
	wsLog("bad command from sim?\n");
	continue;
	}

	switch (cmd) {
	case kCommandQuit:
	wsLog("--- sim sent us a QUIT message\n");
	return;
	case kCommandKeyDown:
	wsLog("KEY DOWN: %d\n", arg);
	wsSendSimKeyEvent(arg, 1);
	break;
	case kCommandKeyUp:
	wsLog("KEY UP: %d\n", arg);
	wsSendSimKeyEvent(arg, 0);
	break;
	default:
	wsLog("--- sim sent unrecognized command %d\n", cmd);
	break;
	}

	Message_release(&msg);
	} else if (msg.mType == kTypeCommandExt) {
	int cmd, arg0, arg1, arg2;

	if (getCommandExt(&msg, &cmd, &arg0, &arg1, &arg2) != 0) {
	wsLog("bad ext-command from sim?\n");
	continue;
	}

	switch (cmd) {
	case kCommandTouch:
	wsSendSimTouchEvent(arg0, arg1, arg2);
	break;
	}

	Message_release(&msg);
	} else {
	wsLog("--- sim sent non-command message, type=%d\n", msg.mType);
	}
	}

	assert(0); // not reached
	}


	/*
	* Tell the simulator front-end that the display has been updated.
	*/
	void wsPostDisplayUpdate(int displayIdx)
	{
	if (gWrapSim.simulatorFd < 0) {
	wsLog("Not posting display update -- sim not ready\n");
	return;
	}

	Message msg;

	setCommand(&msg, kCommandUpdateDisplay, displayIdx);
	Message_write(&msg, gWrapSim.simulatorFd);
	Message_release(&msg);
	}

	/*
	* Send a log message to the front-end.
	*/
	void wsPostLogMessage(int logPrio, const char* tag, const char* message)
	{
	if (gWrapSim.simulatorFd < 0) {
	wsLog("Not posting log message -- sim not ready\n");
	return;
	}

	time_t when = time(NULL);
	int pid = (int) getpid();
	int tagLen, messageLen, totalLen;

	tagLen = strlen(tag) +1;
	messageLen = strlen(message) +1;
	totalLen = sizeof(int) * 3 + tagLen + messageLen;
	unsigned char outBuf[totalLen];
	unsigned char* cp = outBuf;

	/* See Message::set/getLogBundle() in simulator/MessageStream.cpp. */
	memcpy(cp, &when, sizeof(int));
	cp += sizeof(int);
	memcpy(cp, &logPrio, sizeof(int));
	cp += sizeof(int);
	memcpy(cp, &pid, sizeof(int));
	cp += sizeof(int);
	memcpy(cp, tag, tagLen);
	cp += tagLen;
	memcpy(cp, message, messageLen);
	cp += messageLen;

	assert(cp - outBuf == totalLen);

	Message msg;
	msg.mType = kTypeLogBundle;
	msg.mData = outBuf;
	msg.mLength = totalLen;
	Message_write(&msg, gWrapSim.simulatorFd);

	msg.mData = NULL; // don't free
	Message_release(&msg);
	}

	/*
	* Turn the vibrating notification device on or off.
	*/
	void wsEnableVibration(int vibrateOn)
	{
	if (gWrapSim.simulatorFd < 0) {
	wsLog("Not posting vibrator update -- sim not ready\n");
	return;
	}

	Message msg;

	//wsLog("+++ sending vibrate:%d\n", vibrateOn);

	setCommand(&msg, kCommandVibrate, vibrateOn);
	Message_write(&msg, gWrapSim.simulatorFd);
	Message_release(&msg);
	}