vbox的更動 47535 路徑 trunk/src/VBox/Runtime/r3/nt

時間撮記:

2013-8-5 上午01:54:25 (11 年 以前)

作者:

vboxsync

訊息:

IPRT: Wrote native NT directory enumeration - not enabled by default. Provides ChangeTime and later file ID (inode no). Can also enumerate object directories, just for the fun of it.

位置:

trunk/src/VBox/Runtime/r3/nt

檔案:

• direnum-r3-nt.cpp (複製) (複製 從 trunk/src/VBox/Runtime/r3/win/direnum-win.cpp ) (13 筆差異)
• fs-nt.cpp (修改) (2 筆差異)
• internal-r3-nt.h (修改) (5 筆差異)
• pathint-nt.cpp (修改) (4 筆差異)

trunk/src/VBox/Runtime/r3/nt/direnum-r3-nt.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT - Directory Enumeration, Windows.
+ * IPRT - Directory Enumeration, Native NT.
  */
 
@@ -30 +30 @@
 *******************************************************************************/
 #define LOG_GROUP RTLOGGROUP_DIR
-#include <Windows.h>
+#include "internal-r3-nt.h"
 
 #include <iprt/dir.h>
@@ -44 +44 @@
 
 
+/*******************************************************************************
+*   Defined Constants And Macros                                               *
+*******************************************************************************/
+/** Whether to return a single record (TRUE) or multiple (FALSE)o. */
+#define RTDIR_NT_SINGLE_RECORD  FALSE
+
+/** Go hard on record chaining (has slight performance impact). */
+#ifdef RT_STRICT
+# define RTDIR_NT_STRICT
+#endif
+
+
+/* ASSUMES FileID comes after ShortName and the structus are identical up to that point. */
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, NextEntryOffset, FILE_ID_BOTH_DIR_INFORMATION, NextEntryOffset);
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, FileIndex      , FILE_ID_BOTH_DIR_INFORMATION, FileIndex      );
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, CreationTime   , FILE_ID_BOTH_DIR_INFORMATION, CreationTime   );
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, LastAccessTime , FILE_ID_BOTH_DIR_INFORMATION, LastAccessTime );
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, LastWriteTime  , FILE_ID_BOTH_DIR_INFORMATION, LastWriteTime  );
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, ChangeTime     , FILE_ID_BOTH_DIR_INFORMATION, ChangeTime     );
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, EndOfFile      , FILE_ID_BOTH_DIR_INFORMATION, EndOfFile      );
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, AllocationSize , FILE_ID_BOTH_DIR_INFORMATION, AllocationSize );
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, FileAttributes , FILE_ID_BOTH_DIR_INFORMATION, FileAttributes );
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, FileNameLength , FILE_ID_BOTH_DIR_INFORMATION, FileNameLength );
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, EaSize         , FILE_ID_BOTH_DIR_INFORMATION, EaSize         );
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, ShortNameLength, FILE_ID_BOTH_DIR_INFORMATION, ShortNameLength);
+AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, ShortName      , FILE_ID_BOTH_DIR_INFORMATION, ShortName      );
+
+
+
+size_t rtDirNativeGetStructSize(const char *pszPath)
+{
+    NOREF(pszPath);
+    return sizeof(RTDIR);
+}
+
+
 int rtDirNativeOpen(PRTDIR pDir, char *pszPathBuf)
 {
     /*
-     * Setup the search expression.
-     *
-     * pszPathBuf is pointing to the return 4K return buffer for the RTPathReal()
-     * call in rtDirOpenCommon(), so all we gota do is check that we don't overflow
-     * it when adding the wildcard expression.
-     */
-    size_t cbExpr;
-    const char *pszExpr;
-    if (pDir->enmFilter == RTDIRFILTER_WINNT)
-    {
-        pszExpr = pDir->pszFilter;
-        cbExpr  = pDir->cchFilter + 1;
-    }
-    else
-    {
-        pszExpr = "*";
-        cbExpr  = sizeof("*");
-    }
-    if (pDir->cchPath + cbExpr > RTPATH_MAX)
-        return VERR_FILENAME_TOO_LONG;
-    memcpy(pszPathBuf + pDir->cchPath, pszExpr, cbExpr);
-
-
-    /*
-     * Attempt opening the search.
-     */
-    int rc = VINF_SUCCESS;
-    PRTUTF16 pwszName;
-    rc = RTStrToUtf16(pszPathBuf, &pwszName);
+     * Convert the filter to UTF-16.
+     */
+    int rc;
+    pDir->pNtFilterStr = NULL;
+    if (   pDir->cchFilter > 0
+        && pDir->enmFilter == RTDIRFILTER_WINNT)
+    {
+        PRTUTF16 pwszTmp;
+        rc = RTStrToUtf16(pDir->pszFilter, &pwszTmp);
+        if (RT_FAILURE(rc))
+            return rc;
+        pDir->NtFilterStr.Buffer = pwszTmp;
+        pDir->NtFilterStr.Length = pDir->NtFilterStr.MaximumLength = (uint16_t)(RTUtf16Len(pwszTmp) * sizeof(RTUTF16));
+        pDir->pNtFilterStr = &pDir->NtFilterStr;
+    }
+
+    /*
+     * Try open the directory
+     */
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+    bool fObjDir;
+#endif
+    rc = rtNtPathOpenDir(pszPathBuf,
+                         FILE_READ_DATA | SYNCHRONIZE,
+                         FILE_SHARE_READ | FILE_SHARE_WRITE,
+                         FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
+                         OBJ_CASE_INSENSITIVE,
+                         &pDir->hDir,
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+                         &fObjDir
+#else
+                         NULL
+#endif
+                         );
     if (RT_SUCCESS(rc))
     {
-        pDir->hDir    = FindFirstFileW((LPCWSTR)pwszName, &pDir->Data);
-        if (pDir->hDir != INVALID_HANDLE_VALUE)
-            pDir->fDataUnread = true;
-        else
-        {
-            DWORD dwErr = GetLastError();
-            /* Theoretical case of an empty directory or more normal case of no matches. */
-            if (   dwErr == ERROR_FILE_NOT_FOUND
-                || dwErr == ERROR_NO_MORE_FILES /* ???*/)
-                pDir->fDataUnread = false;
-            else
-                rc = RTErrConvertFromWin32(GetLastError());
-        }
-        RTUtf16Free(pwszName);
-    }
-
+        /*
+         * Init data.
+         */
+        pDir->fDataUnread = false; /* spelling it out */
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+        if (fObjDir)
+            pDir->enmInfoClass = FileMaximumInformation; /* object directory. */
+#endif
+    }
     return rc;
 }
@@ -114 +148 @@
      * Close the handle.
      */
-    pDir->u32Magic++;
-    if (pDir->hDir != INVALID_HANDLE_VALUE)
-    {
-        BOOL fRc = FindClose(pDir->hDir);
-        Assert(fRc);
-        pDir->hDir = INVALID_HANDLE_VALUE;
+    pDir->u32Magic = ~RTDIR_MAGIC;
+    if (pDir->hDir != MY_INVALID_HANDLE_VALUE)
+    {
+        int rc = rtNtPathClose(pDir->hDir);
+        AssertRC(rc);
+        pDir->hDir = MY_INVALID_HANDLE_VALUE;
     }
     RTStrFree(pDir->pszName);
     pDir->pszName = NULL;
+    RTUtf16Free(pDir->NtFilterStr.Buffer);
+    pDir->NtFilterStr.Buffer = NULL;
+    RTMemFree(pDir->pabBuffer);
+    pDir->pabBuffer = NULL;
     RTMemFree(pDir);
 
@@ -129 +167 @@
 
 
+/**
+ * Checks the validity of the current record.
+ *
+ * @returns IPRT status code
+ * @param   pThis       The directory instance data.
+ */
+static int rtDirNtCheckRecord(PRTDIR pThis)
+{
+#ifdef RTDIR_NT_STRICT
+# ifdef IPRT_WITH_NT_PATH_PASSTHRU
+    if (pThis->enmInfoClass != FileMaximumInformation)
+# endif
+    {
+        uintptr_t uEndAddr;
+        if (pThis->enmInfoClass == FileIdBothDirectoryInformation)
+            uEndAddr = (uintptr_t)&pThis->uCurData.pBothId->FileName[0];
+        else
+            uEndAddr = (uintptr_t)&pThis->uCurData.pBoth->FileName[0];
+        AssertReturn(uEndAddr < (uintptr_t)&pThis->pabBuffer[pThis->cbBuffer], VERR_IO_GEN_FAILURE);
+
+        AssertReturn(pThis->uCurData.pBoth->FileNameLength < _64K, VERR_FILENAME_TOO_LONG);
+        AssertReturn((pThis->uCurData.pBoth->FileNameLength & 1) == 0, VERR_IO_GEN_FAILURE);
+
+        uEndAddr += pThis->uCurData.pBoth->FileNameLength;
+        AssertReturn(uEndAddr <= (uintptr_t)&pThis->pabBuffer[pThis->cbBuffer], VERR_IO_GEN_FAILURE);
+
+        AssertReturn((unsigned)pThis->uCurData.pBoth->ShortNameLength <= sizeof(pThis->uCurData.pBoth->ShortName),
+                     VERR_IO_GEN_FAILURE);
+    }
+#endif
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Advances the buffer pointer.
+ *
+ * @param   pThis       The directory instance data.
+ */
+static int rtDirNtAdvanceBuffer(PRTDIR pThis)
+{
+    int rc;
+
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+    if (pThis->enmInfoClass == FileMaximumInformation)
+    {
+        pThis->uCurData.pObjDir++;
+        pThis->fDataUnread = pThis->uCurData.pObjDir->Name.Length != 0;
+        return VINF_SUCCESS;
+    }
+#endif
+
+    pThis->fDataUnread = false;
+
+    uint32_t const offNext = pThis->uCurData.pBoth->NextEntryOffset;
+    if (offNext == 0)
+        return VINF_SUCCESS;
+
+#ifdef RTDIR_NT_STRICT
+    /* Make sure the next-record offset is beyond the current record. */
+    size_t cbRec;
+    if (pThis->enmInfoClass == FileIdBothDirectoryInformation)
+        cbRec = RT_UOFFSETOF(FILE_ID_BOTH_DIR_INFORMATION, FileName);
+    else
+        cbRec = RT_UOFFSETOF(FILE_BOTH_DIR_INFORMATION, FileName);
+    cbRec += pThis->uCurData.pBoth->FileNameLength;
+    AssertReturn(offNext >= cbRec, VERR_IO_GEN_FAILURE);
+#endif
+    pThis->uCurData.u += offNext;
+
+    rc = rtDirNtCheckRecord(pThis);
+    pThis->fDataUnread = RT_SUCCESS(rc);
+    return rc;
+}
+
+
+/**
+ * Fetches more data from the file system.
+ *
+ * @returns IPRT status code
+ * @param   pThis       The directory instance data.
+ */
+static int rtDirNtFetchMore(PRTDIR pThis)
+{
+    Assert(!pThis->fDataUnread);
+
+    /*
+     * Allocate the buffer the first time around.
+     * We do this in lazy fashion as some users of RTDirOpen will not actually
+     * list any files, just open it for various reasons.
+     */
+    bool fFirst = false;
+    if (!pThis->pabBuffer)
+    {
+        fFirst = false;
+        pThis->cbBufferAlloc = _256K;
+        pThis->pabBuffer = (uint8_t *)RTMemAlloc(pThis->cbBufferAlloc);
+        if (!pThis->pabBuffer)
+        {
+            do
+            {
+                pThis->cbBufferAlloc /= 4;
+                pThis->pabBuffer = (uint8_t *)RTMemAlloc(pThis->cbBufferAlloc);
+            } while (pThis->pabBuffer == NULL && pThis->cbBufferAlloc > _4K);
+            if (!pThis->pabBuffer)
+                return VERR_NO_MEMORY;
+        }
+    }
+
+    /*
+     * Read more.
+     */
+    NTSTATUS rcNt;
+    IO_STATUS_BLOCK Ios = MY_IO_STATUS_BLOCK_INITIALIZER;
+    if (pThis->enmInfoClass != (FILE_INFORMATION_CLASS)0)
+    {
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+        if (pThis->enmInfoClass == FileMaximumInformation)
+        {
+            Ios.Information = 0;
+            Ios.Status = rcNt = NtQueryDirectoryObject(pThis->hDir,
+                                                       pThis->pabBuffer,
+                                                       pThis->cbBufferAlloc,
+                                                       RTDIR_NT_SINGLE_RECORD /*ReturnSingleEntry */,
+                                                       FALSE /*RestartScan*/,
+                                                       &pThis->uObjDirCtx,
+                                                       (PULONG)&Ios.Information);
+        }
+        else
+#endif
+            rcNt = NtQueryDirectoryFile(pThis->hDir,
+                                        NULL /* Event */,
+                                        NULL /* ApcRoutine */,
+                                        NULL /* ApcContext */,
+                                        &Ios,
+                                        pThis->pabBuffer,
+                                        pThis->cbBufferAlloc,
+                                        pThis->enmInfoClass,
+                                        RTDIR_NT_SINGLE_RECORD /*ReturnSingleEntry */,
+                                        pThis->pNtFilterStr,
+                                        FALSE /*RestartScan */);
+    }
+    else
+    {
+        /*
+         * The first time around we have figure which info class we can use.
+         * We prefer one which gives us file IDs, but we'll settle for less.
+         */
+        pThis->enmInfoClass = FileIdBothDirectoryInformation;
+        rcNt = NtQueryDirectoryFile(pThis->hDir,
+                                    NULL /* Event */,
+                                    NULL /* ApcRoutine */,
+                                    NULL /* ApcContext */,
+                                    &Ios,
+                                    pThis->pabBuffer,
+                                    pThis->cbBufferAlloc,
+                                    pThis->enmInfoClass,
+                                    RTDIR_NT_SINGLE_RECORD /*ReturnSingleEntry */,
+                                    pThis->pNtFilterStr,
+                                    FALSE /*RestartScan */);
+        if (!NT_SUCCESS(rcNt))
+        {
+            pThis->enmInfoClass = FileBothDirectoryInformation;
+            rcNt = NtQueryDirectoryFile(pThis->hDir,
+                                        NULL /* Event */,
+                                        NULL /* ApcRoutine */,
+                                        NULL /* ApcContext */,
+                                        &Ios,
+                                        pThis->pabBuffer,
+                                        pThis->cbBufferAlloc,
+                                        pThis->enmInfoClass,
+                                        RTDIR_NT_SINGLE_RECORD /*ReturnSingleEntry */,
+                                        pThis->pNtFilterStr,
+                                        FALSE /*RestartScan */);
+        }
+    }
+    if (!NT_SUCCESS(rcNt))
+    {
+        if (rcNt == STATUS_NO_MORE_FILES || rcNt == STATUS_NO_MORE_ENTRIES)
+            return VERR_NO_MORE_FILES;
+        return RTErrConvertFromNtStatus(rcNt);
+    }
+    Assert(Ios.Information > sizeof(*pThis->uCurData.pBoth));
+
+    /*
+     * Set up the data members.
+     */
+    pThis->uCurData.u  = (uintptr_t)pThis->pabBuffer;
+    pThis->cbBuffer    = Ios.Information;
+
+    int rc = rtDirNtCheckRecord(pThis);
+    pThis->fDataUnread = RT_SUCCESS(rc);
+
+    return rc;
+}
+
+
+/**
+ * Converts the name from UTF-16 to UTF-8.
+ *
+ * Fortunately, the names are relative to the directory, so we won't have to do
+ * any sweaty path style coversion. :-)
+ *
+ * @returns IPRT status code
+ * @param   pThis       The directory instance data.
+ * @param   cbName      The file name length in bytes.
+ * @param   pwsName     The file name, not terminated.
+ */
+static int rtDirNtConvertName(PRTDIR pThis, uint32_t cbName, PCRTUTF16 pwsName)
+{
+    int rc = RTUtf16ToUtf8Ex(pwsName, cbName / 2, &pThis->pszName, pThis->cbNameAlloc, &pThis->cchName);
+    if (RT_SUCCESS(rc))
+    {
+        if (!pThis->cbNameAlloc)
+            pThis->cbNameAlloc = pThis->cchName + 1;
+    }
+    else if (rc == VERR_BUFFER_OVERFLOW)
+    {
+        RTStrFree(pThis->pszName);
+        pThis->pszName = NULL;
+        pThis->cbNameAlloc = 0;
+
+        rc = RTUtf16ToUtf8Ex(pwsName, cbName / 2, &pThis->pszName, pThis->cbNameAlloc, &pThis->cchName);
+        if (RT_SUCCESS(rc))
+            pThis->cbNameAlloc = pThis->cchName + 1;
+    }
+    Assert(RT_SUCCESS(rc) ? pThis->pszName != NULL : pThis->pszName == NULL);
+    return rc;
+}
+
+
+/**
+ * Converts the name of the current record.
+ *
+ * @returns IPRT status code.
+ * @param   pThis       The directory instance data.
+ */
+static int rtDirNtConvertCurName(PRTDIR pThis)
+{
+    switch (pThis->enmInfoClass)
+    {
+        case FileIdBothDirectoryInformation:
+            return rtDirNtConvertName(pThis, pThis->uCurData.pBothId->FileNameLength, pThis->uCurData.pBothId->FileName);
+        case FileBothDirectoryInformation:
+            return rtDirNtConvertName(pThis, pThis->uCurData.pBoth->FileNameLength, pThis->uCurData.pBoth->FileName);
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+        case FileMaximumInformation:
+            return rtDirNtConvertName(pThis, pThis->uCurData.pObjDir->Name.Length, pThis->uCurData.pObjDir->Name.Buffer);
+#endif
+
+        default:
+            AssertFailedReturn(VERR_INTERNAL_ERROR_3);
+    }
+}
+
+
 RTDECL(int) RTDirRead(PRTDIR pDir, PRTDIRENTRY pDirEntry, size_t *pcbDirEntry)
 {
+    int rc;
+
     /*
      * Validate input.
      */
-    if (!pDir || pDir->u32Magic != RTDIR_MAGIC)
-    {
-        AssertMsgFailed(("Invalid pDir=%p\n", pDir));
-        return VERR_INVALID_PARAMETER;
-    }
-    if (!pDirEntry)
-    {
-        AssertMsgFailed(("Invalid pDirEntry=%p\n", pDirEntry));
-        return VERR_INVALID_PARAMETER;
-    }
+    AssertPtrReturn(pDir, VERR_INVALID_POINTER);
+    AssertReturn(pDir->u32Magic == RTDIR_MAGIC, VERR_INVALID_HANDLE);
+    AssertPtrReturn(pDirEntry, VERR_INVALID_POINTER);
     size_t cbDirEntry = sizeof(*pDirEntry);
     if (pcbDirEntry)
     {
         cbDirEntry = *pcbDirEntry;
-        if (cbDirEntry < RT_UOFFSETOF(RTDIRENTRY, szName[2]))
-        {
-            AssertMsgFailed(("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRY, szName[2])));
-            return VERR_INVALID_PARAMETER;
-        }
+        AssertMsgReturn(cbDirEntry >= RT_UOFFSETOF(RTDIRENTRY, szName[2]),
+                        ("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRY, szName[2])),
+                        VERR_INVALID_PARAMETER);
     }
 
@@ -160 +448 @@
     if (!pDir->fDataUnread)
     {
-        RTStrFree(pDir->pszName);
-        pDir->pszName = NULL;
-
-        BOOL fRc = FindNextFileW(pDir->hDir, &pDir->Data);
-        if (!fRc)
-        {
-            int iErr = GetLastError();
-            if (pDir->hDir == INVALID_HANDLE_VALUE || iErr == ERROR_NO_MORE_FILES)
-                return VERR_NO_MORE_FILES;
-            return RTErrConvertFromWin32(iErr);
-        }
+        rc = rtDirNtFetchMore(pDir);
+        if (RT_FAILURE(rc))
+            return rc;
     }
 
@@ -176 +456 @@
      * Convert the filename to UTF-8.
      */
-    if (!pDir->pszName)
-    {
-        int rc = RTUtf16ToUtf8((PCRTUTF16)pDir->Data.cFileName, &pDir->pszName);
-        if (RT_FAILURE(rc))
-        {
-            pDir->pszName = NULL;
-            return rc;
-        }
-        pDir->cchName = strlen(pDir->pszName);
-    }
+    rc = rtDirNtConvertCurName(pDir);
+    if (RT_FAILURE(rc))
+        return rc;
 
     /*
@@ -201 +474 @@
      * Setup the returned data.
      */
-    pDir->fDataUnread  = false;
-    pDirEntry->INodeId = 0; /** @todo we can use the fileid here if we must (see GetFileInformationByHandle). */
-    pDirEntry->enmType = pDir->Data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
-                       ? RTDIRENTRYTYPE_DIRECTORY : RTDIRENTRYTYPE_FILE;
-    pDirEntry->cbName  = (uint16_t)cchName;
-    Assert(pDirEntry->cbName == cchName);
+    pDirEntry->cbName = (uint16_t)cchName; Assert(pDirEntry->cbName == cchName);
     memcpy(pDirEntry->szName, pszName, cchName + 1);
 
-    return VINF_SUCCESS;
-}
-
-
-RTDECL(int) RTDirReadEx(PRTDIR pDir, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags)
-{
-    /** @todo Symlinks: Find[First|Next]FileW will return info about
-        the link, so RTPATH_F_FOLLOW_LINK is not handled correctly. */
+    pDirEntry->INodeId = pDir->enmInfoClass == FileIdBothDirectoryInformation
+                       ? pDir->uCurData.pBothId->FileId.QuadPart : 0;
+
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+    if (pDir->enmInfoClass != FileMaximumInformation)
+#endif
+    {
+        switch (   pDir->uCurData.pBoth->FileAttributes
+                & (FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_DIRECTORY))
+        {
+            default:
+                AssertFailed();
+            case 0:
+                pDirEntry->enmType = RTDIRENTRYTYPE_FILE;
+                break;
+
+            case FILE_ATTRIBUTE_DIRECTORY:
+                pDirEntry->enmType = RTDIRENTRYTYPE_DIRECTORY;
+                break;
+
+            case FILE_ATTRIBUTE_REPARSE_POINT:
+            case FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_DIRECTORY:
+                pDirEntry->enmType = RTDIRENTRYTYPE_SYMLINK;
+                break;
+        }
+    }
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+    else
+    {
+        pDirEntry->enmType = RTDIRENTRYTYPE_UNKNOWN;
+        if (rtNtCompWideStrAndAscii(pDir->uCurData.pObjDir->TypeName.Buffer, pDir->uCurData.pObjDir->TypeName.Length,
+                                    RT_STR_TUPLE("Directory")))
+            pDirEntry->enmType = RTDIRENTRYTYPE_DIRECTORY;
+        else if (rtNtCompWideStrAndAscii(pDir->uCurData.pObjDir->TypeName.Buffer, pDir->uCurData.pObjDir->TypeName.Length,
+                                         RT_STR_TUPLE("SymbolicLink")))
+            pDirEntry->enmType = RTDIRENTRYTYPE_SYMLINK;
+    }
+#endif
+
+    return rtDirNtAdvanceBuffer(pDir);
+}
+
+
+RTDECL(int) RTDirReadEx(PRTDIR pDir, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry,
+                        RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags)
+{
+    int rc;
+
     /*
      * Validate input.
      */
-    if (!pDir || pDir->u32Magic != RTDIR_MAGIC)
-    {
-        AssertMsgFailed(("Invalid pDir=%p\n", pDir));
-        return VERR_INVALID_PARAMETER;
-    }
-    if (!pDirEntry)
-    {
-        AssertMsgFailed(("Invalid pDirEntry=%p\n", pDirEntry));
-        return VERR_INVALID_PARAMETER;
-    }
-    if (    enmAdditionalAttribs < RTFSOBJATTRADD_NOTHING
-        ||  enmAdditionalAttribs > RTFSOBJATTRADD_LAST)
-    {
-        AssertMsgFailed(("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs));
-        return VERR_INVALID_PARAMETER;
-    }
+    AssertPtrReturn(pDir, VERR_INVALID_POINTER);
+    AssertReturn(pDir->u32Magic == RTDIR_MAGIC, VERR_INVALID_HANDLE);
+    AssertPtrReturn(pDirEntry, VERR_INVALID_POINTER);
+
+    AssertReturn(enmAdditionalAttribs >= RTFSOBJATTRADD_NOTHING && enmAdditionalAttribs <= RTFSOBJATTRADD_LAST,
+                 VERR_INVALID_PARAMETER);
     AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
+
     size_t cbDirEntry = sizeof(*pDirEntry);
     if (pcbDirEntry)
     {
         cbDirEntry = *pcbDirEntry;
-        if (cbDirEntry < RT_UOFFSETOF(RTDIRENTRYEX, szName[2]))
-        {
-            AssertMsgFailed(("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRYEX, szName[2])));
-            return VERR_INVALID_PARAMETER;
-        }
+        AssertMsgReturn(cbDirEntry >= RT_UOFFSETOF(RTDIRENTRYEX, szName[2]),
+                        ("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRYEX, szName[2])),
+                        VERR_INVALID_PARAMETER);
     }
 
@@ -253 +550 @@
     if (!pDir->fDataUnread)
     {
-        RTStrFree(pDir->pszName);
-        pDir->pszName = NULL;
-
-        BOOL fRc = FindNextFileW(pDir->hDir, &pDir->Data);
-        if (!fRc)
-        {
-            int iErr = GetLastError();
-            if (pDir->hDir == INVALID_HANDLE_VALUE || iErr == ERROR_NO_MORE_FILES)
-                return VERR_NO_MORE_FILES;
-            return RTErrConvertFromWin32(iErr);
-        }
+        rc = rtDirNtFetchMore(pDir);
+        if (RT_FAILURE(rc))
+            return rc;
     }
 
@@ -269 +558 @@
      * Convert the filename to UTF-8.
      */
-    if (!pDir->pszName)
-    {
-        int rc = RTUtf16ToUtf8((PCRTUTF16)pDir->Data.cFileName, &pDir->pszName);
-        if (RT_FAILURE(rc))
-        {
-            pDir->pszName = NULL;
-            return rc;
-        }
-        pDir->cchName = strlen(pDir->pszName);
-    }
+    rc = rtDirNtConvertCurName(pDir);
+    if (RT_FAILURE(rc))
+        return rc;
 
     /*
@@ -294 +576 @@
      * Setup the returned data.
      */
-    pDir->fDataUnread  = false;
-    pDirEntry->cbName  = (uint16_t)cchName;
-    Assert(pDirEntry->cbName == cchName);
+    PFILE_BOTH_DIR_INFORMATION pBoth = pDir->uCurData.pBoth;
+
+    pDirEntry->cbName  = (uint16_t)cchName;  Assert(pDirEntry->cbName == cchName);
     memcpy(pDirEntry->szName, pszName, cchName + 1);
-    if (pDir->Data.cAlternateFileName[0])
-    {
-        /* copy and calc length */
-        PCRTUTF16 pwszSrc = (PCRTUTF16)pDir->Data.cAlternateFileName;
-        PRTUTF16  pwszDst = pDirEntry->wszShortName;
-        uint32_t  off = 0;
-        while (pwszSrc[off] && off < RT_ELEMENTS(pDirEntry->wszShortName) - 1U)
+    memset(pDirEntry->wszShortName, 0, sizeof(pDirEntry->wszShortName));
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+    if (pDir->enmInfoClass != FileMaximumInformation)
+#endif
+    {
+        uint8_t cbShort = pBoth->ShortNameLength;
+        if (cbShort > 0)
         {
-            pwszDst[off] = pwszSrc[off];
-            off++;
+            AssertStmt(cbShort < sizeof(pDirEntry->wszShortName), cbShort = sizeof(pDirEntry->wszShortName) - 2);
+            memcpy(pDirEntry->wszShortName, pBoth->ShortName, cbShort);
+            pDirEntry->cwcShortName = cbShort / 2;
         }
-        pDirEntry->cwcShortName = (uint16_t)off;
-
-        /* zero the rest */
-        do
-            pwszDst[off++] = '\0';
-        while (off < RT_ELEMENTS(pDirEntry->wszShortName));
-    }
+        else
+            pDirEntry->cwcShortName = 0;
+
+        pDirEntry->Info.cbObject    = pBoth->EndOfFile.QuadPart;
+        pDirEntry->Info.cbAllocated = pBoth->AllocationSize.QuadPart;
+
+        Assert(sizeof(uint64_t) == sizeof(pBoth->CreationTime));
+        RTTimeSpecSetNtTime(&pDirEntry->Info.BirthTime,         pBoth->CreationTime.QuadPart);
+        RTTimeSpecSetNtTime(&pDirEntry->Info.AccessTime,        pBoth->LastAccessTime.QuadPart);
+        RTTimeSpecSetNtTime(&pDirEntry->Info.ModificationTime,  pBoth->LastWriteTime.QuadPart);
+        RTTimeSpecSetNtTime(&pDirEntry->Info.ChangeTime,        pBoth->ChangeTime.QuadPart);
+
+        pDirEntry->Info.Attr.fMode  = rtFsModeFromDos((pBoth->FileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT,
+                                                       pszName, cchName);
+    }
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
     else
     {
-        memset(pDirEntry->wszShortName, 0, sizeof(pDirEntry->wszShortName));
         pDirEntry->cwcShortName = 0;
-    }
-
-    pDirEntry->Info.cbObject    = ((uint64_t)pDir->Data.nFileSizeHigh << 32)
-                                |  (uint64_t)pDir->Data.nFileSizeLow;
-    pDirEntry->Info.cbAllocated = pDirEntry->Info.cbObject;
-
-    Assert(sizeof(uint64_t) == sizeof(pDir->Data.ftCreationTime));
-    RTTimeSpecSetNtTime(&pDirEntry->Info.BirthTime,         *(uint64_t *)&pDir->Data.ftCreationTime);
-    RTTimeSpecSetNtTime(&pDirEntry->Info.AccessTime,        *(uint64_t *)&pDir->Data.ftLastAccessTime);
-    RTTimeSpecSetNtTime(&pDirEntry->Info.ModificationTime,  *(uint64_t *)&pDir->Data.ftLastWriteTime);
-    pDirEntry->Info.ChangeTime  = pDirEntry->Info.ModificationTime;
-
-    pDirEntry->Info.Attr.fMode  = rtFsModeFromDos((pDir->Data.dwFileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT,
-                                                   pszName, cchName);
+        pDirEntry->Info.cbObject    = 0;
+        pDirEntry->Info.cbAllocated = 0;
+        RTTimeSpecSetNtTime(&pDirEntry->Info.BirthTime,         0);
+        RTTimeSpecSetNtTime(&pDirEntry->Info.AccessTime,        0);
+        RTTimeSpecSetNtTime(&pDirEntry->Info.ModificationTime,  0);
+        RTTimeSpecSetNtTime(&pDirEntry->Info.ChangeTime,        0);
+
+        if (rtNtCompWideStrAndAscii(pDir->uCurData.pObjDir->TypeName.Buffer, pDir->uCurData.pObjDir->TypeName.Length,
+                                    RT_STR_TUPLE("Directory")))
+            pDirEntry->Info.Attr.fMode = RTFS_DOS_DIRECTORY | RTFS_TYPE_DIRECTORY | 0777;
+        else if (rtNtCompWideStrAndAscii(pDir->uCurData.pObjDir->TypeName.Buffer, pDir->uCurData.pObjDir->TypeName.Length,
+                                         RT_STR_TUPLE("SymbolicLink")))
+            pDirEntry->Info.Attr.fMode = RTFS_DOS_NT_REPARSE_POINT | RTFS_TYPE_SYMLINK | 0777;
+        else if (rtNtCompWideStrAndAscii(pDir->uCurData.pObjDir->TypeName.Buffer, pDir->uCurData.pObjDir->TypeName.Length,
+                                         RT_STR_TUPLE("Device")))
+            pDirEntry->Info.Attr.fMode = RTFS_DOS_NT_DEVICE | RTFS_TYPE_DEV_CHAR | 0666;
+        else
+            pDirEntry->Info.Attr.fMode = RTFS_DOS_NT_NORMAL | RTFS_TYPE_FILE | 0666;
+    }
+#endif
 
     /*
@@ -342 +639 @@
         case RTFSOBJATTRADD_EASIZE:
             pDirEntry->Info.Attr.enmAdditional          = RTFSOBJATTRADD_EASIZE;
-            pDirEntry->Info.Attr.u.EASize.cb            = 0;
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+            if (pDir->enmInfoClass == FileMaximumInformation)
+                pDirEntry->Info.Attr.u.EASize.cb        = 0;
+            else
+#endif
+                pDirEntry->Info.Attr.u.EASize.cb        = pBoth->EaSize;
             break;
 
@@ -378 +680 @@
     }
 
-    return VINF_SUCCESS;
-}
-
+    /*
+     * Follow links if requested.
+     */
+    if (   (fFlags & RTPATH_F_FOLLOW_LINK)
+        && RTFS_IS_SYMLINK(fFlags))
+    {
+        /** @todo Symlinks: Find[First|Next]FileW will return info about
+            the link, so RTPATH_F_FOLLOW_LINK is not handled correctly. */
+    }
+
+    /*
+     * Finally advance the buffer.
+     */
+    return rtDirNtAdvanceBuffer(pDir);
+}
+

trunk/src/VBox/Runtime/r3/nt/fs-nt.cpp

@@ -226 +226 @@
 
 
-/**
- * Internal helper for comparing a WCHAR string with a char string.
- *
- * @returns @c true if equal, @c false if not.
- * @param   pwsz1               The first string.
- * @param   cb1                 The length of the first string, in bytes.
- * @param   psz2                The second string.
- * @param   cch2                The length of the second string.
- */
-static bool rtFsCompWideStrAndAscii(WCHAR const *pwsz1, size_t cch1, const char *psz2, size_t cch2)
-{
-    if (cch1 != cch2 * 2)
-        return false;
-    while (cch2-- > 0)
-    {
-        unsigned ch1 = *pwsz1++;
-        unsigned ch2 = (unsigned char)*psz2++;
-        if (ch1 != ch2)
-            return false;
-    }
-    return true;
-}
-
 
 RTR3DECL(int) RTFsQueryType(const char *pszFsPath, PRTFSTYPE penmType)
@@ -287 +264 @@
         {
 #define IS_FS(a_szName) \
-rtFsCompWideStrAndAscii(u.FsAttrInfo.FileSystemName, u.FsAttrInfo.FileSystemNameLength, RT_STR_TUPLE(a_szName))
+    rtNtCompWideStrAndAscii(u.FsAttrInfo.FileSystemName, u.FsAttrInfo.FileSystemNameLength, RT_STR_TUPLE(a_szName))
             if (IS_FS("NTFS"))
                 *penmType = RTFSTYPE_NTFS;

trunk/src/VBox/Runtime/r3/nt/internal-r3-nt.h

@@ -48 +48 @@
 # include <ntifs.h>
 #endif
+#include "internal/iprt.h"
 
 
@@ -53 +54 @@
 *   Defined Constants And Macros                                               *
 *******************************************************************************/
+/** Indicates that we're targetting native NT in the current source. */
+#define RT_USE_NATIVE_NT                1
 /** Initializes a IO_STATUS_BLOCK. */
 #define MY_IO_STATUS_BLOCK_INITIALIZER  { STATUS_FAILED_DRIVER_ENTRY, ~(uintptr_t)42 }
 /** Similar to INVALID_HANDLE_VALUE in the Windows environment. */
 #define MY_INVALID_HANDLE_VALUE         ( (HANDLE)~(uintptr_t)0 )
+
+#ifdef DEBUG_bird
+/** Enables the "\\!\" NT path pass thru as well as hacks for listing NT object
+ * directories. */
+# define IPRT_WITH_NT_PATH_PASSTHRU 1
+#endif
 
 
@@ -65 +74 @@
                   ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs,
                   PHANDLE phHandle, PULONG_PTR puDisposition);
+int  rtNtPathOpenDir(const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fShareAccess, ULONG fCreateOptions,
+                     ULONG fObjAttribs, PHANDLE phHandle, bool *pfObjDir);
 int  rtNtPathClose(HANDLE hHandle);
+
+
+/**
+ * Internal helper for comparing a WCHAR string with a char string.
+ *
+ * @returns @c true if equal, @c false if not.
+ * @param   pwsz1               The first string.
+ * @param   cb1                 The length of the first string, in bytes.
+ * @param   psz2                The second string.
+ * @param   cch2                The length of the second string.
+ */
+DECLINLINE(bool) rtNtCompWideStrAndAscii(WCHAR const *pwsz1, size_t cch1, const char *psz2, size_t cch2)
+{
+    if (cch1 != cch2 * 2)
+        return false;
+    while (cch2-- > 0)
+    {
+        unsigned ch1 = *pwsz1++;
+        unsigned ch2 = (unsigned char)*psz2++;
+        if (ch1 != ch2)
+            return false;
+    }
+    return true;
+}
 
 
@@ -71 +106 @@
 *   NT APIs                                                                    *
 *******************************************************************************/
+
+RT_C_DECLS_BEGIN
 
 #ifdef IPRT_NT_NEED_API_GROUP_1
@@ -86 +123 @@
 #endif
 
+NTSTATUS NTAPI NtOpenDirectoryObject(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
+
+typedef struct _OBJECT_DIRECTORY_INFORMATION
+{
+    UNICODE_STRING Name;
+    UNICODE_STRING TypeName;
+} OBJECT_DIRECTORY_INFORMATION;
+typedef OBJECT_DIRECTORY_INFORMATION *POBJECT_DIRECTORY_INFORMATION;
+
+NTSTATUS NTAPI NtQueryDirectoryObject(HANDLE, PVOID, ULONG, BOOLEAN, BOOLEAN, PULONG, PULONG);
+
+
+RT_C_DECLS_END
 
 #endif

trunk/src/VBox/Runtime/r3/nt/pathint-nt.cpp

@@ -47 +47 @@
  * @param   pszPath             The UTF-8 path.
  */
-static int rtNtPathToNativePassThru(struct _UNICODE_STRING *pNtName, PHANDLE phRootDir, const char *pszPath)
-{
-    PRTUTF16 pwszPath;
-    int rc = RTStrToUtf16(pszPath + 1, &pwszPath);
+static int rtNtPathToNativePassThruWin(struct _UNICODE_STRING *pNtName, PHANDLE phRootDir, const char *pszPath)
+{
+    PRTUTF16 pwszPath = NULL;
+    size_t   cwcLen;
+    int rc = RTStrToUtf16Ex(pszPath + 1, RTSTR_MAX, &pwszPath, 0, &cwcLen);
     if (RT_SUCCESS(rc))
     {
-        pwszPath[0] = '\\';
-        pwszPath[1] = '.';
-        pwszPath[2] = '\\';
-
-        size_t cwcLen = RTUtf16Len(pwszPath);
         if (cwcLen < _32K - 1)
         {
+            pwszPath[0] = '\\';
+            pwszPath[1] = '.';
+            pwszPath[2] = '\\';
+
             pNtName->Buffer = pwszPath;
-            pNtName->MaximumLength = pNtName->Length = (uint16_t)((cwcLen + 0) * 2);
+            pNtName->MaximumLength = pNtName->Length = (uint16_t)(cwcLen * 2);
+            *phRootDir = NULL;
+            return VINF_SUCCESS;
+        }
+
+        RTUtf16Free(pwszPath);
+        rc = VERR_FILENAME_TOO_LONG;
+    }
+    return rc;
+}
+
+
+/**
+ * Converts the path to UTF-16 and sets all the return values.
+ *
+ * @returns IPRT status code.
+ * @param   pNtName             Where to return the NT name.
+ * @param   phRootDir           Where to return the root handle, if applicable.
+ * @param   pszPath             The UTF-8 path.
+ */
+static int rtNtPathToNativeToUtf16(struct _UNICODE_STRING *pNtName, PHANDLE phRootDir, const char *pszPath)
+{
+    PRTUTF16 pwszPath = NULL;
+    size_t   cwcLen;
+    int rc = RTStrToUtf16Ex(pszPath, RTSTR_MAX, &pwszPath, 0, &cwcLen);
+    if (RT_SUCCESS(rc))
+    {
+        if (cwcLen < _32K - 1)
+        {
+            pNtName->Buffer = pwszPath;
+            pNtName->MaximumLength = pNtName->Length = (uint16_t)(cwcLen * 2);
             *phRootDir = NULL;
             return VINF_SUCCESS;
@@ -100 +130 @@
         if (   pszPath[2] == '?'
             && RTPATH_IS_SLASH(pszPath[3]))
-            return rtNtPathToNativePassThru(pNtName, phRootDir, pszPath);
+            return rtNtPathToNativePassThruWin(pNtName, phRootDir, pszPath);
+
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+        /* Special hack: The path starts with "\\\\!\\", we will skip past the bang and pass it thru. */
+        if (   pszPath[2] == '!'
+            && RTPATH_IS_SLASH(pszPath[3]))
+            return rtNtPathToNativeToUtf16(pNtName, phRootDir, pszPath + 3);
+#endif
 
         if (   pszPath[2] == '.'
@@ -132 +169 @@
      */
     memcpy(szPath, pszPrefix, cchPrefix);
-    PRTUTF16 pwszPath;
-    rc = RTStrToUtf16(szPath, &pwszPath);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    size_t cwcLen = RTUtf16Len(pwszPath);
-    if (cwcLen >= _32K - 1)
-    {
-        RTUtf16Free(pwszPath);
-        return VERR_FILENAME_TOO_LONG;
-    }
-
-    /*
-     * Success.
-     */
-    pNtName->Buffer = pwszPath;
-    pNtName->MaximumLength = pNtName->Length = (uint16_t)((cwcLen + 0) * 2);
-    *phRootDir = NULL;
-    return VINF_SUCCESS;
+    return rtNtPathToNativeToUtf16(pNtName, phRootDir, szPath);
 }
 
@@ -227 +246 @@
 
 /**
+ * Wrapper around NtCreateFile.
+ *
+ * @returns IPRT status code.
+ * @param   pszPath             The UTF-8 path.
+ * @param   fDesiredAccess      See NtCreateFile.
+ * @param   fFileAttribs        See NtCreateFile.
+ * @param   fShareAccess        See NtCreateFile.
+ * @param   fCreateDisposition  See NtCreateFile.
+ * @param   fCreateOptions      See NtCreateFile.
+ * @param   fObjAttribs         The OBJECT_ATTRIBUTES::Attributes value, see
+ *                              NtCreateFile and InitializeObjectAttributes.
+ * @param   phHandle            Where to return the handle.
+ * @param   pfObjDir            If not NULL, the variable pointed to will be set
+ *                              to @c true if we opened an object directory and
+ *                              @c false if we opened an directory file (normal
+ *                              directory).
+ */
+int  rtNtPathOpenDir(const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fShareAccess, ULONG fCreateOptions,
+                     ULONG fObjAttribs, PHANDLE phHandle, bool *pfObjDir)
+{
+    *phHandle = MY_INVALID_HANDLE_VALUE;
+
+    HANDLE         hRootDir;
+    UNICODE_STRING NtName;
+    int rc = rtNtPathToNative(&NtName, &hRootDir, pszPath);
+    if (RT_SUCCESS(rc))
+    {
+        HANDLE              hFile = MY_INVALID_HANDLE_VALUE;
+        IO_STATUS_BLOCK     Ios   = MY_IO_STATUS_BLOCK_INITIALIZER;
+        OBJECT_ATTRIBUTES   ObjAttr;
+        InitializeObjectAttributes(&ObjAttr, &NtName, fObjAttribs, hRootDir, NULL);
+
+        NTSTATUS rcNt = NtCreateFile(&hFile,
+                                     fDesiredAccess,
+                                     &ObjAttr,
+                                     &Ios,
+                                     NULL /* AllocationSize*/,
+                                     FILE_ATTRIBUTE_NORMAL,
+                                     fShareAccess,
+                                     FILE_OPEN,
+                                     fCreateOptions,
+                                     NULL /*EaBuffer*/,
+                                     0 /*EaLength*/);
+        if (NT_SUCCESS(rcNt))
+        {
+            if (pfObjDir)
+                *pfObjDir = false;
+            *phHandle = hFile;
+            rc = VINF_SUCCESS;
+        }
+#ifdef IPRT_WITH_NT_PATH_PASSTHRU
+        else if (   pfObjDir
+                 && (rcNt == STATUS_OBJECT_NAME_INVALID || rcNt == STATUS_OBJECT_TYPE_MISMATCH)
+                 && RTPATH_IS_SLASH(pszPath[0])
+                 && RTPATH_IS_SLASH(pszPath[1])
+                 && pszPath[2] == '!'
+                 && RTPATH_IS_SLASH(pszPath[3]))
+        {
+            /* Strip trailing slash. */
+            if (   NtName.Length > 2
+                && RTPATH_IS_SLASH(NtName.Buffer[(NtName.Length / 2) - 1]))
+                NtName.Length -= 2;
+
+            /* Rought conversion of the access flags. */
+            ULONG fObjDesiredAccess = 0;
+            if (fDesiredAccess & (GENERIC_ALL | STANDARD_RIGHTS_ALL))
+                fObjDesiredAccess = DIRECTORY_ALL_ACCESS;
+            else
+            {
+                if (fDesiredAccess & (FILE_GENERIC_WRITE | GENERIC_WRITE | STANDARD_RIGHTS_WRITE))
+                    fObjDesiredAccess |= DIRECTORY_CREATE_OBJECT | DIRECTORY_CREATE_OBJECT;
+                if (   (fDesiredAccess & (FILE_LIST_DIRECTORY | FILE_GENERIC_READ | GENERIC_READ | STANDARD_RIGHTS_READ))
+                    || !fObjDesiredAccess)
+                    fObjDesiredAccess |= DIRECTORY_QUERY | FILE_LIST_DIRECTORY;
+            }
+
+            rcNt = NtOpenDirectoryObject(&hFile, fObjDesiredAccess, &ObjAttr);
+            if (NT_SUCCESS(rcNt))
+            {
+                *pfObjDir = true;
+                *phHandle = hFile;
+                rc = VINF_SUCCESS;
+            }
+            else
+                rc = RTErrConvertFromNtStatus(rcNt);
+        }
+#endif
+        else
+            rc = RTErrConvertFromNtStatus(rcNt);
+        rtNtPathFreeNative(&NtName, &hRootDir);
+    }
+    return rc;
+}
+
+
+/**
  * Closes an handled open by rtNtPathOpen.
  *