source: vbox/trunk/src/VBox/HostServices/SharedClipboard/x11-clipboard.cpp@ 58192

/** @file
 *
 * Shared Clipboard:
 * Linux host.
 */

/*
 * Copyright (C) 2006-2011 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD

#include <string.h>

#include <iprt/assert.h>
#include <iprt/critsect.h>
#include <iprt/env.h>
#include <iprt/mem.h>
#include <iprt/semaphore.h>

#include <VBox/GuestHost/SharedClipboard.h>
#include <VBox/HostServices/VBoxClipboardSvc.h>

#include "VBoxClipboard.h"

struct _VBOXCLIPBOARDREQFROMVBOX;
typedef struct _VBOXCLIPBOARDREQFROMVBOX VBOXCLIPBOARDREQFROMVBOX;

/** Global context information used by the host glue for the X11 clipboard
 * backend */
struct _VBOXCLIPBOARDCONTEXT
{
    /** This mutex is grabbed during any critical operations on the clipboard
     * which might clash with others. */
    RTCRITSECT clipboardMutex;
    /** The currently pending request for data from VBox.  NULL if there is
     * no request pending.  The protocol for completing a request is to grab
     * the critical section, check that @a pReq is not NULL, fill in the data
     * fields and set @a pReq to NULL.  The protocol for cancelling a pending
     * request is to grab the critical section and set pReq to NULL.
     * It is an error if a request arrives while another one is pending, and
     * the backend is responsible for ensuring that this does not happen. */
    VBOXCLIPBOARDREQFROMVBOX *pReq;

    /** Pointer to the opaque X11 backend structure */
    CLIPBACKEND *pBackend;
    /** Pointer to the VBox host client data structure. */
    VBOXCLIPBOARDCLIENTDATA *pClient;
    /** We set this when we start shutting down as a hint not to post any new
     * requests. */
    bool fShuttingDown;
};

/**
 * Report formats available in the X11 clipboard to VBox.
 * @param  pCtx        Opaque context pointer for the glue code
 * @param  u32Formats  The formats available
 * @note  Host glue code
 */
void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx,
                                      uint32_t u32Formats)
{
    LogRelFlowFunc(("called.  pCtx=%p, u32Formats=%02X\n", pCtx, u32Formats));
    vboxSvcClipboardReportMsg(pCtx->pClient,
                              VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS,
                              u32Formats);
}

/**
 * Initialise the host side of the shared clipboard.
 * @note  Host glue code
 */
int vboxClipboardInit (void)
{
    return VINF_SUCCESS;
}

/**
 * Terminate the host side of the shared clipboard.
 * @note  host glue code
 */
void vboxClipboardDestroy (void)
{

}

/**
 * Connect a guest to the shared clipboard.
 * @note  host glue code
 * @note  on the host, we assume that some other application already owns
 *        the clipboard and leave ownership to X11.
 */
int vboxClipboardConnect (VBOXCLIPBOARDCLIENTDATA *pClient, bool fHeadless)
{
    int rc = VINF_SUCCESS;
    CLIPBACKEND *pBackend = NULL;

    LogRel(("Starting host clipboard service\n"));
    VBOXCLIPBOARDCONTEXT *pCtx =
        (VBOXCLIPBOARDCONTEXT *) RTMemAllocZ(sizeof(VBOXCLIPBOARDCONTEXT));
    if (!pCtx)
        rc = VERR_NO_MEMORY;
    else
    {
        RTCritSectInit(&pCtx->clipboardMutex);
        pBackend = ClipConstructX11(pCtx, fHeadless);
        if (pBackend == NULL)
            rc = VERR_NO_MEMORY;
        else
        {
            pCtx->pBackend = pBackend;
            pClient->pCtx = pCtx;
            pCtx->pClient = pClient;
            rc = ClipStartX11(pBackend, true /* grab shared clipboard */);
        }
        if (RT_FAILURE(rc))
            RTCritSectDelete(&pCtx->clipboardMutex);
    }
    if (RT_FAILURE(rc))
    {
        RTMemFree(pCtx);
        LogRel(("Failed to initialise the shared clipboard\n"));
    }
    LogRelFlowFunc(("returning %Rrc\n", rc));
    return rc;
}

/**
 * Synchronise the contents of the host clipboard with the guest, called
 * after a save and restore of the guest.
 * @note  Host glue code
 */
int vboxClipboardSync (VBOXCLIPBOARDCLIENTDATA *pClient)
{
    /* Tell the guest we have no data in case X11 is not available.  If
     * there is data in the host clipboard it will automatically be sent to
     * the guest when the clipboard starts up. */
    vboxSvcClipboardReportMsg (pClient,
                               VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS, 0);
    return VINF_SUCCESS;
}

/**
 * Shut down the shared clipboard service and "disconnect" the guest.
 * @note  Host glue code
 */
void vboxClipboardDisconnect (VBOXCLIPBOARDCLIENTDATA *pClient)
{
    LogRelFlow(("vboxClipboardDisconnect\n"));

    LogRel(("Stopping the host clipboard service\n"));
    VBOXCLIPBOARDCONTEXT *pCtx = pClient->pCtx;
    /* Drop the reference to the client, in case it is still there.  This
     * will cause any outstanding clipboard data requests from X11 to fail
     * immediately. */
    pCtx->fShuttingDown = true;
    /* If there is a currently pending request, release it immediately. */
    vboxClipboardWriteData(pClient, NULL, 0, 0);
    int rc = ClipStopX11(pCtx->pBackend);
    /** @todo handle this slightly more reasonably, or be really sure
     *        it won't go wrong. */
    AssertRC(rc);
    if (RT_SUCCESS(rc))  /* And if not? */
    {
        ClipDestructX11(pCtx->pBackend);
        RTCritSectDelete(&pCtx->clipboardMutex);
        RTMemFree(pCtx);
    }
}

/**
 * VBox is taking possession of the shared clipboard.
 *
 * @param pClient    Context data for the guest system
 * @param u32Formats Clipboard formats the guest is offering
 * @note  Host glue code
 */
void vboxClipboardFormatAnnounce (VBOXCLIPBOARDCLIENTDATA *pClient,
                                  uint32_t u32Formats)
{
    LogRelFlowFunc(("called.  pClient=%p, u32Formats=%02X\n", pClient,
                 u32Formats));
    ClipAnnounceFormatToX11 (pClient->pCtx->pBackend, u32Formats);
}

/** Structure describing a request for clipoard data from the guest. */
struct _CLIPREADCBREQ
{
    /** Where to write the returned data to. */
    void *pv;
    /** The size of the buffer in pv */
    uint32_t cb;
    /** The actual size of the data written */
    uint32_t *pcbActual;
};

/**
 * Called when VBox wants to read the X11 clipboard.
 *
 * @returns VINF_SUCCESS on successful completion
 * @returns VINF_HGCM_ASYNC_EXECUTE if the operation will complete
 *          asynchronously
 * @returns iprt status code on failure
 * @param  pClient   Context information about the guest VM
 * @param  u32Format The format that the guest would like to receive the data in
 * @param  pv        Where to write the data to
 * @param  cb        The size of the buffer to write the data to
 * @param  pcbActual Where to write the actual size of the written data
 * @note   We always fail or complete asynchronously
 * @note   On success allocates a CLIPREADCBREQ structure which must be
 *         freed in ClipCompleteDataRequestFromX11 when it is called back from
 *         the backend code.
 *
 */
int vboxClipboardReadData (VBOXCLIPBOARDCLIENTDATA *pClient,
                           uint32_t u32Format, void *pv, uint32_t cb,
                           uint32_t *pcbActual)
{
    LogRelFlowFunc(("pClient=%p, u32Format=%02X, pv=%p, cb=%u, pcbActual=%p",
                 pClient, u32Format, pv, cb, pcbActual));

    int rc = VINF_SUCCESS;
    CLIPREADCBREQ *pReq = (CLIPREADCBREQ *) RTMemAlloc(sizeof(CLIPREADCBREQ));
    if (!pReq)
        rc = VERR_NO_MEMORY;
    else
    {
        pReq->pv = pv;
        pReq->cb = cb;
        pReq->pcbActual = pcbActual;
        rc = ClipRequestDataFromX11(pClient->pCtx->pBackend, u32Format, pReq);
        if (RT_SUCCESS(rc))
            rc = VINF_HGCM_ASYNC_EXECUTE;
    }
    LogRelFlowFunc(("returning %Rrc\n", rc));
    return rc;
}

/**
 * Complete a request from VBox for the X11 clipboard data.  The data should
 * be written to the buffer provided in the initial request.
 * @param  pCtx  request context information
 * @param  rc    the completion status of the request
 * @param  cbActual  on successful completion, the number of bytes of data
 *                   actually written, on buffer overflow the size of the
 *                   buffer needed, ignored otherwise
 * @todo   change this to deal with the buffer issues rather than offloading
 *         them onto the caller
 */
void ClipCompleteDataRequestFromX11(VBOXCLIPBOARDCONTEXT *pCtx, int rc,
                                    CLIPREADCBREQ *pReq, void *pv,
                                    uint32_t cb)
{
    if (cb <= pReq->cb)
        memcpy(pReq->pv, pv, cb);
    RTMemFree(pReq);
    vboxSvcClipboardCompleteReadData(pCtx->pClient, rc, cb);
}

/** A request for clipboard data from VBox */
struct _VBOXCLIPBOARDREQFROMVBOX
{
    /** Data received */
    void *pv;
    /** The size of the data */
    uint32_t cb;
    /** Format of the data */
    uint32_t format;
    /** A semaphore for waiting for the data */
    RTSEMEVENT finished;
};

/** Wait for clipboard data requested from VBox to arrive. */
static int clipWaitForDataFromVBox(VBOXCLIPBOARDCONTEXT *pCtx,
                                   VBOXCLIPBOARDREQFROMVBOX *pReq,
                                   uint32_t u32Format)
{
    int rc = VINF_SUCCESS;
    LogRelFlowFunc(("pCtx=%p, pReq=%p, u32Format=%02X\n", pCtx, pReq, u32Format));
    /* Request data from VBox */
    vboxSvcClipboardReportMsg(pCtx->pClient,
                              VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
                              u32Format);
    /* Which will signal us when it is ready.  We use a timeout here
     * because we can't be sure that the guest will behave correctly.
     */
    rc = RTSemEventWait(pReq->finished, CLIPBOARD_TIMEOUT);
    /* If the request hasn't yet completed then we cancel it.  We use
     * the critical section to prevent these operations colliding. */
    RTCritSectEnter(&pCtx->clipboardMutex);
    /* The data may have arrived between the semaphore timing out and
     * our grabbing the mutex. */
    if (rc == VERR_TIMEOUT && pReq->pv != NULL)
        rc = VINF_SUCCESS;
    if (pCtx->pReq == pReq)
        pCtx->pReq = NULL;
    Assert(pCtx->pReq == NULL);
    RTCritSectLeave(&pCtx->clipboardMutex);
    if (RT_SUCCESS(rc) && (pReq->pv == NULL))
        rc = VERR_NO_DATA;
    LogRelFlowFunc(("returning %Rrc\n", rc));
    return rc;
}

/** Post a request for clipboard data to VBox/the guest and wait for it to be
 * completed. */
static int clipRequestDataFromVBox(VBOXCLIPBOARDCONTEXT *pCtx,
                                          VBOXCLIPBOARDREQFROMVBOX *pReq,
                                          uint32_t u32Format)
{
    int rc = VINF_SUCCESS;
    LogRelFlowFunc(("pCtx=%p, pReq=%p, u32Format=%02X\n", pCtx, pReq,
                 u32Format));
    /* Start by "posting" the request for the next invocation of
     * vboxClipboardWriteData. */
    RTCritSectEnter(&pCtx->clipboardMutex);
    if (pCtx->pReq != NULL)
    {
        /* This would be a violation of the protocol, see the comments in the
         * context structure definition. */
        Assert(false);
        rc = VERR_WRONG_ORDER;
    }
    else
        pCtx->pReq = pReq;
    RTCritSectLeave(&pCtx->clipboardMutex);
    if (RT_SUCCESS(rc))
        rc = clipWaitForDataFromVBox(pCtx, pReq, u32Format);
    LogRelFlowFunc(("returning %Rrc\n", rc));
    return rc;
}

/**
 * Send a request to VBox to transfer the contents of its clipboard to X11.
 *
 * @param  pCtx      Pointer to the host clipboard structure
 * @param  u32Format The format in which the data should be transferred
 * @param  ppv       On success and if pcb > 0, this will point to a buffer
 *                   to be freed with RTMemFree containing the data read.
 * @param  pcb       On success, this contains the number of bytes of data
 *                   returned
 * @note   Host glue code.
 */
int ClipRequestDataForX11 (VBOXCLIPBOARDCONTEXT *pCtx,
                                   uint32_t u32Format, void **ppv,
                                   uint32_t *pcb)
{
    VBOXCLIPBOARDREQFROMVBOX request = { NULL, 0, 0, NIL_RTSEMEVENT };

    LogRelFlowFunc(("pCtx=%p, u32Format=%02X, ppv=%p, pcb=%p\n", pCtx,
                 u32Format, ppv, pcb));
    if (pCtx->fShuttingDown)
    {
        /* The shared clipboard is disconnecting. */
        LogRelFunc(("host requested guest clipboard data after guest had disconnected.\n"));
        return VERR_WRONG_ORDER;
    }
    int rc = RTSemEventCreate(&request.finished);
    if (RT_SUCCESS(rc))
    {
        rc = clipRequestDataFromVBox(pCtx, &request, u32Format);
        RTSemEventDestroy(request.finished);
    }
    if (RT_SUCCESS(rc))
    {
        *ppv = request.pv;
        *pcb = request.cb;
    }
    LogRelFlowFunc(("returning %Rrc\n", rc));
    if (RT_SUCCESS(rc))
        LogRelFlowFunc(("*ppv=%.*ls, *pcb=%u\n", *pcb / 2, *ppv, *pcb));
    return rc;
}

/**
 * Called when we have requested data from VBox and that data has arrived.
 *
 * @param  pClient   Context information about the guest VM
 * @param  pv        Buffer to which the data was written
 * @param  cb        The size of the data written
 * @param  u32Format The format of the data written
 * @note   Host glue code
 */
void vboxClipboardWriteData (VBOXCLIPBOARDCLIENTDATA *pClient,
                             void *pv, uint32_t cb, uint32_t u32Format)
{
    LogRelFlowFunc (("called.  pClient=%p, pv=%p (%.*ls), cb=%u, u32Format=%02X\n",
                  pClient, pv, cb / 2, pv, cb, u32Format));

    VBOXCLIPBOARDCONTEXT *pCtx = pClient->pCtx;
    /* Grab the mutex and check whether there is a pending request for data.
     */
    RTCritSectEnter(&pCtx->clipboardMutex);
    VBOXCLIPBOARDREQFROMVBOX *pReq = pCtx->pReq;
    if (pReq != NULL)
    {
        if (cb > 0)
        {
            pReq->pv = RTMemDup(pv, cb);
            if (pReq->pv != NULL)  /* NULL may also mean no memory... */
            {
                pReq->cb = cb;
                pReq->format = u32Format;
            }
        }
        /* Signal that the request has been completed. */
        RTSemEventSignal(pReq->finished);
        pCtx->pReq = NULL;
    }
    RTCritSectLeave(&pCtx->clipboardMutex);
}

#ifdef TESTCASE
#include <iprt/initterm.h>
#include <iprt/stream.h>

#define TEST_NAME "tstClipboardX11-2"

struct _CLIPBACKEND
{
    uint32_t formats;
    struct _READDATA
    {
        uint32_t format;
        int rc;
        CLIPREADCBREQ *pReq;
    } readData;
    struct _COMPLETEREAD
    {
        int rc;
        uint32_t cbActual;
    } completeRead;
    struct _WRITEDATA
    {
        void *pv;
        uint32_t cb;
        uint32_t format;
        bool timeout;
    } writeData;
    struct _REPORTDATA
    {
        uint32_t format;
    } reportData;
};

void vboxSvcClipboardReportMsg (VBOXCLIPBOARDCLIENTDATA *pClient, uint32_t u32Msg, uint32_t u32Formats)
{
    CLIPBACKEND *pBackend = pClient->pCtx->pBackend;
    if (   (u32Msg == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA)
        && !pBackend->writeData.timeout)
        vboxClipboardWriteData(pClient, pBackend->writeData.pv,
                               pBackend->writeData.cb,
                               pBackend->writeData.format);
    else
        return;
}

void vboxSvcClipboardCompleteReadData(VBOXCLIPBOARDCLIENTDATA *pClient, int rc, uint32_t cbActual)
{
    CLIPBACKEND *pBackend = pClient->pCtx->pBackend;
    pBackend->completeRead.rc = rc;
    pBackend->completeRead.cbActual = cbActual;
}

CLIPBACKEND *ClipConstructX11(VBOXCLIPBOARDCONTEXT *pFrontend, bool)
{
    return (CLIPBACKEND *)RTMemAllocZ(sizeof(CLIPBACKEND));
}

void ClipDestructX11(CLIPBACKEND *pBackend)
{
    RTMemFree(pBackend);
}

int ClipStartX11(CLIPBACKEND *pBackend, bool)
{
    return VINF_SUCCESS;
}

int ClipStopX11(CLIPBACKEND *pBackend)
{
    return VINF_SUCCESS;
}

void ClipAnnounceFormatToX11(CLIPBACKEND *pBackend,
                                    uint32_t u32Formats)
{
    pBackend->formats = u32Formats;
}

extern int ClipRequestDataFromX11(CLIPBACKEND *pBackend, uint32_t u32Format,
                                  CLIPREADCBREQ *pReq)
{
    pBackend->readData.format = u32Format;
    pBackend->readData.pReq = pReq;
    return pBackend->readData.rc;
}

int main()
{
    VBOXCLIPBOARDCLIENTDATA client;
    unsigned cErrors = 0;
    int rc = RTR3InitExeNoArguments(0);
    RTPrintf(TEST_NAME ": TESTING\n");
    AssertRCReturn(rc, 1);
    rc = vboxClipboardConnect(&client, false);
    CLIPBACKEND *pBackend = client.pCtx->pBackend;
    AssertRCReturn(rc, 1);
    vboxClipboardFormatAnnounce(&client,
                                VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
    if (pBackend->formats != VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
    {
        RTPrintf(TEST_NAME ": vboxClipboardFormatAnnounce failed with VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT\n");
        ++cErrors;
    }
    pBackend->readData.rc = VINF_SUCCESS;
    client.asyncRead.callHandle = (VBOXHGCMCALLHANDLE)pBackend;
    client.asyncRead.paParms = (VBOXHGCMSVCPARM *)&client;
    uint32_t u32Dummy;
    rc = vboxClipboardReadData(&client, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
                               &u32Dummy, 42, &u32Dummy);
    if (rc != VINF_HGCM_ASYNC_EXECUTE)
    {
        RTPrintf(TEST_NAME ": vboxClipboardReadData returned %Rrc\n", rc);
        ++cErrors;
    }
    else
    {
        if (   pBackend->readData.format !=
                       VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT
            || pBackend->readData.pReq->pv != &u32Dummy
            || pBackend->readData.pReq->cb != 42
            || pBackend->readData.pReq->pcbActual != &u32Dummy)
        {
            RTPrintf(TEST_NAME ": format=%u, pReq->pv=%p, pReq->cb=%u, pReq->pcbActual=%p\n",
                     pBackend->readData.format, pBackend->readData.pReq->pv,
                     pBackend->readData.pReq->cb,
                     pBackend->readData.pReq->pcbActual);
            ++cErrors;
        }
        else
        {
            ClipCompleteDataRequestFromX11(client.pCtx, VERR_NO_DATA,
                                           pBackend->readData.pReq, NULL, 43);
            if (   pBackend->completeRead.rc != VERR_NO_DATA
                || pBackend->completeRead.cbActual != 43)
            {
                RTPrintf(TEST_NAME ": rc=%Rrc, cbActual=%u\n",
                         pBackend->completeRead.rc,
                         pBackend->completeRead.cbActual);
                ++cErrors;
            }
        }
    }
    void *pv;
    uint32_t cb;
    pBackend->writeData.pv = (void *)"testing";
    pBackend->writeData.cb = sizeof("testing");
    pBackend->writeData.format = 1234;
    pBackend->reportData.format = 4321;  /* XX this should be handled! */
    rc = ClipRequestDataForX11(client.pCtx, 23, &pv, &cb);
    if (   rc != VINF_SUCCESS
        || strcmp((const char *)pv, "testing") != 0
        || cb != sizeof("testing"))
    {
        RTPrintf("rc=%Rrc, pv=%p, cb=%u\n", rc, pv, cb);
        ++cErrors;
    }
    else
        RTMemFree(pv);
    pBackend->writeData.timeout = true;
    rc = ClipRequestDataForX11(client.pCtx, 23, &pv, &cb);
    if (rc != VERR_TIMEOUT)
    {
        RTPrintf("rc=%Rrc, expected VERR_TIMEOUT\n", rc);
        ++cErrors;
    }
    pBackend->writeData.pv = NULL;
    pBackend->writeData.cb = 0;
    pBackend->writeData.timeout = false;
    rc = ClipRequestDataForX11(client.pCtx, 23, &pv, &cb);
    if (rc != VERR_NO_DATA)
    {
        RTPrintf("rc=%Rrc, expected VERR_NO_DATA\n", rc);
        ++cErrors;
    }
    /* Data arriving after a timeout should *not* cause any segfaults or
     * memory leaks.  Check with Valgrind! */
    vboxClipboardWriteData(&client, (void *)"tested", sizeof("tested"), 999);
    vboxClipboardDisconnect(&client);
    if (cErrors > 0)
        RTPrintf(TEST_NAME ": errors: %u\n", cErrors);
    return cErrors > 0 ? 1 : 0;
}
#endif  /* TESTCASE */