fileio-win.cpp@ 39025

最後變更在這個檔案從39025是 39025,由 vboxsync 提交於 13 年前
fileio-win.cpp: hacking in progress...
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Id`
檔案大小: 33.7 KB

行
1	/* $Id: fileio-win.cpp 39025 2011-10-19 09:19:42Z vboxsync $ */
2	/** @file
3	* IPRT - File I/O, native implementation for the Windows host platform.
4	*/
5
6	/*
7	* Copyright (C) 2006-2011 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_DIR
32	#include <Windows.h>
33
34	#include <iprt/file.h>
35	#include <iprt/path.h>
36	#include <iprt/assert.h>
37	#include <iprt/string.h>
38	#include <iprt/err.h>
39	#include <iprt/log.h>
40	#include "internal/file.h"
41	#include "internal/fs.h"
42	#include "internal/path.h"
43
44
45	/*******************************************************************************
46	* Defined Constants And Macros *
47	*******************************************************************************/
48
49
50	/**
51	* This is wrapper around the ugly SetFilePointer api.
52	*
53	* It's equivalent to SetFilePointerEx which we so unfortunately cannot use because of
54	* it not being present in NT4 GA.
55	*
56	* @returns Success indicator. Extended error information obtainable using GetLastError().
57	* @param hFile Filehandle.
58	* @param offSeek Offset to seek.
59	* @param poffNew Where to store the new file offset. NULL allowed.
60	* @param uMethod Seek method. (The windows one!)
61	*/
62	DECLINLINE(bool) MySetFilePointer(RTFILE hFile, uint64_t offSeek, uint64_t *poffNew, unsigned uMethod)
63	{
64	bool fRc;
65	LARGE_INTEGER off;
66
67	off.QuadPart = offSeek;
68	#if 1
69	if (off.LowPart != INVALID_SET_FILE_POINTER)
70	{
71	off.LowPart = SetFilePointer((HANDLE)RTFileToNative(hFile), off.LowPart, &off.HighPart, uMethod);
72	fRc = off.LowPart != INVALID_SET_FILE_POINTER;
73	}
74	else
75	{
76	SetLastError(NO_ERROR);
77	off.LowPart = SetFilePointer((HANDLE)RTFileToNative(hFile), off.LowPart, &off.HighPart, uMethod);
78	fRc = GetLastError() == NO_ERROR;
79	}
80	#else
81	fRc = SetFilePointerEx((HANDLE)RTFileToNative(hFile), off, &off, uMethod);
82	#endif
83	if (fRc && poffNew)
84	*poffNew = off.QuadPart;
85	return fRc;
86	}
87
88
89	/**
90	* This is a helper to check if an attempt was made to grow a file beyond the
91	* limit of the filesystem.
92	*
93	* @returns true for file size limit exceeded.
94	* @param hFile Filehandle.
95	* @param offSeek Offset to seek.
96	* @param uMethod The seek method.
97	*/
98	DECLINLINE(bool) IsBeyondLimit(RTFILE hFile, uint64_t offSeek, unsigned uMethod)
99	{
100	bool fIsBeyondLimit = false;
101
102	/*
103	* Get the current file position and try set the new one.
104	* If it fails with a seek error it's because we hit the file system limit.
105	*/
106	/** @todo r=bird: I'd be very interested to know on which versions of windows and on which file systems
107	* this supposedly works. The fastfat sources in the latest WDK makes no limit checks during
108	* file seeking, only at the time of writing (and some other odd ones we cannot make use of). */
109	uint64_t offCurrent;
110	if (MySetFilePointer(hFile, 0, &offCurrent, FILE_CURRENT))
111	{
112	if (!MySetFilePointer(hFile, offSeek, NULL, uMethod))
113	fIsBeyondLimit = GetLastError() == ERROR_SEEK;
114	else /* Restore file pointer on success. */
115	MySetFilePointer(hFile, offCurrent, NULL, FILE_BEGIN);
116	}
117
118	return fIsBeyondLimit;
119	}
120
121
122	RTR3DECL(int) RTFileFromNative(PRTFILE pFile, RTHCINTPTR uNative)
123	{
124	HANDLE h = (HANDLE)uNative;
125	AssertCompile(sizeof(h) == sizeof(uNative));
126	if (h == INVALID_HANDLE_VALUE)
127	{
128	AssertMsgFailed(("%p\n", uNative));
129	*pFile = NIL_RTFILE;
130	return VERR_INVALID_HANDLE;
131	}
132	*pFile = (RTFILE)h;
133	return VINF_SUCCESS;
134	}
135
136
137	RTR3DECL(RTHCINTPTR) RTFileToNative(RTFILE hFile)
138	{
139	AssertReturn(hFile != NIL_RTFILE, (RTHCINTPTR)INVALID_HANDLE_VALUE);
140	return (RTHCINTPTR)hFile;
141	}
142
143
144	RTR3DECL(int) RTFileOpen(PRTFILE pFile, const char *pszFilename, uint64_t fOpen)
145	{
146	/*
147	* Validate input.
148	*/
149	if (!pFile)
150	{
151	AssertMsgFailed(("Invalid pFile\n"));
152	return VERR_INVALID_PARAMETER;
153	}
154	*pFile = NIL_RTFILE;
155	if (!pszFilename)
156	{
157	AssertMsgFailed(("Invalid pszFilename\n"));
158	return VERR_INVALID_PARAMETER;
159	}
160
161	/*
162	* Merge forced open flags and validate them.
163	*/
164	int rc = rtFileRecalcAndValidateFlags(&fOpen);
165	if (RT_FAILURE(rc))
166	return rc;
167
168	/*
169	* Determine disposition, access, share mode, creation flags, and security attributes
170	* for the CreateFile API call.
171	*/
172	DWORD dwCreationDisposition;
173	switch (fOpen & RTFILE_O_ACTION_MASK)
174	{
175	case RTFILE_O_OPEN:
176	dwCreationDisposition = fOpen & RTFILE_O_TRUNCATE ? TRUNCATE_EXISTING : OPEN_EXISTING;
177	break;
178	case RTFILE_O_OPEN_CREATE:
179	dwCreationDisposition = OPEN_ALWAYS;
180	break;
181	case RTFILE_O_CREATE:
182	dwCreationDisposition = CREATE_NEW;
183	break;
184	case RTFILE_O_CREATE_REPLACE:
185	dwCreationDisposition = CREATE_ALWAYS;
186	break;
187	default:
188	AssertMsgFailed(("Impossible fOpen=%#llx\n", fOpen));
189	return VERR_INVALID_PARAMETER;
190	}
191
192	DWORD dwDesiredAccess;
193	switch (fOpen & RTFILE_O_ACCESS_MASK)
194	{
195	case RTFILE_O_READ:
196	dwDesiredAccess = FILE_GENERIC_READ; /* RTFILE_O_APPEND is ignored. */
197	break;
198	case RTFILE_O_WRITE:
199	dwDesiredAccess = fOpen & RTFILE_O_APPEND
200	? FILE_GENERIC_WRITE & ~FILE_WRITE_DATA
201	: FILE_GENERIC_WRITE;
202	break;
203	case RTFILE_O_READWRITE:
204	dwDesiredAccess = fOpen & RTFILE_O_APPEND
205	? FILE_GENERIC_READ \| (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA)
206	: FILE_GENERIC_READ \| FILE_GENERIC_WRITE;
207	break;
208	default:
209	AssertMsgFailed(("Impossible fOpen=%#llx\n", fOpen));
210	return VERR_INVALID_PARAMETER;
211	}
212	if (dwCreationDisposition == TRUNCATE_EXISTING)
213	/* Required for truncating the file (see MSDN), it is NOT part of FILE_GENERIC_WRITE. */
214	dwDesiredAccess \|= GENERIC_WRITE;
215
216	/* RTFileSetMode needs following rights as well. */
217	switch (fOpen & RTFILE_O_ACCESS_ATTR_MASK)
218	{
219	case RTFILE_O_ACCESS_ATTR_READ: dwDesiredAccess \|= FILE_READ_ATTRIBUTES \| SYNCHRONIZE; break;
220	case RTFILE_O_ACCESS_ATTR_WRITE: dwDesiredAccess \|= FILE_WRITE_ATTRIBUTES \| SYNCHRONIZE; break;
221	case RTFILE_O_ACCESS_ATTR_READWRITE: dwDesiredAccess \|= FILE_READ_ATTRIBUTES \| FILE_WRITE_ATTRIBUTES \| SYNCHRONIZE; break;
222	default:
223	/* Attributes access is the same as the file access. */
224	switch (fOpen & RTFILE_O_ACCESS_MASK)
225	{
226	case RTFILE_O_READ: dwDesiredAccess \|= FILE_READ_ATTRIBUTES \| SYNCHRONIZE; break;
227	case RTFILE_O_WRITE: dwDesiredAccess \|= FILE_WRITE_ATTRIBUTES \| SYNCHRONIZE; break;
228	case RTFILE_O_READWRITE: dwDesiredAccess \|= FILE_READ_ATTRIBUTES \| FILE_WRITE_ATTRIBUTES \| SYNCHRONIZE; break;
229	default:
230	AssertMsgFailed(("Impossible fOpen=%#llx\n", fOpen));
231	return VERR_INVALID_PARAMETER;
232	}
233	}
234
235	DWORD dwShareMode;
236	switch (fOpen & RTFILE_O_DENY_MASK)
237	{
238	case RTFILE_O_DENY_NONE: dwShareMode = FILE_SHARE_READ \| FILE_SHARE_WRITE; break;
239	case RTFILE_O_DENY_READ: dwShareMode = FILE_SHARE_WRITE; break;
240	case RTFILE_O_DENY_WRITE: dwShareMode = FILE_SHARE_READ; break;
241	case RTFILE_O_DENY_READWRITE: dwShareMode = 0; break;
242
243	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_NONE: dwShareMode = FILE_SHARE_DELETE \| FILE_SHARE_READ \| FILE_SHARE_WRITE; break;
244	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_READ: dwShareMode = FILE_SHARE_DELETE \| FILE_SHARE_WRITE; break;
245	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_WRITE: dwShareMode = FILE_SHARE_DELETE \| FILE_SHARE_READ; break;
246	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_READWRITE:dwShareMode = FILE_SHARE_DELETE; break;
247	default:
248	AssertMsgFailed(("Impossible fOpen=%#llx\n", fOpen));
249	return VERR_INVALID_PARAMETER;
250	}
251
252	SECURITY_ATTRIBUTES SecurityAttributes;
253	PSECURITY_ATTRIBUTES pSecurityAttributes = NULL;
254	if (fOpen & RTFILE_O_INHERIT)
255	{
256	SecurityAttributes.nLength = sizeof(SecurityAttributes);
257	SecurityAttributes.lpSecurityDescriptor = NULL;
258	SecurityAttributes.bInheritHandle = TRUE;
259	pSecurityAttributes = &SecurityAttributes;
260	}
261
262	DWORD dwFlagsAndAttributes;
263	dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
264	if (fOpen & RTFILE_O_WRITE_THROUGH)
265	dwFlagsAndAttributes \|= FILE_FLAG_WRITE_THROUGH;
266	if (fOpen & RTFILE_O_ASYNC_IO)
267	dwFlagsAndAttributes \|= FILE_FLAG_OVERLAPPED;
268	if (fOpen & RTFILE_O_NO_CACHE)
269	{
270	dwFlagsAndAttributes \|= FILE_FLAG_NO_BUFFERING;
271	dwDesiredAccess &= ~FILE_APPEND_DATA;
272	}
273
274	/*
275	* Open/Create the file.
276	*/
277	PRTUTF16 pwszFilename;
278	rc = RTStrToUtf16(pszFilename, &pwszFilename);
279	if (RT_FAILURE(rc))
280	return rc;
281
282	HANDLE hFile = CreateFileW(pwszFilename,
283	dwDesiredAccess,
284	dwShareMode,
285	pSecurityAttributes,
286	dwCreationDisposition,
287	dwFlagsAndAttributes,
288	NULL);
289	if (hFile != INVALID_HANDLE_VALUE)
290	{
291	bool fCreated = dwCreationDisposition == CREATE_ALWAYS
292	\|\| dwCreationDisposition == CREATE_NEW
293	\|\| (dwCreationDisposition == OPEN_ALWAYS && GetLastError() == 0);
294
295	/*
296	* Turn off indexing of directory through Windows Indexing Service.
297	*/
298	if ( fCreated
299	&& (fOpen & RTFILE_O_NOT_CONTENT_INDEXED))
300	{
301	if (!SetFileAttributesW(pwszFilename, FILE_ATTRIBUTE_NOT_CONTENT_INDEXED))
302	rc = RTErrConvertFromWin32(GetLastError());
303	}
304	/*
305	* Do we need to truncate the file?
306	*/
307	else if ( !fCreated
308	&& (fOpen & (RTFILE_O_TRUNCATE \| RTFILE_O_ACTION_MASK))
309	== (RTFILE_O_TRUNCATE \| RTFILE_O_OPEN_CREATE))
310	{
311	if (!SetEndOfFile(hFile))
312	rc = RTErrConvertFromWin32(GetLastError());
313	}
314	if (RT_SUCCESS(rc))
315	{
316	*pFile = (RTFILE)hFile;
317	Assert((HANDLE)*pFile == hFile);
318	RTUtf16Free(pwszFilename);
319	return VINF_SUCCESS;
320	}
321
322	CloseHandle(hFile);
323	}
324	else
325	rc = RTErrConvertFromWin32(GetLastError());
326	RTUtf16Free(pwszFilename);
327	return rc;
328	}
329
330
331	RTR3DECL(int) RTFileOpenBitBucket(PRTFILE phFile, uint64_t fAccess)
332	{
333	AssertReturn( fAccess == RTFILE_O_READ
334	\|\| fAccess == RTFILE_O_WRITE
335	\|\| fAccess == RTFILE_O_READWRITE,
336	VERR_INVALID_PARAMETER);
337	return RTFileOpen(phFile, "NUL", fAccess \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN);
338	}
339
340
341	RTR3DECL(int) RTFileClose(RTFILE hFile)
342	{
343	if (hFile == NIL_RTFILE)
344	return VINF_SUCCESS;
345	if (CloseHandle((HANDLE)RTFileToNative(hFile)))
346	return VINF_SUCCESS;
347	return RTErrConvertFromWin32(GetLastError());
348	}
349
350
351	RTFILE rtFileGetStandard(RTHANDLESTD enmStdHandle)
352	{
353	DWORD dwStdHandle;
354	switch (enmStdHandle)
355	{
356	case RTHANDLESTD_INPUT: dwStdHandle = STD_INPUT_HANDLE; break;
357	case RTHANDLESTD_OUTPUT: dwStdHandle = STD_OUTPUT_HANDLE; break;
358	case RTHANDLESTD_ERROR: dwStdHandle = STD_ERROR_HANDLE; break;
359	break;
360	default:
361	AssertFailedReturn(NIL_RTFILE);
362	}
363
364	HANDLE hNative = GetStdHandle(dwStdHandle);
365	if (hNative == INVALID_HANDLE_VALUE)
366	return NIL_RTFILE;
367
368	RTFILE hFile = (RTFILE)(uintptr_t)hNative;
369	AssertReturn((HANDLE)(uintptr_t)hFile == hNative, NIL_RTFILE);
370	return hFile;
371	}
372
373
374	RTR3DECL(int) RTFileSeek(RTFILE hFile, int64_t offSeek, unsigned uMethod, uint64_t *poffActual)
375	{
376	static ULONG aulSeekRecode[] =
377	{
378	FILE_BEGIN,
379	FILE_CURRENT,
380	FILE_END,
381	};
382
383	/*
384	* Validate input.
385	*/
386	if (uMethod > RTFILE_SEEK_END)
387	{
388	AssertMsgFailed(("Invalid uMethod=%d\n", uMethod));
389	return VERR_INVALID_PARAMETER;
390	}
391
392	/*
393	* Execute the seek.
394	*/
395	if (MySetFilePointer(hFile, offSeek, poffActual, aulSeekRecode[uMethod]))
396	return VINF_SUCCESS;
397	return RTErrConvertFromWin32(GetLastError());
398	}
399
400
401	RTR3DECL(int) RTFileRead(RTFILE hFile, void pvBuf, size_t cbToRead, size_t pcbRead)
402	{
403	if (cbToRead <= 0)
404	return VINF_SUCCESS;
405	ULONG cbToReadAdj = (ULONG)cbToRead;
406	AssertReturn(cbToReadAdj == cbToRead, VERR_NUMBER_TOO_BIG);
407
408	ULONG cbRead = 0;
409	if (ReadFile((HANDLE)RTFileToNative(hFile), pvBuf, cbToReadAdj, &cbRead, NULL))
410	{
411	if (pcbRead)
412	/* Caller can handle partial reads. */
413	*pcbRead = cbRead;
414	else
415	{
416	/* Caller expects everything to be read. */
417	while (cbToReadAdj > cbRead)
418	{
419	ULONG cbReadPart = 0;
420	if (!ReadFile((HANDLE)RTFileToNative(hFile), (char*)pvBuf + cbRead, cbToReadAdj - cbRead, &cbReadPart, NULL))
421	return RTErrConvertFromWin32(GetLastError());
422	if (cbReadPart == 0)
423	return VERR_EOF;
424	cbRead += cbReadPart;
425	}
426	}
427	return VINF_SUCCESS;
428	}
429
430	/*
431	* If it's a console, we might bump into out of memory conditions in the
432	* ReadConsole call.
433	*/
434	DWORD dwErr = GetLastError();
435	if (dwErr == ERROR_NOT_ENOUGH_MEMORY)
436	{
437	ULONG cbChunk = cbToReadAdj / 2;
438	if (cbChunk > 16*_1K)
439	cbChunk = 16*_1K;
440	else
441	cbChunk = RT_ALIGN_32(cbChunk, 256);
442
443	cbRead = 0;
444	while (cbToReadAdj > cbRead)
445	{
446	ULONG cbToRead = RT_MIN(cbChunk, cbToReadAdj - cbRead);
447	ULONG cbReadPart = 0;
448	if (!ReadFile((HANDLE)RTFileToNative(hFile), (char *)pvBuf + cbRead, cbToRead, &cbReadPart, NULL))
449	{
450	/* If we failed because the buffer is too big, shrink it and
451	try again. */
452	dwErr = GetLastError();
453	if ( dwErr == ERROR_NOT_ENOUGH_MEMORY
454	&& cbChunk > 8)
455	{
456	cbChunk /= 2;
457	continue;
458	}
459	return RTErrConvertFromWin32(dwErr);
460	}
461	cbRead += cbReadPart;
462
463	/* Return if the caller can handle partial reads, otherwise try
464	fill the buffer all the way up. */
465	if (pcbRead)
466	{
467	*pcbRead = cbRead;
468	break;
469	}
470	if (cbReadPart == 0)
471	return VERR_EOF;
472	}
473	return VINF_SUCCESS;
474	}
475
476	return RTErrConvertFromWin32(dwErr);
477	}
478
479
480	RTR3DECL(int) RTFileWrite(RTFILE hFile, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
481	{
482	if (cbToWrite <= 0)
483	return VINF_SUCCESS;
484	ULONG cbToWriteAdj = (ULONG)cbToWrite;
485	AssertReturn(cbToWriteAdj == cbToWrite, VERR_NUMBER_TOO_BIG);
486
487	ULONG cbWritten = 0;
488	if (WriteFile((HANDLE)RTFileToNative(hFile), pvBuf, cbToWriteAdj, &cbWritten, NULL))
489	{
490	if (pcbWritten)
491	/* Caller can handle partial writes. */
492	*pcbWritten = cbWritten;
493	else
494	{
495	/* Caller expects everything to be written. */
496	while (cbToWriteAdj > cbWritten)
497	{
498	ULONG cbWrittenPart = 0;
499	if (!WriteFile((HANDLE)RTFileToNative(hFile), (char*)pvBuf + cbWritten,
500	cbToWriteAdj - cbWritten, &cbWrittenPart, NULL))
501	{
502	int rc = RTErrConvertFromWin32(GetLastError());
503	if ( rc == VERR_DISK_FULL
504	&& IsBeyondLimit(hFile, cbToWriteAdj - cbWritten, FILE_CURRENT)
505	)
506	rc = VERR_FILE_TOO_BIG;
507	return rc;
508	}
509	if (cbWrittenPart == 0)
510	return VERR_WRITE_ERROR;
511	cbWritten += cbWrittenPart;
512	}
513	}
514	return VINF_SUCCESS;
515	}
516
517	/*
518	* If it's a console, we might bump into out of memory conditions in the
519	* WriteConsole call.
520	*/
521	DWORD dwErr = GetLastError();
522	if (dwErr == ERROR_NOT_ENOUGH_MEMORY)
523	{
524	ULONG cbChunk = cbToWriteAdj / 2;
525	if (cbChunk > _32K)
526	cbChunk = _32K;
527	else
528	cbChunk = RT_ALIGN_32(cbChunk, 256);
529
530	cbWritten = 0;
531	while (cbToWriteAdj > cbWritten)
532	{
533	ULONG cbToWrite = RT_MIN(cbChunk, cbToWriteAdj - cbWritten);
534	ULONG cbWrittenPart = 0;
535	if (!WriteFile((HANDLE)RTFileToNative(hFile), (const char *)pvBuf + cbWritten, cbToWrite, &cbWrittenPart, NULL))
536	{
537	/* If we failed because the buffer is too big, shrink it and
538	try again. */
539	dwErr = GetLastError();
540	if ( dwErr == ERROR_NOT_ENOUGH_MEMORY
541	&& cbChunk > 8)
542	{
543	cbChunk /= 2;
544	continue;
545	}
546	int rc = RTErrConvertFromWin32(dwErr);
547	if ( rc == VERR_DISK_FULL
548	&& IsBeyondLimit(hFile, cbToWriteAdj - cbWritten, FILE_CURRENT))
549	rc = VERR_FILE_TOO_BIG;
550	return rc;
551	}
552	cbWritten += cbWrittenPart;
553
554	/* Return if the caller can handle partial writes, otherwise try
555	write out everything. */
556	if (pcbWritten)
557	{
558	*pcbWritten = cbWritten;
559	break;
560	}
561	if (cbWrittenPart == 0)
562	return VERR_WRITE_ERROR;
563	}
564	return VINF_SUCCESS;
565	}
566
567	int rc = RTErrConvertFromWin32(dwErr);
568	if ( rc == VERR_DISK_FULL
569	&& IsBeyondLimit(hFile, cbToWriteAdj - cbWritten, FILE_CURRENT))
570	rc = VERR_FILE_TOO_BIG;
571	return rc;
572	}
573
574
575	RTR3DECL(int) RTFileFlush(RTFILE hFile)
576	{
577	if (!FlushFileBuffers((HANDLE)RTFileToNative(hFile)))
578	{
579	int rc = GetLastError();
580	Log(("FlushFileBuffers failed with %d\n", rc));
581	return RTErrConvertFromWin32(rc);
582	}
583	return VINF_SUCCESS;
584	}
585
586
587	RTR3DECL(int) RTFileSetSize(RTFILE hFile, uint64_t cbSize)
588	{
589	/*
590	* Get current file pointer.
591	*/
592	int rc;
593	uint64_t offCurrent;
594	if (MySetFilePointer(hFile, 0, &offCurrent, FILE_CURRENT))
595	{
596	/*
597	* Set new file pointer.
598	*/
599	if (MySetFilePointer(hFile, cbSize, NULL, FILE_BEGIN))
600	{
601	/* set file pointer */
602	if (SetEndOfFile((HANDLE)RTFileToNative(hFile)))
603	{
604	/*
605	* Restore file pointer and return.
606	* If the old pointer was beyond the new file end, ignore failure.
607	*/
608	if ( MySetFilePointer(hFile, offCurrent, NULL, FILE_BEGIN)
609	\|\| offCurrent > cbSize)
610	return VINF_SUCCESS;
611	}
612
613	/*
614	* Failed, try restoring the file pointer.
615	*/
616	rc = GetLastError();
617	MySetFilePointer(hFile, offCurrent, NULL, FILE_BEGIN);
618	}
619	else
620	rc = GetLastError();
621	}
622	else
623	rc = GetLastError();
624
625	return RTErrConvertFromWin32(rc);
626	}
627
628
629	RTR3DECL(int) RTFileGetSize(RTFILE hFile, uint64_t *pcbSize)
630	{
631	/*
632	* GetFileSize works for most handles.
633	*/
634	int rc;
635	ULARGE_INTEGER Size;
636	Size.LowPart = GetFileSize((HANDLE)RTFileToNative(hFile), &Size.HighPart);
637	if (Size.LowPart != INVALID_FILE_SIZE)
638	{
639	*pcbSize = Size.QuadPart;
640	if (Size.QuadPart)
641	return VINF_SUCCESS;
642	rc = VINF_SUCCESS;
643	/** @todo Check what GetFileSize returns on disks and volume
644	* handles! */
645	}
646	else
647	rc = RTErrConvertFromWin32(GetLastError());
648	#if 0
649	/*
650	* Could it be a volume?
651	*/
652	DISK_GEOMETRY DriveGeo;
653	DWORD cbDriveGeo;
654	if (DeviceIoControl((HANDLE)RTFileToNative(hFile),
655	IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
656	&DriveGeo, sizeof(DriveGeo), &cbDriveGeo, NULL))
657	{
658	if ( DriveGeo.MediaType == FixedMedia
659	\|\| DriveGeo.MediaType == RemovableMedia)
660	{
661	*pcbSize = DriveGeo.Cylinders.QuadPart
662	* DriveGeo.TracksPerCylinder
663	* DriveGeo.SectorsPerTrack
664	* DriveGeo.BytesPerSector;
665
666	GET_LENGTH_INFORMATION DiskLenInfo;
667	DWORD Ignored;
668	if (DeviceIoControl((HANDLE)RTFileToNative(hFile),
669	IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
670	&DiskLenInfo, sizeof(DiskLenInfo), &Ignored, (LPOVERLAPPED)NULL))
671	{
672	/* IOCTL_DISK_GET_LENGTH_INFO is supported -- override cbSize. */
673	*pcbSize = DiskLenInfo.Length.QuadPart;
674	}
675	return VINF_SUCCESS;
676	}
677	}
678	#endif
679
680	/*
681	* Return the GetFileSize result if not a volume/disk.
682	*/
683	return rc;
684	}
685
686
687	RTR3DECL(int) RTFileGetMaxSizeEx(RTFILE hFile, PRTFOFF pcbMax)
688	{
689	/** @todo r=bird:
690	* We might have to make this code OS version specific... In the worse
691	* case, we'll have to try GetVolumeInformationByHandle on vista and fall
692	* back on NtQueryVolumeInformationFile(,,,, FileFsAttributeInformation)
693	* else where, and check for known file system names. (For LAN shares we'll
694	* have to figure out the remote file system.) */
695	return VERR_NOT_IMPLEMENTED;
696	}
697
698
699	RTR3DECL(bool) RTFileIsValid(RTFILE hFile)
700	{
701	if (hFile != NIL_RTFILE)
702	{
703	DWORD dwType = GetFileType((HANDLE)RTFileToNative(hFile));
704	switch (dwType)
705	{
706	case FILE_TYPE_CHAR:
707	case FILE_TYPE_DISK:
708	case FILE_TYPE_PIPE:
709	case FILE_TYPE_REMOTE:
710	return true;
711
712	case FILE_TYPE_UNKNOWN:
713	if (GetLastError() == NO_ERROR)
714	return true;
715	break;
716	}
717	}
718	return false;
719	}
720
721
722	#define LOW_DWORD(u64) ((DWORD)u64)
723	#define HIGH_DWORD(u64) (((DWORD *)&u64)[1])
724
725	RTR3DECL(int) RTFileLock(RTFILE hFile, unsigned fLock, int64_t offLock, uint64_t cbLock)
726	{
727	Assert(offLock >= 0);
728
729	/* Check arguments. */
730	if (fLock & ~RTFILE_LOCK_MASK)
731	{
732	AssertMsgFailed(("Invalid fLock=%08X\n", fLock));
733	return VERR_INVALID_PARAMETER;
734	}
735
736	/* Prepare flags. */
737	Assert(RTFILE_LOCK_WRITE);
738	DWORD dwFlags = (fLock & RTFILE_LOCK_WRITE) ? LOCKFILE_EXCLUSIVE_LOCK : 0;
739	Assert(RTFILE_LOCK_WAIT);
740	if (!(fLock & RTFILE_LOCK_WAIT))
741	dwFlags \|= LOCKFILE_FAIL_IMMEDIATELY;
742
743	/* Windows structure. */
744	OVERLAPPED Overlapped;
745	memset(&Overlapped, 0, sizeof(Overlapped));
746	Overlapped.Offset = LOW_DWORD(offLock);
747	Overlapped.OffsetHigh = HIGH_DWORD(offLock);
748
749	/* Note: according to Microsoft, LockFileEx API call is available starting from NT 3.5 */
750	if (LockFileEx((HANDLE)RTFileToNative(hFile), dwFlags, 0, LOW_DWORD(cbLock), HIGH_DWORD(cbLock), &Overlapped))
751	return VINF_SUCCESS;
752
753	return RTErrConvertFromWin32(GetLastError());
754	}
755
756
757	RTR3DECL(int) RTFileChangeLock(RTFILE hFile, unsigned fLock, int64_t offLock, uint64_t cbLock)
758	{
759	Assert(offLock >= 0);
760
761	/* Check arguments. */
762	if (fLock & ~RTFILE_LOCK_MASK)
763	{
764	AssertMsgFailed(("Invalid fLock=%08X\n", fLock));
765	return VERR_INVALID_PARAMETER;
766	}
767
768	/* Remove old lock. */
769	int rc = RTFileUnlock(hFile, offLock, cbLock);
770	if (RT_FAILURE(rc))
771	return rc;
772
773	/* Set new lock. */
774	rc = RTFileLock(hFile, fLock, offLock, cbLock);
775	if (RT_SUCCESS(rc))
776	return rc;
777
778	/* Try to restore old lock. */
779	unsigned fLockOld = (fLock & RTFILE_LOCK_WRITE) ? fLock & ~RTFILE_LOCK_WRITE : fLock \| RTFILE_LOCK_WRITE;
780	rc = RTFileLock(hFile, fLockOld, offLock, cbLock);
781	if (RT_SUCCESS(rc))
782	return VERR_FILE_LOCK_VIOLATION;
783	else
784	return VERR_FILE_LOCK_LOST;
785	}
786
787
788	RTR3DECL(int) RTFileUnlock(RTFILE hFile, int64_t offLock, uint64_t cbLock)
789	{
790	Assert(offLock >= 0);
791
792	if (UnlockFile((HANDLE)RTFileToNative(hFile),
793	LOW_DWORD(offLock), HIGH_DWORD(offLock),
794	LOW_DWORD(cbLock), HIGH_DWORD(cbLock)))
795	return VINF_SUCCESS;
796
797	return RTErrConvertFromWin32(GetLastError());
798	}
799
800
801
802	RTR3DECL(int) RTFileQueryInfo(RTFILE hFile, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
803	{
804	/*
805	* Validate input.
806	*/
807	if (hFile == NIL_RTFILE)
808	{
809	AssertMsgFailed(("Invalid hFile=%RTfile\n", hFile));
810	return VERR_INVALID_PARAMETER;
811	}
812	if (!pObjInfo)
813	{
814	AssertMsgFailed(("Invalid pObjInfo=%p\n", pObjInfo));
815	return VERR_INVALID_PARAMETER;
816	}
817	if ( enmAdditionalAttribs < RTFSOBJATTRADD_NOTHING
818	\|\| enmAdditionalAttribs > RTFSOBJATTRADD_LAST)
819	{
820	AssertMsgFailed(("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs));
821	return VERR_INVALID_PARAMETER;
822	}
823
824	/*
825	* Query file info.
826	*/
827	BY_HANDLE_FILE_INFORMATION Data;
828	if (!GetFileInformationByHandle((HANDLE)RTFileToNative(hFile), &Data))
829	{
830	DWORD dwErr = GetLastError();
831	/* Only return if we really don't have a valid handle value,
832	* everything else is fine here ... */
833	if (dwErr != ERROR_INVALID_HANDLE)
834	return RTErrConvertFromWin32(dwErr);
835	}
836
837	/*
838	* Setup the returned data.
839	*/
840	pObjInfo->cbObject = ((uint64_t)Data.nFileSizeHigh << 32)
841	\| (uint64_t)Data.nFileSizeLow;
842	pObjInfo->cbAllocated = pObjInfo->cbObject;
843
844	Assert(sizeof(uint64_t) == sizeof(Data.ftCreationTime));
845	RTTimeSpecSetNtTime(&pObjInfo->BirthTime, (uint64_t )&Data.ftCreationTime);
846	RTTimeSpecSetNtTime(&pObjInfo->AccessTime, (uint64_t )&Data.ftLastAccessTime);
847	RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, (uint64_t )&Data.ftLastWriteTime);
848	pObjInfo->ChangeTime = pObjInfo->ModificationTime;
849
850	pObjInfo->Attr.fMode = rtFsModeFromDos((Data.dwFileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT, "", 0);
851
852	/*
853	* Requested attributes (we cannot provide anything actually).
854	*/
855	switch (enmAdditionalAttribs)
856	{
857	case RTFSOBJATTRADD_NOTHING:
858	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_NOTHING;
859	break;
860
861	case RTFSOBJATTRADD_UNIX:
862	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
863	pObjInfo->Attr.u.Unix.uid = ~0U;
864	pObjInfo->Attr.u.Unix.gid = ~0U;
865	pObjInfo->Attr.u.Unix.cHardlinks = Data.nNumberOfLinks ? Data.nNumberOfLinks : 1;
866	pObjInfo->Attr.u.Unix.INodeIdDevice = 0; /** @todo Use the volume serial number (see GetFileInformationByHandle). */
867	pObjInfo->Attr.u.Unix.INodeId = 0; /** @todo Use the fileid (see GetFileInformationByHandle). */
868	pObjInfo->Attr.u.Unix.fFlags = 0;
869	pObjInfo->Attr.u.Unix.GenerationId = 0;
870	pObjInfo->Attr.u.Unix.Device = 0;
871	break;
872
873	case RTFSOBJATTRADD_UNIX_OWNER:
874	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_OWNER;
875	pObjInfo->Attr.u.UnixOwner.uid = ~0U;
876	pObjInfo->Attr.u.UnixOwner.szName[0] = '\0'; /** @todo return something sensible here. */
877	break;
878
879	case RTFSOBJATTRADD_UNIX_GROUP:
880	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_GROUP;
881	pObjInfo->Attr.u.UnixGroup.gid = ~0U;
882	pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
883	break;
884
885	case RTFSOBJATTRADD_EASIZE:
886	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
887	pObjInfo->Attr.u.EASize.cb = 0;
888	break;
889
890	default:
891	AssertMsgFailed(("Impossible!\n"));
892	return VERR_INTERNAL_ERROR;
893	}
894
895	return VINF_SUCCESS;
896	}
897
898
899	RTR3DECL(int) RTFileSetTimes(RTFILE hFile, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
900	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
901	{
902	if (!pAccessTime && !pModificationTime && !pBirthTime)
903	return VINF_SUCCESS; /* NOP */
904
905	FILETIME CreationTimeFT;
906	PFILETIME pCreationTimeFT = NULL;
907	if (pBirthTime)
908	pCreationTimeFT = RTTimeSpecGetNtFileTime(pBirthTime, &CreationTimeFT);
909
910	FILETIME LastAccessTimeFT;
911	PFILETIME pLastAccessTimeFT = NULL;
912	if (pAccessTime)
913	pLastAccessTimeFT = RTTimeSpecGetNtFileTime(pAccessTime, &LastAccessTimeFT);
914
915	FILETIME LastWriteTimeFT;
916	PFILETIME pLastWriteTimeFT = NULL;
917	if (pModificationTime)
918	pLastWriteTimeFT = RTTimeSpecGetNtFileTime(pModificationTime, &LastWriteTimeFT);
919
920	int rc = VINF_SUCCESS;
921	if (!SetFileTime((HANDLE)RTFileToNative(hFile), pCreationTimeFT, pLastAccessTimeFT, pLastWriteTimeFT))
922	{
923	DWORD Err = GetLastError();
924	rc = RTErrConvertFromWin32(Err);
925	Log(("RTFileSetTimes(%RTfile, %p, %p, %p, %p): SetFileTime failed with lasterr %d (%Rrc)\n",
926	hFile, pAccessTime, pModificationTime, pChangeTime, pBirthTime, Err, rc));
927	}
928	return rc;
929	}
930
931
932	/* This comes from a source file with a different set of system headers (DDK)
933	* so it can't be declared in a common header, like internal/file.h.
934	*/
935	extern int rtFileNativeSetAttributes(HANDLE FileHandle, ULONG FileAttributes);
936
937
938	RTR3DECL(int) RTFileSetMode(RTFILE hFile, RTFMODE fMode)
939	{
940	/*
941	* Normalize the mode and call the API.
942	*/
943	fMode = rtFsModeNormalize(fMode, NULL, 0);
944	if (!rtFsModeIsValid(fMode))
945	return VERR_INVALID_PARAMETER;
946
947	ULONG FileAttributes = (fMode & RTFS_DOS_MASK) >> RTFS_DOS_SHIFT;
948	int Err = rtFileNativeSetAttributes((HANDLE)hFile, FileAttributes);
949	if (Err != ERROR_SUCCESS)
950	{
951	int rc = RTErrConvertFromWin32(Err);
952	Log(("RTFileSetMode(%RTfile, %RTfmode): rtFileNativeSetAttributes (0x%08X) failed with err %d (%Rrc)\n",
953	hFile, fMode, FileAttributes, Err, rc));
954	return rc;
955	}
956	return VINF_SUCCESS;
957	}
958
959
960	RTR3DECL(int) RTFileQueryFsSizes(RTFILE hFile, PRTFOFF pcbTotal, RTFOFF *pcbFree,
961	uint32_t pcbBlock, uint32_t pcbSector)
962	{
963	/** @todo implement this using NtQueryVolumeInformationFile(hFile,,,,
964	* FileFsSizeInformation). */
965	return VERR_NOT_SUPPORTED;
966	}
967
968
969	RTR3DECL(int) RTFileDelete(const char *pszFilename)
970	{
971	PRTUTF16 pwszFilename;
972	int rc = RTStrToUtf16(pszFilename, &pwszFilename);
973	if (RT_SUCCESS(rc))
974	{
975	if (!DeleteFileW(pwszFilename))
976	rc = RTErrConvertFromWin32(GetLastError());
977	RTUtf16Free(pwszFilename);
978	}
979
980	return rc;
981	}
982
983
984	RTDECL(int) RTFileRename(const char pszSrc, const char pszDst, unsigned fRename)
985	{
986	/*
987	* Validate input.
988	*/
989	AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER);
990	AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER);
991	AssertMsgReturn(!(fRename & ~RTPATHRENAME_FLAGS_REPLACE), ("%#x\n", fRename), VERR_INVALID_PARAMETER);
992
993	/*
994	* Hand it on to the worker.
995	*/
996	int rc = rtPathWin32MoveRename(pszSrc, pszDst,
997	fRename & RTPATHRENAME_FLAGS_REPLACE ? MOVEFILE_REPLACE_EXISTING : 0,
998	RTFS_TYPE_FILE);
999
1000	LogFlow(("RTFileMove(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n",
1001	pszSrc, pszSrc, pszDst, pszDst, fRename, rc));
1002	return rc;
1003
1004	}
1005
1006
1007	RTDECL(int) RTFileMove(const char pszSrc, const char pszDst, unsigned fMove)
1008	{
1009	/*
1010	* Validate input.
1011	*/
1012	AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER);
1013	AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER);
1014	AssertMsgReturn(!(fMove & ~RTFILEMOVE_FLAGS_REPLACE), ("%#x\n", fMove), VERR_INVALID_PARAMETER);
1015
1016	/*
1017	* Hand it on to the worker.
1018	*/
1019	int rc = rtPathWin32MoveRename(pszSrc, pszDst,
1020	fMove & RTFILEMOVE_FLAGS_REPLACE
1021	? MOVEFILE_COPY_ALLOWED \| MOVEFILE_REPLACE_EXISTING
1022	: MOVEFILE_COPY_ALLOWED,
1023	RTFS_TYPE_FILE);
1024
1025	LogFlow(("RTFileMove(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n",
1026	pszSrc, pszSrc, pszDst, pszDst, fMove, rc));
1027	return rc;
1028	}
1029

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Runtime/r3/win/fileio-win.cpp@ 39025

以其他格式下載: