HRESULT Guest::taskCopyFileFromGuest(GuestTask *aTask)
{
LogFlowFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/*
* Do *not* take a write lock here since we don't (and won't)
* touch any class-specific data (of IGuest) here - only the member functions
* which get called here can do that.
*/
HRESULT rc = S_OK;
try
{
ComObjPtr<Guest> pGuest = aTask->pGuest;
/* Does our source file exist? */
BOOL fFileExists;
rc = pGuest->FileExists(Bstr(aTask->strSource).raw(),
Bstr(aTask->strUserName).raw(), Bstr(aTask->strPassword).raw(),
&fFileExists);
if (SUCCEEDED(rc))
{
if (!fFileExists)
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Source file \"%s\" does not exist, or is not a file"),
aTask->strSource.c_str());
}
else
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
/* Query file size to make an estimate for our progress object. */
if (SUCCEEDED(rc))
{
LONG64 lFileSize;
rc = pGuest->FileQuerySize(Bstr(aTask->strSource).raw(),
Bstr(aTask->strUserName).raw(), Bstr(aTask->strPassword).raw(),
&lFileSize);
if (FAILED(rc))
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
com::SafeArray<IN_BSTR> args;
com::SafeArray<IN_BSTR> env;
if (SUCCEEDED(rc))
{
/*
* Prepare tool command line.
*/
char szSource[RTPATH_MAX];
if (RTStrPrintf(szSource, sizeof(szSource), "%s", aTask->strSource.c_str()) <= sizeof(szSource) - 1)
{
/*
* Normalize path slashes, based on the detected guest.
*/
Utf8Str osType = mData.mOSTypeId;
if ( osType.contains("Microsoft", Utf8Str::CaseInsensitive)
|| osType.contains("Windows", Utf8Str::CaseInsensitive))
{
/* We have a Windows guest. */
RTPathChangeToDosSlashes(szSource, true /* Force conversion. */);
}
else /* ... or something which isn't from Redmond ... */
{
RTPathChangeToUnixSlashes(szSource, true /* Force conversion. */);
}
args.push_back(Bstr(szSource).raw()); /* Tell our cat tool which file to output. */
}
else
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Error preparing command line"));
}
ComPtr<IProgress> execProgress;
ULONG uPID;
if (SUCCEEDED(rc))
{
LogRel(("Copying file \"%s\" to host \"%s\" (%u bytes) ...\n",
aTask->strSource.c_str(), aTask->strDest.c_str(), lFileSize));
/*
* Okay, since we gathered all stuff we need until now to start the
* actual copying, start the guest part now.
*/
rc = pGuest->executeAndWaitForTool(Bstr(VBOXSERVICE_TOOL_CAT).raw(),
Bstr("Copying file to host").raw(),
ComSafeArrayAsInParam(args),
ComSafeArrayAsInParam(env),
Bstr(aTask->strUserName).raw(),
Bstr(aTask->strPassword).raw(),
ExecuteProcessFlag_WaitForProcessStartOnly
| ExecuteProcessFlag_WaitForStdOut,
NULL, NULL,
execProgress.asOutParam(), &uPID);
if (FAILED(rc))
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
}
if (SUCCEEDED(rc))
{
BOOL fCompleted = FALSE;
BOOL fCanceled = FALSE;
RTFILE hFileDest;
int vrc = RTFileOpen(&hFileDest, aTask->strDest.c_str(),
RTFILE_O_WRITE | RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_WRITE);
if (RT_FAILURE(vrc))
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Unable to create/open destination file \"%s\", rc=%Rrc"),
aTask->strDest.c_str(), vrc);
else
{
size_t cbToRead = lFileSize;
size_t cbTransfered = 0;
while ( SUCCEEDED(execProgress->COMGETTER(Completed(&fCompleted)))
&& !fCompleted)
{
SafeArray<BYTE> aOutputData;
rc = pGuest->GetProcessOutput(uPID, ProcessOutputFlag_None /* StdOut */,
0 /* No timeout. */,
_64K, ComSafeArrayAsOutParam(aOutputData));
if (SUCCEEDED(rc))
{
if (aOutputData.size())
{
vrc = RTFileWrite(hFileDest, aOutputData.raw(), aOutputData.size(), NULL /* No partial writes */);
if (RT_FAILURE(vrc))
{
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Error writing to file \"%s\" (%u bytes left), rc=%Rrc"),
aTask->strSource.c_str(), cbToRead, vrc);
break;
}
Assert(cbToRead >= aOutputData.size());
cbToRead -= aOutputData.size();
cbTransfered += aOutputData.size();
aTask->pProgress->SetCurrentOperationProgress(cbTransfered / (lFileSize / 100.0));
}
/* Nothing read this time; try next round. */
}
else
{
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
break;
}
}
RTFileClose(hFileDest);
if (SUCCEEDED(rc))
{
if ( cbTransfered
&& (cbTransfered != lFileSize))
{
/*
* Only bitch about an unexpected end of a file when there already
* was data read from that file. If this was the very first read we can
* be (almost) sure that this file is not meant to be read by the specified user.
*/
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Unexpected end of file \"%s\" (%u bytes total, %u bytes transferred)"),
aTask->strSource.c_str(), lFileSize, cbTransfered);
}
if (SUCCEEDED(rc))
aTask->pProgress->notifyComplete(S_OK);
}
}
}
}
}
catch (HRESULT aRC)
{
rc = aRC;
}
/* Clean up */
aTask->rc = rc;
LogFlowFunc(("rc=%Rhrc\n", rc));
LogFlowFuncLeave();
return VINF_SUCCESS;
}
RTDECL(int) RTUriFilePathEx(const char *pszUri, uint32_t fPathStyle, char **ppszPath, size_t cbPath, size_t *pcchPath)
{
/*
* Validate and adjust input.
*/
if (pcchPath)
{
AssertPtrReturn(pcchPath, VERR_INVALID_POINTER);
*pcchPath = ~(size_t)0;
}
AssertPtrReturn(ppszPath, VERR_INVALID_POINTER);
AssertReturn(!(fPathStyle & ~RTPATH_STR_F_STYLE_MASK) && fPathStyle != RTPATH_STR_F_STYLE_RESERVED, VERR_INVALID_FLAGS);
if (fPathStyle == RTPATH_STR_F_STYLE_HOST)
fPathStyle = RTPATH_STYLE;
AssertPtrReturn(pszUri, VERR_INVALID_POINTER);
/*
* Check that this is a file URI.
*/
if (RTStrNICmp(pszUri, RT_STR_TUPLE("file:")) == 0)
{ /* likely */ }
else
return VERR_URI_NOT_FILE_SCHEME;
/*
* We may have a number of variations here, mostly thanks to
* various windows software. First the canonical variations:
* - file:///C:/Windows/System32/kernel32.dll
* - file:///C|/Windows/System32/kernel32.dll
* - file:///C:%5CWindows%5CSystem32%5Ckernel32.dll
* - file://localhost/C:%5CWindows%5CSystem32%5Ckernel32.dll
* - file://cifsserver.dev/systemshare%5CWindows%5CSystem32%5Ckernel32.dll
* - file://cifsserver.dev:139/systemshare%5CWindows%5CSystem32%5Ckernel32.dll (not quite sure here, but whatever)
*
* Legacy variant without any slashes after the schema:
* - file:C:/Windows/System32/kernel32.dll
* - file:C|/Windows/System32%5Ckernel32.dll
* - file:~/.bashrc
* \--path-/
*
* Legacy variant with exactly one slashes after the schema:
* - file:/C:/Windows/System32%5Ckernel32.dll
* - file:/C|/Windows/System32/kernel32.dll
* - file:/usr/bin/env
* \---path---/
*
* Legacy variant with two slashes after the schema and an unescaped DOS path:
* - file://C:/Windows/System32\kernel32.dll (**)
* - file://C|/Windows/System32\kernel32.dll
* \---path---------------------/
* -- authority, with ':' as non-working port separator
*
* Legacy variant with exactly four slashes after the schema and an unescaped DOS path.
* - file:////C:/Windows\System32\user32.dll
*
* Legacy variant with four or more slashes after the schema and an unescaped UNC path:
* - file:////cifsserver.dev/systemshare/System32%\kernel32.dll
* - file://///cifsserver.dev/systemshare/System32\kernel32.dll
* \---path--------------------------------------------/
*
* The the two unescaped variants shouldn't be handed to rtUriParse, which
* is good as we cannot actually handle the one marked by (**). So, handle
* those two special when parsing.
*/
RTURIPARSED Parsed;
int rc;
size_t cSlashes = 0;
while (pszUri[5 + cSlashes] == '/')
cSlashes++;
if ( (cSlashes == 2 || cSlashes == 4)
&& RT_C_IS_ALPHA(pszUri[5 + cSlashes])
&& (pszUri[5 + cSlashes + 1] == ':' || pszUri[5 + cSlashes + 1] == '|'))
{
RT_ZERO(Parsed); /* RTURIPARSED_F_CONTAINS_ESCAPED_CHARS is now clear. */
Parsed.offPath = 5 + cSlashes;
Parsed.cchPath = strlen(&pszUri[Parsed.offPath]);
rc = RTStrValidateEncoding(&pszUri[Parsed.offPath]);
}
else if (cSlashes >= 4)
{
RT_ZERO(Parsed);
Parsed.fFlags = cSlashes > 4 ? RTURIPARSED_F_CONTAINS_ESCAPED_CHARS : 0;
Parsed.offPath = 5 + cSlashes - 2;
Parsed.cchPath = strlen(&pszUri[Parsed.offPath]);
rc = RTStrValidateEncoding(&pszUri[Parsed.offPath]);
}
else
rc = rtUriParse(pszUri, &Parsed);
if (RT_SUCCESS(rc))
{
/*
* Ignore localhost as hostname (it's implicit).
*/
static char const s_szLocalhost[] = "localhost";
if ( Parsed.cchAuthorityHost == sizeof(s_szLocalhost) - 1U
&& RTStrNICmp(&pszUri[Parsed.offAuthorityHost], RT_STR_TUPLE(s_szLocalhost)) == 0)
{
Parsed.cchAuthorityHost = 0;
Parsed.cchAuthority = 0;
}
/*
* Ignore leading path slash/separator if we detect a DOS drive letter
* and we don't have a host name.
*/
if ( Parsed.cchPath >= 3
&& Parsed.cchAuthorityHost == 0
&& pszUri[Parsed.offPath] == '/' /* Leading path slash/separator. */
&& ( pszUri[Parsed.offPath + 2] == ':' /* Colon after drive letter. */
|| pszUri[Parsed.offPath + 2] == '|') /* Colon alternative. */
&& RT_C_IS_ALPHA(pszUri[Parsed.offPath + 1]) ) /* Drive letter. */
{
Parsed.offPath++;
Parsed.cchPath--;
}
/*
* Calculate the size of the encoded result.
*
* Since we're happily returning "C:/Windows/System32/kernel.dll"
* style paths when the caller requested UNIX style paths, we will
* return straight UNC paths too ("//cifsserver/share/dir/file").
*/
size_t cchDecodedHost = 0;
size_t cbResult;
if (Parsed.fFlags & RTURIPARSED_F_CONTAINS_ESCAPED_CHARS)
{
cchDecodedHost = rtUriCalcDecodedLength(&pszUri[Parsed.offAuthorityHost], Parsed.cchAuthorityHost);
cbResult = cchDecodedHost + rtUriCalcDecodedLength(&pszUri[Parsed.offPath], Parsed.cchPath) + 1;
}
else
{
cchDecodedHost = 0;
cbResult = Parsed.cchAuthorityHost + Parsed.cchPath + 1;
}
if (pcchPath)
*pcchPath = cbResult - 1;
if (cbResult > 1)
{
/*
* Prepare the necessary buffer space for the result.
*/
char *pszDst;
char *pszFreeMe = NULL;
if (!cbPath || *ppszPath == NULL)
{
cbPath = RT_MAX(cbPath, cbResult);
*ppszPath = pszFreeMe = pszDst = RTStrAlloc(cbPath);
AssertReturn(pszDst, VERR_NO_STR_MEMORY);
}
else if (cbResult <= cbPath)
pszDst = *ppszPath;
else
return VERR_BUFFER_OVERFLOW;
/*
* Compose the result.
*/
if (Parsed.fFlags & RTURIPARSED_F_CONTAINS_ESCAPED_CHARS)
{
rc = rtUriDecodeIntoBuffer(&pszUri[Parsed.offAuthorityHost],Parsed.cchAuthorityHost,
pszDst, cchDecodedHost + 1);
Assert(RT_SUCCESS(rc) && strlen(pszDst) == cchDecodedHost);
if (RT_SUCCESS(rc))
rc = rtUriDecodeIntoBuffer(&pszUri[Parsed.offPath], Parsed.cchPath,
&pszDst[cchDecodedHost], cbResult - cchDecodedHost);
Assert(RT_SUCCESS(rc) && strlen(pszDst) == cbResult - 1);
}
else
{
memcpy(pszDst, &pszUri[Parsed.offAuthorityHost], Parsed.cchAuthorityHost);
memcpy(&pszDst[Parsed.cchAuthorityHost], &pszUri[Parsed.offPath], Parsed.cchPath);
pszDst[cbResult - 1] = '\0';
}
if (RT_SUCCESS(rc))
{
/*
* Convert colon DOS driver letter colon alternative.
* We do this regardless of the desired path style.
*/
if ( RT_C_IS_ALPHA(pszDst[0])
&& pszDst[1] == '|')
pszDst[1] = ':';
/*
* Fix slashes.
*/
if (fPathStyle == RTPATH_STR_F_STYLE_DOS)
RTPathChangeToDosSlashes(pszDst, true);
else if (fPathStyle == RTPATH_STR_F_STYLE_UNIX)
RTPathChangeToUnixSlashes(pszDst, true); /** @todo not quite sure how this actually makes sense... */
else
AssertFailed();
return rc;
}
/* bail out */
RTStrFree(pszFreeMe);
}
else
rc = VERR_PATH_ZERO_LENGTH;
}
return rc;
}
HRESULT Guest::taskCopyFileToGuest(GuestTask *aTask)
{
LogFlowFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/*
* Do *not* take a write lock here since we don't (and won't)
* touch any class-specific data (of IGuest) here - only the member functions
* which get called here can do that.
*/
HRESULT rc = S_OK;
try
{
ComObjPtr<Guest> pGuest = aTask->pGuest;
/* Does our source file exist? */
if (!RTFileExists(aTask->strSource.c_str()))
{
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Source file \"%s\" does not exist, or is not a file"),
aTask->strSource.c_str());
}
else
{
RTFILE fileSource;
int vrc = RTFileOpen(&fileSource, aTask->strSource.c_str(),
RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
if (RT_FAILURE(vrc))
{
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Could not open source file \"%s\" for reading (%Rrc)"),
aTask->strSource.c_str(), vrc);
}
else
{
uint64_t cbSize;
vrc = RTFileGetSize(fileSource, &cbSize);
if (RT_FAILURE(vrc))
{
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Could not query file size of \"%s\" (%Rrc)"),
aTask->strSource.c_str(), vrc);
}
else
{
com::SafeArray<IN_BSTR> args;
com::SafeArray<IN_BSTR> env;
/*
* Prepare tool command line.
*/
char szOutput[RTPATH_MAX];
if (RTStrPrintf(szOutput, sizeof(szOutput), "--output=%s", aTask->strDest.c_str()) <= sizeof(szOutput) - 1)
{
/*
* Normalize path slashes, based on the detected guest.
*/
Utf8Str osType = mData.mOSTypeId;
if ( osType.contains("Microsoft", Utf8Str::CaseInsensitive)
|| osType.contains("Windows", Utf8Str::CaseInsensitive))
{
/* We have a Windows guest. */
RTPathChangeToDosSlashes(szOutput, true /* Force conversion. */);
}
else /* ... or something which isn't from Redmond ... */
{
RTPathChangeToUnixSlashes(szOutput, true /* Force conversion. */);
}
args.push_back(Bstr(szOutput).raw()); /* We want to write a file ... */
}
else
{
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Error preparing command line"));
}
ComPtr<IProgress> execProgress;
ULONG uPID;
if (SUCCEEDED(rc))
{
LogRel(("Copying file \"%s\" to guest \"%s\" (%u bytes) ...\n",
aTask->strSource.c_str(), aTask->strDest.c_str(), cbSize));
/*
* Okay, since we gathered all stuff we need until now to start the
* actual copying, start the guest part now.
*/
rc = pGuest->executeAndWaitForTool(Bstr(VBOXSERVICE_TOOL_CAT).raw(),
Bstr("Copying file to guest").raw(),
ComSafeArrayAsInParam(args),
ComSafeArrayAsInParam(env),
Bstr(aTask->strUserName).raw(),
Bstr(aTask->strPassword).raw(),
ExecuteProcessFlag_WaitForProcessStartOnly,
NULL, NULL,
execProgress.asOutParam(), &uPID);
if (FAILED(rc))
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
}
if (SUCCEEDED(rc))
{
BOOL fCompleted = FALSE;
BOOL fCanceled = FALSE;
uint64_t cbTransferedTotal = 0;
SafeArray<BYTE> aInputData(_64K);
while ( SUCCEEDED(execProgress->COMGETTER(Completed(&fCompleted)))
&& !fCompleted)
{
size_t cbToRead = cbSize;
size_t cbRead = 0;
if (cbSize) /* If we have nothing to read, take a shortcut. */
{
/** @todo Not very efficient, but works for now. */
vrc = RTFileSeek(fileSource, cbTransferedTotal,
RTFILE_SEEK_BEGIN, NULL /* poffActual */);
if (RT_SUCCESS(vrc))
{
vrc = RTFileRead(fileSource, (uint8_t*)aInputData.raw(),
RT_MIN(cbToRead, _64K), &cbRead);
/*
* Some other error occured? There might be a chance that RTFileRead
* could not resolve/map the native error code to an IPRT code, so just
* print a generic error.
*/
if (RT_FAILURE(vrc))
{
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Could not read from file \"%s\" (%Rrc)"),
aTask->strSource.c_str(), vrc);
break;
}
}
else
{
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Seeking file \"%s\" failed; offset = %RU64 (%Rrc)"),
aTask->strSource.c_str(), cbTransferedTotal, vrc);
break;
}
}
/* Resize buffer to reflect amount we just have read.
* Size 0 is allowed! */
aInputData.resize(cbRead);
ULONG uFlags = ProcessInputFlag_None;
/* Did we reach the end of the content we want to transfer (last chunk)? */
if ( (cbRead < _64K)
/* Did we reach the last block which is exactly _64K? */
|| (cbToRead - cbRead == 0)
/* ... or does the user want to cancel? */
|| ( SUCCEEDED(aTask->pProgress->COMGETTER(Canceled(&fCanceled)))
&& fCanceled)
)
{
uFlags |= ProcessInputFlag_EndOfFile;
}
ULONG uBytesWritten = 0;
rc = pGuest->SetProcessInput(uPID, uFlags,
0 /* Infinite timeout */,
ComSafeArrayAsInParam(aInputData), &uBytesWritten);
if (FAILED(rc))
{
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
break;
}
Assert(cbRead <= cbToRead);
Assert(cbToRead >= cbRead);
cbToRead -= cbRead;
cbTransferedTotal += uBytesWritten;
Assert(cbTransferedTotal <= cbSize);
aTask->pProgress->SetCurrentOperationProgress(cbTransferedTotal / (cbSize / 100.0));
/* End of file reached? */
if (cbToRead == 0)
break;
/* Did the user cancel the operation above? */
if (fCanceled)
break;
/* Progress canceled by Main API? */
if ( SUCCEEDED(execProgress->COMGETTER(Canceled(&fCanceled)))
&& fCanceled)
{
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Copy operation of file \"%s\" was canceled on guest side"),
aTask->strSource.c_str());
break;
}
}
if (SUCCEEDED(rc))
{
/*
* If we got here this means the started process either was completed,
* canceled or we simply got all stuff transferred.
*/
ExecuteProcessStatus_T retStatus;
ULONG uRetExitCode;
rc = executeWaitForExit(uPID, execProgress, 0 /* No timeout */,
&retStatus, &uRetExitCode);
if (FAILED(rc))
{
rc = GuestTask::setProgressErrorInfo(rc, aTask->pProgress, pGuest);
}
else
{
if ( uRetExitCode != 0
|| retStatus != ExecuteProcessStatus_TerminatedNormally)
{
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Guest process reported error %u (status: %u) while copying file \"%s\" to \"%s\""),
uRetExitCode, retStatus, aTask->strSource.c_str(), aTask->strDest.c_str());
}
}
}
if (SUCCEEDED(rc))
{
if (fCanceled)
{
/*
* In order to make the progress object to behave nicely, we also have to
* notify the object with a complete event when it's canceled.
*/
aTask->pProgress->notifyComplete(VBOX_E_IPRT_ERROR,
COM_IIDOF(IGuest),
Guest::getStaticComponentName(),
Guest::tr("Copying file \"%s\" canceled"), aTask->strSource.c_str());
}
else
{
/*
* Even if we succeeded until here make sure to check whether we really transfered
* everything.
*/
if ( cbSize > 0
&& cbTransferedTotal == 0)
{
/* If nothing was transfered but the file size was > 0 then "vbox_cat" wasn't able to write
* to the destination -> access denied. */
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Access denied when copying file \"%s\" to \"%s\""),
aTask->strSource.c_str(), aTask->strDest.c_str());
}
else if (cbTransferedTotal < cbSize)
{
/* If we did not copy all let the user know. */
rc = GuestTask::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->pProgress,
Guest::tr("Copying file \"%s\" failed (%u/%u bytes transfered)"),
aTask->strSource.c_str(), cbTransferedTotal, cbSize);
}
else /* Yay, all went fine! */
aTask->pProgress->notifyComplete(S_OK);
}
}
}
}
RTFileClose(fileSource);
}
}
}
catch (HRESULT aRC)
{
rc = aRC;
}
/* Clean up */
aTask->rc = rc;
LogFlowFunc(("rc=%Rhrc\n", rc));
LogFlowFuncLeave();
return VINF_SUCCESS;
}
RTDECL(int) RTUriFileCreateEx(const char *pszPath, uint32_t fPathStyle, char **ppszUri, size_t cbUri, size_t *pcchUri)
{
/*
* Validate and adjust input. (RTPathParse check pszPath out for us)
*/
if (pcchUri)
{
AssertPtrReturn(pcchUri, VERR_INVALID_POINTER);
*pcchUri = ~(size_t)0;
}
AssertPtrReturn(ppszUri, VERR_INVALID_POINTER);
AssertReturn(!(fPathStyle & ~RTPATH_STR_F_STYLE_MASK) && fPathStyle != RTPATH_STR_F_STYLE_RESERVED, VERR_INVALID_FLAGS);
if (fPathStyle == RTPATH_STR_F_STYLE_HOST)
fPathStyle = RTPATH_STYLE;
/*
* Let the RTPath code parse the stuff (no reason to duplicate path parsing
* and get it slightly wrong here).
*/
RTPATHPARSED ParsedPath;
int rc = RTPathParse(pszPath, &ParsedPath, sizeof(ParsedPath), fPathStyle);
if (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
{
/* Skip leading slashes. */
if (ParsedPath.fProps & RTPATH_PROP_ROOT_SLASH)
{
if (fPathStyle == RTPATH_STR_F_STYLE_DOS)
while (pszPath[0] == '/' || pszPath[0] == '\\')
pszPath++;
else
while (pszPath[0] == '/')
pszPath++;
}
const size_t cchPath = strlen(pszPath);
/*
* Calculate the encoded length and figure destination buffering.
*/
static const char s_szPrefix[] = "file:///";
size_t const cchPrefix = sizeof(s_szPrefix) - (ParsedPath.fProps & RTPATH_PROP_UNC ? 2 : 1);
size_t cchEncoded = rtUriCalcEncodedLength(pszPath, cchPath, fPathStyle != RTPATH_STR_F_STYLE_DOS);
if (pcchUri)
*pcchUri = cchEncoded;
char *pszDst;
char *pszFreeMe = NULL;
if (!cbUri || *ppszUri == NULL)
{
cbUri = RT_MAX(cbUri, cchPrefix + cchEncoded + 1);
*ppszUri = pszFreeMe = pszDst = RTStrAlloc(cbUri);
AssertReturn(pszDst, VERR_NO_STR_MEMORY);
}
else if (cchEncoded < cbUri)
pszDst = *ppszUri;
else
return VERR_BUFFER_OVERFLOW;
/*
* Construct the URI.
*/
memcpy(pszDst, s_szPrefix, cchPrefix);
pszDst[cchPrefix] = '\0';
rc = rtUriEncodeIntoBuffer(pszPath, cchPath, fPathStyle != RTPATH_STR_F_STYLE_DOS, &pszDst[cchPrefix], cbUri - cchPrefix);
if (RT_SUCCESS(rc))
{
Assert(strlen(pszDst) == cbUri - 1);
if (fPathStyle == RTPATH_STR_F_STYLE_DOS)
RTPathChangeToUnixSlashes(pszDst, true /*fForce*/);
return VINF_SUCCESS;
}
AssertRC(rc); /* Impossible! rtUriCalcEncodedLength or something above is busted! */
if (pszFreeMe)
RTStrFree(pszFreeMe);
}
return rc;
}
