/*
 * 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 = NULL;
            const char* val = NULL;
            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);
}

