/**
* Worker for RTPathRename, RTDirRename, RTFileRename.
*
* @returns IPRT status code.
* @param pszSrc The source path.
* @param pszDst The destination path.
* @param fRename The rename flags.
* @param fFileType The filetype. We use the RTFMODE filetypes here. If it's 0,
* anything goes. If it's RTFS_TYPE_DIRECTORY we'll check that the
* source is a directory. If Its RTFS_TYPE_FILE we'll check that it's
* not a directory (we are NOT checking whether it's a file).
*/
DECLHIDDEN(int) rtPathPosixRename(const char *pszSrc, const char *pszDst, unsigned fRename, RTFMODE fFileType)
{
/*
* Convert the paths.
*/
char const *pszNativeSrc;
int rc = rtPathToNative(&pszNativeSrc, pszSrc, NULL);
if (RT_SUCCESS(rc))
{
char const *pszNativeDst;
rc = rtPathToNative(&pszNativeDst, pszDst, NULL);
if (RT_SUCCESS(rc))
{
/*
* Check that the source exists and that any types that's specified matches.
* We have to check this first to avoid getting errnous VERR_ALREADY_EXISTS
* errors from the next step.
*
* There are race conditions here (perhaps unlikely ones, but still), but I'm
* afraid there is little with can do to fix that.
*/
struct stat SrcStat;
if (lstat(pszNativeSrc, &SrcStat))
rc = RTErrConvertFromErrno(errno);
else if (!fFileType)
rc = VINF_SUCCESS;
else if (RTFS_IS_DIRECTORY(fFileType))
rc = S_ISDIR(SrcStat.st_mode) ? VINF_SUCCESS : VERR_NOT_A_DIRECTORY;
else
rc = S_ISDIR(SrcStat.st_mode) ? VERR_IS_A_DIRECTORY : VINF_SUCCESS;
if (RT_SUCCESS(rc))
{
bool fSameFile = false;
/*
* Check if the target exists, rename is rather destructive.
* We'll have to make sure we don't overwrite the source!
* Another race condition btw.
*/
struct stat DstStat;
if (lstat(pszNativeDst, &DstStat))
rc = errno == ENOENT ? VINF_SUCCESS : RTErrConvertFromErrno(errno);
else
{
Assert(SrcStat.st_dev && DstStat.st_dev);
Assert(SrcStat.st_ino && DstStat.st_ino);
if ( SrcStat.st_dev == DstStat.st_dev
&& SrcStat.st_ino == DstStat.st_ino
&& (SrcStat.st_mode & S_IFMT) == (DstStat.st_mode & S_IFMT))
{
/*
* It's likely that we're talking about the same file here.
* We should probably check paths or whatever, but for now this'll have to be enough.
*/
fSameFile = true;
}
if (fSameFile)
rc = VINF_SUCCESS;
else if (S_ISDIR(DstStat.st_mode) || !(fRename & RTPATHRENAME_FLAGS_REPLACE))
rc = VERR_ALREADY_EXISTS;
else
rc = VINF_SUCCESS;
}
if (RT_SUCCESS(rc))
{
if (!rename(pszNativeSrc, pszNativeDst))
rc = VINF_SUCCESS;
else if ( (fRename & RTPATHRENAME_FLAGS_REPLACE)
&& (errno == ENOTDIR || errno == EEXIST))
{
/*
* Check that the destination isn't a directory.
* Yet another race condition.
*/
if (rtPathSame(pszNativeSrc, pszNativeDst))
{
rc = VINF_SUCCESS;
Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): appears to be the same file... (errno=%d)\n",
pszSrc, pszDst, fRename, fFileType, errno));
}
else
{
if (lstat(pszNativeDst, &DstStat))
rc = errno != ENOENT ? RTErrConvertFromErrno(errno) : VINF_SUCCESS;
else if (S_ISDIR(DstStat.st_mode))
rc = VERR_ALREADY_EXISTS;
else
rc = VINF_SUCCESS;
if (RT_SUCCESS(rc))
{
if (!unlink(pszNativeDst))
{
if (!rename(pszNativeSrc, pszNativeDst))
rc = VINF_SUCCESS;
else
{
rc = RTErrConvertFromErrno(errno);
Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): rename failed rc=%Rrc errno=%d\n",
pszSrc, pszDst, fRename, fFileType, rc, errno));
}
}
else
{
rc = RTErrConvertFromErrno(errno);
Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): failed to unlink dst rc=%Rrc errno=%d\n",
pszSrc, pszDst, fRename, fFileType, rc, errno));
}
}
else
Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): dst !dir check failed rc=%Rrc\n",
pszSrc, pszDst, fRename, fFileType, rc));
}
}
else
{
rc = RTErrConvertFromErrno(errno);
if (errno == ENOTDIR)
rc = VERR_ALREADY_EXISTS; /* unless somebody is racing us, this is the right interpretation */
Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): rename failed rc=%Rrc errno=%d\n",
pszSrc, pszDst, fRename, fFileType, rc, errno));
}
}
else
Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): destination check failed rc=%Rrc errno=%d\n",
pszSrc, pszDst, fRename, fFileType, rc, errno));
}
else
Log(("rtPathRename('%s', '%s', %#x ,%RTfmode): source type check failed rc=%Rrc errno=%d\n",
pszSrc, pszDst, fRename, fFileType, rc, errno));
rtPathFreeNative(pszNativeDst, pszDst);
}
rtPathFreeNative(pszNativeSrc, pszSrc);
}
return rc;
}
/**
* Creates a UUID mapping for the file.
*
* @returns IPRT status code.
* @param pszCacheFile The path to the file in the cache.
* @param pFileUuid The UUID of the file.
* @param pszUuidMapDir The UUID map subdirectory in the cache, if this is
* wanted, otherwise NULL.
* @param pCfg The configuration.
*/
static int rtDbgSymCacheAddCreateUuidMapping(const char *pszCacheFile, PRTUUID pFileUuid,
const char *pszUuidMapDir, PCRTDBGSYMCACHEADDCFG pCfg)
{
/*
* Create the UUID map entry first, deep.
*/
char szMapPath[RTPATH_MAX];
int rc = RTPathJoin(szMapPath, sizeof(szMapPath) - sizeof("/xxxx/yyyy/xxxx/yyyy/xxxx/zzzzzzzzzzzz") + 1,
pCfg->pszCache, pszUuidMapDir);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Error constructing UUID map path (RTPathJoin): %Rrc", rc);
size_t cch = strlen(szMapPath);
szMapPath[cch] = '-';
rc = RTUuidToStr(pFileUuid, &szMapPath[cch + 2], sizeof(szMapPath) - cch);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Error constructing UUID map path (RTUuidToStr): %Rrc", rc);
/* Uppercase the whole lot. */
RTStrToUpper(&szMapPath[cch + 2]);
/* Split the first dword in two. */
szMapPath[cch + 1] = szMapPath[cch + 2];
szMapPath[cch + 2] = szMapPath[cch + 3];
szMapPath[cch + 3] = szMapPath[cch + 4];
szMapPath[cch + 4] = szMapPath[cch + 5];
szMapPath[cch + 5] = '-';
/*
* Create the directories in the path.
*/
for (unsigned i = 0; i < 6; i++, cch += 5)
{
Assert(szMapPath[cch] == '-');
szMapPath[cch] = '\0';
if (!RTDirExists(szMapPath))
{
rc = RTDirCreate(szMapPath, 0755, RTDIRCREATE_FLAGS_NOT_CONTENT_INDEXED_NOT_CRITICAL);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "RTDirCreate failed on '%s' (UUID map path): %Rrc", szMapPath, rc);
}
szMapPath[cch] = RTPATH_SLASH;
}
cch -= 5;
/*
* Calculate a relative path from there to the actual file.
*/
char szLinkTarget[RTPATH_MAX];
//szMapPath[cch] = '\0';
rc = RTPathCalcRelative(szLinkTarget, sizeof(szLinkTarget), szMapPath, pszCacheFile);
//szMapPath[cch] = RTPATH_SLASH;
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Failed to calculate relative path from '%s' to '%s': %Rrc", szMapPath, pszCacheFile, rc);
/*
* If there is already a link there, check if it matches or whether
* perhaps it's target doesn't exist.
*/
RTFSOBJINFO ObjInfo;
rc = RTPathQueryInfoEx(szMapPath, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
if (RT_SUCCESS(rc))
{
if (RTFS_IS_SYMLINK(ObjInfo.Attr.fMode))
{
rc = RTPathQueryInfoEx(szMapPath, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK);
if (RT_SUCCESS(rc))
{
char *pszCurTarget = NULL;
rc = RTSymlinkReadA(szMapPath, &pszCurTarget);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "UUID map: failed to read existing symlink '%s': %Rrc", szMapPath, rc);
if (RTPathCompare(pszCurTarget, szLinkTarget) == 0)
RTMsgInfo("UUID map: existing link '%s' has the same target ('%s').", szMapPath, pszCurTarget);
else
{
RTMsgError("UUID map: Existing mapping '%s' pointing to '%s' insted of '%s'",
szMapPath, pszCurTarget, szLinkTarget);
rc = VERR_ALREADY_EXISTS;
}
RTStrFree(pszCurTarget);
return rc;
}
else
RTMsgInfo("UUID map: replacing dangling link '%s'", szMapPath);
RTSymlinkDelete(szMapPath, 0 /*fFlags*/);
}
else if (RTFS_IS_FILE(ObjInfo.Attr.fMode))
return RTMsgErrorRc(VERR_IS_A_FILE,
"UUID map: found file at '%s', expect symbolic link or nothing.", szMapPath);
else if (RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
return RTMsgErrorRc(VERR_IS_A_DIRECTORY,
"UUID map: found directory at '%s', expect symbolic link or nothing.", szMapPath);
else
return RTMsgErrorRc(VERR_NOT_SYMLINK,
"UUID map: Expected symbolic link or nothing at '%s', found: fMode=%#x",
szMapPath, ObjInfo.Attr.fMode);
}
/*
* Create the symbolic link.
*/
rc = RTSymlinkCreate(szMapPath, szLinkTarget, RTSYMLINKTYPE_FILE, 0);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Failed to create UUID map symlink '%s' to '%s': %Rrc", szMapPath, szLinkTarget, rc);
RTMsgInfo("UUID map: %s => %s", szMapPath, szLinkTarget);
return VINF_SUCCESS;
}
/**
* Figure the type of a file/dir based on path and FS object info.
*
* @returns The type.
* @param pszPath The path to the file/dir.
* @param pObjInfo The object information, symlinks followed.
*/
static RTDBGSYMCACHEFILETYPE rtDbgSymCacheFigureType2(const char *pszPath, PCRTFSOBJINFO pObjInfo)
{
const char *pszName = RTPathFilename(pszPath);
const char *pszExt = RTPathSuffix(pszName);
if (pszExt)
pszExt++;
else
pszExt = "";
if ( RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode)
|| (pObjInfo->Attr.fMode & RTFS_DOS_DIRECTORY)) /** @todo OS X samba reports reparse points in /Volumes/ that we cannot resolve. */
{
/* Skip directories shouldn't bother with. */
if ( !RTStrICmp(pszName, ".Trashes")
|| !RTStrICmp(pszName, ".$RESCYCLE.BIN")
|| !RTStrICmp(pszName, "System.kext") /* Usually only plugins here, so skip it. */
)
return RTDBGSYMCACHEFILETYPE_IGNORE;
/* Directories can also be bundles on the mac. */
if (!RTStrICmp(pszExt, "dSYM"))
return RTDBGSYMCACHEFILETYPE_DEBUG_BUNDLE;
for (unsigned i = 0; i < RT_ELEMENTS(g_apszBundleSuffixes) - 1; i++)
if (!RTStrICmp(pszExt, &g_apszBundleSuffixes[i][1]))
return RTDBGSYMCACHEFILETYPE_IMAGE_BUNDLE;
return RTDBGSYMCACHEFILETYPE_DIR;
}
if (!RTFS_IS_FILE(pObjInfo->Attr.fMode))
return RTDBGSYMCACHEFILETYPE_INVALID;
/* Select image vs debug info based on extension. */
if ( !RTStrICmp(pszExt, "pdb")
|| !RTStrICmp(pszExt, "dbg")
|| !RTStrICmp(pszExt, "sym")
|| !RTStrICmp(pszExt, "dwo")
|| !RTStrICmp(pszExt, "dwp")
|| !RTStrICmp(pszExt, "debug")
|| !RTStrICmp(pszExt, "dsym")
|| !RTStrICmp(pszExt, "dwarf")
|| !RTStrICmp(pszExt, "map")
|| !RTStrICmp(pszExt, "cv"))
return RTDBGSYMCACHEFILETYPE_DEBUG_FILE;
/* Filter out a bunch of files which obviously shouldn't be images. */
if ( !RTStrICmp(pszExt, "txt")
|| !RTStrICmp(pszExt, "html")
|| !RTStrICmp(pszExt, "htm")
|| !RTStrICmp(pszExt, "rtf")
|| !RTStrICmp(pszExt, "zip")
|| !RTStrICmp(pszExt, "doc")
|| !RTStrICmp(pszExt, "gz")
|| !RTStrICmp(pszExt, "bz2")
|| !RTStrICmp(pszExt, "xz")
|| !RTStrICmp(pszExt, "kmk")
|| !RTStrICmp(pszExt, "c")
|| !RTStrICmp(pszExt, "cpp")
|| !RTStrICmp(pszExt, "h")
|| !RTStrICmp(pszExt, "m")
|| !RTStrICmp(pszExt, "mm")
|| !RTStrICmp(pszExt, "asm")
|| !RTStrICmp(pszExt, "S")
|| !RTStrICmp(pszExt, "inc")
|| !RTStrICmp(pszExt, "sh")
)
return RTDBGSYMCACHEFILETYPE_IGNORE;
if ( !RTStrICmp(pszName, "Makefile")
|| !RTStrICmp(pszName, "GNUmakefile")
|| !RTStrICmp(pszName, "createsymbolfiles")
|| !RTStrICmp(pszName, "kgmacros")
)
return RTDBGSYMCACHEFILETYPE_IGNORE;
return RTDBGSYMCACHEFILETYPE_IMAGE_FILE;
}
int DnDURIList::appendPathRecursive(const char *pcszPath, size_t cbBaseLen,
uint32_t fFlags)
{
AssertPtrReturn(pcszPath, VERR_INVALID_POINTER);
RTFSOBJINFO objInfo;
int rc = RTPathQueryInfo(pcszPath, &objInfo, RTFSOBJATTRADD_NOTHING);
if (RT_FAILURE(rc))
return rc;
/*
* These are the types we currently support. Symlinks are not directly
* supported. First the guest could be an OS which doesn't support it and
* second the symlink could point to a file which is out of the base tree.
* Both things are hard to support. For now we just copy the target file in
* this case.
*/
if (!( RTFS_IS_DIRECTORY(objInfo.Attr.fMode)
|| RTFS_IS_FILE(objInfo.Attr.fMode)
|| RTFS_IS_SYMLINK(objInfo.Attr.fMode)))
return VINF_SUCCESS;
uint64_t cbSize = 0;
rc = RTFileQuerySize(pcszPath, &cbSize);
if (rc == VERR_IS_A_DIRECTORY)
rc = VINF_SUCCESS;
if (RT_FAILURE(rc))
return rc;
m_lstTree.append(DnDURIObject( RTFS_IS_DIRECTORY(objInfo.Attr.fMode)
? DnDURIObject::Directory
: DnDURIObject::File,
pcszPath, &pcszPath[cbBaseLen],
objInfo.Attr.fMode, cbSize));
m_cbTotal += cbSize;
#ifdef DEBUG_andy
LogFlowFunc(("strSrcPath=%s, strDstPath=%s, fMode=0x%x, cbSize=%RU64, cbTotal=%zu\n",
pcszPath, &pcszPath[cbBaseLen], objInfo.Attr.fMode, cbSize, m_cbTotal));
#endif
PRTDIR hDir;
/* We have to try to open even symlinks, cause they could
* be symlinks to directories. */
rc = RTDirOpen(&hDir, pcszPath);
/* The following error happens when this was a symlink
* to an file or a regular file. */
if ( rc == VERR_PATH_NOT_FOUND
|| rc == VERR_NOT_A_DIRECTORY)
return VINF_SUCCESS;
if (RT_FAILURE(rc))
return rc;
while (RT_SUCCESS(rc))
{
RTDIRENTRY DirEntry;
rc = RTDirRead(hDir, &DirEntry, NULL);
if (RT_FAILURE(rc))
{
if (rc == VERR_NO_MORE_FILES)
rc = VINF_SUCCESS;
break;
}
switch (DirEntry.enmType)
{
case RTDIRENTRYTYPE_DIRECTORY:
{
/* Skip "." and ".." entries. */
if ( RTStrCmp(DirEntry.szName, ".") == 0
|| RTStrCmp(DirEntry.szName, "..") == 0)
break;
char *pszRecDir = RTPathJoinA(pcszPath, DirEntry.szName);
if (pszRecDir)
{
rc = appendPathRecursive(pszRecDir, cbBaseLen, fFlags);
RTStrFree(pszRecDir);
}
else
rc = VERR_NO_MEMORY;
break;
}
case RTDIRENTRYTYPE_SYMLINK:
case RTDIRENTRYTYPE_FILE:
{
char *pszNewFile = RTPathJoinA(pcszPath, DirEntry.szName);
if (pszNewFile)
{
/* We need the size and the mode of the file. */
RTFSOBJINFO objInfo1;
rc = RTPathQueryInfo(pszNewFile, &objInfo1, RTFSOBJATTRADD_NOTHING);
if (RT_FAILURE(rc))
return rc;
rc = RTFileQuerySize(pszNewFile, &cbSize);
if (rc == VERR_IS_A_DIRECTORY) /* Happens for symlinks. */
rc = VINF_SUCCESS;
if (RT_FAILURE(rc))
break;
if (RTFS_IS_FILE(objInfo.Attr.fMode))
{
m_lstTree.append(DnDURIObject(DnDURIObject::File,
pszNewFile, &pszNewFile[cbBaseLen],
objInfo1.Attr.fMode, cbSize));
m_cbTotal += cbSize;
}
else /* Handle symlink directories. */
rc = appendPathRecursive(pszNewFile, cbBaseLen, fFlags);
#ifdef DEBUG_andy
LogFlowFunc(("strSrcPath=%s, strDstPath=%s, fMode=0x%x, cbSize=%RU64, cbTotal=%zu\n",
pszNewFile, &pszNewFile[cbBaseLen], objInfo1.Attr.fMode, cbSize, m_cbTotal));
#endif
RTStrFree(pszNewFile);
}
else
rc = VERR_NO_MEMORY;
break;
}
default:
break;
}
}
RTDirClose(hDir);
return rc;
}
static void test1Worker(RTTEST hTest, const char *pszBaseDir,
const char *pszTarget, RTSYMLINKTYPE enmType, bool fDangling)
{
char szPath1[RTPATH_MAX];
char szPath2[RTPATH_MAX];
size_t cchTarget = strlen(pszTarget);
/* Create it.*/
RTTESTI_CHECK_RC_OK_RETV(RTPathJoin(szPath1, sizeof(szPath1), pszBaseDir, "tstRTSymlink-link-1"));
RTSymlinkDelete(szPath1, 0); /* clean up previous run */
RTTESTI_CHECK_RC_RETV(RTSymlinkCreate(szPath1, pszTarget, RTSYMLINKTYPE_FILE, 0), VINF_SUCCESS);
/* Check the predicate functions. */
RTTESTI_CHECK(RTSymlinkExists(szPath1));
RTTESTI_CHECK(RTSymlinkIsDangling(szPath1) == fDangling);
/* Read it. */
memset(szPath2, 0xff, sizeof(szPath2));
szPath2[sizeof(szPath2) - 1] = '\0';
RTTESTI_CHECK_RC(RTSymlinkRead(szPath1, szPath2, sizeof(szPath2), 0), VINF_SUCCESS);
RTTESTI_CHECK_MSG(strcmp(szPath2, pszTarget) == 0, ("got=\"%s\" expected=\"%s\"", szPath2, pszTarget));
memset(szPath2, 0xff, sizeof(szPath2));
szPath2[sizeof(szPath2) - 1] = '\0';
RTTESTI_CHECK_RC(RTSymlinkRead(szPath1, szPath2, cchTarget + 1, 0), VINF_SUCCESS);
RTTESTI_CHECK_MSG(strcmp(szPath2, pszTarget) == 0, ("got=\"%s\" expected=\"%s\"", szPath2, pszTarget));
memset(szPath2, 0xff, sizeof(szPath2));
szPath2[sizeof(szPath2) - 1] = '\0';
RTTESTI_CHECK_RC(RTSymlinkRead(szPath1, szPath2, cchTarget, 0), VERR_BUFFER_OVERFLOW);
RTTESTI_CHECK_MSG( strncmp(szPath2, pszTarget, cchTarget - 1) == 0
&& szPath2[cchTarget - 1] == '\0',
("got=\"%s\" expected=\"%.*s\"", szPath2, cchTarget - 1, pszTarget));
/* Other APIs that have to handle symlinks carefully. */
int rc;
RTFSOBJINFO ObjInfo;
RTTESTI_CHECK_RC(rc = RTPathQueryInfo(szPath1, &ObjInfo, RTFSOBJATTRADD_NOTHING), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK(RTFS_IS_SYMLINK(ObjInfo.Attr.fMode));
RTTESTI_CHECK_RC(rc = RTPathQueryInfoEx(szPath1, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK(RTFS_IS_SYMLINK(ObjInfo.Attr.fMode));
if (!fDangling)
{
RTTESTI_CHECK_RC(rc = RTPathQueryInfoEx(szPath1, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK(!RTFS_IS_SYMLINK(ObjInfo.Attr.fMode));
else
RT_ZERO(ObjInfo);
if (enmType == RTSYMLINKTYPE_DIR)
{
RTTESTI_CHECK(RTDirExists(szPath1));
RTTESTI_CHECK(RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode));
}
else if (enmType == RTSYMLINKTYPE_FILE)
{
RTTESTI_CHECK(RTFileExists(szPath1));
RTTESTI_CHECK(RTFS_IS_FILE(ObjInfo.Attr.fMode));
}
/** @todo Check more APIs */
}
/* Finally, the removal of the symlink. */
RTTESTI_CHECK_RC(RTSymlinkDelete(szPath1, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTSymlinkDelete(szPath1, 0), VERR_FILE_NOT_FOUND);
}
int DnDURIList::appendPathRecursive(const char *pcszSrcPath,
const char *pcszDstPath, const char *pcszDstBase, size_t cchDstBase, uint32_t fFlags)
{
AssertPtrReturn(pcszSrcPath, VERR_INVALID_POINTER);
AssertPtrReturn(pcszDstBase, VERR_INVALID_POINTER);
AssertPtrReturn(pcszDstPath, VERR_INVALID_POINTER);
LogFlowFunc(("pcszSrcPath=%s, pcszDstPath=%s, pcszDstBase=%s, cchDstBase=%zu\n",
pcszSrcPath, pcszDstPath, pcszDstBase, cchDstBase));
RTFSOBJINFO objInfo;
int rc = RTPathQueryInfo(pcszSrcPath, &objInfo, RTFSOBJATTRADD_NOTHING);
if (RT_SUCCESS(rc))
{
if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
{
rc = addEntry(pcszSrcPath, &pcszDstPath[cchDstBase], fFlags);
if (RT_SUCCESS(rc))
{
PRTDIR hDir;
rc = RTDirOpen(&hDir, pcszSrcPath);
if (RT_SUCCESS(rc))
{
do
{
RTDIRENTRY DirEntry;
rc = RTDirRead(hDir, &DirEntry, NULL);
if (RT_FAILURE(rc))
{
if (rc == VERR_NO_MORE_FILES)
rc = VINF_SUCCESS;
break;
}
switch (DirEntry.enmType)
{
case RTDIRENTRYTYPE_DIRECTORY:
{
/* Skip "." and ".." entries. */
if ( RTStrCmp(DirEntry.szName, ".") == 0
|| RTStrCmp(DirEntry.szName, "..") == 0)
break;
char *pszSrc = RTPathJoinA(pcszSrcPath, DirEntry.szName);
if (pszSrc)
{
char *pszDst = RTPathJoinA(pcszDstPath, DirEntry.szName);
if (pszDst)
{
rc = appendPathRecursive(pszSrc, pszDst, pcszDstBase, cchDstBase, fFlags);
RTStrFree(pszDst);
}
else
rc = VERR_NO_MEMORY;
RTStrFree(pszSrc);
}
else
rc = VERR_NO_MEMORY;
break;
}
case RTDIRENTRYTYPE_FILE:
{
char *pszSrc = RTPathJoinA(pcszSrcPath, DirEntry.szName);
if (pszSrc)
{
char *pszDst = RTPathJoinA(pcszDstPath, DirEntry.szName);
if (pszDst)
{
rc = addEntry(pszSrc, &pszDst[cchDstBase], fFlags);
RTStrFree(pszDst);
}
else
rc = VERR_NO_MEMORY;
RTStrFree(pszSrc);
}
else
rc = VERR_NO_MEMORY;
break;
}
case RTDIRENTRYTYPE_SYMLINK:
{
if (fFlags & DNDURILIST_FLAGS_RESOLVE_SYMLINKS)
{
char *pszSrc = RTPathRealDup(pcszDstBase);
if (pszSrc)
{
rc = RTPathQueryInfo(pszSrc, &objInfo, RTFSOBJATTRADD_NOTHING);
if (RT_SUCCESS(rc))
{
if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
{
LogFlowFunc(("Directory entry is symlink to directory\n"));
rc = appendPathRecursive(pszSrc, pcszDstPath, pcszDstBase, cchDstBase, fFlags);
}
else if (RTFS_IS_FILE(objInfo.Attr.fMode))
{
LogFlowFunc(("Directory entry is symlink to file\n"));
rc = addEntry(pszSrc, &pcszDstPath[cchDstBase], fFlags);
}
else
rc = VERR_NOT_SUPPORTED;
}
RTStrFree(pszSrc);
}
else
rc = VERR_NO_MEMORY;
}
break;
}
default:
break;
}
} while (RT_SUCCESS(rc));
RTDirClose(hDir);
}
}
}
else if (RTFS_IS_FILE(objInfo.Attr.fMode))
{
rc = addEntry(pcszSrcPath, &pcszDstPath[cchDstBase], fFlags);
}
else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode))
{
if (fFlags & DNDURILIST_FLAGS_RESOLVE_SYMLINKS)
{
char *pszSrc = RTPathRealDup(pcszSrcPath);
if (pszSrc)
{
rc = RTPathQueryInfo(pszSrc, &objInfo, RTFSOBJATTRADD_NOTHING);
if (RT_SUCCESS(rc))
{
if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
{
LogFlowFunc(("Symlink to directory\n"));
rc = appendPathRecursive(pszSrc, pcszDstPath, pcszDstBase, cchDstBase, fFlags);
}
else if (RTFS_IS_FILE(objInfo.Attr.fMode))
{
LogFlowFunc(("Symlink to file\n"));
rc = addEntry(pszSrc, &pcszDstPath[cchDstBase], fFlags);
}
else
rc = VERR_NOT_SUPPORTED;
}
RTStrFree(pszSrc);
}
else
rc = VERR_NO_MEMORY;
}
}
else
rc = VERR_NOT_SUPPORTED;
}
LogFlowFuncLeaveRC(rc);
return rc;
}
int DnDURIList::addEntry(const char *pcszSource, const char *pcszTarget, uint32_t fFlags)
{
AssertPtrReturn(pcszSource, VERR_INVALID_POINTER);
AssertPtrReturn(pcszTarget, VERR_INVALID_POINTER);
LogFlowFunc(("pcszSource=%s, pcszTarget=%s, fFlags=0x%x\n", pcszSource, pcszTarget, fFlags));
RTFSOBJINFO objInfo;
int rc = RTPathQueryInfo(pcszSource, &objInfo, RTFSOBJATTRADD_NOTHING);
if (RT_SUCCESS(rc))
{
if (RTFS_IS_FILE(objInfo.Attr.fMode))
{
LogFlowFunc(("File '%s' -> '%s' (%RU64 bytes, file mode 0x%x)\n",
pcszSource, pcszTarget, (uint64_t)objInfo.cbObject, objInfo.Attr.fMode));
DnDURIObject *pObjFile = new DnDURIObject(DnDURIObject::File, pcszSource, pcszTarget);
if (pObjFile)
{
if (fFlags & DNDURILIST_FLAGS_KEEP_OPEN) /* Shall we keep the file open while being added to this list? */
{
/** @todo Add a standard fOpen mode for this list. */
rc = pObjFile->Open(DnDURIObject::Source, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE, objInfo.Attr.fMode);
}
if (RT_SUCCESS(rc))
{
m_lstTree.append(pObjFile);
m_cTotal++;
m_cbTotal += pObjFile->GetSize();
}
else
delete pObjFile;
}
else
rc = VERR_NO_MEMORY;
}
else if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
{
LogFlowFunc(("Directory '%s' -> '%s' (file mode 0x%x)\n", pcszSource, pcszTarget, objInfo.Attr.fMode));
DnDURIObject *pObjDir = new DnDURIObject(DnDURIObject::Directory, pcszSource, pcszTarget,
objInfo.Attr.fMode, 0 /* Size */);
if (pObjDir)
{
m_lstTree.append(pObjDir);
/** @todo Add DNDURILIST_FLAGS_KEEP_OPEN handling? */
m_cTotal++;
}
else
rc = VERR_NO_MEMORY;
}
/* Note: Symlinks already should have been resolved at this point. */
else
rc = VERR_NOT_SUPPORTED;
}
LogFlowFuncLeaveRC(rc);
return rc;
}
/**
* Recursion worker for RTDirRemoveRecursive.
*
* @returns IPRT status code.
* @param pszBuf The path buffer. Contains the abs path to the
* directory to recurse into. Trailing slash.
* @param cchDir The length of the directory we're cursing into,
* including the trailing slash.
* @param pDirEntry The dir entry buffer. (Shared to save stack.)
* @param pObjInfo The object info buffer. (ditto)
*/
static int rtDirRemoveRecursiveSub(char *pszBuf, size_t cchDir, PRTDIRENTRY pDirEntry, PRTFSOBJINFO pObjInfo)
{
AssertReturn(RTPATH_IS_SLASH(pszBuf[cchDir - 1]), VERR_INTERNAL_ERROR_4);
/*
* Enumerate the directory content and dispose of it.
*/
PRTDIR pDir;
int rc = RTDirOpen(&pDir, pszBuf);
if (RT_FAILURE(rc))
return rc;
while (RT_SUCCESS(rc = RTDirRead(pDir, pDirEntry, NULL)))
{
if ( pDirEntry->szName[0] != '.'
|| pDirEntry->cbName > 2
|| ( pDirEntry->cbName == 2
&& pDirEntry->szName[1] != '.')
)
{
/* Construct the full name of the entry. */
if (cchDir + pDirEntry->cbName + 1 /* dir slash */ >= RTPATH_MAX)
{
rc = VERR_FILENAME_TOO_LONG;
break;
}
memcpy(&pszBuf[cchDir], pDirEntry->szName, pDirEntry->cbName + 1);
/* Deal with the unknown type. */
if (pDirEntry->enmType == RTDIRENTRYTYPE_UNKNOWN)
{
rc = RTPathQueryInfoEx(pszBuf, pObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
if (RT_SUCCESS(rc) && RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode))
pDirEntry->enmType = RTDIRENTRYTYPE_DIRECTORY;
else if (RT_SUCCESS(rc) && RTFS_IS_FILE(pObjInfo->Attr.fMode))
pDirEntry->enmType = RTDIRENTRYTYPE_FILE;
else if (RT_SUCCESS(rc) && RTFS_IS_SYMLINK(pObjInfo->Attr.fMode))
pDirEntry->enmType = RTDIRENTRYTYPE_SYMLINK;
}
/* Try the delete the fs object. */
switch (pDirEntry->enmType)
{
case RTDIRENTRYTYPE_FILE:
rc = RTFileDelete(pszBuf);
break;
case RTDIRENTRYTYPE_DIRECTORY:
{
size_t cchSubDir = cchDir + pDirEntry->cbName;
pszBuf[cchSubDir++] = '/';
pszBuf[cchSubDir] = '\0';
rc = rtDirRemoveRecursiveSub(pszBuf, cchSubDir, pDirEntry, pObjInfo);
if (RT_SUCCESS(rc))
{
pszBuf[cchSubDir] = '\0';
rc = RTDirRemove(pszBuf);
}
break;
}
//case RTDIRENTRYTYPE_SYMLINK:
// rc = RTSymlinkDelete(pszBuf, 0);
// break;
default:
/** @todo not implemented yet. */
rc = VINF_SUCCESS;
break;
}
if (RT_FAILURE(rc))
break;
}
}
if (rc == VERR_NO_MORE_FILES)
rc = VINF_SUCCESS;
RTDirClose(pDir);
return rc;
}
int DnDHGSendDataMessage::buildFileTree(const char *pcszPath, size_t cbBaseLen)
{
RTFSOBJINFO objInfo;
int rc = RTPathQueryInfo(pcszPath, &objInfo, RTFSOBJATTRADD_NOTHING);
if (RT_FAILURE(rc))
return rc;
/* These are the types we currently support. Symlinks are not directly
* supported. First the guest could be an OS which doesn't support it and
* second the symlink could point to a file which is out of the base tree.
* Both things are hard to support. For now we just copy the target file in
* this case. */
if (!( RTFS_IS_DIRECTORY(objInfo.Attr.fMode)
|| RTFS_IS_FILE(objInfo.Attr.fMode)
|| RTFS_IS_SYMLINK(objInfo.Attr.fMode)))
return VINF_SUCCESS;
uint64_t cbSize = 0;
rc = RTFileQuerySize(pcszPath, &cbSize);
if (rc == VERR_IS_A_DIRECTORY)
rc = VINF_SUCCESS;
if (RT_FAILURE(rc))
return rc;
m_uriList.append(PathEntry(pcszPath, &pcszPath[cbBaseLen], objInfo.Attr.fMode, cbSize));
m_cbAll += cbSize;
DO(("cbFile: %u\n", cbSize));
PRTDIR hDir;
/* We have to try to open even symlinks, cause they could be symlinks
* to directories. */
rc = RTDirOpen(&hDir, pcszPath);
/* The following error happens when this was a symlink to an file or a
* regular file. */
if (rc == VERR_PATH_NOT_FOUND)
return VINF_SUCCESS;
if (RT_FAILURE(rc))
return rc;
while (RT_SUCCESS(rc))
{
RTDIRENTRY DirEntry;
rc = RTDirRead(hDir, &DirEntry, NULL);
if (RT_FAILURE(rc))
{
if (rc == VERR_NO_MORE_FILES)
rc = VINF_SUCCESS;
break;
}
switch (DirEntry.enmType)
{
case RTDIRENTRYTYPE_DIRECTORY:
{
/* Skip "." and ".." entries. */
if ( RTStrCmp(DirEntry.szName, ".") == 0
|| RTStrCmp(DirEntry.szName, "..") == 0)
break;
if (char *pszRecDir = RTStrAPrintf2("%s%c%s", pcszPath, RTPATH_DELIMITER, DirEntry.szName))
{
rc = buildFileTree(pszRecDir, cbBaseLen);
RTStrFree(pszRecDir);
}
else
rc = VERR_NO_MEMORY;
break;
}
case RTDIRENTRYTYPE_SYMLINK:
case RTDIRENTRYTYPE_FILE:
{
if (char *pszNewFile = RTStrAPrintf2("%s%c%s", pcszPath, RTPATH_DELIMITER, DirEntry.szName))
{
/* We need the size and the mode of the file. */
RTFSOBJINFO objInfo1;
rc = RTPathQueryInfo(pszNewFile, &objInfo1, RTFSOBJATTRADD_NOTHING);
if (RT_FAILURE(rc))
return rc;
rc = RTFileQuerySize(pszNewFile, &cbSize);
if (RT_FAILURE(rc))
break;
m_uriList.append(PathEntry(pszNewFile, &pszNewFile[cbBaseLen], objInfo1.Attr.fMode, cbSize));
m_cbAll += cbSize;
RTStrFree(pszNewFile);
}
else
rc = VERR_NO_MEMORY;
break;
}
default: break;
}
}
RTDirClose(hDir);
return rc;
}
/* set [inode] attributes based on [info], uid/gid based on [sf_g] */
void sf_init_inode(struct sf_glob_info *sf_g, struct inode *inode,
PSHFLFSOBJINFO info)
{
PSHFLFSOBJATTR attr;
int mode;
TRACE();
attr = &info->Attr;
#define mode_set(r) attr->fMode & (RTFS_UNIX_##r) ? (S_##r) : 0;
mode = mode_set(ISUID);
mode |= mode_set(ISGID);
mode |= mode_set(IRUSR);
mode |= mode_set(IWUSR);
mode |= mode_set(IXUSR);
mode |= mode_set(IRGRP);
mode |= mode_set(IWGRP);
mode |= mode_set(IXGRP);
mode |= mode_set(IROTH);
mode |= mode_set(IWOTH);
mode |= mode_set(IXOTH);
#undef mode_set
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
inode->i_mapping->a_ops = &sf_reg_aops;
inode->i_mapping->backing_dev_info = &sf_g->bdi;
#endif
if (RTFS_IS_DIRECTORY(attr->fMode))
{
inode->i_mode = sf_g->dmode != ~0 ? (sf_g->dmode & 0777) : mode;
inode->i_mode &= ~sf_g->dmask;
inode->i_mode |= S_IFDIR;
inode->i_op = &sf_dir_iops;
inode->i_fop = &sf_dir_fops;
/* XXX: this probably should be set to the number of entries
in the directory plus two (. ..) */
inode->i_nlink = 1;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
else if (RTFS_IS_SYMLINK(attr->fMode))
{
inode->i_mode = sf_g->fmode != ~0 ? (sf_g->fmode & 0777): mode;
inode->i_mode &= ~sf_g->fmask;
inode->i_mode |= S_IFLNK;
inode->i_op = &sf_lnk_iops;
inode->i_nlink = 1;
}
#endif
else
{
inode->i_mode = sf_g->fmode != ~0 ? (sf_g->fmode & 0777): mode;
inode->i_mode &= ~sf_g->fmask;
inode->i_mode |= S_IFREG;
inode->i_op = &sf_reg_iops;
inode->i_fop = &sf_reg_fops;
inode->i_nlink = 1;
}
inode->i_uid = sf_g->uid;
inode->i_gid = sf_g->gid;
inode->i_size = info->cbObject;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) && !defined(KERNEL_FC6)
inode->i_blksize = 4096;
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 11)
inode->i_blkbits = 12;
#endif
/* i_blocks always in units of 512 bytes! */
inode->i_blocks = (info->cbAllocated + 511) / 512;
sf_ftime_from_timespec(&inode->i_atime, &info->AccessTime);
sf_ftime_from_timespec(&inode->i_ctime, &info->ChangeTime);
sf_ftime_from_timespec(&inode->i_mtime, &info->ModificationTime);
}
static ssize_t rtLinuxFindDevicePathRecursive(dev_t DevNum, RTFMODE fMode, const char *pszBasePath,
char *pszBuf, size_t cchBuf)
{
/*
* Check assumptions made by the code below.
*/
size_t const cchBasePath = strlen(pszBasePath);
AssertReturnStmt(cchBasePath < RTPATH_MAX - 10U, errno = ENAMETOOLONG, -1);
ssize_t rcRet;
PRTDIR pDir;
int rc = RTDirOpen(&pDir, pszBasePath);
if (RT_SUCCESS(rc))
{
char szPath[RTPATH_MAX]; /** @todo 4K per recursion - can easily be optimized away by passing it along pszBasePath
and only remember the length. */
memcpy(szPath, pszBasePath, cchBasePath + 1);
for (;;)
{
RTDIRENTRYEX Entry;
rc = RTDirReadEx(pDir, &Entry, NULL, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
if (RT_FAILURE(rc))
{
errno = rc == VERR_NO_MORE_FILES
? ENOENT
: rc == VERR_BUFFER_OVERFLOW
? EOVERFLOW
: EIO;
rcRet = -1;
break;
}
if (RTFS_IS_SYMLINK(Entry.Info.Attr.fMode))
continue;
/* Do the matching. */
if ( Entry.Info.Attr.u.Unix.Device == DevNum
&& (Entry.Info.Attr.fMode & RTFS_TYPE_MASK) == fMode)
{
rcRet = rtLinuxConstructPath(pszBuf, cchBuf, pszBasePath, "%s", Entry.szName);
break;
}
/* Recurse into subdirectories. */
if (!RTFS_IS_DIRECTORY(Entry.Info.Attr.fMode))
continue;
if (Entry.szName[0] == '.')
continue;
szPath[cchBasePath] = '\0';
rc = RTPathAppend(szPath, sizeof(szPath) - 1, Entry.szName); /* -1: for slash */
if (RT_FAILURE(rc))
{
errno = ENAMETOOLONG;
rcRet = -1;
break;
}
strcat(&szPath[cchBasePath], "/");
rcRet = rtLinuxFindDevicePathRecursive(DevNum, fMode, szPath, pszBuf, cchBuf);
if (rcRet >= 0 || errno != ENOENT)
break;
}
RTDirClose(pDir);
}
else
{
rcRet = -1;
errno = RTErrConvertToErrno(rc);
}
return rcRet;
}
/**
* Recursive worker function to walk the /dev tree looking for DVD or floppy
* devices.
* @returns true if we have already found MAX_DEVICE_NODES devices, false
* otherwise
* @param pszPath the path to start recursing. The function can modify
* this string at and after the terminating zero
* @param cchPath the size of the buffer (not the string!) in @a pszPath
* @param aDevices where to fill in information about devices that we have
* found
* @param wantDVD are we looking for DVD devices (or floppies)?
*/
static bool devFindDeviceRecursive(char *pszPath, size_t cchPath,
deviceNodeArray aDevices, bool wantDVD)
{
/*
* Check assumptions made by the code below.
*/
size_t const cchBasePath = strlen(pszPath);
AssertReturn(cchBasePath < RTPATH_MAX - 10U, false);
AssertReturn(pszPath[cchBasePath - 1] != '/', false);
PRTDIR pDir;
if (RT_FAILURE(RTDirOpen(&pDir, pszPath)))
return false;
for (;;)
{
RTDIRENTRY Entry;
RTFSOBJINFO ObjInfo;
int rc = RTDirRead(pDir, &Entry, NULL);
if (RT_FAILURE(rc))
break;
if (Entry.enmType == RTDIRENTRYTYPE_UNKNOWN)
{
if (RT_FAILURE(RTPathQueryInfo(pszPath, &ObjInfo,
RTFSOBJATTRADD_UNIX)))
continue;
if (RTFS_IS_SYMLINK(ObjInfo.Attr.fMode))
continue;
}
if (Entry.enmType == RTDIRENTRYTYPE_SYMLINK)
continue;
pszPath[cchBasePath] = '\0';
if (RT_FAILURE(RTPathAppend(pszPath, cchPath, Entry.szName)))
break;
/* Do the matching. */
dev_t DevNode;
char szDesc[256], szUdi[256];
if (!devValidateDevice(pszPath, wantDVD, &DevNode, szDesc,
sizeof(szDesc), szUdi, sizeof(szUdi)))
continue;
unsigned i;
for (i = 0; i < MAX_DEVICE_NODES; ++i)
if (!aDevices[i].Device || (aDevices[i].Device == DevNode))
break;
AssertBreak(i < MAX_DEVICE_NODES);
if (aDevices[i].Device)
continue;
aDevices[i].Device = DevNode;
RTStrPrintf(aDevices[i].szPath, sizeof(aDevices[i].szPath),
"%s", pszPath);
AssertCompile(sizeof(aDevices[i].szDesc) == sizeof(szDesc));
strcpy(aDevices[i].szDesc, szDesc);
AssertCompile(sizeof(aDevices[i].szUdi) == sizeof(szUdi));
strcpy(aDevices[i].szUdi, szUdi);
if (i == MAX_DEVICE_NODES - 1)
break;
continue;
/* Recurse into subdirectories. */
if ( (Entry.enmType == RTDIRENTRYTYPE_UNKNOWN)
&& !RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
continue;
if (Entry.enmType != RTDIRENTRYTYPE_DIRECTORY)
continue;
if (Entry.szName[0] == '.')
continue;
if (devFindDeviceRecursive(pszPath, cchPath, aDevices, wantDVD))
break;
}
RTDirClose(pDir);
return aDevices[MAX_DEVICE_NODES - 1].Device ? true : false;
}
