int main(int argc, char **argv)
{
int rcRet = 0;
int rcRet2;
int rc;
unsigned cMatch;
RTR3InitExe(argc, &argv, 0);
const char *pszTestDir = ".";
char *pszFilter1 = RTPathJoinA(pszTestDir, "xyxzxq*");
if (!pszFilter1)
{
RTPrintf("tstDir-3: cannot create non-match filter!\n");
return 1;
}
char *pszFilter2 = RTPathJoinA(pszTestDir, "*");
if (!pszFilter2)
{
RTPrintf("tstDir-3: cannot create match filter!\n");
return 1;
}
rcRet2 = tstDirOpenFiltered(pszFilter1, &cMatch, &rc);
if (rcRet2)
rcRet = rcRet2;
if (RT_FAILURE(rc))
RTPrintf("tstDir-3: filter '%s' failed! rc=%Rrc\n", pszFilter1, rc);
if (cMatch)
RTPrintf("tstDir-3: filter '%s' gave wrong result count! cMatch=%u\n", pszFilter1, cMatch);
rcRet2 = tstDirOpenFiltered(pszFilter2, &cMatch, &rc);
if (rcRet2)
rcRet = rcRet2;
if (RT_FAILURE(rc))
RTPrintf("tstDir-3: filter '%s' failed! rc=%Rrc\n", pszFilter2, rc);
if (!cMatch)
RTPrintf("tstDir-3: filter '%s' gave wrong result count! cMatch=%u\n", pszFilter2, cMatch);
if (!rcRet)
RTPrintf("tstDir-3: OK\n");
return rcRet;
}
/* static */
int DnDURIObject::RebaseURIPath(RTCString &strPathAbs,
const RTCString &strBaseOld /* = "" */,
const RTCString &strBaseNew /* = "" */)
{
char *pszPath = RTUriFilePath(strPathAbs.c_str());
if (!pszPath) /* No URI? */
pszPath = RTStrDup(strPathAbs.c_str());
int rc;
if (pszPath)
{
const char *pszPathStart = pszPath;
const char *pszBaseOld = strBaseOld.c_str();
if ( pszBaseOld
&& RTPathStartsWith(pszPath, pszBaseOld))
{
pszPathStart += strlen(pszBaseOld);
}
rc = VINF_SUCCESS;
if (RT_SUCCESS(rc))
{
char *pszPathNew = RTPathJoinA(strBaseNew.c_str(), pszPathStart);
if (pszPathNew)
{
char *pszPathURI = RTUriCreate("file" /* pszScheme */, "/" /* pszAuthority */,
pszPathNew /* pszPath */,
NULL /* pszQuery */, NULL /* pszFragment */);
if (pszPathURI)
{
LogFlowFunc(("Rebasing \"%s\" to \"%s\"\n", strPathAbs.c_str(), pszPathURI));
strPathAbs = RTCString(pszPathURI) + "\r\n";
RTStrFree(pszPathURI);
}
else
rc = VERR_INVALID_PARAMETER;
RTStrFree(pszPathNew);
}
else
rc = VERR_NO_MEMORY;
}
RTStrFree(pszPath);
}
else
rc = VERR_NO_MEMORY;
return rc;
}
/** @todo Put this into an own class like DnDURIPath : public RTCString? */
int DnDURIObject::RebaseURIPath(RTCString &strPath,
const RTCString &strBaseOld,
const RTCString &strBaseNew)
{
int rc;
const char *pszPath = RTUriPath(strPath.c_str());
if (pszPath)
{
const char *pszPathStart = pszPath;
const char *pszBaseOld = strBaseOld.c_str();
if ( pszBaseOld
&& RTPathStartsWith(pszPath, pszBaseOld))
{
pszPathStart += strlen(pszBaseOld);
}
rc = VINF_SUCCESS;
if (RT_SUCCESS(rc))
{
char *pszPathNew = RTPathJoinA(strBaseNew.c_str(), pszPathStart);
if (pszPathNew)
{
char *pszPathURI = RTUriCreate("file" /* pszScheme */, "/" /* pszAuthority */,
pszPathNew /* pszPath */,
NULL /* pszQuery */, NULL /* pszFragment */);
if (pszPathURI)
{
#ifdef DEBUG_andy
LogFlowFunc(("Rebasing \"%s\" to \"%s\"", strPath.c_str(), pszPathURI));
#endif
strPath = RTCString(pszPathURI) + "\r\n";
RTStrFree(pszPathURI);
rc = VINF_SUCCESS;
}
else
rc = VERR_INVALID_PARAMETER;
RTStrFree(pszPathNew);
}
else
rc = VERR_NO_MEMORY;
}
}
else
rc = VERR_INVALID_PARAMETER;
#ifdef DEBUG_andy
LogFlowFuncLeaveRC(rc);
#endif
return rc;
}
RTCString DnDURIList::RootToString(const RTCString &strBasePath /* = "" */,
const RTCString &strSeparator /* = "\r\n" */)
{
RTCString strRet;
for (size_t i = 0; i < m_lstRoot.size(); i++)
{
const char *pszCurRoot = m_lstRoot.at(i).c_str();
#ifdef DEBUG_andy
LogFlowFunc(("pszCurRoot=%s\n", pszCurRoot));
#endif
if (strBasePath.isNotEmpty())
{
char *pszPath = RTPathJoinA(strBasePath.c_str(), pszCurRoot);
if (pszPath)
{
char *pszPathURI = RTUriFileCreate(pszPath);
if (pszPathURI)
{
strRet += RTCString(pszPathURI) + strSeparator;
#ifdef DEBUG_andy
LogFlowFunc(("URI: %s\n", strRet.c_str()));
#endif
RTStrFree(pszPathURI);
}
else
break;
RTStrFree(pszPath);
}
else
break;
}
else
{
char *pszPathURI = RTUriFileCreate(pszCurRoot);
if (pszPathURI)
{
strRet += RTCString(pszPathURI) + strSeparator;
#ifdef DEBUG_andy
LogFlowFunc(("URI: %s\n", strRet.c_str()));
#endif
RTStrFree(pszPathURI);
}
else
break;
}
}
return strRet;
}
/**
* Initialization routine for the usbfs based operation.
*
* @returns iprt status code.
*/
int USBProxyBackendLinux::initUsbfs(void)
{
Assert(mUsingUsbfsDevices);
/*
* Open the devices file.
*/
int rc;
char *pszDevices = RTPathJoinA(mDevicesRoot.c_str(), "devices");
if (pszDevices)
{
rc = RTFileOpen(&mhFile, pszDevices, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
if (RT_SUCCESS(rc))
{
rc = RTPipeCreate(&mhWakeupPipeR, &mhWakeupPipeW, 0 /*fFlags*/);
if (RT_SUCCESS(rc))
{
/*
* Start the poller thread.
*/
rc = start();
if (RT_SUCCESS(rc))
{
RTStrFree(pszDevices);
LogFlowThisFunc(("returns successfully\n"));
return VINF_SUCCESS;
}
RTPipeClose(mhWakeupPipeR);
RTPipeClose(mhWakeupPipeW);
mhWakeupPipeW = mhWakeupPipeR = NIL_RTPIPE;
}
else
Log(("USBProxyBackendLinux::USBProxyBackendLinux: RTFilePipe failed with rc=%Rrc\n", rc));
RTFileClose(mhFile);
}
RTStrFree(pszDevices);
}
else
{
rc = VERR_NO_MEMORY;
Log(("USBProxyBackendLinux::USBProxyBackendLinux: out of memory!\n"));
}
LogFlowThisFunc(("returns failure!!! (rc=%Rrc)\n", rc));
return rc;
}
static int vbglR3DnDHGProcessURIMessages(uint32_t uClientId,
uint32_t *puScreenId,
char *pszFormat,
uint32_t cbFormat,
uint32_t *pcbFormatRecv,
void **ppvData,
uint32_t cbData,
size_t *pcbDataRecv)
{
/* Make a string list out of the uri data. */
RTCList<RTCString> uriList = RTCString(static_cast<char*>(*ppvData), *pcbDataRecv - 1).split("\r\n");
if (uriList.isEmpty())
return VINF_SUCCESS;
uint32_t cbTmpData = _1M * 10;
void *pvTmpData = RTMemAlloc(cbTmpData);
if (!pvTmpData)
return VERR_NO_MEMORY;
/* Create and query the drop target directory. */
char pszDropDir[RTPATH_MAX];
int rc = vbglR3DnDCreateDropDir(pszDropDir, sizeof(pszDropDir));
if (RT_FAILURE(rc))
{
RTMemFree(pvTmpData);
return rc;
}
/* Patch the old drop data with the new drop directory, so the drop target
* can find the files. */
RTCList<RTCString> guestUriList;
for (size_t i = 0; i < uriList.size(); ++i)
{
const RTCString &strUri = uriList.at(i);
/* Query the path component of a file URI. If this hasn't a
* file scheme, null is returned. */
if (char *pszFilePath = RTUriFilePath(strUri.c_str(), URI_FILE_FORMAT_AUTO))
{
RTCString strFullPath = RTCString().printf("%s%c%s", pszDropDir, RTPATH_SLASH, pszFilePath);
char *pszNewUri = RTUriFileCreate(strFullPath.c_str());
if (pszNewUri)
{
guestUriList.append(pszNewUri);
RTStrFree(pszNewUri);
}
}
else
guestUriList.append(strUri);
}
/* Cleanup the old data and write the new data back to the event. */
RTMemFree(*ppvData);
RTCString newData = RTCString::join(guestUriList, "\r\n") + "\r\n";
*ppvData = RTStrDupN(newData.c_str(), newData.length());
*pcbDataRecv = newData.length() + 1;
/* Lists for holding created files & directories in the case of a
* rollback. */
RTCList<RTCString> guestDirList;
RTCList<RTCString> guestFileList;
char pszPathname[RTPATH_MAX];
uint32_t cbPathname = 0;
bool fLoop = true;
do
{
uint32_t uNextMsg;
uint32_t cNextParms;
rc = vbglR3DnDQueryNextHostMessageType(uClientId, &uNextMsg, &cNextParms, false);
DO(("%Rrc - %d\n", rc , uNextMsg));
if (RT_SUCCESS(rc))
{
switch(uNextMsg)
{
case DragAndDropSvc::HOST_DND_HG_SND_DIR:
{
uint32_t fMode = 0;
rc = vbglR3DnDHGProcessSendDirMessage(uClientId,
pszPathname,
sizeof(pszPathname),
&cbPathname,
&fMode);
if (RT_SUCCESS(rc))
{
DO(("Got drop dir: %s - %o - %Rrc\n", pszPathname, fMode, rc));
char *pszNewDir = RTPathJoinA(pszDropDir, pszPathname);
rc = RTDirCreate(pszNewDir, (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRWXU, 0);
if (!guestDirList.contains(pszNewDir))
guestDirList.append(pszNewDir);
}
break;
}
case DragAndDropSvc::HOST_DND_HG_SND_FILE:
{
uint32_t cbDataRecv;
uint32_t fMode = 0;
rc = vbglR3DnDHGProcessSendFileMessage(uClientId,
pszPathname,
sizeof(pszPathname),
&cbPathname,
pvTmpData,
cbTmpData,
&cbDataRecv,
&fMode);
if (RT_SUCCESS(rc))
{
char *pszNewFile = RTPathJoinA(pszDropDir, pszPathname);
DO(("Got drop file: %s - %d - %o - %Rrc\n", pszPathname, cbDataRecv, fMode, rc));
RTFILE hFile;
rc = RTFileOpen(&hFile, pszNewFile, RTFILE_O_WRITE | RTFILE_O_APPEND | RTFILE_O_DENY_ALL | RTFILE_O_OPEN_CREATE);
if (RT_SUCCESS(rc))
{
rc = RTFileSeek(hFile, 0, RTFILE_SEEK_END, NULL);
if (RT_SUCCESS(rc))
{
rc = RTFileWrite(hFile, pvTmpData, cbDataRecv, 0);
/* Valid UNIX mode? */
if ( RT_SUCCESS(rc)
&& (fMode & RTFS_UNIX_MASK))
rc = RTFileSetMode(hFile, (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR);
}
RTFileClose(hFile);
if (!guestFileList.contains(pszNewFile))
guestFileList.append(pszNewFile);
}
}
break;
}
case DragAndDropSvc::HOST_DND_HG_EVT_CANCEL:
{
rc = vbglR3DnDHGProcessCancelMessage(uClientId);
if (RT_SUCCESS(rc))
rc = VERR_CANCELLED;
/* Break out of the loop. */
}
default: fLoop = false; break;
}
} else
{
if (rc == VERR_NO_DATA)
rc = VINF_SUCCESS;
break;
}
}while(fLoop);
RTMemFree(pvTmpData);
/* Cleanup on failure or if the user has canceled. */
if (RT_FAILURE(rc))
{
/* Remove any stuff created. */
for (size_t i = 0; i < guestFileList.size(); ++i)
RTFileDelete(guestFileList.at(i).c_str());
for (size_t i = 0; i < guestDirList.size(); ++i)
RTDirRemove(guestDirList.at(i).c_str());
RTDirRemove(pszDropDir);
}
return rc;
}
/**
* Returns the path of the ACPI CPU device with the given core and package ID.
*
* @returns VBox status code.
* @param ppszPath Where to store the path.
* @param idCpuCore The core ID of the CPU.
* @param idCpuPackage The package ID of the CPU.
*/
static int VBoxServiceCpuHotPlugGetACPIDevicePath(char **ppszPath, uint32_t idCpuCore, uint32_t idCpuPackage)
{
int rc = VINF_SUCCESS;
AssertPtrReturn(ppszPath, VERR_INVALID_PARAMETER);
rc = VBoxServiceCpuHotPlugProbePath();
if (RT_SUCCESS(rc))
{
/* Build the path from all components. */
bool fFound = false;
unsigned iLvlCurr = 0;
char *pszPath = NULL;
char *pszPathDir = NULL;
PSYSFSCPUPATH pAcpiCpuPathLvl = &g_aAcpiCpuPath[iLvlCurr];
/* Init everything. */
Assert(pAcpiCpuPathLvl->uId != ACPI_CPU_PATH_NOT_PROBED);
pszPath = RTPathJoinA(SYSFS_ACPI_CPU_PATH, pAcpiCpuPathLvl->aComponentsPossible[pAcpiCpuPathLvl->uId].pcszName);
if (!pszPath)
return VERR_NO_STR_MEMORY;
pAcpiCpuPathLvl->pszPath = RTStrDup(SYSFS_ACPI_CPU_PATH);
if (!pAcpiCpuPathLvl->pszPath)
{
RTStrFree(pszPath);
return VERR_NO_STR_MEMORY;
}
/* Open the directory */
rc = RTDirOpenFiltered(&pAcpiCpuPathLvl->pDir, pszPath, RTDIRFILTER_WINNT, 0);
if (RT_SUCCESS(rc))
{
RTStrFree(pszPath);
/* Search for CPU */
while (!fFound)
{
/* Get the next directory. */
RTDIRENTRY DirFolderContent;
rc = RTDirRead(pAcpiCpuPathLvl->pDir, &DirFolderContent, NULL);
if (RT_SUCCESS(rc))
{
/* Create the new path. */
char *pszPathCurr = RTPathJoinA(pAcpiCpuPathLvl->pszPath, DirFolderContent.szName);
if (!pszPathCurr)
{
rc = VERR_NO_STR_MEMORY;
break;
}
/* If this is the last level check for the given core and package id. */
if (iLvlCurr == RT_ELEMENTS(g_aAcpiCpuPath) - 1)
{
/* Get the sysdev */
uint32_t idCore = RTLinuxSysFsReadIntFile(10, "%s/sysdev/topology/core_id",
pszPathCurr);
uint32_t idPackage = RTLinuxSysFsReadIntFile(10, "%s/sysdev/topology/physical_package_id",
pszPathCurr);
if ( idCore == idCpuCore
&& idPackage == idCpuPackage)
{
/* Return the path */
pszPath = pszPathCurr;
fFound = true;
VBoxServiceVerbose(3, "CPU found\n");
break;
}
else
{
/* Get the next directory. */
RTStrFree(pszPathCurr);
VBoxServiceVerbose(3, "CPU doesn't match, next directory\n");
}
}
else
{
/* Go deeper */
iLvlCurr++;
VBoxServiceVerbose(3, "Going deeper (iLvlCurr=%u)\n", iLvlCurr);
pAcpiCpuPathLvl = &g_aAcpiCpuPath[iLvlCurr];
Assert(!pAcpiCpuPathLvl->pDir);
Assert(!pAcpiCpuPathLvl->pszPath);
pAcpiCpuPathLvl->pszPath = pszPathCurr;
PCSYSFSCPUPATHCOMP pPathComponent = &pAcpiCpuPathLvl->aComponentsPossible[pAcpiCpuPathLvl->uId];
Assert(pAcpiCpuPathLvl->uId != ACPI_CPU_PATH_NOT_PROBED);
pszPathDir = RTPathJoinA(pszPathCurr, pPathComponent->pcszName);
if (!pszPathDir)
{
rc = VERR_NO_STR_MEMORY;
break;
}
VBoxServiceVerbose(3, "New path %s\n", pszPathDir);
/* Open the directory */
rc = RTDirOpenFiltered(&pAcpiCpuPathLvl->pDir, pszPathDir, RTDIRFILTER_WINNT, 0);
if (RT_FAILURE(rc))
break;
}
}
else
{
/* Go back one level and try to get the next entry. */
Assert(iLvlCurr > 0);
RTDirClose(pAcpiCpuPathLvl->pDir);
RTStrFree(pAcpiCpuPathLvl->pszPath);
pAcpiCpuPathLvl->pDir = NULL;
pAcpiCpuPathLvl->pszPath = NULL;
iLvlCurr--;
pAcpiCpuPathLvl = &g_aAcpiCpuPath[iLvlCurr];
VBoxServiceVerbose(3, "Directory not found, going back (iLvlCurr=%u)\n", iLvlCurr);
}
} /* while not found */
} /* Successful init */
/* Cleanup */
for (unsigned i = 0; i < RT_ELEMENTS(g_aAcpiCpuPath); i++)
{
if (g_aAcpiCpuPath[i].pDir)
RTDirClose(g_aAcpiCpuPath[i].pDir);
if (g_aAcpiCpuPath[i].pszPath)
RTStrFree(g_aAcpiCpuPath[i].pszPath);
g_aAcpiCpuPath[i].pDir = NULL;
g_aAcpiCpuPath[i].pszPath = NULL;
}
if (pszPathDir)
RTStrFree(pszPathDir);
if (RT_FAILURE(rc) && pszPath)
RTStrFree(pszPath);
if (RT_SUCCESS(rc))
*ppszPath = pszPath;
}
return rc;
}
/**
* Probes for the correct path to the ACPI CPU object in sysfs for the
* various different kernel versions and distro's.
*
* @returns VBox status code.
*/
static int VBoxServiceCpuHotPlugProbePath(void)
{
int rc = VINF_SUCCESS;
/* Probe for the correct path if we didn't already. */
if (RT_UNLIKELY(g_aAcpiCpuPath[0].uId == ACPI_CPU_PATH_NOT_PROBED))
{
char *pszPath = NULL; /** < Current path, increasing while we dig deeper. */
pszPath = RTStrDup(SYSFS_ACPI_CPU_PATH);
if (!pszPath)
return VERR_NO_MEMORY;
/*
* Simple algorithm to find the path.
* Performance is not a real problem because it is
* only executed once.
*/
for (unsigned iLvlCurr = 0; iLvlCurr < RT_ELEMENTS(g_aAcpiCpuPath); iLvlCurr++)
{
PSYSFSCPUPATH pAcpiCpuPathLvl = &g_aAcpiCpuPath[iLvlCurr];
for (unsigned iCompCurr = 0; iCompCurr < pAcpiCpuPathLvl->cComponents; iCompCurr++)
{
PCSYSFSCPUPATHCOMP pPathComponent = &pAcpiCpuPathLvl->aComponentsPossible[iCompCurr];
/* Open the directory */
PRTDIR pDirCurr = NULL;
char *pszPathTmp = RTPathJoinA(pszPath, pPathComponent->pcszName);
if (pszPathTmp)
{
rc = RTDirOpenFiltered(&pDirCurr, pszPathTmp, RTDIRFILTER_WINNT, 0);
RTStrFree(pszPathTmp);
}
else
rc = VERR_NO_STR_MEMORY;
if (RT_FAILURE(rc))
break;
/* Search if the current directory contains one of the possible parts. */
size_t cchName = strlen(pPathComponent->pcszName);
RTDIRENTRY DirFolderContent;
bool fFound = false;
/* Get rid of the * filter which is in the path component. */
if (pPathComponent->fNumberedSuffix)
cchName--;
while (RT_SUCCESS(RTDirRead(pDirCurr, &DirFolderContent, NULL))) /* Assumption that szName has always enough space */
{
if ( DirFolderContent.cbName >= cchName
&& !strncmp(DirFolderContent.szName, pPathComponent->pcszName, cchName))
{
/* Found, use the complete name to dig deeper. */
fFound = true;
pAcpiCpuPathLvl->uId = iCompCurr;
char *pszPathLvl = RTPathJoinA(pszPath, DirFolderContent.szName);
if (pszPathLvl)
{
RTStrFree(pszPath);
pszPath = pszPathLvl;
}
else
rc = VERR_NO_STR_MEMORY;
break;
}
}
RTDirClose(pDirCurr);
if (fFound)
break;
} /* For every possible component. */
/* No matching component for this part, no need to continue */
if (RT_FAILURE(rc))
break;
} /* For every level */
VBoxServiceVerbose(1, "Final path after probing %s rc=%Rrc\n", pszPath, rc);
RTStrFree(pszPath);
}
return rc;
}
int main()
{
char szPath[RTPATH_MAX];
/*
* Init RT+Test.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTPath", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* RTPathExecDir, RTPathUserHome and RTProcGetExecutablePath.
*/
RTTestSub(hTest, "RTPathExecDir");
RTTESTI_CHECK_RC(rc = RTPathExecDir(szPath, sizeof(szPath)), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTestIPrintf(RTTESTLVL_INFO, "ExecDir={%s}\n", szPath);
RTTestSub(hTest, "RTProcGetExecutablePath");
if (RTProcGetExecutablePath(szPath, sizeof(szPath)) == szPath)
RTTestIPrintf(RTTESTLVL_INFO, "ExecutableName={%s}\n", szPath);
else
RTTestIFailed("RTProcGetExecutablePath -> NULL");
RTTestSub(hTest, "RTPathUserHome");
RTTESTI_CHECK_RC(rc = RTPathUserHome(szPath, sizeof(szPath)), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTestIPrintf(RTTESTLVL_INFO, "UserHome={%s}\n", szPath);
RTTestSub(hTest, "RTPathUserDocuments");
RTTESTI_CHECK_RC(rc = RTPathUserDocuments(szPath, sizeof(szPath)), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTestIPrintf(RTTESTLVL_INFO, "UserDocuments={%s}\n", szPath);
RTTestSub(hTest, "RTPathTemp");
RTTESTI_CHECK_RC(rc = RTPathTemp(szPath, sizeof(szPath)), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTestIPrintf(RTTESTLVL_INFO, "PathTemp={%s}\n", szPath);
size_t cch = strlen(szPath);
RTTESTI_CHECK_RC(RTPathTemp(szPath, cch), VERR_BUFFER_OVERFLOW);
RTTESTI_CHECK_RC(RTPathTemp(szPath, cch+1), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathTemp(szPath, cch+2), VINF_SUCCESS);
/*
* RTPathAbsEx
*/
RTTestSub(hTest, "RTPathAbsEx");
static const struct
{
const char *pcszInputBase;
const char *pcszInputPath;
int rc;
const char *pcszOutput;
}
s_aRTPathAbsExTests[] =
{
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
{ NULL, "", VERR_INVALID_PARAMETER, NULL },
{ NULL, ".", VINF_SUCCESS, "%p" },
{ NULL, "\\", VINF_SUCCESS, "%d\\" },
{ NULL, "\\..", VINF_SUCCESS, "%d\\" },
{ NULL, "/absolute/..", VINF_SUCCESS, "%d\\" },
{ NULL, "/absolute\\\\../..", VINF_SUCCESS, "%d\\" },
{ NULL, "/absolute//../path\\", VINF_SUCCESS, "%d\\path" },
{ NULL, "/absolute/../../path", VINF_SUCCESS, "%d\\path" },
{ NULL, "relative/../dir\\.\\.\\.\\file.txt", VINF_SUCCESS, "%p\\dir\\file.txt" },
{ NULL, "\\data\\", VINF_SUCCESS, "%d\\data" },
{ "relative_base/dir\\", "\\from_root", VINF_SUCCESS, "%d\\from_root" },
{ "relative_base/dir/", "relative_also", VINF_SUCCESS, "%p\\relative_base\\dir\\relative_also" },
#else
{ NULL, "", VERR_INVALID_PARAMETER, NULL },
{ NULL, ".", VINF_SUCCESS, "%p" },
{ NULL, "/", VINF_SUCCESS, "/" },
{ NULL, "/..", VINF_SUCCESS, "/" },
{ NULL, "/absolute/..", VINF_SUCCESS, "/" },
{ NULL, "/absolute\\\\../..", VINF_SUCCESS, "/" },
{ NULL, "/absolute//../path/", VINF_SUCCESS, "/path" },
{ NULL, "/absolute/../../path", VINF_SUCCESS, "/path" },
{ NULL, "relative/../dir/./././file.txt", VINF_SUCCESS, "%p/dir/file.txt" },
{ NULL, "relative/../dir\\.\\.\\.\\file.txt", VINF_SUCCESS, "%p/dir\\.\\.\\.\\file.txt" }, /* linux-specific */
{ NULL, "/data/", VINF_SUCCESS, "/data" },
{ "relative_base/dir/", "/from_root", VINF_SUCCESS, "/from_root" },
{ "relative_base/dir/", "relative_also", VINF_SUCCESS, "%p/relative_base/dir/relative_also" },
#endif
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
{ NULL, "C:\\", VINF_SUCCESS, "C:\\" },
{ "C:\\", "..", VINF_SUCCESS, "C:\\" },
{ "C:\\temp", "..", VINF_SUCCESS, "C:\\" },
{ "C:\\VirtualBox/Machines", "..\\VirtualBox.xml", VINF_SUCCESS, "C:\\VirtualBox\\VirtualBox.xml" },
{ "C:\\MustDie", "\\from_root/dir/..", VINF_SUCCESS, "C:\\from_root" },
{ "C:\\temp", "D:\\data", VINF_SUCCESS, "D:\\data" },
{ NULL, "\\\\server\\..\\share", VINF_SUCCESS, "\\\\server\\..\\share" /* kind of strange */ },
{ NULL, "\\\\server/", VINF_SUCCESS, "\\\\server" },
{ NULL, "\\\\", VINF_SUCCESS, "\\\\" },
{ NULL, "\\\\\\something", VINF_SUCCESS, "\\\\\\something" /* kind of strange */ },
{ "\\\\server\\share_as_base", "/from_root", VINF_SUCCESS, "\\\\server\\from_root" },
{ "\\\\just_server", "/from_root", VINF_SUCCESS, "\\\\just_server\\from_root" },
{ "\\\\server\\share_as_base", "relative\\data", VINF_SUCCESS, "\\\\server\\share_as_base\\relative\\data" },
{ "base", "\\\\?\\UNC\\relative/edwef/..", VINF_SUCCESS, "\\\\?\\UNC\\relative" },
{ "\\\\?\\UNC\\base", "/from_root", VERR_INVALID_NAME, NULL },
#else
{ "/temp", "..", VINF_SUCCESS, "/" },
{ "/VirtualBox/Machines", "../VirtualBox.xml", VINF_SUCCESS, "/VirtualBox/VirtualBox.xml" },
{ "/MustDie", "/from_root/dir/..", VINF_SUCCESS, "/from_root" },
{ "\\temp", "\\data", VINF_SUCCESS, "%p/\\temp/\\data" },
#endif
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aRTPathAbsExTests); ++ i)
{
rc = RTPathAbsEx(s_aRTPathAbsExTests[i].pcszInputBase,
s_aRTPathAbsExTests[i].pcszInputPath,
szPath, sizeof(szPath));
if (rc != s_aRTPathAbsExTests[i].rc)
{
RTTestIFailed("unexpected result code!\n"
" input base: '%s'\n"
" input path: '%s'\n"
" output: '%s'\n"
" rc: %Rrc\n"
" expected rc: %Rrc",
s_aRTPathAbsExTests[i].pcszInputBase,
s_aRTPathAbsExTests[i].pcszInputPath,
szPath, rc,
s_aRTPathAbsExTests[i].rc);
continue;
}
char szTmp[RTPATH_MAX];
char *pszExpected = NULL;
if (s_aRTPathAbsExTests[i].pcszOutput != NULL)
{
if (s_aRTPathAbsExTests[i].pcszOutput[0] == '%')
{
RTTESTI_CHECK_RC(rc = RTPathGetCurrent(szTmp, sizeof(szTmp)), VINF_SUCCESS);
if (RT_FAILURE(rc))
break;
pszExpected = szTmp;
if (s_aRTPathAbsExTests[i].pcszOutput[1] == 'p')
{
cch = strlen(szTmp);
if (cch + strlen(s_aRTPathAbsExTests[i].pcszOutput) - 2 <= sizeof(szTmp))
strcpy(szTmp + cch, s_aRTPathAbsExTests[i].pcszOutput + 2);
}
#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
else if (s_aRTPathAbsExTests[i].pcszOutput[1] == 'd')
{
if (2 + strlen(s_aRTPathAbsExTests[i].pcszOutput) - 2 <= sizeof(szTmp))
strcpy(szTmp + 2, s_aRTPathAbsExTests[i].pcszOutput + 2);
}
#endif
}
else
{
strcpy(szTmp, s_aRTPathAbsExTests[i].pcszOutput);
pszExpected = szTmp;
}
if (strcmp(szPath, pszExpected))
{
RTTestIFailed("Unexpected result\n"
" input base: '%s'\n"
" input path: '%s'\n"
" output: '%s'\n"
" expected: '%s'",
s_aRTPathAbsExTests[i].pcszInputBase,
s_aRTPathAbsExTests[i].pcszInputPath,
szPath,
s_aRTPathAbsExTests[i].pcszOutput);
}
}
}
/*
* RTPathStripFilename
*/
RTTestSub(hTest, "RTPathStripFilename");
static const char *s_apszStripFilenameTests[] =
{
"/usr/include///", "/usr/include//",
"/usr/include/", "/usr/include",
"/usr/include", "/usr",
"/usr", "/",
"usr", ".",
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
"c:/windows", "c:/",
"c:/", "c:/",
"D:", "D:",
"C:\\OS2\\DLLS", "C:\\OS2",
#endif
};
for (unsigned i = 0; i < RT_ELEMENTS(s_apszStripFilenameTests); i += 2)
{
const char *pszInput = s_apszStripFilenameTests[i];
const char *pszExpect = s_apszStripFilenameTests[i + 1];
strcpy(szPath, pszInput);
RTPathStripFilename(szPath);
if (strcmp(szPath, pszExpect))
{
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, szPath, pszExpect);
}
}
/*
* RTPathAppend.
*/
RTTestSub(hTest, "RTPathAppend");
static const char *s_apszAppendTests[] =
{
/* base append result */
"/", "", "/",
"", "/", "/",
"/", "/", "/",
"/x", "", "/x",
"/x", "/", "/x/",
"/", "x", "/x",
"dir", "file", "dir/file",
"dir", "/file", "dir/file",
"dir", "//file", "dir/file",
"dir", "///file", "dir/file",
"dir/", "/file", "dir/file",
"dir/", "//file", "dir/file",
"dir/", "///file", "dir/file",
"dir//", "file", "dir/file",
"dir//", "/file", "dir/file",
"dir//", "//file", "dir/file",
"dir///", "///file", "dir/file",
"/bin/testcase", "foo.r0", "/bin/testcase/foo.r0",
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
"/", "\\", "/",
"\\", "/", "\\",
"\\\\srv\\shr", "dir//", "\\\\srv\\shr/dir//",
"\\\\srv\\shr", "dir//file", "\\\\srv\\shr/dir//file",
"\\\\srv\\shr", "//dir//", "\\\\srv\\shr/dir//",
"\\\\srv\\shr", "/\\dir//", "\\\\srv\\shr\\dir//",
"\\\\", "not-srv/not-shr/file", "\\not-srv/not-shr/file",
"C:", "autoexec.bat", "C:autoexec.bat",
"C:", "/autoexec.bat", "C:/autoexec.bat",
"C:", "\\autoexec.bat", "C:\\autoexec.bat",
"C:\\", "/autoexec.bat", "C:\\autoexec.bat",
"C:\\\\", "autoexec.bat", "C:\\autoexec.bat",
"E:\\bin\\testcase", "foo.r0", "E:\\bin\\testcase/foo.r0",
#endif
};
for (unsigned i = 0; i < RT_ELEMENTS(s_apszAppendTests); i += 3)
{
const char *pszInput = s_apszAppendTests[i];
const char *pszAppend = s_apszAppendTests[i + 1];
const char *pszExpect = s_apszAppendTests[i + 2];
strcpy(szPath, pszInput);
RTTESTI_CHECK_RC(rc = RTPathAppend(szPath, sizeof(szPath), pszAppend), VINF_SUCCESS);
if (RT_FAILURE(rc))
continue;
if (strcmp(szPath, pszExpect))
{
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" append: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, pszAppend, szPath, pszExpect);
}
else
{
size_t const cchResult = strlen(szPath);
strcpy(szPath, pszInput);
RTTESTI_CHECK_RC(rc = RTPathAppend(szPath, cchResult + 2, pszAppend), VINF_SUCCESS);
RTTESTI_CHECK(RT_FAILURE(rc) || !strcmp(szPath, pszExpect));
strcpy(szPath, pszInput);
RTTESTI_CHECK_RC(rc = RTPathAppend(szPath, cchResult + 1, pszAppend), VINF_SUCCESS);
RTTESTI_CHECK(RT_FAILURE(rc) || !strcmp(szPath, pszExpect));
if (strlen(pszInput) < cchResult)
{
strcpy(szPath, pszInput);
RTTESTI_CHECK_RC(RTPathAppend(szPath, cchResult, pszAppend), VERR_BUFFER_OVERFLOW);
}
}
}
/*
* RTPathJoin - reuse the append tests.
*/
RTTestSub(hTest, "RTPathJoin");
for (unsigned i = 0; i < RT_ELEMENTS(s_apszAppendTests); i += 3)
{
const char *pszInput = s_apszAppendTests[i];
const char *pszAppend = s_apszAppendTests[i + 1];
const char *pszExpect = s_apszAppendTests[i + 2];
memset(szPath, 'a', sizeof(szPath)); szPath[sizeof(szPath) - 1] = '\0';
RTTESTI_CHECK_RC(rc = RTPathJoin(szPath, sizeof(szPath), pszInput, pszAppend), VINF_SUCCESS);
if (RT_FAILURE(rc))
continue;
if (strcmp(szPath, pszExpect))
{
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" append: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, pszAppend, szPath, pszExpect);
}
else
{
size_t const cchResult = strlen(szPath);
memset(szPath, 'a', sizeof(szPath)); szPath[sizeof(szPath) - 1] = '\0';
RTTESTI_CHECK_RC(rc = RTPathJoin(szPath, cchResult + 2, pszInput, pszAppend), VINF_SUCCESS);
RTTESTI_CHECK(RT_FAILURE(rc) || !strcmp(szPath, pszExpect));
memset(szPath, 'a', sizeof(szPath)); szPath[sizeof(szPath) - 1] = '\0';
RTTESTI_CHECK_RC(rc = RTPathJoin(szPath, cchResult + 1, pszInput, pszAppend), VINF_SUCCESS);
RTTESTI_CHECK(RT_FAILURE(rc) || !strcmp(szPath, pszExpect));
RTTESTI_CHECK_RC(rc = RTPathJoin(szPath, cchResult, pszInput, pszAppend), VERR_BUFFER_OVERFLOW);
}
}
/*
* RTPathJoinA - reuse the append tests.
*/
RTTestSub(hTest, "RTPathJoinA");
for (unsigned i = 0; i < RT_ELEMENTS(s_apszAppendTests); i += 3)
{
const char *pszInput = s_apszAppendTests[i];
const char *pszAppend = s_apszAppendTests[i + 1];
const char *pszExpect = s_apszAppendTests[i + 2];
char *pszPathDst;
RTTESTI_CHECK(pszPathDst = RTPathJoinA(pszInput, pszAppend));
if (!pszPathDst)
continue;
if (strcmp(pszPathDst, pszExpect))
{
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" append: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, pszAppend, pszPathDst, pszExpect);
}
RTStrFree(pszPathDst);
}
/*
* RTPathStripTrailingSlash
*/
static const char *s_apszStripTrailingSlash[] =
{
/* input result */
"/", "/",
"//", "/",
"////////////////////", "/",
"/tmp", "/tmp",
"/tmp////////////////", "/tmp",
"tmp", "tmp",
"tmp////////////////", "tmp",
"./", ".",
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
"////////////////////", "/",
"D:", "D:",
"D:/", "D:/",
"D:\\", "D:\\",
"D:\\/\\", "D:\\",
"D:/\\/\\", "D:/",
"C:/Temp", "D:/Temp",
"C:/Temp/", "D:/Temp/",
"C:/Temp\\/", "D:/Temp",
#endif
};
for (unsigned i = 0; i < RT_ELEMENTS(s_apszStripTrailingSlash); i += 2)
{
const char *pszInput = s_apszStripTrailingSlash[i];
const char *pszExpect = s_apszStripTrailingSlash[i + 1];
strcpy(szPath, pszInput);
cch = RTPathStripTrailingSlash(szPath);
if (strcmp(szPath, pszExpect))
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, szPath, pszExpect);
else
RTTESTI_CHECK(cch == strlen(szPath));
}
/*
* RTPathCountComponents
*/
RTTestSub(hTest, "RTPathCountComponents");
RTTESTI_CHECK(RTPathCountComponents("") == 0);
RTTESTI_CHECK(RTPathCountComponents("/") == 1);
RTTESTI_CHECK(RTPathCountComponents("//") == 1);
RTTESTI_CHECK(RTPathCountComponents("//////////////") == 1);
RTTESTI_CHECK(RTPathCountComponents("//////////////bin") == 2);
RTTESTI_CHECK(RTPathCountComponents("//////////////bin/") == 2);
RTTESTI_CHECK(RTPathCountComponents("//////////////bin/////") == 2);
RTTESTI_CHECK(RTPathCountComponents("..") == 1);
RTTESTI_CHECK(RTPathCountComponents("../") == 1);
RTTESTI_CHECK(RTPathCountComponents("../..") == 2);
RTTESTI_CHECK(RTPathCountComponents("../../") == 2);
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
RTTESTI_CHECK(RTPathCountComponents("d:") == 1);
RTTESTI_CHECK(RTPathCountComponents("d:/") == 1);
RTTESTI_CHECK(RTPathCountComponents("d:/\\") == 1);
RTTESTI_CHECK(RTPathCountComponents("d:\\") == 1);
RTTESTI_CHECK(RTPathCountComponents("c:\\config.sys") == 2);
RTTESTI_CHECK(RTPathCountComponents("c:\\windows") == 2);
RTTESTI_CHECK(RTPathCountComponents("c:\\windows\\") == 2);
RTTESTI_CHECK(RTPathCountComponents("c:\\windows\\system32") == 3);
RTTESTI_CHECK(RTPathCountComponents("//./C$") == 1);
RTTESTI_CHECK(RTPathCountComponents("\\\\.\\C$") == 1);
RTTESTI_CHECK(RTPathCountComponents("/\\.\\C$") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver/") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share/") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share\\") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share\\x") == 2);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share\\x\\y") == 3);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share\\x\\y\\") == 3);
#endif
/*
* RTPathCopyComponents
*/
struct
{
const char *pszSrc;
size_t cComponents;
const char *pszResult;
} s_aCopyComponents[] =
{
{ "", 0, "" },
{ "", 5, "" },
{ "/", 0, "" },
{ "/", 1, "/" },
{ "/", 2, "/" },
{ "/usr/bin/sed", 0, "" },
{ "/usr/bin/sed", 1, "/" },
{ "/usr/bin/sed", 2, "/usr/" },
{ "/usr/bin/sed", 3, "/usr/bin/" },
{ "/usr/bin/sed", 4, "/usr/bin/sed" },
{ "/usr/bin/sed", 5, "/usr/bin/sed" },
{ "/usr/bin/sed", 6, "/usr/bin/sed" },
{ "/usr///bin/sed", 2, "/usr///" },
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aCopyComponents); i++)
{
const char *pszInput = s_aCopyComponents[i].pszSrc;
size_t cComponents = s_aCopyComponents[i].cComponents;
const char *pszResult = s_aCopyComponents[i].pszResult;
memset(szPath, 'a', sizeof(szPath));
rc = RTPathCopyComponents(szPath, sizeof(szPath), pszInput, cComponents);
RTTESTI_CHECK_RC(rc, VINF_SUCCESS);
if (RT_SUCCESS(rc) && strcmp(szPath, pszResult))
RTTestIFailed("Unexpected result\n"
" input: '%s' cComponents=%u\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, cComponents, szPath, pszResult);
else if (RT_SUCCESS(rc))
{
RTTESTI_CHECK_RC(RTPathCopyComponents(szPath, strlen(pszResult) + 1, pszInput, cComponents), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathCopyComponents(szPath, strlen(pszResult), pszInput, cComponents), VERR_BUFFER_OVERFLOW);
}
}
/*
* RTPathStripExt
*/
RTTestSub(hTest, "RTPathStripExt");
struct
{
const char *pszSrc;
const char *pszResult;
} s_aStripExt[] =
{
{ "filename.ext", "filename" },
{ "filename.ext1.ext2.ext3", "filename.ext1.ext2" },
{ "filename..ext", "filename." },
{ "filename.ext.", "filename.ext" }, /** @todo This is a bit weird/wrong, but not half as weird as the way Windows+OS/2 deals with a trailing dots. */
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aStripExt); i++)
{
const char *pszInput = s_aStripExt[i].pszSrc;
const char *pszResult = s_aStripExt[i].pszResult;
strcpy(szPath, pszInput);
RTPathStripExt(szPath);
if (strcmp(szPath, pszResult))
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, szPath, pszResult);
}
/*
* RTPathCalcRelative
*/
RTTestSub(hTest, "RTPathCalcRelative");
struct
{
const char *pszFrom;
const char *pszTo;
int rc;
const char *pszExpected;
} s_aRelPath[] =
{
{ "/home/test.ext", "/home/test2.ext", VINF_SUCCESS, "test2.ext"},
{ "/dir/test.ext", "/dir/dir2/test2.ext", VINF_SUCCESS, "dir2/test2.ext"},
{ "/dir/dir2/test.ext", "/dir/test2.ext", VINF_SUCCESS, "../test2.ext"},
{ "/dir/dir2/test.ext", "/dir/dir3/test2.ext", VINF_SUCCESS, "../dir3/test2.ext"},
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
{ "\\\\server\\share\\test.ext", "\\\\server\\share2\\test2.ext", VERR_NOT_SUPPORTED, ""},
{ "c:\\dir\\test.ext", "f:\\dir\\test.ext", VERR_NOT_SUPPORTED, ""}
#endif
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aRelPath); i++)
{
const char *pszFrom = s_aRelPath[i].pszFrom;
const char *pszTo = s_aRelPath[i].pszTo;
rc = RTPathCalcRelative(szPath, sizeof(szPath), pszFrom, pszTo);
if (rc != s_aRelPath[i].rc)
RTTestIFailed("Unexpected return code\n"
" got: %Rrc\n"
"expected: %Rrc",
rc, s_aRelPath[i].rc);
else if ( RT_SUCCESS(rc)
&& strcmp(szPath, s_aRelPath[i].pszExpected))
RTTestIFailed("Unexpected result\n"
" from: '%s'\n"
" to: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszFrom, pszTo, szPath, s_aRelPath[i].pszExpected);
}
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
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;
}
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;
}