VirtualBox

Changeset 79630 in vbox


Ignore:
Timestamp:
Jul 9, 2019 8:14:01 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
131932
Message:

Shared Clipboard/URI: Update.

Location:
trunk
Files:
16 edited

Legend:

Unmodified
Added
Removed

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

    r79497 r79630  
    4848
    4949/** A Shared Clipboard list handle. */
    50 typedef uint64_t VBOXCLIPBOARDLISTHANDLE;
     50typedef uint64_t SHAREDCLIPBOARDLISTHANDLE;
    5151/** Pointer to a Shared Clipboard list handle. */
    52 typedef VBOXCLIPBOARDLISTHANDLE *PVBOXCLIPBOARDLISTHANDLE;
     52typedef SHAREDCLIPBOARDLISTHANDLE *PSHAREDCLIPBOARDLISTHANDLE;
    5353
    5454/** Specifies an invalid Shared Clipboard list handle. */
    … …  
    546546
    547547/**
    548  * Structure for a Shared Clipboard list header.
     548 * Structure for keeping a reply message.
     549 */
     550typedef struct _VBOXCLIPBOARDREPLY
     551{
     552    /** Message type of type VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_XXX. */
     553    uint32_t uType;
     554    /** IPRT result of overall operation. Note: int vs. uint32! */
     555    uint32_t rc;
     556    union
     557    {
     558        struct
     559        {
     560            SHAREDCLIPBOARDLISTHANDLE uHandle;
     561        } ListOpen;
     562        struct
     563        {
     564            SHAREDCLIPBOARDOBJHANDLE uHandle;
     565        } ObjOpen;
     566    } u;
     567    /** Pointer to optional payload. */
     568    void    *pvPayload;
     569    /** Payload size (in bytes). */
     570    uint32_t cbPayload;
     571} VBOXCLIPBOARDREPLY, *PVBOXCLIPBOARDREPLY;
     572
     573/**
     574 * Structure for maintaining Shared Clipboard list open paramters.
     575 */
     576typedef struct _VBOXCLIPBOARDLISTOPENPARMS
     577{
     578    /** Listing flags (see VBOX_SHAREDCLIPBOARD_LIST_FLAG_XXX). */
     579    uint32_t fList;
     580    /** Size (in bytes) of the filter string. */
     581    uint32_t cbFilter;
     582    /** Filter string. DOS wilcard-style. */
     583    char    *pszFilter;
     584    /** Size (in bytes) of the listing path. */
     585    uint32_t cbPath;
     586    /** Listing path (absolute). If empty or NULL the listing's root path will be opened. */
     587    char    *pszPath;
     588} VBOXCLIPBOARDLISTOPENPARMS, *PVBOXCLIPBOARDLISTOPENPARMS;
     589
     590/**
     591 * Structure for keeping a Shared Clipboard list header.
    549592 */
    550593typedef struct _VBOXCLIPBOARDLISTHDR
    551594{
    552     uint32_t fList;                 /* IN */
    553     uint32_t cbFilter;              /* IN */
    554     char    *pszFilter;             /* IN */
    555     uint32_t fFeatures;             /* OUT */
    556     uint64_t cTotalObjects;         /* OUT */
    557     uint64_t cbTotalSize;           /* OUT */
    558     uint32_t enmCompression;        /* IN / OUT */
    559     uint32_t enmChecksumType;       /* IN / OUT */
     595    /** Feature flag(s). Not being used atm. */
     596    uint32_t fFeatures;
     597    /** Total objects returned. */
     598    uint64_t cTotalObjects;
     599    /** Total size (in bytes) returned. */
     600    uint64_t cbTotalSize;
     601    /** Compression being method used. Not implemented yet. */
     602    uint32_t enmCompression;
     603    /** Checksum type being used. Not implemented yet. */
     604    uint32_t enmChecksumType;
    560605} VBOXCLIPBOARDLISTHDR, *PVBOXCLIPBOARDLISTHDR;
    561606
    … …  
    565610typedef struct _VBOXCLIPBOARDLISTENTRY
    566611{
     612    /** Information flag(s). */
    567613    uint32_t fInfo;
     614    /** Size (in bytes) of the actual list entry. */
    568615    uint32_t cbInfo;
     616    /** Data of the actual list entry. */
    569617    void    *pvInfo;
    570618} VBOXCLIPBOARDLISTENTRY, *PVBOXCLIPBOARDLISTENTRY;
    … …  
    575623typedef struct _VBOXCLIPBOARDOBJHDR
    576624{
    577     uint32_t                    enmType;
     625    /** Header type. Currently not being used. */
     626    uint32_t enmType;
    578627} VBOXCLIPBOARDOBJHDR, *PVBOXCLIPBOARDOBJHDR;
    579628
    … …  
    589638    /** Object is a file. */
    590639    SHAREDCLIPBOARDAREAOBJTYPE_FILE,
     640    /** Object is a symbolic link. */
     641    SHAREDCLIPBOARDAREAOBJTYPE_SYMLINK,
    591642    /** The usual 32-bit hack. */
    592     SHAREDCLIPBOARDAREAOBJTYPE__32Bit_Hack = 0x7fffffff
     643    SHAREDCLIPBOARDAREAOBJTYPE_32Bit_Hack = 0x7fffffff
    593644} SHAREDCLIPBOARDAREAOBJTYPE;
    594645
    … …  
    771822bool SharedClipboardURIListHdrIsValid(PVBOXCLIPBOARDLISTHDR pListHdr);
    772823
     824int SharedClipboardURIListOpenParmsCopy(PVBOXCLIPBOARDLISTOPENPARMS pDst, PVBOXCLIPBOARDLISTOPENPARMS pSrc);
     825PVBOXCLIPBOARDLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PVBOXCLIPBOARDLISTOPENPARMS pParms);
     826int SharedClipboardURIListOpenParmsInit(PVBOXCLIPBOARDLISTOPENPARMS pParms);
     827void SharedClipboardURIListOpenParmsDestroy(PVBOXCLIPBOARDLISTOPENPARMS pParms);
     828
    773829int SharedClipboardURIListEntryAlloc(PVBOXCLIPBOARDLISTENTRY *ppListEntry);
    774830void SharedClipboardURIListEntryFree(PVBOXCLIPBOARDLISTENTRY pListEntry);
     831int SharedClipboardURIListEntryCopy(PVBOXCLIPBOARDLISTENTRY pDst, PVBOXCLIPBOARDLISTENTRY pSrc);
    775832PVBOXCLIPBOARDLISTENTRY SharedClipboardURIListEntryDup(PVBOXCLIPBOARDLISTENTRY pListEntry);
    776833int SharedClipboardURIListEntryInit(PVBOXCLIPBOARDLISTENTRY pListEntry);
    … …  
    803860    SHAREDCLIPBOARDURITRANSFER *pTransfer;
    804861    SHAREDCLIPBOARDOBJHANDLE    uHandle;
    805     SHAREDCLIPBOARDFSOBJINFO   *pObjInfo;
     862} SHAREDCLIPBOARDCLIENTURIOBJCTX, *PSHAREDCLIPBOARDCLIENTURIOBJCTX;
     863
     864typedef struct _SHAREDCLIPBOARDURITRANSFEROBJSTATE
     865{
    806866    uint64_t                    cbProcessed;
    807 } SHAREDCLIPBOARDCLIENTURIOBJCTX, *PSHAREDCLIPBOARDCLIENTURIOBJCTX;
    808 
    809 /**
    810  * Enumeration specifying an URI transfer status.
    811  */
    812 typedef enum _SHAREDCLIPBOARDURITRANSFERSTATUS
    813 {
    814     /** No status set. */
    815     SHAREDCLIPBOARDURITRANSFERSTATUS_NONE = 0,
    816     /** The transfer has been announced but is not running yet. */
    817     SHAREDCLIPBOARDURITRANSFERSTATUS_READY,
    818     /** The transfer is active and running. */
    819     SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING,
    820     /** The usual 32-bit hack. */
    821     SHAREDCLIPBOARDURITRANSFERSTATUS_32BIT_HACK = 0x7fffffff
    822 } SHAREDCLIPBOARDURITRANSFERSTATUS;
    823 
     867} SHAREDCLIPBOARDURITRANSFEROBJSTATE, *PSHAREDCLIPBOARDURITRANSFEROBJSTATE;
     868
     869typedef struct _SHAREDCLIPBOARDURITRANSFEROBJ
     870{
     871    SHAREDCLIPBOARDOBJHANDLE           uHandle;
     872    char                              *pszPathAbs;
     873    SHAREDCLIPBOARDFSOBJINFO           objInfo;
     874    SHAREDCLIPBOARDSOURCE              enmSource;
     875    SHAREDCLIPBOARDURITRANSFEROBJSTATE State;
     876} SHAREDCLIPBOARDURITRANSFEROBJ, *PSHAREDCLIPBOARDURITRANSFEROBJ;
     877
     878/** No status set. */
     879#define SHAREDCLIPBOARDURITRANSFERSTATUS_NONE           0
     880/** The transfer has been announced but is not running yet. */
     881#define SHAREDCLIPBOARDURITRANSFERSTATUS_READY          1
     882/** The transfer is active and running. */
     883#define SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING        2
     884/** The transfer has been completed. */
     885#define SHAREDCLIPBOARDURITRANSFERSTATUS_COMPLETED      3
     886/** The transfer has been canceled. */
     887#define SHAREDCLIPBOARDURITRANSFERSTATUS_CANCELED       4
     888/** The transfer ran into an unrecoverable error. */
     889#define SHAREDCLIPBOARDURITRANSFERSTATUS_ERROR          5
     890
     891/** Defines a transfer status. */
     892typedef uint32_t SHAREDCLIPBOARDURITRANSFERSTATUS;
     893
     894/**
     895 * Structure for an (optional) URI transfer event payload.
     896 */
    824897typedef struct _SHAREDCLIPBOARDURITRANSFERPAYLOAD
    825898{
     899    /** Payload ID; currently unused. */
    826900    uint32_t uID;
     901    /** Pointer to actual payload data. */
    827902    void    *pvData;
     903    /** Size (in bytes) of actual payload data. */
    828904    uint32_t cbData;
    829905} SHAREDCLIPBOARDURITRANSFERPAYLOAD, *PSHAREDCLIPBOARDURITRANSFERPAYLOAD;
    830906
     907/**
     908 * Structure for maintaining an URI transfer event.
     909 */
    831910typedef struct _SHAREDCLIPBOARDURITRANSFEREVENT
    832911{
     912    /** Event semaphore for signalling the event. */
    833913    RTSEMEVENT                         hEventSem;
     914    /** Payload to this event. Optional and can be NULL. */
    834915    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    835916} SHAREDCLIPBOARDURITRANSFEREVENT, *PSHAREDCLIPBOARDURITRANSFEREVENT;
    836917
     918/**
     919 * Enumeration for an URI transfer event type.
     920 */
    837921typedef enum _SHAREDCLIPBOARDURITRANSFEREVENTTYPE
    838922{
    839923    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_UNKNOWN,
     924    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN,
     925    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_CLOSE,
    840926    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_READ,
     927    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE,
    841928    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_READ,
    842     SHAREDCLIPBOARDURITRANSFEREVENTTYPE_FILE_DATA_READ,
     929    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE,
     930    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_FILE_OPEN,
     931    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_FILE_CLOSE,
     932    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_FILE_READ,
     933    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_FILE_WRITE,
     934    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ERROR,
    843935    /** Marks the end of the event list. */
    844936    SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LAST,
    … …  
    847939} SHAREDCLIPBOARDURITRANSFEREVENTTYPE;
    848940
     941/** Map of URI transfer events.
     942 *  The key specifies the event type of SHAREDCLIPBOARDURITRANSFEREVENTTYPE. */
    849943typedef std::map<uint32_t, SHAREDCLIPBOARDURITRANSFEREVENT *> SharedClipboardURITransferEventMap;
    850944
    851 typedef struct _SHAREDCLIPBOARDURITRANSFEREVENTS
    852 {
    853     SharedClipboardURITransferEventMap *pMap;
    854 } SHAREDCLIPBOARDURITRANSFEREVENTS, *PSHAREDCLIPBOARDURITRANSFEREVENTS;
     945typedef struct _SHAREDCLIPBOARDURILISTHANDLEINFO
     946{
     947    VBOXCLIPBOARDLISTOPENPARMS OpenParms;
     948    RTFMODE                     fMode;
     949    union
     950    {
     951        struct
     952        {
     953            union
     954            {
     955                RTDIR  hDirRoot;
     956                RTFILE hFile;
     957            };
     958        } Local;
     959    } u;
     960} SHAREDCLIPBOARDURILISTHANDLEINFO, *PSHAREDCLIPBOARDURILISTHANDLEINFO;
     961
     962typedef struct _SHAREDCLIPBOARDOBJHANDLEINFO
     963{
     964    union
     965    {
     966        struct
     967        {
     968            RTDIR hDirRoot;
     969        } Local;
     970    } u;
     971} SHAREDCLIPBOARDURIOBJHANDLEINFO, *PSHAREDCLIPBOARDURIOBJHANDLEINFO;
     972
     973/** Map of URI list handles.
     974 *  The key specifies the list handle. */
     975typedef std::map<SHAREDCLIPBOARDLISTHANDLE, SHAREDCLIPBOARDURILISTHANDLEINFO *> SharedClipboardURIListMap;
     976
     977typedef std::map<SHAREDCLIPBOARDOBJHANDLE, SHAREDCLIPBOARDURILISTHANDLEINFO *> SharedClipboardURIObjMap;
    855978
    856979/**
    … …  
    866989    /** The transfer's source. */
    867990    SHAREDCLIPBOARDSOURCE               enmSource;
    868     /** Context of current object being handled. */
    869     SHAREDCLIPBOARDCLIENTURIOBJCTX      ObjCtx;
    870991} SHAREDCLIPBOARDURITRANSFERSTATE, *PSHAREDCLIPBOARDURITRANSFERSTATE;
    871992
    … …  
    8901011    typedef RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDPROVIDER, a_Name);
    8911012
     1013/** Defines an URI clipboard provider function declaration with additional parameters. */
     1014#define SHAREDCLIPBOARDPROVIDERFUNCDECLRET(a_Ret, a_Name, ...) \
     1015    typedef DECLCALLBACK(a_Ret) RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name)(PSHAREDCLIPBOARDPROVIDERCTX, __VA_ARGS__); \
     1016    typedef RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDPROVIDER, a_Name);
     1017
    8921018/** Defines an URI clipboard provider function declaration (no additional parameters). */
    8931019#define SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(a_Name) \
    … …  
    9011027SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(TRANSFEROPEN)
    9021028SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(TRANSFERCLOSE)
    903 SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTOPEN, PVBOXCLIPBOARDLISTHDR pListHdr, PVBOXCLIPBOARDLISTHANDLE phList)
    904 SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTCLOSE, VBOXCLIPBOARDLISTHANDLE hList);
    905 SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTHDRREAD, VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
    906 SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTHDRWRITE, VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
    907 SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTENTRYREAD, VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pEntry)
    908 SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTENTRYWRITE, VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pEntry)
     1029SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTOPEN, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList)
     1030SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTCLOSE, SHAREDCLIPBOARDLISTHANDLE hList);
     1031SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTHDRREAD, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
     1032SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTHDRWRITE, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
     1033SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTENTRYREAD, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pEntry)
     1034SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTENTRYWRITE, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pEntry)
    9091035SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJOPEN, const char *pszPath, PVBOXCLIPBOARDCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj)
    9101036SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJCLOSE, SHAREDCLIPBOARDOBJHANDLE hObj)
    9111037SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJREAD, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    9121038SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJWRITE, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
     1039SHAREDCLIPBOARDPROVIDERFUNCDECLRET(uint64_t, OBJGETSIZE, SHAREDCLIPBOARDOBJHANDLE hObj)
     1040SHAREDCLIPBOARDPROVIDERFUNCDECLRET(uint64_t, OBJGETPROCESSED, SHAREDCLIPBOARDOBJHANDLE hObj)
     1041SHAREDCLIPBOARDPROVIDERFUNCDECLRET(const char *, OBJGETPATH, SHAREDCLIPBOARDOBJHANDLE hObj)
    9131042
    9141043/**
    … …  
    9191048    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(TRANSFEROPEN, pfnTransferOpen);
    9201049    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(TRANSFERCLOSE, pfnTransferClose);
    921     /** Optional. */
    9221050    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTOPEN, pfnListOpen);
    923     /** Optional. */
    9241051    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTCLOSE, pfnListClose);
    9251052    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTHDRREAD, pfnListHdrRead);
    … …  
    9311058    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJREAD, pfnObjRead);
    9321059    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJWRITE, pfnObjWrite);
     1060    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJGETSIZE, pfnObjGetSize);
     1061    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJGETPROCESSED, pfnObjGetProcessed);
     1062    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJGETPATH, pfnObjGetPath);
    9331063} SHAREDCLIPBOARDPROVIDERINTERFACE, *PSHAREDCLIPBOARDPROVIDERINTERFACE;
    9341064
    … …  
    10321162    /** The transfer's state (for SSM, later). */
    10331163    SHAREDCLIPBOARDURITRANSFERSTATE     State;
    1034     SHAREDCLIPBOARDURITRANSFEREVENTS    Events;
     1164    /** Events related to this transfer. */
     1165    SharedClipboardURITransferEventMap *pMapEvents;
     1166    SharedClipboardURIListMap          *pMapLists;
     1167    SharedClipboardURIObjMap           *pMapObj;
    10351168    /** The transfer's own (local) area, if any (can be NULL if not needed).
    10361169     *  The area itself has a clipboard area ID assigned.
    10371170     *  On the host this area ID gets shared (maintained / locked) across all VMs via VBoxSVC. */
    10381171    SharedClipboardArea                *pArea;
    1039     /** The URI list for this transfer. */
    1040     SharedClipboardURIList             *pURIList;
    10411172    SHAREDCLIPBOARDPROVIDERCTX          ProviderCtx;
    10421173    /** The transfer's provider interface. */
    … …  
    10821213int SharedClipboardURITransferClose(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    10831214
    1084 int SharedClipboardURITransferListOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDLISTHDR pListHdr,
    1085                                        PVBOXCLIPBOARDLISTHANDLE phList);
    1086 int SharedClipboardURITransferListClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, VBOXCLIPBOARDLISTHANDLE hList);
    1087 int SharedClipboardURITransferListRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, VBOXCLIPBOARDLISTHANDLE hList,
     1215int SharedClipboardURITransferListOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms,
     1216                                       PSHAREDCLIPBOARDLISTHANDLE phList);
     1217int SharedClipboardURITransferListClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList);
     1218int SharedClipboardURITransferListGetHeader(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
     1219                                            PVBOXCLIPBOARDLISTHDR pHdr);
     1220PSHAREDCLIPBOARDURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHAREDCLIPBOARDURITRANSFER pTransfer,
     1221                                                                    SHAREDCLIPBOARDLISTHANDLE hList, uint64_t uIdx);
     1222int SharedClipboardURITransferListRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
    10881223                                       PVBOXCLIPBOARDLISTENTRY pEntry);
    1089 int SharedClipboardURITransferListWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, VBOXCLIPBOARDLISTHANDLE hList,
     1224int SharedClipboardURITransferListWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
    10901225                                        PVBOXCLIPBOARDLISTENTRY pEntry);
    1091 bool SharedClipboardURITransferListHandleIsValid(PSHAREDCLIPBOARDURITRANSFER pTransfer, VBOXCLIPBOARDLISTHANDLE hList);
     1226bool SharedClipboardURITransferListHandleIsValid(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList);
    10921227
    10931228int SharedClipboardURITransferPrepare(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    1094 int SharedClipboardURITransferProviderCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer,
    1095                                              PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx);
     1229int SharedClipboardURITransferSetInterface(PSHAREDCLIPBOARDURITRANSFER pTransfer,
     1230                                           PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx);
    10961231void SharedClipboardURITransferReset(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    10971232SharedClipboardArea *SharedClipboardURITransferGetArea(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    1098 PSHAREDCLIPBOARDCLIENTURIOBJCTX SharedClipboardURITransferGetCurrentObjCtx(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    1099 const SharedClipboardURIObject *SharedClipboardURITransferGetCurrentObject(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    1100 SharedClipboardURIList *SharedClipboardURITransferGetList(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    1101 SharedClipboardURIObject *SharedClipboardURITransferGetObject(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint64_t uIdx);
    11021233SHAREDCLIPBOARDSOURCE SharedClipboardURITransferGetSource(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    11031234SHAREDCLIPBOARDURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHAREDCLIPBOARDURITRANSFER pTransfer);
     1235int SharedClipboardURITransferHandleReply(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDREPLY pReply);
    11041236int SharedClipboardURITransferRun(PSHAREDCLIPBOARDURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
    11051237void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer,

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

    r79497 r79630  
    287287
    288288    VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent,
    289                                PSHAREDCLIPBOARDURITRANSFER pTransfer, uint64_t uObjIdx);
     289                               PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj);
    290290    virtual ~VBoxClipboardWinStreamImpl(void);
    291291
    … …  
    318318
    319319    /** Pointer to the parent data object. */
    320     VBoxClipboardWinDataObject *m_pParent;
     320    VBoxClipboardWinDataObject    *m_pParent;
    321321    /** The stream object's current reference count. */
    322     LONG                        m_lRefCount;
    323     /** Pointer to the associated URI transfer object. */
    324     PSHAREDCLIPBOARDURITRANSFER m_pURITransfer;
    325     /** Index of the object to handle within the associated URI transfer object. */
    326     uint64_t                    m_uObjIdx;
     322    LONG                           m_lRefCount;
     323    /** Pointer to the associated URI transfer. */
     324    PSHAREDCLIPBOARDURITRANSFER    m_pURITransfer;
     325    /** Handle to the associated URI object. */
     326    SHAREDCLIPBOARDOBJHANDLE       m_hObj;
    327327};
    328328

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

    r79497 r79630  
    5858#define VBOX_SHARED_CLIPBOARD_FMT_URI_LIST      UINT32_C(0x08)
    5959#endif
    60 
    61 /**
    62  * The host messages for the guest.
    63  */
    64 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT                   1
    65 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA              2
    66 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS         3
    67 
    68 /** Initiates a new transfer (read / write) on the guest side. */
    69 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START     4
    70 /** Open an URI list on the guest side. */
    71 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN          5
    72 /** Closes a formerly opened URI list on the guest side. */
    73 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE         6
    74 /** Reads a list header from the guest. */
    75 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ      7
    76 /** Writes a list header to the guest. */
    77 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE     8
    78 /** Reads a list entry from the guest. */
    79 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ    9
    80 /** Writes a list entry to the guest. */
    81 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE   10
    82 /** Open an URI object on the guest side. */
    83 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN           11
    84 /** Closes a formerly opened URI object on the guest side. */
    85 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE          12
    86 /** Reads from an object on the guest side. */
    87 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ           13
    88 /** Writes to an object on the guest side. */
    89 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE          14
    90 /** Indicates that the host has canceled a transfer. */
    91 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_CANCEL             15
    92 /** Indicates that the an unrecoverable error on the host occurred . */
    93 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ERROR              16
    9460
    9561/**

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

    r79497 r79630  
    6666#define VBOX_SHARED_CLIPBOARD_HOST_FN_AREA_DETACH        8
    6767
     68/**
     69 * The host messages for the guest.
     70 */
     71#define VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT                   1
     72#define VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA              2
     73#define VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS         3
     74
     75/** Initiates a new transfer (read / write) on the guest side. */
     76#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START     50
     77/** Open an URI list on the guest side. */
     78#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN          51
     79/** Closes a formerly opened URI list on the guest side. */
     80#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE         52
     81/** Reads a list header from the guest. */
     82#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ      53
     83/** Writes a list header to the guest. */
     84#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE     54
     85/** Reads a list entry from the guest. */
     86#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ    55
     87/** Writes a list entry to the guest. */
     88#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE   56
     89/** Open an URI object on the guest side. */
     90#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN           57
     91/** Closes a formerly opened URI object on the guest side. */
     92#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE          58
     93/** Reads from an object on the guest side. */
     94#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ           59
     95/** Writes to an object on the guest side. */
     96#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE          60
     97/** Indicates that the host has canceled a transfer. */
     98#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_CANCEL             61
     99/** Indicates that the an unrecoverable error on the host occurred . */
     100#define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ERROR              62
     101
    68102/*
    69103 * The service functions which are called by guest.
    … …  
    80114#define VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA        4
    81115
    82 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_TRANSFER_REPORT   5
    83 /** New message for getting the next message from the host (see VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD).
    84  *  New since URI handling was implemented. */
    85 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG      6
     116/** Peeks at the next message, returning immediately.
     117 *  New since URI handling was implemented. */
     118#define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT   5
     119/** Peeks at the next message, waiting for one to arrive.
     120 *  New since URI handling was implemented. */
     121#define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT     6
     122/** Gets the next message, returning immediately.
     123 *  New since URI handling was implemented. */
     124#define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET           7
     125/** Sends a transfer status to the host.
     126 *  New since URI handling was implemented. */
     127#define VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS            8
     128/** Replies to a function from the host.
     129 *  New since URI handling was implemented. */
     130#define VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY             9
    86131/** Opens / gets a list handle from the host.
    87132 *  New since URI handling was implemented. */
    88 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN         7
     133#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN         10
    89134/** Closes a list handle from the host.
    90135 *  New since URI handling was implemented. */
    91 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE        8
     136#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE        11
    92137/** Reads a list header from the host.
    93138 *  New since URI handling was implemented. */
    94 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ     9
     139#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ     12
    95140/** Writes a list header to the host.
    96141 *  New since URI handling was implemented. */
    97 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE    10
     142#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE    13
    98143/** New since URI handling was implemented. */
    99 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ   11
     144#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ   14
    100145/** New since URI handling was implemented. */
    101 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE  12
     146#define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE  15
    102147/** New since URI handling was implemented. */
    103 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN          13
     148#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN          16
    104149/** New since URI handling was implemented. */
    105 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE         14
     150#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE         17
    106151/** New since URI handling was implemented. */
    107 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ          15
     152#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ          18
    108153/**  New since URI handling was implemented. */
    109 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE         16
     154#define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE         19
    110155/** Reports cancellation of the current operation to the host.
    111156 *  New since URI handling was implemented. */
    112 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL            17
     157#define VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL            20
    113158/** Reports an error to the host.
    114159 *  New since URI handling was implemented. */
    115 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR             18
     160#define VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR             21
     161
     162/**
     163 * Translates a Shared Clipboard host message enum to a string.
     164 *
     165 * @returns Message ID string name.
     166 * @param   uMsg                The message to translate.
     167 */
     168DECLINLINE(const char *) VBoxSvcClipboardHostMsgToStr(uint32_t uMsg)
     169{
     170    switch (uMsg)
     171    {
     172        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
     173        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
     174        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS);
     175        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START);
     176        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN);
     177        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE);
     178        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ);
     179        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE);
     180        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ);
     181        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE);
     182        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN);
     183        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE);
     184        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ);
     185        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE);
     186        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_CANCEL);
     187        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ERROR);
     188    }
     189    return "Unknown";
     190}
     191
     192/**
     193 * Translates a Shared Clipboard guest message enum to a string.
     194 *
     195 * @returns Message ID string name.
     196 * @param   uMsg                The message to translate.
     197 */
     198DECLINLINE(const char *) VBoxSvcClipboardGuestMsgToStr(uint32_t uMsg)
     199{
     200    switch (uMsg)
     201    {
     202        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS);
     203        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA);
     204        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA);
     205        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT);
     206        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT);
     207        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET);
     208        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS);
     209        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY);
     210        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN);
     211        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE);
     212        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ);
     213        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE);
     214        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ);
     215        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE);
     216        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN);
     217        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE);
     218        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ);
     219        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE);
     220        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL);
     221        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR);
     222        RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
     223    }
     224    return "Unknown";
     225}
    116226
    117227/** The maximum default chunk size for a single data transfer. */
    … …  
    201311    VBGLIOCHGCMCALL hdr;
    202312
    203     /** Message ID. */
    204     HGCMFunctionParameter uMsg;      /* OUT uint32_t */
    205     /** Number of parameters the message needs. */
    206     HGCMFunctionParameter cParms;    /* OUT uint32_t */
    207     /** Whether or not to block (wait) for a
    208      *  new message to arrive. */
    209     HGCMFunctionParameter fBlock;    /* OUT uint32_t */
    210 } VBoxClipboardGetHostMsg;
     313    /** uint32_t, out: Message ID. */
     314    HGCMFunctionParameter uMsg;
     315    /** uint32_t, out: Number of parameters the message needs. */
     316    HGCMFunctionParameter cParms;
     317    /** uint32_t, in: Whether or not to block (wait) for a  new message to arrive. */
     318    HGCMFunctionParameter fBlock;
     319} VBoxClipboardPeekMsg;
    211320
    212321#define VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG 3
    … …  
    217326#define VBOX_SHAREDCLIPBOARD_LIST_FLAG_RESTART       RT_BIT(1)
    218327
    219 #define VBOX_SHAREDCLIPBOARD_INFO_FLAG_NONE         0
     328#define VBOX_SHAREDCLIPBOARD_LISTHDR_FLAG_NONE       0
     329
     330#define VBOX_SHAREDCLIPBOARD_INFO_FLAG_NONE          0
    220331/** Get object information of type SHAREDCLIPBOARDFSOBJINFO. */
    221332#define VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO     RT_BIT(0)
    222333
    223334/**
     335 * Transfert status message.
     336 */
     337typedef struct _VBoxClipboardStatusMsg
     338{
     339    VBGLIOCHGCMCALL hdr;
     340
     341    /** uint32_t, in: Context ID. Unused at the moment. */
     342    HGCMFunctionParameter uContext;
     343    /** uint32_t, in: Transfer status of type SHAREDCLIPBOARDURITRANSFERSTATUS. */
     344    HGCMFunctionParameter uStatus;
     345    /** uint32_t, in: Size of payload of this status, based on the status type. */
     346    HGCMFunctionParameter cbPayload;
     347    /** pointer, in: Optional payload of this status, based on the status type. */
     348    HGCMFunctionParameter pvPayload;
     349} VBoxClipboardStatusMsg;
     350
     351#define VBOX_SHARED_CLIPBOARD_CPARMS_STATUS 4
     352
     353#define VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_INVALID           0
     354#define VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN         1
     355#define VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN          2
     356
     357/**
     358 * Generic reply message.
     359 */
     360typedef struct _VBoxClipboardReplyMsg
     361{
     362    VBGLIOCHGCMCALL hdr;
     363
     364    /** uint32_t, in: Context ID. Unused at the moment. */
     365    HGCMFunctionParameter uContext;
     366    /** uint32_t, in: Message type of type VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_XXX. */
     367    HGCMFunctionParameter enmType;
     368    /** uint32_t, in: IPRT result of overall operation. */
     369    HGCMFunctionParameter rc;
     370    /** uint32_t, in: Size of optional payload of this reply, based on the message type. */
     371    HGCMFunctionParameter cbPayload;
     372    /** pointer, in: Optional payload of this reply, based on the message type. */
     373    HGCMFunctionParameter pvPayload;
     374    union
     375    {
     376        struct
     377        {
     378            HGCMFunctionParameter uHandle;
     379        } ListOpen;
     380        struct
     381        {
     382            HGCMFunctionParameter uHandle;
     383        } ObjOpen;
     384    } u;
     385} VBoxClipboardReplyMsg;
     386
     387#define VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN 5
     388
     389/**
    224390 * Opens a list.
    225  *
    226  * Used by:
    227  * VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN
    228391 */
    229392typedef struct _VBoxClipboardListOpenMsg
    … …  
    231394    VBGLIOCHGCMCALL hdr;
    232395
    233     /** uint32_t, in/out: Context ID. Unused at the moment. */
    234     HGCMFunctionParameter uContext;
    235     /** uint64_t, out: List handle. */
    236     HGCMFunctionParameter uHandle;
    237     /** uint32_t, in/out: Listing flags (see VBOX_SHAREDCLIPBOARD_LIST_FLAG_XXX). */
     396    /** uint32_t, in: Context ID. Unused at the moment. */
     397    HGCMFunctionParameter uContext;
     398    /** uint32_t, in: Listing flags (see VBOX_SHAREDCLIPBOARD_LIST_FLAG_XXX). */
    238399    HGCMFunctionParameter fList;
    239     /** uint32_t, in/out: Feature flags (see VBOX_SHAREDCLIPBOARD_FEATURE_FLAG_XXX). */
    240     HGCMFunctionParameter fFeatures;
    241400    /** uint32_t, in: Size (in bytes) of the filter string. */
    242401    HGCMFunctionParameter cbFilter;
    243402    /** pointer, in: Filter string. */
    244403    HGCMFunctionParameter pvFilter;
     404    /** uint32_t, in: Size (in bytes) of the listing path. */
     405    HGCMFunctionParameter cbPath;
     406    /** pointer, in: Listing poth. If empty or NULL the listing's root path will be opened. */
     407    HGCMFunctionParameter pvPath;
     408    /** uint64_t, out: List handle. */
     409    HGCMFunctionParameter uHandle;
    245410} VBoxClipboardListOpenMsg;
    246411
    247 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN 5
     412#define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN 7
    248413
    249414/**
    250415 * Closes a list.
    251  *
    252  * Used by:
    253  * VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN
    254416 */
    255417typedef struct _VBoxClipboardListCloseMsg
    … …  
    265427#define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE 2
    266428
    267 /**
    268  * Reads / writes a list header.
    269  *
    270  * Used by:
    271  * VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ
    272  * VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE
    273  */
    274 typedef struct _VBoxClipboardListHdrMsg
    275 {
    276     VBGLIOCHGCMCALL hdr;
    277 
    278     /** uint32_t, in/out: Context ID. Unused at the moment. */
     429typedef struct _VBoxClipboardListHdrReqParms
     430{
     431    /** uint32_t, in: Context ID. Unused at the moment. */
    279432    HGCMFunctionParameter uContext;
    280433    /** uint64_t, in: List handle. */
    281434    HGCMFunctionParameter uHandle;
    282     /** value64, out:  Number of total objects to transfer. */
    283     HGCMFunctionParameter cTotalObjects;
    284     /** value64, out:  Number of total bytes to transfer. */
    285     HGCMFunctionParameter cbTotalSize;
    286     /** Compression type. */
    287     HGCMFunctionParameter enmCompression;
    288     /** Checksum type used for data transfer. */
    289     HGCMFunctionParameter enmChecksumType;
    290 } VBoxClipboardListHdrReadMsg, VBoxClipboardListHdrWriteMsg;
    291 
    292 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ  6
    293 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_WRITE 6
    294 
    295 /**
    296  * Reads / writes a list entry.
    297  *
    298  * Used by:
    299  * VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ
    300  * VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE
    301  */
    302 typedef struct _VBoxClipboardListEntryMsg
    303 {
    304     VBGLIOCHGCMCALL hdr;
    305 
    306     /** Context ID. Unused at the moment. */
     435    /** uint32_t, in: Flags of type VBOX_SHAREDCLIPBOARD_LISTHDR_FLAG_XXX. */
     436    HGCMFunctionParameter fFlags;
     437} VBoxClipboardListHdrReqParms;
     438
     439/**
     440 * Request to read a list header.
     441 */
     442typedef struct _VBoxClipboardListHdrReadReqMsg
     443{
     444    VBGLIOCHGCMCALL hdr;
     445
     446    VBoxClipboardListHdrReqParms ReqParms;
     447} VBoxClipboardListHdrReadReqMsg;
     448
     449#define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ 3
     450
     451/**
     452 * Reads / Writes a list header.
     453 */
     454typedef struct _VBoxClipboardListHdrMsg
     455{
     456    VBGLIOCHGCMCALL hdr;
     457
     458    VBoxClipboardListHdrReqParms ReqParms;
     459    /** uint32_t, in/out: Feature flags (see VBOX_SHAREDCLIPBOARD_FEATURE_FLAG_XXX). */
     460    HGCMFunctionParameter        fFeatures;
     461    /** uint64_t, in/out:  Number of total objects to transfer. */
     462    HGCMFunctionParameter        cTotalObjects;
     463    /** uint64_t, in/out:  Number of total bytes to transfer. */
     464    HGCMFunctionParameter        cbTotalSize;
     465    /** uint32_t, in/out: Compression type. */
     466    HGCMFunctionParameter        enmCompression;
     467    /** uint32_t, in/out: Checksum type used for data transfer. */
     468    HGCMFunctionParameter        enmChecksumType;
     469} VBoxClipboardListHdrMsg;
     470
     471#define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR 8
     472
     473typedef struct _VBoxClipboardListEntryReqParms
     474{
     475    /** uint32_t, Context ID. Unused at the moment. */
    307476    HGCMFunctionParameter uContext;
    308477    /** uint64_t, in: List handle. */
    309478    HGCMFunctionParameter uHandle;
    310     /** uint32_t, in/out: VBOX_SHAREDCLIPBOARD_INFO_FLAG_XXX. */
     479    /** uint32_t, in: VBOX_SHAREDCLIPBOARD_INFO_FLAG_XXX. */
    311480    HGCMFunctionParameter fInfo;
    312     /** uint32_t, in/out: Bytes to be used for information/How many bytes were used.  */
    313     HGCMFunctionParameter cbInfo;
    314     /** pointer, in/out: Information to be set/get (SHAREDCLIPBOARDFSOBJINFO only currently).
     481} VBoxClipboardListEntryReqParms;
     482
     483/**
     484 * Request to read a list entry.
     485 */
     486typedef struct _VBoxClipboardListEntryReadReqMsg
     487{
     488    VBGLIOCHGCMCALL hdr;
     489
     490    VBoxClipboardListEntryReqParms ReqParms;
     491} VBoxClipboardListEntryReadReqMsg;
     492
     493#define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ_REQ 3
     494
     495/**
     496 * Reads / Writes a list entry.
     497 */
     498typedef struct _VBoxClipboardListEntryMsg
     499{
     500    VBGLIOCHGCMCALL hdr;
     501
     502    /** in: Request parameters. */
     503    VBoxClipboardListEntryReqParms ReqParms;
     504    /** uint32_t, out: Bytes to be used for information/How many bytes were used.  */
     505    HGCMFunctionParameter          cbInfo;
     506    /** pointer, out: Information to be set/get (SHAREDCLIPBOARDFSOBJINFO only currently).
    315507     * Do not forget to set the SHAREDCLIPBOARDFSOBJINFO::Attr::enmAdditional for Get operation as well.  */
    316     HGCMFunctionParameter pvInfo;
    317 } VBoxClipboardListEntryReadMsg, VBoxClipboardListEntryWriteMsg;
    318 
    319 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ  5
    320 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_WRITE 5
     508    HGCMFunctionParameter          pvInfo;
     509} VBoxClipboardListEntryMsg;
     510
     511#define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY 5
    321512
    322513typedef struct _VBoxClipboardObjOpenMsg
    … …  
    339530   VBGLIOCHGCMCALL hdr;
    340531
    341     /** value64, in: SHAREDCLIPBOARDOBJHANDLE of object to close. */
     532    /** uint64_t, in: SHAREDCLIPBOARDOBJHANDLE of object to close. */
    342533    HGCMFunctionParameter uHandle;
    343534} VBoxClipboardObjCloseMsg;
    … …  
    358549    /** Context ID. Unused at the moment. */
    359550    HGCMFunctionParameter uContext;     /* OUT uint32_t */
    360     /** value64, in: SHAREDCLIPBOARDOBJHANDLE of object to write to. */
     551    /** uint64_t, in: SHAREDCLIPBOARDOBJHANDLE of object to write to. */
    361552    HGCMFunctionParameter uHandle;
    362553    /** Size (in bytes) of current data chunk. */
    … …  
    416607
    417608#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    418 int VBoxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr);
     609int VBoxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr);
    419610int VBoxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTHDR pListHdr);
    420 int VBoxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry);
     611int VBoxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry);
    421612int VBoxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTENTRY pListEntry);
    422613int VBoxSvcClipboardURIGetFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData);

  • trunk/include/VBox/VBoxGuestLib.h

    r79499 r79630  
    624624VBGLR3DECL(void)    VbglR3ClipboardEventFree(PVBGLR3CLIPBOARDEVENT pEvent);
    625625
    626 VBGLR3DECL(int)     VbglR3ClipboardListHdrRead(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHDR pListHdr);
    627 VBGLR3DECL(int)     VbglR3ClipboardSendListHdrWrite(HGCMCLIENTID idClient, VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr);
    628 VBGLR3DECL(int)     VbglR3ClipboardListEntryRead(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTENTRY pListEntry);
    629 VBGLR3DECL(int)     VbglR3ClipboardSendListEntryWrite(HGCMCLIENTID idClient, VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry);
     626VBGLR3DECL(int)     VbglR3ClipboardTransferSendStatus(HGCMCLIENTID idClient, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus);
     627
     628VBGLR3DECL(int)     VbglR3ClipboardListOpenSend(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList);
     629VBGLR3DECL(int)     VbglR3ClipboardListOpenRecv(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms);
     630VBGLR3DECL(int)     VbglR3ClipboardListOpenReply(HGCMCLIENTID idClient, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList);
     631
     632VBGLR3DECL(int)     VbglR3ClipboardListCloseSend(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList);
     633VBGLR3DECL(int)     VbglR3ClipboardListCloseRecv(HGCMCLIENTID idClient, PSHAREDCLIPBOARDLISTHANDLE phList);
     634
     635VBGLR3DECL(int)     VbglR3ClipboardListHdrWrite(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr);
     636
     637VBGLR3DECL(int)     VbglR3ClipboardListEntryWrite(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry);
    630638
    631639VBGLR3DECL(int)     VbglR3ClipboardObjOpen(HGCMCLIENTID idClient,

  • trunk/include/VBox/err.h

    r79173 r79630  
    29212921/** Maximum of concurrent clipboard transfers has been reached. */
    29222922#define VERR_SHCLPB_MAX_TRANSFERS_REACHED           (-7100)
     2923/** Maximum number of Shared Clipboard objects has been reached. */
     2924#define VERR_SHCLPB_MAX_OBJECTS_REACHED             (-7101)
     2925/** A Shared Clipboard list handle is invalid. */
     2926#define VERR_SHCLPB_LIST_HANDLE_INVALID             (-7102)
     2927/** A Shared Clipboard objects handle is invalid. */
     2928#define VERR_SHCLPB_OBJ_HANDLE_INVALID              (-7103)
    29232929/** @} */
    29242930/* SED-END */

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

    r79506 r79630  
    7070
    7171#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     72typedef struct _VBOXCLIPBOARDURIREADTHREADCTX
     73{
     74    PVBOXCLIPBOARDCONTEXT       pClipboardCtx;
     75    PSHAREDCLIPBOARDURITRANSFER pTransfer;
     76} VBOXCLIPBOARDURIREADTHREADCTX, *PVBOXCLIPBOARDURIREADTHREADCTX;
     77
    7278typedef struct _VBOXCLIPBOARDURIWRITETHREADCTX
    7379{
    … …  
    108114    AssertPtr(pCtx);
    109115
     116    PSHAREDCLIPBOARDURITRANSFER pTransfer = pCtx->pTransfer;
     117    AssertPtr(pTransfer);
     118
     119    pTransfer->Thread.fStarted = true;
     120
    110121    RTThreadUserSignal(RTThreadSelf());
    111122
    … …  
    114125    if (RT_SUCCESS(rc))
    115126    {
    116         VBoxClipboardTransferReport Msg;
    117         RT_ZERO(Msg);
    118 
    119         VBGL_HGCM_HDR_INIT(&Msg.hdr, uClientID,
    120                             VBOX_SHARED_CLIPBOARD_GUEST_FN_TRANSFER_REPORT, VBOX_SHARED_CLIPBOARD_CPARMS_TRANSFER_REPORT);
    121 
    122         Msg.uContext.SetUInt32(0);
    123         Msg.uStatus.SetUInt32(0);
    124 
    125         rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    126 
     127        rc = VbglR3ClipboardTransferSendStatus(uClientID, SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING);
    127128        if (RT_SUCCESS(rc))
    128129        {
    … …  
    132133            for (;;)
    133134            {
    134                 PVBGLR3CLIPBOARDEVENT pEvent;
    135                 rc = VbglR3ClipboardEventGetNext(uClientID, pCtx->pTransfer, &pEvent);
     135                PVBGLR3CLIPBOARDEVENT pEvent = NULL;
     136                rc = VbglR3ClipboardEventGetNext(uClientID, pTransfer, &pEvent);
    136137                if (RT_SUCCESS(rc))
    137138                {
    138                    switch (pEvent->enmType)
    139                    {
    140                        case VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_HDR_READ:
    141                        {
    142                            LogFlowFunc(("VBGLR3CLIPBOARDEVENTTYPE_URI_READ_LIST_HDR\n"));
    143                            break;
    144                        }
    145 
    146                        case VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_ENTRY_READ:
    147                        {
    148                            LogFlowFunc(("VBGLR3CLIPBOARDEVENTTYPE_URI_READ_LIST_ENTRY\n"));
    149                            break;
    150                        }
    151 
    152                        case VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_OPEN:
    153                        {
    154                            LogFlowFunc(("VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_OPEN\n"));
    155                            break;
    156                        }
    157 
    158                        case VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_CLOSE:
    159                        {
    160                            LogFlowFunc(("VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_CLOSE\n"));
    161                            break;
    162                        }
    163 
    164                        case VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_READ:
    165                        {
    166                            LogFlowFunc(("VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_READ\n"));
    167                            break;
    168                        }
    169 
    170                        case VBGLR3CLIPBOARDEVENTTYPE_URI_CANCEL:
    171                            RT_FALL_THROUGH();
    172                        case VBGLR3CLIPBOARDEVENTTYPE_URI_ERROR:
    173                            LogFlowFunc(("VBGLR3CLIPBOARDEVENTTYPE_URI_CANCEL / ERROR\n"));
    174                            fTerminate = true;
    175                            break;
    176 
    177                        default:
    178                            rc = VERR_NOT_SUPPORTED;
    179                            cErrors++;
    180                            break;
    181                    }
    182 
    183                    VbglR3ClipboardEventFree(pEvent);
     139                    /* Nothing to do in here right now. */
     140
     141                    VbglR3ClipboardEventFree(pEvent);
    184142                }
    185143
    … …  
    272230}
    273231
    274 static int vboxClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, VBOXCLIPBOARDLISTHANDLE hList,
    275                                        PVBOXCLIPBOARDLISTHDR pListHdr)
    276 {
    277     RT_NOREF(hList);
     232static int vboxClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDLISTHDR pListHdr,
     233                                    PSHAREDCLIPBOARDLISTHANDLE phList)
     234{
     235    RT_NOREF(pCtx, pListHdr, phList);
    278236
    279237    LogFlowFuncEnter();
    … …  
    282240    AssertPtr(pThisCtx);
    283241
    284     LogFlowFunc(("c=%RU32\n", pThisCtx->u32ClientID));
    285 
    286     RT_NOREF(pListHdr);
    287     int rc = 0; //VbglR3ClipboardListHdrRead(pThisCtx->u32ClientID, pListHdr);
     242    int rc = 0; // VbglR3ClipboardRecvListOpen(pThisCtx->u32ClientID, pListHdr, phList);
    288243
    289244    LogFlowFuncLeaveRC(rc);
    … …  
    291246}
    292247
    293 static int vboxClipboardURIListHdrWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, VBOXCLIPBOARDLISTHANDLE hList,
    294                                         PVBOXCLIPBOARDLISTHDR pListHdr)
    295 {
     248static int vboxClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
     249                                       PVBOXCLIPBOARDLISTHDR pListHdr)
     250{
     251    RT_NOREF(hList);
     252
    296253    LogFlowFuncEnter();
    297254
    … …  
    299256    AssertPtr(pThisCtx);
    300257
    301     int rc = VbglR3ClipboardSendListHdrWrite(pThisCtx->u32ClientID, hList, pListHdr);
     258    LogFlowFunc(("c=%RU32\n", pThisCtx->u32ClientID));
     259
     260    int rc = SharedClipboardURIListHdrInit(pListHdr);
     261    if (RT_SUCCESS(rc))
     262    {
     263        if (RT_SUCCESS(rc))
     264        {
     265            //rc = VbglR3ClipboardListHdrReadRecv(pThisCtx->u32ClientID, hList, pListHdr);
     266        }
     267        else
     268            SharedClipboardURIListHdrDestroy(pListHdr);
     269    }
    302270
    303271    LogFlowFuncLeaveRC(rc);
    … …  
    305273}
    306274
    307 static int vboxClipboardURIListEntryRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, VBOXCLIPBOARDLISTHANDLE hList,
    308                                          PVBOXCLIPBOARDLISTENTRY pListEntry)
    309 {
    310     RT_NOREF(hList);
    311 
     275/*
     276static int vboxClipboardURIListHdrWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
     277                                        PVBOXCLIPBOARDLISTHDR pListHdr)
     278{
    312279    LogFlowFuncEnter();
    313280
    … …  
    315282    AssertPtr(pThisCtx);
    316283
     284    int rc = VbglR3ClipboardListHdrWrite(pThisCtx->u32ClientID, hList, pListHdr);
     285
     286    LogFlowFuncLeaveRC(rc);
     287    return rc;
     288}*/
     289
     290static int vboxClipboardURIListEntryRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
     291                                         PVBOXCLIPBOARDLISTENTRY pListEntry)
     292{
     293    RT_NOREF(hList);
     294
     295    LogFlowFuncEnter();
     296
     297    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     298    AssertPtr(pThisCtx);
     299
    317300    RT_NOREF(pListEntry);
    318301    int rc = 0; // VbglR3ClipboardListEntryRead(pThisCtx->u32ClientID, pListEntry);
    … …  
    322305}
    323306
    324 static int vboxClipboardURIListEntryWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, VBOXCLIPBOARDLISTHANDLE hList,
     307/*
     308static int vboxClipboardURIListEntryWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    325309                                          PVBOXCLIPBOARDLISTENTRY pListEntry)
    326310{
    … …  
    330314    AssertPtr(pThisCtx);
    331315
    332     int rc = VbglR3ClipboardSendListEntryWrite(pThisCtx->u32ClientID, hList, pListEntry);
     316    int rc = VbglR3ClipboardListEntryWrite(pThisCtx->u32ClientID, hList, pListEntry);
    333317
    334318    LogFlowFuncLeaveRC(rc);
    335319    return rc;
    336320}
     321*/
    337322
    338323static int vboxClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const char *pszPath,
    … …  
    636621                   VBoxClipboardWinClear();
    637622
    638 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     623#if 0
    639624                   if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    640625                   {
    … …  
    671656                           creationCtx.pvUser = pCtx;
    672657
    673                            rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx);
     658                           rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
    674659                           if (RT_SUCCESS(rc))
    675660                           {
    … …  
    690675
    691676                       VBoxClipboardWinClose();
    692 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     677#if 0
    693678                   }
    694679#endif
    … …  
    802787               if (RT_SUCCESS(rc))
    803788               {
     789            #if 0
    804790                   SHAREDCLIPBOARDURITRANSFERCALLBACKS TransferCallbacks;
    805791                   RT_ZERO(TransferCallbacks);
    … …  
    824810                   creationCtx.pvUser = pCtx;
    825811
    826                    rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx);
     812                   rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
    827813                   if (RT_SUCCESS(rc))
    828814                   {
     815            #endif
    829816                       rc = SharedClipboardURICtxTransferAdd(&pCtx->URI, pTransfer);
    830817                       if (RT_SUCCESS(rc))
    … …  
    880867                           }
    881868                       }
    882                    }
     869                   //}
    883870               }
    884871
    … …  
    891878       }
    892879
     880       /* The host wants to write URI data. */
    893881       case VBOX_CLIPBOARD_WM_URI_START_WRITE:
    894882       {
    895883           LogFunc(("VBOX_CLIPBOARD_WM_URI_START_WRITE: cTransfersRunning=%RU32\n",
    896884                    SharedClipboardURICtxGetRunningTransfers(&pCtx->URI)));
     885
     886           PSHAREDCLIPBOARDURITRANSFER pTransfer;
     887           int rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ,
     888                                                     SHAREDCLIPBOARDSOURCE_LOCAL,
     889                                                     &pTransfer);
     890           if (RT_SUCCESS(rc))
     891           {
     892               SHAREDCLIPBOARDURITRANSFERCALLBACKS TransferCallbacks;
     893               RT_ZERO(TransferCallbacks);
     894
     895               TransferCallbacks.pvUser              = &pCtx->URI;
     896               TransferCallbacks.pfnTransferComplete = vboxClipboardURITransferCompleteCallback;
     897               TransferCallbacks.pfnTransferError    = vboxClipboardURITransferErrorCallback;
     898
     899               SharedClipboardURITransferSetCallbacks(pTransfer, &TransferCallbacks);
     900
     901               SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
     902               RT_ZERO(creationCtx);
     903               creationCtx.enmSource = SHAREDCLIPBOARDSOURCE_REMOTE;
     904
     905               RT_ZERO(creationCtx.Interface);
     906               creationCtx.Interface.pfnListHdrRead   = vboxClipboardURIListHdrRead;
     907               creationCtx.Interface.pfnListEntryRead = vboxClipboardURIListEntryRead;
     908               creationCtx.Interface.pfnObjOpen       = vboxClipboardURIObjOpen;
     909               creationCtx.Interface.pfnObjClose      = vboxClipboardURIObjClose;
     910               creationCtx.Interface.pfnObjRead       = vboxClipboardURIObjRead;
     911
     912               creationCtx.pvUser = pCtx;
     913
     914               rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
     915               if (RT_SUCCESS(rc))
     916               {
     917                   rc = SharedClipboardURICtxTransferAdd(&pCtx->URI, pTransfer);
     918                   if (RT_SUCCESS(rc))
     919                   {
     920                       if (RT_SUCCESS(rc))
     921                       {
     922                           rc = SharedClipboardURITransferPrepare(pTransfer);
     923                           if (RT_SUCCESS(rc))
     924                           {
     925                               rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
     926                           }
     927                       }
     928                   }
     929               }
     930           }
    897931
    898932           break;

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

    r79500 r79630  
    162162
    163163#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    164 static int vbglR3ClipboardGetNextMsgType(HGCMCLIENTID idClient, uint32_t *puMsg, uint32_t *pcParms, bool fWait)
     164#if 0
     165static int vbglR3ClipboardPeekMsg(HGCMCLIENTID idClient, uint32_t *puMsg, uint32_t *pcParms, bool fWait)
    165166{
    166167    AssertPtrReturn(puMsg,   VERR_INVALID_POINTER);
    167168    AssertPtrReturn(pcParms, VERR_INVALID_POINTER);
    168169
    169     VBoxClipboardGetHostMsg Msg;
     170    VBoxClipboardPeekMsg Msg;
    170171    RT_ZERO(Msg);
    171172
    … …  
    188189    return rc;
    189190}
    190 
    191 static int vbglR3ClipboardRecvListOpen(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHDR pListHdr)
     191#else
     192/**
     193 * Peeks at the next host message, waiting for one to turn up.
     194 *
     195 * @returns VBox status code.
     196 * @retval  VERR_INTERRUPTED if interrupted.  Does the necessary cleanup, so
     197 *          caller just have to repeat this call.
     198 * @retval  VERR_VM_RESTORED if the VM has been restored (idRestoreCheck).
     199 *
     200 * @param   idClient        The client ID returned by VbglR3GuestCtrlConnect().
     201 * @param   pidMsg          Where to store the message id.
     202 * @param   pcParameters    Where to store the number  of parameters which will
     203 *                          be received in a second call to the host.
     204 * @param   pidRestoreCheck Pointer to the VbglR3GetSessionId() variable to use
     205 *                          for the VM restore check.  Optional.
     206 *
     207 * @note    Restore check is only performed optimally with a 6.0 host.
     208 */
     209static int vbglR3ClipboardMsgPeekWait(uint32_t idClient, uint32_t *pidMsg, uint32_t *pcParameters, uint64_t *pidRestoreCheck)
     210{
     211    AssertPtrReturn(pidMsg, VERR_INVALID_POINTER);
     212    AssertPtrReturn(pcParameters, VERR_INVALID_POINTER);
     213
     214    int rc;
     215
     216    struct
     217    {
     218        VBGLIOCHGCMCALL Hdr;
     219        HGCMFunctionParameter idMsg;       /* Doubles as restore check on input. */
     220        HGCMFunctionParameter cParameters;
     221    } Msg;
     222    VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT, 2);
     223    VbglHGCMParmUInt64Set(&Msg.idMsg, pidRestoreCheck ? *pidRestoreCheck : 0);
     224    VbglHGCMParmUInt32Set(&Msg.cParameters, 0);
     225    rc = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg));
     226    LogRel2(("VbglR3GuestCtrlMsgPeekWait -> %Rrc\n", rc));
     227    if (RT_SUCCESS(rc))
     228    {
     229        AssertMsgReturn(   Msg.idMsg.type       == VMMDevHGCMParmType_64bit
     230                        && Msg.cParameters.type == VMMDevHGCMParmType_32bit,
     231                        ("msg.type=%d num_parms.type=%d\n", Msg.idMsg.type, Msg.cParameters.type),
     232                        VERR_INTERNAL_ERROR_3);
     233
     234        *pidMsg       = (uint32_t)Msg.idMsg.u.value64;
     235        *pcParameters = Msg.cParameters.u.value32;
     236        return rc;
     237    }
     238
     239    /*
     240     * If interrupted we must cancel the call so it doesn't prevent us from making another one.
     241     */
     242    if (rc == VERR_INTERRUPTED)
     243    {
     244        VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL, 0);
     245        int rc2 = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg.Hdr));
     246        AssertRC(rc2);
     247    }
     248
     249    /*
     250     * If restored, update pidRestoreCheck.
     251     */
     252    if (rc == VERR_VM_RESTORED && pidRestoreCheck)
     253        *pidRestoreCheck = Msg.idMsg.u.value64;
     254
     255    *pidMsg       = UINT32_MAX - 1;
     256    *pcParameters = UINT32_MAX - 2;
     257    return rc;
     258}
     259#endif
     260
     261VBGLR3DECL(int) VbglR3ClipboardTransferSendStatus(HGCMCLIENTID idClient, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus)
     262{
     263    VBoxClipboardStatusMsg Msg;
     264    RT_ZERO(Msg);
     265
     266    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     267                       VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS, VBOX_SHARED_CLIPBOARD_CPARMS_STATUS);
     268
     269    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     270    Msg.uStatus.SetUInt32(uStatus);
     271    Msg.cbPayload.SetUInt32(0);
     272    Msg.pvPayload.SetPtr(NULL, 0);
     273
     274    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     275
     276    LogFlowFuncLeaveRC(rc);
     277    return rc;
     278}
     279
     280VBGLR3DECL(int) VbglR3ClipboardListOpenSend(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms,
     281                                            PSHAREDCLIPBOARDLISTHANDLE phList)
     282{
     283    AssertPtrReturn(pOpenParms, VERR_INVALID_POINTER);
     284    AssertPtrReturn(phList,     VERR_INVALID_POINTER);
     285
     286    VBoxClipboardListOpenMsg Msg;
     287    RT_ZERO(Msg);
     288
     289    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     290                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
     291
     292    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     293    Msg.fList.SetUInt32(0);
     294    Msg.cbFilter.SetUInt32(pOpenParms->cbFilter);
     295    Msg.pvFilter.SetPtr(pOpenParms->pszFilter, pOpenParms->cbFilter);
     296    Msg.cbPath.SetUInt32(pOpenParms->cbPath);
     297    Msg.pvFilter.SetPtr(pOpenParms->pszPath, pOpenParms->cbPath);
     298
     299    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     300    if (RT_SUCCESS(rc))
     301    {
     302        rc = Msg.uHandle.GetUInt64(phList); AssertRC(rc);
     303    }
     304
     305    LogFlowFuncLeaveRC(rc);
     306    return rc;
     307}
     308
     309VBGLR3DECL(int) VbglR3ClipboardListOpenRecv(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
     310{
     311    AssertPtrReturn(pOpenParms, VERR_INVALID_POINTER);
     312
     313    VBoxClipboardListOpenMsg Msg;
     314    RT_ZERO(Msg);
     315
     316    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     317                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
     318
     319    Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN);
     320    Msg.fList.SetUInt32(0);
     321    Msg.cbPath.SetUInt32(pOpenParms->cbPath);
     322    Msg.pvPath.SetPtr(pOpenParms->pszPath, pOpenParms->cbPath);
     323    Msg.cbFilter.SetUInt32(pOpenParms->cbFilter);
     324    Msg.pvFilter.SetPtr(pOpenParms->pszFilter, pOpenParms->cbFilter);
     325    Msg.uHandle.SetUInt64(0);
     326
     327    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     328    if (RT_SUCCESS(rc))
     329    {
     330        rc = Msg.fList.GetUInt32(&pOpenParms->fList);
     331        if (RT_SUCCESS(rc))
     332            rc = Msg.cbFilter.GetUInt32(&pOpenParms->cbFilter);
     333        if (RT_SUCCESS(rc))
     334            rc = Msg.cbPath.GetUInt32(&pOpenParms->cbPath);
     335    }
     336
     337    LogFlowFuncLeaveRC(rc);
     338    return rc;
     339}
     340
     341VBGLR3DECL(int) VbglR3ClipboardListOpenReply(HGCMCLIENTID idClient, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList)
     342{
     343    VBoxClipboardReplyMsg Msg;
     344    RT_ZERO(Msg);
     345
     346    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     347                       VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY, 6);
     348
     349    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     350    Msg.enmType.SetUInt32(VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN);
     351    Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */
     352    Msg.cbPayload.SetUInt32(0);
     353    Msg.pvPayload.SetPtr(0, NULL);
     354
     355    Msg.u.ListOpen.uHandle.SetUInt64(hList);
     356
     357    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     358
     359    LogFlowFuncLeaveRC(rc);
     360    return rc;
     361}
     362
     363VBGLR3DECL(int) VbglR3ClipboardListCloseSend(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList)
     364{
     365    VBoxClipboardListCloseMsg Msg;
     366    RT_ZERO(Msg);
     367
     368    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     369                       VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
     370
     371    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     372    Msg.uHandle.SetUInt64(hList);
     373
     374    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     375
     376    LogFlowFuncLeaveRC(rc);
     377    return rc;
     378}
     379
     380VBGLR3DECL(int) VbglR3ClipboardListCloseRecv(HGCMCLIENTID idClient, PSHAREDCLIPBOARDLISTHANDLE phList)
     381{
     382    AssertPtrReturn(phList, VERR_INVALID_POINTER);
     383
     384    VBoxClipboardListCloseMsg Msg;
     385    RT_ZERO(Msg);
     386
     387    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     388                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
     389
     390    Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE);
     391    Msg.uHandle.SetUInt64(0);
     392
     393    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     394    if (RT_SUCCESS(rc))
     395    {
     396        rc = Msg.uHandle.GetUInt64(phList); AssertRC(rc);
     397    }
     398
     399    LogFlowFuncLeaveRC(rc);
     400    return rc;
     401}
     402
     403VBGLR3DECL(int) VbglR3ClipboardListHdrRead(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList, uint32_t fFlags,
     404                                           PVBOXCLIPBOARDLISTHDR pListHdr)
    192405{
    193406    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
    194407
    195     VBoxClipboardListOpenMsg Msg;
    196     RT_ZERO(Msg);
    197 
    198     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    199                        VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
    200 
    201     Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
    202     Msg.uHandle.SetUInt64(0);
    203     Msg.fList.SetUInt32(0);
     408    VBoxClipboardListHdrMsg Msg;
     409    RT_ZERO(Msg);
     410
     411    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     412                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR);
     413
     414    Msg.ReqParms.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     415    Msg.ReqParms.uHandle.SetUInt64(hList);
     416    Msg.ReqParms.fFlags.SetUInt32(fFlags);
     417
    204418    Msg.fFeatures.SetUInt32(0);
    205     Msg.cbFilter.SetUInt32(0);
    206     Msg.pvFilter.SetPtr(pListHdr->pszFilter, pListHdr->cbFilter);
    207 
    208     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    209     if (RT_SUCCESS(rc))
    210     {
    211         rc = Msg.fList.GetUInt32(&pListHdr->fList);         AssertRC(rc);
    212         rc = Msg.fFeatures.GetUInt32(&pListHdr->fFeatures); AssertRC(rc);
    213     }
    214 
    215     LogFlowFuncLeaveRC(rc);
    216     return rc;
    217 }
    218 
    219 static int vbglR3ClipboardRecvListClose(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHANDLE phList)
    220 {
    221     AssertPtrReturn(phList, VERR_INVALID_POINTER);
    222 
    223     VBoxClipboardListCloseMsg Msg;
    224     RT_ZERO(Msg);
    225 
    226     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    227                        VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
    228 
    229     Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
    230     Msg.uHandle.SetUInt64(0);
    231 
    232     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    233     if (RT_SUCCESS(rc))
    234     {
    235         rc = Msg.uHandle.GetUInt64(phList); AssertRC(rc);
    236     }
    237 
    238     LogFlowFuncLeaveRC(rc);
    239     return rc;
    240 }
    241 
    242 static int vbglR3ClipboardRecvListHdrRead(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr)
    243 {
    244     AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
    245     AssertPtrReturn(phList,   VERR_INVALID_POINTER);
    246 
    247     VBoxClipboardListHdrReadMsg Msg;
    248     RT_ZERO(Msg);
    249 
    250     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    251                        VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ);
    252 
    253     Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
    254     Msg.uHandle.SetUInt64(0);
     419    Msg.cbTotalSize.SetUInt32(0);
    255420    Msg.cTotalObjects.SetUInt64(0);
    256421    Msg.cbTotalSize.SetUInt64(0);
    … …  
    261426    if (RT_SUCCESS(rc))
    262427    {
    263         rc = Msg.uHandle.GetUInt64(phList); AssertRC(rc);
    264     }
    265 
    266     LogFlowFuncLeaveRC(rc);
    267     return rc;
    268 }
    269 
    270 static int vbglR3ClipboardRecvListEntryRead(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHANDLE phList,
    271                                             PVBOXCLIPBOARDLISTENTRY pListEntry)
     428        rc = Msg.fFeatures.GetUInt32(&pListHdr->fFeatures);
     429        if (RT_SUCCESS(rc))
     430            rc = Msg.cTotalObjects.GetUInt64(&pListHdr->cTotalObjects);
     431        if (RT_SUCCESS(rc))
     432            rc = Msg.cbTotalSize.GetUInt64(&pListHdr->cbTotalSize);
     433        if (RT_SUCCESS(rc))
     434            rc = Msg.enmCompression.GetUInt32(&pListHdr->enmCompression);
     435        if (RT_SUCCESS(rc))
     436            rc = Msg.enmChecksumType.GetUInt32(&pListHdr->enmChecksumType);
     437    }
     438
     439    LogFlowFuncLeaveRC(rc);
     440    return rc;
     441}
     442
     443VBGLR3DECL(int) VbglR3ClipboardListHdrReadRecvReq(HGCMCLIENTID idClient, PSHAREDCLIPBOARDLISTHANDLE phList, uint32_t *pfFlags)
     444{
     445    AssertPtrReturn(phList,  VERR_INVALID_POINTER);
     446    AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
     447
     448    VBoxClipboardListHdrReadReqMsg Msg;
     449    RT_ZERO(Msg);
     450
     451    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     452                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
     453
     454    Msg.ReqParms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ);
     455    Msg.ReqParms.uHandle.SetUInt64(0);
     456    Msg.ReqParms.fFlags.SetUInt32(0);
     457
     458    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     459    if (RT_SUCCESS(rc))
     460    {
     461        if (RT_SUCCESS(rc))
     462            rc = Msg.ReqParms.uHandle.GetUInt64(phList);
     463        if (RT_SUCCESS(rc))
     464            rc = Msg.ReqParms.fFlags.GetUInt32(pfFlags);
     465    }
     466
     467    LogFlowFuncLeaveRC(rc);
     468    return rc;
     469}
     470
     471VBGLR3DECL(int) VbglR3ClipboardListHdrWrite(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList,
     472                                            PVBOXCLIPBOARDLISTHDR pListHdr)
     473{
     474    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
     475
     476    VBoxClipboardListHdrMsg Msg;
     477    RT_ZERO(Msg);
     478
     479    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     480                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR);
     481
     482    Msg.ReqParms.uContext.SetUInt32(0);
     483    Msg.ReqParms.uHandle.SetUInt64(hList);
     484    Msg.ReqParms.fFlags.SetUInt32(0);
     485
     486    Msg.fFeatures.SetUInt32(0);
     487    Msg.cbTotalSize.SetUInt32(pListHdr->fFeatures);
     488    Msg.cTotalObjects.SetUInt64(pListHdr->cTotalObjects);
     489    Msg.cbTotalSize.SetUInt64(pListHdr->cbTotalSize);
     490    Msg.enmCompression.SetUInt32(pListHdr->enmCompression);
     491    Msg.enmChecksumType.SetUInt32(pListHdr->enmChecksumType);
     492
     493    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     494
     495    LogFlowFuncLeaveRC(rc);
     496    return rc;
     497}
     498
     499VBGLR3DECL(int) VbglR3ClipboardListEntryRead(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList,
     500                                             PVBOXCLIPBOARDLISTENTRY pListEntry)
    272501{
    273502    AssertPtrReturn(pListEntry, VERR_INVALID_POINTER);
    274     AssertPtrReturn(phList,     VERR_INVALID_POINTER);
    275 
    276     VBoxClipboardListEntryReadMsg Msg;
    277     RT_ZERO(Msg);
    278 
    279     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    280                        VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
    281 
    282     Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
    283     Msg.uHandle.SetUInt64(0);
    284     Msg.fInfo.SetUInt32(0);
     503
     504    VBoxClipboardListEntryMsg Msg;
     505    RT_ZERO(Msg);
     506
     507    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     508                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY);
     509
     510    Msg.ReqParms.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     511    Msg.ReqParms.uHandle.SetUInt64(hList);
     512    Msg.ReqParms.fInfo.SetUInt32(0);
     513
    285514    Msg.cbInfo.SetUInt32(0);
    286515    Msg.pvInfo.SetPtr(pListEntry->pvInfo, pListEntry->cbInfo);
    … …  
    289518    if (RT_SUCCESS(rc))
    290519    {
    291         rc = Msg.uHandle.GetUInt64(phList);             AssertRC(rc);
    292         rc = Msg.fInfo.GetUInt32(&pListEntry->fInfo);   AssertRC(rc);
    293520        rc = Msg.cbInfo.GetUInt32(&pListEntry->cbInfo); AssertRC(rc);
    294521    }
     522
     523    LogFlowFuncLeaveRC(rc);
     524    return rc;
     525}
     526
     527VBGLR3DECL(int) VbglR3ClipboardListEntryReadRecvReq(HGCMCLIENTID idClient, PSHAREDCLIPBOARDLISTHANDLE phList, uint32_t *pfInfo)
     528{
     529    AssertPtrReturn(phList, VERR_INVALID_POINTER);
     530    AssertPtrReturn(pfInfo, VERR_INVALID_POINTER);
     531
     532    VBoxClipboardListEntryReadReqMsg Msg;
     533    RT_ZERO(Msg);
     534
     535    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     536                       VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ_REQ);
     537
     538    Msg.ReqParms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ);
     539    Msg.ReqParms.uHandle.SetUInt64(0);
     540    Msg.ReqParms.fInfo.SetUInt32(0);
     541
     542    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     543    if (RT_SUCCESS(rc))
     544    {
     545        rc = Msg.ReqParms.uHandle.GetUInt64(phList); AssertRC(rc);
     546        if (RT_SUCCESS(rc))
     547            rc = Msg.ReqParms.fInfo.GetUInt32(pfInfo); AssertRC(rc);
     548    }
     549
     550    LogFlowFuncLeaveRC(rc);
     551    return rc;
     552}
     553
     554VBGLR3DECL(int) VbglR3ClipboardListEntryWrite(HGCMCLIENTID idClient, SHAREDCLIPBOARDLISTHANDLE hList,
     555                                              PVBOXCLIPBOARDLISTENTRY pListEntry)
     556{
     557    AssertPtrReturn(pListEntry, VERR_INVALID_POINTER);
     558
     559    VBoxClipboardListEntryMsg Msg;
     560    RT_ZERO(Msg);
     561
     562    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     563                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY);
     564
     565    Msg.ReqParms.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     566    Msg.ReqParms.uHandle.SetUInt64(hList);
     567    Msg.ReqParms.fInfo.SetUInt32(pListEntry->fInfo);
     568
     569    Msg.cbInfo.SetUInt32(pListEntry->cbInfo);
     570    Msg.pvInfo.SetPtr(pListEntry->pvInfo, pListEntry->cbInfo);
     571
     572    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    295573
    296574    LogFlowFuncLeaveRC(rc);
    … …  
    310588    uint32_t uMsg   = 0;
    311589    uint32_t cParms = 0;
    312     int rc = vbglR3ClipboardGetNextMsgType(idClient, &uMsg, &cParms, true /* fWait */);
    313     if (RT_SUCCESS(rc))
    314     {
    315         /** @todo Check for VM session change. */
    316     }
    317 
    318 #if 0
    319     typedef struct _
    320     {
    321         union
    322         {
    323             struct Dir
    324             {
    325                 RTDIR hDir;
    326             };
    327         } u;
    328     };
    329 #endif
    330 
     590    int rc = vbglR3ClipboardMsgPeekWait(idClient, &uMsg, &cParms, NULL /* pidRestoreCheck */);
    331591    if (RT_SUCCESS(rc))
    332592    {
    … …  
    340600                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN\n"));
    341601
    342                 VBOXCLIPBOARDLISTHDR listHdr;
    343                 rc = SharedClipboardURIListHdrInit(&listHdr);
     602                VBOXCLIPBOARDLISTOPENPARMS openParmsList;
     603                rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
    344604                if (RT_SUCCESS(rc))
    345605                {
    346                     rc = vbglR3ClipboardRecvListOpen(idClient, &listHdr);
     606                    rc = VbglR3ClipboardListOpenRecv(idClient, &openParmsList);
    347607                    if (RT_SUCCESS(rc))
    348608                    {
    349                         rc = SharedClipboardURITransferListOpen(pTransfer, &listHdr, NULL /* phList */);
     609                        SHAREDCLIPBOARDLISTHANDLE hList = SHAREDCLIPBOARDLISTHANDLE_INVALID;
     610                        rc = SharedClipboardURITransferListOpen(pTransfer, &openParmsList, &hList);
     611
     612                        /* Reply in any case. */
     613                        int rc2 = VbglR3ClipboardListOpenReply(idClient, rc, hList);
     614                        AssertRC(rc2);
    350615                    }
    351616
    352                     SharedClipboardURIListHdrDestroy(&listHdr);
     617                    SharedClipboardURIListOpenParmsDestroy(&openParmsList);
    353618                }
    354 
    355619                break;
    356620            }
    … …  
    360624                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE\n"));
    361625
    362                 VBOXCLIPBOARDLISTHANDLE hList;
    363                 rc = vbglR3ClipboardRecvListClose(idClient, &hList);
     626                SHAREDCLIPBOARDLISTHANDLE hList;
     627                rc = VbglR3ClipboardListCloseRecv(idClient, &hList);
    364628                if (RT_SUCCESS(rc))
    365629                {
    … …  
    376640                /** @todo Handle filter + list features. */
    377641
    378                 VBOXCLIPBOARDLISTHDR listHdr;
    379                 rc = SharedClipboardURIListHdrInit(&listHdr);
     642                SHAREDCLIPBOARDLISTHANDLE hList  = SHAREDCLIPBOARDLISTHANDLE_INVALID;
     643                uint32_t                  fFlags = 0;
     644                rc = VbglR3ClipboardListHdrReadRecvReq(idClient, &hList, &fFlags);
    380645                if (RT_SUCCESS(rc))
    381646                {
    382                     VBOXCLIPBOARDLISTHANDLE hList;
    383                     rc = vbglR3ClipboardRecvListHdrRead(idClient, &hList, &listHdr);
     647                    VBOXCLIPBOARDLISTHDR hdrList;
     648                    rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
    384649                    if (RT_SUCCESS(rc))
    385650                    {
    386                         if (SharedClipboardURITransferListHandleIsValid(pTransfer, hList))
    387                         {
    388                             rc = VbglR3ClipboardSendListHdrWrite(idClient, hList, &listHdr);
    389                         }
    390                         else
    391                             rc = VERR_INVALID_HANDLE;
     651                        rc = VbglR3ClipboardListHdrWrite(idClient, hList, &hdrList);
     652                        SharedClipboardURIListHdrDestroy(&hdrList);
    392653                    }
    393 
    394                     SharedClipboardURIListHdrDestroy(&listHdr);
    395654                }
    396655
    … …  
    398657            }
    399658
     659        #if 0
    400660            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE:
    401661            {
    402662                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE\n"));
    403                 pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_HDR_WRITE;
     663
     664                VBOXCLIPBOARDLISTHDR hdrList;
     665                rc = SharedClipboardURIListHdrInit(&hdrList);
     666                if (RT_SUCCESS(rc))
     667                {
     668                    rc = VBglR3ClipboardListHdrRecv(idClient, )
     669                }
    404670                break;
    405671            }
     672        #endif
    406673
    407674            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ:
    … …  
    413680                if (RT_SUCCESS(rc))
    414681                {
    415                     VBOXCLIPBOARDLISTHANDLE hList;
    416                     rc = vbglR3ClipboardRecvListEntryRead(idClient, &hList, &listEntry);
     682                    SHAREDCLIPBOARDLISTHANDLE hList;
     683                    uint32_t                  fInfo;
     684                    rc = VbglR3ClipboardListEntryReadRecvReq(idClient, &hList, &fInfo);
    417685                    if (RT_SUCCESS(rc))
    418686                    {
    419                         if (SharedClipboardURITransferListHandleIsValid(pTransfer, hList))
     687                        rc = SharedClipboardURITransferListRead(pTransfer, hList, &listEntry);
     688                        if (RT_SUCCESS(rc))
    420689                        {
    421                             rc = VbglR3ClipboardSendListEntryWrite(idClient, hList, &listEntry);
     690                            rc = VbglR3ClipboardListEntryWrite(idClient, hList, &listEntry);
    422691                        }
    423                         else
    424                             rc = VERR_INVALID_HANDLE;
    425692                    }
    426693
    427694                    SharedClipboardURIListEntryDestroy(&listEntry);
    428695                }
     696
    429697                break;
    430698            }
    431699
     700        #if 0
    432701            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE:
    433702            {
    … …  
    436705                break;
    437706            }
     707        #endif
    438708
    439709            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN:
    … …  
    458728            }
    459729
     730        #if 0
    460731            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE:
    461732            {
    … …  
    464735                break;
    465736            }
     737        #endif
    466738#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    467739
    … …  
    471743        }
    472744    }
    473 
    474745
    475746    if (RT_SUCCESS(rc))
    … …  
    485756    {
    486757        /* Report error back to the host. */
    487         VbglR3ClipboardWriteError(idClient, rc);
     758        //VbglR3ClipboardWriteError(idClient, rc);
    488759
    489760        VbglR3ClipboardEventFree(pEvent);
    … …  
    514785    RTMemFree(pEvent);
    515786    pEvent = NULL;
     787}
     788
     789#if 0
     790VBGLR3DECL(int) VbglR3ClipboardListHdrReadRecv(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHANDLE phList)
     791{
     792    AssertPtrReturn(phList, VERR_INVALID_POINTER);
     793
     794    VBoxClipboardListHdrReadMsg Msg;
     795    RT_ZERO(Msg);
     796
     797    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     798                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ);
     799
     800    Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
     801    Msg.uHandle.SetUInt64(0);
     802
     803    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     804    if (RT_SUCCESS(rc))
     805    {
     806        Msg.uHandle.GetUInt32(phList);
     807    }
     808
     809    LogFlowFuncLeaveRC(rc);
     810    return rc;
    516811}
    517812
    … …  
    524819 * @param   pListHdr        List header to send.
    525820 */
    526 VBGLR3DECL(int) VbglR3ClipboardSendListHdrWrite(HGCMCLIENTID idClient,
    527                                                 VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
    528 {
    529     VBoxClipboardListHdrWriteMsg Msg;
    530     RT_ZERO(Msg);
    531 
    532     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    533                        VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_WRITE);
     821VBGLR3DECL(int) VbglR3ClipboardListHdrSend(HGCMCLIENTID idClient,
     822                                           VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
     823{
     824    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
     825
     826    VBoxClipboardListHdrMsg Msg;
     827    RT_ZERO(Msg);
     828
     829    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     830                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR);
    534831
    535832    Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
    536     Msg.uHandle.SetUInt64(hList);
     833    Msg.fFeatures.SetUInt32(pListHdr->fFeatures);
    537834    Msg.cTotalObjects.SetUInt64(pListHdr->cTotalObjects);
    538835    Msg.cbTotalSize.SetUInt64(pListHdr->cbTotalSize);
    … …  
    576873    return rc;
    577874}
     875#endif
    578876
    579877VBGLR3DECL(int) VbglR3ClipboardObjOpen(HGCMCLIENTID idClient,
    … …  
    683981    Msg.pvData.SetPtr(pvData, cbData);
    684982    Msg.cbData.SetUInt32(cbData);
    685     Msg.pvChecksum.SetPtr(NULL, 0);
    686     Msg.cbChecksum.SetUInt32(0);
     983    Msg.pvChecksum.SetPtr(NULL, 0); /** @todo Implement this. */
     984    Msg.cbChecksum.SetUInt32(0); /** @todo Implement this. */
    687985
    688986    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));

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

    r79497 r79630  
    249249    if (RT_SUCCESS(rc))
    250250    {
    251         VBOXCLIPBOARDLISTHDR Hdr;
    252         rc = SharedClipboardURIListHdrInit(&Hdr);
     251        VBOXCLIPBOARDLISTOPENPARMS openParmsList;
     252        rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
    253253        if (RT_SUCCESS(rc))
    254254        {
    255             VBOXCLIPBOARDLISTHANDLE hList;
    256             rc = SharedClipboardURITransferListOpen(pTransfer, &Hdr, &hList);
     255            SHAREDCLIPBOARDLISTHANDLE hList;
     256            rc = SharedClipboardURITransferListOpen(pTransfer, &openParmsList, &hList);
    257257            if (RT_SUCCESS(rc))
    258258            {
    259                 LogFlowFunc(("hList=%RU64, cTotalObjects=%RU64, cbTotalSize=%RU64\n\n",
    260                              hList, Hdr.cTotalObjects, Hdr.cbTotalSize));
    261 
    262                 for (uint64_t i = 0; i < Hdr.cTotalObjects; i++)
     259                LogFlowFunc(("hList=%RU64\n", hList));
     260
     261                VBOXCLIPBOARDLISTHDR hdrList;
     262                rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
     263                if (RT_SUCCESS(rc))
    263264                {
    264                     VBOXCLIPBOARDLISTENTRY Entry;
    265                     rc = SharedClipboardURITransferListRead(pTransfer, hList, &Entry);
     265                    LogFlowFunc(("cTotalObjects=%RU64, cbTotalSize=%RU64\n\n",
     266                                 hdrList.cTotalObjects, hdrList.cbTotalSize));
     267
     268                    for (uint64_t i = 0; i < hdrList.cTotalObjects; i++)
     269                    {
     270                        VBOXCLIPBOARDLISTENTRY entryList;
     271                        rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
     272                        if (RT_SUCCESS(rc))
     273                        {
     274                        }
     275                        else
     276                            break;
     277
     278                        if (pTransfer->Thread.fStop)
     279                            break;
     280                    }
     281
    266282                    if (RT_SUCCESS(rc))
    267283                    {
    268 
     284                        /*
     285                         * Signal the "list complete" event so that this data object can return (valid) data via ::GetData().
     286                         * This in turn then will create IStream instances (by the OS) for each file system object to handle.
     287                         */
     288                        int rc2 = RTSemEventSignal(pThis->m_EventListComplete);
     289                        AssertRC(rc2);
     290
     291                        LogFlowFunc(("Waiting for transfer to complete ...\n"));
     292
     293                        /* Transferring stuff can take a while, so don't use any timeout here. */
     294                        rc2 = RTSemEventWait(pThis->m_EventTransferComplete, RT_INDEFINITE_WAIT);
     295                        AssertRC(rc2);
    269296                    }
    270                     else
    271                         break;
    272 
    273                     if (pTransfer->Thread.fStop)
    274                         break;
    275                 }
    276 
    277                 if (RT_SUCCESS(rc))
    278                 {
    279                     /*
    280                      * Signal the "list complete" event so that this data object can return (valid) data via ::GetData().
    281                      * This in turn then will create IStream instances (by the OS) for each file system object to handle.
    282                      */
    283                     int rc2 = RTSemEventSignal(pThis->m_EventListComplete);
    284                     AssertRC(rc2);
    285 
    286                     LogFlowFunc(("Waiting for transfer to complete ...\n"));
    287 
    288                     /* Transferring stuff can take a while, so don't use any timeout here. */
    289                     rc2 = RTSemEventWait(pThis->m_EventTransferComplete, RT_INDEFINITE_WAIT);
    290                     AssertRC(rc2);
    291297                }
    292298
    … …  
    294300            }
    295301
    296             SharedClipboardURIListHdrDestroy(&Hdr);
     302            SharedClipboardURIListOpenParmsDestroy(&openParmsList);
    297303        }
    298304
    … …  
    497503                    if (RT_SUCCESS(rc))
    498504                    {
     505                        /* Don't block for too long here, as this also will screw other apps running on the OS. */
    499506                        LogFunc(("Waiting for listing to arrive ...\n"));
    500                         rc = RTSemEventWait(m_EventListComplete, 5 * 60 * 1000 /* 5 min timeout */);
     507                        rc = RTSemEventWait(m_EventListComplete, 10 * 1000 /* 10s timeout */);
    501508                        if (RT_SUCCESS(rc))
    502509                        {
    … …  
    530537            LogFlowFunc(("FormatIndex_FileContents: m_uObjIdx=%u\n", m_uObjIdx));
    531538
     539            SHAREDCLIPBOARDOBJHANDLE hObj = 0; /** @todo */
     540
    532541            /* Hand-in the provider so that our IStream implementation can continue working with it. */
    533             hr = VBoxClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer, m_uObjIdx, &m_pStream);
     542            hr = VBoxClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer, hObj, &m_pStream);
    534543            if (SUCCEEDED(hr))
    535544            {

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

    r79497 r79630  
    4747
    4848VBoxClipboardWinStreamImpl::VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent,
    49                                                        PSHAREDCLIPBOARDURITRANSFER pTransfer, uint64_t uObjIdx)
     49                                                       PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj)
    5050    : m_pParent(pParent)
    5151    , m_lRefCount(1)
    5252    , m_pURITransfer(pTransfer)
    53     , m_uObjIdx(uObjIdx)
     53    , m_hObj(hObj)
    5454{
    5555    AssertPtr(m_pURITransfer);
    5656
    57     LogFunc(("m_uObjIdx=%RU64\n", uObjIdx));
     57    LogFunc(("m_hObj=%RU64\n", m_hObj));
    5858}
    5959
    … …  
    160160    LogFlowThisFuncEnter();
    161161
    162     AssertPtr(m_pURITransfer->State.ObjCtx.pObjInfo);
    163 
    164     const uint64_t cbSize      = m_pURITransfer->State.ObjCtx.pObjInfo->cbObject;
    165           uint64_t cbProcessed = m_pURITransfer->State.ObjCtx.cbProcessed;
     162    const uint64_t cbSize      = m_pURITransfer->ProviderIface.pfnObjGetSize(&m_pURITransfer->ProviderCtx, m_hObj);
     163          uint64_t cbProcessed = m_pURITransfer->ProviderIface.pfnObjGetProcessed(&m_pURITransfer->ProviderCtx, m_hObj);
    166164
    167165    if (cbProcessed == cbSize)
    … …  
    181179    if (cbToRead)
    182180    {
    183         rc = m_pURITransfer->ProviderIface.pfnObjRead(&m_pURITransfer->ProviderCtx, m_pURITransfer->State.ObjCtx.uHandle,
     181        rc = m_pURITransfer->ProviderIface.pfnObjRead(&m_pURITransfer->ProviderCtx, m_hObj,
    184182                                                      pvBuffer, cbToRead, 0 /* fFlags */, &cbRead);
    185183        if (RT_SUCCESS(rc))
    … …  
    191189                m_pParent->OnTransferComplete();
    192190
    193             m_pURITransfer->State.ObjCtx.cbProcessed = cbProcessed;
     191    #if 0
     192            m_pObj->State.cbProcessed = cbProcessed;
     193            Assert(m_pObj->State.cbProcessed <= m_pObj->objInfo.cbObject);
     194    #endif
    194195        }
    195196    }
    … …  
    231232    if (pStatStg)
    232233    {
    233         const SharedClipboardURIObject *pObj = SharedClipboardURITransferGetObject(m_pURITransfer, m_uObjIdx);
    234 
    235234        RT_BZERO(pStatStg, sizeof(STATSTG));
    236235
    … …  
    243242            case STATFLAG_DEFAULT:
    244243            {
    245                 int rc2 = RTStrToUtf16(pObj->GetDestPathAbs().c_str(), &pStatStg->pwcsName);
     244                int rc2 = RTStrToUtf16(m_pURITransfer->ProviderIface.pfnObjGetPath(&m_pURITransfer->ProviderCtx, m_hObj),
     245                                       &pStatStg->pwcsName);
    246246                if (RT_FAILURE(rc2))
    247247                    hr = E_FAIL;
    … …  
    259259            pStatStg->grfMode           = STGM_READ;
    260260            pStatStg->grfLocksSupported = 0;
    261             pStatStg->cbSize.QuadPart   = pObj->GetSize();
     261            pStatStg->cbSize.QuadPart   = m_pURITransfer->ProviderIface.pfnObjGetSize(&m_pURITransfer->ProviderCtx, m_hObj);
    262262        }
    263263    }
    … …  
    295295 * @param   pParent             Pointer to the parent data object.
    296296 * @param   pTransfer           Pointer to URI transfer object to use.
    297  * @param   uObjIdx             Index of object to handle within the given URI transfer object.
     297 * @param   hObj                Handle of URI transfer object.
    298298 * @param   ppStream            Where to return the created stream object on success.
    299299 */
    300300/* static */
    301 HRESULT VBoxClipboardWinStreamImpl::Create(VBoxClipboardWinDataObject *pParent,
    302                                            PSHAREDCLIPBOARDURITRANSFER pTransfer, uint64_t uObjIdx, IStream **ppStream)
     301HRESULT VBoxClipboardWinStreamImpl::Create(VBoxClipboardWinDataObject *pParent, PSHAREDCLIPBOARDURITRANSFER pTransfer,
     302                                           SHAREDCLIPBOARDOBJHANDLE hObj, IStream **ppStream)
    303303{
    304304    AssertPtrReturn(pTransfer, E_POINTER);
    305305
    306     VBoxClipboardWinStreamImpl *pStream = new VBoxClipboardWinStreamImpl(pParent, pTransfer, uObjIdx);
     306    VBoxClipboardWinStreamImpl *pStream = new VBoxClipboardWinStreamImpl(pParent, pTransfer, hObj);
    307307    if (pStream)
    308308    {

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

    r79497 r79630  
    1919#include <VBox/log.h>
    2020
     21#include <iprt/dir.h>
     22#include <iprt/file.h>
    2123#include <iprt/path.h>
    2224#include <iprt/semaphore.h>
    … …  
    9092    {
    9193        *pListHdrDup = *pListHdr;
    92 
    93         if (pListHdr->pszFilter)
    94         {
    95             pListHdrDup->pszFilter = RTStrDup(pListHdr->pszFilter);
    96             pListHdrDup->cbFilter  = (uint32_t)strlen(pListHdrDup->pszFilter);
    97         }
    9894    }
    9995
    … …  
    111107    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
    112108
     109    LogFlowFuncEnter();
     110
    113111    SharedClipboardURIListHdrReset(pListHdr);
    114112
    … …  
    127125
    128126    LogFlowFuncEnter();
    129 
    130     if (pListHdr->pszFilter)
    131     {
    132         Assert(pListHdr->cbFilter);
    133 
    134         RTStrFree(pListHdr->pszFilter);
    135         pListHdr->pszFilter = NULL;
    136         pListHdr->cbFilter = 0;
    137     }
    138127}
    139128
    … …  
    165154}
    166155
    167 /**
    168  * Creates (allocates) and initializes a VBOXCLIPBOARDListEntry structure.
    169  *
    170  * @param   ppDirData           Where to return the created VBOXCLIPBOARDListEntry structure on success.
     156int SharedClipboardURIListOpenParmsCopy(PVBOXCLIPBOARDLISTOPENPARMS pDst, PVBOXCLIPBOARDLISTOPENPARMS pSrc)
     157{
     158    AssertPtrReturn(pDst, VERR_INVALID_POINTER);
     159    AssertPtrReturn(pSrc, VERR_INVALID_POINTER);
     160
     161    int rc = VINF_SUCCESS;
     162
     163    if (pSrc->pszFilter)
     164    {
     165        pDst->pszFilter = RTStrDup(pSrc->pszFilter);
     166        if (!pDst->pszFilter)
     167            rc = VERR_NO_MEMORY;
     168    }
     169
     170    if (   RT_SUCCESS(rc)
     171        && pSrc->pszPath)
     172    {
     173        pDst->pszPath = RTStrDup(pSrc->pszPath);
     174        if (!pDst->pszPath)
     175            rc = VERR_NO_MEMORY;
     176    }
     177
     178    if (RT_SUCCESS(rc))
     179    {
     180        pDst->fList    = pDst->fList;
     181        pDst->cbFilter = pSrc->cbFilter;
     182        pDst->cbPath   = pSrc->cbPath;
     183    }
     184
     185    return rc;
     186}
     187
     188PVBOXCLIPBOARDLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PVBOXCLIPBOARDLISTOPENPARMS pParms)
     189{
     190    AssertPtrReturn(pParms, NULL);
     191
     192    PVBOXCLIPBOARDLISTOPENPARMS pParmsDup = (PVBOXCLIPBOARDLISTOPENPARMS)RTMemAllocZ(sizeof(VBOXCLIPBOARDLISTOPENPARMS));
     193    if (!pParmsDup)
     194        return NULL;
     195
     196    int rc = SharedClipboardURIListOpenParmsCopy(pParmsDup, pParms);
     197    if (RT_FAILURE(rc))
     198    {
     199        SharedClipboardURIListOpenParmsDestroy(pParmsDup);
     200
     201        RTMemFree(pParmsDup);
     202        pParmsDup = NULL;
     203    }
     204
     205    return pParmsDup;
     206}
     207
     208int SharedClipboardURIListOpenParmsInit(PVBOXCLIPBOARDLISTOPENPARMS pParms)
     209{
     210    AssertPtrReturn(pParms, VERR_INVALID_POINTER);
     211
     212    RT_BZERO(pParms, sizeof(VBOXCLIPBOARDLISTOPENPARMS));
     213
     214    pParms->cbFilter  = 64;
     215    pParms->pszFilter = RTStrAlloc(pParms->cbFilter);
     216
     217    pParms->cbPath    = RTPATH_MAX;
     218    pParms->pszPath   = RTStrAlloc(pParms->cbPath);
     219
     220    LogFlowFuncLeave();
     221    return VINF_SUCCESS;
     222}
     223
     224void SharedClipboardURIListOpenParmsDestroy(PVBOXCLIPBOARDLISTOPENPARMS pParms)
     225{
     226    if (!pParms)
     227        return;
     228
     229    if (pParms->pszFilter)
     230    {
     231        RTStrFree(pParms->pszFilter);
     232        pParms->pszFilter = NULL;
     233    }
     234
     235    if (pParms->pszPath)
     236    {
     237        RTStrFree(pParms->pszPath);
     238        pParms->pszPath = NULL;
     239    }
     240}
     241
     242/**
     243 * Creates (allocates) and initializes a clipboard list entry structure.
     244 *
     245 * @param   ppDirData           Where to return the created clipboard list entry structure on success.
    171246 */
    172247int SharedClipboardURIListEntryAlloc(PVBOXCLIPBOARDLISTENTRY *ppListEntry)
    … …  
    184259
    185260/**
    186  * Frees a VBOXCLIPBOARDListEntry structure.
    187  *
    188  * @param   pListEntry         VBOXCLIPBOARDListEntry structure to free.
     261 * Frees a clipboard list entry structure.
     262 *
     263 * @param   pListEntry         Clipboard list entry structure to free.
    189264 */
    190265void SharedClipboardURIListEntryFree(PVBOXCLIPBOARDLISTENTRY pListEntry)
    … …  
    198273
    199274/**
    200  * Duplicates (allocates) a VBOXCLIPBOARDListEntry structure.
    201  *
    202  * @returns Duplicated VBOXCLIPBOARDListEntry structure on success.
    203  * @param   pListEntry          VBOXCLIPBOARDListEntry to duplicate.
     275 * (Deep) Copies a clipboard list entry structure.
     276 *
     277 * @returns VBox status code.
     278 * @param   pListEntry          Clipboard list entry to copy.
     279 */
     280int SharedClipboardURIListEntryCopy(PVBOXCLIPBOARDLISTENTRY pDst, PVBOXCLIPBOARDLISTENTRY pSrc)
     281{
     282    AssertPtrReturn(pDst, VERR_INVALID_POINTER);
     283    AssertPtrReturn(pSrc, VERR_INVALID_POINTER);
     284
     285    int rc = VINF_SUCCESS;
     286
     287    *pDst = *pSrc;
     288
     289    if (pSrc->pvInfo)
     290    {
     291        pDst->pvInfo = RTMemDup(pSrc->pvInfo, pSrc->cbInfo);
     292        if (pDst->pvInfo)
     293        {
     294            pDst->cbInfo = pSrc->cbInfo;
     295        }
     296        else
     297            rc = VERR_NO_MEMORY;
     298    }
     299
     300    if (RT_FAILURE(rc))
     301    {
     302        if (pDst->pvInfo)
     303        {
     304            RTMemFree(pDst->pvInfo);
     305            pDst->pvInfo = NULL;
     306            pDst->cbInfo = 0;
     307        }
     308    }
     309
     310    return rc;
     311}
     312
     313/**
     314 * Duplicates (allocates) a clipboard list entry structure.
     315 *
     316 * @returns Duplicated clipboard list entry structure on success.
     317 * @param   pListEntry          Clipboard list entry to duplicate.
    204318 */
    205319PVBOXCLIPBOARDLISTENTRY SharedClipboardURIListEntryDup(PVBOXCLIPBOARDLISTENTRY pListEntry)
    … …  
    207321    AssertPtrReturn(pListEntry, NULL);
    208322
    209     PVBOXCLIPBOARDLISTENTRY pListEntryDup = (PVBOXCLIPBOARDLISTENTRY)RTMemAlloc(sizeof(VBOXCLIPBOARDLISTENTRY));
     323    int rc = VINF_SUCCESS;
     324
     325    PVBOXCLIPBOARDLISTENTRY pListEntryDup = (PVBOXCLIPBOARDLISTENTRY)RTMemAllocZ(sizeof(VBOXCLIPBOARDLISTENTRY));
    210326    if (pListEntryDup)
    211     {
    212         *pListEntryDup = *pListEntry;
    213 
    214         if (pListEntry->pvInfo)
    215         {
    216             pListEntryDup->pvInfo= RTMemDup(pListEntry->pvInfo, pListEntry->cbInfo);
    217             pListEntryDup->cbInfo = pListEntry->cbInfo;
    218         }
     327        rc = SharedClipboardURIListEntryCopy(pListEntryDup, pListEntry);
     328
     329    if (RT_FAILURE(rc))
     330    {
     331        SharedClipboardURIListEntryDestroy(pListEntryDup);
     332
     333        RTMemFree(pListEntryDup);
     334        pListEntryDup = NULL;
    219335    }
    220336
    … …  
    223339
    224340/**
    225  * Initializes a VBOXCLIPBOARDListEntry structure.
    226  *
    227  * @param   pListEntry          VBOXCLIPBOARDListEntry structure to initialize.
     341 * Initializes a clipboard list entry structure.
     342 *
     343 * @param   pListEntry          clipboard list entry structure to initialize.
    228344 */
    229345int SharedClipboardURIListEntryInit(PVBOXCLIPBOARDLISTENTRY pListEntry)
    … …  
    235351
    236352/**
    237  * Initializes a VBOXCLIPBOARDListEntry structure.
    238  *
    239  * @param   pListEntry          VBOXCLIPBOARDListEntry structure to destroy.
     353 * Initializes a clipboard list entry structure.
     354 *
     355 * @param   pListEntry          clipboard list entry structure to destroy.
    240356 */
    241357void SharedClipboardURIListEntryDestroy(PVBOXCLIPBOARDLISTENTRY pListEntry)
    242358{
     359    if (!pListEntry)
     360        return;
     361
    243362    if (pListEntry->pvInfo)
    244363    {
    … …  
    543662
    544663    pObjCtx->uHandle  = SHAREDCLIPBOARDOBJHANDLE_INVALID;
    545     pObjCtx->pObjInfo = NULL;
    546664
    547665    return VINF_SUCCESS;
    … …  
    558676
    559677    LogFlowFuncEnter();
    560 
    561     pObjCtx->pObjInfo = NULL;
    562678}
    563679
    … …  
    571687{
    572688    return (   pObjCtx
    573             && pObjCtx->uHandle != SHAREDCLIPBOARDOBJHANDLE_INVALID
    574             && pObjCtx->pObjInfo);
     689            && pObjCtx->uHandle != SHAREDCLIPBOARDOBJHANDLE_INVALID);
    575690}
    576691
    … …  
    615730    RT_ZERO(pTransfer->Callbacks);
    616731
    617     pTransfer->pURIList = new SharedClipboardURIList();
    618     if (pTransfer->pURIList)
    619     {
    620         pTransfer->Events.pMap = new SharedClipboardURITransferEventMap();
    621         if (pTransfer->Events.pMap)
    622         {
    623             rc = SharedClipboardURIObjCtxInit(&pTransfer->State.ObjCtx);
    624             if (RT_SUCCESS(rc))
    625             {
    626                 *ppTransfer = pTransfer;
    627             }
    628         }
    629         else
    630             rc = VERR_NO_MEMORY;
     732    pTransfer->pMapEvents = new SharedClipboardURITransferEventMap();
     733    if (pTransfer->pMapEvents)
     734    {
     735        pTransfer->pMapLists = new SharedClipboardURIListMap();
     736        if (pTransfer->pMapLists)
     737        {
     738            *ppTransfer = pTransfer;
     739        }
    631740    }
    632741    else
    … …  
    659768        return rc;
    660769
    661     if (pTransfer->pURIList)
    662     {
    663         delete pTransfer->pURIList;
    664         pTransfer->pURIList = NULL;
    665     }
    666 
    667     if (pTransfer->Events.pMap)
    668     {
    669         delete pTransfer->Events.pMap;
    670         pTransfer->Events.pMap = NULL;
    671     }
    672 
    673     SharedClipboardURIObjCtxDestroy(&pTransfer->State.ObjCtx);
     770    if (pTransfer->pMapEvents)
     771    {
     772        delete pTransfer->pMapEvents;
     773        pTransfer->pMapEvents = NULL;
     774    }
     775
     776    if (pTransfer->pMapLists)
     777    {
     778        delete pTransfer->pMapLists;
     779        pTransfer->pMapLists = NULL;
     780    }
    674781
    675782    LogFlowFuncLeave();
    … …  
    699806}
    700807
    701 int SharedClipboardURITransferListOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDLISTHDR pListHdr,
    702                                        PVBOXCLIPBOARDLISTHANDLE phList)
     808static SHAREDCLIPBOARDLISTHANDLE sharedClipboardURITransferListHandleNew(PSHAREDCLIPBOARDURITRANSFER pTransfer)
     809{
     810    RT_NOREF(pTransfer);
     811
     812    return 42; /** @todo FIX !!!!! */
     813}
     814
     815int SharedClipboardURITransferListOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms,
     816                                       PSHAREDCLIPBOARDLISTHANDLE phList)
     817{
     818    AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
     819    AssertPtrReturn(pOpenParms, VERR_INVALID_POINTER);
     820    AssertPtrReturn(phList,     VERR_INVALID_POINTER);
     821
     822    int rc;
     823
     824    SHAREDCLIPBOARDLISTHANDLE hList = SHAREDCLIPBOARDLISTHANDLE_INVALID;
     825
     826    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
     827    {
     828        PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo
     829            = (PSHAREDCLIPBOARDURILISTHANDLEINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDURILISTHANDLEINFO));
     830        if (pInfo)
     831        {
     832            if (   !pOpenParms->pszPath
     833                || !strlen(pOpenParms->pszPath))
     834                RTStrAPrintf(&pOpenParms->pszPath, "C:\\Temp"); /** @todo FIX !!!! */
     835
     836            RTFSOBJINFO objInfo;
     837            rc = RTPathQueryInfo(pOpenParms->pszPath, &objInfo, RTFSOBJATTRADD_NOTHING);
     838            if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
     839            {
     840                rc = RTDirOpen(&pInfo->u.Local.hDirRoot, pOpenParms->pszPath);
     841            }
     842            else if (RTFS_IS_FILE(objInfo.Attr.fMode))
     843            {
     844                rc = RTFileOpen(&pInfo->u.Local.hFile, pOpenParms->pszPath, RTFILE_O_READ | RTFILE_O_DENY_WRITE);
     845            }
     846            else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode))
     847            {
     848                rc = VERR_NOT_IMPLEMENTED; /** @todo */
     849            }
     850            else
     851                AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
     852
     853            if (RT_SUCCESS(rc))
     854                rc = SharedClipboardURIListOpenParmsCopy(&pInfo->OpenParms, pOpenParms);
     855
     856            if (RT_SUCCESS(rc))
     857            {
     858                pInfo->fMode = objInfo.Attr.fMode;
     859
     860                hList = sharedClipboardURITransferListHandleNew(pTransfer);
     861
     862                pTransfer->pMapLists->insert(
     863                    std::pair<SHAREDCLIPBOARDLISTHANDLE, PSHAREDCLIPBOARDURILISTHANDLEINFO>(hList, pInfo));
     864            }
     865            else
     866            {
     867                if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
     868                {
     869                    if (RTDirIsValid(pInfo->u.Local.hDirRoot))
     870                        RTDirClose(pInfo->u.Local.hDirRoot);
     871                }
     872                else if (RTFS_IS_FILE(objInfo.Attr.fMode))
     873                {
     874                    if (RTFileIsValid(pInfo->u.Local.hFile))
     875                        RTFileClose(pInfo->u.Local.hFile);
     876                }
     877
     878                RTMemFree(pInfo);
     879                pInfo = NULL;
     880            }
     881        }
     882        else
     883            rc = VERR_NO_MEMORY;
     884    }
     885    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
     886    {
     887        if (pTransfer->ProviderIface.pfnListOpen)
     888        {
     889            rc = pTransfer->ProviderIface.pfnListOpen(&pTransfer->ProviderCtx, pOpenParms, &hList);
     890        }
     891        else
     892            rc = VERR_NOT_SUPPORTED;
     893    }
     894    else
     895        AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
     896
     897    if (RT_SUCCESS(rc))
     898        *phList = hList;
     899
     900    LogFlowFuncLeaveRC(rc);
     901    return rc;
     902}
     903
     904int SharedClipboardURITransferListClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList)
    703905{
    704906    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    705     AssertPtrReturn(pListHdr,  VERR_INVALID_POINTER);
    706     /* phList is optional. */
     907
     908    if (hList == SHAREDCLIPBOARDLISTHANDLE_INVALID)
     909        return VINF_SUCCESS;
    707910
    708911    int rc = VINF_SUCCESS;
    709912
    710     VBOXCLIPBOARDLISTHANDLE hList = SHAREDCLIPBOARDLISTHANDLE_INVALID;
    711 
    712     if (pTransfer->ProviderIface.pfnListOpen)
    713         rc = pTransfer->ProviderIface.pfnListOpen(&pTransfer->ProviderCtx, pListHdr, &hList);
    714 
     913    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
     914    {
     915        SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->find(hList);
     916        if (itList != pTransfer->pMapLists->end())
     917        {
     918            PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = itList->second;
     919            AssertPtr(pInfo);
     920
     921            if (RTDirIsValid(pInfo->u.Local.hDirRoot))
     922                RTDirClose(pInfo->u.Local.hDirRoot);
     923
     924            RTMemFree(pInfo);
     925
     926            pTransfer->pMapLists->erase(itList);
     927        }
     928        else
     929            rc = VERR_NOT_FOUND;
     930    }
     931    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
     932    {
     933        if (pTransfer->ProviderIface.pfnListClose)
     934        {
     935            rc = pTransfer->ProviderIface.pfnListClose(&pTransfer->ProviderCtx, hList);
     936        }
     937        else
     938            rc = VERR_NOT_SUPPORTED;
     939    }
     940
     941    LogFlowFuncLeaveRC(rc);
     942    return rc;
     943}
     944
     945static int sharedClipboardURITransferListHdrAddFile(PVBOXCLIPBOARDLISTHDR pHdr, const char *pszPath)
     946{
     947    uint64_t cbSize = 0;
     948    int rc = RTFileQuerySize(pszPath, &cbSize);
    715949    if (RT_SUCCESS(rc))
    716950    {
    717         AssertPtr(pTransfer->ProviderIface.pfnListHdrRead);
    718         rc = pTransfer->ProviderIface.pfnListHdrRead(&pTransfer->ProviderCtx, hList, pListHdr);
    719     }
    720 
     951        pHdr->cbTotalSize  += cbSize;
     952        pHdr->cTotalObjects++;
     953    }
     954
     955    LogFlowFuncLeaveRC(rc);
     956    return rc;
     957}
     958
     959static int sharedClipboardURITransferListHdrFromDir(PVBOXCLIPBOARDLISTHDR pHdr,
     960                                                    const char *pcszSrcPath, const char *pcszDstPath,
     961                                                    const char *pcszDstBase, size_t cchDstBase)
     962{
     963    AssertPtrReturn(pcszSrcPath, VERR_INVALID_POINTER);
     964    AssertPtrReturn(pcszDstBase, VERR_INVALID_POINTER);
     965    AssertPtrReturn(pcszDstPath, VERR_INVALID_POINTER);
     966
     967    LogFlowFunc(("pcszSrcPath=%s, pcszDstPath=%s, pcszDstBase=%s, cchDstBase=%zu\n",
     968                 pcszSrcPath, pcszDstPath, pcszDstBase, cchDstBase));
     969
     970    RTFSOBJINFO objInfo;
     971    int rc = RTPathQueryInfo(pcszSrcPath, &objInfo, RTFSOBJATTRADD_NOTHING);
    721972    if (RT_SUCCESS(rc))
    722973    {
    723         if (phList)
    724             *phList = hList;
    725     }
    726     else if (pTransfer->ProviderIface.pfnListClose)
    727     {
    728         int rc2 = pTransfer->ProviderIface.pfnListClose(&pTransfer->ProviderCtx, hList);
    729         AssertRC(rc2);
     974        if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
     975        {
     976            pHdr->cTotalObjects++; /* Add directory itself. */
     977
     978            if (RT_SUCCESS(rc))
     979            {
     980                RTDIR hDir;
     981                rc = RTDirOpen(&hDir, pcszSrcPath);
     982                if (RT_SUCCESS(rc))
     983                {
     984                    size_t        cbDirEntry = 0;
     985                    PRTDIRENTRYEX pDirEntry  = NULL;
     986                    do
     987                    {
     988                        /* Retrieve the next directory entry. */
     989                        rc = RTDirReadExA(hDir, &pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
     990                        if (RT_FAILURE(rc))
     991                        {
     992                            if (rc == VERR_NO_MORE_FILES)
     993                                rc = VINF_SUCCESS;
     994                            break;
     995                        }
     996
     997                        switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
     998                        {
     999                            case RTFS_TYPE_DIRECTORY:
     1000                            {
     1001                                /* Skip "." and ".." entries. */
     1002                                if (RTDirEntryExIsStdDotLink(pDirEntry))
     1003                                    break;
     1004
     1005                                char *pszSrc = RTPathJoinA(pcszSrcPath, pDirEntry->szName);
     1006                                if (pszSrc)
     1007                                {
     1008                                    char *pszDst = RTPathJoinA(pcszDstPath, pDirEntry->szName);
     1009                                    if (pszDst)
     1010                                    {
     1011                                        rc = sharedClipboardURITransferListHdrFromDir(pHdr, pszSrc, pszDst,
     1012                                                                                      pcszDstBase, cchDstBase);
     1013                                        RTStrFree(pszDst);
     1014                                    }
     1015                                    else
     1016                                        rc = VERR_NO_MEMORY;
     1017
     1018                                    RTStrFree(pszSrc);
     1019                                }
     1020                                else
     1021                                    rc = VERR_NO_MEMORY;
     1022                                break;
     1023                            }
     1024
     1025                            case RTFS_TYPE_FILE:
     1026                            {
     1027                                char *pszSrc = RTPathJoinA(pcszSrcPath, pDirEntry->szName);
     1028                                if (pszSrc)
     1029                                {
     1030                                    rc = sharedClipboardURITransferListHdrAddFile(pHdr, pszSrc);
     1031                                    RTStrFree(pszSrc);
     1032                                }
     1033                                else
     1034                                    rc = VERR_NO_MEMORY;
     1035                                break;
     1036                            }
     1037                            case RTFS_TYPE_SYMLINK:
     1038                            {
     1039                                /** @todo Not implemented yet. */
     1040                            }
     1041
     1042                            default:
     1043                                break;
     1044                        }
     1045
     1046                    } while (RT_SUCCESS(rc));
     1047
     1048                    RTDirReadExAFree(&pDirEntry, &cbDirEntry);
     1049                    RTDirClose(hDir);
     1050                }
     1051            }
     1052        }
     1053        else if (RTFS_IS_FILE(objInfo.Attr.fMode))
     1054        {
     1055            rc = sharedClipboardURITransferListHdrAddFile(pHdr, pcszSrcPath);
     1056        }
     1057        else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode))
     1058        {
     1059            /** @todo Not implemented yet. */
     1060        }
     1061        else
     1062            rc = VERR_NOT_SUPPORTED;
    7301063    }
    7311064
    … …  
    7341067}
    7351068
    736 int SharedClipboardURITransferListClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, VBOXCLIPBOARDLISTHANDLE hList)
     1069int SharedClipboardURITransferListGetHeader(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
     1070                                            PVBOXCLIPBOARDLISTHDR pHdr)
    7371071{
    7381072    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     1073    AssertPtrReturn(pHdr,      VERR_INVALID_POINTER);
     1074
     1075    int rc;
     1076
     1077    LogFlowFunc(("hList=%RU64\n", hList));
     1078
     1079    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
     1080    {
     1081        SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->find(hList);
     1082        if (itList != pTransfer->pMapLists->end())
     1083        {
     1084            rc = SharedClipboardURIListHdrInit(pHdr);
     1085            if (RT_SUCCESS(rc))
     1086            {
     1087                PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = itList->second;
     1088                AssertPtr(pInfo);
     1089
     1090                if (RTFS_IS_DIRECTORY(pInfo->fMode))
     1091                {
     1092                    char *pszSrcPath = RTStrDup(pInfo->OpenParms.pszPath);
     1093                    if (pszSrcPath)
     1094                    {
     1095                        size_t cbSrcPathLen = RTPathStripTrailingSlash(pszSrcPath);
     1096                        if (cbSrcPathLen)
     1097                        {
     1098                            char *pszFileName = RTPathFilename(pszSrcPath);
     1099                            if (pszFileName)
     1100                            {
     1101                                Assert(pszFileName >= pszSrcPath);
     1102                                size_t cchDstBase = pszFileName - pszSrcPath;
     1103                                char *pszDstPath  = &pszSrcPath[cchDstBase];
     1104
     1105                                LogFlowFunc(("pszSrcPath=%s, pszFileName=%s, pszDstPath=%s\n", pszSrcPath, pszFileName, pszDstPath));
     1106                                rc = sharedClipboardURITransferListHdrFromDir(pHdr,
     1107                                                                              pszSrcPath, pszSrcPath, pszSrcPath, cchDstBase);
     1108                            }
     1109                            else
     1110                                rc = VERR_PATH_NOT_FOUND;
     1111                        }
     1112                        else
     1113                            rc = VERR_INVALID_PARAMETER;
     1114
     1115                        RTStrFree(pszSrcPath);
     1116                    }
     1117                    else
     1118                        rc = VERR_NO_MEMORY;
     1119                }
     1120                else if (RTFS_IS_FILE(pInfo->fMode))
     1121                {
     1122                    pHdr->cTotalObjects = 1;
     1123
     1124                    RTFSOBJINFO objInfo;
     1125                    rc = RTFileQueryInfo(pInfo->u.Local.hFile, &objInfo, RTFSOBJATTRADD_NOTHING);
     1126                    if (RT_SUCCESS(rc))
     1127                    {
     1128                        pHdr->cbTotalSize = objInfo.cbObject;
     1129                    }
     1130                }
     1131                else if (RTFS_IS_SYMLINK(pInfo->fMode))
     1132                {
     1133                    rc = VERR_NOT_IMPLEMENTED; /** @todo */
     1134                }
     1135                else
     1136                    AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
     1137            }
     1138        }
     1139        else
     1140            rc = VERR_NOT_FOUND;
     1141    }
     1142    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
     1143    {
     1144        if (pTransfer->ProviderIface.pfnListHdrRead)
     1145        {
     1146            rc = pTransfer->ProviderIface.pfnListHdrRead(&pTransfer->ProviderCtx, hList, pHdr);
     1147        }
     1148        else
     1149            rc = VERR_NOT_SUPPORTED;
     1150    }
     1151    else
     1152        AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
     1153
     1154    LogFlowFuncLeaveRC(rc);
     1155    return rc;
     1156}
     1157
     1158/**
     1159 * Returns the current URI object for a clipboard URI transfer list.
     1160 *
     1161 * @returns Pointer to URI object.
     1162 * @param   pTransfer           URI clipboard transfer to return URI object for.
     1163 */
     1164PSHAREDCLIPBOARDURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHAREDCLIPBOARDURITRANSFER pTransfer,
     1165                                                                    SHAREDCLIPBOARDLISTHANDLE hList, uint64_t uIdx)
     1166{
     1167    AssertPtrReturn(pTransfer, NULL);
     1168
     1169    RT_NOREF(hList, uIdx);
     1170
     1171    LogFlowFunc(("hList=%RU64\n", hList));
     1172
     1173    return NULL;
     1174}
     1175
     1176int SharedClipboardURITransferListRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
     1177                                       PVBOXCLIPBOARDLISTENTRY pEntry)
     1178{
     1179    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     1180    AssertPtrReturn(pEntry,    VERR_INVALID_POINTER);
    7391181
    7401182    int rc = VINF_SUCCESS;
    7411183
    742     if (pTransfer->ProviderIface.pfnListClose)
    743         rc = pTransfer->ProviderIface.pfnListClose(&pTransfer->ProviderCtx, hList);
     1184    LogFlowFunc(("hList=%RU64\n", hList));
     1185
     1186    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
     1187    {
     1188        SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->find(hList);
     1189        if (itList != pTransfer->pMapLists->end())
     1190        {
     1191            PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = itList->second;
     1192            AssertPtr(pInfo);
     1193
     1194            if (RTFS_IS_DIRECTORY(pInfo->fMode))
     1195            {
     1196                size_t        cbDirEntry = 0;
     1197                PRTDIRENTRYEX pDirEntry  = NULL;
     1198                rc = RTDirReadExA(pInfo->u.Local.hDirRoot, &pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
     1199                if (RT_SUCCESS(rc))
     1200                {
     1201                    switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
     1202                    {
     1203                        case RTFS_TYPE_DIRECTORY:
     1204                        {
     1205                            /* Skip "." and ".." entries. */
     1206                            if (RTDirEntryExIsStdDotLink(pDirEntry))
     1207                                break;
     1208
     1209                            RT_FALL_THROUGH();
     1210                        }
     1211
     1212                        case RTFS_TYPE_FILE:
     1213                        {
     1214                            pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
     1215                            if (pEntry->pvInfo)
     1216                            {
     1217                                SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
     1218
     1219                                pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
     1220                                pEntry->fInfo  = 0; /** @todo Implement. */
     1221                            }
     1222                            else
     1223                                rc = VERR_NO_MEMORY;
     1224                            break;
     1225                        }
     1226
     1227                        case RTFS_TYPE_SYMLINK:
     1228                        {
     1229                            /** @todo Not implemented yet. */
     1230                            break;
     1231                        }
     1232
     1233                        default:
     1234                            break;
     1235                    }
     1236
     1237                    RTDirReadExAFree(&pDirEntry, &cbDirEntry);
     1238                }
     1239            }
     1240            else if (RTFS_IS_FILE(pInfo->fMode))
     1241            {
     1242                RTFSOBJINFO objInfo;
     1243                rc = RTFileQueryInfo(pInfo->u.Local.hFile, &objInfo, RTFSOBJATTRADD_NOTHING);
     1244                if (RT_SUCCESS(rc))
     1245                {
     1246                    pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
     1247                    if (pEntry->pvInfo)
     1248                    {
     1249                        SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &objInfo);
     1250
     1251                        pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
     1252                        pEntry->fInfo  = 0; /** @todo Implement. */
     1253                    }
     1254                    else
     1255                        rc = VERR_NO_MEMORY;
     1256                }
     1257            }
     1258            else if (RTFS_IS_SYMLINK(pInfo->fMode))
     1259            {
     1260                rc = VERR_NOT_IMPLEMENTED;
     1261            }
     1262            else
     1263                AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
     1264        }
     1265        else
     1266            rc = VERR_NOT_FOUND;
     1267    }
     1268    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
     1269    {
     1270        if (pTransfer->ProviderIface.pfnListEntryRead)
     1271            rc = pTransfer->ProviderIface.pfnListEntryRead(&pTransfer->ProviderCtx, hList, pEntry);
     1272        else
     1273            rc = VERR_NOT_SUPPORTED;
     1274    }
    7441275
    7451276    LogFlowFuncLeaveRC(rc);
    … …  
    7471278}
    7481279
    749 int SharedClipboardURITransferListRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, VBOXCLIPBOARDLISTHANDLE hList,
    750                                        PVBOXCLIPBOARDLISTENTRY pEntry)
    751 {
    752     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     1280int SharedClipboardURITransferListWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
     1281                                        PVBOXCLIPBOARDLISTENTRY pEntry)
     1282{
     1283    RT_NOREF(pTransfer, hList, pEntry);
    7531284
    7541285    int rc = VINF_SUCCESS;
    7551286
    756     if (pTransfer->ProviderIface.pfnListEntryRead)
    757         rc = pTransfer->ProviderIface.pfnListEntryRead(&pTransfer->ProviderCtx, hList, pEntry);
    758 
    759     LogFlowFuncLeaveRC(rc);
    760     return rc;
    761 }
    762 
    763 int SharedClipboardURITransferListWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, VBOXCLIPBOARDLISTHANDLE hList,
    764                                         PVBOXCLIPBOARDLISTENTRY pEntry)
    765 {
    766     int rc = VINF_SUCCESS;
    767 
     1287#if 0
    7681288    if (pTransfer->ProviderIface.pfnListEntryWrite)
    7691289        rc = pTransfer->ProviderIface.pfnListEntryWrite(&pTransfer->ProviderCtx, hList, pEntry);
     1290#endif
    7701291
    7711292    LogFlowFuncLeaveRC(rc);
    … …  
    7731294}
    7741295
    775 bool SharedClipboardURITransferListHandleIsValid(PSHAREDCLIPBOARDURITRANSFER pTransfer, VBOXCLIPBOARDLISTHANDLE hList)
    776 {
    777     RT_NOREF(pTransfer, hList);
    778 
    779     return true; /** @todo Implement this. */
     1296bool SharedClipboardURITransferListHandleIsValid(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList)
     1297{
     1298    bool fIsValid = false;
     1299
     1300    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
     1301    {
     1302        SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->find(hList);
     1303        fIsValid = itList != pTransfer->pMapLists->end();
     1304    }
     1305    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
     1306    {
     1307        AssertFailed(); /** @todo Implement. */
     1308    }
     1309
     1310    return fIsValid;
    7801311}
    7811312
    … …  
    8171348
    8181349/**
    819  * Creates an URI provider for a given transfer.
     1350 * Sets the URI provider interface for a given transfer.
    8201351 *
    8211352 * @returns VBox status code.
    … …  
    8231354 * @param   pCreationCtx        Provider creation context to use for provider creation.
    8241355 */
    825 int SharedClipboardURITransferProviderCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer,
    826                                              PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx)
     1356int SharedClipboardURITransferSetInterface(PSHAREDCLIPBOARDURITRANSFER pTransfer,
     1357                                           PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx)
    8271358{
    8281359    AssertPtrReturn(pTransfer,    VERR_INVALID_POINTER);
    … …  
    8541385
    8551386    /** @todo Anything else to do here? */
    856 
    857     if (pTransfer->pURIList)
    858         pTransfer->pURIList->Clear();
    859 
    860     SharedClipboardURIObjCtxDestroy(&pTransfer->State.ObjCtx);
    8611387}
    8621388
    … …  
    8721398
    8731399    return pTransfer->pArea;
    874 }
    875 
    876 /**
    877  * Returns the current object context of a clipboard URI transfer.
    878  *
    879  * @returns Current object context, or NULL if none.
    880  * @param   pTransfer           URI clipboard transfer to return object context for.
    881  */
    882 PSHAREDCLIPBOARDCLIENTURIOBJCTX SharedClipboardURITransferGetCurrentObjCtx(PSHAREDCLIPBOARDURITRANSFER pTransfer)
    883 {
    884     /* At the moment we only have one object context per transfer at a time. */
    885     return &pTransfer->State.ObjCtx;
    886 }
    887 
    888 /**
    889  * Returns the current URI object for a clipboard URI transfer.
    890  *
    891  * @returns Current URI object, or NULL if none.
    892  * @param   pTransfer           URI clipboard transfer to return current URI object for.
    893  */
    894 const SharedClipboardURIObject *SharedClipboardURITransferGetCurrentObject(PSHAREDCLIPBOARDURITRANSFER pTransfer)
    895 {
    896     AssertPtrReturn(pTransfer, NULL);
    897 
    898     if (pTransfer->pURIList)
    899         return pTransfer->pURIList->First();
    900 
    901     return NULL;
    902 }
    903 
    904 /**
    905  * Returns the URI list for a clipboard URI transfer.
    906  *
    907  * @returns Pointer to URI list.
    908  * @param   pTransfer           URI clipboard transfer to return URI list for.
    909  */
    910 SharedClipboardURIList *SharedClipboardURITransferGetList(PSHAREDCLIPBOARDURITRANSFER pTransfer)
    911 {
    912     AssertPtrReturn(pTransfer, NULL);
    913 
    914     return pTransfer->pURIList;
    915 }
    916 
    917 /**
    918  * Returns the current URI object for a clipboard URI transfer.
    919  *
    920  * @returns Pointer to URI object.
    921  * @param   pTransfer           URI clipboard transfer to return URI object for.
    922  */
    923 SharedClipboardURIObject *SharedClipboardURITransferGetObject(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint64_t uIdx)
    924 {
    925     AssertPtrReturn(pTransfer, NULL);
    926 
    927     if (!pTransfer->pURIList)
    928         return NULL;
    929 
    930     return pTransfer->pURIList->At(uIdx);
    9311400}
    9321401
    … …  
    10511520    int rc;
    10521521
    1053     SharedClipboardURITransferEventMap::iterator itEvent = pTransfer->Events.pMap->find(uID);
    1054     if (itEvent == pTransfer->Events.pMap->end())
     1522    SharedClipboardURITransferEventMap::iterator itEvent = pTransfer->pMapEvents->find(uID);
     1523    if (itEvent == pTransfer->pMapEvents->end())
    10551524    {
    10561525        PSHAREDCLIPBOARDURITRANSFEREVENT pEvent
    … …  
    10611530            if (RT_SUCCESS(rc))
    10621531            {
    1063                 pTransfer->Events.pMap->insert(std::pair<uint32_t, PSHAREDCLIPBOARDURITRANSFEREVENT>(uID, pEvent)); /** @todo Can this throw? */
     1532                pTransfer->pMapEvents->insert(std::pair<uint32_t, PSHAREDCLIPBOARDURITRANSFEREVENT>(uID, pEvent)); /** @todo Can this throw? */
    10641533            }
    10651534        }
    … …  
    10781547    int rc;
    10791548
    1080     SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->Events.pMap->find(uID);
    1081     if (itEvent != pTransfer->Events.pMap->end())
     1549    SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->pMapEvents->find(uID);
     1550    if (itEvent != pTransfer->pMapEvents->end())
    10821551    {
    10831552        SharedClipboardURITransferPayloadFree(itEvent->second->pPayload);
    … …  
    10871556        RTMemFree(itEvent->second);
    10881557
    1089         pTransfer->Events.pMap->erase(itEvent);
     1558        pTransfer->pMapEvents->erase(itEvent);
    10901559
    10911560        rc = VINF_SUCCESS;
    … …  
    11051574    int rc;
    11061575
    1107     SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->Events.pMap->find(uID);
    1108     if (itEvent != pTransfer->Events.pMap->end())
     1576    SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->pMapEvents->find(uID);
     1577    if (itEvent != pTransfer->pMapEvents->end())
    11091578    {
    11101579        rc = RTSemEventWait(itEvent->second->hEventSem, uTimeoutMs);
    … …  
    11281597    int rc;
    11291598
    1130     SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->Events.pMap->find(uID);
    1131     if (itEvent != pTransfer->Events.pMap->end())
     1599    SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->pMapEvents->find(uID);
     1600    if (itEvent != pTransfer->pMapEvents->end())
    11321601    {
    11331602        Assert(itEvent->second->pPayload == NULL);

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

    r79503 r79630  
    150150    /** Optional protocol version the client uses. Set to 0 by default. */
    151151    uint32_t                 uProtocolVer;
    152     /** Flag indicating whether this client currently is deferred mode,
    153      *  meaning that it did not return to the caller yet. */
    154     bool                     fDeferred;
    155     /** Structure for keeping the client's deferred state.
     152    /** Structure for keeping the client's pending (deferred return) state.
    156153     *  A client is in a deferred state when it asks for the next HGCM message,
    157154     *  but the service can't provide it yet. That way a client will block (on the guest side, does not return)
    … …  
    161158        /** The client's HGCM call handle. Needed for completing a deferred call. */
    162159        VBOXHGCMCALLHANDLE hHandle;
    163         /** Message type (function number) to use when completing the deferred call. */
     160        /** Message type (function number) to use when completing the deferred call.
     161         *  A non-0 value means the client is in pending mode. */
    164162        uint32_t           uType;
    165163        /** Parameter count to use when completing the deferred call. */
    … …  
    167165        /** Parameters to use when completing the deferred call. */
    168166        PVBOXHGCMSVCPARM   paParms;
    169     } Deferred;
     167    } Pending;
    170168} VBOXCLIPBOARDCLIENT, *PVBOXCLIPBOARDCLIENT;
    171169
    … …  
    184182int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENTDATA pClientData, SHAREDCLIPBOARDSOURCE enmSource);
    185183
    186 int vboxSvcClipboardClientDefer(PVBOXCLIPBOARDCLIENT pClient,
    187                                 VBOXHGCMCALLHANDLE hHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    188 int vboxSvcClipboardClientComplete(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hHandle, int rc);
    189 int vboxSvcClipboardClientDeferredComplete(PVBOXCLIPBOARDCLIENT pClient, int rc);
    190 int vboxSvcClipboardClientDeferredSetMsgInfo(PVBOXCLIPBOARDCLIENT pClient, uint32_t uMsg, uint32_t cParms);
    191 
    192184void vboxSvcClipboardMsgQueueReset(PVBOXCLIPBOARDCLIENTDATA pClientData);
    193185PVBOXCLIPBOARDCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms);
    194186void vboxSvcClipboardMsgFree(PVBOXCLIPBOARDCLIENTMSG pMsg);
     187void vboxSvcClipboardMsgSetPeekReturn(PVBOXCLIPBOARDCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
    195188int vboxSvcClipboardMsgAdd(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDCLIENTMSG pMsg, bool fAppend);
    196 int vboxSvcClipboardMsgGetNextInfo(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t *puType, uint32_t *pcParms);
    197 int vboxSvcClipboardMsgGetNext(PVBOXCLIPBOARDCLIENTDATA pClientData,
    198                                uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     189int vboxSvcClipboardMsgPeek(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
     190int vboxSvcClipboardMsgGet(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     191
     192int vboxSvcClipboardClientWakeup(PVBOXCLIPBOARDCLIENT pClient);
    199193
    200194# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    … …  
    226220
    227221int vboxSvcClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    228                                 PVBOXCLIPBOARDLISTHDR pListHdr, PVBOXCLIPBOARDLISTHANDLE phList);
    229 int vboxSvcClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, VBOXCLIPBOARDLISTHANDLE hList);
    230 int vboxSvcClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, VBOXCLIPBOARDLISTHANDLE hList,
     222                                PVBOXCLIPBOARDLISTHDR pListHdr, PSHAREDCLIPBOARDLISTHANDLE phList);
     223int vboxSvcClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList);
     224int vboxSvcClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    231225                                   PVBOXCLIPBOARDLISTHDR pListHdr);
    232 int vboxSvcClipboardURIListHdrWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, VBOXCLIPBOARDLISTHANDLE hList,
     226int vboxSvcClipboardURIListHdrWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    233227                                    PVBOXCLIPBOARDLISTHDR pListHdr);
    234 int vboxSvcClipboardURIListEntryRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, VBOXCLIPBOARDLISTHANDLE hList,
     228int vboxSvcClipboardURIListEntryRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    235229                                     PVBOXCLIPBOARDLISTENTRY pListEntry);
    236 int vboxSvcClipboardURIListEntryWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, VBOXCLIPBOARDLISTHANDLE hList,
     230int vboxSvcClipboardURIListEntryWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    237231                                      PVBOXCLIPBOARDLISTENTRY pListEntry);
    238232

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

    r79497 r79630  
    4141extern PFNHGCMSVCEXT g_pfnExtension;
    4242extern void *g_pvExtension;
     43extern PVBOXHGCMSVCHELPERS g_pHelpers;
    4344
    4445extern ClipboardClientQueue g_listClientsDeferred;
     46
     47
     48/*********************************************************************************************************************************
     49*   Prototypes                                                                                                                   *
     50*********************************************************************************************************************************/
     51int VBoxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     52                                   PVBOXCLIPBOARDLISTOPENPARMS pOpenParms);
    4553
    4654
    … …  
    6674
    6775DECLCALLBACK(int) vboxSvcClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    68                                               PVBOXCLIPBOARDLISTHDR pListHdr, PVBOXCLIPBOARDLISTHANDLE phList)
    69 {
    70     RT_NOREF(pCtx, pListHdr, phList);
    71 
    72     LogFlowFuncEnter();
    73 
    74     int rc = VINF_SUCCESS;
    75 
    76     LogFlowFuncLeaveRC(rc);
    77     return rc;
    78 }
    79 
    80 DECLCALLBACK(int) vboxSvcClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, VBOXCLIPBOARDLISTHANDLE hList)
    81 {
    82     RT_NOREF(pCtx, hList);
    83 
    84     LogFlowFuncEnter();
    85 
    86     int rc = VINF_SUCCESS;
    87 
    88     LogFlowFuncLeaveRC(rc);
    89     return rc;
    90 }
    91 
    92 DECLCALLBACK(int) vboxSvcClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    93                                                  VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
    94 {
    95     RT_NOREF(pCtx, hList, pListHdr);
     76                                              PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList)
     77{
     78    RT_NOREF(phList);
    9679
    9780    LogFlowFuncEnter();
    … …  
    10285    int rc;
    10386
    104     PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ,
    105                                                             VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ);
     87    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN,
     88                                                            VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
    10689    if (pMsg)
    10790    {
    108         rc = vboxSvcClipboardMsgAdd(&pClient->pData->State, pMsg, true /* fAppend */);
    109         if (RT_SUCCESS(rc))
    110             rc = vboxSvcClipboardClientDeferredComplete(pClient, VINF_SUCCESS);
     91        rc = VBoxSvcClipboardURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, pOpenParms);
     92        if (RT_SUCCESS(rc))
     93        {
     94            rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
     95            if (RT_SUCCESS(rc))
     96            {
     97                int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN);
     98                AssertRC(rc2);
     99
     100                vboxSvcClipboardClientWakeup(pClient);
     101            }
     102        }
    111103    }
    112104    else
    … …  
    116108    {
    117109        PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    118         rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_READ,
     110        rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN,
    119111                                                 30 * 1000 /* Timeout in ms */, &pPayload);
    120112        if (RT_SUCCESS(rc))
    121113        {
     114            Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
     115
     116            PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
     117            AssertPtr(pReply);
     118
     119            Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN);
     120
     121            *phList = pReply->u.ListOpen.uHandle;
     122
     123            SharedClipboardURITransferPayloadFree(pPayload);
     124        }
     125    }
     126
     127    LogFlowFuncLeaveRC(rc);
     128    return rc;
     129}
     130
     131DECLCALLBACK(int) vboxSvcClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList)
     132{
     133    RT_NOREF(pCtx, hList);
     134
     135    LogFlowFuncEnter();
     136
     137    int rc = VINF_SUCCESS;
     138
     139    LogFlowFuncLeaveRC(rc);
     140    return rc;
     141}
     142
     143DECLCALLBACK(int) vboxSvcClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
     144                                                 SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
     145{
     146    LogFlowFuncEnter();
     147
     148    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     149    AssertPtr(pClient);
     150
     151    int rc;
     152
     153    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ,
     154                                                            VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
     155    if (pMsg)
     156    {
     157        HGCMSvcSetU32(&pMsg->m_paParms[0], 0 /* uContextID */);
     158        HGCMSvcSetU64(&pMsg->m_paParms[1], hList);
     159        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */);
     160
     161        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
     162        if (RT_SUCCESS(rc))
     163        {
     164            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE);
     165            AssertRC(rc2);
     166
     167            vboxSvcClipboardClientWakeup(pClient);
     168        }
     169    }
     170    else
     171        rc = VERR_NO_MEMORY;
     172
     173    if (RT_SUCCESS(rc))
     174    {
     175        PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     176        rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE,
     177                                                 30 * 1000 /* Timeout in ms */, &pPayload);
     178        if (RT_SUCCESS(rc))
     179        {
    122180            Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTHDR));
    123             //*ppListHdr = (PVBOXCLIPBOARDLISTHDR)pPayload->pvData;
    124 
    125             RTMemFree(pPayload);
     181
     182            *pListHdr = *(PVBOXCLIPBOARDLISTHDR)pPayload->pvData;
     183
     184            SharedClipboardURITransferPayloadFree(pPayload);
    126185        }
    127186    }
    … …  
    132191
    133192DECLCALLBACK(int) vboxSvcClipboardURIListHdrWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    134                                                   VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
     193                                                  SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
    135194{
    136195    RT_NOREF(pCtx, hList, pListHdr);
    … …  
    142201
    143202DECLCALLBACK(int) vboxSvcClipboardURIListEntryRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    144                                                    VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry)
    145 {
    146     RT_NOREF(pCtx, hList, pListEntry);
    147 
    148     LogFlowFuncEnter();
    149 
    150     PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pCtx->pvUser;
    151     AssertPtr(pClientData);
    152 
    153     PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    154     int rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_READ,
     203                                                   SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry)
     204{
     205    LogFlowFuncEnter();
     206
     207    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     208    AssertPtr(pClient);
     209
     210    int rc;
     211
     212    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ,
     213                                                            VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ_REQ);
     214    if (pMsg)
     215    {
     216        HGCMSvcSetU32(&pMsg->m_paParms[0], 0 /* uContextID */);
     217        HGCMSvcSetU64(&pMsg->m_paParms[1], hList);
     218        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fInfo */);
     219
     220        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
     221        if (RT_SUCCESS(rc))
     222        {
     223            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE);
     224            if (rc2 == VERR_ALREADY_EXISTS)
     225                rc2 = VINF_SUCCESS;
     226            AssertRC(rc2);
     227
     228            vboxSvcClipboardClientWakeup(pClient);
     229        }
     230    }
     231    else
     232        rc = VERR_NO_MEMORY;
     233
     234    if (RT_SUCCESS(rc))
     235    {
     236        PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     237        rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE,
    155238                                                 30 * 1000 /* Timeout in ms */, &pPayload);
    156     if (RT_SUCCESS(rc))
    157     {
    158         Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTENTRY));
    159 
    160         PVBOXCLIPBOARDLISTENTRY pListEntry = (PVBOXCLIPBOARDLISTENTRY)pPayload->pvData;
    161         AssertPtr(pListEntry);
    162 
    163    /*     const uint32_t cbToRead = RT_MIN(cbChunk, pListEntry->cbData);
    164 
    165         memcpy(pvChunk, pListEntry->pvData, cbToRead);*/
    166 
    167         SharedClipboardURITransferPayloadFree(pPayload);
    168 
    169 /*        if (pcbRead)
    170             *pcbRead = cbToRead;*/
     239        if (RT_SUCCESS(rc))
     240        {
     241            Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTENTRY));
     242
     243            rc = SharedClipboardURIListEntryCopy(pListEntry, (PVBOXCLIPBOARDLISTENTRY)pPayload->pvData);
     244
     245            SharedClipboardURITransferPayloadFree(pPayload);
     246        }
    171247    }
    172248
    … …  
    176252
    177253DECLCALLBACK(int) vboxSvcClipboardURIListEntryWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    178                                                     VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry)
     254                                                    SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry)
    179255{
    180256    RT_NOREF(pCtx, hList, pListEntry);
    … …  
    237313DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
    238314{
    239     LogFlowFuncEnter();
    240 
    241     AssertPtrReturnVoid(pData);
    242 
    243     PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pData->pvUser;
    244     AssertPtrReturnVoid(pClientData);
    245 
    246     PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer;
    247     AssertPtrReturnVoid(pTransfer);
    248 
    249     /* Register needed events. */
    250     int rc2 = SharedClipboardURITransferEventRegister(pData->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_READ);
    251     AssertRC(rc2);
    252     rc2 = SharedClipboardURITransferEventRegister(pData->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_READ);
    253     AssertRC(rc2);
    254 
    255 #if 0
    256     /* Tell the guest that it can start sending URI data. */
    257     rc2 = vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START,
    258                                     0 /* u32Formats == 0 means reading data */);
    259     AssertRC(rc2);
    260 #endif
     315    RT_NOREF(pData);
     316
     317    LogFlowFuncEnter();
    261318}
    262319
    263320DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
    264321{
    265     LogFlowFuncEnter();
    266 
    267322    RT_NOREF(pData, rc);
    268323
     324    LogFlowFuncEnter();
     325
    269326    LogRel2(("Shared Clipboard: Transfer complete\n"));
    270327}
    … …  
    286343
    287344    LogRel(("Shared Clipboard: Transfer failed with %Rrc\n", rc));
     345}
     346
     347/**
     348 * Gets an URI message reply from HGCM service parameters.
     349 *
     350 * @returns VBox status code.
     351 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     352 * @param   paParms             Array of HGCM parameters.
     353 * @param   pReply              Where to store the reply.
     354 */
     355int VBoxSvcClipboardURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     356                                PVBOXCLIPBOARDREPLY pReply)
     357{
     358    int rc;
     359
     360    if (cParms >= VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN)
     361    {
     362        uint32_t cbPayload = 0;
     363
     364        /* Note: Context ID (paParms[0]) not used yet. */
     365        rc = HGCMSvcGetU32(&paParms[1], &pReply->uType);
     366        if (RT_SUCCESS(rc))
     367            rc = HGCMSvcGetU32(&paParms[2], &pReply->rc);
     368        if (RT_SUCCESS(rc))
     369            rc = HGCMSvcGetU32(&paParms[3], &cbPayload);
     370        if (RT_SUCCESS(rc))
     371        {
     372            rc = HGCMSvcGetPv(&paParms[4], &pReply->pvPayload, &pReply->cbPayload);
     373            AssertReturn(cbPayload == pReply->cbPayload, VERR_INVALID_PARAMETER);
     374        }
     375
     376        if (RT_SUCCESS(rc))
     377        {
     378            switch (pReply->uType)
     379            {
     380                case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN:
     381                {
     382                    if (cParms >= 6)
     383                    {
     384                        rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ListOpen.uHandle);
     385                    }
     386                    else
     387                        rc = VERR_INVALID_PARAMETER;
     388                    break;
     389                }
     390
     391                case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN:
     392                {
     393                    if (cParms >= 6)
     394                    {
     395                        rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ObjOpen.uHandle);
     396                    }
     397                    else
     398                        rc = VERR_INVALID_PARAMETER;
     399                    break;
     400                }
     401
     402                default:
     403                    break;
     404            }
     405        }
     406    }
     407    else
     408        rc = VERR_INVALID_PARAMETER;
     409
     410    LogFlowFuncLeaveRC(rc);
     411    return rc;
     412}
     413
     414/**
     415 * Gets an URI list open request from HGCM service parameters.
     416 *
     417 * @returns VBox status code.
     418 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     419 * @param   paParms             Array of HGCM parameters.
     420 * @param   pOpenParms          Where to store the open parameters of the request.
     421 */
     422int VBoxSvcClipboardURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     423                                   PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
     424{
     425    int rc;
     426
     427    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN)
     428    {
     429        uint32_t cbPath   = 0;
     430        uint32_t cbFilter = 0;
     431
     432        /* Note: Context ID (paParms[0]) not used yet. */
     433        rc = HGCMSvcGetU32(&paParms[1], &pOpenParms->fList);
     434        if (RT_SUCCESS(rc))
     435            rc = HGCMSvcGetU32(&paParms[2], &cbPath);
     436        if (RT_SUCCESS(rc))
     437        {
     438            rc = HGCMSvcGetStr(&paParms[3], &pOpenParms->pszPath, &pOpenParms->cbPath);
     439            AssertReturn(cbPath == pOpenParms->cbPath, VERR_INVALID_PARAMETER);
     440        }
     441        if (RT_SUCCESS(rc))
     442            rc = HGCMSvcGetU32(&paParms[4], &cbFilter);
     443        if (RT_SUCCESS(rc))
     444        {
     445            rc = HGCMSvcGetStr(&paParms[5], &pOpenParms->pszFilter, &pOpenParms->cbFilter);
     446            AssertReturn(cbFilter == pOpenParms->cbFilter, VERR_INVALID_PARAMETER);
     447        }
     448
     449        if (RT_SUCCESS(rc))
     450        {
     451            /** @todo Some more validation. */
     452        }
     453    }
     454    else
     455        rc = VERR_INVALID_PARAMETER;
     456
     457    LogFlowFuncLeaveRC(rc);
     458    return rc;
     459}
     460
     461int VBoxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     462                                   PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
     463{
     464    int rc;
     465
     466    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN)
     467    {
     468        HGCMSvcSetU32(&paParms[0], 0 /* uContextID */);
     469        HGCMSvcSetU32(&paParms[1], pOpenParms->fList);
     470        HGCMSvcSetU32(&paParms[2], pOpenParms->cbFilter);
     471        HGCMSvcSetPv (&paParms[3], pOpenParms->pszFilter, pOpenParms->cbFilter);
     472        HGCMSvcSetU32(&paParms[4], pOpenParms->cbPath);
     473        HGCMSvcSetPv (&paParms[5], pOpenParms->pszPath, pOpenParms->cbPath);
     474        HGCMSvcSetU64(&paParms[6], 0); /* OUT: uHandle */
     475
     476        rc = VINF_SUCCESS;
     477    }
     478    else
     479        rc = VERR_INVALID_PARAMETER;
     480
     481    LogFlowFuncLeaveRC(rc);
     482    return rc;
    288483}
    289484
    … …  
    298493 */
    299494int VBoxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    300                                   PVBOXCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr)
     495                                  PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr)
    301496{
    302497    int rc;
    303498
    304     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_WRITE)
     499    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
    305500    {
    306501        /* Note: Context ID (paParms[0]) not used yet. */
    307502        rc = HGCMSvcGetU64(&paParms[1], phList);
    308         if (RT_SUCCESS(rc))
    309             rc = HGCMSvcGetU64(&paParms[2], &pListHdr->cTotalObjects);
    310         if (RT_SUCCESS(rc))
    311             rc = HGCMSvcGetU64(&paParms[3], &pListHdr->cbTotalSize);
    312         if (RT_SUCCESS(rc))
    313             rc = HGCMSvcGetU32(&paParms[4], &pListHdr->enmCompression);
    314         if (RT_SUCCESS(rc))
    315             rc = HGCMSvcGetU32(&paParms[5], (uint32_t *)&pListHdr->enmChecksumType);
     503        /* Note: Flags (paParms[2]) not used here. */
     504        if (RT_SUCCESS(rc))
     505            rc = HGCMSvcGetU32(&paParms[3], &pListHdr->fFeatures);
     506        if (RT_SUCCESS(rc))
     507            rc = HGCMSvcGetU64(&paParms[4], &pListHdr->cTotalObjects);
     508        if (RT_SUCCESS(rc))
     509            rc = HGCMSvcGetU64(&paParms[5], &pListHdr->cbTotalSize);
     510        if (RT_SUCCESS(rc))
     511            rc = HGCMSvcGetU32(&paParms[6], &pListHdr->enmCompression);
     512        if (RT_SUCCESS(rc))
     513            rc = HGCMSvcGetU32(&paParms[7], (uint32_t *)&pListHdr->enmChecksumType);
    316514
    317515        if (RT_SUCCESS(rc))
    … …  
    340538    int rc;
    341539
    342     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ)
     540    if (   cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR
     541        || cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
    343542    {
    344543        /** @todo Set pvMetaFmt + cbMetaFmt. */
    345544        /** @todo Calculate header checksum. */
    346545
    347         /* Note: Context ID (paParms[0]) not used yet. */
    348         HGCMSvcSetU32(&paParms[1], pListHdr->fList);
    349         HGCMSvcSetU32(&paParms[2], pListHdr->fFeatures);
    350         HGCMSvcSetU32(&paParms[3], pListHdr->cbFilter);
    351         HGCMSvcSetPv (&paParms[4], pListHdr->pszFilter, pListHdr->cbFilter);
    352         HGCMSvcSetU64(&paParms[5], pListHdr->cTotalObjects);
    353         HGCMSvcSetU64(&paParms[6], pListHdr->cbTotalSize);
    354         HGCMSvcSetU32(&paParms[7], pListHdr->enmCompression);
    355         HGCMSvcSetU32(&paParms[8], (uint32_t)pListHdr->enmChecksumType);
     546        HGCMSvcSetU32(&paParms[0], 0 /* uContextID */);
     547        HGCMSvcSetU32(&paParms[1], pListHdr->fFeatures);
     548        HGCMSvcSetU32(&paParms[2], 0 /* Features, will be returned on success */);
     549        HGCMSvcSetU64(&paParms[3], pListHdr->cTotalObjects);
     550        HGCMSvcSetU64(&paParms[4], pListHdr->cbTotalSize);
     551        HGCMSvcSetU32(&paParms[5], pListHdr->enmCompression);
     552        HGCMSvcSetU32(&paParms[6], pListHdr->enmChecksumType);
    356553
    357554        rc = VINF_SUCCESS;
    … …  
    374571 */
    375572int VBoxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    376                                     PVBOXCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry)
     573                                    PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry)
    377574{
    378575    int rc;
    379576
    380     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_WRITE)
     577    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
    381578    {
    382579        /* Note: Context ID (paParms[0]) not used yet. */
    … …  
    414611    int rc;
    415612
    416     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ)
     613    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
    417614    {
    418615        /** @todo Calculate chunk checksum. */
    419616
    420         /* Note: Context ID (paParms[0]) not used yet. */
     617        HGCMSvcSetU32(&paParms[0], 0 /* uContextID */);
    421618        HGCMSvcSetU32(&paParms[1], pListEntry->fInfo);
    422619        HGCMSvcSetU32(&paParms[2], pListEntry->cbInfo);
    … …  
    432629}
    433630
     631/**
     632 * Gets an URI error from HGCM service parameters.
     633 *
     634 * @returns VBox status code.
     635 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     636 * @param   paParms             Array of HGCM parameters.
     637 * @param   pRc                 Where to store the received error code.
     638 */
    434639int VBoxSvcClipboardURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
    435640{
    … …  
    446651    else
    447652        rc = VERR_INVALID_PARAMETER;
     653
     654    LogFlowFuncLeaveRC(rc);
     655    return rc;
     656}
     657
     658int VBoxSvcClipboardURITransferHandleReply(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer,
     659                                           uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     660{
     661    RT_NOREF(pClient);
     662
     663    int rc;
     664
     665    uint32_t            cbReply = sizeof(VBOXCLIPBOARDREPLY);
     666    PVBOXCLIPBOARDREPLY pReply  = (PVBOXCLIPBOARDREPLY)RTMemAlloc(cbReply);
     667    if (pReply)
     668    {
     669        rc = VBoxSvcClipboardURIGetReply(cParms, paParms, pReply);
     670        if (RT_SUCCESS(rc))
     671        {
     672            PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload
     673                = (PSHAREDCLIPBOARDURITRANSFERPAYLOAD)RTMemAlloc(sizeof(SHAREDCLIPBOARDURITRANSFERPAYLOAD));
     674            if (pPayload)
     675            {
     676                pPayload->pvData = pReply;
     677                pPayload->cbData = cbReply;
     678
     679                switch (pReply->uType)
     680                {
     681                    case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN:
     682                    {
     683                        rc = SharedClipboardURITransferEventSignal(pTransfer,
     684                                                                   SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN, pPayload);
     685                        break;
     686                    }
     687
     688                    default:
     689                        rc = VERR_NOT_FOUND;
     690                        break;
     691                }
     692
     693                if (RT_FAILURE(rc))
     694                {
     695                    if (pPayload)
     696                        RTMemFree(pPayload);
     697                }
     698            }
     699            else
     700                rc = VERR_NO_MEMORY;
     701        }
     702    }
     703    else
     704        rc = VERR_NO_MEMORY;
     705
     706    if (RT_FAILURE(rc))
     707    {
     708        if (pReply)
     709            RTMemFree(pReply);
     710    }
    448711
    449712    LogFlowFuncLeaveRC(rc);
    … …  
    471734    RT_NOREF(paParms, tsArrival);
    472735
    473     LogFlowFunc(("uClient=%RU32, u32Function=%RU32, cParms=%RU32, g_pfnExtension=%p\n",
    474                  pClient->uClientID, u32Function, cParms, g_pfnExtension));
     736    LogFlowFunc(("uClient=%RU32, u32Function=%RU32 (%s), cParms=%RU32, g_pfnExtension=%p\n",
     737                 pClient->uClientID, u32Function, VBoxSvcClipboardGuestMsgToStr(u32Function), cParms, g_pfnExtension));
    475738
    476739    const PVBOXCLIPBOARDCLIENTDATA pClientData = pClient->pData;
    … …  
    503766    switch (u32Function)
    504767    {
    505         case VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG:
     768        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
    506769            RT_FALL_THROUGH();
    507         case VBOX_SHARED_CLIPBOARD_GUEST_FN_TRANSFER_REPORT:
     770        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
     771            RT_FALL_THROUGH();
     772        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
     773            RT_FALL_THROUGH();
     774        case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
    508775            break;
    509776        default:
    … …  
    535802    switch (u32Function)
    536803    {
    537         case VBOX_SHARED_CLIPBOARD_GUEST_FN_TRANSFER_REPORT:
    538         {
    539             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_TRANSFER_REPORT\n"));
    540 
    541             if (!SharedClipboardURICtxTransfersMaximumReached(&pClientData->URI))
     804        case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
     805        {
     806            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS\n", pClient->uClientID));
     807
     808            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_STATUS)
     809                break;
     810
     811            SHAREDCLIPBOARDURITRANSFERSTATUS uStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_NONE;
     812            rc = HGCMSvcGetU32(&paParms[1], &uStatus);
     813            if (RT_FAILURE(rc))
     814                break;
     815
     816            LogFlowFunc(("uStatus: %RU32\n", uStatus));
     817
     818            if (   uStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING
     819                && !SharedClipboardURICtxTransfersMaximumReached(&pClientData->URI))
    542820            {
    543821                SharedClipboardURICtxTransfersCleanup(&pClientData->URI);
    … …  
    592870                        SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks);
    593871
    594                         rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx);
     872                        rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
    595873                        if (RT_SUCCESS(rc))
    596874                            rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer);
    … …  
    614892                rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
    615893
    616             LogFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_TRANSFER_REPORT: %Rrc\n", rc));
     894            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS: %Rrc\n", pClient->uClientID, rc));
    617895
    618896            if (RT_FAILURE(rc))
    … …  
    622900        }
    623901
    624         case VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG:
    625         {
    626             if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG)
    627             {
    628                 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG\n"));
    629                 rc = vboxSvcClipboardMsgGetNextInfo(&pClientData->State,
    630                                                     &paParms[0].u.uint32 /* uMsg */, &paParms[1].u.uint32 /* cParms */);
    631 
    632                 /* No (new) messages available or some error occurred? */
    633                 if (   rc == VERR_NO_DATA
    634                     || RT_FAILURE(rc))
     902        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
     903        {
     904            rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
     905            break;
     906        }
     907
     908        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
     909        {
     910            rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
     911            break;
     912        }
     913
     914        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
     915        {
     916            rc = vboxSvcClipboardMsgGet(pClient, callHandle, cParms, paParms);
     917            break;
     918        }
     919
     920        case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY:
     921        {
     922            rc = VBoxSvcClipboardURITransferHandleReply(pClient, pTransfer, cParms, paParms);
     923            break;
     924        }
     925
     926        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:
     927        {
     928            VBOXCLIPBOARDLISTOPENPARMS listOpenParms;
     929            rc = VBoxSvcClipboardURIGetListOpen(cParms, paParms, &listOpenParms);
     930            if (RT_SUCCESS(rc))
     931            {
     932                SHAREDCLIPBOARDLISTHANDLE hList;
     933                rc = SharedClipboardURITransferListOpen(pTransfer, &listOpenParms, &hList);
     934                if (RT_SUCCESS(rc))
    635935                {
    636                     uint32_t fFlags = 0;
    637                     int rc2 = HGCMSvcGetU32(&paParms[2], &fFlags);
    638                     if (   RT_SUCCESS(rc2)
    639                         && fFlags) /* Blocking flag set? */
    640                     {
    641                         /* Defer client returning. */
    642                         rc = VINF_HGCM_ASYNC_EXECUTE;
    643                     }
    644                     else
    645                         rc = VERR_INVALID_PARAMETER;
    646 
    647                     LogFlowFunc(("Message queue is empty, returning %Rrc to guest\n", rc));
     936                    /* Return list handle. */
     937                    HGCMSvcSetU32(&paParms[1], hList);
    648938                }
    649939            }
    … …  
    651941        }
    652942
    653         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:
    654         {
    655             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN\n"));
    656             rc = VINF_SUCCESS;
    657             break;
    658         }
    659 
    660943        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE:
    661944        {
    662             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE\n"));
    663             rc = VINF_SUCCESS;
     945            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE)
     946                break;
     947
     948            SHAREDCLIPBOARDLISTHANDLE hList;
     949            /* Note: Context ID (paParms[0]) not used yet. */
     950            rc = HGCMSvcGetU64(&paParms[1], &hList);
     951            if (RT_SUCCESS(rc))
     952            {
     953                rc = SharedClipboardURITransferListClose(pTransfer, hList);
     954            }
    664955            break;
    665956        }
    … …  
    667958        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ:
    668959        {
    669             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_LIST_HDR\n"));
    670 
    671             VBOXCLIPBOARDLISTHANDLE hList;
    672             VBOXCLIPBOARDLISTHDR    hdrList;
    673             rc = VBoxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList);
     960            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
     961                break;
     962
     963            SHAREDCLIPBOARDLISTHANDLE hList;
     964            /* Note: Context ID (paParms[0]) not used yet. */
     965            rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */
    674966            if (RT_SUCCESS(rc))
    675967            {
     968                VBOXCLIPBOARDLISTHDR hdrList;
     969                rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
    676970                if (RT_SUCCESS(rc))
    677971                    rc = VBoxSvcClipboardURISetListHdr(cParms, paParms, &hdrList);
    … …  
    682976        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE:
    683977        {
    684             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_LIST_HDR\n"));
    685 
    686978            VBOXCLIPBOARDLISTHDR hdrList;
    687979            rc = SharedClipboardURIListHdrInit(&hdrList);
    688980            if (RT_SUCCESS(rc))
    689981            {
    690                 VBOXCLIPBOARDLISTHANDLE hList;
     982                SHAREDCLIPBOARDLISTHANDLE hList;
    691983                rc = VBoxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList);
    692984                if (RT_SUCCESS(rc))
    … …  
    696988
    697989                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    698                     rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_READ,
     990                    rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE,
    699991                                                                pvData, cbData, &pPayload);
    700992                    if (RT_SUCCESS(rc))
    701993                    {
    702                         rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_READ,
     994                        rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE,
    703995                                                                   pPayload);
    704996                    }
    … …  
    7101002        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ:
    7111003        {
    712             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_LIST_ENTRY\n"));
     1004            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
     1005                break;
     1006
     1007            SHAREDCLIPBOARDLISTHANDLE hList;
     1008            /* Note: Context ID (paParms[0]) not used yet. */
     1009            rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */
     1010            if (RT_SUCCESS(rc))
     1011            {
     1012                VBOXCLIPBOARDLISTENTRY entryList;
     1013                rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
     1014            }
    7131015            break;
    7141016        }
    … …  
    7161018        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE:
    7171019        {
    718             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_LIST_ENTRY\n"));
    719 
    7201020            VBOXCLIPBOARDLISTENTRY entryList;
    7211021            rc = SharedClipboardURIListEntryInit(&entryList);
    7221022            if (RT_SUCCESS(rc))
    7231023            {
    724                 VBOXCLIPBOARDLISTHANDLE hList;
     1024                SHAREDCLIPBOARDLISTHANDLE hList;
    7251025                rc = VBoxSvcClipboardURIGetListEntry(cParms, paParms, &hList, &entryList);
    7261026                if (RT_SUCCESS(rc))
    … …  
    7301030
    7311031                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    732                     rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_READ,
     1032                    rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE,
    7331033                                                                pvData, cbData, &pPayload);
    7341034                    if (RT_SUCCESS(rc))
    7351035                    {
    736                         rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_READ,
     1036                        rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE,
    7371037                                                                   pPayload);
    7381038                    }
    … …  
    7421042            break;
    7431043        }
    744 #if 0
     1044
     1045    #if 0
    7451046        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR:
    7461047        {
    … …  
    9131214#endif
    9141215        case VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL:
    915             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_CANCEL\n"));
    916 
     1216        {
    9171217            LogRel2(("Shared Clipboard: Transfer canceled\n"));
    9181218            break;
     1219        }
    9191220
    9201221        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR:
    9211222        {
    922             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_ERROR\n"));
    923 
    9241223            int rcGuest;
    9251224            rc = VBoxSvcClipboardURIGetError(cParms,paParms, &rcGuest);
    … …  
    9301229
    9311230        default:
    932             AssertMsgFailed(("Not implemented\n"));
    933             break;
    934     }
    935 
    936     if (rc == VINF_HGCM_ASYNC_EXECUTE)
    937     {
    938         try
    939         {
    940             vboxSvcClipboardClientDefer(pClient, callHandle, u32Function, cParms, paParms);
    941             g_listClientsDeferred.push_back(pClient->uClientID);
    942         }
    943         catch (std::bad_alloc &)
    944         {
    945             rc = VERR_NO_MEMORY;
    946             /* Don't report to guest. */
    947         }
    948     }
    949     else if (pClient)
    950     {
    951         int rc2 = vboxSvcClipboardClientComplete(pClient, callHandle, rc);
    952         AssertRC(rc2);
    953     }
    954 
    955     LogFlowFunc(("Returning uClient=%RU32, rc=%Rrc\n", pClient->uClientID, rc));
     1231            LogFunc(("Not implemented\n"));
     1232            break;
     1233    }
     1234
     1235    if (rc != VINF_HGCM_ASYNC_EXECUTE)
     1236    {
     1237        /* Tell the client that the call is complete (unblocks waiting). */
     1238        LogFlowFunc(("[Client %RU32] Calling pfnCallComplete w/ rc=%Rrc\n", pClient->uClientID, rc));
     1239        AssertPtr(g_pHelpers);
     1240        g_pHelpers->pfnCallComplete(callHandle, rc);
     1241    }
     1242
     1243    LogFlowFunc(("[Client %RU32] Returning rc=%Rrc\n", pClient->uClientID, rc));
    9561244    return rc;
    9571245}

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

    r79497 r79630  
    6868            break;
    6969
    70         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE:
    71             RT_FALL_THROUGH();
    72         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE:
    73             RT_FALL_THROUGH();
    74         case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE:
    75             fAllowed = fGuestToHost;
    76             break;
    77 
    78         case VBOX_SHARED_CLIPBOARD_GUEST_FN_TRANSFER_REPORT:
    79             RT_FALL_THROUGH();
    80         case VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG:
     70        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
     71            RT_FALL_THROUGH();
     72        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
     73            RT_FALL_THROUGH();
     74        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
     75            RT_FALL_THROUGH();
     76        case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
    8177            RT_FALL_THROUGH();
    8278        case VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL:
    … …  
    8985            break;
    9086    }
     87
     88    fAllowed = true; /** @todo FIX !!!! */
    9189
    9290    LogFlowFunc(("uMsg=%RU32, uMode=%RU32 -> fAllowed=%RTbool\n", uMsg, uMode, fAllowed));

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

    r79497 r79630  
    646646    {
    647647        if (pCtx->Win.hWnd)
    648             PostMessage(pCtx->Win.hWnd, WM_CLOSE, 0 /* wParam */, 0 /* lParam */);
     648            PostMessage(pCtx->Win.hWnd, WM_DESTROY, 0 /* wParam */, 0 /* lParam */);
    649649
    650650        rc = RTSemEventDestroy(pCtx->hRenderEvent);

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

    r79505 r79630  
    127127 * the rest of the code stays the same.
    128128 *
     129 * @section sec_uri_protocol            URI protocol.
     130 *
     131 * The host service issues commands which the guest has to respond with an own
     132 * message to. The protocol itself is designed so that it has primitives to list
     133 * directories and open/close/read/write file system objects.
     134 *
     135 * The protocol does not rely on the old ReportMsg() / ReturnMsg() mechanism anymore
     136 * and uses a (per-client) message queue instead (see VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD
     137 * vs. VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG).
     138 *
     139 * Note that this is different from the DnD approach, as Shared Clipboard transfers
     140 * need to be deeper integrated within the host / guest OS (i.e. for progress UI),
     141 * and this might require non-monolithic / random access APIs to achieve.
     142 *
     143 * One transfer always is handled by an own (HGCM) client, so for multiple transfers
     144 * at the same time, multiple clients (client IDs) are being used. How this transfer
     145 * is implemented on the guest (and / or host) side depends upon the actual implementation,
     146 * e.g. via an own thread per transfer.
    129147 */
    130148
    … …  
    136154#include <VBox/log.h>
    137155
     156#include <VBox/AssertGuest.h>
    138157#include <VBox/HostServices/Service.h>
    139158#include <VBox/HostServices/VBoxClipboardSvc.h>
    … …  
    167186*   Global Variables                                                                                                             *
    168187*********************************************************************************************************************************/
    169 static PVBOXHGCMSVCHELPERS g_pHelpers;
     188PVBOXHGCMSVCHELPERS g_pHelpers;
    170189
    171190static RTCRITSECT g_CritSect;
    … …  
    183202static bool g_fHeadless = false;
    184203
    185 /** Map of all connected clients. */
     204/** Global map of all connected clients. */
    186205ClipboardClientMap g_mapClients;
    187206
    188 /** List of all clients which are queued up (deferred return) and ready
     207/** Global list of all clients which are queued up (deferred return) and ready
    189208 *  to process new commands. The key is the (unique) client ID. */
    190209ClipboardClientQueue g_listClientsDeferred;
    191210
    192 
    193 #if 0
    194 static void VBoxHGCMParmPtrSet (VBOXHGCMSVCPARM *pParm, void *pv, uint32_t cb)
    195 {
    196     pParm->type             = VBOX_HGCM_SVC_PARM_PTR;
    197     pParm->u.pointer.size   = cb;
    198     pParm->u.pointer.addr   = pv;
    199 }
    200 #endif
    201211
    202212static int VBoxHGCMParmPtrGet(VBOXHGCMSVCPARM *pParm, void **ppv, uint32_t *pcb)
    … …  
    323333
    324334/**
     335 * Sets the GUEST_MSG_PEEK_WAIT GUEST_MSG_PEEK_NOWAIT return parameters.
     336 *
     337 * @param   paDstParms  The peek parameter vector.
     338 * @param   cDstParms   The number of peek parameters (at least two).
     339 * @remarks ASSUMES the parameters has been cleared by clientMsgPeek.
     340 */
     341void vboxSvcClipboardMsgSetPeekReturn(PVBOXCLIPBOARDCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
     342{
     343    Assert(cDstParms >= 2);
     344    if (paDstParms[0].type == VBOX_HGCM_SVC_PARM_32BIT)
     345        paDstParms[0].u.uint32 = pMsg->m_uMsg;
     346    else
     347        paDstParms[0].u.uint64 = pMsg->m_uMsg;
     348    paDstParms[1].u.uint32 = pMsg->m_cParms;
     349
     350    uint32_t i = RT_MIN(cDstParms, pMsg->m_cParms + 2);
     351    while (i-- > 2)
     352        switch (pMsg->m_paParms[i - 2].type)
     353        {
     354            case VBOX_HGCM_SVC_PARM_32BIT: paDstParms[i].u.uint32 = ~(uint32_t)sizeof(uint32_t); break;
     355            case VBOX_HGCM_SVC_PARM_64BIT: paDstParms[i].u.uint32 = ~(uint32_t)sizeof(uint64_t); break;
     356            case VBOX_HGCM_SVC_PARM_PTR:   paDstParms[i].u.uint32 = pMsg->m_paParms[i - 2].u.pointer.size; break;
     357        }
     358}
     359
     360/**
    325361 * Adds a new message to a client'S message queue.
    326362 *
    … …  
    347383
    348384/**
    349  * Retrieves information about the next message in the queue.
    350  *
    351  * @returns IPRT status code. VERR_NO_DATA if no next message is available.
    352  * @param   pClientData         Pointer to the client data structure to get message info for.
    353  * @param   puType              Where to store the message type.
    354  * @param   pcParms             Where to store the message parameter count.
     385 * Implements VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT and VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT.
     386 *
     387 * @returns VBox status code.
     388 * @retval  VINF_SUCCESS if a message was pending and is being returned.
     389 * @retval  VERR_TRY_AGAIN if no message pending and not blocking.
     390 * @retval  VERR_RESOURCE_BUSY if another read already made a waiting call.
     391 * @retval  VINF_HGCM_ASYNC_EXECUTE if message wait is pending.
     392 *
     393 * @param   pClient     The client state.
     394 * @param   hCall       The client's call handle.
     395 * @param   cParms      Number of parameters.
     396 * @param   paParms     Array of parameters.
     397 * @param   fWait       Set if we should wait for a message, clear if to return
     398 *                      immediately.
    355399 */
    356 int vboxSvcClipboardMsgGetNextInfo(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t *puType, uint32_t *pcParms)
    357 {
    358     AssertPtrReturn(puType, VERR_INVALID_POINTER);
    359     AssertPtrReturn(pcParms, VERR_INVALID_POINTER);
    360 
    361     int rc;
    362 
    363     if (pClientData->queueMsg.isEmpty())
    364     {
    365         rc = VERR_NO_DATA;
    366     }
    367     else
    368     {
    369         PVBOXCLIPBOARDCLIENTMSG pMsg = pClientData->queueMsg.first();
    370         AssertPtr(pMsg);
    371 
    372         *puType  = pMsg->m_uMsg;
    373         *pcParms = pMsg->m_cParms;
     400int vboxSvcClipboardMsgPeek(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     401                            bool fWait)
     402{
     403    /*
     404     * Validate the request.
     405     */
     406    ASSERT_GUEST_MSG_RETURN(cParms >= 2, ("cParms=%u!\n", cParms), VERR_WRONG_PARAMETER_COUNT);
     407
     408    uint64_t idRestoreCheck = 0;
     409    uint32_t i              = 0;
     410    if (paParms[i].type == VBOX_HGCM_SVC_PARM_64BIT)
     411    {
     412        idRestoreCheck = paParms[0].u.uint64;
     413        paParms[0].u.uint64 = 0;
     414        i++;
     415    }
     416    for (; i < cParms; i++)
     417    {
     418        ASSERT_GUEST_MSG_RETURN(paParms[i].type == VBOX_HGCM_SVC_PARM_32BIT, ("#%u type=%u\n", i, paParms[i].type),
     419                                VERR_WRONG_PARAMETER_TYPE);
     420        paParms[i].u.uint32 = 0;
     421    }
     422
     423    /*
     424     * Check restore session ID.
     425     */
     426    if (idRestoreCheck != 0)
     427    {
     428        uint64_t idRestore = g_pHelpers->pfnGetVMMDevSessionId(g_pHelpers);
     429        if (idRestoreCheck != idRestore)
     430        {
     431            paParms[0].u.uint64 = idRestore;
     432            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VERR_VM_RESTORED (%#RX64 -> %#RX64)\n",
     433                         pClient->uClientID, idRestoreCheck, idRestore));
     434            return VERR_VM_RESTORED;
     435        }
     436        Assert(!g_pHelpers->pfnIsCallRestored(hCall));
     437    }
     438
     439    /*
     440     * Return information about the first message if one is pending in the list.
     441     */
     442    if (!pClient->pData->queueMsg.isEmpty())
     443    {
     444        PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->pData->queueMsg.first();
     445        if (pFirstMsg)
     446        {
     447            vboxSvcClipboardMsgSetPeekReturn(pFirstMsg, paParms, cParms);
     448            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
     449                         pClient->uClientID, pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg),
     450                         pFirstMsg->m_cParms));
     451            return VINF_SUCCESS;
     452        }
     453    }
     454
     455    /*
     456     * If we cannot wait, fail the call.
     457     */
     458    if (!fWait)
     459    {
     460        LogFlowFunc(("[Client %RU32] GUEST_MSG_PEEK_NOWAIT -> VERR_TRY_AGAIN\n", pClient->uClientID));
     461        return VERR_TRY_AGAIN;
     462    }
     463
     464    /*
     465     * Wait for the host to queue a message for this client.
     466     */
     467    ASSERT_GUEST_MSG_RETURN(pClient->Pending.uType == 0, ("Already pending! (idClient=%RU32)\n",
     468                                                           pClient->uClientID), VERR_RESOURCE_BUSY);
     469    pClient->Pending.hHandle = hCall;
     470    pClient->Pending.cParms  = cParms;
     471    pClient->Pending.paParms = paParms;
     472    pClient->Pending.uType   = VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT;
     473    LogFlowFunc(("[Client %RU32] Is now in pending mode...\n", pClient->uClientID));
     474    return VINF_HGCM_ASYNC_EXECUTE;
     475}
     476
     477/**
     478 * Implements VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET.
     479 *
     480 * @returns VBox status code.
     481 * @retval  VINF_SUCCESS if message retrieved and removed from the pending queue.
     482 * @retval  VERR_TRY_AGAIN if no message pending.
     483 * @retval  VERR_BUFFER_OVERFLOW if a parmeter buffer is too small.  The buffer
     484 *          size was updated to reflect the required size, though this isn't yet
     485 *          forwarded to the guest.  (The guest is better of using peek with
     486 *          parameter count + 2 parameters to get the sizes.)
     487 * @retval  VERR_MISMATCH if the incoming message ID does not match the pending.
     488 * @retval  VINF_HGCM_ASYNC_EXECUTE if message was completed already.
     489 *
     490 * @param   pClient      The client state.
     491 * @param   hCall        The client's call handle.
     492 * @param   cParms       Number of parameters.
     493 * @param   paParms      Array of parameters.
     494 */
     495int vboxSvcClipboardMsgGet(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     496{
     497    /*
     498     * Validate the request.
     499     */
     500    uint32_t const idMsgExpected = cParms > 0 && paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT ? paParms[0].u.uint32
     501                                 : cParms > 0 && paParms[0].type == VBOX_HGCM_SVC_PARM_64BIT ? paParms[0].u.uint64
     502                                 : UINT32_MAX;
     503
     504    /*
     505     * Return information about the first message if one is pending in the list.
     506     */
     507    PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->pData->queueMsg.first();
     508    if (pFirstMsg)
     509    {
     510        LogFlowFunc(("First message is: %RU32 %s (%RU32 parms)\n",
     511                     pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms));
     512
     513        ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_uMsg == idMsgExpected || idMsgExpected == UINT32_MAX,
     514                                ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
     515                                 pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_uMsg,
     516                                 idMsgExpected, VBoxSvcClipboardHostMsgToStr(idMsgExpected), cParms),
     517                                VERR_MISMATCH);
     518        ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_cParms == cParms,
     519                                ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
     520                                 pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,
     521                                 idMsgExpected, VBoxSvcClipboardHostMsgToStr(idMsgExpected), cParms),
     522                                VERR_WRONG_PARAMETER_COUNT);
     523
     524        /* Check the parameter types. */
     525        for (uint32_t i = 0; i < cParms; i++)
     526            ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_paParms[i].type == paParms[i].type,
     527                                    ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->m_paParms[i].type,
     528                                     paParms[i].type, pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg)),
     529                                    VERR_WRONG_PARAMETER_TYPE);
     530        /*
     531         * Copy out the parameters.
     532         *
     533         * No assertions on buffer overflows, and keep going till the end so we can
     534         * communicate all the required buffer sizes.
     535         */
     536        int rc = VINF_SUCCESS;
     537        for (uint32_t i = 0; i < cParms; i++)
     538            switch (pFirstMsg->m_paParms[i].type)
     539            {
     540                case VBOX_HGCM_SVC_PARM_32BIT:
     541                    paParms[i].u.uint32 = pFirstMsg->m_paParms[i].u.uint32;
     542                    break;
     543
     544                case VBOX_HGCM_SVC_PARM_64BIT:
     545                    paParms[i].u.uint64 = pFirstMsg->m_paParms[i].u.uint64;
     546                    break;
     547
     548                case VBOX_HGCM_SVC_PARM_PTR:
     549                {
     550                    uint32_t const cbSrc = pFirstMsg->m_paParms[i].u.pointer.size;
     551                    uint32_t const cbDst = paParms[i].u.pointer.size;
     552                    paParms[i].u.pointer.size = cbSrc; /** @todo Check if this is safe in other layers...
     553                                                        * Update: Safe, yes, but VMMDevHGCM doesn't pass it along. */
     554                    if (cbSrc <= cbDst)
     555                        memcpy(paParms[i].u.pointer.addr, pFirstMsg->m_paParms[i].u.pointer.addr, cbSrc);
     556                    else
     557                        rc = VERR_BUFFER_OVERFLOW;
     558                    break;
     559                }
     560
     561                default:
     562                    AssertMsgFailed(("#%u: %u\n", i, pFirstMsg->m_paParms[i].type));
     563                    rc = VERR_INTERNAL_ERROR;
     564                    break;
     565            }
     566        if (RT_SUCCESS(rc))
     567        {
     568            /*
     569             * Complete the message and remove the pending message unless the
     570             * guest raced us and cancelled this call in the meantime.
     571             */
     572            AssertPtr(g_pHelpers);
     573            rc = g_pHelpers->pfnCallComplete(hCall, rc);
     574
     575            LogFlowFunc(("[Client %RU32] pfnCallComplete -> %Rrc\n", pClient->uClientID, rc));
     576
     577            if (rc != VERR_CANCELLED)
     578            {
     579                pClient->pData->queueMsg.removeFirst();
     580                vboxSvcClipboardMsgFree(pFirstMsg);
     581            }
     582
     583            return VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
     584        }
     585
     586        LogFlowFunc(("[Client %RU32] Returning %Rrc\n", pClient->uClientID, rc));
     587        return rc;
     588    }
     589
     590    paParms[0].u.uint32 = 0;
     591    paParms[1].u.uint32 = 0;
     592    LogFlowFunc(("[Client %RU32] -> VERR_TRY_AGAIN\n", pClient->uClientID));
     593    return VERR_TRY_AGAIN;
     594}
     595
     596int vboxSvcClipboardClientWakeup(PVBOXCLIPBOARDCLIENT pClient)
     597{
     598    int rc = VINF_NO_CHANGE;
     599
     600    if (pClient->Pending.uType)
     601    {
     602        LogFlowFunc(("[Client %RU32] Waking up ...\n", pClient->uClientID));
    374603
    375604        rc = VINF_SUCCESS;
    376     }
    377 
    378     LogFlowFunc(("Returning puMsg=%RU32, pcParms=%RU32, rc=%Rrc\n", *puType, *pcParms, rc));
    379     return rc;
    380 }
    381 
    382 /**
    383  * Retrieves the next queued up message and removes it from the queue on success.
    384  * Will return VERR_NO_DATA if no next message is available.
    385  *
    386  * @returns IPRT status code.
    387  * @param   pClientData         Pointer to the client data structure to get message for.
    388  * @param   uMsg                Message type to retrieve.
    389  * @param   cParms              Number of parameters the \@a paParms array can store.
    390  * @param   paParms             Where to store the message parameters.
    391  */
    392 int vboxSvcClipboardMsgGetNext(PVBOXCLIPBOARDCLIENTDATA pClientData,
    393                                uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    394 {
    395     LogFlowFunc(("uMsg=%RU32, cParms=%RU32\n", uMsg, cParms));
    396 
    397     /* Check for pending messages in our queue. */
    398     if (pClientData->queueMsg.isEmpty())
    399         return VERR_NO_DATA;
    400 
    401     /* Get the current message. */
    402     PVBOXCLIPBOARDCLIENTMSG pMsg = pClientData->queueMsg.first();
    403     AssertPtr(pMsg);
    404 
    405     int rc = VINF_SUCCESS;
    406 
    407     /* Fetch the current message info. */
    408     if (pMsg->m_uMsg != uMsg)
    409     {
    410         LogFunc(("Stored message type (%RU32) does not match request (%RU32)\n", pMsg->m_uMsg, uMsg));
    411         rc = VERR_INVALID_PARAMETER;
    412     }
    413     else if (pMsg->m_cParms > cParms)
    414     {
    415         LogFunc(("Stored parameter count (%RU32) exceeds request buffer (%RU32)\n", pMsg->m_cParms, cParms));
    416         rc = VERR_INVALID_PARAMETER;
    417     }
    418 
    419     if (RT_SUCCESS(rc))
    420     {
    421         rc = Message::CopyParms(paParms, cParms, pMsg->m_paParms, pMsg->m_cParms, true /* fDeepCopy */);
    422 
    423         /** @todo Only remove on success? */
    424         pClientData->queueMsg.removeFirst(); /* Remove the current message from the queue. */
    425     }
    426     else
    427     {
    428         vboxSvcClipboardMsgQueueReset(pClientData);
    429         /** @todo Cleanup, send notification to guest. */
    430     }
    431 
    432     LogFlowFunc(("Message processed with rc=%Rrc\n", rc));
    433     return rc;
     605
     606        if (!pClient->pData->queueMsg.isEmpty())
     607        {
     608            PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->pData->queueMsg.first();
     609            if (pFirstMsg)
     610            {
     611                LogFlowFunc(("[Client %RU32] Current host message is %RU32 (cParms=%RU32)\n",
     612                             pClient->uClientID, pFirstMsg->m_uMsg, pFirstMsg->m_cParms));
     613
     614                if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT)
     615                {
     616                    vboxSvcClipboardMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
     617                    rc = g_pHelpers->pfnCallComplete(pClient->Pending.hHandle, VINF_SUCCESS);
     618
     619                    pClient->Pending.hHandle = NULL;
     620                    pClient->Pending.paParms = NULL;
     621                    pClient->Pending.cParms  = 0;
     622                    pClient->Pending.uType   = false;
     623                }
     624            }
     625            else
     626                AssertFailed();
     627        }
     628        else
     629            AssertMsgFailed(("Waking up client ID=%RU32 with no host message in queue is a bad idea\n", pClient->uClientID));
     630
     631        return rc;
     632    }
     633
     634    return VINF_NO_CHANGE;
    434635}
    435636
    … …  
    9191120                                        SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks);
    9201121
    921                                         rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx);
     1122                                        rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
    9221123                                        if (RT_SUCCESS(rc))
    9231124                                            rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer);
    … …  
    10361237                                    creationCtx.pvUser = pClientData;
    10371238
    1038                                     rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx);
     1239                                    rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
    10391240                                    if (RT_SUCCESS(rc))
    10401241                                        rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer);
    … …  
    12331434
    12341435/**
    1235  * Defers a client from returning back to the caller (guest side).
    1236  *
    1237  * @returns VBox status code.
    1238  * @param   pClient             Client to defer.
    1239  * @param   hHandle             The call handle to defer.
    1240  * @param   u32Function         Function ID to save.
    1241  * @param   cParms              Number of parameters to save.
    1242  * @param   paParms             Parameter arrray to save.
    1243  */
    1244 int vboxSvcClipboardClientDefer(PVBOXCLIPBOARDCLIENT pClient,
    1245                                 VBOXHGCMCALLHANDLE hHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    1246 {
    1247     LogFlowFunc(("uClient=%RU32\n", pClient->uClientID));
    1248 
    1249     AssertMsgReturn(pClient->fDeferred == false, ("Client already in deferred mode\n"),
    1250                     VERR_WRONG_ORDER);
    1251 
    1252     pClient->fDeferred = true;
    1253 
    1254     pClient->Deferred.hHandle = hHandle;
    1255     pClient->Deferred.uType   = u32Function;
    1256     pClient->Deferred.cParms  = cParms;
    1257     pClient->Deferred.paParms = paParms;
    1258 
    1259     return false;
    1260 }
    1261 
    1262 /**
    1263  * Completes a call of a client, which in turn will return the result to the caller on
    1264  * the guest side.
    1265  *
    1266  * @returns VBox status code.
    1267  * @param   pClient             Client to complete.
    1268  * @param   hHandle             Call handle to complete.
    1269  * @param   rc                  Return code to set for the client.
    1270  */
    1271 int vboxSvcClipboardClientComplete(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hHandle, int rc)
    1272 {
    1273     RT_NOREF(pClient);
    1274 
    1275     LogFlowFunc(("uClient=%RU32, rc=%Rrc\n", pClient->uClientID, rc));
    1276 
    1277     g_pHelpers->pfnCallComplete(hHandle, rc);
    1278 
    1279     return VINF_SUCCESS;
    1280 }
    1281 
    1282 /**
    1283  * Completes a deferred client.
    1284  *
    1285  * @returns VBox status code.
    1286  * @param   pClient             Client to complete.
    1287  * @param   rcComplete          Return code to set for the client.
    1288  */
    1289 int vboxSvcClipboardClientDeferredComplete(PVBOXCLIPBOARDCLIENT pClient, int rcComplete)
    1290 {
    1291     LogFlowFunc(("uClient=%RU32, fDeferred=%RTbool\n", pClient->uClientID, pClient->fDeferred));
    1292 
    1293     int rc = VINF_SUCCESS;
    1294 
    1295     if (pClient->fDeferred) /* Not deferred? Bail out early. */
    1296     {
    1297         LogFlowFunc(("Completing call\n"));
    1298 
    1299         rc = vboxSvcClipboardClientComplete(pClient, pClient->Deferred.hHandle, rcComplete);
    1300 
    1301         pClient->fDeferred = false;
    1302         RT_ZERO(pClient->Deferred);
    1303     }
    1304 
    1305     return rc;
    1306 }
    1307 
    1308 /**
    1309  * Sets a deferred client's next message info -- when returning to the client, it then
    1310  * can retrieve the actual message sent by the host.
    1311  *
    1312  * @returns VBox status code.
    1313  * @param   pClient             Client to set the next message information for.
    1314  * @param   uMsg                Message ID to set.
    1315  * @param   cParms              Number of parameters of message required.
    1316  */
    1317 int vboxSvcClipboardClientDeferredSetMsgInfo(PVBOXCLIPBOARDCLIENT pClient, uint32_t uMsg, uint32_t cParms)
    1318 {
    1319     int rc;
    1320 
    1321     LogFlowFunc(("uClient=%RU32\n", pClient->uClientID));
    1322 
    1323     if (pClient->fDeferred)
    1324     {
    1325         if (pClient->Deferred.cParms >= 2)
    1326         {
    1327             AssertPtrReturn(pClient->Deferred.paParms, VERR_BUFFER_OVERFLOW);
    1328 
    1329             HGCMSvcSetU32(&pClient->Deferred.paParms[0], uMsg);
    1330             HGCMSvcSetU32(&pClient->Deferred.paParms[1], cParms);
    1331 
    1332             rc = VINF_SUCCESS;
    1333         }
    1334         else
    1335             rc = VERR_INVALID_PARAMETER;
    1336     }
    1337     else
    1338         rc = VERR_INVALID_STATE;
    1339 
    1340     LogFlowFuncLeaveRC(rc);
    1341     return rc;
    1342 }
    1343 
    1344 /**
    13451436 * Initializes a Shared Clipboard service's client state.
    13461437 *
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