STDMETHODIMP SharedFolder::COMGETTER(Accessible) (BOOL *aAccessible)
{
CheckComArgOutPointerValid(aAccessible);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/* mName and mHostPath are constant during life time, no need to lock */
/* check whether the host path exists */
Utf8Str hostPath = m->strHostPath;
char hostPathFull[RTPATH_MAX];
int vrc = RTPathExists(hostPath.c_str()) ? RTPathReal(hostPath.c_str(),
hostPathFull,
sizeof(hostPathFull))
: VERR_PATH_NOT_FOUND;
if (RT_SUCCESS(vrc))
{
*aAccessible = TRUE;
return S_OK;
}
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
m->strLastAccessError = Utf8StrFmt(tr("'%s' is not accessible (%Rrc)"),
m->strHostPath.c_str(),
vrc);
LogWarningThisFunc(("m.lastAccessError=\"%s\"\n", m->strLastAccessError.c_str()));
*aAccessible = FALSE;
return S_OK;
}
/**
* Same as RTPathReal only the result is RTStrDup()'ed.
*
* @returns Pointer to real path. Use RTStrFree() to free this string.
* @returns NULL if RTPathReal() or RTStrDup() fails.
* @param pszPath
*/
RTDECL(char *) RTPathRealDup(const char *pszPath)
{
char szPath[RTPATH_MAX];
int rc = RTPathReal(pszPath, szPath, sizeof(szPath));
if (RT_SUCCESS(rc))
return RTStrDup(szPath);
return NULL;
}
int CollectorLinux::getDiskListByFs(const char *pszPath, DiskList& listUsage, DiskList& listLoad)
{
FILE *mtab = setmntent("/etc/mtab", "r");
if (mtab)
{
struct mntent *mntent;
while ((mntent = getmntent(mtab)))
{
/* Skip rootfs entry, there must be another root mount. */
if (strcmp(mntent->mnt_fsname, "rootfs") == 0)
continue;
if (strcmp(pszPath, mntent->mnt_dir) == 0)
{
char szDevName[128];
char szFsName[1024];
/* Try to resolve symbolic link if necessary. Yes, we access the file system here! */
int rc = RTPathReal(mntent->mnt_fsname, szFsName, sizeof(szFsName));
if (RT_FAILURE(rc))
continue; /* something got wrong, just ignore this path */
/* check against the actual mtab entry, NOT the real path as /dev/mapper/xyz is
* often a symlink to something else */
if (!strncmp(mntent->mnt_fsname, RT_STR_TUPLE("/dev/mapper")))
{
/* LVM */
getDiskName(szDevName, sizeof(szDevName), mntent->mnt_fsname, false /*=fTrimDigits*/);
addVolumeDependencies(szDevName, listUsage);
listLoad = listUsage;
}
else if (!strncmp(szFsName, RT_STR_TUPLE("/dev/md")))
{
/* Software RAID */
getDiskName(szDevName, sizeof(szDevName), szFsName, false /*=fTrimDigits*/);
listUsage.push_back(RTCString(szDevName));
addRaidDisks(szDevName, listLoad);
}
else
{
/* Plain disk partition. Trim the trailing digits to get the drive name */
getDiskName(szDevName, sizeof(szDevName), szFsName, true /*=fTrimDigits*/);
listUsage.push_back(RTCString(szDevName));
listLoad.push_back(RTCString(szDevName));
}
if (listUsage.empty() || listLoad.empty())
{
LogRel(("Failed to retrive disk info: getDiskName(%s) --> %s\n",
mntent->mnt_fsname, szDevName));
}
break;
}
}
endmntent(mtab);
}
return VINF_SUCCESS;
}
/** @copydoc KRDROPS::pfnCreate */
static int krdrRTFileCreate(PPKRDR ppRdr, const char *pszFilename)
{
KSIZE cchFilename;
PKRDRFILE pRdrFile;
RTFILE File;
uint64_t cb;
int rc;
char szFilename[RTPATH_MAX];
/*
* Open the file, determin its size and correct filename.
*/
rc = RTFileOpen(&File, pszFilename, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
if (RT_FAILURE(rc))
return rc;
rc = RTFileGetSize(File, &cb);
if (RT_SUCCESS(rc))
{
rc = RTPathReal(pszFilename, szFilename, sizeof(szFilename));
if (RT_SUCCESS(rc))
{
/*
* Allocate the reader instance.
*/
cchFilename = strlen(szFilename);
pRdrFile = (PKRDRFILE)RTMemAlloc(sizeof(*pRdrFile) + cchFilename);
if (pRdrFile)
{
/*
* Initialize it and return successfully.
*/
pRdrFile->Core.u32Magic = KRDR_MAGIC;
pRdrFile->Core.pOps = &g_kRdrFileOps;
pRdrFile->File = File;
pRdrFile->cb = cb;
pRdrFile->off = 0;
pRdrFile->cMappings = 0;
pRdrFile->cPreps = 0;
memcpy(&pRdrFile->szFilename[0], szFilename, cchFilename + 1);
*ppRdr = &pRdrFile->Core;
return 0;
}
rc = KERR_NO_MEMORY;
}
}
RTFileClose(File);
return rc;
}
/* static */
int getDriveInfoFromEnv(const char *pcszVar, DriveInfoList *pList,
bool isDVD, bool *pfSuccess)
{
AssertPtrReturn(pcszVar, VERR_INVALID_POINTER);
AssertPtrReturn(pList, VERR_INVALID_POINTER);
AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
LogFlowFunc(("pcszVar=%s, pList=%p, isDVD=%d, pfSuccess=%p\n", pcszVar,
pList, isDVD, pfSuccess));
int rc = VINF_SUCCESS;
bool success = false;
char *pszFreeMe = RTEnvDupEx(RTENV_DEFAULT, pcszVar);
try
{
const char *pcszCurrent = pszFreeMe;
while (pcszCurrent && *pcszCurrent != '\0')
{
const char *pcszNext = strchr(pcszCurrent, ':');
char szPath[RTPATH_MAX], szReal[RTPATH_MAX];
char szDesc[256], szUdi[256];
if (pcszNext)
RTStrPrintf(szPath, sizeof(szPath), "%.*s",
pcszNext - pcszCurrent - 1, pcszCurrent);
else
RTStrPrintf(szPath, sizeof(szPath), "%s", pcszCurrent);
if ( RT_SUCCESS(RTPathReal(szPath, szReal, sizeof(szReal)))
&& devValidateDevice(szReal, isDVD, NULL, szDesc,
sizeof(szDesc), szUdi, sizeof(szUdi)))
{
pList->push_back(DriveInfo(szReal, szUdi, szDesc));
success = true;
}
pcszCurrent = pcszNext ? pcszNext + 1 : NULL;
}
if (pfSuccess != NULL)
*pfSuccess = success;
}
catch(std::bad_alloc &e)
{
rc = VERR_NO_MEMORY;
}
RTStrFree(pszFreeMe);
LogFlowFunc(("rc=%Rrc, success=%d\n", rc, success));
return rc;
}
/**
* Common worker for opening a directory.
*
* @returns IPRT status code.
* @param ppDir Where to store the directory handle.
* @param pszPath The specified path.
* @param pszFilter Pointer to where the filter start in the path. NULL if no filter.
* @param enmFilter The type of filter to apply.
*/
static int rtDirOpenCommon(PRTDIR *ppDir, const char *pszPath, const char *pszFilter, RTDIRFILTER enmFilter)
{
/*
* Expand the path.
*
* The purpose of this exercise to have the abs path around
* for querying extra information about the objects we list.
* As a sideeffect we also validate the path here.
*/
char szRealPath[RTPATH_MAX + 1];
int rc;
size_t cbFilter; /* includes '\0' (thus cb and not cch). */
size_t cucFilter0; /* includes U+0. */
if (!pszFilter)
{
cbFilter = cucFilter0 = 0;
rc = RTPathAbs(pszPath, szRealPath, sizeof(szRealPath) - 1);
}
else
{
cbFilter = strlen(pszFilter) + 1;
cucFilter0 = RTStrUniLen(pszFilter) + 1;
if (pszFilter != pszPath)
{
/* yea, I'm lazy. sue me. */
char *pszTmp = RTStrDup(pszPath);
if (!pszTmp)
return VERR_NO_MEMORY;
pszTmp[pszFilter - pszPath] = '\0';
rc = RTPathAbs(pszTmp, szRealPath, sizeof(szRealPath) - 1);
RTStrFree(pszTmp);
}
else
rc = RTPathReal(".", szRealPath, sizeof(szRealPath) - 1);
}
if (RT_FAILURE(rc))
return rc;
/* add trailing '/' if missing. */
size_t cchRealPath = strlen(szRealPath);
if (!RTPATH_IS_SEP(szRealPath[cchRealPath - 1]))
{
szRealPath[cchRealPath++] = RTPATH_SLASH;
szRealPath[cchRealPath] = '\0';
}
/*
* Allocate and initialize the directory handle.
*
* The posix definition of Data.d_name allows it to be < NAME_MAX + 1,
* thus the horrible ugliness here. Solaris uses d_name[1] for instance.
*/
size_t cbDir = rtDirNativeGetStructSize(szRealPath);
size_t const cbAllocated = cbDir
+ cucFilter0 * sizeof(RTUNICP)
+ cbFilter
+ cchRealPath + 1 + 4;
PRTDIR pDir = (PRTDIR)RTMemAllocZ(cbAllocated);
if (!pDir)
return VERR_NO_MEMORY;
uint8_t *pb = (uint8_t *)pDir + cbDir;
/* initialize it */
pDir->u32Magic = RTDIR_MAGIC;
pDir->cbSelf = cbDir;
if (cbFilter)
{
pDir->puszFilter = (PRTUNICP)pb;
rc = RTStrToUniEx(pszFilter, RTSTR_MAX, &pDir->puszFilter, cucFilter0, &pDir->cucFilter);
AssertRC(rc);
pb += cucFilter0 * sizeof(RTUNICP);
pDir->pszFilter = (char *)memcpy(pb, pszFilter, cbFilter);
pDir->cchFilter = cbFilter - 1;
pb += cbFilter;
}
else
{
pDir->puszFilter = NULL;
pDir->cucFilter = 0;
pDir->pszFilter = NULL;
pDir->cchFilter = 0;
}
pDir->enmFilter = enmFilter;
switch (enmFilter)
{
default:
case RTDIRFILTER_NONE:
pDir->pfnFilter = NULL;
break;
case RTDIRFILTER_WINNT:
pDir->pfnFilter = rtDirFilterWinNtInit(pDir);
break;
case RTDIRFILTER_UNIX:
pDir->pfnFilter = NULL;
break;
case RTDIRFILTER_UNIX_UPCASED:
pDir->pfnFilter = NULL;
break;
}
pDir->cchPath = cchRealPath;
pDir->pszPath = (char *)memcpy(pb, szRealPath, cchRealPath + 1);
Assert(pb - (uint8_t *)pDir + cchRealPath + 1 <= cbAllocated);
pDir->fDataUnread = false;
pDir->pszName = NULL;
pDir->cchName = 0;
/*
* Hand it over to the native part.
*/
rc = rtDirNativeOpen(pDir, szRealPath);
if (RT_SUCCESS(rc))
*ppDir = pDir;
else
RTMemFree(pDir);
return rc;
}
