int UIDnDMimeData::setData(const QString &mimeType)
{
LogFlowFunc(("mimeType=%s, dataType=%s\n",
mimeType.toAscii().constData(), m_vaData.typeName()));
int rc = VINF_SUCCESS;
switch (m_vaData.type())
{
case QVariant::String: /* Plain text. */
{
QMimeData::setText(m_vaData.toString());
break;
}
case QVariant::ByteArray: /* Raw byte data. */
{
QMimeData::setData(mimeType, m_vaData.toByteArray());
break;
}
case QVariant::StringList: /* URI. */
{
QList<QVariant> lstData = m_vaData.toList();
QList<QUrl> lstURL;
for (int i = 0; i < lstData.size(); i++)
{
QFileInfo fileInfo(lstData.at(i).toString());
#ifdef DEBUG
LogFlowFunc(("\tURL: %s (fExists=%RTbool, fIsDir=%RTbool, cb=%RU64)\n",
fileInfo.absoluteFilePath().constData(), fileInfo.exists(),
fileInfo.isDir(), fileInfo.size()));
#endif
lstURL << QUrl::fromLocalFile(fileInfo.absoluteFilePath());
}
LogFlowFunc(("Number of URLs: %d\n", lstURL.size()));
if (RT_SUCCESS(rc))
QMimeData::setUrls(lstURL);
break;
}
default:
rc = VERR_NOT_SUPPORTED;
break;
}
LogFlowFuncLeaveRC(rc);
return rc;
}
int VBoxNetBaseService::waitForIntNetEvent(int cMillis)
{
INTNETIFWAITREQ WaitReq;
LogFlowFunc(("ENTER:cMillis: %d\n", cMillis));
WaitReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
WaitReq.Hdr.cbReq = sizeof(WaitReq);
WaitReq.pSession = m->m_pSession;
WaitReq.hIf = m->m_hIf;
WaitReq.cMillies = cMillis;
int rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_IF_WAIT, 0, &WaitReq.Hdr);
LogFlowFuncLeaveRC(rc);
return rc;
}
DECLINLINE(int) pftpSessionOpenFile(PNATState pData, PTFTPSESSION pTftpSession, PRTFILE pSessionFile)
{
char aszSessionFileName[TFTP_FILENAME_MAX];
size_t cbSessionFileName;
int rc = VINF_SUCCESS;
cbSessionFileName = RTStrPrintf(aszSessionFileName, TFTP_FILENAME_MAX, "%s/%s",
tftp_prefix, pTftpSession->pszFilename);
if (cbSessionFileName >= TFTP_FILENAME_MAX)
{
LogFlowFuncLeaveRC(VERR_INTERNAL_ERROR);
return VERR_INTERNAL_ERROR;
}
if (!RTFileExists(aszSessionFileName))
{
LogFlowFuncLeaveRC(VERR_FILE_NOT_FOUND);
return VERR_FILE_NOT_FOUND;
}
rc = RTFileOpen(pSessionFile, aszSessionFileName, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
LogFlowFuncLeaveRC(rc);
return rc;
}
int SessionTaskCopyFrom::RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress)
{
LogFlowThisFunc(("strDesc=%s, strSource=%s, strDest=%s, uFlags=%x\n",
strDesc.c_str(), mSource.c_str(), mDest.c_str(), mFlags));
mDesc = strDesc;
mProgress = pProgress;
int rc = RTThreadCreate(NULL, SessionTaskCopyFrom::taskThread, this,
0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
"gctlCpyFrom");
LogFlowFuncLeaveRC(rc);
return rc;
}
int VBoxNetBaseService::abortWait()
{
INTNETIFABORTWAITREQ AbortReq;
LogFlowFunc(("ENTER:\n"));
AbortReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
AbortReq.Hdr.cbReq = sizeof(AbortReq);
AbortReq.pSession = m->m_pSession;
AbortReq.hIf = m->m_hIf;
AbortReq.fNoMoreWaits = true;
int rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_IF_ABORT_WAIT, 0, &AbortReq.Hdr);
LogFlowFuncLeaveRC(rc);
return rc;
}
int DnDURIList::AppendURIPath(const char *pszURI, uint32_t fFlags)
{
AssertPtrReturn(pszURI, VERR_INVALID_POINTER);
/** @todo Check for string termination? */
#ifdef DEBUG_andy
LogFlowFunc(("pszPath=%s, fFlags=0x%x\n", pszURI, fFlags));
#endif
int rc = VINF_SUCCESS;
/* Query the path component of a file URI. If this hasn't a
* file scheme NULL is returned. */
char *pszSrcPath = RTUriFilePath(pszURI);
if (pszSrcPath)
{
/* Add the path to our internal file list (recursive in
* the case of a directory). */
size_t cbPathLen = RTPathStripTrailingSlash(pszSrcPath);
if (cbPathLen)
{
char *pszFileName = RTPathFilename(pszSrcPath);
if (pszFileName)
{
Assert(pszFileName >= pszSrcPath);
size_t cchDstBase = (fFlags & DNDURILIST_FLAGS_ABSOLUTE_PATHS)
? 0 /* Use start of path as root. */
: pszFileName - pszSrcPath;
char *pszDstPath = &pszSrcPath[cchDstBase];
m_lstRoot.append(pszDstPath);
LogFlowFunc(("pszFilePath=%s, pszFileName=%s, pszRoot=%s\n",
pszSrcPath, pszFileName, pszDstPath));
rc = appendPathRecursive(pszSrcPath, pszSrcPath, pszSrcPath, cchDstBase, fFlags);
}
else
rc = VERR_PATH_NOT_FOUND;
}
else
rc = VERR_INVALID_PARAMETER;
RTStrFree(pszSrcPath);
}
else
rc = VERR_INVALID_PARAMETER;
LogFlowFuncLeaveRC(rc);
return rc;
}
DECLCALLBACK(int) VBoxClipboardStop(void *pInstance)
{
AssertPtrReturn(pInstance, VERR_INVALID_POINTER);
LogFunc(("Stopping pInstance=%p\n", pInstance));
PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)pInstance;
AssertPtr(pCtx);
VbglR3ClipboardDisconnect(pCtx->u32ClientID);
pCtx->u32ClientID = 0;
LogFlowFuncLeaveRC(VINF_SUCCESS);
return VINF_SUCCESS;
}
int GuestCtrlCallback::Init(eVBoxGuestCtrlCallbackType enmType)
{
LogFlowFuncEnter();
AssertReturn(enmType > VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN, VERR_INVALID_PARAMETER);
Assert((pvData == NULL) && !cbData);
switch (enmType)
{
case VBOXGUESTCTRLCALLBACKTYPE_EXEC_START:
{
pvData = (PCALLBACKDATAEXECSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECSTATUS));
AssertPtrReturn(pvData, VERR_NO_MEMORY);
RT_BZERO(pvData, sizeof(CALLBACKDATAEXECSTATUS));
cbData = sizeof(CALLBACKDATAEXECSTATUS);
break;
}
case VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT:
{
pvData = (PCALLBACKDATAEXECOUT)RTMemAlloc(sizeof(CALLBACKDATAEXECOUT));
AssertPtrReturn(pvData, VERR_NO_MEMORY);
RT_BZERO(pvData, sizeof(CALLBACKDATAEXECOUT));
cbData = sizeof(CALLBACKDATAEXECOUT);
break;
}
case VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS:
{
PCALLBACKDATAEXECINSTATUS pData = (PCALLBACKDATAEXECINSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECINSTATUS));
AssertPtrReturn(pData, VERR_NO_MEMORY);
RT_BZERO(pData, sizeof(CALLBACKDATAEXECINSTATUS));
cbData = sizeof(CALLBACKDATAEXECINSTATUS);
break;
}
default:
AssertMsgFailed(("Unknown callback type specified (%d)\n", enmType));
break;
}
int rc = GuestCtrlEvent::Init();
if (RT_SUCCESS(rc))
mType = enmType;
LogFlowFuncLeaveRC(rc);
return rc;
}
int DnDURIList::AppendNativePathsFromList(const RTCList<RTCString> &lstNativePaths,
uint32_t fFlags)
{
int rc = VINF_SUCCESS;
for (size_t i = 0; i < lstNativePaths.size(); i++)
{
const RTCString &strPath = lstNativePaths.at(i);
rc = AppendNativePath(strPath.c_str(), fFlags);
if (RT_FAILURE(rc))
break;
}
LogFlowFuncLeaveRC(rc);
return rc;
}
int GuestCtrlEvent::Wait(ULONG uTimeoutMS)
{
LogFlowFuncEnter();
AssertReturn(hEventSem != NIL_RTSEMEVENT, VERR_CANCELLED);
RTMSINTERVAL msInterval = uTimeoutMS;
if (!uTimeoutMS)
msInterval = RT_INDEFINITE_WAIT;
int rc = RTSemEventWait(hEventSem, msInterval);
if (RT_SUCCESS(rc))
ASMAtomicWriteBool(&fCompleted, true);
LogFlowFuncLeaveRC(rc);
return rc;
}
int GuestFile::i_seekAt(int64_t iOffset, GUEST_FILE_SEEKTYPE eSeekType,
uint32_t uTimeoutMS, uint64_t *puOffset)
{
LogFlowThisFunc(("iOffset=%RI64, uTimeoutMS=%RU32\n",
iOffset, uTimeoutMS));
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
int vrc;
GuestWaitEvent *pEvent = NULL;
GuestEventTypes eventTypes;
try
{
eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
eventTypes.push_back(VBoxEventType_OnGuestFileOffsetChanged);
vrc = registerWaitEvent(eventTypes, &pEvent);
}
catch (std::bad_alloc)
{
vrc = VERR_NO_MEMORY;
}
if (RT_FAILURE(vrc))
return vrc;
/* Prepare HGCM call. */
VBOXHGCMSVCPARM paParms[4];
int i = 0;
paParms[i++].setUInt32(pEvent->ContextID());
paParms[i++].setUInt32(mData.mID /* File handle */);
paParms[i++].setUInt32(eSeekType /* Seek method */);
/** @todo uint64_t vs. int64_t! */
paParms[i++].setUInt64((uint64_t)iOffset /* Offset (in bytes) to start reading */);
alock.release(); /* Drop write lock before sending. */
vrc = sendCommand(HOST_FILE_SEEK, i, paParms);
if (RT_SUCCESS(vrc))
vrc = i_waitForOffsetChange(pEvent, uTimeoutMS, puOffset);
unregisterWaitEvent(pEvent);
LogFlowFuncLeaveRC(vrc);
return vrc;
}
DECLCALLBACK(int) VBoxSeamlessInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
{
LogFlowFuncEnter();
PVBOXSEAMLESSCONTEXT pCtx = &g_Ctx; /* Only one instance at the moment. */
AssertPtr(pCtx);
pCtx->pEnv = pEnv;
pCtx->hModHook = NIL_RTLDRMOD;
OSVERSIONINFO OSinfo;
OSinfo.dwOSVersionInfoSize = sizeof (OSinfo);
GetVersionEx (&OSinfo);
int rc;
/* We have to jump out here when using NT4, otherwise it complains about
a missing API function "UnhookWinEvent" used by the dynamically loaded VBoxHook.dll below */
if (OSinfo.dwMajorVersion <= 4) /* Windows NT 4.0 or older */
{
Log(("VBoxTray: VBoxSeamlessInit: Windows NT 4.0 or older not supported!\n"));
rc = VERR_NOT_SUPPORTED;
}
else
{
/* Will fail if SetWinEventHook is not present (version < NT4 SP6 apparently) */
rc = RTLdrLoadAppPriv(VBOXHOOK_DLL_NAME, &pCtx->hModHook);
if (RT_SUCCESS(rc))
{
*(PFNRT *)&pCtx->pfnVBoxHookInstallWindowTracker = RTLdrGetFunction(pCtx->hModHook, "VBoxHookInstallWindowTracker");
*(PFNRT *)&pCtx->pfnVBoxHookRemoveWindowTracker = RTLdrGetFunction(pCtx->hModHook, "VBoxHookRemoveWindowTracker");
/* rc should contain success status */
AssertRC(rc); /** @todo r=andy Makes no sense here!? */
VBoxSeamlessSetSupported(TRUE);
*ppInstance = pCtx;
}
else
LogFlowFunc(("Unable to load %s, rc=%Rrc\n", VBOXHOOK_DLL_NAME, rc));
}
LogFlowFuncLeaveRC(rc);
return rc;
}
STDMETHODIMP GuestFile::Seek(LONG64 aOffset, FileSeekType_T aType)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
HRESULT hr = S_OK;
GUEST_FILE_SEEKTYPE eSeekType;
switch (aType)
{
case FileSeekType_Set:
eSeekType = GUEST_FILE_SEEKTYPE_BEGIN;
break;
case FileSeekType_Current:
eSeekType = GUEST_FILE_SEEKTYPE_CURRENT;
break;
default:
return setError(E_INVALIDARG, tr("Invalid seek type specified"));
break; /* Never reached. */
}
int vrc = seekAt(aOffset, eSeekType,
30 * 1000 /* 30s timeout */, NULL /* puOffset */);
if (RT_FAILURE(vrc))
{
switch (vrc)
{
default:
hr = setError(VBOX_E_IPRT_ERROR,
tr("Seeking file \"%s\" (to offset %RI64) failed: %Rrc"),
mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
break;
}
}
LogFlowFuncLeaveRC(vrc);
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
HRESULT GuestFile::seek(LONG64 aOffset, FileSeekOrigin_T aWhence, LONG64 *aNewOffset)
{
LogFlowThisFuncEnter();
HRESULT hr = S_OK;
GUEST_FILE_SEEKTYPE eSeekType;
switch (aWhence)
{
case FileSeekOrigin_Begin:
eSeekType = GUEST_FILE_SEEKTYPE_BEGIN;
break;
case FileSeekOrigin_Current:
eSeekType = GUEST_FILE_SEEKTYPE_CURRENT;
break;
case FileSeekOrigin_End:
eSeekType = GUEST_FILE_SEEKTYPE_END;
break;
default:
return setError(E_INVALIDARG, tr("Invalid seek type specified"));
break; /* Never reached. */
}
uint64_t uNewOffset;
int vrc = i_seekAt(aOffset, eSeekType,
30 * 1000 /* 30s timeout */, &uNewOffset);
if (RT_SUCCESS(vrc))
*aNewOffset = RT_MIN(uNewOffset, (uint64_t)INT64_MAX);
else
{
switch (vrc)
{
default:
hr = setError(VBOX_E_IPRT_ERROR,
tr("Seeking file \"%s\" (to offset %RI64) failed: %Rrc"),
mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
break;
}
}
LogFlowFuncLeaveRC(vrc);
return hr;
}
/**
* This function evaluate file name.
* @param pu8Payload
* @param cbPayload
* @param cbFileName
* @return VINF_SUCCESS -
* VERR_INVALID_PARAMETER -
*/
DECLINLINE(int) tftpSecurityFilenameCheck(PNATState pData, PCTFTPSESSION pcTftpSession)
{
size_t cbSessionFilename = 0;
int rc = VINF_SUCCESS;
AssertPtrReturn(pcTftpSession, VERR_INVALID_PARAMETER);
cbSessionFilename = RTStrNLen((const char *)pcTftpSession->pszFilename, TFTP_FILENAME_MAX);
if ( !RTStrNCmp((const char*)pcTftpSession->pszFilename, "../", 3)
|| (pcTftpSession->pszFilename[cbSessionFilename - 1] == '/')
|| RTStrStr((const char *)pcTftpSession->pszFilename, "/../"))
rc = VERR_FILE_NOT_FOUND;
/* only allow exported prefixes */
if ( RT_SUCCESS(rc)
&& !tftp_prefix)
rc = VERR_INTERNAL_ERROR;
LogFlowFuncLeaveRC(rc);
return rc;
}
/** @todo GuestDnDResponse *pResp needs to go. */
int GuestDnDBase::waitForEvent(GuestDnDCallbackEvent *pEvent, GuestDnDResponse *pResp, RTMSINTERVAL msTimeout)
{
AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
AssertPtrReturn(pResp, VERR_INVALID_POINTER);
int rc;
LogFlowFunc(("msTimeout=%RU32\n", msTimeout));
uint64_t tsStart = RTTimeMilliTS();
do
{
/*
* Wait until our desired callback triggered the
* wait event. As we don't want to block if the guest does not
* respond, do busy waiting here.
*/
rc = pEvent->Wait(500 /* ms */);
if (RT_SUCCESS(rc))
{
rc = pEvent->Result();
LogFlowFunc(("Callback done, result is %Rrc\n", rc));
break;
}
else if (rc == VERR_TIMEOUT) /* Continue waiting. */
rc = VINF_SUCCESS;
if ( msTimeout != RT_INDEFINITE_WAIT
&& RTTimeMilliTS() - tsStart > msTimeout)
{
rc = VERR_TIMEOUT;
LogRel2(("DnD: Error: Guest did not respond within time\n"));
}
else if (pResp->isProgressCanceled()) /** @todo GuestDnDResponse *pResp needs to go. */
{
LogRel2(("DnD: Operation was canceled by user\n"));
rc = VERR_CANCELLED;
}
} while (RT_SUCCESS(rc));
LogFlowFuncLeaveRC(rc);
return rc;
}
DECLCALLBACK(int) VBoxClipboardInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
{
LogFlowFuncEnter();
PVBOXCLIPBOARDCONTEXT pCtx = &g_Ctx; /* Only one instance for now. */
AssertPtr(pCtx);
if (pCtx->pEnv)
{
/* Clipboard was already initialized. 2 or more instances are not supported. */
return VERR_NOT_SUPPORTED;
}
if (VbglR3AutoLogonIsRemoteSession())
{
/* Do not use clipboard for remote sessions. */
LogRel(("Clipboard: Clipboard has been disabled for a remote session\n"));
return VERR_NOT_SUPPORTED;
}
RT_BZERO(pCtx, sizeof(VBOXCLIPBOARDCONTEXT));
pCtx->pEnv = pEnv;
/* Check that new Clipboard API is available */
VBoxClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
int rc = VbglR3ClipboardConnect(&pCtx->u32ClientID);
if (RT_SUCCESS(rc))
{
rc = vboxClipboardCreateWindow(pCtx);
if (RT_SUCCESS(rc))
{
*ppInstance = pCtx;
}
else
{
VbglR3ClipboardDisconnect(pCtx->u32ClientID);
}
}
LogFlowFuncLeaveRC(rc);
return rc;
}
int GuestDirectory::parseData(GuestProcessStreamBlock &streamBlock)
{
LogFlowThisFunc(("cbStream=%RU32\n", mData.mStream.GetSize()));
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
int rc;
do
{
/* Try parsing the data to see if the current block is complete. */
rc = mData.mStream.ParseBlock(streamBlock);
if (streamBlock.GetCount())
break;
} while (RT_SUCCESS(rc));
LogFlowFuncLeaveRC(rc);
return rc;
}
STDMETHODIMP Guest::COMGETTER(EventSource)(IEventSource ** aEventSource)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
CheckComArgOutPointerValid(aEventSource);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
// no need to lock - lifetime constant
mEventSource.queryInterfaceTo(aEventSource);
LogFlowFuncLeaveRC(S_OK);
return S_OK;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestFile::ReadAt(LONG64 aOffset, ULONG aToRead, ULONG aTimeoutMS, ComSafeArrayOut(BYTE, aData))
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
if (aToRead == 0)
return setError(E_INVALIDARG, tr("The size to read is zero"));
CheckComArgOutSafeArrayPointerValid(aData);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
com::SafeArray<BYTE> data((size_t)aToRead);
Assert(data.size() >= aToRead);
HRESULT hr = S_OK;
size_t cbRead;
int vrc = readDataAt(aOffset, aToRead, aTimeoutMS,
data.raw(), aToRead, &cbRead);
if (RT_SUCCESS(vrc))
{
if (data.size() != cbRead)
data.resize(cbRead);
data.detachTo(ComSafeArrayOutArg(aData));
}
else
{
switch (vrc)
{
default:
hr = setError(VBOX_E_IPRT_ERROR,
tr("Reading from file \"%s\" (at offset %RU64) failed: %Rrc"),
mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
break;
}
}
LogFlowFuncLeaveRC(vrc);
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
int UIDnDHandler::retrieveData( Qt::DropAction dropAction,
const QString &strMIMEType,
QVariant::Type vaType,
QVariant &vaData)
{
QVector<uint8_t> vecData;
int rc = retrieveData(dropAction, strMIMEType, vecData);
if (RT_SUCCESS(rc))
{
/* If no/an invalid variant is set, try to guess the variant type.
* This can happen on OS X. */
if (vaType == QVariant::Invalid)
vaType = UIDnDMIMEData::getVariantType(strMIMEType);
rc = UIDnDMIMEData::getDataAsVariant(vecData, strMIMEType, vaType, vaData);
}
LogFlowFuncLeaveRC(rc);
return rc;
}
int GuestCtrlEvent::Cancel(void)
{
LogFlowThisFuncEnter();
int rc = VINF_SUCCESS;
if (!ASMAtomicReadBool(&fCompleted))
{
if (!ASMAtomicReadBool(&fCanceled))
{
ASMAtomicXchgBool(&fCanceled, true);
LogFlowThisFunc(("Cancelling ...\n"));
rc = hEventSem != NIL_RTSEMEVENT
? RTSemEventSignal(hEventSem) : VINF_SUCCESS;
}
}
LogFlowFuncLeaveRC(rc);
return rc;
}
int UIDnDHandler::dragStop(ulong screenID)
{
int rc;
#ifdef VBOX_WITH_DRAG_AND_DROP_GH
NOREF(screenID);
reset();
rc = VINF_SUCCESS;
#else /* !VBOX_WITH_DRAG_AND_DROP_GH */
NOREF(screenID);
rc = VERR_NOT_SUPPORTED;
#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
LogFlowFuncLeaveRC(rc);
return rc;
}
DECLINLINE(int) tftpSend(PNATState pData,
PTFTPSESSION pTftpSession,
struct mbuf *pMBuf,
PCTFTPIPHDR pcTftpIpHeaderRecv)
{
int rc = VINF_SUCCESS;
struct sockaddr_in saddr, daddr;
LogFlowFunc(("pMBuf:%p, pcTftpIpHeaderRecv:%p\n", pMBuf, pcTftpIpHeaderRecv));
saddr.sin_addr = pcTftpIpHeaderRecv->IPv4Hdr.ip_dst;
saddr.sin_port = pcTftpIpHeaderRecv->UdpHdr.uh_dport;
daddr.sin_addr = pTftpSession->IpClientAddress;
daddr.sin_port = pTftpSession->u16ClientPort;
pMBuf->m_data += sizeof(struct udpiphdr);
pMBuf->m_len -= sizeof(struct udpiphdr);
udp_output2(pData, NULL, pMBuf, &saddr, &daddr, IPTOS_LOWDELAY);
LogFlowFuncLeaveRC(rc);
return rc;
}
int slirpTftpInput(PNATState pData, struct mbuf *pMbuf)
{
PTFTPIPHDR pTftpIpHeader = NULL;
AssertPtr(pData);
AssertPtr(pMbuf);
pTftpIpHeader = mtod(pMbuf, PTFTPIPHDR);
switch(RT_N2H_U16(pTftpIpHeader->u16TftpOpType))
{
case TFTP_RRQ:
tftpProcessRRQ(pData, pTftpIpHeader, m_length(pMbuf, NULL));
break;
case TFTP_ACK:
tftpProcessACK(pData, pTftpIpHeader);
break;
default:;
}
LogFlowFuncLeaveRC(VINF_SUCCESS);
return VINF_SUCCESS;
}
int GuestFsObjData::FromStat(const GuestProcessStreamBlock &strmBlk)
{
LogFlowFunc(("\n"));
int rc = VINF_SUCCESS;
try
{
#ifdef DEBUG
strmBlk.DumpToLog();
#endif
/* Node ID, optional because we don't include this
* in older VBoxService (< 4.2) versions. */
mNodeID = strmBlk.GetInt64("node_id");
/* Object name. */
mName = strmBlk.GetString("name");
if (mName.isEmpty()) throw VERR_NOT_FOUND;
/* Type. */
Utf8Str strType(strmBlk.GetString("ftype"));
if (strType.equalsIgnoreCase("-"))
mType = FsObjType_File;
else if (strType.equalsIgnoreCase("d"))
mType = FsObjType_Directory;
/** @todo Add more types! */
else
mType = FsObjType_Undefined;
/* Object size. */
rc = strmBlk.GetInt64Ex("st_size", &mObjectSize);
if (RT_FAILURE(rc)) throw rc;
/** @todo Add complete stat info! */
}
catch (int rc2)
{
rc = rc2;
}
LogFlowFuncLeaveRC(rc);
return rc;
}
/* S/G API */
int VBoxNetBaseService::sendBufferOnWire(PCINTNETSEG paSegs, size_t cSegs, size_t cbFrame)
{
/* Allocate frame */
PINTNETHDR pHdr = NULL;
uint8_t *pbFrame = NULL;
int rc = IntNetRingAllocateFrame(&m->m_pIfBuf->Send, (uint32_t)cbFrame, &pHdr, (void **)&pbFrame);
AssertRCReturn(rc, rc);
/* Now we fill pvFrame with S/G above */
size_t offFrame = 0;
for (size_t idxSeg = 0; idxSeg < cSegs; ++idxSeg)
{
memcpy(&pbFrame[offFrame], paSegs[idxSeg].pv, paSegs[idxSeg].cb);
offFrame += paSegs[idxSeg].cb;
}
/* Commit */
IntNetRingCommitFrameEx(&m->m_pIfBuf->Send, pHdr, cbFrame);
LogFlowFuncLeaveRC(rc);
return rc;
}
/* S/G API */
int VBoxNetBaseService::sendBufferOnWire(PCINTNETSEG pcSg, int cSg, size_t cbFrame)
{
int rc = VINF_SUCCESS;
PINTNETHDR pHdr = NULL;
uint8_t *pu8Frame = NULL;
int offFrame = 0;
int idxSg = 0;
/* Allocate frame */
rc = IntNetRingAllocateFrame(&m_pIfBuf->Send, cbFrame, &pHdr, (void **)&pu8Frame);
AssertRCReturn(rc, rc);
/* Now we fill pvFrame with S/G above */
for (idxSg = 0; idxSg < cSg; ++idxSg)
{
memcpy(&pu8Frame[offFrame], pcSg[idxSg].pv, pcSg[idxSg].cb);
offFrame+=pcSg[idxSg].cb;
}
/* Commit */
IntNetRingCommitFrame(&m_pIfBuf->Send, pHdr);
LogFlowFuncLeaveRC(rc);
return rc;
}
int GuestBase::cancelWaitEvents(void)
{
LogFlowThisFuncEnter();
int rc = RTCritSectEnter(&mWaitEventCritSect);
if (RT_SUCCESS(rc))
{
GuestEventGroup::iterator itEventGroups = mWaitEventGroups.begin();
while (itEventGroups != mWaitEventGroups.end())
{
GuestWaitEvents::iterator itEvents = itEventGroups->second.begin();
while (itEvents != itEventGroups->second.end())
{
GuestWaitEvent *pEvent = itEvents->second;
AssertPtr(pEvent);
/*
* Just cancel the event, but don't remove it from the
* wait events map. Don't delete it though, this (hopefully)
* is done by the caller using unregisterWaitEvent().
*/
int rc2 = pEvent->Cancel();
AssertRC(rc2);
itEvents++;
}
itEventGroups++;
}
int rc2 = RTCritSectLeave(&mWaitEventCritSect);
if (RT_SUCCESS(rc))
rc = rc2;
}
LogFlowFuncLeaveRC(rc);
return rc;
}
int GuestDnDBase::updateProgress(GuestDnDData *pData, GuestDnDResponse *pResp,
uint32_t cbDataAdd /* = 0 */)
{
AssertPtrReturn(pData, VERR_INVALID_POINTER);
AssertPtrReturn(pResp, VERR_INVALID_POINTER);
/* cbDataAdd is optional. */
LogFlowFunc(("cbTotal=%RU64, cbProcessed=%RU64, cbRemaining=%RU64, cbDataAdd=%RU32\n",
pData->getTotal(), pData->getProcessed(), pData->getRemaining(), cbDataAdd));
if (!pResp)
return VINF_SUCCESS;
if (cbDataAdd)
pData->addProcessed(cbDataAdd);
int rc = pResp->setProgress(pData->getPercentComplete(),
pData->isComplete()
? DND_PROGRESS_COMPLETE
: DND_PROGRESS_RUNNING);
LogFlowFuncLeaveRC(rc);
return rc;
}
