VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/win/fs-win.cpp@ 34079

Last change on this file since 34079 was 32431, checked in by vboxsync, 14 years ago

scm cleanup
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 12.7 KB
Line 
1/* $Id: fs-win.cpp 32431 2010-09-11 18:02:17Z vboxsync $ */
2/** @file
3 * IPRT - File System, Win32.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.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_FS
32#include <windows.h>
33
34#include <iprt/fs.h>
35#include <iprt/path.h>
36#include <iprt/string.h>
37#include <iprt/param.h>
38#include <iprt/err.h>
39#include <iprt/log.h>
40#include <iprt/assert.h>
41#include "internal/fs.h"
42
43/* from ntdef.h */
44typedef LONG NTSTATUS;
45
46/* from ntddk.h */
47typedef struct _IO_STATUS_BLOCK {
48 union {
49 NTSTATUS Status;
50 PVOID Pointer;
51 };
52 ULONG_PTR Information;
53} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
54
55typedef enum _FSINFOCLASS {
56 FileFsAttributeInformation = 5,
57} FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
58
59/* from ntifs.h */
60
61typedef struct _FILE_FS_ATTRIBUTE_INFORMATION {
62 ULONG FileSystemAttributes;
63 LONG MaximumComponentNameLength;
64 ULONG FIleSystemNameLength;
65 WCHAR FileSystemName[1];
66} FILE_FS_ATTRIBUTE_INFORMATION, *PFILE_FS_ATTRIBUTE_INFORMATION;
67
68extern "C" NTSTATUS NTAPI NtQueryVolumeInformationFile(HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FS_INFORMATION_CLASS);
69
70/**
71 * Checks quickly if this is an correct root specification.
72 * Root specs ends with a slash of some kind.
73 *
74 * @returns indicator.
75 * @param pszFsPath Path to check.
76 */
77static bool rtFsIsRoot(const char *pszFsPath)
78{
79 /*
80 * UNC has exactly two slashes..
81 *
82 * Anything else starting with slashe(s) requires
83 * expansion and will have to take the long road.
84 */
85 if (RTPATH_IS_SLASH(pszFsPath[0]))
86 {
87 if ( !RTPATH_IS_SLASH(pszFsPath[1])
88 || RTPATH_IS_SLASH(pszFsPath[2]))
89 return false;
90
91 /* end of machine name */
92 const char *pszSlash = strpbrk(pszFsPath + 2, "\\/");
93 if (!pszSlash)
94 return false;
95
96 /* end of service name. */
97 pszSlash = strpbrk(pszSlash + 1, "\\/");
98 if (!pszSlash)
99 return false;
100
101 return pszSlash[1] == '\0';
102 }
103
104 /*
105 * Ok the other alternative is driver letter.
106 */
107 return pszFsPath[0] >= 'A' && pszFsPath[0] <= 'Z'
108 && pszFsPath[1] == ':'
109 && RTPATH_IS_SLASH(pszFsPath[2])
110 && !pszFsPath[3];
111}
112
113
114
115/**
116 * Finds the root of the specified volume.
117 *
118 * @returns iprt status code.
119 * @param pszFsPath Path within the filesystem. Verified as one byte or more.
120 * @param ppwszFsRoot Where to store the returned string. Free with rtFsFreeRoot(),
121 */
122static int rtFsGetRoot(const char *pszFsPath, PRTUTF16 *ppwszFsRoot)
123{
124 /*
125 * Do straight forward stuff first,
126 */
127 if (rtFsIsRoot(pszFsPath))
128 return RTStrToUtf16(pszFsPath, ppwszFsRoot);
129
130 /*
131 * Expand and add slash (if required).
132 */
133 char szFullPath[RTPATH_MAX];
134 int rc = RTPathAbs(pszFsPath, szFullPath, sizeof(szFullPath));
135 if (RT_FAILURE(rc))
136 return rc;
137 size_t cb = strlen(szFullPath);
138 if (!RTPATH_IS_SLASH(szFullPath[cb - 1]))
139 {
140 AssertReturn(cb + 1 < RTPATH_MAX, VERR_FILENAME_TOO_LONG);
141 szFullPath[cb] = '\\';
142 szFullPath[++cb] = '\0';
143 }
144
145 /*
146 * Convert the path.
147 */
148 rc = RTStrToUtf16(szFullPath, ppwszFsRoot);
149 if (RT_FAILURE(rc))
150 return rc == VERR_BUFFER_OVERFLOW ? VERR_FILENAME_TOO_LONG : rc;
151
152 /*
153 * Walk the path until our proper API is happy or there is no more path left.
154 */
155 PRTUTF16 pwszStart = *ppwszFsRoot;
156 if (!GetVolumeInformationW(pwszStart, NULL, 0, NULL, NULL, 0, NULL, 0))
157 {
158 PRTUTF16 pwszEnd = pwszStart + RTUtf16Len(pwszStart);
159 PRTUTF16 pwszMin = pwszStart + 2;
160 do
161 {
162 /* Strip off the last path component. */
163 while (pwszEnd-- > pwszMin)
164 if (RTPATH_IS_SLASH(*pwszEnd))
165 break;
166 AssertReturn(pwszEnd >= pwszMin, VERR_INTERNAL_ERROR); /* leaks, but that's irrelevant for an internal error. */
167 pwszEnd[1] = '\0';
168 } while (!GetVolumeInformationW(pwszStart, NULL, 0, NULL, NULL, 0, NULL, 0));
169 }
170
171 return VINF_SUCCESS;
172}
173
174/**
175 * Frees string returned by rtFsGetRoot().
176 */
177static void rtFsFreeRoot(PRTUTF16 pwszFsRoot)
178{
179 RTUtf16Free(pwszFsRoot);
180}
181
182
183RTR3DECL(int) RTFsQuerySizes(const char *pszFsPath, RTFOFF *pcbTotal, RTFOFF *pcbFree,
184 uint32_t *pcbBlock, uint32_t *pcbSector)
185{
186 /*
187 * Validate & get valid root path.
188 */
189 AssertMsgReturn(VALID_PTR(pszFsPath) && *pszFsPath, ("%p", pszFsPath), VERR_INVALID_PARAMETER);
190 PRTUTF16 pwszFsRoot;
191 int rc = rtFsGetRoot(pszFsPath, &pwszFsRoot);
192 if (RT_FAILURE(rc))
193 return rc;
194
195 /*
196 * Free and total.
197 */
198 if (pcbTotal || pcbFree)
199 {
200 ULARGE_INTEGER cbTotal;
201 ULARGE_INTEGER cbFree;
202 if (GetDiskFreeSpaceExW(pwszFsRoot, &cbFree, &cbTotal, NULL))
203 {
204 if (pcbTotal)
205 *pcbTotal = cbTotal.QuadPart;
206 if (pcbFree)
207 *pcbFree = cbFree.QuadPart;
208 }
209 else
210 {
211 DWORD Err = GetLastError();
212 rc = RTErrConvertFromWin32(Err);
213 Log(("RTFsQuerySizes(%s,): GetDiskFreeSpaceEx failed with lasterr %d (%Rrc)\n",
214 pszFsPath, Err, rc));
215 }
216 }
217
218 /*
219 * Block and sector size.
220 */
221 if ( RT_SUCCESS(rc)
222 && (pcbBlock || pcbSector))
223 {
224 DWORD dwDummy1, dwDummy2;
225 DWORD cbSector;
226 DWORD cSectorsPerCluster;
227 if (GetDiskFreeSpaceW(pwszFsRoot, &cSectorsPerCluster, &cbSector, &dwDummy1, &dwDummy2))
228 {
229 if (pcbBlock)
230 *pcbBlock = cbSector * cSectorsPerCluster;
231 if (pcbSector)
232 *pcbSector = cbSector;
233 }
234 else
235 {
236 DWORD Err = GetLastError();
237 rc = RTErrConvertFromWin32(Err);
238 Log(("RTFsQuerySizes(%s,): GetDiskFreeSpace failed with lasterr %d (%Rrc)\n",
239 pszFsPath, Err, rc));
240 }
241 }
242
243 rtFsFreeRoot(pwszFsRoot);
244 return rc;
245}
246
247
248/**
249 * Query the serial number of a filesystem.
250 *
251 * @returns iprt status code.
252 * @param pszFsPath Path within the mounted filesystem.
253 * @param pu32Serial Where to store the serial number.
254 */
255RTR3DECL(int) RTFsQuerySerial(const char *pszFsPath, uint32_t *pu32Serial)
256{
257 /*
258 * Validate & get valid root path.
259 */
260 AssertMsgReturn(VALID_PTR(pszFsPath) && *pszFsPath, ("%p", pszFsPath), VERR_INVALID_PARAMETER);
261 AssertMsgReturn(VALID_PTR(pu32Serial), ("%p", pu32Serial), VERR_INVALID_PARAMETER);
262 PRTUTF16 pwszFsRoot;
263 int rc = rtFsGetRoot(pszFsPath, &pwszFsRoot);
264 if (RT_FAILURE(rc))
265 return rc;
266
267 /*
268 * Do work.
269 */
270 DWORD dwMaxName;
271 DWORD dwFlags;
272 DWORD dwSerial;
273 if (GetVolumeInformationW(pwszFsRoot, NULL, 0, &dwSerial, &dwMaxName, &dwFlags, NULL, 0))
274 *pu32Serial = dwSerial;
275 else
276 {
277 DWORD Err = GetLastError();
278 rc = RTErrConvertFromWin32(Err);
279 Log(("RTFsQuerySizes(%s,): GetDiskFreeSpaceEx failed with lasterr %d (%Rrc)\n",
280 pszFsPath, Err, rc));
281 }
282
283 RTUtf16Free(pwszFsRoot);
284 return rc;
285}
286
287
288/**
289 * Query the properties of a mounted filesystem.
290 *
291 * @returns iprt status code.
292 * @param pszFsPath Path within the mounted filesystem.
293 * @param pProperties Where to store the properties.
294 */
295RTR3DECL(int) RTFsQueryProperties(const char *pszFsPath, PRTFSPROPERTIES pProperties)
296{
297 /*
298 * Validate & get valid root path.
299 */
300 AssertMsgReturn(VALID_PTR(pszFsPath) && *pszFsPath, ("%p", pszFsPath), VERR_INVALID_PARAMETER);
301 AssertMsgReturn(VALID_PTR(pProperties), ("%p", pProperties), VERR_INVALID_PARAMETER);
302 PRTUTF16 pwszFsRoot;
303 int rc = rtFsGetRoot(pszFsPath, &pwszFsRoot);
304 if (RT_FAILURE(rc))
305 return rc;
306
307 /*
308 * Do work.
309 */
310 DWORD dwMaxName;
311 DWORD dwFlags;
312 DWORD dwSerial;
313 if (GetVolumeInformationW(pwszFsRoot, NULL, 0, &dwSerial, &dwMaxName, &dwFlags, NULL, 0))
314 {
315 memset(pProperties, 0, sizeof(*pProperties));
316 pProperties->cbMaxComponent = dwMaxName;
317 pProperties->fFileCompression = !!(dwFlags & FILE_FILE_COMPRESSION);
318 pProperties->fCompressed = !!(dwFlags & FILE_VOLUME_IS_COMPRESSED);
319 pProperties->fReadOnly = !!(dwFlags & FILE_READ_ONLY_VOLUME);
320 pProperties->fSupportsUnicode = !!(dwFlags & FILE_UNICODE_ON_DISK);
321 pProperties->fCaseSensitive = false; /* win32 is case preserving only */
322 pProperties->fRemote = false; /* no idea yet */
323 }
324 else
325 {
326 DWORD Err = GetLastError();
327 rc = RTErrConvertFromWin32(Err);
328 Log(("RTFsQuerySizes(%s,): GetVolumeInformation failed with lasterr %d (%Rrc)\n",
329 pszFsPath, Err, rc));
330 }
331
332 RTUtf16Free(pwszFsRoot);
333 return rc;
334}
335
336
337/**
338 * Internal helper for comparing a WCHAR string with a char string.
339 *
340 * @returns @c true if equal, @c false if not.
341 * @param pwsz1 The first string.
342 * @param cb1 The length of the first string, in bytes.
343 * @param psz2 The second string.
344 * @param cch2 The length of the second string.
345 */
346static bool rtFsWinAreEqual(WCHAR const *pwsz1, size_t cch1, const char *psz2, size_t cch2)
347{
348 if (cch1 != cch2 * 2)
349 return false;
350 while (cch2-- > 0)
351 {
352 unsigned ch1 = *pwsz1++;
353 unsigned ch2 = (unsigned char)*psz2++;
354 if (ch1 != ch2)
355 return false;
356 }
357 return true;
358}
359
360
361RTR3DECL(int) RTFsQueryType(const char *pszFsPath, PRTFSTYPE penmType)
362{
363 *penmType = RTFSTYPE_UNKNOWN;
364
365 AssertPtrReturn(pszFsPath, VERR_INVALID_POINTER);
366 AssertReturn(*pszFsPath, VERR_INVALID_PARAMETER);
367
368 /*
369 * Convert the path and try open it.
370 */
371 PRTUTF16 pwszFsPath;
372 int rc = RTStrToUtf16(pszFsPath, &pwszFsPath);
373 if (RT_SUCCESS(rc))
374 {
375 HANDLE hFile = CreateFileW(pwszFsPath,
376 GENERIC_READ,
377 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
378 NULL,
379 OPEN_EXISTING,
380 FILE_FLAG_BACKUP_SEMANTICS,
381 NULL);
382 if (hFile != INVALID_HANDLE_VALUE)
383 {
384 /*
385 * Use the NT api directly to get the file system name.
386 */
387 char abBuf[8192];
388 IO_STATUS_BLOCK Ios;
389 NTSTATUS rcNt = NtQueryVolumeInformationFile(hFile, &Ios,
390 abBuf, sizeof(abBuf),
391 FileFsAttributeInformation);
392 if (rcNt >= 0)
393 {
394 PFILE_FS_ATTRIBUTE_INFORMATION pFsAttrInfo = (PFILE_FS_ATTRIBUTE_INFORMATION)abBuf;
395 if (pFsAttrInfo->FIleSystemNameLength)
396 {
397 }
398#define IS_FS(szName) \
399 rtFsWinAreEqual(pFsAttrInfo->FileSystemName, pFsAttrInfo->FIleSystemNameLength, szName, sizeof(szName) - 1)
400 if (IS_FS("NTFS"))
401 *penmType = RTFSTYPE_NTFS;
402 else if (IS_FS("FAT"))
403 *penmType = RTFSTYPE_FAT;
404 else if (IS_FS("FAT32"))
405 *penmType = RTFSTYPE_FAT;
406 else if (IS_FS("VBoxSharedFolderFS"))
407 *penmType = RTFSTYPE_VBOXSHF;
408#undef IS_FS
409 }
410 else
411 rc = RTErrConvertFromNtStatus(rcNt);
412 CloseHandle(hFile);
413 }
414 else
415 rc = RTErrConvertFromWin32(GetLastError());
416 RTUtf16Free(pwszFsPath);
417 }
418 return rc;
419}
Note: See TracBrowser for help on using the repository browser.

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