VirtualBox

Changeset 86908 in vbox


Ignore:
Timestamp:
Nov 18, 2020 10:56:12 AM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
141388
Message:

Shared Clipboard/Transfers: Removed clipboard area handling code. bugref:9437

Location:
trunk
Files:
1 deleted
14 edited

Legend:

Unmodified
Added
Removed

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

    r85121 r86908  
    467467
    468468/**
    469  * Enumeration for specifying a clipboard area object type.
    470  */
    471 typedef enum _SHCLAREAOBJTYPE
    472 {
    473     /** Unknown object type; do not use. */
    474     SHCLAREAOBJTYPE_UNKNOWN = 0,
    475     /** Object is a directory. */
    476     SHCLAREAOBJTYPE_DIR,
    477     /** Object is a file. */
    478     SHCLAREAOBJTYPE_FILE,
    479     /** Object is a symbolic link. */
    480     SHCLAREAOBJTYPE_SYMLINK,
    481     /** The usual 32-bit hack. */
    482     SHCLAREAOBJTYPE_32Bit_Hack = 0x7fffffff
    483 } SHCLAREAOBJTYPE;
    484 
    485 /** Clipboard area ID. A valid area is >= 1.
    486  *  If 0 is specified, the last (most recent) area is meant.
    487  *  Set to UINT32_MAX if not initialized. */
    488 typedef uint32_t SHCLAREAID;
    489 
    490 /** Defines a non-initialized (nil) clipboard area. */
    491 #define NIL_SHCLAREAID       UINT32_MAX
    492 
    493 /** SharedClipboardArea open flags. */
    494 typedef uint32_t SHCLAREAOPENFLAGS;
    495 
    496 /** No clipboard area open flags specified. */
    497 #define SHCLAREA_OPEN_FLAGS_NONE               0
    498 /** The clipboard area must not exist yet. */
    499 #define SHCLAREA_OPEN_FLAGS_MUST_NOT_EXIST     RT_BIT(0)
    500 /** Mask of all valid clipboard area open flags.  */
    501 #define SHCLAREA_OPEN_FLAGS_VALID_MASK         0x1
    502 
    503 /** Defines a clipboard area object state. */
    504 typedef uint32_t SHCLAREAOBJSTATE;
    505 
    506 /** No object state set. */
    507 #define SHCLAREAOBJSTATE_NONE                0
    508 /** The object is considered as being complete (e.g. serialized). */
    509 #define SHCLAREAOBJSTATE_COMPLETE            RT_BIT(0)
    510 
    511 /**
    512  * Lightweight structure to keep a clipboard area object's state.
    513  *
    514  * Note: We don't want to use the ClipboardURIObject class here, as this
    515  *       is too heavy for this purpose.
    516  */
    517 typedef struct _SHCLAREAOBJ
    518 {
    519     SHCLAREAOBJTYPE  enmType;
    520     SHCLAREAOBJSTATE fState;
    521 } SHCLAREAOBJ, *PSHCLAREAOBJ;
    522 
    523 /**
    524  * Class for maintaining a Shared Clipboard area on the host or guest.
    525  *
    526  * This will contain all received files & directories for a single Shared
    527  * Clipboard operation.
    528  *
    529  * In case of a failed Shared Clipboard operation this class can also
    530  * perform a gentle rollback if required.
    531  */
    532 class SharedClipboardArea
    533 {
    534 public:
    535 
    536     SharedClipboardArea(void);
    537     SharedClipboardArea(const char *pszPath, SHCLAREAID uID = NIL_SHCLAREAID,
    538                         SHCLAREAOPENFLAGS fFlags = SHCLAREA_OPEN_FLAGS_NONE);
    539     virtual ~SharedClipboardArea(void);
    540 
    541 public:
    542 
    543     uint32_t AddRef(void);
    544     uint32_t Release(void);
    545 
    546     int Lock(void);
    547     int Unlock(void);
    548 
    549     int AddObject(const char *pszPath, const SHCLAREAOBJ &Obj);
    550     int GetObject(const char *pszPath, PSHCLAREAOBJ pObj);
    551 
    552     int Close(void);
    553     bool IsOpen(void) const;
    554     int OpenEx(const char *pszPath, SHCLAREAID uID = NIL_SHCLAREAID,
    555                SHCLAREAOPENFLAGS fFlags = SHCLAREA_OPEN_FLAGS_NONE);
    556     int OpenTemp(SHCLAREAID uID = NIL_SHCLAREAID,
    557                  SHCLAREAOPENFLAGS fFlags = SHCLAREA_OPEN_FLAGS_NONE);
    558     SHCLAREAID GetID(void) const;
    559     const char *GetDirAbs(void) const;
    560     uint32_t GetRefCount(void);
    561     int Reopen(void);
    562     int Reset(bool fDeleteContent);
    563     int Rollback(void);
    564 
    565 public:
    566 
    567     static int PathConstruct(const char *pszBase, SHCLAREAID uID, char *pszPath, size_t cbPath);
    568 
    569 protected:
    570 
    571     int initInternal(void);
    572     int destroyInternal(void);
    573     int closeInternal(void);
    574 
    575 protected:
    576 
    577     typedef std::map<RTCString, SHCLAREAOBJ> SharedClipboardAreaFsObjMap;
    578 
    579     /** Creation timestamp (in ms). */
    580     uint64_t                     m_tsCreatedMs;
    581     /** Number of references to this instance. */
    582     volatile uint32_t            m_cRefs;
    583     /** Critical section for serializing access. */
    584     RTCRITSECT                   m_CritSect;
    585     /** Open flags. */
    586     uint32_t                     m_fOpen;
    587     /** Directory handle for root clipboard directory. */
    588     RTDIR                        m_hDir;
    589     /** Absolute path to root clipboard directory. */
    590     RTCString                    m_strPathAbs;
    591     /** List for holding created directories in the case of a rollback. */
    592     SharedClipboardAreaFsObjMap  m_mapObj;
    593     /** Associated clipboard area ID. */
    594     SHCLAREAID                   m_uID;
    595 };
    596 
    597 /**
    598469 * Structure for handling a single transfer object context.
    599470 */
    … …  
    862733    /** Map of all objects handles related to this transfer. */
    863734    RTLISTANCHOR             lstObj;
    864     /** The transfer's own (local) area, if any (can be NULL if not needed).
    865      *  The area itself has a clipboard area ID assigned.
    866      *  On the host this area ID gets shared (maintained / locked) across all VMs via VBoxSVC. */
    867     SharedClipboardArea     *pArea;
    868735    /** The transfer's own provider context. */
    869736    SHCLPROVIDERCTX          ProviderCtx;
    … …  
    991858int ShClTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots);
    992859void ShClTransferReset(PSHCLTRANSFER pTransfer);
    993 SharedClipboardArea *ShClTransferGetArea(PSHCLTRANSFER pTransfer);
    994860
    995861uint32_t ShClTransferRootsCount(PSHCLTRANSFER pTransfer);
    … …  
    1025891
    1026892#endif /* !VBOX_INCLUDED_GuestHost_SharedClipboard_transfers_h */
    1027 

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

    r85121 r86908  
    3939#define VBOX_CLIPBOARD_EXT_FN_DATA_READ            (2)
    4040#define VBOX_CLIPBOARD_EXT_FN_DATA_WRITE           (3)
    41 /** Registers a new clipboard area.
    42  *  Uses the SHCLEXTAREAPARMS struct. */
    43 #define VBOX_CLIPBOARD_EXT_FN_AREA_REGISTER        (4)
    44 /** Unregisters an existing clipboard area.
    45  *  Uses the SHCLEXTAREAPARMS struct. */
    46 #define VBOX_CLIPBOARD_EXT_FN_AREA_UNREGISTER      (5)
    47 /** Attaches to an existing clipboard area.
    48  *  Uses the SHCLEXTAREAPARMS struct. */
    49 #define VBOX_CLIPBOARD_EXT_FN_AREA_ATTACH          (6)
    50 /** Detaches from an existing clipboard area.
    51  *  Uses the SHCLEXTAREAPARMS struct. */
    52 #define VBOX_CLIPBOARD_EXT_FN_AREA_DETACH          (7)
    5341
    5442typedef DECLCALLBACKTYPE(int, FNVRDPCLIPBOARDEXTCALLBACK,(uint32_t u32Function, uint32_t u32Format, void *pvData, uint32_t cbData));
    … …  
    6654} SHCLEXTPARMS;
    6755
    68 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    69 typedef uint32_t SHCLEXTAREAREGISTETRFLAGS;
    70 /** No clipboard register area flags specified. */
    71 #define SHCLEXTAREA_REGISTER_FLAGS_NONE        0
    72 
    73 typedef uint32_t SHCLEXTAREAATTACHFLAGS;
    74 /** No clipboard attach area flags specified. */
    75 #define SHCLEXTAREA_ATTACH_FLAGS_NONE          0
    76 
    77 /**
    78  * Structure for keeping clipboard area callback parameters.
    79  */
    80 typedef struct _SHCLEXTAREAPARMS
    81 {
    82     /** The clipboard area's ID the callback is for. */
    83     SHCLAREAID uID;
    84     union
    85     {
    86         struct
    87         {
    88             void                              *pvData;
    89             uint32_t                           cbData;
    90             /** Area register flags; not used yet and must be set to 0. */
    91             SHCLEXTAREAREGISTETRFLAGS fFlags;
    92         } fn_register;
    93         struct
    94         {
    95             /** Area attach flags; not used yet and must be set to 0. */
    96             SHCLEXTAREAATTACHFLAGS    fFlags;
    97         } fn_attach;
    98     } u;
    99 } SHCLEXTAREAPARMS, *PSHCLEXTAREAPARMS;
    100 #endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    101 
    10256#endif /* !VBOX_INCLUDED_HostServices_VBoxClipboardExt_h */

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

    r84540 r86908  
    5757  VBoxTray_DEFS     += VBOX_WITH_SHARED_CLIPBOARD_GUEST
    5858  VBoxTray_SOURCES  += \
    59         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardArea.cpp \
    6059        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp \
    6160        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp \
    … …  
    9897
    9998include $(FILE_KBUILD_SUB_FOOTER)
    100 

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

    r86644 r86908  
    11651165    pTransfer->State.enmSource = SHCLSOURCE_INVALID;
    11661166
    1167     pTransfer->pArea = NULL; /* Will be created later if needed. */
    1168 
    11691167    pTransfer->Thread.hThread    = NIL_RTTHREAD;
    11701168    pTransfer->Thread.fCancelled = false;
    … …  
    21422140
    21432141/**
    2144  * Returns the clipboard area for a Shared Clipboard transfer.
    2145  *
    2146  * @returns Current clipboard area, or NULL if none.
    2147  * @param   pTransfer           Clipboard transfer to return clipboard area for.
    2148  */
    2149 SharedClipboardArea *ShClTransferGetArea(PSHCLTRANSFER pTransfer)
    2150 {
    2151     AssertPtrReturn(pTransfer, NULL);
    2152 
    2153     return pTransfer->pArea;
    2154 }
    2155 
    2156 /**
    21572142 * Returns the number of transfer root list entries.
    21582143 *

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

    r82968 r86908  
    4949        VBoxSharedClipboardSvc-transfers.cpp \
    5050        VBoxSharedClipboardSvc-utils.cpp \
    51         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardArea.cpp \
    5251        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp \
    5352        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp

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

    r86531 r86908  
    389389 * @{
    390390 */
    391 int shClSvcTransferAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer);
    392391int shClSvcTransferHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function,
    393392                           uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);

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

    r84996 r86908  
    7272
    7373    LogFlowFuncEnter();
    74 
    75     const uint32_t cTransfers = ShClTransferCtxGetTotalTransfers(&pClient->TransferCtx);
    76     for (uint32_t i = 0; i < cTransfers; i++)
    77     {
    78         PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(&pClient->TransferCtx, i);
    79         if (pTransfer)
    80             shClSvcTransferAreaDetach(&pClient->State, pTransfer);
    81     }
    8274
    8375    ShClTransferCtxDestroy(&pClient->TransferCtx);
    … …  
    13111303    }
    13121304
    1313     /* A (valid) service extension is needed because VBoxSVC needs to keep track of the
    1314      * clipboard areas cached on the host. */
    1315     if (!g_ExtState.pfnExtension)
    1316     {
    1317 #ifdef DEBUG_andy
    1318         AssertPtr(g_ExtState.pfnExtension);
    1319 #endif
    1320         LogFunc(("Invalid / no service extension set, skipping transfer handling\n"));
    1321         return VERR_NOT_SUPPORTED;
    1322     }
    1323 
    13241305    int rc = VERR_INVALID_PARAMETER; /* Play safe by default. */
    13251306
    … …  
    17551736            break;
    17561737    }
    1757 
    1758     LogFlowFuncLeaveRC(rc);
    1759     return rc;
    1760 }
    1761 
    1762 /**
    1763  * Registers an clipboard transfer area.
    1764  *
    1765  * @returns VBox status code.
    1766  * @param   pClientState        Client state to use.
    1767  * @param   pTransfer           Shared Clipboard transfer to register a clipboard area for.
    1768  */
    1769 int shClSvcTransferAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
    1770 {
    1771     RT_NOREF(pClientState);
    1772 
    1773     LogFlowFuncEnter();
    1774 
    1775     AssertMsgReturn(pTransfer->pArea == NULL, ("An area already is registered for this transfer\n"),
    1776                     VERR_WRONG_ORDER);
    1777 
    1778     pTransfer->pArea = new SharedClipboardArea();
    1779     if (!pTransfer->pArea)
    1780         return VERR_NO_MEMORY;
    1781 
    1782     int rc;
    1783 
    1784     if (g_ExtState.pfnExtension)
    1785     {
    1786         SHCLEXTAREAPARMS parms;
    1787         RT_ZERO(parms);
    1788 
    1789         parms.uID = NIL_SHCLAREAID;
    1790 
    1791         /* As the meta data is now complete, register a new clipboard on the host side. */
    1792         rc = g_ExtState.pfnExtension(g_ExtState.pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_REGISTER, &parms, sizeof(parms));
    1793         if (RT_SUCCESS(rc))
    1794         {
    1795             /* Note: Do *not* specify SHCLAREA_OPEN_FLAGS_MUST_NOT_EXIST as flags here, as VBoxSVC took care of the
    1796              *       clipboard area creation already. */
    1797             rc = pTransfer->pArea->OpenTemp(parms.uID /* Area ID */,
    1798                                             SHCLAREA_OPEN_FLAGS_NONE);
    1799         }
    1800 
    1801         LogFlowFunc(("Registered new clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
    1802                      parms.uID, pClientState->uClientID, rc));
    1803     }
    1804     else
    1805         rc = VERR_NOT_SUPPORTED;
    1806 
    1807     LogFlowFuncLeaveRC(rc);
    1808     return rc;
    1809 }
    1810 
    1811 /**
    1812  * Unregisters an clipboard transfer area.
    1813  *
    1814  * @returns VBox status code.
    1815  * @param   pClientState        Client state to use.
    1816  * @param   pTransfer           Shared Clipboard transfer to unregister a clipboard area from.
    1817  */
    1818 int shClSvcTransferAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
    1819 {
    1820     RT_NOREF(pClientState);
    1821 
    1822     LogFlowFuncEnter();
    1823 
    1824     if (!pTransfer->pArea)
    1825         return VINF_SUCCESS;
    1826 
    1827     int rc = VINF_SUCCESS;
    1828 
    1829     if (g_ExtState.pfnExtension)
    1830     {
    1831         SHCLEXTAREAPARMS parms;
    1832         RT_ZERO(parms);
    1833 
    1834         parms.uID = pTransfer->pArea->GetID();
    1835 
    1836         rc = g_ExtState.pfnExtension(g_ExtState.pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_UNREGISTER, &parms, sizeof(parms));
    1837         if (RT_SUCCESS(rc))
    1838         {
    1839             rc = pTransfer->pArea->Close();
    1840             if (RT_SUCCESS(rc))
    1841             {
    1842                 delete pTransfer->pArea;
    1843                 pTransfer->pArea = NULL;
    1844             }
    1845         }
    1846 
    1847         LogFlowFunc(("Unregistered clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
    1848                      parms.uID, pClientState->uClientID, rc));
    1849     }
    1850 
    1851     delete pTransfer->pArea;
    1852     pTransfer->pArea = NULL;
    1853 
    1854     LogFlowFuncLeaveRC(rc);
    1855     return rc;
    1856 }
    1857 
    1858 /**
    1859  * Attaches to an existing (registered) clipboard transfer area.
    1860  *
    1861  * @returns VBox status code.
    1862  * @param   pClientState        Client state to use.
    1863  * @param   pTransfer           Shared Clipboard transfer to attach a clipboard area to.
    1864  * @param   uID                 ID of clipboard area to to attach to. Specify 0 to attach to the most recent one.
    1865  */
    1866 int shClSvcTransferAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer,
    1867                               SHCLAREAID uID)
    1868 {
    1869     RT_NOREF(pClientState);
    1870 
    1871     LogFlowFuncEnter();
    1872 
    1873     AssertMsgReturn(pTransfer->pArea == NULL, ("An area already is attached to this transfer\n"),
    1874                     VERR_WRONG_ORDER);
    1875 
    1876     pTransfer->pArea = new SharedClipboardArea();
    1877     if (!pTransfer->pArea)
    1878         return VERR_NO_MEMORY;
    1879 
    1880     int rc = VINF_SUCCESS;
    1881 
    1882     if (g_ExtState.pfnExtension)
    1883     {
    1884         SHCLEXTAREAPARMS parms;
    1885         RT_ZERO(parms);
    1886 
    1887         parms.uID = uID; /* 0 means most recent clipboard area. */
    1888 
    1889         /* The client now needs to attach to the most recent clipboard area
    1890          * to keep a reference to it. The host does the actual book keeping / cleanup then.
    1891          *
    1892          * This might fail if the host does not have a most recent clipboard area (yet). */
    1893         rc = g_ExtState.pfnExtension(g_ExtState.pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_ATTACH, &parms, sizeof(parms));
    1894         if (RT_SUCCESS(rc))
    1895             rc = pTransfer->pArea->OpenTemp(parms.uID /* Area ID */);
    1896 
    1897         LogFlowFunc(("Attached client %RU32 to clipboard area %RU32 with rc=%Rrc\n",
    1898                      pClientState->uClientID, parms.uID, rc));
    1899     }
    1900     else
    1901         rc = VERR_NOT_SUPPORTED;
    1902 
    1903     LogFlowFuncLeaveRC(rc);
    1904     return rc;
    1905 }
    1906 
    1907 /**
    1908  * Detaches from an clipboard transfer area.
    1909  *
    1910  * @returns VBox status code.
    1911  * @param   pClientState        Client state to use.
    1912  * @param   pTransfer           Shared Clipboard transfer to detach a clipboard area from.
    1913  */
    1914 int shClSvcTransferAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
    1915 {
    1916     RT_NOREF(pClientState);
    1917 
    1918     LogFlowFuncEnter();
    1919 
    1920     if (!pTransfer->pArea)
    1921         return VINF_SUCCESS;
    1922 
    1923     const uint32_t uAreaID = pTransfer->pArea->GetID();
    1924 
    1925     int rc = VINF_SUCCESS;
    1926 
    1927     if (g_ExtState.pfnExtension)
    1928     {
    1929         SHCLEXTAREAPARMS parms;
    1930         RT_ZERO(parms);
    1931         parms.uID = uAreaID;
    1932 
    1933         rc = g_ExtState.pfnExtension(g_ExtState.pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_DETACH, &parms, sizeof(parms));
    1934 
    1935         LogFlowFunc(("Detached client %RU32 from clipboard area %RU32 with rc=%Rrc\n",
    1936                      pClientState->uClientID, uAreaID, rc));
    1937     }
    1938 
    1939     delete pTransfer->pArea;
    1940     pTransfer->pArea = NULL;
    19411738
    19421739    LogFlowFuncLeaveRC(rc);
    … …  
    20411838                if (enmDir == SHCLTRANSFERDIR_FROM_REMOTE)
    20421839                {
    2043                     rc = shClSvcTransferAreaRegister(&pClient->State, pTransfer);
    2044                     if (RT_SUCCESS(rc))
    2045                     {
    2046                         creationCtx.Interface.pfnTransferOpen  = shClSvcTransferIfaceOpen;
    2047                         creationCtx.Interface.pfnTransferClose = shClSvcTransferIfaceClose;
    2048 
    2049                         creationCtx.Interface.pfnRootsGet      = shClSvcTransferIfaceGetRoots;
    2050 
    2051                         creationCtx.Interface.pfnListOpen      = shClSvcTransferIfaceListOpen;
    2052                         creationCtx.Interface.pfnListClose     = shClSvcTransferIfaceListClose;
    2053                         creationCtx.Interface.pfnListHdrRead   = shClSvcTransferIfaceListHdrRead;
    2054                         creationCtx.Interface.pfnListEntryRead = shClSvcTransferIfaceListEntryRead;
    2055 
    2056                         creationCtx.Interface.pfnObjOpen       = shClSvcTransferIfaceObjOpen;
    2057                         creationCtx.Interface.pfnObjClose      = shClSvcTransferIfaceObjClose;
    2058                         creationCtx.Interface.pfnObjRead       = shClSvcTransferIfaceObjRead;
    2059                     }
     1840                    creationCtx.Interface.pfnTransferOpen  = shClSvcTransferIfaceOpen;
     1841                    creationCtx.Interface.pfnTransferClose = shClSvcTransferIfaceClose;
     1842
     1843                    creationCtx.Interface.pfnRootsGet      = shClSvcTransferIfaceGetRoots;
     1844
     1845                    creationCtx.Interface.pfnListOpen      = shClSvcTransferIfaceListOpen;
     1846                    creationCtx.Interface.pfnListClose     = shClSvcTransferIfaceListClose;
     1847                    creationCtx.Interface.pfnListHdrRead   = shClSvcTransferIfaceListHdrRead;
     1848                    creationCtx.Interface.pfnListEntryRead = shClSvcTransferIfaceListEntryRead;
     1849
     1850                    creationCtx.Interface.pfnObjOpen       = shClSvcTransferIfaceObjOpen;
     1851                    creationCtx.Interface.pfnObjClose      = shClSvcTransferIfaceObjClose;
     1852                    creationCtx.Interface.pfnObjRead       = shClSvcTransferIfaceObjRead;
    20601853                }
    20611854                else if (enmDir == SHCLTRANSFERDIR_TO_REMOTE)

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

    r86362 r86908  
    3939  tstClipboardServiceHost_SOURCES += \
    4040        ../VBoxSharedClipboardSvc-transfers.cpp \
    41         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp \
    42         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardArea.cpp
     41        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp
    4342 endif
    4443

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

    r86753 r86908  
    726726endif
    727727
    728 ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    729  VBoxSVC_SOURCES += $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardArea.cpp
    730 endif
    731 
    732728$(call KB_FN_DO_PASS0_ON_TARGET,VBoxSVC) # Sets VBoxSVC_0_OUTDIR
    733729

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r86752 r86908  
    49284928  <interface
    49294929    name="IInternalMachineControl" extends="$unknown"
    4930     uuid="0075FD6C-00C2-4484-0077-C057003D9C90"
     4930    uuid="EA05E40C-CB31-423B-B3B7-A5B19300F40C"
    49314931    internal="yes"
    49324932    wsmap="suppress"
    … …  
    51275127          The flags of the properties returned. The array entries match the
    51285128          corresponding entries in the @a name array.
    5129         </desc>
    5130       </param>
    5131     </method>
    5132     <method name="clipboardAreaRegister">
    5133       <desc>
    5134         Registers a new clipboard area.
    5135       </desc>
    5136       <param name="parms" type="wstring" dir="in" safearray="yes">
    5137         <desc>
    5138           Registration parameters. Currently not used and therefore ignored.
    5139         </desc>
    5140       </param>
    5141       <param name="id" type="unsigned long" dir="out">
    5142         <desc>
    5143           Returns the new clipboard area which got registered.
    5144         </desc>
    5145       </param>
    5146     </method>
    5147     <method name="clipboardAreaUnregister">
    5148       <desc>
    5149         Unregisters a formerly registered clipboard area.
    5150       </desc>
    5151       <param name="id" type="unsigned long" dir="in">
    5152         <desc>
    5153           Clipboard area to unregister.
    5154         </desc>
    5155       </param>
    5156     </method>
    5157     <method name="clipboardAreaAttach">
    5158       <desc>
    5159         Attaches to a registered clipboard area.
    5160       </desc>
    5161       <param name="id" type="unsigned long" dir="in">
    5162         <desc>
    5163           Clipboard area to attach to.
    5164         </desc>
    5165       </param>
    5166     </method>
    5167     <method name="clipboardAreaDetach">
    5168       <desc>
    5169         Detaches from a registered clipboard area.
    5170       </desc>
    5171       <param name="id" type="unsigned long" dir="in">
    5172         <desc>
    5173           Clipboard area to detach from.
    5174         </desc>
    5175       </param>
    5176     </method>
    5177     <method name="clipboardAreaGetMostRecent">
    5178       <desc>
    5179         Returns the most recent (last registered) clipboard area.
    5180       </desc>
    5181       <param name="id" type="unsigned long" dir="out">
    5182         <desc>
    5183           Returns the most recent clipboard area.
    5184         </desc>
    5185       </param>
    5186     </method>
    5187     <method name="clipboardAreaGetRefCount">
    5188       <desc>
    5189         Returns the current reference count of a clipboard area.
    5190       </desc>
    5191       <param name="id" type="unsigned long" dir="in">
    5192         <desc>
    5193           Clipboard area to return reference count for.
    5194         </desc>
    5195       </param>
    5196       <param name="refcount" type="unsigned long" dir="out">
    5197         <desc>
    5198           Returns the current reference count.
    51995129        </desc>
    52005130      </param>

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

    r85769 r86908  
    12151215                         ComPtr<IProgress> &aProgress);
    12161216    HRESULT finishOnlineMergeMedium();
    1217     HRESULT clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID);
    1218     HRESULT clipboardAreaUnregister(ULONG aID);
    1219     HRESULT clipboardAreaAttach(ULONG aID);
    1220     HRESULT clipboardAreaDetach(ULONG aID);
    1221     HRESULT clipboardAreaGetMostRecent(ULONG *aID);
    1222     HRESULT clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount);
    12231217    HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
    12241218                                std::vector<com::Utf8Str> &aValues,
    … …  
    13771371                         ComPtr<IProgress> &aProgress);
    13781372    HRESULT finishOnlineMergeMedium();
    1379     HRESULT clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID);
    1380     HRESULT clipboardAreaUnregister(ULONG aID);
    1381     HRESULT clipboardAreaAttach(ULONG aID);
    1382     HRESULT clipboardAreaDetach(ULONG aID);
    1383     HRESULT clipboardAreaGetMostRecent(ULONG *aID);
    1384     HRESULT clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount);
    13851373    HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
    13861374                                std::vector<com::Utf8Str> &aValues,

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

    r86501 r86908  
    7575#endif
    7676
    77 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    78 struct SharedClipboardAreaData;
    79 #endif
    80 
    8177class ATL_NO_VTABLE VirtualBox :
    8278    public VirtualBoxWrap
    … …  
    178174    void i_onSnapshotRestored(const Guid &aMachineId, const Guid &aSnapshotId);
    179175    void i_onSnapshotChanged(const Guid &aMachineId, const Guid &aSnapshotId);
    180 
    181 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    182     int i_clipboardAreaCreate(ULONG uAreaID, uint32_t fFlags, SharedClipboardAreaData **ppAreaData);
    183     int i_clipboardAreaDestroy(SharedClipboardAreaData *pAreaData);
    184 
    185     HRESULT i_onClipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID);
    186     HRESULT i_onClipboardAreaUnregister(ULONG aID);
    187     HRESULT i_onClipboardAreaAttach(ULONG aID);
    188     HRESULT i_onClipboardAreaDetach(ULONG aID);
    189     ULONG i_onClipboardAreaGetMostRecent(void);
    190     ULONG i_onClipboardAreaGetRefCount(ULONG aID);
    191 #endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    192176
    193177    void i_onGuestPropertyChanged(const Guid &aMachineId, const Utf8Str &aName, const Utf8Str &aValue, const Utf8Str &aFlags);

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

    r86498 r86908  
    1337613376}
    1337713377
    13378 HRESULT SessionMachine::clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID)
    13379 {
    13380 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13381     ULONG uID;
    13382     int rc = mParent->i_onClipboardAreaRegister(aParms, &uID);
    13383     if (RT_SUCCESS(rc))
    13384     {
    13385         if (aID)
    13386             *aID = uID;
    13387         return S_OK;
    13388     }
    13389     return E_FAIL;
    13390 #else
    13391     RT_NOREF(aParms, aID);
    13392     ReturnComNotImplemented();
    13393 #endif
    13394 }
    13395 
    13396 HRESULT SessionMachine::clipboardAreaUnregister(ULONG aID)
    13397 {
    13398 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13399     return mParent->i_onClipboardAreaUnregister(aID);
    13400 #else
    13401     RT_NOREF(aID);
    13402     ReturnComNotImplemented();
    13403 #endif
    13404 }
    13405 
    13406 HRESULT SessionMachine::clipboardAreaAttach(ULONG aID)
    13407 {
    13408 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13409     return mParent->i_onClipboardAreaAttach(aID);
    13410 #else
    13411     RT_NOREF(aID);
    13412     ReturnComNotImplemented();
    13413 #endif
    13414 }
    13415 HRESULT SessionMachine::clipboardAreaDetach(ULONG aID)
    13416 {
    13417 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13418     return mParent->i_onClipboardAreaDetach(aID);
    13419 #else
    13420     RT_NOREF(aID);
    13421     ReturnComNotImplemented();
    13422 #endif
    13423 }
    13424 
    13425 HRESULT SessionMachine::clipboardAreaGetMostRecent(ULONG *aID)
    13426 {
    13427 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13428     ULONG uID = mParent->i_onClipboardAreaGetMostRecent();
    13429     if (aID)
    13430         *aID = uID;
    13431     return S_OK;
    13432 #else
    13433     RT_NOREF(aID);
    13434     ReturnComNotImplemented();
    13435 #endif
    13436 }
    13437 
    13438 HRESULT SessionMachine::clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount)
    13439 {
    13440 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13441     ULONG uRefCount = mParent->i_onClipboardAreaGetRefCount(aID);
    13442     if (aRefCount)
    13443         *aRefCount = uRefCount;
    13444     return S_OK;
    13445 #else
    13446     RT_NOREF(aID, aRefCount);
    13447     ReturnComNotImplemented();
    13448 #endif
    13449 }
    13450 
    1345113378HRESULT SessionMachine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
    1345213379                                            std::vector<com::Utf8Str> &aValues,
    … …  
    1495614883}
    1495714884
    14958 HRESULT Machine::clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID)
    14959 {
    14960     RT_NOREF(aParms, aID);
    14961     ReturnComNotImplemented();
    14962 }
    14963 
    14964 HRESULT Machine::clipboardAreaUnregister(ULONG aID)
    14965 {
    14966     RT_NOREF(aID);
    14967     ReturnComNotImplemented();
    14968 }
    14969 
    14970 HRESULT Machine::clipboardAreaAttach(ULONG aID)
    14971 {
    14972     RT_NOREF(aID);
    14973     ReturnComNotImplemented();
    14974 }
    14975 HRESULT Machine::clipboardAreaDetach(ULONG aID)
    14976 {
    14977     RT_NOREF(aID);
    14978     ReturnComNotImplemented();
    14979 }
    14980 
    14981 HRESULT Machine::clipboardAreaGetMostRecent(ULONG *aID)
    14982 {
    14983     RT_NOREF(aID);
    14984     ReturnComNotImplemented();
    14985 }
    14986 
    14987 HRESULT Machine::clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount)
    14988 {
    14989     RT_NOREF(aID, aRefCount);
    14990     ReturnComNotImplemented();
    14991 }
    14992 
    1499314885HRESULT Machine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
    1499414886                                     std::vector<com::Utf8Str> &aValues,

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

    r86521 r86908  
    262262typedef std::map<Guid, ComObjPtr<Medium> > HardDiskMap;
    263263
    264 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    265 /**
    266  * Structure for keeping Shared Clipboard area data within the VirtualBox object.
    267  */
    268 struct SharedClipboardAreaData
    269 {
    270     SharedClipboardAreaData()
    271         : uID(NIL_SHCLAREAID) { }
    272 
    273     /** The area's (unique) ID.
    274      *  Set to NIL_SHCLAREAID if not initialized yet. */
    275     ULONG               uID;
    276     /** The actual Shared Clipboard area assigned to this ID. */
    277     SharedClipboardArea Area;
    278 };
    279 
    280 /** Map of Shared Clipboard areas. The key defines the area ID. */
    281 typedef std::map<ULONG, SharedClipboardAreaData *> SharedClipboardAreaMap;
    282 
    283 /**
    284  * Structure for keeping global Shared Clipboard data within the VirtualBox object.
    285  */
    286 struct SharedClipboardData
    287 {
    288     SharedClipboardData()
    289         : uMostRecentClipboardAreaID(NIL_SHCLAREAID)
    290         , uMaxClipboardAreas(32) /** @todo Make this configurable. */
    291     {
    292 #ifdef DEBUG_andy
    293         uMaxClipboardAreas = 9999;
    294 #endif
    295         int rc2 = RTCritSectInit(&CritSect);
    296         AssertRC(rc2);
    297     }
    298 
    299     virtual ~SharedClipboardData()
    300     {
    301         RTCritSectDelete(&CritSect);
    302     }
    303 
    304     /**
    305      * Generates a new clipboard area ID.
    306      * Currently does *not* check for collisions and stuff.
    307      *
    308      * @returns New clipboard area ID.
    309      */
    310     ULONG GenerateAreaID(void)
    311     {
    312         ULONG uID = NIL_SHCLAREAID;
    313 
    314         int rc = RTCritSectEnter(&CritSect);
    315         if (RT_SUCCESS(rc))
    316         {
    317             uID = RTRandU32Ex(1, UINT32_MAX - 1); /** @todo Make this a bit more sophisticated. Later. */
    318 
    319             int rc2 = RTCritSectLeave(&CritSect);
    320             AssertRC(rc2);
    321         }
    322 
    323         LogFlowFunc(("uID=%RU32\n", uID));
    324         return uID;
    325     }
    326 
    327     /** Critical section to serialize access. */
    328     RTCRITSECT                          CritSect;
    329     /** The most recent (last created) clipboard area ID.
    330      *  NIL_SHCLAREAID if not initialized yet. */
    331     ULONG                               uMostRecentClipboardAreaID;
    332     /** Maximum of concurrent clipboard areas.
    333      *  @todo Make this configurable. */
    334     ULONG                               uMaxClipboardAreas;
    335     /** Map of clipboard areas. The key is the area ID. */
    336     SharedClipboardAreaMap              mapClipboardAreas;
    337 };
    338 #endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    339 
    340264/**
    341265 *  Main VirtualBox data structure.
    … …  
    492416    bool                                fWatcherIsReliable;
    493417#endif
    494 
    495 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    496     /** Data related to Shared Clipboard handling. */
    497     SharedClipboardData                 SharedClipboard;
    498 #endif
    499418};
    500419
    … …  
    11291048        unconst(m->ptrExtPackManager).setNull();
    11301049    }
    1131 #endif
    1132 
    1133 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1134     LogFlowThisFunc(("Destroying Shared Clipboard areas...\n"));
    1135     SharedClipboardAreaMap::iterator itArea = m->SharedClipboard.mapClipboardAreas.begin();
    1136     while (itArea != m->SharedClipboard.mapClipboardAreas.end())
    1137     {
    1138         i_clipboardAreaDestroy(itArea->second);
    1139         ++itArea;
    1140     }
    1141     m->SharedClipboard.mapClipboardAreas.clear();
    11421050#endif
    11431051
    … …  
    34453353}
    34463354
    3447 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS /** @todo r=bird: Why is this still here?  */
    3448 
    3449 /**
    3450  * Generates a new clipboard area on the host by opening (and locking) a new, temporary directory.
    3451  *
    3452  * @returns VBox status code.
    3453  * @param   uAreaID             Clipboard area ID to use for creation.
    3454  * @param   fFlags              Additional creation flags; currently unused and ignored.
    3455  * @param   ppAreaData          Where to return the created clipboard area on success.
    3456  */
    3457 int VirtualBox::i_clipboardAreaCreate(ULONG uAreaID, uint32_t fFlags, SharedClipboardAreaData **ppAreaData)
    3458 {
    3459     RT_NOREF(fFlags);
    3460 
    3461     int vrc;
    3462 
    3463     SharedClipboardAreaData *pAreaData = new SharedClipboardAreaData();
    3464     if (pAreaData)
    3465     {
    3466         vrc = pAreaData->Area.OpenTemp(uAreaID, SHCLAREA_OPEN_FLAGS_MUST_NOT_EXIST);
    3467         if (RT_SUCCESS(vrc))
    3468         {
    3469             pAreaData->uID = uAreaID;
    3470 
    3471             *ppAreaData = pAreaData;
    3472         }
    3473     }
    3474     else
    3475         vrc = VERR_NO_MEMORY;
    3476 
    3477     LogFlowFunc(("uID=%RU32, rc=%Rrc\n", uAreaID, vrc));
    3478     return vrc;
    3479 }
    3480 
    3481 /**
    3482  * Destroys a formerly created clipboard area.
    3483  *
    3484  * @returns VBox status code.
    3485  * @param   pAreaData           Area data to destroy. The pointer will be invalid on successful return.
    3486  */
    3487 int VirtualBox::i_clipboardAreaDestroy(SharedClipboardAreaData *pAreaData)
    3488 {
    3489     if (!pAreaData)
    3490         return VINF_SUCCESS;
    3491 
    3492     /** @todo Do we need a worker for this to not block here for too long?
    3493      *        This could take a while to clean up huge areas ... */
    3494     int vrc = pAreaData->Area.Close();
    3495     if (RT_SUCCESS(vrc))
    3496     {
    3497         delete pAreaData;
    3498         pAreaData = NULL;
    3499     }
    3500 
    3501     LogFlowFunc(("uID=%RU32, rc=%Rrc\n", pAreaData->uID, vrc));
    3502     return vrc;
    3503 }
    3504 
    3505 /**
    3506  * Registers and creates a new clipboard area on the host (for all VMs), returned the clipboard area ID for it.
    3507  *
    3508  * @returns HRESULT
    3509  * @param   aParms              Creation parameters. Currently unused.
    3510  * @param   aID                 Where to return the clipboard area ID on success.
    3511  */
    3512 HRESULT VirtualBox::i_onClipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID)
    3513 {
    3514     RT_NOREF(aParms);
    3515 
    3516     HRESULT rc = S_OK;
    3517 
    3518     int vrc = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3519     if (RT_SUCCESS(vrc))
    3520     {
    3521         try
    3522         {
    3523             if (m->SharedClipboard.mapClipboardAreas.size() < m->SharedClipboard.uMaxClipboardAreas)
    3524             {
    3525                 for (unsigned uTries = 0; uTries < 32; uTries++) /* Don't try too hard. */
    3526                 {
    3527                     const ULONG uAreaID = m->SharedClipboard.GenerateAreaID();
    3528 
    3529                     /* Area ID already taken? */
    3530                     if (m->SharedClipboard.mapClipboardAreas.find(uAreaID) != m->SharedClipboard.mapClipboardAreas.end())
    3531                         continue;
    3532 
    3533                     SharedClipboardAreaData *pAreaData;
    3534                     vrc = i_clipboardAreaCreate(uAreaID, 0 /* fFlags */, &pAreaData);
    3535                     if (RT_SUCCESS(vrc))
    3536                     {
    3537                         m->SharedClipboard.mapClipboardAreas[uAreaID] = pAreaData;
    3538                         m->SharedClipboard.uMostRecentClipboardAreaID = uAreaID;
    3539 
    3540                         /** @todo Implement collision detection / wrap-around. */
    3541 
    3542                         if (aID)
    3543                             *aID = uAreaID;
    3544 
    3545                         LogThisFunc(("Registered new clipboard area %RU32: '%s'\n",
    3546                                      uAreaID, pAreaData->Area.GetDirAbs()));
    3547                         break;
    3548                     }
    3549                 }
    3550 
    3551                 if (RT_FAILURE(vrc))
    3552                     rc = setError(E_FAIL, /** @todo Find a better rc. */
    3553                                   tr("Failed to create new clipboard area (%Rrc)"), vrc);
    3554             }
    3555             else
    3556             {
    3557                 rc = setError(E_FAIL, /** @todo Find a better rc. */
    3558                               tr("Maximum number of concurrent clipboard areas reached (%RU32)"),
    3559                               m->SharedClipboard.uMaxClipboardAreas);
    3560             }
    3561         }
    3562         catch (std::bad_alloc &ba)
    3563         {
    3564             vrc = VERR_NO_MEMORY;
    3565             RT_NOREF(ba);
    3566         }
    3567 
    3568         RTCritSectLeave(&m->SharedClipboard.CritSect);
    3569     }
    3570     LogFlowThisFunc(("rc=%Rhrc\n", rc));
    3571     return rc;
    3572 }
    3573 
    3574 /**
    3575  * Unregisters (destroys) a formerly created clipboard area.
    3576  *
    3577  * @returns HRESULT
    3578  * @param   aID                 ID of clipboard area to destroy.
    3579  */
    3580 HRESULT VirtualBox::i_onClipboardAreaUnregister(ULONG aID)
    3581 {
    3582     HRESULT rc = S_OK;
    3583 
    3584     int vrc = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3585     if (RT_SUCCESS(vrc))
    3586     {
    3587         SharedClipboardAreaMap::iterator itArea = m->SharedClipboard.mapClipboardAreas.find(aID);
    3588         if (itArea != m->SharedClipboard.mapClipboardAreas.end())
    3589         {
    3590             if (itArea->second->Area.GetRefCount() == 0)
    3591             {
    3592                 vrc = i_clipboardAreaDestroy(itArea->second);
    3593                 if (RT_SUCCESS(vrc))
    3594                 {
    3595                     m->SharedClipboard.mapClipboardAreas.erase(itArea);
    3596                 }
    3597             }
    3598             else
    3599                 rc = setError(E_ACCESSDENIED, /** @todo Find a better rc. */
    3600                               tr("Area with ID %RU32 still in used, cannot unregister"), aID);
    3601         }
    3602         else
    3603             rc = setError(VBOX_E_OBJECT_NOT_FOUND, /** @todo Find a better rc. */
    3604                           tr("Could not find a registered clipboard area with ID %RU32"), aID);
    3605 
    3606         int vrc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    3607         AssertRC(vrc2);
    3608     }
    3609     LogFlowThisFunc(("aID=%RU32, rc=%Rhrc\n", aID, rc));
    3610     return rc;
    3611 }
    3612 
    3613 /**
    3614  * Attaches to an existing clipboard area.
    3615  *
    3616  * @returns HRESULT
    3617  * @param   aID                 ID of clipboard area to attach.
    3618  */
    3619 HRESULT VirtualBox::i_onClipboardAreaAttach(ULONG aID)
    3620 {
    3621     HRESULT rc = S_OK;
    3622 
    3623     int vrc = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3624     if (RT_SUCCESS(vrc))
    3625     {
    3626         SharedClipboardAreaMap::iterator itArea = m->SharedClipboard.mapClipboardAreas.find(aID);
    3627         if (itArea != m->SharedClipboard.mapClipboardAreas.end())
    3628         {
    3629             const uint32_t cRefs = itArea->second->Area.AddRef();
    3630             RT_NOREF(cRefs);
    3631             LogFlowThisFunc(("aID=%RU32 -> cRefs=%RU32\n", aID, cRefs));
    3632             vrc = VINF_SUCCESS;
    3633         }
    3634         else
    3635             rc = setError(VBOX_E_OBJECT_NOT_FOUND, /** @todo Find a better rc. */
    3636                           tr("Could not find a registered clipboard area with ID %RU32"), aID);
    3637 
    3638         int vrc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    3639         AssertRC(vrc2);
    3640     }
    3641     LogFlowThisFunc(("aID=%RU32, rc=%Rhrc\n", aID, rc));
    3642     return rc;
    3643 }
    3644 
    3645 /**
    3646  * Detaches from an existing clipboard area.
    3647  *
    3648  * @returns HRESULT
    3649  * @param   aID                 ID of clipboard area to detach from.
    3650  */
    3651 HRESULT VirtualBox::i_onClipboardAreaDetach(ULONG aID)
    3652 {
    3653     HRESULT rc = S_OK;
    3654 
    3655     int vrc = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3656     if (RT_SUCCESS(vrc))
    3657     {
    3658         SharedClipboardAreaMap::iterator itArea = m->SharedClipboard.mapClipboardAreas.find(aID);
    3659         if (itArea != m->SharedClipboard.mapClipboardAreas.end())
    3660         {
    3661             const uint32_t cRefs = itArea->second->Area.Release();
    3662             RT_NOREF(cRefs);
    3663             LogFlowThisFunc(("aID=%RU32 -> cRefs=%RU32\n", aID, cRefs));
    3664             vrc = VINF_SUCCESS;
    3665         }
    3666         else
    3667             rc = setError(VBOX_E_OBJECT_NOT_FOUND, /** @todo Find a better rc. */
    3668                           tr("Could not find a registered clipboard area with ID %RU32"), aID);
    3669 
    3670         int rc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    3671         AssertRC(rc2);
    3672     }
    3673     LogFlowThisFunc(("aID=%RU32, rc=%Rhrc\n", aID, rc));
    3674     return rc;
    3675 }
    3676 
    3677 /**
    3678  * Returns the ID of the most recent (last created) clipboard area,
    3679  * or NIL_SHCLAREAID if no clipboard area has been created yet.
    3680  *
    3681  * @returns Most recent clipboard area ID.
    3682  */
    3683 ULONG VirtualBox::i_onClipboardAreaGetMostRecent(void)
    3684 {
    3685     ULONG aID = 0;
    3686     int vrc2 = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3687     if (RT_SUCCESS(vrc2))
    3688     {
    3689         aID = m->SharedClipboard.uMostRecentClipboardAreaID;
    3690 
    3691         vrc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    3692         AssertRC(vrc2);
    3693     }
    3694     LogFlowThisFunc(("aID=%RU32\n", aID));
    3695     return aID;
    3696 }
    3697 
    3698 /**
    3699  * Returns the current reference count of a clipboard area.
    3700  *
    3701  * @returns Reference count of given clipboard area ID.
    3702  */
    3703 ULONG VirtualBox::i_onClipboardAreaGetRefCount(ULONG aID)
    3704 {
    3705     ULONG cRefCount = 0;
    3706     int rc2 = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3707     if (RT_SUCCESS(rc2))
    3708     {
    3709         SharedClipboardAreaMap::iterator itArea = m->SharedClipboard.mapClipboardAreas.find(aID);
    3710         if (itArea != m->SharedClipboard.mapClipboardAreas.end())
    3711         {
    3712             cRefCount = itArea->second->Area.GetRefCount();
    3713         }
    3714 
    3715         rc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    3716         AssertRC(rc2);
    3717     }
    3718     LogFlowThisFunc(("aID=%RU32, cRefCount=%RU32\n", aID, cRefCount));
    3719     return cRefCount;
    3720 }
    3721 
    3722 #endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    3723 
    37243355/**
    37253356 *  @note Doesn't lock any object.
Note: See TracChangeset for help on using the changeset viewer.

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