VirtualBox

Changeset 81220 in vbox


Ignore:
Timestamp:
Oct 11, 2019 8:19:05 AM (5 years ago)
Author:
vboxsync
Message:

Shared Clipboard/Transfers: Update.

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r81212 r81220  
    643643    SHCLAREAID                   m_uID;
    644644};
    645 
    646 int SharedClipboardPathSanitizeFilename(char *pszPath, size_t cbPath);
    647 int SharedClipboardPathSanitize(char *pszPath, size_t cbPath);
    648 
    649 PSHCLROOTLIST SharedClipboardTransferRootListAlloc(void);
    650 void SharedClipboardTransferRootListFree(PSHCLROOTLIST pRootList);
    651 
    652 PSHCLROOTLISTHDR SharedClipboardTransferRootListHdrDup(PSHCLROOTLISTHDR pRoots);
    653 int SharedClipboardTransferRootListHdrInit(PSHCLROOTLISTHDR pRoots);
    654 void SharedClipboardTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRoots);
    655 
    656 int SharedClipboardTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc);
    657 int SharedClipboardTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry);
    658 void SharedClipboardTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry);
    659 PSHCLROOTLISTENTRY SharedClipboardTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry);
    660 
    661 int SharedClipboardTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr);
    662 void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr);
    663 PSHCLLISTHDR SharedClipboardTransferListHdrDup(PSHCLLISTHDR pListHdr);
    664 int SharedClipboardTransferListHdrInit(PSHCLLISTHDR pListHdr);
    665 void SharedClipboardTransferListHdrDestroy(PSHCLLISTHDR pListHdr);
    666 void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr);
    667 void SharedClipboardTransferListHdrReset(PSHCLLISTHDR pListHdr);
    668 bool SharedClipboardTransferListHdrIsValid(PSHCLLISTHDR pListHdr);
    669 
    670 int SharedClipboardTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc);
    671 PSHCLLISTOPENPARMS SharedClipboardTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms);
    672 int SharedClipboardTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms);
    673 void SharedClipboardTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms);
    674 
    675 int SharedClipboardTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry);
    676 void SharedClipboardTransferListEntryFree(PSHCLLISTENTRY pListEntry);
    677 int SharedClipboardTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc);
    678 PSHCLLISTENTRY SharedClipboardTransferListEntryDup(PSHCLLISTENTRY pListEntry);
    679 int SharedClipboardTransferListEntryInit(PSHCLLISTENTRY pListEntry);
    680 void SharedClipboardTransferListEntryDestroy(PSHCLLISTENTRY pListEntry);
    681 bool SharedClipboardTransferListEntryIsValid(PSHCLLISTENTRY pListEntry);
    682645
    683646/**
    … …  
    11051068bool SharedClipboardTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
    11061069
     1070int SharedClipboardPathSanitizeFilename(char *pszPath, size_t cbPath);
     1071int SharedClipboardPathSanitize(char *pszPath, size_t cbPath);
     1072
     1073PSHCLROOTLIST SharedClipboardTransferRootListAlloc(void);
     1074void SharedClipboardTransferRootListFree(PSHCLROOTLIST pRootList);
     1075
     1076PSHCLROOTLISTHDR SharedClipboardTransferRootListHdrDup(PSHCLROOTLISTHDR pRoots);
     1077int SharedClipboardTransferRootListHdrInit(PSHCLROOTLISTHDR pRoots);
     1078void SharedClipboardTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRoots);
     1079
     1080int SharedClipboardTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc);
     1081int SharedClipboardTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry);
     1082void SharedClipboardTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry);
     1083PSHCLROOTLISTENTRY SharedClipboardTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry);
     1084
     1085int SharedClipboardTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo);
     1086void SharedClipboardTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo);
     1087
     1088int SharedClipboardTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr);
     1089void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr);
     1090PSHCLLISTHDR SharedClipboardTransferListHdrDup(PSHCLLISTHDR pListHdr);
     1091int SharedClipboardTransferListHdrInit(PSHCLLISTHDR pListHdr);
     1092void SharedClipboardTransferListHdrDestroy(PSHCLLISTHDR pListHdr);
     1093void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr);
     1094void SharedClipboardTransferListHdrReset(PSHCLLISTHDR pListHdr);
     1095bool SharedClipboardTransferListHdrIsValid(PSHCLLISTHDR pListHdr);
     1096
     1097int SharedClipboardTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc);
     1098PSHCLLISTOPENPARMS SharedClipboardTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms);
     1099int SharedClipboardTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms);
     1100void SharedClipboardTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms);
     1101
     1102int SharedClipboardTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry);
     1103void SharedClipboardTransferListEntryFree(PSHCLLISTENTRY pListEntry);
     1104int SharedClipboardTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc);
     1105PSHCLLISTENTRY SharedClipboardTransferListEntryDup(PSHCLLISTENTRY pListEntry);
     1106int SharedClipboardTransferListEntryInit(PSHCLLISTENTRY pListEntry);
     1107void SharedClipboardTransferListEntryDestroy(PSHCLLISTENTRY pListEntry);
     1108bool SharedClipboardTransferListEntryIsValid(PSHCLLISTENTRY pListEntry);
     1109
    11071110int SharedClipboardTransferSetInterface(PSHCLTRANSFER pTransfer, PSHCLPROVIDERCREATIONCTX pCreationCtx);
    11081111int SharedClipboardTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots);

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

    r81212 r81220  
    774774    Msg.pvFilter.SetPtr(pOpenParms->pszFilter, pOpenParms->cbFilter);
    775775    Msg.cbPath.SetUInt32(pOpenParms->cbPath);
    776     Msg.pvFilter.SetPtr(pOpenParms->pszPath, pOpenParms->cbPath);
     776    Msg.pvPath.SetPtr(pOpenParms->pszPath, pOpenParms->cbPath);
     777    Msg.uHandle.SetUInt64(0);
    777778
    778779    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    … …  
    17761777
    17771778    int rc;
     1779
     1780    bool fErrorSent = false; /* Whether an error has been reported back to the host already. */
    17781781
    17791782    switch (idMsg)
    … …  
    20942097        {
    20952098            rc = VbglR3ClipboardEventGetNext(idMsg, cParms, pCmdCtx, pEvent);
     2099            if (RT_FAILURE(rc))
     2100                fErrorSent = true;
    20962101            break;
    20972102        }
     2103    }
     2104
     2105    if (   !fErrorSent
     2106        && RT_FAILURE(rc))
     2107    {
     2108        /* Report error back to the host. */
     2109        int rc2 = VbglR3ClipboardWriteError(pCmdCtx->uClientID, rc);
     2110        AssertRC(rc2);
    20982111    }
    20992112
    … …  
    21582171        int rc2 = VbglR3ClipboardWriteError(pCtx->uClientID, rc);
    21592172        AssertRC(rc2);
    2160 
    2161    }
     2173    }
    21622174
    21632175    LogFlowFuncLeaveRC(rc);

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

    r81212 r81220  
    168168{
    169169    return SharedClipboardTransferListEntryDup(pRootListEntry);
     170}
     171
     172/**
     173 * Initializes an list handle info structure.
     174 *
     175 * @returns VBox status code.
     176 * @param   pInfo               List handle info structure to initialize.
     177 */
     178int SharedClipboardTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo)
     179{
     180    AssertPtrReturn(pInfo, VERR_INVALID_POINTER);
     181
     182    pInfo->hList   = SHCLLISTHANDLE_INVALID;
     183    pInfo->enmType = SHCLOBJTYPE_INVALID;
     184
     185    pInfo->pszPathLocalAbs = NULL;
     186
     187    RT_ZERO(pInfo->u);
     188
     189    return VINF_SUCCESS;
    170190}
    171191
    … …  
    12141234    pTransfer->State.enmSource = enmSource;
    12151235
     1236    LogFlowFunc(("uID=%RU32, enmDir=%RU32, enmSource=%RU32\n",
     1237                 pTransfer->State.uID, pTransfer->State.enmDir, pTransfer->State.enmSource));
     1238
    12161239    int rc = SharedClipboardEventSourceCreate(&pTransfer->Events, pTransfer->State.uID);
    12171240    if (RT_SUCCESS(rc))
    … …  
    12591282 * @param   hList               List handle of the list to get handle info for.
    12601283 */
    1261 inline PSHCLLISTHANDLEINFO sharedClipboardTransferListGet(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
     1284inline PSHCLLISTHANDLEINFO sharedClipboardTransferListGetByHandle(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
    12621285{
    12631286    PSHCLLISTHANDLEINFO pIt;
    … …  
    13031326    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
    13041327    {
     1328        LogFlowFunc(("pszPath=%s\n", pOpenParms->pszPath));
     1329
    13051330        PSHCLLISTHANDLEINFO pInfo
    13061331            = (PSHCLLISTHANDLEINFO)RTMemAlloc(sizeof(SHCLLISTHANDLEINFO));
    13071332        if (pInfo)
    13081333        {
    1309             LogFlowFunc(("pszPath=%s\n", pOpenParms->pszPath));
    1310 
    1311             RTFSOBJINFO objInfo;
    1312             rc = RTPathQueryInfo(pOpenParms->pszPath, &objInfo, RTFSOBJATTRADD_NOTHING);
     1334            rc = SharedClipboardTransferListHandleInfoInit(pInfo);
    13131335            if (RT_SUCCESS(rc))
    13141336            {
    1315                 switch (pInfo->enmType)
     1337                RTFSOBJINFO objInfo;
     1338                rc = RTPathQueryInfo(pOpenParms->pszPath, &objInfo, RTFSOBJATTRADD_NOTHING);
     1339                if (RT_SUCCESS(rc))
    13161340                {
    1317                     case SHCLOBJTYPE_DIRECTORY:
     1341                    if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
    13181342                    {
    13191343                        rc = RTDirOpen(&pInfo->u.Local.hDir, pOpenParms->pszPath);
    1320                         break;
     1344                        if (RT_SUCCESS(rc))
     1345                            pInfo->enmType = SHCLOBJTYPE_DIRECTORY;
     1346
    13211347                    }
    1322 
    1323                     case SHCLOBJTYPE_FILE:
     1348                    else if (RTFS_IS_FILE(objInfo.Attr.fMode))
    13241349                    {
    13251350                        rc = RTFileOpen(&pInfo->u.Local.hFile, pOpenParms->pszPath,
    13261351                                        RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
    1327                         break;
     1352                        if (RT_SUCCESS(rc))
     1353                            pInfo->enmType = SHCLOBJTYPE_FILE;
    13281354                    }
    1329 
    1330                     default:
     1355                    else
    13311356                        rc = VERR_NOT_SUPPORTED;
    1332                         break;
     1357
     1358                    if (RT_SUCCESS(rc))
     1359                    {
     1360                        pInfo->hList = sharedClipboardTransferListHandleNew(pTransfer);
     1361
     1362                        RTListAppend(&pTransfer->lstList, &pInfo->Node);
     1363                    }
     1364                    else
     1365                    {
     1366                        if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
     1367                        {
     1368                            if (RTDirIsValid(pInfo->u.Local.hDir))
     1369                                RTDirClose(pInfo->u.Local.hDir);
     1370                        }
     1371                        else if (RTFS_IS_FILE(objInfo.Attr.fMode))
     1372                        {
     1373                            if (RTFileIsValid(pInfo->u.Local.hFile))
     1374                                RTFileClose(pInfo->u.Local.hFile);
     1375                        }
     1376                    }
    13331377                }
    13341378
    1335                 if (RT_SUCCESS(rc))
    1336                 {
    1337                     pInfo->hList = sharedClipboardTransferListHandleNew(pTransfer);
    1338 
    1339                     RTListAppend(&pTransfer->lstList, &pInfo->Node);
    1340                 }
    1341                 else
    1342                 {
    1343                     if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
    1344                     {
    1345                         if (RTDirIsValid(pInfo->u.Local.hDir))
    1346                             RTDirClose(pInfo->u.Local.hDir);
    1347                     }
    1348                     else if (RTFS_IS_FILE(objInfo.Attr.fMode))
    1349                     {
    1350                         if (RTFileIsValid(pInfo->u.Local.hFile))
    1351                             RTFileClose(pInfo->u.Local.hFile);
    1352                     }
    1353 
    1354                     RTMemFree(pInfo);
    1355                     pInfo = NULL;
    1356                 }
     1379                if (RT_FAILURE(rc))
     1380                    SharedClipboardTransferListHandleInfoDestroy(pInfo);
     1381            }
     1382
     1383            if (RT_FAILURE(rc))
     1384            {
     1385                RTMemFree(pInfo);
     1386                pInfo = NULL;
    13571387            }
    13581388        }
    … …  
    13971427    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
    13981428    {
    1399         PSHCLLISTHANDLEINFO pInfo = sharedClipboardTransferListGet(pTransfer, hList);
     1429        PSHCLLISTHANDLEINFO pInfo = sharedClipboardTransferListGetByHandle(pTransfer, hList);
    14001430        if (pInfo)
    14011431        {
    … …  
    16331663    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
    16341664    {
    1635         PSHCLLISTHANDLEINFO pInfo = sharedClipboardTransferListGet(pTransfer, hList);
     1665        PSHCLLISTHANDLEINFO pInfo = sharedClipboardTransferListGetByHandle(pTransfer, hList);
    16361666        if (pInfo)
    16371667        {
    … …  
    16471677                        {
    16481678                            rc = sharedClipboardTransferListHdrFromDir(pHdr,
    1649                                                                           pszPathRel, pszPathRel, pszPathRel);
     1679                                                                       pszPathRel, pszPathRel, pszPathRel);
    16501680                            RTStrFree(pszPathRel);
    16511681                        }
    … …  
    17371767    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
    17381768    {
    1739         PSHCLLISTHANDLEINFO pInfo = sharedClipboardTransferListGet(pTransfer, hList);
     1769        PSHCLLISTHANDLEINFO pInfo = sharedClipboardTransferListGetByHandle(pTransfer, hList);
    17401770        if (pInfo)
    17411771        {
    … …  
    18881918    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
    18891919    {
    1890         fIsValid = sharedClipboardTransferListGet(pTransfer, hList) != NULL;
     1920        fIsValid = sharedClipboardTransferListGetByHandle(pTransfer, hList) != NULL;
    18911921    }
    18921922    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)

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

    r81212 r81220  
    885885        rc = HGCMSvcGetU32(&paParms[1], &pOpenParms->fList);
    886886        if (RT_SUCCESS(rc))
    887             rc = HGCMSvcGetU32(&paParms[2], &cbPath);
    888         if (RT_SUCCESS(rc))
    889         {
    890             rc = HGCMSvcGetStr(&paParms[3], &pOpenParms->pszPath, &pOpenParms->cbPath);
     887            rc = HGCMSvcGetU32(&paParms[2], &cbFilter);
     888        if (RT_SUCCESS(rc))
     889        {
     890            rc = HGCMSvcGetStr(&paParms[3], &pOpenParms->pszFilter, &pOpenParms->cbFilter);
     891            AssertReturn(cbFilter == pOpenParms->cbFilter, VERR_INVALID_PARAMETER);
     892        }
     893        if (RT_SUCCESS(rc))
     894            rc = HGCMSvcGetU32(&paParms[4], &cbPath);
     895        if (RT_SUCCESS(rc))
     896        {
     897            rc = HGCMSvcGetStr(&paParms[5], &pOpenParms->pszPath, &pOpenParms->cbPath);
    891898            AssertReturn(cbPath == pOpenParms->cbPath, VERR_INVALID_PARAMETER);
    892899        }
    893         if (RT_SUCCESS(rc))
    894             rc = HGCMSvcGetU32(&paParms[4], &cbFilter);
    895         if (RT_SUCCESS(rc))
    896         {
    897             rc = HGCMSvcGetStr(&paParms[5], &pOpenParms->pszFilter, &pOpenParms->cbFilter);
    898             AssertReturn(cbFilter == pOpenParms->cbFilter, VERR_INVALID_PARAMETER);
    899         }
    900 
    901         if (RT_SUCCESS(rc))
    902         {
    903             /** @todo Some more validation. */
    904         }
     900
     901        /** @todo Some more validation. */
    905902    }
    906903    else
    … …  
    18621859            rc = shclSvcTransferGetError(cParms,paParms, &rcGuest);
    18631860            if (RT_SUCCESS(rc))
    1864                 LogRel(("Shared Clipboard: Transfer error: %Rrc\n", rcGuest));
     1861                LogRel(("Shared Clipboard: Transfer error from guest: %Rrc\n", rcGuest));
    18651862            break;
    18661863        }
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