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;
}
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;
}
