fileio-posix.cpp@ 37596

Last change on this file since 37596 was 37596, checked in by vboxsync, 13 years ago
*: RTFILE becomes a pointer, RTFileOpen++ expands it's flags paramter from uint32_t to uint64_t.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 19.0 KB

Line
1	/* $Id: fileio-posix.cpp 37596 2011-06-22 19:30:06Z vboxsync $ */
2	/** @file
3	* IPRT - File I/O, POSIX, Part 1.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*******************************************************************************
29	* Header Files *
30	*******************************************************************************/
31	#define LOG_GROUP RTLOGGROUP_FILE
32
33	#include <errno.h>
34	#include <sys/stat.h>
35	#include <sys/types.h>
36	#include <sys/ioctl.h>
37	#include <sys/fcntl.h>
38	#include <fcntl.h>
39	#ifdef _MSC_VER
40	# include <io.h>
41	# include <stdio.h>
42	#else
43	# include <unistd.h>
44	# include <sys/time.h>
45	#endif
46	#ifdef RT_OS_LINUX
47	# include <sys/file.h>
48	#endif
49	#if defined(RT_OS_OS2) && (!defined(__INNOTEK_LIBC__) \|\| __INNOTEK_LIBC__ < 0x006)
50	# include <io.h>
51	#endif
52
53	#include <iprt/file.h>
54	#include <iprt/path.h>
55	#include <iprt/assert.h>
56	#include <iprt/string.h>
57	#include <iprt/err.h>
58	#include <iprt/log.h>
59	#include "internal/file.h"
60	#include "internal/fs.h"
61	#include "internal/path.h"
62
63
64
65	/*******************************************************************************
66	* Defined Constants And Macros *
67	*******************************************************************************/
68	/** Default file permissions for newly created files. */
69	#if defined(S_IRUSR) && defined(S_IWUSR)
70	# define RT_FILE_PERMISSION (S_IRUSR \| S_IWUSR)
71	#else
72	# define RT_FILE_PERMISSION (00600)
73	#endif
74
75
76	RTDECL(bool) RTFileExists(const char *pszPath)
77	{
78	bool fRc = false;
79	char const *pszNativePath;
80	int rc = rtPathToNative(&pszNativePath, pszPath, NULL);
81	if (RT_SUCCESS(rc))
82	{
83	struct stat s;
84	fRc = !stat(pszNativePath, &s)
85	&& S_ISREG(s.st_mode);
86
87	rtPathFreeNative(pszNativePath, pszPath);
88	}
89
90	LogFlow(("RTFileExists(%p={%s}): returns %RTbool\n", pszPath, pszPath, fRc));
91	return fRc;
92	}
93
94
95	RTR3DECL(int) RTFileOpen(PRTFILE pFile, const char *pszFilename, uint64_t fOpen)
96	{
97	/*
98	* Validate input.
99	*/
100	AssertPtrReturn(pFile, VERR_INVALID_POINTER);
101	*pFile = NIL_RTFILE;
102	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
103
104	/*
105	* Merge forced open flags and validate them.
106	*/
107	int rc = rtFileRecalcAndValidateFlags(&fOpen);
108	if (RT_FAILURE(rc))
109	return rc;
110	#ifndef O_NONBLOCK
111	if (fOpen & RTFILE_O_NON_BLOCK)
112	{
113	AssertMsgFailed(("Invalid parameters! fOpen=%#llx\n", fOpen));
114	return VERR_INVALID_PARAMETER;
115	}
116	#endif
117
118	/*
119	* Calculate open mode flags.
120	*/
121	int fOpenMode = 0;
122	#ifdef O_BINARY
123	fOpenMode \|= O_BINARY; /* (pc) */
124	#endif
125	#ifdef O_LARGEFILE
126	fOpenMode \|= O_LARGEFILE; /* (linux, solaris) */
127	#endif
128	#ifdef O_NOINHERIT
129	if (!(fOpen & RTFILE_O_INHERIT))
130	fOpenMode \|= O_NOINHERIT;
131	#endif
132	#ifdef O_CLOEXEC
133	static int s_fHave_O_CLOEXEC = 0; /* {-1,0,1}; since Linux 2.6.23 */
134	if (!(fOpen & RTFILE_O_INHERIT) && s_fHave_O_CLOEXEC >= 0)
135	fOpenMode \|= O_CLOEXEC;
136	#endif
137	#ifdef O_NONBLOCK
138	if (fOpen & RTFILE_O_NON_BLOCK)
139	fOpenMode \|= O_NONBLOCK;
140	#endif
141	#ifdef O_SYNC
142	if (fOpen & RTFILE_O_WRITE_THROUGH)
143	fOpenMode \|= O_SYNC;
144	#endif
145	#if defined(O_DIRECT) && defined(RT_OS_LINUX)
146	/* O_DIRECT is mandatory to get async I/O working on Linux. */
147	if (fOpen & RTFILE_O_ASYNC_IO)
148	fOpenMode \|= O_DIRECT;
149	#endif
150	#if defined(O_DIRECT) && (defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD))
151	/* Disable the kernel cache. */
152	if (fOpen & RTFILE_O_NO_CACHE)
153	fOpenMode \|= O_DIRECT;
154	#endif
155
156	/* create/truncate file */
157	switch (fOpen & RTFILE_O_ACTION_MASK)
158	{
159	case RTFILE_O_OPEN: break;
160	case RTFILE_O_OPEN_CREATE: fOpenMode \|= O_CREAT; break;
161	case RTFILE_O_CREATE: fOpenMode \|= O_CREAT \| O_EXCL; break;
162	case RTFILE_O_CREATE_REPLACE: fOpenMode \|= O_CREAT \| O_TRUNC; break; /** @todo replacing needs fixing, this is not a 1:1 mapping! */
163	}
164	if (fOpen & RTFILE_O_TRUNCATE)
165	fOpenMode \|= O_TRUNC;
166
167	switch (fOpen & RTFILE_O_ACCESS_MASK)
168	{
169	case RTFILE_O_READ:
170	fOpenMode \|= O_RDONLY; /* RTFILE_O_APPEND is ignored. */
171	break;
172	case RTFILE_O_WRITE:
173	fOpenMode \|= fOpen & RTFILE_O_APPEND ? O_APPEND \| O_WRONLY : O_WRONLY;
174	break;
175	case RTFILE_O_READWRITE:
176	fOpenMode \|= fOpen & RTFILE_O_APPEND ? O_APPEND \| O_RDWR : O_RDWR;
177	break;
178	default:
179	AssertMsgFailed(("RTFileOpen received an invalid RW value, fOpen=%#llx\n", fOpen));
180	return VERR_INVALID_PARAMETER;
181	}
182
183	/* File mode. */
184	int fMode = (fOpen & RTFILE_O_CREATE_MODE_MASK)
185	? (fOpen & RTFILE_O_CREATE_MODE_MASK) >> RTFILE_O_CREATE_MODE_SHIFT
186	: RT_FILE_PERMISSION;
187
188	/** @todo sharing! */
189
190	/*
191	* Open/create the file.
192	*/
193	char const *pszNativeFilename;
194	rc = rtPathToNative(&pszNativeFilename, pszFilename, NULL);
195	if (RT_FAILURE(rc))
196	return (rc);
197
198	int fh = open(pszNativeFilename, fOpenMode, fMode);
199	int iErr = errno;
200
201	#ifdef O_CLOEXEC
202	if ( (fOpenMode & O_CLOEXEC)
203	&& s_fHave_O_CLOEXEC == 0)
204	{
205	if (fh < 0 && iErr == EINVAL)
206	{
207	s_fHave_O_CLOEXEC = -1;
208	fh = open(pszNativeFilename, fOpenMode, fMode);
209	iErr = errno;
210	}
211	else if (fh >= 0)
212	s_fHave_O_CLOEXEC = fcntl(fh, F_GETFD, 0) > 0 ? 1 : -1;
213	}
214	#endif
215
216	rtPathFreeNative(pszNativeFilename, pszFilename);
217	if (fh >= 0)
218	{
219	iErr = 0;
220
221	/*
222	* Mark the file handle close on exec, unless inherit is specified.
223	*/
224	if ( !(fOpen & RTFILE_O_INHERIT)
225	#ifdef O_NOINHERIT
226	&& !(fOpenMode & O_NOINHERIT) /* Take care since it might be a zero value dummy. */
227	#endif
228	#ifdef O_CLOEXEC
229	&& s_fHave_O_CLOEXEC <= 0
230	#endif
231	)
232	iErr = fcntl(fh, F_SETFD, FD_CLOEXEC) >= 0 ? 0 : errno;
233
234	/*
235	* Switch direct I/O on now if requested and required.
236	*/
237	#if defined(RT_OS_DARWIN) \
238	\|\| (defined(RT_OS_SOLARIS) && !defined(IN_GUEST))
239	if (iErr == 0 && (fOpen & RTFILE_O_NO_CACHE))
240	{
241	# if defined(RT_OS_DARWIN)
242	iErr = fcntl(fh, F_NOCACHE, 1) >= 0 ? 0 : errno;
243	# else
244	iErr = directio(fh, DIRECTIO_ON) >= 0 ? 0 : errno;
245	# endif
246	}
247	#endif
248
249	/*
250	* Implement / emulate file sharing.
251	*
252	* We need another mode which allows skipping this stuff completely
253	* and do things the UNIX way. So for the present this is just a debug
254	* aid that can be enabled by developers too lazy to test on Windows.
255	*/
256	#if 0 && defined(RT_OS_LINUX)
257	if (iErr == 0)
258	{
259	/* This approach doesn't work because only knfsd checks for these
260	buggers. :-( */
261	int iLockOp;
262	switch (fOpen & RTFILE_O_DENY_MASK)
263	{
264	default:
265	AssertFailed();
266	case RTFILE_O_DENY_NONE:
267	case RTFILE_O_DENY_NOT_DELETE:
268	iLockOp = LOCK_MAND \| LOCK_READ \| LOCK_WRITE;
269	break;
270	case RTFILE_O_DENY_READ:
271	case RTFILE_O_DENY_READ \| RTFILE_O_DENY_NOT_DELETE:
272	iLockOp = LOCK_MAND \| LOCK_WRITE;
273	break;
274	case RTFILE_O_DENY_WRITE:
275	case RTFILE_O_DENY_WRITE \| RTFILE_O_DENY_NOT_DELETE:
276	iLockOp = LOCK_MAND \| LOCK_READ;
277	break;
278	case RTFILE_O_DENY_WRITE \| RTFILE_O_DENY_READ:
279	case RTFILE_O_DENY_WRITE \| RTFILE_O_DENY_READ \| RTFILE_O_DENY_NOT_DELETE:
280	iLockOp = LOCK_MAND;
281	break;
282	}
283	iErr = flock(fh, iLockOp \| LOCK_NB);
284	if (iErr != 0)
285	iErr = errno == EAGAIN ? ETXTBSY : 0;
286	}
287	#endif /* 0 && RT_OS_LINUX */
288	#if defined(DEBUG_bird) && !defined(RT_OS_SOLARIS)
289	if (iErr == 0)
290	{
291	/* This emulation is incomplete but useful. */
292	switch (fOpen & RTFILE_O_DENY_MASK)
293	{
294	default:
295	AssertFailed();
296	case RTFILE_O_DENY_NONE:
297	case RTFILE_O_DENY_NOT_DELETE:
298	case RTFILE_O_DENY_READ:
299	case RTFILE_O_DENY_READ \| RTFILE_O_DENY_NOT_DELETE:
300	break;
301	case RTFILE_O_DENY_WRITE:
302	case RTFILE_O_DENY_WRITE \| RTFILE_O_DENY_NOT_DELETE:
303	case RTFILE_O_DENY_WRITE \| RTFILE_O_DENY_READ:
304	case RTFILE_O_DENY_WRITE \| RTFILE_O_DENY_READ \| RTFILE_O_DENY_NOT_DELETE:
305	if (fOpen & RTFILE_O_WRITE)
306	{
307	iErr = flock(fh, LOCK_EX \| LOCK_NB);
308	if (iErr != 0)
309	iErr = errno == EAGAIN ? ETXTBSY : 0;
310	}
311	break;
312	}
313	}
314	#endif
315	#ifdef RT_OS_SOLARIS
316	/** @todo Use fshare_t and associates, it's a perfect match. see sys/fcntl.h */
317	#endif
318
319	/*
320	* We're done.
321	*/
322	if (iErr == 0)
323	{
324	*pFile = (RTFILE)(uintptr_t)fh;
325	Assert((intptr_t)*pFile == fh);
326	LogFlow(("RTFileOpen(%p:{%RTfile}, %p:{%s}, %#llx): returns %Rrc\n",
327	pFile, *pFile, pszFilename, pszFilename, fOpen, rc));
328	return VINF_SUCCESS;
329	}
330
331	close(fh);
332	}
333	return RTErrConvertFromErrno(iErr);
334	}
335
336
337	RTR3DECL(int) RTFileOpenBitBucket(PRTFILE phFile, uint64_t fAccess)
338	{
339	AssertReturn( fAccess == RTFILE_O_READ
340	\|\| fAccess == RTFILE_O_WRITE
341	\|\| fAccess == RTFILE_O_READWRITE,
342	VERR_INVALID_PARAMETER);
343	return RTFileOpen(phFile, "/dev/null", fAccess \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN);
344	}
345
346
347	RTR3DECL(int) RTFileClose(RTFILE hFile)
348	{
349	if (hFile == NIL_RTFILE)
350	return VINF_SUCCESS;
351	if (close(RTFileToNative(hFile)) == 0)
352	return VINF_SUCCESS;
353	return RTErrConvertFromErrno(errno);
354	}
355
356
357	RTR3DECL(int) RTFileFromNative(PRTFILE pFile, RTHCINTPTR uNative)
358	{
359	AssertCompile(sizeof(uNative) == sizeof(*pFile));
360	if (uNative < 0)
361	{
362	AssertMsgFailed(("%p\n", uNative));
363	*pFile = NIL_RTFILE;
364	return VERR_INVALID_HANDLE;
365	}
366	*pFile = (RTFILE)uNative;
367	return VINF_SUCCESS;
368	}
369
370
371	RTR3DECL(RTHCINTPTR) RTFileToNative(RTFILE hFile)
372	{
373	AssertReturn(hFile != NIL_RTFILE, -1);
374	return (intptr_t)hFile;
375	}
376
377
378	RTFILE rtFileGetStandard(RTHANDLESTD enmStdHandle)
379	{
380	int fd;
381	switch (enmStdHandle)
382	{
383	case RTHANDLESTD_INPUT: fd = 0; break;
384	case RTHANDLESTD_OUTPUT: fd = 1; break;
385	case RTHANDLESTD_ERROR: fd = 2; break;
386	break;
387	default:
388	AssertFailedReturn(NIL_RTFILE);
389	}
390
391	struct stat st;
392	int rc = fstat(fd, &st);
393	if (rc == -1)
394	return NIL_RTFILE;
395	return (RTFILE)fd;
396	}
397
398
399	RTR3DECL(int) RTFileDelete(const char *pszFilename)
400	{
401	char const *pszNativeFilename;
402	int rc = rtPathToNative(&pszNativeFilename, pszFilename, NULL);
403	if (RT_SUCCESS(rc))
404	{
405	if (unlink(pszNativeFilename) != 0)
406	rc = RTErrConvertFromErrno(errno);
407	rtPathFreeNative(pszNativeFilename, pszFilename);
408	}
409	return rc;
410	}
411
412
413	RTR3DECL(int) RTFileSeek(RTFILE hFile, int64_t offSeek, unsigned uMethod, uint64_t *poffActual)
414	{
415	static const unsigned aSeekRecode[] =
416	{
417	SEEK_SET,
418	SEEK_CUR,
419	SEEK_END,
420	};
421
422	/*
423	* Validate input.
424	*/
425	if (uMethod > RTFILE_SEEK_END)
426	{
427	AssertMsgFailed(("Invalid uMethod=%d\n", uMethod));
428	return VERR_INVALID_PARAMETER;
429	}
430
431	/* check that within off_t range. */
432	if ( sizeof(off_t) < sizeof(offSeek)
433	&& ( (offSeek > 0 && (unsigned)(offSeek >> 32) != 0)
434	\|\| (offSeek < 0 && (unsigned)(-offSeek >> 32) != 0)))
435	{
436	AssertMsgFailed(("64-bit search not supported\n"));
437	return VERR_NOT_SUPPORTED;
438	}
439
440	off_t offCurrent = lseek(RTFileToNative(hFile), (off_t)offSeek, aSeekRecode[uMethod]);
441	if (offCurrent != ~0)
442	{
443	if (poffActual)
444	*poffActual = (uint64_t)offCurrent;
445	return VINF_SUCCESS;
446	}
447	return RTErrConvertFromErrno(errno);
448	}
449
450
451	RTR3DECL(int) RTFileRead(RTFILE hFile, void pvBuf, size_t cbToRead, size_t pcbRead)
452	{
453	if (cbToRead <= 0)
454	return VINF_SUCCESS;
455
456	/*
457	* Attempt read.
458	*/
459	ssize_t cbRead = read(RTFileToNative(hFile), pvBuf, cbToRead);
460	if (cbRead >= 0)
461	{
462	if (pcbRead)
463	/* caller can handle partial read. */
464	*pcbRead = cbRead;
465	else
466	{
467	/* Caller expects all to be read. */
468	while ((ssize_t)cbToRead > cbRead)
469	{
470	ssize_t cbReadPart = read(RTFileToNative(hFile), (char*)pvBuf + cbRead, cbToRead - cbRead);
471	if (cbReadPart <= 0)
472	{
473	if (cbReadPart == 0)
474	return VERR_EOF;
475	return RTErrConvertFromErrno(errno);
476	}
477	cbRead += cbReadPart;
478	}
479	}
480	return VINF_SUCCESS;
481	}
482
483	return RTErrConvertFromErrno(errno);
484	}
485
486
487	RTR3DECL(int) RTFileWrite(RTFILE hFile, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
488	{
489	if (cbToWrite <= 0)
490	return VINF_SUCCESS;
491
492	/*
493	* Attempt write.
494	*/
495	ssize_t cbWritten = write(RTFileToNative(hFile), pvBuf, cbToWrite);
496	if (cbWritten >= 0)
497	{
498	if (pcbWritten)
499	/* caller can handle partial write. */
500	*pcbWritten = cbWritten;
501	else
502	{
503	/* Caller expects all to be write. */
504	while ((ssize_t)cbToWrite > cbWritten)
505	{
506	ssize_t cbWrittenPart = write(RTFileToNative(hFile), (const char *)pvBuf + cbWritten, cbToWrite - cbWritten);
507	if (cbWrittenPart <= 0)
508	return RTErrConvertFromErrno(errno);
509	cbWritten += cbWrittenPart;
510	}
511	}
512	return VINF_SUCCESS;
513	}
514	return RTErrConvertFromErrno(errno);
515	}
516
517
518	RTR3DECL(int) RTFileSetSize(RTFILE hFile, uint64_t cbSize)
519	{
520	/*
521	* Validate offset.
522	*/
523	if ( sizeof(off_t) < sizeof(cbSize)
524	&& (cbSize >> 32) != 0)
525	{
526	AssertMsgFailed(("64-bit filesize not supported! cbSize=%lld\n", cbSize));
527	return VERR_NOT_SUPPORTED;
528	}
529
530	#if defined(_MSC_VER) \|\| (defined(RT_OS_OS2) && (!defined(__INNOTEK_LIBC__) \|\| __INNOTEK_LIBC__ < 0x006))
531	if (chsize(RTFileToNative(hFile), (off_t)cbSize) == 0)
532	#else
533	/* This relies on a non-standard feature of FreeBSD, Linux, and OS/2
534	* LIBC v0.6 and higher. (SuS doesn't define ftruncate() and size bigger
535	* than the file.)
536	*/
537	if (ftruncate(RTFileToNative(hFile), (off_t)cbSize) == 0)
538	#endif
539	return VINF_SUCCESS;
540	return RTErrConvertFromErrno(errno);
541	}
542
543
544	RTR3DECL(int) RTFileGetSize(RTFILE hFile, uint64_t *pcbSize)
545	{
546	struct stat st;
547	if (!fstat(RTFileToNative(hFile), &st))
548	{
549	*pcbSize = st.st_size;
550	return VINF_SUCCESS;
551	}
552	return RTErrConvertFromErrno(errno);
553	}
554
555
556	RTR3DECL(int) RTFileGetMaxSizeEx(RTFILE hFile, PRTFOFF pcbMax)
557	{
558	/*
559	* Save the current location
560	*/
561	uint64_t offOld;
562	int rc = RTFileSeek(hFile, 0, RTFILE_SEEK_CURRENT, &offOld);
563	if (RT_FAILURE(rc))
564	return rc;
565
566	/*
567	* Perform a binary search for the max file size.
568	*/
569	uint64_t offLow = 0;
570	uint64_t offHigh = 8 * _1T; /* we don't need bigger files */
571	/** @todo Unfortunately this does not work for certain file system types,
572	* for instance cifs mounts. Even worse, statvfs.f_fsid returns 0 for such
573	* file systems. */
574	//uint64_t offHigh = INT64_MAX;
575	for (;;)
576	{
577	uint64_t cbInterval = (offHigh - offLow) >> 1;
578	if (cbInterval == 0)
579	{
580	if (pcbMax)
581	*pcbMax = offLow;
582	return RTFileSeek(hFile, offOld, RTFILE_SEEK_BEGIN, NULL);
583	}
584
585	rc = RTFileSeek(hFile, offLow + cbInterval, RTFILE_SEEK_BEGIN, NULL);
586	if (RT_FAILURE(rc))
587	offHigh = offLow + cbInterval;
588	else
589	offLow = offLow + cbInterval;
590	}
591	}
592
593
594	RTR3DECL(bool) RTFileIsValid(RTFILE hFile)
595	{
596	if (hFile != NIL_RTFILE)
597	{
598	int fFlags = fcntl(RTFileToNative(hFile), F_GETFD);
599	if (fFlags >= 0)
600	return true;
601	}
602	return false;
603	}
604
605
606	RTR3DECL(int) RTFileFlush(RTFILE hFile)
607	{
608	if (fsync(RTFileToNative(hFile)))
609	return RTErrConvertFromErrno(errno);
610	return VINF_SUCCESS;
611	}
612
613
614	RTR3DECL(int) RTFileIoCtl(RTFILE hFile, unsigned long ulRequest, void pvData, unsigned cbData, int piRet)
615	{
616	int rc = ioctl(RTFileToNative(hFile), ulRequest, pvData);
617	if (piRet)
618	*piRet = rc;
619	return rc >= 0 ? VINF_SUCCESS : RTErrConvertFromErrno(errno);
620	}
621
622
623	RTR3DECL(int) RTFileSetMode(RTFILE hFile, RTFMODE fMode)
624	{
625	/*
626	* Normalize the mode and call the API.
627	*/
628	fMode = rtFsModeNormalize(fMode, NULL, 0);
629	if (!rtFsModeIsValid(fMode))
630	return VERR_INVALID_PARAMETER;
631
632	if (fchmod(RTFileToNative(hFile), fMode & RTFS_UNIX_MASK))
633	{
634	int rc = RTErrConvertFromErrno(errno);
635	Log(("RTFileSetMode(%RTfile,%RTfmode): returns %Rrc\n", hFile, fMode, rc));
636	return rc;
637	}
638	return VINF_SUCCESS;
639	}
640
641
642	RTR3DECL(int) RTFileRename(const char pszSrc, const char pszDst, unsigned fRename)
643	{
644	/*
645	* Validate input.
646	*/
647	AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER);
648	AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER);
649	AssertMsgReturn(*pszSrc, ("%p\n", pszSrc), VERR_INVALID_PARAMETER);
650	AssertMsgReturn(*pszDst, ("%p\n", pszDst), VERR_INVALID_PARAMETER);
651	AssertMsgReturn(!(fRename & ~RTPATHRENAME_FLAGS_REPLACE), ("%#x\n", fRename), VERR_INVALID_PARAMETER);
652
653	/*
654	* Take common cause with RTPathRename.
655	*/
656	int rc = rtPathPosixRename(pszSrc, pszDst, fRename, RTFS_TYPE_FILE);
657
658	LogFlow(("RTDirRename(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n",
659	pszSrc, pszSrc, pszDst, pszDst, fRename, rc));
660	return rc;
661	}
662

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

source: vbox/trunk/src/VBox/Runtime/r3/posix/fileio-posix.cpp@ 37596

Download in other formats: