path-posix.cpp@ 33889

Last change on this file since 33889 was 33602, checked in by vboxsync, 14 years ago
IPRT/r3/posix: Split out RTPathUserHome and the process creation APIs into separate files to avoid linker warnings on linux when linking statically.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 27.3 KB

Line
1	/* $Id: path-posix.cpp 33602 2010-10-29 12:39:54Z vboxsync $ */
2	/** @file
3	* IPRT - Path Manipulation, 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_PATH
32	#include <stdlib.h>
33	#include <limits.h>
34	#include <errno.h>
35	#include <unistd.h>
36	#include <sys/stat.h>
37	#include <sys/time.h>
38	#include <stdio.h>
39	#include <sys/types.h>
40	#include <pwd.h>
41
42	#include <iprt/path.h>
43	#include <iprt/env.h>
44	#include <iprt/assert.h>
45	#include <iprt/string.h>
46	#include <iprt/err.h>
47	#include <iprt/log.h>
48	#include "internal/path.h"
49	#include "internal/process.h"
50	#include "internal/fs.h"
51
52	#ifdef RT_OS_L4
53	# include <l4/vboxserver/vboxserver.h>
54	#endif
55
56
57
58
59	RTDECL(int) RTPathReal(const char pszPath, char pszRealPath, size_t cchRealPath)
60	{
61	/*
62	* Convert input.
63	*/
64	char const *pszNativePath;
65	int rc = rtPathToNative(&pszNativePath, pszPath, NULL);
66	if (RT_SUCCESS(rc))
67	{
68	/*
69	* On POSIX platforms the API doesn't take a length parameter, which makes it
70	* a little bit more work.
71	*/
72	char szTmpPath[PATH_MAX + 1];
73	const char *psz = realpath(pszNativePath, szTmpPath);
74	if (psz)
75	rc = rtPathFromNativeCopy(pszRealPath, cchRealPath, szTmpPath, NULL);
76	else
77	rc = RTErrConvertFromErrno(errno);
78	rtPathFreeNative(pszNativePath, pszPath);
79	}
80
81	LogFlow(("RTPathReal(%p:{%s}, %p:{%s}, %u): returns %Rrc\n", pszPath, pszPath,
82	pszRealPath, RT_SUCCESS(rc) ? pszRealPath : "<failed>", cchRealPath));
83	return rc;
84	}
85
86
87	/**
88	* Cleans up a path specifier a little bit.
89	* This includes removing duplicate slashes, unnecessary single dots, and
90	* trailing slashes. Also, replaces all RTPATH_SLASH characters with '/'.
91	*
92	* @returns Number of bytes in the clean path.
93	* @param pszPath The path to cleanup.
94	*/
95	static int fsCleanPath(char *pszPath)
96	{
97	/*
98	* Change to '/' and remove duplicates.
99	*/
100	char *pszSrc = pszPath;
101	char *pszTrg = pszPath;
102	#ifdef HAVE_UNC
103	int fUnc = 0;
104	if ( RTPATH_IS_SLASH(pszPath[0])
105	&& RTPATH_IS_SLASH(pszPath[1]))
106	{ /* Skip first slash in a unc path. */
107	pszSrc++;
108	*pszTrg++ = '/';
109	fUnc = 1;
110	}
111	#endif
112
113	for (;;)
114	{
115	char ch = *pszSrc++;
116	if (RTPATH_IS_SLASH(ch))
117	{
118	*pszTrg++ = '/';
119	for (;;)
120	{
121	do ch = *pszSrc++;
122	while (RTPATH_IS_SLASH(ch));
123
124	/* Remove '/./' and '/.'. */
125	if (ch != '.' \|\| (pszSrc && !RTPATH_IS_SLASH(pszSrc)))
126	break;
127	}
128	}
129	*pszTrg = ch;
130	if (!ch)
131	break;
132	pszTrg++;
133	}
134
135	/*
136	* Remove trailing slash if the path may be pointing to a directory.
137	*/
138	int cch = pszTrg - pszPath;
139	if ( cch > 1
140	&& RTPATH_IS_SLASH(pszTrg[-1])
141	#ifdef HAVE_DRIVE
142	&& !RTPATH_IS_VOLSEP(pszTrg[-2])
143	#endif
144	&& !RTPATH_IS_SLASH(pszTrg[-2]))
145	pszPath[--cch] = '\0';
146
147	return cch;
148	}
149
150
151	RTDECL(int) RTPathAbs(const char pszPath, char pszAbsPath, size_t cchAbsPath)
152	{
153	int rc;
154
155	/*
156	* Validation.
157	*/
158	AssertPtr(pszAbsPath);
159	AssertPtr(pszPath);
160	if (RT_UNLIKELY(!*pszPath))
161	return VERR_INVALID_PARAMETER;
162
163	/*
164	* Make a clean working copy of the input.
165	*/
166	size_t cchPath = strlen(pszPath);
167	if (cchPath > PATH_MAX)
168	{
169	LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath, pszPath, pszAbsPath, cchAbsPath, VERR_FILENAME_TOO_LONG));
170	return VERR_FILENAME_TOO_LONG;
171	}
172
173	char szTmpPath[PATH_MAX + 1];
174	memcpy(szTmpPath, pszPath, cchPath + 1);
175	size_t cchTmpPath = fsCleanPath(szTmpPath);
176
177	/*
178	* Handle "." specially (fsCleanPath does).
179	*/
180	if (szTmpPath[0] == '.' && !szTmpPath[1])
181	return RTPathGetCurrent(pszAbsPath, cchAbsPath);
182
183	/*
184	* Do we have a root slash?
185	*/
186	char *pszCur = szTmpPath;
187	#ifdef HAVE_DRIVE
188	if (pszCur[0] && RTPATH_IS_VOLSEP(pszCur[1]) && pszCur[2] == '/')
189	pszCur += 3;
190	# ifdef HAVE_UNC
191	else if (pszCur[0] == '/' && pszCur[1] == '/')
192	pszCur += 2;
193	# endif
194	#else /* !HAVE_DRIVE */
195	if (pszCur[0] == '/')
196	pszCur += 1;
197	#endif /* !HAVE_DRIVE */
198	else
199	{
200	/*
201	* No, prepend the current directory to the relative path.
202	*/
203	char szCurDir[RTPATH_MAX];
204	rc = RTPathGetCurrent(szCurDir, sizeof(szCurDir));
205	AssertRCReturn(rc, rc);
206
207	size_t cchCurDir = fsCleanPath(szCurDir); /* paranoia */
208	if (cchCurDir + cchTmpPath + 1 > PATH_MAX)
209	{
210	LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath, pszPath, pszAbsPath, cchAbsPath, VERR_FILENAME_TOO_LONG));
211	return VERR_FILENAME_TOO_LONG;
212	}
213
214	memmove(szTmpPath + cchCurDir + 1, szTmpPath, cchTmpPath + 1);
215	memcpy(szTmpPath, szCurDir, cchCurDir);
216	szTmpPath[cchCurDir] = '/';
217
218
219	#ifdef HAVE_DRIVE
220	if (pszCur[0] && RTPATH_IS_VOLSEP(pszCur[1]) && pszCur[2] == '/')
221	pszCur += 3;
222	# ifdef HAVE_UNC
223	else if (pszCur[0] == '/' && pszCur[1] == '/')
224	pszCur += 2;
225	# endif
226	#else
227	if (pszCur[0] == '/')
228	pszCur += 1;
229	#endif
230	else
231	AssertMsgFailedReturn(("pszCur=%s\n", pszCur), VERR_INTERNAL_ERROR);
232	}
233
234	char *pszTop = pszCur;
235
236	/*
237	* Get rid of double dot path components by evaluating them.
238	*/
239	for (;;)
240	{
241	if ( pszCur[0] == '.'
242	&& pszCur[1] == '.'
243	&& (!pszCur[2] \|\| pszCur[2] == '/'))
244	{
245	/* rewind to the previous component if any */
246	char *pszPrev = pszCur - 1;
247	if (pszPrev > pszTop)
248	while (*--pszPrev != '/')
249	;
250
251	AssertMsg(*pszPrev == '/', ("szTmpPath={%s}, pszPrev=+%u\n", szTmpPath, pszPrev - szTmpPath));
252	memmove(pszPrev, pszCur + 2, strlen(pszCur + 2) + 1);
253
254	pszCur = pszPrev;
255	}
256	else
257	{
258	/* advance to end of component. */
259	while (pszCur && pszCur != '/')
260	pszCur++;
261	}
262
263	if (!*pszCur)
264	break;
265
266	/* skip the slash */
267	++pszCur;
268	}
269
270	if (pszCur < pszTop)
271	{
272	/*
273	* We overwrote the root slash with '\0', restore it.
274	*/
275	*pszCur++ = '/';
276	*pszCur = '\0';
277	}
278	else if (pszCur > pszTop && pszCur[-1] == '/')
279	{
280	/*
281	* Extra trailing slash in a non-root path, remove it.
282	* (A bit questionable...)
283	*/
284	*--pszCur = '\0';
285	}
286
287	/*
288	* Copy the result to the user buffer.
289	*/
290	cchTmpPath = pszCur - szTmpPath;
291	if (cchTmpPath < cchAbsPath)
292	{
293	memcpy(pszAbsPath, szTmpPath, cchTmpPath + 1);
294	rc = VINF_SUCCESS;
295	}
296	else
297	rc = VERR_BUFFER_OVERFLOW;
298
299	LogFlow(("RTPathAbs(%p:{%s}, %p:{%s}, %d): returns %Rrc\n", pszPath, pszPath, pszAbsPath,
300	RT_SUCCESS(rc) ? pszAbsPath : "<failed>", cchAbsPath, rc));
301	return rc;
302	}
303
304
305	RTR3DECL(int) RTPathQueryInfo(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
306	{
307	return RTPathQueryInfoEx(pszPath, pObjInfo, enmAdditionalAttribs, RTPATH_F_ON_LINK);
308	}
309
310
311	RTR3DECL(int) RTPathQueryInfoEx(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags)
312	{
313	/*
314	* Validate input.
315	*/
316	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
317	AssertReturn(*pszPath, VERR_INVALID_PARAMETER);
318	AssertPtrReturn(pObjInfo, VERR_INVALID_POINTER);
319	AssertMsgReturn( enmAdditionalAttribs >= RTFSOBJATTRADD_NOTHING
320	&& enmAdditionalAttribs <= RTFSOBJATTRADD_LAST,
321	("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs),
322	VERR_INVALID_PARAMETER);
323	AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
324
325	/*
326	* Convert the filename.
327	*/
328	char const *pszNativePath;
329	int rc = rtPathToNative(&pszNativePath, pszPath, NULL);
330	if (RT_SUCCESS(rc))
331	{
332	struct stat Stat;
333	if (fFlags & RTPATH_F_FOLLOW_LINK)
334	rc = stat(pszNativePath, &Stat);
335	else
336	rc = lstat(pszNativePath, &Stat); /** @todo how doesn't have lstat again? */
337	if (!rc)
338	{
339	rtFsConvertStatToObjInfo(pObjInfo, &Stat, pszPath, 0);
340	switch (enmAdditionalAttribs)
341	{
342	case RTFSOBJATTRADD_EASIZE:
343	/** @todo Use SGI extended attribute interface to query EA info. */
344	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
345	pObjInfo->Attr.u.EASize.cb = 0;
346	break;
347
348	case RTFSOBJATTRADD_NOTHING:
349	case RTFSOBJATTRADD_UNIX:
350	Assert(pObjInfo->Attr.enmAdditional == RTFSOBJATTRADD_UNIX);
351	break;
352
353	default:
354	AssertMsgFailed(("Impossible!\n"));
355	return VERR_INTERNAL_ERROR;
356	}
357	}
358	else
359	rc = RTErrConvertFromErrno(errno);
360	rtPathFreeNative(pszNativePath, pszPath);
361	}
362
363	LogFlow(("RTPathQueryInfo(%p:{%s}, pObjInfo=%p, %d): returns %Rrc\n",
364	pszPath, pszPath, pObjInfo, enmAdditionalAttribs, rc));
365	return rc;
366	}
367
368
369	RTR3DECL(int) RTPathSetTimes(const char *pszPath, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
370	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
371	{
372	return RTPathSetTimesEx(pszPath, pAccessTime, pModificationTime, pChangeTime, pBirthTime, RTPATH_F_ON_LINK);
373	}
374
375
376	RTR3DECL(int) RTPathSetTimesEx(const char *pszPath, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
377	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime, uint32_t fFlags)
378	{
379	/*
380	* Validate input.
381	*/
382	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
383	AssertReturn(*pszPath, VERR_INVALID_PARAMETER);
384	AssertPtrNullReturn(pAccessTime, VERR_INVALID_POINTER);
385	AssertPtrNullReturn(pModificationTime, VERR_INVALID_POINTER);
386	AssertPtrNullReturn(pChangeTime, VERR_INVALID_POINTER);
387	AssertPtrNullReturn(pBirthTime, VERR_INVALID_POINTER);
388	AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
389
390	/*
391	* Convert the paths.
392	*/
393	char const *pszNativePath;
394	int rc = rtPathToNative(&pszNativePath, pszPath, NULL);
395	if (RT_SUCCESS(rc))
396	{
397	RTFSOBJINFO ObjInfo;
398
399	/*
400	* If it's a no-op, we'll only verify the existance of the file.
401	*/
402	if (!pAccessTime && !pModificationTime)
403	rc = RTPathQueryInfoEx(pszPath, &ObjInfo, RTFSOBJATTRADD_NOTHING, fFlags);
404	else
405	{
406	/*
407	* Convert the input to timeval, getting the missing one if necessary,
408	* and call the API which does the change.
409	*/
410	struct timeval aTimevals[2];
411	if (pAccessTime && pModificationTime)
412	{
413	RTTimeSpecGetTimeval(pAccessTime, &aTimevals[0]);
414	RTTimeSpecGetTimeval(pModificationTime, &aTimevals[1]);
415	}
416	else
417	{
418	rc = RTPathQueryInfoEx(pszPath, &ObjInfo, RTFSOBJATTRADD_UNIX, fFlags);
419	if (RT_SUCCESS(rc))
420	{
421	RTTimeSpecGetTimeval(pAccessTime ? pAccessTime : &ObjInfo.AccessTime, &aTimevals[0]);
422	RTTimeSpecGetTimeval(pModificationTime ? pModificationTime : &ObjInfo.ModificationTime, &aTimevals[1]);
423	}
424	else
425	Log(("RTPathSetTimes('%s',%p,%p,,): RTPathQueryInfo failed with %Rrc\n",
426	pszPath, pAccessTime, pModificationTime, rc));
427	}
428	if (RT_SUCCESS(rc))
429	{
430	if (fFlags & RTPATH_F_FOLLOW_LINK)
431	{
432	if (utimes(pszNativePath, aTimevals))
433	rc = RTErrConvertFromErrno(errno);
434	}
435	#if (defined(RT_OS_DARWIN) && MAC_OS_X_VERSION_MIN_REQUIRED >= 1050) \
436	\|\| defined(RT_OS_FREEBSD) \
437	\|\| defined(RT_OS_LINUX) \
438	\|\| defined(RT_OS_OS2) /** @todo who really has lutimes? */
439	else
440	{
441	if (lutimes(pszNativePath, aTimevals))
442	rc = RTErrConvertFromErrno(errno);
443	}
444	#else
445	else
446	{
447	if (pAccessTime && pModificationTime)
448	rc = RTPathQueryInfoEx(pszPath, &ObjInfo, RTFSOBJATTRADD_UNIX, fFlags);
449	if (RT_SUCCESS(rc) && RTFS_IS_SYMLINK(ObjInfo.Attr.fMode))
450	rc = VERR_NS_SYMLINK_SET_TIME;
451	else if (RT_SUCCESS(rc))
452	{
453	if (utimes(pszNativePath, aTimevals))
454	rc = RTErrConvertFromErrno(errno);
455	}
456	}
457	#endif
458	if (RT_FAILURE(rc))
459	Log(("RTPathSetTimes('%s',%p,%p,,): failed with %Rrc and errno=%d\n",
460	pszPath, pAccessTime, pModificationTime, rc, errno));
461	}
462	}
463	rtPathFreeNative(pszNativePath, pszPath);
464	}
465
466	LogFlow(("RTPathSetTimes(%p:{%s}, %p:{%RDtimespec}, %p:{%RDtimespec}, %p:{%RDtimespec}, %p:{%RDtimespec}): return %Rrc\n",
467	pszPath, pszPath, pAccessTime, pAccessTime, pModificationTime, pModificationTime,
468	pChangeTime, pChangeTime, pBirthTime, pBirthTime, rc));
469	return rc;
470	}
471
472
473	RTR3DECL(int) RTPathSetOwner(const char *pszPath, uint32_t uid, uint32_t gid)
474	{
475	return RTPathSetOwnerEx(pszPath, uid, gid, RTPATH_F_ON_LINK);
476	}
477
478
479	RTR3DECL(int) RTPathSetOwnerEx(const char *pszPath, uint32_t uid, uint32_t gid, uint32_t fFlags)
480	{
481	/*
482	* Validate input.
483	*/
484	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
485	AssertReturn(*pszPath, VERR_INVALID_PARAMETER);
486	AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
487	uid_t uidNative = uid != UINT32_MAX ? (uid_t)uid : (uid_t)-1;
488	AssertReturn(uid == uidNative, VERR_INVALID_PARAMETER);
489	gid_t gidNative = gid != UINT32_MAX ? (gid_t)gid : (uid_t)-1;
490	AssertReturn(gid == gidNative, VERR_INVALID_PARAMETER);
491
492	/*
493	* Convert the path.
494	*/
495	char const *pszNativePath;
496	int rc = rtPathToNative(&pszNativePath, pszPath, NULL);
497	if (RT_SUCCESS(rc))
498	{
499	if (fFlags & RTPATH_F_FOLLOW_LINK)
500	{
501	if (chown(pszNativePath, uidNative, gidNative))
502	rc = RTErrConvertFromErrno(errno);
503	}
504	#if 1
505	else
506	{
507	if (lchown(pszNativePath, uidNative, gidNative))
508	rc = RTErrConvertFromErrno(errno);
509	}
510	#else
511	else
512	{
513	RTFSOBJINFO ObjInfo;
514	rc = RTPathQueryInfoEx(pszPath, &ObjInfo, RTFSOBJATTRADD_UNIX, fFlags);
515	if (RT_SUCCESS(rc) && RTFS_IS_SYMLINK(ObjInfo.Attr.fMode))
516	rc = VERR_NS_SYMLINK_CHANGE_OWNER;
517	else if (RT_SUCCESS(rc))
518	{
519	if (lchown(pszNativePath, uidNative, gidNative))
520	rc = RTErrConvertFromErrno(errno);
521	}
522	}
523	#endif
524	if (RT_FAILURE(rc))
525	Log(("RTPathSetOwnerEx('%s',%d,%d): failed with %Rrc and errno=%d\n",
526	pszPath, uid, gid, rc, errno));
527
528	rtPathFreeNative(pszNativePath, pszPath);
529	}
530
531	LogFlow(("RTPathSetOwnerEx(%p:{%s}, uid, gid): return %Rrc\n",
532	pszPath, pszPath, uid, gid, rc));
533	return rc;
534	}
535
536
537	RTR3DECL(int) RTPathSetMode(const char *pszPath, RTFMODE fMode)
538	{
539	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
540	AssertReturn(*pszPath, VERR_INVALID_PARAMETER);
541
542	int rc;
543	fMode = rtFsModeNormalize(fMode, pszPath, 0);
544	if (rtFsModeIsValidPermissions(fMode))
545	{
546	char const *pszNativePath;
547	rc = rtPathToNative(&pszNativePath, pszPath, NULL);
548	if (RT_SUCCESS(rc))
549	{
550	if (chmod(pszNativePath, fMode & RTFS_UNIX_MASK) != 0)
551	rc = RTErrConvertFromErrno(errno);
552	rtPathFreeNative(pszNativePath, pszPath);
553	}
554	}
555	else
556	{
557	AssertMsgFailed(("Invalid file mode! %RTfmode\n", fMode));
558	rc = VERR_INVALID_FMODE;
559	}
560	return rc;
561	}
562
563
564	/**
565	* Checks if two files are the one and same file.
566	*/
567	static bool rtPathSame(const char pszNativeSrc, const char pszNativeDst)
568	{
569	struct stat SrcStat;
570	if (stat(pszNativeSrc, &SrcStat))
571	return false;
572	struct stat DstStat;
573	if (stat(pszNativeDst, &DstStat))
574	return false;
575	Assert(SrcStat.st_dev && DstStat.st_dev);
576	Assert(SrcStat.st_ino && DstStat.st_ino);
577	if ( SrcStat.st_dev == DstStat.st_dev
578	&& SrcStat.st_ino == DstStat.st_ino
579	&& (SrcStat.st_mode & S_IFMT) == (DstStat.st_mode & S_IFMT))
580	return true;
581	return false;
582	}
583
584
585	/**
586	* Worker for RTPathRename, RTDirRename, RTFileRename.
587	*
588	* @returns IPRT status code.
589	* @param pszSrc The source path.
590	* @param pszDst The destination path.
591	* @param fRename The rename flags.
592	* @param fFileType The filetype. We use the RTFMODE filetypes here. If it's 0,
593	* anything goes. If it's RTFS_TYPE_DIRECTORY we'll check that the
594	* source is a directory. If Its RTFS_TYPE_FILE we'll check that it's
595	* not a directory (we are NOT checking whether it's a file).
596	*/
597	DECLHIDDEN(int) rtPathPosixRename(const char pszSrc, const char pszDst, unsigned fRename, RTFMODE fFileType)
598	{
599	/*
600	* Convert the paths.
601	*/
602	char const *pszNativeSrc;
603	int rc = rtPathToNative(&pszNativeSrc, pszSrc, NULL);
604	if (RT_SUCCESS(rc))
605	{
606	char const *pszNativeDst;
607	rc = rtPathToNative(&pszNativeDst, pszDst, NULL);
608	if (RT_SUCCESS(rc))
609	{
610	/*
611	* Check that the source exists and that any types that's specified matches.
612	* We have to check this first to avoid getting errnous VERR_ALREADY_EXISTS
613	* errors from the next step.
614	*
615	* There are race conditions here (perhaps unlikely ones but still), but I'm
616	* afraid there is little with can do to fix that.
617	*/
618	struct stat SrcStat;
619	if (stat(pszNativeSrc, &SrcStat))
620	rc = RTErrConvertFromErrno(errno);
621	else if (!fFileType)
622	rc = VINF_SUCCESS;
623	else if (RTFS_IS_DIRECTORY(fFileType))
624	rc = S_ISDIR(SrcStat.st_mode) ? VINF_SUCCESS : VERR_NOT_A_DIRECTORY;
625	else
626	rc = S_ISDIR(SrcStat.st_mode) ? VERR_IS_A_DIRECTORY : VINF_SUCCESS;
627	if (RT_SUCCESS(rc))
628	{
629	bool fSameFile = false;
630
631	/*
632	* Check if the target exists, rename is rather destructive.
633	* We'll have to make sure we don't overwrite the source!
634	* Another race condition btw.
635	*/
636	struct stat DstStat;
637	if (stat(pszNativeDst, &DstStat))
638	rc = errno == ENOENT ? VINF_SUCCESS : RTErrConvertFromErrno(errno);
639	else
640	{
641	Assert(SrcStat.st_dev && DstStat.st_dev);
642	Assert(SrcStat.st_ino && DstStat.st_ino);
643	if ( SrcStat.st_dev == DstStat.st_dev
644	&& SrcStat.st_ino == DstStat.st_ino
645	&& (SrcStat.st_mode & S_IFMT) == (DstStat.st_mode & S_IFMT))
646	{
647	/*
648	* It's likely that we're talking about the same file here.
649	* We should probably check paths or whatever, but for now this'll have to be enough.
650	*/
651	fSameFile = true;
652	}
653	if (fSameFile)
654	rc = VINF_SUCCESS;
655	else if (S_ISDIR(DstStat.st_mode) \|\| !(fRename & RTPATHRENAME_FLAGS_REPLACE))
656	rc = VERR_ALREADY_EXISTS;
657	else
658	rc = VINF_SUCCESS;
659
660	}
661	if (RT_SUCCESS(rc))
662	{
663	if (!rename(pszNativeSrc, pszNativeDst))
664	rc = VINF_SUCCESS;
665	else if ( (fRename & RTPATHRENAME_FLAGS_REPLACE)
666	&& (errno == ENOTDIR \|\| errno == EEXIST))
667	{
668	/*
669	* Check that the destination isn't a directory.
670	* Yet another race condition.
671	*/
672	if (rtPathSame(pszNativeSrc, pszNativeDst))
673	{
674	rc = VINF_SUCCESS;
675	Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): appears to be the same file... (errno=%d)\n",
676	pszSrc, pszDst, fRename, fFileType, errno));
677	}
678	else
679	{
680	if (stat(pszNativeDst, &DstStat))
681	rc = errno != ENOENT ? RTErrConvertFromErrno(errno) : VINF_SUCCESS;
682	else if (S_ISDIR(DstStat.st_mode))
683	rc = VERR_ALREADY_EXISTS;
684	else
685	rc = VINF_SUCCESS;
686	if (RT_SUCCESS(rc))
687	{
688	if (!unlink(pszNativeDst))
689	{
690	if (!rename(pszNativeSrc, pszNativeDst))
691	rc = VINF_SUCCESS;
692	else
693	{
694	rc = RTErrConvertFromErrno(errno);
695	Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): rename failed rc=%Rrc errno=%d\n",
696	pszSrc, pszDst, fRename, fFileType, rc, errno));
697	}
698	}
699	else
700	{
701	rc = RTErrConvertFromErrno(errno);
702	Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): failed to unlink dst rc=%Rrc errno=%d\n",
703	pszSrc, pszDst, fRename, fFileType, rc, errno));
704	}
705	}
706	else
707	Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): dst !dir check failed rc=%Rrc\n",
708	pszSrc, pszDst, fRename, fFileType, rc));
709	}
710	}
711	else
712	{
713	rc = RTErrConvertFromErrno(errno);
714	if (errno == ENOTDIR)
715	rc = VERR_ALREADY_EXISTS; /* unless somebody is racing us, this is the right interpretation */
716	Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): rename failed rc=%Rrc errno=%d\n",
717	pszSrc, pszDst, fRename, fFileType, rc, errno));
718	}
719	}
720	else
721	Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): destination check failed rc=%Rrc errno=%d\n",
722	pszSrc, pszDst, fRename, fFileType, rc, errno));
723	}
724	else
725	Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): source type check failed rc=%Rrc errno=%d\n",
726	pszSrc, pszDst, fRename, fFileType, rc, errno));
727
728	rtPathFreeNative(pszNativeDst, pszDst);
729	}
730	rtPathFreeNative(pszNativeSrc, pszSrc);
731	}
732	return rc;
733	}
734
735
736	RTR3DECL(int) RTPathRename(const char pszSrc, const char pszDst, unsigned fRename)
737	{
738	/*
739	* Validate input.
740	*/
741	AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER);
742	AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER);
743	AssertMsgReturn(*pszSrc, ("%p\n", pszSrc), VERR_INVALID_PARAMETER);
744	AssertMsgReturn(*pszDst, ("%p\n", pszDst), VERR_INVALID_PARAMETER);
745	AssertMsgReturn(!(fRename & ~RTPATHRENAME_FLAGS_REPLACE), ("%#x\n", fRename), VERR_INVALID_PARAMETER);
746
747	/*
748	* Hand it to the worker.
749	*/
750	int rc = rtPathPosixRename(pszSrc, pszDst, fRename, 0);
751
752	Log(("RTPathRename(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n", pszSrc, pszSrc, pszDst, pszDst, fRename, rc));
753	return rc;
754	}
755
756
757	RTDECL(bool) RTPathExists(const char *pszPath)
758	{
759	return RTPathExistsEx(pszPath, RTPATH_F_FOLLOW_LINK);
760	}
761
762
763	RTDECL(bool) RTPathExistsEx(const char *pszPath, uint32_t fFlags)
764	{
765	/*
766	* Validate input.
767	*/
768	AssertPtrReturn(pszPath, false);
769	AssertReturn(*pszPath, false);
770	Assert(RTPATH_F_IS_VALID(fFlags, 0));
771
772	/*
773	* Convert the path and check if it exists using stat().
774	*/
775	char const *pszNativePath;
776	int rc = rtPathToNative(&pszNativePath, pszPath, NULL);
777	if (RT_SUCCESS(rc))
778	{
779	struct stat Stat;
780	if (fFlags & RTPATH_F_FOLLOW_LINK)
781	rc = stat(pszNativePath, &Stat);
782	else
783	rc = lstat(pszNativePath, &Stat);
784	if (!rc)
785	rc = VINF_SUCCESS;
786	else
787	rc = VERR_GENERAL_FAILURE;
788	rtPathFreeNative(pszNativePath, pszPath);
789	}
790	return RT_SUCCESS(rc);
791	}
792
793
794	RTDECL(int) RTPathGetCurrent(char *pszPath, size_t cchPath)
795	{
796	int rc;
797	char szNativeCurDir[RTPATH_MAX];
798	if (getcwd(szNativeCurDir, sizeof(szNativeCurDir)) != NULL)
799	rc = rtPathFromNativeCopy(pszPath, cchPath, szNativeCurDir, NULL);
800	else
801	rc = RTErrConvertFromErrno(errno);
802	return rc;
803	}
804
805
806	RTDECL(int) RTPathSetCurrent(const char *pszPath)
807	{
808	/*
809	* Validate input.
810	*/
811	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
812	AssertReturn(*pszPath, VERR_INVALID_PARAMETER);
813
814	/*
815	* Change the directory.
816	*/
817	char const *pszNativePath;
818	int rc = rtPathToNative(&pszNativePath, pszPath, NULL);
819	if (RT_SUCCESS(rc))
820	{
821	if (chdir(pszNativePath))
822	rc = RTErrConvertFromErrno(errno);
823	rtPathFreeNative(pszNativePath, pszPath);
824	}
825	return rc;
826	}
827

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

source: vbox/trunk/src/VBox/Runtime/r3/posix/path-posix.cpp@ 33889

Download in other formats: