GuestDnDSourceImpl.cpp@ 98262

Last change on this file since 98262 was 98262, checked in by vboxsync, 23 months ago
Main: rc() -> hrc()/vrc(). bugref:10223
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 60.6 KB

Line
1	/* $Id: GuestDnDSourceImpl.cpp 98262 2023-01-24 01:42:14Z vboxsync $ */
2	/** @file
3	* VBox Console COM Class implementation - Guest drag and drop source.
4	*/
5
6	/*
7	* Copyright (C) 2014-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_GUEST_DND //LOG_GROUP_MAIN_GUESTDNDSOURCE
33	#include "LoggingNew.h"
34
35	#include "GuestImpl.h"
36	#include "GuestDnDSourceImpl.h"
37	#include "GuestDnDPrivate.h"
38	#include "ConsoleImpl.h"
39
40	#include "Global.h"
41	#include "AutoCaller.h"
42	#include "ThreadTask.h"
43
44	#include <iprt/asm.h>
45	#include <iprt/dir.h>
46	#include <iprt/file.h>
47	#include <iprt/path.h>
48	#include <iprt/uri.h>
49
50	#include <iprt/cpp/utils.h> /* For unconst(). */
51
52	#include <VBox/com/array.h>
53
54
55	/**
56	* Base class for a source task.
57	*/
58	class GuestDnDSourceTask : public ThreadTask
59	{
60	public:
61
62	GuestDnDSourceTask(GuestDnDSource *pSource)
63	: ThreadTask("GenericGuestDnDSourceTask")
64	, mSource(pSource)
65	, mRC(VINF_SUCCESS) { }
66
67	virtual ~GuestDnDSourceTask(void) { }
68
69	/** Returns the overall result of the task. */
70	int getRC(void) const { return mRC; }
71	/** Returns if the overall result of the task is ok (succeeded) or not. */
72	bool isOk(void) const { return RT_SUCCESS(mRC); }
73
74	protected:
75
76	/** COM object pointer to the parent (source). */
77	const ComObjPtr<GuestDnDSource> mSource;
78	/** Overall result of the task. */
79	int mRC;
80	};
81
82	/**
83	* Task structure for receiving data from a source using
84	* a worker thread.
85	*/
86	class GuestDnDRecvDataTask : public GuestDnDSourceTask
87	{
88	public:
89
90	GuestDnDRecvDataTask(GuestDnDSource pSource, GuestDnDRecvCtx pCtx)
91	: GuestDnDSourceTask(pSource)
92	, mpCtx(pCtx)
93	{
94	m_strTaskName = "dndSrcRcvData";
95	}
96
97	void handler()
98	{
99	LogFlowThisFunc(("\n"));
100
101	const ComObjPtr<GuestDnDSource> pThis(mSource);
102	Assert(!pThis.isNull());
103
104	AutoCaller autoCaller(pThis);
105	if (FAILED(autoCaller.hrc()))
106	return;
107
108	int vrc = pThis->i_receiveData(mpCtx, RT_INDEFINITE_WAIT /* msTimeout */);
109	if (RT_FAILURE(vrc)) /* In case we missed some error handling within i_receiveData(). */
110	{
111	if (vrc != VERR_CANCELLED)
112	LogRel(("DnD: Receiving data from guest failed with %Rrc\n", vrc));
113
114	/* Make sure to fire a cancel request to the guest side in case something went wrong. */
115	pThis->sendCancel();
116	}
117	}
118
119	virtual ~GuestDnDRecvDataTask(void) { }
120
121	protected:
122
123	/** Pointer to receive data context. */
124	GuestDnDRecvCtx *mpCtx;
125	};
126
127	// constructor / destructor
128	/////////////////////////////////////////////////////////////////////////////
129
130	GuestDnDSource::GuestDnDSource(void)
131	: GuestDnDBase(this) { }
132
133	GuestDnDSource::~GuestDnDSource(void) { }
134
135	HRESULT GuestDnDSource::FinalConstruct(void)
136	{
137	/*
138	* Set the maximum block size this source can handle to 64K. This always has
139	* been hardcoded until now.
140	*
141	* Note: Never ever rely on information from the guest; the host dictates what and
142	* how to do something, so try to negogiate a sensible value here later.
143	*/
144	mData.mcbBlockSize = DND_DEFAULT_CHUNK_SIZE; /** @todo Make this configurable. */
145
146	LogFlowThisFunc(("\n"));
147	return BaseFinalConstruct();
148	}
149
150	void GuestDnDSource::FinalRelease(void)
151	{
152	LogFlowThisFuncEnter();
153	uninit();
154	BaseFinalRelease();
155	LogFlowThisFuncLeave();
156	}
157
158	// public initializer/uninitializer for internal purposes only
159	/////////////////////////////////////////////////////////////////////////////
160
161	HRESULT GuestDnDSource::init(const ComObjPtr<Guest>& pGuest)
162	{
163	LogFlowThisFuncEnter();
164
165	/* Enclose the state transition NotReady->InInit->Ready. */
166	AutoInitSpan autoInitSpan(this);
167	AssertReturn(autoInitSpan.isOk(), E_FAIL);
168
169	unconst(m_pGuest) = pGuest;
170
171	/* Set the response we're going to use for this object.
172	*
173	* At the moment we only have one response total, as we
174	* don't allow
175	* 1) parallel transfers (multiple G->H at the same time)
176	* nor 2) mixed transfers (G->H + H->G at the same time).
177	*/
178	m_pState = GuestDnDInst()->getState();
179	AssertPtrReturn(m_pState, E_POINTER);
180
181	/* Confirm a successful initialization when it's the case. */
182	autoInitSpan.setSucceeded();
183
184	return S_OK;
185	}
186
187	/**
188	* Uninitializes the instance.
189	* Called from FinalRelease().
190	*/
191	void GuestDnDSource::uninit(void)
192	{
193	LogFlowThisFunc(("\n"));
194
195	/* Enclose the state transition Ready->InUninit->NotReady. */
196	AutoUninitSpan autoUninitSpan(this);
197	if (autoUninitSpan.uninitDone())
198	return;
199	}
200
201	// implementation of wrapped IDnDBase methods.
202	/////////////////////////////////////////////////////////////////////////////
203
204	HRESULT GuestDnDSource::isFormatSupported(const com::Utf8Str &aFormat, BOOL *aSupported)
205	{
206	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
207	ReturnComNotImplemented();
208	#else /* VBOX_WITH_DRAG_AND_DROP */
209
210	AutoCaller autoCaller(this);
211	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
212
213	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
214
215	*aSupported = GuestDnDBase::i_isFormatSupported(aFormat) ? TRUE : FALSE;
216
217	return S_OK;
218	#endif /* VBOX_WITH_DRAG_AND_DROP */
219	}
220
221	HRESULT GuestDnDSource::getFormats(GuestDnDMIMEList &aFormats)
222	{
223	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
224	ReturnComNotImplemented();
225	#else /* VBOX_WITH_DRAG_AND_DROP */
226
227	AutoCaller autoCaller(this);
228	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
229
230	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
231
232	aFormats = GuestDnDBase::i_getFormats();
233
234	return S_OK;
235	#endif /* VBOX_WITH_DRAG_AND_DROP */
236	}
237
238	HRESULT GuestDnDSource::addFormats(const GuestDnDMIMEList &aFormats)
239	{
240	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
241	ReturnComNotImplemented();
242	#else /* VBOX_WITH_DRAG_AND_DROP */
243
244	AutoCaller autoCaller(this);
245	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
246
247	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
248
249	return GuestDnDBase::i_addFormats(aFormats);
250	#endif /* VBOX_WITH_DRAG_AND_DROP */
251	}
252
253	HRESULT GuestDnDSource::removeFormats(const GuestDnDMIMEList &aFormats)
254	{
255	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
256	ReturnComNotImplemented();
257	#else /* VBOX_WITH_DRAG_AND_DROP */
258
259	AutoCaller autoCaller(this);
260	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
261
262	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
263
264	return GuestDnDBase::i_removeFormats(aFormats);
265	#endif /* VBOX_WITH_DRAG_AND_DROP */
266	}
267
268	// implementation of wrapped IDnDSource methods.
269	/////////////////////////////////////////////////////////////////////////////
270
271	HRESULT GuestDnDSource::dragIsPending(ULONG uScreenId, GuestDnDMIMEList &aFormats,
272	std::vector<DnDAction_T> &aAllowedActions, DnDAction_T *aDefaultAction)
273	{
274	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
275	ReturnComNotImplemented();
276	#else /* VBOX_WITH_DRAG_AND_DROP */
277
278	/* aDefaultAction is optional. */
279
280	AutoCaller autoCaller(this);
281	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
282
283	/* Default is ignoring the action. */
284	if (aDefaultAction)
285	*aDefaultAction = DnDAction_Ignore;
286
287	GuestDnDState *pState = GuestDnDInst()->getState();
288	AssertPtr(pState);
289
290	/* Check if any operation is active, and if so, bail out, returning an ignore action (see above). */
291	if (pState->get() != VBOXDNDSTATE_UNKNOWN)
292	return S_OK;
293
294	pState->set(VBOXDNDSTATE_QUERY_FORMATS);
295
296	HRESULT hrc = S_OK;
297
298	GuestDnDMsg Msg;
299	Msg.setType(HOST_DND_FN_GH_REQ_PENDING);
300	if (m_pState->m_uProtocolVersion >= 3)
301	Msg.appendUInt32(0); /** @todo ContextID not used yet. */
302	Msg.appendUInt32(uScreenId);
303
304	int vrc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
305	if (RT_SUCCESS(vrc))
306	{
307	int vrcGuest;
308	vrc = pState->waitForGuestResponseEx(100 /* Timeout in ms */, &vrcGuest);
309	if (RT_SUCCESS(vrc))
310	{
311	if (!isDnDIgnoreAction(pState->getActionDefault()))
312	{
313	/*
314	* In the GuestDnDSource case the source formats are from the guest,
315	* as GuestDnDSource acts as a target for the guest. The host always
316	* dictates what's supported and what's not, so filter out all formats
317	* which are not supported by the host.
318	*/
319	GuestDnDMIMEList const &lstGuest = pState->formats();
320	GuestDnDMIMEList const lstFiltered = GuestDnD::toFilteredFormatList(m_lstFmtSupported, lstGuest);
321	if (lstFiltered.size())
322	{
323	LogRel2(("DnD: Host offered the following formats:\n"));
324	for (size_t i = 0; i < lstFiltered.size(); i++)
325	LogRel2(("DnD:\tFormat #%zu: %s\n", i, lstFiltered.at(i).c_str()));
326
327	aFormats = lstFiltered;
328	aAllowedActions = GuestDnD::toMainActions(pState->getActionsAllowed());
329	if (aDefaultAction)
330	*aDefaultAction = GuestDnD::toMainAction(pState->getActionDefault());
331
332	/* Apply the (filtered) formats list. */
333	m_lstFmtOffered = lstFiltered;
334	}
335	else
336	{
337	bool fSetError = true; /* Whether to set an error and reset or not. */
338
339	/*
340	* HACK ALERT: As we now expose an error (via i_setErrorAndReset(), see below) back to the API client, we
341	* have to add a kludge here. Older X11-based Guest Additions report "TARGETS, MULTIPLE" back
342	* to us, even if they don't offer any other supported formats of the host. This then in turn
343	* would lead to exposing an error, whereas we just should ignore those specific X11-based
344	* formats. For anything other we really want to be notified by setting an error though.
345	*/
346	if ( lstGuest.size() == 2
347	&& GuestDnD::isFormatInFormatList("TARGETS", lstGuest)
348	&& GuestDnD::isFormatInFormatList("MULTIPLE", lstGuest))
349	{
350	fSetError = false;
351	}
352	/* HACK ALERT END */
353
354	if (fSetError)
355	hrc = i_setErrorAndReset(tr("Negotiation of formats between guest and host failed!\n\nHost offers: %s\n\nGuest offers: %s"),
356	GuestDnD::toFormatString(m_lstFmtSupported , ",").c_str(),
357	GuestDnD::toFormatString(pState->formats() , ",").c_str());
358	else /* Just silently reset. */
359	i_reset();
360	}
361	}
362	/* Note: Don't report an error here when the action is "ignore" -- that only means that the current window on the guest
363	simply doesn't support the format or drag and drop at all. */
364	}
365	else
366	hrc = i_setErrorAndReset(vrc == VERR_DND_GUEST_ERROR ? vrcGuest : vrc, tr("Requesting pending data from guest failed"));
367	}
368	else
369	{
370	switch (vrc)
371	{
372	case VERR_ACCESS_DENIED:
373	{
374	hrc = i_setErrorAndReset(tr("Dragging from guest to host not allowed -- make sure that the correct drag'n drop mode is set"));
375	break;
376	}
377
378	case VERR_NOT_SUPPORTED:
379	{
380	hrc = i_setErrorAndReset(tr("Dragging from guest to host not supported by guest -- make sure that the Guest Additions are properly installed and running"));
381	break;
382	}
383
384	default:
385	{
386	hrc = i_setErrorAndReset(vrc, tr("Sending drag pending event to guest failed"));
387	break;
388	}
389	}
390	}
391
392	pState->set(VBOXDNDSTATE_UNKNOWN);
393
394	LogFlowFunc(("hr=%Rhrc\n", hrc));
395	return hrc;
396	#endif /* VBOX_WITH_DRAG_AND_DROP */
397	}
398
399	HRESULT GuestDnDSource::drop(const com::Utf8Str &aFormat, DnDAction_T aAction, ComPtr<IProgress> &aProgress)
400	{
401	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
402	ReturnComNotImplemented();
403	#else /* VBOX_WITH_DRAG_AND_DROP */
404
405	AutoCaller autoCaller(this);
406	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
407
408	LogFunc(("aFormat=%s, aAction=%RU32\n", aFormat.c_str(), aAction));
409
410	/* Input validation. */
411	if (RT_UNLIKELY((aFormat.c_str()) == NULL \|\| *(aFormat.c_str()) == '\0'))
412	return setError(E_INVALIDARG, tr("No drop format specified"));
413
414	/* Is the specified format in our list of (left over) offered formats? */
415	if (!GuestDnD::isFormatInFormatList(aFormat, m_lstFmtOffered))
416	return setError(E_INVALIDARG, tr("Specified format '%s' is not supported"), aFormat.c_str());
417
418	/* Check that the given action is supported by us. */
419	VBOXDNDACTION dndAction = GuestDnD::toHGCMAction(aAction);
420	if (isDnDIgnoreAction(dndAction)) /* If there is no usable action, ignore this request. */
421	return S_OK;
422
423	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
424
425	/* Check if this object still is in a pending state and bail out if so. */
426	if (m_fIsPending)
427	return setError(E_FAIL, tr("Current drop operation to host still in progress"));
428
429	/* Reset our internal state. */
430	i_reset();
431
432	/* At the moment we only support one transfer at a time. */
433	if (GuestDnDInst()->getSourceCount())
434	return setError(E_INVALIDARG, tr("Another drag and drop operation to the host already is in progress"));
435
436	/* Reset progress object. */
437	GuestDnDState *pState = GuestDnDInst()->getState();
438	AssertPtr(pState);
439	HRESULT hr = pState->resetProgress(m_pGuest, tr("Dropping data to host"));
440	if (FAILED(hr))
441	return hr;
442
443	GuestDnDRecvDataTask *pTask = NULL;
444
445	try
446	{
447	mData.mRecvCtx.pSource = this;
448	mData.mRecvCtx.pState = pState;
449	mData.mRecvCtx.enmAction = dndAction;
450	mData.mRecvCtx.strFmtReq = aFormat;
451	mData.mRecvCtx.lstFmtOffered = m_lstFmtOffered;
452
453	LogRel2(("DnD: Requesting data from guest in format '%s'\n", aFormat.c_str()));
454
455	pTask = new GuestDnDRecvDataTask(this, &mData.mRecvCtx);
456	if (!pTask->isOk())
457	{
458	delete pTask;
459	LogRel2(("DnD: Receive data task failed to initialize\n"));
460	throw hr = E_FAIL;
461	}
462
463	/* Drop write lock before creating thread. */
464	alock.release();
465
466	/* This function delete pTask in case of exceptions,
467	* so there is no need in the call of delete operator. */
468	hr = pTask->createThreadWithType(RTTHREADTYPE_MAIN_WORKER);
469	pTask = NULL; /* Note: pTask is now owned by the worker thread. */
470	}
471	catch (std::bad_alloc &)
472	{
473	hr = E_OUTOFMEMORY;
474	}
475	catch (...)
476	{
477	LogRel2(("DnD: Could not create thread for data receiving task\n"));
478	hr = E_FAIL;
479	}
480
481	if (SUCCEEDED(hr))
482	{
483	/* Register ourselves at the DnD manager. */
484	GuestDnDInst()->registerSource(this);
485
486	hr = pState->queryProgressTo(aProgress.asOutParam());
487	ComAssertComRC(hr);
488
489	}
490	else
491	hr = i_setErrorAndReset(tr("Starting thread for GuestDnDSource failed (%Rhrc)"), hr);
492
493	LogFlowFunc(("Returning hr=%Rhrc\n", hr));
494	return hr;
495	#endif /* VBOX_WITH_DRAG_AND_DROP */
496	}
497
498	HRESULT GuestDnDSource::receiveData(std::vector<BYTE> &aData)
499	{
500	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
501	ReturnComNotImplemented();
502	#else /* VBOX_WITH_DRAG_AND_DROP */
503
504	AutoCaller autoCaller(this);
505	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
506
507	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
508
509	/* Don't allow receiving the actual data until our current transfer is complete. */
510	if (m_fIsPending)
511	return setError(E_FAIL, tr("Current drop operation to host still in progress"));
512
513	HRESULT hr = S_OK;
514
515	try
516	{
517	GuestDnDRecvCtx *pCtx = &mData.mRecvCtx;
518	if (DnDMIMENeedsDropDir(pCtx->strFmtRecv.c_str(), pCtx->strFmtRecv.length()))
519	{
520	PDNDDROPPEDFILES pDF = &pCtx->Transfer.DroppedFiles;
521
522	const char *pcszDropDirAbs = DnDDroppedFilesGetDirAbs(pDF);
523	AssertPtr(pcszDropDirAbs);
524
525	LogRel2(("DnD: Using drop directory '%s', got %RU64 root entries\n",
526	pcszDropDirAbs, DnDTransferListGetRootCount(&pCtx->Transfer.List)));
527
528	/* We return the data as "text/uri-list" MIME data here. */
529	char *pszBuf = NULL;
530	size_t cbBuf = 0;
531	int rc = DnDTransferListGetRootsEx(&pCtx->Transfer.List, DNDTRANSFERLISTFMT_URI,
532	pcszDropDirAbs, DND_PATH_SEPARATOR_STR, &pszBuf, &cbBuf);
533	if (RT_SUCCESS(rc))
534	{
535	Assert(cbBuf);
536	AssertPtr(pszBuf);
537
538	aData.resize(cbBuf);
539	memcpy(&aData.front(), pszBuf, cbBuf);
540	RTStrFree(pszBuf);
541	}
542	else
543	LogRel(("DnD: Unable to build source root list, rc=%Rrc\n", rc));
544	}
545	else /* Raw data. */
546	{
547	if (pCtx->Meta.cbData)
548	{
549	/* Copy the data into a safe array of bytes. */
550	aData.resize(pCtx->Meta.cbData);
551	memcpy(&aData.front(), pCtx->Meta.pvData, pCtx->Meta.cbData);
552	}
553	else
554	aData.resize(0);
555	}
556	}
557	catch (std::bad_alloc &)
558	{
559	hr = E_OUTOFMEMORY;
560	}
561
562	LogFlowFunc(("Returning hr=%Rhrc\n", hr));
563	return hr;
564	#endif /* VBOX_WITH_DRAG_AND_DROP */
565	}
566
567	// implementation of internal methods.
568	/////////////////////////////////////////////////////////////////////////////
569
570	/**
571	* Returns an error string from a guest DnD error.
572	*
573	* @returns Error string.
574	* @param guestRc Guest error to return error string for.
575	*/
576	/* static */
577	Utf8Str GuestDnDSource::i_guestErrorToString(int guestRc)
578	{
579	Utf8Str strError;
580
581	switch (guestRc)
582	{
583	case VERR_ACCESS_DENIED:
584	strError += Utf8StrFmt(tr("For one or more guest files or directories selected for transferring to the host your guest "
585	"user does not have the appropriate access rights for. Please make sure that all selected "
586	"elements can be accessed and that your guest user has the appropriate rights"));
587	break;
588
589	case VERR_NOT_FOUND:
590	/* Should not happen due to file locking on the guest, but anyway ... */
591	strError += Utf8StrFmt(tr("One or more guest files or directories selected for transferring to the host were not"
592	"found on the guest anymore. This can be the case if the guest files were moved and/or"
593	"altered while the drag and drop operation was in progress"));
594	break;
595
596	case VERR_SHARING_VIOLATION:
597	strError += Utf8StrFmt(tr("One or more guest files or directories selected for transferring to the host were locked. "
598	"Please make sure that all selected elements can be accessed and that your guest user has "
599	"the appropriate rights"));
600	break;
601
602	case VERR_TIMEOUT:
603	strError += Utf8StrFmt(tr("The guest was not able to retrieve the drag and drop data within time"));
604	break;
605
606	default:
607	strError += Utf8StrFmt(tr("Drag and drop error from guest (%Rrc)"), guestRc);
608	break;
609	}
610
611	return strError;
612	}
613
614	/**
615	* Returns an error string from a host DnD error.
616	*
617	* @returns Error string.
618	* @param hostRc Host error to return error string for.
619	*/
620	/* static */
621	Utf8Str GuestDnDSource::i_hostErrorToString(int hostRc)
622	{
623	Utf8Str strError;
624
625	switch (hostRc)
626	{
627	case VERR_ACCESS_DENIED:
628	strError += Utf8StrFmt(tr("For one or more host files or directories selected for transferring to the guest your host "
629	"user does not have the appropriate access rights for. Please make sure that all selected "
630	"elements can be accessed and that your host user has the appropriate rights."));
631	break;
632
633	case VERR_DISK_FULL:
634	strError += Utf8StrFmt(tr("Host disk ran out of space (disk is full)."));
635	break;
636
637	case VERR_NOT_FOUND:
638	/* Should not happen due to file locking on the host, but anyway ... */
639	strError += Utf8StrFmt(tr("One or more host files or directories selected for transferring to the host were not"
640	"found on the host anymore. This can be the case if the host files were moved and/or"
641	"altered while the drag and drop operation was in progress."));
642	break;
643
644	case VERR_SHARING_VIOLATION:
645	strError += Utf8StrFmt(tr("One or more host files or directories selected for transferring to the guest were locked. "
646	"Please make sure that all selected elements can be accessed and that your host user has "
647	"the appropriate rights."));
648	break;
649
650	default:
651	strError += Utf8StrFmt(tr("Drag and drop error from host (%Rrc)"), hostRc);
652	break;
653	}
654
655	return strError;
656	}
657
658	/**
659	* Resets all internal data and state.
660	*/
661	void GuestDnDSource::i_reset(void)
662	{
663	LogRel2(("DnD: Source reset\n"));
664
665	mData.mRecvCtx.reset();
666
667	m_fIsPending = false;
668
669	/* Unregister ourselves from the DnD manager. */
670	GuestDnDInst()->unregisterSource(this);
671	}
672
673	#ifdef VBOX_WITH_DRAG_AND_DROP_GH
674
675	/**
676	* Handles receiving a send data header from the guest.
677	*
678	* @returns VBox status code.
679	* @param pCtx Receive context to use.
680	* @param pDataHdr Pointer to send data header from the guest.
681	*/
682	int GuestDnDSource::i_onReceiveDataHdr(GuestDnDRecvCtx *pCtx, PVBOXDNDSNDDATAHDR pDataHdr)
683	{
684	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
685	AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
686
687	LogRel2(("DnD: Receiving %RU64 bytes total data (%RU32 bytes meta data, %RU64 objects) from guest ...\n",
688	pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects));
689
690	AssertReturn(pDataHdr->cbTotal >= pDataHdr->cbMeta, VERR_INVALID_PARAMETER);
691
692	pCtx->Meta.cbAnnounced = pDataHdr->cbMeta;
693	pCtx->cbExtra = pDataHdr->cbTotal - pDataHdr->cbMeta;
694
695	Assert(pCtx->Transfer.cObjToProcess == 0); /* Sanity. */
696	Assert(pCtx->Transfer.cObjProcessed == 0);
697
698	pCtx->Transfer.reset();
699
700	pCtx->Transfer.cObjToProcess = pDataHdr->cObjects;
701
702	/** @todo Handle compression type. */
703	/** @todo Handle checksum type. */
704
705	LogFlowFuncLeave();
706	return VINF_SUCCESS;
707	}
708
709	/**
710	* Main function for receiving data from the guest.
711	*
712	* @returns VBox status code.
713	* @param pCtx Receive context to use.
714	* @param pSndData Pointer to send data block from the guest.
715	*/
716	int GuestDnDSource::i_onReceiveData(GuestDnDRecvCtx *pCtx, PVBOXDNDSNDDATA pSndData)
717	{
718	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
719	AssertPtrReturn(pSndData, VERR_INVALID_POINTER);
720
721	int rc = VINF_SUCCESS;
722
723	try
724	{
725	GuestDnDTransferRecvData *pTransfer = &pCtx->Transfer;
726
727	size_t cbData;
728	void *pvData;
729	size_t cbTotalAnnounced;
730	size_t cbMetaAnnounced;
731
732	if (m_pState->m_uProtocolVersion < 3)
733	{
734	cbData = pSndData->u.v1.cbData;
735	pvData = pSndData->u.v1.pvData;
736
737	/* Sends the total data size to receive for every data chunk. */
738	cbTotalAnnounced = pSndData->u.v1.cbTotalSize;
739
740	/* Meta data size always is cbData, meaning there cannot be an
741	* extended data chunk transfer by sending further data. */
742	cbMetaAnnounced = cbData;
743	}
744	else
745	{
746	cbData = pSndData->u.v3.cbData;
747	pvData = pSndData->u.v3.pvData;
748
749	/* Note: Data sizes get initialized in i_onReceiveDataHdr().
750	* So just use the set values here. */
751	cbTotalAnnounced = pCtx->getTotalAnnounced();
752	cbMetaAnnounced = pCtx->Meta.cbAnnounced;
753	}
754
755	if (cbData > cbTotalAnnounced)
756	{
757	AssertMsgFailed(("Incoming data size invalid: cbData=%zu, cbTotal=%zu\n", cbData, cbTotalAnnounced));
758	rc = VERR_INVALID_PARAMETER;
759	}
760	else if ( cbTotalAnnounced == 0
761	\|\| cbTotalAnnounced < cbMetaAnnounced)
762	{
763	AssertMsgFailed(("cbTotal (%zu) is smaller than cbMeta (%zu)\n", cbTotalAnnounced, cbMetaAnnounced));
764	rc = VERR_INVALID_PARAMETER;
765	}
766
767	if (RT_FAILURE(rc))
768	return rc;
769
770	AssertReturn(cbData <= mData.mcbBlockSize, VERR_BUFFER_OVERFLOW);
771
772	const size_t cbMetaRecv = pCtx->Meta.add(pvData, cbData);
773	AssertReturn(cbMetaRecv <= pCtx->Meta.cbData, VERR_BUFFER_OVERFLOW);
774
775	LogFlowThisFunc(("cbData=%zu, cbMetaRecv=%zu, cbMetaAnnounced=%zu, cbTotalAnnounced=%zu\n",
776	cbData, cbMetaRecv, cbMetaAnnounced, cbTotalAnnounced));
777
778	LogRel2(("DnD: %RU8%% of meta data complete (%zu/%zu bytes)\n",
779	(uint8_t)(cbMetaRecv * 100 / RT_MAX(cbMetaAnnounced, 1)), cbMetaRecv, cbMetaAnnounced));
780
781	/*
782	* (Meta) Data transfer complete?
783	*/
784	if (cbMetaAnnounced == cbMetaRecv)
785	{
786	LogRel2(("DnD: Receiving meta data complete\n"));
787
788	if (DnDMIMENeedsDropDir(pCtx->strFmtRecv.c_str(), pCtx->strFmtRecv.length()))
789	{
790	rc = DnDTransferListInitEx(&pTransfer->List,
791	DnDDroppedFilesGetDirAbs(&pTransfer->DroppedFiles), DNDTRANSFERLISTFMT_NATIVE);
792	if (RT_SUCCESS(rc))
793	rc = DnDTransferListAppendRootsFromBuffer(&pTransfer->List, DNDTRANSFERLISTFMT_URI,
794	(const char *)pCtx->Meta.pvData, pCtx->Meta.cbData, DND_PATH_SEPARATOR_STR,
795	DNDTRANSFERLIST_FLAGS_NONE);
796	/* Validation. */
797	if (RT_SUCCESS(rc))
798	{
799	uint64_t cRoots = DnDTransferListGetRootCount(&pTransfer->List);
800
801	LogRel2(("DnD: Received %RU64 root entries from guest\n", cRoots));
802
803	if ( cRoots == 0
804	\|\| cRoots > pTransfer->cObjToProcess)
805	{
806	LogRel(("DnD: Number of root entries invalid / mismatch: Got %RU64, expected %RU64\n",
807	cRoots, pTransfer->cObjToProcess));
808	rc = VERR_INVALID_PARAMETER;
809	}
810	}
811
812	if (RT_SUCCESS(rc))
813	{
814	/* Update our process with the data we already received. */
815	rc = updateProgress(pCtx, pCtx->pState, cbMetaAnnounced);
816	AssertRC(rc);
817	}
818
819	if (RT_FAILURE(rc))
820	LogRel(("DnD: Error building root entry list, rc=%Rrc\n", rc));
821	}
822	else /* Raw data. */
823	{
824	rc = updateProgress(pCtx, pCtx->pState, cbData);
825	AssertRC(rc);
826	}
827
828	if (RT_FAILURE(rc))
829	LogRel(("DnD: Error receiving meta data, rc=%Rrc\n", rc));
830	}
831	}
832	catch (std::bad_alloc &)
833	{
834	rc = VERR_NO_MEMORY;
835	}
836
837	LogFlowFuncLeaveRC(rc);
838	return rc;
839	}
840
841
842	int GuestDnDSource::i_onReceiveDir(GuestDnDRecvCtx pCtx, const char pszPath, uint32_t cbPath, uint32_t fMode)
843	{
844	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
845	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
846	AssertReturn(cbPath, VERR_INVALID_PARAMETER);
847
848	LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x\n", pszPath, cbPath, fMode));
849
850	const PDNDTRANSFEROBJECT pObj = &pCtx->Transfer.ObjCur;
851	const PDNDDROPPEDFILES pDF = &pCtx->Transfer.DroppedFiles;
852
853	int rc = DnDTransferObjectInitEx(pObj, DNDTRANSFEROBJTYPE_DIRECTORY,
854	DnDDroppedFilesGetDirAbs(pDF), pszPath);
855	if (RT_SUCCESS(rc))
856	{
857	const char *pcszPathAbs = DnDTransferObjectGetSourcePath(pObj);
858	AssertPtr(pcszPathAbs);
859
860	rc = RTDirCreateFullPath(pcszPathAbs, fMode);
861	if (RT_SUCCESS(rc))
862	{
863	pCtx->Transfer.cObjProcessed++;
864	if (pCtx->Transfer.cObjProcessed <= pCtx->Transfer.cObjToProcess)
865	{
866	rc = DnDDroppedFilesAddDir(pDF, pcszPathAbs);
867	}
868	else
869	rc = VERR_TOO_MUCH_DATA;
870
871	DnDTransferObjectDestroy(pObj);
872
873	if (RT_FAILURE(rc))
874	LogRel2(("DnD: Created guest directory '%s' on host\n", pcszPathAbs));
875	}
876	else
877	LogRel(("DnD: Error creating guest directory '%s' on host, rc=%Rrc\n", pcszPathAbs, rc));
878	}
879
880	if (RT_FAILURE(rc))
881	LogRel(("DnD: Receiving guest directory '%s' failed with rc=%Rrc\n", pszPath, rc));
882
883	LogFlowFuncLeaveRC(rc);
884	return rc;
885	}
886
887	/**
888	* Receives a file header from the guest.
889	*
890	* @returns VBox status code.
891	* @param pCtx Receive context to use.
892	* @param pszPath File path of file to use.
893	* @param cbPath Size (in bytes, including terminator) of file path.
894	* @param cbSize File size (in bytes) to receive.
895	* @param fMode File mode to use.
896	* @param fFlags Additional receive flags; not used yet.
897	*/
898	int GuestDnDSource::i_onReceiveFileHdr(GuestDnDRecvCtx pCtx, const char pszPath, uint32_t cbPath,
899	uint64_t cbSize, uint32_t fMode, uint32_t fFlags)
900	{
901	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
902	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
903	AssertReturn(cbPath, VERR_INVALID_PARAMETER);
904	AssertReturn(fMode, VERR_INVALID_PARAMETER);
905	/* fFlags are optional. */
906
907	RT_NOREF(fFlags);
908
909	LogFlowFunc(("pszPath=%s, cbPath=%RU32, cbSize=%RU64, fMode=0x%x, fFlags=0x%x\n", pszPath, cbPath, cbSize, fMode, fFlags));
910
911	AssertMsgReturn(cbSize <= pCtx->cbExtra,
912	("File size (%RU64) exceeds extra size to transfer (%RU64)\n", cbSize, pCtx->cbExtra), VERR_INVALID_PARAMETER);
913	AssertMsgReturn( pCtx->isComplete() == false
914	&& pCtx->Transfer.cObjToProcess,
915	("Data transfer already complete, bailing out\n"), VERR_INVALID_PARAMETER);
916
917	int rc = VINF_SUCCESS;
918
919	do
920	{
921	const PDNDTRANSFEROBJECT pObj = &pCtx->Transfer.ObjCur;
922
923	if ( DnDTransferObjectIsOpen(pObj)
924	&& !DnDTransferObjectIsComplete(pObj))
925	{
926	AssertMsgFailed(("Object '%s' not complete yet\n", DnDTransferObjectGetSourcePath(pObj)));
927	rc = VERR_WRONG_ORDER;
928	break;
929	}
930
931	const PDNDDROPPEDFILES pDF = &pCtx->Transfer.DroppedFiles;
932
933	rc = DnDTransferObjectInitEx(pObj, DNDTRANSFEROBJTYPE_FILE, DnDDroppedFilesGetDirAbs(pDF), pszPath);
934	AssertRCBreak(rc);
935
936	const char *pcszSource = DnDTransferObjectGetSourcePath(pObj);
937	AssertPtrBreakStmt(pcszSource, VERR_INVALID_POINTER);
938
939	/** @todo Add sparse file support based on fFlags? (Use Open(..., fFlags \| SPARSE). */
940	rc = DnDTransferObjectOpen(pObj, RTFILE_O_CREATE_REPLACE \| RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE,
941	(fMode & RTFS_UNIX_MASK) \| RTFS_UNIX_IRUSR \| RTFS_UNIX_IWUSR, DNDTRANSFEROBJECT_FLAGS_NONE);
942	if (RT_FAILURE(rc))
943	{
944	LogRel(("DnD: Error opening/creating guest file '%s' on host, rc=%Rrc\n", pcszSource, rc));
945	break;
946	}
947
948	/* Note: Protocol v1 does not send any file sizes, so always 0. */
949	if (m_pState->m_uProtocolVersion >= 2)
950	rc = DnDTransferObjectSetSize(pObj, cbSize);
951
952	/** @todo Unescape path before printing. */
953	LogRel2(("DnD: Transferring guest file '%s' to host (%RU64 bytes, mode %#x)\n",
954	pcszSource, DnDTransferObjectGetSize(pObj), DnDTransferObjectGetMode(pObj)));
955
956	/** @todo Set progress object title to current file being transferred? */
957
958	if (DnDTransferObjectIsComplete(pObj)) /* 0-byte file? We're done already. */
959	{
960	LogRel2(("DnD: Transferring guest file '%s' (0 bytes) to host complete\n", pcszSource));
961
962	pCtx->Transfer.cObjProcessed++;
963	if (pCtx->Transfer.cObjProcessed <= pCtx->Transfer.cObjToProcess)
964	{
965	/* Add for having a proper rollback. */
966	rc = DnDDroppedFilesAddFile(pDF, pcszSource);
967	}
968	else
969	rc = VERR_TOO_MUCH_DATA;
970
971	DnDTransferObjectDestroy(pObj);
972	}
973
974	} while (0);
975
976	if (RT_FAILURE(rc))
977	LogRel(("DnD: Error receiving guest file header, rc=%Rrc\n", rc));
978
979	LogFlowFuncLeaveRC(rc);
980	return rc;
981	}
982
983	/**
984	* Receives file data from the guest.
985	*
986	* @returns VBox status code.
987	* @param pCtx Receive context to use.
988	* @param pvData Pointer to file data received from the guest.
989	* @param pCtx Size (in bytes) of file data received from the guest.
990	*/
991	int GuestDnDSource::i_onReceiveFileData(GuestDnDRecvCtx pCtx, const void pvData, uint32_t cbData)
992	{
993	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
994	AssertPtrReturn(pvData, VERR_INVALID_POINTER);
995	AssertReturn(cbData, VERR_INVALID_PARAMETER);
996
997	int rc = VINF_SUCCESS;
998
999	LogFlowFunc(("pvData=%p, cbData=%RU32, cbBlockSize=%RU32\n", pvData, cbData, mData.mcbBlockSize));
1000
1001	/*
1002	* Sanity checking.
1003	*/
1004	if (cbData > mData.mcbBlockSize)
1005	return VERR_INVALID_PARAMETER;
1006
1007	do
1008	{
1009	const PDNDTRANSFEROBJECT pObj = &pCtx->Transfer.ObjCur;
1010
1011	const char *pcszSource = DnDTransferObjectGetSourcePath(pObj);
1012	AssertPtrBreakStmt(pcszSource, VERR_INVALID_POINTER);
1013
1014	AssertMsgReturn(DnDTransferObjectIsOpen(pObj),
1015	("Object '%s' not open (anymore)\n", pcszSource), VERR_WRONG_ORDER);
1016	AssertMsgReturn(DnDTransferObjectIsComplete(pObj) == false,
1017	("Object '%s' already marked as complete\n", pcszSource), VERR_WRONG_ORDER);
1018
1019	uint32_t cbWritten;
1020	rc = DnDTransferObjectWrite(pObj, pvData, cbData, &cbWritten);
1021	if (RT_FAILURE(rc))
1022	LogRel(("DnD: Error writing guest file data for '%s', rc=%Rrc\n", pcszSource, rc));
1023
1024	Assert(cbWritten <= cbData);
1025	if (cbWritten < cbData)
1026	{
1027	LogRel(("DnD: Only written %RU32 of %RU32 bytes of guest file '%s' -- disk full?\n",
1028	cbWritten, cbData, pcszSource));
1029	rc = VERR_IO_GEN_FAILURE; /** @todo Find a better rc. */
1030	break;
1031	}
1032
1033	rc = updateProgress(pCtx, pCtx->pState, cbWritten);
1034	AssertRCBreak(rc);
1035
1036	if (DnDTransferObjectIsComplete(pObj))
1037	{
1038	LogRel2(("DnD: Transferring guest file '%s' to host complete\n", pcszSource));
1039
1040	pCtx->Transfer.cObjProcessed++;
1041	if (pCtx->Transfer.cObjProcessed > pCtx->Transfer.cObjToProcess)
1042	rc = VERR_TOO_MUCH_DATA;
1043
1044	DnDTransferObjectDestroy(pObj);
1045	}
1046
1047	} while (0);
1048
1049	if (RT_FAILURE(rc))
1050	LogRel(("DnD: Error receiving guest file data, rc=%Rrc\n", rc));
1051
1052	LogFlowFuncLeaveRC(rc);
1053	return rc;
1054	}
1055	#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1056
1057	/**
1058	* Main function to receive DnD data from the guest.
1059	*
1060	* @returns VBox status code.
1061	* @param pCtx Receive context to use.
1062	* @param msTimeout Timeout (in ms) to wait for receiving data.
1063	*/
1064	int GuestDnDSource::i_receiveData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout)
1065	{
1066	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1067
1068	/* Sanity. */
1069	AssertMsgReturn(pCtx->enmAction,
1070	("Action to perform is none when it shouldn't\n"), VERR_INVALID_PARAMETER);
1071	AssertMsgReturn(pCtx->strFmtReq.isNotEmpty(),
1072	("Requested format from host is empty when it shouldn't\n"), VERR_INVALID_PARAMETER);
1073
1074	/*
1075	* Do we need to receive a different format than initially requested?
1076	*
1077	* For example, receiving a file link as "text/plain" requires still to receive
1078	* the file from the guest as "text/uri-list" first, then pointing to
1079	* the file path on the host in the "text/plain" data returned.
1080	*/
1081
1082	bool fFoundFormat = true; /* Whether we've found a common format between host + guest. */
1083
1084	LogFlowFunc(("strFmtReq=%s, strFmtRecv=%s, enmAction=0x%x\n",
1085	pCtx->strFmtReq.c_str(), pCtx->strFmtRecv.c_str(), pCtx->enmAction));
1086
1087	/* Plain text wanted? */
1088	if ( pCtx->strFmtReq.equalsIgnoreCase("text/plain")
1089	\|\| pCtx->strFmtReq.equalsIgnoreCase("text/plain;charset=utf-8"))
1090	{
1091	/* Did the guest offer a file? Receive a file instead. */
1092	if (GuestDnD::isFormatInFormatList("text/uri-list", pCtx->lstFmtOffered))
1093	pCtx->strFmtRecv = "text/uri-list";
1094	/* Guest only offers (plain) text. */
1095	else
1096	pCtx->strFmtRecv = "text/plain;charset=utf-8";
1097
1098	/** @todo Add more conversions here. */
1099	}
1100	/* File(s) wanted? */
1101	else if (pCtx->strFmtReq.equalsIgnoreCase("text/uri-list"))
1102	{
1103	/* Does the guest support sending files? */
1104	if (GuestDnD::isFormatInFormatList("text/uri-list", pCtx->lstFmtOffered))
1105	pCtx->strFmtRecv = "text/uri-list";
1106	else /* Bail out. */
1107	fFoundFormat = false;
1108	}
1109
1110	int rc = VINF_SUCCESS;
1111
1112	if (fFoundFormat)
1113	{
1114	if (!pCtx->strFmtRecv.equals(pCtx->strFmtReq))
1115	LogRel2(("DnD: Requested data in format '%s', receiving in intermediate format '%s' now\n",
1116	pCtx->strFmtReq.c_str(), pCtx->strFmtRecv.c_str()));
1117
1118	/*
1119	* Call the appropriate receive handler based on the data format to handle.
1120	*/
1121	bool fURIData = DnDMIMENeedsDropDir(pCtx->strFmtRecv.c_str(), pCtx->strFmtRecv.length());
1122	if (fURIData)
1123	{
1124	rc = i_receiveTransferData(pCtx, msTimeout);
1125	}
1126	else
1127	{
1128	rc = i_receiveRawData(pCtx, msTimeout);
1129	}
1130	}
1131	else /* Just inform the user (if verbose release logging is enabled). */
1132	{
1133	LogRel(("DnD: The guest does not support format '%s':\n", pCtx->strFmtReq.c_str()));
1134	LogRel(("DnD: Guest offered the following formats:\n"));
1135	for (size_t i = 0; i < pCtx->lstFmtOffered.size(); i++)
1136	LogRel(("DnD:\tFormat #%zu: %s\n", i, pCtx->lstFmtOffered.at(i).c_str()));
1137
1138	rc = VERR_NOT_SUPPORTED;
1139	}
1140
1141	if (RT_FAILURE(rc))
1142	{
1143	LogRel(("DnD: Receiving data from guest failed with %Rrc\n", rc));
1144
1145	/* Let the guest side know first. */
1146	sendCancel();
1147
1148	/* Reset state. */
1149	i_reset();
1150	}
1151
1152	LogFlowFuncLeaveRC(rc);
1153	return rc;
1154	}
1155
1156	/**
1157	* Receives raw (meta) data from the guest.
1158	*
1159	* @returns VBox status code.
1160	* @param pCtx Receive context to use.
1161	* @param msTimeout Timeout (in ms) to wait for receiving data.
1162	*/
1163	int GuestDnDSource::i_receiveRawData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout)
1164	{
1165	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1166
1167	int rc;
1168
1169	LogFlowFuncEnter();
1170
1171	GuestDnDState *pState = pCtx->pState;
1172	AssertPtr(pCtx->pState);
1173
1174	GuestDnD *pInst = GuestDnDInst();
1175	if (!pInst)
1176	return VERR_INVALID_POINTER;
1177
1178	#define REGISTER_CALLBACK(x) \
1179	do { \
1180	rc = pState->setCallback(x, i_receiveRawDataCallback, pCtx); \
1181	if (RT_FAILURE(rc)) \
1182	return rc; \
1183	} while (0)
1184
1185	#define UNREGISTER_CALLBACK(x) \
1186	do { \
1187	int rc2 = pState->setCallback(x, NULL); \
1188	AssertRC(rc2); \
1189	} while (0)
1190
1191	/*
1192	* Register callbacks.
1193	*/
1194	REGISTER_CALLBACK(GUEST_DND_FN_CONNECT);
1195	REGISTER_CALLBACK(GUEST_DND_FN_DISCONNECT);
1196	REGISTER_CALLBACK(GUEST_DND_FN_EVT_ERROR);
1197	if (m_pState->m_uProtocolVersion >= 3)
1198	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA_HDR);
1199	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA);
1200
1201	do
1202	{
1203	/*
1204	* Receive the raw data.
1205	*/
1206	GuestDnDMsg Msg;
1207	Msg.setType(HOST_DND_FN_GH_EVT_DROPPED);
1208	if (m_pState->m_uProtocolVersion >= 3)
1209	Msg.appendUInt32(0); /** @todo ContextID not used yet. */
1210	Msg.appendPointer((void*)pCtx->strFmtRecv.c_str(), (uint32_t)pCtx->strFmtRecv.length() + 1);
1211	Msg.appendUInt32((uint32_t)pCtx->strFmtRecv.length() + 1);
1212	Msg.appendUInt32(pCtx->enmAction);
1213
1214	/* Make the initial call to the guest by telling that we initiated the "dropped" event on
1215	* the host and therefore now waiting for the actual raw data. */
1216	rc = pInst->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
1217	if (RT_SUCCESS(rc))
1218	{
1219	rc = waitForEvent(&pCtx->EventCallback, pCtx->pState, msTimeout);
1220	if (RT_SUCCESS(rc))
1221	rc = pCtx->pState->setProgress(100, DND_PROGRESS_COMPLETE, VINF_SUCCESS);
1222	}
1223
1224	} while (0);
1225
1226	/*
1227	* Unregister callbacks.
1228	*/
1229	UNREGISTER_CALLBACK(GUEST_DND_FN_CONNECT);
1230	UNREGISTER_CALLBACK(GUEST_DND_FN_DISCONNECT);
1231	UNREGISTER_CALLBACK(GUEST_DND_FN_EVT_ERROR);
1232	if (m_pState->m_uProtocolVersion >= 3)
1233	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA_HDR);
1234	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA);
1235
1236	#undef REGISTER_CALLBACK
1237	#undef UNREGISTER_CALLBACK
1238
1239	if (RT_FAILURE(rc))
1240	{
1241	if (rc == VERR_CANCELLED) /* Transfer was cancelled by the host. */
1242	{
1243	/*
1244	* Now that we've cleaned up tell the guest side to cancel.
1245	* This does not imply we're waiting for the guest to react, as the
1246	* host side never must depend on anything from the guest.
1247	*/
1248	int rc2 = sendCancel();
1249	AssertRC(rc2);
1250
1251	rc2 = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
1252	AssertRC(rc2);
1253	}
1254	else if (rc != VERR_DND_GUEST_ERROR) /* Guest-side error are already handled in the callback. */
1255	{
1256	int rc2 = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR,
1257	rc, GuestDnDSource::i_hostErrorToString(rc));
1258	AssertRC(rc2);
1259	}
1260
1261	rc = VINF_SUCCESS; /* The error was handled by the setProgress() calls above. */
1262	}
1263
1264	LogFlowFuncLeaveRC(rc);
1265	return rc;
1266	}
1267
1268	/**
1269	* Receives transfer data (files / directories / ...) from the guest.
1270	*
1271	* @returns VBox status code.
1272	* @param pCtx Receive context to use.
1273	* @param msTimeout Timeout (in ms) to wait for receiving data.
1274	*/
1275	int GuestDnDSource::i_receiveTransferData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout)
1276	{
1277	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1278
1279	int rc;
1280
1281	LogFlowFuncEnter();
1282
1283	GuestDnDState *pState = pCtx->pState;
1284	AssertPtr(pCtx->pState);
1285
1286	GuestDnD *pInst = GuestDnDInst();
1287	if (!pInst)
1288	return VERR_INVALID_POINTER;
1289
1290	#define REGISTER_CALLBACK(x) \
1291	do { \
1292	rc = pState->setCallback(x, i_receiveTransferDataCallback, pCtx); \
1293	if (RT_FAILURE(rc)) \
1294	return rc; \
1295	} while (0)
1296
1297	#define UNREGISTER_CALLBACK(x) \
1298	do { \
1299	int rc2 = pState->setCallback(x, NULL); \
1300	AssertRC(rc2); \
1301	} while (0)
1302
1303	/*
1304	* Register callbacks.
1305	*/
1306	/* Guest callbacks. */
1307	REGISTER_CALLBACK(GUEST_DND_FN_CONNECT);
1308	REGISTER_CALLBACK(GUEST_DND_FN_DISCONNECT);
1309	REGISTER_CALLBACK(GUEST_DND_FN_EVT_ERROR);
1310	if (m_pState->m_uProtocolVersion >= 3)
1311	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA_HDR);
1312	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA);
1313	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DIR);
1314	if (m_pState->m_uProtocolVersion >= 2)
1315	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_FILE_HDR);
1316	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_FILE_DATA);
1317
1318	const PDNDDROPPEDFILES pDF = &pCtx->Transfer.DroppedFiles;
1319
1320	do
1321	{
1322	rc = DnDDroppedFilesOpenTemp(pDF, 0 /* fFlags */);
1323	if (RT_FAILURE(rc))
1324	{
1325	LogRel(("DnD: Opening dropped files directory '%s' on the host failed with rc=%Rrc\n",
1326	DnDDroppedFilesGetDirAbs(pDF), rc));
1327	break;
1328	}
1329
1330	/*
1331	* Receive the transfer list.
1332	*/
1333	GuestDnDMsg Msg;
1334	Msg.setType(HOST_DND_FN_GH_EVT_DROPPED);
1335	if (m_pState->m_uProtocolVersion >= 3)
1336	Msg.appendUInt32(0); /** @todo ContextID not used yet. */
1337	Msg.appendPointer((void*)pCtx->strFmtRecv.c_str(), (uint32_t)pCtx->strFmtRecv.length() + 1);
1338	Msg.appendUInt32((uint32_t)pCtx->strFmtRecv.length() + 1);
1339	Msg.appendUInt32(pCtx->enmAction);
1340
1341	/* Make the initial call to the guest by telling that we initiated the "dropped" event on
1342	* the host and therefore now waiting for the actual URI data. */
1343	rc = pInst->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
1344	if (RT_SUCCESS(rc))
1345	{
1346	LogFlowFunc(("Waiting ...\n"));
1347
1348	rc = waitForEvent(&pCtx->EventCallback, pCtx->pState, msTimeout);
1349	if (RT_SUCCESS(rc))
1350	rc = pCtx->pState->setProgress(100, DND_PROGRESS_COMPLETE, VINF_SUCCESS);
1351
1352	LogFlowFunc(("Waiting ended with rc=%Rrc\n", rc));
1353	}
1354
1355	} while (0);
1356
1357	/*
1358	* Unregister callbacks.
1359	*/
1360	UNREGISTER_CALLBACK(GUEST_DND_FN_CONNECT);
1361	UNREGISTER_CALLBACK(GUEST_DND_FN_DISCONNECT);
1362	UNREGISTER_CALLBACK(GUEST_DND_FN_EVT_ERROR);
1363	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA_HDR);
1364	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA);
1365	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DIR);
1366	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_FILE_HDR);
1367	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_FILE_DATA);
1368
1369	#undef REGISTER_CALLBACK
1370	#undef UNREGISTER_CALLBACK
1371
1372	if (RT_FAILURE(rc))
1373	{
1374	int rc2 = DnDDroppedFilesRollback(pDF);
1375	if (RT_FAILURE(rc2))
1376	LogRel(("DnD: Deleting left over temporary files failed (%Rrc), please remove directory '%s' manually\n",
1377	rc2, DnDDroppedFilesGetDirAbs(pDF)));
1378
1379	if (rc == VERR_CANCELLED)
1380	{
1381	/*
1382	* Now that we've cleaned up tell the guest side to cancel.
1383	* This does not imply we're waiting for the guest to react, as the
1384	* host side never must depend on anything from the guest.
1385	*/
1386	rc2 = sendCancel();
1387	AssertRC(rc2);
1388
1389	rc2 = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
1390	AssertRC(rc2);
1391
1392	/* Cancelling is not an error, just set success here. */
1393	rc = VINF_SUCCESS;
1394	}
1395	else if (rc != VERR_DND_GUEST_ERROR) /* Guest-side error are already handled in the callback. */
1396	{
1397	rc2 = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR,
1398	rc, GuestDnDSource::i_hostErrorToString(rc));
1399	AssertRC(rc2);
1400	}
1401	}
1402
1403	DnDDroppedFilesClose(pDF);
1404
1405	LogFlowFuncLeaveRC(rc);
1406	return rc;
1407	}
1408
1409	/**
1410	* Static HGCM service callback which handles receiving raw data.
1411	*
1412	* @returns VBox status code. Will get sent back to the host service.
1413	* @param uMsg HGCM message ID (function number).
1414	* @param pvParms Pointer to additional message data. Optional and can be NULL.
1415	* @param cbParms Size (in bytes) additional message data. Optional and can be 0.
1416	* @param pvUser User-supplied pointer on callback registration.
1417	*/
1418	/* static */
1419	DECLCALLBACK(int) GuestDnDSource::i_receiveRawDataCallback(uint32_t uMsg, void pvParms, size_t cbParms, void pvUser)
1420	{
1421	GuestDnDRecvCtx pCtx = (GuestDnDRecvCtx )pvUser;
1422	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1423
1424	GuestDnDSource *pThis = pCtx->pSource;
1425	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1426
1427	LogFlowFunc(("pThis=%p, uMsg=%RU32\n", pThis, uMsg));
1428
1429	int rc = VINF_SUCCESS;
1430
1431	int rcCallback = VINF_SUCCESS; /* rc for the callback. */
1432	bool fNotify = false;
1433
1434	switch (uMsg)
1435	{
1436	case GUEST_DND_FN_CONNECT:
1437	/* Nothing to do here (yet). */
1438	break;
1439
1440	case GUEST_DND_FN_DISCONNECT:
1441	rc = VERR_CANCELLED;
1442	break;
1443
1444	#ifdef VBOX_WITH_DRAG_AND_DROP_GH
1445	case GUEST_DND_FN_GH_SND_DATA_HDR:
1446	{
1447	PVBOXDNDCBSNDDATAHDRDATA pCBData = reinterpret_cast<PVBOXDNDCBSNDDATAHDRDATA>(pvParms);
1448	AssertPtr(pCBData);
1449	AssertReturn(sizeof(VBOXDNDCBSNDDATAHDRDATA) == cbParms, VERR_INVALID_PARAMETER);
1450	AssertReturn(CB_MAGIC_DND_GH_SND_DATA_HDR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1451
1452	rc = pThis->i_onReceiveDataHdr(pCtx, &pCBData->data);
1453	break;
1454	}
1455	case GUEST_DND_FN_GH_SND_DATA:
1456	{
1457	PVBOXDNDCBSNDDATADATA pCBData = reinterpret_cast<PVBOXDNDCBSNDDATADATA>(pvParms);
1458	AssertPtr(pCBData);
1459	AssertReturn(sizeof(VBOXDNDCBSNDDATADATA) == cbParms, VERR_INVALID_PARAMETER);
1460	AssertReturn(CB_MAGIC_DND_GH_SND_DATA == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1461
1462	rc = pThis->i_onReceiveData(pCtx, &pCBData->data);
1463	break;
1464	}
1465	case GUEST_DND_FN_EVT_ERROR:
1466	{
1467	PVBOXDNDCBEVTERRORDATA pCBData = reinterpret_cast<PVBOXDNDCBEVTERRORDATA>(pvParms);
1468	AssertPtr(pCBData);
1469	AssertReturn(sizeof(VBOXDNDCBEVTERRORDATA) == cbParms, VERR_INVALID_PARAMETER);
1470	AssertReturn(CB_MAGIC_DND_EVT_ERROR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1471
1472	pCtx->pState->reset();
1473
1474	if (RT_SUCCESS(pCBData->rc))
1475	{
1476	AssertMsgFailed(("Received guest error with no error code set\n"));
1477	pCBData->rc = VERR_GENERAL_FAILURE; /* Make sure some error is set. */
1478	}
1479	else if (pCBData->rc == VERR_WRONG_ORDER)
1480	{
1481	rc = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
1482	}
1483	else
1484	rc = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR, pCBData->rc,
1485	GuestDnDSource::i_guestErrorToString(pCBData->rc));
1486
1487	LogRel3(("DnD: Guest reported data transfer error: %Rrc\n", pCBData->rc));
1488
1489	if (RT_SUCCESS(rc))
1490	rcCallback = VERR_DND_GUEST_ERROR;
1491	break;
1492	}
1493	#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1494	default:
1495	rc = VERR_NOT_SUPPORTED;
1496	break;
1497	}
1498
1499	if ( RT_FAILURE(rc)
1500	\|\| RT_FAILURE(rcCallback))
1501	{
1502	fNotify = true;
1503	if (RT_SUCCESS(rcCallback))
1504	rcCallback = rc;
1505	}
1506
1507	if (RT_FAILURE(rc))
1508	{
1509	switch (rc)
1510	{
1511	case VERR_NO_DATA:
1512	LogRel2(("DnD: Data transfer to host complete\n"));
1513	break;
1514
1515	case VERR_CANCELLED:
1516	LogRel2(("DnD: Data transfer to host canceled\n"));
1517	break;
1518
1519	default:
1520	LogRel(("DnD: Error %Rrc occurred, aborting data transfer to host\n", rc));
1521	break;
1522	}
1523
1524	/* Unregister this callback. */
1525	AssertPtr(pCtx->pState);
1526	int rc2 = pCtx->pState->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
1527	AssertRC(rc2);
1528	}
1529
1530	/* All data processed? */
1531	if (pCtx->isComplete())
1532	fNotify = true;
1533
1534	LogFlowFunc(("cbProcessed=%RU64, cbExtra=%RU64, fNotify=%RTbool, rcCallback=%Rrc, rc=%Rrc\n",
1535	pCtx->cbProcessed, pCtx->cbExtra, fNotify, rcCallback, rc));
1536
1537	if (fNotify)
1538	{
1539	int rc2 = pCtx->EventCallback.Notify(rcCallback);
1540	AssertRC(rc2);
1541	}
1542
1543	LogFlowFuncLeaveRC(rc);
1544	return rc; /* Tell the guest. */
1545	}
1546
1547	/**
1548	* Static HGCM service callback which handles receiving transfer data from the guest.
1549	*
1550	* @returns VBox status code. Will get sent back to the host service.
1551	* @param uMsg HGCM message ID (function number).
1552	* @param pvParms Pointer to additional message data. Optional and can be NULL.
1553	* @param cbParms Size (in bytes) additional message data. Optional and can be 0.
1554	* @param pvUser User-supplied pointer on callback registration.
1555	*/
1556	/* static */
1557	DECLCALLBACK(int) GuestDnDSource::i_receiveTransferDataCallback(uint32_t uMsg, void pvParms, size_t cbParms, void pvUser)
1558	{
1559	GuestDnDRecvCtx pCtx = (GuestDnDRecvCtx )pvUser;
1560	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1561
1562	GuestDnDSource *pThis = pCtx->pSource;
1563	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1564
1565	LogFlowFunc(("pThis=%p, uMsg=%RU32\n", pThis, uMsg));
1566
1567	int rc = VINF_SUCCESS;
1568
1569	int rcCallback = VINF_SUCCESS; /* rc for the callback. */
1570	bool fNotify = false;
1571
1572	switch (uMsg)
1573	{
1574	case GUEST_DND_FN_CONNECT:
1575	/* Nothing to do here (yet). */
1576	break;
1577
1578	case GUEST_DND_FN_DISCONNECT:
1579	rc = VERR_CANCELLED;
1580	break;
1581
1582	#ifdef VBOX_WITH_DRAG_AND_DROP_GH
1583	case GUEST_DND_FN_GH_SND_DATA_HDR:
1584	{
1585	PVBOXDNDCBSNDDATAHDRDATA pCBData = reinterpret_cast<PVBOXDNDCBSNDDATAHDRDATA>(pvParms);
1586	AssertPtr(pCBData);
1587	AssertReturn(sizeof(VBOXDNDCBSNDDATAHDRDATA) == cbParms, VERR_INVALID_PARAMETER);
1588	AssertReturn(CB_MAGIC_DND_GH_SND_DATA_HDR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1589
1590	rc = pThis->i_onReceiveDataHdr(pCtx, &pCBData->data);
1591	break;
1592	}
1593	case GUEST_DND_FN_GH_SND_DATA:
1594	{
1595	PVBOXDNDCBSNDDATADATA pCBData = reinterpret_cast<PVBOXDNDCBSNDDATADATA>(pvParms);
1596	AssertPtr(pCBData);
1597	AssertReturn(sizeof(VBOXDNDCBSNDDATADATA) == cbParms, VERR_INVALID_PARAMETER);
1598	AssertReturn(CB_MAGIC_DND_GH_SND_DATA == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1599
1600	rc = pThis->i_onReceiveData(pCtx, &pCBData->data);
1601	break;
1602	}
1603	case GUEST_DND_FN_GH_SND_DIR:
1604	{
1605	PVBOXDNDCBSNDDIRDATA pCBData = reinterpret_cast<PVBOXDNDCBSNDDIRDATA>(pvParms);
1606	AssertPtr(pCBData);
1607	AssertReturn(sizeof(VBOXDNDCBSNDDIRDATA) == cbParms, VERR_INVALID_PARAMETER);
1608	AssertReturn(CB_MAGIC_DND_GH_SND_DIR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1609
1610	rc = pThis->i_onReceiveDir(pCtx, pCBData->pszPath, pCBData->cbPath, pCBData->fMode);
1611	break;
1612	}
1613	case GUEST_DND_FN_GH_SND_FILE_HDR:
1614	{
1615	PVBOXDNDCBSNDFILEHDRDATA pCBData = reinterpret_cast<PVBOXDNDCBSNDFILEHDRDATA>(pvParms);
1616	AssertPtr(pCBData);
1617	AssertReturn(sizeof(VBOXDNDCBSNDFILEHDRDATA) == cbParms, VERR_INVALID_PARAMETER);
1618	AssertReturn(CB_MAGIC_DND_GH_SND_FILE_HDR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1619
1620	rc = pThis->i_onReceiveFileHdr(pCtx, pCBData->pszFilePath, pCBData->cbFilePath,
1621	pCBData->cbSize, pCBData->fMode, pCBData->fFlags);
1622	break;
1623	}
1624	case GUEST_DND_FN_GH_SND_FILE_DATA:
1625	{
1626	PVBOXDNDCBSNDFILEDATADATA pCBData = reinterpret_cast<PVBOXDNDCBSNDFILEDATADATA>(pvParms);
1627	AssertPtr(pCBData);
1628	AssertReturn(sizeof(VBOXDNDCBSNDFILEDATADATA) == cbParms, VERR_INVALID_PARAMETER);
1629	AssertReturn(CB_MAGIC_DND_GH_SND_FILE_DATA == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1630
1631	if (pThis->m_pState->m_uProtocolVersion <= 1)
1632	{
1633	/**
1634	* Notes for protocol v1 (< VBox 5.0):
1635	* - Every time this command is being sent it includes the file header,
1636	* so just process both calls here.
1637	* - There was no information whatsoever about the total file size; the old code only
1638	* appended data to the desired file. So just pass 0 as cbSize.
1639	*/
1640	rc = pThis->i_onReceiveFileHdr(pCtx, pCBData->u.v1.pszFilePath, pCBData->u.v1.cbFilePath,
1641	0 /* cbSize /, pCBData->u.v1.fMode, 0 / fFlags */);
1642	if (RT_SUCCESS(rc))
1643	rc = pThis->i_onReceiveFileData(pCtx, pCBData->pvData, pCBData->cbData);
1644	}
1645	else /* Protocol v2 and up. */
1646	rc = pThis->i_onReceiveFileData(pCtx, pCBData->pvData, pCBData->cbData);
1647	break;
1648	}
1649	case GUEST_DND_FN_EVT_ERROR:
1650	{
1651	PVBOXDNDCBEVTERRORDATA pCBData = reinterpret_cast<PVBOXDNDCBEVTERRORDATA>(pvParms);
1652	AssertPtr(pCBData);
1653	AssertReturn(sizeof(VBOXDNDCBEVTERRORDATA) == cbParms, VERR_INVALID_PARAMETER);
1654	AssertReturn(CB_MAGIC_DND_EVT_ERROR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1655
1656	pCtx->pState->reset();
1657
1658	if (RT_SUCCESS(pCBData->rc))
1659	{
1660	AssertMsgFailed(("Received guest error with no error code set\n"));
1661	pCBData->rc = VERR_GENERAL_FAILURE; /* Make sure some error is set. */
1662	}
1663	else if (pCBData->rc == VERR_WRONG_ORDER)
1664	{
1665	rc = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
1666	}
1667	else
1668	rc = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR, pCBData->rc,
1669	GuestDnDSource::i_guestErrorToString(pCBData->rc));
1670
1671	LogRel3(("DnD: Guest reported file transfer error: %Rrc\n", pCBData->rc));
1672
1673	if (RT_SUCCESS(rc))
1674	rcCallback = VERR_DND_GUEST_ERROR;
1675	break;
1676	}
1677	#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1678	default:
1679	rc = VERR_NOT_SUPPORTED;
1680	break;
1681	}
1682
1683	if ( RT_FAILURE(rc)
1684	\|\| RT_FAILURE(rcCallback))
1685	{
1686	fNotify = true;
1687	if (RT_SUCCESS(rcCallback))
1688	rcCallback = rc;
1689	}
1690
1691	if (RT_FAILURE(rc))
1692	{
1693	switch (rc)
1694	{
1695	case VERR_NO_DATA:
1696	LogRel2(("DnD: File transfer to host complete\n"));
1697	break;
1698
1699	case VERR_CANCELLED:
1700	LogRel2(("DnD: File transfer to host canceled\n"));
1701	break;
1702
1703	default:
1704	LogRel(("DnD: Error %Rrc occurred, aborting file transfer to host\n", rc));
1705	break;
1706	}
1707
1708	/* Unregister this callback. */
1709	AssertPtr(pCtx->pState);
1710	int rc2 = pCtx->pState->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
1711	AssertRC(rc2);
1712	}
1713
1714	/* All data processed? */
1715	if ( pCtx->Transfer.isComplete()
1716	&& pCtx->isComplete())
1717	{
1718	fNotify = true;
1719	}
1720
1721	LogFlowFunc(("cbProcessed=%RU64, cbExtra=%RU64, fNotify=%RTbool, rcCallback=%Rrc, rc=%Rrc\n",
1722	pCtx->cbProcessed, pCtx->cbExtra, fNotify, rcCallback, rc));
1723
1724	if (fNotify)
1725	{
1726	int rc2 = pCtx->EventCallback.Notify(rcCallback);
1727	AssertRC(rc2);
1728	}
1729
1730	LogFlowFuncLeaveRC(rc);
1731	return rc; /* Tell the guest. */
1732	}
1733

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/src-client/GuestDnDSourceImpl.cpp@ 98262

Download in other formats: