VirtualBox

Changeset 79347 in vbox for trunk


Ignore:
Timestamp:
Jun 26, 2019 9:15:29 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
131579
Message:

Shared Clipboard/URI: Update.

Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk

    • Property svn:mergeinfo

      •  

        old new  
        99/branches/VBox-5.1:112367,115992,116543,116550,116568,116573
        1010/branches/VBox-5.2:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124260,124263,124271,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812
        11 /branches/VBox-6.0:130474-130475,130477,130479
         11/branches/VBox-6.0:130474-130475,130477,130479,131352
        1212/branches/aeichner/vbox-chromium-cleanup:129816,129818-129851,129853-129861,129871-129872,129876,129880,129882,130013-130015,130036,130094-130095
        1313/branches/andy/draganddrop:90781-91268

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

    r79299 r79347  
    6161#define SHAREDCLIPBOARDAREA_OPEN_FLAGS_VALID_MASK         0x1
    6262
    63 /**
    64  * Class for maintaining a Shared Clipboard area
    65  * on the host or guest. This will contain all received files & directories
    66  * for a single Shared Clipboard operation.
    67  *
    68  * In case of a failed Shared Clipboard operation this class can also
    69  * perform a gentle rollback if required.
    70  */
    71 class SharedClipboardArea
    72 {
    73 public:
    74 
    75     SharedClipboardArea(void);
    76     SharedClipboardArea(const char *pszPath, SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
    77                         SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
    78     virtual ~SharedClipboardArea(void);
    79 
    80 public:
    81 
    82     uint32_t AddRef(void);
    83     uint32_t Release(void);
    84 
    85     int Lock(void);
    86     int Unlock(void);
    87 
    88     int AddFile(const char *pszFile);
    89     int AddDir(const char *pszDir);
    90     int Close(void);
    91     bool IsOpen(void) const;
    92     int OpenEx(const char *pszPath, SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
    93                SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
    94     int OpenTemp(SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
    95                  SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
    96     SHAREDCLIPBOARDAREAID GetID(void) const;
    97     const char *GetDirAbs(void) const;
    98     uint32_t GetRefCount(void);
    99     int Reopen(void);
    100     int Reset(bool fDeleteContent);
    101     int Rollback(void);
    102 
    103 public:
    104 
    105     static int PathConstruct(const char *pszBase, SHAREDCLIPBOARDAREAID uID, char *pszPath, size_t cbPath);
    106 
    107 protected:
    108 
    109     int initInternal(void);
    110     int destroyInternal(void);
    111     int closeInternal(void);
    112 
    113 protected:
    114 
    115     /** Creation timestamp (in ms). */
    116     uint64_t                     m_tsCreatedMs;
    117     /** Number of references to this instance. */
    118     volatile uint32_t            m_cRefs;
    119     /** Critical section for serializing access. */
    120     RTCRITSECT                   m_CritSect;
    121     /** Open flags. */
    122     uint32_t                     m_fOpen;
    123     /** Directory handle for drop directory. */
    124     RTDIR                        m_hDir;
    125     /** Absolute path to drop directory. */
    126     RTCString                    m_strPathAbs;
    127     /** List for holding created directories in the case of a rollback. */
    128     RTCList<RTCString>           m_lstDirs;
    129     /** List for holding created files in the case of a rollback. */
    130     RTCList<RTCString>           m_lstFiles;
    131     /** Associated clipboard area ID. */
    132     SHAREDCLIPBOARDAREAID        m_uID;
    133 };
    134 
    135 int SharedClipboardPathSanitizeFilename(char *pszPath, size_t cbPath);
    136 int SharedClipboardPathSanitize(char *pszPath, size_t cbPath);
    137 
    13863/** SharedClipboardURIObject flags. */
    13964typedef uint32_t SHAREDCLIPBOARDURIOBJECTFLAGS;
    … …  
    16691        /** The usual 32-bit hack. */
    16792        Type_32Bit_Hack = 0x7fffffff
     93    };
     94
     95    enum Storage
     96    {
     97        Storage_Unknown = 0,
     98        Storage_Local,
     99        Storage_Temporary,
     100        /** The usual 32-bit hack. */
     101        Storage_32Bit_Hack = 0x7fffffff
    168102    };
    169103
    … …  
    269203    /** The object's view. */
    270204    View      m_enmView;
     205    /** Where the object is being stored to. */
     206    Storage   m_enmStorage;
    271207    /** Absolute path (base) for the source. */
    272208    RTCString m_strSrcPathAbs;
    … …  
    309245};
    310246
     247/**
     248 * Enumeration for specifying a clipboard area object type.
     249 */
     250typedef enum _SHAREDCLIPBOARDAREAOBJTYPE
     251{
     252    /** Unknown object type; do not use. */
     253    SHAREDCLIPBOARDAREAOBJTYPE_UNKNOWN = 0,
     254    /** Object is a directory. */
     255    SHAREDCLIPBOARDAREAOBJTYPE_DIR,
     256    /** Object is a file. */
     257    SHAREDCLIPBOARDAREAOBJTYPE_FILE,
     258    /** The usual 32-bit hack. */
     259    SHAREDCLIPBOARDAREAOBJTYPE__32Bit_Hack = 0x7fffffff
     260} SHAREDCLIPBOARDAREAOBJTYPE;
     261
     262/** Defines a clipboard area object state. */
     263typedef uint32_t SHAREDCLIPBOARDAREAOBJSTATE;
     264
     265/** No object state set. */
     266#define SHAREDCLIPBOARDAREAOBJSTATE_NONE                0
     267/** The object is considered as being complete (e.g. serialized). */
     268#define SHAREDCLIPBOARDAREAOBJSTATE_COMPLETE            RT_BIT(0)
     269
     270/**
     271 * Lightweight structure to keep a clipboard area object's state.
     272 *
     273 * Note: We don't want to use the ClipboardURIObject class here, as this
     274 *       is too heavy for this purpose.
     275 */
     276typedef struct _SHAREDCLIPBOARDAREAOBJ
     277{
     278    SHAREDCLIPBOARDAREAOBJTYPE  enmType;
     279    SHAREDCLIPBOARDAREAOBJSTATE fState;
     280} SHAREDCLIPBOARDAREAOBJ, *PSHAREDCLIPBOARDAREAOBJ;
     281
     282/**
     283 * Class for maintaining a Shared Clipboard area
     284 * on the host or guest. This will contain all received files & directories
     285 * for a single Shared Clipboard operation.
     286 *
     287 * In case of a failed Shared Clipboard operation this class can also
     288 * perform a gentle rollback if required.
     289 */
     290class SharedClipboardArea
     291{
     292public:
     293
     294    SharedClipboardArea(void);
     295    SharedClipboardArea(const char *pszPath, SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
     296                        SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
     297    virtual ~SharedClipboardArea(void);
     298
     299public:
     300
     301    uint32_t AddRef(void);
     302    uint32_t Release(void);
     303
     304    int Lock(void);
     305    int Unlock(void);
     306
     307    int AddObject(const char *pszPath, const SHAREDCLIPBOARDAREAOBJ &Obj);
     308    int GetObject(const char *pszPath, PSHAREDCLIPBOARDAREAOBJ pObj);
     309
     310    int Close(void);
     311    bool IsOpen(void) const;
     312    int OpenEx(const char *pszPath, SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
     313               SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
     314    int OpenTemp(SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
     315                 SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
     316    SHAREDCLIPBOARDAREAID GetID(void) const;
     317    const char *GetDirAbs(void) const;
     318    uint32_t GetRefCount(void);
     319    int Reopen(void);
     320    int Reset(bool fDeleteContent);
     321    int Rollback(void);
     322
     323public:
     324
     325    static int PathConstruct(const char *pszBase, SHAREDCLIPBOARDAREAID uID, char *pszPath, size_t cbPath);
     326
     327protected:
     328
     329    int initInternal(void);
     330    int destroyInternal(void);
     331    int closeInternal(void);
     332
     333protected:
     334
     335    typedef std::map<RTCString, SHAREDCLIPBOARDAREAOBJ> SharedClipboardAreaFsObjMap;
     336
     337    /** Creation timestamp (in ms). */
     338    uint64_t                     m_tsCreatedMs;
     339    /** Number of references to this instance. */
     340    volatile uint32_t            m_cRefs;
     341    /** Critical section for serializing access. */
     342    RTCRITSECT                   m_CritSect;
     343    /** Open flags. */
     344    uint32_t                     m_fOpen;
     345    /** Directory handle for root clipboard directory. */
     346    RTDIR                        m_hDir;
     347    /** Absolute path to root clipboard directory. */
     348    RTCString                    m_strPathAbs;
     349    /** List for holding created directories in the case of a rollback. */
     350    SharedClipboardAreaFsObjMap  m_mapObj;
     351    /** Associated clipboard area ID. */
     352    SHAREDCLIPBOARDAREAID        m_uID;
     353};
     354
     355int SharedClipboardPathSanitizeFilename(char *pszPath, size_t cbPath);
     356int SharedClipboardPathSanitize(char *pszPath, size_t cbPath);
     357
    311358/** SharedClipboardURIList flags. */
    312359typedef uint32_t SHAREDCLIPBOARDURILISTFLAGS;
    … …  
    408455int SharedClipboardURIFileHdrInit(PVBOXCLIPBOARDFILEHDR pFileHdr);
    409456void SharedClipboardURIFileHdrDestroy(PVBOXCLIPBOARDFILEHDR pFileHdr);
     457void SharedClipboardURIFileHdrFree(PVBOXCLIPBOARDFILEHDR pFileHdr);
    410458PVBOXCLIPBOARDFILEHDR SharedClipboardURIFileHdrDup(PVBOXCLIPBOARDFILEHDR pFileHdr);
    411459bool SharedClipboardURIFileHdrIsValid(PVBOXCLIPBOARDFILEHDR pFileHdr, PVBOXCLIPBOARDDATAHDR pDataHdr);
    … …  
    457505    /** How many bytes are being used in the meta data block. */
    458506    uint32_t                    cbUsed;
     507    /** Current reading offset (in bytes). */
     508    uint32_t                    cbOffRead;
    459509} SHAREDCLIPBOARDMETADATA, *PSHAREDCLIPBOARDMETADATA;
    460510
    461511int SharedClipboardMetaDataInit(PSHAREDCLIPBOARDMETADATA pMeta, SHAREDCLIPBOARDMETADATAFMT enmFmt);
    462512void SharedClipboardMetaDataDestroy(PSHAREDCLIPBOARDMETADATA pMeta);
     513void SharedClipboardMetaDataFree(PSHAREDCLIPBOARDMETADATA pMeta);
    463514int SharedClipboardMetaDataAdd(PSHAREDCLIPBOARDMETADATA pMeta, const void *pvDataAdd, uint32_t cbDataAdd);
    464515int SharedClipboardMetaDataConvertToFormat(const void *pvData, size_t cbData, SHAREDCLIPBOARDMETADATAFMT enmFmt,
    465516                                           void **ppvData, uint32_t *pcbData);
     517int SharedClipboardMetaDataRead(PSHAREDCLIPBOARDMETADATA pMeta, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead);
    466518int SharedClipboardMetaDataResize(PSHAREDCLIPBOARDMETADATA pMeta, uint32_t cbNewSize);
    467519size_t SharedClipboardMetaDataGetFree(PSHAREDCLIPBOARDMETADATA pMeta);
    … …  
    486538} SHAREDCLIPBOARDURITRANSFERDIR;
    487539
     540struct _SHAREDCLIPBOARDURITRANSFER;
     541typedef struct _SHAREDCLIPBOARDURITRANSFER SHAREDCLIPBOARDURITRANSFER;
     542
     543/**
     544 * Structure for handling a single URI object context.
     545 */
     546typedef struct _SHAREDCLIPBOARDCLIENTURIOBJCTX
     547{
     548    SHAREDCLIPBOARDURITRANSFER    *pTransfer;
     549    /** Pointer to current object being processed. */
     550    SharedClipboardURIObject      *pObj;
     551} SHAREDCLIPBOARDCLIENTURIOBJCTX, *PSHAREDCLIPBOARDCLIENTURIOBJCTX;
     552
     553/**
     554 * Enumeration specifying an URI transfer status.
     555 */
     556typedef enum SHAREDCLIPBOARDURITRANSFERSTATUS
     557{
     558    /** No status set. */
     559    SHAREDCLIPBOARDURITRANSFERSTATUS_NONE = 0,
     560    /** The transfer has been announced but is not running yet. */
     561    SHAREDCLIPBOARDURITRANSFERSTATUS_ANNOUNCED,
     562    /** The transfer is active and running. */
     563    SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING
     564};
     565
     566/**
     567 * Enumeration to specify the Shared Clipboard URI source type.
     568 */
     569typedef enum SHAREDCLIPBOARDSOURCE
     570{
     571    /** Invalid source type. */
     572    SHAREDCLIPBOARDSOURCE_INVALID = 0,
     573    /** Source is local. */
     574    SHAREDCLIPBOARDSOURCE_LOCAL,
     575    /** Source is remote. */
     576    SHAREDCLIPBOARDSOURCE_REMOTE,
     577    /** The usual 32-bit hack. */
     578    SHAREDCLIPBOARDSOURCE_32Bit_Hack = 0x7fffffff
     579} SHAREDCLIPBOARDSOURCE;
     580
    488581/**
    489582 * Structure for maintaining an URI transfer state.
    … …  
    492585typedef struct _SHAREDCLIPBOARDURITRANSFERSTATE
    493586{
     587    /** The transfer's current status. */
     588    SHAREDCLIPBOARDURITRANSFERSTATUS    enmStatus;
    494589    /** The transfer's direction. */
    495     SHAREDCLIPBOARDURITRANSFERDIR enmDir;
     590    SHAREDCLIPBOARDURITRANSFERDIR       enmDir;
     591    /** The transfer's source. */
     592    SHAREDCLIPBOARDSOURCE               enmSource;
     593    bool                                fHostMsgSendHeader;
    496594    /** The transfer's cached data header.
    497595     *  Can be NULL if no header has been received yet. */
    498     PVBOXCLIPBOARDDATAHDR         pHeader;
     596    PVBOXCLIPBOARDDATAHDR               pHeader;
     597    bool                                fHostMsgSendMetaDataHdr;
     598    bool                                fHostMsgSendMetaDataChunk;
    499599    /** The transfer's cached meta data.
    500600     *  Can be NULL if no meta data has been received yet. */
    501     PSHAREDCLIPBOARDMETADATA      pMeta;
     601    PSHAREDCLIPBOARDMETADATA            pMeta;
     602    /** Context of current object being handled. */
     603    SHAREDCLIPBOARDCLIENTURIOBJCTX      ObjCtx;
    502604} SHAREDCLIPBOARDURITRANSFERSTATE, *PSHAREDCLIPBOARDURITRANSFERSTATE;
    503605
    504 /**
    505  * Enumeration to specify the Shared Clipboard URI provider source type.
    506  */
    507 typedef enum SHAREDCLIPBOARDURIPROVIDERSOURCE
    508 {
    509     /** Invalid source type. */
    510     SHAREDCLIPBOARDURIPROVIDERSOURCE_INVALID = 0,
    511     /** Source is VbglR3. */
    512     SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3,
    513     /** Source is the host service. */
    514     SHAREDCLIPBOARDURIPROVIDERSOURCE_HOSTSERVICE
    515 } SHAREDCLIPBOARDURIPROVIDERSOURCE;
    516 
    517 class SharedClipboardProvider;
    518 
    519 /**
    520  * Structure for storing clipboard provider callback data.
    521  */
    522 typedef struct _SHAREDCLIPBOARDPROVIDERCALLBACKDATA
    523 {
    524     /** Pointer to related clipboard provider ("this"). */
    525     SharedClipboardProvider    *pProvider;
    526     /** Saved user pointer. */
     606struct _SHAREDCLIPBOARDURITRANSFER;
     607typedef struct _SHAREDCLIPBOARDURITRANSFER *PSHAREDCLIPBOARDURITRANSFER;
     608
     609typedef struct _SHAREDCLIPBOARDPROVIDERCTX
     610{
     611    PSHAREDCLIPBOARDURITRANSFER pTransfer;
    527612    void                       *pvUser;
    528 } SHAREDCLIPBOARDPROVIDERCALLBACKDATA, *PSHAREDCLIPBOARDPROVIDERCALLBACKDATA;
    529 
    530 /** Callback functopn for the Shared Clipboard provider. */
    531 typedef DECLCALLBACK(int) FNSSHAREDCLIPBOARDPROVIDERCALLBACK(PSHAREDCLIPBOARDPROVIDERCALLBACKDATA pData);
    532 /** Pointer to a FNSSHAREDCLIPBOARDPROVIDERCALLBACK function. */
    533 typedef FNSSHAREDCLIPBOARDPROVIDERCALLBACK *PFNSSHAREDCLIPBOARDPROVIDERCALLBACK;
    534 
    535 /**
    536  * Structure acting as a function callback table for clipboard providers.
    537  * All callbacks are optional and therefore can be NULL.
    538  */
    539 typedef struct _SHAREDCLIPBOARDPROVIDERCALLBACKS
    540 {
    541     /** Saved user pointer. Will be passed to the callback (if needed). */
    542     void                                    *pvUser;
    543     /** Function pointer, called when reading the (meta) data header. */
    544     PFNSSHAREDCLIPBOARDPROVIDERCALLBACK      pfnReadDataHdr;
    545     /** Function pointer, called when reading a (meta) data chunk. */
    546     PFNSSHAREDCLIPBOARDPROVIDERCALLBACK      pfnReadDataChunk;
    547 } SHAREDCLIPBOARDPROVIDERCALLBACKS, *PSHAREDCLIPBOARDPROVIDERCALLBACKS;
     613} SHAREDCLIPBOARDPROVIDERCTX, *PSHAREDCLIPBOARDPROVIDERCTX;
     614
     615#define SHAREDCLIPBOARDPROVIDERFUNCDECL(a_Name, ...) \
     616    typedef DECLCALLBACK(int) RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name)(PSHAREDCLIPBOARDPROVIDERCTX, __VA_ARGS__); \
     617    typedef RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDPROVIDER, a_Name);
     618
     619#define SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(a_Name) \
     620    typedef DECLCALLBACK(int) RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name)(PSHAREDCLIPBOARDPROVIDERCTX); \
     621    typedef RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDPROVIDER, a_Name);
     622
     623#define SHAREDCLIPBOARDPROVIDERFUNCMEMBER(a_Name, a_Member) \
     624    RT_CONCAT(PFNSHAREDCLIPBOARDPROVIDER, a_Name) a_Member;
     625
     626SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(PREPARE)
     627SHAREDCLIPBOARDPROVIDERFUNCDECL(READDATAHDR, PVBOXCLIPBOARDDATAHDR *ppDataHdr)
     628SHAREDCLIPBOARDPROVIDERFUNCDECL(WRITEDATAHDR, const PVBOXCLIPBOARDDATAHDR pDataHdr)
     629SHAREDCLIPBOARDPROVIDERFUNCDECL(READDATACHUNK, const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead)
     630SHAREDCLIPBOARDPROVIDERFUNCDECL(WRITEDATACHUNK, const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten)
     631SHAREDCLIPBOARDPROVIDERFUNCDECL(READOBJHDR, PVBOXCLIPBOARDOBJHDR *ppObjHdr)
     632SHAREDCLIPBOARDPROVIDERFUNCDECL(READDIRECTORY, PVBOXCLIPBOARDDIRDATA *ppDirData)
     633SHAREDCLIPBOARDPROVIDERFUNCDECL(WRITEDIRECTORY, const PVBOXCLIPBOARDDIRDATA pDirData)
     634SHAREDCLIPBOARDPROVIDERFUNCDECL(READFILEHDR, PVBOXCLIPBOARDFILEHDR *ppFileHdr);
     635SHAREDCLIPBOARDPROVIDERFUNCDECL(WRITEFILEHDR, const PVBOXCLIPBOARDFILEHDR pFileHdr);
     636SHAREDCLIPBOARDPROVIDERFUNCDECL(READFILEDATA, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
     637SHAREDCLIPBOARDPROVIDERFUNCDECL(WRITEFILEDATA, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
     638SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(RESET)
     639
     640typedef struct _SHAREDCLIPBOARDPROVIDERINTERFACE
     641{
     642    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(PREPARE, pfnPrepare);
     643    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(READDATAHDR, pfnReadDataHdr);
     644    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(WRITEDATAHDR, pfnWriteDataHdr);
     645    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(WRITEDATACHUNK, pfnWriteDataChunk);
     646    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(READDATACHUNK, pfnReadDataChunk);
     647    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(READOBJHDR, pfnReadObjHdr);
     648    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(READDIRECTORY, pfnReadDirectory);
     649    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(WRITEDIRECTORY, pfnWriteDirectory);
     650    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(READFILEHDR, pfnReadFileHdr);
     651    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(WRITEFILEHDR, pfnWriteFileHdr);
     652    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(READFILEDATA, pfnReadFileData);
     653    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(WRITEFILEDATA, pfnWriteFileData);
     654    SHAREDCLIPBOARDPROVIDERFUNCMEMBER(RESET, pfnReset);
     655} SHAREDCLIPBOARDPROVIDERINTERFACE, *PSHAREDCLIPBOARDPROVIDERINTERFACE;
    548656
    549657/**
    … …  
    553661{
    554662    /** Specifies what the source of the provider is. */
    555     SHAREDCLIPBOARDURIPROVIDERSOURCE  enmSource;
    556     /** Specifies whether the provider will read or write data. */
    557     SHAREDCLIPBOARDURITRANSFERDIR     enmDir;
    558     /** Optional callback table; can be NULL if not needed. */
    559     PSHAREDCLIPBOARDPROVIDERCALLBACKS pCallbacks;
     663    SHAREDCLIPBOARDSOURCE             enmSource;
     664    SHAREDCLIPBOARDPROVIDERINTERFACE  Interface;
     665    void                             *pvUser;
    560666    union
    561667    {
    … …  
    601707} SHAREDCLIPBOARDPROVIDERWRITEPARMS, *PSHAREDCLIPBOARDPROVIDERWRITEPARMS;
    602708
     709#if 0
    603710/**
    604711 * Interface class acting as a lightweight proxy for abstracting reading / writing clipboard data.
    … …  
    800907};
    801908#endif /* VBOX_WITH_SHARED_CLIPBOARD_HOST */
     909#endif
    802910
    803911struct _SHAREDCLIPBOARDURITRANSFER;
    … …  
    815923} SHAREDCLIPBOARDURITRANSFERCALLBACKDATA, *PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA;
    816924
    817 typedef DECLCALLBACK(void) FNSHAREDCLIPBOARDURITRANSFERSTARTED(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
    818 /** Pointer to a FNSHAREDCLIPBOARDURITRANSFERSTARTED function. */
    819 typedef FNSHAREDCLIPBOARDURITRANSFERSTARTED *PFNSHAREDCLIPBOARDURITRANSFERSTARTED;
    820 
    821 typedef DECLCALLBACK(void) FNSHAREDCLIPBOARDURITRANSFERPREPARE(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
    822 /** Pointer to a FNSHAREDCLIPBOARDURITRANSFERPREPARE function. */
    823 typedef FNSHAREDCLIPBOARDURITRANSFERPREPARE *PFNSHAREDCLIPBOARDURITRANSFERPREPARE;
    824 
    825 typedef DECLCALLBACK(void) FNSHAREDCLIPBOARDURIMETADATACOMPLETE(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
    826 /** Pointer to a FNSHAREDCLIPBOARDURIMETADATACOMPLETE function. */
    827 typedef FNSHAREDCLIPBOARDURIMETADATACOMPLETE *PFNSHAREDCLIPBOARDURIMETADATACOMPLETE;
    828 
    829 typedef DECLCALLBACK(void) FNSHAREDCLIPBOARDURITRANSFERCANCELED(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
    830 /** Pointer to a FNSHAREDCLIPBOARDURITRANSFERCANCELED function. */
    831 typedef FNSHAREDCLIPBOARDURITRANSFERCANCELED *PFNSHAREDCLIPBOARDURITRANSFERCANCELED;
    832 
    833 typedef DECLCALLBACK(void) FNSHAREDCLIPBOARDURITRANSFERCOMPLETE(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
    834 /** Pointer to a FNSHAREDCLIPBOARDURITRANSFERCOMPLETE function. */
    835 typedef FNSHAREDCLIPBOARDURITRANSFERCOMPLETE *PFNSHAREDCLIPBOARDURITRANSFERCOMPLETE;
    836 
    837 typedef DECLCALLBACK(void) FNSHAREDCLIPBOARDURITRANSFERERROR(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
    838 /** Pointer to a FNSHAREDCLIPBOARDURITRANSFERERROR function. */
    839 typedef FNSHAREDCLIPBOARDURITRANSFERERROR *PFNSHAREDCLIPBOARDURITRANSFERERROR;
     925#define SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(a_Name) \
     926    typedef DECLCALLBACK(void) RT_CONCAT(FNSHAREDCLIPBOARDCALLBACK, a_Name)(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData); \
     927    typedef RT_CONCAT(FNSHAREDCLIPBOARDCALLBACK, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDCALLBACK, a_Name);
     928
     929#define SHAREDCLIPBOARDTRANSFERCALLBACKDECL(a_Name, ...) \
     930    typedef DECLCALLBACK(void) RT_CONCAT(FNSHAREDCLIPBOARDCALLBACK, a_Name)(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, __VA_ARGS__); \
     931    typedef RT_CONCAT(FNSHAREDCLIPBOARDCALLBACK, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDCALLBACK, a_Name);
     932
     933#define SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(a_Name, a_Member) \
     934    RT_CONCAT(PFNSHAREDCLIPBOARDCALLBACK, a_Name) a_Member;
     935
     936SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(TRANSFERPREPARE)
     937SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(TRANSFERSTARTED)
     938SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(DATAHDRCOMPLETE)
     939SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(DATACHUNKCOMPLETE)
     940SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(TRANSFERCANCELED)
     941SHAREDCLIPBOARDTRANSFERCALLBACKDECL    (TRANSFERCOMPLETE, int rc)
     942SHAREDCLIPBOARDTRANSFERCALLBACKDECL    (TRANSFERERROR, int rc)
    840943
    841944/**
    … …  
    846949{
    847950    /** Saved user pointer. */
    848     void                                 *pvUser;
     951    void                                  *pvUser;
    849952    /** Function pointer, called when the transfer is going to be prepared. */
    850     PFNSHAREDCLIPBOARDURITRANSFERPREPARE  pfnTransferPrepare;
     953    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERPREPARE, pfnTransferPrepare);
    851954    /** Function pointer, called when the transfer has been started. */
    852     PFNSHAREDCLIPBOARDURITRANSFERSTARTED  pfnTransferStarted;
    853     /** Function pointer, called when reading / writing meta data is complete. */
    854     PFNSHAREDCLIPBOARDURIMETADATACOMPLETE pfnMetaDataComplete;
     955    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERSTARTED, pfnTransferStarted);
     956    /** Function pointer, called when reading / writing the meta data header is complete. */
     957    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(DATAHDRCOMPLETE, pfnDataHeaderComplete);
     958    /** Function pointer, called when reading / writing the meta data is complete. */
     959    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(DATACHUNKCOMPLETE, pfnDataComplete);
    855960    /** Function pointer, called when the transfer is complete. */
    856     PFNSHAREDCLIPBOARDURITRANSFERCOMPLETE pfnTransferComplete;
     961    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERCOMPLETE, pfnTransferComplete);
    857962    /** Function pointer, called when the transfer has been canceled. */
    858     PFNSHAREDCLIPBOARDURITRANSFERCANCELED pfnTransferCanceled;
     963    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERCANCELED, pfnTransferCanceled);
    859964    /** Function pointer, called when transfer resulted in an unrecoverable error. */
    860     PFNSHAREDCLIPBOARDURITRANSFERERROR    pfnTransferError;
     965    SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERERROR, pfnTransferError);
    861966} SHAREDCLIPBOARDURITRANSFERCALLBACKS, *PSHAREDCLIPBOARDURITRANSFERCALLBACKS;
    862967
    … …  
    874979    volatile bool               fCancelled;
    875980} SHAREDCLIPBOARDURITRANSFERTHREAD, *PSHAREDCLIPBOARDURITRANSFERTHREAD;
    876 
    877 /**
    878  * Structure for handling a single URI object context.
    879  */
    880 typedef struct _SHAREDCLIPBOARDCLIENTURIOBJCTX
    881 {
    882     /** Pointer to current object being processed. */
    883     SharedClipboardURIObject      *pObj;
    884 } SHAREDCLIPBOARDCLIENTURIOBJCTX, *PSHAREDCLIPBOARDCLIENTURIOBJCTX;
    885981
    886982/**
    … …  
    903999    /** The URI list for this transfer. */
    9041000    SharedClipboardURIList             *pURIList;
    905     /** Context of current object being handled. */
    906     SHAREDCLIPBOARDCLIENTURIOBJCTX      ObjCtx;
    907     /** The Shared Clipboard provider in charge for this transfer. */
    908     SharedClipboardProvider            *pProvider;
     1001    SHAREDCLIPBOARDPROVIDERCTX          ProviderCtx;
     1002    /** The transfer's provider interface. */
     1003    SHAREDCLIPBOARDPROVIDERINTERFACE    ProviderIface;
     1004    /** The transfer's (optional) callback table. */
     1005    SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
    9091006    /** Opaque pointer to implementation-specific parameters. */
    9101007    void                               *pvUser;
    … …  
    9131010    /** Contains thread-related attributes. */
    9141011    SHAREDCLIPBOARDURITRANSFERTHREAD    Thread;
    915     /** (Optional) callbacks related to this transfer. */
    916     SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
    9171012} SHAREDCLIPBOARDURITRANSFER, *PSHAREDCLIPBOARDURITRANSFER;
    9181013
    … …  
    9271022     *  Use a list or something lateron. */
    9281023    RTLISTANCHOR                List;
    929     /** Number of concurrent transfers.
     1024    /** Number of running (concurrent) transfers.
    9301025     *  At the moment we only support only one transfer per client at a time. */
    931     uint32_t                    cTransfers;
    932     /** Maximum Number of concurrent transfers.
     1026    uint32_t                    cRunning;
     1027    /** Maximum Number of running (concurrent) transfers.
    9331028     *  At the moment we only support only one transfer per client at a time. */
    934     uint32_t                    cMaxTransfers;
     1029    uint32_t                    cMaxRunning;
     1030#ifdef DEBUG
     1031    uint32_t                    cTransfer;
     1032#endif
    9351033} SHAREDCLIPBOARDURICTX, *PSHAREDCLIPBOARDURICTX;
    9361034
    … …  
    9401038bool SharedClipboardURIObjCtxIsValid(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx);
    9411039
    942 int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, PSHAREDCLIPBOARDURITRANSFER *ppTransfer);
     1040int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource, PSHAREDCLIPBOARDURITRANSFER *ppTransfer);
    9431041int SharedClipboardURITransferDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    9441042int SharedClipboardURITransferPrepare(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    9451043int SharedClipboardURITransferProviderCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer,
    946                                              PSHAREDCLIPBOARDPROVIDERCREATIONCTX pProviderCtx);
     1044                                             PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx);
    9471045void SharedClipboardURITransferReset(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    9481046SharedClipboardArea *SharedClipboardURITransferGetArea(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    9491047PSHAREDCLIPBOARDCLIENTURIOBJCTX SharedClipboardURITransferGetCurrentObjCtx(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    9501048const SharedClipboardURIObject *SharedClipboardURITransferGetCurrentObject(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    951 SharedClipboardProvider *SharedClipboardURITransferGetProvider(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    9521049SharedClipboardURIList *SharedClipboardURITransferGetList(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    9531050SharedClipboardURIObject *SharedClipboardURITransferGetObject(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint64_t uIdx);
     1051SHAREDCLIPBOARDSOURCE SharedClipboardURITransferGetSource(PSHAREDCLIPBOARDURITRANSFER pTransfer);
     1052SHAREDCLIPBOARDURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    9541053int SharedClipboardURITransferRun(PSHAREDCLIPBOARDURITRANSFER pTransfer, bool fAsync);
    9551054void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer,
    9561055                                            PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks);
     1056int SharedClipboardURITransferSetDataHeader(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDDATAHDR pDataHdr);
     1057int SharedClipboardURITransferSetDataChunk(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDDATACHUNK pDataChunk);
    9571058
    9581059int SharedClipboardURITransferMetaDataAdd(PSHAREDCLIPBOARDURITRANSFER pTransfer, const void *pvMeta, uint32_t cbMeta);
    … …  
    9711072void SharedClipboardURICtxReset(PSHAREDCLIPBOARDURICTX pURI);
    9721073PSHAREDCLIPBOARDURITRANSFER SharedClipboardURICtxGetTransfer(PSHAREDCLIPBOARDURICTX pURI, uint32_t uIdx);
    973 uint32_t SharedClipboardURICtxGetActiveTransfers(PSHAREDCLIPBOARDURICTX pURI);
    974 bool SharedClipboardURICtxMaximumTransfersReached(PSHAREDCLIPBOARDURICTX pURI);
     1074uint32_t SharedClipboardURICtxGetRunningTransfers(PSHAREDCLIPBOARDURICTX pURI);
     1075void SharedClipboardURICtxTransfersCleanup(PSHAREDCLIPBOARDURICTX pURI);
     1076bool SharedClipboardURICtxTransfersMaximumReached(PSHAREDCLIPBOARDURICTX pURI);
    9751077int SharedClipboardURICtxTransferAdd(PSHAREDCLIPBOARDURICTX pURI, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    9761078int SharedClipboardURICtxTransferRemove(PSHAREDCLIPBOARDURICTX pURI, PSHAREDCLIPBOARDURITRANSFER pTransfer);

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

    r79299 r79347  
    137137int VBoxClipboardWinAnnounceFormats(PVBOXCLIPBOARDWINCTX pWinCtx, VBOXCLIPBOARDFORMATS fFormats);
    138138#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    139 int VBoxClipboardWinURIAnnounce(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURICTX pURICtx,
    140                                 PSHAREDCLIPBOARDURITRANSFER pTransfer);
     139int VBoxClipboardWinURITransferCreate(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer);
     140void VBoxClipboardWinURITransferDestroy(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    141141#endif
    142142
    … …  
    204204
    205205    int Init(void);
     206    void OnMetaDataComplete(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    206207    void OnTransferComplete(int rc = VINF_SUCCESS);
    207208    void OnTransferCanceled();
    … …  
    222223    void registerFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat, TYMED tyMed = TYMED_HGLOBAL,
    223224                        LONG lindex = -1, DWORD dwAspect = DVASPECT_CONTENT, DVTARGETDEVICE *pTargetDevice = NULL);
    224 
    225 protected: /* URI transfer callbacks */
    226 
    227     static DECLCALLBACK(void) onMetaDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
    228 
    229225protected:
    230226

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

    r79299 r79347  
    402402} VBOXCLIPBOARDDATACHUNK, *PVBOXCLIPBOARDDATACHUNK;
    403403
     404typedef struct _VBOXCLIPBOARDOBJHDR
     405{
     406    uint32_t                    enmType;
     407} VBOXCLIPBOARDOBJHDR, *PVBOXCLIPBOARDOBJHDR;
     408
    404409typedef struct _VBOXCLIPBOARDDIRDATA
    405410{
    … …  
    448453
    449454#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    450 int VBoxSvcClipboardURIReadDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr);
    451 int VBoxSvcClipboardURIWriteDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr);
    452 int VBoxSvcClipboardURIReadDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk);
    453 int VBoxSvcClipboardURIWriteDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk);
    454 int VBoxSvcClipboardURIReadDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData);
    455 int VBoxSvcClipboardURIWriteDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData);
    456 int VBoxSvcClipboardURIReadFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr);
    457 int VBoxSvcClipboardURIWriteFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr);
    458 int VBoxSvcClipboardURIReadFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData);
    459 int VBoxSvcClipboardURIWriteFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData);
     455int VBoxSvcClipboardURIGetDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr);
     456int VBoxSvcClipboardURISetDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr);
     457int VBoxSvcClipboardURISetDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk);
     458int VBoxSvcClipboardURISetDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk);
     459int VBoxSvcClipboardURIGetDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData);
     460int VBoxSvcClipboardURISetDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData);
     461int VBoxSvcClipboardURIGetFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr);
     462int VBoxSvcClipboardURISetFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr);
     463int VBoxSvcClipboardURIGetFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData);
     464int VBoxSvcClipboardURISetFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData);
    460465#endif
    461466

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

    r79270 r79347  
    6161        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp \
    6262        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp \
    63         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardProvider.cpp \
    64         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardProvider-VbglR3.cpp \
    6563        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp \
    6664        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardURIList.cpp \

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

    r79299 r79347  
    8282*********************************************************************************************************************************/
    8383#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    84 static DECLCALLBACK(void) vboxClipboardOnURITransferComplete(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
    85 static DECLCALLBACK(void) vboxClipboardOnURITransferError(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
     84static DECLCALLBACK(void) vboxClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
     85static DECLCALLBACK(void) vboxClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
    8686#endif
    8787
     88
     89#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     90static DECLCALLBACK(void) vboxClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
     91{
     92    RT_NOREF(rc);
     93
     94    LogFlowFunc(("pData=%p, rc=%Rrc\n", pData, rc));
     95
     96    LogRel2(("Shared Clipboard: Transfer to destination complete\n"));
     97
     98    PSHAREDCLIPBOARDURICTX pCtx = (PSHAREDCLIPBOARDURICTX)pData->pvUser;
     99    AssertPtr(pCtx);
     100
     101    PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer;
     102    AssertPtr(pTransfer);
     103
     104    if (pTransfer->pvUser) /* SharedClipboardWinURITransferCtx */
     105    {
     106        delete pTransfer->pvUser;
     107        pTransfer->pvUser = NULL;
     108    }
     109
     110    int rc2 = SharedClipboardURICtxTransferRemove(pCtx, pTransfer);
     111    AssertRC(rc2);
     112}
     113
     114static DECLCALLBACK(void) vboxClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
     115{
     116    RT_NOREF(rc);
     117
     118    LogFlowFunc(("pData=%p, rc=%Rrc\n", pData, rc));
     119
     120    LogRel(("Shared Clipboard: Transfer to destination failed with %Rrc\n", rc));
     121
     122    PSHAREDCLIPBOARDURICTX pCtx = (PSHAREDCLIPBOARDURICTX)pData->pvUser;
     123    AssertPtr(pCtx);
     124
     125    PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer;
     126    AssertPtr(pTransfer);
     127
     128    if (pTransfer->pvUser) /* SharedClipboardWinURITransferCtx */
     129    {
     130        delete pTransfer->pvUser;
     131        pTransfer->pvUser = NULL;
     132    }
     133
     134    int rc2 = SharedClipboardURICtxTransferRemove(pCtx, pTransfer);
     135    AssertRC(rc2);
     136}
     137
     138static int vboxClipboardURIReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDATAHDR *ppDataHdr)
     139{
     140    LogFlowFuncEnter();
     141
     142    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     143    AssertPtr(pThisCtx);
     144
     145    LogFlowFunc(("c=%RU32\n", pThisCtx->u32ClientID));
     146
     147    VBOXCLIPBOARDDATAHDR dataHdr;
     148    SharedClipboardURIDataHdrInit(&dataHdr);
     149
     150    int rc = VbglR3ClipboardReadDataHdr(pThisCtx->u32ClientID, &dataHdr);
     151    if (RT_SUCCESS(rc))
     152    {
     153        *ppDataHdr = SharedClipboardURIDataHdrDup(&dataHdr);
     154    }
     155
     156    LogFlowFuncLeaveRC(rc);
     157    return rc;
     158}
     159
     160static int vboxClipboardURIWriteDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr)
     161{
     162    LogFlowFuncEnter();
     163
     164    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     165    AssertPtr(pThisCtx);
     166
     167    int rc = VbglR3ClipboardWriteDataHdr(pThisCtx->u32ClientID, pDataHdr);
     168
     169    LogFlowFuncLeaveRC(rc);
     170    return rc;
     171}
     172
     173static int vboxClipboardURIReadDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr,
     174                                         void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead)
     175{
     176    RT_NOREF(fFlags);
     177
     178    LogFlowFuncEnter();
     179
     180    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     181    AssertPtr(pThisCtx);
     182
     183    int rc = VINF_SUCCESS;
     184
     185    uint32_t cbReadTotal = 0;
     186    uint32_t cbToRead = RT_MIN(pDataHdr->cbMeta, cbChunk);
     187
     188    while (cbToRead)
     189    {
     190        uint32_t cbRead;
     191        rc = VbglR3ClipboardReadMetaData(pThisCtx->u32ClientID, pDataHdr, (uint8_t *)pvChunk + cbReadTotal, cbToRead, &cbRead);
     192        if (RT_FAILURE(rc))
     193            break;
     194
     195        cbReadTotal += cbRead;
     196        Assert(cbToRead >= cbRead);
     197        cbToRead    -= cbRead;
     198    }
     199
     200    if (RT_SUCCESS(rc))
     201    {
     202        if (pcbRead)
     203            *pcbRead = cbReadTotal;
     204    }
     205
     206    LogFlowFuncLeaveRC(rc);
     207    return rc;
     208}
     209
     210static int vboxClipboardURIWriteDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr,
     211                                          const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten)
     212{
     213    RT_NOREF(fFlags);
     214
     215    LogFlowFuncEnter();
     216
     217    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     218    AssertPtr(pThisCtx);
     219
     220    int rc = VINF_SUCCESS;
     221
     222    uint32_t cbWrittenTotal = 0;
     223    uint32_t cbToWrite      = RT_MIN(pDataHdr->cbMeta, cbChunk);
     224
     225    while (cbToWrite)
     226    {
     227        uint32_t cbWritten;
     228        rc = VbglR3ClipboardWriteMetaData(pThisCtx->u32ClientID, pDataHdr, (uint8_t *)pvChunk + cbWrittenTotal, cbToWrite,
     229                                          &cbWritten);
     230        if (RT_FAILURE(rc))
     231            break;
     232
     233        cbWrittenTotal += cbWritten;
     234        Assert(cbToWrite >= cbWritten);
     235        cbToWrite      -= cbWritten;
     236    }
     237
     238    if (RT_SUCCESS(rc))
     239    {
     240        if (pcbWritten)
     241            *pcbWritten = cbWrittenTotal;
     242    }
     243
     244    LogFlowFunc(("cbWrittenTotal=%RU32, rc=%Rrc\n", cbWrittenTotal, rc));
     245    return rc;
     246}
     247
     248static int vboxClipboardURIReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDIRDATA *ppDirData)
     249{
     250    LogFlowFuncEnter();
     251
     252    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     253    AssertPtr(pThisCtx);
     254
     255    VBOXCLIPBOARDDIRDATA dirData;
     256    SharedClipboardURIDirDataInit(&dirData);
     257
     258    int rc = VbglR3ClipboardReadDir(pThisCtx->u32ClientID, dirData.pszPath, dirData.cbPath, &dirData.cbPath, &dirData.fMode);
     259    if (RT_SUCCESS(rc))
     260    {
     261        *ppDirData = SharedClipboardURIDirDataDup(&dirData);
     262    }
     263
     264    LogFlowFuncLeaveRC(rc);
     265    return rc;
     266}
     267
     268static int vboxClipboardURIWriteDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDIRDATA pDirData)
     269{
     270    LogFlowFuncEnter();
     271
     272    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     273    AssertPtr(pThisCtx);
     274
     275    int rc = VbglR3ClipboardWriteDir(pThisCtx->u32ClientID, pDirData->pszPath, pDirData->cbPath, pDirData->fMode);
     276
     277    LogFlowFuncLeaveRC(rc);
     278    return rc;
     279}
     280
     281static int vboxClipboardURIReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDFILEHDR *ppFileHdr)
     282{
     283    LogFlowFuncEnter();
     284
     285    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     286    AssertPtr(pThisCtx);
     287
     288    VBOXCLIPBOARDFILEHDR fileHdr;
     289    SharedClipboardURIFileHdrInit(&fileHdr);
     290
     291    int rc = VbglR3ClipboardReadFileHdr(pThisCtx->u32ClientID, fileHdr.pszFilePath, fileHdr.cbFilePath,
     292                                        &fileHdr.fFlags, &fileHdr.fMode, &fileHdr.cbSize);
     293    if (RT_SUCCESS(rc))
     294    {
     295        *ppFileHdr = SharedClipboardURIFileHdrDup(&fileHdr);
     296    }
     297
     298    LogFlowFuncLeaveRC(rc);
     299    return rc;
     300}
     301
     302static int vboxClipboardURIWriteFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDFILEHDR pFileHdr)
     303{
     304    LogFlowFuncEnter();
     305
     306    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     307    AssertPtr(pThisCtx);
     308
     309    int rc = VbglR3ClipboardWriteFileHdr(pThisCtx->u32ClientID, pFileHdr->pszFilePath, pFileHdr->cbFilePath,
     310                                         pFileHdr->fFlags, pFileHdr->fMode, pFileHdr->cbSize);
     311    LogFlowFuncLeaveRC(rc);
     312    return rc;
     313}
     314
     315static int vboxClipboardURIReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags,
     316                                        uint32_t *pcbRead)
     317{
     318    RT_NOREF(fFlags);
     319
     320    AssertPtrReturn(pcbRead, VERR_INVALID_POINTER);
     321
     322    LogFlowFuncEnter();
     323
     324    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     325    AssertPtr(pThisCtx);
     326
     327    int rc = VbglR3ClipboardReadFileData(pThisCtx->u32ClientID, pvData, cbData, pcbRead);
     328
     329    LogFlowFuncLeaveRC(rc);
     330    return rc;
     331}
     332
     333static int vboxClipboardURIWriteFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags,
     334                                         uint32_t *pcbWritten)
     335{
     336    RT_NOREF(fFlags);
     337
     338    AssertPtrReturn(pcbWritten, VERR_INVALID_POINTER);
     339
     340    LogFlowFuncEnter();
     341
     342    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     343    AssertPtr(pThisCtx);
     344
     345    int rc = VbglR3ClipboardWriteFileData(pThisCtx->u32ClientID, pvData, cbData, pcbWritten);
     346
     347    LogFlowFuncLeaveRC(rc);
     348    return rc;
     349}
     350#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    88351
    89352static LRESULT vboxClipboardWinProcessMsg(PVBOXCLIPBOARDCONTEXT pCtx, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
    … …  
    99362       case WM_CLIPBOARDUPDATE:
    100363       {
    101             const HWND hWndClipboardOwner = GetClipboardOwner();
    102             if (pWinCtx->hWndClipboardOwnerUs != hWndClipboardOwner)
    103             {
    104                 LogFunc(("WM_CLIPBOARDUPDATE: hWndOldClipboardOwner=%p, hWndNewClipboardOwner=%p\n",
    105                          pWinCtx->hWndClipboardOwnerUs, hWndClipboardOwner));
    106 
    107                 /* Clipboard was updated by another application.
     364           const HWND hWndClipboardOwner = GetClipboardOwner();
     365           if (pWinCtx->hWndClipboardOwnerUs != hWndClipboardOwner)
     366           {
     367               LogFunc(("WM_CLIPBOARDUPDATE: hWndOldClipboardOwner=%p, hWndNewClipboardOwner=%p\n",
     368                        pWinCtx->hWndClipboardOwnerUs, hWndClipboardOwner));
     369
     370               /* Clipboard was updated by another application.
    108371                * Report available formats to the host. */
    109372               VBOXCLIPBOARDFORMATS fFormats;
    … …  
    114377                   rc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, fFormats);
    115378               }
    116             }
     379           }
    117380       }
    118381       break;
    … …  
    340603
    341604                            TransferCallbacks.pvUser              = &pCtx->URI;
    342                             TransferCallbacks.pfnTransferComplete = vboxClipboardOnURITransferComplete;
    343                             TransferCallbacks.pfnTransferError    = vboxClipboardOnURITransferError;
     605                            TransferCallbacks.pfnTransferComplete = vboxClipboardURITransferCompleteCallback;
     606                            TransferCallbacks.pfnTransferError    = vboxClipboardURITransferErrorCallback;
    344607
    345608                            SharedClipboardURITransferSetCallbacks(pTransfer, &TransferCallbacks);
    … …  
    347610                            SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    348611                            RT_ZERO(creationCtx);
    349                             creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3;
    350                             creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_READ;
     612                            creationCtx.enmSource = SHAREDCLIPBOARDSOURCE_REMOTE;
     613
     614                            RT_ZERO(creationCtx.Interface);
     615                            creationCtx.Interface.pfnReadDataHdr    = vboxClipboardURIReadDataHdr;
     616                            creationCtx.Interface.pfnReadDataChunk  = vboxClipboardURIReadDataChunk;
     617                            creationCtx.Interface.pfnReadDirectory  = vboxClipboardURIReadDir;
     618                            creationCtx.Interface.pfnReadFileHdr    = vboxClipboardURIReadFileHdr;
     619                            creationCtx.Interface.pfnReadFileData   = vboxClipboardURIReadFileData;
     620
     621                            creationCtx.pvUser = pCtx;
     622
    351623                            creationCtx.u.VbglR3.uClientID = pCtx->u32ClientID;
    352624
    … …  
    356628                                rc = SharedClipboardURICtxTransferAdd(&pCtx->URI, pTransfer);
    357629                                if (RT_SUCCESS(rc))
    358                                     rc = VBoxClipboardWinURIAnnounce(pWinCtx, &pCtx->URI, pTransfer);
     630                                    rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
    359631                            }
    360632
    361                             /* Note: VBoxClipboardWinURIAnnounce() takes care of closing the clipboard. */
     633                            /* Note: VBoxClipboardWinURITransferCreate() takes care of closing the clipboard. */
    362634
    363635                            LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST: rc=%Rrc\n", rc));
    … …  
    453725               {
    454726                   LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST cTransfers=%RU32\n",
    455                             SharedClipboardURICtxGetActiveTransfers(&pCtx->URI)));
     727                            SharedClipboardURICtxGetRunningTransfers(&pCtx->URI)));
    456728
    457729                    PSHAREDCLIPBOARDURITRANSFER pTransfer;
    … …  
    463735
    464736                        TransferCallbacks.pvUser              = &pCtx->URI;
    465                         TransferCallbacks.pfnTransferComplete = vboxClipboardOnURITransferComplete;
    466                         TransferCallbacks.pfnTransferError    = vboxClipboardOnURITransferError;
     737                        TransferCallbacks.pfnTransferComplete = vboxClipboardURITransferCompleteCallback;
     738                        TransferCallbacks.pfnTransferError    = vboxClipboardURITransferErrorCallback;
    467739
    468740                        SharedClipboardURITransferSetCallbacks(pTransfer, &TransferCallbacks);
    … …  
    470742                        SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    471743                        RT_ZERO(creationCtx);
    472                         creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3;
    473                         creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_WRITE;
     744                        creationCtx.enmSource          = SHAREDCLIPBOARDSOURCE_LOCAL;
    474745                        creationCtx.u.VbglR3.uClientID = pCtx->u32ClientID;
    475746
    … …  
    610881    return rc;
    611882}
    612 
    613 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    614 static DECLCALLBACK(void) vboxClipboardOnURITransferComplete(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
    615 {
    616     RT_NOREF(rc);
    617 
    618     LogFlowFunc(("pData=%p, rc=%Rrc\n", pData, rc));
    619 
    620     LogRel2(("Shared Clipboard: Transfer to destination complete\n"));
    621 
    622     PSHAREDCLIPBOARDURICTX pCtx = (PSHAREDCLIPBOARDURICTX)pData->pvUser;
    623     AssertPtr(pCtx);
    624 
    625     PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer;
    626     AssertPtr(pTransfer);
    627 
    628     if (pTransfer->pvUser) /* SharedClipboardWinURITransferCtx */
    629     {
    630         delete pTransfer->pvUser;
    631         pTransfer->pvUser = NULL;
    632     }
    633 
    634     int rc2 = SharedClipboardURICtxTransferRemove(pCtx, pTransfer);
    635     AssertRC(rc2);
    636 }
    637 
    638 static DECLCALLBACK(void) vboxClipboardOnURITransferError(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
    639 {
    640     RT_NOREF(rc);
    641 
    642     LogFlowFunc(("pData=%p, rc=%Rrc\n", pData, rc));
    643 
    644     LogRel(("Shared Clipboard: Transfer to destination failed with %Rrc\n", rc));
    645 
    646     PSHAREDCLIPBOARDURICTX pCtx = (PSHAREDCLIPBOARDURICTX)pData->pvUser;
    647     AssertPtr(pCtx);
    648 
    649     PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer;
    650     AssertPtr(pTransfer);
    651 
    652     if (pTransfer->pvUser) /* SharedClipboardWinURITransferCtx */
    653     {
    654         delete pTransfer->pvUser;
    655         pTransfer->pvUser = NULL;
    656     }
    657 
    658     int rc2 = SharedClipboardURICtxTransferRemove(pCtx, pTransfer);
    659     AssertRC(rc2);
    660 }
    661 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    662883
    663884static void vboxClipboardDestroy(PVBOXCLIPBOARDCONTEXT pCtx)

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

    r79174 r79347  
    115115}
    116116
    117 int SharedClipboardArea::AddFile(const char *pszFile)
    118 {
    119     AssertPtrReturn(pszFile, VERR_INVALID_POINTER);
    120 
    121     if (!this->m_lstFiles.contains(pszFile))
    122         this->m_lstFiles.append(pszFile);
     117int SharedClipboardArea::AddObject(const char *pszPath, const SHAREDCLIPBOARDAREAOBJ &Obj)
     118{
     119    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
     120
     121    AssertReturn(m_mapObj.find(pszPath) == m_mapObj.end(), VERR_ALREADY_EXISTS);
     122
     123    m_mapObj[pszPath] = Obj; /** @todo Throw? */
     124
    123125    return VINF_SUCCESS;
    124126}
    125127
    126 int SharedClipboardArea::AddDir(const char *pszDir)
    127 {
    128     AssertPtrReturn(pszDir, VERR_INVALID_POINTER);
    129 
    130     if (!this->m_lstDirs.contains(pszDir))
    131         this->m_lstDirs.append(pszDir);
    132     return VINF_SUCCESS;
     128int SharedClipboardArea::GetObject(const char *pszPath, PSHAREDCLIPBOARDAREAOBJ pObj)
     129{
     130    SharedClipboardAreaFsObjMap::const_iterator itObj = m_mapObj.find(pszPath);
     131    if (itObj != m_mapObj.end())
     132    {
     133        *pObj = itObj->second;
     134        return VINF_SUCCESS;
     135    }
     136
     137    return VERR_NOT_FOUND;
    133138}
    134139
    … …  
    306311        else
    307312        {
    308             this->m_lstDirs.clear();
    309             this->m_lstFiles.clear();
     313
    310314        }
    311315    }
    … …  
    330334    int rc = VINF_SUCCESS;
    331335
     336#if 0
    332337    /* Rollback by removing any stuff created.
    333338     * Note: Only remove empty directories, never ever delete
    … …  
    370375            rc = rc2;
    371376    }
     377#endif
    372378
    373379    LogFlowFuncLeaveRC(rc);

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

    r79299 r79347  
    123123        int rc2 = RTSemEventCreate(&m_EventMetaDataComplete);
    124124        AssertRC(rc2);
    125 
    126         AssertPtr(m_pTransfer->pProvider);
    127         m_pTransfer->pProvider->AddRef();
    128125    }
    129126
    … …  
    134131{
    135132    RTSemEventDestroy(m_EventMetaDataComplete);
    136 
    137     if (m_pTransfer->pProvider)
    138         m_pTransfer->pProvider->Release();
    139133
    140134    if (m_pStream)
    … …  
    406400                LogFlowFunc(("FormatIndex_FileDescriptor%s\n", fUnicode ? "W" : "A"));
    407401
    408                 /* Register needed callbacks so that we can wait for the meta data to arrive here. */
    409                 SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
    410                 RT_ZERO(Callbacks);
    411                 Callbacks.pfnMetaDataComplete = VBoxClipboardWinDataObject::onMetaDataCompleteCallback;
    412 
    413                 SharedClipboardURITransferSetCallbacks(m_pTransfer, &Callbacks);
    414 
    415402                /* Start the transfer asynchronously in a separate thread. */
    416403                rc = SharedClipboardURITransferRun(m_pTransfer, true /* fAsync */);
    … …  
    422409                    if (RT_SUCCESS(rc))
    423410                    {
    424                         const SharedClipboardURIList *pURIList = SharedClipboardURITransferGetList(m_pTransfer);
    425                         if (    pURIList
    426                             && !pURIList->IsEmpty())
     411                        HGLOBAL hGlobal;
     412                        rc = createFileGroupDescriptorFromTransfer(m_pTransfer, fUnicode, &hGlobal);
     413                        if (RT_SUCCESS(rc))
    427414                        {
    428                             HGLOBAL hGlobal;
    429                             rc = createFileGroupDescriptorFromTransfer(m_pTransfer, fUnicode, &hGlobal);
    430                             if (RT_SUCCESS(rc))
    431                             {
    432                                 pMedium->tymed   = TYMED_HGLOBAL;
    433                                 pMedium->hGlobal = hGlobal;
    434                                 /* Note: hGlobal now is being owned by pMedium / the caller. */
    435 
    436                                 hr = S_OK;
    437                             }
     415                            pMedium->tymed   = TYMED_HGLOBAL;
     416                            pMedium->hGlobal = hGlobal;
     417                            /* Note: hGlobal now is being owned by pMedium / the caller. */
     418
     419                            hr = S_OK;
    438420                        }
    439421                    }
    … …  
    603585    LogFlowFuncLeaveRC(VINF_SUCCESS);
    604586    return VINF_SUCCESS;
     587}
     588
     589DECLCALLBACK(void) VBoxClipboardWinDataObject::OnMetaDataComplete(PSHAREDCLIPBOARDURITRANSFER pTransfer)
     590{
     591    LogFlowFuncEnter();
     592
     593    AssertReturnVoid(pTransfer == m_pTransfer);
     594
     595    int rc2 = RTSemEventSignal(m_EventMetaDataComplete);
     596    AssertRC(rc2);
    605597}
    606598
    … …  
    744736}
    745737
    746 /* static */
    747 DECLCALLBACK(void) VBoxClipboardWinDataObject::onMetaDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
    748 {
    749     VBoxClipboardWinDataObject *pThis = (VBoxClipboardWinDataObject *)pData->pvUser;
    750 
    751     LogFlowFunc(("pThis=%p\n", pThis));
    752 
    753     int rc2 = RTSemEventSignal(pThis->m_EventMetaDataComplete);
    754     AssertRC(rc2);
    755 }
    756 

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

    r79267 r79347  
    3737    AssertPtrReturn(pMeta, VERR_INVALID_POINTER);
    3838
    39     pMeta->enmFmt = enmFmt;
    40     pMeta->pvMeta = NULL;
    41     pMeta->cbMeta = 0;
    42     pMeta->cbUsed = 0;
     39    pMeta->enmFmt    = enmFmt;
     40    pMeta->pvMeta    = NULL;
     41    pMeta->cbMeta    = 0;
     42    pMeta->cbUsed    = 0;
     43    pMeta->cbOffRead = 0;
    4344
    4445    return VINF_SUCCESS;
    … …  
    4647
    4748/**
    48  * Destroys a clipboard meta data struct by free'ing all its data.
     49 * Destroys a clipboard meta data struct by free'ing all its data, internal version.
    4950 *
    5051 * @param   pMeta               Meta data struct to destroy.
    5152 */
    52 void SharedClipboardMetaDataDestroy(PSHAREDCLIPBOARDMETADATA pMeta)
     53static void sharedClipboardMetaDataDestroyInternal(PSHAREDCLIPBOARDMETADATA pMeta)
    5354{
    5455    if (!pMeta)
    … …  
    6667
    6768    pMeta->cbUsed = 0;
     69}
     70
     71/**
     72 * Destroys a clipboard meta data struct by free'ing all its data.
     73 *
     74 * @param   pMeta               Meta data struct to destroy.
     75 */
     76void SharedClipboardMetaDataDestroy(PSHAREDCLIPBOARDMETADATA pMeta)
     77{
     78    sharedClipboardMetaDataDestroyInternal(pMeta);
     79}
     80
     81/**
     82 * Frees a clipboard meta data struct.
     83 *
     84 * @param   pMeta               Meta data struct to free.
     85 */
     86void SharedClipboardMetaDataFree(PSHAREDCLIPBOARDMETADATA pMeta)
     87{
     88    if (pMeta)
     89    {
     90        sharedClipboardMetaDataDestroyInternal(pMeta);
     91
     92        RTMemFree(pMeta);
     93        pMeta = NULL;
     94    }
    6895}
    6996
    … …  
    158185
    159186/**
     187 * Reads meta data.
     188 *
     189 * @returns VBox status code.
     190 * @param   pMeta               Meta data struct to read from.
     191 * @param   pvBuf               Buffer where to store the read data.
     192 * @param   cbBuf               Size of buffer (in bytes) where to store the data.
     193 * @param   pcbRead             Where to return the read amount in bytes. Optional.
     194 */
     195int SharedClipboardMetaDataRead(PSHAREDCLIPBOARDMETADATA pMeta, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
     196{
     197    AssertPtrReturn(pMeta, VERR_INVALID_POINTER);
     198    AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
     199    AssertPtrReturn(cbBuf, VERR_INVALID_PARAMETER);
     200    /* pcRead is optional. */
     201
     202    int rc = VINF_SUCCESS;
     203
     204    uint32_t cbRead   = 0;
     205    uint32_t cbToRead = pMeta->cbUsed - pMeta->cbOffRead;
     206
     207    if (cbBuf > cbToRead)
     208        cbBuf = cbToRead;
     209
     210    if (cbToRead)
     211    {
     212        memcpy(pvBuf, (uint8_t *)pMeta->pvMeta + pMeta->cbOffRead, cbToRead);
     213
     214        Assert(pMeta->cbUsed >= cbToRead);
     215        pMeta->cbUsed -= cbToRead;
     216
     217        pMeta->cbOffRead += cbToRead;
     218        Assert(pMeta->cbOffRead <= pMeta->cbMeta);
     219    }
     220
     221    if (pcbRead)
     222        *pcbRead = cbRead;
     223
     224    LogFlowFuncLeaveRC(rc);
     225    return rc;
     226}
     227
     228/**
    160229 * Resizes the data buffer of a meta data struct.
    161230 * Note: At the moment only supports growing the data buffer.

  • trunk/src/VBox/GuestHost/SharedClipboard/ClipboardProvider-HostService.cpp

    r79299 r79347  
    5555    LogFlowFuncEnter();
    5656
    57     /*return vboxSvcClipboardReportMsg(,
    58                                      VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, );*/
    59     return 0;
     57    return VINF_SUCCESS;
    6058}
    6159
    … …  
    6664    LogFlowFuncEnter();
    6765
    68     /*return eventWait(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR, m_Callbacks.pfnReadDataHdr, m_uTimeoutMs,
    69                      (void **)ppDataHdr);*/
    70     return 0;
     66    return VERR_NOT_IMPLEMENTED;
    7167}
    7268
    … …  
    8480{
    8581    RT_NOREF(pDataHdr, pvChunk, cbChunk, fFlags, pcbRead);
    86 
    87     /*return eventWait(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_CHUNK, m_Callbacks.pfnReadDataChunk, m_uTimeoutMs,
    88                      (void **)ppDataChunk);*/
    89     return 0;
     82    return VERR_NOT_IMPLEMENTED;
    9083}
    9184
    … …  
    9992int SharedClipboardProviderHostService::ReadDirectory(PVBOXCLIPBOARDDIRDATA *ppDirData)
    10093{
    101     //return eventWait(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR, NULL, m_uTimeoutMs, (void **)ppDirData);
    10294    RT_NOREF(ppDirData);
    103     return 0;
     95    return VERR_NOT_IMPLEMENTED;
    10496}
    10597
    … …  
    119111{
    120112    RT_NOREF(ppFileHdr);
    121     //return eventWait(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR, NULL, m_uTimeoutMs, (void **)ppFileHdr);
    122     return 0;
     113    return VERR_NOT_IMPLEMENTED;
    123114}
    124115
    … …  
    139130{
    140131    RT_NOREF(pvData, cbData, fFlags, pcbRead);
    141     //return eventWait(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_DATA, NULL, m_uTimeoutMs, (void **)ppFileData);
    142     return 0;
     132    return VERR_NOT_IMPLEMENTED;
    143133}
    144134

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

    r79267 r79347  
    5454{
    5555    AssertPtr(m_pURITransfer);
    56     AssertPtr(m_pURITransfer->pProvider);
    5756
    5857    LogFunc(("m_uObjIdx=%RU64\n", uObjIdx));
    59 
    60     m_pURITransfer->pProvider->AddRef();
    6158}
    6259
    … …  
    6461{
    6562    LogFlowThisFuncEnter();
    66 
    67     if (   m_pURITransfer
    68         && m_pURITransfer->pProvider)
    69         m_pURITransfer->pProvider->Release();
    7063}
    7164
    … …  
    188181    if (cbToRead)
    189182    {
    190         rc = m_pURITransfer->pProvider->ReadFileData(pvBuffer, cbToRead, 0 /* fFlags */, &cbRead);
     183        rc = m_pURITransfer->ProviderIface.pfnReadFileData(&m_pURITransfer->ProviderCtx,
     184                                                           pvBuffer, cbToRead, 0 /* fFlags */, &cbRead);
    191185        if (RT_SUCCESS(rc))
    192186        {

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

    r79299 r79347  
    430430
    431431/**
     432 * Frees a VBOXCLIPBOARDFILEHDR structure.
     433 *
     434 * @param   pFileHdr            VBOXCLIPBOARDFILEHDR structure to free.
     435 */
     436void SharedClipboardURIFileHdrFree(PVBOXCLIPBOARDFILEHDR pFileHdr)
     437{
     438    if (!pFileHdr)
     439        return;
     440
     441    SharedClipboardURIFileHdrDestroy(pFileHdr);
     442
     443    RTMemFree(pFileHdr);
     444    pFileHdr = NULL;
     445}
     446
     447/**
    432448 * Duplicates (allocates) a VBOXCLIPBOARDFILEHDR structure.
    433449 *
    … …  
    608624 *
    609625 * @returns VBox status code.
    610  * @param   enmDir              Transfer direction.
     626 * @param   enmDir              Specifies the transfer direction of this transfer.
     627 * @param   enmSource           Specifies the data source of the transfer.
    611628 * @param   ppTransfer          Where to return the created URI transfer struct.
    612629 *                              Must be destroyed by SharedClipboardURITransferDestroy().
    613630 */
    614 int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, PSHAREDCLIPBOARDURITRANSFER *ppTransfer)
     631int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource,
     632                                     PSHAREDCLIPBOARDURITRANSFER *ppTransfer)
    615633{
    616634    AssertPtrReturn(ppTransfer, VERR_INVALID_POINTER);
    … …  
    624642    int rc = VINF_SUCCESS;
    625643
    626     pTransfer->State.enmDir = enmDir;
     644    pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_NONE;
     645    pTransfer->State.enmDir    = enmDir;
     646    pTransfer->State.enmSource = enmSource;
     647
     648    LogFlowFunc(("enmDir=%RU32, enmSource=%RU32\n", pTransfer->State.enmDir, pTransfer->State.enmSource));
    627649
    628650    pTransfer->State.pHeader = NULL;
    … …  
    646668    }
    647669
    648     rc = SharedClipboardURIObjCtxInit(&pTransfer->ObjCtx);
     670    rc = SharedClipboardURIObjCtxInit(&pTransfer->State.ObjCtx);
    649671    if (RT_SUCCESS(rc))
    650672    {
    … …  
    682704    }
    683705
    684     if (pTransfer->pProvider)
    685     {
    686         delete pTransfer->pProvider;
    687         pTransfer->pProvider = NULL;
    688     }
    689 
    690     SharedClipboardURIObjCtxDestroy(&pTransfer->ObjCtx);
     706    SharedClipboardURIObjCtxDestroy(&pTransfer->State.ObjCtx);
    691707
    692708    RTMemFree(pTransfer);
    … …  
    710726    LogFlowFuncEnter();
    711727
    712     int rc;
    713 
    714     LogFlowFunc(("enmDir=%RU32\n", pTransfer->State.enmDir));
     728    int rc = VINF_SUCCESS;
     729
     730    LogFlowFunc(("pTransfer=%p, enmDir=%RU32\n", pTransfer, pTransfer->State.enmDir));
    715731
    716732    if (pTransfer->Callbacks.pfnTransferPrepare)
    … …  
    722738    if (pTransfer->State.enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ)
    723739    {
    724         rc = pTransfer->pProvider->Prepare();
     740        if (pTransfer->ProviderIface.pfnPrepare)
     741            rc = pTransfer->ProviderIface.pfnPrepare(&pTransfer->ProviderCtx);
    725742    #if 0
    726743        rc = pTransfer->pURIList->SetFromURIData(SharedClipboardMetaDataRaw(pMeta),
    … …  
    734751    else if (pTransfer->State.enmDir == SHAREDCLIPBOARDURITRANSFERDIR_WRITE)
    735752    {
    736         AssertPtrReturn(pTransfer->State.pMeta, VERR_WRONG_ORDER);
    737         AssertPtrReturn(pTransfer->pURIList,    VERR_WRONG_ORDER);
    738 
    739         const PSHAREDCLIPBOARDMETADATA pMeta = pTransfer->State.pMeta;
    740 
    741         rc = pTransfer->pURIList->AppendURIPathsFromList((char *)SharedClipboardMetaDataRaw(pMeta),
    742                                                          SharedClipboardMetaDataGetUsed(pMeta),
    743                                                          SHAREDCLIPBOARDURILIST_FLAGS_KEEP_OPEN);
    744         if (RT_SUCCESS(rc))
    745         {
    746             PVBOXCLIPBOARDDATAHDR pHeader;
    747             rc = SharedClipboardURIDataHdrAlloc(&pHeader);
     753        if (   pTransfer->State.pMeta
     754            && pTransfer->pURIList)
     755        {
     756            const PSHAREDCLIPBOARDMETADATA pMeta = pTransfer->State.pMeta;
     757
     758            rc = pTransfer->pURIList->AppendURIPathsFromList((char *)SharedClipboardMetaDataRaw(pMeta),
     759                                                             SharedClipboardMetaDataGetUsed(pMeta),
     760                                                             SHAREDCLIPBOARDURILIST_FLAGS_KEEP_OPEN);
    748761            if (RT_SUCCESS(rc))
    749762            {
    750                 /* The total size also contains the size of the meta data. */
    751                 uint64_t cbTotal  = pMeta->cbUsed;
    752                          cbTotal += pTransfer->pURIList->GetTotalBytes();
    753 
    754                 pHeader->cbTotal  = cbTotal;
    755                 pHeader->cbMeta   = (uint32_t)SharedClipboardMetaDataGetUsed(pMeta);
    756                 pHeader->cObjects = pTransfer->pURIList->GetTotalCount();
    757 
    758                 SharedClipboardURIDataHdrDestroy(pTransfer->State.pHeader);
    759 
     763                PVBOXCLIPBOARDDATAHDR pHeader;
     764                rc = SharedClipboardURIDataHdrAlloc(&pHeader);
    760765                if (RT_SUCCESS(rc))
    761766                {
    762                     LogFlowFunc(("Writing cbTotal=%RU64, cbMeta=%RU32, cObj=%RU64\n",
    763                                  pHeader->cbTotal, pHeader->cbMeta, pHeader->cObjects));
    764 
    765                     pTransfer->State.pHeader = pHeader;
     767                    /* The total size also contains the size of the meta data. */
     768                    uint64_t cbTotal  = pMeta->cbUsed;
     769                             cbTotal += pTransfer->pURIList->GetTotalBytes();
     770
     771                    pHeader->cbTotal  = cbTotal;
     772                    pHeader->cbMeta   = (uint32_t)SharedClipboardMetaDataGetUsed(pMeta);
     773                    pHeader->cObjects = pTransfer->pURIList->GetTotalCount();
     774
     775                    SharedClipboardURIDataHdrDestroy(pTransfer->State.pHeader);
     776
     777                    if (RT_SUCCESS(rc))
     778                    {
     779                        LogFlowFunc(("Writing cbTotal=%RU64, cbMeta=%RU32, cObj=%RU64\n",
     780                                     pHeader->cbTotal, pHeader->cbMeta, pHeader->cObjects));
     781
     782                        pTransfer->State.pHeader = pHeader;
     783                    }
     784                    else
     785                        SharedClipboardURIDataHdrFree(pHeader);
    766786                }
    767                 else
    768                     SharedClipboardURIDataHdrFree(pHeader);
    769787            }
    770788        }
     789        else
     790            rc = VERR_WRONG_ORDER;
    771791    }
    772792    else
    … …  
    790810 * @returns VBox status code.
    791811 * @param   pTransfer           Transfer to create URI provider for.
    792  * @param   pProviderCtx        Provider creation context to use for provider creation.
     812 * @param   pCreationCtx        Provider creation context to use for provider creation.
    793813 */
    794814int SharedClipboardURITransferProviderCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer,
    795                                              PSHAREDCLIPBOARDPROVIDERCREATIONCTX pProviderCtx)
     815                                             PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx)
    796816{
    797817    AssertPtrReturn(pTransfer,    VERR_INVALID_POINTER);
    798     AssertPtrReturn(pProviderCtx, VERR_INVALID_POINTER);
    799 
    800     LogFlowFuncEnter();
    801 
    802     int rc;
    803 
    804     pTransfer->pProvider = SharedClipboardProvider::Create(pProviderCtx);
    805     if (pTransfer->pProvider)
    806     {
    807         rc = VINF_SUCCESS;
    808     }
    809     else
    810         rc = VERR_NO_MEMORY;
     818    AssertPtrReturn(pCreationCtx, VERR_INVALID_POINTER);
     819
     820    LogFlowFuncEnter();
     821
     822    int rc = VINF_SUCCESS;
     823
     824    pTransfer->ProviderIface         = pCreationCtx->Interface;
     825
     826    pTransfer->ProviderCtx.pTransfer = pTransfer;
     827    pTransfer->ProviderCtx.pvUser    = pCreationCtx->pvUser;
    811828
    812829    LogFlowFuncLeaveRC(rc);
    … …  
    826843
    827844    /** @todo Anything else to do here? */
    828 
    829     if (pTransfer->pProvider)
    830         pTransfer->pProvider->Reset();
    831845
    832846    if (pTransfer->pURIList)
    833847        pTransfer->pURIList->Clear();
    834848
    835     SharedClipboardURIObjCtxDestroy(&pTransfer->ObjCtx);
     849    SharedClipboardURIObjCtxDestroy(&pTransfer->State.ObjCtx);
    836850}
    837851
    … …  
    858872{
    859873    /* At the moment we only have one object context per transfer at a time. */
    860     return &pTransfer->ObjCtx;
     874    return &pTransfer->State.ObjCtx;
    861875}
    862876
    … …  
    878892
    879893/**
    880  * Returns the provider for a clipboard URI transfer.
    881  *
    882  * @returns Current provider, or NULL if none.
    883  * @param   pTransfer           URI clipboard transfer to return provider for.
    884  */
    885 SharedClipboardProvider *SharedClipboardURITransferGetProvider(PSHAREDCLIPBOARDURITRANSFER pTransfer)
    886 {
    887     AssertPtrReturn(pTransfer, NULL);
    888 
    889     return pTransfer->pProvider;
    890 }
    891 
    892 /**
    893894 * Returns the URI list for a clipboard URI transfer.
    894895 *
    … …  
    917918
    918919    return pTransfer->pURIList->At(uIdx);
     920}
     921
     922SHAREDCLIPBOARDSOURCE SharedClipboardURITransferGetSource(PSHAREDCLIPBOARDURITRANSFER pTransfer)
     923{
     924    AssertPtrReturn(pTransfer, SHAREDCLIPBOARDSOURCE_INVALID);
     925
     926    return pTransfer->State.enmSource;
     927}
     928
     929/**
     930 * Returns the current transfer status.
     931 *
     932 * @returns Current transfer status.
     933 * @param   pTransfer           URI clipboard transfer to return status for.
     934 */
     935SHAREDCLIPBOARDURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHAREDCLIPBOARDURITRANSFER pTransfer)
     936{
     937    AssertPtrReturn(pTransfer, SHAREDCLIPBOARDURITRANSFERSTATUS_NONE);
     938
     939    return pTransfer->State.enmStatus;
    919940}
    920941
    … …  
    973994    SET_CALLBACK(pfnTransferPrepare);
    974995    SET_CALLBACK(pfnTransferStarted);
    975     SET_CALLBACK(pfnMetaDataComplete);
     996    SET_CALLBACK(pfnDataHeaderComplete);
     997    SET_CALLBACK(pfnDataComplete);
    976998    SET_CALLBACK(pfnTransferCanceled);
    977999    SET_CALLBACK(pfnTransferError);
    … …  
    9791001
    9801002#undef SET_CALLBACK
     1003
     1004    pTransfer->Callbacks.pvUser = pCallbacks->pvUser;
     1005}
     1006
     1007int SharedClipboardURITransferSetDataHeader(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDDATAHDR pDataHdr)
     1008{
     1009    AssertReturn(pTransfer->State.pHeader == NULL, VERR_WRONG_ORDER);
     1010
     1011    LogFlowFuncEnter();
     1012
     1013    int rc;
     1014
     1015    pTransfer->State.pHeader = SharedClipboardURIDataHdrDup(pDataHdr);
     1016    if (pTransfer->State.pHeader)
     1017    {
     1018        LogFlowFunc(("Meta data size is %RU32, total size is %RU64, %RU64 objects\n",
     1019                     pTransfer->State.pHeader->cbMeta, pTransfer->State.pHeader->cbTotal,
     1020                     pTransfer->State.pHeader->cObjects));
     1021
     1022        rc = VINF_SUCCESS;
     1023
     1024        if (pTransfer->Callbacks.pfnDataHeaderComplete)
     1025        {
     1026            SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
     1027            pTransfer->Callbacks.pfnDataHeaderComplete(&callbackData);
     1028        }
     1029    }
     1030    else
     1031        rc = VERR_NO_MEMORY;
     1032
     1033    LogFlowFuncLeaveRC(rc);
     1034    return rc;
     1035}
     1036
     1037int SharedClipboardURITransferSetDataChunk(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDDATACHUNK pDataChunk)
     1038{
     1039    LogFlowFuncEnter();
     1040
     1041    AssertPtrReturn(pTransfer->State.pHeader, VERR_WRONG_ORDER);
     1042
     1043    int rc = SharedClipboardURITransferMetaDataAdd(pTransfer, pDataChunk->pvData, pDataChunk->cbData);
     1044
     1045    LogFlowFuncLeaveRC(rc);
     1046    return rc;
    9811047}
    9821048
    … …  
    10511117    LogFlowFuncEnter();
    10521118
     1119    AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING,
     1120                    ("Transfer already is running\n"), VERR_WRONG_ORDER);
     1121
     1122    pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING;
     1123
    10531124    if (pTransfer->Callbacks.pfnTransferStarted)
    10541125    {
    … …  
    10801151    }
    10811152
     1153    pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_NONE;
     1154
     1155    LogFlowFuncLeaveRC(rc);
     1156    return rc;
     1157}
     1158
     1159int SharedClipboardURITransferReadDir(PSHAREDCLIPBOARDURITRANSFER pTransfer, PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx)
     1160{
     1161    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     1162
     1163    RT_NOREF(pObjCtx);
     1164
     1165    LogFlowFuncEnter();
     1166
     1167    PVBOXCLIPBOARDDIRDATA pDirData;
     1168    int rc = pTransfer->ProviderIface.pfnReadDirectory(&pTransfer->ProviderCtx, &pDirData);
     1169    if (RT_SUCCESS(rc))
     1170    {
     1171        SharedClipboardURIDirDataFree(pDirData);
     1172    }
     1173
     1174    LogFlowFuncLeaveRC(rc);
     1175    return rc;
     1176}
     1177
     1178int SharedClipboardURITransferReadFile(PSHAREDCLIPBOARDURITRANSFER pTransfer, PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx)
     1179{
     1180    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     1181
     1182    RT_NOREF(pObjCtx);
     1183
     1184    LogFlowFuncEnter();
     1185
     1186    PVBOXCLIPBOARDFILEHDR pFileHdr;
     1187    int rc = pTransfer->ProviderIface.pfnReadFileHdr(&pTransfer->ProviderCtx, &pFileHdr);
     1188    if (RT_SUCCESS(rc))
     1189    {
     1190        uint64_t cbToRead = pFileHdr->cbSize;
     1191        uint32_t cbRead;
     1192
     1193        uint8_t  pvBuf[_64K]; /** @todo Improve. */
     1194        uint32_t cbBuf = _64K;
     1195
     1196        while (cbToRead)
     1197        {
     1198            rc = pTransfer->ProviderIface.pfnReadFileData(&pTransfer->ProviderCtx,
     1199                                                          pvBuf, cbBuf, 0 /* fFlags */, &cbRead);
     1200            if (RT_FAILURE(rc))
     1201                break;
     1202
     1203            /** @todo Validate data block checksum. */
     1204
     1205            Assert(cbToRead >= cbRead);
     1206            cbToRead -= cbRead;
     1207        }
     1208
     1209        SharedClipboardURIFileHdrFree(pFileHdr);
     1210    }
     1211
     1212    LogFlowFuncLeaveRC(rc);
     1213    return rc;
     1214}
     1215
     1216int SharedClipboardURITransferReadObject(PSHAREDCLIPBOARDURITRANSFER pTransfer, PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx)
     1217{
     1218    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     1219
     1220    RT_NOREF(pObjCtx);
     1221
     1222    LogFlowFuncEnter();
     1223
     1224    PVBOXCLIPBOARDOBJHDR pObjHdr;
     1225    int rc = pTransfer->ProviderIface.pfnReadObjHdr(&pTransfer->ProviderCtx, &pObjHdr);
     1226    if (RT_SUCCESS(rc))
     1227    {
     1228        switch (pObjHdr->enmType)
     1229        {
     1230#if 0
     1231            case Dir:
     1232            {
     1233                SHAREDCLIPBOARDCLIENTURIOBJCTX objCtx;
     1234                rc = SharedClipboardURITransferReadDir(pTransfer, &objCtx);
     1235                break;
     1236            }
     1237
     1238            case File:
     1239            {
     1240                SHAREDCLIPBOARDCLIENTURIOBJCTX objCtx;
     1241                rc = SharedClipboardURITransferReadFile(pTransfer, &objCtx);
     1242                break;
     1243            }
     1244#endif
     1245            default:
     1246                /** @todo Skip -- how? */
     1247                break;
     1248        }
     1249    }
     1250
    10821251    LogFlowFuncLeaveRC(rc);
    10831252    return rc;
    … …  
    10961265    LogFlowFuncEnter();
    10971266
    1098     int rc = VERR_NOT_IMPLEMENTED;
     1267    const PVBOXCLIPBOARDDATAHDR pHdr = pTransfer->State.pHeader;
     1268    AssertPtrReturn(pHdr, VERR_WRONG_ORDER);
     1269
     1270    int rc = VINF_SUCCESS;
     1271
     1272    for (uint64_t i = 0; i < pHdr->cObjects; i++)
     1273    {
     1274        SHAREDCLIPBOARDCLIENTURIOBJCTX objCtx;
     1275        rc = SharedClipboardURITransferReadObject(pTransfer, &objCtx);
     1276        if (RT_FAILURE(rc))
     1277            break;
     1278    }
    10991279
    11001280    LogFlowFuncLeaveRC(rc);
    … …  
    11181298    /* At the moment we only support one transfer at a time. */
    11191299    PSHAREDCLIPBOARDURITRANSFER pTransfer = (PSHAREDCLIPBOARDURITRANSFER)pvUser;
    1120     AssertPtr(pTransfer->pProvider);
     1300    AssertPtr(pTransfer);
    11211301
    11221302    int rc = VINF_SUCCESS;
    … …  
    12661446    uint32_t cbReadTotal = 0;
    12671447
    1268     int rc = pTransfer->pProvider->ReadDataHdr(&pTransfer->State.pHeader);
     1448    int rc = pTransfer->ProviderIface.pfnReadDataHdr(&pTransfer->ProviderCtx, &pTransfer->State.pHeader);
    12691449    if (RT_SUCCESS(rc))
    12701450    {
    … …  
    12791459            {
    12801460                uint32_t cbMetaRead;
    1281                 rc = pTransfer->pProvider->ReadDataChunk(pTransfer->State.pHeader, pvMeta, cbMeta, 0 /* fFlags */, &cbMetaRead);
     1461                rc = pTransfer->ProviderIface.pfnReadDataChunk(&pTransfer->ProviderCtx,
     1462                                                               pTransfer->State.pHeader, pvMeta, cbMeta, 0 /* fFlags */,
     1463                                                               &cbMetaRead);
    12821464                if (RT_SUCCESS(rc))
    12831465                    rc = sharedClipboardURITransferMetaDataAddInternal(pTransfer, pvMeta, cbMeta);
    … …  
    12981480                if (pcbRead)
    12991481                    *pcbRead = cbReadTotal;
    1300 
    1301                 if (pTransfer->Callbacks.pfnMetaDataComplete)
    1302                 {
    1303                     SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
    1304                     pTransfer->Callbacks.pfnMetaDataComplete(&callbackData);
    1305                 }
    13061482            }
    13071483        }
    … …  
    13261502    /* pcbWritten is optional. */
    13271503
    1328     AssertPtr(pTransfer->pProvider);
    1329 
    13301504    LogFlowFuncEnter();
    13311505
    … …  
    13351509    uint32_t cbWrittenTotal = 0;
    13361510
    1337     int rc = pTransfer->pProvider->WriteDataHdr(pTransfer->State.pHeader);
     1511    int rc = pTransfer->ProviderIface.pfnWriteDataHdr(&pTransfer->ProviderCtx, pTransfer->State.pHeader);
    13381512    if (RT_SUCCESS(rc))
    13391513    {
    … …  
    13451519        {
    13461520            uint32_t cbMetaWritten;
    1347             rc = pTransfer->pProvider->WriteDataChunk(pTransfer->State.pHeader, (uint8_t *)pTransfer->State.pMeta->pvMeta + cbWrittenTotal,
    1348                                                       cbMetaToWrite, 0 /* fFlags */, &cbMetaWritten);
     1521            rc = pTransfer->ProviderIface.pfnWriteDataChunk(&pTransfer->ProviderCtx, pTransfer->State.pHeader,
     1522                                                            (uint8_t *)pTransfer->State.pMeta->pvMeta + cbWrittenTotal,
     1523                                                            cbMetaToWrite, 0 /* fFlags */, &cbMetaWritten);
    13491524            if (RT_FAILURE(rc))
    13501525                break;
    … …  
    13621537                *pcbWritten = cbWrittenTotal;
    13631538
    1364             if (pTransfer->Callbacks.pfnMetaDataComplete)
     1539            if (pTransfer->Callbacks.pfnDataComplete)
    13651540            {
    13661541                SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
    1367                 pTransfer->Callbacks.pfnMetaDataComplete(&callbackData);
     1542                pTransfer->Callbacks.pfnDataComplete(&callbackData);
    13681543            }
    13691544        }
    … …  
    13881563    int rc = VINF_SUCCESS;
    13891564
    1390     AssertPtrReturn(pTransfer->pURIList,  VERR_WRONG_ORDER);
    1391     AssertPtrReturn(pTransfer->pProvider, VERR_WRONG_ORDER);
     1565    AssertPtrReturn(pTransfer->pURIList, VERR_WRONG_ORDER);
    13921566
    13931567    while (!pTransfer->pURIList->IsEmpty())
    … …  
    14101584                dirData.cbPath  = (uint32_t)strlen(dirData.pszPath);
    14111585
    1412                 rc = pTransfer->pProvider->WriteDirectory(&dirData);
     1586                rc = pTransfer->ProviderIface.pfnWriteDirectory(&pTransfer->ProviderCtx, &dirData);
    14131587
    14141588                SharedClipboardURIDirDataDestroy(&dirData);
    … …  
    14341608                fileHdr.fMode       = pObj->GetMode();
    14351609
    1436                 rc = pTransfer->pProvider->WriteFileHdr(&fileHdr);
     1610                rc = pTransfer->ProviderIface.pfnWriteFileHdr(&pTransfer->ProviderCtx, &fileHdr);
    14371611                SharedClipboardURIFileHdrDestroy(&fileHdr);
    14381612
    … …  
    14521626                    {
    14531627                        uint32_t cbToRead = cbRead;
    1454                         rc = pTransfer->pProvider->WriteFileData(pvData, cbToRead, 0 /* fFlags */, &cbRead);
     1628                        rc = pTransfer->ProviderIface.pfnWriteFileData(&pTransfer->ProviderCtx,
     1629                                                                       pvData, cbToRead, 0 /* fFlags */, &cbRead);
    14551630                    }
    14561631
    … …  
    14961671    /* At the moment we only support one transfer at a time. */
    14971672    PSHAREDCLIPBOARDURITRANSFER pTransfer = (PSHAREDCLIPBOARDURITRANSFER)pvUser;
    1498     AssertPtr(pTransfer->pProvider);
    14991673
    15001674    int rc = VINF_SUCCESS;
    … …  
    15301704
    15311705    LogFlowFuncEnter();
     1706
     1707    AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING,
     1708                    ("Transfer already is running\n"), VERR_WRONG_ORDER);
     1709
     1710    pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING;
    15321711
    15331712    if (pTransfer->Callbacks.pfnTransferStarted)
    … …  
    15601739    }
    15611740
     1741    pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_NONE;
     1742
    15621743    LogFlowFuncLeaveRC(rc);
    15631744    return rc;
    … …  
    15811762        RTListInit(&pURI->List);
    15821763
    1583         pURI->cTransfers    = 0;
    1584         pURI->cMaxTransfers = 1; /* For now we only support one transfer per client at a time. */
     1764        pURI->cRunning    = 0;
     1765        pURI->cMaxRunning = 1; /* For now we only support one transfer per client at a time. */
    15851766
    15861767#ifdef DEBUG_andy
    1587         pURI->cMaxTransfers = UINT32_MAX;
     1768        pURI->cMaxRunning = UINT32_MAX;
    15881769#endif
    1589 
    15901770        SharedClipboardURICtxReset(pURI);
    15911771    }
    … …  
    16021782{
    16031783    AssertPtrReturnVoid(pURI);
     1784
     1785    LogFlowFuncEnter();
    16041786
    16051787    RTCritSectDelete(&pURI->CritSect);
    … …  
    16121794    }
    16131795
    1614     LogFlowFuncEnter();
     1796    pURI->cRunning  = 0;
     1797#ifdef DEBUG
     1798    pURI->cTransfer = 0;
     1799#endif
    16151800}
    16161801
    … …  
    16451830    LogFlowFuncEnter();
    16461831
    1647     if (pURI->cTransfers == pURI->cMaxTransfers)
     1832    if (pURI->cRunning == pURI->cMaxRunning)
    16481833        return VERR_SHCLPB_MAX_TRANSFERS_REACHED;
    16491834
    16501835    RTListAppend(&pURI->List, &pTransfer->Node);
    1651     pURI->cTransfers++;
     1836
     1837#ifdef DEBUG
     1838    pURI->cTransfer++;
     1839    LogFlowFunc(("cTransfers=%RU32, cRunning=%RU32\n", pURI->cTransfer, pURI->cRunning));
     1840#endif
    16521841
    16531842    return VINF_SUCCESS;
    … …  
    16681857    LogFlowFuncEnter();
    16691858
    1670     /* Sanity. */
    1671     AssertReturn(pURI->cTransfers, VERR_WRONG_ORDER);
    16721859
    16731860    int rc = SharedClipboardURITransferDestroy(pTransfer);
    16741861    if (RT_SUCCESS(rc))
    16751862    {
    1676 
    16771863        RTListNodeRemove(&pTransfer->Node);
    1678         Assert(pURI->cTransfers);
    1679         pURI->cTransfers--;
    16801864    }
    16811865
    … …  
    17101894
    17111895/**
    1712  * Returns the number of active URI transfers.
     1896 * Returns the number of running URI transfers.
    17131897 *
    17141898 * @returns VBox status code.
    17151899 * @param   pURI                URI clipboard context to return number for.
    17161900 */
    1717 uint32_t SharedClipboardURICtxGetActiveTransfers(PSHAREDCLIPBOARDURICTX pURI)
     1901uint32_t SharedClipboardURICtxGetRunningTransfers(PSHAREDCLIPBOARDURICTX pURI)
    17181902{
    17191903    AssertPtrReturn(pURI, 0);
    1720     return pURI->cTransfers;
     1904    return pURI->cRunning;
     1905}
     1906
     1907/**
     1908 * Cleans up all associated transfers which are not needed (anymore).
     1909 * This can be due to transfers which only have been announced but not / never being run.
     1910 *
     1911 * @param   pURI                URI clipboard context to cleanup transfers for.
     1912 */
     1913void SharedClipboardURICtxTransfersCleanup(PSHAREDCLIPBOARDURICTX pURI)
     1914{
     1915    AssertPtrReturnVoid(pURI);
     1916
     1917    LogFlowFunc(("cRunning=%RU32\n", pURI->cRunning));
     1918
     1919    /* Remove all transfers which are not in a running state (e.g. only announced). */
     1920    PSHAREDCLIPBOARDURITRANSFER pTransfer, pTransferNext;
     1921    RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHAREDCLIPBOARDURITRANSFER, Node)
     1922    {
     1923        if (SharedClipboardURITransferGetStatus(pTransfer) != SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING)
     1924        {
     1925            SharedClipboardURITransferDestroy(pTransfer);
     1926            RTListNodeRemove(&pTransfer->Node);
     1927
     1928#ifdef DEBUG
     1929            Assert(pURI->cTransfer);
     1930            pURI->cTransfer--;
     1931
     1932            LogFlowFunc(("cTransfers=%RU32\n", pURI->cTransfer));
     1933#endif
     1934        }
     1935    }
    17211936}
    17221937
    … …  
    17271942 * @param   pURI                URI clipboard context to determine value for.
    17281943 */
    1729 bool SharedClipboardURICtxMaximumTransfersReached(PSHAREDCLIPBOARDURICTX pURI)
     1944bool SharedClipboardURICtxTransfersMaximumReached(PSHAREDCLIPBOARDURICTX pURI)
    17301945{
    17311946    AssertPtrReturn(pURI, true);
    17321947
    1733     LogFlowFunc(("cTransfers=%RU32\n", pURI->cTransfers));
    1734 
    1735     Assert(pURI->cTransfers <= pURI->cMaxTransfers);
    1736     return pURI->cTransfers == pURI->cMaxTransfers;
    1737 }
    1738 
     1948    LogFlowFunc(("cRunning=%RU32\n", pURI->cRunning));
     1949
     1950    Assert(pURI->cRunning <= pURI->cMaxRunning);
     1951    return pURI->cRunning == pURI->cMaxRunning;
     1952}
     1953

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

    r79268 r79347  
    3939#include <VBox/GuestHost/SharedClipboard-win.h>
    4040#include <VBox/GuestHost/clipboard-helper.h>
     41
     42
     43DECLCALLBACK(void) vboxClipboardWinURIMetaDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
     44
    4145
    4246/**
    … …  
    833837#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    834838/**
    835  * Announces URI data (via IDataObject) to Windows.
     839 * Creates an URI transfer by announcing URI data (via IDataObject) to Windows.
     840 *
    836841 * This creates the necessary IDataObject + IStream implementations and initiates the actual transfers required for getting
    837842 * the meta data. Whether or not the actual (file++) transfer(s) are happening is up to the user (at some point) later then.
    … …  
    842847 * @param   pTransfer           URI transfer to use.
    843848 */
    844 int VBoxClipboardWinURIAnnounce(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURICTX pURICtx,
    845                                 PSHAREDCLIPBOARDURITRANSFER pTransfer)
    846 {
    847     AssertPtrReturn(pURICtx, VERR_INVALID_POINTER);
     849int VBoxClipboardWinURITransferCreate(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     850{
    848851    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    849852
    … …  
    851854
    852855    int rc;
     856
     857    if (pTransfer->pvUser)
     858    {
     859        Assert(pTransfer->cbUser == sizeof(SharedClipboardWinURITransferCtx));
     860        SharedClipboardWinURITransferCtx *pWinURITransferCtx = (SharedClipboardWinURITransferCtx *)pTransfer->pvUser;
     861        Assert(pWinURITransferCtx);
     862
     863        if (pWinURITransferCtx->pDataObj)
     864            delete pWinURITransferCtx->pDataObj;
     865    }
    853866
    854867    SharedClipboardWinURITransferCtx *pWinURITransferCtx = new SharedClipboardWinURITransferCtx();
    … …  
    903916
    904917/**
     918 * Destroys implementation-specific data for an URI transfer.
     919 *
     920 * @param   pWinCtx             Windows context to use.
     921 * @param   pTransfer           URI transfer to create implementation-specific data for.
     922 */
     923void VBoxClipboardWinURITransferDestroy(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     924{
     925    RT_NOREF(pWinCtx);
     926
     927    if (!pTransfer)
     928        return;
     929
     930    LogFlowFuncEnter();
     931
     932    if (pTransfer->pvUser)
     933    {
     934        Assert(pTransfer->cbUser == sizeof(SharedClipboardWinURITransferCtx));
     935        SharedClipboardWinURITransferCtx *pWinURITransferCtx = (SharedClipboardWinURITransferCtx *)pTransfer->pvUser;
     936        Assert(pWinURITransferCtx);
     937
     938        if (pWinURITransferCtx->pDataObj)
     939        {
     940            delete pWinURITransferCtx->pDataObj;
     941            pWinURITransferCtx->pDataObj = NULL;
     942        }
     943
     944        delete pWinURITransferCtx;
     945
     946        pTransfer->pvUser = NULL;
     947        pTransfer->cbUser = 0;
     948    }
     949}
     950
     951/**
    905952 * Converts a DROPFILES (HDROP) structure to a string list, separated by \r\n.
    906953 * Does not do any locking on the input data.

  • trunk/src/VBox/HostServices/SharedClipboard/Makefile.kmk

    r79270 r79347  
    5151        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardMetaData.cpp \
    5252        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp \
    53         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardProvider.cpp \
    54         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardProvider-HostService.cpp \
    5553        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardURIList.cpp \
    5654        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardURIObject.cpp \

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

    r79120 r79347  
    8282    uint32_t u32ClientID;
    8383
     84    SHAREDCLIPBOARDSOURCE enmSource;
     85
    8486    /** The guest is waiting for a message. */
    8587    bool fAsync;
    … …  
    9597    struct {
    9698        VBOXHGCMCALLHANDLE callHandle;
     99        uint32_t           cParms;
    97100        VBOXHGCMSVCPARM   *paParms;
    98101    } async;
    … …  
    100103    struct {
    101104        VBOXHGCMCALLHANDLE callHandle;
     105        uint32_t           cParms;
    102106        VBOXHGCMSVCPARM   *paParms;
    103107    } asyncRead;
    … …  
    129133 * The service functions. Locking is between the service thread and the platform-dependent (window) thread.
    130134 */
     135int vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, int rc, uint32_t cbActual);
    131136uint32_t vboxSvcClipboardGetMode(void);
    132137int vboxSvcClipboardReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t uMsg, uint32_t uFormats);
    133 int vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, int rc, uint32_t cbActual);
     138int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENTDATA pClientData, SHAREDCLIPBOARDSOURCE enmSource);
    134139
    135140# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    … …  
    157162
    158163#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    159 int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData);
    160 int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData);
    161 int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr);
    162 int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr);
    163 int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData);
    164 int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData);
     164int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer);
     165int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer);
     166
     167int VBoxClipboardSvcImplURIReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDATAHDR *ppDataHdr);
     168int VBoxClipboardSvcImplURIWriteDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr);
     169int VBoxClipboardSvcImplURIReadDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead);
     170int VBoxClipboardSvcImplURIWriteDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten);
     171
     172int VBoxClipboardSvcImplURIReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDIRDATA *ppDirData);
     173int VBoxClipboardSvcImplURIWriteDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDIRDATA pDirData);
     174
     175int VBoxClipboardSvcImplURIReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDFILEHDR *ppFileHdr);
     176int VBoxClipboardSvcImplURIWriteFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDFILEHDR pFileHdr);
     177int VBoxClipboardSvcImplURIReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
     178int VBoxClipboardSvcImplURIWriteFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
    165179#endif
    166180

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

    r79299 r79347  
    4343
    4444
    45 /**
    46  * Reads an URI data header from HGCM service parameters.
     45static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
     46                                                                    PVBOXCLIPBOARDDATAHDR *ppDataHdr)
     47{
     48    RT_NOREF(pCtx, ppDataHdr);
     49    return VERR_NOT_IMPLEMENTED;
     50}
     51
     52static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadObjHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
     53                                                                   PVBOXCLIPBOARDDATAHDR *ppDataHdr)
     54{
     55    RT_NOREF(pCtx, ppDataHdr);
     56    return VERR_NOT_IMPLEMENTED;
     57}
     58
     59static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
     60                                                                PVBOXCLIPBOARDDIRDATA *ppDirData)
     61{
     62    RT_NOREF(pCtx, ppDirData);
     63    return VERR_NOT_IMPLEMENTED;
     64}
     65
     66static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
     67                                                                    PVBOXCLIPBOARDFILEHDR *ppFileHdr)
     68{
     69    RT_NOREF(pCtx, ppFileHdr);
     70    return VERR_NOT_IMPLEMENTED;
     71}
     72
     73static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtX,
     74                                                                     void *pvData, uint32_t cbData, uint32_t fFlags,
     75                                                                     uint32_t *pcbRead)
     76{
     77#if 0
     78    const PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pCtx->pvUser;
     79
     80    return pObjCtx->pObj->Read(pvBuf, cbBuf, pcbWritten);
     81#endif
     82
     83    RT_NOREF(pCtX, pvData, cbData, fFlags, pcbRead);
     84    return VERR_NOT_IMPLEMENTED;
     85}
     86
     87#if 0
     88int vboxSvcClipboardURIAnnounce(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     89{
     90    Provider.pfnReadDataHdr    = vboxSvcClipboardURIProviderImplReadDataHdr;
     91    Provider.pfnReadDataChunk  = vboxSvcClipboardURIProviderImplReadDataChunk;
     92    Provider.pfnReadDir        = vboxSvcClipboardURIProviderImplReadDir;
     93    Provider.pfnReadFileHdr    = vboxSvcClipboardURIProviderImplReadFileHdr;
     94    Provider.pfnReadFileData   = vboxSvcClipboardURIProviderImplReadFileData;
     95
     96    Provider.pvUser =
     97
     98    SharedClipboardURITransferSetProvider(&Provider);
     99
     100    return rc;
     101}
     102#endif
     103
     104/**
     105 * Gets an URI data header from HGCM service parameters.
    47106 *
    48107 * @returns VBox status code.
    … …  
    51110 * @param   pDataHdr            Where to store the result.
    52111 */
    53 int VBoxSvcClipboardURIReadDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr)
     112int VBoxSvcClipboardURIGetDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr)
    54113{
    55114    int rc;
    … …  
    97156
    98157/**
    99  * Reads an URI data header from HGCM service parameters.
     158 * Sets an URI data header to HGCM service parameters.
    100159 *
    101160 * @returns VBox status code.
    102161 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
    103162 * @param   paParms             Array of HGCM parameters.
    104  * @param   pDataHdr            Pointer to data to write the the HGCM parameters.
    105  */
    106 int VBoxSvcClipboardURIWriteDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr)
     163 * @param   pDataHdr            Pointer to data to set to the HGCM parameters.
     164 */
     165int VBoxSvcClipboardURISetDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr)
    107166{
    108167    int rc;
    … …  
    139198
    140199/**
    141  * Reads an URI data chunk from HGCM service parameters.
     200 * Gets an URI data chunk from HGCM service parameters.
    142201 *
    143202 * @returns VBox status code.
    … …  
    146205 * @param   pDataChunk          Where to store the result.
    147206 */
    148 int VBoxSvcClipboardURIReadDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk)
     207int VBoxSvcClipboardURIGetDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk)
    149208{
    150209    int rc;
    … …  
    175234
    176235/**
    177  * Writes an URI data chunk to HGCM service parameters.
     236 * Sets an URI data chunk to HGCM service parameters.
    178237 *
    179238 * @returns VBox status code.
    180239 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
    181240 * @param   paParms             Array of HGCM parameters.
    182  * @param   pDataChunk          Pointer to data to write the the HGCM parameters.
    183  */
    184 int VBoxSvcClipboardURIWriteDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk)
     241 * @param   pDataChunk          Pointer to data to set to the HGCM parameters.
     242 */
     243int VBoxSvcClipboardURISetDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk)
    185244{
    186245    int rc;
    … …  
    206265
    207266/**
    208  * Reads an URI directory entry from HGCM service parameters.
     267 * Gets an URI directory entry from HGCM service parameters.
    209268 *
    210269 * @returns VBox status code.
    … …  
    213272 * @param   pDirData            Where to store the result.
    214273 */
    215 int VBoxSvcClipboardURIReadDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData)
     274int VBoxSvcClipboardURIGetDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData)
    216275{
    217276    int rc;
    … …  
    242301
    243302/**
    244  * Writes an URI directory entry to HGCM service parameters.
     303 * Sets an URI directory entry to HGCM service parameters.
    245304 *
    246305 * @returns VBox status code.
    247306 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
    248307 * @param   paParms             Array of HGCM parameters.
    249  * @param   pDirData            Pointer to data to write the the HGCM parameters.
    250  */
    251 int VBoxSvcClipboardURIWriteDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData)
     308 * @param   pDirData            Pointer to data to set to the HGCM parameters.
     309 */
     310int VBoxSvcClipboardURISetDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData)
    252311{
    253312    int rc;
    … …  
    277336 * @param   pFileHdr            Where to store the result.
    278337 */
    279 int VBoxSvcClipboardURIReadFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr)
     338int VBoxSvcClipboardURIGetFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr)
    280339{
    281340    int rc;
    … …  
    305364
    306365/**
    307  * Writes an URI file header to HGCM service parameters.
     366 * Sets an URI file header to HGCM service parameters.
    308367 *
    309368 * @returns VBox status code.
    310369 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
    311370 * @param   paParms             Array of HGCM parameters.
    312  * @param   pFileHdr            Pointer to data to write the the HGCM parameters.
    313  */
    314 int VBoxSvcClipboardURIWriteFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr)
     371 * @param   pFileHdr            Pointer to data to set to the HGCM parameters.
     372 */
     373int VBoxSvcClipboardURISetFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr)
    315374{
    316375    int rc;
    … …  
    335394
    336395/**
    337  * Reads an URI file data chunk from HGCM service parameters.
     396 * Gets an URI file data chunk from HGCM service parameters.
    338397 *
    339398 * @returns VBox status code.
    … …  
    342401 * @param   pFileData           Where to store the result.
    343402 */
    344 int VBoxSvcClipboardURIReadFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData)
     403int VBoxSvcClipboardURIGetFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData)
    345404{
    346405    int rc;
    … …  
    367426
    368427/**
    369  * Writes an URI file data chunk to HGCM service parameters.
     428 * Sets an URI file data chunk to HGCM service parameters.
    370429 *
    371430 * @returns VBox status code.
    372431 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
    373432 * @param   paParms             Array of HGCM parameters.
    374  * @param   pFileData           Pointer to data to write the the HGCM parameters.
    375  */
    376 int VBoxSvcClipboardURIWriteFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData)
     433 * @param   pFileData           Pointer to data to set to the HGCM parameters.
     434 */
     435int VBoxSvcClipboardURISetFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData)
    377436{
    378437    int rc;
    … …  
    438497    }
    439498
    440     if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    441     {
    442         LogFunc(("No active transfers found\n"));
     499    if (!SharedClipboardURICtxGetRunningTransfers(&pClientData->URI))
     500    {
     501        LogFunc(("No running transfers found\n"));
    443502        return VERR_WRONG_ORDER;
    444503    }
    … …  
    462521        {
    463522            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_HDR\n"));
     523
     524            VBOXCLIPBOARDDATAHDR dataHdr;
     525            rc = VBoxSvcClipboardURISetDataHdr(cParms, paParms, &dataHdr);
    464526            break;
    465527        }
    … …  
    472534            rc = SharedClipboardURIDataHdrInit(&dataHdr);
    473535            if (RT_SUCCESS(rc))
    474                 rc = VBoxSvcClipboardURIReadDataHdr(cParms, paParms, &dataHdr);
    475             if (RT_SUCCESS(rc))
    476             {
    477                 AssertBreakStmt(pTransfer->State.pHeader == NULL, rc = VERR_WRONG_ORDER);
    478                 pTransfer->State.pHeader = SharedClipboardURIDataHdrDup(&dataHdr);
    479                 if (pTransfer->State.pHeader)
    480                 {
    481                     LogFlowFunc(("Meta data size is %RU32\n", pTransfer->State.pHeader->cbMeta));
    482                 }
    483                 else
    484                     rc = VERR_NO_MEMORY;
    485             }
     536                rc = VBoxSvcClipboardURIGetDataHdr(cParms, paParms, &dataHdr);
     537            /*if (RT_SUCCESS(rc))
     538                rc = SharedClipboardURITransferSetDataHeader(&dataHdr);*/
    486539            break;
    487540        }
    … …  
    500553            rc = SharedClipboardURIDataChunkInit(&dataChunk);
    501554            if (RT_SUCCESS(rc))
    502                 rc = VBoxSvcClipboardURIReadDataChunk(cParms, paParms, &dataChunk);
     555                rc = VBoxSvcClipboardURIGetDataChunk(cParms, paParms, &dataChunk);
     556    #if 0
    503557            if (RT_SUCCESS(rc))
    504558            {
    505                 AssertPtrBreakStmt(pTransfer->State.pHeader, rc = VERR_WRONG_ORDER);
    506 
    507                 rc = SharedClipboardURITransferMetaDataAdd(pTransfer, dataChunk.pvData, dataChunk.cbData);
    508                 if (   RT_SUCCESS(rc)
    509                     && SharedClipboardURITransferMetaDataIsComplete(pTransfer)) /* Meta data transfer complete? */
    510                 {
    511                     rc = SharedClipboardURITransferPrepare(pTransfer);
    512                 }
     559                VBOXCLIPBOARDTRANSFEREVENT Event = { &dataChunk, sizeof(dataChunk) };
     560                rc = SharedClipboardURITransferSendEvent(WRITE_DATA_CHUNK, &Event);
    513561            }
    514 
     562        #endif
    515563            break;
    516564        }
    … …  
    519567        {
    520568            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DIR\n"));
    521             if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DIR)
    522             {
    523                 if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    524                 {
    525                     rc = VERR_WRONG_ORDER;
    526                     break;
    527                 }
    528 
    529                 VBOXCLIPBOARDDIRDATA data;
    530                 rc = VBoxClipboardSvcImplURIReadDir(pClientData, &data);
    531                 if (RT_SUCCESS(rc))
    532                 {
    533                     /* Note: Context ID (paParms[0]) not used yet. */
    534                     HGCMSvcSetPv (&paParms[1], data.pszPath, data.cbPath);
    535                     HGCMSvcSetU32(&paParms[2], data.cbPath);
    536                     HGCMSvcSetU32(&paParms[3], data.fMode);
    537 
    538                     SharedClipboardURIDirDataDestroy(&data);
    539                 }
    540             }
     569
     570            VBOXCLIPBOARDDIRDATA data;
     571            rc = VBoxSvcClipboardURISetDir(cParms, paParms, &data);
    541572            break;
    542573        }
    … …  
    547578
    548579            VBOXCLIPBOARDDIRDATA dirData;
    549             rc = VBoxSvcClipboardURIReadDir(cParms, paParms, &dirData);
     580            rc = VBoxSvcClipboardURIGetDir(cParms, paParms, &dirData);
    550581            if (RT_SUCCESS(rc))
    551582            {
    … …  
    562593                    if (RT_SUCCESS(rc))
    563594                    {
    564                         /* Add for having a proper rollback. */
    565                         int rc2 = pArea->AddDir(pszDir);
     595                        SHAREDCLIPBOARDAREAOBJ Obj = { SHAREDCLIPBOARDAREAOBJTYPE_DIR, SHAREDCLIPBOARDAREAOBJSTATE_COMPLETE };
     596                        int rc2 = pArea->AddObject(pszDir, Obj);
    566597                        AssertRC(rc2);
    567598                    }
    … …  
    578609        {
    579610            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR\n"));
    580             if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_HDR)
    581             {
    582                 VBOXCLIPBOARDFILEHDR hdr;
    583                 rc = VBoxClipboardSvcImplURIReadFileHdr(pClientData, &hdr);
    584                 if (RT_SUCCESS(rc))
    585                 {
    586                     /* Note: Context ID (paParms[0]) not used yet. */
    587                     HGCMSvcSetPv (&paParms[1], hdr.pszFilePath, hdr.cbFilePath);
    588                     HGCMSvcSetU32(&paParms[2], hdr.cbFilePath);
    589                     HGCMSvcSetU32(&paParms[3], hdr.fFlags);
    590                     HGCMSvcSetU32(&paParms[4], hdr.fMode);
    591                     HGCMSvcSetU64(&paParms[5], hdr.cbSize);
    592 
    593                     SharedClipboardURIFileHdrDestroy(&hdr);
    594                 }
    595             }
     611
     612            VBOXCLIPBOARDFILEHDR fileHdr;
     613            rc = VBoxSvcClipboardURISetFileHdr(cParms, paParms, &fileHdr);
    596614            break;
    597615        }
    … …  
    603621            if (!SharedClipboardURIObjCtxIsValid(SharedClipboardURITransferGetCurrentObjCtx(pTransfer)))
    604622            {
    605                 pTransfer->ObjCtx.pObj = new SharedClipboardURIObject(SharedClipboardURIObject::Type_File);
    606                 if (pTransfer->ObjCtx.pObj) /** @todo Can this throw? */
     623                pTransfer->State.ObjCtx.pObj = new SharedClipboardURIObject(SharedClipboardURIObject::Type_File);
     624                if (pTransfer->State.ObjCtx.pObj) /** @todo Can this throw? */
    607625                {
    608626                    rc = VINF_SUCCESS;
    … …  
    618636
    619637            VBOXCLIPBOARDFILEHDR fileHdr;
    620             rc = VBoxSvcClipboardURIReadFileHdr(cParms, paParms, &fileHdr);
     638            rc = VBoxSvcClipboardURIGetFileHdr(cParms, paParms, &fileHdr);
    621639            if (RT_SUCCESS(rc))
    622640            {
    … …  
    659677                                         pObj->GetDestPathAbs().c_str()));
    660678
    661                                 SharedClipboardURIObjCtxDestroy(&pTransfer->ObjCtx);
     679                                SharedClipboardURIObjCtxDestroy(&pTransfer->State.ObjCtx);
    662680                            }
    663681
    664                             /* Add for having a proper rollback. */
    665                             int rc2 = pArea->AddFile(pszPathAbs);
     682                            SHAREDCLIPBOARDAREAOBJ Obj = { SHAREDCLIPBOARDAREAOBJTYPE_FILE, SHAREDCLIPBOARDAREAOBJSTATE_NONE };
     683                            int rc2 = pArea->AddObject(pszPathAbs, Obj);
    666684                            AssertRC(rc2);
    667685                        }
    … …  
    677695        {
    678696            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA\n"));
    679             if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_DATA)
    680             {
    681                 if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    682                 {
    683                     rc = VERR_WRONG_ORDER;
    684                     break;
    685                 }
    686 
    687                 VBOXCLIPBOARDFILEDATA data;
    688                 rc = VBoxClipboardSvcImplURIReadFileData(pClientData, &data);
    689                 if (RT_SUCCESS(rc))
    690                 {
    691                     /* Note: Context ID (paParms[0]) not used yet. */
    692                     HGCMSvcSetPv (&paParms[1], data.pvData, data.cbData);
    693                     HGCMSvcSetU32(&paParms[2], data.cbData);
    694                     HGCMSvcSetPv (&paParms[3], data.pvChecksum, data.cbChecksum);
    695                     HGCMSvcSetU32(&paParms[4], data.cbChecksum);
    696 
    697                     SharedClipboardURIFileDataDestroy(&data);
    698                 }
    699             }
     697
     698            VBOXCLIPBOARDFILEDATA fileData;
     699            rc = VBoxSvcClipboardURISetFileData(cParms, paParms, &fileData);
    700700            break;
    701701        }
    … …  
    705705            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA\n"));
    706706
    707             if (!SharedClipboardURIObjCtxIsValid(&pTransfer->ObjCtx))
     707            if (!SharedClipboardURIObjCtxIsValid(&pTransfer->State.ObjCtx))
    708708            {
    709709                rc = VERR_WRONG_ORDER;
    … …  
    712712
    713713            VBOXCLIPBOARDFILEDATA fileData;
    714             rc = VBoxSvcClipboardURIReadFileData(cParms, paParms, &fileData);
     714            rc = VBoxSvcClipboardURIGetFileData(cParms, paParms, &fileData);
    715715            if (RT_SUCCESS(rc))
    716716            {
    … …  
    734734                    if (   pObj->IsComplete()
    735735                        || RT_FAILURE(rc))
    736                         SharedClipboardURIObjCtxDestroy(&pTransfer->ObjCtx);
     736                        SharedClipboardURIObjCtxDestroy(&pTransfer->State.ObjCtx);
    737737                }
    738738                else
    … …  
    771771            writeParms.u.HostService.paParms = paParms;
    772772
    773             rc = pTransfer->pProvider->OnWrite(&writeParms);
     773            //rc = pTransfer->pProvider->OnWrite(&writeParms);
    774774        }
    775775    }
    … …  
    919919 * @param   pClientState        Client state to use.
    920920 * @param   pTransfer           URI transfer to attach a clipboard area to.
    921  */
    922 int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     921 * @param   uID                 ID of clipboard area to to attach to. Specify 0 to attach to the most recent one.
     922 */
     923int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer,
     924                                  SHAREDCLIPBOARDAREAID uID)
    923925{
    924926    LogFlowFuncEnter();
    … …  
    938940        RT_ZERO(parms);
    939941
    940         parms.uID = 0; /* 0 means most recent clipboard area. */
     942        parms.uID = uID; /* 0 means most recent clipboard area. */
    941943
    942944        /* The client now needs to attach to the most recent clipboard area

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

    r79174 r79347  
    2222#endif
    2323
     24//int vboxSvcClipboardURIAnnounce(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     25
    2426int vboxSvcClipboardURIHandler(uint32_t u32ClientID, void *pvClient, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival, bool *pfAsync);
    2527int vboxSvcClipboardURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    … …  
    2729int vboxSvcClipboardURIAreaRegister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    2830int vboxSvcClipboardURIAreaUnregister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    29 int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);
     31int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDAREAID uID);
    3032int vboxSvcClipboardURIAreaDetach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    31 
    32 DECLCALLBACK(int) vboxClipboardSvcReadDataHdrCallback(PSHAREDCLIPBOARDPROVIDERCALLBACKDATA pData);
    3333
    3434#endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_uri_h */

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

    r79267 r79347  
    158158    bool fHandled = false;
    159159
    160 #if 0
     160    /* For now we only support one transfer at a time. */
    161161    PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClientData->URI, 0 /* Index */);
    162     if (pTransfer)
    163     {
    164         if (   !s_fReqHdr
    165             && !pTransfer->State.pHeader)
    166         {
    167             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA\n"));
    168 
    169             HGCMSvcSetU32(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    170             HGCMSvcSetU32(&paParms[1], VBOX_SHARED_CLIPBOARD_FMT_URI_LIST /* fFormats */);
     162    if (!pTransfer)
     163        return fHandled;
     164
     165#if 1
     166    int rc = 0;
     167#else
     168    /* Sanity. */
     169    Assert(pTransfer->State.enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ);
     170
     171    int rc;
     172
     173    /* Note: Message priority / order is taken into account here. */
     174    if (pTransfer->State.pHeader)
     175    {
     176        LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_HDR\n"));
     177        rc = VBoxSvcClipboardURIWriteDataHdr(cParms, paParms, pTransfer->State.pHeader);
     178        if (RT_SUCCESS(rc))
     179        {
     180            /* We're done witht the data header, destroy it. */
     181            SharedClipboardURIDataHdrFree(pTransfer->State.pHeader);
     182            pTransfer->State.pHeader = NULL;
     183
    171184            fHandled = true;
    172 
    173             s_fReqHdr = true;
    174         }
    175         else
    176         {
    177         }
    178     }
     185        }
     186    }
     187    else if (pTransfer->State.pMeta)
     188    {
     189        LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_CHUNK\n"));
     190
     191        uint32_t cbBuf = _64K;
     192        uint8_t  pvBuf[_64K]; /** @todo Improve */
     193
     194        uint32_t cbRead;
     195        rc = SharedClipboardMetaDataRead(pTransfer->State.pMeta, pvBuf, cbBuf, &cbRead);
     196        if (RT_SUCCESS(rc))
     197        {
     198            Assert(cbRead <= cbBuf);
     199
     200            VBOXCLIPBOARDDATACHUNK dataChunk;
     201            RT_ZERO(dataChunk);
     202            dataChunk.pvData = pvBuf;
     203            dataChunk.cbData = cbRead;
     204
     205            rc = VBoxSvcClipboardURIWriteDataChunk(cParms, paParms, &dataChunk);
     206        }
     207
     208        /* Has all meta data been read? */
     209        if (RT_SUCCESS(rc))
     210        {
     211            if (SharedClipboardMetaDataGetUsed(pTransfer->State.pMeta) == 0)
     212            {
     213                SharedClipboardMetaDataFree(pTransfer->State.pMeta);
     214                pTransfer->State.pMeta = NULL;
     215            }
     216
     217            fHandled = true;
     218        }
     219    }
     220    else if (pTransfer->pURIList)
     221    {
     222        PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer);
     223        if (!SharedClipboardURIObjCtxIsValid(pObjCtx))
     224        {
     225            if (!pTransfer->pURIList->IsEmpty())
     226                pObjCtx->pObj = pTransfer->pURIList->First();
     227        }
     228
     229        if (   pObjCtx
     230            && pObjCtx->pObj)
     231        {
     232            switch (pObjCtx->pObj->GetType())
     233            {
     234                case SharedClipboardURIObject::Type_Directory:
     235                {
     236                    rc = VBoxSvcClipboardURIWriteDir(cParms, paParms, &dataChunk);
     237                    break;
     238                }
     239            }
     240        }
     241
     242        if (0)
     243        {
     244            delete pTransfer->pURIList;
     245            pTransfer->pURIList = NULL;
     246        }
     247
     248        fHandled = true;
     249    }
     250    else
     251        rc = VERR_WRONG_ORDER;
    179252#endif
    180253
    181     LogFlowFunc(("fHandled=%RTbool\n", fHandled));
     254    LogFlowFunc(("rc=%Rrc, fHandled=%RTbool\n", rc, fHandled));
    182255    return fHandled;
    183256}

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

    r79299 r79347  
    5656*   Internal Functions                                                                                                           *
    5757*********************************************************************************************************************************/
    58 static int vboxClipboardWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx);
     58static int vboxClipboardSvcWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx);
    5959
    6060struct _VBOXCLIPBOARDCONTEXT
    … …  
    131131 *                              Specify 0 if no waiting is required.
    132132 */
    133 static int vboxClipboardWinRequestData(PVBOXCLIPBOARDCONTEXT pCtx, VBOXCLIPBOARDFORMAT fFormat,
    134                                        RTMSINTERVAL uTimeoutMs)
    135 {
    136     Assert(pCtx->pClientData);
     133static int vboxClipboardSvcWinRequestData(PVBOXCLIPBOARDCONTEXT pCtx, VBOXCLIPBOARDFORMAT fFormat,
     134                                          RTMSINTERVAL uTimeoutMs)
     135{
     136    AssertPtr(pCtx->pClientData);
    137137    Assert(pCtx->hRenderEvent);
    138138    Assert(pCtx->pClientData->State.data.pv == NULL && pCtx->pClientData->State.data.cb == 0 && pCtx->pClientData->State.data.u32Format == 0);
    … …  
    151151}
    152152
    153 static LRESULT CALLBACK vboxClipboardWinWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
     153static LRESULT CALLBACK vboxClipboardSvcWinWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
    154154{
    155155    LRESULT lresultRc = 0;
    … …  
    169169
    170170                /* Clipboard was updated by another application, retrieve formats and report back. */
    171                 int rc = vboxClipboardWinSyncInternal(pCtx);
     171                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    172172                AssertRC(rc);
     173
     174                vboxSvcClipboardSetSource(pCtx->pClientData, SHAREDCLIPBOARDSOURCE_LOCAL);
    173175            }
    174176        } break;
    … …  
    187189            {
    188190                /* Clipboard was updated by another application, retrieve formats and report back. */
    189                 int vboxrc = vboxClipboardWinSyncInternal(pCtx);
    190                 AssertRC(vboxrc);
     191                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
     192                if (RT_SUCCESS(rc))
     193                    vboxSvcClipboardSetSource(pCtx->pClientData, SHAREDCLIPBOARDSOURCE_LOCAL);
    191194            }
    192195
    … …  
    221224            else
    222225            {
    223                 int rc = vboxClipboardWinRequestData(pCtx, fFormat, 30 * 1000 /* 30s timeout */);
     226                int rc = vboxClipboardSvcWinRequestData(pCtx, fFormat, 30 * 1000 /* 30s timeout */);
    224227
    225228                LogFunc(("vboxClipboardReadDataFromClient rc = %Rrc, pv %p, cb %d, u32Format %d\n",
    … …  
    328331                        if (pTransfer)
    329332                        {
    330                             rc = VBoxClipboardWinURIAnnounce(pWinCtx, &pCtx->pClientData->URI, pTransfer);
     333                            rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
    331334
    332335                            /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation
    … …  
    336339                            AssertFailedStmt(rc = VERR_NOT_FOUND);
    337340
    338                         /* Note: VBoxClipboardWinURIAnnounce() takes care of closing the clipboard. */
     341                        /* Note: VBoxClipboardWinURITransferCreate() takes care of closing the clipboard. */
    339342                    }
    340343                    else
    … …  
    376379}
    377380
    378 DECLCALLBACK(int) vboxClipboardWinThread(RTTHREAD hThreadSelf, void *pvUser)
     381DECLCALLBACK(int) vboxClipboardSvcWinThread(RTTHREAD hThreadSelf, void *pvUser)
    379382{
    380383    RT_NOREF(hThreadSelf, pvUser);
    … …  
    395398
    396399    wc.style         = CS_NOCLOSE;
    397     wc.lpfnWndProc   = vboxClipboardWinWndProc;
     400    wc.lpfnWndProc   = vboxClipboardSvcWinWndProc;
    398401    wc.hInstance     = hInstance;
    399402    wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
    … …  
    485488 * @param   pCtx                Clipboard context to synchronize.
    486489 */
    487 static int vboxClipboardWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx)
     490static int vboxClipboardSvcWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx)
    488491{
    489492    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
    … …  
    521524    if (RT_SUCCESS(rc))
    522525    {
    523         rc = RTThreadCreate(&g_ctx.hThread, vboxClipboardWinThread, NULL, _64K /* Stack size */,
     526        rc = RTThreadCreate(&g_ctx.hThread, vboxClipboardSvcWinThread, NULL, _64K /* Stack size */,
    524527                            RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLIP");
    525528    }
    … …  
    577580{
    578581    /* Sync the host clipboard content with the client. */
    579     return vboxClipboardWinSyncInternal(pClientData->State.pCtx);
     582    return vboxClipboardSvcWinSyncInternal(pClientData->State.pCtx);
    580583}
    581584
    … …  
    767770
    768771#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    769 int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData)
    770 {
    771     RT_NOREF(pClientData, pDirData);
     772DECLCALLBACK(void) vboxClipboardSvcWinURITransferPrepareCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
     773{
     774    LogFlowFuncEnter();
     775
     776    AssertPtrReturnVoid(pData);
     777
     778    PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pData->pvUser;
     779    AssertPtrReturnVoid(pClientData);
     780
     781    /* Tell the guest that it can start sending URI data. */
     782    int rc2 = vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     783                                        VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
     784    AssertRC(rc2);
     785}
     786
     787DECLCALLBACK(void) vboxClipboardSvcWinURIDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
     788{
     789    LogFlowFuncEnter();
     790
     791    AssertPtrReturnVoid(pData);
     792
     793    PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer;
     794    AssertPtrReturnVoid(pTransfer);
     795
     796    SharedClipboardWinURITransferCtx *pTransferCtx = (SharedClipboardWinURITransferCtx *)pTransfer->pvUser;
     797    AssertPtrReturnVoid(pTransferCtx);
     798
     799    /* Notify the Windows implementation's data object that the meta data has been read successfully. */
     800    if (pTransferCtx->pDataObj)
     801        pTransferCtx->pDataObj->OnMetaDataComplete(pTransfer);
     802}
     803
     804int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     805{
     806    LogFlowFuncEnter();
     807
     808    /* Register needed callbacks so that we can wait for the meta data to arrive here. */
     809    SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
     810    RT_ZERO(Callbacks);
     811
     812    Callbacks.pvUser              = pClientData;
     813    Callbacks.pfnTransferPrepare  = vboxClipboardSvcWinURITransferPrepareCallback;
     814
     815    SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks);
     816
     817    return VINF_SUCCESS;
     818}
     819
     820int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     821{
     822    LogFlowFuncEnter();
     823
     824    VBoxClipboardWinURITransferDestroy(&pClientData->State.pCtx->Win, pTransfer);
     825
     826    return VINF_SUCCESS;
     827}
     828
     829int VBoxClipboardSvcImplURIReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDATAHDR *ppDataHdr)
     830{
     831    RT_NOREF(ppDataHdr);
     832
     833    LogFlowFuncEnter();
     834
     835    PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pCtx->pvUser;
     836    AssertPtr(pClientData);
     837
     838
    772839    return VERR_NOT_IMPLEMENTED;
    773840}
    774841
    775 int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData)
    776 {
    777     RT_NOREF(pClientData, pDirData);
     842int VBoxClipboardSvcImplURIWriteDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr)
     843{
     844    RT_NOREF(pCtx, pDataHdr);
    778845    return VERR_NOT_IMPLEMENTED;
    779846}
    780847
    781 int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr)
    782 {
    783     RT_NOREF(pClientData, pFileHdr);
     848int VBoxClipboardSvcImplURIReadDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr,
     849                                         void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead)
     850{
     851    RT_NOREF(pCtx, pDataHdr, pvChunk, cbChunk, fFlags, pcbRead);
    784852    return VERR_NOT_IMPLEMENTED;
    785853}
    786854
    787 int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr)
    788 {
    789     RT_NOREF(pClientData, pFileHdr);
     855int VBoxClipboardSvcImplURIWriteDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr,
     856                                          const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten)
     857{
     858    RT_NOREF(pCtx, pDataHdr, pvChunk, cbChunk, fFlags, pcbWritten);
    790859    return VERR_NOT_IMPLEMENTED;
    791860}
    792861
    793 int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData)
    794 {
    795     RT_NOREF(pClientData, pFileData);
     862int VBoxClipboardSvcImplURIReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDIRDATA *ppDirData)
     863{
     864    RT_NOREF(pCtx, ppDirData);
    796865    return VERR_NOT_IMPLEMENTED;
    797866}
    798867
    799 int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData)
    800 {
    801     RT_NOREF(pClientData, pFileData);
     868int VBoxClipboardSvcImplURIWriteDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDIRDATA pDirData)
     869{
     870    RT_NOREF(pCtx, pDirData);
    802871    return VERR_NOT_IMPLEMENTED;
    803872}
     873
     874int VBoxClipboardSvcImplURIReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDFILEHDR *ppFileHdr)
     875{
     876    RT_NOREF(pCtx, ppFileHdr);
     877    return VERR_NOT_IMPLEMENTED;
     878}
     879
     880int VBoxClipboardSvcImplURIWriteFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDFILEHDR pFileHdr)
     881{
     882    RT_NOREF(pCtx, pFileHdr);
     883    return VERR_NOT_IMPLEMENTED;
     884}
     885
     886int VBoxClipboardSvcImplURIReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags,
     887                                        uint32_t *pcbRead)
     888{
     889    RT_NOREF(pCtx, pvData, cbData, fFlags, pcbRead);
     890    return VERR_NOT_IMPLEMENTED;
     891}
     892
     893int VBoxClipboardSvcImplURIWriteFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags,
     894                                         uint32_t *pcbWritten)
     895{
     896    RT_NOREF(pCtx, pvData, cbData, fFlags, pcbWritten);
     897    return VERR_NOT_IMPLEMENTED;
     898}
    804899#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    805900

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

    r79299 r79347  
    259259static bool vboxSvcClipboardReturnMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    260260{
    261     RT_NOREF(cParms);
     261    /** @todo r=andy The client at the moment supplies two parameters, which we can
     262     *        use by filling in the next message type sent by the host service.
     263     *        Make this more flexible later, as I don't want to break the existing protocol right now. */
     264    if (cParms < 2)
     265    {
     266        AssertFailed(); /* Should never happen. */
     267        return false;
     268    }
    262269
    263270    /* Message priority is taken into account. */
    … …  
    385392            {
    386393                /* The client waits for a response. */
    387                 bool fMessageReturned = vboxSvcClipboardReturnMsg(pClientData, 0 /* cParms, fix */,
     394                bool fMessageReturned = vboxSvcClipboardReturnMsg(pClientData,
     395                                                                  pClientData->State.async.cParms,
    388396                                                                  pClientData->State.async.paParms);
    389397
    … …  
    410418        else
    411419            VBoxSvcClipboardUnlock();
     420    }
     421
     422    LogFlowFuncLeaveRC(rc);
     423    return rc;
     424}
     425
     426
     427int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENTDATA pClientData, SHAREDCLIPBOARDSOURCE enmSource)
     428{
     429    if (!pClientData) /* If no client connected (anymore), bail out. */
     430        return VINF_SUCCESS;
     431
     432    int rc = VINF_SUCCESS;
     433
     434    if (VBoxSvcClipboardLock())
     435    {
     436        pClientData->State.enmSource = enmSource;
     437
     438        LogFlowFunc(("Source of client %RU32 is now %RU32\n", pClientData->State.u32ClientID, pClientData->State.enmSource));
     439
     440        VBoxSvcClipboardUnlock();
    412441    }
    413442
    … …  
    585614                        pClientData->State.fAsync           = true;
    586615                        pClientData->State.async.callHandle = callHandle;
     616                        pClientData->State.async.cParms     = cParms;
    587617                        pClientData->State.async.paParms    = paParms;
    588618                    }
    … …  
    623653                    else
    624654                    {
     655                        rc = vboxSvcClipboardSetSource(pClientData, SHAREDCLIPBOARDSOURCE_REMOTE);
     656
    625657#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    626658                        if (   RT_SUCCESS(rc)
    627659                            && (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST))
    628660                        {
    629                             if (!SharedClipboardURICtxMaximumTransfersReached(&pClientData->URI))
     661                            if (!SharedClipboardURICtxTransfersMaximumReached(&pClientData->URI))
    630662                            {
     663                                SharedClipboardURICtxTransfersCleanup(&pClientData->URI);
     664
    631665                                PSHAREDCLIPBOARDURITRANSFER pTransfer;
    632                                 rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ, &pTransfer);
     666                                rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ,
     667                                                                      SHAREDCLIPBOARDSOURCE_REMOTE, &pTransfer);
    633668                                if (RT_SUCCESS(rc))
    634669                                {
    … …  
    638673                                        SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    639674                                        RT_ZERO(creationCtx);
    640                                         creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_HOSTSERVICE;
    641                                         creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_READ;
     675
     676                                        creationCtx.enmSource = pClientData->State.enmSource;
     677
     678                                        RT_ZERO(creationCtx.Interface);
     679                                        creationCtx.Interface.pfnReadDataHdr    = VBoxClipboardSvcImplURIReadDataHdr;
     680                                        creationCtx.Interface.pfnReadDataChunk  = VBoxClipboardSvcImplURIReadDataChunk;
     681                                        creationCtx.Interface.pfnReadDirectory  = VBoxClipboardSvcImplURIReadDir;
     682                                        creationCtx.Interface.pfnReadFileHdr    = VBoxClipboardSvcImplURIReadFileHdr;
     683                                        creationCtx.Interface.pfnReadFileData   = VBoxClipboardSvcImplURIReadFileData;
     684
     685                                        creationCtx.Interface.pfnWriteDataHdr    = VBoxClipboardSvcImplURIWriteDataHdr;
     686                                        creationCtx.Interface.pfnWriteDataChunk  = VBoxClipboardSvcImplURIWriteDataChunk;
     687                                        creationCtx.Interface.pfnWriteDirectory  = VBoxClipboardSvcImplURIWriteDir;
     688                                        creationCtx.Interface.pfnWriteFileHdr    = VBoxClipboardSvcImplURIWriteFileHdr;
     689                                        creationCtx.Interface.pfnWriteFileData   = VBoxClipboardSvcImplURIWriteFileData;
     690
     691                                        creationCtx.pvUser = pClientData;
     692
    642693                                        creationCtx.u.HostService.pArea = pTransfer->pArea;
    643694
    … …  
    645696                                        if (RT_SUCCESS(rc))
    646697                                            rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer);
     698                                    }
     699
     700                                    if (RT_SUCCESS(rc))
     701                                    {
     702                                        rc = VBoxClipboardSvcImplURITransferCreate(pClientData, pTransfer);
     703                                    }
     704                                    else
     705                                    {
     706                                        VBoxClipboardSvcImplURITransferDestroy(pClientData, pTransfer);
     707                                        SharedClipboardURITransferDestroy(pTransfer);
    647708                                    }
    648709                                }
    … …  
    650711                            else
    651712                                rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
     713
     714                            LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST: %Rrc\n", rc));
     715
     716                            if (RT_FAILURE(rc))
     717                                LogRel(("Shared Clipboard: Initializing URI guest to host read transfer failed with %Rrc\n", rc));
    652718                        }
    653719#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    … …  
    689755            else
    690756            {
     757                if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
     758                    && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     759                {
     760                    rc = VERR_ACCESS_DENIED;
     761                    break;
     762                }
     763
    691764                uint32_t u32Format;
    692                 void     *pv;
    693                 uint32_t cb;
    694 
    695765                rc = HGCMSvcGetU32(&paParms[0], &u32Format);
    696766                if (RT_SUCCESS(rc))
    697767                {
    698                     rc = VBoxHGCMParmPtrGet(&paParms[1], &pv, &cb);
    699 
    700                     if (RT_SUCCESS (rc))
     768#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     769                    if (u32Format == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    701770                    {
    702                         if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
    703                             && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     771                        if (!SharedClipboardURICtxTransfersMaximumReached(&pClientData->URI))
    704772                        {
    705                             rc = VERR_NOT_SUPPORTED;
    706                             break;
    707                         }
    708 
    709                         uint32_t cbActual = 0;
    710 
    711                         if (g_pfnExtension)
    712                         {
    713                             VBOXCLIPBOARDEXTPARMS parms;
    714                             RT_ZERO(parms);
    715 
    716                             parms.u32Format = u32Format;
    717                             parms.u.pvData  = pv;
    718                             parms.cbData    = cb;
    719 
    720                             g_fReadingData = true;
    721 
    722                             rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_READ, &parms, sizeof (parms));
    723                             LogFlowFunc(("DATA: g_fDelayedAnnouncement = %d, g_u32DelayedFormats = 0x%x\n", g_fDelayedAnnouncement, g_u32DelayedFormats));
    724 
    725                             if (g_fDelayedAnnouncement)
     773                            SharedClipboardURICtxTransfersCleanup(&pClientData->URI);
     774
     775                            PSHAREDCLIPBOARDURITRANSFER pTransfer;
     776                            rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE,
     777                                                                  pClientData->State.enmSource,
     778                                                                  &pTransfer);
     779                            if (RT_SUCCESS(rc))
    726780                            {
    727                                 vboxSvcClipboardReportMsg(g_pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, g_u32DelayedFormats);
    728                                 g_fDelayedAnnouncement = false;
    729                                 g_u32DelayedFormats = 0;
    730                             }
    731 
    732                             g_fReadingData = false;
    733 
    734                             if (RT_SUCCESS (rc))
    735                             {
    736                                 cbActual = parms.cbData;
     781                                /* Attach to the most recent clipboard area. */
     782                                rc = vboxSvcClipboardURIAreaAttach(&pClientData->State, pTransfer, 0 /* Area ID */);
     783                                if (RT_SUCCESS(rc))
     784                                {
     785                                    SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
     786                                    RT_ZERO(creationCtx);
     787
     788                                    creationCtx.enmSource = SharedClipboardURITransferGetSource(pTransfer);
     789
     790                                    RT_ZERO(creationCtx.Interface);
     791
     792                                    creationCtx.Interface.pfnReadDataHdr    = VBoxClipboardSvcImplURIReadDataHdr;
     793                                    creationCtx.Interface.pfnReadDataChunk  = VBoxClipboardSvcImplURIReadDataChunk;
     794                                    creationCtx.Interface.pfnReadDirectory  = VBoxClipboardSvcImplURIReadDir;
     795                                    creationCtx.Interface.pfnReadFileHdr    = VBoxClipboardSvcImplURIReadFileHdr;
     796                                    creationCtx.Interface.pfnReadFileData   = VBoxClipboardSvcImplURIReadFileData;
     797
     798                                    creationCtx.Interface.pfnWriteDataHdr    = VBoxClipboardSvcImplURIWriteDataHdr;
     799                                    creationCtx.Interface.pfnWriteDataChunk  = VBoxClipboardSvcImplURIWriteDataChunk;
     800                                    creationCtx.Interface.pfnWriteDirectory  = VBoxClipboardSvcImplURIWriteDir;
     801                                    creationCtx.Interface.pfnWriteFileHdr    = VBoxClipboardSvcImplURIWriteFileHdr;
     802                                    creationCtx.Interface.pfnWriteFileData   = VBoxClipboardSvcImplURIWriteFileData;
     803
     804                                    creationCtx.pvUser = pClientData;
     805
     806                                    creationCtx.u.HostService.pArea = pTransfer->pArea;
     807
     808                                    rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx);
     809                                    if (RT_SUCCESS(rc))
     810                                        rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer);
     811                                }
     812
     813                                if (RT_SUCCESS(rc))
     814                                {
     815                                    rc = VBoxClipboardSvcImplURITransferCreate(pClientData, pTransfer);
     816                                }
     817                                else
     818                                {
     819                                    VBoxClipboardSvcImplURITransferDestroy(pClientData, pTransfer);
     820                                    SharedClipboardURITransferDestroy(pTransfer);
     821                                }
    737822                            }
    738823                        }
    739 
    740                         /* Release any other pending read, as we only
    741                          * support one pending read at one time. */
    742                         rc = vboxSvcClipboardCompleteReadData(pClientData, VERR_NO_DATA, 0);
     824                        else
     825                            rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
     826
     827                        if (RT_FAILURE(rc))
     828                            LogRel(("Shared Clipboard: Initializing URI host to guest write transfer failed with %Rrc\n", rc));
     829                    }
     830                    else
     831                    {
     832#endif
     833                        void    *pv;
     834                        uint32_t cb;
     835                        rc = VBoxHGCMParmPtrGet(&paParms[1], &pv, &cb);
    743836                        if (RT_SUCCESS(rc))
    744                             rc = VBoxClipboardSvcImplReadData(pClientData, u32Format, pv, cb, &cbActual);
    745 
    746                         /* Remember our read request until it is completed.
    747                          * See the protocol description above for more
    748                          * information. */
    749                         if (rc == VINF_HGCM_ASYNC_EXECUTE)
    750837                        {
    751                             if (VBoxSvcClipboardLock())
     838                            uint32_t cbActual = 0;
     839
     840                            if (g_pfnExtension)
    752841                            {
    753                                 pClientData->State.asyncRead.callHandle = callHandle;
    754                                 pClientData->State.asyncRead.paParms    = paParms;
    755                                 pClientData->State.fReadPending         = true;
    756                                 fAsynchronousProcessing = true;
    757                                 VBoxSvcClipboardUnlock();
     842                                VBOXCLIPBOARDEXTPARMS parms;
     843                                RT_ZERO(parms);
     844
     845                                parms.u32Format = u32Format;
     846                                parms.u.pvData  = pv;
     847                                parms.cbData    = cb;
     848
     849                                g_fReadingData = true;
     850
     851                                rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_READ, &parms, sizeof (parms));
     852                                LogFlowFunc(("DATA: g_fDelayedAnnouncement = %d, g_u32DelayedFormats = 0x%x\n", g_fDelayedAnnouncement, g_u32DelayedFormats));
     853
     854                                if (g_fDelayedAnnouncement)
     855                                {
     856                                    vboxSvcClipboardReportMsg(g_pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, g_u32DelayedFormats);
     857                                    g_fDelayedAnnouncement = false;
     858                                    g_u32DelayedFormats = 0;
     859                                }
     860
     861                                g_fReadingData = false;
     862
     863                                if (RT_SUCCESS (rc))
     864                                {
     865                                    cbActual = parms.cbData;
     866                                }
    758867                            }
    759                             else
    760                                 rc = VERR_NOT_SUPPORTED;
     868
     869                            /* Release any other pending read, as we only
     870                             * support one pending read at one time. */
     871                            rc = vboxSvcClipboardCompleteReadData(pClientData, VERR_NO_DATA, 0);
     872                            if (RT_SUCCESS(rc))
     873                                rc = VBoxClipboardSvcImplReadData(pClientData, u32Format, pv, cb, &cbActual);
     874
     875                            /* Remember our read request until it is completed.
     876                             * See the protocol description above for more
     877                             * information. */
     878                            if (rc == VINF_HGCM_ASYNC_EXECUTE)
     879                            {
     880                                if (VBoxSvcClipboardLock())
     881                                {
     882                                    pClientData->State.asyncRead.callHandle = callHandle;
     883                                    pClientData->State.asyncRead.cParms     = cParms;
     884                                    pClientData->State.asyncRead.paParms    = paParms;
     885                                    pClientData->State.fReadPending         = true;
     886                                    fAsynchronousProcessing = true;
     887                                    VBoxSvcClipboardUnlock();
     888                                }
     889                                else
     890                                    rc = VERR_NOT_SUPPORTED;
     891                            }
     892                            else if (RT_SUCCESS (rc))
     893                            {
     894                                HGCMSvcSetU32(&paParms[2], cbActual);
     895                            }
    761896                        }
    762                         else if (RT_SUCCESS (rc))
    763                         {
    764                             HGCMSvcSetU32(&paParms[2], cbActual);
    765                         }
     897#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    766898                    }
     899#endif
    767900                }
    768901            }
    … …  
    9861119    return rc;
    9871120}
    988 
    989 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    990 DECLCALLBACK(int) vboxClipboardSvcReadDataHdrCallback(PSHAREDCLIPBOARDPROVIDERCALLBACKDATA pData)
    991 {
    992     LogFlowFuncEnter();
    993 
    994     PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pData->pvUser;
    995 
    996     int rc = vboxSvcClipboardReportMsg(pClientData,
    997                                        VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_READ_DATA_HDR, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
    998     LogFlowFuncLeaveRC(rc);
    999     return rc;
    1000 }
    1001 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    10021121
    10031122#ifndef UNIT_TEST

  • trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

    r79217 r79347  
    251251        , uMaxClipboardAreas(32) /** @todo Make this configurable. */
    252252    {
     253#ifdef DEBUG_andy
     254        uMaxClipboardAreas = ULONG_MAX;
     255#endif
    253256        int rc2 = RTCritSectInit(&CritSect);
    254257        AssertRC(rc2);
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