fileio-win.cpp@ 23047

Last change on this file since 23047 was 23047, checked in by vboxsync, 16 years ago
Fix RTFILE_O_NO_CACHE on Windows. Document that FILE_APPEND_DATA is disabled and how to workaround it
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 28.4 KB

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

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

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

Download in other formats: