VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/nt/RTPathQueryInfo-nt.cpp@ 70375

最後變更 在這個檔案從70375是 70195,由 vboxsync 提交於 7 年 前

IPRT/R3: Made the core work on NT 3.51 (still experimental).
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Author Date Id Revision
檔案大小: 29.1 KB
行 
1/* $Id: RTPathQueryInfo-nt.cpp 70195 2017-12-18 13:40:26Z vboxsync $ */
2/** @file
3 * IPRT - RTPathQueryInfo[Ex], Native NT.
4 */
5
6/*
7 * Copyright (C) 2006-2017 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.alldomusa.eu.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#define LOG_GROUP RTLOGGROUP_FILE
32#include "internal-r3-nt.h"
33
34#include <iprt/path.h>
35#include <iprt/err.h>
36#include <iprt/time.h>
37#include "internal/fs.h"
38#include "internal/path.h"
39
40
41/*********************************************************************************************************************************
42* Defined Constants And Macros *
43*********************************************************************************************************************************/
44/** Helper for comparing a UNICODE_STRING with a string litteral. */
45#define ARE_UNICODE_STRINGS_EQUAL(a_UniStr, a_wszType) \
46 ( (a_UniStr)->Length == sizeof(a_wszType) - sizeof(RTUTF16) \
47 && memcmp((a_UniStr)->Buffer, a_wszType, sizeof(a_wszType) - sizeof(RTUTF16)) == 0)
48
49
50/*********************************************************************************************************************************
51* Global Variables *
52*********************************************************************************************************************************/
53extern decltype(NtQueryFullAttributesFile) *g_pfnNtQueryFullAttributesFile; /* init-win.cpp */
54
55
56/* ASSUMES FileID comes after ShortName and the structs are identical up to that point. */
57AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, NextEntryOffset, FILE_ID_BOTH_DIR_INFORMATION, NextEntryOffset);
58AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, FileIndex , FILE_ID_BOTH_DIR_INFORMATION, FileIndex );
59AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, CreationTime , FILE_ID_BOTH_DIR_INFORMATION, CreationTime );
60AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, LastAccessTime , FILE_ID_BOTH_DIR_INFORMATION, LastAccessTime );
61AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, LastWriteTime , FILE_ID_BOTH_DIR_INFORMATION, LastWriteTime );
62AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, ChangeTime , FILE_ID_BOTH_DIR_INFORMATION, ChangeTime );
63AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, EndOfFile , FILE_ID_BOTH_DIR_INFORMATION, EndOfFile );
64AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, AllocationSize , FILE_ID_BOTH_DIR_INFORMATION, AllocationSize );
65AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, FileAttributes , FILE_ID_BOTH_DIR_INFORMATION, FileAttributes );
66AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, FileNameLength , FILE_ID_BOTH_DIR_INFORMATION, FileNameLength );
67AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, EaSize , FILE_ID_BOTH_DIR_INFORMATION, EaSize );
68AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, ShortNameLength, FILE_ID_BOTH_DIR_INFORMATION, ShortNameLength);
69AssertCompileMembersSameSizeAndOffset(FILE_BOTH_DIR_INFORMATION, ShortName , FILE_ID_BOTH_DIR_INFORMATION, ShortName );
70
71
72
73/**
74 * Splits up an NT path into directory and filename.
75 *
76 * @param pNtName The path to split.
77 * @param pNtParent Where to return the directory path.
78 * @param pNtFilename Where to return the filename part.
79 * @param fNoParentDirSlash Whether to make sure the directory path doesn't
80 * end with a slash (except root).
81 */
82static void ntPathNtSplitName(UNICODE_STRING const *pNtName, UNICODE_STRING *pNtParent, UNICODE_STRING *pNtFilename,
83 bool fNoParentDirSlash)
84{
85 PRTUTF16 pwszBuffer = pNtName->Buffer;
86 size_t off = pNtName->Length / sizeof(RTUTF16);
87
88 /* Skip trailing slash if present. */
89 if ( off > 0
90 && pwszBuffer[off - 1] == '\\')
91 off--;
92
93 /* Find the slash before that. */
94 RTUTF16 wc;
95 while ( off > 0
96 && (wc = pwszBuffer[off - 1]) != '\\'
97 && wc != '/')
98 off--;
99 if (off != 0)
100 {
101 pNtParent->Buffer = pwszBuffer;
102 pNtParent->MaximumLength = pNtParent->Length = (USHORT)(off * sizeof(RTUTF16));
103 }
104 else
105 {
106 AssertFailed(); /* This is impossible and won't work (NT doesn't know '.' or '..'). */
107 /** @todo query the whole path as it is possible relative. Use the buffer for
108 * temporary name storage. */
109 pNtParent->Buffer = L".";
110 pNtParent->Length = 1 * sizeof(RTUTF16);
111 pNtParent->MaximumLength = 2 * sizeof(RTUTF16);
112 }
113
114 pNtFilename->Buffer = &pwszBuffer[off];
115 pNtFilename->Length = pNtName->Length - (USHORT)(off * sizeof(RTUTF16));
116 pNtFilename->MaximumLength = pNtName->MaximumLength - (USHORT)(off * sizeof(RTUTF16));
117
118 while ( fNoParentDirSlash
119 && pNtParent->Length > sizeof(RTUTF16)
120 && pNtParent->Buffer[pNtParent->Length / sizeof(RTUTF16) - 1] == '\\')
121 pNtParent->Length -= sizeof(RTUTF16);
122}
123
124
125/**
126 * Deals with enmAddAttr != RTFSOBJATTRADD_UNIX.
127 *
128 * @returns IPRT status code (usually @a rc).
129 * @param rc The return code.
130 * @param pObjInfo The info to complete.
131 * @param enmAddAttr What to complete it with. Caller should fill in
132 * RTFSOBJATTRADD_UNIX.
133 */
134static int rtPathNtQueryInfoFillInDummyData(int rc, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
135{
136 switch (enmAddAttr)
137 {
138 case RTFSOBJATTRADD_UNIX:
139 pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
140 break;
141
142 case RTFSOBJATTRADD_NOTHING:
143 pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_NOTHING;
144 break;
145
146 case RTFSOBJATTRADD_UNIX_OWNER:
147 pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_OWNER;
148 pObjInfo->Attr.u.UnixOwner.uid = NIL_RTUID;
149 pObjInfo->Attr.u.UnixOwner.szName[0] = '\0'; /** @todo return something sensible here. */
150 break;
151
152 case RTFSOBJATTRADD_UNIX_GROUP:
153 pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_GROUP;
154 pObjInfo->Attr.u.UnixGroup.gid = NIL_RTGID;
155 pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
156 break;
157
158 case RTFSOBJATTRADD_EASIZE:
159 pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
160 pObjInfo->Attr.u.EASize.cb = 0;
161 break;
162
163 default:
164 AssertMsgFailed(("Impossible!\n"));
165 rc = VERR_INTERNAL_ERROR;
166 }
167 return rc;
168}
169
170
171/**
172 * Deal with getting info about something that could be in a directory object.
173 *
174 * @returns IPRT status code
175 * @param pObjAttr The NT object attribute.
176 * @param pObjInfo Where to return the info.
177 * @param enmAddAttr Which extra attributes to get (/fake).
178 * @param fFlags The flags.
179 * @param pvBuf Query buffer space.
180 * @param cbBuf Size of the buffer. ASSUMES lots of space.
181 */
182static int rtPathNtQueryInfoInDirectoryObject(OBJECT_ATTRIBUTES *pObjAttr, PRTFSOBJINFO pObjInfo,
183 RTFSOBJATTRADD enmAddAttr, uint32_t fFlags,
184 void *pvBuf, size_t cbBuf)
185{
186 RT_NOREF(fFlags);
187
188 /*
189 * Special case: Root dir.
190 */
191 if ( pObjAttr->RootDirectory == NULL
192 && pObjAttr->ObjectName->Length == sizeof(RTUTF16)
193 && pObjAttr->ObjectName->Buffer[0] == '\\')
194 {
195 pObjInfo->cbObject = 0;
196 pObjInfo->cbAllocated = 0;
197 RTTimeSpecSetNtTime(&pObjInfo->BirthTime, 0);
198 RTTimeSpecSetNtTime(&pObjInfo->AccessTime, 0);
199 RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, 0);
200 RTTimeSpecSetNtTime(&pObjInfo->ChangeTime, 0);
201 pObjInfo->Attr.fMode = RTFS_DOS_DIRECTORY | RTFS_TYPE_DIRECTORY | 0777;
202 return rtPathNtQueryInfoFillInDummyData(VINF_SUCCESS, pObjInfo, enmAddAttr);
203 }
204
205 /*
206 * We must open and scan the parent directory object.
207 */
208 UNICODE_STRING NtDirName;
209 UNICODE_STRING NtDirEntry;
210 ntPathNtSplitName(pObjAttr->ObjectName, &NtDirName, &NtDirEntry, true /*fNoParentDirSlash*/);
211
212 while ( NtDirEntry.Length > sizeof(RTUTF16)
213 && NtDirEntry.Buffer[NtDirEntry.Length / sizeof(RTUTF16) - 1] == '\\')
214 NtDirEntry.Length -= sizeof(RTUTF16);
215
216 pObjAttr->ObjectName = &NtDirName;
217 HANDLE hDir = RTNT_INVALID_HANDLE_VALUE;
218 NTSTATUS rcNt = NtOpenDirectoryObject(&hDir, DIRECTORY_QUERY | DIRECTORY_TRAVERSE, pObjAttr);
219 if (NT_SUCCESS(rcNt))
220 {
221 ULONG uObjDirCtx = 0;
222 for (;;)
223 {
224 ULONG cbReturned = 0;
225 rcNt = NtQueryDirectoryObject(hDir,
226 pvBuf,
227 (ULONG)cbBuf,
228 FALSE /*ReturnSingleEntry */,
229 FALSE /*RestartScan*/,
230 &uObjDirCtx,
231 &cbReturned);
232 if (!NT_SUCCESS(rcNt))
233 break;
234
235 for (POBJECT_DIRECTORY_INFORMATION pObjDir = (POBJECT_DIRECTORY_INFORMATION)pvBuf;
236 pObjDir->Name.Length != 0;
237 pObjDir++)
238 {
239 if ( pObjDir->Name.Length == NtDirEntry.Length
240 && memcmp(pObjDir->Name.Buffer, NtDirEntry.Buffer, NtDirEntry.Length) == 0)
241 {
242 /*
243 * Find it. Fill in the info we've got and return (see similar code in direnum-r3-nt.cpp).
244 */
245 NtClose(hDir);
246
247 pObjInfo->cbObject = 0;
248 pObjInfo->cbAllocated = 0;
249 RTTimeSpecSetNtTime(&pObjInfo->BirthTime, 0);
250 RTTimeSpecSetNtTime(&pObjInfo->AccessTime, 0);
251 RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, 0);
252 RTTimeSpecSetNtTime(&pObjInfo->ChangeTime, 0);
253
254 if (ARE_UNICODE_STRINGS_EQUAL(&pObjDir->TypeName, L"Directory"))
255 pObjInfo->Attr.fMode = RTFS_DOS_DIRECTORY | RTFS_TYPE_DIRECTORY | 0777;
256 else if (ARE_UNICODE_STRINGS_EQUAL(&pObjDir->TypeName, L"SymbolicLink"))
257 pObjInfo->Attr.fMode = RTFS_DOS_NT_REPARSE_POINT | RTFS_TYPE_SYMLINK | 0777;
258 else if (ARE_UNICODE_STRINGS_EQUAL(&pObjDir->TypeName, L"Device"))
259 pObjInfo->Attr.fMode = RTFS_DOS_NT_DEVICE | RTFS_TYPE_DEV_CHAR | 0666;
260 else
261 pObjInfo->Attr.fMode = RTFS_DOS_NT_NORMAL | RTFS_TYPE_FILE | 0666;
262
263 pObjInfo->Attr.enmAdditional = enmAddAttr;
264 return rtPathNtQueryInfoFillInDummyData(VINF_SUCCESS, pObjInfo, enmAddAttr);
265 }
266 }
267 }
268
269 NtClose(hDir);
270 if (rcNt == STATUS_NO_MORE_FILES || rcNt == STATUS_NO_MORE_ENTRIES || rcNt == STATUS_NO_SUCH_FILE)
271 return VERR_FILE_NOT_FOUND;
272 }
273 return RTErrConvertFromNtStatus(rcNt);
274}
275
276
277/**
278 * Queries information from a file or directory handle.
279 *
280 * This is shared between the RTPathQueryInfo, RTFileQueryInfo and
281 * RTDirQueryInfo code.
282 *
283 * @returns IPRT status code.
284 * @param hFile The handle to query information from. Must have
285 * the necessary privileges.
286 * @param pvBuf Pointer to a scratch buffer.
287 * @param cbBuf The size of the buffer. This must be large
288 * enough to hold a FILE_ALL_INFORMATION struct.
289 * @param pObjInfo Where to return information about the handle.
290 * @param enmAddAttr What extra info to return.
291 * @param pszPath The path if this is a file (for exe detect).
292 * @param uReparseTag The reparse tag number (0 if not applicable) for
293 * symlink detection/whatnot.
294 */
295DECLHIDDEN(int) rtPathNtQueryInfoFromHandle(HANDLE hFile, void *pvBuf, size_t cbBuf, PRTFSOBJINFO pObjInfo,
296 RTFSOBJATTRADD enmAddAttr, const char *pszPath, ULONG uReparseTag)
297{
298 Assert(cbBuf >= sizeof(FILE_ALL_INFORMATION));
299
300 /** @todo Try optimize this for when RTFSOBJATTRADD_UNIX isn't set? */
301 IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
302 NTSTATUS rcNt = NtQueryInformationFile(hFile, &Ios, pvBuf, sizeof(FILE_ALL_INFORMATION), FileAllInformation);
303 if ( NT_SUCCESS(rcNt)
304 || rcNt == STATUS_BUFFER_OVERFLOW)
305 {
306 FILE_ALL_INFORMATION *pAllInfo = (FILE_ALL_INFORMATION *)pvBuf;
307 pObjInfo->cbObject = pAllInfo->StandardInformation.EndOfFile.QuadPart;
308 pObjInfo->cbAllocated = pAllInfo->StandardInformation.AllocationSize.QuadPart;
309 RTTimeSpecSetNtTime(&pObjInfo->BirthTime, pAllInfo->BasicInformation.CreationTime.QuadPart);
310 RTTimeSpecSetNtTime(&pObjInfo->AccessTime, pAllInfo->BasicInformation.LastAccessTime.QuadPart);
311 RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, pAllInfo->BasicInformation.LastWriteTime.QuadPart);
312 RTTimeSpecSetNtTime(&pObjInfo->ChangeTime, pAllInfo->BasicInformation.ChangeTime.QuadPart);
313 pObjInfo->Attr.fMode = rtFsModeFromDos( (pAllInfo->BasicInformation.FileAttributes << RTFS_DOS_SHIFT)
314 & RTFS_DOS_MASK_NT,
315 pszPath, pszPath ? strlen(pszPath) : 0, uReparseTag);
316 pObjInfo->Attr.enmAdditional = enmAddAttr;
317 if (enmAddAttr == RTFSOBJATTRADD_UNIX)
318 {
319 pObjInfo->Attr.u.Unix.uid = ~0U;
320 pObjInfo->Attr.u.Unix.gid = ~0U;
321 pObjInfo->Attr.u.Unix.cHardlinks = RT_MAX(1, pAllInfo->StandardInformation.NumberOfLinks);
322 pObjInfo->Attr.u.Unix.INodeIdDevice = 0; /* below */
323 pObjInfo->Attr.u.Unix.INodeId = pAllInfo->InternalInformation.IndexNumber.QuadPart;
324 pObjInfo->Attr.u.Unix.fFlags = 0;
325 pObjInfo->Attr.u.Unix.GenerationId = 0;
326 pObjInfo->Attr.u.Unix.Device = 0;
327
328 /* Get the serial number. */
329 rcNt = NtQueryVolumeInformationFile(hFile, &Ios, pvBuf, (ULONG)RT_MIN(cbBuf, _2K), FileFsVolumeInformation);
330 if (NT_SUCCESS(rcNt) || rcNt == STATUS_BUFFER_OVERFLOW)
331 {
332 FILE_FS_VOLUME_INFORMATION *pVolInfo = (FILE_FS_VOLUME_INFORMATION *)pvBuf;
333 pObjInfo->Attr.u.Unix.INodeIdDevice = pVolInfo->VolumeSerialNumber;
334 }
335 }
336
337 return rtPathNtQueryInfoFillInDummyData(VINF_SUCCESS, pObjInfo, enmAddAttr);
338 }
339 return RTErrConvertFromNtStatus(rcNt);
340}
341
342
343/**
344 * Worker for RTPathQueryInfoEx and RTDirRelPathQueryInfo.
345 *
346 * @returns IPRT status code.
347 * @param hRootDir The root directory that pNtName is relative to.
348 * @param pNtName The NT path which we want to query info for.
349 * @param pObjInfo Where to return the info.
350 * @param enmAddAttr What additional info to get/fake.
351 * @param fFlags Query flags (RTPATH_F_XXX).
352 * @param pszPath The path for detecting executables and such.
353 * Pass empty string if not applicable/available.
354 */
355DECLHIDDEN(int) rtPathNtQueryInfoWorker(HANDLE hRootDir, UNICODE_STRING *pNtName, PRTFSOBJINFO pObjInfo,
356 RTFSOBJATTRADD enmAddAttr, uint32_t fFlags, const char *pszPath)
357{
358 /*
359 * There are a three different ways of doing this:
360 * 1. Use NtQueryFullAttributesFile to the get basic file info.
361 * 2. Open whatever the path points to and use NtQueryInformationFile.
362 * 3. Open the parent directory and use NtQueryDirectoryFile like RTDirReadEx.
363 *
364 * The first two options may fail with sharing violations or access denied,
365 * in which case we must use the last one as fallback.
366 */
367 HANDLE hFile = RTNT_INVALID_HANDLE_VALUE;
368 IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
369 NTSTATUS rcNt;
370 OBJECT_ATTRIBUTES ObjAttr;
371 union
372 {
373 FILE_NETWORK_OPEN_INFORMATION NetOpenInfo;
374 FILE_ALL_INFORMATION AllInfo;
375 FILE_FS_VOLUME_INFORMATION VolInfo;
376 FILE_BOTH_DIR_INFORMATION Both;
377 FILE_ID_BOTH_DIR_INFORMATION BothId;
378 uint8_t abPadding[sizeof(FILE_ID_BOTH_DIR_INFORMATION) + RTPATH_MAX * sizeof(wchar_t)];
379 } uBuf;
380
381 /*
382 * We can only use the first option if no additional UNIX attribs are
383 * requested and it isn't a symbolic link. NT directory object
384 */
385 int rc = VINF_TRY_AGAIN;
386 if ( enmAddAttr != RTFSOBJATTRADD_UNIX
387 && g_pfnNtQueryFullAttributesFile)
388 {
389 InitializeObjectAttributes(&ObjAttr, pNtName, OBJ_CASE_INSENSITIVE, hRootDir, NULL);
390 rcNt = g_pfnNtQueryFullAttributesFile(&ObjAttr, &uBuf.NetOpenInfo);
391 if (NT_SUCCESS(rcNt))
392 {
393 if (!(uBuf.NetOpenInfo.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
394 {
395 pObjInfo->cbObject = uBuf.NetOpenInfo.EndOfFile.QuadPart;
396 pObjInfo->cbAllocated = uBuf.NetOpenInfo.AllocationSize.QuadPart;
397 RTTimeSpecSetNtTime(&pObjInfo->BirthTime, uBuf.NetOpenInfo.CreationTime.QuadPart);
398 RTTimeSpecSetNtTime(&pObjInfo->AccessTime, uBuf.NetOpenInfo.LastAccessTime.QuadPart);
399 RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, uBuf.NetOpenInfo.LastWriteTime.QuadPart);
400 RTTimeSpecSetNtTime(&pObjInfo->ChangeTime, uBuf.NetOpenInfo.ChangeTime.QuadPart);
401 pObjInfo->Attr.fMode = rtFsModeFromDos((uBuf.NetOpenInfo.FileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT,
402 pszPath, strlen(pszPath), 0 /*uReparseTag*/);
403 pObjInfo->Attr.enmAdditional = enmAddAttr;
404
405 return rtPathNtQueryInfoFillInDummyData(VINF_SUCCESS, pObjInfo, enmAddAttr);
406 }
407 }
408 else if ( rcNt == STATUS_OBJECT_TYPE_MISMATCH
409 || rcNt == STATUS_OBJECT_NAME_INVALID
410 || rcNt == STATUS_INVALID_PARAMETER)
411 {
412 rc = rtPathNtQueryInfoInDirectoryObject(&ObjAttr, pObjInfo, enmAddAttr, fFlags, &uBuf, sizeof(uBuf));
413 if (RT_SUCCESS(rc))
414 return rc;
415 rc = RTErrConvertFromNtStatus(rcNt);
416 }
417 else if ( rcNt != STATUS_ACCESS_DENIED
418 && rcNt != STATUS_SHARING_VIOLATION)
419 rc = RTErrConvertFromNtStatus(rcNt);
420 else
421 RTNT_IO_STATUS_BLOCK_REINIT(&Ios);
422 }
423
424 /*
425 * Try the 2nd option. We might have to redo this if not following symbolic
426 * links and the reparse point isn't a symbolic link but a mount point or similar.
427 * We want to return information about the mounted root directory if we can, not
428 * the directory in which it was mounted.
429 */
430 if (rc == VINF_TRY_AGAIN)
431 {
432 InitializeObjectAttributes(&ObjAttr, pNtName, OBJ_CASE_INSENSITIVE, hRootDir, NULL);
433 rcNt = NtCreateFile(&hFile,
434 FILE_READ_ATTRIBUTES | SYNCHRONIZE,
435 &ObjAttr,
436 &Ios,
437 NULL /*pcbFile*/,
438 FILE_ATTRIBUTE_NORMAL,
439 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
440 FILE_OPEN,
441 FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT
442 | (fFlags & RTPATH_F_FOLLOW_LINK ? 0 : FILE_OPEN_REPARSE_POINT),
443 NULL /*pvEaBuffer*/,
444 0 /*cbEa*/);
445 if (NT_SUCCESS(rcNt))
446 {
447 /* Query tag information first in order to try re-open non-symlink reparse points. */
448 FILE_ATTRIBUTE_TAG_INFORMATION TagInfo;
449 rcNt = NtQueryInformationFile(hFile, &Ios, &TagInfo, sizeof(TagInfo), FileAttributeTagInformation);
450 if (!NT_SUCCESS(rcNt))
451 TagInfo.FileAttributes = TagInfo.ReparseTag = 0;
452 if ( !(TagInfo.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
453 || TagInfo.ReparseTag == IO_REPARSE_TAG_SYMLINK
454 || (fFlags & RTPATH_F_FOLLOW_LINK))
455 { /* likely */ }
456 else
457 {
458 /* Reparse point that isn't a symbolic link, try follow the reparsing. */
459 HANDLE hFile2;
460 RTNT_IO_STATUS_BLOCK_REINIT(&Ios);
461 rcNt = NtCreateFile(&hFile2,
462 FILE_READ_ATTRIBUTES | SYNCHRONIZE,
463 &ObjAttr,
464 &Ios,
465 NULL /*pcbFile*/,
466 FILE_ATTRIBUTE_NORMAL,
467 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
468 FILE_OPEN,
469 FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
470 NULL /*pvEaBuffer*/,
471 0 /*cbEa*/);
472 if (NT_SUCCESS(rcNt))
473 {
474 NtClose(hFile);
475 hFile = hFile2;
476 TagInfo.FileAttributes = TagInfo.ReparseTag = 0;
477 }
478 }
479
480 /*
481 * Get the information we need and convert it.
482 */
483 rc = rtPathNtQueryInfoFromHandle(hFile, &uBuf, sizeof(uBuf), pObjInfo, enmAddAttr, pszPath, TagInfo.ReparseTag);
484 NtClose(hFile);
485 if (RT_SUCCESS(rc))
486 return rc;
487
488 if (RT_FAILURE(rc))
489 rc = VERR_TRY_AGAIN;
490 }
491 else if ( rcNt != STATUS_ACCESS_DENIED
492 && rcNt != STATUS_SHARING_VIOLATION)
493 rc = RTErrConvertFromNtStatus(rcNt);
494 else
495 RTNT_IO_STATUS_BLOCK_REINIT(&Ios);
496 }
497
498 /*
499 * Try the 3rd option if none of the other worked.
500 * If none of the above worked, try open the directory and enumerate
501 * the file we're after. This
502 */
503 if (rc == VINF_TRY_AGAIN)
504 {
505 /* Split up the name into parent directory path and filename. */
506 UNICODE_STRING NtDirName;
507 UNICODE_STRING NtFilter;
508 ntPathNtSplitName(pNtName, &NtDirName, &NtFilter, false /*fNoParentDirSlash*/);
509
510 /* Try open the directory. */
511 InitializeObjectAttributes(&ObjAttr, &NtDirName, OBJ_CASE_INSENSITIVE, hRootDir, NULL);
512 rcNt = NtCreateFile(&hFile,
513 FILE_LIST_DIRECTORY | SYNCHRONIZE,
514 &ObjAttr,
515 &Ios,
516 NULL /*pcbFile*/,
517 FILE_ATTRIBUTE_NORMAL,
518 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
519 FILE_OPEN,
520 FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
521 NULL /*pvEaBuffer*/,
522 0 /*cbEa*/);
523 if (NT_SUCCESS(rcNt))
524 {
525 FILE_INFORMATION_CLASS enmInfoClass;
526 if (RT_MAKE_U64(RTNtCurrentPeb()->OSMinorVersion, RTNtCurrentPeb()->OSMajorVersion) > RT_MAKE_U64(0,5) /* > W2K */)
527 enmInfoClass = FileIdBothDirectoryInformation; /* Introduced in XP, from I can tell. */
528 else
529 enmInfoClass = FileBothDirectoryInformation;
530 rcNt = NtQueryDirectoryFile(hFile,
531 NULL /* Event */,
532 NULL /* ApcRoutine */,
533 NULL /* ApcContext */,
534 &Ios,
535 &uBuf,
536 RT_MIN(sizeof(uBuf), 0xfff0),
537 enmInfoClass,
538 TRUE /*ReturnSingleEntry */,
539 &NtFilter,
540 FALSE /*RestartScan */);
541 if (NT_SUCCESS(rcNt))
542 {
543 pObjInfo->cbObject = uBuf.Both.EndOfFile.QuadPart;
544 pObjInfo->cbAllocated = uBuf.Both.AllocationSize.QuadPart;
545
546 RTTimeSpecSetNtTime(&pObjInfo->BirthTime, uBuf.Both.CreationTime.QuadPart);
547 RTTimeSpecSetNtTime(&pObjInfo->AccessTime, uBuf.Both.LastAccessTime.QuadPart);
548 RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, uBuf.Both.LastWriteTime.QuadPart);
549 RTTimeSpecSetNtTime(&pObjInfo->ChangeTime, uBuf.Both.ChangeTime.QuadPart);
550
551 pObjInfo->Attr.fMode = rtFsModeFromDos((uBuf.Both.FileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT,
552 pszPath, strlen(pszPath), uBuf.Both.EaSize);
553
554 pObjInfo->Attr.enmAdditional = enmAddAttr;
555 if (enmAddAttr == RTFSOBJATTRADD_UNIX)
556 {
557 pObjInfo->Attr.u.Unix.uid = ~0U;
558 pObjInfo->Attr.u.Unix.gid = ~0U;
559 pObjInfo->Attr.u.Unix.cHardlinks = 1;
560 pObjInfo->Attr.u.Unix.INodeIdDevice = 0; /* below */
561 pObjInfo->Attr.u.Unix.INodeId = enmInfoClass == FileIdBothDirectoryInformation
562 ? uBuf.BothId.FileId.QuadPart : 0;
563 pObjInfo->Attr.u.Unix.fFlags = 0;
564 pObjInfo->Attr.u.Unix.GenerationId = 0;
565 pObjInfo->Attr.u.Unix.Device = 0;
566
567 /* Get the serial number. */
568 rcNt = NtQueryVolumeInformationFile(hFile, &Ios, &uBuf, RT_MIN(sizeof(uBuf), _2K),
569 FileFsVolumeInformation);
570 if (NT_SUCCESS(rcNt))
571 pObjInfo->Attr.u.Unix.INodeIdDevice = uBuf.VolInfo.VolumeSerialNumber;
572 }
573
574 rc = rtPathNtQueryInfoFillInDummyData(VINF_SUCCESS, pObjInfo, enmAddAttr);
575 }
576 else
577 rc = RTErrConvertFromNtStatus(rcNt);
578
579 NtClose(hFile);
580 }
581 else
582 rc = RTErrConvertFromNtStatus(rcNt);
583 }
584
585 return rc;
586}
587
588
589RTR3DECL(int) RTPathQueryInfoEx(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags)
590{
591 /*
592 * Validate input.
593 */
594 AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
595 AssertReturn(*pszPath, VERR_INVALID_PARAMETER);
596 AssertPtrReturn(pObjInfo, VERR_INVALID_POINTER);
597 AssertMsgReturn( enmAdditionalAttribs >= RTFSOBJATTRADD_NOTHING
598 && enmAdditionalAttribs <= RTFSOBJATTRADD_LAST,
599 ("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs),
600 VERR_INVALID_PARAMETER);
601 AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
602
603
604 /*
605 * Convert the input path and call common worker.
606 */
607 HANDLE hRootDir;
608 UNICODE_STRING NtName;
609 int rc = RTNtPathFromWinUtf8(&NtName, &hRootDir, pszPath);
610 if (RT_SUCCESS(rc))
611 {
612 rc = rtPathNtQueryInfoWorker(hRootDir, &NtName, pObjInfo, enmAdditionalAttribs, fFlags, pszPath);
613 RTNtPathFree(&NtName, &hRootDir);
614 }
615 return rc;
616}
617
618
619RTR3DECL(int) RTPathQueryInfo(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
620{
621 return RTPathQueryInfoEx(pszPath, pObjInfo, enmAdditionalAttribs, RTPATH_F_ON_LINK);
622}
623
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette