VirtualBox

Changeset 80283 in vbox


Ignore:
Timestamp:
Aug 15, 2019 8:47:23 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
132738
Message:

Shared Clipboard/URI: Update; more work on root list handling.

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed

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

    r79703 r80283  
    7070
    7171/** No flags. Initialization value. */
    72 #define SHAREDCLIPBOARD_CF_NONE                  (0x00000000)
     72#define SHAREDCLIPBOARD_OBJ_CF_NONE                  (0x00000000)
    7373
    7474/** Lookup only the object, do not return a handle. All other flags are ignored. */
    75 #define SHAREDCLIPBOARD_CF_LOOKUP                (0x00000001)
     75#define SHAREDCLIPBOARD_OBJ_CF_LOOKUP                (0x00000001)
    7676
    7777/** Create/open a directory. */
    78 #define SHAREDCLIPBOARD_CF_DIRECTORY             (0x00000004)
     78#define SHAREDCLIPBOARD_OBJ_CF_DIRECTORY             (0x00000004)
    7979
    8080/** Open/create action to do if object exists
    … …  
    8787 *  FILE_EXISTS with NIL handle.
    8888 */
    89 #define SHAREDCLIPBOARD_CF_ACT_MASK_IF_EXISTS      (0x000000F0)
    90 #define SHAREDCLIPBOARD_CF_ACT_MASK_IF_NEW         (0x00000F00)
     89#define SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_EXISTS      (0x000000F0)
     90#define SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW         (0x00000F00)
    9191
    9292/** What to do if object exists. */
    93 #define SHAREDCLIPBOARD_CF_ACT_OPEN_IF_EXISTS      (0x00000000)
    94 #define SHAREDCLIPBOARD_CF_ACT_FAIL_IF_EXISTS      (0x00000010)
    95 #define SHAREDCLIPBOARD_CF_ACT_REPLACE_IF_EXISTS   (0x00000020)
    96 #define SHAREDCLIPBOARD_CF_ACT_OVERWRITE_IF_EXISTS (0x00000030)
     93#define SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS      (0x00000000)
     94#define SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_EXISTS      (0x00000010)
     95#define SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS   (0x00000020)
     96#define SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS (0x00000030)
    9797
    9898/** What to do if object does not exist. */
    99 #define SHAREDCLIPBOARD_CF_ACT_CREATE_IF_NEW       (0x00000000)
    100 #define SHAREDCLIPBOARD_CF_ACT_FAIL_IF_NEW         (0x00000100)
     99#define SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW       (0x00000000)
     100#define SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW         (0x00000100)
    101101
    102102/** Read/write requested access for the object. */
    103 #define SHAREDCLIPBOARD_CF_ACCESS_MASK_RW          (0x00003000)
     103#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_RW          (0x00003000)
    104104
    105105/** No access requested. */
    106 #define SHAREDCLIPBOARD_CF_ACCESS_NONE             (0x00000000)
     106#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_NONE             (0x00000000)
    107107/** Read access requested. */
    108 #define SHAREDCLIPBOARD_CF_ACCESS_READ             (0x00001000)
     108#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ             (0x00001000)
    109109/** Write access requested. */
    110 #define SHAREDCLIPBOARD_CF_ACCESS_WRITE            (0x00002000)
     110#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE            (0x00002000)
    111111/** Read/Write access requested. */
    112 #define SHAREDCLIPBOARD_CF_ACCESS_READWRITE        (SHAREDCLIPBOARD_CF_ACCESS_READ | SHAREDCLIPBOARD_CF_ACCESS_WRITE)
     112#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_READWRITE        (SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ | SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE)
    113113
    114114/** Requested share access for the object. */
    115 #define SHAREDCLIPBOARD_CF_ACCESS_MASK_DENY        (0x0000C000)
     115#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_DENY        (0x0000C000)
    116116
    117117/** Allow any access. */
    118 #define SHAREDCLIPBOARD_CF_ACCESS_DENYNONE         (0x00000000)
     118#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYNONE         (0x00000000)
    119119/** Do not allow read. */
    120 #define SHAREDCLIPBOARD_CF_ACCESS_DENYREAD         (0x00004000)
     120#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYREAD         (0x00004000)
    121121/** Do not allow write. */
    122 #define SHAREDCLIPBOARD_CF_ACCESS_DENYWRITE        (0x00008000)
     122#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE        (0x00008000)
    123123/** Do not allow access. */
    124 #define SHAREDCLIPBOARD_CF_ACCESS_DENYALL          (SHAREDCLIPBOARD_CF_ACCESS_DENYREAD | SHAREDCLIPBOARD_CF_ACCESS_DENYWRITE)
     124#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYALL          (SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYREAD | SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE)
    125125
    126126/** Requested access to attributes of the object. */
    127 #define SHAREDCLIPBOARD_CF_ACCESS_MASK_ATTR        (0x00030000)
     127#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_ATTR        (0x00030000)
    128128
    129129/** No access requested. */
    130 #define SHAREDCLIPBOARD_CF_ACCESS_ATTR_NONE        (0x00000000)
     130#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE        (0x00000000)
    131131/** Read access requested. */
    132 #define SHAREDCLIPBOARD_CF_ACCESS_ATTR_READ        (0x00010000)
     132#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READ        (0x00010000)
    133133/** Write access requested. */
    134 #define SHAREDCLIPBOARD_CF_ACCESS_ATTR_WRITE       (0x00020000)
     134#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_WRITE       (0x00020000)
    135135/** Read/Write access requested. */
    136 #define SHAREDCLIPBOARD_CF_ACCESS_ATTR_READWRITE   (SHAREDCLIPBOARD_CF_ACCESS_ATTR_READ | SHAREDCLIPBOARD_CF_ACCESS_ATTR_WRITE)
    137 
    138 /** The file is opened in append mode. Ignored if SHAREDCLIPBOARD_CF_ACCESS_WRITE is not set. */
    139 #define SHAREDCLIPBOARD_CF_ACCESS_APPEND           (0x00040000)
     136#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READWRITE   (SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READ | SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_WRITE)
     137
     138/** The file is opened in append mode. Ignored if SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE is not set. */
     139#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_APPEND           (0x00040000)
    140140
    141141/** @} */
    … …  
    327327
    328328#pragma pack(1)
    329 typedef struct _VBOXCLIPBOARDCREATEPARMS
    330 {
    331     /** Returned SHAREDCLIPBOARDOBJHANDLE of opened object. */
    332     SHAREDCLIPBOARDOBJHANDLE    uHandle;
    333     /** Returned result of the operation. */
    334     SHAREDCLIPBOARDCREATERESULT enmResult;
    335     /** SHAREDCLIPBOARD_CF_* */
     329/**
     330 * Structure for keeping object open/create parameters.
     331 */
     332typedef struct _VBOXCLIPBOARDOBJOPENCREATEPARMS
     333{
     334    char                       *pszPath;
     335    uint32_t                    cbPath;
     336    /** SHAREDCLIPBOARD_OBJ_CF_* */
    336337    uint32_t                    fCreate;
    337338    /**
    … …  
    340341     */
    341342    SHAREDCLIPBOARDFSOBJINFO    ObjInfo;
    342 } VBOXCLIPBOARDCREATEPARMS, *PVBOXCLIPBOARDCREATEPARMS;
     343} VBOXCLIPBOARDOBJOPENCREATEPARMS, *PVBOXCLIPBOARDOBJOPENCREATEPARMS;
    343344#pragma pack()
    344345
    … …  
    369370} VBOXCLIPBOARDREPLY, *PVBOXCLIPBOARDREPLY;
    370371
    371 /**
    372  * Structure for keeping Shared Clipboard list root entries.
    373  */
    374 typedef struct _VBOXCLIPBOARDROOTS
     372struct _VBOXCLIPBOARDLISTENTRY;
     373typedef _VBOXCLIPBOARDLISTENTRY VBOXCLIPBOARDLISTENTRY;
     374
     375/** Defines a single root list entry. Currently the same as a regular list entry. */
     376typedef VBOXCLIPBOARDLISTENTRY VBOXCLIPBOARDROOTLISTENTRY;
     377/** Defines a pointer to a single root list entry. Currently the same as a regular list entry pointer. */
     378typedef VBOXCLIPBOARDROOTLISTENTRY *PVBOXCLIPBOARDROOTLISTENTRY;
     379
     380/**
     381 * Structure for keeping Shared Clipboard root list headers.
     382 */
     383typedef struct _VBOXCLIPBOARDROOTLISTHDR
    375384{
    376385    /** Roots listing flags; unused at the moment. */
    377     uint32_t fRoots;
    378     /** Boolean indicating that more root items are following. */
    379     bool     fMore;
    380     /** Number of root items in this message. */
    381     uint32_t cRoots;
    382     /** Size (in bytes) of string list. */
    383     uint32_t cbRoots;
    384     /** String list (separated with CRLF) containing the root items. */
    385     char    *pszRoots;
    386 } VBOXCLIPBOARDROOTS, *PVBOXCLIPBOARDROOTS;
     386    uint32_t                fRoots;
     387    /** Number of root list entries. */
     388    uint32_t                cRoots;
     389} VBOXCLIPBOARDROOTLISTHDR, *PVBOXCLIPBOARDROOTLISTHDR;
     390
     391/**
     392 * Structure for maintaining a Shared Clipboard root list.
     393 */
     394typedef struct _VBOXCLIPBOARDROOTLIST
     395{
     396    /** Root list header. */
     397    VBOXCLIPBOARDROOTLISTHDR    Hdr;
     398    /** Root list entries. */
     399    VBOXCLIPBOARDROOTLISTENTRY *paEntries;
     400} VBOXCLIPBOARDROOTLIST, *PVBOXCLIPBOARDROOTLIST;
    387401
    388402/**
    … …  
    437451} VBOXCLIPBOARDLISTENTRY, *PVBOXCLIPBOARDLISTENTRY;
    438452
    439 #define VBOXCLIPBOARDLISTENTRY_MAX_NAME     RTPATH_MAX
     453/** Maximum length (in UTF-8 characters) of a list entry name. */
     454#define VBOXCLIPBOARDLISTENTRY_MAX_NAME     RTPATH_MAX /** @todo Improve this to be more dynamic. */
     455
     456/**
     457 * Structure for maintaining a Shared Clipboard list.
     458 */
     459typedef struct _VBOXCLIPBOARDLIST
     460{
     461    /** List header. */
     462    VBOXCLIPBOARDLISTHDR        Hdr;
     463    /** List entries. */
     464    VBOXCLIPBOARDROOTLISTENTRY *paEntries;
     465} VBOXCLIPBOARDLIST, *PVBOXCLIPBOARDLIST;
    440466
    441467/**
    … …  
    579605int SharedClipboardPathSanitize(char *pszPath, size_t cbPath);
    580606
    581 PVBOXCLIPBOARDROOTS SharedClipboardURIRootsDup(PVBOXCLIPBOARDROOTS pRoots);
    582 int SharedClipboardURIRootsInit(PVBOXCLIPBOARDROOTS pRoots);
    583 void SharedClipboardURIRootsDestroy(PVBOXCLIPBOARDROOTS pRoots);
     607PVBOXCLIPBOARDROOTLIST SharedClipboardURIRootListAlloc(void);
     608void SharedClipboardURIRootListFree(PVBOXCLIPBOARDROOTLIST pRootList);
     609
     610PVBOXCLIPBOARDROOTLISTHDR SharedClipboardURIRootListHdrDup(PVBOXCLIPBOARDROOTLISTHDR pRoots);
     611int SharedClipboardURIRootListHdrInit(PVBOXCLIPBOARDROOTLISTHDR pRoots);
     612void SharedClipboardURIRootListHdrDestroy(PVBOXCLIPBOARDROOTLISTHDR pRoots);
     613
     614int SharedClipboardURIRootListEntryCopy(PVBOXCLIPBOARDROOTLISTENTRY pDst, PVBOXCLIPBOARDROOTLISTENTRY pSrc);
     615PVBOXCLIPBOARDROOTLISTENTRY SharedClipboardURIRootListEntryDup(PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry);
     616void SharedClipboardURIRootListEntryDestroy(PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry);
    584617
    585618int SharedClipboardURIListHdrAlloc(PVBOXCLIPBOARDLISTHDR *ppListHdr);
    … …  
    686719} SHAREDCLIPBOARDURITRANSFEREVENT, *PSHAREDCLIPBOARDURITRANSFEREVENT;
    687720
    688 /**
    689  * Enumeration for an URI transfer event type.
    690  */
    691 typedef enum _SHAREDCLIPBOARDURITRANSFEREVENTTYPE
    692 {
    693     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_UNKNOWN,
    694     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS,
    695     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN,
    696     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_CLOSE,
    697     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_READ,
    698     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE,
    699     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_READ,
    700     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE,
    701     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_OBJ_OPEN,
    702     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_OBJ_CLOSE,
    703     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_OBJ_READ,
    704     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_OBJ_WRITE,
    705     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ERROR,
    706     /** Marks the end of the event list. */
    707     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LAST,
    708     /** The usual 32-bit hack. */
    709     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_32BIT_HACK = 0x7fffffff
    710 } SHAREDCLIPBOARDURITRANSFEREVENTTYPE;
    711 
    712721/** Map of URI transfer events.
    713722 *  The key specifies the event type of SHAREDCLIPBOARDURITRANSFEREVENTTYPE. */
    714 typedef std::map<uint32_t, SHAREDCLIPBOARDURITRANSFEREVENT *> SharedClipboardURITransferEventMap;
     723typedef std::map<uint16_t, SHAREDCLIPBOARDURITRANSFEREVENT *> SharedClipboardURITransferEventMap;
    715724
    716725typedef struct _SHAREDCLIPBOARDURILISTHANDLEINFO
    … …  
    750759typedef std::map<SHAREDCLIPBOARDOBJHANDLE, SHAREDCLIPBOARDURILISTHANDLEINFO *> SharedClipboardURIObjMap;
    751760
     761/**
     762 * Structure for keeping a single root list entry.
     763 *
     764 * Warning: Contains non-POD types.
     765 */
     766typedef struct _SHAREDCLIPBOARDURILISTROOT
     767{
     768    /** Absolute path of entry. */
     769    RTCString strPathAbs;
     770} SHAREDCLIPBOARDURILISTROOT, *PSHAREDCLIPBOARDURILISTROOT;
     771
    752772/** List of URI list root entries. */
    753 typedef RTCList<RTCString> SharedClipboardURIListRootEntries;
     773typedef RTCList<SHAREDCLIPBOARDURILISTROOT> SharedClipboardURIListRootEntries;
    754774
    755775/**
    … …  
    759779typedef struct _SHAREDCLIPBOARDURITRANSFERSTATE
    760780{
     781    /** The transfer's (local) ID. */
     782    uint16_t                            uID;
    761783    /** The transfer's current status. */
    762784    SHAREDCLIPBOARDURITRANSFERSTATUS    enmStatus;
    … …  
    803825SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(TRANSFEROPEN)
    804826SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(TRANSFERCLOSE)
    805 SHAREDCLIPBOARDPROVIDERFUNCDECL(GETROOTS, char **ppapszRoots, uint32_t *pcRoots)
     827SHAREDCLIPBOARDPROVIDERFUNCDECL(GETROOTS, PVBOXCLIPBOARDROOTLIST *ppRootList);
    806828SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTOPEN, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList)
    807829SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTCLOSE, SHAREDCLIPBOARDLISTHANDLE hList);
    … …  
    810832SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTENTRYREAD, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pEntry)
    811833SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTENTRYWRITE, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pEntry)
    812 SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJOPEN, const char *pszPath, PVBOXCLIPBOARDCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj)
     834SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJOPEN, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj)
    813835SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJCLOSE, SHAREDCLIPBOARDOBJHANDLE hObj)
    814836SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJREAD, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    … …  
    934956    /** The transfer's state (for SSM, later). */
    935957    SHAREDCLIPBOARDURITRANSFERSTATE     State;
     958    /** Timeout (in ms) for waiting of events. Default is 30s. */
     959    RTMSINTERVAL                        uTimeoutMs;
     960    /** Maximum data chunk size (in bytes) to transfer. Default is 64K. */
     961    uint32_t                            cbMaxChunkSize;
    936962    /** Events related to this transfer. */
    937963    SharedClipboardURITransferEventMap *pMapEvents;
     964    /** Next upcoming list handle. */
     965    uint64_t                            uListHandleNext;
    938966    /** Map of all lists related to this transfer. */
    939967    SharedClipboardURIListMap          *pMapLists;
    940968    /** List of root entries of this transfer. */
    941969    SharedClipboardURIListRootEntries   lstRootEntries;
     970    /** Next upcoming object handle. */
     971    uint64_t                            uObjHandleNext;
     972    /** Next upcoming event ID.
     973     *  0 is reserved for invalid event IDs. */
     974    uint16_t                            uEventIDNext;
    942975    /** Map of all objects related to this transfer. */
    943976    SharedClipboardURIObjMap           *pMapObj;
    … …  
    9821015bool SharedClipboardURIObjCtxIsValid(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx);
    9831016
     1017int SharedClipboardURIObjectOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDOBJOPENCREATEPARMS pOpenCreateParms,
     1018                                 PSHAREDCLIPBOARDOBJHANDLE phObj);
     1019int SharedClipboardURIObjectClose(SHAREDCLIPBOARDOBJHANDLE hObj);
     1020int SharedClipboardURIObjectRead(SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags);
     1021int SharedClipboardURIObjectWrite(SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags);
     1022int SharedClipboardURIObjectQueryInfo(SHAREDCLIPBOARDOBJHANDLE hObj, PSHAREDCLIPBOARDFSOBJINFO pObjInfo);
     1023
    9841024int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource,
    9851025                                     PSHAREDCLIPBOARDURITRANSFER *ppTransfer);
    … …  
    10091049void SharedClipboardURITransferReset(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    10101050SharedClipboardArea *SharedClipboardURITransferGetArea(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    1011 int SharedClipboardURILTransferGetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, char **ppapszRoots, uint32_t *pcRoots);
     1051
     1052uint32_t SharedClipboardURILTransferRootsCount(PSHAREDCLIPBOARDURITRANSFER pTransfer);
     1053int SharedClipboardURILTransferRootsEntry(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uIndex, PVBOXCLIPBOARDLISTENTRY pEntry);
     1054int SharedClipboardURILTransferRootsAsList(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDROOTLIST *ppRootList);
     1055
    10121056SHAREDCLIPBOARDSOURCE SharedClipboardURITransferGetSource(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    10131057SHAREDCLIPBOARDURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    … …  
    10211065void SharedClipboardURITransferPayloadFree(PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload);
    10221066
    1023 int SharedClipboardURITransferEventRegister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID);
    1024 int SharedClipboardURITransferEventUnregister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID);
    1025 int SharedClipboardURITransferEventWait(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID, RTMSINTERVAL uTimeoutMs,
     1067uint16_t SharedClipboardURITransferEventIDGenerate(PSHAREDCLIPBOARDURITRANSFER pTransfer);
     1068int SharedClipboardURITransferEventRegister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID);
     1069int SharedClipboardURITransferEventUnregister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID);
     1070int SharedClipboardURITransferEventWait(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID, RTMSINTERVAL uTimeoutMs,
    10261071                                        PSHAREDCLIPBOARDURITRANSFERPAYLOAD *ppPayload);
    1027 int SharedClipboardURITransferEventSignal(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID, PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload);
     1072int SharedClipboardURITransferEventSignal(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID, PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload);
    10281073
    10291074int SharedClipboardURITransferRead(PSHAREDCLIPBOARDURITRANSFER pTransfer);

  • trunk/include/VBox/GuestHost/clipboard-helper.h

    r79178 r80283  
    190190 */
    191191void VBoxClipboardDbgDumpData(const void *pv, size_t cb, VBOXCLIPBOARDFORMAT u32Format);
     192
     193/**
     194 * Translates a Shared Clipboard host message enum to a string.
     195 *
     196 * @returns Message ID string name.
     197 * @param   uMsg                The message to translate.
     198 */
     199const char *VBoxClipboardHostMsgToStr(uint32_t uMsg);
     200
     201/**
     202 * Translates a Shared Clipboard guest message enum to a string.
     203 *
     204 * @returns Message ID string name.
     205 * @param   uMsg                The message to translate.
     206 */
     207const char *VBoxClipboardGuestMsgToStr(uint32_t uMsg);
    192208#endif /* LOG_ENABLED */
    193209

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

    r79703 r80283  
    7474
    7575/** Initiates a new transfer (read / write) on the guest side. */
    76 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START     50
    77 /** Requests reading the root entries from the guest. */
    78 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOTS              51
     76#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START           50
     77/** Reads the root list header from the guest. */
     78#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ       51
     79/** Writes the root list header to the guest. */
     80#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_WRITE      52
     81/** Reads a root list entry from the guest. */
     82#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ     53
     83/** Writes a root list entry to the guest. */
     84#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_WRITE    54
    7985/** Open an URI list on the guest side. */
    80 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN          52
     86#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN                55
    8187/** Closes a formerly opened URI list on the guest side. */
    82 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE         53
     88#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE               56
    8389/** Reads a list header from the guest. */
    84 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ      54
     90#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ            57
    8591/** Writes a list header to the guest. */
    86 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE     55
     92#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE           58
    8793/** Reads a list entry from the guest. */
    88 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ    56
     94#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ          59
    8995/** Writes a list entry to the guest. */
    90 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE   57
     96#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE         60
    9197/** Open an URI object on the guest side. */
    92 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN           58
     98#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN                 61
    9399/** Closes a formerly opened URI object on the guest side. */
    94 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE          59
     100#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE                62
    95101/** Reads from an object on the guest side. */
    96 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ           60
     102#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ                 63
    97103/** Writes to an object on the guest side. */
    98 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE          61
     104#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE                64
    99105/** Indicates that the host has canceled a transfer. */
    100 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_CANCEL             62
     106#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_CANCEL                   65
    101107/** Indicates that the an unrecoverable error on the host occurred . */
    102 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ERROR              63
     108#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ERROR                    66
    103109
    104110/*
    … …  
    118124/** Peeks at the next message, returning immediately.
    119125 *  New since URI handling was implemented. */
    120 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT   5
     126#define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT        5
    121127/** Peeks at the next message, waiting for one to arrive.
    122128 *  New since URI handling was implemented. */
    123 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT     6
     129#define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT          6
    124130/** Gets the next message, returning immediately.
    125131 *  New since URI handling was implemented. */
    126 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET           7
     132#define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET                7
    127133/** Sends a transfer status to the host.
    128134 *  New since URI handling was implemented. */
    129 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS            8
     135#define VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS                 8
    130136/** Replies to a function from the host.
    131137 *  New since URI handling was implemented. */
    132 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY             9
     138#define VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY                  9
    133139/** Reports the available root entries of a transfer.
    134   *  New since URI handling was implemented. */
    135 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOTS             10
     140 *  New since URI handling was implemented. */
     141#define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ     10
     142/** 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
     145/** 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
     148/** 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
    136151/** Opens / gets a list handle from the host.
    137152 *  New since URI handling was implemented. */
    138 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN         11
     153#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN              14
    139154/** Closes a list handle from the host.
    140155 *  New since URI handling was implemented. */
    141 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE        12
     156#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE             15
    142157/** Reads a list header from the host.
    143158 *  New since URI handling was implemented. */
    144 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ     13
     159#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ          16
    145160/** Writes a list header to the host.
    146161 *  New since URI handling was implemented. */
    147 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE    14
     162#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE         17
    148163/** New since URI handling was implemented. */
    149 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ   15
     164#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ        18
    150165/** New since URI handling was implemented. */
    151 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE  16
     166#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE       19
    152167/** New since URI handling was implemented. */
    153 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN          17
     168#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN               20
    154169/** New since URI handling was implemented. */
    155 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE         18
     170#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE              21
    156171/** New since URI handling was implemented. */
    157 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ          19
     172#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ               22
    158173/**  New since URI handling was implemented. */
    159 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE         20
     174#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE              23
    160175/** Reports cancellation of the current operation to the host.
    161176 *  New since URI handling was implemented. */
    162 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL            21
     177#define VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL                 24
    163178/** Reports an error to the host.
    164179 *  New since URI handling was implemented. */
    165 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR             22
    166 
    167 /**
    168  * Translates a Shared Clipboard host message enum to a string.
    169  *
    170  * @returns Message ID string name.
    171  * @param   uMsg                The message to translate.
    172  */
    173 DECLINLINE(const char *) VBoxSvcClipboardHostMsgToStr(uint32_t uMsg)
    174 {
    175     switch (uMsg)
    176     {
    177         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
    178         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    179         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS);
    180         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START);
    181         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOTS);
    182         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN);
    183         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE);
    184         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ);
    185         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE);
    186         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ);
    187         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE);
    188         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN);
    189         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE);
    190         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ);
    191         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE);
    192         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_CANCEL);
    193         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ERROR);
    194     }
    195     return "Unknown";
    196 }
    197 
    198 /**
    199  * Translates a Shared Clipboard guest message enum to a string.
    200  *
    201  * @returns Message ID string name.
    202  * @param   uMsg                The message to translate.
    203  */
    204 DECLINLINE(const char *) VBoxSvcClipboardGuestMsgToStr(uint32_t uMsg)
    205 {
    206     switch (uMsg)
    207     {
    208         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS);
    209         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA);
    210         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA);
    211         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT);
    212         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT);
    213         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET);
    214         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS);
    215         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY);
    216         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOTS);
    217         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN);
    218         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE);
    219         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ);
    220         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE);
    221         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ);
    222         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE);
    223         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN);
    224         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE);
    225         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ);
    226         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE);
    227         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL);
    228         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR);
    229         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
    230     }
    231     return "Unknown";
    232 }
     180#define VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR                  25
    233181
    234182/** The maximum default chunk size for a single data transfer. */
    235 #define VBOX_SHARED_CLIPBOARD_MAX_CHUNK_SIZE             _64K
     183#define VBOX_SHARED_CLIPBOARD_MAX_CHUNK_SIZE                  _64K
     184
     185/** Maximum number of concurrent Shared Clipboard transfers a VM can have. */
     186#define VBOX_SHARED_CLIPBOARD_MAX_TRANSFERS                   UINT16_MAX
     187/** Maximum number of concurrent events a transfer can have. */
     188#define VBOX_SHARED_CLIPBOARD_MAX_EVENTS                      UINT16_MAX
     189
     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)
     193/** Gets the transfer ID out of a context ID. */
     194#define VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_TRANSFER(uContextID) \
     195    RT_HI_U16(uContextID)
     196/** Gets the event ID out of a context ID. */
     197#define VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uContextID) \
     198    RT_LO_U16(uContextID)
    236199
    237200/*
    … …  
    392355            HGCMFunctionParameter uHandle;
    393356        } ObjOpen;
     357        struct
     358        {
     359            HGCMFunctionParameter uHandle;
     360        } ObjClose;
    394361    } u;
    395362} VBoxClipboardReplyMsg;
    … …  
    397364#define VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN 5
    398365
    399 /**
    400  * Reads / Writes the roots list.
    401  */
    402 typedef struct _VBoxClipboardRootsMsg
    403 {
    404     VBGLIOCHGCMCALL hdr;
    405 
    406     /** uint32_t, in: Context ID. Unused at the moment. */
     366typedef struct _VBoxClipboardRootListParms
     367{
     368    /** uint32_t, in: Context ID. s*/
    407369    HGCMFunctionParameter uContext;
    408370    /** uint32_t, in: Roots listing flags; unused at the moment. */
    409371    HGCMFunctionParameter fRoots;
    410     /** uint32_t, out: Boolean indicating that more root items are following
    411      *                 (via another message). */
    412     HGCMFunctionParameter fMore;
    413     /** uint32_t, out: Number of root items in this message. */
    414     HGCMFunctionParameter cRoots;
    415     /** uin32_t, out: Size (in bytes) of string list. */
    416     HGCMFunctionParameter cbRoots;
    417     /** pointer, out: string list (separated with CRLF) containing the root items. */
    418     HGCMFunctionParameter pvRoots;
    419 } VBoxClipboardRootsMsg;
    420 
    421 #define VBOX_SHARED_CLIPBOARD_CPARMS_ROOTS 6
     372} VBoxClipboardRootListParms;
     373
     374/**
     375 * Requests to read the root list.
     376 */
     377typedef struct _VBoxClipboardRootListReadReqMsg
     378{
     379    VBGLIOCHGCMCALL hdr;
     380
     381    VBoxClipboardRootListParms ReqParms;
     382} VBoxClipboardRootListReadReqMsg;
     383
     384#define VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ 2
     385
     386/**
     387 * Reads / Writes a root list header.
     388 */
     389typedef struct _VBoxClipboardRootListHdrMsg
     390{
     391    VBGLIOCHGCMCALL hdr;
     392
     393    VBoxClipboardRootListParms ReqParms;
     394    /** uint64_t, in/out: Number of total root list entries. */
     395    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;
     400} VBoxClipboardRootListHdrMsg;
     401
     402#define VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR 5
     403
     404typedef struct _VBoxClipboardRootListEntryParms
     405{
     406    /** uint32_t, in: Context ID. */
     407    HGCMFunctionParameter uContext;
     408    /** uint32_t, in: VBOX_SHAREDCLIPBOARD_INFO_FLAG_XXX. */
     409    HGCMFunctionParameter fInfo;
     410    /** uint32_t, in: Index of root list entry to get (zero-based). */
     411    HGCMFunctionParameter uIndex;
     412} VBoxClipboardRootListEntryParms;
     413
     414/**
     415 * Request to read a list root entry.
     416 */
     417typedef struct _VBoxClipboardRootListEntryReadReqMsg
     418{
     419    VBGLIOCHGCMCALL hdr;
     420
     421    /** in: Request parameters. */
     422    VBoxClipboardRootListEntryParms Parms;
     423} VBoxClipboardRootListEntryReadReqMsg;
     424
     425#define VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ 3
     426
     427/**
     428 * Reads / Writes a root list entry.
     429 */
     430typedef struct _VBoxClipboardRootListEntryMsg
     431{
     432    VBGLIOCHGCMCALL hdr;
     433
     434    /** in/out: Request parameters. */
     435    VBoxClipboardRootListEntryParms Parms;
     436    /** pointer, in/out: Entry name. */
     437    HGCMFunctionParameter           szName;
     438    /** uint32_t, out: Bytes to be used for information/How many bytes were used.  */
     439    HGCMFunctionParameter           cbInfo;
     440    /** pointer, in/out: Information to be set/get (SHAREDCLIPBOARDFSOBJINFO only currently).
     441     *  Do not forget to set the SHAREDCLIPBOARDFSOBJINFO::Attr::enmAdditional for Get operation as well.  */
     442    HGCMFunctionParameter           pvInfo;
     443} VBoxClipboardRootListEntryMsg;
     444
     445#define VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY 6
    422446
    423447/**
    … …  
    507531typedef struct _VBoxClipboardListEntryReqParms
    508532{
    509     /** uint32_t, Context ID. Unused at the moment. */
     533    /** uint32_t, in: Context ID. Unused at the moment. */
    510534    HGCMFunctionParameter uContext;
    511535    /** uint64_t, in: List handle. */
    … …  
    525549} VBoxClipboardListEntryReadReqMsg;
    526550
    527 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ_REQ 3
     551#define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ 3
    528552
    529553/**
    … …  
    541565    HGCMFunctionParameter          cbInfo;
    542566    /** pointer, in/out: Information to be set/get (SHAREDCLIPBOARDFSOBJINFO only currently).
    543      * Do not forget to set the SHAREDCLIPBOARDFSOBJINFO::Attr::enmAdditional for Get operation as well.  */
     567     *  Do not forget to set the SHAREDCLIPBOARDFSOBJINFO::Attr::enmAdditional for Get operation as well.  */
    544568    HGCMFunctionParameter          pvInfo;
    545569} VBoxClipboardListEntryMsg;
    … …  
    549573typedef struct _VBoxClipboardObjOpenMsg
    550574{
    551    VBGLIOCHGCMCALL hdr;
    552 
    553     /** Absoulte path of object to open/create. */
     575    VBGLIOCHGCMCALL hdr;
     576
     577    /** uint32_t, in/out: Context ID. Unused at the moment. */
     578    HGCMFunctionParameter uContext;
     579    /** uint64_t, in/out: Object handle. */
     580    HGCMFunctionParameter uHandle;
     581    /** uint32_t, in/out: Size (in bytes) of absoulte path of object to open/create. */
    554582    HGCMFunctionParameter cbPath;
    555     /** Absoulte path of object to open/create. */
     583    /** pointer, in/out: Absoulte path of object to open/create. */
    556584    HGCMFunctionParameter szPath;
    557     /** Points to SHAREDCLIPBOARDCREATEPARMS buffer. */
    558     HGCMFunctionParameter parms;
    559 
     585    /** uint32_t in/out: Open / Create flags of type SHAREDCLIPBOARD_OBJ_CF_. */
     586    HGCMFunctionParameter fCreate;
     587    /** pointer, in/out: SHAREDCLIPBOARDFSOBJINFO. */
     588    HGCMFunctionParameter objInfo;
    560589} VBoxClipboardObjOpenMsg;
    561590
    562 #define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN 2
     591#define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN 4
    563592
    564593typedef struct _VBoxClipboardObjCloseMsg
    565594{
    566    VBGLIOCHGCMCALL hdr;
    567 
     595    VBGLIOCHGCMCALL hdr;
     596
     597    /** uint32_t, in/out: Context ID. Unused at the moment. */
     598    HGCMFunctionParameter uContext;
    568599    /** uint64_t, in: SHAREDCLIPBOARDOBJHANDLE of object to close. */
    569600    HGCMFunctionParameter uHandle;
    570601} VBoxClipboardObjCloseMsg;
    571602
    572 #define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE 1
     603#define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE 2
     604
     605typedef struct _VBoxClipboardObjReadReqParms
     606{
     607    /** uint32_t, in: Context ID. Unused at the moment. */
     608    HGCMFunctionParameter uContext;
     609    /** uint64_t, in: SHAREDCLIPBOARDOBJHANDLE of object to write to. */
     610    HGCMFunctionParameter uHandle;
     611    /** uint32_t, in: How many bytes to read. */
     612    HGCMFunctionParameter cbToRead;
     613    /** uint32_t, in: Read flags. Currently unused. */
     614    HGCMFunctionParameter fRead;
     615} VBoxClipboardObjReadReqParms;
     616
     617typedef struct _VBoxClipboardObjReadReqMsg
     618{
     619    VBGLIOCHGCMCALL hdr;
     620
     621    VBoxClipboardObjReadReqParms ReqParms;
     622} VBoxClipboardObjReadReqMsg;
     623
     624#define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ 3
    573625
    574626/**
    … …  
    583635    VBGLIOCHGCMCALL hdr;
    584636
    585     /** Context ID. Unused at the moment. */
    586     HGCMFunctionParameter uContext;     /* OUT uint32_t */
    587     /** uint64_t, in: SHAREDCLIPBOARDOBJHANDLE of object to write to. */
    588     HGCMFunctionParameter uHandle;
    589     /** Size (in bytes) of current data chunk. */
    590     HGCMFunctionParameter cbData;       /* OUT uint32_t */
    591     /** Current data chunk. */
    592     HGCMFunctionParameter pvData;       /* OUT ptr */
    593     /** Size (in bytes) of current data chunk checksum. */
    594     HGCMFunctionParameter cbChecksum;   /* OUT uint32_t */
    595     /** Checksum of data block, based on the checksum
     637    /** uint32_t, in/out: Context ID. Unused at the moment. */
     638    HGCMFunctionParameter uContext;
     639    /** uint64_t, in/out: SHAREDCLIPBOARDOBJHANDLE of object to write to. */
     640    HGCMFunctionParameter uHandle;
     641    /** uint32_t, in/out: Size (in bytes) of current data chunk. */
     642    HGCMFunctionParameter cbData;
     643    /** pointer, in/out: Current data chunk. */
     644    HGCMFunctionParameter pvData;
     645    /** uint32_t, in/out: Size (in bytes) of current data chunk checksum. */
     646    HGCMFunctionParameter cbChecksum;
     647    /** pointer, in/out: Checksum of data block, based on the checksum
    596648     *  type in the data header. Optional. */
    597     HGCMFunctionParameter pvChecksum;   /* OUT ptr */
     649    HGCMFunctionParameter pvChecksum;
    598650} VBoxClipboardObjReadWriteMsg;
    599651
    … …  
    642694void VBoxSvcClipboardUnlock(void);
    643695
    644 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    645 int VBoxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr);
    646 int VBoxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTHDR pListHdr);
    647 int VBoxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry);
    648 int VBoxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTENTRY pListEntry);
    649 int VBoxSvcClipboardURIGetFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData);
    650 int VBoxSvcClipboardURISetFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData);
    651 #endif
    652 
    653696#endif /* !VBOX_INCLUDED_HostServices_VBoxClipboardSvc_h */
    654697

  • trunk/include/VBox/VBoxGuestLib.h

    r79672 r80283  
    575575/** @name Shared Clipboard
    576576 * @{ */
     577
     578/**
     579 * Structure containing the context required for
     580 * either retrieving or sending a HGCM shared clipboard
     581 * commands from or to the host.
     582 *
     583 * Note: Do not change parameter order without also
     584 *       adapting all structure initializers.
     585 */
     586typedef struct VBGLR3SHCLCMDCTX
     587{
     588    /** @todo This struct could be handy if we want to implement
     589     *        a second communication channel, e.g. via TCP/IP.
     590     *        Use a union for the HGCM stuff then. */
     591
     592    /** IN: HGCM client ID to use for communication. */
     593    uint32_t uClientID;
     594    /** IN/OUT: Context ID to retrieve or to use. */
     595    uint32_t uContextID;
     596    /** IN: Protocol version to use. */
     597    uint32_t uProtocol;
     598    /** OUT: Number of parameters retrieved. */
     599    uint32_t uNumParms;
     600} VBGLR3SHCLCMDCTX, *PVBGLR3SHCLCMDCTX;
    577601
    578602#  ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    … …  
    620644
    621645#  ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    622 VBGLR3DECL(int)     VbglR3ClipboardEventGetNext(HGCMCLIENTID idClient, PSHAREDCLIPBOARDURITRANSFER pTransfer,
     646VBGLR3DECL(int)     VbglR3ClipboardEventGetNext(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer,
    623647                                                PVBGLR3CLIPBOARDEVENT *ppEvent);
    624648VBGLR3DECL(void)    VbglR3ClipboardEventFree(PVBGLR3CLIPBOARDEVENT pEvent);
    625649
    626 VBGLR3DECL(int)     VbglR3ClipboardTransferSendStatus(HGCMCLIENTID idClient, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus);
    627 
    628 VBGLR3DECL(int)     VbglR3ClipboardRootsRecv(HGCMCLIENTID idClient, uint32_t *pfRoots);
    629 VBGLR3DECL(int)     VbglR3ClipboardRootsWrite(HGCMCLIENTID idClient, uint32_t cRoots, const char *papszList, uint32_t cbList);
    630 
    631 VBGLR3DECL(int)     VbglR3ClipboardListOpenSend(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList);
    632 VBGLR3DECL(int)     VbglR3ClipboardListOpenRecv(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms);
    633 VBGLR3DECL(int)     VbglR3ClipboardListOpenReply(HGCMCLIENTID idClient, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList);
    634 
    635 VBGLR3DECL(int)     VbglR3ClipboardListCloseSend(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList);
    636 VBGLR3DECL(int)     VbglR3ClipboardListCloseRecv(HGCMCLIENTID idClient, PSHAREDCLIPBOARDLISTHANDLE phList);
    637 
    638 VBGLR3DECL(int)     VbglR3ClipboardListHdrWrite(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr);
    639 
    640 VBGLR3DECL(int)     VbglR3ClipboardListEntryWrite(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry);
    641 
    642 VBGLR3DECL(int)     VbglR3ClipboardObjOpen(HGCMCLIENTID idClient,
    643                                            const char *pszPath, PVBOXCLIPBOARDCREATEPARMS pCreateParms,
    644                                            PSHAREDCLIPBOARDOBJHANDLE phObj);
    645 VBGLR3DECL(int)     VbglR3ClipboardObjClose(HGCMCLIENTID idClient, SHAREDCLIPBOARDOBJHANDLE hObj);
    646 VBGLR3DECL(int)     VbglR3ClipboardObjRead(HGCMCLIENTID idClient, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvData, uint32_t cbData,
    647                                            uint32_t *pcbRead);
    648 VBGLR3DECL(int)     VbglR3ClipboardObjWrite(HGCMCLIENTID idClient, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvData, uint32_t cbData,
    649                                             uint32_t *pcbWritten);
     650VBGLR3DECL(int)     VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus);
     651
     652VBGLR3DECL(int)     VbglR3ClipboardRootListHdrReadReq(PVBGLR3SHCLCMDCTX pCtx, uint32_t *pfRoots);
     653VBGLR3DECL(int)     VbglR3ClipboardRootListHdrReadReply(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLIST pRootList);
     654VBGLR3DECL(int)     VbglR3ClipboardRootsWrite(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLISTHDR pRoots);
     655
     656VBGLR3DECL(int)     VbglR3ClipboardListOpenSend(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList);
     657VBGLR3DECL(int)     VbglR3ClipboardListOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms);
     658VBGLR3DECL(int)     VbglR3ClipboardListOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList);
     659
     660VBGLR3DECL(int)     VbglR3ClipboardListCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList);
     661VBGLR3DECL(int)     VbglR3ClipboardListCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDLISTHANDLE phList);
     662
     663VBGLR3DECL(int)     VbglR3ClipboardListHdrWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr);
     664VBGLR3DECL(int)     VbglR3ClipboardListEntryWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry);
     665
     666VBGLR3DECL(int)     VbglR3ClipboardObjOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms);
     667VBGLR3DECL(int)     VbglR3ClipboardObjOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDOBJHANDLE hObj);
     668VBGLR3DECL(int)     VbglR3ClipboardObjOpenSend(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms,
     669                                               PSHAREDCLIPBOARDOBJHANDLE phObj);
     670
     671VBGLR3DECL(int)     VbglR3ClipboardObjCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj);
     672VBGLR3DECL(int)     VbglR3ClipboardObjCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDOBJHANDLE hObj);
     673VBGLR3DECL(int)     VbglR3ClipboardObjCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj);
     674
     675VBGLR3DECL(int)     VbglR3ClipboardObjReadRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj, uint32_t pcbToRead,
     676                                               uint32_t *pfFlags);
     677VBGLR3DECL(int)     VbglR3ClipboardObjReadSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
     678                                               uint32_t *pcbRead);
     679VBGLR3DECL(int)     VbglR3ClipboardObjWriteSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
     680                                                uint32_t *pcbWritten);
    650681
    651682VBGLR3DECL(int)     VbglR3ClipboardWriteError(HGCMCLIENTID idClient, int rcErr);

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

    r79702 r80283  
    5959    /** Pointer to the VBoxClient service environment. */
    6060    const VBOXSERVICEENV    *pEnv;
    61     /** Client ID the service is connected to the HGCM service with. */
    62     uint32_t                 u32ClientID;
     61    /** Command context. */
     62    VBGLR3SHCLCMDCTX         CmdCtx;
    6363    /** Windows-specific context data. */
    6464    VBOXCLIPBOARDWINCTX      Win;
    … …  
    119119    RTThreadUserSignal(RTThreadSelf());
    120120
    121     uint32_t uClientID;
    122     int rc = VbglR3ClipboardConnect(&uClientID);
     121    VBGLR3SHCLCMDCTX cmdCtx;
     122    RT_ZERO(cmdCtx);
     123
     124    int rc = VbglR3ClipboardConnect(&cmdCtx.uClientID);
    123125    if (RT_SUCCESS(rc))
    124126    {
    125         rc = VbglR3ClipboardTransferSendStatus(uClientID, SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING);
     127        rc = VbglR3ClipboardTransferSendStatus(&cmdCtx, SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING);
    126128        if (RT_SUCCESS(rc))
    127129        {
    … …  
    132134            {
    133135                PVBGLR3CLIPBOARDEVENT pEvent = NULL;
    134                 rc = VbglR3ClipboardEventGetNext(uClientID, pTransfer, &pEvent);
     136                rc = VbglR3ClipboardEventGetNext(&cmdCtx, pTransfer, &pEvent);
    135137                if (RT_SUCCESS(rc))
    136138                {
    … …  
    152154        }
    153155
    154         VbglR3ClipboardDisconnect(uClientID);
     156        VbglR3ClipboardDisconnect(cmdCtx.uClientID);
    155157    }
    156158
    … …  
    235237    AssertPtr(pThisCtx);
    236238
     239    RT_NOREF(pThisCtx);
     240
    237241    int rc = 0; // VbglR3ClipboardRecvListOpen(pThisCtx->u32ClientID, pListHdr, phList);
    238242
    … …  
    251255    AssertPtr(pThisCtx);
    252256
    253     LogFlowFunc(("c=%RU32\n", pThisCtx->u32ClientID));
     257    RT_NOREF(pThisCtx);
    254258
    255259    int rc = SharedClipboardURIListHdrInit(pListHdr);
    … …  
    293297    AssertPtr(pThisCtx);
    294298
     299    RT_NOREF(pThisCtx);
     300
    295301    RT_NOREF(pListEntry);
    296302    int rc = 0; // VbglR3ClipboardListEntryRead(pThisCtx->u32ClientID, pListEntry);
    … …  
    316322*/
    317323
    318 static int vboxClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const char *pszPath,
    319                                    PVBOXCLIPBOARDCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj)
     324static int vboxClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
     325                                   PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj)
    320326{
    321327    LogFlowFuncEnter();
    … …  
    324330    AssertPtr(pThisCtx);
    325331
    326     int rc = VbglR3ClipboardObjOpen(pThisCtx->u32ClientID, pszPath, pCreateParms, phObj);
     332    int rc = VbglR3ClipboardObjOpenSend(&pThisCtx->CmdCtx, pCreateParms, phObj);
    327333
    328334    LogFlowFuncLeaveRC(rc);
    … …  
    337343    AssertPtr(pThisCtx);
    338344
    339     int rc = VbglR3ClipboardObjClose(pThisCtx->u32ClientID, hObj);
     345    int rc = VbglR3ClipboardObjCloseSend(&pThisCtx->CmdCtx, hObj);
    340346
    341347    LogFlowFuncLeaveRC(rc);
    … …  
    353359    AssertPtr(pThisCtx);
    354360
    355     int rc = VbglR3ClipboardObjRead(pThisCtx->u32ClientID, hObj, pvData, cbData, pcbRead);
     361    int rc = VbglR3ClipboardObjReadSend(&pThisCtx->CmdCtx, hObj, pvData, cbData, pcbRead);
    356362
    357363    LogFlowFuncLeaveRC(rc);
    … …  
    369375    AssertPtr(pThisCtx);
    370376
    371     int rc = VbglR3ClipboardObjWrite(pThisCtx->u32ClientID, hObj, pvData, cbData, pcbWritten);
     377    int rc = VbglR3ClipboardObjWriteSend(&pThisCtx->CmdCtx, hObj, pvData, cbData, pcbWritten);
    372378
    373379    LogFlowFuncLeaveRC(rc);
    … …  
    401407               {
    402408                   LogFunc(("WM_CLIPBOARDUPDATE: Reporting formats 0x%x\n", fFormats));
    403                    rc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, fFormats);
     409                   rc = VbglR3ClipboardReportFormats(pCtx->CmdCtx.uClientID, fFormats);
    404410               }
    405411           }
    … …  
    425431               int rc = VBoxClipboardWinGetFormats(pWinCtx, &fFormats);
    426432               if (RT_SUCCESS(rc))
    427                    rc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, fFormats);
     433                   rc = VbglR3ClipboardReportFormats(pCtx->CmdCtx.uClientID, fFormats);
    428434           }
    429435
    … …  
    478484                   {
    479485                       /* Read the host data to the preallocated buffer. */
    480                        int rc = VbglR3ClipboardReadData(pCtx->u32ClientID, fFormat, pMem, cbPrealloc, &cb);
     486                       int rc = VbglR3ClipboardReadData(pCtx->CmdCtx.uClientID, fFormat, pMem, cbPrealloc, &cb);
    481487                       LogFlowFunc(("VbglR3ClipboardReadData returned with rc = %Rrc\n",  rc));
    482488
    … …  
    509515                                       /* Read the host data to the preallocated buffer. */
    510516                                       uint32_t cbNew = 0;
    511                                        rc = VbglR3ClipboardReadData(pCtx->u32ClientID, fFormat, pMem, cb, &cbNew);
     517                                       rc = VbglR3ClipboardReadData(pCtx->CmdCtx.uClientID, fFormat, pMem, cb, &cbNew);
    512518                                       LogFlowFunc(("VbglR3ClipboardReadData returned with rc = %Rrc, cb = %d, cbNew = %d\n",
    513519                                                    rc, cb, cbNew));
    … …  
    698704                       if (lp != NULL)
    699705                       {
    700                            rc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_BITMAP,
     706                           rc = VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_BITMAP,
    701707                                                         lp, GlobalSize(hClip));
    702708                           GlobalUnlock(hClip);
    … …  
    716722                       if (uniString != NULL)
    717723                       {
    718                            rc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
     724                           rc = VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
    719725                                                         uniString, (lstrlenW(uniString) + 1) * 2);
    720726                           GlobalUnlock(hClip);
    … …  
    738744                           if (lp != NULL)
    739745                           {
    740                                rc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_HTML,
     746                               rc = VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_HTML,
    741747                                                             lp, GlobalSize(hClip));
    742748                               GlobalUnlock(hClip);
    … …  
    755761
    756762                   /* Requested clipboard format is not available, send empty data. */
    757                    VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_NONE, NULL, 0);
     763                   VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_NONE, NULL, 0);
    758764#ifdef DEBUG_andy
    759765                   AssertFailed();
    … …  
    10471053        /* ignore rc */ VBoxClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
    10481054
    1049         rc = VbglR3ClipboardConnect(&pCtx->u32ClientID);
     1055        rc = VbglR3ClipboardConnect(&pCtx->CmdCtx.uClientID);
    10501056        if (RT_SUCCESS(rc))
    10511057        {
     1058            pCtx->CmdCtx.uProtocol = 0;
     1059
    10521060            rc = vboxClipboardCreateWindow(pCtx);
    10531061            if (RT_SUCCESS(rc))
    … …  
    10611069            else
    10621070            {
    1063                 VbglR3ClipboardDisconnect(pCtx->u32ClientID);
     1071                VbglR3ClipboardDisconnect(pCtx->CmdCtx.uClientID);
    10641072            }
    10651073        }
    … …  
    10951103        uint32_t u32Msg;
    10961104        uint32_t u32Formats;
    1097         rc = VbglR3ClipboardGetHostMsgOld(pCtx->u32ClientID, &u32Msg, &u32Formats);
     1105        rc = VbglR3ClipboardGetHostMsgOld(pCtx->CmdCtx.uClientID, &u32Msg, &u32Formats);
    10981106        if (RT_FAILURE(rc))
    10991107        {
    … …  
    11851193    AssertPtr(pCtx);
    11861194
    1187     VbglR3ClipboardDisconnect(pCtx->u32ClientID);
    1188     pCtx->u32ClientID = 0;
     1195    VbglR3ClipboardDisconnect(pCtx->CmdCtx.uClientID);
     1196    pCtx->CmdCtx.uClientID = 0;
    11891197
    11901198    LogFlowFuncLeaveRC(VINF_SUCCESS);
    … …  
    12001208
    12011209    /* Make sure that we are disconnected. */
    1202     Assert(pCtx->u32ClientID == 0);
     1210    Assert(pCtx->CmdCtx.uClientID == 0);
    12031211
    12041212    vboxClipboardDestroy(pCtx);

  • trunk/src/VBox/Additions/common/VBoxGuest/lib/Makefile.kmk

    r79497 r80283  
    147147endif
    148148ifdef VBOX_WITH_SHARED_CLIPBOARD
    149  VBoxGuestR3Lib_DEFS      += VBOX_WITH_SHARED_CLIPBOARD_GUEST
     149 VBoxGuestR3Lib_DEFS      += VBOX_WITH_SHARED_CLIPBOARD_GUEST LOG_ENABLED
    150150 VBoxGuestR3Lib_SOURCES   += \
    151151        VBoxGuestR3LibClipboard.cpp

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

    r79702 r80283  
    3030*********************************************************************************************************************************/
    3131#include <VBox/GuestHost/SharedClipboard.h>
     32#include <VBox/GuestHost/clipboard-helper.h>
    3233#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    3334# include <VBox/GuestHost/SharedClipboard-uri.h>
    … …  
    207208 * @note    Restore check is only performed optimally with a 6.0 host.
    208209 */
    209 static int vbglR3ClipboardMsgPeekWait(uint32_t idClient, uint32_t *pidMsg, uint32_t *pcParameters, uint64_t *pidRestoreCheck)
     210static int vbglR3ClipboardMsgPeekWait(PVBGLR3SHCLCMDCTX pCtx, uint32_t *pidMsg, uint32_t *pcParameters, uint64_t *pidRestoreCheck)
    210211{
    211212    AssertPtrReturn(pidMsg, VERR_INVALID_POINTER);
    … …  
    220221        HGCMFunctionParameter cParameters;
    221222    } Msg;
    222     VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT, 2);
     223    VBGL_HGCM_HDR_INIT(&Msg.Hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT, 2);
    223224    VbglHGCMParmUInt64Set(&Msg.idMsg, pidRestoreCheck ? *pidRestoreCheck : 0);
    224225    VbglHGCMParmUInt32Set(&Msg.cParameters, 0);
    … …  
    242243    if (rc == VERR_INTERRUPTED)
    243244    {
    244         VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL, 0);
     245        VBGL_HGCM_HDR_INIT(&Msg.Hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL, 0);
    245246        int rc2 = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg.Hdr));
    246247        AssertRC(rc2);
    … …  
    259260#endif
    260261
    261 VBGLR3DECL(int) VbglR3ClipboardTransferSendStatus(HGCMCLIENTID idClient, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus)
    262 {
     262VBGLR3DECL(int) VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus)
     263{
     264    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     265
    263266    VBoxClipboardStatusMsg Msg;
    264267    RT_ZERO(Msg);
    265268
    266     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     269    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    267270                       VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS, VBOX_SHARED_CLIPBOARD_CPARMS_STATUS);
    268271
    … …  
    278281}
    279282
    280 VBGLR3DECL(int) VbglR3ClipboardRootsRecv(HGCMCLIENTID idClient, PVBOXCLIPBOARDROOTS pRoots)
    281 {
    282     AssertPtrReturn(pRoots, VERR_INVALID_POINTER);
    283 
    284     VBoxClipboardRootsMsg Msg;
    285     RT_ZERO(Msg);
    286 
    287     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    288                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_ROOTS);
    289 
    290     Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOTS);
    291     Msg.fRoots.SetUInt32(0);
    292     Msg.fMore.SetUInt32(0);
    293     Msg.cRoots.SetUInt32(0);
    294     Msg.cbRoots.SetUInt32(pRoots->cbRoots);
    295     Msg.pvRoots.SetPtr((void *)pRoots->pszRoots, pRoots->cbRoots);
    296 
    297     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    298     if (RT_SUCCESS(rc))
    299     {
    300         uint32_t fMore;
    301         rc = Msg.fMore.GetUInt32(&fMore); AssertRC(rc);
    302         if (RT_SUCCESS(rc))
    303         {
    304             pRoots->fMore = RT_BOOL(fMore);
    305         }
    306         if (RT_SUCCESS(rc))
    307             rc = Msg.fRoots.GetUInt32(&pRoots->fRoots); AssertRC(rc);
    308         if (RT_SUCCESS(rc))
    309             rc = Msg.cRoots.GetUInt32(&pRoots->cRoots); AssertRC(rc);
    310         if (RT_SUCCESS(rc))
    311             rc = Msg.cbRoots.GetUInt32(&pRoots->cbRoots); AssertRC(rc);
    312     }
    313 
    314     LogFlowFuncLeaveRC(rc);
    315     return rc;
    316 }
    317 
    318 VBGLR3DECL(int) VbglR3ClipboardRootsWrite(HGCMCLIENTID idClient, uint32_t cRoots, char *papszList, uint32_t cbList)
    319 {
    320     AssertPtrReturn(papszList, VERR_INVALID_POINTER);
    321     AssertReturn(cbList,       VERR_INVALID_PARAMETER);
    322 
    323     VBoxClipboardRootsMsg Msg;
    324     RT_ZERO(Msg);
    325 
    326     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    327                        VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOTS, VBOX_SHARED_CLIPBOARD_CPARMS_ROOTS);
    328 
    329     Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
    330     Msg.fRoots.SetUInt32(0);
    331     Msg.fMore.SetUInt32(0);
    332     Msg.cRoots.SetUInt32(cRoots);
    333     Msg.cbRoots.SetUInt32(cbList);
    334     Msg.pvRoots.SetPtr(papszList, cbList);
    335 
    336     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    337 
    338     LogFlowFuncLeaveRC(rc);
    339     return rc;
    340 }
    341 
    342 VBGLR3DECL(int) VbglR3ClipboardListOpenSend(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms,
     283VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReq(PVBGLR3SHCLCMDCTX pCtx, uint32_t *pfRoots)
     284{
     285    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
     286    AssertPtrReturn(pfRoots, VERR_INVALID_POINTER);
     287
     288    VBoxClipboardRootListReadReqMsg Msg;
     289    RT_ZERO(Msg);
     290
     291    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     292                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
     293
     294    Msg.ReqParms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ);
     295    Msg.ReqParms.fRoots.SetUInt32(0);
     296
     297    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     298    if (RT_SUCCESS(rc))
     299    {
     300        rc = Msg.ReqParms.uContext.GetUInt32(&pCtx->uContextID); AssertRC(rc);
     301        if (RT_SUCCESS(rc))
     302            rc = Msg.ReqParms.fRoots.GetUInt32(pfRoots); AssertRC(rc);
     303    }
     304
     305    LogFlowFuncLeaveRC(rc);
     306    return rc;
     307}
     308
     309VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReply(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLISTHDR pRootListHdr)
     310{
     311    AssertPtrReturn(pCtx,         VERR_INVALID_POINTER);
     312    AssertPtrReturn(pRootListHdr, VERR_INVALID_POINTER);
     313
     314    VBoxClipboardRootListHdrMsg Msg;
     315    RT_ZERO(Msg);
     316
     317    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     318                       VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR);
     319
     320    Msg.ReqParms.uContext.SetUInt32(pCtx->uContextID);
     321    Msg.ReqParms.fRoots.SetUInt32(pRootListHdr->fRoots);
     322
     323    Msg.cRoots.SetUInt32(pRootListHdr->cRoots);
     324    Msg.enmCompression.SetUInt32(0);  /** @todo Not implemented yet. */
     325    Msg.enmChecksumType.SetUInt32(0); /** @todo Not implemented yet. */
     326
     327    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     328
     329    LogFlowFuncLeaveRC(rc);
     330    return rc;
     331}
     332
     333VBGLR3DECL(int) VbglR3ClipboardRootListEntryReadReq(PVBGLR3SHCLCMDCTX pCtx, uint32_t *puIndex, uint32_t *pfInfo)
     334{
     335    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
     336    AssertPtrReturn(puIndex, VERR_INVALID_POINTER);
     337    AssertPtrReturn(pfInfo,  VERR_INVALID_POINTER);
     338
     339    VBoxClipboardRootListEntryReadReqMsg Msg;
     340    RT_ZERO(Msg);
     341
     342    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     343                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
     344
     345    Msg.Parms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ);
     346    Msg.Parms.fInfo.SetUInt32(0);
     347    Msg.Parms.uIndex.SetUInt32(0);
     348
     349    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     350    if (RT_SUCCESS(rc))
     351    {
     352        rc = Msg.Parms.uContext.GetUInt32(&pCtx->uContextID); AssertRC(rc);
     353        if (RT_SUCCESS(rc))
     354            rc = Msg.Parms.fInfo.GetUInt32(pfInfo); AssertRC(rc);
     355        if (RT_SUCCESS(rc))
     356            rc = Msg.Parms.uIndex.GetUInt32(puIndex); AssertRC(rc);
     357    }
     358
     359    LogFlowFuncLeaveRC(rc);
     360    return rc;
     361}
     362
     363VBGLR3DECL(int) VbglR3ClipboardRootListEntryReadReply(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PVBOXCLIPBOARDLISTENTRY pEntry)
     364{
     365    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
     366    AssertPtrReturn(pEntry, VERR_INVALID_POINTER);
     367
     368    VBoxClipboardRootListEntryMsg Msg;
     369    RT_ZERO(Msg);
     370
     371    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     372                       VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY);
     373
     374    Msg.Parms.uContext.SetUInt32(pCtx->uContextID);
     375    Msg.Parms.fInfo.SetUInt32(0);
     376    Msg.Parms.uIndex.SetUInt32(uIndex);
     377
     378    Msg.szName.SetPtr(pEntry->pszName, pEntry->cbName);
     379    Msg.cbInfo.SetUInt32(pEntry->cbInfo);
     380    Msg.pvInfo.SetPtr(pEntry->pvInfo, pEntry->cbInfo);
     381
     382    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     383
     384    LogFlowFuncLeaveRC(rc);
     385    return rc;
     386}
     387
     388VBGLR3DECL(int) VbglR3ClipboardListOpenSend(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms,
    343389                                            PSHAREDCLIPBOARDLISTHANDLE phList)
    344390{
     391    AssertPtrReturn(pCtx,       VERR_INVALID_POINTER);
    345392    AssertPtrReturn(pOpenParms, VERR_INVALID_POINTER);
    346393    AssertPtrReturn(phList,     VERR_INVALID_POINTER);
    … …  
    349396    RT_ZERO(Msg);
    350397
    351     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     398    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    352399                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
    353400
    … …  
    369416}
    370417
    371 VBGLR3DECL(int) VbglR3ClipboardListOpenRecv(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
    372 {
     418VBGLR3DECL(int) VbglR3ClipboardListOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
     419{
     420    AssertPtrReturn(pCtx,       VERR_INVALID_POINTER);
    373421    AssertPtrReturn(pOpenParms, VERR_INVALID_POINTER);
    374422
    … …  
    376424    RT_ZERO(Msg);
    377425
    378     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     426    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    379427                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
    380428
    … …  
    401449}
    402450
    403 VBGLR3DECL(int) VbglR3ClipboardListOpenReply(HGCMCLIENTID idClient, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList)
    404 {
     451VBGLR3DECL(int) VbglR3ClipboardListOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList)
     452{
     453    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     454
    405455    VBoxClipboardReplyMsg Msg;
    406456    RT_ZERO(Msg);
    407457
    408     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     458    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    409459                       VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY, 6);
    410460
    … …  
    423473}
    424474
    425 VBGLR3DECL(int) VbglR3ClipboardListCloseReply(HGCMCLIENTID idClient, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList)
    426 {
     475VBGLR3DECL(int) VbglR3ClipboardListCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDLISTHANDLE phList)
     476{
     477    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
     478    AssertPtrReturn(phList, VERR_INVALID_POINTER);
     479
     480    VBoxClipboardListCloseMsg Msg;
     481    RT_ZERO(Msg);
     482
     483    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     484                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
     485
     486    Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE);
     487    Msg.uHandle.SetUInt64(0);
     488
     489    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     490    if (RT_SUCCESS(rc))
     491    {
     492        rc = Msg.uHandle.GetUInt64(phList); AssertRC(rc);
     493    }
     494
     495    LogFlowFuncLeaveRC(rc);
     496    return rc;
     497}
     498
     499VBGLR3DECL(int) VbglR3ClipboardListCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList)
     500{
     501    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     502
    427503    VBoxClipboardReplyMsg Msg;
    428504    RT_ZERO(Msg);
    429505
    430     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     506    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    431507                       VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY, 6);
    432508
    … …  
    445521}
    446522
    447 VBGLR3DECL(int) VbglR3ClipboardListCloseSend(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList)
    448 {
     523VBGLR3DECL(int) VbglR3ClipboardListCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList)
     524{
     525    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     526
    449527    VBoxClipboardListCloseMsg Msg;
    450528    RT_ZERO(Msg);
    451529
    452     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     530    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    453531                       VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
    454532
    … …  
    462540}
    463541
    464 VBGLR3DECL(int) VbglR3ClipboardListCloseRecv(HGCMCLIENTID idClient, PSHAREDCLIPBOARDLISTHANDLE phList)
    465 {
    466     AssertPtrReturn(phList, VERR_INVALID_POINTER);
    467 
    468     VBoxClipboardListCloseMsg Msg;
    469     RT_ZERO(Msg);
    470 
    471     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    472                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
    473 
    474     Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE);
    475     Msg.uHandle.SetUInt64(0);
    476 
    477     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    478     if (RT_SUCCESS(rc))
    479     {
    480         rc = Msg.uHandle.GetUInt64(phList); AssertRC(rc);
    481     }
    482 
    483     LogFlowFuncLeaveRC(rc);
    484     return rc;
    485 }
    486 
    487 VBGLR3DECL(int) VbglR3ClipboardListHdrRead(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList, uint32_t fFlags,
     542
     543VBGLR3DECL(int) VbglR3ClipboardListHdrRead(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, uint32_t fFlags,
    488544                                           PVBOXCLIPBOARDLISTHDR pListHdr)
    489545{
     546    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
    490547    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
    491548
    … …  
    493550    RT_ZERO(Msg);
    494551
    495     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     552    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    496553                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR);
    497554
    … …  
    525582}
    526583
    527 VBGLR3DECL(int) VbglR3ClipboardListHdrReadRecvReq(HGCMCLIENTID idClient, PSHAREDCLIPBOARDLISTHANDLE phList, uint32_t *pfFlags)
    528 {
     584VBGLR3DECL(int) VbglR3ClipboardListHdrReadRecvReq(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDLISTHANDLE phList, uint32_t *pfFlags)
     585{
     586    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
    529587    AssertPtrReturn(phList,  VERR_INVALID_POINTER);
    530588    AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
    … …  
    533591    RT_ZERO(Msg);
    534592
    535     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     593    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    536594                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
    537595
    … …  
    553611}
    554612
    555 VBGLR3DECL(int) VbglR3ClipboardListHdrWrite(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList,
     613VBGLR3DECL(int) VbglR3ClipboardListHdrWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    556614                                            PVBOXCLIPBOARDLISTHDR pListHdr)
    557615{
     616    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
    558617    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
    559618
    … …  
    561620    RT_ZERO(Msg);
    562621
    563     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     622    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    564623                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR);
    565624
    … …  
    581640}
    582641
    583 VBGLR3DECL(int) VbglR3ClipboardListEntryRead(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList,
     642VBGLR3DECL(int) VbglR3ClipboardListEntryRead(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    584643                                             PVBOXCLIPBOARDLISTENTRY pListEntry)
    585644{
     645    AssertPtrReturn(pCtx,       VERR_INVALID_POINTER);
    586646    AssertPtrReturn(pListEntry, VERR_INVALID_POINTER);
    587647
    … …  
    589649    RT_ZERO(Msg);
    590650
    591     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     651    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    592652                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY);
    593653
    … …  
    597657
    598658    Msg.szName.SetPtr(pListEntry->pszName, pListEntry->cbName);
    599     Msg.cbInfo.SetUInt32(0);
     659    Msg.cbInfo.SetUInt32(pListEntry->cbInfo);
    600660    Msg.pvInfo.SetPtr(pListEntry->pvInfo, pListEntry->cbInfo);
    601661
    … …  
    610670}
    611671
    612 VBGLR3DECL(int) VbglR3ClipboardListEntryReadRecvReq(HGCMCLIENTID idClient, PSHAREDCLIPBOARDLISTHANDLE phList, uint32_t *pfInfo)
    613 {
     672VBGLR3DECL(int) VbglR3ClipboardListEntryReadRecvReq(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDLISTHANDLE phList, uint32_t *pfInfo)
     673{
     674    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
    614675    AssertPtrReturn(phList, VERR_INVALID_POINTER);
    615676    AssertPtrReturn(pfInfo, VERR_INVALID_POINTER);
    … …  
    618679    RT_ZERO(Msg);
    619680
    620     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    621                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ_REQ);
     681    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     682                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
    622683
    623684    Msg.ReqParms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ);
    … …  
    637698}
    638699
    639 VBGLR3DECL(int) VbglR3ClipboardListEntryWrite(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList,
     700VBGLR3DECL(int) VbglR3ClipboardListEntryWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    640701                                              PVBOXCLIPBOARDLISTENTRY pListEntry)
    641702{
     703    AssertPtrReturn(pCtx,       VERR_INVALID_POINTER);
    642704    AssertPtrReturn(pListEntry, VERR_INVALID_POINTER);
    643705
    … …  
    645707    RT_ZERO(Msg);
    646708
    647     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     709    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    648710                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY);
    649711
    … …  
    662724}
    663725
    664 VBGLR3DECL(int) VbglR3ClipboardEventGetNext(HGCMCLIENTID idClient, PSHAREDCLIPBOARDURITRANSFER pTransfer,
     726VBGLR3DECL(int) VbglR3ClipboardObjOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms)
     727{
     728    AssertPtrReturn(pCtx,         VERR_INVALID_POINTER);
     729    AssertPtrReturn(pCreateParms, VERR_INVALID_POINTER);
     730
     731    VBoxClipboardObjOpenMsg Msg;
     732    RT_ZERO(Msg);
     733
     734    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     735                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
     736
     737    Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN);
     738    Msg.cbPath.SetUInt64(pCreateParms->cbPath);
     739    Msg.szPath.SetPtr(pCreateParms->pszPath, pCreateParms->cbPath);
     740    Msg.fCreate.SetUInt32(0);
     741    Msg.objInfo.SetPtr(&pCreateParms->ObjInfo, sizeof(pCreateParms->ObjInfo));
     742
     743    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     744    if (RT_SUCCESS(rc))
     745    {
     746        rc = Msg.cbPath.GetUInt32(&pCreateParms->cbPath);
     747        if (RT_SUCCESS(rc))
     748            rc = Msg.fCreate.GetUInt32(&pCreateParms->fCreate);
     749    }
     750
     751    LogFlowFuncLeaveRC(rc);
     752    return rc;
     753}
     754
     755VBGLR3DECL(int) VbglR3ClipboardObjOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDOBJHANDLE hObj)
     756{
     757    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     758
     759    VBoxClipboardReplyMsg Msg;
     760    RT_ZERO(Msg);
     761
     762    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     763                       VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY, 6);
     764
     765    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     766    Msg.enmType.SetUInt32(VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN);
     767    Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */
     768    Msg.cbPayload.SetUInt32(0);
     769    Msg.pvPayload.SetPtr(0, NULL);
     770
     771    Msg.u.ObjOpen.uHandle.SetUInt64(hObj);
     772
     773    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     774
     775    LogFlowFuncLeaveRC(rc);
     776    return rc;
     777}
     778
     779VBGLR3DECL(int) VbglR3ClipboardObjOpenSend(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms,
     780                                           PSHAREDCLIPBOARDOBJHANDLE phObj)
     781{
     782    AssertPtrReturn(pCtx,         VERR_INVALID_POINTER);
     783    AssertPtrReturn(pCreateParms, VERR_INVALID_POINTER);
     784    AssertPtrReturn(phObj,        VERR_INVALID_POINTER);
     785
     786    VBoxClipboardObjOpenMsg Msg;
     787    RT_ZERO(Msg);
     788
     789    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     790                       VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
     791
     792    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     793    Msg.uHandle.SetUInt64(0);
     794    Msg.cbPath.SetUInt32(pCreateParms->cbPath);
     795    Msg.szPath.SetPtr((void *)pCreateParms->pszPath, pCreateParms->cbPath + 1 /* Include terminating zero */);
     796    Msg.fCreate.SetUInt32(pCreateParms->fCreate);
     797    Msg.objInfo.SetPtr((void *)&pCreateParms->ObjInfo, sizeof(pCreateParms->ObjInfo));
     798
     799    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     800    if (RT_SUCCESS(rc))
     801    {
     802        Msg.uHandle.GetUInt64(phObj);
     803    }
     804
     805    LogFlowFuncLeaveRC(rc);
     806    return rc;
     807}
     808
     809VBGLR3DECL(int) VbglR3ClipboardObjCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj)
     810{
     811    AssertPtrReturn(pCtx,  VERR_INVALID_POINTER);
     812    AssertPtrReturn(phObj, VERR_INVALID_POINTER);
     813
     814    VBoxClipboardObjCloseMsg Msg;
     815    RT_ZERO(Msg);
     816
     817    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     818                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
     819
     820    Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN);
     821    Msg.uHandle.SetUInt64(0);
     822
     823    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     824    if (RT_SUCCESS(rc))
     825    {
     826        rc = Msg.uHandle.GetUInt64(phObj);
     827    }
     828
     829    LogFlowFuncLeaveRC(rc);
     830    return rc;
     831}
     832
     833VBGLR3DECL(int) VbglR3ClipboardObjCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDOBJHANDLE hObj)
     834{
     835    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     836
     837    VBoxClipboardReplyMsg Msg;
     838    RT_ZERO(Msg);
     839
     840    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     841                       VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY, 6);
     842
     843    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     844    Msg.enmType.SetUInt32(VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE);
     845    Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */
     846    Msg.cbPayload.SetUInt32(0);
     847    Msg.pvPayload.SetPtr(0, NULL);
     848
     849    Msg.u.ObjClose.uHandle.SetUInt64(hObj);
     850
     851    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     852
     853    LogFlowFuncLeaveRC(rc);
     854    return rc;
     855}
     856
     857VBGLR3DECL(int) VbglR3ClipboardObjCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj)
     858{
     859    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     860
     861    VBoxClipboardObjCloseMsg Msg;
     862    RT_ZERO(Msg);
     863
     864    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     865                       VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
     866
     867    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     868    Msg.uHandle.SetUInt64(hObj);
     869
     870    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     871
     872    LogFlowFuncLeaveRC(rc);
     873    return rc;
     874}
     875
     876VBGLR3DECL(int) VbglR3ClipboardObjReadRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj, uint32_t *pcbToRead,
     877                                           uint32_t *pfFlags)
     878{
     879    AssertPtrReturn(pCtx,      VERR_INVALID_POINTER);
     880    AssertPtrReturn(phObj,     VERR_INVALID_POINTER);
     881    AssertPtrReturn(pcbToRead, VERR_INVALID_POINTER);
     882    AssertPtrReturn(pfFlags,   VERR_INVALID_POINTER);
     883
     884    VBoxClipboardObjReadReqMsg Msg;
     885    RT_ZERO(Msg);
     886
     887    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     888                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
     889
     890    Msg.ReqParms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ);
     891    Msg.ReqParms.uHandle.SetUInt64(0);
     892    Msg.ReqParms.cbToRead.SetUInt32(0);
     893    Msg.ReqParms.fRead.SetUInt32(0);
     894
     895    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     896    if (RT_SUCCESS(rc))
     897    {
     898        rc = Msg.ReqParms.uHandle.GetUInt64(phObj);
     899        if (RT_SUCCESS(rc))
     900            rc = Msg.ReqParms.cbToRead.GetUInt32(pcbToRead);
     901        if (RT_SUCCESS(rc))
     902            rc = Msg.ReqParms.fRead.GetUInt32(pfFlags);
     903    }
     904
     905    LogFlowFuncLeaveRC(rc);
     906    return rc;
     907}
     908
     909VBGLR3DECL(int) VbglR3ClipboardObjReadSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj,
     910                                           void *pvData, uint32_t cbData, uint32_t *pcbRead)
     911{
     912    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
     913    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
     914    AssertReturn(cbData,    VERR_INVALID_PARAMETER);
     915    /* pcbRead is optional. */
     916
     917    VBoxClipboardObjReadWriteMsg Msg;
     918    RT_ZERO(Msg);
     919
     920    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ);
     921
     922    Msg.uContext.SetUInt32(0);
     923    Msg.uHandle.SetUInt64(hObj);
     924    Msg.pvData.SetPtr(pvData, cbData);
     925    Msg.cbData.SetUInt32(0);
     926    Msg.pvChecksum.SetPtr(NULL, 0);
     927    Msg.cbChecksum.SetUInt32(0);
     928
     929    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     930    if (RT_SUCCESS(rc))
     931    {
     932        /** @todo Context ID not used yet. */
     933        /** @todo Add checksum support. */
     934
     935        if (pcbRead)
     936        {
     937            rc = Msg.cbData.GetUInt32(pcbRead); AssertRC(rc);
     938            AssertReturn(cbData >= *pcbRead, VERR_TOO_MUCH_DATA);
     939        }
     940    }
     941
     942    LogFlowFuncLeaveRC(rc);
     943    return rc;
     944}
     945
     946VBGLR3DECL(int) VbglR3ClipboardObjWriteSend(PVBGLR3SHCLCMDCTX pCtx,
     947                                            SHAREDCLIPBOARDOBJHANDLE hObj,
     948                                            void *pvData, uint32_t cbData, uint32_t *pcbWritten)
     949{
     950    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
     951    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
     952    AssertReturn(cbData,    VERR_INVALID_PARAMETER);
     953    /* pcbWritten is optional. */
     954
     955    VBoxClipboardObjReadWriteMsg Msg;
     956    RT_ZERO(Msg);
     957
     958    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
     959
     960    Msg.uContext.SetUInt32(0);
     961    Msg.uHandle.SetUInt64(hObj);
     962    Msg.pvData.SetPtr(pvData, cbData);
     963    Msg.cbData.SetUInt32(cbData);
     964    Msg.pvChecksum.SetPtr(NULL, 0); /** @todo Implement this. */
     965    Msg.cbChecksum.SetUInt32(0); /** @todo Implement this. */
     966
     967    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     968    if (RT_SUCCESS(rc))
     969    {
     970        if (pcbWritten)
     971            *pcbWritten = cbData;
     972    }
     973
     974    LogFlowFuncLeaveRC(rc);
     975    return rc;
     976}
     977
     978VBGLR3DECL(int) VbglR3ClipboardEventGetNext(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer,
    665979                                            PVBGLR3CLIPBOARDEVENT *ppEvent)
    666980{
     981    AssertPtrReturn(pCtx,      VERR_INVALID_POINTER);
    667982    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    668983    AssertPtrReturn(ppEvent,   VERR_INVALID_POINTER);
    … …  
    674989    uint32_t uMsg   = 0;
    675990    uint32_t cParms = 0;
    676     int rc = vbglR3ClipboardMsgPeekWait(idClient, &uMsg, &cParms, NULL /* pidRestoreCheck */);
    677     if (RT_SUCCESS(rc))
    678     {
    679         LogFunc(("Handling uMsg=%RU32\n", uMsg));
    680 
     991    int rc = vbglR3ClipboardMsgPeekWait(pCtx, &uMsg, &cParms, NULL /* pidRestoreCheck */);
     992    if (RT_SUCCESS(rc))
     993    {
     994#ifdef LOG_ENABLED
     995        LogFunc(("Handling uMsg=%RU32 (%s)\n", uMsg, VBoxClipboardHostMsgToStr(uMsg)));
     996#endif
    681997        switch (uMsg)
    682998        {
    683999#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    684             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOTS:
     1000            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ:
    6851001            {
    686                 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOTS\n"));
    687 
    688                 VBOXCLIPBOARDROOTS Roots;
    689                 rc = SharedClipboardURIRootsInit(&Roots);
     1002                uint32_t fRoots;
     1003                rc = VbglR3ClipboardRootListHdrReadReq(pCtx, &fRoots);
     1004
     1005                /** @todo Validate / handle fRoots. */
     1006
    6901007                if (RT_SUCCESS(rc))
    6911008                {
    692                     rc = VbglR3ClipboardRootsRecv(idClient, &Roots);
     1009                    VBOXCLIPBOARDROOTLISTHDR rootListHdr;
     1010                    RT_ZERO(rootListHdr);
     1011
     1012                    rootListHdr.cRoots = SharedClipboardURILTransferRootsCount(pTransfer);
     1013
     1014                    LogFlowFunc(("cRoots=%RU32\n", rootListHdr.cRoots));
     1015
     1016                    rc = VbglR3ClipboardRootListHdrReadReply(pCtx, &rootListHdr);
     1017                }
     1018                break;
     1019            }
     1020
     1021            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ:
     1022            {
     1023                uint32_t uIndex;
     1024                uint32_t fInfo;
     1025                rc = VbglR3ClipboardRootListEntryReadReq(pCtx, &uIndex, &fInfo);
     1026                if (RT_SUCCESS(rc))
     1027                {
     1028                    VBOXCLIPBOARDLISTENTRY rootListEntry;
     1029                    rc = SharedClipboardURILTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
    6931030                    if (RT_SUCCESS(rc))
    694                     {
    695                         /** @todo Handle Roots.fRoots flags. */
    696 
    697                         char    *pszRoots = NULL;
    698                         uint32_t cRoots   = 0;
    699                         rc = SharedClipboardURILTransferGetRoots(pTransfer, &pszRoots, &cRoots);
    700                         if (RT_SUCCESS(rc))
    701                         {
    702                             /** @todo Split up transfers in _64K each. */
    703 
    704                             const uint32_t cbRoots = pszRoots
    705                                                    ? (uint32_t)strlen(pszRoots) + 1 /* Include termination. */
    706                                                    : 0;
    707 
    708                             rc = VbglR3ClipboardRootsWrite(idClient, cRoots, pszRoots, cbRoots);
    709                         }
    710                     }
     1031                        rc = VbglR3ClipboardRootListEntryReadReply(pCtx, uIndex, &rootListEntry);
    7111032                }
    712 
    7131033                break;
    7141034            }
    … …  
    7221042                if (RT_SUCCESS(rc))
    7231043                {
    724                     rc = VbglR3ClipboardListOpenRecv(idClient, &openParmsList);
     1044                    rc = VbglR3ClipboardListOpenRecv(pCtx, &openParmsList);
    7251045                    if (RT_SUCCESS(rc))
    7261046                    {
    … …  
    7311051
    7321052                        /* Reply in any case. */
    733                         int rc2 = VbglR3ClipboardListOpenReply(idClient, rc, hList);
     1053                        int rc2 = VbglR3ClipboardListOpenReply(pCtx, rc, hList);
    7341054                        AssertRC(rc2);
    7351055
    … …  
    7461066
    7471067                SHAREDCLIPBOARDLISTHANDLE hList;
    748                 rc = VbglR3ClipboardListCloseRecv(idClient, &hList);
     1068                rc = VbglR3ClipboardListCloseRecv(pCtx, &hList);
    7491069                if (RT_SUCCESS(rc))
    7501070                {
    … …  
    7521072
    7531073                    /* Reply in any case. */
    754                     int rc2 = VbglR3ClipboardListCloseReply(idClient, rc, hList);
     1074                    int rc2 = VbglR3ClipboardListCloseReply(pCtx, rc, hList);
    7551075                    AssertRC(rc2);
    7561076                }
    … …  
    7671087                SHAREDCLIPBOARDLISTHANDLE hList  = SHAREDCLIPBOARDLISTHANDLE_INVALID;
    7681088                uint32_t                  fFlags = 0;
    769                 rc = VbglR3ClipboardListHdrReadRecvReq(idClient, &hList, &fFlags);
     1089                rc = VbglR3ClipboardListHdrReadRecvReq(pCtx, &hList, &fFlags);
    7701090                if (RT_SUCCESS(rc))
    7711091                {
    … …  
    7741094                    if (RT_SUCCESS(rc))
    7751095                    {
    776                         rc = VbglR3ClipboardListHdrWrite(idClient, hList, &hdrList);
     1096                        rc = VbglR3ClipboardListHdrWrite(pCtx, hList, &hdrList);
     1097
    7771098                        SharedClipboardURIListHdrDestroy(&hdrList);
    7781099                    }
    … …  
    7911112                if (RT_SUCCESS(rc))
    7921113                {
    793                     rc = VBglR3ClipboardListHdrRecv(idClient, )
     1114                    rc = VBglR3ClipboardListHdrRecv(pCtx, )
    7941115                }
    7951116                break;
    … …  
    8071128                    SHAREDCLIPBOARDLISTHANDLE hList;
    8081129                    uint32_t                  fInfo;
    809                     rc = VbglR3ClipboardListEntryReadRecvReq(idClient, &hList, &fInfo);
     1130                    rc = VbglR3ClipboardListEntryReadRecvReq(pCtx, &hList, &fInfo);
    8101131                    if (RT_SUCCESS(rc))
    8111132                    {
    … …  
    8161137                            Assert(entryList.cbInfo == sizeof(SHAREDCLIPBOARDFSOBJINFO));
    8171138
     1139                            RT_NOREF(pObjInfo);
     1140
    8181141                            LogFlowFunc(("\t%s (%RU64 bytes)\n", entryList.pszName, pObjInfo->cbObject));
    8191142
    820                             rc = VbglR3ClipboardListEntryWrite(idClient, hList, &entryList);
     1143                            rc = VbglR3ClipboardListEntryWrite(pCtx, hList, &entryList);
    8211144                        }
    8221145                    }
    … …  
    8401163            {
    8411164                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN\n"));
    842                 pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_OPEN;
     1165
     1166                VBOXCLIPBOARDOBJOPENCREATEPARMS createParms;
     1167                rc = VbglR3ClipboardObjOpenRecv(pCtx, &createParms);
     1168                if (RT_SUCCESS(rc))
     1169                {
     1170                    SHAREDCLIPBOARDOBJHANDLE hObj;
     1171                    rc = SharedClipboardURIObjectOpen(pTransfer, &createParms, &hObj);
     1172                    if (RT_SUCCESS(rc))
     1173                    {
     1174                        int rc2 = VbglR3ClipboardObjOpenReply(pCtx, rc, hObj);
     1175                        AssertRC(rc2);
     1176                    }
     1177                }
     1178
    8431179                break;
    8441180            }
    … …  
    8471183            {
    8481184                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE\n"));
    849                 pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_CLOSE;
     1185
     1186                SHAREDCLIPBOARDOBJHANDLE hObj;
     1187                rc = VbglR3ClipboardObjCloseRecv(pCtx, &hObj);
     1188                if (RT_SUCCESS(rc))
     1189                {
     1190                    rc = SharedClipboardURIObjectClose(hObj);
     1191
     1192                    /* Reply in any case. */
     1193                    int rc2 = VbglR3ClipboardObjCloseReply(pCtx, rc, hObj);
     1194                    AssertRC(rc2);
     1195                }
    8501196                break;
    8511197            }
    … …  
    8541200            {
    8551201                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ\n"));
    856                 pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_READ;
     1202
     1203                SHAREDCLIPBOARDOBJHANDLE hObj;
     1204                uint32_t cbBuf;
     1205                uint32_t fFlags;
     1206                rc = VbglR3ClipboardObjReadRecv(pCtx, &hObj, &cbBuf, &fFlags);
     1207                if (RT_SUCCESS(rc))
     1208                {
     1209                    void *pvBuf = RTMemAlloc(RT_MIN(cbBuf, _64K)); /** @todo Make this more flexible. */
     1210                    if (pvBuf)
     1211                    {
     1212                        uint32_t cbRead;
     1213                        rc = SharedClipboardURIObjectRead(hObj, pvBuf, cbBuf, &cbRead, fFlags);
     1214                        if (RT_SUCCESS(rc))
     1215                            rc = VbglR3ClipboardObjReadSend(pCtx, hObj, pvBuf, cbRead, NULL /* pcbWritten */);
     1216
     1217                        RTMemFree(pvBuf);
     1218                    }
     1219                    else
     1220                        rc = VERR_NO_MEMORY;
     1221                }
    8571222                break;
    8581223            }
    … …  
    8621227            {
    8631228                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE\n"));
    864                 pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_WRITE;
    8651229                break;
    8661230            }
    … …  
    8861250    {
    8871251        /* Report error back to the host. */
    888         //VbglR3ClipboardWriteError(idClient, rc);
     1252        int rc2 = VbglR3ClipboardWriteError(pCtx->uClientID, rc);
     1253        Assert(rc2);
    8891254
    8901255        VbglR3ClipboardEventFree(pEvent);
    … …  
    10041369}
    10051370#endif
    1006 
    1007 VBGLR3DECL(int) VbglR3ClipboardObjOpen(HGCMCLIENTID idClient,
    1008                                        const char *pszPath, PVBOXCLIPBOARDCREATEPARMS pCreateParms,
    1009                                        PSHAREDCLIPBOARDOBJHANDLE phObj)
    1010 {
    1011     AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
    1012     AssertPtrReturn(pCreateParms, VERR_INVALID_POINTER);
    1013     AssertPtrReturn(phObj, VERR_INVALID_POINTER);
    1014 
    1015     VBoxClipboardObjOpenMsg Msg;
    1016     RT_ZERO(Msg);
    1017 
    1018     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    1019                        VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
    1020 
    1021     int rc;
    1022 
    1023     char *pszPathTmp = RTStrDup(pszPath);
    1024     if (pszPathTmp)
    1025     {
    1026         Msg.szPath.SetPtr((void *)pszPathTmp, (uint32_t)strlen(pszPathTmp) + 1 /* Include terminating zero */);
    1027         Msg.parms.SetPtr(pCreateParms, sizeof(VBOXCLIPBOARDCREATEPARMS));
    1028 
    1029         rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    1030         if (RT_SUCCESS(rc))
    1031         {
    1032             *phObj = pCreateParms->uHandle;
    1033         }
    1034 
    1035         RTStrFree(pszPathTmp);
    1036     }
    1037     else
    1038         rc = VERR_NO_MEMORY;
    1039 
    1040     LogFlowFuncLeaveRC(rc);
    1041     return rc;
    1042 }
    1043 
    1044 VBGLR3DECL(int) VbglR3ClipboardObjClose(HGCMCLIENTID idClient, SHAREDCLIPBOARDOBJHANDLE hObj)
    1045 {
    1046     VBoxClipboardObjCloseMsg Msg;
    1047     RT_ZERO(Msg);
    1048 
    1049     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    1050                        VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
    1051 
    1052     Msg.uHandle.SetUInt64(hObj);
    1053 
    1054     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    1055 
    1056     LogFlowFuncLeaveRC(rc);
    1057     return rc;
    1058 }
    1059 
    1060 VBGLR3DECL(int) VbglR3ClipboardObjRead(HGCMCLIENTID idClient, SHAREDCLIPBOARDOBJHANDLE hObj,
    1061                                        void *pvData, uint32_t cbData, uint32_t *pcbRead)
    1062 {
    1063     AssertPtrReturn(pvData,  VERR_INVALID_POINTER);
    1064     AssertReturn(cbData,     VERR_INVALID_PARAMETER);
    1065     /* pcbRead is optional. */
    1066 
    1067     VBoxClipboardObjReadWriteMsg Msg;
    1068     RT_ZERO(Msg);
    1069 
    1070     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ);
    1071 
    1072     Msg.uContext.SetUInt32(0);
    1073     Msg.uHandle.SetUInt64(hObj);
    1074     Msg.pvData.SetPtr(pvData, cbData);
    1075     Msg.cbData.SetUInt32(0);
    1076     Msg.pvChecksum.SetPtr(NULL, 0);
    1077     Msg.cbChecksum.SetUInt32(0);
    1078 
    1079     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    1080     if (RT_SUCCESS(rc))
    1081     {
    1082         /** @todo Context ID not used yet. */
    1083         /** @todo Add checksum support. */
    1084 
    1085         if (pcbRead)
    1086         {
    1087             rc = Msg.cbData.GetUInt32(pcbRead); AssertRC(rc);
    1088             AssertReturn(cbData >= *pcbRead, VERR_TOO_MUCH_DATA);
    1089         }
    1090     }
    1091 
    1092     LogFlowFuncLeaveRC(rc);
    1093     return rc;
    1094 }
    1095 
    1096 VBGLR3DECL(int) VbglR3ClipboardObjWrite(HGCMCLIENTID idClient,
    1097                                         SHAREDCLIPBOARDOBJHANDLE hObj,
    1098                                         void *pvData, uint32_t cbData, uint32_t *pcbWritten)
    1099 {
    1100     AssertPtrReturn(pvData, VERR_INVALID_POINTER);
    1101     AssertReturn(cbData, VERR_INVALID_PARAMETER);
    1102     /* pcbWritten is optional. */
    1103 
    1104     VBoxClipboardObjReadWriteMsg Msg;
    1105     RT_ZERO(Msg);
    1106 
    1107     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
    1108 
    1109     Msg.uContext.SetUInt32(0);
    1110     Msg.uHandle.SetUInt64(hObj);
    1111     Msg.pvData.SetPtr(pvData, cbData);
    1112     Msg.cbData.SetUInt32(cbData);
    1113     Msg.pvChecksum.SetPtr(NULL, 0); /** @todo Implement this. */
    1114     Msg.cbChecksum.SetUInt32(0); /** @todo Implement this. */
    1115 
    1116     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    1117     if (RT_SUCCESS(rc))
    1118     {
    1119         if (pcbWritten)
    1120             *pcbWritten = cbData;
    1121     }
    1122 
    1123     LogFlowFuncLeaveRC(rc);
    1124     return rc;
    1125 }
    11261371#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    11271372

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

    r79702 r80283  
    245245
    246246    pTransfer->Thread.fStarted = true;
     247    pTransfer->Thread.fStop    = false;
    247248
    248249    RTThreadUserSignal(RTThreadSelf());
    249250
    250     LogRel2(("Shared Clipboard: Calculating transfer ....\n"));
     251    LogRel2(("Shared Clipboard: Calculating transfer ...\n"));
    251252
    252253    int rc = SharedClipboardURITransferOpen(pTransfer);
    253254    if (RT_SUCCESS(rc))
    254255    {
    255         uint32_t cRoots;
    256         char    *pszRoots;
    257         rc = SharedClipboardURILTransferGetRoots(pTransfer, &pszRoots, &cRoots);
     256        PVBOXCLIPBOARDROOTLIST pRootList;
     257        rc = SharedClipboardURILTransferRootsAsList(pTransfer, &pRootList);
    258258        if (RT_SUCCESS(rc))
    259259        {
    260             SharedClipboardURIListRootEntries lstRoots = RTCString(pszRoots, strlen(pszRoots)).split("\r\n");
    261             Assert(lstRoots.size() == cRoots);
    262 
    263             LogFlowFunc(("cRoots=%zu\n", lstRoots.size()));
    264 
    265             for (uint32_t i = 0; i < lstRoots.size(); i++)
     260            for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++)
    266261            {
    267                 VBOXCLIPBOARDLISTOPENPARMS openParmsList;
    268                 rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
    269                 if (RT_SUCCESS(rc))
     262                PVBOXCLIPBOARDLISTENTRY pRootEntry = &pRootList->paEntries[i];
     263                AssertPtr(pRootEntry);
     264
     265                Assert(pRootEntry->cbInfo == sizeof(SHAREDCLIPBOARDFSOBJINFO));
     266                PSHAREDCLIPBOARDFSOBJINFO pFsObjInfo = (PSHAREDCLIPBOARDFSOBJINFO)pRootEntry->pvInfo;
     267
     268                LogFlowFunc(("pszRoot=%s, fMode=0x%x\n", pRootEntry->pszName, pFsObjInfo->Attr.fMode));
     269
     270                if (RTFS_IS_DIRECTORY(pFsObjInfo->Attr.fMode))
    270271                {
    271                     LogFlowFunc(("pszRoot=%s\n", lstRoots[i].c_str()));
    272 
    273                     rc = RTStrCopy(openParmsList.pszPath, openParmsList.cbPath, lstRoots[i].c_str());
     272                    VBOXCLIPBOARDLISTOPENPARMS openParmsList;
     273                    rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
     274                    if (RT_FAILURE(rc))
     275                        break;
     276
     277                    rc = RTStrCopy(openParmsList.pszPath, openParmsList.cbPath, pRootEntry->pszName);
    274278                    if (RT_FAILURE(rc))
    275279                        break;
    … …  
    288292                                         hdrList.cTotalObjects, hdrList.cbTotalSize));
    289293
    290                             for (uint64_t i = 0; i < hdrList.cTotalObjects; i++)
     294                            do
    291295                            {
    292296                                VBOXCLIPBOARDLISTENTRY entryList;
    … …  
    303307                                }
    304308                                else
     309                                {
     310                                    if (rc == VERR_NO_MORE_FILES) /* End of list has been reached. */
     311                                        rc = VINF_SUCCESS;
    305312                                    break;
     313                                }
    306314
    307315                                if (pTransfer->Thread.fStop)
    308316                                    break;
    309                             }
     317
     318                            } while (RT_SUCCESS(rc));
    310319                        }
    311320
    … …  
    314323
    315324                    SharedClipboardURIListOpenParmsDestroy(&openParmsList);
     325                }
     326                else if (RTFS_IS_FILE(pFsObjInfo->Attr.fMode))
     327                {
     328                    FSOBJENTRY objEntry = { pRootEntry->pszName, *pFsObjInfo };
     329
     330                    pThis->m_lstRootEntries.push_back(objEntry); /** @todo Can this throw? */
    316331                }
    317332
    … …  
    319334                    break;
    320335            }
     336
     337            SharedClipboardURIRootListFree(pRootList);
     338            pRootList = NULL;
    321339
    322340            if (RT_SUCCESS(rc))
    … …  
    337355                AssertRC(rc2);
    338356            }
    339 
    340             RTStrFree(pszRoots);
    341357        }
    342358
    … …  
    553569    if (pFormatEtc->cfFormat == m_cfFileContents)
    554570    {
    555         if (   pFormatEtc->lindex >= 0
    556             && pFormatEtc->lindex < m_lstRootEntries.size())
     571        if (          pFormatEtc->lindex >= 0
     572            && (ULONG)pFormatEtc->lindex < m_lstRootEntries.size())
    557573        {
    558574            m_uObjIdx = pFormatEtc->lindex; /* lIndex of FormatEtc contains the actual index to the object being handled. */
    559575
    560             LogFlowFunc(("FormatIndex_FileContents: m_uObjIdx=%u\n", m_uObjIdx));
    561 
    562576            FSOBJENTRY &fsObjEntry = m_lstRootEntries.at(m_uObjIdx);
    563577
    564             LogRel2(("Shared Clipboard: Receiving file '%s' ...\n", fsObjEntry.strPath.c_str()));
     578            LogFlowFunc(("FormatIndex_FileContents: m_uObjIdx=%u (entry '%s')\n", m_uObjIdx, fsObjEntry.strPath.c_str()));
     579
     580            LogRel2(("Shared Clipboard: Receiving object '%s' ...\n", fsObjEntry.strPath.c_str()));
    565581
    566582            /* Hand-in the provider so that our IStream implementation can continue working with it. */

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

    r79702 r80283  
    187187            && m_pURITransfer->ProviderIface.pfnObjOpen)
    188188        {
    189             VBOXCLIPBOARDCREATEPARMS createParms;
     189            VBOXCLIPBOARDOBJOPENCREATEPARMS createParms;
    190190            RT_ZERO(createParms);
    191191
    192             rc = m_pURITransfer->ProviderIface.pfnObjOpen(&m_pURITransfer->ProviderCtx, m_strPath.c_str(), &createParms, &m_hObj);
     192            createParms.pszPath = RTStrDup(m_strPath.c_str());
     193            if (createParms.pszPath)
     194            {
     195                rc = m_pURITransfer->ProviderIface.pfnObjOpen(&m_pURITransfer->ProviderCtx, &createParms, &m_hObj);
     196
     197                RTStrFree(createParms.pszPath);
     198            }
     199            else
     200                rc = VERR_NO_MEMORY;
    193201        }
    194202        else

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

    r79272 r80283  
    2727#include <VBox/log.h>
    2828#include <VBox/GuestHost/clipboard-helper.h>
    29 
     29#ifdef LOG_ENABLED
     30# include <VBox/HostServices/VBoxClipboardSvc.h>
     31#endif
    3032
    3133/** @todo use const where appropriate; delinuxify the code (*Lin* -> *Host*); use AssertLogRel*. */
    … …  
    407409        LogFunc(("Invalid format %02X\n", u32Format));
    408410}
     411
     412/**
     413 * Translates a Shared Clipboard host message enum to a string.
     414 *
     415 * @returns Message ID string name.
     416 * @param   uMsg                The message to translate.
     417 */
     418const char *VBoxClipboardHostMsgToStr(uint32_t uMsg)
     419{
     420    switch (uMsg)
     421    {
     422        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
     423        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
     424        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS);
     425        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START);
     426        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ);
     427        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_WRITE);
     428        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ);
     429        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_WRITE);
     430        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN);
     431        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE);
     432        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ);
     433        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE);
     434        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ);
     435        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE);
     436        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN);
     437        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE);
     438        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ);
     439        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE);
     440        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_CANCEL);
     441        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ERROR);
     442    }
     443    return "Unknown";
     444}
     445
     446/**
     447 * Translates a Shared Clipboard guest message enum to a string.
     448 *
     449 * @returns Message ID string name.
     450 * @param   uMsg                The message to translate.
     451 */
     452const char *VBoxClipboardGuestMsgToStr(uint32_t uMsg)
     453{
     454    switch (uMsg)
     455    {
     456        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS);
     457        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA);
     458        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA);
     459        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT);
     460        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT);
     461        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET);
     462        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS);
     463        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY);
     464        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ);
     465        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE);
     466        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ);
     467        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE);
     468        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN);
     469        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE);
     470        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ);
     471        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE);
     472        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ);
     473        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE);
     474        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN);
     475        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE);
     476        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ);
     477        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE);
     478        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL);
     479        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR);
     480        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
     481    }
     482    return "Unknown";
     483}
    409484#endif /* LOG_ENABLED */
    410485

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

    r79702 r80283  
    3636#endif
    3737
    38 
    39 int SharedClipboardURIRootsInit(PVBOXCLIPBOARDROOTS pRoots)
    40 {
    41     AssertPtrReturn(pRoots, VERR_INVALID_POINTER);
    42 
    43     RT_BZERO(pRoots, sizeof(VBOXCLIPBOARDROOTS));
    44 
    45     const uint32_t cbRoots = _64K;
    46 
    47     pRoots->pszRoots = RTStrAlloc(cbRoots);
    48     if (!pRoots->pszRoots)
    49         return VERR_NO_MEMORY;
    50 
    51     pRoots->cbRoots = cbRoots;
     38/** @todo Split this file up in different modules. */
     39
     40/**
     41 * Allocates a new URI root list.
     42 *
     43 * @returns Allocated URI root list on success, or NULL on failure.
     44 */
     45PVBOXCLIPBOARDROOTLIST SharedClipboardURIRootListAlloc(void)
     46{
     47    PVBOXCLIPBOARDROOTLIST pRootList = (PVBOXCLIPBOARDROOTLIST)RTMemAllocZ(sizeof(VBOXCLIPBOARDROOTLIST));
     48
     49    return pRootList;
     50}
     51
     52/**
     53 * Frees an URI root list.
     54 *
     55 * @param   pRootList           URI root list to free. The pointer will be
     56 *                              invalid after returning from this function.
     57 */
     58void SharedClipboardURIRootListFree(PVBOXCLIPBOARDROOTLIST pRootList)
     59{
     60    if (!pRootList)
     61        return;
     62
     63    for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++)
     64        SharedClipboardURIListEntryDestroy(&pRootList->paEntries[i]);
     65
     66    RTMemFree(pRootList);
     67    pRootList = NULL;
     68}
     69
     70/**
     71 * Initializes an URI root list header.
     72 *
     73 * @returns VBox status code.
     74 * @param   pRootLstHdr         Root list header to initialize.
     75 */
     76int SharedClipboardURIRootListHdrInit(PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr)
     77{
     78    AssertPtrReturn(pRootLstHdr, VERR_INVALID_POINTER);
     79
     80    RT_BZERO(pRootLstHdr, sizeof(VBOXCLIPBOARDROOTLISTHDR));
    5281
    5382    return VINF_SUCCESS;
    5483}
    5584
    56 void SharedClipboardURIRootsDestroy(PVBOXCLIPBOARDROOTS pRoots)
    57 {
    58     if (!pRoots)
     85/**
     86 * Destroys an URI root list header.
     87 *
     88 * @param   pRootLstHdr         Root list header to destroy.
     89 */
     90void SharedClipboardURIRootListHdrDestroy(PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr)
     91{
     92    if (!pRootLstHdr)
    5993        return;
    6094
    61     if (pRoots->pszRoots)
    62         RTStrFree(pRoots->pszRoots);
    63 }
    64 
    65 PVBOXCLIPBOARDROOTS SharedClipboardURIRootsDup(PVBOXCLIPBOARDROOTS pRoots)
    66 {
    67     AssertPtrReturn(pRoots, NULL);
     95    pRootLstHdr->fRoots = 0;
     96    pRootLstHdr->cRoots = 0;
     97}
     98
     99/**
     100 * Duplicates an URI list header.
     101 *
     102 * @returns Duplicated URI list header on success, or NULL on failure.
     103 * @param   pRootLstHdr         Root list header to duplicate.
     104 */
     105PVBOXCLIPBOARDROOTLISTHDR SharedClipboardURIRootListHdrDup(PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr)
     106{
     107    AssertPtrReturn(pRootLstHdr, NULL);
    68108
    69109    int rc = VINF_SUCCESS;
    70110
    71     PVBOXCLIPBOARDROOTS pRootsDup = (PVBOXCLIPBOARDROOTS)RTMemAlloc(sizeof(VBOXCLIPBOARDROOTS));
     111    PVBOXCLIPBOARDROOTLISTHDR pRootsDup = (PVBOXCLIPBOARDROOTLISTHDR)RTMemAllocZ(sizeof(VBOXCLIPBOARDROOTLISTHDR));
    72112    if (pRootsDup)
    73113    {
    74         *pRootsDup = *pRoots;
    75 
    76         if (pRoots->pszRoots)
    77         {
    78             pRootsDup->pszRoots = RTStrDup(pRoots->pszRoots);
    79             if (!pRootsDup->pszRoots)
    80                 rc = VERR_NO_MEMORY;
    81         }
    82     }
     114        *pRootsDup = *pRootLstHdr;
     115    }
     116    else
     117        rc = VERR_NO_MEMORY;
    83118
    84119    if (RT_FAILURE(rc))
    85120    {
    86         if (pRootsDup->pszRoots)
    87             RTStrFree(pRootsDup->pszRoots);
    88 
    89         RTMemFree(pRootsDup);
     121        SharedClipboardURIRootListHdrDestroy(pRootsDup);
    90122        pRootsDup = NULL;
    91123    }
    … …  
    95127
    96128/**
    97  * Allocates a VBOXCLIPBOARDListHdr structure.
    98  *
    99  * @returns VBox status code.
    100  * @param   ppListEntry         Where to store the allocated VBOXCLIPBOARDListHdr structure on success.
     129 * (Deep) Copies a clipboard root list entry structure.
     130 *
     131 * @returns VBox status code.
     132 * @param   pListEntry          Clipboard root list entry to copy.
     133 */
     134int SharedClipboardURIRootListEntryCopy(PVBOXCLIPBOARDROOTLISTENTRY pDst, PVBOXCLIPBOARDROOTLISTENTRY pSrc)
     135{
     136    return SharedClipboardURIListEntryCopy(pDst, pSrc);
     137}
     138
     139/**
     140 * Duplicates (allocates) a clipboard root list entry structure.
     141 *
     142 * @returns Duplicated clipboard root list entry structure on success.
     143 * @param   pListEntry          Clipboard root list entry to duplicate.
     144 */
     145PVBOXCLIPBOARDROOTLISTENTRY SharedClipboardURIRootListEntryDup(PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry)
     146{
     147    return SharedClipboardURIListEntryDup(pRootListEntry);
     148}
     149
     150/**
     151 * Destroys a clipboard root list entry structure.
     152 *
     153 * @param   pListEntry          Clipboard root list entry structure to destroy.
     154 */
     155void SharedClipboardURIRootListEntryDestroy(PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry)
     156{
     157    return SharedClipboardURIListEntryDestroy(pRootListEntry);
     158}
     159
     160/**
     161 * Allocates a URI list header structure.
     162 *
     163 * @returns VBox status code.
     164 * @param   ppListHdr           Where to store the allocated URI list header structure on success.
    101165 */
    102166int SharedClipboardURIListHdrAlloc(PVBOXCLIPBOARDLISTHDR *ppListHdr)
    … …  
    118182
    119183/**
    120  * Frees a VBOXCLIPBOARDListHdr structure.
    121  *
    122  * @param   pListEntry          VBOXCLIPBOARDListHdr structure to free.
     184 * Frees an URI list header structure.
     185 *
     186 * @param   pListEntry          URI list header structure to free.
    123187 */
    124188void SharedClipboardURIListHdrFree(PVBOXCLIPBOARDLISTHDR pListHdr)
    … …  
    136200
    137201/**
    138  * Duplicates (allocates) a VBOXCLIPBOARDListHdr structure.
    139  *
    140  * @returns Duplicated VBOXCLIPBOARDListHdr structure on success.
    141  * @param   pListHdr            VBOXCLIPBOARDListHdr to duplicate.
     202 * Duplicates (allocates) an URI list header structure.
     203 *
     204 * @returns Duplicated URI list header structure on success.
     205 * @param   pListHdr            URI list header to duplicate.
    142206 */
    143207PVBOXCLIPBOARDLISTHDR SharedClipboardURIListHdrDup(PVBOXCLIPBOARDLISTHDR pListHdr)
    … …  
    243307}
    244308
     309/**
     310 * Duplicates an URI list open parameters structure.
     311 *
     312 * @returns Duplicated URI list open parameters structure on success, or NULL on failure.
     313 * @param   pParms              URI list open parameters structure to duplicate.
     314 */
    245315PVBOXCLIPBOARDLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PVBOXCLIPBOARDLISTOPENPARMS pParms)
    246316{
    … …  
    263333}
    264334
     335/**
     336 * Initializes an URI list open parameters structure.
     337 *
     338 * @returns VBox status code.
     339 * @param   pParms              URI list open parameters structure to initialize.
     340 */
    265341int SharedClipboardURIListOpenParmsInit(PVBOXCLIPBOARDLISTOPENPARMS pParms)
    266342{
    … …  
    269345    RT_BZERO(pParms, sizeof(VBOXCLIPBOARDLISTOPENPARMS));
    270346
    271     pParms->cbFilter  = 64;
     347    pParms->cbFilter  = 64; /** @todo Make this dynamic. */
    272348    pParms->pszFilter = RTStrAlloc(pParms->cbFilter);
    273349
    … …  
    279355}
    280356
     357/**
     358 * Destroys an URI list open parameters structure.
     359 *
     360 * @param   pParms              URI list open parameters structure to destroy.
     361 */
    281362void SharedClipboardURIListOpenParmsDestroy(PVBOXCLIPBOARDLISTOPENPARMS pParms)
    282363{
    … …  
    418499
    419500    pListEntry->cbName = VBOXCLIPBOARDLISTENTRY_MAX_NAME;
     501    pListEntry->pvInfo = NULL;
     502    pListEntry->cbInfo = 0;
     503    pListEntry->fInfo  = 0;
    420504
    421505    return VINF_SUCCESS;
    … …  
    423507
    424508/**
    425  * Initializes a clipboard list entry structure.
     509 * Destroys a clipboard list entry structure.
    426510 *
    427511 * @param   pListEntry          Clipboard list entry structure to destroy.
    … …  
    502586    return (   pObjCtx
    503587            && pObjCtx->uHandle != SHAREDCLIPBOARDOBJHANDLE_INVALID);
     588}
     589
     590int SharedClipboardURIObjectOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDOBJOPENCREATEPARMS pOpenCreateParms,
     591                                 PSHAREDCLIPBOARDOBJHANDLE phObj)
     592{
     593    RT_NOREF(pTransfer, pOpenCreateParms, phObj);
     594    return 0;
     595}
     596
     597int SharedClipboardURIObjectClose(SHAREDCLIPBOARDOBJHANDLE hObj)
     598{
     599    RT_NOREF(hObj);
     600    return 0;
     601}
     602
     603int SharedClipboardURIObjectRead(SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
     604{
     605    RT_NOREF(hObj, pvBuf, cbBuf, pcbRead, fFlags);
     606    return 0;
     607}
     608
     609int SharedClipboardURIObjectWrite(SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
     610                                  uint32_t fFlags)
     611{
     612    RT_NOREF(hObj, pvBuf, cbBuf, pcbWritten, fFlags);
     613    return 0;
     614}
     615
     616int SharedClipboardURIObjectQueryInfo(SHAREDCLIPBOARDOBJHANDLE hObj, PSHAREDCLIPBOARDFSOBJINFO pObjInfo)
     617{
     618    RT_NOREF(hObj, pObjInfo);
     619    return 0;
    504620}
    505621
    … …  
    526642    int rc = VINF_SUCCESS;
    527643
     644    pTransfer->State.uID       = 0;
    528645    pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_NONE;
    529646    pTransfer->State.enmDir    = enmDir;
    … …  
    538655    pTransfer->Thread.fStarted   = false;
    539656    pTransfer->Thread.fStop      = false;
     657
     658    pTransfer->uListHandleNext   = 1;
     659    pTransfer->uObjHandleNext    = 1;
     660    pTransfer->uEventIDNext      = 1;
     661
     662    pTransfer->uTimeoutMs     = 30 * 1000; /* 30s timeout by default. */
     663    pTransfer->cbMaxChunkSize = _64K; /** @todo Make this configurable. */
    540664
    541665    pTransfer->pvUser = NULL;
    … …  
    628752static SHAREDCLIPBOARDLISTHANDLE sharedClipboardURITransferListHandleNew(PSHAREDCLIPBOARDURITRANSFER pTransfer)
    629753{
    630     RT_NOREF(pTransfer);
    631 
    632     return 42; /** @todo FIX !!!!! */
     754    return pTransfer->uListHandleNext++; /** @todo Good enough for now. Improve this later. */
    633755}
    634756
    … …  
    658780        if (pInfo)
    659781        {
    660             LogFlowFunc(("pszPath=%RU32\n", pOpenParms->pszPath));
     782            LogFlowFunc(("pszPath=%s\n", pOpenParms->pszPath));
    661783
    662784            RTFSOBJINFO objInfo;
    … …  
    851973                        switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
    852974                        {
     975                    #if 0 /* No recursion here (yet). */
    853976                            case RTFS_TYPE_DIRECTORY:
    854977                            {
    … …  
    876999                                break;
    8771000                            }
    878 
     1001                    #endif
    8791002                            case RTFS_TYPE_FILE:
    8801003                            {
    … …  
    9631086                                Assert(pszFileName >= pszSrcPath);
    9641087                                size_t cchDstBase = pszFileName - pszSrcPath;
     1088#ifdef VBOX_STRICT
    9651089                                char *pszDstPath  = &pszSrcPath[cchDstBase];
    966 
    967                                 LogFlowFunc(("pszSrcPath=%s, pszFileName=%s, pszDstPath=%s\n", pszSrcPath, pszFileName, pszDstPath));
     1090                                LogFlowFunc(("pszSrcPath=%s, pszFileName=%s, pszDstPath=%s\n",
     1091                                             pszSrcPath, pszFileName, pszDstPath));
     1092#endif
    9681093                                rc = sharedClipboardURITransferListHdrFromDir(pHdr,
    9691094                                                                              pszSrcPath, pszSrcPath, pszSrcPath, cchDstBase);
    … …  
    10391164 * Reads a single Shared Clipboard list entry.
    10401165 *
    1041  * @returns VBox status code.
     1166 * @returns VBox status code or VERR_NO_MORE_FILES if the end of the list has been reached.
    10421167 * @param   pTransfer           URI clipboard transfer to handle.
    10431168 * @param   hList               List handle of list to read from.
    … …  
    10791204                            case RTFS_TYPE_DIRECTORY:
    10801205                            {
    1081                                 LogFlowFunc(("Directory: %s\n", pDirEntry->szName));
    1082 
    10831206                                /* Skip "." and ".." entries. */
    10841207                                if (RTDirEntryExIsStdDotLink(pDirEntry))
     1208                                {
    10851209                                    fSkipEntry = true;
    1086 
    1087                                 RT_FALL_THROUGH();
     1210                                    break;
     1211                                }
     1212
     1213                                LogFlowFunc(("Directory: %s\n", pDirEntry->szName));
     1214                                break;
    10881215                            }
    10891216
    … …  
    10911218                            {
    10921219                                LogFlowFunc(("File: %s\n", pDirEntry->szName));
    1093 
    1094                                 pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
    1095                                 if (pEntry->pvInfo)
    1096                                 {
    1097                                     rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pDirEntry->szName);
    1098                                     if (RT_SUCCESS(rc))
    1099                                     {
    1100                                         SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
    1101 
    1102                                         pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
    1103                                         pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
    1104                                     }
    1105                                 }
    1106                                 else
    1107                                     rc = VERR_NO_MEMORY;
    11081220                                break;
    11091221                            }
    … …  
    11111223                            case RTFS_TYPE_SYMLINK:
    11121224                            {
    1113                                 /** @todo Not implemented yet. */
     1225                                rc = VERR_NOT_IMPLEMENTED; /** @todo Not implemented yet. */
    11141226                                break;
    11151227                            }
    … …  
    11171229                            default:
    11181230                                break;
     1231                        }
     1232
     1233                        if (   RT_SUCCESS(rc)
     1234                            && !fSkipEntry)
     1235                        {
     1236                            pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
     1237                            if (pEntry->pvInfo)
     1238                            {
     1239                                rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pDirEntry->szName);
     1240                                if (RT_SUCCESS(rc))
     1241                                {
     1242                                    SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
     1243
     1244                                    pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
     1245                                    pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
     1246                                }
     1247                            }
     1248                            else
     1249                                rc = VERR_NO_MEMORY;
    11191250                        }
    11201251
    … …  
    12771408}
    12781409
     1410/**
     1411 * Clears (resets) the root list of an URI transfer.
     1412 *
     1413 * @param   pTransfer           Transfer to clear URI root list for.
     1414 */
     1415static void sharedClipboardURIListTransferRootsClear(PSHAREDCLIPBOARDURITRANSFER pTransfer)
     1416{
     1417    AssertPtrReturnVoid(pTransfer);
     1418
     1419    pTransfer->lstRootEntries.clear();
     1420}
     1421
     1422/**
     1423 * Sets URI root list entries for a given transfer.
     1424 *
     1425 * @returns VBox status code.
     1426 * @param   pTransfer           Transfer to set URI list entries for.
     1427 * @param   pszRoots            String list (separated by CRLF) of root entries to set.
     1428 * @param   cbRoots             Size (in bytes) of string list.
     1429 */
    12791430int SharedClipboardURILTransferSetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
    12801431{
    … …  
    12881439    int rc = VINF_SUCCESS;
    12891440
    1290     pTransfer->lstRootEntries.clear();
    1291 
    1292     pTransfer->lstRootEntries = RTCString(pszRoots, cbRoots - 1).split("\r\n");
     1441    sharedClipboardURIListTransferRootsClear(pTransfer);
     1442
     1443    RTCList<RTCString> lstRootEntries = RTCString(pszRoots, cbRoots - 1).split("\r\n");
     1444    for (size_t i = 0; i < lstRootEntries.size(); ++i)
     1445    {
     1446        SHAREDCLIPBOARDURILISTROOT listRoot;
     1447
     1448        listRoot.strPathAbs = lstRootEntries.at(i);
     1449
     1450        pTransfer->lstRootEntries.append(listRoot);
     1451    }
    12931452
    12941453    LogFlowFunc(("cRoots=%RU32\n", pTransfer->lstRootEntries.size()));
    … …  
    13091468    LogFlowFuncEnter();
    13101469
    1311     /** @todo Anything else to do here? */
     1470    sharedClipboardURIListTransferRootsClear(pTransfer);
    13121471}
    13131472
    … …  
    13251484}
    13261485
    1327 int SharedClipboardURILTransferGetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, char **ppszRoots, uint32_t *pcRoots)
     1486/**
     1487 * Returns the number of URI root list entries.
     1488 *
     1489 * @returns Root list entry count.
     1490 * @param   pTransfer           URI clipboard transfer to return root entry count for.
     1491 */
     1492uint32_t SharedClipboardURILTransferRootsCount(PSHAREDCLIPBOARDURITRANSFER pTransfer)
     1493{
     1494    AssertPtrReturn(pTransfer, 0);
     1495
     1496    return (uint32_t)pTransfer->lstRootEntries.size();
     1497}
     1498
     1499/**
     1500 * Get a specific root list entry.
     1501 *
     1502 * @returns VBox status code.
     1503 * @param   pTransfer           URI clipboard transfer to get root list entry of.
     1504 * @param   uIndex              Index (zero-based) of entry to get.
     1505 * @param   pEntry              Where to store the returned entry on success.
     1506 */
     1507int SharedClipboardURILTransferRootsEntry(PSHAREDCLIPBOARDURITRANSFER pTransfer,
     1508                                          uint32_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pEntry)
    13281509{
    13291510    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    1330     AssertPtrReturn(ppszRoots, VERR_INVALID_POINTER);
    1331 
    1332     int rc = VINF_SUCCESS;
    1333 
    1334     if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
    1335     {
    1336         char *pszRoots = NULL;
    1337 
    1338         for (size_t i = 0; i < pTransfer->lstRootEntries.size(); ++i)
    1339         {
    1340             rc = RTStrAAppend(&pszRoots, pTransfer->lstRootEntries.at(i).c_str());
    1341 
    1342             /* Add separation between paths.
    1343              * Note: Also do this for the last element of the list. */
    1344             if (RT_SUCCESS(rc))
    1345                 rc = RTStrAAppendExN(&pszRoots, 1 /* cPairs */, "\r\n", 2 /* Bytes */);
    1346 
    1347             if (RT_FAILURE(rc))
    1348                 break;
    1349         }
    1350 
     1511    AssertPtrReturn(pEntry,    VERR_INVALID_POINTER);
     1512
     1513    if (uIndex >= pTransfer->lstRootEntries.size())
     1514        return VERR_INVALID_PARAMETER;
     1515
     1516    int rc;
     1517
     1518    PSHAREDCLIPBOARDURILISTROOT pRoot = &pTransfer->lstRootEntries.at(uIndex);
     1519    AssertPtrReturn(pRoot, VERR_INVALID_POINTER);
     1520
     1521    /* Make sure that we only advertise relative source paths, not absolute ones. */
     1522    const char *pcszSrcPath = pRoot->strPathAbs.c_str();
     1523
     1524    char *pszFileName = RTPathFilename(pcszSrcPath);
     1525    if (pszFileName)
     1526    {
     1527        Assert(pszFileName >= pcszSrcPath);
     1528        size_t cchDstBase = pszFileName - pcszSrcPath;
     1529        const char *pszDstPath = &pcszSrcPath[cchDstBase];
     1530
     1531        LogFlowFunc(("pcszSrcPath=%s, pszDstPath=%s\n", pcszSrcPath, pszDstPath));
     1532
     1533        rc = SharedClipboardURIListEntryInit(pEntry);
    13511534        if (RT_SUCCESS(rc))
    13521535        {
    1353             LogFlowFunc(("Roots (%RU32):\n%s\n", pTransfer->lstRootEntries.size(), pszRoots));
    1354 
    1355             *ppszRoots = pszRoots;
    1356             *pcRoots   = (uint32_t)pTransfer->lstRootEntries.size();
     1536            rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pszDstPath);
     1537            if (RT_SUCCESS(rc))
     1538            {
     1539                pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
     1540                pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(pEntry->cbInfo);
     1541                if (pEntry->pvInfo)
     1542                {
     1543                    RTFSOBJINFO fsObjInfo;
     1544                    rc = RTPathQueryInfo(pcszSrcPath, & fsObjInfo, RTFSOBJATTRADD_NOTHING);
     1545                    if (RT_SUCCESS(rc))
     1546                    {
     1547                        SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &fsObjInfo);
     1548
     1549                        pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
     1550                    }
     1551                }
     1552                else
     1553                    rc = VERR_NO_MEMORY;
     1554            }
     1555        }
     1556    }
     1557    else
     1558        rc = VERR_INVALID_POINTER;
     1559
     1560    LogFlowFuncLeaveRC(rc);
     1561    return rc;
     1562}
     1563
     1564/**
     1565 * Returns the root entries of an URI transfer.
     1566 *
     1567 * @returns VBox status code.
     1568 * @param   pTransfer           URI clipboard transfer to return root entries for.
     1569 * @param   ppRootList          Where to store the root list on success.
     1570 */
     1571int SharedClipboardURILTransferRootsAsList(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDROOTLIST *ppRootList)
     1572{
     1573    AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
     1574    AssertPtrReturn(ppRootList, VERR_INVALID_POINTER);
     1575
     1576    int rc = VINF_SUCCESS;
     1577
     1578    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
     1579    {
     1580        PVBOXCLIPBOARDROOTLIST pRootList = SharedClipboardURIRootListAlloc();
     1581        if (!pRootList)
     1582            return VERR_NO_MEMORY;
     1583
     1584        const uint32_t cRoots = (uint32_t)pTransfer->lstRootEntries.size();
     1585
     1586        LogFlowFunc(("cRoots=%RU32\n", cRoots));
     1587
     1588        if (cRoots)
     1589        {
     1590            PVBOXCLIPBOARDROOTLISTENTRY paRootListEntries
     1591                = (PVBOXCLIPBOARDROOTLISTENTRY)RTMemAllocZ(cRoots * sizeof(VBOXCLIPBOARDROOTLISTENTRY));
     1592            if (paRootListEntries)
     1593            {
     1594                for (uint32_t i = 0; i < cRoots; ++i)
     1595                {
     1596                    rc = SharedClipboardURILTransferRootsEntry(pTransfer, i, &paRootListEntries[i]);
     1597                    if (RT_FAILURE(rc))
     1598                        break;
     1599                }
     1600
     1601                if (RT_SUCCESS(rc))
     1602                    pRootList->paEntries = paRootListEntries;
     1603            }
     1604            else
     1605                rc = VERR_NO_MEMORY;
    13571606        }
    13581607        else
     1608            rc = VERR_NOT_FOUND;
     1609
     1610        if (RT_SUCCESS(rc))
    13591611        {
    1360             if (pszRoots)
    1361                 RTStrFree(pszRoots);
     1612            pRootList->Hdr.cRoots = cRoots;
     1613            pRootList->Hdr.fRoots = 0; /** @todo Implement this. */
     1614
     1615            *ppRootList = pRootList;
    13621616        }
    13631617    }
    … …  
    13651619    {
    13661620        if (pTransfer->ProviderIface.pfnGetRoots)
    1367             rc = pTransfer->ProviderIface.pfnGetRoots(&pTransfer->ProviderCtx, ppszRoots, pcRoots);
     1621            rc = pTransfer->ProviderIface.pfnGetRoots(&pTransfer->ProviderCtx, ppRootList);
    13681622        else
    13691623            rc = VERR_NOT_SUPPORTED;
    … …  
    13741628}
    13751629
     1630/**
     1631 * Returns the transfer's source.
     1632 *
     1633 * @returns The transfer's source.
     1634 * @param   pTransfer           URI clipboard transfer to return source for.
     1635 */
    13761636SHAREDCLIPBOARDSOURCE SharedClipboardURITransferGetSource(PSHAREDCLIPBOARDURITRANSFER pTransfer)
    13771637{
    … …  
    14471707}
    14481708
     1709/**
     1710 * Allocates a new event payload.
     1711 *
     1712 * @returns VBox status code.
     1713 * @param   uID                 Event ID to associate payload to.
     1714 * @param   pvData              Data block to associate to this payload.
     1715 * @param   cbData              Size (in bytes) of data block to associate.
     1716 * @param   ppPayload           Where to store the allocated event payload on success.
     1717 */
    14491718int SharedClipboardURITransferPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
    14501719                                           PSHAREDCLIPBOARDURITRANSFERPAYLOAD *ppPayload)
    … …  
    14721741}
    14731742
     1743/**
     1744 * Frees an event payload.
     1745 *
     1746 * @returns VBox status code.
     1747 * @param   pPayload            URI clipboard transfer event payload to free.
     1748 */
    14741749void SharedClipboardURITransferPayloadFree(PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload)
    14751750{
    … …  
    14901765}
    14911766
    1492 int SharedClipboardURITransferEventRegister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID)
     1767/**
     1768 * Generates a new event ID for a specific URI transfer.
     1769 *
     1770 * @returns New event ID generated, or 0 on error.
     1771 * @param   pTransfer           URI clipboard transfer to generate event for.
     1772 */
     1773uint16_t SharedClipboardURITransferEventIDGenerate(PSHAREDCLIPBOARDURITRANSFER pTransfer)
     1774{
     1775    LogFlowFunc(("New event %RU16\n", pTransfer->uEventIDNext));
     1776    return pTransfer->uEventIDNext++; /** @todo Improve this. */
     1777}
     1778
     1779/**
     1780 * Registers an URI transfer event.
     1781 *
     1782 * @returns VBox status code.
     1783 * @param   pTransfer           URI clipboard transfer to register event for.
     1784 * @param   uID                 Event ID to register.
     1785 */
     1786int SharedClipboardURITransferEventRegister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID)
    14931787{
    14941788    int rc;
    … …  
    15041798            if (RT_SUCCESS(rc))
    15051799            {
    1506                 pTransfer->pMapEvents->insert(std::pair<uint32_t, PSHAREDCLIPBOARDURITRANSFEREVENT>(uID, pEvent)); /** @todo Can this throw? */
     1800                pTransfer->pMapEvents->insert(std::pair<uint16_t, PSHAREDCLIPBOARDURITRANSFEREVENT>(uID, pEvent)); /** @todo Can this throw? */
     1801
     1802                LogFlowFunc(("Event %RU16\n", uID));
    15071803            }
    15081804        }
    … …  
    15111807    }
    15121808    else
    1513         rc = VINF_SUCCESS;
     1809        rc = VERR_ALREADY_EXISTS;
     1810
     1811#ifdef DEBUG_andy
     1812    AssertRC(rc);
     1813#endif
    15141814
    15151815    LogFlowFuncLeaveRC(rc);
    … …  
    15171817}
    15181818
    1519 int SharedClipboardURITransferEventUnregister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID)
     1819/**
     1820 * Unregisters an URI transfer event.
     1821 *
     1822 * @returns VBox status code.
     1823 * @param   pTransfer           URI clipboard transfer to unregister event for.
     1824 * @param   uID                 Event ID to unregister.
     1825 */
     1826int SharedClipboardURITransferEventUnregister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID)
    15201827{
    15211828    int rc;
    … …  
    15321839        pTransfer->pMapEvents->erase(itEvent);
    15331840
     1841        LogFlowFunc(("Event %RU16\n", uID));
     1842
    15341843        rc = VINF_SUCCESS;
    15351844    }
    … …  
    15371846        rc = VERR_NOT_FOUND;
    15381847
     1848    AssertRC(rc);
     1849
    15391850    LogFlowFuncLeaveRC(rc);
    15401851    return rc;
    15411852}
    15421853
    1543 int SharedClipboardURITransferEventWait(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID, RTMSINTERVAL uTimeoutMs,
     1854/**
     1855 * Waits for an URI transfer event to get signalled.
     1856 *
     1857 * @returns VBox status code.
     1858 * @param   pTransfer           URI clipboard transfer that contains the event to wait for.
     1859 * @param   uID                 Event ID to wait for.
     1860 * @param   uTimeoutMs          Timeout (in ms) to wait.
     1861 * @param   ppPayload           Where to store the (allocated) event payload on success. Needs to be free'd with
     1862 *                              SharedClipboardURITransferPayloadFree().
     1863 */
     1864int SharedClipboardURITransferEventWait(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID, RTMSINTERVAL uTimeoutMs,
    15441865                                        PSHAREDCLIPBOARDURITRANSFERPAYLOAD *ppPayload)
    15451866{
    … …  
    15661887}
    15671888
    1568 int SharedClipboardURITransferEventSignal(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID,
     1889/**
     1890 * Signals an URI transfer event.
     1891 *
     1892 * @returns VBox status code.
     1893 * @param   pTransfer           URI clipboard transfer of event to signal.
     1894 * @param   uID                 Event ID to signal.
     1895 * @param   pPayload            Event payload to associate. Takes ownership. Optional.
     1896 */
     1897int SharedClipboardURITransferEventSignal(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint16_t uID,
    15691898                                          PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload)
    15701899{
    … …  
    15821911    else
    15831912        rc = VERR_NOT_FOUND;
     1913
     1914#ifdef DEBUG_andy
     1915    AssertRC(rc);
     1916#endif
    15841917
    15851918    LogFlowFuncLeaveRC(rc);

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

    r79631 r80283  
    222222                                      PVBOXCLIPBOARDLISTENTRY pListEntry);
    223223
    224 int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const char *pszPath,
    225                                PVBOXCLIPBOARDCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj);
     224int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms,
     225                               PSHAREDCLIPBOARDOBJHANDLE phObj);
    226226int vboxSvcClipboardURIObjClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj);
    227227int vboxSvcClipboardURIObjRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj,

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

    r79704 r80283  
    2525#include <VBox/err.h>
    2626
     27#include <VBox/GuestHost/clipboard-helper.h>
    2728#include <VBox/HostServices/VBoxClipboardSvc.h>
    2829#include <VBox/HostServices/VBoxClipboardExt.h>
    … …  
    4950*   Prototypes                                                                                                                   *
    5051*********************************************************************************************************************************/
    51 int VBoxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    52                                    PVBOXCLIPBOARDLISTOPENPARMS pOpenParms);
    53 int VBoxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    54                                     SHAREDCLIPBOARDLISTHANDLE hList);
     52static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     53                                          PVBOXCLIPBOARDLISTOPENPARMS pOpenParms);
     54static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     55                                           SHAREDCLIPBOARDLISTHANDLE hList);
    5556
    5657
    … …  
    7576}
    7677
    77 DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    78                                               char **ppapszRoots, uint32_t *pcRoots)
     78DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList)
    7979{
    8080    LogFlowFuncEnter();
    … …  
    8585    int rc;
    8686
    87     size_t   cbRootsRecv = 0;
    88 
    89     char    *pszRoots = NULL;
    90     uint32_t cRoots   = 0;
    91 
    92     /* There might be more than one message needed for retrieving all root items. */
    93     for (;;)
    94     {
    95         PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOTS,
    96                                                                 VBOX_SHARED_CLIPBOARD_CPARMS_ROOTS);
    97         if (pMsg)
    98         {
    99             HGCMSvcSetU32(&pMsg->m_paParms[0], 0 /* uContextID */);
    100             HGCMSvcSetU32(&pMsg->m_paParms[1], 0 /* fRoots */);
    101             HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fMore */);
    102             HGCMSvcSetU32(&pMsg->m_paParms[3], 0 /* cRoots */);
    103 
    104             uint32_t  cbData = _64K;
    105             void     *pvData = RTMemAlloc(cbData);
    106             AssertPtrBreakStmt(pvData, rc = VERR_NO_MEMORY);
    107 
    108             HGCMSvcSetU32(&pMsg->m_paParms[4], cbData);
    109             HGCMSvcSetPv (&pMsg->m_paParms[5], pvData, cbData);
    110 
    111             rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
    112             if (RT_SUCCESS(rc))
    113             {
    114                 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer,
    115                                                                   SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS);
    116                 AssertRC(rc2);
    117 
    118                 vboxSvcClipboardClientWakeup(pClient);
    119             }
    120         }
    121         else
    122             rc = VERR_NO_MEMORY;
    123 
    124         if (RT_SUCCESS(rc))
    125         {
    126             PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    127             rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS,
    128                                                      30 * 1000 /* Timeout in ms */, &pPayload);
    129             if (RT_SUCCESS(rc))
    130             {
    131                 PVBOXCLIPBOARDROOTS pRoots = (PVBOXCLIPBOARDROOTS)pPayload->pvData;
    132                 Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDROOTS));
    133 
    134                 LogFlowFunc(("cbRoots=%RU32, fRoots=%RU32, fMore=%RTbool\n", pRoots->cbRoots, pRoots->fRoots, pRoots->fMore));
    135 
    136                 if (!pRoots->cbRoots)
    137                     break;
    138                 AssertPtr(pRoots->pszRoots);
    139 
    140                 if (pszRoots == NULL)
    141                     pszRoots = (char *)RTMemDup((void *)pRoots->pszRoots, pRoots->cbRoots);
    142                 else
    143                     pszRoots = (char *)RTMemRealloc(pszRoots, cbRootsRecv + pRoots->cbRoots);
    144 
    145                 AssertPtrBreakStmt(pszRoots, rc = VERR_NO_MEMORY);
    146 
    147                 cbRootsRecv += pRoots->cbRoots;
    148 
    149                 if (cbRootsRecv > _32M) /* Don't allow more than 32MB root entries for now. */
     87    PVBOXCLIPBOARDCLIENTMSG pMsgHdr = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ,
     88                                                               VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
     89    if (pMsgHdr)
     90    {
     91        uint16_t uEventHdrRead = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     92
     93        HGCMSvcSetU32(&pMsgHdr->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEventHdrRead));
     94        HGCMSvcSetU32(&pMsgHdr->m_paParms[1], 0 /* fRoots */);
     95
     96        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsgHdr, true /* fAppend */);
     97        if (RT_SUCCESS(rc))
     98        {
     99            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEventHdrRead);
     100            AssertRC(rc2);
     101
     102            rc = vboxSvcClipboardClientWakeup(pClient);
     103            if (RT_SUCCESS(rc))
     104            {
     105                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayloadHdr;
     106                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEventHdrRead,
     107                                                         pCtx->pTransfer->uTimeoutMs, &pPayloadHdr);
     108                if (RT_SUCCESS(rc))
    150109                {
    151                     rc = VERR_ALLOCATION_TOO_BIG; /** @todo Find a better rc. */
    152                     break;
     110                    PVBOXCLIPBOARDROOTLISTHDR pSrcRootListHdr = (PVBOXCLIPBOARDROOTLISTHDR)pPayloadHdr->pvData;
     111                    Assert(pPayloadHdr->cbData == sizeof(VBOXCLIPBOARDROOTLISTHDR));
     112
     113                    LogFlowFunc(("cRoots=%RU32, fRoots=0x%x\n", pSrcRootListHdr->cRoots, pSrcRootListHdr->fRoots));
     114
     115                    PVBOXCLIPBOARDROOTLIST pRootList = SharedClipboardURIRootListAlloc();
     116                    if (pRootList)
     117                    {
     118                        if (pSrcRootListHdr->cRoots)
     119                        {
     120                            pRootList->paEntries =
     121                                (PVBOXCLIPBOARDROOTLISTENTRY)RTMemAllocZ(pSrcRootListHdr->cRoots * sizeof(VBOXCLIPBOARDROOTLISTENTRY));
     122
     123                            if (pRootList->paEntries)
     124                            {
     125                                for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++)
     126                                {
     127                                    PVBOXCLIPBOARDCLIENTMSG pMsgEntry = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
     128                                                                                                 VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
     129
     130                                    uint16_t uEventEntryRead = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     131
     132                                    HGCMSvcSetU32(&pMsgEntry->m_paParms[0],
     133                                                  VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEventEntryRead));
     134                                    HGCMSvcSetU32(&pMsgEntry->m_paParms[1], 0 /* fRoots */);
     135                                    HGCMSvcSetU32(&pMsgEntry->m_paParms[2], i /* uIndex */);
     136
     137                                    int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEventEntryRead);
     138                                    AssertRC(rc2);
     139
     140                                    rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsgEntry, true /* fAppend */);
     141                                    if (RT_FAILURE(rc))
     142                                        break;
     143
     144                                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayloadEntry;
     145                                    rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEventEntryRead,
     146                                                                             pCtx->pTransfer->uTimeoutMs, &pPayloadEntry);
     147                                    if (RT_FAILURE(rc))
     148                                        break;
     149
     150                                    PVBOXCLIPBOARDROOTLISTENTRY pSrcRootListEntry = (PVBOXCLIPBOARDROOTLISTENTRY)pPayloadEntry->pvData;
     151                                    Assert(pPayloadEntry->cbData == sizeof(VBOXCLIPBOARDROOTLISTENTRY));
     152
     153                                    rc = SharedClipboardURIListEntryCopy(&pRootList->paEntries[i], pSrcRootListEntry);
     154
     155                                    SharedClipboardURITransferPayloadFree(pPayloadEntry);
     156
     157                                    SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEventEntryRead);
     158
     159                                    if (RT_FAILURE(rc))
     160                                        break;
     161                                }
     162                            }
     163                            else
     164                                rc = VERR_NO_MEMORY;
     165                        }
     166
     167                        if (RT_SUCCESS(rc))
     168                        {
     169                            pRootList->Hdr.cRoots = pSrcRootListHdr->cRoots;
     170                            pRootList->Hdr.fRoots = 0; /** @todo Implement this. */
     171
     172                            *ppRootList = pRootList;
     173                        }
     174                        else
     175                            SharedClipboardURIRootListFree(pRootList);
     176
     177                        SharedClipboardURITransferPayloadFree(pPayloadHdr);
     178                    }
     179                    else
     180                        rc = VERR_NO_MEMORY;
    153181                }
    154 
    155                 cRoots += pRoots->cRoots;
    156 
    157                 const bool fDone = !RT_BOOL(pRoots->fMore); /* More root entries to be retrieved? Otherwise bail out. */
    158 
    159                 SharedClipboardURITransferPayloadFree(pPayload);
    160 
    161                 if (fDone)
    162                     break;
    163             }
    164         }
    165 
    166         if (RT_FAILURE(rc))
    167             break;
    168     }
    169 
    170     if (RT_SUCCESS(rc))
    171     {
    172         LogFlowFunc(("cRoots=%RU32\n", cRoots));
    173 
    174         *ppapszRoots = pszRoots;
    175         *pcRoots     = cRoots;
     182            }
     183
     184            SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEventHdrRead);
     185        }
    176186    }
    177187    else
    178     {
    179         RTMemFree(pszRoots);
    180         pszRoots = NULL;
    181     }
     188        rc = VERR_NO_MEMORY;
    182189
    183190    LogFlowFuncLeave();
    … …  
    199206    if (pMsg)
    200207    {
    201         rc = VBoxSvcClipboardURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, pOpenParms);
     208        rc = vboxSvcClipboardURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, pOpenParms);
    202209        if (RT_SUCCESS(rc))
    203210        {
    … …  
    205212            if (RT_SUCCESS(rc))
    206213            {
    207                 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN);
     214                uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     215
     216                int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
    208217                AssertRC(rc2);
    209218
    210                 vboxSvcClipboardClientWakeup(pClient);
     219                rc = vboxSvcClipboardClientWakeup(pClient);
     220                if (RT_SUCCESS(rc))
     221                {
     222                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     223                    rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     224                    if (RT_SUCCESS(rc))
     225                    {
     226                        Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
     227
     228                        PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
     229                        AssertPtr(pReply);
     230
     231                        Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN);
     232
     233                        *phList = pReply->u.ListOpen.uHandle;
     234
     235                        SharedClipboardURITransferPayloadFree(pPayload);
     236                    }
     237                }
     238
     239                SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEvent);
    211240            }
    212241        }
    … …  
    214243    else
    215244        rc = VERR_NO_MEMORY;
    216 
    217     if (RT_SUCCESS(rc))
    218     {
    219         PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    220         rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN,
    221                                                  30 * 1000 /* Timeout in ms */, &pPayload);
    222         if (RT_SUCCESS(rc))
    223         {
    224             Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
    225 
    226             PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
    227             AssertPtr(pReply);
    228 
    229             Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN);
    230 
    231             *phList = pReply->u.ListOpen.uHandle;
    232 
    233             SharedClipboardURITransferPayloadFree(pPayload);
    234         }
    235     }
    236245
    237246    LogFlowFuncLeaveRC(rc);
    … …  
    252261    if (pMsg)
    253262    {
    254         rc = VBoxSvcClipboardURISetListClose(pMsg->m_cParms, pMsg->m_paParms, hList);
     263        rc = vboxSvcClipboardURISetListClose(pMsg->m_cParms, pMsg->m_paParms, hList);
    255264        if (RT_SUCCESS(rc))
    256265        {
    … …  
    258267            if (RT_SUCCESS(rc))
    259268            {
    260                 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_CLOSE);
     269                uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     270
     271                int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
    261272                AssertRC(rc2);
    262273
    263                 vboxSvcClipboardClientWakeup(pClient);
     274                rc = vboxSvcClipboardClientWakeup(pClient);
     275                if (RT_SUCCESS(rc))
     276                {
     277                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     278                    rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     279                    if (RT_SUCCESS(rc))
     280                        SharedClipboardURITransferPayloadFree(pPayload);
     281                }
     282
     283                SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEvent);
    264284            }
    265285        }
    … …  
    267287    else
    268288        rc = VERR_NO_MEMORY;
    269 
    270     if (RT_SUCCESS(rc))
    271     {
    272         PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    273         rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_CLOSE,
    274                                                  30 * 1000 /* Timeout in ms */, &pPayload);
    275         if (RT_SUCCESS(rc))
    276             SharedClipboardURITransferPayloadFree(pPayload);
    277     }
    278289
    279290    LogFlowFuncLeaveRC(rc);
    … …  
    302313        if (RT_SUCCESS(rc))
    303314        {
    304             int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE);
     315            uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     316
     317            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
    305318            AssertRC(rc2);
    306319
    307             vboxSvcClipboardClientWakeup(pClient);
     320            rc = vboxSvcClipboardClientWakeup(pClient);
     321            if (RT_SUCCESS(rc))
     322            {
     323                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     324                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent,
     325                                                         pCtx->pTransfer->uTimeoutMs, &pPayload);
     326                if (RT_SUCCESS(rc))
     327                {
     328                    Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTHDR));
     329
     330                    *pListHdr = *(PVBOXCLIPBOARDLISTHDR)pPayload->pvData;
     331
     332                    SharedClipboardURITransferPayloadFree(pPayload);
     333                }
     334            }
    308335        }
    309336    }
    … …  
    311338        rc = VERR_NO_MEMORY;
    312339
    313     if (RT_SUCCESS(rc))
    314     {
    315         PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    316         rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE,
    317                                                  30 * 1000 /* Timeout in ms */, &pPayload);
    318         if (RT_SUCCESS(rc))
    319         {
    320             Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTHDR));
    321 
    322             *pListHdr = *(PVBOXCLIPBOARDLISTHDR)pPayload->pvData;
    323 
    324             SharedClipboardURITransferPayloadFree(pPayload);
    325         }
    326     }
    327 
    328340    LogFlowFuncLeaveRC(rc);
    329341    return rc;
    … …  
    351363
    352364    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ,
    353                                                             VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ_REQ);
     365                                                            VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
    354366    if (pMsg)
    355367    {
    356         HGCMSvcSetU32(&pMsg->m_paParms[0], 0 /* uContextID */);
     368        uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     369
     370        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    357371        HGCMSvcSetU64(&pMsg->m_paParms[1], hList);
    358372        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fInfo */);
    … …  
    361375        if (RT_SUCCESS(rc))
    362376        {
    363             int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE);
    364             if (rc2 == VERR_ALREADY_EXISTS)
    365                 rc2 = VINF_SUCCESS;
     377            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
    366378            AssertRC(rc2);
    367379
    368             vboxSvcClipboardClientWakeup(pClient);
     380            rc = vboxSvcClipboardClientWakeup(pClient);
     381            if (RT_SUCCESS(rc))
     382            {
     383                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     384                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     385                if (RT_SUCCESS(rc))
     386                {
     387                    Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTENTRY));
     388
     389                    rc = SharedClipboardURIListEntryCopy(pListEntry, (PVBOXCLIPBOARDLISTENTRY)pPayload->pvData);
     390
     391                    SharedClipboardURITransferPayloadFree(pPayload);
     392                }
     393            }
    369394        }
    370395    }
    … …  
    372397        rc = VERR_NO_MEMORY;
    373398
    374     if (RT_SUCCESS(rc))
    375     {
    376         PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    377         rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE,
    378                                                  30 * 1000 /* Timeout in ms */, &pPayload);
    379         if (RT_SUCCESS(rc))
    380         {
    381             Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTENTRY));
    382 
    383             rc = SharedClipboardURIListEntryCopy(pListEntry, (PVBOXCLIPBOARDLISTENTRY)pPayload->pvData);
    384 
    385             SharedClipboardURITransferPayloadFree(pPayload);
    386         }
    387     }
    388 
    389399    LogFlowFuncLeaveRC(rc);
    390400    return rc;
    … …  
    401411}
    402412
    403 int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const char *pszPath,
    404                                PVBOXCLIPBOARDCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj)
    405 {
    406     RT_NOREF(pCtx, pszPath, pCreateParms, phObj);
     413int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms,
     414                               PSHAREDCLIPBOARDOBJHANDLE phObj)
     415{
     416    RT_NOREF(pCtx, pCreateParms, phObj);
    407417
    408418    LogFlowFuncEnter();
    … …  
    413423    AssertPtr(pThisCtx);
    414424
     425    RT_NOREF(pThisCtx);
     426
    415427    LogFlowFuncLeaveRC(rc);
    416428    return rc;
    … …  
    427439    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
    428440    AssertPtr(pThisCtx);
     441
     442    RT_NOREF(pThisCtx);
    429443
    430444    LogFlowFuncLeaveRC(rc);
    … …  
    509523 * @param   pReply              Where to store the reply.
    510524 */
    511 int VBoxSvcClipboardURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    512                                 PVBOXCLIPBOARDREPLY pReply)
     525static int vboxSvcClipboardURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     526                                       PVBOXCLIPBOARDREPLY pReply)
    513527{
    514528    int rc;
    … …  
    518532        uint32_t cbPayload = 0;
    519533
    520         /* Note: Context ID (paParms[0]) not used yet. */
    521534        rc = HGCMSvcGetU32(&paParms[1], &pReply->uType);
    522535        if (RT_SUCCESS(rc))
    … …  
    569582
    570583/**
    571  * Gets the URI root entries from HGCM service parameters.
     584 * Gets an URI root list header from HGCM service parameters.
    572585 *
    573586 * @returns VBox status code.
    574587 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
    575588 * @param   paParms             Array of HGCM parameters.
    576  * @param   pRoots              Where to store the URI root entries on success.
    577  */
    578 int VBoxSvcClipboardURIGetRoots(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    579                                 PVBOXCLIPBOARDROOTS pRoots)
     589 * @param   pRootLstHdr         Where to store the URI root list header on success.
     590 */
     591static int vboxSvcClipboardURIGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     592                                             PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr)
    580593{
    581594    int rc;
    582595
    583     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOTS)
    584     {
    585         /* Note: Context ID (paParms[0]) not used yet. */
    586         rc = HGCMSvcGetU32(&paParms[1], &pRoots->fRoots);
    587         if (RT_SUCCESS(rc))
    588         {
    589             uint32_t fMore;
    590             rc = HGCMSvcGetU32(&paParms[2], &fMore);
    591             if (RT_SUCCESS(rc))
    592                 pRoots->fMore = RT_BOOL(fMore);
    593         }
    594         if (RT_SUCCESS(rc))
    595             rc = HGCMSvcGetU32(&paParms[3], &pRoots->cRoots);
    596         if (RT_SUCCESS(rc))
    597         {
    598             uint32_t cbRoots;
    599             rc = HGCMSvcGetU32(&paParms[4], &cbRoots);
    600             if (RT_SUCCESS(rc))
    601                 rc = HGCMSvcGetPv(&paParms[5], (void **)&pRoots->pszRoots, &pRoots->cbRoots);
    602 
    603             AssertReturn(cbRoots == pRoots->cbRoots, VERR_INVALID_PARAMETER);
     596    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR)
     597    {
     598        rc = HGCMSvcGetU32(&paParms[1], &pRootLstHdr->fRoots);
     599        if (RT_SUCCESS(rc))
     600            rc = HGCMSvcGetU32(&paParms[2], &pRootLstHdr->cRoots);
     601    }
     602    else
     603        rc = VERR_INVALID_PARAMETER;
     604
     605    LogFlowFuncLeaveRC(rc);
     606    return rc;
     607}
     608
     609/**
     610 * Gets an URI root list entry from HGCM service parameters.
     611 *
     612 * @returns VBox status code.
     613 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     614 * @param   paParms             Array of HGCM parameters.
     615 * @param   pListEntry          Where to store the root list entry.
     616 */
     617static int vboxSvcClipboardURIGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     618                                               PVBOXCLIPBOARDROOTLISTENTRY pListEntry)
     619{
     620    int rc;
     621
     622    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY)
     623    {
     624        rc = HGCMSvcGetU32(&paParms[1], &pListEntry->fInfo);
     625        /* Note: paParms[2] contains the entry index, currently being ignored. */
     626        if (RT_SUCCESS(rc))
     627            rc = HGCMSvcGetPv(&paParms[3], (void **)&pListEntry->pszName, &pListEntry->cbName);
     628        if (RT_SUCCESS(rc))
     629        {
     630            uint32_t cbInfo;
     631            rc = HGCMSvcGetU32(&paParms[4], &cbInfo);
     632            if (RT_SUCCESS(rc))
     633            {
     634                rc = HGCMSvcGetPv(&paParms[5], &pListEntry->pvInfo, &pListEntry->cbInfo);
     635                AssertReturn(cbInfo == pListEntry->cbInfo, VERR_INVALID_PARAMETER);
     636            }
    604637        }
    605638    }
    … …  
    619652 * @param   pOpenParms          Where to store the open parameters of the request.
    620653 */
    621 int VBoxSvcClipboardURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    622                                    PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
     654static int vboxSvcClipboardURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     655                                          PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
    623656{
    624657    int rc;
    … …  
    629662        uint32_t cbFilter = 0;
    630663
    631         /* Note: Context ID (paParms[0]) not used yet. */
    632664        rc = HGCMSvcGetU32(&paParms[1], &pOpenParms->fList);
    633665        if (RT_SUCCESS(rc))
    … …  
    666698 * @param   pOpenParms          List open parameters to set.
    667699 */
    668 int VBoxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    669                                    PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
     700static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     701                                          PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
    670702{
    671703    int rc;
    … …  
    698730 * @param   hList               Handle of list to close.
    699731 */
    700 int VBoxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    701                                     SHAREDCLIPBOARDLISTHANDLE hList)
     732static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     733                                           SHAREDCLIPBOARDLISTHANDLE hList)
    702734{
    703735    int rc;
    … …  
    726758 * @param   pListHdr            Where to store the list header.
    727759 */
    728 int VBoxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    729                                   PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr)
     760static int vboxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     761                                         PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr)
    730762{
    731763    int rc;
    … …  
    733765    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
    734766    {
    735         /* Note: Context ID (paParms[0]) not used yet. */
    736767        rc = HGCMSvcGetU64(&paParms[1], phList);
    737768        /* Note: Flags (paParms[2]) not used here. */
    … …  
    768799 * @param   pListHdr            Pointer to data to set to the HGCM parameters.
    769800 */
    770 int VBoxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTHDR pListHdr)
     801static int vboxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTHDR pListHdr)
    771802{
    772803    int rc;
    … …  
    804835 * @param   pListEntry          Where to store the list entry.
    805836 */
    806 int VBoxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    807                                     PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry)
     837static int vboxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     838                                           PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry)
    808839{
    809840    int rc;
    … …  
    811842    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
    812843    {
    813         /* Note: Context ID (paParms[0]) not used yet. */
    814844        rc = HGCMSvcGetU64(&paParms[1], phList);
    815845        if (RT_SUCCESS(rc))
    … …  
    849879 * @param   pListEntry          Pointer to data to set to the HGCM parameters.
    850880 */
    851 int VBoxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTENTRY pListEntry)
     881static int vboxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTENTRY pListEntry)
    852882{
    853883    int rc;
    … …  
    879909 * @param   pRc                 Where to store the received error code.
    880910 */
    881 int VBoxSvcClipboardURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
     911static int vboxSvcClipboardURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
    882912{
    883913    AssertPtrReturn(paParms, VERR_INVALID_PARAMETER);
    … …  
    888918    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ERROR)
    889919    {
    890         /* Note: Context ID (paParms[0]) not used yet. */
    891920        rc = HGCMSvcGetU32(&paParms[1], (uint32_t *)pRc); /** @todo int vs. uint32_t !!! */
    892921    }
    … …  
    907936 * @param   paParms             Array function parameters supplied.
    908937 */
    909 int VBoxSvcClipboardURITransferHandleReply(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer,
    910                                            uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     938static int vboxSvcClipboardURITransferHandleReply(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer,
     939                                                  uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    911940{
    912941    RT_NOREF(pClient);
    … …  
    918947    if (pReply)
    919948    {
    920         rc = VBoxSvcClipboardURIGetReply(cParms, paParms, pReply);
     949        rc = vboxSvcClipboardURIGetReply(cParms, paParms, pReply);
    921950        if (RT_SUCCESS(rc))
    922951        {
    … …  
    931960                {
    932961                    case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN:
    933                     {
    934                         rc = SharedClipboardURITransferEventSignal(pTransfer,
    935                                                                    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN, pPayload);
    936                         break;
    937                     }
    938 
     962                        RT_FALL_THROUGH();
    939963                    case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_CLOSE:
    940                     {
    941                         rc = SharedClipboardURITransferEventSignal(pTransfer,
    942                                                                    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_CLOSE, pPayload);
    943                         break;
    944                     }
    945 
     964                        RT_FALL_THROUGH();
    946965                    case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN:
    947                     {
    948                         rc = SharedClipboardURITransferEventSignal(pTransfer,
    949                                                                    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_OBJ_OPEN, pPayload);
    950                         break;
    951                     }
    952 
     966                        RT_FALL_THROUGH();
    953967                    case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE:
    954968                    {
    955                         rc = SharedClipboardURITransferEventSignal(pTransfer,
    956                                                                    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_OBJ_CLOSE, pPayload);
     969                        uint32_t uCID;
     970                        rc = HGCMSvcGetU32(&paParms[0], &uCID);
     971                        if (RT_SUCCESS(rc))
     972                        {
     973                            const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     974                            rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     975                        }
    957976                        break;
    958977                    }
    … …  
    10071026
    10081027    LogFlowFunc(("uClient=%RU32, u32Function=%RU32 (%s), cParms=%RU32, g_pfnExtension=%p\n",
    1009                  pClient->uClientID, u32Function, VBoxSvcClipboardGuestMsgToStr(u32Function), cParms, g_pfnExtension));
     1028                 pClient->uClientID, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, g_pfnExtension));
    10101029
    10111030    const PVBOXCLIPBOARDCLIENTDATA pClientData = pClient->pData;
    … …  
    11931212        case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY:
    11941213        {
    1195             rc = VBoxSvcClipboardURITransferHandleReply(pClient, pTransfer, cParms, paParms);
    1196             break;
    1197         }
    1198 
    1199         case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOTS:
    1200         {
    1201             VBOXCLIPBOARDROOTS Roots;
    1202             rc = VBoxSvcClipboardURIGetRoots(cParms, paParms, &Roots);
    1203             if (RT_SUCCESS(rc))
    1204             {
    1205                 void    *pvData = SharedClipboardURIRootsDup(&Roots);
    1206                 uint32_t cbData = sizeof(VBOXCLIPBOARDROOTS);
     1214            rc = vboxSvcClipboardURITransferHandleReply(pClient, pTransfer, cParms, paParms);
     1215            break;
     1216        }
     1217
     1218        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ:
     1219        {
     1220            break;
     1221        }
     1222
     1223        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE:
     1224        {
     1225            VBOXCLIPBOARDROOTLISTHDR lstHdr;
     1226            rc = vboxSvcClipboardURIGetRootListHdr(cParms, paParms, &lstHdr);
     1227            if (RT_SUCCESS(rc))
     1228            {
     1229                void    *pvData = SharedClipboardURIRootListHdrDup(&lstHdr);
     1230                uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTHDR);
     1231
     1232                uint32_t uCID;
     1233                rc = HGCMSvcGetU32(&paParms[0], &uCID);
     1234                if (RT_SUCCESS(rc))
     1235                {
     1236                    const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1237
     1238                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     1239                    rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1240                    if (RT_SUCCESS(rc))
     1241                        rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1242                }
     1243            }
     1244            break;
     1245        }
     1246
     1247        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ:
     1248        {
     1249    #if 0
     1250            VBOXCLIPBOARDROOTLISTENTRY lstEntry;
     1251            rc = VBoxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry);
     1252            if (RT_SUCCESS(rc))
     1253            {
     1254                void    *pvData = SharedClipboardURIRootListEntryDup(&lstEntry);
     1255                uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTENTRY);
    12071256
    12081257                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    1209                 rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS,
     1258                rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
    12101259                                                            pvData, cbData, &pPayload);
    12111260                if (RT_SUCCESS(rc))
    1212                     rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS,
     1261                    rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
    12131262                                                               pPayload);
    12141263            }
    12151264            break;
     1265    #endif
     1266        }
     1267
     1268        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
     1269        {
     1270            VBOXCLIPBOARDROOTLISTENTRY lstEntry;
     1271            rc = vboxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry);
     1272            if (RT_SUCCESS(rc))
     1273            {
     1274                void    *pvData = SharedClipboardURIRootListEntryDup(&lstEntry);
     1275                uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTENTRY);
     1276
     1277                uint32_t uCID;
     1278                rc = HGCMSvcGetU32(&paParms[0], &uCID);
     1279                if (RT_SUCCESS(rc))
     1280                {
     1281                    const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1282
     1283                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     1284                    rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1285                    if (RT_SUCCESS(rc))
     1286                        rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1287                }
     1288            }
     1289            break;
    12161290        }
    12171291
    … …  
    12191293        {
    12201294            VBOXCLIPBOARDLISTOPENPARMS listOpenParms;
    1221             rc = VBoxSvcClipboardURIGetListOpen(cParms, paParms, &listOpenParms);
     1295            rc = vboxSvcClipboardURIGetListOpen(cParms, paParms, &listOpenParms);
    12221296            if (RT_SUCCESS(rc))
    12231297            {
    … …  
    12391313
    12401314            SHAREDCLIPBOARDLISTHANDLE hList;
    1241             /* Note: Context ID (paParms[0]) not used yet. */
    12421315            rc = HGCMSvcGetU64(&paParms[1], &hList);
    12431316            if (RT_SUCCESS(rc))
    … …  
    12541327
    12551328            SHAREDCLIPBOARDLISTHANDLE hList;
    1256             /* Note: Context ID (paParms[0]) not used yet. */
    12571329            rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */
    12581330            if (RT_SUCCESS(rc))
    … …  
    12611333                rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
    12621334                if (RT_SUCCESS(rc))
    1263                     rc = VBoxSvcClipboardURISetListHdr(cParms, paParms, &hdrList);
     1335                    rc = vboxSvcClipboardURISetListHdr(cParms, paParms, &hdrList);
    12641336            }
    12651337            break;
    … …  
    12731345            {
    12741346                SHAREDCLIPBOARDLISTHANDLE hList;
    1275                 rc = VBoxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList);
     1347                rc = vboxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList);
    12761348                if (RT_SUCCESS(rc))
    12771349                {
    … …  
    12791351                    uint32_t cbData = sizeof(VBOXCLIPBOARDLISTHDR);
    12801352
    1281                     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    1282                     rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE,
    1283                                                                 pvData, cbData, &pPayload);
     1353                    uint32_t uCID;
     1354                    rc = HGCMSvcGetU32(&paParms[0], &uCID);
    12841355                    if (RT_SUCCESS(rc))
    12851356                    {
    1286                         rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE,
    1287                                                                    pPayload);
     1357                        const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1358
     1359                        PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     1360                        rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1361                        if (RT_SUCCESS(rc))
     1362                            rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
    12881363                    }
    12891364                }
    … …  
    12981373
    12991374            SHAREDCLIPBOARDLISTHANDLE hList;
    1300             /* Note: Context ID (paParms[0]) not used yet. */
    13011375            rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */
    13021376            if (RT_SUCCESS(rc))
    … …  
    13151389            {
    13161390                SHAREDCLIPBOARDLISTHANDLE hList;
    1317                 rc = VBoxSvcClipboardURIGetListEntry(cParms, paParms, &hList, &entryList);
     1391                rc = vboxSvcClipboardURIGetListEntry(cParms, paParms, &hList, &entryList);
    13181392                if (RT_SUCCESS(rc))
    13191393                {
    … …  
    13211395                    uint32_t cbData = sizeof(VBOXCLIPBOARDLISTENTRY);
    13221396
    1323                     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    1324                     rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE,
    1325                                                                 pvData, cbData, &pPayload);
     1397                    uint32_t uCID;
     1398                    rc = HGCMSvcGetU32(&paParms[0], &uCID);
    13261399                    if (RT_SUCCESS(rc))
    13271400                    {
    1328                         rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE,
    1329                                                                    pPayload);
     1401                        const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1402
     1403                        PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     1404                        rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1405                        if (RT_SUCCESS(rc))
     1406                            rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
    13301407                    }
    1331 
    13321408                }
    13331409            }
    … …  
    15141590        {
    15151591            int rcGuest;
    1516             rc = VBoxSvcClipboardURIGetError(cParms,paParms, &rcGuest);
     1592            rc = vboxSvcClipboardURIGetError(cParms,paParms, &rcGuest);
    15171593            if (RT_SUCCESS(rc))
    15181594                LogRel(("Shared Clipboard: Transfer error: %Rrc\n", rcGuest));
    … …  
    15811657int vboxSvcClipboardURIAreaRegister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
    15821658{
     1659    RT_NOREF(pClientState);
     1660
    15831661    LogFlowFuncEnter();
    15841662
    … …  
    16281706int vboxSvcClipboardURIAreaUnregister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
    16291707{
     1708    RT_NOREF(pClientState);
     1709
    16301710    LogFlowFuncEnter();
    16311711
    … …  
    16751755                                  SHAREDCLIPBOARDAREAID uID)
    16761756{
     1757    RT_NOREF(pClientState);
     1758
    16771759    LogFlowFuncEnter();
    16781760
    … …  
    17201802int vboxSvcClipboardURIAreaDetach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
    17211803{
     1804    RT_NOREF(pClientState);
     1805
    17221806    LogFlowFuncEnter();
    17231807

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

    r79630 r80283  
    143143    }
    144144
    145 #if 1
    146     int rc = 0;
    147 #else
    148     /* Sanity. */
    149     Assert(pTransfer->State.enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ);
    150 
    151     int rc;
    152 
    153     /* Note: Message priority / order is taken into account here. */
    154     if (pTransfer->State.pHeader)
    155     {
    156         LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_HDR\n"));
    157         rc = VBoxSvcClipboardURIWriteListHdr(cParms, paParms, pTransfer->State.pHeader);
    158         if (RT_SUCCESS(rc))
    159         {
    160             /* We're done witht the data header, destroy it. */
    161             SharedClipboardURIListHdrFree(pTransfer->State.pHeader);
    162             pTransfer->State.pHeader = NULL;
    163 
    164             fHandled = true;
    165         }
    166     }
    167     else if (pTransfer->State.pMeta)
    168     {
    169         LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_CHUNK\n"));
    170 
    171         uint32_t cbBuf = _64K;
    172         uint8_t  pvBuf[_64K]; /** @todo Improve */
    173 
    174         uint32_t cbRead;
    175         rc = SharedClipboardMetaDataRead(pTransfer->State.pMeta, pvBuf, cbBuf, &cbRead);
    176         if (RT_SUCCESS(rc))
    177         {
    178             Assert(cbRead <= cbBuf);
    179 
    180             VBOXCLIPBOARDListEntry ListEntry;
    181             RT_ZERO(ListEntry);
    182             ListEntry.pvData = pvBuf;
    183             ListEntry.cbData = cbRead;
    184 
    185             rc = VBoxSvcClipboardURIWriteListEntry(cParms, paParms, &ListEntry);
    186         }
    187 
    188         /* Has all meta data been read? */
    189         if (RT_SUCCESS(rc))
    190         {
    191             if (SharedClipboardMetaDataGetUsed(pTransfer->State.pMeta) == 0)
    192             {
    193                 SharedClipboardMetaDataFree(pTransfer->State.pMeta);
    194                 pTransfer->State.pMeta = NULL;
    195             }
    196 
    197             fHandled = true;
    198         }
    199     }
    200     else if (pTransfer->pURIList)
    201     {
    202         PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer);
    203         if (!SharedClipboardURIObjCtxIsValid(pObjCtx))
    204         {
    205             if (!pTransfer->pURIList->IsEmpty())
    206                 pObjCtx->pObj = pTransfer->pURIList->First();
    207         }
    208 
    209         if (   pObjCtx
    210             && pObjCtx->pObj)
    211         {
    212             switch (pObjCtx->pObj->GetType())
    213             {
    214                 case SharedClipboardURIObject::Type_Directory:
    215                 {
    216                     rc = VBoxSvcClipboardURIWriteDir(cParms, paParms, &ListEntry);
    217                     break;
    218                 }
    219             }
    220         }
    221 
    222         if (0)
    223         {
    224             delete pTransfer->pURIList;
    225             pTransfer->pURIList = NULL;
    226         }
    227 
    228         fHandled = true;
    229     }
    230     else
    231         rc = VERR_WRONG_ORDER;
    232 #endif
    233 
    234     LogFlowFunc(("rc=%Rrc, fHandled=%RTbool\n", rc, fHandled));
     145    LogFlowFunc(("fHandled=%RTbool\n", fHandled));
    235146    return fHandled;
    236147}

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

    r79705 r80283  
    177177
    178178#include <VBox/AssertGuest.h>
     179#include <VBox/GuestHost/clipboard-helper.h>
    179180#include <VBox/HostServices/Service.h>
    180181#include <VBox/HostServices/VBoxClipboardSvc.h>
    … …  
    471472            vboxSvcClipboardMsgSetPeekReturn(pFirstMsg, paParms, cParms);
    472473            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
    473                          pClient->uClientID, pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg),
     474                         pClient->uClientID, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg),
    474475                         pFirstMsg->m_cParms));
    475476            return VINF_SUCCESS;
    … …  
    535536        {
    536537            LogFlowFunc(("First message is: %RU32 %s (%RU32 parms)\n",
    537                          pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms));
     538                         pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms));
    538539
    539540            ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_uMsg == idMsgExpected || idMsgExpected == UINT32_MAX,
    540541                                    ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
    541                                      pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,
    542                                      idMsgExpected, VBoxSvcClipboardHostMsgToStr(idMsgExpected), cParms),
     542                                     pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,
     543                                     idMsgExpected, VBoxClipboardHostMsgToStr(idMsgExpected), cParms),
    543544                                    VERR_MISMATCH);
    544545            ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_cParms == cParms,
    545546                                    ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
    546                                      pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,
    547                                      idMsgExpected, VBoxSvcClipboardHostMsgToStr(idMsgExpected), cParms),
     547                                     pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,
     548                                     idMsgExpected, VBoxClipboardHostMsgToStr(idMsgExpected), cParms),
    548549                                    VERR_WRONG_PARAMETER_COUNT);
    549550
    … …  
    552553                ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_paParms[i].type == paParms[i].type,
    553554                                        ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->m_paParms[i].type,
    554                                          paParms[i].type, pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg)),
     555                                         paParms[i].type, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg)),
    555556                                        VERR_WRONG_PARAMETER_TYPE);
    556557            /*
Note: See TracChangeset for help on using the changeset viewer.

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