VirtualBox

Changeset 78950 in vbox for trunk


Ignore:
Timestamp:
Jun 4, 2019 7:26:56 AM (6 years ago)
Author:
vboxsync
Message:

Shared Clipboard/URI: Update; more work on clipboard area code, documentation.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r78942 r78950  
    4848#define NIL_SHAREDCLIPBOARDAREAID       UINT32_MAX
    4949
    50 /** SharedClipboardArea flags. */
    51 typedef uint32_t SHAREDCLIPBOARDAREAFLAGS;
    52 
    53 /** No flags specified. */
    54 #define SHAREDCLIPBOARDAREA_FLAGS_NONE     0
     50/** SharedClipboardArea open flags. */
     51typedef uint32_t SHAREDCLIPBOARDAREAOPENFLAGS;
     52
     53/** No open flags specified. */
     54#define SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE               0
     55/** The clipboard area must not exist yet. */
     56#define SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST     RT_BIT(0)
    5557
    5658/**
    … …  
    6870    SharedClipboardArea(void);
    6971    SharedClipboardArea(const char *pszPath, SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
    70                         SHAREDCLIPBOARDAREAFLAGS fFlags = SHAREDCLIPBOARDAREA_FLAGS_NONE);
     72                        SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
    7173    virtual ~SharedClipboardArea(void);
    7274
    … …  
    8486    bool IsOpen(void) const;
    8587    int OpenEx(const char *pszPath, SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
    86                SHAREDCLIPBOARDAREAFLAGS fFlags = SHAREDCLIPBOARDAREA_FLAGS_NONE);
     88               SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
    8789    int OpenTemp(SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID,
    88                  SHAREDCLIPBOARDAREAFLAGS fFlags = SHAREDCLIPBOARDAREA_FLAGS_NONE);
     90                 SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
    8991    SHAREDCLIPBOARDAREAID GetID(void) const;
    9092    const char *GetDirAbs(void) const;

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

    r78942 r78950  
    4747SharedClipboardArea::SharedClipboardArea(const char *pszPath,
    4848                                         SHAREDCLIPBOARDAREAID uID /* = NIL_SHAREDCLIPBOARDAREAID */,
    49                                          SHAREDCLIPBOARDAREAFLAGS fFlags /* = SHAREDCLIPBOARDAREA_FLAGS_NONE */)
     49                                         SHAREDCLIPBOARDAREAOPENFLAGS fFlags /* = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE */)
    5050    : m_tsCreatedMs(0)
    5151    , m_cRefs(0)
    … …  
    158158    if (RT_SUCCESS(rc))
    159159    {
    160         this->m_fOpen = SHAREDCLIPBOARDAREA_FLAGS_NONE;
     160        this->m_fOpen = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE;
    161161        this->m_uID   = NIL_SHAREDCLIPBOARDAREAID;
    162162    }
    … …  
    238238int SharedClipboardArea::OpenEx(const char *pszPath,
    239239                                SHAREDCLIPBOARDAREAID uID /* = NIL_SHAREDCLIPBOARDAREAID */,
    240                                 SHAREDCLIPBOARDAREAFLAGS fFlags /* = SHAREDCLIPBOARDAREA_FLAGS_NONE */)
     240                                SHAREDCLIPBOARDAREAOPENFLAGS fFlags /* = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE */)
    241241{
    242242    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
    … …  
    247247    if (RT_SUCCESS(rc))
    248248    {
    249         if (!RTDirExists(szAreaDir))
    250             rc = RTDirCreateFullPath(szAreaDir, RTFS_UNIX_IRWXU);
     249        if (   RTDirExists(szAreaDir)
     250            && (fFlags & SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST))
     251        {
     252            rc = VERR_ALREADY_EXISTS;
     253        }
     254        else
     255            rc = RTDirCreateFullPath(szAreaDir, RTFS_UNIX_IRWXU); /** @todo Tweak path mode? */
    251256
    252257        if (RT_SUCCESS(rc))
    … …  
    270275
    271276int SharedClipboardArea::OpenTemp(SHAREDCLIPBOARDAREAID uID,
    272                                   SHAREDCLIPBOARDAREAFLAGS fFlags /* = SHAREDCLIPBOARDAREA_FLAGS_NONE */)
     277                                  SHAREDCLIPBOARDAREAOPENFLAGS fFlags /* = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE */)
    273278{
    274279    AssertReturn(fFlags == 0, VERR_INVALID_PARAMETER); /* Flags not supported yet. */

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

    r78942 r78950  
    114114    AssertPtrReturn(pState,    VERR_INVALID_POINTER);
    115115
    116     int rc = pTransfer->Area.OpenTemp(SHAREDCLIPBOARDAREA_FLAGS_NONE);
     116    int rc = SharedClipboardMetaDataInit(&pTransfer->Meta);
    117117    if (RT_SUCCESS(rc))
    118118    {
    119         rc = SharedClipboardMetaDataInit(&pTransfer->Meta);
     119        vboxClipboardSvcURIObjCtxInit(&pTransfer->ObjCtx);
    120120        if (RT_SUCCESS(rc))
    121121        {
    122             vboxClipboardSvcURIObjCtxInit(&pTransfer->ObjCtx);
    123             if (RT_SUCCESS(rc))
    124             {
    125                 pTransfer->pState = pState;
    126             }
     122            pTransfer->pState = pState;
    127123        }
    128124    }
    … …  
    472468                            RT_ZERO(parms);
    473469
     470                            parms.uID                  = NIL_SHAREDCLIPBOARDAREAID;
    474471                            parms.u.fn_register.pvData = pvMeta;
    475472                            parms.u.fn_register.cbData = (uint32_t)cbMeta;
    … …  
    477474                            /* As the meta data is now complete, register a new clipboard on the host side. */
    478475                            rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_REGISTER, &parms, sizeof(parms));
     476                            if (RT_SUCCESS(rc))
     477                                rc = pTransfer->Area.OpenTemp(parms.uID /* Area ID */);
    479478#ifdef LOG_ENABLED
    480479                            AssertPtr(pTransfer->pState);
    481                             LogFlowFunc(("Registered new clipboard area by client %RU32 with rc=%Rrc\n",
    482                                          pTransfer->pState->u32ClientID, rc));
     480                            LogFlowFunc(("Registered new clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
     481                                         parms.uID, pTransfer->pState->u32ClientID, rc));
    483482#endif
    484483                        }

  • trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

    r78916 r78950  
    84618461
    84628462            VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms;
     8463            AssertPtr(pParms);
    84638464
    84648465            /* The guest announces clipboard formats. This must be delivered to all clients. */
    … …  
    84768477
    84778478            VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms;
     8479            AssertPtr(pParms);
    84788480
    84798481            /* The clipboard service expects that the pvData buffer will be filled
    … …  
    84948496
    84958497            VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms;
     8498            AssertPtr(pParms);
    84968499
    84978500            if (pThis->mConsoleVRDPServer)
    … …  
    85098512            ULONG uID;
    85108513            hrc = pControl->ClipboardAreaRegister(ComSafeArrayAsInParam(abstrParms), &uID);      H();
     8514            if (SUCCEEDED(hrc))
     8515            {
     8516                 PVBOXCLIPBOARDEXTAREAPARMS pParms = (PVBOXCLIPBOARDEXTAREAPARMS)pvParms;
     8517                 AssertPtr(pParms);
     8518
     8519                 /* Return the registered area ID back to the caller. */
     8520                 pParms->uID = uID;
     8521            }
    85118522        } break;
    85128523

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

    r78942 r78950  
    230230{
    231231    SharedClipboardAreaData()
    232         : uID(0) { }
    233 
    234     /** The area's (unique) ID. */
     232        : uID(NIL_SHAREDCLIPBOARDAREAID) { }
     233
     234    /** The area's (unique) ID.
     235     *  Set to NIL_SHAREDCLIPBOARDAREAID if not initialized yet. */
    235236    ULONG               uID;
    236237    /** The actual Shared Clipboard area assigned to this ID. */
    … …  
    247248{
    248249    SharedClipboardData()
    249         : uNextClipboardAreaID(0)
    250         , uMaxClipboardAreas(32)
     250        : uMostRecentClipboardAreaID(NIL_SHAREDCLIPBOARDAREAID)
     251        , uMaxClipboardAreas(32) /** @todo Make this configurable. */
    251252    {
    252253        int rc2 = RTCritSectInit(&CritSect);
    … …  
    259260    }
    260261
     262    /**
     263     * Generates a new clipboard area ID.
     264     * Currently does *not* check for collisions and stuff.
     265     *
     266     * @returns New clipboard area ID.
     267     */
     268    ULONG GenerateAreaID(void)
     269    {
     270        ULONG uID = NIL_SHAREDCLIPBOARDAREAID;
     271
     272        int rc = RTCritSectEnter(&CritSect);
     273        if (RT_SUCCESS(rc))
     274        {
     275            uID = RTRandU32Ex(1, UINT32_MAX - 1); /** @todo Make this a bit more sophisticated. Later. */
     276
     277            int rc2 = RTCritSectLeave(&CritSect);
     278            AssertRC(rc2);
     279        }
     280
     281        LogFlowFunc(("uID=%RU32\n", uID));
     282        return uID;
     283    }
     284
    261285    /** Critical section to serialize access. */
    262286    RTCRITSECT                          CritSect;
    263     /** The next (free) clipboard area ID. */
    264     ULONG                               uNextClipboardAreaID;
     287    /** The most recent (last created) clipboard area ID.
     288     *  NIL_SHAREDCLIPBOARDAREAID if not initialized yet. */
     289    ULONG                               uMostRecentClipboardAreaID;
    265290    /** Maximum of concurrent clipboard areas.
    266291     *  @todo Make this configurable. */
    … …  
    33533378
    33543379#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     3380/**
     3381 * Generates a new clipboard area on the host by opening (and locking) a new, temporary directory.
     3382 *
     3383 * @returns HRESULT
     3384 * @param   AreaData            Area data to use for clipboard area creation.
     3385 * @param   fFlags              Additional creation flags; currently unused and ignored.
     3386 */
    33553387int VirtualBox::i_clipboardAreaCreate(SharedClipboardAreaData &AreaData, uint32_t fFlags)
    33563388{
    33573389    RT_NOREF(fFlags);
    3358     int vrc = AreaData.Area.OpenTemp(AreaData.uID);
    3359     if (RT_SUCCESS(vrc))
    3360     {
    3361     }
     3390    int vrc = AreaData.Area.OpenTemp(AreaData.uID, SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST);
    33623391    LogFlowFunc(("uID=%RU32, rc=%Rrc\n", AreaData.uID, vrc));
    33633392    return vrc;
    33643393}
    33653394
     3395/**
     3396 * Destroys a formerly created clipboard area.
     3397 *
     3398 * @returns HRESULT
     3399 * @param   AreaData            Area data to use for clipboard area destruction.
     3400 */
    33663401int VirtualBox::i_clipboardAreaDestroy(SharedClipboardAreaData &AreaData)
    33673402{
    … …  
    33733408}
    33743409
     3410/**
     3411 * Registers and creates a new clipboard area on the host (for all VMs), returned the clipboard area ID for it.
     3412 *
     3413 * @returns HRESULT
     3414 * @param   aParms              Creation parameters. Currently unused.
     3415 * @param   aID                 Where to return the clipboard area ID on success.
     3416 */
    33753417HRESULT VirtualBox::i_onClipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID)
    33763418{
    … …  
    33863428            if (m->SharedClipboard.mapClipboardAreas.size() >= m->SharedClipboard.uMaxClipboardAreas)
    33873429            {
    3388                 const ULONG uAreaID = m->SharedClipboard.uNextClipboardAreaID;
    3389 
    3390                 SharedClipboardAreaData AreaData;
    3391                 AreaData.uID = uAreaID;
    3392 
    3393                 vrc = i_clipboardAreaCreate(AreaData, 0 /* fFlags */);
    3394                 if (RT_SUCCESS(vrc))
     3430                for (unsigned uTries = 0; uTries < 32; uTries++) /* Don't try too hard. */
    33953431                {
    3396                     m->SharedClipboard.mapClipboardAreas[uAreaID] = AreaData;
    3397                     m->SharedClipboard.uNextClipboardAreaID++;
    3398 
    3399                     /** @todo Implement collision detection / wrap-around. */
    3400 
    3401                     if (aID)
    3402                         *aID = uAreaID;
    3403 
    3404                     LogThisFunc(("Registered new clipboard area %RU32: '%s'\n",
    3405                                  uAreaID, AreaData.Area.GetDirAbs()));
     3432                    const ULONG uAreaID = m->SharedClipboard.GenerateAreaID();
     3433
     3434                    /* Area ID already taken? */
     3435                    if (m->SharedClipboard.mapClipboardAreas.find(uAreaID) != m->SharedClipboard.mapClipboardAreas.end())
     3436                        continue;
     3437
     3438                    SharedClipboardAreaData AreaData;
     3439                    AreaData.uID = uAreaID;
     3440
     3441                    vrc = i_clipboardAreaCreate(AreaData, 0 /* fFlags */);
     3442                    if (RT_SUCCESS(vrc))
     3443                    {
     3444                        m->SharedClipboard.mapClipboardAreas[uAreaID] = AreaData;
     3445                        m->SharedClipboard.uMostRecentClipboardAreaID = uAreaID;
     3446
     3447                        /** @todo Implement collision detection / wrap-around. */
     3448
     3449                        if (aID)
     3450                            *aID = uAreaID;
     3451
     3452                        LogThisFunc(("Registered new clipboard area %RU32: '%s'\n",
     3453                                     uAreaID, AreaData.Area.GetDirAbs()));
     3454                        break;
     3455                    }
    34063456                }
    3407                 else
     3457
     3458                if (RT_FAILURE(vrc))
    34083459                    rc = setError(E_FAIL, /** @todo Find a better rc. */
    3409                                   tr("Failed to create new clipboard area %RU32 (%Rrc)"), aID, vrc);
     3460                                  tr("Failed to create new clipboard area (%Rrc)"), vrc);
    34103461            }
    34113462            else
    34123463            {
    34133464                rc = setError(E_FAIL, /** @todo Find a better rc. */
    3414                               tr("Maximum number of conucurrent clipboard areas reached (%RU32)"),
     3465                              tr("Maximum number of concurrent clipboard areas reached (%RU32)"),
    34153466                              m->SharedClipboard.uMaxClipboardAreas);
    34163467            }
    … …  
    34283479}
    34293480
     3481/**
     3482 * Unregisters (destroys) a formerly created clipboard area.
     3483 *
     3484 * @returns HRESULT
     3485 * @param   aID                 ID of clipboard area to destroy.
     3486 */
    34303487HRESULT VirtualBox::i_onClipboardAreaUnregister(ULONG aID)
    34313488{
    … …  
    34613518}
    34623519
     3520/**
     3521 * Attaches to an existing clipboard area.
     3522 *
     3523 * @returns HRESULT
     3524 * @param   aID                 ID of clipboard area to attach.
     3525 */
    34633526HRESULT VirtualBox::i_onClipboardAreaAttach(ULONG aID)
    34643527{
    … …  
    34863549}
    34873550
     3551/**
     3552 * Detaches from an existing clipboard area.
     3553 *
     3554 * @returns HRESULT
     3555 * @param   aID                 ID of clipboard area to detach from.
     3556 */
    34883557HRESULT VirtualBox::i_onClipboardAreaDetach(ULONG aID)
    34893558{
    … …  
    35113580}
    35123581
     3582/**
     3583 * Returns the ID of the most recent (last created) clipboard area,
     3584 * or NIL_SHAREDCLIPBOARDAREAID if no clipboard area has been created yet.
     3585 *
     3586 * @returns Most recent clipboard area ID.
     3587 */
    35133588ULONG VirtualBox::i_onClipboardAreaGetMostRecent(void)
    35143589{
    … …  
    35173592    if (RT_SUCCESS(vrc2))
    35183593    {
    3519         aID = m->SharedClipboard.uNextClipboardAreaID
    3520             ? m->SharedClipboard.uNextClipboardAreaID - 1 : 0;
     3594        aID = m->SharedClipboard.uMostRecentClipboardAreaID;
    35213595
    35223596        vrc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    … …  
    35273601}
    35283602
     3603/**
     3604 * Returns the current reference count of a clipboard area.
     3605 *
     3606 * @returns Reference count of given clipboard area ID.
     3607 */
    35293608ULONG VirtualBox::i_onClipboardAreaGetRefCount(ULONG aID)
    35303609{
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