fileio-posix.cpp@ 22516

Last change on this file since 22516 was 22516, checked in by vboxsync, 15 years ago
IPRT: Added RTFileExists
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 18.6 KB

Line
1	/* $Id: fileio-posix.cpp 22516 2009-08-27 12:42:16Z vboxsync $ */
2	/** @file
3	* IPRT - File I/O, POSIX.
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_FILE
36
37	#include <errno.h>
38	#include <sys/stat.h>
39	#include <sys/types.h>
40	#include <sys/ioctl.h>
41	#include <sys/fcntl.h>
42	#include <fcntl.h>
43	#ifdef _MSC_VER
44	# include <io.h>
45	# include <stdio.h>
46	#else
47	# include <unistd.h>
48	# include <sys/time.h>
49	#endif
50	#if defined(RT_OS_OS2) && (!defined(__INNOTEK_LIBC__) \|\| __INNOTEK_LIBC__ < 0x006)
51	# include <io.h>
52	#endif
53	#ifdef RT_OS_L4
54	/* This is currently ifdef'ed out in the relevant L4 header file */
55	/* Same as `utimes', but takes an open file descriptor instead of a name. */
56	extern int futimes(int __fd, __const struct timeval __tvp[2]) __THROW;
57	#endif
58
59	#ifdef RT_OS_SOLARIS
60	# define futimes(filedes, timeval) futimesat(filedes, NULL, timeval)
61	#endif
62
63	#include <iprt/file.h>
64	#include <iprt/path.h>
65	#include <iprt/assert.h>
66	#include <iprt/string.h>
67	#include <iprt/err.h>
68	#include <iprt/log.h>
69	#include "internal/file.h"
70	#include "internal/fs.h"
71	#include "internal/path.h"
72
73
74
75	/*******************************************************************************
76	* Defined Constants And Macros *
77	*******************************************************************************/
78	/** @def RT_DONT_CONVERT_FILENAMES
79	* Define this to pass UTF-8 unconverted to the kernel. */
80	#ifdef __DOXYGEN__
81	#define RT_DONT_CONVERT_FILENAMES 1
82	#endif
83
84	/** Default file permissions for newly created files. */
85	#if defined(S_IRUSR) && defined(S_IWUSR)
86	# define RT_FILE_PERMISSION (S_IRUSR \| S_IWUSR)
87	#else
88	# define RT_FILE_PERMISSION (00600)
89	#endif
90
91
92	RTDECL(bool) RTFileExists(const char *pszPath)
93	{
94	bool fRc = false;
95	char *pszNativePath;
96	int rc = rtPathToNative(&pszNativePath, pszPath);
97	if (RT_SUCCESS(rc))
98	{
99	struct stat s;
100	fRc = !stat(pszNativePath, &s)
101	&& S_ISREG(s.st_mode);
102
103	rtPathFreeNative(pszNativePath);
104	}
105
106	LogFlow(("RTFileExists(%p={%s}): returns %RTbool\n", pszPath, pszPath, fRc));
107	return fRc;
108	}
109
110
111	RTR3DECL(int) RTFileOpen(PRTFILE pFile, const char *pszFilename, unsigned fOpen)
112	{
113	/*
114	* Validate input.
115	*/
116	if (!VALID_PTR(pFile))
117	{
118	AssertMsgFailed(("Invalid pFile %p\n", pFile));
119	return VERR_INVALID_PARAMETER;
120	}
121	*pFile = NIL_RTFILE;
122	if (!VALID_PTR(pszFilename))
123	{
124	AssertMsgFailed(("Invalid pszFilename %p\n", pszFilename));
125	return VERR_INVALID_PARAMETER;
126	}
127
128	/*
129	* Merge forced open flags and validate them.
130	*/
131	int rc = rtFileRecalcAndValidateFlags(&fOpen);
132	if (RT_FAILURE(rc))
133	return rc;
134	#ifndef O_NONBLOCK
135	if (fOpen & RTFILE_O_NON_BLOCK)
136	{
137	AssertMsgFailed(("Invalid parameters! fOpen=%#x\n", fOpen));
138	return VERR_INVALID_PARAMETER;
139	}
140	#endif
141
142	/*
143	* Calculate open mode flags.
144	*/
145	int fOpenMode = 0;
146	#ifdef O_BINARY
147	fOpenMode \|= O_BINARY; /* (pc) */
148	#endif
149	#ifdef O_LARGEFILE
150	fOpenMode \|= O_LARGEFILE; /* (linux) */
151	#endif
152	#ifdef O_NOINHERIT
153	if (!(fOpen & RTFILE_O_INHERIT))
154	fOpenMode \|= O_NOINHERIT;
155	#endif
156	#ifdef O_NONBLOCK
157	if (fOpen & RTFILE_O_NON_BLOCK)
158	fOpenMode \|= O_NONBLOCK;
159	#endif
160	#ifdef O_SYNC
161	if (fOpen & RTFILE_O_WRITE_THROUGH)
162	fOpenMode \|= O_SYNC;
163	#endif
164	#if defined(O_DIRECT) && defined(RT_OS_LINUX)
165	/* O_DIRECT is mandatory to get async I/O working on Linux. */
166	if (fOpen & RTFILE_O_ASYNC_IO)
167	fOpenMode \|= O_DIRECT;
168	#endif
169	#if defined(O_DIRECT) && (defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD))
170	/* Disable the kernel cache. */
171	if (fOpen & RTFILE_O_NO_CACHE)
172	fOpenMode \|= O_DIRECT;
173	#endif
174
175	/* create/truncate file */
176	switch (fOpen & RTFILE_O_ACTION_MASK)
177	{
178	case RTFILE_O_OPEN: break;
179	case RTFILE_O_OPEN_CREATE: fOpenMode \|= O_CREAT; break;
180	case RTFILE_O_CREATE: fOpenMode \|= O_CREAT \| O_EXCL; break;
181	case RTFILE_O_CREATE_REPLACE: fOpenMode \|= O_CREAT \| O_TRUNC; break; /** @todo replacing needs fixing, this is not a 1:1 mapping! */
182	}
183	if (fOpen & RTFILE_O_TRUNCATE)
184	fOpenMode \|= O_TRUNC;
185
186	switch (fOpen & RTFILE_O_ACCESS_MASK)
187	{
188	case RTFILE_O_READ:
189	fOpenMode \|= O_RDONLY; /* RTFILE_O_APPEND is ignored. */
190	break;
191	case RTFILE_O_WRITE:
192	fOpenMode \|= fOpen & RTFILE_O_APPEND ? O_APPEND \| O_WRONLY : O_WRONLY;
193	break;
194	case RTFILE_O_READWRITE:
195	fOpenMode \|= fOpen & RTFILE_O_APPEND ? O_APPEND \| O_RDWR : O_RDWR;
196	break;
197	default:
198	AssertMsgFailed(("RTFileOpen received an invalid RW value, fOpen=%#x\n", fOpen));
199	return VERR_INVALID_PARAMETER;
200	}
201
202	/* File mode. */
203	int fMode = (fOpen & RTFILE_O_CREATE_MODE_MASK)
204	? (fOpen & RTFILE_O_CREATE_MODE_MASK) >> RTFILE_O_CREATE_MODE_SHIFT
205	: RT_FILE_PERMISSION;
206
207	/** @todo sharing! */
208
209	/*
210	* Open/create the file.
211	*/
212	#ifdef RT_DONT_CONVERT_FILENAMES
213	int fh = open(pszFilename, fOpenMode, fMode);
214	int iErr = errno;
215	#else
216	char *pszNativeFilename;
217	rc = rtPathToNative(&pszNativeFilename, pszFilename);
218	if (RT_FAILURE(rc))
219	return (rc);
220
221	int fh = open(pszNativeFilename, fOpenMode, fMode);
222	int iErr = errno;
223	rtPathFreeNative(pszNativeFilename);
224	#endif
225	if (fh >= 0)
226	{
227	/*
228	* Mark the file handle close on exec, unless inherit is specified.
229	*/
230	if ( !(fOpen & RTFILE_O_INHERIT)
231	#ifdef O_NOINHERIT
232	\|\| (fOpenMode & O_NOINHERIT) /* careful since it could be a dummy. */
233	#endif
234	\|\| fcntl(fh, F_SETFD, FD_CLOEXEC) >= 0)
235	{
236	#if defined(RT_OS_SOLARIS) \|\| defined(RT_OS_DARWIN)
237	iErr = 0;
238	/* Switch direct I/O on now if requested */
239	# if defined(RT_OS_SOLARIS) && !defined(IN_GUEST)
240	if (fOpen & RTFILE_O_NO_CACHE)
241	iErr = directio(fh, DIRECTIO_ON);
242	# elif defined(RT_OS_DARWIN)
243	if (fOpen & RTFILE_O_NO_CACHE)
244	iErr = fcntl(fh, F_NOCACHE);
245	# endif
246	if (iErr < 0)
247	iErr = errno;
248	else
249	#endif
250	{
251	*pFile = (RTFILE)fh;
252	Assert((int)*pFile == fh);
253	LogFlow(("RTFileOpen(%p:{%RTfile}, %p:{%s}, %#x): returns %Rrc\n",
254	pFile, *pFile, pszFilename, pszFilename, fOpen, rc));
255	return VINF_SUCCESS;
256	}
257	}
258	iErr = errno;
259	close(fh);
260	}
261	return RTErrConvertFromErrno(iErr);
262	}
263
264
265	RTR3DECL(int) RTFileClose(RTFILE File)
266	{
267	if (close((int)File) == 0)
268	return VINF_SUCCESS;
269	return RTErrConvertFromErrno(errno);
270	}
271
272
273	RTR3DECL(int) RTFileFromNative(PRTFILE pFile, RTHCINTPTR uNative)
274	{
275	if ( uNative < 0
276	\|\| (RTFILE)uNative != (RTUINTPTR)uNative)
277	{
278	AssertMsgFailed(("%p\n", uNative));
279	*pFile = NIL_RTFILE;
280	return VERR_INVALID_HANDLE;
281	}
282	*pFile = (RTFILE)uNative;
283	return VINF_SUCCESS;
284	}
285
286
287	RTR3DECL(RTHCINTPTR) RTFileToNative(RTFILE File)
288	{
289	AssertReturn(File != NIL_RTFILE, -1);
290	return (RTHCINTPTR)File;
291	}
292
293
294	RTR3DECL(int) RTFileDelete(const char *pszFilename)
295	{
296	char *pszNativeFilename;
297	int rc = rtPathToNative(&pszNativeFilename, pszFilename);
298	if (RT_SUCCESS(rc))
299	{
300	if (unlink(pszNativeFilename) != 0)
301	rc = RTErrConvertFromErrno(errno);
302	rtPathFreeNative(pszNativeFilename);
303	}
304	return rc;
305	}
306
307
308	RTR3DECL(int) RTFileSeek(RTFILE File, int64_t offSeek, unsigned uMethod, uint64_t *poffActual)
309	{
310	static const unsigned aSeekRecode[] =
311	{
312	SEEK_SET,
313	SEEK_CUR,
314	SEEK_END,
315	};
316
317	/*
318	* Validate input.
319	*/
320	if (uMethod > RTFILE_SEEK_END)
321	{
322	AssertMsgFailed(("Invalid uMethod=%d\n", uMethod));
323	return VERR_INVALID_PARAMETER;
324	}
325
326	/* check that within off_t range. */
327	if ( sizeof(off_t) < sizeof(offSeek)
328	&& ( (offSeek > 0 && (unsigned)(offSeek >> 32) != 0)
329	\|\| (offSeek < 0 && (unsigned)(-offSeek >> 32) != 0)))
330	{
331	AssertMsgFailed(("64-bit search not supported\n"));
332	return VERR_NOT_SUPPORTED;
333	}
334
335	off_t offCurrent = lseek((int)File, (off_t)offSeek, aSeekRecode[uMethod]);
336	if (offCurrent != ~0)
337	{
338	if (poffActual)
339	*poffActual = (uint64_t)offCurrent;
340	return VINF_SUCCESS;
341	}
342	return RTErrConvertFromErrno(errno);
343	}
344
345
346	RTR3DECL(int) RTFileRead(RTFILE File, void pvBuf, size_t cbToRead, size_t pcbRead)
347	{
348	if (cbToRead <= 0)
349	return VINF_SUCCESS;
350
351	/*
352	* Attempt read.
353	*/
354	ssize_t cbRead = read((int)File, pvBuf, cbToRead);
355	if (cbRead >= 0)
356	{
357	if (pcbRead)
358	/* caller can handle partial read. */
359	*pcbRead = cbRead;
360	else
361	{
362	/* Caller expects all to be read. */
363	while ((ssize_t)cbToRead > cbRead)
364	{
365	ssize_t cbReadPart = read((int)File, (char*)pvBuf + cbRead, cbToRead - cbRead);
366	if (cbReadPart <= 0)
367	{
368	if (cbReadPart == 0)
369	return VERR_EOF;
370	return RTErrConvertFromErrno(errno);
371	}
372	cbRead += cbReadPart;
373	}
374	}
375	return VINF_SUCCESS;
376	}
377
378	return RTErrConvertFromErrno(errno);
379	}
380
381
382	RTR3DECL(int) RTFileWrite(RTFILE File, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
383	{
384	if (cbToWrite <= 0)
385	return VINF_SUCCESS;
386
387	/*
388	* Attempt write.
389	*/
390	ssize_t cbWritten = write((int)File, pvBuf, cbToWrite);
391	if (cbWritten >= 0)
392	{
393	if (pcbWritten)
394	/* caller can handle partial write. */
395	*pcbWritten = cbWritten;
396	else
397	{
398	/* Caller expects all to be write. */
399	while ((ssize_t)cbToWrite > cbWritten)
400	{
401	ssize_t cbWrittenPart = write((int)File, (const char *)pvBuf + cbWritten, cbToWrite - cbWritten);
402	if (cbWrittenPart <= 0)
403	return RTErrConvertFromErrno(errno);
404	cbWritten += cbWrittenPart;
405	}
406	}
407	return VINF_SUCCESS;
408	}
409	return RTErrConvertFromErrno(errno);
410	}
411
412
413	RTR3DECL(int) RTFileSetSize(RTFILE File, uint64_t cbSize)
414	{
415	/*
416	* Validate offset.
417	*/
418	if ( sizeof(off_t) < sizeof(cbSize)
419	&& (cbSize >> 32) != 0)
420	{
421	AssertMsgFailed(("64-bit filesize not supported! cbSize=%lld\n", cbSize));
422	return VERR_NOT_SUPPORTED;
423	}
424
425	#if defined(_MSC_VER) \|\| (defined(RT_OS_OS2) && (!defined(__INNOTEK_LIBC__) \|\| __INNOTEK_LIBC__ < 0x006))
426	if (chsize((int)File, (off_t)cbSize) == 0)
427	#else
428	/* This relies on a non-standard feature of FreeBSD, Linux, and OS/2
429	* LIBC v0.6 and higher. (SuS doesn't define ftruncate() and size bigger
430	* than the file.)
431	*/
432	if (ftruncate((int)File, (off_t)cbSize) == 0)
433	#endif
434	return VINF_SUCCESS;
435	return RTErrConvertFromErrno(errno);
436	}
437
438
439	RTR3DECL(int) RTFileGetSize(RTFILE File, uint64_t *pcbSize)
440	{
441	struct stat st;
442	if (!fstat((int)File, &st))
443	{
444	*pcbSize = st.st_size;
445	return VINF_SUCCESS;
446	}
447	return RTErrConvertFromErrno(errno);
448	}
449
450
451	/**
452	* Determine the maximum file size.
453	*
454	* @returns IPRT status code.
455	* @param File Handle to the file.
456	* @param pcbMax Where to store the max file size.
457	* @see RTFileGetMaxSize.
458	*/
459	RTR3DECL(int) RTFileGetMaxSizeEx(RTFILE File, PRTFOFF pcbMax)
460	{
461	/*
462	* Save the current location
463	*/
464	uint64_t offOld;
465	int rc = RTFileSeek(File, 0, RTFILE_SEEK_CURRENT, &offOld);
466	if (RT_FAILURE(rc))
467	return rc;
468
469	/*
470	* Perform a binary search for the max file size.
471	*/
472	uint64_t offLow = 0;
473	uint64_t offHigh = 8 * _1T; /* we don't need bigger files */
474	/** @todo Unfortunately this does not work for certain file system types,
475	* for instance cifs mounts. Even worse, statvfs.f_fsid returns 0 for such
476	* file systems. */
477	//uint64_t offHigh = INT64_MAX;
478	for (;;)
479	{
480	uint64_t cbInterval = (offHigh - offLow) >> 1;
481	if (cbInterval == 0)
482	{
483	if (pcbMax)
484	*pcbMax = offLow;
485	return RTFileSeek(File, offOld, RTFILE_SEEK_BEGIN, NULL);
486	}
487
488	rc = RTFileSeek(File, offLow + cbInterval, RTFILE_SEEK_BEGIN, NULL);
489	if (RT_FAILURE(rc))
490	offHigh = offLow + cbInterval;
491	else
492	offLow = offLow + cbInterval;
493	}
494	}
495
496
497	RTR3DECL(bool) RTFileIsValid(RTFILE File)
498	{
499	if (File != NIL_RTFILE)
500	{
501	int fFlags = fcntl(File, F_GETFD);
502	if (fFlags >= 0)
503	return true;
504	}
505	return false;
506	}
507
508
509	RTR3DECL(int) RTFileFlush(RTFILE File)
510	{
511	if (fsync((int)File))
512	return RTErrConvertFromErrno(errno);
513	return VINF_SUCCESS;
514	}
515
516
517	RTR3DECL(int) RTFileIoCtl(RTFILE File, int iRequest, void pvData, unsigned cbData, int piRet)
518	{
519	int rc = ioctl((int)File, iRequest, pvData);
520	if (piRet)
521	*piRet = rc;
522	return rc >= 0 ? VINF_SUCCESS : RTErrConvertFromErrno(errno);
523	}
524
525
526	RTR3DECL(int) RTFileQueryInfo(RTFILE File, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
527	{
528	/*
529	* Validate input.
530	*/
531	if (File == NIL_RTFILE)
532	{
533	AssertMsgFailed(("Invalid File=%RTfile\n", File));
534	return VERR_INVALID_PARAMETER;
535	}
536	if (!pObjInfo)
537	{
538	AssertMsgFailed(("Invalid pObjInfo=%p\n", pObjInfo));
539	return VERR_INVALID_PARAMETER;
540	}
541	if ( enmAdditionalAttribs < RTFSOBJATTRADD_NOTHING
542	\|\| enmAdditionalAttribs > RTFSOBJATTRADD_LAST)
543	{
544	AssertMsgFailed(("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs));
545	return VERR_INVALID_PARAMETER;
546	}
547
548	/*
549	* Query file info.
550	*/
551	struct stat Stat;
552	if (fstat((int)File, &Stat))
553	{
554	int rc = RTErrConvertFromErrno(errno);
555	Log(("RTFileQueryInfo(%RTfile,,%d): returns %Rrc\n", File, enmAdditionalAttribs, rc));
556	return rc;
557	}
558
559	/*
560	* Setup the returned data.
561	*/
562	rtFsConvertStatToObjInfo(pObjInfo, &Stat, NULL, 0);
563
564	/*
565	* Requested attributes (we cannot provide anything actually).
566	*/
567	switch (enmAdditionalAttribs)
568	{
569	case RTFSOBJATTRADD_EASIZE:
570	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
571	pObjInfo->Attr.u.EASize.cb = 0;
572	break;
573
574	case RTFSOBJATTRADD_NOTHING:
575	case RTFSOBJATTRADD_UNIX:
576	/* done */
577	break;
578
579	default:
580	AssertMsgFailed(("Impossible!\n"));
581	return VERR_INTERNAL_ERROR;
582	}
583
584	LogFlow(("RTFileQueryInfo(%RTfile,,%d): returns VINF_SUCCESS\n", File, enmAdditionalAttribs));
585	return VINF_SUCCESS;
586	}
587
588
589	RTR3DECL(int) RTFileSetTimes(RTFILE File, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
590	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
591	{
592	/*
593	* We can only set AccessTime and ModificationTime, so if neither
594	* are specified we can return immediately.
595	*/
596	if (!pAccessTime && !pModificationTime)
597	return VINF_SUCCESS;
598
599	/*
600	* Convert the input to timeval, getting the missing one if necessary,
601	* and call the API which does the change.
602	*/
603	struct timeval aTimevals[2];
604	if (pAccessTime && pModificationTime)
605	{
606	RTTimeSpecGetTimeval(pAccessTime, &aTimevals[0]);
607	RTTimeSpecGetTimeval(pModificationTime, &aTimevals[1]);
608	}
609	else
610	{
611	RTFSOBJINFO ObjInfo;
612	int rc = RTFileQueryInfo(File, &ObjInfo, RTFSOBJATTRADD_UNIX);
613	if (RT_FAILURE(rc))
614	return rc;
615	RTTimeSpecGetTimeval(pAccessTime ? pAccessTime : &ObjInfo.AccessTime, &aTimevals[0]);
616	RTTimeSpecGetTimeval(pModificationTime ? pModificationTime : &ObjInfo.ModificationTime, &aTimevals[1]);
617	}
618
619	if (futimes((int)File, aTimevals))
620	{
621	int rc = RTErrConvertFromErrno(errno);
622	Log(("RTFileSetTimes(%RTfile,%p,%p,,): returns %Rrc\n", File, pAccessTime, pModificationTime, rc));
623	return rc;
624	}
625	return VINF_SUCCESS;
626	}
627
628
629	RTR3DECL(int) RTFileSetMode(RTFILE File, RTFMODE fMode)
630	{
631	/*
632	* Normalize the mode and call the API.
633	*/
634	fMode = rtFsModeNormalize(fMode, NULL, 0);
635	if (!rtFsModeIsValid(fMode))
636	return VERR_INVALID_PARAMETER;
637
638	if (fchmod((int)File, fMode & RTFS_UNIX_MASK))
639	{
640	int rc = RTErrConvertFromErrno(errno);
641	Log(("RTFileSetMode(%RTfile,%RTfmode): returns %Rrc\n", File, fMode, rc));
642	return rc;
643	}
644	return VINF_SUCCESS;
645	}
646
647
648	RTR3DECL(int) RTFileRename(const char pszSrc, const char pszDst, unsigned fRename)
649	{
650	/*
651	* Validate input.
652	*/
653	AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER);
654	AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER);
655	AssertMsgReturn(*pszSrc, ("%p\n", pszSrc), VERR_INVALID_PARAMETER);
656	AssertMsgReturn(*pszDst, ("%p\n", pszDst), VERR_INVALID_PARAMETER);
657	AssertMsgReturn(!(fRename & ~RTPATHRENAME_FLAGS_REPLACE), ("%#x\n", fRename), VERR_INVALID_PARAMETER);
658
659	/*
660	* Take common cause with RTPathRename.
661	*/
662	int rc = rtPathPosixRename(pszSrc, pszDst, fRename, RTFS_TYPE_FILE);
663
664	LogFlow(("RTDirRename(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n",
665	pszSrc, pszSrc, pszDst, pszDst, fRename, rc));
666	return rc;
667	}
668
669

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

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

Download in other formats: