VirtualBox

Changeset 81229 in vbox


Ignore:
Timestamp:
Oct 11, 2019 2:33:25 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
133917
Message:

Shared Clipboard/Transfers: Update.

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/VBox/GuestHost/SharedClipboard-transfers.h

    r81223 r81229  
    397397            SHCLLISTHANDLE uHandle;
    398398        } ListOpen;
     399        struct
     400        {
     401            SHCLLISTHANDLE uHandle;
     402        } ListClose;
    399403        struct
    400404        {
  • trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp

    r81223 r81229  
    19531953
    19541954            SHCLLISTHANDLE hList  = SHCLLISTHANDLE_INVALID;
    1955             uint32_t                  fFlags = 0;
     1955            uint32_t       fFlags = 0;
    19561956            rc = VbglR3ClipboardListHdrReadRecvReq(pCmdCtx, &hList, &fFlags);
    19571957            if (RT_SUCCESS(rc))
     
    19831983            {
    19841984                SHCLLISTHANDLE hList;
    1985                 uint32_t                  fInfo;
     1985                uint32_t       fInfo;
    19861986                rc = VbglR3ClipboardListEntryReadRecvReq(pCmdCtx, &hList, &fInfo);
    19871987                if (RT_SUCCESS(rc))
     
    20612061        {
    20622062            SHCLOBJHANDLE hObj;
    2063             uint32_t cbBuf;
    2064             uint32_t fFlags;
     2063            uint32_t      cbBuf;
     2064            uint32_t      fFlags;
    20652065            rc = VbglR3ClipboardObjReadRecv(pCmdCtx, &hObj, &cbBuf, &fFlags);
    20662066            if (RT_SUCCESS(rc))
  • trunk/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp

    r81223 r81229  
    268268
    269269/**
    270  * Initializes a transfer data  header struct.
    271  *
    272  * @returns VBox status code.
    273  * @param   pListHdr            Data header struct to initialize.
     270 * Initializes a transfer list header structure.
     271 *
     272 * @returns VBox status code.
     273 * @param   pListHdr            Transfer list header struct to initialize.
    274274 */
    275275int ShClTransferListHdrInit(PSHCLLISTHDR pListHdr)
     
    285285
    286286/**
    287  * Destroys a transfer data  header struct.
    288  *
    289  * @param   pListHdr            Data header struct to destroy.
     287 * Destroys a transfer list header structure.
     288 *
     289 * @param   pListHdr            Transfer list header struct to destroy.
    290290 */
    291291void ShClTransferListHdrDestroy(PSHCLLISTHDR pListHdr)
     
    298298
    299299/**
    300  * Resets a SHCLListHdr structture.
    301  *
    302  * @returns VBox status code.
    303  * @param   pListHdr            SHCLListHdr structture to reset.
     300 * Resets a transfer list header structure.
     301 *
     302 * @returns VBox status code.
     303 * @param   pListHdr            Transfer list header struct to reset.
    304304 */
    305305void ShClTransferListHdrReset(PSHCLLISTHDR pListHdr)
     
    313313
    314314/**
    315  * Returns whether a given clipboard data header is valid or not.
     315 * Returns whether a given transfer list header is valid or not.
    316316 *
    317317 * @returns \c true if valid, \c false if not.
    318  * @param   pListHdr            Clipboard data header to validate.
     318 * @param   pListHdr            Transfer list header to validate.
    319319 */
    320320bool ShClTransferListHdrIsValid(PSHCLLISTHDR pListHdr)
     
    880880                    rc = RTDirClose(pInfo->u.Local.hDir);
    881881                    if (RT_SUCCESS(rc))
     882                    {
    882883                        pInfo->u.Local.hDir = NIL_RTDIR;
     884
     885                        LogRel2(("Shared Clipboard: Closed directory '%s'\n", pInfo->pszPathLocalAbs));
     886                    }
     887                    else
     888                        LogRel(("Shared Clipboard: Closing directory '%s' failed with %Rrc\n", pInfo->pszPathLocalAbs, rc));
    883889                    break;
    884890                }
     
    888894                    rc = RTFileClose(pInfo->u.Local.hFile);
    889895                    if (RT_SUCCESS(rc))
     896                    {
    890897                        pInfo->u.Local.hFile = NIL_RTFILE;
     898
     899                        LogRel2(("Shared Clipboard: Closed file '%s'\n", pInfo->pszPathLocalAbs));
     900                    }
     901                    else
     902                        LogRel(("Shared Clipboard: Closing file '%s' failed with %Rrc\n", pInfo->pszPathLocalAbs, rc));
    891903                    break;
    892904                }
     
    12851297{
    12861298    PSHCLLISTHANDLEINFO pIt;
    1287     RTListForEach(&pTransfer->lstList, pIt, SHCLLISTHANDLEINFO, Node)
     1299    RTListForEach(&pTransfer->lstList, pIt, SHCLLISTHANDLEINFO, Node) /** @todo Sloooow ... improve this. */
    12881300    {
    12891301        if (pIt->hList == hList)
     
    13031315{
    13041316    return pTransfer->uListHandleNext++; /** @todo Good enough for now. Improve this later. */
     1317}
     1318
     1319/**
     1320 * Resolves a relative path of a specific transfer to its absolute path.
     1321 *
     1322 * @returns VBox status code.
     1323 * @param   pTransfer           Clipboard transfer to resolve path for.
     1324 * @param   pszPath             Path to resolve.
     1325 * @param   fFlags              Resolve flags. Currently not used and must be 0.
     1326 * @param   ppszResolved        Where to store the allocated resolved path. Must be free'd by the called using RTStrFree().
     1327 */
     1328static int shClTransferResolvePathAbs(PSHCLTRANSFER pTransfer, const char *pszPath, uint32_t fFlags,
     1329                                      char **ppszResolved)
     1330{
     1331    AssertPtrReturn(pTransfer,   VERR_INVALID_POINTER);
     1332    AssertPtrReturn(pszPath,     VERR_INVALID_POINTER);
     1333    AssertReturn   (fFlags == 0, VERR_INVALID_PARAMETER);
     1334
     1335    /* Paranoia. */
     1336    if (   !strlen(pTransfer->pszPathRootAbs)
     1337        || !RTStrIsValidEncoding(pTransfer->pszPathRootAbs)
     1338        || !RTStrCmp(pTransfer->pszPathRootAbs, ".")
     1339        || !RTStrCmp(pTransfer->pszPathRootAbs, "..")
     1340        || !RTPathStartsWithRoot(pTransfer->pszPathRootAbs))
     1341    {
     1342        return VERR_INVALID_PARAMETER;
     1343    }
     1344
     1345    int rc;
     1346
     1347    char *pszResolved = RTPathJoinA(pTransfer->pszPathRootAbs, pszPath);
     1348    if (pszResolved)
     1349    {
     1350        LogFlowFunc(("pszPathRootAbs=%s, pszPath=%s -> %s\n", pTransfer->pszPathRootAbs, pszPath, pszResolved));
     1351
     1352        *ppszResolved = pszResolved;
     1353
     1354        rc = VINF_SUCCESS;
     1355    }
     1356    else
     1357        rc = VERR_NO_MEMORY;
     1358
     1359    LogFlowFuncLeaveRC(rc);
     1360    return rc;
    13051361}
    13061362
     
    13221378    int rc;
    13231379
    1324     SHCLLISTHANDLE hList = SHCLLISTHANDLE_INVALID;
    1325 
    13261380    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
    13271381    {
    13281382        LogFlowFunc(("pszPath=%s\n", pOpenParms->pszPath));
    13291383
    1330         PSHCLLISTHANDLEINFO pInfo
    1331             = (PSHCLLISTHANDLEINFO)RTMemAlloc(sizeof(SHCLLISTHANDLEINFO));
    1332         if (pInfo)
    1333         {
    1334             rc = ShClTransferListHandleInfoInit(pInfo);
    1335             if (RT_SUCCESS(rc))
     1384        char *pszPathAbs;
     1385        rc = shClTransferResolvePathAbs(pTransfer, pOpenParms->pszPath, 0 /* fFlags */, &pszPathAbs);
     1386        if (RT_SUCCESS(rc))
     1387        {
     1388            PSHCLLISTHANDLEINFO pInfo
     1389                = (PSHCLLISTHANDLEINFO)RTMemAlloc(sizeof(SHCLLISTHANDLEINFO));
     1390            if (pInfo)
    13361391            {
    1337                 RTFSOBJINFO objInfo;
    1338                 rc = RTPathQueryInfo(pOpenParms->pszPath, &objInfo, RTFSOBJATTRADD_NOTHING);
     1392                rc = ShClTransferListHandleInfoInit(pInfo);
    13391393                if (RT_SUCCESS(rc))
    13401394                {
    1341                     if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
    1342                     {
    1343                         rc = RTDirOpen(&pInfo->u.Local.hDir, pOpenParms->pszPath);
    1344                         if (RT_SUCCESS(rc))
    1345                             pInfo->enmType = SHCLOBJTYPE_DIRECTORY;
    1346 
    1347                     }
    1348                     else if (RTFS_IS_FILE(objInfo.Attr.fMode))
    1349                     {
    1350                         rc = RTFileOpen(&pInfo->u.Local.hFile, pOpenParms->pszPath,
    1351                                         RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
    1352                         if (RT_SUCCESS(rc))
    1353                             pInfo->enmType = SHCLOBJTYPE_FILE;
    1354                     }
    1355                     else
    1356                         rc = VERR_NOT_SUPPORTED;
    1357 
     1395                    RTFSOBJINFO objInfo;
     1396                    rc = RTPathQueryInfo(pOpenParms->pszPath, &objInfo, RTFSOBJATTRADD_NOTHING);
    13581397                    if (RT_SUCCESS(rc))
    1359                     {
    1360                         pInfo->hList = sharedClipboardTransferListHandleNew(pTransfer);
    1361 
    1362                         RTListAppend(&pTransfer->lstList, &pInfo->Node);
    1363                     }
    1364                     else
    13651398                    {
    13661399                        if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
    13671400                        {
    1368                             if (RTDirIsValid(pInfo->u.Local.hDir))
    1369                                 RTDirClose(pInfo->u.Local.hDir);
     1401                            rc = RTDirOpen(&pInfo->u.Local.hDir, pszPathAbs);
     1402                            if (RT_SUCCESS(rc))
     1403                            {
     1404                                pInfo->enmType = SHCLOBJTYPE_DIRECTORY;
     1405
     1406                                LogRel2(("Shared Clipboard: Opening directory '%s'\n", pszPathAbs));
     1407                            }
     1408                            else
     1409                                LogRel(("Shared Clipboard: Opening directory '%s' failed with %Rrc\n", pInfo->pszPathLocalAbs, rc));
     1410
    13701411                        }
    13711412                        else if (RTFS_IS_FILE(objInfo.Attr.fMode))
    13721413                        {
    1373                             if (RTFileIsValid(pInfo->u.Local.hFile))
    1374                                 RTFileClose(pInfo->u.Local.hFile);
     1414                            rc = RTFileOpen(&pInfo->u.Local.hFile, pszPathAbs,
     1415                                            RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
     1416                            if (RT_SUCCESS(rc))
     1417                            {
     1418                                pInfo->enmType = SHCLOBJTYPE_FILE;
     1419
     1420                                LogRel2(("Shared Clipboard: Opening file '%s'\n", pszPathAbs));
     1421                            }
     1422                            else
     1423                                LogRel(("Shared Clipboard: Opening file '%s' failed with %Rrc\n", pInfo->pszPathLocalAbs, rc));
     1424                        }
     1425                        else
     1426                            rc = VERR_NOT_SUPPORTED;
     1427
     1428                        if (RT_SUCCESS(rc))
     1429                        {
     1430                            pInfo->hList           = sharedClipboardTransferListHandleNew(pTransfer);
     1431                            pInfo->pszPathLocalAbs = RTStrDup(pszPathAbs);
     1432                            if (pInfo->pszPathLocalAbs)
     1433                            {
     1434                                RTListAppend(&pTransfer->lstList, &pInfo->Node);
     1435
     1436                                LogFlowFunc(("pszPathLocalAbs=%s, hList=%RU64\n", pInfo->pszPathLocalAbs, pInfo->hList));
     1437
     1438                                *phList = pInfo->hList;
     1439                            }
     1440                            else
     1441                                rc = VERR_NO_MEMORY;
     1442                        }
     1443                        else
     1444                        {
     1445                            if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
     1446                            {
     1447                                if (RTDirIsValid(pInfo->u.Local.hDir))
     1448                                    RTDirClose(pInfo->u.Local.hDir);
     1449                            }
     1450                            else if (RTFS_IS_FILE(objInfo.Attr.fMode))
     1451                            {
     1452                                if (RTFileIsValid(pInfo->u.Local.hFile))
     1453                                    RTFileClose(pInfo->u.Local.hFile);
     1454                            }
    13751455                        }
    13761456                    }
     1457
     1458                    if (RT_FAILURE(rc))
     1459                        ShClTransferListHandleInfoDestroy(pInfo);
    13771460                }
    13781461
    13791462                if (RT_FAILURE(rc))
    1380                     ShClTransferListHandleInfoDestroy(pInfo);
     1463                {
     1464                    RTMemFree(pInfo);
     1465                    pInfo = NULL;
     1466                }
    13811467            }
    1382 
    1383             if (RT_FAILURE(rc))
    1384             {
    1385                 RTMemFree(pInfo);
    1386                 pInfo = NULL;
    1387             }
    1388         }
    1389         else
    1390             rc = VERR_NO_MEMORY;
     1468            else
     1469                rc = VERR_NO_MEMORY;
     1470
     1471            RTStrFree(pszPathAbs);
     1472        }
    13911473    }
    13921474    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     
    13941476        if (pTransfer->ProviderIface.pfnListOpen)
    13951477        {
    1396             rc = pTransfer->ProviderIface.pfnListOpen(&pTransfer->ProviderCtx, pOpenParms, &hList);
     1478            rc = pTransfer->ProviderIface.pfnListOpen(&pTransfer->ProviderCtx, pOpenParms, phList);
    13971479        }
    13981480        else
     
    14011483    else
    14021484        AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
    1403 
    1404     if (RT_SUCCESS(rc))
    1405         *phList = hList;
    14061485
    14071486    LogFlowFuncLeaveRC(rc);
     
    14991578 * @param   cchDstBase          Number of charaters of destination base path.
    15001579 */
    1501 static int sharedClipboardTransferListHdrFromDir(PSHCLLISTHDR pHdr,
    1502                                                  const char *pcszSrcPath, const char *pcszDstPath,
    1503                                                  const char *pcszDstBase)
    1504 {
    1505     AssertPtrReturn(pcszSrcPath, VERR_INVALID_POINTER);
    1506     AssertPtrReturn(pcszDstBase, VERR_INVALID_POINTER);
    1507     AssertPtrReturn(pcszDstPath, VERR_INVALID_POINTER);
    1508 
    1509     LogFlowFunc(("pcszSrcPath=%s, pcszDstPath=%s, pcszDstBase=%s\n",
    1510                  pcszSrcPath, pcszDstPath, pcszDstBase));
     1580static int sharedClipboardTransferListHdrFromDir(PSHCLLISTHDR pHdr, const char *pcszPathAbs)
     1581{
     1582    AssertPtrReturn(pcszPathAbs, VERR_INVALID_POINTER);
     1583
     1584    LogFlowFunc(("pcszPathAbs=%s\n", pcszPathAbs));
    15111585
    15121586    RTFSOBJINFO objInfo;
    1513     int rc = RTPathQueryInfo(pcszSrcPath, &objInfo, RTFSOBJATTRADD_NOTHING);
     1587    int rc = RTPathQueryInfo(pcszPathAbs, &objInfo, RTFSOBJATTRADD_NOTHING);
    15141588    if (RT_SUCCESS(rc))
    15151589    {
    15161590        if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
    15171591        {
    1518             pHdr->cTotalObjects++;
    1519 
    15201592            RTDIR hDir;
    1521             rc = RTDirOpen(&hDir, pcszSrcPath);
     1593            rc = RTDirOpen(&hDir, pcszPathAbs);
    15221594            if (RT_SUCCESS(rc))
    15231595            {
     
    15371609                    switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
    15381610                    {
    1539                 #if 0 /* No recursion here (yet). */
    15401611                        case RTFS_TYPE_DIRECTORY:
    15411612                        {
     
    15441615                                break;
    15451616
    1546                             char *pszSrc = RTPathJoinA(pcszSrcPath, pDirEntry->szName);
    1547                             if (pszSrc)
    1548                             {
    1549                                 char *pszDst = RTPathJoinA(pcszDstPath, pDirEntry->szName);
    1550                                 if (pszDst)
    1551                                 {
    1552                                     rc = sharedClipboardTransferListHdrFromDir(pHdr, pszSrc, pszDst,
    1553                                                                                   pcszDstBase, cchDstBase);
    1554                                     RTStrFree(pszDst);
    1555                                 }
    1556                                 else
    1557                                     rc = VERR_NO_MEMORY;
    1558 
    1559                                 RTStrFree(pszSrc);
    1560                             }
    1561                             else
    1562                                 rc = VERR_NO_MEMORY;
     1617                            pHdr->cTotalObjects++;
    15631618                            break;
    15641619                        }
    1565                 #endif
    15661620                        case RTFS_TYPE_FILE:
    15671621                        {
    1568                             char *pszSrc = RTPathJoinA(pcszSrcPath, pDirEntry->szName);
     1622                            char *pszSrc = RTPathJoinA(pcszPathAbs, pDirEntry->szName);
    15691623                            if (pszSrc)
    15701624                            {
     
    15931647        else if (RTFS_IS_FILE(objInfo.Attr.fMode))
    15941648        {
    1595             rc = sharedClipboardTransferListHdrAddFile(pHdr, pcszSrcPath);
     1649            rc = sharedClipboardTransferListHdrAddFile(pHdr, pcszPathAbs);
    15961650        }
    15971651        else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode))
     
    16161670static char *sharedClipboardPathTranslate(const char *pszPath)
    16171671{
     1672    AssertPtrReturn(pszPath, NULL);
     1673
     1674    LogFlowFunc(("pszPath=%s\n", pszPath));
     1675
    16181676    char *pszPathTranslated = NULL;
    16191677
     
    16731731                    case SHCLOBJTYPE_DIRECTORY:
    16741732                    {
    1675                         char *pszPathRel = sharedClipboardPathTranslate(pInfo->pszPathLocalAbs);
    1676                         if (pszPathRel)
    1677                         {
    1678                             rc = sharedClipboardTransferListHdrFromDir(pHdr,
    1679                                                                        pszPathRel, pszPathRel, pszPathRel);
    1680                             RTStrFree(pszPathRel);
    1681                         }
    1682                         else
    1683                             rc = VERR_NO_MEMORY;
     1733                        LogFlowFunc(("DirAbs: %s\n", pInfo->pszPathLocalAbs));
     1734
     1735                        rc = sharedClipboardTransferListHdrFromDir(pHdr, pInfo->pszPathLocalAbs);
    16841736                        break;
    16851737                    }
     
    16871739                    case SHCLOBJTYPE_FILE:
    16881740                    {
     1741                        LogFlowFunc(("FileAbs: %s\n", pInfo->pszPathLocalAbs));
     1742
    16891743                        pHdr->cTotalObjects = 1;
    16901744
     
    25132567    LogFlowFunc(("pTransferCtx=%p\n", pTransferCtx));
    25142568
    2515     RTCritSectDelete(&pTransferCtx->CritSect);
     2569    if (RTCritSectIsInitialized(&pTransferCtx->CritSect))
     2570        RTCritSectDelete(&pTransferCtx->CritSect);
    25162571
    25172572    PSHCLTRANSFER pTransfer, pTransferNext;
  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h

    r81212 r81229  
    200200int shclSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
    201201bool shclSvcTransferMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
     202void shclSvcClientTransfersReset(PSHCLCLIENT pClient);
    202203#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    203204
  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp

    r81223 r81229  
    5858*********************************************************************************************************************************/
    5959
     60/**
     61 * Resets all transfers of a Shared Clipboard client.
     62 *
     63 * @param   pClient             Client to reset transfers for.
     64 */
     65void shclSvcClientTransfersReset(PSHCLCLIENT pClient)
     66{
     67    if (!pClient)
     68        return;
     69
     70    LogFlowFuncEnter();
     71
     72    const uint32_t cTransfers = ShClTransferCtxGetTotalTransfers(&pClient->TransferCtx);
     73    for (uint32_t i = 0; i < cTransfers; i++)
     74    {
     75        PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(&pClient->TransferCtx, i);
     76        if (pTransfer)
     77            shclSvcTransferAreaDetach(&pClient->State, pTransfer);
     78    }
     79
     80    ShClTransferCtxDestroy(&pClient->TransferCtx);
     81}
     82
     83
     84/*********************************************************************************************************************************
     85*   Provider implementation                                                                                                      *
     86*********************************************************************************************************************************/
     87
    6088DECLCALLBACK(int) shclSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx)
    6189{
     
    208236        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    209237
    210         pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,  pCtx->pTransfer->State.uID,
     238        pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
    211239                                                        uEvent);
    212240
     
    233261
    234262                        Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN);
     263
     264                        LogFlowFunc(("hList=%RU64\n", pReply->u.ListOpen.uHandle));
    235265
    236266                        *phList = pReply->u.ListOpen.uHandle;
     
    466496                    Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_OBJ_OPEN);
    467497
     498                    LogFlowFunc(("hObj=%RU64\n", pReply->u.ObjOpen.uHandle));
     499
    468500                    *phObj = pReply->u.ObjOpen.uHandle;
    469501
     
    519551
    520552                    Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_OBJ_CLOSE);
     553
     554                    LogFlowFunc(("hObj=%RU64\n", pReply->u.ObjClose.uHandle));
    521555#endif
    522556
     
    765799                    if (cParms >= 6)
    766800                        rc = HGCMSvcGetU32(&paParms[5], &pReply->u.TransferStatus.uStatus);
     801
     802                    LogFlowFunc(("uTransferStatus=%RU32\n", pReply->u.TransferStatus.uStatus));
    767803                    break;
    768804                }
     
    772808                    if (cParms >= 6)
    773809                        rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ListOpen.uHandle);
     810
     811                    LogFlowFunc(("hListOpen=%RU64\n", pReply->u.ListOpen.uHandle));
     812                    break;
     813                }
     814
     815                case VBOX_SHCL_REPLYMSGTYPE_LIST_CLOSE:
     816                {
     817                    if (cParms >= 6)
     818                        rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ListClose.uHandle);
     819
     820                    LogFlowFunc(("hListClose=%RU64\n", pReply->u.ListClose.uHandle));
    774821                    break;
    775822                }
     
    779826                    if (cParms >= 6)
    780827                        rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ObjOpen.uHandle);
     828
     829                    LogFlowFunc(("hObjOpen=%RU64\n", pReply->u.ObjOpen.uHandle));
    781830                    break;
    782831                }
     
    786835                    if (cParms >= 6)
    787836                        rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ObjClose.uHandle);
     837
     838                    LogFlowFunc(("hObjClose=%RU64\n", pReply->u.ObjClose.uHandle));
    788839                    break;
    789840                }
     
    11521203            }
    11531204        }
    1154     }
    1155     else
    1156         rc = VERR_INVALID_PARAMETER;
    1157 
    1158     LogFlowFuncLeaveRC(rc);
    1159     return rc;
    1160 }
    1161 
    1162 /**
    1163  * Gets a transfer error from HGCM service parameters.
    1164  *
    1165  * @returns VBox status code.
    1166  * @param   cParms              Number of HGCM parameters supplied in \a paParms.
    1167  * @param   paParms             Array of HGCM parameters.
    1168  * @param   pRc                 Where to store the received error code.
    1169  */
    1170 static int shclSvcTransferGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
    1171 {
    1172     AssertPtrReturn(paParms, VERR_INVALID_PARAMETER);
    1173     AssertPtrReturn(pRc,     VERR_INVALID_PARAMETER);
    1174 
    1175     int rc;
    1176 
    1177     if (cParms == VBOX_SHCL_CPARMS_ERROR)
    1178     {
    1179         rc = HGCMSvcGetU32(&paParms[1], (uint32_t *)pRc); /** @todo int vs. uint32_t !!! */
    11801205    }
    11811206    else
     
    18481873        }
    18491874#endif
    1850         case VBOX_SHCL_GUEST_FN_CANCEL:
    1851         {
    1852             LogRel2(("Shared Clipboard: Transfer canceled\n"));
    1853             break;
    1854         }
    1855 
    1856         case VBOX_SHCL_GUEST_FN_ERROR:
    1857         {
    1858             int rcGuest;
    1859             rc = shclSvcTransferGetError(cParms,paParms, &rcGuest);
    1860             if (RT_SUCCESS(rc))
    1861                 LogRel(("Shared Clipboard: Transfer error from guest: %Rrc\n", rcGuest));
    1862             break;
    1863         }
    1864 
    18651875        default:
    18661876            LogFunc(("Not implemented\n"));
  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp

    r81223 r81229  
    10601060}
    10611061
     1062/**
     1063 * Gets an error from HGCM service parameters.
     1064 *
     1065 * @returns VBox status code.
     1066 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     1067 * @param   paParms             Array of HGCM parameters.
     1068 * @param   pRc                 Where to store the received error code.
     1069 */
     1070static int shclSvcGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
     1071{
     1072    AssertPtrReturn(paParms, VERR_INVALID_PARAMETER);
     1073    AssertPtrReturn(pRc,     VERR_INVALID_PARAMETER);
     1074
     1075    int rc;
     1076
     1077    if (cParms == VBOX_SHCL_CPARMS_ERROR)
     1078    {
     1079        rc = HGCMSvcGetU32(&paParms[1], (uint32_t *)pRc); /** @todo int vs. uint32_t !!! */
     1080    }
     1081    else
     1082        rc = VERR_INVALID_PARAMETER;
     1083
     1084    LogFlowFuncLeaveRC(rc);
     1085    return rc;
     1086}
     1087
    10621088int shclSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource)
    10631089{
     
    11211147
    11221148#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1123     PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(&pClient->TransferCtx, 0 /* Index*/);
    1124     if (pTransfer)
    1125         shclSvcTransferAreaDetach(&pClient->State, pTransfer);
    1126 
    1127     ShClTransferCtxDestroy(&pClient->TransferCtx);
     1149    shclSvcClientTransfersReset(pClient);
    11281150#endif
    11291151
     
    14871509        }
    14881510
     1511        case VBOX_SHCL_GUEST_FN_CANCEL:
     1512        {
     1513            LogRel2(("Shared Clipboard: Operation canceled by guest side\n"));
     1514
     1515            /** @todo Do we need to do anything here? */
     1516            break;
     1517        }
     1518
     1519        case VBOX_SHCL_GUEST_FN_ERROR:
     1520        {
     1521            int rcGuest;
     1522            rc = shclSvcGetError(cParms,paParms, &rcGuest);
     1523            if (RT_SUCCESS(rc))
     1524            {
     1525                LogRel(("Shared Clipboard: Error from guest side: %Rrc\n", rcGuest));
     1526
     1527                /* Reset client state and start over. */
     1528                shclSvcClientStateReset(&pClient->State);
     1529#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     1530                shclSvcClientTransfersReset(pClient);
     1531#endif
     1532            }
     1533            break;
     1534        }
     1535
    14891536        default:
    14901537        {
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