fileio-win.cpp@ 62584

Last change on this file since 62584 was 62584, checked in by vboxsync, 8 years ago
IPRT: Unused parameters on windows.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 36.0 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: