fileio-win32.cpp@ 402

最後變更在這個檔案從402是 1,由 vboxsync 提交於 55 年前
import
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Id`
檔案大小: 21.0 KB

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

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

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

以其他格式下載: