VirtualBox

Ignore:
Timestamp:
Nov 23, 2017 7:44:07 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
119242
Message:

IPRT/VFS: Got rid of the pfnTraversalOpen method.

Location:
trunk/src/VBox/Runtime/common/vfs
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/common/vfs/vfsbase.cpp

    r69816 r69818  
    9292        Assert((pDirOps)->uVersion == RTVFSDIROPS_VERSION); \
    9393        Assert(!(pDirOps)->fReserved); \
    94         AssertPtr((pDirOps)->pfnTraversalOpen); \
    95         AssertPtr((pDirOps)->pfnOpenFile); \
    96         AssertPtr((pDirOps)->pfnOpenDir); \
    97         AssertPtr((pDirOps)->pfnCreateDir); \
    98         AssertPtr((pDirOps)->pfnOpenSymlink); \
     94        AssertPtr((pDirOps)->pfnOpen); \
     95        AssertPtrNull((pDirOps)->pfnOpenFile); \
     96        AssertPtrNull((pDirOps)->pfnOpenDir); \
     97        AssertPtrNull((pDirOps)->pfnCreateDir); \
     98        AssertPtrNull((pDirOps)->pfnOpenSymlink); \
    9999        AssertPtr((pDirOps)->pfnCreateSymlink); \
    100100        AssertPtr((pDirOps)->pfnUnlinkEntry); \
    … …  
    16971697        RTVFSSYMLINK    hSymlink = NIL_RTVFSSYMLINK;
    16981698        RTVFS           hVfsMnt  = NIL_RTVFS;
     1699        RTVFSOBJ        hVfsObj  = NIL_RTVFSOBJ;
    16991700        if (fFinal)
    17001701        {
    17011702            RTVfsLockAcquireRead(pCurDir->Base.hLock);
    1702             rc = pCurDir->pOps->pfnTraversalOpen(pCurDir->Base.pvThis, pszEntry, NULL, &hSymlink, NULL);
     1703            rc = pCurDir->pOps->pfnOpen(pCurDir->Base.pvThis, pszEntry,
     1704                                        RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
     1705                                        RTVFSOBJ_F_OPEN_SYMLINK | RTVFSOBJ_F_CREATE_NOTHING
     1706                                        | RTVFSOBJ_F_TRAVERSAL | RTPATH_F_ON_LINK,
     1707                                        &hVfsObj);
    17031708            RTVfsLockReleaseRead(pCurDir->Base.hLock);
    17041709            *pszEntryEnd = '\0';
    1705             if (   rc == VERR_PATH_NOT_FOUND
    1706                 || rc == VERR_FILE_NOT_FOUND
    1707                 || rc == VERR_NOT_A_DIRECTORY
    1708                 || rc == VERR_NOT_SYMLINK)
    1709                 rc = VINF_SUCCESS;
    17101710            if (RT_FAILURE(rc))
     1711            {
     1712                if (   rc == VERR_PATH_NOT_FOUND
     1713                    || rc == VERR_FILE_NOT_FOUND
     1714                    || rc == VERR_IS_A_DIRECTORY
     1715                    || rc == VERR_IS_A_FILE
     1716                    || rc == VERR_IS_A_FIFO
     1717                    || rc == VERR_IS_A_SOCKET
     1718                    || rc == VERR_IS_A_CHAR_DEVICE
     1719                    || rc == VERR_IS_A_BLOCK_DEVICE
     1720                    || rc == VERR_NOT_SYMLINK)
     1721                {
     1722                    *ppVfsParentDir = pCurDir;
     1723                    return VINF_SUCCESS;
     1724                }
    17111725                break;
    1712 
    1713             if (hSymlink == NIL_RTVFSSYMLINK)
    1714             {
    1715                 *ppVfsParentDir = pCurDir;
    1716                 return VINF_SUCCESS;
    17171726            }
     1727            hSymlink = RTVfsObjToSymlink(hVfsObj);
     1728            Assert(hSymlink != NIL_RTVFSSYMLINK);
    17181729        }
    17191730        else
    17201731        {
    17211732            RTVfsLockAcquireRead(pCurDir->Base.hLock);
    1722             rc = pCurDir->pOps->pfnTraversalOpen(pCurDir->Base.pvThis, pszEntry, &hDir, &hSymlink, &hVfsMnt);
     1733            rc = pCurDir->pOps->pfnOpen(pCurDir->Base.pvThis, pszEntry,
     1734                                        RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
     1735                                        RTVFSOBJ_F_OPEN_DIRECTORY   | RTVFSOBJ_F_OPEN_SYMLINK | RTVFSOBJ_F_OPEN_MOUNT
     1736                                        | RTVFSOBJ_F_CREATE_NOTHING | RTVFSOBJ_F_TRAVERSAL    | RTPATH_F_ON_LINK,
     1737                                        &hVfsObj);
    17231738            RTVfsLockReleaseRead(pCurDir->Base.hLock);
    17241739            *pszEntryEnd = '/';
    17251740            if (RT_FAILURE(rc))
    1726                 break;
    1727 
    1728             if (   hDir     == NIL_RTVFSDIR
    1729                 && hSymlink == NIL_RTVFSSYMLINK
    1730                 && hVfsMnt  == NIL_RTVFS)
    17311741            {
    1732                 rc = VERR_NOT_A_DIRECTORY;
     1742                if (rc == VERR_FILE_NOT_FOUND)
     1743                    rc = VERR_PATH_NOT_FOUND;
    17331744                break;
    17341745            }
     1746            hDir     = RTVfsObjToDir(hVfsObj);
     1747            hSymlink = RTVfsObjToSymlink(hVfsObj);
     1748            hVfsMnt  = RTVfsObjToVfs(hVfsObj);
    17351749        }
    17361750        Assert(   (hDir != NIL_RTVFSDIR && hSymlink == NIL_RTVFSSYMLINK && hVfsMnt == NIL_RTVFS)
    17371751               || (hDir == NIL_RTVFSDIR && hSymlink != NIL_RTVFSSYMLINK && hVfsMnt == NIL_RTVFS)
    17381752               || (hDir == NIL_RTVFSDIR && hSymlink == NIL_RTVFSSYMLINK && hVfsMnt != NIL_RTVFS));
     1753        RTVfsObjRelease(hVfsObj);
    17391754
    17401755        if (hDir != NIL_RTVFSDIR)
    … …  
    26132628    if (RT_SUCCESS(rc))
    26142629    {
    2615         if (   !pPath->fDirSlash
    2616             && pPath->cComponents > 0)
     2630        if (pPath->cComponents > 0)
    26172631        {
    26182632            /*
    … …  
    26212635             */
    26222636            RTVFSDIRINTERNAL *pVfsParentDir;
    2623             rc = rtVfsDirTraverseToParent(pThis, pPath, RTPATH_F_FOLLOW_LINK, &pVfsParentDir);
     2637            rc = rtVfsDirTraverseToParent(pThis, pPath,
     2638                                          (fOpen & RTFILE_O_NO_SYMLINKS ? RTPATH_F_NO_SYMLINKS : 0) | RTPATH_F_FOLLOW_LINK,
     2639                                          &pVfsParentDir);
    26242640            if (RT_SUCCESS(rc))
    26252641            {
    26262642                const char *pszEntryName = &pPath->szPath[pPath->aoffComponents[pPath->cComponents - 1]];
    26272643
    2628                 /** @todo there is a symlink creation race here. */
    2629                 RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
    2630                 rc = pVfsParentDir->pOps->pfnOpenFile(pVfsParentDir->Base.pvThis, pszEntryName, fOpen, phVfsFile);
    2631                 RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
    2632 
    2633                 RTVfsDirRelease(pVfsParentDir);
     2644                if (   pVfsParentDir->pOps->pfnOpenFile == NULL
     2645                    || pPath->fDirSlash)
     2646                {
     2647                    RTVFSOBJ hVfsObj;
     2648                    RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
     2649                    rc = pVfsParentDir->pOps->pfnOpen(pVfsParentDir->Base.pvThis, pszEntryName, fOpen,
     2650                                                      RTVFSOBJ_F_OPEN_ANY_FILE | RTVFSOBJ_F_CREATE_FILE
     2651                                                      | RTPATH_F_FOLLOW_LINK, &hVfsObj);
     2652                    RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
     2653                    if (RT_SUCCESS(rc))
     2654                    {
     2655                        if (RTVfsObjGetType(hVfsObj) != RTVFSOBJTYPE_SYMLINK)
     2656                            *phVfsFile = RTVfsObjToFile(hVfsObj);
     2657                        else
     2658                        {
     2659                            /** @todo parse symbolic links. */
     2660                            AssertFailed();
     2661                            rc = VERR_NOT_IMPLEMENTED;
     2662                        }
     2663                        RTVfsObjRelease(hVfsObj);
     2664                    }
     2665                }
     2666                else
     2667                {
     2668                    /** @todo there is a symlink creation race here. */
     2669                    RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
     2670                    rc = pVfsParentDir->pOps->pfnOpenFile(pVfsParentDir->Base.pvThis, pszEntryName, fOpen, phVfsFile);
     2671                    RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
     2672                }
    26342673
    26352674                if (RT_SUCCESS(rc))
    … …  
    26382677                    Assert((*phVfsFile)->uMagic == RTVFSFILE_MAGIC);
    26392678                }
     2679
     2680                RTVfsDirRelease(pVfsParentDir);
    26402681            }
    26412682        }
    … …  
    26822723
    26832724    /*
    2684      * Parse the relative path.
     2725     * Parse the relative path.  If it ends with a directory slash or it boils
     2726     * down to an empty path (i.e. re-opening hVfsDir), adjust the flags to only
     2727     * open/create directories.
    26852728     */
    26862729    PRTVFSPARSEDPATH pPath;
    … …  
    26902733        if (   pPath->fDirSlash
    26912734            || pPath->cComponents == 0)
     2735        {
    26922736            fObjFlags &= ~RTVFSOBJ_F_OPEN_ANY | RTVFSOBJ_F_OPEN_DIRECTORY;
    2693 
     2737            if ((fObjFlags & RTVFSOBJ_F_CREATE_MASK) != RTVFSOBJ_F_CREATE_DIRECTORY)
     2738                fObjFlags = (fObjFlags & ~RTVFSOBJ_F_CREATE_MASK) | RTVFSOBJ_F_CREATE_NOTHING;
     2739        }
     2740
     2741        /*
     2742         * Tranverse the path, resolving the parent node, not checking for
     2743         * symbolic links in the final element.
     2744         */
     2745        const char       *pszEntryName;
     2746        RTVFSDIRINTERNAL *pVfsParentDir;
    26942747        if (pPath->cComponents > 0)
    26952748        {
     2749            rc = rtVfsDirTraverseToParent(pThis, pPath, fObjFlags & RTPATH_F_MASK, &pVfsParentDir);
     2750            pszEntryName = &pPath->szPath[pPath->aoffComponents[pPath->cComponents - 1]];
     2751        }
     2752        else
     2753        {
     2754            RTVfsDirRetain(pThis);
     2755            pVfsParentDir = pThis;
     2756            pszEntryName  = ".";
     2757        }
     2758        if (RT_SUCCESS(rc))
     2759        {
    26962760            /*
    2697              * Tranverse the path, resolving the parent node, not
    2698              * checking for symbolic links in the final element.
     2761             * Do the opening.
    26992762             */
    2700             RTVFSDIRINTERNAL *pVfsParentDir;
    2701             rc = rtVfsDirTraverseToParent(pThis, pPath, RTPATH_F_ON_LINK, &pVfsParentDir);
    2702             if (RT_SUCCESS(rc))
     2763            RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
     2764            rc = pVfsParentDir->pOps->pfnOpen(pVfsParentDir->Base.pvThis, pszEntryName, fFileOpen, fObjFlags, phVfsObj);
     2765            RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
     2766
     2767            if (   (fObjFlags & RTPATH_F_FOLLOW_LINK)
     2768                && RTVfsObjGetType(*phVfsObj) == RTVFSOBJTYPE_SYMLINK)
    27032769            {
    2704                 const char *pszEntryName = &pPath->szPath[pPath->aoffComponents[pPath->cComponents - 1]];
    2705 
    2706                 /*
    2707                  * If we've got a trailing directory slash, use pfnOpenDir
    2708                  * instead of pfnOpenObj.
    2709                  */
    2710                 if (pPath->fDirSlash)
    2711                 {
    2712                     RTVFSDIR hVfsSubDir;
    2713                     RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
    2714                     rc = pVfsParentDir->pOps->pfnOpenDir(pVfsParentDir->Base.pvThis, pszEntryName,
    2715                                                          0 /** @todo fFlags*/, &hVfsSubDir);
    2716                     RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
    2717                     if (RT_SUCCESS(rc))
    2718                     {
    2719                         *phVfsObj = RTVfsObjFromDir(hVfsSubDir);
    2720                         RTVfsDirRelease(hVfsSubDir);
    2721                         AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
    2722                     }
    2723                 }
    2724                 else
    2725                 {
    2726                     RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
    2727                     rc = pVfsParentDir->pOps->pfnOpen(pVfsParentDir->Base.pvThis, pszEntryName, fFileOpen, fObjFlags, phVfsObj);
    2728                     RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
    2729                 }
    2730                 RTVfsDirRelease(pVfsParentDir);
     2770                /** @todo implement following symbolic links. */
     2771                AssertFailed();
     2772                RTVfsObjRelease(*phVfsObj);
     2773                *phVfsObj = NIL_RTVFSOBJ;
     2774                rc = VERR_NOT_IMPLEMENTED;
    27312775            }
    2732         }
    2733         /*
    2734          * The path boils down to '.', call pfnOpenDir on pThis with '.' as input.
    2735          * The caller may wish for a new directory instance to enumerate the entries
    2736          * in parallel or some such thing.
    2737          */
    2738         else
    2739         {
    2740             RTVFSDIR hVfsSubDir;
    2741             RTVfsLockAcquireWrite(pThis->Base.hLock);
    2742             rc = pThis->pOps->pfnOpenDir(pThis->Base.pvThis, ".", 0 /** @todo fFlags*/, &hVfsSubDir);
    2743             RTVfsLockReleaseWrite(pThis->Base.hLock);
    2744             if (RT_SUCCESS(rc))
    2745             {
    2746                 *phVfsObj = RTVfsObjFromDir(hVfsSubDir);
    2747                 RTVfsDirRelease(hVfsSubDir);
    2748                 AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
    2749             }
    2750         }
    2751 
     2776
     2777            RTVfsDirRelease(pVfsParentDir);
     2778        }
    27522779        RTVfsParsePathFree(pPath);
    27532780    }

  • trunk/src/VBox/Runtime/common/vfs/vfsstddir.cpp

    r69813 r69818  
    251251
    252252
    253 
    254 /**
    255  * @interface_method_impl{RTVFSDIROPS,pfnTraversalOpen}
    256  */
    257 static DECLCALLBACK(int) rtVfsStdDir_TraversalOpen(void *pvThis, const char *pszEntry, PRTVFSDIR phVfsDir,
    258                                                    PRTVFSSYMLINK phVfsSymlink, PRTVFS phVfsMounted)
    259 {
    260     /* No union mounting or mount points here (yet). */
    261     if (phVfsMounted)
    262         *phVfsMounted = NIL_RTVFS;
    263 
    264     int rc;
    265     if (phVfsDir || phVfsSymlink)
    266     {
    267         if (phVfsDir)
    268             *phVfsDir = NIL_RTVFSDIR;
    269         if (phVfsSymlink)
    270             *phVfsSymlink = NIL_RTVFSSYMLINK;
    271 
    272         RTFSOBJINFO ObjInfo;
    273         rc = rtVfsStdDir_QueryEntryInfo(pvThis, pszEntry, &ObjInfo, RTFSOBJATTRADD_NOTHING);
    274         if (RT_SUCCESS(rc))
    275         {
    276             switch (ObjInfo.Attr.fMode & RTFS_TYPE_MASK)
    277             {
    278                 case RTFS_TYPE_DIRECTORY:
    279                     if (phVfsDir)
    280                         rc = rtVfsStdDir_OpenDir(pvThis, pszEntry, 0, phVfsDir);
    281                     else
    282                         rc = VERR_NOT_SYMLINK;
    283                     break;
    284 
    285                 case RTFS_TYPE_SYMLINK:
    286                     if (phVfsSymlink)
    287                         rc = rtVfsStdDir_OpenSymlink(pvThis, pszEntry, phVfsSymlink);
    288                     else
    289                         rc = VERR_NOT_A_DIRECTORY;
    290                     break;
    291 
    292                 default:
    293                     rc = phVfsDir ? VERR_NOT_A_DIRECTORY : VERR_NOT_SYMLINK;
    294                     break;
    295             }
    296         }
    297     }
    298     else
    299         rc = VERR_PATH_NOT_FOUND;
    300 
    301     LogFlow(("rtVfsStdDir_TraversalOpen: %s -> %Rrc\n", pszEntry, rc));
    302     return rc;
    303 }
    304 
    305 
    306 /**
    307  * @interface_method_impl{RTVFSDIROPS,pfnOpenObj}
    308  */
    309 static DECLCALLBACK(int) rtVfsStdDir_OpenObj(void *pvThis, const char *pszEntry, uint64_t fOpen,
    310                                              uint32_t fFlags, PRTVFSOBJ phVfsObj)
     253/**
     254 * @interface_method_impl{RTVFSDIROPS,pfnOpen}
     255 */
     256static DECLCALLBACK(int) rtVfsStdDir_Open(void *pvThis, const char *pszEntry, uint64_t fFileOpen,
     257                                          uint32_t fVfsFlags, PRTVFSOBJ phVfsObj)
    311258{
    312259    PRTVFSSTDDIR pThis = (PRTVFSSTDDIR)pvThis;
    … …  
    323270        {
    324271            case RTFS_TYPE_DIRECTORY:
    325                 if (!(fFlags & RTVFSOBJ_F_OPEN_DIRECTORY))
     272                if (!(fVfsFlags & RTVFSOBJ_F_OPEN_DIRECTORY))
    326273                {
    327                     if (   (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
    328                         || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
    329                         || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
     274                    if (   (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
     275                        || (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
     276                        || (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
    330277                    {
    331278                        RTDIR hSubDir;
    332                         rc = RTDirRelDirOpenFiltered(pThis->hDir, pszEntry, RTDIRFILTER_NONE, fFlags, &hSubDir);
     279                        rc = RTDirRelDirOpenFiltered(pThis->hDir, pszEntry, RTDIRFILTER_NONE, fVfsFlags, &hSubDir);
    333280                        if (RT_SUCCESS(rc))
    334281                        {
    … …  
    339286                                *phVfsObj = RTVfsObjFromDir(hVfsDir);
    340287                                RTVfsDirRelease(hVfsDir);
    341                                 AssertStmt(*phVfsObj == NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
     288                                AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
    342289                            }
    343290                            else
    … …  
    360307                {
    361308                    case RTFS_TYPE_FILE:
    362                         rc = fFlags & RTVFSOBJ_F_OPEN_FILE      ? VINF_SUCCESS : VERR_IS_A_FILE;
     309                        rc = fVfsFlags & RTVFSOBJ_F_OPEN_FILE      ? VINF_SUCCESS : VERR_IS_A_FILE;
    363310                        break;
    364311                    case RTFS_TYPE_DEV_BLOCK:
    365                         rc = fFlags & RTVFSOBJ_F_OPEN_DEV_BLOCK ? VINF_SUCCESS : VERR_IS_A_BLOCK_DEVICE;
     312                        rc = fVfsFlags & RTVFSOBJ_F_OPEN_DEV_BLOCK ? VINF_SUCCESS : VERR_IS_A_BLOCK_DEVICE;
    366313                        break;
    367314                    case RTFS_TYPE_DEV_CHAR:
    368                         rc = fFlags & RTVFSOBJ_F_OPEN_DEV_CHAR  ? VINF_SUCCESS : VERR_IS_A_CHAR_DEVICE;
     315                        rc = fVfsFlags & RTVFSOBJ_F_OPEN_DEV_CHAR  ? VINF_SUCCESS : VERR_IS_A_CHAR_DEVICE;
    369316                        break;
    370317                    /** @todo These two types should not result in files, but pure I/O streams.
    371318                     *        possibly char device too.  */
    372319                    case RTFS_TYPE_FIFO:
    373                         rc = fFlags & RTVFSOBJ_F_OPEN_FIFO      ? VINF_SUCCESS : VERR_IS_A_FIFO;
     320                        rc = fVfsFlags & RTVFSOBJ_F_OPEN_FIFO      ? VINF_SUCCESS : VERR_IS_A_FIFO;
    374321                        break;
    375322                    case RTFS_TYPE_SOCKET:
    376                         rc = fFlags & RTVFSOBJ_F_OPEN_SOCKET    ? VINF_SUCCESS : VERR_IS_A_SOCKET;
     323                        rc = fVfsFlags & RTVFSOBJ_F_OPEN_SOCKET    ? VINF_SUCCESS : VERR_IS_A_SOCKET;
    377324                        break;
    378325                    default:
    … …  
    382329                if (RT_SUCCESS(rc))
    383330                {
    384                     if (   (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
    385                         || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
    386                         || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
     331                    if (   (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
     332                        || (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
     333                        || (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
    387334                    {
    388335                        RTFILE hFile;
    389                         rc = RTDirRelFileOpen(pThis->hDir, pszEntry, fOpen, &hFile);
     336                        rc = RTDirRelFileOpen(pThis->hDir, pszEntry, fFileOpen, &hFile);
    390337                        if (RT_SUCCESS(rc))
    391338                        {
    392339                            RTVFSFILE hVfsFile;
    393                             rc = RTVfsFileFromRTFile(hFile, fOpen, false /*fLeaveOpen*/, &hVfsFile);
     340                            rc = RTVfsFileFromRTFile(hFile, fFileOpen, false /*fLeaveOpen*/, &hVfsFile);
    394341                            if (RT_SUCCESS(rc))
    395342                            {
    396343                                *phVfsObj = RTVfsObjFromFile(hVfsFile);
    397344                                RTVfsFileRelease(hVfsFile);
    398                                 AssertStmt(*phVfsObj == NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
     345                                AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
    399346                            }
    400347                            else
    … …  
    408355
    409356            case RTFS_TYPE_SYMLINK:
    410                 if (fFlags & RTVFSOBJ_F_OPEN_SYMLINK)
     357                if (fVfsFlags & RTVFSOBJ_F_OPEN_SYMLINK)
    411358                {
    412359                    uint32_t cRefs = RTVfsDirRetain(pThis->hSelf);
    … …  
    448395         * Consider file or directory creation.
    449396         */
    450         if (   (   (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE
    451                 || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
    452                 || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
    453             && (fFlags & RTVFSOBJ_F_CREATE_MASK) != RTVFSOBJ_F_CREATE_NOTHING)
     397        if (   (   (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE
     398                || (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
     399                || (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
     400            && (fVfsFlags & RTVFSOBJ_F_CREATE_MASK) != RTVFSOBJ_F_CREATE_NOTHING)
    454401        {
    455402
    456             if ((fFlags & RTVFSOBJ_F_CREATE_MASK) == RTVFSOBJ_F_CREATE_FILE)
     403            if ((fVfsFlags & RTVFSOBJ_F_CREATE_MASK) == RTVFSOBJ_F_CREATE_FILE)
    457404            {
    458405                RTFILE hFile;
    459                 rc = RTDirRelFileOpen(pThis->hDir, pszEntry, fOpen, &hFile);
     406                rc = RTDirRelFileOpen(pThis->hDir, pszEntry, fFileOpen, &hFile);
    460407                if (RT_SUCCESS(rc))
    461408                {
    462409                    RTVFSFILE hVfsFile;
    463                     rc = RTVfsFileFromRTFile(hFile, fOpen, false /*fLeaveOpen*/, &hVfsFile);
     410                    rc = RTVfsFileFromRTFile(hFile, fFileOpen, false /*fLeaveOpen*/, &hVfsFile);
    464411                    if (RT_SUCCESS(rc))
    465412                    {
    466413                        *phVfsObj = RTVfsObjFromFile(hVfsFile);
    467414                        RTVfsFileRelease(hVfsFile);
    468                         AssertStmt(*phVfsObj == NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
     415                        AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
    469416                    }
    470417                    else
    … …  
    472419                }
    473420            }
    474             else if ((fFlags & RTVFSOBJ_F_CREATE_MASK) == RTVFSOBJ_F_CREATE_DIRECTORY)
     421            else if ((fVfsFlags & RTVFSOBJ_F_CREATE_MASK) == RTVFSOBJ_F_CREATE_DIRECTORY)
    475422            {
    476423                RTDIR hSubDir;
    477                 rc = RTDirRelDirCreate(pThis->hDir, pszEntry, (fOpen & RTFILE_O_CREATE_MODE_MASK) >> RTFILE_O_CREATE_MODE_SHIFT,
    478                                        0 /* fFlags */, &hSubDir);
     424                rc = RTDirRelDirCreate(pThis->hDir, pszEntry, (fFileOpen & RTFILE_O_CREATE_MODE_MASK) >> RTFILE_O_CREATE_MODE_SHIFT,
     425                                       0 /* fVfsFlags */, &hSubDir);
    479426                if (RT_SUCCESS(rc))
    480427                {
    … …  
    720667        RTVFSOBJSETOPS_VERSION
    721668    },
    722     rtVfsStdDir_OpenObj,
    723     rtVfsStdDir_TraversalOpen,
     669    rtVfsStdDir_Open,
    724670    rtVfsStdDir_OpenFile,
    725671    rtVfsStdDir_OpenDir,
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