VirtualBox

Ignore:
Timestamp:
Jul 10, 2019 1:02:50 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
131985
Message:

Shared Clipboard/URI: More code for root entries handling.

Location:
trunk/src/VBox/GuestHost/SharedClipboard
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r79630 r79672  
    246246    RTThreadUserSignal(RTThreadSelf());
    247247
     248    LogRel2(("Shared Clipboard: Calculating transfer ....\n"));
     249
    248250    int rc = SharedClipboardURITransferOpen(pTransfer);
    249251    if (RT_SUCCESS(rc))
    250252    {
    251         VBOXCLIPBOARDLISTOPENPARMS openParmsList;
    252         rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
     253        uint32_t cRoots;
     254        char    *pszRoots;
     255        rc = SharedClipboardURILTransferGetRoots(pTransfer, &pszRoots, &cRoots);
    253256        if (RT_SUCCESS(rc))
    254257        {
    255             SHAREDCLIPBOARDLISTHANDLE hList;
    256             rc = SharedClipboardURITransferListOpen(pTransfer, &openParmsList, &hList);
     258            SharedClipboardURIListRootEntries lstRoots = RTCString(pszRoots, strlen(pszRoots)).split("\r\n");
     259            Assert(lstRoots.size() == cRoots);
     260
     261            LogFlowFunc(("cRoots=%zu\n", lstRoots.size()));
     262
     263            for (uint32_t i = 0; i < lstRoots.size(); i++)
     264            {
     265                VBOXCLIPBOARDLISTOPENPARMS openParmsList;
     266                rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
     267                if (RT_SUCCESS(rc))
     268                {
     269                    LogFlowFunc(("pszRoot=%s\n", lstRoots[i].c_str()));
     270
     271                    rc = RTStrCopy(openParmsList.pszPath, openParmsList.cbPath, lstRoots[i].c_str());
     272                    if (RT_FAILURE(rc))
     273                        break;
     274
     275                    SHAREDCLIPBOARDLISTHANDLE hList;
     276                    rc = SharedClipboardURITransferListOpen(pTransfer, &openParmsList, &hList);
     277                    if (RT_SUCCESS(rc))
     278                    {
     279                        LogFlowFunc(("hList=%RU64\n", hList));
     280
     281                        VBOXCLIPBOARDLISTHDR hdrList;
     282                        rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
     283                        if (RT_SUCCESS(rc))
     284                        {
     285                            LogFlowFunc(("cTotalObjects=%RU64, cbTotalSize=%RU64\n\n",
     286                                         hdrList.cTotalObjects, hdrList.cbTotalSize));
     287
     288                            for (uint64_t i = 0; i < hdrList.cTotalObjects; i++)
     289                            {
     290                                VBOXCLIPBOARDLISTENTRY entryList;
     291                                rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
     292                                if (RT_SUCCESS(rc))
     293                                {
     294                                    PSHAREDCLIPBOARDFSOBJINFO pObjInfo = (PSHAREDCLIPBOARDFSOBJINFO)entryList.pvInfo;
     295                                    Assert(entryList.cbInfo == sizeof(SHAREDCLIPBOARDFSOBJINFO));
     296
     297                                    LogFlowFunc(("\t%s (%RU64 bytes)\n", entryList.pszName, pObjInfo->cbObject));
     298                                }
     299                                else
     300                                    break;
     301
     302                                if (pTransfer->Thread.fStop)
     303                                    break;
     304                            }
     305                        }
     306
     307                        SharedClipboardURITransferListClose(pTransfer, hList);
     308                    }
     309
     310                    SharedClipboardURIListOpenParmsDestroy(&openParmsList);
     311                }
     312
     313                if (RT_FAILURE(rc))
     314                    break;
     315            }
     316
    257317            if (RT_SUCCESS(rc))
    258318            {
    259                 LogFlowFunc(("hList=%RU64\n", hList));
    260 
    261                 VBOXCLIPBOARDLISTHDR hdrList;
    262                 rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
    263                 if (RT_SUCCESS(rc))
    264                 {
    265                     LogFlowFunc(("cTotalObjects=%RU64, cbTotalSize=%RU64\n\n",
    266                                  hdrList.cTotalObjects, hdrList.cbTotalSize));
    267 
    268                     for (uint64_t i = 0; i < hdrList.cTotalObjects; i++)
    269                     {
    270                         VBOXCLIPBOARDLISTENTRY entryList;
    271                         rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
    272                         if (RT_SUCCESS(rc))
    273                         {
    274                         }
    275                         else
    276                             break;
    277 
    278                         if (pTransfer->Thread.fStop)
    279                             break;
    280                     }
    281 
    282                     if (RT_SUCCESS(rc))
    283                     {
    284                         /*
    285                          * Signal the "list complete" event so that this data object can return (valid) data via ::GetData().
    286                          * This in turn then will create IStream instances (by the OS) for each file system object to handle.
    287                          */
    288                         int rc2 = RTSemEventSignal(pThis->m_EventListComplete);
    289                         AssertRC(rc2);
    290 
    291                         LogFlowFunc(("Waiting for transfer to complete ...\n"));
    292 
    293                         /* Transferring stuff can take a while, so don't use any timeout here. */
    294                         rc2 = RTSemEventWait(pThis->m_EventTransferComplete, RT_INDEFINITE_WAIT);
    295                         AssertRC(rc2);
    296                     }
    297                 }
    298 
    299                 SharedClipboardURITransferListClose(pTransfer, hList);
     319                LogRel2(("Shared Clipboard: Calculation complete, starting transfer ...\n"));
     320
     321                /*
     322                 * Signal the "list complete" event so that this data object can return (valid) data via ::GetData().
     323                 * This in turn then will create IStream instances (by the OS) for each file system object to handle.
     324                 */
     325                int rc2 = RTSemEventSignal(pThis->m_EventListComplete);
     326                AssertRC(rc2);
     327
     328                LogFlowFunc(("Waiting for transfer to complete ...\n"));
     329
     330                /* Transferring stuff can take a while, so don't use any timeout here. */
     331                rc2 = RTSemEventWait(pThis->m_EventTransferComplete, RT_INDEFINITE_WAIT);
     332                AssertRC(rc2);
    300333            }
    301334
    302             SharedClipboardURIListOpenParmsDestroy(&openParmsList);
     335            RTStrFree(pszRoots);
    303336        }
    304337

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

    r79630 r79672  
    3737
    3838
     39int SharedClipboardURIRootsInit(PVBOXCLIPBOARDROOTS pRoots)
     40{
     41    AssertPtrReturn(pRoots, VERR_INVALID_POINTER);
     42
     43    RT_BZERO(pRoots, sizeof(VBOXCLIPBOARDROOTS));
     44
     45    const uint32_t cbRoots = _64K;
     46
     47    pRoots->pszRoots = RTStrAlloc(cbRoots);
     48    if (!pRoots->pszRoots)
     49        return VERR_NO_MEMORY;
     50
     51    pRoots->cbRoots = cbRoots;
     52
     53    return VINF_SUCCESS;
     54}
     55
     56void SharedClipboardURIRootsDestroy(PVBOXCLIPBOARDROOTS pRoots)
     57{
     58    if (!pRoots)
     59        return;
     60
     61    if (pRoots->pszRoots)
     62        RTStrFree(pRoots->pszRoots);
     63}
     64
     65PVBOXCLIPBOARDROOTS SharedClipboardURIRootsDup(PVBOXCLIPBOARDROOTS pRoots)
     66{
     67    AssertPtrReturn(pRoots, NULL);
     68
     69    int rc = VINF_SUCCESS;
     70
     71    PVBOXCLIPBOARDROOTS pRootsDup = (PVBOXCLIPBOARDROOTS)RTMemAlloc(sizeof(VBOXCLIPBOARDROOTS));
     72    if (pRootsDup)
     73    {
     74        *pRootsDup = *pRoots;
     75
     76        if (pRoots->pszRoots)
     77        {
     78            pRootsDup->pszRoots = RTStrDup(pRoots->pszRoots);
     79            if (!pRootsDup->pszRoots)
     80                rc = VERR_NO_MEMORY;
     81        }
     82    }
     83
     84    if (RT_FAILURE(rc))
     85    {
     86        if (pRootsDup->pszRoots)
     87            RTStrFree(pRootsDup->pszRoots);
     88
     89        RTMemFree(pRootsDup);
     90        pRootsDup = NULL;
     91    }
     92
     93    return pRootsDup;
     94}
     95
    3996/**
    4097 * Allocates a VBOXCLIPBOARDListHdr structure.
    … …  
    287344    *pDst = *pSrc;
    288345
    289     if (pSrc->pvInfo)
     346    if (pSrc->pszName)
     347    {
     348        pDst->pszName = RTStrDup(pSrc->pszName);
     349        if (!pDst->pszName)
     350            rc = VERR_NO_MEMORY;
     351    }
     352
     353    if (   RT_SUCCESS(rc)
     354        && pSrc->pvInfo)
    290355    {
    291356        pDst->pvInfo = RTMemDup(pSrc->pvInfo, pSrc->cbInfo);
    … …  
    341406 * Initializes a clipboard list entry structure.
    342407 *
    343  * @param   pListEntry          clipboard list entry structure to initialize.
     408 * @returns VBox status code.
     409 * @param   pListEntry          Clipboard list entry structure to initialize.
    344410 */
    345411int SharedClipboardURIListEntryInit(PVBOXCLIPBOARDLISTENTRY pListEntry)
    … …  
    347413    RT_BZERO(pListEntry, sizeof(VBOXCLIPBOARDLISTENTRY));
    348414
     415    pListEntry->pszName = RTStrAlloc(VBOXCLIPBOARDLISTENTRY_MAX_NAME);
     416    if (!pListEntry->pszName)
     417        return VERR_NO_MEMORY;
     418
     419    pListEntry->cbName = VBOXCLIPBOARDLISTENTRY_MAX_NAME;
     420
    349421    return VINF_SUCCESS;
    350422}
    … …  
    353425 * Initializes a clipboard list entry structure.
    354426 *
    355  * @param   pListEntry          clipboard list entry structure to destroy.
     427 * @param   pListEntry          Clipboard list entry structure to destroy.
    356428 */
    357429void SharedClipboardURIListEntryDestroy(PVBOXCLIPBOARDLISTENTRY pListEntry)
    … …  
    359431    if (!pListEntry)
    360432        return;
     433
     434    if (pListEntry->pszName)
     435    {
     436        RTStrFree(pListEntry->pszName);
     437
     438        pListEntry->pszName = NULL;
     439        pListEntry->cbName  = 0;
     440    }
    361441
    362442    if (pListEntry->pvInfo)
    … …  
    382462    return true; /** @todo Implement this. */
    383463}
    384 
    385 #if 0
    386 /**
    387  * Creates (allocates) and initializes a VBOXCLIPBOARDDIRDATA structure.
    388  *
    389  * @param   ppDirData           Where to return the created VBOXCLIPBOARDDIRDATA structure on success.
    390  */
    391 int SharedClipboardURIDirDataAlloc(PVBOXCLIPBOARDDIRDATA *ppDirData)
    392 {
    393     PVBOXCLIPBOARDDIRDATA pDirData = (PVBOXCLIPBOARDDIRDATA)RTMemAlloc(sizeof(VBOXCLIPBOARDDIRDATA));
    394     if (!pDirData)
    395         return VERR_NO_MEMORY;
    396 
    397     int rc = SharedClipboardURIDirDataInit(pDirData);
    398     if (RT_SUCCESS(rc))
    399         *ppDirData = pDirData;
    400 
    401     return rc;
    402 }
    403 
    404 /**
    405  * Frees a VBOXCLIPBOARDDIRDATA structure.
    406  *
    407  * @param   pDirData           Where to return the created VBOXCLIPBOARDDIRDATA structure on success.
    408  */
    409 void SharedClipboardURIDirDataFree(PVBOXCLIPBOARDDIRDATA pDirData)
    410 {
    411     if (!pDirData)
    412         return;
    413 
    414     SharedClipboardURIDirDataDestroy(pDirData);
    415     RTMemFree(pDirData);
    416 }
    417 
    418 /**
    419  * Initializes a VBOXCLIPBOARDDIRDATA structure.
    420  *
    421  * @param   pDirData            VBOXCLIPBOARDDIRDATA structure to initialize.
    422  */
    423 int SharedClipboardURIDirDataInit(PVBOXCLIPBOARDDIRDATA pDirData)
    424 {
    425     RT_BZERO(pDirData, sizeof(VBOXCLIPBOARDDIRDATA));
    426 
    427     return VINF_SUCCESS;
    428 }
    429 
    430 /**
    431  * Destroys a VBOXCLIPBOARDDIRDATA structure.
    432  *
    433  * @param   pDirData            VBOXCLIPBOARDDIRDATA structure to destroy.
    434  */
    435 void SharedClipboardURIDirDataDestroy(PVBOXCLIPBOARDDIRDATA pDirData)
    436 {
    437     if (!pDirData)
    438         return;
    439 
    440     if (pDirData->pszPath)
    441     {
    442         Assert(pDirData->cbPath);
    443         RTStrFree(pDirData->pszPath);
    444         pDirData->pszPath = NULL;
    445     }
    446 }
    447 
    448 /**
    449  * Duplicates (allocates) a VBOXCLIPBOARDDIRDATA structure.
    450  *
    451  * @returns Duplicated VBOXCLIPBOARDDIRDATA structure on success.
    452  * @param   pDirData            VBOXCLIPBOARDDIRDATA to duplicate.
    453  */
    454 PVBOXCLIPBOARDDIRDATA SharedClipboardURIDirDataDup(PVBOXCLIPBOARDDIRDATA pDirData)
    455 {
    456     AssertPtrReturn(pDirData, NULL);
    457 
    458     PVBOXCLIPBOARDDIRDATA pDirDataDup = (PVBOXCLIPBOARDDIRDATA)RTMemAllocZ(sizeof(VBOXCLIPBOARDDIRDATA));
    459     if (pDirDataDup)
    460     {
    461         *pDirDataDup = *pDirData;
    462 
    463         if (pDirData->pszPath)
    464         {
    465             pDirDataDup->pszPath = RTStrDup(pDirData->pszPath);
    466             if (pDirDataDup->pszPath)
    467                 pDirDataDup->cbPath = pDirData->cbPath;
    468         }
    469     }
    470 
    471     return pDirDataDup;
    472 }
    473 
    474 /**
    475  * Returns whether given clipboard directory data is valid or not.
    476  *
    477  * @returns \c true if valid, \c false if not.
    478  * @param   pDirData            Clipboard directory data to validate.
    479  */
    480 bool SharedClipboardURIDirDataIsValid(PVBOXCLIPBOARDDIRDATA pDirData)
    481 {
    482     if (   !pDirData->cbPath
    483         || pDirData->cbPath > RTPATH_MAX)
    484         return false;
    485 
    486     if (!RTStrIsValidEncoding(pDirData->pszPath))
    487         return false;
    488 
    489     return true;
    490 }
    491 
    492 /**
    493  * Initializes a VBOXCLIPBOARDFILEHDR structure.
    494  *
    495  * @param   pDirData            VBOXCLIPBOARDFILEHDR structure to initialize.
    496  */
    497 int SharedClipboardURIFileHdrInit(PVBOXCLIPBOARDFILEHDR pFileHdr)
    498 {
    499     RT_BZERO(pFileHdr, sizeof(VBOXCLIPBOARDFILEHDR));
    500 
    501     return VINF_SUCCESS;
    502 }
    503 
    504 /**
    505  * Destroys a VBOXCLIPBOARDFILEHDR structure.
    506  *
    507  * @param   pFileHdr            VBOXCLIPBOARDFILEHDR structure to destroy.
    508  */
    509 void SharedClipboardURIFileHdrDestroy(PVBOXCLIPBOARDFILEHDR pFileHdr)
    510 {
    511     if (!pFileHdr)
    512         return;
    513 
    514     if (pFileHdr->pszFilePath)
    515     {
    516         Assert(pFileHdr->pszFilePath);
    517         RTStrFree(pFileHdr->pszFilePath);
    518         pFileHdr->pszFilePath = NULL;
    519     }
    520 }
    521 
    522 /**
    523  * Frees a VBOXCLIPBOARDFILEHDR structure.
    524  *
    525  * @param   pFileHdr            VBOXCLIPBOARDFILEHDR structure to free.
    526  */
    527 void SharedClipboardURIFileHdrFree(PVBOXCLIPBOARDFILEHDR pFileHdr)
    528 {
    529     if (!pFileHdr)
    530         return;
    531 
    532     SharedClipboardURIFileHdrDestroy(pFileHdr);
    533 
    534     RTMemFree(pFileHdr);
    535     pFileHdr = NULL;
    536 }
    537 
    538 /**
    539  * Duplicates (allocates) a VBOXCLIPBOARDFILEHDR structure.
    540  *
    541  * @returns Duplicated VBOXCLIPBOARDFILEHDR structure on success.
    542  * @param   pFileHdr            VBOXCLIPBOARDFILEHDR to duplicate.
    543  */
    544 PVBOXCLIPBOARDFILEHDR SharedClipboardURIFileHdrDup(PVBOXCLIPBOARDFILEHDR pFileHdr)
    545 {
    546     AssertPtrReturn(pFileHdr, NULL);
    547 
    548     PVBOXCLIPBOARDFILEHDR pFileHdrDup = (PVBOXCLIPBOARDFILEHDR)RTMemAllocZ(sizeof(VBOXCLIPBOARDFILEHDR));
    549     if (pFileHdrDup)
    550     {
    551         *pFileHdrDup = *pFileHdr;
    552 
    553         if (pFileHdr->pszFilePath)
    554         {
    555             pFileHdrDup->pszFilePath = RTStrDup(pFileHdr->pszFilePath);
    556             if (pFileHdrDup->pszFilePath)
    557                 pFileHdrDup->cbFilePath = pFileHdrDup->cbFilePath;
    558         }
    559     }
    560 
    561     return pFileHdrDup;
    562 }
    563 
    564 /**
    565  * Returns whether a given clipboard file header is valid or not.
    566  *
    567  * @returns \c true if valid, \c false if not.
    568  * @param   pFileHdr            Clipboard file header to validate.
    569  * @param   pListHdr            Data header to use for validation.
    570  */
    571 bool SharedClipboardURIFileHdrIsValid(PVBOXCLIPBOARDFILEHDR pFileHdr, PVBOXCLIPBOARDLISTHDR pListHdr)
    572 {
    573     if (   !pFileHdr->cbFilePath
    574         || pFileHdr->cbFilePath > RTPATH_MAX)
    575         return false;
    576 
    577     if (!RTStrIsValidEncoding(pFileHdr->pszFilePath))
    578         return false;
    579 
    580     if (pFileHdr->cbSize > pListHdr->cbTotalSize)
    581         return false;
    582 
    583     return true;
    584 }
    585 
    586 /**
    587  * Destroys a VBOXCLIPBOARDFILEDATA structure.
    588  *
    589  * @param   pFileData           VBOXCLIPBOARDFILEDATA structure to destroy.
    590  */
    591 void SharedClipboardURIFileDataDestroy(PVBOXCLIPBOARDFILEDATA pFileData)
    592 {
    593     if (!pFileData)
    594         return;
    595 
    596     if (pFileData->pvData)
    597     {
    598         Assert(pFileData->cbData);
    599         RTMemFree(pFileData->pvData);
    600         pFileData->pvData = NULL;
    601     }
    602 }
    603 
    604 /**
    605  * Duplicates (allocates) a VBOXCLIPBOARDFILEDATA structure.
    606  *
    607  * @returns Duplicated VBOXCLIPBOARDFILEDATA structure on success.
    608  * @param   pFileData           VBOXCLIPBOARDFILEDATA to duplicate.
    609  */
    610 PVBOXCLIPBOARDFILEDATA SharedClipboardURIFileDataDup(PVBOXCLIPBOARDFILEDATA pFileData)
    611 {
    612     AssertPtrReturn(pFileData, NULL);
    613 
    614     PVBOXCLIPBOARDFILEDATA pFileDataDup = (PVBOXCLIPBOARDFILEDATA)RTMemAllocZ(sizeof(VBOXCLIPBOARDFILEDATA));
    615     if (pFileDataDup)
    616     {
    617         *pFileDataDup = *pFileData;
    618 
    619         if (pFileData->pvData)
    620         {
    621             pFileDataDup->pvData = RTMemDup(pFileData->pvData, pFileData->cbData);
    622             if (pFileDataDup->pvData)
    623                 pFileDataDup->cbData = pFileDataDup->cbData;
    624         }
    625 
    626         if (pFileData->pvChecksum)
    627         {
    628             pFileDataDup->pvChecksum = RTMemDup(pFileData->pvChecksum, pFileData->cbChecksum);
    629             if (pFileDataDup->pvChecksum)
    630                 pFileDataDup->cbChecksum = pFileData->cbChecksum;
    631         }
    632     }
    633 
    634     return pFileDataDup;
    635 }
    636 
    637 /**
    638  * Returns whether given clipboard file data is valid or not.
    639  *
    640  * @returns \c true if valid, \c false if not.
    641  * @param   pFileData           Clipboard file data to validate.
    642  * @param   pListHdr            Data header to use for validation.
    643  */
    644 bool SharedClipboardURIFileDataIsValid(PVBOXCLIPBOARDFILEDATA pFileData, PVBOXCLIPBOARDLISTHDR pListHdr)
    645 {
    646     RT_NOREF(pFileData, pListHdr);
    647     return true;
    648 }
    649 #endif
    650464
    651465/**
    … …  
    806620}
    807621
     622/**
     623 * Creates a new list handle (local only).
     624 *
     625 * @returns New List handle on success, or SHAREDCLIPBOARDLISTHANDLE_INVALID on error.
     626 * @param   pTransfer           URI clipboard transfer to create new list handle for.
     627 */
    808628static SHAREDCLIPBOARDLISTHANDLE sharedClipboardURITransferListHandleNew(PSHAREDCLIPBOARDURITRANSFER pTransfer)
    809629{
    … …  
    813633}
    814634
     635/**
     636 * Opens a list.
     637 *
     638 * @returns VBox status code.
     639 * @param   pTransfer           URI clipboard transfer to handle.
     640 * @param   pOpenParms          List open parameters to use for opening.
     641 * @param   phList              Where to store the List handle of opened list on success.
     642 */
    815643int SharedClipboardURITransferListOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms,
    816644                                       PSHAREDCLIPBOARDLISTHANDLE phList)
    … …  
    830658        if (pInfo)
    831659        {
    832             if (   !pOpenParms->pszPath
    833                 || !strlen(pOpenParms->pszPath))
    834                 RTStrAPrintf(&pOpenParms->pszPath, "C:\\Temp"); /** @todo FIX !!!! */
    835 
    836660            RTFSOBJINFO objInfo;
    837661            rc = RTPathQueryInfo(pOpenParms->pszPath, &objInfo, RTFSOBJATTRADD_NOTHING);
    … …  
    842666            else if (RTFS_IS_FILE(objInfo.Attr.fMode))
    843667            {
    844                 rc = RTFileOpen(&pInfo->u.Local.hFile, pOpenParms->pszPath, RTFILE_O_READ | RTFILE_O_DENY_WRITE);
     668                rc = RTFileOpen(&pInfo->u.Local.hFile, pOpenParms->pszPath,
     669                                RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
    845670            }
    846671            else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode))
    … …  
    902727}
    903728
     729/**
     730 * Closes a list.
     731 *
     732 * @returns VBox status code.
     733 * @param   pTransfer           URI clipboard transfer to handle.
     734 * @param   hList               Handle of list to close.
     735 */
    904736int SharedClipboardURITransferListClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList)
    905737{
    … …  
    943775}
    944776
     777/**
     778 * Adds a file to a list heaer.
     779 *
     780 * @returns VBox status code.
     781 * @param   pHdr                List header to add file to.
     782 * @param   pszPath             Path of file to add.
     783 */
    945784static int sharedClipboardURITransferListHdrAddFile(PVBOXCLIPBOARDLISTHDR pHdr, const char *pszPath)
    946785{
    … …  
    957796}
    958797
     798/**
     799 * Builds a list header, internal version.
     800 *
     801 * @returns VBox status code.
     802 * @param   pHdr                Where to store the build list header.
     803 * @param   pcszSrcPath         Source path of list.
     804 * @param   pcszDstPath         Destination path of list.
     805 * @param   pcszDstBase         Destination base path.
     806 * @param   cchDstBase          Number of charaters of destination base path.
     807 */
    959808static int sharedClipboardURITransferListHdrFromDir(PVBOXCLIPBOARDLISTHDR pHdr,
    960809                                                    const char *pcszSrcPath, const char *pcszDstPath,
    … …  
    1067916}
    1068917
     918/**
     919 * Retrieves the header of a Shared Clipboard list.
     920 *
     921 * @returns VBox status code.
     922 * @param   pTransfer           URI clipboard transfer to handle.
     923 * @param   hList               Handle of list to get header for.
     924 * @param   pHdr                Where to store the returned list header information.
     925 */
    1069926int SharedClipboardURITransferListGetHeader(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
    1070927                                            PVBOXCLIPBOARDLISTHDR pHdr)
    … …  
    11741031}
    11751032
     1033/**
     1034 * Reads a single Shared Clipboard list entry.
     1035 *
     1036 * @returns VBox status code.
     1037 * @param   pTransfer           URI clipboard transfer to handle.
     1038 * @param   hList               List handle of list to read from.
     1039 * @param   pEntry              Where to store the read information.
     1040 */
    11761041int SharedClipboardURITransferListRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
    11771042                                       PVBOXCLIPBOARDLISTENTRY pEntry)
    … …  
    11921057            AssertPtr(pInfo);
    11931058
     1059            LogFlowFunc(("\tfMode=%RU32, pszPath=%s\n", pInfo->fMode, pInfo->OpenParms.pszPath));
     1060
    11941061            if (RTFS_IS_DIRECTORY(pInfo->fMode))
    11951062            {
    1196                 size_t        cbDirEntry = 0;
    1197                 PRTDIRENTRYEX pDirEntry  = NULL;
    1198                 rc = RTDirReadExA(pInfo->u.Local.hDirRoot, &pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
    1199                 if (RT_SUCCESS(rc))
     1063                for (;;)
    12001064                {
    1201                     switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
     1065                    bool fSkipEntry = false; /* Whether to skip an entry in the enumeration. */
     1066
     1067                    size_t        cbDirEntry = 0;
     1068                    PRTDIRENTRYEX pDirEntry  = NULL;
     1069                    rc = RTDirReadExA(pInfo->u.Local.hDirRoot, &pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
     1070                    if (RT_SUCCESS(rc))
    12021071                    {
    1203                         case RTFS_TYPE_DIRECTORY:
     1072                        switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
    12041073                        {
    1205                             /* Skip "." and ".." entries. */
    1206                             if (RTDirEntryExIsStdDotLink(pDirEntry))
     1074                            case RTFS_TYPE_DIRECTORY:
     1075                            {
     1076                                LogFlowFunc(("Directory: %s\n", pDirEntry->szName));
     1077
     1078                                /* Skip "." and ".." entries. */
     1079                                if (RTDirEntryExIsStdDotLink(pDirEntry))
     1080                                    fSkipEntry = true;
     1081
     1082                                RT_FALL_THROUGH();
     1083                            }
     1084
     1085                            case RTFS_TYPE_FILE:
     1086                            {
     1087                                LogFlowFunc(("File: %s\n", pDirEntry->szName));
     1088
     1089                                pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
     1090                                if (pEntry->pvInfo)
     1091                                {
     1092                                    rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pDirEntry->szName);
     1093                                    if (RT_SUCCESS(rc))
     1094                                    {
     1095                                        SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
     1096
     1097                                        pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
     1098                                        pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
     1099                                    }
     1100                                }
     1101                                else
     1102                                    rc = VERR_NO_MEMORY;
    12071103                                break;
    1208 
    1209                             RT_FALL_THROUGH();
     1104                            }
     1105
     1106                            case RTFS_TYPE_SYMLINK:
     1107                            {
     1108                                /** @todo Not implemented yet. */
     1109                                break;
     1110                            }
     1111
     1112                            default:
     1113                                break;
    12101114                        }
    12111115
    1212                         case RTFS_TYPE_FILE:
    1213                         {
    1214                             pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
    1215                             if (pEntry->pvInfo)
    1216                             {
    1217                                 SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
    1218 
    1219                                 pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
    1220                                 pEntry->fInfo  = 0; /** @todo Implement. */
    1221                             }
    1222                             else
    1223                                 rc = VERR_NO_MEMORY;
    1224                             break;
    1225                         }
    1226 
    1227                         case RTFS_TYPE_SYMLINK:
    1228                         {
    1229                             /** @todo Not implemented yet. */
    1230                             break;
    1231                         }
    1232 
    1233                         default:
    1234                             break;
     1116                        RTDirReadExAFree(&pDirEntry, &cbDirEntry);
    12351117                    }
    12361118
    1237                     RTDirReadExAFree(&pDirEntry, &cbDirEntry);
     1119                    if (   !fSkipEntry /* Do we have a valid entry? Bail out. */
     1120                        || RT_FAILURE(rc))
     1121                    {
     1122                        break;
     1123                    }
    12381124                }
    12391125            }
    12401126            else if (RTFS_IS_FILE(pInfo->fMode))
    12411127            {
     1128                LogFlowFunc(("\tSingle file: %s\n", pInfo->OpenParms.pszPath));
     1129
    12421130                RTFSOBJINFO objInfo;
    12431131                rc = RTFileQueryInfo(pInfo->u.Local.hFile, &objInfo, RTFSOBJATTRADD_NOTHING);
    … …  
    12471135                    if (pEntry->pvInfo)
    12481136                    {
    1249                         SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &objInfo);
    1250 
    1251                         pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
    1252                         pEntry->fInfo  = 0; /** @todo Implement. */
     1137                        rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pInfo->OpenParms.pszPath);
     1138                        if (RT_SUCCESS(rc))
     1139                        {
     1140                            SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &objInfo);
     1141
     1142                            pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
     1143                            pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
     1144                        }
    12531145                    }
    12541146                    else
    … …  
    12941186}
    12951187
     1188/**
     1189 * Returns whether a given list handle is valid or not.
     1190 *
     1191 * @returns \c true if list handle is valid, \c false if not.
     1192 * @param   pTransfer           URI clipboard transfer to handle.
     1193 * @param   hList               List handle to check.
     1194 */
    12961195bool SharedClipboardURITransferListHandleIsValid(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList)
    12971196{
    … …  
    13731272}
    13741273
     1274int SharedClipboardURILTransferSetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
     1275{
     1276    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     1277    AssertPtrReturn(pszRoots,  VERR_INVALID_POINTER);
     1278    AssertReturn(cbRoots,      VERR_INVALID_PARAMETER);
     1279
     1280    if (!RTStrIsValidEncoding(pszRoots))
     1281        return VERR_INVALID_PARAMETER;
     1282
     1283    int rc = VINF_SUCCESS;
     1284
     1285    pTransfer->lstRootEntries.clear();
     1286
     1287    pTransfer->lstRootEntries = RTCString(pszRoots, cbRoots - 1).split("\r\n");
     1288
     1289    LogFlowFunc(("cRoots=%RU32\n", pTransfer->lstRootEntries.size()));
     1290
     1291    LogFlowFuncLeaveRC(rc);
     1292    return rc;
     1293}
     1294
    13751295/**
    13761296 * Resets an clipboard URI transfer.
    … …  
    13981318
    13991319    return pTransfer->pArea;
     1320}
     1321
     1322int SharedClipboardURILTransferGetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, char **ppszRoots, uint32_t *pcRoots)
     1323{
     1324    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     1325    AssertPtrReturn(ppszRoots, VERR_INVALID_POINTER);
     1326
     1327    int rc = VINF_SUCCESS;
     1328
     1329    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
     1330    {
     1331        char *pszRoots = NULL;
     1332
     1333        for (size_t i = 0; i < pTransfer->lstRootEntries.size(); ++i)
     1334        {
     1335            if (pszRoots)
     1336                rc = RTStrAAppend(&pszRoots, "\r\n");
     1337            if (RT_SUCCESS(rc))
     1338                rc = RTStrAAppend(&pszRoots, pTransfer->lstRootEntries.at(i).c_str());
     1339
     1340            if (RT_FAILURE(rc))
     1341                break;
     1342        }
     1343
     1344        if (RT_SUCCESS(rc))
     1345        {
     1346            LogFlowFunc(("Roots (%RU32):\n%s\n", pTransfer->lstRootEntries.size(), pszRoots));
     1347
     1348            *ppszRoots = pszRoots;
     1349            *pcRoots     = (uint32_t)pTransfer->lstRootEntries.size();
     1350        }
     1351        else
     1352        {
     1353            if (pszRoots)
     1354                RTStrFree(pszRoots);
     1355        }
     1356    }
     1357    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
     1358    {
     1359        if (pTransfer->ProviderIface.pfnGetRoots)
     1360            rc = pTransfer->ProviderIface.pfnGetRoots(&pTransfer->ProviderCtx, ppszRoots, pcRoots);
     1361        else
     1362            rc = VERR_NOT_SUPPORTED;
     1363    }
     1364
     1365    LogFlowFuncLeaveRC(rc);
     1366    return rc;
    14001367}
    14011368
    … …  
    15371504    }
    15381505    else
    1539         rc = VERR_ALREADY_EXISTS;
     1506        rc = VINF_SUCCESS;
    15401507
    15411508    LogFlowFuncLeaveRC(rc);

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

    r79497 r79672  
    10301030            LogRel(("Shared Clipboard: Adding guest file '%s'\n", pszFileUtf8));
    10311031
    1032         #if 0
    1033             char    *pszFileURI;
    1034             uint32_t cchFileURI;
    1035             rc = SharedClipboardMetaDataConvertToFormat(pszFileUtf8, strlen(pszFileUtf8), SHAREDCLIPBOARDMETADATAFMT_URI_LIST,
    1036                                                         (void **)&pszFileURI, &cchFileURI);
    1037             if (RT_SUCCESS(rc))
    1038             {
    1039                 LogFlowFunc(("\tURI is: %s (%RU32)\n", pszFileURI, cchFileURI));
    1040 
    1041                 rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */, pszFileURI, cchFileURI);
    1042                 if (RT_SUCCESS(rc))
    1043                     cchFiles += cchFileURI;
    1044 
    1045                 RTStrFree(pszFileURI);
    1046             }
    1047         #endif
     1032            rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */, pszFileUtf8, strlen(pszFileUtf8));
     1033            cchFiles += (uint32_t)strlen(pszFileUtf8);
    10481034        }
    10491035
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