VirtualBox

Changeset 78683 in vbox


Ignore:
Timestamp:
May 23, 2019 10:07:21 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
130759
Message:

Shared Clipboard/URI: Update.

Location:
trunk
Files:
2 added
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/GuestHost/SharedClipboard-uri.h

    r78648 r78683  
    3838#include <iprt/cpp/ministring.h>
    3939
     40/** Clipboard area ID. A valid area is >= 1.
     41 *  If 0 is specified, the last (most recent) area is meant.
     42 *  Set to UINT32_MAX if not initialized. */
     43typedef uint32_t SHAREDCLIPBOARDAREAID;
     44
     45/** Defines a non-initialized (nil) clipboard area. */
     46#define NIL_SHAREDCLIPBOARDAREAID       UINT32_MAX
     47
    4048/** SharedClipboardCache flags. */
    4149typedef uint32_t SHAREDCLIPBOARDCACHEFLAGS;
    … …  
    5866
    5967    SharedClipboardCache(void);
    60     SharedClipboardCache(const char *pszPath, SHAREDCLIPBOARDCACHEFLAGS fFlags = SHAREDCLIPBOARDCACHE_FLAGS_NONE);
     68    SharedClipboardCache(const char *pszPath, SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
     69                         SHAREDCLIPBOARDCACHEFLAGS fFlags = SHAREDCLIPBOARDCACHE_FLAGS_NONE);
    6170    virtual ~SharedClipboardCache(void);
    6271
    … …  
    7382    int Close(void);
    7483    bool IsOpen(void) const;
    75     int OpenEx(const char *pszPath, SHAREDCLIPBOARDCACHEFLAGS fFlags = SHAREDCLIPBOARDCACHE_FLAGS_NONE);
    76     int OpenTemp(SHAREDCLIPBOARDCACHEFLAGS fFlags = SHAREDCLIPBOARDCACHE_FLAGS_NONE);
     84    int OpenEx(const char *pszPath, SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
     85               SHAREDCLIPBOARDCACHEFLAGS fFlags = SHAREDCLIPBOARDCACHE_FLAGS_NONE);
     86    int OpenTemp(SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
     87                 SHAREDCLIPBOARDCACHEFLAGS fFlags = SHAREDCLIPBOARDCACHE_FLAGS_NONE);
     88    SHAREDCLIPBOARDAREAID GetAreaID(void) const;
    7789    const char *GetDirAbs(void) const;
    7890    int Reopen(void);
    … …  
    8597    int destroyInternal(void);
    8698    int closeInternal(void);
     99    int pathConstruct(const char *pszBase, char *pszPath, size_t cbPath);
    87100
    88101protected:
    … …  
    102115    /** List for holding created files in the case of a rollback. */
    103116    RTCList<RTCString>           m_lstFiles;
     117    /** Associated clipboard area ID. */
     118    SHAREDCLIPBOARDAREAID        m_uID;
    104119};
    105120
    … …  
    350365size_t SharedClipboardMetaDataGetUsed(PSHAREDCLIPBOARDMETADATA pMeta);
    351366size_t SharedClipboardMetaDataGetSize(PSHAREDCLIPBOARDMETADATA pMeta);
     367void *SharedClipboardMetaDataMutableRaw(PSHAREDCLIPBOARDMETADATA pMeta);
    352368const void *SharedClipboardMetaDataRaw(PSHAREDCLIPBOARDMETADATA pMeta);
    353369

  • trunk/include/VBox/HostServices/VBoxClipboardExt.h

    r76585 r78683  
    3131
    3232#include <VBox/types.h>
     33#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     34# include <VBox/GuestHost/SharedClipboard-uri.h>
     35#endif
    3336
    34 #define VBOX_CLIPBOARD_EXT_FN_SET_CALLBACK    (0)
    35 #define VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE (1)
    36 #define VBOX_CLIPBOARD_EXT_FN_DATA_READ       (2)
    37 #define VBOX_CLIPBOARD_EXT_FN_DATA_WRITE      (3)
     37#define VBOX_CLIPBOARD_EXT_FN_SET_CALLBACK         (0)
     38#define VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE      (1)
     39#define VBOX_CLIPBOARD_EXT_FN_DATA_READ            (2)
     40#define VBOX_CLIPBOARD_EXT_FN_DATA_WRITE           (3)
     41/** Registers a new clipboard area.
     42 *  Uses the VBOXCLIPBOARDEXTAREAPARMS struct. */
     43#define VBOX_CLIPBOARD_EXT_FN_AREA_REGISTER        (4)
     44/** Unregisters an existing clipboard area.
     45 *  Uses the VBOXCLIPBOARDEXTAREAPARMS struct. */
     46#define VBOX_CLIPBOARD_EXT_FN_AREA_UNREGISTER      (5)
     47/** Attaches to an existing clipboard area.
     48 *  Uses the VBOXCLIPBOARDEXTAREAPARMS struct. */
     49#define VBOX_CLIPBOARD_EXT_FN_AREA_ATTACH          (6)
     50/** Detaches from an existing clipboard area.
     51 *  Uses the VBOXCLIPBOARDEXTAREAPARMS struct. */
     52#define VBOX_CLIPBOARD_EXT_FN_AREA_DETACH          (7)
    3853
    3954typedef DECLCALLBACK(int) VRDPCLIPBOARDEXTCALLBACK (uint32_t u32Function, uint32_t u32Format, void *pvData, uint32_t cbData);
    … …  
    4560    union
    4661    {
    47         void                        *pvData;
     62        void                       *pvData;
    4863        PFNVRDPCLIPBOARDEXTCALLBACK pfnCallback;
    4964    } u;
    … …  
    5166} VBOXCLIPBOARDEXTPARMS;
    5267
     68#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     69typedef uint32_t VBOXCLIPBOARDEXTAREAREGISTETRFLAGS;
     70/** No clipboard register area flags specified. */
     71#define VBOXCLIPBOARDEXTAREA_REGISTER_FLAGS_NONE        0
     72
     73typedef uint32_t VBOXCLIPBOARDEXTAREAATTACHFLAGS;
     74/** No clipboard attach area flags specified. */
     75#define VBOXCLIPBOARDEXTAREA_ATTACH_FLAGS_NONE          0
     76
     77/**
     78 * Structure for keeping clipboard area callback parameters.
     79 */
     80typedef struct _VBOXCLIPBOARDEXTAREAPARMS
     81{
     82    /** The clipboard area's ID. */
     83    SHAREDCLIPBOARDAREAID uID;
     84    union
     85    {
     86        struct
     87        {
     88            void                              *pvData;
     89            uint32_t                           cbData;
     90            VBOXCLIPBOARDEXTAREAREGISTETRFLAGS fFlags;
     91        } fn_register;
     92        struct
     93        {
     94            VBOXCLIPBOARDEXTAREAATTACHFLAGS    fFlags;
     95        } fn_attach;
     96    } u;
     97} VBOXCLIPBOARDEXTAREAPARMS, *PVBOXCLIPBOARDEXTAREAPARMS;
     98#endif
     99
    53100#endif /* !VBOX_INCLUDED_HostServices_VBoxClipboardExt_h */

  • trunk/include/VBox/HostServices/VBoxClipboardSvc.h

    r78649 r78683  
    4545 * The service functions which are callable by host.
    4646 */
    47 #define VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE      1
     47#define VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE           1
    4848/** Run headless on the host, i.e. do not touch the host clipboard. */
    49 #define VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS  2
     49#define VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS       2
    5050/** Reports cancellation of the current operation to the guest. */
    51 #define VBOX_SHARED_CLIPBOARD_HOST_FN_CANCEL        3
     51#define VBOX_SHARED_CLIPBOARD_HOST_FN_CANCEL             3
    5252/** Reports an error to the guest. */
    53 #define VBOX_SHARED_CLIPBOARD_HOST_FN_ERROR         4
     53#define VBOX_SHARED_CLIPBOARD_HOST_FN_ERROR              4
     54/** Reports that a new clipboard area has been registered. */
     55#define VBOX_SHARED_CLIPBOARD_HOST_FN_AREA_REGISTER      5
     56/** Reports that a clipboard area has been unregistered. */
     57#define VBOX_SHARED_CLIPBOARD_HOST_FN_AREA_UNREGISTER    6
     58/** Reports that a client (host / guest) has attached to a clipboard area. */
     59#define VBOX_SHARED_CLIPBOARD_HOST_FN_AREA_ATTACH        7
     60/** Reports that a client (host / guest) has detached from a clipboard area. */
     61#define VBOX_SHARED_CLIPBOARD_HOST_FN_AREA_DETACH        8
    5462
    5563/*
    … …  
    119127#define VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG 2
    120128
    121 typedef struct _VBoxClipboardWriteFormats
     129typedef struct _VBoxClipboardWriteFormatsMsg
    122130{
    123131    VBGLIOCHGCMCALL hdr;
    … …  
    125133    /* VBOX_SHARED_CLIPBOARD_FMT_* */
    126134    HGCMFunctionParameter formats; /* OUT uint32_t */
    127 } VBoxClipboardWriteFormats;
     135} VBoxClipboardWriteFormatsMsg;
    128136
    129137#define VBOX_SHARED_CLIPBOARD_CPARMS_FORMATS 1
    130138
    131 typedef struct _VBoxClipboardReadData
     139typedef struct _VBoxClipboardReadDataMsg
    132140{
    133141    VBGLIOCHGCMCALL hdr;
    … …  
    144152    HGCMFunctionParameter size;   /* OUT uint32_t */
    145153
    146 } VBoxClipboardReadData;
     154} VBoxClipboardReadDataMsg;
    147155
    148156#define VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA 3
    149157
    150 typedef struct _VBoxClipboardWriteData
     158typedef struct _VBoxClipboardWriteDataMsg
    151159{
    152160    VBGLIOCHGCMCALL hdr;
    … …  
    157165    /* Data.  */
    158166    HGCMFunctionParameter ptr;    /* IN linear pointer. */
    159 } VBoxClipboardWriteData;
     167} VBoxClipboardWriteDataMsg;
    160168
    161169#define VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA 2
    162170
    163171/**
    164  * Sends the header of an incoming (meta) data block.
    165  *
    166  * Used by:
    167  * XXX
    168  */
    169 typedef struct _VBoxClipboardWriteDataHdrMsg
     172 * Reads / writes the (meta) data header.
     173 *
     174 * Used by:
     175 * VBOX_SHARED_CLIPBOARD_FN_READ_DATA_HDR
     176 * VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_HDR
     177 */
     178typedef struct _VBoxClipboardReadDataHdrMsg
    170179{
    171180    VBGLIOCHGCMCALL hdr;
    … …  
    200209    /** Size (in bytes) of checksum. */
    201210    HGCMFunctionParameter cbChecksum;      /* OUT uint32_t */
    202 } VBoxClipboardWriteDataHdrMsg;
    203 
     211} VBoxClipboardReadDataHdrMsg, VBoxClipboardWriteDataHdrMsg;
     212
     213#define VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_HDR  12
    204214#define VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_HDR 12
    205215
    206216/**
    207  * Sends a (meta) data block to the host.
    208  *
    209  * Used by:
    210  * GUEST_DND_GH_SND_DATA
    211  */
    212 typedef struct _VBoxClipboardWriteDataChunkMsg
     217 * Reads / writes a (meta) data block.
     218 *
     219 * Used by:
     220 * VBOX_SHARED_CLIPBOARD_FN_READ_DATA_CHUNK
     221 * VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_CHUNK
     222 */
     223typedef struct _VBoxClipboardDataChunkMsg
    213224{
    214225    VBGLIOCHGCMCALL hdr;
    … …  
    224235    /** Size (in bytes) of checksum. */
    225236    HGCMFunctionParameter cbChecksum;   /* OUT uint32_t */
    226 } VBoxClipboardWriteDataChunkMsg;
    227 
     237} VBoxClipboardReadDataChunkMsg, VBoxClipboardWriteDataChunkMsg;
     238
     239#define VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_CHUNK  5
    228240#define VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_CHUNK 5
    229241
    230242/**
    231  * Sends a directory entry.
    232  *
    233  * Used by:
    234  * XXX
    235  */
    236 typedef struct _VBoxClipboardWriteDirMsg
     243 * Reads / writes a directory entry.
     244 *
     245 * Used by:
     246 * VBOX_SHARED_CLIPBOARD_FN_READ_DIR
     247 * VBOX_SHARED_CLIPBOARD_FN_WRITE_DIR
     248 */
     249typedef struct _VBoxClipboardDirMsg
    237250{
    238251    VBGLIOCHGCMCALL hdr;
    … …  
    246259    /** Directory mode. */
    247260    HGCMFunctionParameter fMode;        /* OUT uint32_t */
    248 } VBoxClipboardWriteDirMsg;
    249 
     261} VBoxClipboardReadDirMsg, VBoxClipboardWriteDirMsg;
     262
     263#define VBOX_SHARED_CLIPBOARD_CPARMS_READ_DIR  4
    250264#define VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DIR 4
    251265
    … …  
    254268 *
    255269 * Used by:
    256  * XXX
    257  */
    258 typedef struct _VBoxClipboardWriteFileHdrMsg
     270 * VBOX_SHARED_CLIPBOARD_FN_READ_FILE_HDR
     271 * VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_HDR
     272 */
     273typedef struct _VBoxClipboardFileHdrMsg
    259274{
    260275    VBGLIOCHGCMCALL hdr;
    … …  
    272287    /** Total size (in bytes). */
    273288    HGCMFunctionParameter cbTotal;      /* OUT uint64_t */
    274 } VBoxClipboardWriteFileHdrMsg;
    275 
     289} VBoxClipboardWriteReadHdrMsg, VBoxClipboardWriteFileHdrMsg;
     290
     291#define VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_HDR  6
    276292#define VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_HDR 6
    277293
    278294/**
    279  * Sends data of a file entry.
    280  *
    281  * Used by:
    282  * XXX
    283  */
    284 typedef struct _VBoxClipboardWriteFileDataMsg
     295 * Reads / writes data of a file entry.
     296 *
     297 * Used by:
     298 * VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA
     299 * VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA
     300 */
     301typedef struct _VBoxClipboardFileDataMsg
    285302{
    286303    VBGLIOCHGCMCALL hdr;
    … …  
    299316} VBoxClipboardWriteFileDataMsg;
    300317
     318#define VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_DATA  5
    301319#define VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_DATA 5
    302320
    … …  
    305323 *
    306324 * Used by:
    307  * XXX
    308  */
    309 typedef struct _VBoxClipboardWriteErrorMsg
     325 * VBOX_SHARED_CLIPBOARD_FN_WRITE_ERROR
     326 */
     327typedef struct _VBoxClipboardErrorMsg
    310328{
    311329    VBGLIOCHGCMCALL hdr;

  • trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp

    r78581 r78683  
    128128VBGLR3DECL(int) VbglR3ClipboardReadData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb, uint32_t *pcb)
    129129{
    130     VBoxClipboardReadData Msg;
     130    VBoxClipboardReadDataMsg Msg;
    131131
    132132    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_READ_DATA, 3);
    … …  
    152152}
    153153
     154/**
     155 * Reads the meta data header from the host.
     156 *
     157 * @returns IPRT status code.
     158 * @param   idClient            The client id returned by VbglR3ClipboardConnect().
     159 * @param   pDataHdr            Where to store the read meta data header.
     160 */
     161static int vbglR3ClipboardReadMetaDataHdr(HGCMCLIENTID idClient, PVBOXDNDSNDDATAHDR pDataHdr)
     162{
     163    AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
     164
     165    VBOXDNDHGSENDDATAHDRMSG Msg;
     166    RT_ZERO(Msg);
     167    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, HOST_DND_HG_SND_DATA_HDR, 12);
     168    Msg.uContext.SetUInt32(0);
     169    Msg.uFlags.SetUInt32(0);
     170    Msg.uScreenId.SetUInt32(0);
     171    Msg.cbTotal.SetUInt64(0);
     172    Msg.cbMeta.SetUInt32(0);
     173    Msg.pvMetaFmt.SetPtr(pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt);
     174    Msg.cbMetaFmt.SetUInt32(0);
     175    Msg.cObjects.SetUInt64(0);
     176    Msg.enmCompression.SetUInt32(0);
     177    Msg.enmChecksumType.SetUInt32(0);
     178    Msg.pvChecksum.SetPtr(pDataHdr->pvChecksum, pDataHdr->cbChecksum);
     179    Msg.cbChecksum.SetUInt32(0);
     180
     181    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     182    if (RT_SUCCESS(rc))
     183    {
     184        /* Msg.uContext not needed here. */
     185        Msg.uFlags.GetUInt32(&pDataHdr->uFlags);
     186        Msg.uScreenId.GetUInt32(&pDataHdr->uScreenId);
     187        Msg.cbTotal.GetUInt64(&pDataHdr->cbTotal);
     188        Msg.cbMeta.GetUInt32(&pDataHdr->cbMeta);
     189        Msg.cbMetaFmt.GetUInt32(&pDataHdr->cbMetaFmt);
     190        Msg.cObjects.GetUInt64(&pDataHdr->cObjects);
     191        Msg.enmCompression.GetUInt32(&pDataHdr->enmCompression);
     192        Msg.enmChecksumType.GetUInt32((uint32_t *)&pDataHdr->enmChecksumType);
     193        Msg.cbChecksum.GetUInt32(&pDataHdr->cbChecksum);
     194    }
     195
     196    LogFlowFuncLeaveRC(rc);
     197    return rc;
     198}
     199
     200/**
     201 * Helper function for reading the actual clipboard meta data from the host. Do not call directly.
     202 *
     203 * @returns IPRT status code.
     204 * @param   idClient            The client id returned by VbglR3ClipboardConnect().
     205 * @param   pDataHdr            Where to store the data header data.
     206 * @param   ppvData             Returns the received meta data. Needs to be free'd by the caller.
     207 * @param   pcbData             Where to store the size (in bytes) of the received meta data.
     208 */
     209static int vbglR3ClipboardReadMetaDataLoop(HGCMCLIENTID idClient, PVBOXDNDSNDDATAHDR pDataHdr,
     210                                           void **ppvData, uint64_t *pcbData)
     211{
     212    AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
     213    AssertPtrReturn(ppvData,  VERR_INVALID_POINTER);
     214    AssertPtrReturn(pcbData,  VERR_INVALID_POINTER);
     215
     216    int rc;
     217    uint32_t cbDataRecv;
     218
     219    LogFlowFuncEnter();
     220
     221    rc = vbglR3DnDHGRecvDataHdr(pCtx, pDataHdr);
     222    if (RT_FAILURE(rc))
     223        return rc;
     224
     225    LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32, cObjects=%RU32\n", pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects));
     226    if (pDataHdr->cbMeta)
     227    {
     228        uint64_t cbDataTmp = 0;
     229        void    *pvDataTmp = RTMemAlloc(pDataHdr->cbMeta);
     230        if (!pvDataTmp)
     231            rc = VERR_NO_MEMORY;
     232
     233        if (RT_SUCCESS(rc))
     234        {
     235            uint8_t *pvDataOff = (uint8_t *)pvDataTmp;
     236            while (cbDataTmp < pDataHdr->cbMeta)
     237            {
     238                rc = vbglR3DnDHGRecvDataRaw(pCtx, pDataHdr,
     239                                            pvDataOff, RT_MIN(pDataHdr->cbMeta - cbDataTmp, pCtx->cbMaxChunkSize),
     240                                            &cbDataRecv);
     241                if (RT_SUCCESS(rc))
     242                {
     243                    LogFlowFunc(("cbDataRecv=%RU32, cbDataTmp=%RU64\n", cbDataRecv, cbDataTmp));
     244                    Assert(cbDataTmp + cbDataRecv <= pDataHdr->cbMeta);
     245                    cbDataTmp += cbDataRecv;
     246                    pvDataOff += cbDataRecv;
     247                }
     248                else
     249                    break;
     250            }
     251
     252            if (RT_SUCCESS(rc))
     253            {
     254                Assert(cbDataTmp == pDataHdr->cbMeta);
     255
     256                LogFlowFunc(("Received %RU64 bytes of data\n", cbDataTmp));
     257
     258                *ppvData = pvDataTmp;
     259                *pcbData = cbDataTmp;
     260            }
     261            else
     262                RTMemFree(pvDataTmp);
     263        }
     264    }
     265    else
     266    {
     267        *ppvData = NULL;
     268        *pcbData = 0;
     269    }
     270
     271    LogFlowFuncLeaveRC(rc);
     272    return rc;
     273}
     274
     275/**
     276 * Main function for reading the actual meta data from the host, extended version.
     277 *
     278 * @returns IPRT status code.
     279 * @param   idClient            The client id returned by VbglR3ClipboardConnect().
     280 * @param   pEnmType            Where to store the meta data type. Optional.
     281 * @param   ppvData             Returns the received meta data. Needs to be free'd by the caller.  Optional.
     282 * @param   pcbData             Where to store the size (in bytes) of the received meta data. Optional.
     283 */
     284static int vbglR3ClipboardReadMetaDataMainEx(HGCMCLIENTID                 idClient,
     285                                             VBGLR3GUESTDNDMETADATATYPE  *pEnmType,
     286                                             void                       **ppvData,
     287                                             uint32_t                    *pcbData)
     288{
     289    /* The rest is optional. */
     290
     291    VBOXDNDDATAHDR dataHdr;
     292    RT_ZERO(dataHdr);
     293
     294    AssertMsg(pCtx->cbMaxChunkSize, ("Maximum chunk size must not be 0\n"));
     295
     296    dataHdr.cbMetaFmt = pCtx->cbMaxChunkSize;
     297    dataHdr.pvMetaFmt = RTMemAlloc(dataHdr.cbMetaFmt);
     298    if (!dataHdr.pvMetaFmt)
     299        return VERR_NO_MEMORY;
     300
     301    DnDURIList lstURI;
     302    DnDDroppedFiles droppedFiles;
     303
     304    void    *pvData = NULL;
     305    uint64_t cbData = 0;
     306
     307    int rc = vbglR3DnDHGRecvDataLoop(pCtx, &dataHdr, &pvData, &cbData);
     308    if (RT_SUCCESS(rc))
     309    {
     310        /**
     311         * Check if this is an URI event. If so, let VbglR3 do all the actual
     312         * data transfer + file/directory creation internally without letting
     313         * the caller know.
     314         *
     315         * This keeps the actual (guest OS-)dependent client (like VBoxClient /
     316         * VBoxTray) small by not having too much redundant code.
     317         */
     318        Assert(dataHdr.cbMetaFmt);
     319        AssertPtr(dataHdr.pvMetaFmt);
     320        if (DnDMIMEHasFileURLs((char *)dataHdr.pvMetaFmt, dataHdr.cbMetaFmt)) /* URI data. */
     321        {
     322            AssertPtr(pvData);
     323            Assert(cbData);
     324
     325            rc = lstURI.SetFromURIData(pvData, cbData, 0 /* fFlags */);
     326            if (RT_SUCCESS(rc))
     327                rc = vbglR3DnDHGRecvURIData(pCtx, &dataHdr, &droppedFiles);
     328
     329            if (RT_SUCCESS(rc)) /** @todo Remove this block as soon as we hand in DnDURIList. */
     330            {
     331                if (pvData)
     332                {
     333                    /* Reuse data buffer to fill in the transformed URI file list. */
     334                    RTMemFree(pvData);
     335                    pvData = NULL;
     336                }
     337
     338                RTCString strData = lstURI.GetRootEntries(droppedFiles.GetDirAbs());
     339                Assert(!strData.isEmpty());
     340
     341                cbData = strData.length() + 1;
     342                LogFlowFunc(("URI list has %zu bytes\n", cbData));
     343
     344                pvData = RTMemAlloc(cbData);
     345                if (pvData)
     346                {
     347                    memcpy(pvData, strData.c_str(), cbData);
     348
     349                    if (pEnmType)
     350                        *pEnmType = VBGLR3GUESTDNDMETADATATYPE_URI_LIST;
     351                }
     352                else
     353                    rc =  VERR_NO_MEMORY;
     354            }
     355        }
     356        else /* Raw data. */
     357        {
     358            if (pEnmType)
     359                *pEnmType = VBGLR3GUESTDNDMETADATATYPE_RAW;
     360        }
     361    }
     362
     363    if (dataHdr.pvMetaFmt)
     364        RTMemFree(dataHdr.pvMetaFmt);
     365
     366    if (RT_SUCCESS(rc))
     367    {
     368        if (   pvData
     369            && cbData)
     370        {
     371            if (pcbData)
     372                *pcbData = cbData;
     373            if (ppvData)
     374                *ppvData = pvData;
     375            else
     376                RTMemFree(pvData);
     377        }
     378    }
     379    else if (   RT_FAILURE(rc)
     380             && rc != VERR_CANCELLED)
     381    {
     382        if (pvData)
     383            RTMemFree(pvData);
     384
     385        int rc2 = VbglR3DnDHGSendProgress(pCtx, DND_PROGRESS_ERROR, 100 /* Percent */, rc);
     386        if (RT_FAILURE(rc2))
     387            LogFlowFunc(("Unable to send progress error %Rrc to host: %Rrc\n", rc, rc2));
     388    }
     389
     390    LogFlowFuncLeaveRC(rc);
     391    return rc;
     392}
     393
     394/**
     395 * Main function for reading the actual meta data from the host.
     396 *
     397 * @returns IPRT status code.
     398 * @param   idClient            The client id returned by VbglR3ClipboardConnect().
     399 * @param   pMeta               Where to store the actual meta data received from the host.
     400 */
     401static int vbglR3ClipboardReadMetaDataMain(HGCMCLIENTID idClient, PVBGLR3GUESTDNDMETADATA pMeta)
     402{
     403    AssertPtrReturn(pMeta, VERR_INVALID_POINTER);
     404
     405    int rc = vbglR3ClipboardReadMetaDataMainEx(idClient,
     406                                               &pMeta->enmType,
     407                                               &pMeta->pvMeta,
     408                                               &pMeta->cbMeta);
     409    return rc;
     410}
    154411
    155412/**
    … …  
    162419VBGLR3DECL(int) VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats)
    163420{
    164     VBoxClipboardWriteFormats Msg;
     421    VBoxClipboardWriteFormatsMsg Msg;
    165422
    166423    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_REPORT_FORMATS, 1);
    … …  
    184441static int vbglR3ClipboardWriteDataRaw(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb)
    185442{
    186     VBoxClipboardWriteData Msg;
     443    VBoxClipboardWriteDataMsg Msg;
    187444    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA, 2);
    188445    VbglHGCMParmUInt32Set(&Msg.format, fFormat);

  • trunk/src/VBox/GuestHost/SharedClipboard/ClipboardCache.cpp

    r78618 r78683  
    3737    : m_cRefs(0)
    3838    , m_fOpen(0)
    39     , m_hDir(NULL)
     39    , m_hDir(NIL_RTDIR)
     40    , m_uID(NIL_SHAREDCLIPBOARDAREAID)
    4041{
    4142    int rc = initInternal();
    … …  
    4546
    4647SharedClipboardCache::SharedClipboardCache(const char *pszPath,
     48                                           SHAREDCLIPBOARDAREAID uID /* = NIL_SHAREDCLIPBOARDAREAID */,
    4749                                           SHAREDCLIPBOARDCACHEFLAGS fFlags /* = SHAREDCLIPBOARDCACHE_FLAGS_NONE */)
    4850    : m_cRefs(0)
    4951    , m_fOpen(0)
    50     , m_hDir(NULL)
     52    , m_hDir(NIL_RTDIR)
     53    , m_uID(uID)
    5154{
    5255    int rc = initInternal();
    … …  
    140143{
    141144    int rc;
    142     if (this->m_hDir != NULL)
     145    if (this->m_hDir != NIL_RTDIR)
    143146    {
    144147        rc = RTDirClose(this->m_hDir);
    145148        if (RT_SUCCESS(rc))
    146             this->m_hDir = NULL;
     149            this->m_hDir = NIL_RTDIR;
    147150    }
    148151    else
    149152        rc = VINF_SUCCESS;
    150153
     154    this->m_fOpen = SHAREDCLIPBOARDCACHE_FLAGS_NONE;
     155    this->m_uID   = NIL_SHAREDCLIPBOARDAREAID;
     156
    151157    LogFlowFuncLeaveRC(rc);
    152158    return rc;
    153159}
    154160
     161/**
     162 * Construcuts the cache's base path.
     163 *
     164 * @returns VBox status code.
     165 * @param   pszBase             Base path to use for the cache.
     166 * @param   pszPath             Where to store the constructured cache base path.
     167 * @param   cbPath              Size (in bytes) of the constructured cache base path.
     168 */
     169int SharedClipboardCache::pathConstruct(const char *pszBase, char *pszPath, size_t cbPath)
     170{
     171    RTStrPrintf(pszPath, cbPath, "%s", pszBase);
     172
     173    /** @todo On Windows we also could use the registry to override
     174     *        this path, on Posix a dotfile and/or a guest property
     175     *        can be used. */
     176
     177    /* Append our base cache directory. */
     178    int rc = RTPathAppend(pszPath, sizeof(pszPath), "VirtualBox Shared Clipboards"); /** @todo Make this tag configurable? */
     179    if (RT_FAILURE(rc))
     180        return rc;
     181
     182    /* Create it when necessary. */
     183    if (!RTDirExists(pszPath))
     184    {
     185        rc = RTDirCreateFullPath(pszPath, RTFS_UNIX_IRWXU);
     186        if (RT_FAILURE(rc))
     187            return rc;
     188    }
     189
     190    rc = RTPathAppend(pszPath, sizeof(pszPath), "Clipboard");
     191    return rc;
     192}
     193
    155194int SharedClipboardCache::Close(void)
    156195{
    … …  
    158197}
    159198
     199SHAREDCLIPBOARDAREAID SharedClipboardCache::GetAreaID(void) const
     200{
     201    return this->m_uID;
     202}
     203
    160204const char *SharedClipboardCache::GetDirAbs(void) const
    161205{
    … …  
    168212}
    169213
    170 int SharedClipboardCache::OpenEx(const char *pszPath, SHAREDCLIPBOARDCACHEFLAGS fFlags /* = SHAREDCLIPBOARDCACHE_FLAGS_NONE */)
     214int SharedClipboardCache::OpenEx(const char *pszPath,
     215                                 SHAREDCLIPBOARDAREAID uID /* = NIL_SHAREDCLIPBOARDAREAID */,
     216                                 SHAREDCLIPBOARDCACHEFLAGS fFlags /* = SHAREDCLIPBOARDCACHE_FLAGS_NONE */)
    171217{
    172218    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
    173219    AssertReturn(fFlags == 0, VERR_INVALID_PARAMETER); /* Flags not supported yet. */
    174220
    175     int rc;
    176 
    177     do
    178     {
    179         char pszDropDir[RTPATH_MAX];
    180         RTStrPrintf(pszDropDir, sizeof(pszDropDir), "%s", pszPath);
    181 
    182         /** @todo On Windows we also could use the registry to override
    183          *        this path, on Posix a dotfile and/or a guest property
    184          *        can be used. */
    185 
    186         /* Append our base drop directory. */
    187         rc = RTPathAppend(pszDropDir, sizeof(pszDropDir), "VirtualBox Shared Clipboard Files"); /** @todo Make this tag configurable? */
    188         if (RT_FAILURE(rc))
    189             break;
    190 
    191         /* Create it when necessary. */
    192         if (!RTDirExists(pszDropDir))
    193         {
    194             rc = RTDirCreateFullPath(pszDropDir, RTFS_UNIX_IRWXU);
    195             if (RT_FAILURE(rc))
    196                 break;
    197         }
    198 
    199         /* The actually drop directory consist of the current time stamp and a
    200          * unique number when necessary. */
    201         char pszTime[64];
    202         RTTIMESPEC time;
    203         if (!RTTimeSpecToString(RTTimeNow(&time), pszTime, sizeof(pszTime)))
    204         {
    205             rc = VERR_BUFFER_OVERFLOW;
    206             break;
    207         }
    208 
    209         rc = SharedClipboardPathSanitizeFilename(pszTime, sizeof(pszTime));
    210         if (RT_FAILURE(rc))
    211             break;
    212 
    213         rc = RTPathAppend(pszDropDir, sizeof(pszDropDir), pszTime);
    214         if (RT_FAILURE(rc))
    215             break;
    216 
     221    char szCacheDir[RTPATH_MAX];
     222    int rc = pathConstruct(pszPath, szCacheDir, sizeof(szCacheDir));
     223    if (RT_SUCCESS(rc))
     224    {
    217225        /* Create it (only accessible by the current user) */
    218         rc = RTDirCreateUniqueNumbered(pszDropDir, sizeof(pszDropDir), RTFS_UNIX_IRWXU, 3, '-');
     226        rc = RTDirCreateUniqueNumbered(szCacheDir, sizeof(szCacheDir), RTFS_UNIX_IRWXU, 3, '-');
    219227        if (RT_SUCCESS(rc))
    220228        {
    221229            RTDIR hDir;
    222             rc = RTDirOpen(&hDir, pszDropDir);
     230            rc = RTDirOpen(&hDir, szCacheDir);
    223231            if (RT_SUCCESS(rc))
    224232            {
    225233                this->m_hDir       = hDir;
    226                 this->m_strPathAbs = pszDropDir;
     234                this->m_strPathAbs = szCacheDir;
    227235                this->m_fOpen      = fFlags;
     236                this->m_uID        = uID;
    228237            }
    229238        }
    230 
    231     } while (0);
     239    }
    232240
    233241    LogFlowFuncLeaveRC(rc);
    … …  
    235243}
    236244
    237 int SharedClipboardCache::OpenTemp(SHAREDCLIPBOARDCACHEFLAGS fFlags /* = SHAREDCLIPBOARDCACHE_FLAGS_NONE */)
     245int SharedClipboardCache::OpenTemp(SHAREDCLIPBOARDAREAID uID,
     246                                   SHAREDCLIPBOARDCACHEFLAGS fFlags /* = SHAREDCLIPBOARDCACHE_FLAGS_NONE */)
    238247{
    239248    AssertReturn(fFlags == 0, VERR_INVALID_PARAMETER); /* Flags not supported yet. */
    … …  
    247256    int rc = RTPathTemp(szTemp, sizeof(szTemp));
    248257    if (RT_SUCCESS(rc))
    249         rc = OpenEx(szTemp, fFlags);
     258        rc = OpenEx(szTemp, uID, fFlags);
    250259
    251260    return rc;

  • trunk/src/VBox/GuestHost/SharedClipboard/ClipboardMetaData.cpp

    r78651 r78683  
    2323#include <VBox/GuestHost/SharedClipboard-uri.h>
    2424
     25/**
     26 * Initializes a clipboard meta data struct.
     27 *
     28 * @returns VBox status code.
     29 * @param   pMeta               Meta data struct to initialize.
     30 */
    2531int SharedClipboardMetaDataInit(PSHAREDCLIPBOARDMETADATA pMeta)
    2632{
    … …  
    3642}
    3743
     44/**
     45 * Destroys a clipboard meta data struct by free'ing all its data.
     46 *
     47 * @param   pMeta               Meta data struct to destroy.
     48 */
    3849void SharedClipboardMetaDataDestroy(PSHAREDCLIPBOARDMETADATA pMeta)
    3950{
    … …  
    5465}
    5566
     67/**
     68 * Adds new meta data to a meta data struct.
     69 *
     70 * @returns VBox status code.
     71 * @param   pMeta               Meta data struct to add data to.
     72 */
    5673int SharedClipboardMetaDataAdd(PSHAREDCLIPBOARDMETADATA pMeta, const void *pvDataAdd, uint32_t cbDataAdd)
    5774{
    … …  
    7491}
    7592
     93/**
     94 * Resizes the data buffer of a meta data struct.
     95 * Note: At the moment only supports growing the data buffer.
     96 *
     97 * @returns VBox status code.
     98 * @param   pMeta               Meta data struct to resize.
     99 * @param   cbNewSize           New size (in bytes) to use for resizing.
     100 */
    76101int SharedClipboardMetaDataResize(PSHAREDCLIPBOARDMETADATA pMeta, size_t cbNewSize)
    77102{
    … …  
    86111    if (cbNewSize == pMeta->cbMeta)
    87112        return VINF_SUCCESS;
     113
     114    if (cbNewSize > _32M) /* Meta data can be up to 32MB. */
     115        return VERR_INVALID_PARAMETER;
    88116
    89117    void *pvTmp = NULL;
    … …  
    110138}
    111139
     140/**
     141 * Returns the actual used bytes of a meta data struct.
     142 *
     143 * @returns Actual used bytes of a meta data struct.
     144 * @param   pMeta               Meta data struct to return used bytes for.
     145 */
    112146size_t SharedClipboardMetaDataGetUsed(PSHAREDCLIPBOARDMETADATA pMeta)
    113147{
    … …  
    116150}
    117151
     152/**
     153 * Returns the overall (allocated) size in bytes of a meta data struct.
     154 *
     155 * @returns Overall (allocated) size of a meta data struct.
     156 * @param   pMeta               Meta data struct to return size for.
     157 */
    118158size_t SharedClipboardMetaDataGetSize(PSHAREDCLIPBOARDMETADATA pMeta)
    119159{
    … …  
    122162}
    123163
     164/**
     165 * Returns the a mutable raw pointer to the actual meta data.
     166 *
     167 * @returns Mutable raw pointer to the actual meta data.
     168 * @param   pMeta               Meta data struct to return mutable data pointer for.
     169 */
     170void *SharedClipboardMetaDataMutableRaw(PSHAREDCLIPBOARDMETADATA pMeta)
     171{
     172    return pMeta->pvMeta;
     173}
     174
     175/**
     176 * Returns the a const'ed raw pointer to the actual meta data.
     177 *
     178 * @returns Const'ed raw pointer to the actual meta data.
     179 * @param   pMeta               Meta data struct to return const'ed data pointer for.
     180 */
    124181const void *SharedClipboardMetaDataRaw(PSHAREDCLIPBOARDMETADATA pMeta)
    125182{

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h

    r78648 r78683  
    5050    /** Node for keeping this transfer in a RTList. */
    5151    RTLISTNODE                     Node;
    52     /** The transfer's own (local) cache. */
     52    /** The transfer's own (local) cache.
     53     *  The cache itself has a clipboard area ID assigned. */
    5354    SharedClipboardCache           Cache;
    5455    /** The transfer's URI list, containing the fs object root entries. */

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp

    r78648 r78683  
    2222#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
    2323#include <VBox/HostServices/VBoxClipboardSvc.h>
     24#include <VBox/HostServices/VBoxClipboardExt.h>
    2425
    2526#include <iprt/dir.h>
    … …  
    3132
    3233
     34/*********************************************************************************************************************************
     35*   Externals                                                                                                                    *
     36*********************************************************************************************************************************/
     37extern PFNHGCMSVCEXT g_pfnExtension;
     38extern void *g_pvExtension;
     39
     40
    3341/**
    3442 * Initializes an URI object context.
    … …  
    4149    AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
    4250
     51    LogFlowFuncEnter();
     52
    4353    pObjCtx->pObj = NULL;
    4454
    … …  
    5464{
    5565    AssertPtrReturnVoid(pObjCtx);
     66
     67    LogFlowFuncEnter();
    5668
    5769    if (pObjCtx->pObj)
    … …  
    122134    AssertPtrReturnVoid(pTransfer);
    123135
     136    LogFlowFuncEnter();
     137
    124138    vboxClipboardSvcURITransferReset(pTransfer);
    125 
    126     int rc2 = pTransfer->Cache.Close();
     139}
     140
     141/**
     142 * Resets a URI transfer object.
     143 *
     144 * @param   pTransfer           Transfer object to reset.
     145 */
     146void vboxClipboardSvcURITransferReset(PVBOXCLIPBOARDCLIENTURITRANSFER pTransfer)
     147{
     148    AssertPtrReturnVoid(pTransfer);
     149
     150    LogFlowFuncEnter();
     151
     152    vboxClipboardSvcURIObjCtxUninit(&pTransfer->ObjCtx);
     153
     154    int rc2;
     155
     156    /* Do we need to detach from a previously attached clipboard area? */
     157    const SHAREDCLIPBOARDAREAID uAreaID = pTransfer->Cache.GetAreaID();
     158    if (uAreaID != NIL_SHAREDCLIPBOARDAREAID)
     159    {
     160        VBOXCLIPBOARDEXTAREAPARMS parms;
     161        RT_ZERO(parms);
     162        parms.uID = uAreaID;
     163
     164        rc2 = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_DETACH, &parms, sizeof(parms));
     165        AssertRC(rc2);
     166    }
     167
     168    rc2 = pTransfer->Cache.Rollback();
    127169    AssertRC(rc2);
    128 }
    129 
    130 /**
    131  * Resets a URI transfer object.
    132  *
    133  * @param   pTransfer           Transfer object to reset.
    134  */
    135 void vboxClipboardSvcURITransferReset(PVBOXCLIPBOARDCLIENTURITRANSFER pTransfer)
    136 {
    137     AssertPtrReturnVoid(pTransfer);
    138 
    139     vboxClipboardSvcURIObjCtxUninit(&pTransfer->ObjCtx);
    140 
    141     int rc2 = pTransfer->Cache.Rollback();
     170
     171    rc2 = pTransfer->Cache.Close();
    142172    AssertRC(rc2);
    143173
    … …  
    230260        {
    231261            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_DATA_HDR\n"));
    232             AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
     262            if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_HDR)
     263            {
     264                if (   RT_SUCCESS(rc)
     265                    && g_pfnExtension)
     266                {
     267                    VBOXCLIPBOARDEXTAREAPARMS parms;
     268                    RT_ZERO(parms);
     269
     270                    parms.uID = 0; /* 0 means most recent clipboard area. */
     271
     272                    /* The client now needs to attach to the most recent clipboard area
     273                     * to keep a reference to it. The host does the actual book keeping / cleanup then. */
     274                    rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_ATTACH, &parms, sizeof(parms));
     275                    if (RT_SUCCESS(rc))
     276                    {
     277
     278                    }
     279
     280                    /* Do we need to detach again because we're done? */
     281                    if (   RT_SUCCESS(rc))
     282                    {
     283                        RT_ZERO(parms);
     284                        parms.uID = pTransfer->Cache.GetAreaID();
     285
     286                        rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_DETACH, &parms, sizeof(parms));
     287                    }
     288                }
     289            }
    233290            break;
    234291        }
    … …  
    314371                        && SharedClipboardMetaDataGetUsed(&pTransfer->Meta) == pTransfer->Hdr.cbMeta) /* Meta data transfer complete? */
    315372                    {
    316                         rc = pTransfer->List.SetFromURIData(SharedClipboardMetaDataRaw(&pTransfer->Meta),
    317                                                             SharedClipboardMetaDataGetSize(&pTransfer->Meta),
    318                                                             SHAREDCLIPBOARDURILIST_FLAGS_NONE);
     373                              void  *pvMeta = SharedClipboardMetaDataMutableRaw(&pTransfer->Meta);
     374                        const size_t cbMeta = SharedClipboardMetaDataGetSize(&pTransfer->Meta);
     375
     376                        rc = pTransfer->List.SetFromURIData(pvMeta, cbMeta, SHAREDCLIPBOARDURILIST_FLAGS_NONE);
     377
     378                        if (   RT_SUCCESS(rc)
     379                            && g_pfnExtension)
     380                        {
     381                            VBOXCLIPBOARDEXTAREAPARMS parms;
     382                            RT_ZERO(parms);
     383
     384                            parms.u.fn_register.pvData = pvMeta;
     385                            parms.u.fn_register.cbData = cbMeta;
     386
     387                            /* As the meta data is now complete, register a new clipboard on the host side. */
     388                            rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_REGISTER, &parms, sizeof(parms));
     389                        }
    319390
    320391                        /* We're done processing the meta data, so just destroy it. */
    321392                        SharedClipboardMetaDataDestroy(&pTransfer->Meta);
    322 
    323                         /*
    324                          * As we now have valid meta data, other parties can now acquire those and
    325                          * request additional data as well.
    326                          *
    327                          * In case of file data, receiving and requesting now depends on the speed of
    328                          * the actual source and target, i.e. the source might not be finished yet in receiving
    329                          * the current object, while the target already requests (and maybe waits) for the data to arrive.
    330                          */
    331393                    }
    332394                }

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp

    r78648 r78683  
    540540                        parms.u32Format = u32Formats;
    541541
    542                         g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE, &parms, sizeof (parms));
     542                        g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE, &parms, sizeof (parms));
    543543                    }
    544544                    else
    … …  
    690690                            parms.cbData = cb;
    691691
    692                             g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_WRITE, &parms, sizeof (parms));
     692                            g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_WRITE, &parms, sizeof (parms));
    693693                        }
    694694                        else
    … …  
    775775                uint32_t u32Mode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
    776776
    777                 rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Mode);
     777                rc = VBoxHGCMParmUInt32Get(&paParms[0], &u32Mode);
    778778
    779779                /* The setter takes care of invalid values. */
    780                 vboxSvcClipboardModeSet (u32Mode);
     780                vboxSvcClipboardModeSet(u32Mode);
    781781            }
    782782        } break;
    … …  
    789789            if (cParms != 1)
    790790                break;
    791             rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Headless);
     791
     792            rc = VBoxHGCMParmUInt32Get(&paParms[0], &u32Headless);
    792793            if (RT_SUCCESS(rc))
    793794                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS, u32Headless=%u\n",
    794795                            (unsigned) u32Headless));
     796
    795797            g_fHeadless = RT_BOOL(u32Headless);
     798
    796799        } break;
    797800

  • trunk/src/VBox/Main/Makefile.kmk

    r78156 r78683  
    834834        $(if $(VBOX_WITH_DRAG_AND_DROP),VBOX_WITH_DRAG_AND_DROP,) \
    835835        $(if $(VBOX_WITH_DRAG_AND_DROP_GH),VBOX_WITH_DRAG_AND_DROP_GH,) \
     836        $(if $(VBOX_WITH_SHARED_CLIPBOARD),VBOX_WITH_SHARED_CLIPBOARD,) \
     837        $(if $(VBOX_WITH_SHARED_CLIPBOARD_URI_LIST),VBOX_WITH_SHARED_CLIPBOARD_URI_LIST,) \
    836838        $(if $(VBOX_WITH_USB),VBOX_WITH_USB,) \
    837839        $(if $(VBOX_WITH_VRDEAUTH_IN_VBOXSVC),VBOX_WITH_VRDEAUTH_IN_VBOXSVC,)
    … …  
    10041006        src-client/GuestDnDTargetImpl.cpp
    10051007endif
     1008ifdef VBOX_WITH_SHARED_CLIPBOARD
     1009 VBoxC_SOURCES += \
     1010        src-client/SharedClipboardPrivate.cpp
     1011endif
    10061012ifdef VBOX_WITH_XPCOM
    10071013 VBoxC_SOURCES += \

  • trunk/src/VBox/Main/include/ConsoleImpl.h

    r78509 r78683  
    766766                                                          ISerialPort *pSerialPort);
    767767
    768     void i_changeClipboardMode(ClipboardMode_T aClipboardMode);
     768    int i_changeClipboardMode(ClipboardMode_T aClipboardMode);
    769769    int i_changeDnDMode(DnDMode_T aDnDMode);
    770770

  • trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

    r78509 r78683  
    91409140 * Changes the clipboard mode.
    91419141 *
    9142  * @param aClipboardMode  new clipboard mode.
    9143  */
    9144 void Console::i_changeClipboardMode(ClipboardMode_T aClipboardMode)
     9142 * @returns VBox status code.
     9143 * @param   aClipboardMode  new clipboard mode.
     9144 */
     9145int Console::i_changeClipboardMode(ClipboardMode_T aClipboardMode)
    91459146{
    91469147    VMMDev *pVMMDev = m_pVMMDev;
    9147     Assert(pVMMDev);
     9148    AssertPtr(pVMMDev);
    91489149
    91499150    VBOXHGCMSVCPARM parm;
    … …  
    91719172    }
    91729173
    9173     pVMMDev->hgcmHostCall("VBoxSharedClipboard", VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE, 1, &parm);
     9174    int rc =  pVMMDev->hgcmHostCall("VBoxSharedClipboard", VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE, 1, &parm);
     9175    if (RT_FAILURE(rc))
     9176        LogRel(("Error changing shared clipboard mode: %Rrc\n", rc));
     9177
     9178    return rc;
    91749179}
    91759180

  • trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp

    r78632 r78683  
    7474#include <VBox/vmm/pdmstorageifs.h>
    7575#include <VBox/version.h>
    76 #include <VBox/HostServices/VBoxClipboardSvc.h>
     76#ifdef VBOX_WITH_SHARED_CLIPBOARD
     77# include <VBox/HostServices/VBoxClipboardSvc.h>
     78# include "SharedClipboardPrivate.h"
     79#endif
    7780#ifdef VBOX_WITH_CROGL
    7881# include <VBox/HostServices/VBoxCrOpenGLSvc.h>
    79 #include <VBox/VBoxOGL.h>
     82# include <VBox/VBoxOGL.h>
    8083#endif
    8184#ifdef VBOX_WITH_GUEST_PROPS
    … …  
    30753078        }
    30763079
     3080#ifdef VBOX_WITH_SHARED_CLIPBOARD
    30773081        /*
    30783082         * Shared Clipboard.
    30793083         */
    30803084        {
    3081             ClipboardMode_T mode = ClipboardMode_Disabled;
    3082             hrc = pMachine->COMGETTER(ClipboardMode)(&mode);                                H();
    3083 
    3084             if (/* mode != ClipboardMode_Disabled */ true)
    3085             {
    3086                 /* Load the service */
    3087                 rc = pVMMDev->hgcmLoadService("VBoxSharedClipboard", "VBoxSharedClipboard");
     3085            /* Load the service */
     3086            rc = pVMMDev->hgcmLoadService("VBoxSharedClipboard", "VBoxSharedClipboard");
     3087            if (RT_FAILURE(rc))
     3088            {
     3089                LogRel(("Shared clipboard is not available, rc=%Rrc\n", rc));
     3090                /* That is not a fatal failure. */
     3091                rc = VINF_SUCCESS;
     3092            }
     3093            else
     3094            {
     3095# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     3096                HGCMSVCEXTHANDLE hDummy;
     3097                rc = HGCMHostRegisterServiceExtension(&hDummy, "VBoxSharedClipboard",
     3098                                                      &SharedClipboard::hostServiceCallback,
     3099                                                      SHAREDCLIPBOARDINST());
    30883100                if (RT_FAILURE(rc))
    3089                 {
    3090                     LogRel(("Shared clipboard is not available, rc=%Rrc\n", rc));
    3091                     /* That is not a fatal failure. */
    3092                     rc = VINF_SUCCESS;
    3093                 }
    3094                 else
     3101                    Log(("Cannot register VBoxSharedClipboard extension, rc=%Rrc\n", rc));
     3102# endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
     3103
     3104                if (RT_SUCCESS(rc))
    30953105                {
    30963106                    LogRel(("Shared clipboard service loaded\n"));
    30973107
    3098                     i_changeClipboardMode(mode);
     3108                    /* Set initial clipboard mode. */
     3109                    ClipboardMode_T mode = ClipboardMode_Disabled;
     3110                    hrc = pMachine->COMGETTER(ClipboardMode)(&mode); H();
     3111                    /* ignore rc, not fatal */ i_changeClipboardMode(mode);
    30993112
    31003113                    /* Setup the service. */
    31013114                    VBOXHGCMSVCPARM parm;
    31023115                    HGCMSvcSetU32(&parm, !i_useHostClipboard());
    3103                     pVMMDev->hgcmHostCall("VBoxSharedClipboard",
    3104                                           VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS, 1, &parm);
    3105                 }
    3106             }
    3107         }
     3116                    SHAREDCLIPBOARDINST()->hostCall(VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS, 1, &parm);
     3117                }
     3118            }
     3119        }
     3120#endif /* VBOX_WITH_SHARED_CLIPBOARD */
    31083121
    31093122        /*
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette