fileio-win32.cpp@ 4495

Last change on this file since 4495 was 4372, checked in by vboxsync, 18 years ago
Finally corrected the RTFileRead, RTFileReadAt, RTFileWrite and RTFileWriteAt APIs to size_t. This was long overdue.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 22.1 KB

Line
1	/* $Id: fileio-win32.cpp 4372 2007-08-24 21:21:51Z vboxsync $ */
2	/** @file
3	* innotek Portable Runtime - File I/O, native implementation for the Windows host platform.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP RTLOGGROUP_DIR
23	#include <Windows.h>
24
25	#include <iprt/file.h>
26	#include <iprt/path.h>
27	#include <iprt/assert.h>
28	#include <iprt/string.h>
29	#include <iprt/err.h>
30	#include <iprt/log.h>
31	#include "internal/file.h"
32	#include "internal/fs.h"
33	#include "internal/path.h"
34
35
36	/*******************************************************************************
37	* Defined Constants And Macros *
38	*******************************************************************************/
39	/** @def RT_DONT_CONVERT_FILENAMES
40	* Define this to pass UTF-8 unconverted to the kernel. */
41	#ifdef __DOXYGEN__
42	# define RT_DONT_CONVERT_FILENAMES 1
43	#endif
44
45
46	/**
47	* This is wrapper around the ugly SetFilePointer api.
48	*
49	* It's equivalent to SetFilePointerEx which we so unfortunately cannot use because of
50	* it not being present in NT4 GA.
51	*
52	* @returns Success indicator. Extended error information obtainable using GetLastError().
53	* @param File Filehandle.
54	* @param offSeek Offset to seek.
55	* @param poffNew Where to store the new file offset. NULL allowed.
56	* @param uMethod Seek method. (The windows one!)
57	*/
58	inline bool MySetFilePointer(RTFILE File, uint64_t offSeek, uint64_t *poffNew, unsigned uMethod)
59	{
60	LARGE_INTEGER off;
61	off.QuadPart = offSeek;
62	#if 1
63	off.LowPart = SetFilePointer((HANDLE)File, off.LowPart, &off.HighPart, uMethod);
64	bool fRc = off.LowPart != INVALID_SET_FILE_POINTER;
65	#else
66	bool fRc = SetFilePointerEx((HANDLE)File, off, &off, uMethod);
67	#endif
68	if (fRc && poffNew)
69	*poffNew = off.QuadPart;
70	return fRc;
71	}
72
73
74	/**
75	* This is a helper to check if an attempt was made to grow a file beyond the
76	* limit of the filesystem.
77	*
78	* @returns true for file size limit exceeded.
79	* @param File Filehandle.
80	* @param offSeek Offset to seek.
81	*/
82	DECLINLINE(bool) IsBeyondLimit(RTFILE File, uint64_t offSeek, unsigned uMethod)
83	{
84	bool fIsBeyondLimit = false;
85
86	/*
87	* Get the current file position and try set the new one.
88	* If it fails with a seek error it's because we hit the file system limit.
89	*/
90	uint64_t offCurrent;
91	if (MySetFilePointer(File, 0, &offCurrent, FILE_CURRENT))
92	{
93	if (!MySetFilePointer(File, offSeek, NULL, uMethod))
94	fIsBeyondLimit = GetLastError() == ERROR_SEEK;
95	else /* Restore file pointer on success. */
96	MySetFilePointer(File, offCurrent, NULL, FILE_BEGIN);
97	}
98
99	return fIsBeyondLimit;
100	}
101
102
103	RTR3DECL(int) RTFileOpen(PRTFILE pFile, const char *pszFilename, unsigned fOpen)
104	{
105	/*
106	* Validate input.
107	*/
108	if (!pFile)
109	{
110	AssertMsgFailed(("Invalid pFile\n"));
111	return VERR_INVALID_PARAMETER;
112	}
113	*pFile = NIL_RTFILE;
114	if (!pszFilename)
115	{
116	AssertMsgFailed(("Invalid pszFilename\n"));
117	return VERR_INVALID_PARAMETER;
118	}
119
120	/*
121	* Merge forced open flags and validate them.
122	*/
123	int rc = rtFileRecalcAndValidateFlags(&fOpen);
124	if (RT_FAILURE(rc))
125	return rc;
126
127	/*
128	* Determine disposition, access, share mode, creation flags, and security attributes
129	* for the CreateFile API call.
130	*/
131	DWORD dwCreationDisposition;
132	switch (fOpen & RTFILE_O_ACTION_MASK)
133	{
134	case RTFILE_O_OPEN:
135	dwCreationDisposition = fOpen & RTFILE_O_TRUNCATE ? TRUNCATE_EXISTING : OPEN_EXISTING;
136	break;
137	case RTFILE_O_OPEN_CREATE:
138	dwCreationDisposition = OPEN_ALWAYS;
139	break;
140	case RTFILE_O_CREATE:
141	dwCreationDisposition = CREATE_NEW;
142	break;
143	case RTFILE_O_CREATE_REPLACE:
144	dwCreationDisposition = CREATE_ALWAYS;
145	break;
146	default:
147	AssertMsgFailed(("Impossible fOpen=%#x\n", fOpen));
148	return VERR_INVALID_PARAMETER;
149	}
150
151	DWORD dwDesiredAccess;
152	switch (fOpen & RTFILE_O_ACCESS_MASK)
153	{
154	case RTFILE_O_READ: dwDesiredAccess = GENERIC_READ; break;
155	case RTFILE_O_WRITE: dwDesiredAccess = GENERIC_WRITE; break;
156	case RTFILE_O_READWRITE: dwDesiredAccess = GENERIC_READ \| GENERIC_WRITE; break;
157	default:
158	AssertMsgFailed(("Impossible fOpen=%#x\n", fOpen));
159	return VERR_INVALID_PARAMETER;
160	}
161
162	DWORD dwShareMode;
163	Assert(RTFILE_O_DENY_READWRITE == RTFILE_O_DENY_ALL && !RTFILE_O_DENY_NONE);
164	switch (fOpen & RTFILE_O_DENY_MASK)
165	{
166	case RTFILE_O_DENY_NONE: dwShareMode = FILE_SHARE_READ \| FILE_SHARE_WRITE; break;
167	case RTFILE_O_DENY_READ: dwShareMode = FILE_SHARE_WRITE; break;
168	case RTFILE_O_DENY_WRITE: dwShareMode = FILE_SHARE_READ; break;
169	case RTFILE_O_DENY_READWRITE: dwShareMode = 0; break;
170
171	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_NONE: dwShareMode = FILE_SHARE_DELETE \| FILE_SHARE_READ \| FILE_SHARE_WRITE; break;
172	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_READ: dwShareMode = FILE_SHARE_DELETE \| FILE_SHARE_WRITE; break;
173	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_WRITE: dwShareMode = FILE_SHARE_DELETE \| FILE_SHARE_READ; break;
174	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_READWRITE:dwShareMode = FILE_SHARE_DELETE; break;
175	default:
176	AssertMsgFailed(("Impossible fOpen=%#x\n", fOpen));
177	return VERR_INVALID_PARAMETER;
178	}
179
180	SECURITY_ATTRIBUTES SecurityAttributes;
181	PSECURITY_ATTRIBUTES pSecurityAttributes = NULL;
182	if (fOpen & RTFILE_O_INHERIT)
183	{
184	SecurityAttributes.nLength = sizeof(SecurityAttributes);
185	SecurityAttributes.lpSecurityDescriptor = NULL;
186	SecurityAttributes.bInheritHandle = TRUE;
187	pSecurityAttributes = &SecurityAttributes;
188	}
189
190	DWORD dwFlagsAndAttributes;
191	dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
192	if (fOpen & RTFILE_O_WRITE_THROUGH)
193	dwFlagsAndAttributes \|= FILE_FLAG_WRITE_THROUGH;
194
195	/*
196	* Open/Create the file.
197	*/
198	#ifdef RT_DONT_CONVERT_FILENAMES
199	HANDLE hFile = CreateFile(pszFilename,
200	dwDesiredAccess,
201	dwShareMode,
202	pSecurityAttributes,
203	dwCreationDisposition,
204	dwFlagsAndAttributes,
205	NULL);
206	if (hFile == INVALID_HANDLE_VALUE)
207	return RTErrConvertFromWin32(GetLastError());
208
209	#else
210	PRTUCS2 pwszFilename;
211	rc = RTStrToUtf16(pszFilename, &pwszFilename);
212	if (RT_FAILURE(rc))
213	return rc;
214
215	HANDLE hFile = CreateFileW(pwszFilename,
216	dwDesiredAccess,
217	dwShareMode,
218	pSecurityAttributes,
219	dwCreationDisposition,
220	dwFlagsAndAttributes,
221	NULL);
222	if (hFile == INVALID_HANDLE_VALUE)
223	{
224	rc = RTErrConvertFromWin32(GetLastError()); /* get error first! */
225	RTUtf16Free(pwszFilename);
226	return rc;
227	}
228	RTUtf16Free(pwszFilename);
229	#endif
230
231	/*
232	* Do we need to truncate the file?
233	*/
234	if ( (fOpen & (RTFILE_O_TRUNCATE \| RTFILE_O_ACTION_MASK))
235	== (RTFILE_O_TRUNCATE \| RTFILE_O_OPEN_CREATE))
236	{
237	if (!SetEndOfFile(hFile))
238	{
239	rc = RTErrConvertFromWin32(GetLastError()); /* get error first! */
240	CloseHandle(hFile);
241	return rc;
242	}
243	}
244
245	*pFile = (RTFILE)hFile;
246	Assert((HANDLE)*pFile == hFile);
247	return VINF_SUCCESS;
248	}
249
250
251	RTR3DECL(int) RTFileClose(RTFILE File)
252	{
253	if (CloseHandle((HANDLE)File))
254	return VINF_SUCCESS;
255	return RTErrConvertFromWin32(GetLastError());
256	}
257
258
259	RTR3DECL(int) RTFileSeek(RTFILE File, int64_t offSeek, unsigned uMethod, uint64_t *poffActual)
260	{
261	static ULONG aulSeekRecode[] =
262	{
263	FILE_BEGIN,
264	FILE_CURRENT,
265	FILE_END,
266	};
267
268	/*
269	* Validate input.
270	*/
271	if (uMethod > RTFILE_SEEK_END)
272	{
273	AssertMsgFailed(("Invalid uMethod=%d\n", uMethod));
274	return VERR_INVALID_PARAMETER;
275	}
276
277	/*
278	* Execute the seek.
279	*/
280	if (MySetFilePointer(File, offSeek, poffActual, aulSeekRecode[uMethod]))
281	return VINF_SUCCESS;
282	return RTErrConvertFromWin32(GetLastError());
283	}
284
285
286	RTR3DECL(int) RTFileRead(RTFILE File, void pvBuf, size_t cbToRead, size_t pcbRead)
287	{
288	if (cbToRead <= 0)
289	return VINF_SUCCESS;
290
291	ULONG cbRead = 0;
292	if (ReadFile((HANDLE)File, pvBuf, cbToRead, &cbRead, NULL))
293	{
294	if (pcbRead)
295	/* Caller can handle partial reads. */
296	*pcbRead = cbRead;
297	else
298	{
299	/* Caller expects everything to be read. */
300	while (cbToRead > cbRead)
301	{
302	ULONG cbReadPart = 0;
303	if (!ReadFile((HANDLE)File, (char*)pvBuf + cbRead, cbToRead - cbRead, &cbReadPart, NULL))
304	return RTErrConvertFromWin32(GetLastError());
305	if (cbReadPart == 0)
306	return VERR_EOF;
307	cbRead += cbReadPart;
308	}
309	}
310	return VINF_SUCCESS;
311	}
312	return RTErrConvertFromWin32(GetLastError());
313	}
314
315
316	RTR3DECL(int) RTFileWrite(RTFILE File, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
317	{
318	if (cbToWrite <= 0)
319	return VINF_SUCCESS;
320
321	ULONG cbWritten = 0;
322	if (WriteFile((HANDLE)File, pvBuf, cbToWrite, &cbWritten, NULL))
323	{
324	if (pcbWritten)
325	/* Caller can handle partial writes. */
326	*pcbWritten = cbWritten;
327	else
328	{
329	/* Caller expects everything to be written. */
330	while (cbToWrite > cbWritten)
331	{
332	ULONG cbWrittenPart = 0;
333	if (!WriteFile((HANDLE)File, (char*)pvBuf + cbWritten, cbToWrite - cbWritten, &cbWrittenPart, NULL))
334	{
335	int rc = RTErrConvertFromWin32(GetLastError());
336	if ( rc == VERR_DISK_FULL
337	&& IsBeyondLimit(File, cbToWrite - cbWritten, FILE_CURRENT)
338	)
339	rc = VERR_FILE_TOO_BIG;
340	return rc;
341	}
342	if (cbWrittenPart == 0)
343	return VERR_WRITE_ERROR;
344	cbWritten += cbWrittenPart;
345	}
346	}
347	return VINF_SUCCESS;
348	}
349	int rc = RTErrConvertFromWin32(GetLastError());
350	if ( rc == VERR_DISK_FULL
351	&& IsBeyondLimit(File, cbToWrite - cbWritten, FILE_CURRENT)
352	)
353	rc = VERR_FILE_TOO_BIG;
354	return rc;
355	}
356
357
358	RTR3DECL(int) RTFileFlush(RTFILE File)
359	{
360	int rc;
361
362	if (FlushFileBuffers((HANDLE)File) == FALSE)
363	{
364	rc = GetLastError();
365	Log(("FlushFileBuffers failed with %d\n", rc));
366	return RTErrConvertFromWin32(rc);
367	}
368	return VINF_SUCCESS;
369	}
370
371
372	RTR3DECL(int) RTFileSetSize(RTFILE File, uint64_t cbSize)
373	{
374	/*
375	* Get current file pointer.
376	*/
377	int rc;
378	uint64_t offCurrent;
379	if (MySetFilePointer(File, 0, &offCurrent, FILE_CURRENT))
380	{
381	/*
382	* Set new file pointer.
383	*/
384	if (MySetFilePointer(File, cbSize, NULL, FILE_BEGIN))
385	{
386	/* file pointer setted */
387	if (SetEndOfFile((HANDLE)File))
388	{
389	/*
390	* Restore file pointer and return.
391	* If the old pointer was beyond the new file end, ignore failure.
392	*/
393	if ( MySetFilePointer(File, offCurrent, NULL, FILE_BEGIN)
394	\|\| offCurrent > cbSize)
395	return VINF_SUCCESS;
396	}
397
398	/*
399	* Failed, try restore file pointer.
400	*/
401	rc = GetLastError();
402	MySetFilePointer(File, offCurrent, NULL, FILE_BEGIN);
403	}
404	else
405	rc = GetLastError();
406	}
407	else
408	rc = GetLastError();
409
410	return RTErrConvertFromWin32(rc);
411	}
412
413
414	RTR3DECL(int) RTFileGetSize(RTFILE File, uint64_t *pcbSize)
415	{
416	ULARGE_INTEGER Size;
417	Size.LowPart = GetFileSize((HANDLE)File, &Size.HighPart);
418	if (Size.LowPart != INVALID_FILE_SIZE)
419	{
420	*pcbSize = Size.QuadPart;
421	return VINF_SUCCESS;
422	}
423
424	/* error exit */
425	return RTErrConvertFromWin32(GetLastError());
426	}
427
428
429	RTR3DECL(bool) RTFileIsValid(RTFILE File)
430	{
431	if (File != NIL_RTFILE)
432	{
433	DWORD dwType = GetFileType((HANDLE)File);
434	switch (dwType)
435	{
436	case FILE_TYPE_CHAR:
437	case FILE_TYPE_DISK:
438	case FILE_TYPE_PIPE:
439	case FILE_TYPE_REMOTE:
440	return true;
441
442	case FILE_TYPE_UNKNOWN:
443	if (GetLastError() == NO_ERROR)
444	return true;
445	break;
446	}
447	}
448	return false;
449	}
450
451
452	#define LOW_DWORD(u64) ((DWORD)u64)
453	#define HIGH_DWORD(u64) (((DWORD *)&u64)[1])
454
455	RTR3DECL(int) RTFileLock(RTFILE File, unsigned fLock, int64_t offLock, uint64_t cbLock)
456	{
457	Assert(offLock >= 0);
458
459	/* Check arguments. */
460	if (fLock & ~RTFILE_LOCK_MASK)
461	{
462	AssertMsgFailed(("Invalid fLock=%08X\n", fLock));
463	return VERR_INVALID_PARAMETER;
464	}
465
466	/* Prepare flags. */
467	Assert(RTFILE_LOCK_WRITE);
468	DWORD dwFlags = (fLock & RTFILE_LOCK_WRITE) ? LOCKFILE_EXCLUSIVE_LOCK : 0;
469	Assert(RTFILE_LOCK_WAIT);
470	if (!(fLock & RTFILE_LOCK_WAIT))
471	dwFlags \|= LOCKFILE_FAIL_IMMEDIATELY;
472
473	/* Windows structure. */
474	OVERLAPPED Overlapped;
475	memset(&Overlapped, 0, sizeof(Overlapped));
476	Overlapped.Offset = LOW_DWORD(offLock);
477	Overlapped.OffsetHigh = HIGH_DWORD(offLock);
478
479	/* Note: according to Microsoft, LockFileEx API call is available starting from NT 3.5 */
480	if (LockFileEx((HANDLE)File, dwFlags, 0, LOW_DWORD(cbLock), HIGH_DWORD(cbLock), &Overlapped))
481	return VINF_SUCCESS;
482
483	return RTErrConvertFromWin32(GetLastError());
484	}
485
486
487	RTR3DECL(int) RTFileChangeLock(RTFILE File, unsigned fLock, int64_t offLock, uint64_t cbLock)
488	{
489	Assert(offLock >= 0);
490
491	/* Check arguments. */
492	if (fLock & ~RTFILE_LOCK_MASK)
493	{
494	AssertMsgFailed(("Invalid fLock=%08X\n", fLock));
495	return VERR_INVALID_PARAMETER;
496	}
497
498	/* Remove old lock. */
499	int rc = RTFileUnlock(File, offLock, cbLock);
500	if (RT_FAILURE(rc))
501	return rc;
502
503	/* Set new lock. */
504	rc = RTFileLock(File, fLock, offLock, cbLock);
505	if (RT_SUCCESS(rc))
506	return rc;
507
508	/* Try to restore old lock. */
509	unsigned fLockOld = (fLock & RTFILE_LOCK_WRITE) ? fLock & ~RTFILE_LOCK_WRITE : fLock \| RTFILE_LOCK_WRITE;
510	rc = RTFileLock(File, fLockOld, offLock, cbLock);
511	if (RT_SUCCESS(rc))
512	return VERR_FILE_LOCK_VIOLATION;
513	else
514	return VERR_FILE_LOCK_LOST;
515	}
516
517
518	RTR3DECL(int) RTFileUnlock(RTFILE File, int64_t offLock, uint64_t cbLock)
519	{
520	Assert(offLock >= 0);
521
522	if (UnlockFile((HANDLE)File, LOW_DWORD(offLock), HIGH_DWORD(offLock), LOW_DWORD(cbLock), HIGH_DWORD(cbLock)))
523	return VINF_SUCCESS;
524
525	return RTErrConvertFromWin32(GetLastError());
526	}
527
528
529
530	RTR3DECL(int) RTFileQueryInfo(RTFILE File, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
531	{
532	/*
533	* Validate input.
534	*/
535	if (File == NIL_RTFILE)
536	{
537	AssertMsgFailed(("Invalid File=%RTfile\n", File));
538	return VERR_INVALID_PARAMETER;
539	}
540	if (!pObjInfo)
541	{
542	AssertMsgFailed(("Invalid pObjInfo=%p\n", pObjInfo));
543	return VERR_INVALID_PARAMETER;
544	}
545	if ( enmAdditionalAttribs < RTFSOBJATTRADD_NOTHING
546	\|\| enmAdditionalAttribs > RTFSOBJATTRADD_LAST)
547	{
548	AssertMsgFailed(("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs));
549	return VERR_INVALID_PARAMETER;
550	}
551
552	/*
553	* Query file info.
554	*/
555	BY_HANDLE_FILE_INFORMATION Data;
556	if (!GetFileInformationByHandle((HANDLE)File, &Data))
557	return RTErrConvertFromWin32(GetLastError());
558
559	/*
560	* Setup the returned data.
561	*/
562	pObjInfo->cbObject = ((uint64_t)Data.nFileSizeHigh << 32)
563	\| (uint64_t)Data.nFileSizeLow;
564	pObjInfo->cbAllocated = pObjInfo->cbObject;
565
566	Assert(sizeof(uint64_t) == sizeof(Data.ftCreationTime));
567	RTTimeSpecSetNtTime(&pObjInfo->BirthTime, (uint64_t )&Data.ftCreationTime);
568	RTTimeSpecSetNtTime(&pObjInfo->AccessTime, (uint64_t )&Data.ftLastAccessTime);
569	RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, (uint64_t )&Data.ftLastWriteTime);
570	pObjInfo->ChangeTime = pObjInfo->ModificationTime;
571
572	pObjInfo->Attr.fMode = rtFsModeFromDos((Data.dwFileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT, "", 0);
573
574	/*
575	* Requested attributes (we cannot provide anything actually).
576	*/
577	switch (enmAdditionalAttribs)
578	{
579	case RTFSOBJATTRADD_EASIZE:
580	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
581	pObjInfo->Attr.u.EASize.cb = 0;
582	break;
583
584	case RTFSOBJATTRADD_UNIX:
585	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
586	pObjInfo->Attr.u.Unix.uid = ~0U;
587	pObjInfo->Attr.u.Unix.gid = ~0U;
588	pObjInfo->Attr.u.Unix.cHardlinks = Data.nNumberOfLinks ? Data.nNumberOfLinks : 1;
589	pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
590	pObjInfo->Attr.u.Unix.INodeId = 0;
591	pObjInfo->Attr.u.Unix.fFlags = 0;
592	pObjInfo->Attr.u.Unix.GenerationId = 0;
593	pObjInfo->Attr.u.Unix.Device = 0;
594	break;
595
596	case RTFSOBJATTRADD_NOTHING:
597	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_NOTHING;
598	break;
599
600	default:
601	AssertMsgFailed(("Impossible!\n"));
602	return VERR_INTERNAL_ERROR;
603	}
604
605	return VINF_SUCCESS;
606	}
607
608
609	RTR3DECL(int) RTFileSetTimes(RTFILE File, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
610	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
611	{
612	if (!pAccessTime && !pModificationTime && !pBirthTime)
613	return VINF_SUCCESS; /* NOP */
614
615	FILETIME CreationTimeFT;
616	PFILETIME pCreationTimeFT = NULL;
617	if (pBirthTime)
618	pCreationTimeFT = RTTimeSpecGetNtFileTime(pBirthTime, &CreationTimeFT);
619
620	FILETIME LastAccessTimeFT;
621	PFILETIME pLastAccessTimeFT = NULL;
622	if (pAccessTime)
623	pLastAccessTimeFT = RTTimeSpecGetNtFileTime(pAccessTime, &LastAccessTimeFT);
624
625	FILETIME LastWriteTimeFT;
626	PFILETIME pLastWriteTimeFT = NULL;
627	if (pModificationTime)
628	pLastWriteTimeFT = RTTimeSpecGetNtFileTime(pModificationTime, &LastWriteTimeFT);
629
630	int rc = VINF_SUCCESS;
631	if (!SetFileTime((HANDLE)File, pCreationTimeFT, pLastAccessTimeFT, pLastWriteTimeFT))
632	{
633	DWORD Err = GetLastError();
634	rc = RTErrConvertFromWin32(Err);
635	Log(("RTFileSetTimes(%RTfile, %p, %p, %p, %p): SetFileTime failed with lasterr %d (%Vrc)\n",
636	File, pAccessTime, pModificationTime, pChangeTime, pBirthTime, Err, rc));
637	}
638	return rc;
639	}
640
641
642	RTR3DECL(int) RTFileSetMode(RTFILE File, RTFMODE fMode)
643	{
644	/** @todo darn. this needs a full path; probably must be done if the file is closed
645	* It's quite possible that there is an NT API for this. NtSetInformationFile() for instance. */
646	return VINF_SUCCESS;
647	}
648
649
650	RTR3DECL(int) RTFileDelete(const char *pszFilename)
651	{
652	#ifdef RT_DONT_CONVERT_FILENAMES
653	if (DeleteFile(pszFilename))
654	return VINF_SUCCESS;
655	return RTErrConvertFromWin32(GetLastError());
656
657	#else
658	PRTUTF16 pwszFilename;
659	int rc = RTStrToUtf16(pszFilename, &pwszFilename);
660	if (RT_SUCCESS(rc))
661	{
662	if (!DeleteFileW(pwszFilename))
663	rc = RTErrConvertFromWin32(GetLastError());
664	RTUtf16Free(pwszFilename);
665	}
666
667	return rc;
668	#endif
669	}
670
671
672	RTDECL(int) RTFileRename(const char pszSrc, const char pszDst, unsigned fRename)
673	{
674	/*
675	* Validate input.
676	*/
677	AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER);
678	AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER);
679	AssertMsgReturn(!(fRename & ~RTPATHRENAME_FLAGS_REPLACE), ("%#x\n", fRename), VERR_INVALID_PARAMETER);
680
681	/*
682	* Hand it on to the worker.
683	*/
684	int rc = rtPathWin32MoveRename(pszSrc, pszDst,
685	fRename & RTPATHRENAME_FLAGS_REPLACE ? MOVEFILE_REPLACE_EXISTING : 0,
686	RTFS_TYPE_FILE);
687
688	LogFlow(("RTFileMove(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n",
689	pszSrc, pszSrc, pszDst, pszDst, fRename, rc));
690	return rc;
691
692	}
693
694
695	RTDECL(int) RTFileMove(const char pszSrc, const char pszDst, unsigned fMove)
696	{
697	/*
698	* Validate input.
699	*/
700	AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER);
701	AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER);
702	AssertMsgReturn(!(fMove & ~RTFILEMOVE_FLAGS_REPLACE), ("%#x\n", fMove), VERR_INVALID_PARAMETER);
703
704	/*
705	* Hand it on to the worker.
706	*/
707	int rc = rtPathWin32MoveRename(pszSrc, pszDst,
708	fMove & RTFILEMOVE_FLAGS_REPLACE
709	? MOVEFILE_COPY_ALLOWED \| MOVEFILE_REPLACE_EXISTING
710	: MOVEFILE_COPY_ALLOWED,
711	RTFS_TYPE_FILE);
712
713	LogFlow(("RTFileMove(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n",
714	pszSrc, pszSrc, pszDst, pszDst, fMove, rc));
715	return rc;
716	}
717

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

source: vbox/trunk/src/VBox/Runtime/r3/win32/fileio-win32.cpp@ 4495

Download in other formats: