static void test1(RTTEST hTest, const char *pszBaseDir)
{
char szPath1[RTPATH_MAX];
char szPath2[RTPATH_MAX];
/*
* Making some assumptions about how we are executed from to start with...
*/
RTTestISub("Negative RTSymlinkRead, Exists & IsDangling");
char szExecDir[RTPATH_MAX];
RTTESTI_CHECK_RC_OK_RETV(RTPathExecDir(szExecDir, sizeof(szExecDir)));
size_t cchExecDir = strlen(szExecDir);
RTTESTI_CHECK(RTDirExists(szExecDir));
char szExecFile[RTPATH_MAX];
RTTESTI_CHECK_RETV(RTProcGetExecutablePath(szExecFile, sizeof(szExecFile)) != NULL);
size_t cchExecFile = strlen(szExecFile);
RTTESTI_CHECK(RTFileExists(szExecFile));
RTTESTI_CHECK(!RTSymlinkExists(szExecFile));
RTTESTI_CHECK(!RTSymlinkExists(szExecDir));
RTTESTI_CHECK(!RTSymlinkIsDangling(szExecFile));
RTTESTI_CHECK(!RTSymlinkIsDangling(szExecDir));
RTTESTI_CHECK(!RTSymlinkExists("/"));
RTTESTI_CHECK(!RTSymlinkIsDangling("/"));
RTTESTI_CHECK(!RTSymlinkExists("/some/non-existing/directory/name/iprt"));
RTTESTI_CHECK(!RTSymlinkExists("/some/non-existing/directory/name/iprt/"));
RTTESTI_CHECK(!RTSymlinkIsDangling("/some/non-existing/directory/name/iprt"));
RTTESTI_CHECK(!RTSymlinkIsDangling("/some/non-existing/directory/name/iprt/"));
RTTESTI_CHECK_RC(RTSymlinkRead(szExecFile, szPath1, sizeof(szPath1), 0), VERR_NOT_SYMLINK);
RTTESTI_CHECK_RC(RTSymlinkRead(szExecDir, szPath1, sizeof(szPath1), 0), VERR_NOT_SYMLINK);
/*
* Do some symlinking. ASSUME they are supported on the test file system.
*/
RTTestISub("Basics");
RTTESTI_CHECK_RETV(RTDirExists(pszBaseDir));
test1Worker(hTest, pszBaseDir, szExecFile, RTSYMLINKTYPE_FILE, false /*fDangling*/);
test1Worker(hTest, pszBaseDir, szExecDir, RTSYMLINKTYPE_DIR, false /*fDangling*/);
test1Worker(hTest, pszBaseDir, szExecFile, RTSYMLINKTYPE_UNKNOWN, false /*fDangling*/);
test1Worker(hTest, pszBaseDir, szExecDir, RTSYMLINKTYPE_UNKNOWN, false /*fDangling*/);
/*
* Create a few dangling links.
*/
RTTestISub("Dangling links");
test1Worker(hTest, pszBaseDir, "../dangle/dangle", RTSYMLINKTYPE_FILE, true /*fDangling*/);
test1Worker(hTest, pszBaseDir, "../dangle/dangle", RTSYMLINKTYPE_DIR, true /*fDangling*/);
test1Worker(hTest, pszBaseDir, "../dangle/dangle", RTSYMLINKTYPE_UNKNOWN, true /*fDangling*/);
test1Worker(hTest, pszBaseDir, "../dangle/dangle/", RTSYMLINKTYPE_UNKNOWN, true /*fDangling*/);
}
static int vbglR3DnDCreateDropDir(char* pszDropDir, size_t cbSize)
{
/* Validate input */
AssertPtrReturn(pszDropDir, VERR_INVALID_POINTER);
AssertReturn(cbSize, VERR_INVALID_PARAMETER);
/* Get the users document directory (usually $HOME/Documents). */
int rc = RTPathUserDocuments(pszDropDir, cbSize);
if (RT_FAILURE(rc))
return rc;
/* Append our base drop directory. */
rc = RTPathAppend(pszDropDir, cbSize, "VirtualBox Dropped Files");
if (RT_FAILURE(rc))
return rc;
/* Create it when necessary. */
if (!RTDirExists(pszDropDir))
{
rc = RTDirCreateFullPath(pszDropDir, RTFS_UNIX_IRWXU);
if (RT_FAILURE(rc))
return rc;
}
/* The actually drop directory consist of the current time stamp and a
* unique number when necessary. */
char pszTime[64];
RTTIMESPEC time;
if (!RTTimeSpecToString(RTTimeNow(&time), pszTime, sizeof(pszTime)))
return VERR_BUFFER_OVERFLOW;
rc = RTPathAppend(pszDropDir, cbSize, pszTime);
if (RT_FAILURE(rc))
return rc;
/* Create it (only accessible by the current user) */
return RTDirCreateUniqueNumbered(pszDropDir, cbSize, RTFS_UNIX_IRWXU, 3, '-');
}
int GetVBoxUserHomeDirectory(char *aDir, size_t aDirLen)
{
AssertReturn(aDir, VERR_INVALID_POINTER);
AssertReturn(aDirLen > 0, VERR_BUFFER_OVERFLOW);
/* start with null */
*aDir = 0;
char szTmp[RTPATH_MAX];
int vrc = RTEnvGetEx(RTENV_DEFAULT, "VBOX_USER_HOME", szTmp, sizeof(szTmp), NULL);
if (RT_SUCCESS(vrc) || vrc == VERR_ENV_VAR_NOT_FOUND)
{
if (RT_SUCCESS(vrc))
{
/* get the full path name */
vrc = RTPathAbs(szTmp, aDir, aDirLen);
}
else
{
/* compose the config directory (full path) */
/** @todo r=bird: RTPathUserHome doesn't necessarily return a full (abs) path
* like the comment above seems to indicate. */
vrc = RTPathUserHome(aDir, aDirLen);
if (RT_SUCCESS(vrc))
vrc = RTPathAppend(aDir, aDirLen, VBOX_USER_HOME_SUFFIX);
}
/* ensure the home directory exists */
if (RT_SUCCESS(vrc))
if (!RTDirExists(aDir))
vrc = RTDirCreateFullPath(aDir, 0700);
}
return vrc;
}
/**
* Checks if the specified directory is part of a SVN working copy.
*
* @returns true if it is, false if it isn't or we cannot tell.
* @param pszDir The directory in question.
*/
bool ScmSvnIsDirInWorkingCopy(const char *pszDir)
{
#ifdef SCM_WITHOUT_LIBSVN
scmSvnFindSvnBinary(NULL);
if (g_enmSvnVersion < kScmSvnVersion_1_7)
{
/*
* Hack: check if the .svn/ dir exists.
*/
char szPath[RTPATH_MAX];
int rc = RTPathJoin(szPath, sizeof(szPath), pszDir, ".svn");
if (RT_SUCCESS(rc))
return RTDirExists(szPath);
}
else
{
const char *apszArgs[] = { g_szSvnPath, "propget", "svn:no-such-property", pszDir, NULL };
char *pszValue;
int rc = scmSvnRunAndGetOutput(NULL, apszArgs, true, &pszValue);
if (RT_SUCCESS(rc))
{
RTStrFree(pszValue);
return true;
}
}
#else
NOREF(pState);
#endif
return false;
}
int main(int argc, char *argv[])
{
RTR3InitExe(argc, &argv, 0);
int rc;
RTPrintf("tstVD: TESTING...\n");
/*
* Clean up potential leftovers from previous unsuccessful runs.
*/
RTFileDelete("tmpVDCreate.vdi");
if (!RTDirExists("tmp"))
{
rc = RTDirCreate("tmp", RTFS_UNIX_IRWXU, 0);
if (RT_FAILURE(rc))
{
RTPrintf("tstVD: Failed to create 'tmp' directory! rc=%Rrc\n", rc);
g_cErrors++;
}
}
#ifdef VDI_TEST
rc = tstVDCreateShareDelete("VDI", "tmpVDCreate.vdi", 10 * _1M,
VD_IMAGE_FLAGS_FIXED);
if (RT_FAILURE(rc))
{
RTPrintf("tstVD: VDI shareable test failed! rc=%Rrc\n", rc);
g_cErrors++;
}
#endif /* VDI_TEST */
/*
* Clean up any leftovers.
*/
RTFileDelete("tmpVDCreate.vdi");
rc = VDShutdown();
if (RT_FAILURE(rc))
{
RTPrintf("tstVD: unloading backends failed! rc=%Rrc\n", rc);
g_cErrors++;
}
/*
* Summary
*/
if (!g_cErrors)
RTPrintf("tstVD: SUCCESS\n");
else
RTPrintf("tstVD: FAILURE - %d errors\n", g_cErrors);
return !!g_cErrors;
}
/**
* Adds a image bundle of some sort.
*
* @returns IPRT status code.
* @param pszPath Path to the bundle. This a RTPATH_MAX size
* buffer that we can write to when creating the
* path to the file inside the bundle that we're
* interested in.
* @param cchPath The length of the path up to the bundle name.
* @param cchName The length of the bundle name.
* @param pDirEntry The directory entry buffer, for handling bundle
* within bundle recursion.
* @param pCfg The configuration.
*/
static int rtDbgSymCacheAddImageBundle(char *pszPath, size_t cchPath, size_t cchName,
PRTDIRENTRYEX pDirEntry, PCRTDBGSYMCACHEADDCFG pCfg)
{
/*
* Assuming these are kexts or simple applications, we only add the image
* file itself to the cache. No Info.plist or other files.
*/
/** @todo consider looking for Frameworks and handling framework bundles. */
int rc = rtDbgSymCacheConstructBundlePath(pszPath, cchPath, cchName, "Contents/MacOS/", g_apszBundleSuffixes);
if (RT_SUCCESS(rc))
rc = rtDbgSymCacheAddImageFile(pszPath, NULL, RTDBG_CACHE_UUID_MAP_DIR_IMAGES, pCfg);
/*
* Look for plugins and other sub-bundles.
*/
if (pCfg->fRecursive)
{
static char const * const s_apszSubBundleDirs[] =
{
"Contents/Plugins/",
/** @todo Frameworks ++ */
};
for (uint32_t i = 0; i < RT_ELEMENTS(s_apszSubBundleDirs); i++)
{
pszPath[cchPath + cchName] = '\0';
int rc2 = RTPathAppend(pszPath, RTPATH_MAX - 1, s_apszSubBundleDirs[i]);
if (RT_SUCCESS(rc2))
{
if (RTDirExists(pszPath))
{
size_t cchPath2 = strlen(pszPath);
if (!RTPATH_IS_SLASH(pszPath[cchPath2 - 1]))
{
pszPath[cchPath2++] = RTPATH_SLASH;
pszPath[cchPath2] = '\0';
}
rc2 = rtDbgSymCacheAddDirWorker(pszPath, cchPath2, pDirEntry, pCfg);
}
}
else
{
pszPath[cchPath + cchName] = '\0';
RTMsgError("Error constructing bundle subdir path for '%s' + '%s': %Rrc", pszPath, s_apszSubBundleDirs[i], rc);
}
if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
rc = rc2;
}
}
return rc;
}
/**
* Adds a file to the cache.
*
* @returns IPRT status code.
* @param pszSrcPath Path to the source file.
* @param pszDstName The name of the destionation file (no path stuff).
* @param pszExtraSuff Optional extra suffix. Mach-O dSYM hack.
* @param pszDstSubDir The subdirectory to file it under. This is the
* stringification of a relatively unique identifier of
* the file in question.
* @param pAddToUuidMap Optional file UUID that is used to create a UUID map
* entry.
* @param pszUuidMapDir The UUID map subdirectory in the cache, if this is
* wanted, otherwise NULL.
* @param pCfg The configuration.
*/
static int rtDbgSymCacheAddOneFile(const char *pszSrcPath, const char *pszDstName, const char *pszExtraStuff,
const char *pszDstSubDir, PRTUUID pAddToUuidMap, const char *pszUuidMapDir,
PCRTDBGSYMCACHEADDCFG pCfg)
{
/*
* Build and create the destination path, step by step.
*/
char szDstPath[RTPATH_MAX];
int rc = RTPathJoin(szDstPath, sizeof(szDstPath), pCfg->pszCache, pszDstName);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Error constructing cache path for '%s': %Rrc", pszSrcPath, rc);
if (!RTDirExists(szDstPath))
{
rc = RTDirCreate(szDstPath, 0755, RTDIRCREATE_FLAGS_NOT_CONTENT_INDEXED_NOT_CRITICAL);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Error creating '%s': %Rrc", szDstPath, rc);
}
rc = RTPathAppend(szDstPath, sizeof(szDstPath), pszDstSubDir);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Error constructing cache path for '%s': %Rrc", pszSrcPath, rc);
if (!RTDirExists(szDstPath))
{
rc = RTDirCreate(szDstPath, 0755, RTDIRCREATE_FLAGS_NOT_CONTENT_INDEXED_NOT_CRITICAL);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Error creating '%s': %Rrc", szDstPath, rc);
}
rc = RTPathAppend(szDstPath, sizeof(szDstPath), pszDstName);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Error constructing cache path for '%s': %Rrc", pszSrcPath, rc);
if (pszExtraStuff)
{
rc = RTStrCat(szDstPath, sizeof(szDstPath), pszExtraStuff);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Error constructing cache path for '%s': %Rrc", pszSrcPath, rc);
}
/*
* If the file exists, we compare the two and throws an error if the doesn't match.
*/
if (RTPathExists(szDstPath))
{
rc = RTFileCompare(pszSrcPath, szDstPath);
if (RT_SUCCESS(rc))
{
RTMsgInfo("%s is already in the cache.", pszSrcPath);
if (pAddToUuidMap && pszUuidMapDir)
return rtDbgSymCacheAddCreateUuidMapping(szDstPath, pAddToUuidMap, pszUuidMapDir, pCfg);
return VINF_SUCCESS;
}
if (rc == VERR_NOT_EQUAL)
RTMsgInfo("Cache conflict with existing entry '%s' when inserting '%s'.", szDstPath, pszSrcPath);
else
RTMsgInfo("Error comparing '%s' with '%s': %Rrc", pszSrcPath, szDstPath, rc);
if (!pCfg->fOverwriteOnConflict)
return rc;
}
/*
* The file doesn't exist or we should overwrite it,
*/
RTMsgInfo("Copying '%s' to '%s'...", pszSrcPath, szDstPath);
rc = RTFileCopy(pszSrcPath, szDstPath);
if (RT_FAILURE(rc))
return RTMsgErrorRc(rc, "Error copying '%s' to '%s': %Rrc", pszSrcPath, szDstPath, rc);
if (pAddToUuidMap && pszUuidMapDir)
return rtDbgSymCacheAddCreateUuidMapping(szDstPath, pAddToUuidMap, pszUuidMapDir, pCfg);
return VINF_SUCCESS;
}
/**
* 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.
*/
char chSaved = RTPATH_SLASH;
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;
}
/**
* Handles the 'add' command.
*
* @returns Program exit code.
* @param pszArg0 The program name.
* @param cArgs The number of arguments to the 'add' command.
* @param papszArgs The argument vector, starting after 'add'.
*/
static RTEXITCODE rtDbgSymCacheCmdAdd(const char *pszArg0, int cArgs, char **papszArgs)
{
/*
* Parse the command line.
*/
static RTGETOPTDEF const s_aOptions[] =
{
{ "--recursive", 'R', RTGETOPT_REQ_NOTHING },
{ "--no-recursive", 'n', RTGETOPT_REQ_NOTHING },
{ "--overwrite-on-conflict", 'o', RTGETOPT_REQ_NOTHING },
};
const char *pszCache = NULL;
bool fRecursive = false;
bool fOverwriteOnConflict = false;
RTGETOPTSTATE State;
int rc = RTGetOptInit(&State, cArgs, papszArgs, &s_aOptions[0], RT_ELEMENTS(s_aOptions), 0, RTGETOPTINIT_FLAGS_OPTS_FIRST);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTGetOptInit failed: %Rrc", rc);
uint32_t cAdded = 0;
RTGETOPTUNION ValueUnion;
int chOpt;
while ((chOpt = RTGetOpt(&State, &ValueUnion)) != 0)
{
switch (chOpt)
{
case 'R':
fRecursive = true;
break;
case 'n':
fRecursive = false;
break;
case 'o':
fOverwriteOnConflict = true;
break;
case VINF_GETOPT_NOT_OPTION:
/* The first non-option is a cache directory. */
if (!pszCache)
{
pszCache = ValueUnion.psz;
if (!RTPathExists(pszCache))
{
rc = RTDirCreate(pszCache, 0755, RTDIRCREATE_FLAGS_NOT_CONTENT_INDEXED_NOT_CRITICAL);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Error creating cache directory '%s': %Rrc", pszCache, rc);
}
else if (!RTDirExists(pszCache))
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Specified cache directory is not a directory: '%s'", pszCache);
}
/* Subsequent non-options are files to be added to the cache. */
else
{
RTEXITCODE rcExit = rtDbgSymCacheAddFileOrDir(ValueUnion.psz, pszCache, fRecursive, fOverwriteOnConflict);
if (rcExit != RTEXITCODE_FAILURE)
return rcExit;
}
break;
case 'h':
return rtDbgSymCacheUsage(pszArg0, "add");
case 'V':
return rtDbgSymCacheVersion();
default:
return RTGetOptPrintError(chOpt, &ValueUnion);
}
}
if (!pszCache)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No cache directory or files to add were specified.");
return RTEXITCODE_SUCCESS;
}
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);
char szPath3[RTPATH_MAX];
RTStrCopy(szPath3, sizeof(szPath3), pszTarget);
#ifdef RT_OS_WINDOWS
/* see RTSymlinkCreate in symlink-win.cpp */
char c;
char *psz = szPath3;
while ((c = *psz) != '\0')
{
if (c == '/')
*psz = '\\';
psz++;
}
#endif
/* 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, szPath3) == 0, ("got=\"%s\" expected=\"%s\"", szPath2, szPath3));
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, szPath3) == 0, ("got=\"%s\" expected=\"%s\"", szPath2, szPath3));
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, szPath3, cchTarget - 1) == 0
&& szPath2[cchTarget - 1] == '\0',
("got=\"%s\" expected=\"%.*s\"", szPath2, cchTarget - 1, szPath3));
/* 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 main(int argc, char **argv)
{
RTEXITCODE rcExit = RTTestInitAndCreate("tstRTPrfIO", &g_hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
RTTestBanner(g_hTest);
/*
* Parse arguments
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--test-dir", 'd', RTGETOPT_REQ_STRING },
};
bool fFileOpenCloseTest = true;
bool fFileWriteByteTest = true;
bool fPathQueryInfoTest = true;
//bool fFileTests = true;
//bool fDirTests = true;
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'd':
g_pszTestDir = ValueUnion.psz;
break;
case 'V':
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "$Revision$\n");
return RTTestSummaryAndDestroy(g_hTest);
case 'h':
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "usage: testname [-d <testdir>]\n");
return RTTestSummaryAndDestroy(g_hTest);
default:
RTTestFailed(g_hTest, "invalid argument");
RTGetOptPrintError(ch, &ValueUnion);
return RTTestSummaryAndDestroy(g_hTest);
}
}
/*
* Set up and check the prerequisites.
*/
RTTESTI_CHECK_RC(RTPathJoin(g_szTestFile1, sizeof(g_szTestFile1), g_pszTestDir, "tstRTPrfIO-TestFile1"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szTestDir1, sizeof(g_szTestDir1), g_pszTestDir, "tstRTPrfIO-TestDir1"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szNotExitingFile, sizeof(g_szNotExitingFile), g_pszTestDir, "tstRTPrfIO-nonexistent-file"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szNotExitingDir, sizeof(g_szNotExitingDir), g_pszTestDir, "tstRTPrfIO-nonexistent-dir"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szNotExitingDirFile, sizeof(g_szNotExitingDirFile), g_szNotExitingDir, "nonexistent-file"), VINF_SUCCESS);
RTTESTI_CHECK(RTDirExists(g_pszTestDir));
if (RTPathExists(g_szTestDir1))
RTTestFailed(g_hTest, "The primary test directory (%s) already exist, please remove it", g_szTestDir1);
if (RTPathExists(g_szTestFile1))
RTTestFailed(g_hTest, "The primary test file (%s) already exist, please remove it", g_szTestFile1);
if (RTPathExists(g_szNotExitingFile))
RTTestFailed(g_hTest, "'%s' exists, remove it", g_szNotExitingFile);
if (RTPathExists(g_szNotExitingDir))
RTTestFailed(g_hTest, "'%s' exists, remove it", g_szNotExitingDir);
if (RTPathExists(g_szNotExitingDirFile))
RTTestFailed(g_hTest, "'%s' exists, remove it", g_szNotExitingDirFile);
/*
* Do the testing.
*/
if (RTTestIErrorCount() == 0)
{
#if 1
if (fPathQueryInfoTest)
benchmarkPathQueryInfo();
if (fFileOpenCloseTest)
benchmarkFileOpenClose();
#endif
if (fFileWriteByteTest)
benchmarkFileWriteByte();
//if (fFileTests)
// benchmarkFile();
//if (fDirTests)
// benchmarkDir();
/*
* Cleanup.
*/
RTFileDelete(g_szTestFile1);
RTDirRemoveRecursive(g_szTestDir1, 0);
RTTESTI_CHECK(RTDirExists(g_pszTestDir));
RTTESTI_CHECK(!RTPathExists(g_szTestDir1));
RTTESTI_CHECK(!RTPathExists(g_szTestFile1));
}
return RTTestSummaryAndDestroy(g_hTest);
}
RTDECL(int) RTCrStoreCreateSnapshotById(PRTCRSTORE phStore, RTCRSTOREID enmStoreId, PRTERRINFO pErrInfo)
{
AssertReturn(enmStoreId > RTCRSTOREID_INVALID && enmStoreId < RTCRSTOREID_END, VERR_INVALID_PARAMETER);
/*
* Create an empty in-memory store.
*/
RTCRSTORE hStore;
uint32_t cExpected = enmStoreId == RTCRSTOREID_SYSTEM_TRUSTED_CAS_AND_CERTIFICATES ? 256 : 0;
int rc = RTCrStoreCreateInMem(&hStore, cExpected);
if (RT_SUCCESS(rc))
{
*phStore = hStore;
/*
* Add system certificates if part of the given store ID.
*/
bool fFound = false;
rc = VINF_SUCCESS;
if (enmStoreId == RTCRSTOREID_SYSTEM_TRUSTED_CAS_AND_CERTIFICATES)
{
for (uint32_t i = 0; i < RT_ELEMENTS(g_apszSystemPemFiles); i++)
if (RTFileExists(g_apszSystemPemFiles[i]))
{
fFound = true;
int rc2 = RTCrStoreCertAddFromFile(hStore,
RTCRCERTCTX_F_ADD_IF_NOT_FOUND | RTCRCERTCTX_F_ADD_CONTINUE_ON_ERROR,
g_apszSystemPemFiles[i], pErrInfo);
if (RT_FAILURE(rc2))
rc = -rc2;
}
/*
* If we didn't find any of the certificate collection files, go hunting
* for directories containing PEM/CRT files with single certificates.
*/
if (!fFound)
for (uint32_t i = 0; i < RT_ELEMENTS(g_apszSystemPemDirs); i++)
if (RTDirExists(g_apszSystemPemDirs[i]))
{
static RTSTRTUPLE const s_aSuffixes[] =
{
{ RT_STR_TUPLE(".crt") },
{ RT_STR_TUPLE(".pem") },
{ RT_STR_TUPLE(".PEM") },
{ RT_STR_TUPLE(".CRT") },
};
fFound = true;
int rc2 = RTCrStoreCertAddFromDir(hStore,
RTCRCERTCTX_F_ADD_IF_NOT_FOUND | RTCRCERTCTX_F_ADD_CONTINUE_ON_ERROR,
g_apszSystemPemDirs[i], &s_aSuffixes[0], RT_ELEMENTS(s_aSuffixes),
pErrInfo);
if (RT_FAILURE(rc2))
rc = -rc2;
}
}
}
else
RTErrInfoAdd(pErrInfo, rc, " RTCrStoreCreateInMem failed");
return rc;
}