fileio-win.cpp@ 27509

Last change on this file since 27509 was 27388, checked in by vboxsync, 15 years ago
iprt: flush file & pipe.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 28.4 KB

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

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

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

Download in other formats: