fileio-posix.cpp@ 30111

Last change on this file since 30111 was 29263, checked in by vboxsync, 14 years ago
sparc adjustments.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 21.2 KB

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

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

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

Download in other formats: