VirtualBox

Changeset 80444 in vbox


Ignore:
Timestamp:
Aug 27, 2019 5:47:44 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
132934
Message:

Shared Clipboard/URI: Added protocol versioning support plus enhanced versions of existing commands (to also provide context IDs, among other stuff). So far only the host service(s) and the Windows guest is using the new(er) protocol.

Location:
trunk
Files:
29 edited

Legend:

Unmodified
Added
Removed

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

    r80359 r80444  
    434434    /** Total size (in bytes) returned. */
    435435    uint64_t cbTotalSize;
    436     /** Compression being method used. Not implemented yet. */
    437     uint32_t enmCompression;
    438     /** Checksum type being used. Not implemented yet. */
    439     uint32_t enmChecksumType;
    440436} VBOXCLIPBOARDLISTHDR, *PVBOXCLIPBOARDLISTHDR;
    441437
    … …  
    700696
    701697/**
    702  * Structure for an (optional) URI transfer event payload.
    703  */
    704 typedef struct _SHAREDCLIPBOARDURITRANSFERPAYLOAD
    705 {
    706     /** Payload ID; currently unused. */
    707     uint32_t uID;
    708     /** Pointer to actual payload data. */
    709     void    *pvData;
    710     /** Size (in bytes) of actual payload data. */
    711     uint32_t cbData;
    712 } SHAREDCLIPBOARDURITRANSFERPAYLOAD, *PSHAREDCLIPBOARDURITRANSFERPAYLOAD;
    713 
    714 /**
    715  * Structure for maintaining an URI transfer event.
    716  */
    717 typedef struct _SHAREDCLIPBOARDURITRANSFEREVENT
    718 {
    719     /** Event semaphore for signalling the event. */
    720     RTSEMEVENT                         hEventSem;
    721     /** Payload to this event. Optional and can be NULL. */
    722     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    723 } SHAREDCLIPBOARDURITRANSFEREVENT, *PSHAREDCLIPBOARDURITRANSFEREVENT;
    724 
    725 /** Map of URI transfer events.
    726  *  The key specifies the event type of SHAREDCLIPBOARDURITRANSFEREVENTTYPE. */
    727 typedef std::map<uint16_t, SHAREDCLIPBOARDURITRANSFEREVENT *> SharedClipboardURITransferEventMap;
    728 
    729 /**
    730698 * Enumeration for specifying a Shared Clipboard object type.
    731699 */
    … …  
    750718typedef struct _SHAREDCLIPBOARDURILISTHANDLEINFO
    751719{
     720    /** The list node. */
     721    RTLISTNODE                    Node;
     722    /** The list's handle. */
     723    SHAREDCLIPBOARDLISTHANDLE     hList;
    752724    /** Type of list handle. */
    753     SHAREDCLIPBOARDURIOBJTYPE enmType;
     725    SHAREDCLIPBOARDURIOBJTYPE     enmType;
    754726    /** Absolute local path of the list object. */
    755     char                     *pszPathLocalAbs;
     727    char                         *pszPathLocalAbs;
    756728    union
    757729    {
    … …  
    768740} SHAREDCLIPBOARDURILISTHANDLEINFO, *PSHAREDCLIPBOARDURILISTHANDLEINFO;
    769741
    770 /** Map of URI list handles.
    771  *  The key specifies the list handle. */
    772 typedef std::map<SHAREDCLIPBOARDLISTHANDLE, SHAREDCLIPBOARDURILISTHANDLEINFO *> SharedClipboardURIListMap;
    773 
    774742/**
    775743 * Structure for keeping URI object handle information.
    … …  
    778746typedef struct _SHAREDCLIPBOARDURIOBJHANDLEINFO
    779747{
     748    /** The list node. */
     749    RTLISTNODE                Node;
     750    /** The object's handle. */
     751    SHAREDCLIPBOARDOBJHANDLE  hObj;
    780752    /** Type of object handle. */
    781753    SHAREDCLIPBOARDURIOBJTYPE enmType;
    … …  
    796768} SHAREDCLIPBOARDURIOBJHANDLEINFO, *PSHAREDCLIPBOARDURIOBJHANDLEINFO;
    797769
    798 /** Map of URI object handles.
    799  *  The key specifies the object handle. */
    800 typedef std::map<SHAREDCLIPBOARDOBJHANDLE, SHAREDCLIPBOARDURIOBJHANDLEINFO *> SharedClipboardURIObjMap;
    801 
    802770/**
    803771 * Structure for keeping a single root list entry.
    804  *
    805  * Warning: Contains non-POD types.
    806772 */
    807773typedef struct _SHAREDCLIPBOARDURILISTROOT
    808774{
     775    /** The list node. */
     776    RTLISTNODE          Node;
    809777    /** Absolute path of entry. */
    810     RTCString strPathAbs;
     778    char               *pszPathAbs;
    811779} SHAREDCLIPBOARDURILISTROOT, *PSHAREDCLIPBOARDURILISTROOT;
    812 
    813 /** List of URI list root entries. */
    814 typedef RTCList<SHAREDCLIPBOARDURILISTROOT> SharedClipboardURIListRootEntries;
    815780
    816781/**
    … …  
    866831SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(TRANSFEROPEN)
    867832SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(TRANSFERCLOSE)
    868 SHAREDCLIPBOARDPROVIDERFUNCDECL(GETROOTS, PVBOXCLIPBOARDROOTLIST *ppRootList);
     833SHAREDCLIPBOARDPROVIDERFUNCDECL(GETROOTS, PVBOXCLIPBOARDROOTLIST *ppRootList)
    869834SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTOPEN, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList)
    870 SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTCLOSE, SHAREDCLIPBOARDLISTHANDLE hList);
     835SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTCLOSE, SHAREDCLIPBOARDLISTHANDLE hList)
    871836SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTHDRREAD, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
    872837SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTHDRWRITE, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
    … …  
    883848typedef struct _SHAREDCLIPBOARDPROVIDERINTERFACE
    884849{
    885     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(TRANSFEROPEN, pfnTransferOpen);
    886     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(TRANSFERCLOSE, pfnTransferClose);
    887     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(GETROOTS, pfnGetRoots);
    888     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTOPEN, pfnListOpen);
    889     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTCLOSE, pfnListClose);
    890     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTHDRREAD, pfnListHdrRead);
    891     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTHDRWRITE, pfnListHdrWrite);
    892     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTENTRYREAD, pfnListEntryRead);
    893     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTENTRYWRITE, pfnListEntryWrite);
    894     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJOPEN, pfnObjOpen);
    895     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJCLOSE, pfnObjClose);
    896     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJREAD, pfnObjRead);
    897     SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJWRITE, pfnObjWrite);
     850    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(TRANSFEROPEN, pfnTransferOpen)
     851    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(TRANSFERCLOSE, pfnTransferClose)
     852    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(GETROOTS, pfnGetRoots)
     853    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTOPEN, pfnListOpen)
     854    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTCLOSE, pfnListClose)
     855    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTHDRREAD, pfnListHdrRead)
     856    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTHDRWRITE, pfnListHdrWrite)
     857    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTENTRYREAD, pfnListEntryRead)
     858    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTENTRYWRITE, pfnListEntryWrite)
     859    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJOPEN, pfnObjOpen)
     860    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJCLOSE, pfnObjClose)
     861    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJREAD, pfnObjRead)
     862    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJWRITE, pfnObjWrite)
    898863} SHAREDCLIPBOARDPROVIDERINTERFACE, *PSHAREDCLIPBOARDPROVIDERINTERFACE;
    899864
    … …  
    953918    void                                  *pvUser;
    954919    /** Function pointer, called when the transfer is going to be prepared. */
    955     SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERPREPARE, pfnTransferPrepare);
     920    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERPREPARE, pfnTransferPrepare)
    956921    /** Function pointer, called when the transfer has been started. */
    957     SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERSTARTED, pfnTransferStarted);
     922    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERSTARTED, pfnTransferStarted)
    958923    /** Function pointer, called when reading / writing the list header is complete. */
    959     SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(LISTHEADERCOMPLETE, pfnListHeaderComplete);
     924    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(LISTHEADERCOMPLETE, pfnListHeaderComplete)
    960925    /** Function pointer, called when reading / writing a list entry is complete. */
    961     SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(LISTENTRYCOMPLETE, pfnListEntryComplete);
     926    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(LISTENTRYCOMPLETE, pfnListEntryComplete)
    962927    /** Function pointer, called when the transfer is complete. */
    963     SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERCOMPLETE, pfnTransferComplete);
     928    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERCOMPLETE, pfnTransferComplete)
    964929    /** Function pointer, called when the transfer has been canceled. */
    965     SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERCANCELED, pfnTransferCanceled);
     930    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERCANCELED, pfnTransferCanceled)
    966931    /** Function pointer, called when transfer resulted in an unrecoverable error. */
    967     SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERERROR, pfnTransferError);
     932    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERERROR, pfnTransferError)
    968933} SHAREDCLIPBOARDURITRANSFERCALLBACKS, *PSHAREDCLIPBOARDURITRANSFERCALLBACKS;
    969934
    … …  
    1003968    /** Maximum data chunk size (in bytes) to transfer. Default is 64K. */
    1004969    uint32_t                            cbMaxChunkSize;
    1005     /** Events related to this transfer. */
    1006     SharedClipboardURITransferEventMap *pMapEvents;
     970    /** The transfer's own event source. */
     971    SHAREDCLIPBOARDEVENTSOURCE          Events;
    1007972    /** Next upcoming list handle. */
    1008973    SHAREDCLIPBOARDLISTHANDLE           uListHandleNext;
    1009     /** Map of all lists related to this transfer. */
    1010     SharedClipboardURIListMap          *pMapLists;
     974    /** List of all list handles elated to this transfer. */
     975    RTLISTANCHOR                        lstList;
     976    /** Number of root entries in list. */
     977    uint64_t                            cRoots;
    1011978    /** List of root entries of this transfer. */
    1012     SharedClipboardURIListRootEntries   lstRootEntries;
     979    RTLISTANCHOR                        lstRoots;
    1013980    /** Next upcoming object handle. */
    1014981    SHAREDCLIPBOARDOBJHANDLE            uObjHandleNext;
    1015     /** Next upcoming event ID.
    1016      *  0 is reserved for invalid event IDs. */
    1017     uint16_t                            uEventIDNext;
    1018     /** Map of all objects related to this transfer. */
    1019     SharedClipboardURIObjMap           *pMapObj;
     982    /** Map of all objects handles related to this transfer. */
     983    RTLISTANCHOR                        lstObj;
    1020984    /** The transfer's own (local) area, if any (can be NULL if not needed).
    1021985     *  The area itself has a clipboard area ID assigned.
    … …  
    10931057
    10941058int SharedClipboardURITransferPrepare(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    1095 int SharedClipboardURITransferSetData(PSHAREDCLIPBOARDURITRANSFER pTransfer, SharedClipboardURIListRootEntries *pEntries);
    10961059int SharedClipboardURITransferSetInterface(PSHAREDCLIPBOARDURITRANSFER pTransfer,
    10971060                                           PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx);
    … …  
    11011064
    11021065uint32_t SharedClipboardURILTransferRootsCount(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    1103 int SharedClipboardURILTransferRootsEntry(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uIndex, PVBOXCLIPBOARDLISTENTRY pEntry);
     1066int SharedClipboardURILTransferRootsEntry(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint64_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pEntry);
    11041067int SharedClipboardURILTransferRootsAsList(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDROOTLIST *ppRootList);
    11051068
    … …  
    11101073void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer,
    11111074                                            PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks);
    1112 
    1113 int SharedClipboardURITransferPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
    1114                                            PSHAREDCLIPBOARDURITRANSFERPAYLOAD *ppPayload);
    1115 void SharedClipboardURITransferPayloadFree(PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload);
    1116 
    1117 uint16_t SharedClipboardURITransferEventIDGenerate(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    1118 int SharedClipboardURITransferEventRegister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID);
    1119 int SharedClipboardURITransferEventUnregister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID);
    1120 int SharedClipboardURITransferEventWait(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID, RTMSINTERVAL uTimeoutMs,
    1121                                         PSHAREDCLIPBOARDURITRANSFERPAYLOAD *ppPayload);
    1122 int SharedClipboardURITransferEventSignal(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID, PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload);
    11231075
    11241076int SharedClipboardURITransferRead(PSHAREDCLIPBOARDURITRANSFER pTransfer);

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

    r80374 r80444  
    130130
    131131VBOXCLIPBOARDFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat);
    132 int VBoxClipboardWinGetFormats(PVBOXCLIPBOARDWINCTX pCtx, PVBOXCLIPBOARDFORMAT pfFormats);
     132int VBoxClipboardWinGetFormats(PVBOXCLIPBOARDWINCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats);
    133133
    134134#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST

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

    r79630 r80444  
    3131
    3232#include <iprt/cdefs.h>
     33#include <iprt/list.h>
    3334#include <iprt/types.h>
    3435
    … …  
    6061
    6162/**
     63 * Structure for keeping a generic Shared Clipboard data block.
     64 */
     65typedef struct _SHAREDCLIPBOARDDATABLOCK
     66{
     67    /** Clipboard format this data block represents. */
     68    VBOXCLIPBOARDFORMAT  uFormat;
     69    /** Pointer to actual data block. */
     70    void                *pvData;
     71    /** Size (in bytes) of actual data block. */
     72    uint32_t             cbData;
     73} SHAREDCLIPBOARDDATABLOCK, *PSHAREDCLIPBOARDDATABLOCK;
     74
     75/**
     76 * Structure for keeping a Shared Clipboard data read request.
     77 */
     78typedef struct _SHAREDCLIPBOARDDATAREQ
     79{
     80    /** In which format the data needs to be sent. */
     81    VBOXCLIPBOARDFORMAT uFmt;
     82    /** Read flags; currently unused. */
     83    uint32_t            fFlags;
     84    /** Maximum data (in byte) can be sent. */
     85    uint32_t            cbSize;
     86} SHAREDCLIPBOARDDATAREQ, *PSHAREDCLIPBOARDDATAREQ;
     87
     88/**
     89 * Structure for keeping Shared Clipboard formats specifications.
     90 */
     91typedef struct _SHAREDCLIPBOARDFORMATDATA
     92{
     93    /** Available format(s) as bit map. */
     94    VBOXCLIPBOARDFORMATS uFormats;
     95    /** Formats flags. Currently unused. */
     96    uint32_t             fFlags;
     97} SHAREDCLIPBOARDFORMATDATA, *PSHAREDCLIPBOARDFORMATDATA;
     98
     99/**
     100 * Structure for an (optional) Shared Clipboard event payload.
     101 */
     102typedef struct _SHAREDCLIPBOARDEVENTPAYLOAD
     103{
     104    /** Payload ID; currently unused. */
     105    uint32_t uID;
     106    /** Pointer to actual payload data. */
     107    void    *pvData;
     108    /** Size (in bytes) of actual payload data. */
     109    uint32_t cbData;
     110} SHAREDCLIPBOARDEVENTPAYLOAD, *PSHAREDCLIPBOARDEVENTPAYLOAD;
     111
     112/**
     113 * Structure for maintaining a Shared Clipboard event.
     114 */
     115typedef struct _SHAREDCLIPBOARDEVENT
     116{
     117    /** List node. */
     118    RTLISTNODE                   Node;
     119    /** The event's ID, for self-reference. */
     120    uint16_t                     uID;
     121    /** Event semaphore for signalling the event. */
     122    RTSEMEVENT                   hEventSem;
     123    /** Payload to this event. Optional and can be NULL. */
     124    PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     125} SHAREDCLIPBOARDEVENT, *PSHAREDCLIPBOARDEVENT;
     126
     127/**
     128 * Structure for maintaining a Shared Clipboard event source.
     129 *
     130 * Each event source maintains an own counter for events, so that
     131 * it can be used in different contexts.
     132 */
     133typedef struct _SHAREDCLIPBOARDEVENTSOURCE
     134{
     135    /** The event source' ID. */
     136    uint16_t                 uID;
     137    /** Next upcoming event ID.
     138     *  0 is reserved for invalid event IDs. */
     139    uint16_t                 uEventIDNext;
     140    /** List of events (PSHAREDCLIPBOARDEVENT). */
     141    RTLISTANCHOR             lstEvents;
     142} SHAREDCLIPBOARDEVENTSOURCE, *PSHAREDCLIPBOARDEVENTSOURCE;
     143
     144int SharedClipboardPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
     145                                PSHAREDCLIPBOARDEVENTPAYLOAD *ppPayload);
     146void SharedClipboardPayloadFree(PSHAREDCLIPBOARDEVENTPAYLOAD pPayload);
     147
     148int SharedClipboardEventSourceCreate(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID);
     149void SharedClipboardEventSourceDestroy(PSHAREDCLIPBOARDEVENTSOURCE pSource);
     150
     151uint16_t SharedClipboardEventIDGenerate(PSHAREDCLIPBOARDEVENTSOURCE pSource);
     152int SharedClipboardEventRegister(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID);
     153int SharedClipboardEventUnregister(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID);
     154int SharedClipboardEventWait(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID, RTMSINTERVAL uTimeoutMs,
     155                             PSHAREDCLIPBOARDEVENTPAYLOAD* ppPayload);
     156int SharedClipboardEventSignal(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID, PSHAREDCLIPBOARDEVENTPAYLOAD pPayload);
     157void SharedClipboardEventPayloadDetach(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID);
     158
     159/**
    62160 * Enumeration to specify the Shared Clipboard URI source type.
    63161 */

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

    r80359 r80444  
    6969 * The host messages for the guest.
    7070 */
    71 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT                   1
    72 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA              2
    73 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS         3
     71/** Asks the client to quit / terminate. */
     72#define VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT                         1
     73/** Reads (simple) data from the guest. */
     74#define VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA                    2
     75/** Reports available clipboard format from host to the guest.
     76 *  Formerly known as VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS. */
     77#define VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE                3
     78/** Reports available clipboard format from host to the guest. */
     79#define VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_READ                 4
    7480
    7581/** Initiates a new transfer (read / write) on the guest side. */
    … …  
    114120 *  Note: This is the old message which still is being used for the non-URI Shared Clipboard transfers,
    115121 *        to not break compatibility with older Guest Additions / VBox versions. */
    116 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD  1
    117 /** Sends a list of available formats to the host. */
    118 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS    2
     122#define VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD       1
     123/** Sends a list of available formats to the host.
     124 *  Formely known as VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS. */
     125#define VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_WRITE         2
    119126/** Reads data in specified format from the host. */
    120 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA         3
     127#define VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_READ              3
    121128/** Writes data in requested format to the host. */
    122 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA        4
    123 
     129#define VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE             4
     130
     131/** */
     132#define VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT                5
    124133/** Peeks at the next message, returning immediately.
    125  *  New since URI handling was implemented. */
    126 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT        5
     134 *  New since protocol v1. */
     135#define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT        6
    127136/** Peeks at the next message, waiting for one to arrive.
    128  *  New since URI handling was implemented. */
    129 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT          6
     137 *  New since protocol v1. */
     138#define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT          7
    130139/** Gets the next message, returning immediately.
    131  *  New since URI handling was implemented. */
    132 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET                7
     140 *  New since protocol v1. */
     141#define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET                8
    133142/** Sends a transfer status to the host.
    134  *  New since URI handling was implemented. */
    135 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS                 8
     143 *  New since protocol v1. */
     144#define VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS                 9
    136145/** Replies to a function from the host.
    137  *  New since URI handling was implemented. */
    138 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY                  9
     146 *  New since protocol v1. */
     147#define VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY                  10
    139148/** Reports the available root entries of a transfer.
    140  *  New since URI handling was implemented. */
    141 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ     10
     149 *  New since protocol v1. */
     150#define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ     11
    142151/** Reports the available root entries of a transfer.
    143  *  New since URI handling was implemented. */
    144 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE    11
     152 *  New since protocol v1. */
     153#define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE    12
    145154/** Reports the available root entries of a transfer.
    146  *  New since URI handling was implemented. */
    147 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ   12
     155 *  New since protocol v1. */
     156#define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ   13
    148157/** Reports the available root entries of a transfer.
    149  *  New since URI handling was implemented. */
    150 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE  13
     158 *  New since protocol v1. */
     159#define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE  14
    151160/** Opens / gets a list handle from the host.
    152  *  New since URI handling was implemented. */
    153 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN              14
     161 *  New since protocol v1. */
     162#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN              15
    154163/** Closes a list handle from the host.
    155  *  New since URI handling was implemented. */
    156 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE             15
     164 *  New since protocol v1. */
     165#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE             16
    157166/** Reads a list header from the host.
    158  *  New since URI handling was implemented. */
    159 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ          16
     167 *  New since protocol v1. */
     168#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ          17
    160169/** Writes a list header to the host.
    161  *  New since URI handling was implemented. */
    162 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE         17
    163 /** New since URI handling was implemented. */
    164 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ        18
    165 /** New since URI handling was implemented. */
    166 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE       19
    167 /** New since URI handling was implemented. */
    168 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN               20
    169 /** New since URI handling was implemented. */
    170 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE              21
    171 /** New since URI handling was implemented. */
    172 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ               22
    173 /**  New since URI handling was implemented. */
    174 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE              23
     170 *  New since protocol v1. */
     171#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE         18
     172/** New since protocol v1. */
     173#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ        19
     174/** New since protocol v1. */
     175#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE       20
     176/** New since protocol v1. */
     177#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN               21
     178/** New since protocol v1. */
     179#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE              22
     180/** New since protocol v1. */
     181#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ               23
     182/** New since protocol v1. */
     183#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE              24
    175184/** Reports cancellation of the current operation to the host.
    176  *  New since URI handling was implemented. */
    177 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL                 24
     185 *  New since protocol v1. */
     186#define VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL                 25
    178187/** Reports an error to the host.
    179  *  New since URI handling was implemented. */
    180 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR                  25
     188 *  New since protocol v1. */
     189#define VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR                  26
    181190
    182191/** The maximum default chunk size for a single data transfer. */
    183192#define VBOX_SHARED_CLIPBOARD_MAX_CHUNK_SIZE                  _64K
    184193
    185 /** Maximum number of concurrent Shared Clipboard transfers a VM can have. */
    186 #define VBOX_SHARED_CLIPBOARD_MAX_TRANSFERS                   UINT16_MAX
     194/** Maximum number of concurrent Shared Clipboard transfers a VM can have.
     195 *  Number 0 always is reserved for the client itself. */
     196#define VBOX_SHARED_CLIPBOARD_MAX_TRANSFERS                   UINT16_MAX - 1
    187197/** Maximum number of concurrent events a transfer can have. */
    188198#define VBOX_SHARED_CLIPBOARD_MAX_EVENTS                      UINT16_MAX
    189199
    190 /** Creates a context ID out of a transfer ID. */
    191 #define VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(uTransfer, uEvent) \
    192     RT_MAKE_U32(uEvent, uTransfer)
     200/**
     201 * Creates a context ID out of a source ID.
     202 *
     203 * ID 0 *always* is reserved for the client itself, whereas
     204 * IDs > 0 are being used for transfers of this client.
     205 */
     206#define VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(uID, uEvent) \
     207    RT_MAKE_U32(uEvent, uID)
    193208/** Gets the transfer ID out of a context ID. */
    194 #define VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_TRANSFER(uContextID) \
     209#define VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_SOURCE(uContextID) \
    195210    RT_HI_U16(uContextID)
    196211/** Gets the event ID out of a context ID. */
    … …  
    202217 */
    203218#pragma pack(1)
     219/**
     220 * Waits (blocking) for a new host message to arrive.
     221 * Deprecated; do not use anymore.
     222 * Kept for maintaining compatibility with older Guest Additions.
     223 */
    204224typedef struct _VBoxClipboardGetHostMsgOld
    205225{
    206226    VBGLIOCHGCMCALL hdr;
    207227
    208     /* VBOX_SHARED_CLIPBOARD_HOST_MSG_* */
    209     HGCMFunctionParameter msg;     /* OUT uint32_t */
    210 
    211     /* VBOX_SHARED_CLIPBOARD_FMT_*, depends on the 'msg'. */
     228    /** uint32_t, out: Host message type. */
     229    HGCMFunctionParameter msg;
     230    /** uint32_t, out: VBOX_SHARED_CLIPBOARD_FMT_*, depends on the 'msg'.
     231     *  r=andy This actual can have *different* meanings, depending on the host message type. */
    212232    HGCMFunctionParameter formats; /* OUT uint32_t */
    213233} VBoxClipboardGetHostMsgOld;
    … …  
    215235#define VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG_OLD 2
    216236
    217 typedef struct _VBoxClipboardReportFormatsMsg
    218 {
    219     VBGLIOCHGCMCALL hdr;
    220 
    221     /* VBOX_SHARED_CLIPBOARD_FMT_* */
    222     HGCMFunctionParameter formats; /* OUT uint32_t */
    223 } VBoxClipboardReportFormatsMsg;
    224 
    225 #define VBOX_SHARED_CLIPBOARD_CPARMS_REPORT_FORMATS 1
     237/**
     238 * Message for doing the protocol negotiation between the host
     239 * and the guest. Not available on older (VBox <= 6.0) hosts.
     240 */
     241typedef struct _VBoxClipboardConnect
     242{
     243    VBGLIOCHGCMCALL hdr;
     244
     245    /** uint32_t, out: Protocol version. */
     246    HGCMFunctionParameter uProtocolVer;
     247    /** uint32_t, out: Protocol flags, unused at the moment. */
     248    HGCMFunctionParameter uProtocolFlags;
     249    /** uint32_t, out: Maximum chunk size for data transfers. */
     250    HGCMFunctionParameter cbChunkSize;
     251    /** uint32_t, in/out: Compression type. Currently unused. */
     252    HGCMFunctionParameter enmCompression;
     253    /** uint32_t, in/out: Checksum type used for data transfer. Currently unused. */
     254    HGCMFunctionParameter enmChecksumType;
     255} VBoxClipboardConnect;
     256
     257#define VBOX_SHARED_CLIPBOARD_CPARMS_CONNECT 5
     258
     259typedef struct _VBoxClipboardFormatsMsg
     260{
     261    VBGLIOCHGCMCALL hdr;
     262
     263    /** uint32_t, in: Context ID. */
     264    HGCMFunctionParameter uContext;
     265    /** uint32_t, out:  VBOX_SHARED_CLIPBOARD_FMT_*. */
     266    HGCMFunctionParameter uFormats;
     267    /** uint32_t, in: Format flags. */
     268    HGCMFunctionParameter fFlags;
     269} VBoxClipboardFormatsMsg;
     270
     271typedef struct _VBoxClipboardReadDataReqMsg
     272{
     273    VBGLIOCHGCMCALL hdr;
     274
     275    /** uint32_t, out: Context ID. */
     276    HGCMFunctionParameter uContext;
     277    /** uint32_t, out: Requested format to read data in. */
     278    HGCMFunctionParameter uFormat;
     279    /** uint32_t, out: Maximum size (in bytes) to read. */
     280    HGCMFunctionParameter cbSize;
     281} VBoxClipboardReadDataReqMsg;
     282
     283#define VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_REQ 2
    226284
    227285typedef struct _VBoxClipboardReadDataMsg
    … …  
    229287    VBGLIOCHGCMCALL hdr;
    230288
    231     /* Requested format. */
     289    /** uint32_t, out: Requested format. */
    232290    HGCMFunctionParameter format; /* IN uint32_t */
    233 
    234     /* The data buffer. */
     291    /** ptr, out: The data buffer. */
    235292    HGCMFunctionParameter ptr;    /* IN linear pointer. */
    236 
    237     /* Size of returned data, if > ptr->cb, then no data was
    238      * actually transferred and the guest must repeat the call.
     293    /** uint32_t, out: Size of returned data, if > ptr->cb, then no data was
     294     *  actually transferred and the guest must repeat the call.
    239295     */
    240296    HGCMFunctionParameter size;   /* OUT uint32_t */
    … …  
    248304    VBGLIOCHGCMCALL hdr;
    249305
    250     /* Returned format as requested in the VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA message. */
    251     HGCMFunctionParameter format; /* IN uint32_t */
    252 
    253     /* Data.  */
    254     HGCMFunctionParameter ptr;    /* IN linear pointer. */
     306    union
     307    {
     308        struct
     309        {
     310            /** Returned format as requested in the VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA message. */
     311            HGCMFunctionParameter format; /* IN uint32_t */
     312            /** Data.  */
     313            HGCMFunctionParameter ptr;    /* IN linear pointer. */
     314        } v0;
     315        struct
     316        {
     317            /** uint32_t, out: Context ID. */
     318            HGCMFunctionParameter uContext;
     319            /** uint32_t, out: Requested format to read data in. */
     320            HGCMFunctionParameter uFormat;
     321            /** uint32_t, out: Size of data (in bytes). */
     322            HGCMFunctionParameter cbData;
     323            /** ptr, out: Actual data. */
     324            HGCMFunctionParameter pvData;
     325        } v1;
     326    };
    255327} VBoxClipboardWriteDataMsg;
    256328
    257 #define VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA 2
     329#define VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA 4
    258330
    259331typedef struct _VBoxClipboardTransferReport
    … …  
    394466    /** uint64_t, in/out: Number of total root list entries. */
    395467    HGCMFunctionParameter      cRoots;
    396     /** uint32_t, in/out: Compression type. */
    397     HGCMFunctionParameter      enmCompression;
    398     /** uint32_t, in/out: Checksum type used for data transfer. */
    399     HGCMFunctionParameter      enmChecksumType;
    400468} VBoxClipboardRootListHdrMsg;
    401469
    402 #define VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR 5
     470#define VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR 2
    403471
    404472typedef struct _VBoxClipboardRootListEntryParms
    … …  
    521589    /** uint64_t, in/out:  Number of total bytes to transfer. */
    522590    HGCMFunctionParameter        cbTotalSize;
    523     /** uint32_t, in/out: Compression type. */
    524     HGCMFunctionParameter        enmCompression;
    525     /** uint32_t, in/out: Checksum type used for data transfer. */
    526     HGCMFunctionParameter        enmChecksumType;
    527591} VBoxClipboardListHdrMsg;
    528592
    529 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR 8
     593#define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR 6
    530594
    531595typedef struct _VBoxClipboardListEntryReqParms

  • trunk/include/VBox/VBoxGuestLib.h

    r80374 r80444  
    595595    uint32_t uContextID;
    596596    /** IN: Protocol version to use. */
    597     uint32_t uProtocol;
     597    uint32_t uProtocolVer;
     598    /** IN: Protocol flags. Currently unused. */
     599    uint32_t uProtocolFlags;
    598600    /** IN: Maximum chunk size (in bytes). */
    599601    uint32_t cbChunkSize;
    … …  
    602604} VBGLR3SHCLCMDCTX, *PVBGLR3SHCLCMDCTX;
    603605
    604 #  ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    605606/**
    606607 * Enumeration specifying a Shared Clipboard event type.
    … …  
    609610{
    610611    VBGLR3CLIPBOARDEVENTTYPE_INVALID = 0,
     612    VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS,
     613    VBGLR3CLIPBOARDEVENTTYPE_READ_DATA,
     614    VBGLR3CLIPBOARDEVENTTYPE_QUIT,
    611615    VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_HDR_READ,
    612616    VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_HDR_WRITE,
    … …  
    623627} VBGLR3CLIPBOARDEVENTTYPE;
    624628
     629/**
     630 * Structure for keeping a Shared Clipboard VbglR3 event.
     631 */
    625632typedef struct _VBGLR3CLIPBOARDEVENT
    626633{
    627634    /** The event type the union contains. */
    628635    VBGLR3CLIPBOARDEVENTTYPE enmType;
     636    /** Command context bound to this event. */
     637    VBGLR3SHCLCMDCTX         cmdCtx;
    629638    union
    630639    {
    631         struct
    632         {
    633             PVBOXCLIPBOARDLISTHDR pHdr;
    634         } ListHdrRead, ListHdrWrite;
     640        /** Reports available formats from the host. */
     641        SHAREDCLIPBOARDFORMATDATA ReportFormats;
     642        /** Requests data to be read from the guest. */
     643        SHAREDCLIPBOARDDATAREQ ReadData;
    635644    } u;
    636645} VBGLR3CLIPBOARDEVENT, *PVBGLR3CLIPBOARDEVENT;
    637646typedef const PVBGLR3CLIPBOARDEVENT CPVBGLR3CLIPBOARDEVENT;
    638 #  endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    639647
    640648VBGLR3DECL(int)     VbglR3ClipboardConnect(HGCMCLIENTID *pidClient);
    … …  
    642650VBGLR3DECL(int)     VbglR3ClipboardGetHostMsgOld(HGCMCLIENTID idClient, uint32_t *pMsg, uint32_t *pfFormats);
    643651VBGLR3DECL(int)     VbglR3ClipboardReadData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb, uint32_t *pcb);
     652VBGLR3DECL(int)     VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb);
     653VBGLR3DECL(int)     VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDDATABLOCK pData);
     654VBGLR3DECL(int)     VbglR3ClipboardFormatsSend(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats);
    644655VBGLR3DECL(int)     VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats);
    645 VBGLR3DECL(int)     VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb);
    646 
    647 #  ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     656
    648657VBGLR3DECL(int)     VbglR3ClipboardConnectEx(PVBGLR3SHCLCMDCTX pCtx);
    649658VBGLR3DECL(int)     VbglR3ClipboardDisconnectEx(PVBGLR3SHCLCMDCTX pCtx);
    650 VBGLR3DECL(int)     VbglR3ClipboardEventGetNext(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer,
    651                                                 PVBGLR3CLIPBOARDEVENT *ppEvent);
     659VBGLR3DECL(int)     VbglR3ClipboardEventGetNext(PVBGLR3SHCLCMDCTX pCtx, PVBGLR3CLIPBOARDEVENT *ppEvent);
    652660VBGLR3DECL(void)    VbglR3ClipboardEventFree(PVBGLR3CLIPBOARDEVENT pEvent);
    653661
    654 VBGLR3DECL(int)     VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus);
     662VBGLR3DECL(int)     VbglR3ClipboardWriteError(HGCMCLIENTID idClient, int rcErr);
     663
     664#  ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     665VBGLR3DECL(int)     VbglR3ClipboardTransferEvent(PVBGLR3SHCLCMDCTX pCtx, uint32_t uMsg, uint32_t cParms,
     666                                                 PSHAREDCLIPBOARDURITRANSFER pTransfer);
     667VBGLR3DECL(int)     VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer,
     668                                                      SHAREDCLIPBOARDURITRANSFERSTATUS uStatus);
    655669
    656670VBGLR3DECL(int)     VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList);
    … …  
    685699VBGLR3DECL(int)     VbglR3ClipboardObjWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
    686700                                            uint32_t *pcbWritten);
    687 
    688 VBGLR3DECL(int)     VbglR3ClipboardWriteError(HGCMCLIENTID idClient, int rcErr);
    689701#  endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    690702/** @} */

  • trunk/src/VBox/Additions/WINNT/VBoxTray/Makefile.kmk

    r80324 r80444  
    5151 VBoxTray_SOURCES  += \
    5252        VBoxClipboard.cpp \
    53         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp
     53        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp \
     54        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp
    5455 ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    5556  VBoxTray_DEFS     += VBOX_WITH_SHARED_CLIPBOARD_GUEST
    … …  
    6061        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp \
    6162        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp \
    62         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp \
    6363        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp
    6464 endif

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp

    r80374 r80444  
    2727
    2828#include <iprt/asm.h>
     29#include <iprt/errcore.h>
     30#include <iprt/mem.h>
    2931#include <iprt/ldr.h>
    3032
    31 #include <iprt/errcore.h>
    3233
    3334#include <VBox/GuestHost/SharedClipboard.h>
     35#include <VBox/GuestHost/SharedClipboard-win.h>
     36#include <VBox/GuestHost/clipboard-helper.h>
    3437#include <VBox/HostServices/VBoxClipboardSvc.h> /* Temp, remove. */
    35 #include <VBox/GuestHost/SharedClipboard-win.h>
    3638#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    3739# include <VBox/GuestHost/SharedClipboard-uri.h>
    … …  
    118120    if (RT_SUCCESS(rc))
    119121    {
    120         rc = VbglR3ClipboardTransferSendStatus(&cmdCtx, SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING);
     122        rc = VbglR3ClipboardTransferSendStatus(&cmdCtx, pTransfer, SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING);
    121123        if (RT_SUCCESS(rc))
    122124        {
    … …  
    127129            {
    128130                PVBGLR3CLIPBOARDEVENT pEvent = NULL;
    129                 rc = VbglR3ClipboardEventGetNext(&cmdCtx, pTransfer, &pEvent);
     131                rc = VbglR3ClipboardEventGetNext(&cmdCtx, &pEvent);
    130132                if (RT_SUCCESS(rc))
    131133                {
    … …  
    425427               /* Clipboard was updated by another application.
    426428                * Report available formats to the host. */
    427                VBOXCLIPBOARDFORMATS fFormats;
    428                int rc = VBoxClipboardWinGetFormats(&pCtx->Win, &fFormats);
     429               SHAREDCLIPBOARDFORMATDATA Formats;
     430               int rc = VBoxClipboardWinGetFormats(&pCtx->Win, &Formats);
    429431               if (RT_SUCCESS(rc))
    430432               {
    431                    LogFunc(("WM_CLIPBOARDUPDATE: Reporting formats 0x%x\n", fFormats));
    432                    rc = VbglR3ClipboardReportFormats(pCtx->CmdCtx.uClientID, fFormats);
     433                   LogFunc(("WM_CLIPBOARDUPDATE: Reporting formats 0x%x\n", Formats.uFormats));
     434                   rc = VbglR3ClipboardFormatsSend(&pCtx->CmdCtx, &Formats);
    433435               }
    434436           }
    … …  
    452454               /* Clipboard was updated by another application. */
    453455               /* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */
    454                VBOXCLIPBOARDFORMATS fFormats;
    455                int rc = VBoxClipboardWinGetFormats(pWinCtx, &fFormats);
     456               SHAREDCLIPBOARDFORMATDATA Formats;
     457               int rc = VBoxClipboardWinGetFormats(pWinCtx, &Formats);
    456458               if (RT_SUCCESS(rc))
    457                    rc = VbglR3ClipboardReportFormats(pCtx->CmdCtx.uClientID, fFormats);
     459                   rc = VbglR3ClipboardFormatsSend(&pCtx->CmdCtx, &Formats);
    458460           }
    459461
    … …  
    641643
    642644           /* Announce available formats. Do not insert data -- will be inserted in WM_RENDERFORMAT. */
    643            VBOXCLIPBOARDFORMATS fFormats = (uint32_t)lParam;
     645           PVBGLR3CLIPBOARDEVENT pEvent = (PVBGLR3CLIPBOARDEVENT)lParam;
     646           AssertPtr(pEvent);
     647           Assert(pEvent->enmType == VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS);
     648
     649           const VBOXCLIPBOARDFORMATS fFormats =  pEvent->u.ReportFormats.uFormats;
     650
    644651           if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */
    645652           {
    … …  
    687694       {
    688695           /* Send data in the specified format to the host. */
    689            VBOXCLIPBOARDFORMAT uFormat = (uint32_t)lParam;
     696           PVBGLR3CLIPBOARDEVENT pEvent = (PVBGLR3CLIPBOARDEVENT)lParam;
     697           AssertPtr(pEvent);
     698           Assert(pEvent->enmType == VBGLR3CLIPBOARDEVENTTYPE_READ_DATA);
     699
     700           const VBOXCLIPBOARDFORMAT uFormat = (uint32_t)pEvent->u.ReadData.uFmt;
     701
    690702           HANDLE hClip = NULL;
    691703
    … …  
    703715                       if (lp != NULL)
    704716                       {
    705                            rc = VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_BITMAP,
    706                                                          lp, GlobalSize(hClip));
     717                           SHAREDCLIPBOARDDATABLOCK dataBlock = { uFormat, lp, (uint32_t)GlobalSize(hClip) };
     718
     719                           rc = VbglR3ClipboardWriteDataEx(&pEvent->cmdCtx, &dataBlock);
     720
    707721                           GlobalUnlock(hClip);
    708722                       }
    … …  
    721735                       if (uniString != NULL)
    722736                       {
    723                            rc = VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
    724                                                          uniString, (lstrlenW(uniString) + 1) * 2);
     737                           SHAREDCLIPBOARDDATABLOCK dataBlock = { uFormat, uniString, ((uint32_t)lstrlenW(uniString) + 1) * 2 };
     738
     739                           rc = VbglR3ClipboardWriteDataEx(&pEvent->cmdCtx, &dataBlock);
     740
    725741                           GlobalUnlock(hClip);
    726742                       }
    … …  
    743759                           if (lp != NULL)
    744760                           {
    745                                rc = VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_HTML,
    746                                                              lp, GlobalSize(hClip));
     761                               SHAREDCLIPBOARDDATABLOCK dataBlock = { uFormat, lp, (uint32_t)GlobalSize(hClip) };
     762
     763                               rc = VbglR3ClipboardWriteDataEx(&pEvent->cmdCtx, &dataBlock);
     764
    747765                               GlobalUnlock(hClip);
    748766                           }
    … …  
    754772                   }
    755773               }
     774#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     775               else if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
     776               {
     777                   LogFunc(("cTransfersRunning=%RU32\n", SharedClipboardURICtxGetRunningTransfers(&pCtx->URI)));
     778
     779                   int rc = VBoxClipboardWinOpen(hwnd);
     780                   if (RT_SUCCESS(rc))
     781                   {
     782                       PSHAREDCLIPBOARDURITRANSFER pTransfer;
     783                       rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE,
     784                                                             SHAREDCLIPBOARDSOURCE_LOCAL,
     785                                                             &pTransfer);
     786                       if (RT_SUCCESS(rc))
     787                       {
     788                           rc = SharedClipboardURICtxTransferAdd(&pCtx->URI, pTransfer);
     789                           if (RT_SUCCESS(rc))
     790                           {
     791                               /* The data data in CF_HDROP format, as the files are locally present and don't need to be
     792                                * presented as a IDataObject or IStream. */
     793                               HANDLE hClip = hClip = GetClipboardData(CF_HDROP);
     794                               if (hClip)
     795                               {
     796                                   HDROP hDrop = (HDROP)GlobalLock(hClip);
     797                                   if (hDrop)
     798                                   {
     799                                       char    *papszList;
     800                                       uint32_t cbList;
     801                                       rc = VBoxClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList);
     802
     803                                       GlobalUnlock(hClip);
     804
     805                                       if (RT_SUCCESS(rc))
     806                                       {
     807                                           rc = SharedClipboardURILTransferSetRoots(pTransfer,
     808                                                                                    papszList, cbList + 1 /* Include termination */);
     809                                           if (RT_SUCCESS(rc))
     810                                           {
     811                                               PVBOXCLIPBOARDURIWRITETHREADCTX pThreadCtx
     812                                                   = (PVBOXCLIPBOARDURIWRITETHREADCTX)RTMemAllocZ(sizeof(VBOXCLIPBOARDURIWRITETHREADCTX));
     813                                               if (pThreadCtx)
     814                                               {
     815                                                   pThreadCtx->pClipboardCtx = pCtx;
     816                                                   pThreadCtx->pTransfer     = pTransfer;
     817
     818                                                   rc = SharedClipboardURITransferPrepare(pTransfer);
     819                                                   if (RT_SUCCESS(rc))
     820                                                   {
     821                                                       rc = SharedClipboardURITransferRun(pTransfer, vboxClipboardURIWriteThread,
     822                                                                                          pThreadCtx /* pvUser */);
     823                                                       /* pThreadCtx now is owned by vboxClipboardURIWriteThread(). */
     824                                                   }
     825                                               }
     826                                               else
     827                                                   rc = VERR_NO_MEMORY;
     828                                           }
     829
     830                                           if (papszList)
     831                                               RTStrFree(papszList);
     832                                       }
     833                                   }
     834                                   else
     835                                   {
     836                                       hClip = NULL;
     837                                   }
     838                               }
     839                           }
     840                       }
     841
     842                       VBoxClipboardWinClose();
     843                   }
     844
     845                   if (RT_FAILURE(rc))
     846                       LogFunc(("Failed with rc=%Rrc\n", rc));
     847               }
     848#endif
    756849
    757850               if (hClip == NULL)
    … …  
    771864       }
    772865
    773 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     866#if 0
    774867       /* The host wants to read URI data. */
    775868       case VBOX_CLIPBOARD_WM_URI_START_READ:
    … …  
    10551148        /* ignore rc */ VBoxClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
    10561149
    1057         rc = VbglR3ClipboardConnect(&pCtx->CmdCtx.uClientID);
     1150        rc = VbglR3ClipboardConnectEx(&pCtx->CmdCtx);
    10581151        if (RT_SUCCESS(rc))
    10591152        {
    1060             pCtx->CmdCtx.uProtocol = 0;
    1061 
    10621153            rc = vboxClipboardCreateWindow(pCtx);
    10631154            if (RT_SUCCESS(rc))
    … …  
    10711162            else
    10721163            {
    1073                 VbglR3ClipboardDisconnect(pCtx->CmdCtx.uClientID);
     1164                VbglR3ClipboardDisconnectEx(&pCtx->CmdCtx);
    10741165            }
    10751166        }
    … …  
    10981189    int rc;
    10991190
     1191    LogFlowFunc(("Using protocol %RU32\n", pCtx->CmdCtx.uProtocolVer));
     1192
     1193    uint32_t uMsg;
     1194    uint32_t uFormats;
     1195
    11001196    /* The thread waits for incoming messages from the host. */
    11011197    for (;;)
    11021198    {
    1103         LogFlowFunc(("Waiting for host message ...\n"));
    1104 
    1105         uint32_t u32Msg;
    1106         uint32_t u32Formats;
    1107         rc = VbglR3ClipboardGetHostMsgOld(pCtx->CmdCtx.uClientID, &u32Msg, &u32Formats);
     1199        PVBGLR3CLIPBOARDEVENT pEvent = NULL;
     1200
     1201        LogFlowFunc(("Waiting for host message (protocol v%RU32) ...\n", pCtx->CmdCtx.uProtocolVer));
     1202
     1203        if (pCtx->CmdCtx.uProtocolVer == 0) /* Legacy protocol */
     1204        {
     1205            rc = VbglR3ClipboardGetHostMsgOld(pCtx->CmdCtx.uClientID, &uMsg, &uFormats);
     1206            if (RT_FAILURE(rc))
     1207            {
     1208                if (rc == VERR_INTERRUPTED)
     1209                    break;
     1210
     1211                LogFunc(("Error getting host message, rc=%Rrc\n", rc));
     1212            }
     1213            else
     1214            {
     1215                PVBGLR3CLIPBOARDEVENT pEvent = (PVBGLR3CLIPBOARDEVENT)RTMemAllocZ(sizeof(VBGLR3CLIPBOARDEVENT));
     1216                if (!pEvent)
     1217                {
     1218                    rc = VERR_NO_MEMORY;
     1219                    break;
     1220                }
     1221
     1222                switch (uMsg)
     1223                {
     1224                    case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE:
     1225                    {
     1226                        pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS;
     1227                        pEvent->u.ReportFormats.uFormats = uFormats;
     1228                        break;
     1229                    }
     1230
     1231                    case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
     1232                    {
     1233                        pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_READ_DATA;
     1234                        pEvent->u.ReadData.uFmt = uFormats;
     1235                        break;
     1236                    }
     1237
     1238                    default:
     1239                        rc = VERR_NOT_SUPPORTED;
     1240                        break;
     1241                }
     1242            }
     1243        }
     1244        else /* Protocol >= v1. */
     1245        {
     1246            rc = VbglR3ClipboardEventGetNext(&pCtx->CmdCtx, &pEvent);
     1247        }
     1248
    11081249        if (RT_FAILURE(rc))
    11091250        {
    1110             if (rc == VERR_INTERRUPTED)
    1111                 break;
    1112 
    1113             LogFunc(("Error getting host message, rc=%Rrc\n", rc));
    1114 
    11151251            if (*pfShutdown)
    11161252                break;
    … …  
    11221258        else
    11231259        {
    1124             LogFlowFunc(("u32Msg=%RU32, u32Formats=0x%x\n", u32Msg, u32Formats));
    1125             switch (u32Msg)
     1260            AssertPtr(pEvent);
     1261            LogFlowFunc(("Event uType=%RU32\n", pEvent->enmType));
     1262
     1263            switch (pEvent->enmType)
    11261264            {
    1127                case VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS:
    1128                {
    1129                    LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS\n"));
    1130 
     1265               case VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS:
     1266               {
    11311267                   /* The host has announced available clipboard formats.
    11321268                    * Forward the information to the window, so it can later
    11331269                    * respond to WM_RENDERFORMAT message. */
    1134                    ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS, 0, u32Formats);
     1270                   ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS,
     1271                                 0 /* wParam */, (LPARAM)pEvent /* lParam */);
    11351272                   break;
    11361273               }
    11371274
    1138                case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
    1139                {
    1140                    LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA\n"));
    1141 
     1275               case VBGLR3CLIPBOARDEVENTTYPE_READ_DATA:
     1276               {
    11421277                   /* The host needs data in the specified format. */
    1143                    ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_READ_DATA, 0, u32Formats);
     1278                   ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_READ_DATA,
     1279                                 0 /* wParam */, (LPARAM)pEvent /* lParam */);
    11441280                   break;
    11451281               }
    1146 
    1147 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     1282#if 0
    11481283               case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START:
    11491284               {
    1150                    LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START\n"));
    1151 
    11521285                   const UINT uMsg = u32Formats == 0 ?
    11531286                                     VBOX_CLIPBOARD_WM_URI_START_READ : VBOX_CLIPBOARD_WM_URI_START_WRITE;
    … …  
    11571290               }
    11581291#endif
    1159                case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
    1160                {
    1161                    LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT\n"));
    1162 
     1292               case VBGLR3CLIPBOARDEVENTTYPE_QUIT:
     1293               {
    11631294                   /* The host is terminating. */
    11641295                   LogRel(("Clipboard: Terminating ...\n"));
    … …  
    11691300               default:
    11701301               {
    1171                    LogFlowFunc(("Unsupported message from host, message=%RU32\n", u32Msg));
    1172 
    11731302                   /* Wait a bit before retrying. */
    11741303                   RTThreadSleep(1000);
    … …  
    11761305               }
    11771306            }
     1307
     1308            if (RT_FAILURE(rc))
     1309                VbglR3ClipboardEventFree(pEvent);
    11781310        }
    11791311

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

    r80374 r80444  
    5454
    5555/**
    56  * Connects to the Shared Clipboard service.
     56 * Connects to the Shared Clipboard service, legacy version, do not use anymore.
    5757 *
    5858 * @returns VBox status code
    … …  
    8282    if (RT_SUCCESS(rc))
    8383    {
    84         pCtx->uProtocol   = 0;    /** @todo Makke this dynamic. */
    85         pCtx->cbChunkSize = _64K; /** @todo Makke this dynamic. */
     84        VBoxClipboardConnect Msg;
     85        RT_ZERO(Msg);
     86
     87        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     88                           VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT, VBOX_SHARED_CLIPBOARD_CPARMS_CONNECT);
     89
     90        VbglHGCMParmUInt32Set(&Msg.uProtocolVer, 0);
     91        VbglHGCMParmUInt32Set(&Msg.uProtocolFlags, 0);
     92        VbglHGCMParmUInt32Set(&Msg.cbChunkSize, 0);
     93        VbglHGCMParmUInt32Set(&Msg.enmCompression, 0);
     94        VbglHGCMParmUInt32Set(&Msg.enmChecksumType, 0);
     95
     96        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     97        if (RT_SUCCESS(rc))
     98        {
     99            rc = VbglHGCMParmUInt32Get(&Msg.uProtocolVer, &pCtx->uProtocolVer);
     100            if (RT_SUCCESS(rc))
     101                rc = VbglHGCMParmUInt32Get(&Msg.uProtocolFlags, &pCtx->uProtocolFlags);
     102            if (RT_SUCCESS(rc))
     103                rc = VbglHGCMParmUInt32Get(&Msg.cbChunkSize, &pCtx->cbChunkSize);
     104
     105            /** @todo Add / handle checksum + compression type. */
     106        }
     107        else
     108        {
     109            /* If the above call fails, make sure to use some sane defaults for
     110             * the old (legacy) protocol. */
     111            pCtx->uProtocolVer   = 0;
     112            pCtx->uProtocolFlags = 0;
     113            pCtx->cbChunkSize    = _64K;
     114
     115            rc = VINF_SUCCESS; /* Failing above is not fatal. */
     116        }
     117
     118        LogFlowFunc(("uProtocolVer=%RU32, cbChunkSize=%RU32\n", pCtx->uProtocolVer, pCtx->cbChunkSize));
    86119    }
    87120
    … …  
    92125
    93126/**
    94  * Disconnects from the Shared Clipboard service.
     127 * Disconnects from the Shared Clipboard service, legacy version, do not use anymore.
    95128 *
    96129 * @returns VBox status code.
    … …  
    122155
    123156
     157VBGLR3DECL(int) VbglR3ClipboardFormatsWriteRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats)
     158{
     159    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
     160    AssertPtrReturn(pFormats, VERR_INVALID_POINTER);
     161
     162    VBoxClipboardFormatsMsg Msg;
     163    RT_ZERO(Msg);
     164
     165    if (pCtx->uProtocolVer >= 1)
     166    {
     167        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     168                           VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, 3);
     169
     170        Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE);
     171        Msg.uFormats.SetUInt32(0);
     172        Msg.fFlags.SetUInt32(0);
     173    }
     174
     175    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     176    if (RT_SUCCESS(rc))
     177    {
     178        rc = Msg.uContext.GetUInt32(&pCtx->uContextID);
     179        if (RT_SUCCESS(rc))
     180            rc = Msg.uFormats.GetUInt32(&pFormats->uFormats);
     181        if (RT_SUCCESS(rc))
     182            rc = Msg.fFlags.GetUInt32(&pFormats->fFlags);
     183    }
     184
     185    LogFlowFuncLeaveRC(rc);
     186    return rc;
     187}
     188
     189
     190VBGLR3DECL(int) VbglR3ClipboardReadDataRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDDATAREQ pDataReq)
     191{
     192    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
     193    AssertPtrReturn(pDataReq, VERR_INVALID_POINTER);
     194
     195    VBoxClipboardReadDataReqMsg Msg;
     196
     197    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     198                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
     199
     200    Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
     201    Msg.uFormat.SetUInt32(0);
     202    Msg.cbSize.SetUInt32(0);
     203
     204    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     205    if (RT_SUCCESS(rc))
     206    {
     207        rc = Msg.uContext.GetUInt32(&pCtx->uContextID);
     208        if (RT_SUCCESS(rc))
     209            rc = Msg.uFormat.GetUInt32(&pDataReq->uFmt);
     210        if (RT_SUCCESS(rc))
     211            rc = Msg.cbSize.GetUInt32(&pDataReq->cbSize);
     212    }
     213
     214    LogFlowFuncLeaveRC(rc);
     215    return rc;
     216}
     217
     218
    124219/**
    125  * Get a host message, old version.
     220 * Get a host message, legacy version (protocol v0). Do not use anymore.
    126221 *
    127222 * Note: This is the old message which still is being used for the non-URI Shared Clipboard transfers,
    … …  
    179274    VBoxClipboardReadDataMsg Msg;
    180275
    181     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA, VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
     276    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_READ, VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
    182277    VbglHGCMParmUInt32Set(&Msg.format, fFormat);
    183278    VbglHGCMParmPtrSet(&Msg.ptr, pv, cb);
    … …  
    201296}
    202297
    203 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    204 #if 0
    205 static int vbglR3ClipboardPeekMsg(HGCMCLIENTID idClient, uint32_t *puMsg, uint32_t *pcParms, bool fWait)
    206 {
    207     AssertPtrReturn(puMsg,   VERR_INVALID_POINTER);
    208     AssertPtrReturn(pcParms, VERR_INVALID_POINTER);
    209 
    210     VBoxClipboardPeekMsg Msg;
    211     RT_ZERO(Msg);
    212 
    213     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    214                        VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG, VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG);
    215 
    216     Msg.uMsg.SetUInt32(0);
    217     Msg.cParms.SetUInt32(0);
    218     Msg.fBlock.SetUInt32(fWait ? 1 : 0);
    219 
    220     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    221     if (RT_SUCCESS(rc))
    222     {
    223         rc = Msg.uMsg.GetUInt32(puMsg);
    224         if (RT_SUCCESS(rc))
    225             rc = Msg.cParms.GetUInt32(pcParms);
    226     }
    227 
    228     LogFlowFuncLeaveRC(rc);
    229     return rc;
    230 }
    231 #else
    232298/**
    233299 * Peeks at the next host message, waiting for one to turn up.
    … …  
    264330    VbglHGCMParmUInt32Set(&Msg.cParameters, 0);
    265331    rc = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg));
    266     LogRel2(("VbglR3GuestCtrlMsgPeekWait -> %Rrc\n", rc));
     332    LogFlowFunc(("VbglR3HGCMCall -> %Rrc\n", rc));
    267333    if (RT_SUCCESS(rc))
    268334    {
    … …  
    297363    return rc;
    298364}
    299 #endif
    300 
    301 VBGLR3DECL(int) VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus)
    302 {
    303     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     365
     366#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     367VBGLR3DECL(int) VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx,
     368                                                  PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus)
     369{
     370    AssertPtrReturn(pCtx,      VERR_INVALID_POINTER);
     371    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    304372
    305373    VBoxClipboardStatusMsg Msg;
    … …  
    309377                       VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS, VBOX_SHARED_CLIPBOARD_CPARMS_STATUS);
    310378
    311     Msg.uContext.SetUInt32(pCtx->uContextID);
     379    Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pTransfer->State.uID, 0 /* Event, ignored */));
    312380    Msg.uStatus.SetUInt32(uStatus);
    313381    Msg.cbPayload.SetUInt32(0);
    … …  
    332400
    333401    Msg.ReqParms.uContext.SetUInt32(pCtx->uContextID);
    334     Msg.ReqParms.fRoots.SetUInt32(pRootListHdr->fRoots);
     402    Msg.ReqParms.fRoots.SetUInt32(0);
    335403
    336404    Msg.cRoots.SetUInt32(0);
    337     Msg.enmCompression.SetUInt32(0);  /** @todo Not implemented yet. */
    338     Msg.enmChecksumType.SetUInt32(0); /** @todo Not implemented yet. */
    339405
    340406    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    … …  
    375441        if (RT_SUCCESS(rc))
    376442        {
    377             uint32_t cbInfo;
     443            uint32_t cbInfo = 0;
    378444            rc = Msg.cbInfo.GetUInt32(&cbInfo); AssertRC(rc);
    379445            if (pRootListEntry->cbInfo != cbInfo)
    … …  
    476542
    477543    Msg.cRoots.SetUInt32(pRootListHdr->cRoots);
    478     Msg.enmCompression.SetUInt32(0);  /** @todo Not implemented yet. */
    479     Msg.enmChecksumType.SetUInt32(0); /** @todo Not implemented yet. */
    480544
    481545    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    … …  
    515579}
    516580
    517 VBGLR3DECL(int) VbglR3ClipboardRootListEntryReadReply(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PVBOXCLIPBOARDLISTENTRY pEntry)
     581VBGLR3DECL(int) VbglR3ClipboardRootListEntryReadReply(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pEntry)
    518582{
    519583    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
    … …  
    619683    Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */
    620684    Msg.cbPayload.SetUInt32(0);
    621     Msg.pvPayload.SetPtr(0, NULL);
     685    Msg.pvPayload.SetPtr(NULL, 0);
    622686
    623687    Msg.u.ListOpen.uHandle.SetUInt64(hList);
    … …  
    669733    Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */
    670734    Msg.cbPayload.SetUInt32(0);
    671     Msg.pvPayload.SetPtr(0, NULL);
     735    Msg.pvPayload.SetPtr(NULL, 0);
    672736
    673737    Msg.u.ListOpen.uHandle.SetUInt64(hList);
    … …  
    719783    Msg.cTotalObjects.SetUInt64(0);
    720784    Msg.cbTotalSize.SetUInt64(0);
    721     Msg.enmCompression.SetUInt32(0);
    722     Msg.enmChecksumType.SetUInt32(0);
    723785
    724786    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    … …  
    730792        if (RT_SUCCESS(rc))
    731793            rc = Msg.cbTotalSize.GetUInt64(&pListHdr->cbTotalSize);
    732         if (RT_SUCCESS(rc))
    733             rc = Msg.enmCompression.GetUInt32(&pListHdr->enmCompression);
    734         if (RT_SUCCESS(rc))
    735             rc = Msg.enmChecksumType.GetUInt32(&pListHdr->enmChecksumType);
    736794    }
    737795
    … …  
    790848    Msg.cTotalObjects.SetUInt64(pListHdr->cTotalObjects);
    791849    Msg.cbTotalSize.SetUInt64(pListHdr->cbTotalSize);
    792     Msg.enmCompression.SetUInt32(pListHdr->enmCompression);
    793     Msg.enmChecksumType.SetUInt32(pListHdr->enmChecksumType);
    794850
    795851    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    … …  
    930986    Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */
    931987    Msg.cbPayload.SetUInt32(0);
    932     Msg.pvPayload.SetPtr(0, NULL);
     988    Msg.pvPayload.SetPtr(NULL, 0);
    933989
    934990    Msg.u.ObjOpen.uHandle.SetUInt64(hObj);
    … …  
    10091065    Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */
    10101066    Msg.cbPayload.SetUInt32(0);
    1011     Msg.pvPayload.SetPtr(0, NULL);
     1067    Msg.pvPayload.SetPtr(NULL, 0);
    10121068
    10131069    Msg.u.ObjClose.uHandle.SetUInt64(hObj);
    … …  
    11441200}
    11451201
    1146 VBGLR3DECL(int) VbglR3ClipboardEventGetNext(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer,
    1147                                             PVBGLR3CLIPBOARDEVENT *ppEvent)
     1202VBGLR3DECL(int) VbglR3ClipboardTransferEvent(PVBGLR3SHCLCMDCTX pCtx, uint32_t uMsg, uint32_t cParms,
     1203                                             PSHAREDCLIPBOARDURITRANSFER pTransfer)
     1204{
     1205    RT_NOREF(cParms);
     1206
     1207    LogFunc(("Handling uMsg=%RU32 (%s), cParms=%RU32\n", uMsg, VBoxClipboardHostMsgToStr(uMsg), cParms));
     1208
     1209    int rc;
     1210
     1211    switch (uMsg)
     1212    {
     1213        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ:
     1214        {
     1215            uint32_t fRoots;
     1216            rc = VbglR3ClipboardRootListHdrReadReq(pCtx, &fRoots);
     1217
     1218            /** @todo Validate / handle fRoots. */
     1219
     1220            if (RT_SUCCESS(rc))
     1221            {
     1222                VBOXCLIPBOARDROOTLISTHDR rootListHdr;
     1223                RT_ZERO(rootListHdr);
     1224
     1225                rootListHdr.cRoots = SharedClipboardURILTransferRootsCount(pTransfer);
     1226
     1227                LogFlowFunc(("cRoots=%RU32\n", rootListHdr.cRoots));
     1228
     1229                rc = VbglR3ClipboardRootListHdrReadReply(pCtx, &rootListHdr);
     1230            }
     1231            break;
     1232        }
     1233
     1234        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ:
     1235        {
     1236            uint32_t uIndex;
     1237            uint32_t fInfo;
     1238            rc = VbglR3ClipboardRootListEntryReadReq(pCtx, &uIndex, &fInfo);
     1239            if (RT_SUCCESS(rc))
     1240            {
     1241                VBOXCLIPBOARDROOTLISTENTRY rootListEntry;
     1242                rc = SharedClipboardURILTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
     1243                if (RT_SUCCESS(rc))
     1244                    rc = VbglR3ClipboardRootListEntryReadReply(pCtx, uIndex, &rootListEntry);
     1245            }
     1246            break;
     1247        }
     1248
     1249        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN:
     1250        {
     1251            VBOXCLIPBOARDLISTOPENPARMS openParmsList;
     1252            rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
     1253            if (RT_SUCCESS(rc))
     1254            {
     1255                rc = VbglR3ClipboardListOpenRecv(pCtx, &openParmsList);
     1256                if (RT_SUCCESS(rc))
     1257                {
     1258                    LogFlowFunc(("pszPath=%s\n", openParmsList.pszPath));
     1259
     1260                    SHAREDCLIPBOARDLISTHANDLE hList = SHAREDCLIPBOARDLISTHANDLE_INVALID;
     1261                    rc = SharedClipboardURITransferListOpen(pTransfer, &openParmsList, &hList);
     1262
     1263                    /* Reply in any case. */
     1264                    int rc2 = VbglR3ClipboardListOpenReply(pCtx, rc, hList);
     1265                    AssertRC(rc2);
     1266                }
     1267
     1268                SharedClipboardURIListOpenParmsDestroy(&openParmsList);
     1269            }
     1270
     1271            break;
     1272        }
     1273
     1274        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE:
     1275        {
     1276            SHAREDCLIPBOARDLISTHANDLE hList;
     1277            rc = VbglR3ClipboardListCloseRecv(pCtx, &hList);
     1278            if (RT_SUCCESS(rc))
     1279            {
     1280                rc = SharedClipboardURITransferListClose(pTransfer, hList);
     1281
     1282                /* Reply in any case. */
     1283                int rc2 = VbglR3ClipboardListCloseReply(pCtx, rc, hList);
     1284                AssertRC(rc2);
     1285            }
     1286
     1287            break;
     1288        }
     1289
     1290        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ:
     1291        {
     1292            /** @todo Handle filter + list features. */
     1293
     1294            SHAREDCLIPBOARDLISTHANDLE hList  = SHAREDCLIPBOARDLISTHANDLE_INVALID;
     1295            uint32_t                  fFlags = 0;
     1296            rc = VbglR3ClipboardListHdrReadRecvReq(pCtx, &hList, &fFlags);
     1297            if (RT_SUCCESS(rc))
     1298            {
     1299                VBOXCLIPBOARDLISTHDR hdrList;
     1300                rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
     1301                if (RT_SUCCESS(rc))
     1302                {
     1303                    rc = VbglR3ClipboardListHdrWrite(pCtx, hList, &hdrList);
     1304
     1305                    SharedClipboardURIListHdrDestroy(&hdrList);
     1306                }
     1307            }
     1308
     1309            break;
     1310        }
     1311
     1312    #if 0
     1313        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE:
     1314        {
     1315            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE\n"));
     1316
     1317            VBOXCLIPBOARDLISTHDR hdrList;
     1318            rc = SharedClipboardURIListHdrInit(&hdrList);
     1319            if (RT_SUCCESS(rc))
     1320            {
     1321                rc = VBglR3ClipboardListHdrRecv(pCtx, )
     1322            }
     1323            break;
     1324        }
     1325    #endif
     1326
     1327        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ:
     1328        {
     1329            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ\n"));
     1330
     1331            VBOXCLIPBOARDLISTENTRY entryList;
     1332            rc = SharedClipboardURIListEntryInit(&entryList);
     1333            if (RT_SUCCESS(rc))
     1334            {
     1335                SHAREDCLIPBOARDLISTHANDLE hList;
     1336                uint32_t                  fInfo;
     1337                rc = VbglR3ClipboardListEntryReadRecvReq(pCtx, &hList, &fInfo);
     1338                if (RT_SUCCESS(rc))
     1339                {
     1340                    rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
     1341                    if (RT_SUCCESS(rc))
     1342                    {
     1343                        PSHAREDCLIPBOARDFSOBJINFO pObjInfo = (PSHAREDCLIPBOARDFSOBJINFO)entryList.pvInfo;
     1344                        Assert(entryList.cbInfo == sizeof(SHAREDCLIPBOARDFSOBJINFO));
     1345
     1346                        RT_NOREF(pObjInfo);
     1347
     1348                        LogFlowFunc(("\t%s (%RU64 bytes)\n", entryList.pszName, pObjInfo->cbObject));
     1349
     1350                        rc = VbglR3ClipboardListEntryWrite(pCtx, hList, &entryList);
     1351                    }
     1352                }
     1353
     1354                SharedClipboardURIListEntryDestroy(&entryList);
     1355            }
     1356
     1357            break;
     1358        }
     1359
     1360    #if 0
     1361        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE:
     1362        {
     1363            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE\n"));
     1364            pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_ENTRY_WRITE;
     1365            break;
     1366        }
     1367    #endif
     1368
     1369        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN:
     1370        {
     1371            VBOXCLIPBOARDOBJOPENCREATEPARMS openParms;
     1372            rc = SharedClipboardURIObjectOpenParmsInit(&openParms);
     1373            if (RT_SUCCESS(rc))
     1374            {
     1375                rc = VbglR3ClipboardObjOpenRecv(pCtx, &openParms);
     1376                if (RT_SUCCESS(rc))
     1377                {
     1378                    SHAREDCLIPBOARDOBJHANDLE hObj;
     1379                    rc = SharedClipboardURIObjectOpen(pTransfer, &openParms, &hObj);
     1380
     1381                    /* Reply in any case. */
     1382                    int rc2 = VbglR3ClipboardObjOpenReply(pCtx, rc, hObj);
     1383                    AssertRC(rc2);
     1384                }
     1385
     1386                SharedClipboardURIObjectOpenParmsDestroy(&openParms);
     1387            }
     1388
     1389            break;
     1390        }
     1391
     1392        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE:
     1393        {
     1394            SHAREDCLIPBOARDOBJHANDLE hObj;
     1395            rc = VbglR3ClipboardObjCloseRecv(pCtx, &hObj);
     1396            if (RT_SUCCESS(rc))
     1397            {
     1398                rc = SharedClipboardURIObjectClose(pTransfer, hObj);
     1399
     1400                /* Reply in any case. */
     1401                int rc2 = VbglR3ClipboardObjCloseReply(pCtx, rc, hObj);
     1402                AssertRC(rc2);
     1403            }
     1404
     1405            break;
     1406        }
     1407
     1408        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ:
     1409        {
     1410            SHAREDCLIPBOARDOBJHANDLE hObj;
     1411            uint32_t cbBuf;
     1412            uint32_t fFlags;
     1413            rc = VbglR3ClipboardObjReadRecv(pCtx, &hObj, &cbBuf, &fFlags);
     1414            if (RT_SUCCESS(rc))
     1415            {
     1416                AssertBreakStmt(pCtx->cbChunkSize, rc = VERR_INVALID_PARAMETER);
     1417
     1418                const uint32_t cbToRead = RT_MIN(cbBuf, pCtx->cbChunkSize);
     1419
     1420                LogFlowFunc(("hObj=%RU64, cbBuf=%RU32, fFlags=0x%x -> cbChunkSize=%RU32, cbToRead=%RU32\n",
     1421                             hObj, cbBuf, fFlags, pCtx->cbChunkSize, cbToRead));
     1422
     1423                void *pvBuf = RTMemAlloc(cbToRead);
     1424                if (pvBuf)
     1425                {
     1426                    uint32_t cbRead;
     1427                    rc = SharedClipboardURIObjectRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, fFlags);
     1428                    if (RT_SUCCESS(rc))
     1429                        rc = VbglR3ClipboardObjWrite(pCtx, hObj, pvBuf, cbRead, NULL /* pcbWritten */);
     1430
     1431                    RTMemFree(pvBuf);
     1432                }
     1433                else
     1434                    rc = VERR_NO_MEMORY;
     1435            }
     1436
     1437            break;
     1438        }
     1439
     1440    #if 0
     1441        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE:
     1442        {
     1443            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE\n"));
     1444            break;
     1445        }
     1446    #endif
     1447
     1448        default:
     1449            rc = VERR_NOT_SUPPORTED;
     1450            break;
     1451    }
     1452
     1453    LogFlowFuncLeaveRC(rc);
     1454    return rc;
     1455}
     1456#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
     1457
     1458VBGLR3DECL(int) VbglR3ClipboardEventGetNext(PVBGLR3SHCLCMDCTX pCtx, PVBGLR3CLIPBOARDEVENT *ppEvent)
    11481459{
    11491460    AssertPtrReturn(pCtx,      VERR_INVALID_POINTER);
    1150     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    11511461    AssertPtrReturn(ppEvent,   VERR_INVALID_POINTER);
    11521462
    … …  
    11551465        return VERR_NO_MEMORY;
    11561466
     1467    pEvent->cmdCtx = *pCtx; /* Use the handed-in context as the base. */
     1468
    11571469    uint32_t uMsg   = 0;
    11581470    uint32_t cParms = 0;
    1159     int rc = vbglR3ClipboardMsgPeekWait(pCtx, &uMsg, &cParms, NULL /* pidRestoreCheck */);
     1471    int rc = vbglR3ClipboardMsgPeekWait(&pEvent->cmdCtx, &uMsg, &cParms, NULL /* pidRestoreCheck */);
    11601472    if (RT_SUCCESS(rc))
    11611473    {
    … …  
    11651477        switch (uMsg)
    11661478        {
    1167 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1168             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ:
     1479            case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE:
    11691480            {
    1170                 uint32_t fRoots;
    1171                 rc = VbglR3ClipboardRootListHdrReadReq(pCtx, &fRoots);
    1172 
    1173                 /** @todo Validate / handle fRoots. */
    1174 
     1481                rc = VbglR3ClipboardFormatsWriteRecv(&pEvent->cmdCtx, &pEvent->u.ReportFormats);
    11751482                if (RT_SUCCESS(rc))
    1176                 {
    1177                     VBOXCLIPBOARDROOTLISTHDR rootListHdr;
    1178                     RT_ZERO(rootListHdr);
    1179 
    1180                     rootListHdr.cRoots = SharedClipboardURILTransferRootsCount(pTransfer);
    1181 
    1182                     LogFlowFunc(("cRoots=%RU32\n", rootListHdr.cRoots));
    1183 
    1184                     rc = VbglR3ClipboardRootListHdrReadReply(pCtx, &rootListHdr);
    1185                 }
     1483                    pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS;
    11861484                break;
    11871485            }
    11881486
    1189             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ:
     1487            case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
    11901488            {
    1191                 uint32_t uIndex;
    1192                 uint32_t fInfo;
    1193                 rc = VbglR3ClipboardRootListEntryReadReq(pCtx, &uIndex, &fInfo);
     1489                rc = VbglR3ClipboardReadDataRecv(&pEvent->cmdCtx, &pEvent->u.ReadData);
    11941490                if (RT_SUCCESS(rc))
    1195                 {
    1196                     VBOXCLIPBOARDLISTENTRY rootListEntry;
    1197                     rc = SharedClipboardURILTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
    1198                     if (RT_SUCCESS(rc))
    1199                         rc = VbglR3ClipboardRootListEntryReadReply(pCtx, uIndex, &rootListEntry);
    1200                 }
     1491                    pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_READ_DATA;
    12011492                break;
    12021493            }
    12031494
    1204             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN:
     1495            default:
    12051496            {
    1206                 VBOXCLIPBOARDLISTOPENPARMS openParmsList;
    1207                 rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
    1208                 if (RT_SUCCESS(rc))
    1209                 {
    1210                     rc = VbglR3ClipboardListOpenRecv(pCtx, &openParmsList);
    1211                     if (RT_SUCCESS(rc))
    1212                     {
    1213                         LogFlowFunc(("pszPath=%s\n", openParmsList.pszPath));
    1214 
    1215                         SHAREDCLIPBOARDLISTHANDLE hList = SHAREDCLIPBOARDLISTHANDLE_INVALID;
    1216                         rc = SharedClipboardURITransferListOpen(pTransfer, &openParmsList, &hList);
    1217 
    1218                         /* Reply in any case. */
    1219                         int rc2 = VbglR3ClipboardListOpenReply(pCtx, rc, hList);
    1220                         AssertRC(rc2);
    1221                     }
    1222 
    1223                     SharedClipboardURIListOpenParmsDestroy(&openParmsList);
    1224                 }
    1225 
     1497#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     1498                rc = VbglR3ClipboardTransferEvent(&pEvent->cmdCtx, uMsg, cParms, NULL /* pTransfer */ ); /**** @todo FIX !!! */
     1499#endif
     1500                rc = VERR_NOT_SUPPORTED;
    12261501                break;
    12271502            }
    1228 
    1229             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE:
    1230             {
    1231                 SHAREDCLIPBOARDLISTHANDLE hList;
    1232                 rc = VbglR3ClipboardListCloseRecv(pCtx, &hList);
    1233                 if (RT_SUCCESS(rc))
    1234                 {
    1235                     rc = SharedClipboardURITransferListClose(pTransfer, hList);
    1236 
    1237                     /* Reply in any case. */
    1238                     int rc2 = VbglR3ClipboardListCloseReply(pCtx, rc, hList);
    1239                     AssertRC(rc2);
    1240                 }
    1241 
    1242                 break;
    1243             }
    1244 
    1245             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ:
    1246             {
    1247                 /** @todo Handle filter + list features. */
    1248 
    1249                 SHAREDCLIPBOARDLISTHANDLE hList  = SHAREDCLIPBOARDLISTHANDLE_INVALID;
    1250                 uint32_t                  fFlags = 0;
    1251                 rc = VbglR3ClipboardListHdrReadRecvReq(pCtx, &hList, &fFlags);
    1252                 if (RT_SUCCESS(rc))
    1253                 {
    1254                     VBOXCLIPBOARDLISTHDR hdrList;
    1255                     rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
    1256                     if (RT_SUCCESS(rc))
    1257                     {
    1258                         rc = VbglR3ClipboardListHdrWrite(pCtx, hList, &hdrList);
    1259 
    1260                         SharedClipboardURIListHdrDestroy(&hdrList);
    1261                     }
    1262                 }
    1263 
    1264                 break;
    1265             }
    1266 
    1267         #if 0
    1268             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE:
    1269             {
    1270                 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE\n"));
    1271 
    1272                 VBOXCLIPBOARDLISTHDR hdrList;
    1273                 rc = SharedClipboardURIListHdrInit(&hdrList);
    1274                 if (RT_SUCCESS(rc))
    1275                 {
    1276                     rc = VBglR3ClipboardListHdrRecv(pCtx, )
    1277                 }
    1278                 break;
    1279             }
    1280         #endif
    1281 
    1282             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ:
    1283             {
    1284                 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ\n"));
    1285 
    1286                 VBOXCLIPBOARDLISTENTRY entryList;
    1287                 rc = SharedClipboardURIListEntryInit(&entryList);
    1288                 if (RT_SUCCESS(rc))
    1289                 {
    1290                     SHAREDCLIPBOARDLISTHANDLE hList;
    1291                     uint32_t                  fInfo;
    1292                     rc = VbglR3ClipboardListEntryReadRecvReq(pCtx, &hList, &fInfo);
    1293                     if (RT_SUCCESS(rc))
    1294                     {
    1295                         rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
    1296                         if (RT_SUCCESS(rc))
    1297                         {
    1298                             PSHAREDCLIPBOARDFSOBJINFO pObjInfo = (PSHAREDCLIPBOARDFSOBJINFO)entryList.pvInfo;
    1299                             Assert(entryList.cbInfo == sizeof(SHAREDCLIPBOARDFSOBJINFO));
    1300 
    1301                             RT_NOREF(pObjInfo);
    1302 
    1303                             LogFlowFunc(("\t%s (%RU64 bytes)\n", entryList.pszName, pObjInfo->cbObject));
    1304 
    1305                             rc = VbglR3ClipboardListEntryWrite(pCtx, hList, &entryList);
    1306                         }
    1307                     }
    1308 
    1309                     SharedClipboardURIListEntryDestroy(&entryList);
    1310                 }
    1311 
    1312                 break;
    1313             }
    1314 
    1315         #if 0
    1316             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE:
    1317             {
    1318                 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE\n"));
    1319                 pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_ENTRY_WRITE;
    1320                 break;
    1321             }
    1322         #endif
    1323 
    1324             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN:
    1325             {
    1326                 VBOXCLIPBOARDOBJOPENCREATEPARMS openParms;
    1327                 rc = SharedClipboardURIObjectOpenParmsInit(&openParms);
    1328                 if (RT_SUCCESS(rc))
    1329                 {
    1330                     rc = VbglR3ClipboardObjOpenRecv(pCtx, &openParms);
    1331                     if (RT_SUCCESS(rc))
    1332                     {
    1333                         SHAREDCLIPBOARDOBJHANDLE hObj;
    1334                         rc = SharedClipboardURIObjectOpen(pTransfer, &openParms, &hObj);
    1335 
    1336                         /* Reply in any case. */
    1337                         int rc2 = VbglR3ClipboardObjOpenReply(pCtx, rc, hObj);
    1338                         AssertRC(rc2);
    1339                     }
    1340 
    1341                     SharedClipboardURIObjectOpenParmsDestroy(&openParms);
    1342                 }
    1343 
    1344                 break;
    1345             }
    1346 
    1347             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE:
    1348             {
    1349                 SHAREDCLIPBOARDOBJHANDLE hObj;
    1350                 rc = VbglR3ClipboardObjCloseRecv(pCtx, &hObj);
    1351                 if (RT_SUCCESS(rc))
    1352                 {
    1353                     rc = SharedClipboardURIObjectClose(pTransfer, hObj);
    1354 
    1355                     /* Reply in any case. */
    1356                     int rc2 = VbglR3ClipboardObjCloseReply(pCtx, rc, hObj);
    1357                     AssertRC(rc2);
    1358                 }
    1359                 break;
    1360             }
    1361 
    1362             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ:
    1363             {
    1364                 SHAREDCLIPBOARDOBJHANDLE hObj;
    1365                 uint32_t cbBuf;
    1366                 uint32_t fFlags;
    1367                 rc = VbglR3ClipboardObjReadRecv(pCtx, &hObj, &cbBuf, &fFlags);
    1368                 if (RT_SUCCESS(rc))
    1369                 {
    1370                     AssertBreakStmt(pCtx->cbChunkSize, rc = VERR_INVALID_PARAMETER);
    1371 
    1372                     const uint32_t cbToRead = RT_MIN(cbBuf, pCtx->cbChunkSize);
    1373 
    1374                     LogFlowFunc(("hObj=%RU64, cbBuf=%RU32, fFlags=0x%x -> cbChunkSize=%RU32, cbToRead=%RU32\n",
    1375                                  hObj, cbBuf, fFlags, pCtx->cbChunkSize, cbToRead));
    1376 
    1377                     void *pvBuf = RTMemAlloc(cbToRead);
    1378                     if (pvBuf)
    1379                     {
    1380                         uint32_t cbRead;
    1381                         rc = SharedClipboardURIObjectRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, fFlags);
    1382                         if (RT_SUCCESS(rc))
    1383                             rc = VbglR3ClipboardObjWrite(pCtx, hObj, pvBuf, cbRead, NULL /* pcbWritten */);
    1384 
    1385                         RTMemFree(pvBuf);
    1386                     }
    1387                     else
    1388                         rc = VERR_NO_MEMORY;
    1389                 }
    1390                 break;
    1391             }
    1392 
    1393         #if 0
    1394             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE:
    1395             {
    1396                 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE\n"));
    1397                 break;
    1398             }
    1399         #endif
    1400 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    1401 
    1402             default:
    1403                 rc = VERR_NOT_SUPPORTED;
    1404                 break;
    14051503        }
    14061504    }
    … …  
    15371635}
    15381636#endif
    1539 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
     1637
     1638/**
     1639 * Sends (reports) guest clipboard formats to the host.
     1640 *
     1641 * @returns VBox status code.
     1642 * @param   pCtx                The command context returned by VbglR3ClipboardConnect().
     1643 * @param   pFormats            The formats to send (report).
     1644 */
     1645VBGLR3DECL(int) VbglR3ClipboardFormatsSend(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats)
     1646{
     1647    VBoxClipboardFormatsMsg Msg;
     1648
     1649    if (pCtx->uProtocolVer == 0)
     1650    {
     1651        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_WRITE, 1);
     1652        VbglHGCMParmUInt32Set(&Msg.uFormats, pFormats->uFormats);
     1653    }
     1654    else
     1655    {
     1656        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_WRITE, 3);
     1657
     1658        Msg.uContext.SetUInt32(pCtx->uContextID);
     1659        Msg.uFormats.SetUInt32(pFormats->uFormats);
     1660        Msg.fFlags.SetUInt32(pFormats->fFlags);
     1661    }
     1662
     1663    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     1664
     1665    LogFlowFuncLeaveRC(rc);
     1666    return rc;
     1667}
    15401668
    15411669/**
    15421670 * Reports (advertises) guest clipboard formats to the host.
     1671 *
     1672 * Legacy function, do not use anymore.
    15431673 *
    15441674 * @returns VBox status code.
    … …  
    15481678VBGLR3DECL(int) VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats)
    15491679{
    1550     VBoxClipboardReportFormatsMsg Msg;
    1551 
    1552     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS, VBOX_SHARED_CLIPBOARD_CPARMS_REPORT_FORMATS);
    1553     VbglHGCMParmUInt32Set(&Msg.formats, fFormats);
     1680    VBoxClipboardFormatsMsg Msg;
     1681
     1682    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_WRITE, 1);
     1683    VbglHGCMParmUInt32Set(&Msg.uFormats, fFormats);
    15541684
    15551685    return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    … …  
    15571687
    15581688/**
    1559  * Sends guest clipboard data to the host.
    1560  *
    1561  * This is usually called in reply to a VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA message
    1562  * from the host.
    1563  *
    1564  * @returns VBox status code.
    1565  * @param   idClient        The client id returned by VbglR3ClipboardConnect().
    1566  * @param   fFormat         The format of the data.
    1567  * @param   pv              The data.
    1568  * @param   cb              The size of the data.
    1569  */
    1570 static int vbglR3ClipboardWriteDataRaw(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb)
    1571 {
    1572     VBoxClipboardWriteDataMsg Msg;
    1573     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA, VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA);
    1574     VbglHGCMParmUInt32Set(&Msg.format, fFormat);
    1575     VbglHGCMParmPtrSet(&Msg.ptr, pv, cb);
    1576 
    1577     return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    1578 }
    1579 
    1580 /**
    1581  * Send guest clipboard data to the host.
     1689 * Sends guest clipboard data to the host. Legacy function kept for compatibility, do not use anymore.
    15821690 *
    15831691 * This is usually called in reply to a VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA message
    … …  
    15921700VBGLR3DECL(int) VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb)
    15931701{
    1594     int rc  = vbglR3ClipboardWriteDataRaw(idClient, fFormat, pv, cb);
    1595 
    1596     return rc;
    1597 }
    1598 
    1599 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     1702    VBoxClipboardWriteDataMsg Msg;
     1703    RT_ZERO(Msg);
     1704
     1705    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     1706                       VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE, 2);
     1707
     1708    VbglHGCMParmUInt32Set(&Msg.v0.format, fFormat);
     1709    VbglHGCMParmPtrSet(&Msg.v0.ptr, pv, cb);
     1710
     1711    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     1712
     1713    LogFlowFuncLeaveRC(rc);
     1714    return rc;
     1715}
     1716
     1717/**
     1718 * Sends guest clipboard data to the host.
     1719 *
     1720 * This is usually called in reply to a VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA message
     1721 * from the host.
     1722 *
     1723 * @returns VBox status code.
     1724 * @param   pCtx                The command context returned by VbglR3ClipboardConnect().
     1725 * @param   pData               Clipboard data to send.
     1726 */
     1727VBGLR3DECL(int) VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDDATABLOCK pData)
     1728{
     1729    int rc;
     1730
     1731    if (pCtx->uProtocolVer == 0)
     1732    {
     1733        rc = VbglR3ClipboardWriteData(pCtx->uClientID, pData->uFormat, pData->pvData, pData->cbData);
     1734    }
     1735    else
     1736    {
     1737        VBoxClipboardWriteDataMsg Msg;
     1738        RT_ZERO(Msg);
     1739
     1740        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     1741                           VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA);
     1742
     1743        LogFlowFunc(("CID=%RU32\n", pCtx->uContextID));
     1744
     1745        Msg.v1.uContext.SetUInt32(pCtx->uContextID);
     1746        Msg.v1.uFormat.SetUInt32(pData->uFormat);
     1747        Msg.v1.cbData.SetUInt32(pData->cbData);
     1748        Msg.v1.pvData.SetPtr(pData->pvData, pData->cbData);
     1749
     1750        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     1751    }
     1752
     1753    LogFlowFuncLeaveRC(rc);
     1754    return rc;
     1755}
     1756
    16001757/**
    16011758 * Writes an error to the host.
    … …  
    16291786    return rc;
    16301787}
    1631 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    1632 
     1788

  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceClipboard-os2.cpp

    r79497 r80444  
    775775         * Listener message - the host has new formats to offer.
    776776         */
    777         case WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS:
     777        case WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE:
    778778            vgsvcClipboardOs2AdvertiseHostFormats(LONGFROMMP(mp1));
    779779            break;
    … …  
    895895                         * respond do WM_RENDERFORMAT message.
    896896                         */
    897                         case VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS:
    898                             if (!WinPostMsg(g_hwndWorker, WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS,
     897                        case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE:
     898                            if (!WinPostMsg(g_hwndWorker, WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE,
    899899                                            MPFROMLONG(fFormats), 0))
    900900                                VGSvcError("WinPostMsg(%lx, FORMATS,,) failed, lasterr=%#lx\n",

  • trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp

    r79497 r80444  
    380380            switch (u32Msg)
    381381            {
    382                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS:
     382                case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE:
    383383                {
    384384                    /*

  • trunk/src/VBox/Additions/x11/VBoxClient/Makefile.kmk

    r80378 r80444  
    9999  VBoxClient_DEFS    += VBOX_WITH_SHARED_CLIPBOARD_GUEST
    100100  VBoxClient_SOURCES += \
    101         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardURIList.cpp \
    102         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardURIObject.cpp \
    103         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp \
    104         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardProvider.cpp \
    105         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardProvider-VbglR3.cpp
     101        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp \
     102        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp
    106103  ifdef VBOX_WITH_LIBFUSE_DISABLED
    107104   VBoxClient_SOURCES += \

  • trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp

    r79497 r80444  
    145145 * Tell the host that new clipboard formats are available.
    146146 *
    147  * @param  pCtx      Our context information
    148  * @param u32Formats The formats to advertise
     147 * @param pCtx                  Our context information.
     148 * @param u32Formats            The formats to report.
    149149 */
    150150void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats)
    … …  
    229229            switch (Msg)
    230230            {
    231                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS:
     231                case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE:
    232232                {
    233233                    /* The host has announced available clipboard formats.
    … …  
    235235                     * future requests from guest applications.
    236236                     */
    237                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS fFormats=%x\n", fFormats));
     237                    LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE fFormats=%x\n", fFormats));
    238238                    ClipAnnounceFormatToX11(g_ctx.pBackend, fFormats);
    239239                    break;

  • trunk/src/VBox/Devices/USB/VUSBDevice.cpp

    r79500 r80444  
    16661666    PRTREQ hReq = NULL;
    16671667
    1668     Assert(pDev->hUrbIoThread != NIL_RTTHREAD);
     1668//    Assert(pDev->hUrbIoThread != NIL_RTTHREAD);
    16691669    if (RT_LIKELY(pDev->hUrbIoThread != NIL_RTTHREAD))
    16701670    {

  • trunk/src/VBox/Frontends/VirtualBox/src/logviewer/UIVMLogPage.cpp

    r80339 r80444  
    193193    if (m_bookmarkVector.size() <= index)
    194194         return;
    195     m_bookmarkVector.remove(index, 1);
     195    //m_bookmarkVector.remove(index, 1);
    196196    updateTextEditBookmarkLineSet();
    197197}

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkManagerIndicator.cpp

    r79365 r80444  
    117117
    118118    /* Delete corresponding network-request: */
    119     m_ids.remove(iIndexOfRequiredElement);
    120     m_data.remove(iIndexOfRequiredElement);
     119    RT_NOREF(iIndexOfRequiredElement);
     120    //m_ids.remove(iIndexOfRequiredElement);
     121    //m_data.remove(iIndexOfRequiredElement);
    121122
    122123    /* Update appearance: */

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIMediaComboBox.cpp

    r79365 r80444  
    4949    {
    5050        removeItem(0);
    51         m_media.erase(m_media.begin());
     51        //m_media.erase(m_media.begin());
    5252    }
    5353
    … …  
    165165    /* Replace medium from combo-box: */
    166166    removeItem(iIndex);
    167     m_media.erase(m_media.begin() + iIndex);
     167    //m_media.erase(m_media.begin() + iIndex);
    168168
    169169    /* If no real medium left, add the NULL medium: */

  • trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp

    r80285 r80444  
    2222#include <iprt/alloc.h>
    2323#include <iprt/assert.h>
     24#include <iprt/semaphore.h>
    2425#include <iprt/path.h>
    2526
    … …  
    2829#include <VBox/GuestHost/clipboard-helper.h>
    2930#include <VBox/HostServices/VBoxClipboardSvc.h>
     31
     32
     33/**
     34 * Allocates a new event payload.
     35 *
     36 * @returns VBox status code.
     37 * @param   uID                 Event ID to associate payload to.
     38 * @param   pvData              Data block to associate to this payload.
     39 * @param   cbData              Size (in bytes) of data block to associate.
     40 * @param   ppPayload           Where to store the allocated event payload on success.
     41 */
     42int SharedClipboardPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
     43                                PSHAREDCLIPBOARDEVENTPAYLOAD *ppPayload)
     44{
     45    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
     46    AssertReturn   (cbData, VERR_INVALID_PARAMETER);
     47
     48    PSHAREDCLIPBOARDEVENTPAYLOAD pPayload =
     49        (PSHAREDCLIPBOARDEVENTPAYLOAD)RTMemAlloc(sizeof(SHAREDCLIPBOARDEVENTPAYLOAD));
     50    if (!pPayload)
     51        return VERR_NO_MEMORY;
     52
     53    pPayload->pvData = RTMemAlloc(cbData);
     54    if (pPayload->pvData)
     55    {
     56        memcpy(pPayload->pvData, pvData, cbData);
     57
     58        pPayload->cbData = cbData;
     59        pPayload->uID    = uID;
     60
     61        *ppPayload = pPayload;
     62
     63        return VINF_SUCCESS;
     64    }
     65
     66    RTMemFree(pPayload);
     67    return VERR_NO_MEMORY;
     68}
     69
     70/**
     71 * Frees an event payload.
     72 *
     73 * @returns VBox status code.
     74 * @param   pPayload            Event payload to free.
     75 */
     76void SharedClipboardPayloadFree(PSHAREDCLIPBOARDEVENTPAYLOAD pPayload)
     77{
     78    if (!pPayload)
     79        return;
     80
     81    if (pPayload->pvData)
     82    {
     83        Assert(pPayload->cbData);
     84        RTMemFree(pPayload->pvData);
     85        pPayload->pvData = NULL;
     86    }
     87
     88    pPayload->cbData = 0;
     89
     90    RTMemFree(pPayload);
     91    pPayload = NULL;
     92}
     93
     94int SharedClipboardEventCreate(PSHAREDCLIPBOARDEVENT pEvent, uint16_t uID)
     95{
     96    AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
     97
     98    LogFlowFunc(("Event %RU16\n", uID));
     99
     100    int rc = RTSemEventCreate(&pEvent->hEventSem);
     101    if (RT_SUCCESS(rc))
     102    {
     103        pEvent->uID      = uID;
     104        pEvent->pPayload = NULL;
     105    }
     106
     107    return rc;
     108}
     109
     110void SharedClipboardEventDestroy(PSHAREDCLIPBOARDEVENT pEvent)
     111{
     112    if (!pEvent)
     113        return;
     114
     115    LogFlowFunc(("Event %RU16\n", pEvent->uID));
     116
     117    if (pEvent->hEventSem != NIL_RTSEMEVENT)
     118    {
     119        RTSemEventDestroy(pEvent->hEventSem);
     120        pEvent->hEventSem = NIL_RTSEMEVENT;
     121    }
     122
     123    SharedClipboardPayloadFree(pEvent->pPayload);
     124
     125    pEvent->uID = 0;
     126}
     127
     128int SharedClipboardEventSourceCreate(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID)
     129{
     130    AssertPtrReturn(pSource, VERR_INVALID_POINTER);
     131
     132    LogFlowFunc(("pSource=%p, uID=%RU16\n", pSource, uID));
     133
     134    int rc = VINF_SUCCESS;
     135
     136    RTListInit(&pSource->lstEvents);
     137
     138    pSource->uID          = uID;
     139    pSource->uEventIDNext = 1; /* Event ID 0 always is reserved (marks "unused"). */
     140
     141    LogFlowFuncLeaveRC(rc);
     142    return rc;
     143}
     144
     145void SharedClipboardEventSourceDestroy(PSHAREDCLIPBOARDEVENTSOURCE pSource)
     146{
     147    if (!pSource)
     148        return;
     149
     150    LogFlowFunc(("ID=%RU16\n", pSource->uID));
     151
     152    PSHAREDCLIPBOARDEVENT pEvIt;
     153    PSHAREDCLIPBOARDEVENT pEvItNext;
     154    RTListForEachSafe(&pSource->lstEvents, pEvIt, pEvItNext, SHAREDCLIPBOARDEVENT, Node)
     155    {
     156        SharedClipboardEventDestroy(pEvIt);
     157        RTMemFree(pEvIt);
     158    }
     159}
     160
     161/**
     162 * Generates a new event ID for a specific event source.
     163 *
     164 * @returns New event ID generated, or 0 on error.
     165 * @param   pSource             Event source to generate event for.
     166 */
     167uint16_t SharedClipboardEventIDGenerate(PSHAREDCLIPBOARDEVENTSOURCE pSource)
     168{
     169    AssertPtrReturn(pSource, 0);
     170
     171    LogFlowFunc(("uSource=%RU16: New event: %RU16\n", pSource->uID, pSource->uEventIDNext));
     172    return pSource->uEventIDNext++; /** @todo Improve this. */
     173}
     174
     175/**
     176 * Returns a specific event of a event source.
     177 *
     178 * @returns Pointer to event if found, or NULL if not found.
     179 * @param   pSource             Event source to get event from.
     180 * @param   uID                 Event ID to get.
     181 */
     182inline PSHAREDCLIPBOARDEVENT sharedClipboardEventGet(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID)
     183{
     184    PSHAREDCLIPBOARDEVENT pEvIt;
     185    RTListForEach(&pSource->lstEvents, pEvIt, SHAREDCLIPBOARDEVENT, Node)
     186    {
     187        if (pEvIt->uID == uID)
     188            return pEvIt;
     189    }
     190
     191    return NULL;
     192}
     193
     194/**
     195 * Registers an event.
     196 *
     197 * @returns VBox status code.
     198 * @param   pSource             Event source to register event for.
     199 * @param   uID                 Event ID to register.
     200 */
     201int SharedClipboardEventRegister(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID)
     202{
     203    AssertPtrReturn(pSource, VERR_INVALID_POINTER);
     204
     205    int rc;
     206
     207    LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
     208
     209    if (sharedClipboardEventGet(pSource, uID) == NULL)
     210    {
     211        PSHAREDCLIPBOARDEVENT pEvent
     212            = (PSHAREDCLIPBOARDEVENT)RTMemAllocZ(sizeof(SHAREDCLIPBOARDEVENT));
     213        if (pEvent)
     214        {
     215            rc = SharedClipboardEventCreate(pEvent, uID);
     216            if (RT_SUCCESS(rc))
     217            {
     218                RTListAppend(&pSource->lstEvents, &pEvent->Node);
     219
     220                LogFlowFunc(("Event %RU16\n", uID));
     221            }
     222        }
     223        else
     224            rc = VERR_NO_MEMORY;
     225    }
     226    else
     227        rc = VERR_ALREADY_EXISTS;
     228
     229#ifdef DEBUG_andy
     230    AssertRC(rc);
     231#endif
     232
     233    LogFlowFuncLeaveRC(rc);
     234    return rc;
     235}
     236
     237/**
     238 * Unregisters an event.
     239 *
     240 * @returns VBox status code.
     241 * @param   pSource             Event source to unregister event for.
     242 * @param   uID                 Event ID to unregister.
     243 */
     244int SharedClipboardEventUnregister(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID)
     245{
     246    AssertPtrReturn(pSource, VERR_INVALID_POINTER);
     247
     248    int rc;
     249
     250    LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
     251
     252    PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     253    if (pEvent)
     254    {
     255        LogFlowFunc(("Event %RU16\n", pEvent->uID));
     256
     257        SharedClipboardEventDestroy(pEvent);
     258        RTMemFree(pEvent);
     259
     260        RTListNodeRemove(&pEvent->Node);
     261
     262        rc = VINF_SUCCESS;
     263    }
     264    else
     265        rc = VERR_NOT_FOUND;
     266
     267    AssertRC(rc);
     268
     269    LogFlowFuncLeaveRC(rc);
     270    return rc;
     271}
     272
     273/**
     274 * Waits for an event to get signalled.
     275 *
     276 * @returns VBox status code.
     277 * @param   pSource             Event source that contains the event to wait for.
     278 * @param   uID                 Event ID to wait for.
     279 * @param   uTimeoutMs          Timeout (in ms) to wait.
     280 * @param   ppPayload           Where to store the (allocated) event payload on success. Needs to be free'd with
     281 *                              SharedClipboardPayloadFree().
     282 */
     283int SharedClipboardEventWait(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID, RTMSINTERVAL uTimeoutMs,
     284                             PSHAREDCLIPBOARDEVENTPAYLOAD* ppPayload)
     285{
     286    AssertPtrReturn(pSource, VERR_INVALID_POINTER);
     287
     288    LogFlowFuncEnter();
     289
     290    int rc;
     291
     292    PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     293    if (pEvent)
     294    {
     295        rc = RTSemEventWait(pEvent->hEventSem, uTimeoutMs);
     296        if (RT_SUCCESS(rc))
     297        {
     298            *ppPayload = pEvent->pPayload;
     299
     300            pEvent->pPayload = NULL;
     301        }
     302    }
     303    else
     304        rc = VERR_NOT_FOUND;
     305
     306    LogFlowFuncLeaveRC(rc);
     307    return rc;
     308}
     309
     310/**
     311 * Signals an event.
     312 *
     313 * @returns VBox status code.
     314 * @param   pSource             Event source of event to signal.
     315 * @param   uID                 Event ID to signal.
     316 * @param   pPayload            Event payload to associate. Takes ownership. Optional.
     317 */
     318int SharedClipboardEventSignal(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID,
     319                               PSHAREDCLIPBOARDEVENTPAYLOAD pPayload)
     320{
     321    AssertPtrReturn(pSource, VERR_INVALID_POINTER);
     322
     323    int rc;
     324
     325    LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
     326
     327    PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     328    if (pEvent)
     329    {
     330        Assert(pEvent->pPayload == NULL);
     331
     332        pEvent->pPayload = pPayload;
     333
     334        rc = RTSemEventSignal(pEvent->hEventSem);
     335    }
     336    else
     337        rc = VERR_NOT_FOUND;
     338
     339#ifdef DEBUG_andy
     340    AssertRC(rc);
     341#endif
     342
     343    LogFlowFuncLeaveRC(rc);
     344    return rc;
     345}
     346
     347/**
     348 * Detaches a payload from an event.
     349 *
     350 * @returns VBox status code.
     351 * @param   pSource             Event source of event to detach payload for.
     352 * @param   uID                 Event ID to detach payload for.
     353 */
     354void SharedClipboardEventPayloadDetach(PSHAREDCLIPBOARDEVENTSOURCE pSource, uint16_t uID)
     355{
     356    AssertPtrReturnVoid(pSource);
     357
     358    LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
     359
     360    PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     361    if (pEvent)
     362    {
     363        pEvent->pPayload = NULL;
     364    }
     365#ifdef DEBUG_andy
     366    else
     367        AssertMsgFailed(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
     368#endif
     369}
    30370
    31371/** @todo use const where appropriate; delinuxify the code (*Lin* -> *Host*); use AssertLogRel*. */
    … …  
    421761        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
    422762        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    423         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS);
     763        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE);
    424764        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START);
    425765        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ);
    … …  
    453793    switch (uMsg)
    454794    {
    455         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS);
    456         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA);
    457         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA);
     795        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD);
     796        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_WRITE);
     797        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_READ);
     798        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE);
     799        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT);
    458800        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT);
    459801        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT);
    … …  
    477819        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL);
    478820        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR);
    479         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
    480821    }
    481822    return "Unknown";
    482823}
     824

  • trunk/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp

    r80374 r80444  
    2121#include <iprt/dir.h>
    2222#include <iprt/file.h>
     23#include <iprt/list.h>
    2324#include <iprt/path.h>
    2425#include <iprt/semaphore.h>
    … …  
    3132static int sharedClipboardURITransferThreadCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
    3233static int sharedClipboardURITransferThreadDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs);
    33 static int sharedClipboardURITransferWriteThread(RTTHREAD hThread, void *pvUser);
    3434static PSHAREDCLIPBOARDURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHAREDCLIPBOARDURICTX pURI, uint32_t uIdx);
    3535static int sharedClipboardConvertFileCreateFlags(bool fWritable, unsigned fShClFlags, RTFMODE fMode,
    … …  
    695695        pParms->pszPath = NULL;
    696696    }
     697}
     698
     699/**
     700 * Returns a specific object handle info of a transfer.
     701 *
     702 * @returns Pointer to object handle info if found, or NULL if not found.
     703 * @param   pTransfer           URI clipboard transfer to get object handle info from.
     704 * @param   hObj                Object handle of the object to get handle info for.
     705 */
     706inline PSHAREDCLIPBOARDURIOBJHANDLEINFO sharedClipboardURIObjectGet(PSHAREDCLIPBOARDURITRANSFER pTransfer,
     707                                                                    SHAREDCLIPBOARDOBJHANDLE hObj)
     708{
     709    PSHAREDCLIPBOARDURIOBJHANDLEINFO pIt;
     710    RTListForEach(&pTransfer->lstObj, pIt, SHAREDCLIPBOARDURIOBJHANDLEINFO, Node)
     711    {
     712        if (pIt->hObj == hObj)
     713            return pIt;
     714    }
     715
     716    return NULL;
    697717}
    698718
    … …  
    744764            if (RT_SUCCESS(rc))
    745765            {
    746                 const SHAREDCLIPBOARDOBJHANDLE hObj = pTransfer->uObjHandleNext++;
    747 
     766                pInfo->hObj    = pTransfer->uObjHandleNext++;
    748767                pInfo->enmType = SHAREDCLIPBOARDURIOBJTYPE_FILE;
    749768
    750                 pTransfer->pMapObj->insert(
    751                     std::pair<SHAREDCLIPBOARDOBJHANDLE, PSHAREDCLIPBOARDURIOBJHANDLEINFO>(hObj, pInfo));
    752 
    753                 *phObj = hObj;
     769                RTListAppend(&pTransfer->lstObj, &pInfo->Node);
     770
     771                *phObj = pInfo->hObj;
    754772            }
    755773
    … …  
    789807    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
    790808    {
    791         SharedClipboardURIObjMap::iterator itObj = pTransfer->pMapObj->find(hObj);
    792         if (itObj != pTransfer->pMapObj->end())
    793         {
    794             PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = itObj->second;
    795             AssertPtr(pInfo);
    796 
     809        PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
     810        if (pInfo)
     811        {
    797812            switch (pInfo->enmType)
    798813            {
    … …  
    820835            RTMemFree(pInfo);
    821836
    822             pTransfer->pMapObj->erase(itObj);
     837            RTListNodeRemove(&pInfo->Node);
    823838        }
    824839        else
    … …  
    862877    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
    863878    {
    864         SharedClipboardURIObjMap::iterator itObj = pTransfer->pMapObj->find(hObj);
    865         if (itObj != pTransfer->pMapObj->end())
    866         {
    867             PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = itObj->second;
    868             AssertPtr(pInfo);
    869 
     879        PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
     880        if (pInfo)
     881        {
    870882            switch (pInfo->enmType)
    871883            {
    … …  
    927939    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
    928940    {
    929         SharedClipboardURIObjMap::iterator itObj = pTransfer->pMapObj->find(hObj);
    930         if (itObj != pTransfer->pMapObj->end())
    931         {
    932             PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = itObj->second;
    933             AssertPtr(pInfo);
    934 
     941        PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
     942        if (pInfo)
     943        {
    935944            switch (pInfo->enmType)
    936945            {
    … …  
    10701079    pTransfer->uListHandleNext   = 1;
    10711080    pTransfer->uObjHandleNext    = 1;
    1072     pTransfer->uEventIDNext      = 1;
    10731081
    10741082    pTransfer->uTimeoutMs     = 30 * 1000; /* 30s timeout by default. */
    … …  
    10801088    RT_ZERO(pTransfer->Callbacks);
    10811089
    1082     pTransfer->pMapEvents = new SharedClipboardURITransferEventMap();
    1083     if (pTransfer->pMapEvents)
    1084     {
    1085         pTransfer->pMapLists = new SharedClipboardURIListMap();
    1086         if (pTransfer->pMapLists)
    1087         {
    1088             pTransfer->pMapObj = new SharedClipboardURIObjMap();
    1089             if (pTransfer->pMapObj)
    1090                 *ppTransfer = pTransfer;
    1091         }
    1092     }
    1093     else
    1094         rc = VERR_NO_MEMORY;
     1090    RTListInit(&pTransfer->lstList);
     1091    RTListInit(&pTransfer->lstObj);
     1092
     1093    pTransfer->cRoots = 0;
     1094    RTListInit(&pTransfer->lstRoots);
     1095
     1096    *ppTransfer = pTransfer;
    10951097
    10961098    if (RT_FAILURE(rc))
    … …  
    11261128    RTStrFree(pTransfer->pszPathRootAbs);
    11271129
    1128     if (pTransfer->pMapEvents)
    1129     {
    1130         SharedClipboardURITransferEventMap::iterator itEvent = pTransfer->pMapEvents->begin();
    1131         while (itEvent != pTransfer->pMapEvents->end())
    1132         {
    1133 
    1134             itEvent = pTransfer->pMapEvents->begin();
    1135         }
    1136 
    1137         delete pTransfer->pMapEvents;
    1138         pTransfer->pMapEvents = NULL;
    1139     }
    1140 
    1141     if (pTransfer->pMapLists)
    1142     {
    1143         SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->begin();
    1144         while (itList != pTransfer->pMapLists->end())
    1145         {
    1146             SharedClipboardURIListHandleInfoDestroy(itList->second);
    1147             pTransfer->pMapLists->erase(itList);
    1148             itList = pTransfer->pMapLists->begin();
    1149         }
    1150 
    1151         Assert(pTransfer->pMapLists->size() == 0);
    1152 
    1153         delete pTransfer->pMapLists;
    1154         pTransfer->pMapLists = NULL;
    1155     }
    1156 
    1157     if (pTransfer->pMapObj)
    1158     {
    1159         SharedClipboardURIObjMap::iterator itObj = pTransfer->pMapObj->begin();
    1160         while (itObj != pTransfer->pMapObj->end())
    1161         {
    1162             SharedClipboardURIObjectHandleInfoDestroy(itObj->second);
    1163             pTransfer->pMapObj->erase(itObj);
    1164             itObj = pTransfer->pMapObj->begin();
    1165         }
    1166 
    1167         Assert(pTransfer->pMapObj->size() == 0);
    1168 
    1169         delete pTransfer->pMapObj;
    1170         pTransfer->pMapObj = NULL;
     1130    SharedClipboardEventSourceDestroy(&pTransfer->Events);
     1131
     1132    PSHAREDCLIPBOARDURILISTHANDLEINFO pItList, pItListNext;
     1133    RTListForEachSafe(&pTransfer->lstList, pItList, pItListNext, SHAREDCLIPBOARDURILISTHANDLEINFO, Node)
     1134    {
     1135        SharedClipboardURIListHandleInfoDestroy(pItList);
     1136
     1137        RTListNodeRemove(&pItList->Node);
     1138
     1139        RTMemFree(pItList);
     1140    }
     1141
     1142    PSHAREDCLIPBOARDURIOBJHANDLEINFO pItObj, pItObjNext;
     1143    RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHAREDCLIPBOARDURIOBJHANDLEINFO, Node)
     1144    {
     1145        SharedClipboardURIObjectHandleInfoDestroy(pItObj);
     1146
     1147        RTListNodeRemove(&pItObj->Node);
     1148
     1149        RTMemFree(pItObj);
    11711150    }
    11721151
    … …  
    11981177
    11991178/**
     1179 * Returns a specific list handle info of a transfer.
     1180 *
     1181 * @returns Pointer to list handle info if found, or NULL if not found.
     1182 * @param   pTransfer           URI clipboard transfer to get list handle info from.
     1183 * @param   hList               List handle of the list to get handle info for.
     1184 */
     1185inline PSHAREDCLIPBOARDURILISTHANDLEINFO sharedClipboardURITransferListGet(PSHAREDCLIPBOARDURITRANSFER pTransfer,
     1186                                                                           SHAREDCLIPBOARDLISTHANDLE hList)
     1187{
     1188    PSHAREDCLIPBOARDURILISTHANDLEINFO pIt;
     1189    RTListForEach(&pTransfer->lstList, pIt, SHAREDCLIPBOARDURILISTHANDLEINFO, Node)
     1190    {
     1191        if (pIt->hList == hList)
     1192            return pIt;
     1193    }
     1194
     1195    return NULL;
     1196}
     1197
     1198/**
    12001199 * Creates a new list handle (local only).
    12011200 *
    … …  
    12031202 * @param   pTransfer           URI clipboard transfer to create new list handle for.
    12041203 */
    1205 static SHAREDCLIPBOARDLISTHANDLE sharedClipboardURITransferListHandleNew(PSHAREDCLIPBOARDURITRANSFER pTransfer)
     1204inline SHAREDCLIPBOARDLISTHANDLE sharedClipboardURITransferListHandleNew(PSHAREDCLIPBOARDURITRANSFER pTransfer)
    12061205{
    12071206    return pTransfer->uListHandleNext++; /** @todo Good enough for now. Improve this later. */
    … …  
    12441243                    {
    12451244                        rc = RTDirOpen(&pInfo->u.Local.hDir, pOpenParms->pszPath);
     1245                        break;
    12461246                    }
    12471247
    … …  
    12601260                if (RT_SUCCESS(rc))
    12611261                {
    1262                     hList = sharedClipboardURITransferListHandleNew(pTransfer);
    1263 
    1264                     pTransfer->pMapLists->insert(
    1265                         std::pair<SHAREDCLIPBOARDLISTHANDLE, PSHAREDCLIPBOARDURILISTHANDLEINFO>(hList, pInfo)); /** @todo Can this throw? */
     1262                    pInfo->hList = sharedClipboardURITransferListHandleNew(pTransfer);
     1263
     1264                    RTListAppend(&pTransfer->lstList, &pInfo->Node);
    12661265                }
    12671266                else
    … …  
    13231322    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
    13241323    {
    1325         SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->find(hList);
    1326         if (itList != pTransfer->pMapLists->end())
    1327         {
    1328             PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = itList->second;
    1329             AssertPtr(pInfo);
    1330 
     1324        PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
     1325        if (pInfo)
     1326        {
    13311327            switch (pInfo->enmType)
    13321328            {
    … …  
    13431339            }
    13441340
     1341            RTListNodeRemove(&pInfo->Node);
     1342
    13451343            RTMemFree(pInfo);
    1346 
    1347             pTransfer->pMapLists->erase(itList);
    13481344        }
    13491345        else
    … …  
    15591555    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
    15601556    {
    1561         SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->find(hList);
    1562         if (itList != pTransfer->pMapLists->end())
     1557        PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
     1558        if (pInfo)
    15631559        {
    15641560            rc = SharedClipboardURIListHdrInit(pHdr);
    15651561            if (RT_SUCCESS(rc))
    15661562            {
    1567                 PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = itList->second;
    1568                 AssertPtr(pInfo);
    1569 
    15701563                switch (pInfo->enmType)
    15711564                {
    … …  
    16661659    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
    16671660    {
    1668         SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->find(hList);
    1669         if (itList != pTransfer->pMapLists->end())
    1670         {
    1671             PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = itList->second;
    1672             AssertPtr(pInfo);
    1673 
     1661        PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
     1662        if (pInfo)
     1663        {
    16741664            switch (pInfo->enmType)
    16751665            {
    … …  
    18261816    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
    18271817    {
    1828         SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->find(hList);
    1829         fIsValid = itList != pTransfer->pMapLists->end();
     1818        fIsValid = sharedClipboardURITransferListGet(pTransfer, hList) != NULL;
    18301819    }
    18311820    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
    … …  
    19271916    }
    19281917
    1929     pTransfer->lstRootEntries.clear();
     1918    PSHAREDCLIPBOARDURILISTROOT pListRoot, pListRootNext;
     1919    RTListForEachSafe(&pTransfer->lstRoots, pListRoot, pListRootNext, SHAREDCLIPBOARDURILISTROOT, Node)
     1920    {
     1921        RTStrFree(pListRoot->pszPathAbs);
     1922
     1923        RTListNodeRemove(&pListRoot->Node);
     1924
     1925        RTMemFree(pListRoot);
     1926        pListRoot = NULL;
     1927    }
     1928
     1929    pTransfer->cRoots = 0;
    19301930}
    19311931
    … …  
    19521952    sharedClipboardURIListTransferRootsClear(pTransfer);
    19531953
    1954     char *pszPathRootAbs = NULL;
     1954    char  *pszPathRootAbs = NULL;
    19551955
    19561956    RTCList<RTCString> lstRootEntries = RTCString(pszRoots, cbRoots - 1).split("\r\n");
    19571957    for (size_t i = 0; i < lstRootEntries.size(); ++i)
    19581958    {
    1959         SHAREDCLIPBOARDURILISTROOT listRoot;
    1960         listRoot.strPathAbs = lstRootEntries.at(i);
     1959        PSHAREDCLIPBOARDURILISTROOT pListRoot = (PSHAREDCLIPBOARDURILISTROOT)RTMemAlloc(sizeof(SHAREDCLIPBOARDURILISTROOT));
     1960        AssertPtrBreakStmt(pListRoot, rc = VERR_NO_MEMORY);
     1961
     1962        pListRoot->pszPathAbs = RTStrDup(lstRootEntries.at(i).c_str());
     1963        AssertPtrBreakStmt(pListRoot->pszPathAbs, rc = VERR_NO_MEMORY);
    19611964
    19621965        if (!pszPathRootAbs)
    19631966        {
    1964             pszPathRootAbs = RTStrDup(listRoot.strPathAbs.c_str());
     1967            pszPathRootAbs = RTStrDup(pListRoot->pszPathAbs);
    19651968            if (pszPathRootAbs)
    19661969            {
    … …  
    19761979
    19771980        /* Make sure all entries have the same root path. */
    1978         if (!RTStrStartsWith(listRoot.strPathAbs.c_str(), pszPathRootAbs))
     1981        if (!RTStrStartsWith(pListRoot->pszPathAbs, pszPathRootAbs))
    19791982        {
    19801983            rc = VERR_INVALID_PARAMETER;
    … …  
    19821985        }
    19831986
    1984         pTransfer->lstRootEntries.append(listRoot);
     1987        RTListAppend(&pTransfer->lstRoots, &pListRoot->Node);
     1988
     1989        pTransfer->cRoots++;
    19851990    }
    19861991
    … …  
    19901995    {
    19911996        pTransfer->pszPathRootAbs = pszPathRootAbs;
    1992         LogFlowFunc(("pszPathRootAbs=%s, cRoots=%zu\n", pTransfer->pszPathRootAbs, pTransfer->lstRootEntries.size()));
     1997        LogFlowFunc(("pszPathRootAbs=%s, cRoots=%zu\n", pTransfer->pszPathRootAbs, pTransfer->cRoots));
    19931998    }
    19941999
    … …  
    20342039    AssertPtrReturn(pTransfer, 0);
    20352040
    2036     return (uint32_t)pTransfer->lstRootEntries.size();
     2041    return (uint32_t)pTransfer->cRoots;
     2042}
     2043
     2044/**
     2045 * Returns a specific root list entry of a transfer.
     2046 *
     2047 * @returns Pointer to root list entry if found, or NULL if not found.
     2048 * @param   pTransfer           URI clipboard transfer to get root list entry from.
     2049 * @param   uIdx                Index of root list entry to return.
     2050 */
     2051inline PSHAREDCLIPBOARDURILISTROOT sharedClipboardURILTransferRootsGet(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uIdx)
     2052{
     2053    if (uIdx >= pTransfer->cRoots)
     2054        return NULL;
     2055
     2056    PSHAREDCLIPBOARDURILISTROOT pIt = RTListGetFirst(&pTransfer->lstRoots, SHAREDCLIPBOARDURILISTROOT, Node);
     2057    while (uIdx--)
     2058        pIt = RTListGetNext(&pTransfer->lstRoots, pIt, SHAREDCLIPBOARDURILISTROOT, Node);
     2059
     2060    return pIt;
    20372061}
    20382062
    … …  
    20462070 */
    20472071int SharedClipboardURILTransferRootsEntry(PSHAREDCLIPBOARDURITRANSFER pTransfer,
    2048                                           uint32_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pEntry)
     2072                                          uint64_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pEntry)
    20492073{
    20502074    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    20512075    AssertPtrReturn(pEntry,    VERR_INVALID_POINTER);
    20522076
    2053     if (uIndex >= pTransfer->lstRootEntries.size())
     2077    if (uIndex >= pTransfer->cRoots)
    20542078        return VERR_INVALID_PARAMETER;
    20552079
    20562080    int rc;
    20572081
    2058     PSHAREDCLIPBOARDURILISTROOT pRoot = &pTransfer->lstRootEntries.at(uIndex);
    2059     AssertPtrReturn(pRoot, VERR_INVALID_POINTER);
     2082    PSHAREDCLIPBOARDURILISTROOT pRoot = sharedClipboardURILTransferRootsGet(pTransfer, uIndex);
     2083    AssertPtrReturn(pRoot, VERR_INVALID_PARAMETER);
    20602084
    20612085    /* Make sure that we only advertise relative source paths, not absolute ones. */
    2062     const char *pcszSrcPath = pRoot->strPathAbs.c_str();
     2086    const char *pcszSrcPath = pRoot->pszPathAbs;
    20632087
    20642088    char *pszFileName = RTPathFilename(pcszSrcPath);
    … …  
    21242148            return VERR_NO_MEMORY;
    21252149
    2126         const uint32_t cRoots = (uint32_t)pTransfer->lstRootEntries.size();
    2127 
    2128         LogFlowFunc(("cRoots=%RU32\n", cRoots));
     2150        const uint64_t cRoots = (uint32_t)pTransfer->cRoots;
     2151
     2152        LogFlowFunc(("cRoots=%RU64\n", cRoots));
    21292153
    21302154        if (cRoots)
    … …  
    21342158            if (paRootListEntries)
    21352159            {
    2136                 for (uint32_t i = 0; i < cRoots; ++i)
     2160                for (uint64_t i = 0; i < cRoots; ++i)
    21372161                {
    21382162                    rc = SharedClipboardURILTransferRootsEntry(pTransfer, i, &paRootListEntries[i]);
    … …  
    22502274
    22512275/**
    2252  * Allocates a new event payload.
    2253  *
    2254  * @returns VBox status code.
    2255  * @param   uID                 Event ID to associate payload to.
    2256  * @param   pvData              Data block to associate to this payload.
    2257  * @param   cbData              Size (in bytes) of data block to associate.
    2258  * @param   ppPayload           Where to store the allocated event payload on success.
    2259  */
    2260 int SharedClipboardURITransferPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
    2261                                            PSHAREDCLIPBOARDURITRANSFERPAYLOAD *ppPayload)
    2262 {
    2263     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload =
    2264         (PSHAREDCLIPBOARDURITRANSFERPAYLOAD)RTMemAlloc(sizeof(SHAREDCLIPBOARDURITRANSFERPAYLOAD));
    2265     if (!pPayload)
    2266         return VERR_NO_MEMORY;
    2267 
    2268     pPayload->pvData = RTMemAlloc(cbData);
    2269     if (pPayload->pvData)
    2270     {
    2271         memcpy(pPayload->pvData, pvData, cbData);
    2272 
    2273         pPayload->cbData = cbData;
    2274         pPayload->uID    = uID;
    2275 
    2276         *ppPayload = pPayload;
    2277 
    2278         return VINF_SUCCESS;
    2279     }
    2280 
    2281     RTMemFree(pPayload);
    2282     return VERR_NO_MEMORY;
    2283 }
    2284 
    2285 /**
    2286  * Frees an event payload.
    2287  *
    2288  * @returns VBox status code.
    2289  * @param   pPayload            URI clipboard transfer event payload to free.
    2290  */
    2291 void SharedClipboardURITransferPayloadFree(PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload)
    2292 {
    2293     if (!pPayload)
    2294         return;
    2295 
    2296     if (pPayload->pvData)
    2297     {
    2298         Assert(pPayload->cbData);
    2299         RTMemFree(pPayload->pvData);
    2300         pPayload->pvData = NULL;
    2301     }
    2302 
    2303     pPayload->cbData = 0;
    2304 
    2305     RTMemFree(pPayload);
    2306     pPayload = NULL;
    2307 }
    2308 
    2309 /**
    2310  * Generates a new event ID for a specific URI transfer.
    2311  *
    2312  * @returns New event ID generated, or 0 on error.
    2313  * @param   pTransfer           URI clipboard transfer to generate event for.
    2314  */
    2315 uint16_t SharedClipboardURITransferEventIDGenerate(PSHAREDCLIPBOARDURITRANSFER pTransfer)
    2316 {
    2317     LogFlowFunc(("New event %RU16\n", pTransfer->uEventIDNext));
    2318     return pTransfer->uEventIDNext++; /** @todo Improve this. */
    2319 }
    2320 
    2321 /**
    2322  * Registers an URI transfer event.
    2323  *
    2324  * @returns VBox status code.
    2325  * @param   pTransfer           URI clipboard transfer to register event for.
    2326  * @param   uID                 Event ID to register.
    2327  */
    2328 int SharedClipboardURITransferEventRegister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID)
    2329 {
    2330     int rc;
    2331 
    2332     SharedClipboardURITransferEventMap::iterator itEvent = pTransfer->pMapEvents->find(uID);
    2333     if (itEvent == pTransfer->pMapEvents->end())
    2334     {
    2335         PSHAREDCLIPBOARDURITRANSFEREVENT pEvent
    2336             = (PSHAREDCLIPBOARDURITRANSFEREVENT)RTMemAllocZ(sizeof(SHAREDCLIPBOARDURITRANSFEREVENT));
    2337         if (pEvent)
    2338         {
    2339             rc = RTSemEventCreate(&pEvent->hEventSem);
    2340             if (RT_SUCCESS(rc))
    2341             {
    2342                 pTransfer->pMapEvents->insert(std::pair<uint16_t, PSHAREDCLIPBOARDURITRANSFEREVENT>(uID, pEvent)); /** @todo Can this throw? */
    2343 
    2344                 LogFlowFunc(("Event %RU16\n", uID));
    2345             }
    2346         }
    2347         else
    2348             rc = VERR_NO_MEMORY;
    2349     }
    2350     else
    2351         rc = VERR_ALREADY_EXISTS;
    2352 
    2353 #ifdef DEBUG_andy
    2354     AssertRC(rc);
    2355 #endif
    2356 
    2357     LogFlowFuncLeaveRC(rc);
    2358     return rc;
    2359 }
    2360 
    2361 /**
    2362  * Unregisters an URI transfer event.
    2363  *
    2364  * @returns VBox status code.
    2365  * @param   pTransfer           URI clipboard transfer to unregister event for.
    2366  * @param   uID                 Event ID to unregister.
    2367  */
    2368 int SharedClipboardURITransferEventUnregister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID)
    2369 {
    2370     int rc;
    2371 
    2372     SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->pMapEvents->find(uID);
    2373     if (itEvent != pTransfer->pMapEvents->end())
    2374     {
    2375         SharedClipboardURITransferPayloadFree(itEvent->second->pPayload);
    2376 
    2377         RTSemEventDestroy(itEvent->second->hEventSem);
    2378 
    2379         RTMemFree(itEvent->second);
    2380 
    2381         pTransfer->pMapEvents->erase(itEvent);
    2382 
    2383         LogFlowFunc(("Event %RU16\n", uID));
    2384 
    2385         rc = VINF_SUCCESS;
    2386     }
    2387     else
    2388         rc = VERR_NOT_FOUND;
    2389 
    2390     AssertRC(rc);
    2391 
    2392     LogFlowFuncLeaveRC(rc);
    2393     return rc;
    2394 }
    2395 
    2396 /**
    2397  * Waits for an URI transfer event to get signalled.
    2398  *
    2399  * @returns VBox status code.
    2400  * @param   pTransfer           URI clipboard transfer that contains the event to wait for.
    2401  * @param   uID                 Event ID to wait for.
    2402  * @param   uTimeoutMs          Timeout (in ms) to wait.
    2403  * @param   ppPayload           Where to store the (allocated) event payload on success. Needs to be free'd with
    2404  *                              SharedClipboardURITransferPayloadFree().
    2405  */
    2406 int SharedClipboardURITransferEventWait(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID, RTMSINTERVAL uTimeoutMs,
    2407                                         PSHAREDCLIPBOARDURITRANSFERPAYLOAD *ppPayload)
    2408 {
    2409     LogFlowFuncEnter();
    2410 
    2411     int rc;
    2412 
    2413     SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->pMapEvents->find(uID);
    2414     if (itEvent != pTransfer->pMapEvents->end())
    2415     {
    2416         rc = RTSemEventWait(itEvent->second->hEventSem, uTimeoutMs);
    2417         if (RT_SUCCESS(rc))
    2418         {
    2419             *ppPayload = itEvent->second->pPayload;
    2420 
    2421             itEvent->second->pPayload = NULL;
    2422         }
    2423     }
    2424     else
    2425         rc = VERR_NOT_FOUND;
    2426 
    2427     LogFlowFuncLeaveRC(rc);
    2428     return rc;
    2429 }
    2430 
    2431 /**
    2432  * Signals an URI transfer event.
    2433  *
    2434  * @returns VBox status code.
    2435  * @param   pTransfer           URI clipboard transfer of event to signal.
    2436  * @param   uID                 Event ID to signal.
    2437  * @param   pPayload            Event payload to associate. Takes ownership. Optional.
    2438  */
    2439 int SharedClipboardURITransferEventSignal(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID,
    2440                                           PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload)
    2441 {
    2442     int rc;
    2443 
    2444     SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->pMapEvents->find(uID);
    2445     if (itEvent != pTransfer->pMapEvents->end())
    2446     {
    2447         Assert(itEvent->second->pPayload == NULL);
    2448 
    2449         itEvent->second->pPayload = pPayload;
    2450 
    2451         rc = RTSemEventSignal(itEvent->second->hEventSem);
    2452     }
    2453     else
    2454         rc = VERR_NOT_FOUND;
    2455 
    2456 #ifdef DEBUG_andy
    2457     AssertRC(rc);
    2458 #endif
    2459 
    2460     LogFlowFuncLeaveRC(rc);
    2461     return rc;
    2462 }
    2463 
    2464 /**
    24652276 * Creates a thread for a clipboard URI transfer.
    24662277 *
    … …  
    27082519    AssertPtrReturnVoid(pURI);
    27092520
    2710     LogFlowFunc(("cRunning=%RU32\n", pURI->cRunning));
     2521    LogFlowFunc(("cTransfers=%RU32, cRunning=%RU32\n", pURI->cTransfers, pURI->cRunning));
    27112522
    27122523    /* Remove all transfers which are not in a running state (e.g. only announced). */
    … …  
    27242535            Assert(pURI->cTransfers);
    27252536            pURI->cTransfers--;
    2726 
    2727             LogFlowFunc(("cTransfers=%RU32\n", pURI->cTransfers));
    27282537        }
    27292538    }

  • trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp

    r79672 r80444  
    384384 * @returns VBox status code.
    385385 * @param   pCtx                Windows clipboard context to retrieve formats for.
    386  * @param   pfFormats           Where to store the retrieved formats of type VBOX_SHARED_CLIPBOARD_FMT_ (bitmask).
    387  */
    388 int VBoxClipboardWinGetFormats(PVBOXCLIPBOARDWINCTX pCtx, PVBOXCLIPBOARDFORMATS pfFormats)
    389 {
    390     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
    391     AssertPtrReturn(pfFormats, VERR_INVALID_POINTER);
     386 * @param   pFormats            Where to store the retrieved formats.
     387 */
     388int VBoxClipboardWinGetFormats(PVBOXCLIPBOARDWINCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats)
     389{
     390    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
     391    AssertPtrReturn(pFormats, VERR_INVALID_POINTER);
    392392
    393393    VBOXCLIPBOARDFORMATS fFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE;
    … …  
    412412    {
    413413        LogFlowFunc(("fFormats=0x%08X\n", fFormats));
    414         *pfFormats = fFormats;
     414
     415        pFormats->uFormats   = fFormats;
     416        pFormats->fFlags = 0; /** @todo Handle flags. */
    415417    }
    416418

  • trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp

    r78583 r80444  
    588588 *        unit test.  So keep it simple, be paranoid and log everything.
    589589 */
    590 static void clipConvertX11Targets(Widget widget, XtPointer pClientData,
     590static void clipConvertX11Targets(Widget widget, XtPointer pClient,
    591591                                  Atom * /* selection */, Atom *atomType,
    592592                                  XtPointer pValue, long unsigned int *pcLen,
    … …  
    594594{
    595595    RT_NOREF1(piFormat);
    596     CLIPBACKEND *pCtx = reinterpret_cast<CLIPBACKEND *>(pClientData);
     596    CLIPBACKEND *pCtx = reinterpret_cast<CLIPBACKEND *>(pClient);
    597597    Atom *pAtoms = (Atom *)pValue;
    598598    unsigned i, j;
    … …  
    17641764 *        the X11 clipboard contains a format we understand.
    17651765 */
    1766 static void clipConvertX11CB(void *pClientData, void *pvSrc, unsigned cbSrc)
    1767 {
    1768     CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *) pClientData;
     1766static void clipConvertX11CB(void *pClient, void *pvSrc, unsigned cbSrc)
     1767{
     1768    CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *) pClient;
    17691769    LogRelFlowFunc(("pReq->mFormat=%02X, pReq->mTextFormat=%u, "
    17701770                "pReq->mBitmapFormat=%u, pReq->mHtmlFormat=%u, pReq->mCtx=%p\n",
    … …  
    19091909 *        the X11 clipboard contains a format we understand.
    19101910 */
    1911 static void cbConvertX11CB(Widget widget, XtPointer pClientData,
     1911static void cbConvertX11CB(Widget widget, XtPointer pClient,
    19121912                           Atom * /* selection */, Atom *atomType,
    19131913                           XtPointer pvSrc, long unsigned int *pcLen,
    … …  
    19161916    RT_NOREF1(widget);
    19171917    if (*atomType == XT_CONVERT_FAIL) /* Xt timeout */
    1918         clipConvertX11CB(pClientData, NULL, 0);
     1918        clipConvertX11CB(pClient, NULL, 0);
    19191919    else
    1920         clipConvertX11CB(pClientData, pvSrc, (*pcLen) * (*piFormat) / 8);
     1920        clipConvertX11CB(pClient, pvSrc, (*pcLen) * (*piFormat) / 8);
    19211921
    19221922    XtFree((char *)pvSrc);

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

    r79042 r80444  
    4444    PasteboardRef pasteboard;
    4545
    46     PVBOXCLIPBOARDCLIENTDATA pClientData;
     46    PVBOXCLIPBOARDCLIENT pClient;
    4747};
    4848
    … …  
    6363static int vboxClipboardChanged(VBOXCLIPBOARDCONTEXT *pCtx)
    6464{
    65     if (pCtx->pClientData == NULL)
     65    if (pCtx->pClient == NULL)
    6666        return VINF_SUCCESS;
    6767
    … …  
    7272    if (RT_SUCCESS(rc) && fChanged)
    7373    {
    74         vboxSvcClipboardReportMsg(pCtx->pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, fFormats);
     74        vboxSvcClipboardOldReportMsg(pCtx->pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE, fFormats);
    7575        Log(("vboxClipboardChanged fFormats %02X\n", fFormats));
    7676    }
    … …  
    157157    destroyPasteboard(&g_ctx.pasteboard);
    158158    g_ctx.thread = NIL_RTTHREAD;
    159     g_ctx.pClientData = NULL;
    160 }
    161 
    162 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA pClientData, bool fHeadless)
    163 {
    164     NOREF(fHeadless);
    165     if (g_ctx.pClientData != NULL)
     159    g_ctx.pClient = NULL;
     160}
     161
     162int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless)
     163{
     164    RT_NOREF(fHeadless);
     165
     166    if (g_ctx.pClient != NULL)
    166167    {
    167168        /* One client only. */
    … …  
    171172    VBoxSvcClipboardLock();
    172173
    173     pClientData->State.pCtx = &g_ctx;
    174     pClientData->State.pCtx->pClientData = pClientData;
     174    pClient->State.pCtx = &g_ctx;
     175    pClient->State.pCtx->pClient = pClient;
    175176
    176177    /* Initially sync the host clipboard content with the client. */
    177     int rc = VBoxClipboardSvcImplSync(pClientData);
    178 
    179     VBoxSvcClipboardUnlock();
    180     return rc;
    181 }
    182 
    183 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA pClientData)
     178    int rc = VBoxClipboardSvcImplSync(pClient);
     179
     180    VBoxSvcClipboardUnlock();
     181    return rc;
     182}
     183
     184int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient)
    184185{
    185186    /* Sync the host clipboard content with the client. */
    186187    VBoxSvcClipboardLock();
    187     int rc = vboxClipboardChanged(pClientData->State.pCtx);
    188     VBoxSvcClipboardUnlock();
    189 
    190     return rc;
    191 }
    192 
    193 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA pClientData)
    194 {
    195     VBoxSvcClipboardLock();
    196     pClientData->State.pCtx->pClientData = NULL;
     188    int rc = vboxClipboardChanged(pClient->State.pCtx);
     189    VBoxSvcClipboardUnlock();
     190
     191    return rc;
     192}
     193
     194int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient)
     195{
     196    VBoxSvcClipboardLock();
     197    pClient->State.pCtx->pClient = NULL;
    197198    VBoxSvcClipboardUnlock();
    198199
    … …  
    200201}
    201202
    202 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Formats)
    203 {
    204     LogFlowFunc(("u32Formats=%02X\n", u32Formats));
    205 
    206     if (u32Formats == 0)
     203int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
     204                                       PSHAREDCLIPBOARDFORMATDATA pFormats)
     205{
     206    RT_NOREF(pCmdCtx);
     207
     208    LogFlowFunc(("uFormats=%02X\n", pFormats->uFormats));
     209
     210    if (pFormats->uFormats == 0)
    207211    {
    208212        /* This is just an automatism, not a genuine announcement */
    … …  
    210214    }
    211215
    212     return vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Formats);
     216#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     217    if (pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) /* No URI support yet. */
     218        return VINF_SUCCESS;
     219#endif
     220
     221    return vboxSvcClipboardOldReportMsg(pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, pFormats->uFormats);
    213222}
    214223
    … …  
    216225 * Called by the HGCM clipboard subsystem when the guest wants to read the host clipboard.
    217226 *
    218  * @param pClientData   Context information about the guest VM
    219  * @param u32Format     The format that the guest would like to receive the data in
    220  * @param pv            Where to write the data to
    221  * @param cb            The size of the buffer to write the data to
    222  * @param pcbActual     Where to write the actual size of the written data
    223  */
    224 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Format,
    225                                  void *pv, uint32_t cb, uint32_t *pcbActual)
     227 * @param pClient               Context information about the guest VM.
     228 * @param pData                 Data block to put read data into.
     229 * @param pcbActual             Where to write the actual size of the written data.
     230 */
     231int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient,
     232                                 PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual)
    226233{
    227234    VBoxSvcClipboardLock();
    … …  
    229236    /* Default to no data available. */
    230237    *pcbActual = 0;
    231     int rc = readFromPasteboard(pClientData->State.pCtx->pasteboard, u32Format, pv, cb, pcbActual);
    232 
    233     VBoxSvcClipboardUnlock();
     238
     239    int rc = readFromPasteboard(pClient->State.pCtx->pasteboard,
     240                                pData->uFormat, pData->pvData, pData->cbData, pcbActual);
     241
     242    VBoxSvcClipboardUnlock();
     243
    234244    return rc;
    235245}
    … …  
    238248 * Called by the HGCM clipboard subsystem when we have requested data and that data arrives.
    239249 *
    240  * @param pClientData   Context information about the guest VM
    241  * @param pv            Buffer to which the data was written
    242  * @param cb            The size of the data written
    243  * @param u32Format     The format of the data written
    244  */
    245 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA pClientData, void *pv, uint32_t cb, uint32_t u32Format)
    246 {
    247     VBoxSvcClipboardLock();
    248 
    249     writeToPasteboard(pClientData->State.pCtx->pasteboard, pv, cb, u32Format);
     250 * @param pClient       Context information about the guest VM
     251 * @param pData         Data block to write to clipboard.
     252 */
     253int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDDATABLOCK pData)
     254{
     255    VBoxSvcClipboardLock();
     256
     257    writeToPasteboard(pClient->State.pCtx->pasteboard, pData->pvData, pData->cbData, pData->uFormat);
    250258
    251259    VBoxSvcClipboardUnlock();
    … …  
    255263
    256264#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    257 int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData)
    258 {
    259     RT_NOREF(pClientData, pDirData);
    260     return VERR_NOT_IMPLEMENTED;
    261 }
    262 
    263 int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData)
    264 {
    265     RT_NOREF(pClientData, pDirData);
    266     return VERR_NOT_IMPLEMENTED;
    267 }
    268 
    269 int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr)
    270 {
    271     RT_NOREF(pClientData, pFileHdr);
    272     return VERR_NOT_IMPLEMENTED;
    273 }
    274 
    275 int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr)
    276 {
    277     RT_NOREF(pClientData, pFileHdr);
    278     return VERR_NOT_IMPLEMENTED;
    279 }
    280 
    281 int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData)
    282 {
    283     RT_NOREF(pClientData, pFileData);
    284     return VERR_NOT_IMPLEMENTED;
    285 }
    286 
    287 int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData)
    288 {
    289     RT_NOREF(pClientData, pFileData);
     265int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDDIRDATA pDirData)
     266{
     267    RT_NOREF(pClient, pDirData);
     268    return VERR_NOT_IMPLEMENTED;
     269}
     270
     271int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDDIRDATA pDirData)
     272{
     273    RT_NOREF(pClient, pDirData);
     274    return VERR_NOT_IMPLEMENTED;
     275}
     276
     277int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEHDR pFileHdr)
     278{
     279    RT_NOREF(pClient, pFileHdr);
     280    return VERR_NOT_IMPLEMENTED;
     281}
     282
     283int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEHDR pFileHdr)
     284{
     285    RT_NOREF(pClient, pFileHdr);
     286    return VERR_NOT_IMPLEMENTED;
     287}
     288
     289int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEDATA pFileData)
     290{
     291    RT_NOREF(pClient, pFileData);
     292    return VERR_NOT_IMPLEMENTED;
     293}
     294
     295int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEDATA pFileData)
     296{
     297    RT_NOREF(pClient, pFileData);
    290298    return VERR_NOT_IMPLEMENTED;
    291299}

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

    r80320 r80444  
    8080
    8181/**
    82  * Structure for keeping generic client state data within the Shared Clipboard host service.
    83  * This structure needs to be serializable by SSM (must be a POD type).
    84  */
    85 typedef struct VBOXCLIPBOARDCLIENTSTATE
    86 {
    87     struct VBOXCLIPBOARDCLIENTSTATE *pNext;
    88     struct VBOXCLIPBOARDCLIENTSTATE *pPrev;
    89 
    90     VBOXCLIPBOARDCONTEXT *pCtx;
    91 
    92     uint32_t u32ClientID;
    93 
    94     SHAREDCLIPBOARDSOURCE enmSource;
    95 
     82 * Structure for keeping the old client state tracking,
     83 * needed for compatbility to older Guest Additions (for now). Remove this later.
     84 */
     85typedef struct VBOXCLIPBOARDCLIENTSTATEOLD
     86{
    9687    /** The guest is waiting for a message. */
    9788    bool fAsync;
    … …  
    10596    bool fHostMsgFormats;
    10697
    107 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    108     /** The client's URI state. */
    109     VBOXCLIPBOARDCLIENTURISTATE URI;
    110 #endif
    111 
    11298    struct {
    11399        VBOXHGCMCALLHANDLE callHandle;
    … …  
    130116    uint32_t u32AvailableFormats;
    131117    uint32_t u32RequestedFormat;
     118} VBOXCLIPBOARDCLIENTSTATEOLD;
     119
     120/**
     121 * Structure for keeping generic client state data within the Shared Clipboard host service.
     122 * This structure needs to be serializable by SSM (must be a POD type).
     123 */
     124typedef struct VBOXCLIPBOARDCLIENTSTATE
     125{
     126    struct VBOXCLIPBOARDCLIENTSTATE *pNext;
     127    struct VBOXCLIPBOARDCLIENTSTATE *pPrev;
     128
     129    VBOXCLIPBOARDCONTEXT            *pCtx;
     130
     131    /** The client's HGCM ID. */
     132    uint32_t                         u32ClientID;
     133    /** Optional protocol version the client uses. Set to 0 by default. */
     134    uint32_t                         uProtocolVer;
     135    /** Maximum chunk size to use for data transfers. Set to _64K by default. */
     136    uint32_t                         cbChunkSize;
     137    SHAREDCLIPBOARDSOURCE            enmSource;
     138    /** Old cruft (needed for VBox Guest Additions <= 6.0), remove this some time later. */
     139    VBOXCLIPBOARDCLIENTSTATEOLD      Old;
     140#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     141    /** The client's URI state. */
     142    VBOXCLIPBOARDCLIENTURISTATE      URI;
     143#endif
    132144} VBOXCLIPBOARDCLIENTSTATE, *PVBOXCLIPBOARDCLIENTSTATE;
    133145
    134 /**
    135  * Structure for keeping a HGCM client state within the Shared Clipboard host service.
    136  */
    137 typedef struct _VBOXCLIPBOARDCLIENTDATA
    138 {
     146typedef struct _VBOXCLIPBOARDCLIENTCMDCTX
     147{
     148    uint32_t                          uContextID;
     149} VBOXCLIPBOARDCLIENTCMDCTX, *PVBOXCLIPBOARDCLIENTCMDCTX;
     150
     151typedef struct _VBOXCLIPBOARDCLIENT
     152{
     153    /** The client's HGCM client ID. */
     154    uint32_t                          uClientID;
    139155    /** General client state data. */
    140156    VBOXCLIPBOARDCLIENTSTATE          State;
    141157    /** The client's message queue (FIFO). */
    142158    RTCList<VBOXCLIPBOARDCLIENTMSG *> queueMsg;
     159    /** The client's own event source. */
     160    SHAREDCLIPBOARDEVENTSOURCE        Events;
    143161#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    144162    /** URI context data. */
    145163    SHAREDCLIPBOARDURICTX             URI;
    146164#endif
    147 } VBOXCLIPBOARDCLIENTDATA, *PVBOXCLIPBOARDCLIENTDATA;
    148 
    149 typedef struct _VBOXCLIPBOARDCLIENT
    150 {
    151     /** The client's HGCM client ID. */
    152     uint32_t                 uClientID;
    153     /** Pointer to the client'data, owned by HGCM. */
    154     PVBOXCLIPBOARDCLIENTDATA pData;
    155     /** Optional protocol version the client uses. Set to 0 by default. */
    156     uint32_t                 uProtocolVer;
    157165    /** Structure for keeping the client's pending (deferred return) state.
    158166     *  A client is in a deferred state when it asks for the next HGCM message,
    … …  
    173181} VBOXCLIPBOARDCLIENT, *PVBOXCLIPBOARDCLIENT;
    174182
     183typedef struct _VBOXCLIPBOARDCLIENTMAPENTRY
     184{
     185} VBOXCLIPBOARDCLIENTMAPENTRY;
     186
    175187/** Map holding pointers to drag and drop clients. Key is the (unique) HGCM client ID. */
    176 typedef std::map<uint32_t, VBOXCLIPBOARDCLIENT *> ClipboardClientMap;
     188typedef std::map<uint32_t, VBOXCLIPBOARDCLIENTMAPENTRY> ClipboardClientMap;
    177189
    178190/** Simple queue (list) which holds deferred (waiting) clients. */
    … …  
    182194 * The service functions. Locking is between the service thread and the platform-dependent (window) thread.
    183195 */
    184 int vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, int rc, uint32_t cbActual);
     196int vboxSvcClipboardSendFormatsWrite(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDFORMATDATA pFormats);
     197
     198int vboxSvcClipboardOldCompleteReadData(PVBOXCLIPBOARDCLIENT pClient, int rc, uint32_t cbActual);
     199int vboxSvcClipboardOldReportMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t uMsg, uint32_t uFormats);
     200
    185201uint32_t vboxSvcClipboardGetMode(void);
    186 int vboxSvcClipboardReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t uMsg, uint32_t uFormats);
    187 int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENTDATA pClientData, SHAREDCLIPBOARDSOURCE enmSource);
    188 
    189 void vboxSvcClipboardMsgQueueReset(PVBOXCLIPBOARDCLIENTDATA pClientData);
     202int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENT pClient, SHAREDCLIPBOARDSOURCE enmSource);
     203
     204void vboxSvcClipboardMsgQueueReset(PVBOXCLIPBOARDCLIENT pClient);
    190205PVBOXCLIPBOARDCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms);
    191206void vboxSvcClipboardMsgFree(PVBOXCLIPBOARDCLIENTMSG pMsg);
    192207void vboxSvcClipboardMsgSetPeekReturn(PVBOXCLIPBOARDCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
    193 int vboxSvcClipboardMsgAdd(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDCLIENTMSG pMsg, bool fAppend);
     208int vboxSvcClipboardMsgAdd(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTMSG pMsg, bool fAppend);
    194209int vboxSvcClipboardMsgPeek(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
    195210int vboxSvcClipboardMsgGet(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    … …  
    199214# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    200215bool vboxSvcClipboardURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
    201 int  vboxSvcClipboardURIReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Msg, uint32_t u32Formats);
    202 bool vboxSvcClipboardURIReturnMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    203216# endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    204217
    … …  
    209222void VBoxClipboardSvcImplDestroy(void);
    210223
    211 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA pClientData, bool fHeadless);
    212 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA pClientData);
    213 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Formats);
    214 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Format, void *pv, uint32_t cb, uint32_t *pcbActual);
    215 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA pClientData, void *pv, uint32_t cb, uint32_t u32Format);
     224int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless);
     225int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient);
     226int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDFORMATDATA pFormats);
     227int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual);
     228int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData);
    216229/**
    217230 * Synchronise the contents of the host clipboard with the guest, called by the HGCM layer
    218231 * after a save and restore of the guest.
    219232 */
    220 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA pClientData);
     233int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient);
    221234
    222235#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    … …  
    251264DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
    252265
    253 int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    254 int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer);
     266int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer);
     267int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    255268#endif
    256269

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

    r80374 r80444  
    8989    if (pMsgHdr)
    9090    {
    91         uint16_t uEventHdrRead = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     91        uint16_t uEventHdrRead = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    9292
    9393        HGCMSvcSetU32(&pMsgHdr->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEventHdrRead));
    9494        HGCMSvcSetU32(&pMsgHdr->m_paParms[1], 0 /* fRoots */);
    9595
    96         rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsgHdr, true /* fAppend */);
    97         if (RT_SUCCESS(rc))
    98         {
    99             int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEventHdrRead);
     96        rc = vboxSvcClipboardMsgAdd(pClient, pMsgHdr, true /* fAppend */);
     97        if (RT_SUCCESS(rc))
     98        {
     99            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEventHdrRead);
    100100            AssertRC(rc2);
    101101
    … …  
    103103            if (RT_SUCCESS(rc))
    104104            {
    105                 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayloadHdr;
    106                 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEventHdrRead,
    107                                                          pCtx->pTransfer->uTimeoutMs, &pPayloadHdr);
     105                PSHAREDCLIPBOARDEVENTPAYLOAD pPayloadHdr;
     106                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEventHdrRead,
     107                                              pCtx->pTransfer->uTimeoutMs, &pPayloadHdr);
    108108                if (RT_SUCCESS(rc))
    109109                {
    … …  
    128128                                                                                                 VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
    129129
    130                                     uint16_t uEventEntryRead = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     130                                    uint16_t uEventEntryRead = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    131131
    132132                                    HGCMSvcSetU32(&pMsgEntry->m_paParms[0],
    … …  
    135135                                    HGCMSvcSetU32(&pMsgEntry->m_paParms[2], i /* uIndex */);
    136136
    137                                     int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEventEntryRead);
     137                                    rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEventEntryRead);
    138138                                    AssertRC(rc2);
    139139
    140                                     rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsgEntry, true /* fAppend */);
     140                                    rc = vboxSvcClipboardMsgAdd(pClient, pMsgEntry, true /* fAppend */);
    141141                                    if (RT_FAILURE(rc))
    142142                                        break;
    143143
    144                                     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayloadEntry;
    145                                     rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEventEntryRead,
    146                                                                              pCtx->pTransfer->uTimeoutMs, &pPayloadEntry);
     144                                    PSHAREDCLIPBOARDEVENTPAYLOAD pPayloadEntry;
     145                                    rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEventEntryRead,
     146                                                                  pCtx->pTransfer->uTimeoutMs, &pPayloadEntry);
    147147                                    if (RT_FAILURE(rc))
    148148                                        break;
    … …  
    153153                                    rc = SharedClipboardURIListEntryCopy(&pRootList->paEntries[i], pSrcRootListEntry);
    154154
    155                                     SharedClipboardURITransferPayloadFree(pPayloadEntry);
    156 
    157                                     SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEventEntryRead);
     155                                    SharedClipboardPayloadFree(pPayloadEntry);
     156
     157                                    SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEventEntryRead);
    158158
    159159                                    if (RT_FAILURE(rc))
    … …  
    175175                            SharedClipboardURIRootListFree(pRootList);
    176176
    177                         SharedClipboardURITransferPayloadFree(pPayloadHdr);
     177                        SharedClipboardPayloadFree(pPayloadHdr);
    178178                    }
    179179                    else
    … …  
    182182            }
    183183
    184             SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEventHdrRead);
     184            SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEventHdrRead);
    185185        }
    186186    }
    … …  
    206206    if (pMsg)
    207207    {
    208         const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     208        const uint16_t uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    209209
    210210        pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent);
    … …  
    213213        if (RT_SUCCESS(rc))
    214214        {
    215             rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
    216             if (RT_SUCCESS(rc))
    217             {
    218                 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     215            rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     216            if (RT_SUCCESS(rc))
     217            {
     218                int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
    219219                AssertRC(rc2);
    220220
    … …  
    222222                if (RT_SUCCESS(rc))
    223223                {
    224                     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    225                     rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     224                    PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     225                    rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    226226                    if (RT_SUCCESS(rc))
    227227                    {
    … …  
    235235                        *phList = pReply->u.ListOpen.uHandle;
    236236
    237                         SharedClipboardURITransferPayloadFree(pPayload);
     237                        SharedClipboardPayloadFree(pPayload);
    238238                    }
    239239                }
    240240
    241                 SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEvent);
     241                SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEvent);
    242242            }
    243243        }
    … …  
    263263    if (pMsg)
    264264    {
    265         const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     265        const uint16_t uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    266266
    267267        pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent);
    … …  
    270270        if (RT_SUCCESS(rc))
    271271        {
    272             rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
    273             if (RT_SUCCESS(rc))
    274             {
    275                 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     272            rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     273            if (RT_SUCCESS(rc))
     274            {
     275                int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
    276276                AssertRC(rc2);
    277277
    … …  
    279279                if (RT_SUCCESS(rc))
    280280                {
    281                     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    282                     rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     281                    PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     282                    rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    283283                    if (RT_SUCCESS(rc))
    284                         SharedClipboardURITransferPayloadFree(pPayload);
    285                 }
    286 
    287                 SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEvent);
     284                        SharedClipboardPayloadFree(pPayload);
     285                }
     286
     287                SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEvent);
    288288            }
    289289        }
    … …  
    310310    if (pMsg)
    311311    {
    312         const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     312        const uint16_t uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    313313
    314314        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    … …  
    316316        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */);
    317317
    318         rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
    319         if (RT_SUCCESS(rc))
    320         {
    321             int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     318        rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     319        if (RT_SUCCESS(rc))
     320        {
     321            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
    322322            AssertRC(rc2);
    323323
    … …  
    325325            if (RT_SUCCESS(rc))
    326326            {
    327                 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    328                 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent,
     327                PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     328                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
    329329                                                         pCtx->pTransfer->uTimeoutMs, &pPayload);
    330330                if (RT_SUCCESS(rc))
    … …  
    334334                    *pListHdr = *(PVBOXCLIPBOARDLISTHDR)pPayload->pvData;
    335335
    336                     SharedClipboardURITransferPayloadFree(pPayload);
     336                    SharedClipboardPayloadFree(pPayload);
    337337                }
    338338            }
    … …  
    370370    if (pMsg)
    371371    {
    372         const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     372        const uint16_t uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    373373
    374374        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    … …  
    376376        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fInfo */);
    377377
    378         rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
    379         if (RT_SUCCESS(rc))
    380         {
    381             int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     378        rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     379        if (RT_SUCCESS(rc))
     380        {
     381            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
    382382            AssertRC(rc2);
    383383
    … …  
    385385            if (RT_SUCCESS(rc))
    386386            {
    387                 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    388                 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     387                PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     388                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    389389                if (RT_SUCCESS(rc))
    390390                {
    … …  
    393393                    rc = SharedClipboardURIListEntryCopy(pListEntry, (PVBOXCLIPBOARDLISTENTRY)pPayload->pvData);
    394394
    395                     SharedClipboardURITransferPayloadFree(pPayload);
     395                    SharedClipboardPayloadFree(pPayload);
    396396                }
    397397            }
    … …  
    429429    if (pMsg)
    430430    {
    431         const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     431        const uint16_t uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    432432
    433433        LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pCreateParms->pszPath, pCreateParms->fCreate));
    … …  
    441441        HGCMSvcSetU32(&pMsg->m_paParms[4], pCreateParms->fCreate);
    442442
    443         rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
    444         if (RT_SUCCESS(rc))
    445         {
    446             int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     443        rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     444        if (RT_SUCCESS(rc))
     445        {
     446            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
    447447            AssertRC(rc2);
    448448
    … …  
    450450            if (RT_SUCCESS(rc))
    451451            {
    452                 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    453                 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     452                PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     453                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    454454                if (RT_SUCCESS(rc))
    455455                {
    … …  
    463463                    *phObj = pReply->u.ObjOpen.uHandle;
    464464
    465                     SharedClipboardURITransferPayloadFree(pPayload);
     465                    SharedClipboardPayloadFree(pPayload);
    466466                }
    467467            }
    … …  
    488488    if (pMsg)
    489489    {
    490         const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     490        const uint16_t uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    491491
    492492        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    493493        HGCMSvcSetU64(&pMsg->m_paParms[1], hObj);
    494494
    495         rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
    496         if (RT_SUCCESS(rc))
    497         {
    498             int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     495        rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     496        if (RT_SUCCESS(rc))
     497        {
     498            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
    499499            AssertRC(rc2);
    500500
    … …  
    502502            if (RT_SUCCESS(rc))
    503503            {
    504                 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    505                 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     504                PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     505                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    506506                if (RT_SUCCESS(rc))
    507507                {
    508508                    Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
    509509
     510#ifdef VBOX_STRICT
    510511                    PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
    511512                    AssertPtr(pReply);
    512513
    513514                    Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE);
    514 
    515                     SharedClipboardURITransferPayloadFree(pPayload);
     515#endif
     516
     517                    SharedClipboardPayloadFree(pPayload);
    516518                }
    517519            }
    … …  
    539541    if (pMsg)
    540542    {
    541         const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     543        const uint16_t uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    542544
    543545        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    … …  
    546548        HGCMSvcSetU32(&pMsg->m_paParms[3], fFlags);
    547549
    548         rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
    549         if (RT_SUCCESS(rc))
    550         {
    551             int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     550        rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     551        if (RT_SUCCESS(rc))
     552        {
     553            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
    552554            AssertRC(rc2);
    553555
    … …  
    555557            if (RT_SUCCESS(rc))
    556558            {
    557                 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    558                 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     559                PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     560                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    559561                if (RT_SUCCESS(rc))
    560562                {
    … …  
    571573                        *pcbRead = cbRead;
    572574
    573                     SharedClipboardURITransferPayloadFree(pPayload);
     575                    SharedClipboardPayloadFree(pPayload);
    574576                }
    575577            }
    … …  
    597599    if (pMsg)
    598600    {
    599         const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     601        const uint16_t uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    600602
    601603        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    … …  
    604606        HGCMSvcSetU64(&pMsg->m_paParms[3], fFlags);
    605607
    606         rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
    607         if (RT_SUCCESS(rc))
    608         {
    609             int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     608        rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     609        if (RT_SUCCESS(rc))
     610        {
     611            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
    610612            AssertRC(rc2);
    611613
    … …  
    613615            if (RT_SUCCESS(rc))
    614616            {
    615                 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    616                 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     617                PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     618                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    617619                if (RT_SUCCESS(rc))
    618620                {
    … …  
    624626                        *pcbWritten = cbRead;
    625627
    626                     SharedClipboardURITransferPayloadFree(pPayload);
     628                    SharedClipboardPayloadFree(pPayload);
    627629                }
    628630            }
    … …  
    942944        if (RT_SUCCESS(rc))
    943945            rc = HGCMSvcGetU64(&paParms[5], &pListHdr->cbTotalSize);
    944         if (RT_SUCCESS(rc))
    945             rc = HGCMSvcGetU32(&paParms[6], &pListHdr->enmCompression);
    946         if (RT_SUCCESS(rc))
    947             rc = HGCMSvcGetU32(&paParms[7], (uint32_t *)&pListHdr->enmChecksumType);
    948946
    949947        if (RT_SUCCESS(rc))
    … …  
    960958}
    961959
     960#if 0
    962961/**
    963962 * Sets an URI list header to HGCM service parameters.
    … …  
    974973    int rc;
    975974
    976     if (   cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR
    977         || cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
     975    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
    978976    {
    979977        /** @todo Set pvMetaFmt + cbMetaFmt. */
    … …  
    985983        HGCMSvcSetU64(&paParms[3], pListHdr->cTotalObjects);
    986984        HGCMSvcSetU64(&paParms[4], pListHdr->cbTotalSize);
    987         HGCMSvcSetU32(&paParms[5], pListHdr->enmCompression);
    988         HGCMSvcSetU32(&paParms[6], pListHdr->enmChecksumType);
    989985
    990986        rc = VINF_SUCCESS;
    … …  
    996992    return rc;
    997993}
     994#endif
    998995
    999996/**
    … …  
    10421039}
    10431040
     1041#if 0
    10441042/**
    10451043 * Sets an URI data chunk to HGCM service parameters.
    … …  
    10731071    return rc;
    10741072}
     1073#endif
    10751074
    10761075/**
    … …  
    11611160        if (RT_SUCCESS(rc))
    11621161        {
    1163             PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload
    1164                 = (PSHAREDCLIPBOARDURITRANSFERPAYLOAD)RTMemAlloc(sizeof(SHAREDCLIPBOARDURITRANSFERPAYLOAD));
     1162            PSHAREDCLIPBOARDEVENTPAYLOAD pPayload
     1163                = (PSHAREDCLIPBOARDEVENTPAYLOAD)RTMemAlloc(sizeof(SHAREDCLIPBOARDEVENTPAYLOAD));
    11651164            if (pPayload)
    11661165            {
    … …  
    11861185                            LogFlowFunc(("uCID=%RU32 -> uEvent=%RU32\n", uCID, uEvent));
    11871186
    1188                             rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1187                            rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
    11891188                        }
    11901189                        break;
    … …  
    12421241                 pClient->uClientID, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, g_pfnExtension));
    12431242
    1244     const PVBOXCLIPBOARDCLIENTDATA pClientData = pClient->pData;
    1245     AssertPtrReturn(pClientData, VERR_INVALID_POINTER);
    1246 
    12471243    /* Check if we've the right mode set. */
    12481244    if (!vboxSvcClipboardURIMsgIsAllowed(vboxSvcClipboardGetMode(), u32Function))
    … …  
    12711267    switch (u32Function)
    12721268    {
    1273         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
    1274             RT_FALL_THROUGH();
    1275         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
    1276             RT_FALL_THROUGH();
    1277         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
    1278             RT_FALL_THROUGH();
    12791269        case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
    12801270            break;
    12811271        default:
    12821272        {
    1283             if (!SharedClipboardURICtxGetTotalTransfers(&pClientData->URI))
     1273            if (!SharedClipboardURICtxGetTotalTransfers(&pClient->URI))
    12841274            {
    12851275                LogFunc(("No transfers found\n"));
    … …  
    12901280            const uint32_t uTransferID = 0; /* Only one transfer per client is supported at the moment. */
    12911281
    1292             pTransfer = SharedClipboardURICtxGetTransfer(&pClientData->URI, uTransferID);
     1282            pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, uTransferID);
    12931283            if (!pTransfer)
    12941284            {
    … …  
    13071297    switch (u32Function)
    13081298    {
     1299#if 0
    13091300        case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
    13101301        {
    1311             LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS\n", pClient->uClientID));
    1312 
    13131302            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_STATUS)
    13141303                break;
    … …  
    13211310            LogFlowFunc(("uStatus: %RU32\n", uStatus));
    13221311
    1323             if (   uStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING
    1324                 && !SharedClipboardURICtxTransfersMaximumReached(&pClientData->URI))
    1325             {
    1326                 SharedClipboardURICtxTransfersCleanup(&pClientData->URI);
    1327 
     1312            SharedClipboardURICtxTransfersCleanup(&pClient->URI);
     1313
     1314            if (SharedClipboardURICtxTransfersMaximumReached(&pClient->URI))
     1315            {
     1316                rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
     1317                break;
     1318            }
     1319
     1320            if (uStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING)
     1321            {
    13281322                const SHAREDCLIPBOARDURITRANSFERDIR enmDir = SHAREDCLIPBOARDURITRANSFERDIR_READ;
    13291323
    … …  
    13331327                if (RT_SUCCESS(rc))
    13341328                {
    1335                     rc = vboxSvcClipboardURIAreaRegister(&pClientData->State, pTransfer);
     1329                    rc = vboxSvcClipboardURIAreaRegister(&pClient->State, pTransfer);
    13361330                    if (RT_SUCCESS(rc))
    13371331                    {
    … …  
    13391333                        RT_ZERO(creationCtx);
    13401334
    1341                         creationCtx.enmSource = pClientData->State.enmSource;
     1335                        creationCtx.enmSource = pClient->State.enmSource;
    13421336
    13431337                        creationCtx.Interface.pfnTransferOpen  = vboxSvcClipboardURITransferOpen;
    … …  
    13661360                        RT_ZERO(Callbacks);
    13671361
    1368                         Callbacks.pvUser                = pClientData;
     1362                        Callbacks.pvUser                = pClient;
    13691363
    13701364                        Callbacks.pfnTransferPrepare    = VBoxSvcClipboardURITransferPrepareCallback;
    … …  
    13771371                        rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
    13781372                        if (RT_SUCCESS(rc))
    1379                             rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer);
     1373                            rc = SharedClipboardURICtxTransferAdd(&pClient->URI, pTransfer);
    13801374                    }
    13811375
    13821376                    if (RT_SUCCESS(rc))
    13831377                    {
    1384                         rc = VBoxClipboardSvcImplURITransferCreate(pClientData, pTransfer);
     1378                        rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer);
    13851379                        if (RT_SUCCESS(rc))
    1386                             rc = VBoxClipboardSvcImplFormatAnnounce(pClientData, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
     1380                            rc = VBoxClipboardSvcImplFormatAnnounce(pClient, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
    13871381                    }
    13881382
    13891383                    if (RT_FAILURE(rc))
    13901384                    {
    1391                         VBoxClipboardSvcImplURITransferDestroy(pClientData, pTransfer);
     1385                        VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer);
    13921386                        SharedClipboardURITransferDestroy(pTransfer);
    13931387                    }
    13941388                }
    13951389            }
    1396             else
    1397                 rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
    13981390
    13991391            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS: %Rrc\n", pClient->uClientID, rc));
    … …  
    14041396            break;
    14051397        }
    1406 
    1407         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
    1408         {
    1409             rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
    1410             break;
    1411         }
    1412 
    1413         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
    1414         {
    1415             rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
    1416             break;
    1417         }
    1418 
    1419         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
    1420         {
    1421             rc = vboxSvcClipboardMsgGet(pClient, callHandle, cParms, paParms);
    1422             break;
    1423         }
     1398#endif
    14241399
    14251400        case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY:
    … …  
    14491424                    const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    14501425
    1451                     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    1452                     rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1426                    PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1427                    rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    14531428                    if (RT_SUCCESS(rc))
    14541429                    {
    1455                         rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1430                        rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
    14561431                        if (RT_FAILURE(rc))
    1457                             SharedClipboardURITransferPayloadFree(pPayload);
     1432                            SharedClipboardPayloadFree(pPayload);
    14581433                    }
    14591434                }
    … …  
    14981473                    const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    14991474
    1500                     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    1501                     rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1475                    PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1476                    rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    15021477                    if (RT_SUCCESS(rc))
    15031478                    {
    1504                         rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1479                        rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
    15051480                        if (RT_FAILURE(rc))
    1506                             SharedClipboardURITransferPayloadFree(pPayload);
     1481                            SharedClipboardPayloadFree(pPayload);
    15071482                    }
    15081483                }
    … …  
    15781553                        const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    15791554
    1580                         PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    1581                         rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1555                        PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1556                        rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    15821557                        if (RT_SUCCESS(rc))
    15831558                        {
    1584                             rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1559                            rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
    15851560                            if (RT_FAILURE(rc))
    1586                                 SharedClipboardURITransferPayloadFree(pPayload);
     1561                                SharedClipboardPayloadFree(pPayload);
    15871562                        }
    15881563                    }
    … …  
    16261601                        const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    16271602
    1628                         PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    1629                         rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1603                        PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1604                        rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    16301605                        if (RT_SUCCESS(rc))
    16311606                        {
    1632                             rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1607                            rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
    16331608                            if (RT_FAILURE(rc))
    1634                                 SharedClipboardURITransferPayloadFree(pPayload);
     1609                                SharedClipboardPayloadFree(pPayload);
    16351610                        }
    16361611                    }
    … …  
    16721647                    const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    16731648
    1674                     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    1675                     rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1649                    PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1650                    rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    16761651                    if (RT_SUCCESS(rc))
    16771652                    {
    1678                         rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1653                        rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
    16791654                        if (RT_FAILURE(rc))
    1680                             SharedClipboardURITransferPayloadFree(pPayload);
     1655                            SharedClipboardPayloadFree(pPayload);
    16811656                    }
    16821657                }
    … …  
    19061881    switch (u32Function)
    19071882    {
    1908         case VBOX_SHARED_CLIPBOARD_HOST_FN_CANCEL:
    1909             /** @todo */
    1910             break;
    1911 
    1912         case VBOX_SHARED_CLIPBOARD_HOST_FN_ERROR:
    1913             /** @todo */
     1883        case VBOX_SHARED_CLIPBOARD_HOST_FN_CANCEL: /** @todo Implement this. */
     1884            break;
     1885
     1886        case VBOX_SHARED_CLIPBOARD_HOST_FN_ERROR: /** @todo Implement this. */
    19141887            break;
    19151888

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

    r80374 r80444  
    9292}
    9393
    94 int vboxSvcClipboardURIReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t uMsg, uint32_t uParm)
     94#if 0
     95int vboxSvcClipboardURIReportMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t uMsg, uint32_t uParm)
    9596{
    96     AssertPtrReturn(pClientData, VERR_INVALID_POINTER);
     97    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    9798
    9899    int rc = VINF_SUCCESS;
    … …  
    102103        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START:
    103104        {
    104             Assert(pClientData->State.URI.fTransferStart == false);
     105            Assert(pClient->State.URI.fTransferStart == false);
    105106
    106107            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START\n"));
    … …  
    113114            }
    114115
    115             pClientData->State.URI.fTransferStart = true;
    116             pClientData->State.URI.enmTransferDir = (SHAREDCLIPBOARDURITRANSFERDIR)uParm;
     116            pClient->State.URI.fTransferStart = true;
     117            pClient->State.URI.enmTransferDir = (SHAREDCLIPBOARDURITRANSFERDIR)uParm;
    117118            break;
    118119
    … …  
    129130}
    130131
    131 bool vboxSvcClipboardURIReturnMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     132bool vboxSvcClipboardURIReturnMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    132133{
    133     RT_NOREF(pClientData, cParms, paParms);
     134    RT_NOREF(pClient, cParms, paParms);
    134135
    135136    bool fHandled = false;
    136137
    137     if (   pClientData->State.URI.fTransferStart
     138    if (   pClient->State.URI.fTransferStart
    138139        && cParms >= 2)
    139140    {
    140141        HGCMSvcSetU32(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START);
    141         HGCMSvcSetU32(&paParms[1], pClientData->State.URI.enmTransferDir);
    142         pClientData->State.URI.fTransferStart = false;
     142        HGCMSvcSetU32(&paParms[1], pClient->State.URI.enmTransferDir);
     143        pClient->State.URI.fTransferStart = false;
    143144
    144145        fHandled = true;
    … …  
    148149    return fHandled;
    149150}
     151#endif
    150152#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    151153

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

    r80374 r80444  
    5555static int vboxClipboardSvcWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx);
    5656
     57typedef struct _VBOXCLIPBOARDCONTEXTOLD
     58{
     59    /** Event which gets triggered if the host clipboard needs to render its data. */
     60    RTSEMEVENT               hRenderEvent;
     61} VBOXCLIPBOARDCONTEXTOLD;
     62
    5763struct _VBOXCLIPBOARDCONTEXT
    5864{
    5965    /** Handle for window message handling thread. */
    6066    RTTHREAD                 hThread;
    61     /** Event which gets triggered if the host clipboard needs to render its data. */
    62     RTSEMEVENT               hRenderEvent;
    63     /** Structure for keeping and communicating with client data (from the guest). */
    64     PVBOXCLIPBOARDCLIENTDATA pClientData;
     67    /** Structure for keeping and communicating with service client. */
     68    PVBOXCLIPBOARDCLIENT     pClient;
    6569    /** Windows-specific context data. */
    6670    VBOXCLIPBOARDWINCTX      Win;
     71    /** Old cruft, needed for the legacy protocol (v0). */
     72    VBOXCLIPBOARDCONTEXTOLD  Old;
    6773};
    6874
    … …  
    116122}
    117123
     124static int vboxClipboardSvcWinDataSet(PVBOXCLIPBOARDCONTEXT pCtx, UINT cfFormat, void *pvData, uint32_t cbData)
     125{
     126    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
     127    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
     128    AssertReturn   (cbData, VERR_INVALID_PARAMETER);
     129
     130    int rc = VINF_SUCCESS;
     131
     132    HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbData);
     133
     134    LogFlowFunc(("hMem=%p\n", hMem));
     135
     136    if (hMem)
     137    {
     138        void *pMem = GlobalLock(hMem);
     139
     140        LogFlowFunc(("pMem=%p, GlobalSize=%zu\n", pMem, GlobalSize(hMem)));
     141
     142        if (pMem)
     143        {
     144            LogFlowFunc(("Setting data\n"));
     145
     146            memcpy(pMem, pvData, cbData);
     147
     148            /* The memory must be unlocked before inserting to the Clipboard. */
     149            GlobalUnlock(hMem);
     150
     151            /* 'hMem' contains the host clipboard data.
     152             * size is 'cb' and format is 'format'.
     153             */
     154            HANDLE hClip = SetClipboardData(cfFormat, hMem);
     155
     156            LogFlowFunc(("hClip=%p\n", hClip));
     157
     158            if (hClip)
     159            {
     160                /* The hMem ownership has gone to the system. Nothing to do. */
     161            }
     162            else
     163                rc = RTErrConvertFromWin32(GetLastError());
     164        }
     165        else
     166            rc = VERR_ACCESS_DENIED;
     167
     168        GlobalFree(hMem);
     169    }
     170    else
     171        rc = RTErrConvertFromWin32(GetLastError());
     172
     173    LogFlowFuncLeaveRC(rc);
     174    return rc;
     175}
     176
    118177/**
    119  * Requests data of a specific format from the guest, optionally waiting for its arrival via VBoxClipboardSvcImplWriteData().
     178 * Requests data of a specific format from the guest, optionally waiting for its arrival via VBoxClipboardSvcImplWriteData()
     179 * and copying the retrieved data into the OS' clipboard.
     180 *
     181 * Legacy protocol, do not use anymore.
    120182 *
    121183 * @returns VBox status code.
    122184 * @param   pCtx                Clipboard context to use.
    123  * @param   fFormat             Format to receive data in.
     185 * @param   cfFormat            Windows clipboard format to receive data in.
    124186 * @param   uTimeoutMs          Timeout (in ms) to wait until the render event has been triggered.
    125187 *                              Specify 0 if no waiting is required.
    126188 */
    127 static int vboxClipboardSvcWinRequestData(PVBOXCLIPBOARDCONTEXT pCtx, VBOXCLIPBOARDFORMAT fFormat,
    128                                           RTMSINTERVAL uTimeoutMs)
    129 {
    130     AssertPtr(pCtx->pClientData);
    131     Assert(pCtx->hRenderEvent);
    132     Assert(pCtx->pClientData->State.data.pv == NULL && pCtx->pClientData->State.data.cb == 0 && pCtx->pClientData->State.data.u32Format == 0);
    133 
    134     LogFlowFunc(("fFormat=%02X, uTimeoutMs=%RU32\n", fFormat, uTimeoutMs));
    135 
    136     int rc = vboxSvcClipboardReportMsg(pCtx->pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, fFormat);
     189static int vboxClipboardSvcWinOldRequestData(PVBOXCLIPBOARDCONTEXT pCtx, UINT cfFormat,
     190                                             RTMSINTERVAL uTimeoutMs)
     191{
     192    Assert(pCtx->Old.hRenderEvent);
     193    Assert(pCtx->pClient->State.Old.data.pv == NULL && pCtx->pClient->State.Old.data.cb == 0 && pCtx->pClient->State.Old.data.u32Format == 0);
     194
     195    LogFlowFunc(("cfFormat=%u, uTimeoutMs=%RU32\n", cfFormat, uTimeoutMs));
     196
     197    const VBOXCLIPBOARDFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
     198
     199    int rc = vboxSvcClipboardOldReportMsg(pCtx->pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, fFormat);
    137200    if (   RT_SUCCESS(rc)
    138201        && uTimeoutMs)
    139202    {
    140         rc = RTSemEventWait(pCtx->hRenderEvent, uTimeoutMs /* Timeout in ms */);
    141     }
     203        rc = RTSemEventWait(pCtx->Old.hRenderEvent, uTimeoutMs /* Timeout in ms */);
     204        if (RT_SUCCESS(rc))
     205        {
     206            LogFlowFunc(("rc=%Rrc, pv=%p, cb=%RU32, u32Format=%RU32\n",
     207                         rc, pCtx->pClient->State.Old.data.pv, pCtx->pClient->State.Old.data.cb,
     208                         pCtx->pClient->State.Old.data.u32Format));
     209
     210            if (   RT_SUCCESS (rc)
     211                && pCtx->pClient->State.Old.data.pv != NULL
     212                && pCtx->pClient->State.Old.data.cb > 0
     213                && pCtx->pClient->State.Old.data.u32Format == fFormat)
     214            {
     215                rc = vboxClipboardSvcWinDataSet(pCtx, cfFormat,
     216                                                pCtx->pClient->State.Old.data.pv, pCtx->pClient->State.Old.data.cb);
     217
     218                if (pCtx->pClient->State.Old.data.pv)
     219                {
     220                    RTMemFree(pCtx->pClient->State.Old.data.pv);
     221                    pCtx->pClient->State.Old.data.pv = NULL;
     222                }
     223            }
     224
     225            if (RT_FAILURE(rc))
     226            {
     227                if (pCtx->pClient->State.Old.data.pv)
     228                {
     229                    RTMemFree(pCtx->pClient->State.Old.data.pv);
     230                    pCtx->pClient->State.Old.data.pv = NULL;
     231                }
     232
     233                pCtx->pClient->State.Old.data.cb        = 0;
     234                pCtx->pClient->State.Old.data.u32Format = 0;
     235
     236                /* Something went wrong. */
     237                VBoxClipboardWinClear();
     238            }
     239        }
     240    }
     241
     242    LogFlowFuncLeaveRC(rc);
     243    return rc;
     244}
     245
     246static int vboxClipboardSvcWinDataRead(PVBOXCLIPBOARDCONTEXT pCtx, UINT cfFormat,
     247                                       void **ppvData, uint32_t *pcbData)
     248{
     249    LogFlowFunc(("cfFormat=%u\n", cfFormat));
     250
     251    int rc;
     252
     253    PVBOXCLIPBOARDCLIENTMSG pMsgReadData = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     254                                                                    VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
     255    if (pMsgReadData)
     256    {
     257        const uint16_t uEvent = SharedClipboardEventIDGenerate(&pCtx->pClient->Events);
     258
     259        const VBOXCLIPBOARDFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
     260        const uint32_t            uCID    = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pClient->Events.uID, uEvent);
     261
     262        HGCMSvcSetU32(&pMsgReadData->m_paParms[0], uCID);
     263        HGCMSvcSetU32(&pMsgReadData->m_paParms[1], fFormat);
     264        HGCMSvcSetU32(&pMsgReadData->m_paParms[2], pCtx->pClient->State.cbChunkSize);
     265
     266        LogFlowFunc(("CID=%RU32\n", uCID));
     267
     268        rc = vboxSvcClipboardMsgAdd(pCtx->pClient, pMsgReadData, true /* fAppend */);
     269        if (RT_SUCCESS(rc))
     270        {
     271            int rc2 = SharedClipboardEventRegister(&pCtx->pClient->Events, uEvent);
     272            AssertRC(rc2);
     273
     274            rc = vboxSvcClipboardClientWakeup(pCtx->pClient);
     275            if (RT_SUCCESS(rc))
     276            {
     277                PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     278                rc = SharedClipboardEventWait(&pCtx->pClient->Events, uEvent,
     279                                              30 * 1000, &pPayload);
     280                if (RT_SUCCESS(rc))
     281                {
     282                    *ppvData = pPayload->pvData;
     283                    *pcbData = pPayload->cbData;
     284
     285                    /* Detach the payload, as the caller then will own the data. */
     286                    SharedClipboardEventPayloadDetach(&pCtx->pClient->Events, uEvent);
     287                }
     288            }
     289
     290            SharedClipboardEventUnregister(&pCtx->pClient->Events, uEvent);
     291        }
     292    }
     293    else
     294        rc = VERR_NO_MEMORY;
    142295
    143296    LogFlowFuncLeaveRC(rc);
    … …  
    167320                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    168321                if (RT_SUCCESS(rc))
    169                     vboxSvcClipboardSetSource(pCtx->pClientData, SHAREDCLIPBOARDSOURCE_LOCAL);
    170             }
    171         } break;
     322                    vboxSvcClipboardSetSource(pCtx->pClient, SHAREDCLIPBOARDSOURCE_LOCAL);
     323            }
     324
     325            break;
     326        }
    172327
    173328        case WM_CHANGECBCHAIN:
    … …  
    175330            LogFunc(("WM_CHANGECBCHAIN\n"));
    176331            lresultRc = VBoxClipboardWinHandleWMChangeCBChain(pWinCtx, hWnd, uMsg, wParam, lParam);
    177         } break;
     332            break;
     333        }
    178334
    179335        case WM_DRAWCLIPBOARD:
    … …  
    186342                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    187343                if (RT_SUCCESS(rc))
    188                     vboxSvcClipboardSetSource(pCtx->pClientData, SHAREDCLIPBOARDSOURCE_LOCAL);
     344                    vboxSvcClipboardSetSource(pCtx->pClient, SHAREDCLIPBOARDSOURCE_LOCAL);
    189345            }
    190346
    191347            lresultRc = VBoxClipboardWinChainPassToNext(pWinCtx, uMsg, wParam, lParam);
    192 
    193         } break;
     348            break;
     349        }
    194350
    195351        case WM_TIMER:
    … …  
    197353            int rc = VBoxClipboardWinHandleWMTimer(pWinCtx);
    198354            AssertRC(rc);
    199         } break;
     355
     356            break;
     357        }
    200358
    201359        case WM_RENDERFORMAT:
    … …  
    211369
    212370            if (   fFormat       == VBOX_SHARED_CLIPBOARD_FMT_NONE
    213                 || pCtx->pClientData == NULL)
     371                || pCtx->pClient == NULL)
    214372            {
    215373                /* Unsupported clipboard format is requested. */
    … …  
    219377            else
    220378            {
    221                 int rc = vboxClipboardSvcWinRequestData(pCtx, fFormat, 30 * 1000 /* 30s timeout */);
    222 
    223                 LogFlowFunc(("rc=%Rrc, pv=%p, cb=%RU32, u32Format=%RU32\n",
    224                              rc, pCtx->pClientData->State.data.pv, pCtx->pClientData->State.data.cb,
    225                              pCtx->pClientData->State.data.u32Format));
    226 
    227                 if (   RT_SUCCESS (rc)
    228                     && pCtx->pClientData->State.data.pv != NULL
    229                     && pCtx->pClientData->State.data.cb > 0
    230                     && pCtx->pClientData->State.data.u32Format == fFormat)
    231                 {
    232                     HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, pCtx->pClientData->State.data.cb);
    233 
    234                     LogFlowFunc(("hMem=%p\n", hMem));
    235 
    236                     if (hMem)
     379                int rc;
     380
     381                if (pCtx->pClient->State.uProtocolVer == 0)
     382                {
     383                    rc = vboxClipboardSvcWinOldRequestData(pCtx, cfFormat, 30 * 1000 /* 30s timeout */);
     384                }
     385                else
     386                {
     387                    void    *pvData = NULL;
     388                    uint32_t cbData = 0;
     389                    rc = vboxClipboardSvcWinDataRead(pCtx, cfFormat, &pvData, &cbData);
     390                    if (   RT_SUCCESS(rc)
     391                        && pvData
     392                        && cbData)
    237393                    {
    238                         void *pMem = GlobalLock(hMem);
    239 
    240                         LogFlowFunc(("pMem=%p, GlobalSize=%zu\n", pMem, GlobalSize(hMem)));
    241 
    242                         if (pMem)
    243                         {
    244                             LogFlowFunc(("WM_RENDERFORMAT: Setting data\n"));
    245 
    246                             if (pCtx->pClientData->State.data.pv)
    247                             {
    248                                 memcpy(pMem, pCtx->pClientData->State.data.pv, pCtx->pClientData->State.data.cb);
    249 
    250                                 RTMemFree(pCtx->pClientData->State.data.pv);
    251                                 pCtx->pClientData->State.data.pv        = NULL;
    252                             }
    253 
    254                             pCtx->pClientData->State.data.cb        = 0;
    255                             pCtx->pClientData->State.data.u32Format = 0;
    256 
    257                             /* The memory must be unlocked before inserting to the Clipboard. */
    258                             GlobalUnlock(hMem);
    259 
    260                             /* 'hMem' contains the host clipboard data.
    261                              * size is 'cb' and format is 'format'.
    262                              */
    263                             HANDLE hClip = SetClipboardData(cfFormat, hMem);
    264 
    265                             LogFlowFunc(("hClip=%p\n", hClip));
    266 
    267                             if (hClip)
    268                             {
    269                                 /* The hMem ownership has gone to the system. Nothing to do. */
    270                                 break;
    271                             }
    272                         }
    273 
    274                         GlobalFree(hMem);
     394                        rc = vboxClipboardSvcWinDataSet(pCtx, cfFormat, pvData, cbData);
     395
     396                        RTMemFree(pvData);
    275397                    }
    276                 }
    277 
    278                 RTMemFree(pCtx->pClientData->State.data.pv);
    279                 pCtx->pClientData->State.data.pv        = NULL;
    280                 pCtx->pClientData->State.data.cb        = 0;
    281                 pCtx->pClientData->State.data.u32Format = 0;
    282 
    283                 /* Something went wrong. */
    284                 VBoxClipboardWinClear();
    285             }
    286         } break;
     398                    else
     399                        AssertFailed();
     400                }
     401            }
     402
     403            break;
     404        }
    287405
    288406        case WM_RENDERALLFORMATS:
    … …  
    292410            int rc = VBoxClipboardWinHandleWMRenderAllFormats(pWinCtx, hWnd);
    293411            AssertRC(rc);
    294         } break;
     412
     413            break;
     414        }
    295415
    296416        case VBOX_CLIPBOARD_WM_REPORT_FORMATS:
    … …  
    298418            LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS\n"));
    299419
    300             if (   pCtx->pClientData == NULL
    301                 || pCtx->pClientData->State.fHostMsgFormats)
     420            /* Some legcay protocol checks. */
     421            if (   pCtx->pClient->State.uProtocolVer == 0
     422                && (   pCtx->pClient == NULL
     423                    || pCtx->pClient->State.Old.fHostMsgFormats))
    302424            {
    303425                /* Host has pending formats message. Ignore the guest announcement,
    304426                 * because host clipboard has more priority.
    305427                 */
    306                 LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS ignored; pClientData=%p\n", pCtx->pClientData));
     428                LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS ignored; pClient=%p\n", pCtx->pClient));
    307429                break;
    308430            }
    … …  
    316438                {
    317439                    VBoxClipboardWinClear();
    318 
    319 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     440#if 0
    320441                    if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    321442                    {
    322443                        LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST\n"));
    323444
    324                         PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pCtx->pClientData->URI,
     445                        PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pCtx->pClient->URI,
    325446                                                                                                 0 /* uIdx */);
    326447                        if (pTransfer)
    … …  
    342463
    343464                        VBoxClipboardWinClose();
    344 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     465#if 0
    345466                    }
    346467#endif
    347468                }
    348469
    349                 if (RT_FAILURE(rc))
    350                     LogFunc(("Failed with rc=%Rrc\n", rc));
    351             }
    352             LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS: fFormats=0x%x, lastErr=%ld\n", fFormats, GetLastError()));
    353         } break;
     470                LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS: fFormats=0x%x, lastErr=%ld\n", fFormats, GetLastError()));
     471            }
     472
     473            break;
     474        }
    354475
    355476        case WM_DESTROY:
    … …  
    361482
    362483            PostQuitMessage(0);
    363         } break;
     484            break;
     485        }
    364486
    365487        default:
    … …  
    544666    int rc;
    545667
    546     if (pCtx->pClientData)
    547     {
    548         VBOXCLIPBOARDFORMATS uFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE;
    549         rc = VBoxClipboardWinGetFormats(&pCtx->Win, &uFormats);
     668    if (pCtx->pClient)
     669    {
     670        SHAREDCLIPBOARDFORMATDATA Formats;
     671        RT_ZERO(Formats);
     672
     673        rc = VBoxClipboardWinGetFormats(&pCtx->Win, &Formats);
    550674        if (   RT_SUCCESS(rc)
    551             && uFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE
    552 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    553             /* For URI handling we don't need to sync the format. */
    554             && !(uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    555 #endif
    556            )
    557         {
    558             vboxSvcClipboardReportMsg(pCtx->pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, uFormats);
     675            && Formats.uFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE)
     676        {
     677            if (pCtx->pClient->State.uProtocolVer == 0)
     678            {
     679                rc = vboxSvcClipboardOldReportMsg(pCtx->pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE, Formats.uFormats);
     680            }
     681            else /* Protocol v1 and up. */
     682            {
     683                rc = vboxSvcClipboardSendFormatsWrite(pCtx->pClient, &Formats);
     684            }
    559685        }
    560686    }
    … …  
    581707}
    582708
    583 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA pClientData, bool fHeadless)
     709int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless)
    584710{
    585711    RT_NOREF(fHeadless);
    586 
    587     AssertPtrReturn(pClientData, VERR_INVALID_POINTER);
    588712
    589713    LogFlowFuncEnter();
    … …  
    598722        if (RT_SUCCESS(rc))
    599723        {
    600             rc = RTSemEventCreate(&pCtx->hRenderEvent);
     724            rc = RTSemEventCreate(&pCtx->Old.hRenderEvent);
    601725            if (RT_SUCCESS(rc))
    602726            {
    … …  
    611735
    612736            if (RT_FAILURE(rc))
    613                 RTSemEventDestroy(pCtx->hRenderEvent);
    614         }
    615 
    616         pClientData->State.pCtx = pCtx;
    617         pClientData->State.pCtx->pClientData = pClientData;
     737                RTSemEventDestroy(pCtx->Old.hRenderEvent);
     738        }
     739
     740        pClient->State.pCtx = pCtx;
     741        pClient->State.pCtx->pClient = pClient;
    618742
    619743        /* Sync the host clipboard content with the client. */
    620         rc = VBoxClipboardSvcImplSync(pClientData);
     744        rc = VBoxClipboardSvcImplSync(pClient);
    621745    }
    622746    else
    … …  
    627751}
    628752
    629 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA pClientData)
     753int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient)
    630754{
    631755    /* Sync the host clipboard content with the client. */
    632     return vboxClipboardSvcWinSyncInternal(pClientData->State.pCtx);
    633 }
    634 
    635 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA pClientData)
    636 {
    637     AssertPtrReturn(pClientData, VERR_INVALID_POINTER);
     756    return vboxClipboardSvcWinSyncInternal(pClient->State.pCtx);
     757}
     758
     759int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient)
     760{
     761    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    638762
    639763    LogFlowFuncEnter();
    … …  
    641765    int rc = VINF_SUCCESS;
    642766
    643     PVBOXCLIPBOARDCONTEXT pCtx = pClientData->State.pCtx;
     767    PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx;
    644768    if (pCtx)
    645769    {
    … …  
    647771            PostMessage(pCtx->Win.hWnd, WM_DESTROY, 0 /* wParam */, 0 /* lParam */);
    648772
    649         rc = RTSemEventDestroy(pCtx->hRenderEvent);
     773        rc = RTSemEventDestroy(pCtx->Old.hRenderEvent);
    650774        if (RT_SUCCESS(rc))
    651775        {
    … …  
    668792            pCtx = NULL;
    669793
    670             pClientData->State.pCtx = NULL;
     794            pClient->State.pCtx = NULL;
    671795        }
    672796    }
    … …  
    676800}
    677801
    678 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Formats)
    679 {
    680     AssertPtrReturn(pClientData, VERR_INVALID_POINTER);
    681 
    682     PVBOXCLIPBOARDCONTEXT pCtx = pClientData->State.pCtx;
     802int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
     803                                       PSHAREDCLIPBOARDFORMATDATA pFormats)
     804{
     805    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
     806    RT_NOREF(pCmdCtx);
     807
     808    PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx;
    683809    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
    684810
    685     LogFlowFunc(("u32Formats=0x%x, hWnd=%p\n", u32Formats, pCtx->Win.hWnd));
     811    LogFlowFunc(("uFormats=0x%x, hWnd=%p\n", pFormats->uFormats, pCtx->Win.hWnd));
    686812
    687813    /*
    … …  
    689815     */
    690816    PostMessage(pCtx->Win.hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS,
    691                 0 /* wParam */, u32Formats /* lParam */);
     817                0 /* wParam */, pFormats->uFormats /* lParam */);
    692818
    693819    return VINF_SUCCESS;
    694820}
    695821
    696 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Format, void *pv, uint32_t cb,
    697                                  uint32_t *pcbActual)
    698 {
    699     AssertPtrReturn(pClientData,             VERR_INVALID_POINTER);
    700     AssertPtrReturn(pClientData->State.pCtx, VERR_INVALID_POINTER);
    701 
    702     LogFlowFunc(("u32Format=%02X\n", u32Format));
     822int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
     823                                 PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual)
     824{
     825    AssertPtrReturn(pClient,             VERR_INVALID_POINTER);
     826    RT_NOREF(pCmdCtx);
     827    AssertPtrReturn(pClient->State.pCtx, VERR_INVALID_POINTER);
     828
     829    LogFlowFunc(("uFormat=%02X\n", pData->uFormat));
    703830
    704831    HANDLE hClip = NULL;
    705832
    706     const PVBOXCLIPBOARDWINCTX pWinCtx = &pClientData->State.pCtx->Win;
     833    const PVBOXCLIPBOARDWINCTX pWinCtx = &pClient->State.pCtx->Win;
    707834
    708835    /*
    … …  
    714841        LogFunc(("Clipboard opened\n"));
    715842
    716         if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
     843        if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
    717844        {
    718845            hClip = GetClipboardData(CF_DIB);
    … …  
    726853
    727854                    vboxClipboardGetData(VBOX_SHARED_CLIPBOARD_FMT_BITMAP, lp, GlobalSize(hClip),
    728                                          pv, cb, pcbActual);
     855                                         pData->pvData, pData->cbData, pcbActual);
    729856
    730857                    GlobalUnlock(hClip);
    … …  
    736863            }
    737864        }
    738         else if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
     865        else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
    739866        {
    740867            hClip = GetClipboardData(CF_UNICODETEXT);
    … …  
    748875
    749876                    vboxClipboardGetData(VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, uniString, (lstrlenW(uniString) + 1) * 2,
    750                                          pv, cb, pcbActual);
     877                                         pData->pvData, pData->cbData, pcbActual);
    751878
    752879                    GlobalUnlock(hClip);
    … …  
    758885            }
    759886        }
    760         else if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_HTML)
     887        else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)
    761888        {
    762889            UINT format = RegisterClipboardFormat(VBOX_CLIPBOARD_WIN_REGFMT_HTML);
    … …  
    771898                        /** @todo r=andy Add data overflow handling. */
    772899                        vboxClipboardGetData(VBOX_SHARED_CLIPBOARD_FMT_HTML, lp, GlobalSize(hClip),
    773                                              pv, cb, pcbActual);
     900                                             pData->pvData, pData->cbData, pcbActual);
    774901#ifdef VBOX_STRICT
    775902                        LogFlowFunc(("Raw HTML clipboard data from host:"));
    776                         VBoxClipboardDbgDumpHtml((char *)pv, cb);
     903                        VBoxClipboardDbgDumpHtml((char *)pData->pvData, pData->cbData);
    777904#endif
    778905                        GlobalUnlock(hClip);
    … …  
    786913        }
    787914#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    788         else if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
     915        else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    789916        {
    790917            AssertFailed(); /** @todo */
    … …  
    797924    {
    798925        /* Reply with empty data. */
    799         vboxClipboardGetData(0, NULL, 0, pv, cb, pcbActual);
     926        vboxClipboardGetData(0, NULL, 0, pData->pvData, pData->cbData, pcbActual);
    800927    }
    801928
    … …  
    804931}
    805932
    806 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA pClientData, void *pv, uint32_t cb, uint32_t u32Format)
     933static int vboxClipboardSvcWinOldWriteData(PVBOXCLIPBOARDCLIENT pClient,
     934                                           void *pv, uint32_t cb, uint32_t u32Format)
    807935{
    808936    LogFlowFuncEnter();
     937
     938    const PVBOXCLIPBOARDCLIENTSTATE pState = &pClient->State;
    809939
    810940    /*
    811941     * The guest returns data that was requested in the WM_RENDERFORMAT handler.
    812942     */
    813     Assert(pClientData->State.data.pv == NULL && pClientData->State.data.cb == 0 && pClientData->State.data.u32Format == 0);
     943    Assert(   pState->Old.data.pv == NULL
     944           && pState->Old.data.cb == 0
     945           && pState->Old.data.u32Format == 0);
    814946
    815947#ifdef LOG_ENABLED
    … …  
    831963                if (pszResult != NULL && cbResult != 0)
    832964                {
    833                     pClientData->State.data.pv        = pszResult;
    834                     pClientData->State.data.cb        = cbResult;
    835                     pClientData->State.data.u32Format = u32Format;
     965                    pState->Old.data.pv        = pszResult;
     966                    pState->Old.data.cb        = cbResult;
     967                    pState->Old.data.u32Format = u32Format;
    836968                }
    837969            }
    … …  
    839971        else
    840972        {
    841             pClientData->State.data.pv = RTMemDup(pv, cb);
    842             if (pClientData->State.data.pv)
    843             {
    844                 pClientData->State.data.cb = cb;
    845                 pClientData->State.data.u32Format = u32Format;
    846             }
    847         }
    848     }
    849 
    850     AssertPtr(pClientData->State.pCtx);
    851     int rc = RTSemEventSignal(pClientData->State.pCtx->hRenderEvent);
     973            pState->Old.data.pv = RTMemDup(pv, cb);
     974            if (pState->Old.data.pv)
     975            {
     976                pState->Old.data.cb = cb;
     977                pState->Old.data.u32Format = u32Format;
     978            }
     979        }
     980    }
     981
     982    AssertPtr(pState->pCtx);
     983    int rc = RTSemEventSignal(pState->pCtx->Old.hRenderEvent);
    852984    AssertRC(rc);
    853985
    … …  
    856988}
    857989
     990int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
     991                                  PSHAREDCLIPBOARDDATABLOCK pData)
     992{
     993    LogFlowFuncEnter();
     994
     995    int rc;
     996
     997    if (pClient->State.uProtocolVer == 0)
     998    {
     999        rc = vboxClipboardSvcWinOldWriteData(pClient, pData->pvData, pData->cbData, pData->uFormat);
     1000    }
     1001    else
     1002    {
     1003        const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(pCmdCtx->uContextID);
     1004
     1005        PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1006        rc = SharedClipboardPayloadAlloc(uEvent, pData->pvData, pData->cbData, &pPayload);
     1007        if (RT_SUCCESS(rc))
     1008        {
     1009            rc = SharedClipboardEventSignal(&pClient->Events, uEvent, pPayload);
     1010             if (RT_FAILURE(rc))
     1011                SharedClipboardPayloadFree(pPayload);
     1012        }
     1013    }
     1014
     1015    LogFlowFuncLeaveRC(rc);
     1016    return rc;
     1017}
     1018
    8581019#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    859 int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer)
    860 {
    861     RT_NOREF(pClientData, pTransfer);
     1020int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     1021{
     1022    RT_NOREF(pClient, pTransfer);
    8621023
    8631024    LogFlowFuncEnter();
    … …  
    8661027}
    8671028
    868 int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     1029int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer)
    8691030{
    8701031    LogFlowFuncEnter();
    8711032
    872     VBoxClipboardWinURITransferDestroy(&pClientData->State.pCtx->Win, pTransfer);
     1033    VBoxClipboardWinURITransferDestroy(&pClient->State.pCtx->Win, pTransfer);
    8731034
    8741035    return VINF_SUCCESS;

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp

    r79036 r80444  
    5454  * Enable the shared clipboard - called by the hgcm clipboard subsystem.
    5555  *
    56   * @param   pClientData    Structure containing context information about the guest system
    57   * @param   fHeadless      Whether headless.
    5856  * @returns RT status code
     57  * @param   pClient            Structure containing context information about the guest system
     58  * @param   fHeadless          Whether headless.
    5959  */
    60 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA pClientData, bool fHeadless)
     60int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless)
    6161{
    62     RT_NOREF(pClientData, fHeadless);
     62    RT_NOREF(pClient, fHeadless);
    6363    LogFlowFunc(("called, returning VINF_SUCCESS\n"));
    6464    return VINF_SUCCESS;
    … …  
    6969 * after a save and restore of the guest.
    7070 */
    71 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA /* pClientData */)
     71int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient)
    7272{
     73    RT_NOREF(pClient);
    7374    LogFlowFunc(("called, returning VINF_SUCCESS\n"));
    7475    return VINF_SUCCESS;
    … …  
    7879 * Shut down the shared clipboard subsystem and "disconnect" the guest.
    7980 *
    80  * @param   pClientData    Structure containing context information about the guest system
     81 * @param   pClient         Structure containing context information about the guest system
    8182 */
    82 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA pClientData)
     83int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient)
    8384{
    84     RT_NOREF(pClientData);
     85    RT_NOREF(pClient);
    8586    return VINF_SUCCESS;
    8687}
    … …  
    9091 * subsystem.
    9192 *
    92  * @param pClientData           Context data for the guest system
    93  * @param u32Formats            Clipboard formats the guest is offering
     93 * @param pClient               Context data for the guest system.
     94 * @param pCmdCtx               Command context to use.
     95 * @param pFormats              Clipboard formats the guest is offering.
    9496 */
    95 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Formats)
     97int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
     98                                       PSHAREDCLIPBOARDFORMATDATA pFormats)
    9699{
    97     RT_NOREF(pClientData, u32Formats);
     100    RT_NOREF(pClient, pCmdCtx, pFormats);
    98101    return VINF_SUCCESS;
    99102}
    … …  
    102105 * Called by the HGCM clipboard subsystem when the guest wants to read the host clipboard.
    103106 *
    104  * @param pClientData   Context information about the guest VM
    105  * @param u32Format     The format that the guest would like to receive the data in
    106  * @param pv            Where to write the data to
    107  * @param cb            The size of the buffer to write the data to
    108  * @param pcbActual     Where to write the actual size of the written data
     107 * @param pClient       Context information about the guest VM
     108 * @param pCmdCtx       Command context to use.
     109 * @param pData         Data block to put read data into.
    109110 */
    110 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Format,
    111                                  void *pv, uint32_t cb, uint32_t *pcbActual)
     111int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
     112                                 PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual)
    112113{
    113     RT_NOREF(pClientData, u32Format, pv, cb);
    114     LogFlowFunc(("called, returning VINF_SUCCESS\n"));
     114    RT_NOREF(pClient, pCmdCtx, pData);
     115
    115116    /* No data available. */
    116117    *pcbActual = 0;
     118
    117119    return VINF_SUCCESS;
    118120}
    119121
    120 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA pClientData, void *pv, uint32_t cb,
    121                                   uint32_t u32Format)
     122int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
     123                                  PSHAREDCLIPBOARDDATABLOCK pData)
    122124{
    123     RT_NOREF(pClientData, pv, cb, u32Format);
     125    RT_NOREF(pClient, pCmdCtx, pData);
    124126    return VERR_NOT_IMPLEMENTED;
    125127}
    126128
    127129#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    128 int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData)
     130int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDDIRDATA pDirData)
    129131{
    130     RT_NOREF(pClientData, pDirData);
     132    RT_NOREF(pClient, pDirData);
    131133    return VERR_NOT_IMPLEMENTED;
    132134}
    133135
    134 int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData)
     136int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDDIRDATA pDirData)
    135137{
    136     RT_NOREF(pClientData, pDirData);
     138    RT_NOREF(pClient, pDirData);
    137139    return VERR_NOT_IMPLEMENTED;
    138140}
    139141
    140 int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr)
     142int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEHDR pFileHdr)
    141143{
    142     RT_NOREF(pClientData, pFileHdr);
     144    RT_NOREF(pClient, pFileHdr);
    143145    return VERR_NOT_IMPLEMENTED;
    144146}
    145147
    146 int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr)
     148int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEHDR pFileHdr)
    147149{
    148     RT_NOREF(pClientData, pFileHdr);
     150    RT_NOREF(pClient, pFileHdr);
    149151    return VERR_NOT_IMPLEMENTED;
    150152}
    151153
    152 int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData)
     154int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEDATA pFileData)
    153155{
    154     RT_NOREF(pClientData, pFileData);
     156    RT_NOREF(pClient, pFileData);
    155157    return VERR_NOT_IMPLEMENTED;
    156158}
    157159
    158 int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData)
     160int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEDATA pFileData)
    159161{
    160     RT_NOREF(pClientData, pFileData);
     162    RT_NOREF(pClient, pFileData);
    161163    return VERR_NOT_IMPLEMENTED;
    162164}

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

    r79174 r80444  
    5959    CLIPBACKEND *pBackend;
    6060    /** Pointer to the VBox host client data structure. */
    61     PVBOXCLIPBOARDCLIENTDATA pClientData;
     61    PVBOXCLIPBOARDCLIENT pClient;
    6262    /** We set this when we start shutting down as a hint not to post any new
    6363     * requests. */
    … …  
    7777    LogFlowFunc(("pCtx=%p, u32Formats=%02X\n", pCtx, u32Formats));
    7878
    79     vboxSvcClipboardReportMsg(pCtx->pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, u32Formats);
     79    vboxSvcClipboardOldReportMsg(pCtx->pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE, u32Formats);
    8080}
    8181
    … …  
    104104 *        the clipboard and leave ownership to X11.
    105105 */
    106 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA pClientData, bool fHeadless)
     106int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless)
    107107{
    108108    int rc = VINF_SUCCESS;
    … …  
    126126        {
    127127            pCtx->pBackend = pBackend;
    128             pClientData->State.pCtx = pCtx;
    129             pCtx->pClientData = pClientData;
     128            pClient->State.pCtx = pCtx;
     129            pCtx->pClient = pClient;
    130130
    131131            rc = ClipStartX11(pBackend, true /* grab shared clipboard */);
    … …  
    153153 * @note  Host glue code
    154154 */
    155 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA pClientData)
     155int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient)
    156156{
    157157    LogFlowFuncEnter();
    … …  
    160160     * there is data in the host clipboard it will automatically be sent to
    161161     * the guest when the clipboard starts up. */
    162     return vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, 0);
     162    return vboxSvcClipboardOldReportMsg(pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE, 0);
    163163}
    164164
    … …  
    167167 * @note  Host glue code
    168168 */
    169 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA pClientData)
     169int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient)
    170170{
    171171    LogFlowFuncEnter();
    … …  
    173173    LogRel(("Stopping the host clipboard service\n"));
    174174
    175     PVBOXCLIPBOARDCONTEXT pCtx = pClientData->State.pCtx;
     175    PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx;
    176176
    177177    /* Drop the reference to the client, in case it is still there.  This
    … …  
    181181
    182182    /* If there is a currently pending request, release it immediately. */
    183     VBoxClipboardSvcImplWriteData(pClientData, NULL, 0, 0);
     183    SHAREDCLIPBOARDDATABLOCK dataBlock = { 0, NULL, 0 };
     184    VBoxClipboardSvcImplWriteData(pClient, NULL, &dataBlock);
    184185
    185186    int rc = ClipStopX11(pCtx->pBackend);
    … …  
    202203 * VBox is taking possession of the shared clipboard.
    203204 *
    204  * @param pClientData    Context data for the guest system
    205  * @param u32Formats Clipboard formats the guest is offering
    206  * @note  Host glue code
    207  */
    208 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Formats)
    209 {
    210     LogFlowFunc(("pClientData=%p, u32Formats=%02X\n", pClientData, u32Formats));
    211 
    212     ClipAnnounceFormatToX11(pClientData->State.pCtx->pBackend, u32Formats);
     205 * @param pClient               Context data for the guest system.
     206 * @param pCmdCtx               Command context to use.
     207 * @param pFormats              Clipboard formats the guest is offering.
     208 */
     209int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
     210                                       PSHAREDCLIPBOARDFORMATDATA pFormats)
     211{
     212    RT_NOREF(pCmdCtx);
     213
     214#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     215    if (pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) /* No URI support yet. */
     216        return VINF_SUCCESS;
     217#endif
     218
     219    ClipAnnounceFormatToX11(pClient->State.pCtx->pBackend, pFormats->uFormats);
    213220
    214221    return VINF_SUCCESS;
    … …  
    233240 *          asynchronously
    234241 * @returns iprt status code on failure
    235  * @param  pClientData   Context information about the guest VM
    236  * @param  u32Format     The format that the guest would like to receive the data in
    237  * @param  pv            Where to write the data to
    238  * @param  cb            The size of the buffer to write the data to
    239  * @param  pcbActual Where to write the actual size of the written data
    240  *
    241  * @note   We always fail or complete asynchronously
     242 *
     243 * @param pClient               Context information about the guest VM
     244 * @param pData                 Data block to put read data into.
     245 * @param pcbActual             Where to write the actual size of the written data
     246 *
     247 * @note   We always fail or complete asynchronously.
    242248 * @note   On success allocates a CLIPREADCBREQ structure which must be
    243249 *         freed in ClipCompleteDataRequestFromX11 when it is called back from
    … …  
    245251 *
    246252 */
    247 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA pClientData,
    248                                  uint32_t u32Format, void *pv, uint32_t cb, uint32_t *pcbActual)
    249 {
    250     LogFlowFunc(("pClientData=%p, u32Format=%02X, pv=%p, cb=%u, pcbActual=%p\n",
    251                  pClientData, u32Format, pv, cb, pcbActual));
     253int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient,
     254                                 PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual)
     255{
     256    LogFlowFunc(("pClient=%p, uFormat=%02X, pv=%p, cb=%u, pcbActual=%p\n",
     257                 pClient, pData->uFormat, pData->pvData, pData->cbData, pcbActual));
    252258
    253259    int rc = VINF_SUCCESS;
     260
    254261    CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)RTMemAlloc(sizeof(CLIPREADCBREQ));
    255262    if (!pReq)
    … …  
    259266    else
    260267    {
    261         pReq->pv = pv;
    262         pReq->cb = cb;
     268        pReq->pv = pData->pvData;
     269        pReq->cb = pData->cbData;
    263270        pReq->pcbActual = pcbActual;
    264         rc = ClipRequestDataFromX11(pClientData->State.pCtx->pBackend, u32Format, pReq);
     271        rc = ClipRequestDataFromX11(pClient->State.pCtx->pBackend, pData->uFormat, pReq);
    265272        if (RT_SUCCESS(rc))
    266273            rc = VINF_HGCM_ASYNC_EXECUTE;
    … …  
    291298    RTMemFree(pReq);
    292299
    293     vboxSvcClipboardCompleteReadData(pCtx->pClientData, rc, cb);
     300    vboxSvcClipboardOldCompleteReadData(pCtx->pClient, rc, cb);
    294301}
    295302
    … …  
    317324
    318325    /* Request data from VBox */
    319     vboxSvcClipboardReportMsg(pCtx->pClientData,
     326    vboxSvcClipboardOldReportMsg(pCtx->pClient,
    320327                              VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    321328                              u32Format);
    … …  
    421428 * Called when we have requested data from VBox and that data has arrived.
    422429 *
    423  * @param  pClientData   Context information about the guest VM
    424  * @param  pv            Buffer to which the data was written
    425  * @param  cb            The size of the data written
    426  * @param  u32Format     The format of the data written
    427  * @note   Host glue code
    428  */
    429 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA pClientData,
    430                                   void *pv, uint32_t cb, uint32_t u32Format)
    431 {
    432     LogFlowFunc(("pClientData=%p, pv=%p (%.*ls), cb=%u, u32Format=%02X\n", pClientData, pv, cb / 2, pv, cb, u32Format));
    433 
    434     VBOXCLIPBOARDCONTEXT *pCtx = pClientData->State.pCtx;
     430 * @param pClient               Context information about the guest VM.
     431 * @param pData                 Data block to write to clipboard.
     432 */
     433int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient,
     434                                  PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData)
     435{
     436    RT_NOREF(pCmdCtx);
     437
     438    LogFlowFunc(("pClient=%p, pv=%p (%.*ls), cb=%u, uFormat=%02X\n",
     439                 pClient, pData->pvData, pData->cbData / 2, pData->pvData, pData->cbData, pData->uFormat));
     440
     441    PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx;
    435442
    436443    /* Grab the mutex and check whether there is a pending request for data. */
    … …  
    440447    if (pReq != NULL)
    441448    {
    442         if (cb > 0)
     449        if (pData->cbData > 0)
    443450        {
    444             pReq->pv = RTMemDup(pv, cb);
     451            pReq->pv = RTMemDup(pData->pvData, pData->cbData);
    445452            if (pReq->pv != NULL)  /* NULL may also mean no memory... */
    446453            {
    447                 pReq->cb = cb;
    448                 pReq->format = u32Format;
     454                pReq->cb     = pData->cbData;
     455                pReq->format = pData->uFormat;
    449456            }
    450457        }
     458
    451459        /* Signal that the request has been completed. */
    452460        RTSemEventSignal(pReq->finished);
    … …  
    459467}
    460468
    461 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    462 int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData)
    463 {
    464     RT_NOREF(pClientData, pDirData);
     469#if 0
     470int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDDIRDATA pDirData)
     471{
     472    RT_NOREF(pClient, pDirData);
    465473    return VERR_NOT_IMPLEMENTED;
    466474}
    467475
    468 int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData)
    469 {
    470     RT_NOREF(pClientData, pDirData);
     476int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDDIRDATA pDirData)
     477{
     478    RT_NOREF(pClient, pDirData);
    471479    return VERR_NOT_IMPLEMENTED;
    472480}
    473481
    474 int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr)
    475 {
    476     RT_NOREF(pClientData, pFileHdr);
     482int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEHDR pFileHdr)
     483{
     484    RT_NOREF(pClient, pFileHdr);
    477485    return VERR_NOT_IMPLEMENTED;
    478486}
    479487
    480 int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr)
    481 {
    482     RT_NOREF(pClientData, pFileHdr);
     488int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEHDR pFileHdr)
     489{
     490    RT_NOREF(pClient, pFileHdr);
    483491    return VERR_NOT_IMPLEMENTED;
    484492}
    485493
    486 int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData)
    487 {
    488     RT_NOREF(pClientData, pFileData);
     494int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEDATA pFileData)
     495{
     496    RT_NOREF(pClient, pFileData);
    489497    return VERR_NOT_IMPLEMENTED;
    490498}
    491499
    492 int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData)
    493 {
    494     RT_NOREF(pClientData, pFileData);
     500int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEDATA pFileData)
     501{
     502    RT_NOREF(pClient, pFileData);
    495503    return VERR_NOT_IMPLEMENTED;
    496504}
    … …  
    530538};
    531539
    532 int vboxSvcClipboardReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t uMsg, uint32_t uFormats)
     540int vboxSvcClipboardOldReportMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t uMsg, uint32_t uFormats)
    533541{
    534542    RT_NOREF(uFormats);
    535     CLIPBACKEND *pBackend = pClientData->State.pCtx->pBackend;
     543    CLIPBACKEND *pBackend = pClient->State.pCtx->pBackend;
    536544
    537545    int rc;
    … …  
    540548        && !pBackend->writeData.timeout)
    541549    {
    542         rc = VBoxClipboardSvcImplWriteData(pClientData, pBackend->writeData.pv, pBackend->writeData.cb, pBackend->writeData.format);
     550        rc = VBoxClipboardSvcImplWriteData(pClient, pBackend->writeData.pv, pBackend->writeData.cb, pBackend->writeData.format);
    543551    }
    544552    else
    … …  
    548556}
    549557
    550 int vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, int rc, uint32_t cbActual)
    551 {
    552     CLIPBACKEND *pBackend = pClientData->State.pCtx->pBackend;
     558int vboxSvcClipboardOldCompleteReadData(PVBOXCLIPBOARDCLIENT pClient, int rc, uint32_t cbActual)
     559{
     560    CLIPBACKEND *pBackend = pClient->State.pCtx->pBackend;
    553561    pBackend->completeRead.rc = rc;
    554562    pBackend->completeRead.cbActual = cbActual;

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

    r80374 r80444  
    201201*   Prototypes                                                                                                                   *
    202202*********************************************************************************************************************************/
    203 static int vboxSvcClipboardClientStateInit(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t uClientID);
    204 static int vboxSvcClipboardClientStateDestroy(PVBOXCLIPBOARDCLIENTDATA pClientData);
    205 static void vboxSvcClipboardClientStateReset(PVBOXCLIPBOARDCLIENTDATA pClientData);
     203static int vboxSvcClipboardClientStateInit(PVBOXCLIPBOARDCLIENTSTATE pClientState, uint32_t uClientID);
     204static int vboxSvcClipboardClientStateDestroy(PVBOXCLIPBOARDCLIENTSTATE pClientState);
     205static void vboxSvcClipboardClientStateReset(PVBOXCLIPBOARDCLIENTSTATE pClientState);
    206206
    207207
    … …  
    232232ClipboardClientQueue g_listClientsDeferred;
    233233
    234 
    235 static int VBoxHGCMParmPtrGet(VBOXHGCMSVCPARM *pParm, void **ppv, uint32_t *pcb)
    236 {
    237     if (pParm->type == VBOX_HGCM_SVC_PARM_PTR)
    238     {
    239         *ppv = pParm->u.pointer.addr;
    240         *pcb = pParm->u.pointer.size;
    241         return VINF_SUCCESS;
    242     }
    243 
    244     return VERR_INVALID_PARAMETER;
    245 }
    246234
    247235uint32_t vboxSvcClipboardGetMode(void)
    … …  
    300288 * @param   pClientData         Pointer to the client data structure to reset message queue for.
    301289 */
    302 void vboxSvcClipboardMsgQueueReset(PVBOXCLIPBOARDCLIENTDATA pClientData)
     290void vboxSvcClipboardMsgQueueReset(PVBOXCLIPBOARDCLIENT pClient)
    303291{
    304292    LogFlowFuncEnter();
    305293
    306     while (!pClientData->queueMsg.isEmpty())
    307     {
    308         RTMemFree(pClientData->queueMsg.last());
    309         pClientData->queueMsg.removeLast();
     294    while (!pClient->queueMsg.isEmpty())
     295    {
     296        RTMemFree(pClient->queueMsg.last());
     297        pClient->queueMsg.removeLast();
    310298    }
    311299}
    … …  
    391379 * @param   fAppend             Whether to append or prepend the message to the queue.
    392380 */
    393 int vboxSvcClipboardMsgAdd(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDCLIENTMSG pMsg, bool fAppend)
     381int vboxSvcClipboardMsgAdd(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTMSG pMsg, bool fAppend)
    394382{
    395383    AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
    396384
    397     LogFlowFunc(("uMsg=%RU32, cParms=%RU32, fAppend=%RTbool\n", pMsg->m_uMsg, pMsg->m_cParms, fAppend));
     385    LogFlowFunc(("uMsg=%RU32 (%s), cParms=%RU32, fAppend=%RTbool\n",
     386                 pMsg->m_uMsg, VBoxClipboardHostMsgToStr(pMsg->m_uMsg), pMsg->m_cParms, fAppend));
    398387
    399388    if (fAppend)
    400         pClientData->queueMsg.append(pMsg);
     389        pClient->queueMsg.append(pMsg);
    401390    else
    402         pClientData->queueMsg.prepend(pMsg);
     391        pClient->queueMsg.prepend(pMsg);
    403392
    404393    /** @todo Catch / handle OOM? */
    … …  
    465454     * Return information about the first message if one is pending in the list.
    466455     */
    467     if (!pClient->pData->queueMsg.isEmpty())
    468     {
    469         PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->pData->queueMsg.first();
     456    if (!pClient->queueMsg.isEmpty())
     457    {
     458        PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first();
    470459        if (pFirstMsg)
    471460        {
    … …  
    530519     * Return information about the first message if one is pending in the list.
    531520     */
    532     if (!pClient->pData->queueMsg.isEmpty())
    533     {
    534         PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->pData->queueMsg.first();
     521    if (!pClient->queueMsg.isEmpty())
     522    {
     523        PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first();
    535524        if (pFirstMsg)
    536525        {
    537             LogFlowFunc(("First message is: %RU32 %s (%RU32 parms)\n",
     526            LogFlowFunc(("First message is: %RU32 (%s), cParms=%RU32\n",
    538527                         pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms));
    539528
    … …  
    607596                if (rc != VERR_CANCELLED)
    608597                {
    609                     pClient->pData->queueMsg.removeFirst();
     598                    pClient->queueMsg.removeFirst();
    610599                    vboxSvcClipboardMsgFree(pFirstMsg);
    611600                }
    … …  
    635624        rc = VINF_SUCCESS;
    636625
    637         if (!pClient->pData->queueMsg.isEmpty())
    638         {
    639             PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->pData->queueMsg.first();
     626        if (!pClient->queueMsg.isEmpty())
     627        {
     628            PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first();
    640629            if (pFirstMsg)
    641630            {
    … …  
    667656}
    668657
    669 /* Set the HGCM parameters according to pending messages.
     658/**
     659 * Set the HGCM parameters according to pending messages.
    670660 * Executed under the clipboard lock.
     661 *
     662 * Legacy protocol, do not use anymore.
    671663 */
    672 static bool vboxSvcClipboardReturnMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     664static bool vboxSvcClipboardOldReturnMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    673665{
    674666    /** @todo r=andy The client at the moment supplies two parameters, which we can
    … …  
    682674
    683675    /* Message priority is taken into account. */
    684     if (pClientData->State.fHostMsgQuit)
     676    if (pClient->State.Old.fHostMsgQuit)
    685677    {
    686678        LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT\n"));
    687679        HGCMSvcSetU32(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
    688680        HGCMSvcSetU32(&paParms[1], 0);
    689         pClientData->State.fHostMsgQuit = false;
    690     }
    691     else if (pClientData->State.fHostMsgReadData)
     681        pClient->State.Old.fHostMsgQuit = false;
     682    }
     683    else if (pClient->State.Old.fHostMsgReadData)
    692684    {
    693685        uint32_t fFormat = 0;
    694686
    695687        LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA: u32RequestedFormat=%02X\n",
    696                      pClientData->State.u32RequestedFormat));
    697 
    698         if (pClientData->State.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
     688                     pClient->State.Old.u32RequestedFormat));
     689
     690        if (pClient->State.Old.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
    699691            fFormat = VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
    700         else if (pClientData->State.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
     692        else if (pClient->State.Old.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
    701693            fFormat = VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
    702         else if (pClientData->State.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)
     694        else if (pClient->State.Old.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)
    703695            fFormat = VBOX_SHARED_CLIPBOARD_FMT_HTML;
    704696#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    705         else if (pClientData->State.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
     697        else if (pClient->State.Old.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    706698            fFormat = VBOX_SHARED_CLIPBOARD_FMT_URI_LIST;
    707699#endif
    … …  
    709701        {
    710702            LogRel2(("Clipboard: Unsupported format from guest (0x%x), skipping\n", fFormat));
    711             pClientData->State.u32RequestedFormat = 0;
    712         }
    713         pClientData->State.u32RequestedFormat &= ~fFormat;
     703            pClient->State.Old.u32RequestedFormat = 0;
     704        }
     705        pClient->State.Old.u32RequestedFormat &= ~fFormat;
    714706        HGCMSvcSetU32(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    715707        HGCMSvcSetU32(&paParms[1], fFormat);
    716         if (pClientData->State.u32RequestedFormat == 0)
    717             pClientData->State.fHostMsgReadData = false;
    718     }
    719     else if (pClientData->State.fHostMsgFormats)
     708        if (pClient->State.Old.u32RequestedFormat == 0)
     709            pClient->State.Old.fHostMsgReadData = false;
     710    }
     711    else if (pClient->State.Old.fHostMsgFormats)
    720712    {
    721713        LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS: u32AvailableFormats=%02X\n",
    722                      pClientData->State.u32AvailableFormats));
    723 
    724         HGCMSvcSetU32(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS);
    725         HGCMSvcSetU32(&paParms[1], pClientData->State.u32AvailableFormats);
    726         pClientData->State.fHostMsgFormats = false;
    727     }
    728 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    729     else if (vboxSvcClipboardURIReturnMsg(pClientData, cParms, paParms))
    730     {
    731         /* Nothing to do here yet. */
    732     }
    733 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
     714                     pClient->State.Old.u32AvailableFormats));
     715
     716        HGCMSvcSetU32(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE);
     717        HGCMSvcSetU32(&paParms[1], pClient->State.Old.u32AvailableFormats);
     718        pClient->State.Old.fHostMsgFormats = false;
     719    }
    734720    else
    735721    {
    … …  
    743729}
    744730
    745 int vboxSvcClipboardReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t uMsg, uint32_t uFormats)
    746 {
    747     AssertPtrReturn(pClientData, VERR_INVALID_POINTER);
     731int vboxSvcClipboardSendFormatsWrite(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDFORMATDATA pFormats)
     732{
     733    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
     734
     735    int rc;
     736
     737    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE, 3);
     738    if (pMsg)
     739    {
     740        uint16_t uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
     741
     742        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->Events.uID, uEvent));
     743        HGCMSvcSetU32(&pMsg->m_paParms[1], pFormats->uFormats);
     744        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */);
     745
     746        rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     747        if (RT_SUCCESS(rc))
     748        {
     749            rc = vboxSvcClipboardClientWakeup(pClient);
     750        }
     751    }
     752    else
     753        rc = VERR_NO_MEMORY;
     754
     755    LogFlowFuncLeaveRC(rc);
     756    return rc;
     757}
     758
     759int vboxSvcClipboardGetDataWrite(PVBOXCLIPBOARDCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     760{
     761    LogFlowFuncEnter();
     762
     763    if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
     764        && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     765    {
     766        return VERR_NOT_SUPPORTED;
     767    }
     768
     769    int rc;
     770
     771    SHAREDCLIPBOARDDATABLOCK dataBlock;
     772    RT_ZERO(dataBlock);
     773
     774    VBOXCLIPBOARDCLIENTCMDCTX cmdCtx;
     775    RT_ZERO(cmdCtx);
     776
     777    if (pClient->State.uProtocolVer == 0) /* Legacy protocol */
     778    {
     779        if (cParms < 2)
     780        {
     781            rc = VERR_INVALID_PARAMETER;
     782        }
     783        else if (   paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT   /* format */
     784                 || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR)    /* ptr */
     785        {
     786            rc = VERR_INVALID_PARAMETER;
     787        }
     788        else
     789        {
     790            rc = HGCMSvcGetU32(&paParms[0], &dataBlock.uFormat);
     791            if (RT_SUCCESS(rc))
     792                rc = HGCMSvcGetBuf(&paParms[1], &dataBlock.pvData, &dataBlock.cbData);
     793        }
     794    }
     795    else
     796    {
     797        if (cParms < VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA)
     798        {
     799            rc = VERR_INVALID_PARAMETER;
     800        }
     801        else if (   paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT   /* uContext */
     802                 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT   /* uFormat */
     803                 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT   /* cbData */
     804                 || paParms[3].type != VBOX_HGCM_SVC_PARM_PTR)    /* pvData */
     805        {
     806            rc = VERR_INVALID_PARAMETER;
     807        }
     808        else
     809        {
     810            rc = HGCMSvcGetU32(&paParms[0], &cmdCtx.uContextID);
     811            if (RT_SUCCESS(rc))
     812                rc = HGCMSvcGetU32(&paParms[1], &dataBlock.uFormat);
     813            if (RT_SUCCESS(rc))
     814                rc = HGCMSvcGetBuf(&paParms[3], &dataBlock.pvData, &dataBlock.cbData);
     815
     816            /** @todo Handle the rest. */
     817        }
     818    }
     819
     820    if (RT_SUCCESS(rc))
     821    {
     822        if (g_pfnExtension)
     823        {
     824            VBOXCLIPBOARDEXTPARMS parms;
     825            RT_ZERO(parms);
     826
     827            parms.u32Format = dataBlock.uFormat;
     828            parms.u.pvData  = dataBlock.pvData;
     829            parms.cbData    = dataBlock.cbData;
     830
     831            g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_WRITE, &parms, sizeof(parms));
     832        }
     833
     834        rc = VBoxClipboardSvcImplWriteData(pClient, &cmdCtx, &dataBlock);
     835    }
     836
     837    LogFlowFuncLeaveRC(rc);
     838    return rc;
     839}
     840
     841/**
     842 * Reports a cached message back to the guest.
     843 *
     844 * Legacy protocol, do not use anymore.
     845 */
     846int vboxSvcClipboardOldReportMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t uMsg, uint32_t uFormats)
     847{
     848    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    748849
    749850    int rc = VINF_SUCCESS;
    750851
    751     LogFlowFunc(("uMsg=%RU32, fIsAsync=%RTbool\n", uMsg, pClientData->State.fAsync));
     852    LogFlowFunc(("uMsg=%RU32 (%s), fIsAsync=%RTbool\n",
     853                 uMsg, VBoxClipboardHostMsgToStr(uMsg), pClient->State.Old.fAsync));
    752854
    753855    if (VBoxSvcClipboardLock())
    … …  
    757859            case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
    758860            {
    759                 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT\n"));
    760                 pClientData->State.fHostMsgQuit = true;
     861                pClient->State.Old.fHostMsgQuit = true;
    761862            } break;
    762863
    … …  
    770871                }
    771872
    772                 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA: uFormats=%02X\n", uFormats));
    773                 pClientData->State.u32RequestedFormat = uFormats;
    774                 pClientData->State.fHostMsgReadData = true;
     873                LogFlowFunc(("uFormats=%02X\n", uFormats));
     874
     875                pClient->State.Old.u32RequestedFormat = uFormats;
     876                pClient->State.Old.fHostMsgReadData = true;
    775877            } break;
    776878
    777             case VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS:
     879            case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE:
    778880            {
    779881                if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
    … …  
    784886                }
    785887
    786                 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS: uFormats=%02X\n", uFormats));
    787                 pClientData->State.u32AvailableFormats = uFormats;
    788                 pClientData->State.fHostMsgFormats = true;
     888                LogFlowFunc(("uFormats=%02X\n", uFormats));
     889
     890                pClient->State.Old.u32AvailableFormats = uFormats;
     891                pClient->State.Old.fHostMsgFormats = true;
    789892            } break;
    790893
    791894            default:
    792895            {
    793 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    794                 rc = vboxSvcClipboardURIReportMsg(pClientData, uMsg, uFormats);
    795 #else
    796896                AssertMsgFailed(("Invalid message %RU32\n", uMsg));
    797897                rc = VERR_INVALID_PARAMETER;
    798 #endif
    799             } break;
     898                break;
     899            }
    800900        }
    801901
    802902        if (RT_SUCCESS(rc))
    803903        {
    804             if (pClientData->State.fAsync)
     904            if (pClient->State.Old.fAsync)
    805905            {
    806906                /* The client waits for a response. */
    807                 bool fMessageReturned = vboxSvcClipboardReturnMsg(pClientData,
    808                                                                   pClientData->State.async.cParms,
    809                                                                   pClientData->State.async.paParms);
     907                bool fMessageReturned = vboxSvcClipboardOldReturnMsg(pClient,
     908                                                                  pClient->State.Old.async.cParms,
     909                                                                  pClient->State.Old.async.paParms);
    810910
    811911                /* Make a copy of the handle. */
    812                 VBOXHGCMCALLHANDLE callHandle = pClientData->State.async.callHandle;
     912                VBOXHGCMCALLHANDLE callHandle = pClient->State.Old.async.callHandle;
    813913
    814914                if (fMessageReturned)
    815915                {
    816916                    /* There is a response. */
    817                     pClientData->State.fAsync = false;
     917                    pClient->State.Old.fAsync = false;
    818918                }
    819919
    … …  
    838938
    839939
    840 int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENTDATA pClientData, SHAREDCLIPBOARDSOURCE enmSource)
    841 {
    842     if (!pClientData) /* If no client connected (anymore), bail out. */
     940int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENT pClient, SHAREDCLIPBOARDSOURCE enmSource)
     941{
     942    if (!pClient) /* If no client connected (anymore), bail out. */
    843943        return VINF_SUCCESS;
    844944
    … …  
    847947    if (VBoxSvcClipboardLock())
    848948    {
    849         pClientData->State.enmSource = enmSource;
    850 
    851         LogFlowFunc(("Source of client %RU32 is now %RU32\n", pClientData->State.u32ClientID, pClientData->State.enmSource));
     949        pClient->State.enmSource = enmSource;
     950
     951        LogFlowFunc(("Source of client %RU32 is now %RU32\n", pClient->State.u32ClientID, pClient->State.enmSource));
    852952
    853953        VBoxSvcClipboardUnlock();
    … …  
    885985
    886986    VBoxClipboardSvcImplDestroy();
    887 
    888     ClipboardClientMap::iterator itClient = g_mapClients.begin();
    889     while (itClient != g_mapClients.end())
    890     {
    891         RTMemFree(itClient->second);
    892         g_mapClients.erase(itClient);
    893 
    894         itClient = g_mapClients.begin();
    895     }
    896987
    897988    RTCritSectDelete(&g_CritSect);
    … …  
    9101001    LogFunc(("u32ClientID=%RU32\n", u32ClientID));
    9111002
     1003    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient;
     1004    AssertPtr(pClient);
     1005
     1006    vboxSvcClipboardOldReportMsg(pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT, 0); /** @todo r=andy Why is this necessary? The client already disconnected ... */
     1007    vboxSvcClipboardOldCompleteReadData(pClient, VERR_NO_DATA, 0);
     1008
     1009#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     1010    PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, 0 /* Index*/);
     1011    if (pTransfer)
     1012        vboxSvcClipboardURIAreaDetach(&pClient->State, pTransfer);
     1013
     1014    SharedClipboardURICtxDestroy(&pClient->URI);
     1015#endif
     1016
     1017    VBoxClipboardSvcImplDisconnect(pClient);
     1018
     1019    vboxSvcClipboardClientStateReset(&pClient->State);
     1020    vboxSvcClipboardClientStateDestroy(&pClient->State);
     1021
    9121022    ClipboardClientMap::iterator itClient = g_mapClients.find(u32ClientID);
    913     if (itClient == g_mapClients.end())
    914     {
    915         AssertFailed(); /* Should never happen. */
    916         return VERR_NOT_FOUND;
    917     }
    918 
    919     PVBOXCLIPBOARDCLIENT     pClient     = itClient->second;
    920     AssertPtr(pClient);
    921     PVBOXCLIPBOARDCLIENTDATA pClientData = pClient->pData;
    922     AssertPtr(pClientData);
    923 
    924     /* Sanity. */
    925     Assert(pClientData == (PVBOXCLIPBOARDCLIENTDATA)pvClient);
    926 
    927     vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT, 0); /** @todo r=andy Why is this necessary? The client already disconnected ... */
    928 
    929     vboxSvcClipboardCompleteReadData(pClientData, VERR_NO_DATA, 0);
    930 
     1023    if (itClient != g_mapClients.end())
     1024    {
     1025        g_mapClients.erase(itClient);
     1026    }
     1027    else
     1028        AssertFailed();
     1029
     1030    return VINF_SUCCESS;
     1031}
     1032
     1033static DECLCALLBACK(int) svcConnect(void *, uint32_t u32ClientID, void *pvClient, uint32_t fRequestor, bool fRestoring)
     1034{
     1035    RT_NOREF(fRequestor, fRestoring);
     1036
     1037    int rc = VINF_SUCCESS;
     1038
     1039    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient;
     1040    AssertPtr(pvClient);
     1041
     1042    /* Assign the client ID. */
     1043    pClient->uClientID = u32ClientID;
     1044
     1045    /* Create the client's own event source. */
     1046    SharedClipboardEventSourceCreate(&pClient->Events, (uint16_t)g_mapClients.size());
     1047
     1048    LogFlowFunc(("[Client %RU32] Using event source %RU32\n", u32ClientID, pClient->Events.uID));
     1049
     1050    /* Reset the client state. */
     1051    vboxSvcClipboardClientStateReset(&pClient->State);
     1052
     1053    /* (Re-)initialize the client state. */
     1054    vboxSvcClipboardClientStateInit(&pClient->State, u32ClientID);
     1055
     1056    rc = VBoxClipboardSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless());
    9311057#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    932     PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClientData->URI, 0 /* Index*/);
    933     if (pTransfer)
    934         vboxSvcClipboardURIAreaDetach(&pClientData->State, pTransfer);
    935 
    936     SharedClipboardURICtxDestroy(&pClientData->URI);
     1058    if (RT_SUCCESS(rc))
     1059        rc = SharedClipboardURICtxInit(&pClient->URI);
    9371060#endif
    9381061
    939     VBoxClipboardSvcImplDisconnect(pClientData);
    940 
    941     vboxSvcClipboardClientStateReset(pClientData);
    942     vboxSvcClipboardClientStateDestroy(pClientData);
    943 
    944     RTMemFree(itClient->second);
    945     g_mapClients.erase(itClient);
    946 
    947     return VINF_SUCCESS;
    948 }
    949 
    950 static DECLCALLBACK(int) svcConnect(void *, uint32_t u32ClientID, void *pvClient, uint32_t fRequestor, bool fRestoring)
    951 {
    952     RT_NOREF(fRequestor, fRestoring);
    953 
    954     LogFlowFunc(("u32ClientID=%RU32\n", u32ClientID));
    955 
    956     int rc = VINF_SUCCESS;
    957 
    958     if (g_mapClients.find(u32ClientID) != g_mapClients.end())
    959     {
    960         rc = VERR_ALREADY_EXISTS;
    961         AssertFailed(); /* Should never happen. */
    962     }
    963 
    9641062    if (RT_SUCCESS(rc))
    9651063    {
    966         PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)RTMemAllocZ(sizeof(VBOXCLIPBOARDCLIENT));
    967         if (RT_SUCCESS(rc))
    968         {
    969             pClient->uClientID = u32ClientID;
    970             pClient->pData     = (PVBOXCLIPBOARDCLIENTDATA)pvClient;
    971 
    972             /* Reset the client state. */
    973             vboxSvcClipboardClientStateReset(pClient->pData);
    974 
    975             /* (Re-)initialize the client state. */
    976             vboxSvcClipboardClientStateInit(pClient->pData, u32ClientID);
    977 
    978             rc = VBoxClipboardSvcImplConnect(pClient->pData, VBoxSvcClipboardGetHeadless());
    979 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    980             if (RT_SUCCESS(rc))
    981                 rc = SharedClipboardURICtxInit(&pClient->pData->URI);
    982 #endif
    983             g_mapClients[u32ClientID] = pClient; /** @todo Can this throw? */
    984         }
     1064        VBOXCLIPBOARDCLIENTMAPENTRY ClientEntry;
     1065        RT_ZERO(ClientEntry);
     1066
     1067        g_mapClients[u32ClientID] = ClientEntry; /** @todo Handle OOM / collisions? */
    9851068    }
    9861069
    … …  
    10021085    int rc = VINF_SUCCESS;
    10031086
    1004     LogFunc(("u32ClientID=%RU32, fn=%RU32, cParms=%RU32, paParms=%p\n",
    1005              u32ClientID, u32Function, cParms, paParms));
    1006 
    1007     ClipboardClientMap::iterator itClient = g_mapClients.find(u32ClientID);
    1008     if (itClient == g_mapClients.end())
    1009     {
    1010         AssertFailed(); /* Should never happen. */
    1011         return;
    1012     }
    1013 
    1014     PVBOXCLIPBOARDCLIENT     pClient     = itClient->second;
     1087    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient;
    10151088    AssertPtr(pClient);
    1016     PVBOXCLIPBOARDCLIENTDATA pClientData = pClient->pData;
    1017     AssertPtr(pClientData);
     1089
     1090    LogFunc(("u32ClientID=%RU32 (proto %RU32), fn=%RU32 (%s), cParms=%RU32, paParms=%p\n",
     1091             u32ClientID, pClient->State.uProtocolVer, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, paParms));
    10181092
    10191093#ifdef DEBUG
    … …  
    10331107        case VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD:
    10341108        {
    1035             /* The quest requests a host message. */
    1036             LogFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD\n"));
    1037 
    10381109            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG_OLD)
    10391110            {
    … …  
    10501121                if (VBoxSvcClipboardLock())
    10511122                {
    1052                     bool fMessageReturned = vboxSvcClipboardReturnMsg(pClientData, cParms, paParms);
     1123                    bool fMessageReturned = vboxSvcClipboardOldReturnMsg(pClient, cParms, paParms);
    10531124                    if (fMessageReturned)
    10541125                    {
    10551126                        /* Just return to the caller. */
    1056                         pClientData->State.fAsync = false;
     1127                        pClient->State.Old.fAsync = false;
    10571128                    }
    10581129                    else
    … …  
    10611132                        fDefer = true;
    10621133
    1063                         pClientData->State.fAsync           = true;
    1064                         pClientData->State.async.callHandle = callHandle;
    1065                         pClientData->State.async.cParms     = cParms;
    1066                         pClientData->State.async.paParms    = paParms;
     1134                        pClient->State.Old.fAsync           = true;
     1135                        pClient->State.Old.async.callHandle = callHandle;
     1136                        pClient->State.Old.async.cParms     = cParms;
     1137                        pClient->State.Old.async.paParms    = paParms;
    10671138                    }
    10681139
    … …  
    10741145                }
    10751146            }
    1076         } break;
    1077 
    1078         case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS:
    1079         {
    1080             /* The guest reports that some formats are available. */
    1081             LogFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS\n"));
    1082 
    1083             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_REPORT_FORMATS)
     1147
     1148            break;
     1149        }
     1150
     1151        case VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT:
     1152        {
     1153            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_CONNECT)
    10841154            {
    10851155                rc = VERR_INVALID_PARAMETER;
    10861156            }
    1087             else if (paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT) /* formats */
     1157            else if (   paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT  /* uProtocolVer */
     1158                     || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT  /* uProtocolFlags */
     1159                     || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT  /* cbChunkSize */
     1160                     || paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT  /* enmCompression */
     1161                     || paParms[4].type != VBOX_HGCM_SVC_PARM_32BIT) /* enmChecksumType */
    10881162            {
    10891163                rc = VERR_INVALID_PARAMETER;
    10901164            }
     1165            else if (vboxSvcClipboardGetMode() == VBOX_SHARED_CLIPBOARD_MODE_OFF)
     1166            {
     1167                rc = VERR_ACCESS_DENIED;
     1168            }
    10911169            else
    10921170            {
    1093                 uint32_t u32Formats;
    1094                 rc = HGCMSvcGetU32(&paParms[0], &u32Formats);
    1095                 if (RT_SUCCESS(rc))
    1096                 {
    1097                     if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
    1098                         && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     1171                /* Update the protocol version and tell the guest. */
     1172                pClient->State.uProtocolVer = 1;
     1173
     1174                LogFlowFunc(("Now using protocol v%RU32\n", pClient->State.uProtocolVer));
     1175
     1176                HGCMSvcSetU32(&paParms[0], pClient->State.uProtocolVer);
     1177                HGCMSvcSetU32(&paParms[1], 0 /* Procotol flags, not used yet */);
     1178                HGCMSvcSetU32(&paParms[2], pClient->State.cbChunkSize);
     1179                HGCMSvcSetU32(&paParms[3], 0 /* Compression type, not used yet */);
     1180                HGCMSvcSetU32(&paParms[4], 0 /* Checksum type, not used yet */);
     1181
     1182                rc = VINF_SUCCESS;
     1183            }
     1184
     1185            break;
     1186        }
     1187
     1188        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
     1189        {
     1190            rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
     1191            break;
     1192        }
     1193
     1194        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
     1195        {
     1196            rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
     1197            if (rc == VINF_HGCM_ASYNC_EXECUTE)
     1198                fDefer = true;
     1199            break;
     1200        }
     1201
     1202        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
     1203        {
     1204            rc = vboxSvcClipboardMsgGet(pClient, callHandle, cParms, paParms);
     1205            if (RT_SUCCESS(rc)) /* vboxSvcClipboardMsgGet did the completion already. */
     1206                fDefer = true;
     1207            break;
     1208        }
     1209
     1210        case VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_WRITE:
     1211        {
     1212            uint32_t u32Formats = 0;
     1213
     1214            if (pClient->State.uProtocolVer == 0)
     1215            {
     1216                if (cParms != 1)
     1217                {
     1218                    rc = VERR_INVALID_PARAMETER;
     1219                }
     1220                else if (paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT) /* uFormats */
     1221                {
     1222                    rc = VERR_INVALID_PARAMETER;
     1223                }
     1224                else
     1225                {
     1226                    rc = HGCMSvcGetU32(&paParms[0], &u32Formats);
     1227                }
     1228            }
     1229            else
     1230            {
     1231                if (cParms != 3)
     1232                {
     1233                    rc = VERR_INVALID_PARAMETER;
     1234                }
     1235                else if (   paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT  /* uContextID */
     1236                         || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT  /* uFormats */
     1237                         || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT) /* fFlags */
     1238                {
     1239                    rc = VERR_INVALID_PARAMETER;
     1240                }
     1241                else
     1242                {
     1243                    rc = HGCMSvcGetU32(&paParms[1], &u32Formats);
     1244
     1245                    /** @todo Handle rest. */
     1246                }
     1247            }
     1248
     1249            if (RT_SUCCESS(rc))
     1250            {
     1251                if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
     1252                    && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     1253                {
     1254                    rc = VERR_ACCESS_DENIED;
     1255                }
     1256                else
     1257                {
     1258                    rc = vboxSvcClipboardSetSource(pClient, SHAREDCLIPBOARDSOURCE_REMOTE);
     1259                    if (RT_SUCCESS(rc))
    10991260                    {
    1100                         rc = VERR_ACCESS_DENIED;
    1101                     }
    1102                     else
    1103                     {
    1104                         rc = vboxSvcClipboardSetSource(pClientData, SHAREDCLIPBOARDSOURCE_REMOTE);
    1105 
    1106 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST_DISABLED
    1107                         if (   RT_SUCCESS(rc)
    1108                             && (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST))
     1261            #if 0
     1262                        if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    11091263                        {
    1110                             if (!SharedClipboardURICtxTransfersMaximumReached(&pClientData->URI))
     1264                            /* Tell the guest that we want to start a reading transfer
     1265                             * (from guest to the host). */
     1266                            rc = vboxSvcClipboardReportMsg(pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START,
     1267                                                           0 /* u32Formats == 0 means reading data */);
     1268
     1269                            /* Note: Announcing the actual format will be done in the
     1270                                     host service guest call URI handler (vboxSvcClipboardURIHandler). */
     1271                        }
     1272                        else /* Announce simple formats to the OS-specific service implemenation. */
     1273            #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
     1274                        {
     1275                            if (g_pfnExtension)
    11111276                            {
    1112                                 SharedClipboardURICtxTransfersCleanup(&pClientData->URI);
    1113 
    1114                                 PSHAREDCLIPBOARDURITRANSFER pTransfer;
    1115                                 rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ,
    1116                                                                       SHAREDCLIPBOARDSOURCE_REMOTE, &pTransfer);
    1117                                 if (RT_SUCCESS(rc))
    1118                                 {
    1119                                     rc = vboxSvcClipboardURIAreaRegister(&pClientData->State, pTransfer);
    1120                                     if (RT_SUCCESS(rc))
    1121                                     {
    1122                                         SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    1123                                         RT_ZERO(creationCtx);
    1124 
    1125                                         creationCtx.enmSource = pClientData->State.enmSource;
    1126 
    1127                                         RT_ZERO(creationCtx.Interface);
    1128                                         RT_ZERO(creationCtx.Interface);
    1129                                         creationCtx.Interface.pfnTransferOpen  = vboxSvcClipboardURITransferOpen;
    1130                                         creationCtx.Interface.pfnTransferClose = vboxSvcClipboardURITransferClose;
    1131                                         creationCtx.Interface.pfnListOpen      = vboxSvcClipboardURIListOpen;
    1132                                         creationCtx.Interface.pfnListClose     = vboxSvcClipboardURIListClose;
    1133                                         creationCtx.Interface.pfnListHdrRead   = vboxSvcClipboardURIListHdrRead;
    1134                                         creationCtx.Interface.pfnListEntryRead = vboxSvcClipboardURIListEntryRead;
    1135                                         creationCtx.Interface.pfnObjOpen       = vboxSvcClipboardURIObjOpen;
    1136                                         creationCtx.Interface.pfnObjClose      = vboxSvcClipboardURIObjClose;
    1137                                         creationCtx.Interface.pfnObjRead       = vboxSvcClipboardURIObjRead;
    1138 
    1139                                         creationCtx.pvUser = pClient;
    1140 
    1141                                         /* Register needed callbacks so that we can wait for the meta data to arrive here. */
    1142                                         SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
    1143                                         RT_ZERO(Callbacks);
    1144 
    1145                                         Callbacks.pvUser                = pClientData;
    1146 
    1147                                         Callbacks.pfnTransferPrepare    = VBoxSvcClipboardURITransferPrepareCallback;
    1148                                         Callbacks.pfnTransferComplete   = VBoxSvcClipboardURITransferCompleteCallback;
    1149                                         Callbacks.pfnTransferCanceled   = VBoxSvcClipboardURITransferCanceledCallback;
    1150                                         Callbacks.pfnTransferError      = VBoxSvcClipboardURITransferErrorCallback;
    1151 
    1152                                         SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks);
    1153 
    1154                                         rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
    1155                                         if (RT_SUCCESS(rc))
    1156                                             rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer);
    1157                                     }
    1158 
    1159                                     if (RT_SUCCESS(rc))
    1160                                     {
    1161                                         rc = VBoxClipboardSvcImplURITransferCreate(pClientData, pTransfer);
    1162                                     }
    1163                                     else
    1164                                     {
    1165                                         VBoxClipboardSvcImplURITransferDestroy(pClientData, pTransfer);
    1166                                         SharedClipboardURITransferDestroy(pTransfer);
    1167                                     }
    1168                                 }
     1277                                VBOXCLIPBOARDEXTPARMS parms;
     1278                                RT_ZERO(parms);
     1279                                parms.u32Format = u32Formats;
     1280
     1281                                g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE, &parms, sizeof (parms));
    11691282                            }
    1170                             else
    1171                                 rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
    1172 
    1173                             LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST: %Rrc\n", rc));
    1174 
    1175                             if (RT_FAILURE(rc))
    1176                                 LogRel(("Shared Clipboard: Initializing URI guest to host read transfer failed with %Rrc\n", rc));
    1177                         }
    1178 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    1179 
    1180                         if (RT_SUCCESS(rc))
    1181                         {
    1182 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1183                             if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    1184                             {
    1185                                 /* Tell the guest that we want to start a reading transfer
    1186                                  * (from guest to the host). */
    1187                                 rc = vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START,
    1188                                                                0 /* u32Formats == 0 means reading data */);
    1189 
    1190                                 /* Note: Announcing the actual format will be done in the
    1191                                          host service URI handler (vboxSvcClipboardURIHandler). */
    1192                             }
    1193                             else /* Announce simple formats to the OS-specific service implemenation. */
    1194 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    1195                             {
    1196                                 if (g_pfnExtension)
    1197                                 {
    1198                                     VBOXCLIPBOARDEXTPARMS parms;
    1199                                     RT_ZERO(parms);
    1200                                     parms.u32Format = u32Formats;
    1201 
    1202                                     g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE, &parms, sizeof (parms));
    1203                                 }
    1204 
    1205                                 rc = VBoxClipboardSvcImplFormatAnnounce(pClientData, u32Formats);
    1206                             }
     1283
     1284                            VBOXCLIPBOARDCLIENTCMDCTX cmdCtx;
     1285                            RT_ZERO(cmdCtx);
     1286
     1287                            SHAREDCLIPBOARDFORMATDATA formatData;
     1288                            RT_ZERO(formatData);
     1289
     1290                            formatData.uFormats = u32Formats;
     1291
     1292                            rc = VBoxClipboardSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData);
    12071293                        }
    12081294                    }
    12091295                }
    12101296            }
    1211         } break;
    1212 
    1213         case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA:
    1214         {
    1215             /* The guest wants to read data in the given format. */
    1216             LogFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA\n"));
    1217 
     1297
     1298            break;
     1299        }
     1300
     1301        case VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_READ:
     1302        {
    12181303            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA)
    12191304            {
    … …  
    12431328                    if (u32Format == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    12441329                    {
    1245                         if (!SharedClipboardURICtxTransfersMaximumReached(&pClientData->URI))
     1330                        if (!SharedClipboardURICtxTransfersMaximumReached(&pClient->URI))
    12461331                        {
    1247                             SharedClipboardURICtxTransfersCleanup(&pClientData->URI);
     1332                            SharedClipboardURICtxTransfersCleanup(&pClient->URI);
    12481333
    12491334                            PSHAREDCLIPBOARDURITRANSFER pTransfer;
    12501335                            rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE,
    1251                                                                   pClientData->State.enmSource,
     1336                                                                  pClient->State.enmSource,
    12521337                                                                  &pTransfer);
    12531338                            if (RT_SUCCESS(rc))
    12541339                            {
    12551340                                /* Attach to the most recent clipboard area. */
    1256                                 rc = vboxSvcClipboardURIAreaAttach(&pClientData->State, pTransfer, 0 /* Area ID */);
     1341                                rc = vboxSvcClipboardURIAreaAttach(&pClient->State, pTransfer, 0 /* Area ID */);
    12571342                                if (RT_SUCCESS(rc))
    12581343                                {
    … …  
    12681353                                    creationCtx.Interface.pfnObjWrite        = vboxSvcClipboardURIObjWrite;
    12691354
    1270                                     creationCtx.pvUser = pClientData;
     1355                                    creationCtx.pvUser = pClient;
    12711356
    12721357                                    rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
    12731358                                    if (RT_SUCCESS(rc))
    1274                                         rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer);
     1359                                        rc = SharedClipboardURICtxTransferAdd(&pClient->URI, pTransfer);
    12751360                                }
    12761361
    12771362                                if (RT_SUCCESS(rc))
    12781363                                {
    1279                                     rc = VBoxClipboardSvcImplURITransferCreate(pClientData, pTransfer);
     1364                                    rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer);
    12801365                                }
    12811366                                else
    12821367                                {
    1283                                     VBoxClipboardSvcImplURITransferDestroy(pClientData, pTransfer);
     1368                                    VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer);
    12841369                                    SharedClipboardURITransferDestroy(pTransfer);
    12851370                                }
    … …  
    12971382                        void    *pv;
    12981383                        uint32_t cb;
    1299                         rc = VBoxHGCMParmPtrGet(&paParms[1], &pv, &cb);
     1384                        rc = HGCMSvcGetBuf(&paParms[1], &pv, &cb);
    13001385                        if (RT_SUCCESS(rc))
    13011386                        {
    … …  
    13181403                                if (g_fDelayedAnnouncement)
    13191404                                {
    1320                                     vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, g_u32DelayedFormats);
     1405                                    vboxSvcClipboardOldReportMsg(pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE, g_u32DelayedFormats);
    13211406                                    g_fDelayedAnnouncement = false;
    13221407                                    g_u32DelayedFormats = 0;
    … …  
    13331418                            /* Release any other pending read, as we only
    13341419                             * support one pending read at one time. */
    1335                             rc = vboxSvcClipboardCompleteReadData(pClientData, VERR_NO_DATA, 0);
     1420                            rc = vboxSvcClipboardOldCompleteReadData(pClient, VERR_NO_DATA, 0);
    13361421                            if (RT_SUCCESS(rc))
    1337                                 rc = VBoxClipboardSvcImplReadData(pClientData, u32Format, pv, cb, &cbActual);
     1422                            {
     1423                                VBOXCLIPBOARDCLIENTCMDCTX cmdCtx;
     1424                                RT_ZERO(cmdCtx);
     1425
     1426                                SHAREDCLIPBOARDDATABLOCK dataBlock;
     1427                                RT_ZERO(dataBlock);
     1428
     1429                                dataBlock.pvData  = pv;
     1430                                dataBlock.cbData  = cb;
     1431                                dataBlock.uFormat = u32Format;
     1432
     1433                                rc = VBoxClipboardSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual);
     1434                            }
    13381435
    13391436                            /* Remember our read request until it is completed.
    … …  
    13441441                                if (VBoxSvcClipboardLock())
    13451442                                {
    1346                                     pClientData->State.asyncRead.callHandle = callHandle;
    1347                                     pClientData->State.asyncRead.cParms     = cParms;
    1348                                     pClientData->State.asyncRead.paParms    = paParms;
    1349                                     pClientData->State.fReadPending         = true;
     1443                                    pClient->State.Old.asyncRead.callHandle = callHandle;
     1444                                    pClient->State.Old.asyncRead.cParms     = cParms;
     1445                                    pClient->State.Old.asyncRead.paParms    = paParms;
     1446                                    pClient->State.Old.fReadPending         = true;
    13501447                                    fDefer = true;
    13511448                                    VBoxSvcClipboardUnlock();
    … …  
    13641461                }
    13651462            }
    1366         } break;
    1367 
    1368         case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA:
    1369         {
    1370             /* The guest writes the requested data. */
    1371             LogFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA\n"));
    1372 
    1373             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA)
    1374             {
    1375                 rc = VERR_INVALID_PARAMETER;
    1376             }
    1377             else if (   paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT   /* format */
    1378                      || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR     /* ptr */
    1379                     )
    1380             {
    1381                 rc = VERR_INVALID_PARAMETER;
    1382             }
    1383             else
    1384             {
    1385                 void *pv;
    1386                 uint32_t cb;
    1387                 uint32_t u32Format;
    1388 
    1389                 rc = HGCMSvcGetU32(&paParms[0], &u32Format);
    1390                 if (RT_SUCCESS(rc))
    1391                 {
    1392                     rc = VBoxHGCMParmPtrGet(&paParms[1], &pv, &cb);
    1393                     if (RT_SUCCESS(rc))
    1394                     {
    1395                         if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
    1396                             && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
    1397                         {
    1398                             rc = VERR_NOT_SUPPORTED;
    1399                             break;
    1400                         }
    1401 
    1402                         if (g_pfnExtension)
    1403                         {
    1404                             VBOXCLIPBOARDEXTPARMS parms;
    1405                             RT_ZERO(parms);
    1406 
    1407                             parms.u32Format = u32Format;
    1408                             parms.u.pvData  = pv;
    1409                             parms.cbData    = cb;
    1410 
    1411                             g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_WRITE, &parms, sizeof (parms));
    1412                         }
    1413 
    1414                         rc = VBoxClipboardSvcImplWriteData(pClientData, pv, cb, u32Format);
    1415                     }
    1416                 }
    1417             }
    1418         } break;
     1463
     1464            break;
     1465        }
     1466
     1467        case VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE:
     1468        {
     1469            rc = vboxSvcClipboardGetDataWrite(pClient, cParms, paParms);
     1470            break;
     1471        }
    14191472
    14201473        default:
    … …  
    14281481            rc = VERR_NOT_IMPLEMENTED;
    14291482#endif
    1430         } break;
     1483            break;
     1484        }
    14311485    }
    14321486
    … …  
    14421496 * then complete it, otherwise return.  See the protocol description in the
    14431497 * shared clipboard module description. */
    1444 int vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, int rc, uint32_t cbActual)
     1498int vboxSvcClipboardOldCompleteReadData(PVBOXCLIPBOARDCLIENT pClient, int rc, uint32_t cbActual)
    14451499{
    14461500    VBOXHGCMCALLHANDLE callHandle = NULL;
    … …  
    14491503    if (VBoxSvcClipboardLock())  /* if not can we do anything useful? */
    14501504    {
    1451         callHandle   = pClientData->State.asyncRead.callHandle;
    1452         paParms      = pClientData->State.asyncRead.paParms;
    1453         fReadPending = pClientData->State.fReadPending;
    1454         pClientData->State.fReadPending = false;
     1505        callHandle   = pClient->State.Old.asyncRead.callHandle;
     1506        paParms      = pClient->State.Old.asyncRead.paParms;
     1507        fReadPending = pClient->State.Old.fReadPending;
     1508        pClient->State.Old.fReadPending = false;
    14551509        VBoxSvcClipboardUnlock();
    14561510    }
    … …  
    14681522 *
    14691523 * @returns VBox status code.
    1470  * @param   pClientData         Client state to initialize.
     1524 * @param   pClientState        Client state to initialize.
    14711525 * @param   uClientID           Client ID (HGCM) to use for this client state.
    14721526 */
    1473 static int vboxSvcClipboardClientStateInit(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t uClientID)
     1527static int vboxSvcClipboardClientStateInit(PVBOXCLIPBOARDCLIENTSTATE pClientState, uint32_t uClientID)
    14741528{
    14751529    LogFlowFuncEnter();
     1530
     1531    vboxSvcClipboardClientStateReset(pClientState);
    14761532
    14771533    /* Register the client.
    14781534     * Note: Do *not* memset the struct, as it contains classes (for caching). */
    1479     pClientData->State.u32ClientID = uClientID;
     1535    pClientState->u32ClientID    = uClientID;
     1536    pClientState->uProtocolVer   = 0;
    14801537
    14811538    return VINF_SUCCESS;
    … …  
    14861543 *
    14871544 * @returns VBox status code.
    1488  * @param   pClientData         Client state to destroy.
     1545 * @param   pClientState        Client state to destroy.
    14891546 */
    1490 static int vboxSvcClipboardClientStateDestroy(PVBOXCLIPBOARDCLIENTDATA pClientData)
    1491 {
     1547static int vboxSvcClipboardClientStateDestroy(PVBOXCLIPBOARDCLIENTSTATE pClientState)
     1548{
     1549    RT_NOREF(pClientState);
     1550
    14921551    LogFlowFuncEnter();
    14931552
    1494     vboxSvcClipboardMsgQueueReset(pClientData);
    1495 
    14961553    return VINF_SUCCESS;
     1554}
     1555
     1556/**
     1557 * Resets a Shared Clipboard service's old client state.
     1558 * Legacy protocol, do not use anymore.
     1559 *
     1560 * @param   pClientState        Client state to reset.
     1561 */
     1562static void vboxSvcClipboardOldClientStateReset(PVBOXCLIPBOARDCLIENTSTATE pClientState)
     1563{
     1564    LogFlowFuncEnter();
     1565
     1566    pClientState->Old.fAsync                       = false;
     1567    pClientState->Old.fReadPending                 = false;
     1568
     1569    pClientState->Old.fHostMsgQuit                 = false;
     1570    pClientState->Old.fHostMsgReadData             = false;
     1571    pClientState->Old.fHostMsgFormats              = false;
     1572
     1573    pClientState->Old.u32AvailableFormats = 0;
     1574    pClientState->Old.u32RequestedFormat  = 0;
    14971575}
    14981576
    … …  
    15001578 * Resets a Shared Clipboard service's client state.
    15011579 *
    1502  * @param   pClientData         Client state to reset.
     1580 * @param   pClient         Client state to reset.
    15031581 */
    1504 static void vboxSvcClipboardClientStateReset(PVBOXCLIPBOARDCLIENTDATA pClientData)
     1582static void vboxSvcClipboardClientStateReset(PVBOXCLIPBOARDCLIENTSTATE pClientState)
    15051583{
    15061584    LogFlowFuncEnter();
    15071585
    1508     /** @todo Clear async / asynRead / ... data? */
    1509     vboxSvcClipboardMsgQueueReset(pClientData);
    1510 
    1511     pClientData->State.u32ClientID                  = 0;
    1512     pClientData->State.fAsync                       = false;
    1513     pClientData->State.fReadPending                 = false;
    1514 
    1515     pClientData->State.fHostMsgQuit                 = false;
    1516     pClientData->State.fHostMsgReadData             = false;
    1517     pClientData->State.fHostMsgFormats              = false;
    15181586#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1519     pClientData->State.URI.fTransferStart = false;
    1520     pClientData->State.URI.enmTransferDir = SHAREDCLIPBOARDURITRANSFERDIR_UNKNOWN;
     1587    pClientState->URI.fTransferStart = false;
     1588    pClientState->URI.enmTransferDir = SHAREDCLIPBOARDURITRANSFERDIR_UNKNOWN;
    15211589#endif
    15221590
    1523     pClientData->State.u32AvailableFormats = 0;
    1524     pClientData->State.u32RequestedFormat = 0;
     1591    vboxSvcClipboardOldClientStateReset(pClientState);
    15251592}
    15261593
    … …  
    16011668{
    16021669    SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, u32ClientID),  /* for validation purposes */
    1603     SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, fHostMsgQuit),
    1604     SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, fHostMsgReadData),
    1605     SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, fHostMsgFormats),
    1606     SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, u32RequestedFormat),
     1670    SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, Old.fHostMsgQuit),
     1671    SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, Old.fHostMsgReadData),
     1672    SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, Old.fHostMsgFormats),
     1673    SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, Old.u32RequestedFormat),
    16071674    SSMFIELD_ENTRY_TERM()
    16081675};
    … …  
    16221689    LogFunc(("u32ClientID=%RU32\n", u32ClientID));
    16231690
    1624     PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pvClient;
     1691    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient;
    16251692
    16261693    /* This field used to be the length. We're using it as a version field
    16271694       with the high bit set. */
    16281695    SSMR3PutU32(pSSM, UINT32_C(0x80000002));
    1629     int rc = SSMR3PutStructEx(pSSM, pClientData, sizeof(*pClientData), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);
     1696    int rc = SSMR3PutStructEx(pSSM, pClient, sizeof(*pClient), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);
    16301697    AssertRCReturn(rc, rc);
    16311698
    … …  
    16431710    LogFunc(("u32ClientID=%RU32\n", u32ClientID));
    16441711
    1645     PVBOXCLIPBOARDCLIENTDATA pClientData   = (PVBOXCLIPBOARDCLIENTDATA)pvClient;
    1646     AssertPtr(pClientData);
     1712    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient;
     1713    AssertPtr(pClient);
    16471714
    16481715    /* Existing client can not be in async state yet. */
    1649     Assert(!pClientData->State.fAsync);
     1716    Assert(!pClient->State.Old.fAsync);
    16501717
    16511718    /* Save the client ID for data validation. */
    16521719    /** @todo isn't this the same as u32ClientID? Playing safe for now... */
    1653     uint32_t const u32ClientIDOld = pClientData->State.u32ClientID;
     1720    uint32_t const u32ClientIDOld = pClient->State.u32ClientID;
    16541721
    16551722    /* Restore the client data. */
    … …  
    16591726    if (lenOrVer == UINT32_C(0x80000002))
    16601727    {
    1661         rc = SSMR3GetStructEx(pSSM, pClientData, sizeof(*pClientData), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);
     1728        rc = SSMR3GetStructEx(pSSM, pClient, sizeof(*pClient), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);
    16621729        AssertRCReturn(rc, rc);
    16631730    }
    … …  
    16691736
    16701737    /* Verify the client ID. */
    1671     if (pClientData->State.u32ClientID != u32ClientIDOld)
    1672     {
    1673         LogFunc(("Client ID mismatch: expected %d, got %d\n", u32ClientIDOld, pClientData->State.u32ClientID));
    1674         pClientData->State.u32ClientID = u32ClientIDOld;
     1738    if (pClient->State.u32ClientID != u32ClientIDOld)
     1739    {
     1740        LogFunc(("Client ID mismatch: expected %d, got %d\n", u32ClientIDOld, pClient->State.u32ClientID));
     1741        pClient->State.u32ClientID = u32ClientIDOld;
    16751742        return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
    16761743    }
    16771744
    16781745    /* Actual host data are to be reported to guest (SYNC). */
    1679     VBoxClipboardSvcImplSync(pClientData);
     1746    VBoxClipboardSvcImplSync(pClient);
    16801747
    16811748#else  /* UNIT_TEST*/
    … …  
    16931760    int rc = VINF_SUCCESS;
    16941761
    1695     PVBOXCLIPBOARDCLIENTDATA pClientData = NULL; /** @todo FIX !!! */
    1696 
    1697     if (pClientData != NULL)
     1762    PVBOXCLIPBOARDCLIENT pClient = NULL; /** @todo FIX !!! */
     1763
     1764    if (pClient != NULL)
    16981765    {
    16991766        switch (u32Function)
    … …  
    17101777                else
    17111778                {
    1712                     vboxSvcClipboardReportMsg(g_pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, u32Format);
     1779                    vboxSvcClipboardReportMsg(g_pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, u32Format);
    17131780                }
    17141781            #endif
    … …  
    17181785            case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
    17191786            {
    1720                 vboxSvcClipboardReportMsg(g_pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format);
     1787                vboxSvcClipboardReportMsg(g_pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format);
    17211788            } break;
    17221789#endif
    … …  
    17841851            g_pHelpers = ptable->pHelpers;
    17851852
    1786             ptable->cbClient = sizeof(VBOXCLIPBOARDCLIENTDATA);
     1853            ptable->cbClient = sizeof(VBOXCLIPBOARDCLIENT);
    17871854
    17881855            ptable->pfnUnload     = svcUnload;

  • trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp

    r79556 r80444  
    122122                  2, parms, 0);
    123123    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
    124     vboxSvcClipboardReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     124    vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    125125                              VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
    126126    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    … …  
    134134    RTTestISub("Testing FN_GET_HOST_MSG, one format, no waiting guest calls.");
    135135    RT_ZERO(g_Client.State);
    136     vboxSvcClipboardReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     136    vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    137137                              VBOX_SHARED_CLIPBOARD_FMT_HTML);
    138138    HGCMSvcSetU32(&parms[0], 0);
    … …  
    157157                  2, parms, 0);
    158158    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
    159     vboxSvcClipboardReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     159    vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    160160                              VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
    161161    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    … …  
    175175    RTTestISub("Testing FN_GET_HOST_MSG, two formats, no waiting guest calls.");
    176176    RT_ZERO(g_Client.State);
    177     vboxSvcClipboardReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     177    vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    178178                              VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
    179179    HGCMSvcSetU32(&parms[0], 0);
    … …  
    277277int VBoxClipboardSvcImplInit() { return VINF_SUCCESS; }
    278278void VBoxClipboardSvcImplDestroy() { }
    279 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA)
     279int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT)
    280280{ return VINF_SUCCESS; }
    281 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA, bool)
     281int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT, bool)
    282282{ return VINF_SUCCESS; }
    283 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA, unsigned int)
     283int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDFORMATDATA pFormats)
    284284{ AssertFailed(); return VINF_SUCCESS; }
    285 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA, unsigned int, void *, unsigned int, unsigned int *)
     285int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData, unsigned int *)
    286286{ AssertFailed(); return VERR_WRONG_ORDER; }
    287 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA, void *, unsigned int, unsigned int)
     287int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData)
    288288{ AssertFailed(); return VINF_SUCCESS; }
    289 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA)
     289int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT)
    290290{ AssertFailed(); return VERR_WRONG_ORDER; }
    291291
Note: See TracChangeset for help on using the changeset viewer.

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