VirtualBox

Changeset 106237 in vbox for trunk/src/VBox/HostServices


Ignore:
Timestamp:
Oct 8, 2024 2:08:34 PM (5 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
165026
Message:

HostServices/SharedFolders: Added a missing check to vbsfCopyFile() to
verify that the share is writable before proceeding. Also updated
the test suite (tstSharedFolderService) to verify that vbsfCopyFile()
fails when attempting to write to a read-only share. bugref:10739

Location:
trunk/src/VBox/HostServices/SharedFolders
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.cpp

    r106061 r106237  
    595595}
    596596
     597extern int testRTFileCopy(const char *pszSrc, const char *pszDst)
     598{
     599    if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszSrc, "/\\"))
     600        && !RTStrIsLowerCased(strpbrk(pszDst, "/\\")))
     601        return VERR_FILE_NOT_FOUND;
     602    RT_NOREF2(pszSrc, pszDst);
     603    return 0;
     604}
     605
    597606
    598607/*********************************************************************************************************************************
    … …  
    727736                                   + Mapping.string.u16Size);
    728737    HGCMSvcSetU32(&aParms[2], SHFL_ADD_MAPPING_F_WRITABLE | SHFL_ADD_MAPPING_F_CREATE_SYMLINKS);
     738    HGCMSvcSetPv(&aParms[3], &AutoMountPoint, SHFLSTRING_HEADER_SIZE + AutoMountPoint.string.u16Size);
     739    HGCMSvcSetU32(&aParms[4], enmSymlinkPolicy);
     740    rc = psvcTable->pfnHostCall(psvcTable->pvService, SHFL_FN_ADD_MAPPING,
     741                                SHFL_CPARMS_ADD_MAPPING, aParms);
     742    AssertReleaseRC(rc);
     743    HGCMSvcSetPv(&aParms[0], &Mapping,   RT_UOFFSETOF(SHFLSTRING, String)
     744                                   + Mapping.string.u16Size);
     745    HGCMSvcSetU32(&aParms[1], 0);  /* root */
     746    HGCMSvcSetU32(&aParms[2], '/');  /* delimiter */
     747    HGCMSvcSetU32(&aParms[3], fCaseSensitive);
     748    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
     749                       psvcTable->pvService, SHFL_FN_MAP_FOLDER,
     750                       SHFL_CPARMS_MAP_FOLDER, aParms, 0);
     751    AssertReleaseRC(callHandle.rc);
     752    return aParms[1].u.uint32;
     753}
     754
     755static SHFLROOT initWithUnwritableMapping(RTTEST hTest,
     756                                          VBOXHGCMSVCFNTABLE *psvcTable,
     757                                          VBOXHGCMSVCHELPERS *psvcHelpers,
     758                                          const char *pcszFolderName,
     759                                          const char *pcszMapping,
     760                                          bool fCaseSensitive = true,
     761                                          SymlinkPolicy_T enmSymlinkPolicy = SymlinkPolicy_AllowedToAnyTarget)
     762{
     763    VBOXHGCMSVCPARM aParms[RT_MAX(SHFL_CPARMS_ADD_MAPPING,
     764                                  SHFL_CPARMS_MAP_FOLDER)];
     765    union TESTSHFLSTRING FolderName;
     766    union TESTSHFLSTRING Mapping;
     767    union TESTSHFLSTRING AutoMountPoint;
     768    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
     769    int rc;
     770
     771    initTable(psvcTable, psvcHelpers);
     772    rc = VBoxHGCMSvcLoad(psvcTable);
     773    AssertReleaseRC(rc);
     774    AssertRelease(  psvcTable->pvService
     775                  = RTTestGuardedAllocTail(hTest, psvcTable->cbClient));
     776    RT_BZERO(psvcTable->pvService, psvcTable->cbClient);
     777    fillTestShflString(&FolderName, pcszFolderName);
     778    fillTestShflString(&Mapping, pcszMapping);
     779    fillTestShflString(&AutoMountPoint, "");
     780    HGCMSvcSetPv(&aParms[0], &FolderName,   RT_UOFFSETOF(SHFLSTRING, String)
     781                                      + FolderName.string.u16Size);
     782    HGCMSvcSetPv(&aParms[1], &Mapping,   RT_UOFFSETOF(SHFLSTRING, String)
     783                                   + Mapping.string.u16Size);
     784    HGCMSvcSetU32(&aParms[2], SHFL_ADD_MAPPING_F_CREATE_SYMLINKS);
    729785    HGCMSvcSetPv(&aParms[3], &AutoMountPoint, SHFLSTRING_HEADER_SIZE + AutoMountPoint.string.u16Size);
    730786    HGCMSvcSetU32(&aParms[4], enmSymlinkPolicy);
    … …  
    795851        *pResult = CreateParms.Result;
    796852    return VINF_SUCCESS;
     853}
     854
     855static int fileCopy(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT Root,
     856                    const char *pcszSrcFilename, const char *pcszDstFilename)
     857{
     858    VBOXHGCMSVCPARM aParms[SHFL_CPARMS_COPY_FILE];
     859    union TESTSHFLSTRING srcPath;
     860    union TESTSHFLSTRING dstPath;
     861    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
     862
     863    fillTestShflString(&srcPath, pcszSrcFilename);
     864    fillTestShflString(&dstPath, pcszDstFilename);
     865
     866    HGCMSvcSetU32(&aParms[0], Root);
     867    HGCMSvcSetPv(&aParms[1], &srcPath,   RT_UOFFSETOF(SHFLSTRING, String)
     868                                + srcPath.string.u16Size);
     869    HGCMSvcSetU32(&aParms[2], Root);
     870    HGCMSvcSetPv(&aParms[3], &dstPath,   RT_UOFFSETOF(SHFLSTRING, String)
     871                                + dstPath.string.u16Size);
     872    HGCMSvcSetU32(&aParms[4], 0);
     873    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
     874                       psvcTable->pvService, SHFL_FN_COPY_FILE,
     875                       RT_ELEMENTS(aParms), aParms, 0);
     876    return callHandle.rc;
    797877}
    798878
    … …  
    10561136}
    10571137
     1138void testCopyFileReadWrite(RTTEST hTest)
     1139{
     1140    VBOXHGCMSVCFNTABLE  svcTable;
     1141    VBOXHGCMSVCHELPERS  svcHelpers;
     1142    SHFLROOT Root;
     1143    const RTFILE hFile = (RTFILE) 0x10000;
     1144    SHFLCREATERESULT Result;
     1145    int rc;
     1146
     1147    RTTestSub(hTest, "Test copying files (RTFileCopy()) to a writable share");
     1148    Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
     1149                                   "/test/mapping", "testname");
     1150    rc = fileCopy(&svcTable, Root, "file", "file-copy");
     1151    RTTEST_CHECK_RC_OK(hTest, rc);
     1152
     1153    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
     1154    rc = svcTable.pfnDisconnect(NULL, 0, svcTable.pvService);
     1155    AssertReleaseRC(rc);
     1156    rc = svcTable.pfnUnload(NULL);
     1157    AssertReleaseRC(rc);
     1158    RTTestGuardedFree(hTest, svcTable.pvService);
     1159    RTTEST_CHECK_MSG(hTest, g_testRTFileClose_hFile == hFile,
     1160                     (hTest, "File=%u\n", (uintptr_t)g_testRTFileClose_hFile));
     1161}
     1162
     1163void testCopyFileReadOnly(RTTEST hTest)
     1164{
     1165    VBOXHGCMSVCFNTABLE  svcTable;
     1166    VBOXHGCMSVCHELPERS  svcHelpers;
     1167    SHFLROOT Root;
     1168    SHFLCREATERESULT Result;
     1169    int rc;
     1170
     1171    RTTestSub(hTest, "Test copying files (RTFileCopy()) to a read-only share");
     1172    Root = initWithUnwritableMapping(hTest, &svcTable, &svcHelpers,
     1173                                     "/test/mapping", "testname");
     1174    rc = fileCopy(&svcTable, Root, "file", "file-copy");
     1175    RTTEST_CHECK_MSG(hTest, rc == VERR_WRITE_PROTECT,
     1176                     (hTest, "RTFileCopy() copied a file to a read-only share: rc=%Rrc\n", rc));
     1177
     1178    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
     1179    rc = svcTable.pfnDisconnect(NULL, 0, svcTable.pvService);
     1180    AssertReleaseRC(rc);
     1181    rc = svcTable.pfnUnload(NULL);
     1182    AssertReleaseRC(rc);
     1183    RTTestGuardedFree(hTest, svcTable.pvService);
     1184}
     1185
    10581186static int testSymlinkCreationForSpecificPolicy(RTTEST hTest, SymlinkPolicy_T enmSymlinkPolicy)
    10591187{
    … …  
    11401268    for (size_t i = 0; i < RT_ELEMENTS(aEnmSymlinkPolicy); i++)
    11411269        testSymlinkCreationForSpecificPolicy(hTest, aEnmSymlinkPolicy[i]);
     1270}
     1271
     1272void testSymlinkReadOnlyCreation(RTTEST hTest)
     1273{
     1274    VBOXHGCMSVCFNTABLE  svcTable;
     1275    VBOXHGCMSVCHELPERS  svcHelpers;
     1276    SHFLROOT Root;
     1277    SHFLCREATERESULT Result;
     1278    int rc;
     1279
     1280    RTTestSub(hTest, "Test creating symlink in a read-only share");
     1281    Root = initWithUnwritableMapping(hTest, &svcTable, &svcHelpers,
     1282                                     "/test/mapping", "testname");
     1283
     1284    rc = createSymlink(&svcTable, Root, "file", "symlink");
     1285    RTTEST_CHECK_MSG(hTest, rc == VERR_WRITE_PROTECT,
     1286                     (hTest, "RTSymlinkCreate() created a symlink in a read-only share: rc=%Rrc\n", rc));
     1287
     1288    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
     1289    rc = svcTable.pfnDisconnect(NULL, 0, svcTable.pvService);
     1290    AssertReleaseRC(rc);
     1291    rc = svcTable.pfnUnload(NULL);
     1292    AssertReleaseRC(rc);
     1293    RTTestGuardedFree(hTest, svcTable.pvService);
    11421294}
    11431295
    … …  
    15181670    testRemove(hTest);
    15191671    testRename(hTest);
     1672    testCopyFile(hTest);
    15201673    testSymlink(hTest);
    15211674    testMappingsAdd(hTest);

  • trunk/src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.h

    r106061 r106237  
    120120void testRenameBadParameters(RTTEST hTest);
    121121
     122void testCopyFile(RTTEST hTest);
     123/* Sub-tests for testCopyFile(). */
     124void testCopyFileReadWrite(RTTEST hTest);
     125void testCopyFileReadOnly(RTTEST hTest);
     126
    122127void testSymlink(RTTEST hTest);
    123128/* Sub-tests for testSymlink(). */
    124129void testSymlinkBadParameters(RTTEST hTest);
    125130void testSymlinkCreation(RTTEST hTest);
     131void testSymlinkReadOnlyCreation(RTTEST hTest);
    126132
    127133void testMappingsAdd(RTTEST hTest);

  • trunk/src/VBox/HostServices/SharedFolders/teststubs.h

    r106061 r106237  
    103103#define RTSymlinkCreate      testRTSymlinkCreate
    104104extern int testRTSymlinkCreate(const char *pszSymlink, const char *pszTarget, RTSYMLINKTYPE enmType, uint32_t fCreate);
     105#define RTFileCopy           testRTFileCopy
     106extern int testRTFileCopy(const char *pszSrc, const char *pszDst);
    105107
    106108#endif /* !VBOX_INCLUDED_SRC_SharedFolders_teststubs_h */

  • trunk/src/VBox/HostServices/SharedFolders/vbsf.cpp

    r106061 r106237  
    25492549}
    25502550
     2551#ifdef UNITTEST
     2552/** Unit test the SHFL_FN_COPY_FILE API.  Located here as a form of API
     2553 * documentation. */
     2554void testCopyFile(RTTEST hTest)
     2555{
     2556    /* Verify copying a file within a read-write share. */
     2557    testCopyFileReadWrite(hTest);
     2558
     2559    /* Verify attempts to copy a file within a read-only share returns EROFS. */
     2560    testCopyFileReadOnly(hTest);
     2561    /* Add tests as required... */
     2562}
     2563#endif
     2564
    25512565/**
    25522566 * Implements SHFL_FN_COPY_FILE (wrapping RTFileCopy).
    … …  
    25752589        if (RT_SUCCESS(rc))
    25762590        {
     2591            /* is the guest allowed to write to this share? */
     2592            bool fWritable;
     2593            rc = vbsfMappingsQueryWritable(pClient, idRootDst, &fWritable);
     2594            if (RT_FAILURE(rc) || !fWritable)
     2595                rc = VERR_WRITE_PROTECT;
     2596
    25772597            /*
    25782598             * Do the job.
    25792599             */
    2580             rc = RTFileCopy(pszPathSrc, pszPathDst);
     2600            if (RT_SUCCESS(rc))
     2601                rc = RTFileCopy(pszPathSrc, pszPathDst);
    25812602
    25822603            vbsfFreeFullPath(pszPathDst);
    … …  
    25972618    /* If the number or types of parameters are wrong the API should fail. */
    25982619    testSymlinkBadParameters(hTest);
    2599     /* Add tests as required... */
     2620    /* Exercise symbolic link creation with various symlink policies in place. */
    26002621    testSymlinkCreation(hTest);
     2622    /* Verify attempts to create a symbolic link within a read-only share returns EROFS. */
     2623    testSymlinkReadOnlyCreation(hTest);
     2624    /* Add additional tests as required... */
    26012625}
    26022626#endif
    … …  
    26132637        return VERR_NOT_IMPLEMENTED;
    26142638
     2639    /* is the guest allowed to create symlinks in this share? */
    26152640    bool fSymlinksCreate;
    26162641    rc = vbsfMappingsQuerySymlinksCreate(pClient, root, &fSymlinksCreate);
    2617     AssertRCReturn(rc, rc);
    2618     if (!fSymlinksCreate)
     2642    if (RT_FAILURE(rc) || !fSymlinksCreate)
    26192643        return VERR_WRITE_PROTECT; /* XXX or VERR_TOO_MANY_SYMLINKS? */
     2644
     2645    /* is the guest allowed to write to this share? */
     2646    bool fWritable;
     2647    rc = vbsfMappingsQueryWritable(pClient, root, &fWritable);
     2648    if (RT_FAILURE(rc) || !fWritable)
     2649        return VERR_WRITE_PROTECT;
    26202650
    26212651    rc = vbsfBuildFullPath(pClient, root, pSymlinkPath, pSymlinkPath->u16Size + SHFLSTRING_HEADER_SIZE, &pszFullSymlinkPath,
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