GuestDnDSourceImpl.cpp@ 98278

Last change on this file since 98278 was 98273, checked in by vboxsync, 22 months ago
Main/GuestDnD*: rc -> hrc/vrc. bugref:10223
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 60.0 KB

Line
1	/* $Id: GuestDnDSourceImpl.cpp 98273 2023-01-24 11:17:31Z 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(("hrc=%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 hrc = pState->resetProgress(m_pGuest, tr("Dropping data to host"));
440	if (FAILED(hrc))
441	return hrc;
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 hrc = 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	hrc = 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	hrc = E_OUTOFMEMORY;
474	}
475	catch (...)
476	{
477	LogRel2(("DnD: Could not create thread for data receiving task\n"));
478	hrc = E_FAIL;
479	}
480
481	if (SUCCEEDED(hrc))
482	{
483	/* Register ourselves at the DnD manager. */
484	GuestDnDInst()->registerSource(this);
485
486	hrc = pState->queryProgressTo(aProgress.asOutParam());
487	ComAssertComRC(hrc);
488	}
489	else
490	hrc = i_setErrorAndReset(tr("Starting thread for GuestDnDSource failed (%Rhrc)"), hrc);
491
492	LogFlowFunc(("Returning hrc=%Rhrc\n", hrc));
493	return hrc;
494	#endif /* VBOX_WITH_DRAG_AND_DROP */
495	}
496
497	HRESULT GuestDnDSource::receiveData(std::vector<BYTE> &aData)
498	{
499	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
500	ReturnComNotImplemented();
501	#else /* VBOX_WITH_DRAG_AND_DROP */
502
503	AutoCaller autoCaller(this);
504	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
505
506	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
507
508	/* Don't allow receiving the actual data until our current transfer is complete. */
509	if (m_fIsPending)
510	return setError(E_FAIL, tr("Current drop operation to host still in progress"));
511
512	HRESULT hrc = S_OK;
513
514	try
515	{
516	GuestDnDRecvCtx *pCtx = &mData.mRecvCtx;
517	if (DnDMIMENeedsDropDir(pCtx->strFmtRecv.c_str(), pCtx->strFmtRecv.length()))
518	{
519	PDNDDROPPEDFILES pDF = &pCtx->Transfer.DroppedFiles;
520
521	const char *pcszDropDirAbs = DnDDroppedFilesGetDirAbs(pDF);
522	AssertPtr(pcszDropDirAbs);
523
524	LogRel2(("DnD: Using drop directory '%s', got %RU64 root entries\n",
525	pcszDropDirAbs, DnDTransferListGetRootCount(&pCtx->Transfer.List)));
526
527	/* We return the data as "text/uri-list" MIME data here. */
528	char *pszBuf = NULL;
529	size_t cbBuf = 0;
530	int vrc = DnDTransferListGetRootsEx(&pCtx->Transfer.List, DNDTRANSFERLISTFMT_URI,
531	pcszDropDirAbs, DND_PATH_SEPARATOR_STR, &pszBuf, &cbBuf);
532	if (RT_SUCCESS(vrc))
533	{
534	Assert(cbBuf);
535	AssertPtr(pszBuf);
536
537	aData.resize(cbBuf);
538	memcpy(&aData.front(), pszBuf, cbBuf);
539	RTStrFree(pszBuf);
540	}
541	else
542	LogRel(("DnD: Unable to build source root list, vrc=%Rrc\n", vrc));
543	}
544	else /* Raw data. */
545	{
546	if (pCtx->Meta.cbData)
547	{
548	/* Copy the data into a safe array of bytes. */
549	aData.resize(pCtx->Meta.cbData);
550	memcpy(&aData.front(), pCtx->Meta.pvData, pCtx->Meta.cbData);
551	}
552	else
553	aData.resize(0);
554	}
555	}
556	catch (std::bad_alloc &)
557	{
558	hrc = E_OUTOFMEMORY;
559	}
560
561	LogFlowFunc(("Returning hrc=%Rhrc\n", hrc));
562	return hrc;
563	#endif /* VBOX_WITH_DRAG_AND_DROP */
564	}
565
566	// implementation of internal methods.
567	/////////////////////////////////////////////////////////////////////////////
568
569	/**
570	* Returns an error string from a guest DnD error.
571	*
572	* @returns Error string.
573	* @param guestRc Guest error to return error string for.
574	*/
575	/* static */
576	Utf8Str GuestDnDSource::i_guestErrorToString(int guestRc)
577	{
578	Utf8Str strError;
579
580	switch (guestRc)
581	{
582	case VERR_ACCESS_DENIED:
583	strError += Utf8StrFmt(tr("For one or more guest files or directories selected for transferring to the host your guest "
584	"user does not have the appropriate access rights for. Please make sure that all selected "
585	"elements can be accessed and that your guest user has the appropriate rights"));
586	break;
587
588	case VERR_NOT_FOUND:
589	/* Should not happen due to file locking on the guest, but anyway ... */
590	strError += Utf8StrFmt(tr("One or more guest files or directories selected for transferring to the host were not"
591	"found on the guest anymore. This can be the case if the guest files were moved and/or"
592	"altered while the drag and drop operation was in progress"));
593	break;
594
595	case VERR_SHARING_VIOLATION:
596	strError += Utf8StrFmt(tr("One or more guest files or directories selected for transferring to the host were locked. "
597	"Please make sure that all selected elements can be accessed and that your guest user has "
598	"the appropriate rights"));
599	break;
600
601	case VERR_TIMEOUT:
602	strError += Utf8StrFmt(tr("The guest was not able to retrieve the drag and drop data within time"));
603	break;
604
605	default:
606	strError += Utf8StrFmt(tr("Drag and drop error from guest (%Rrc)"), guestRc);
607	break;
608	}
609
610	return strError;
611	}
612
613	/**
614	* Returns an error string from a host DnD error.
615	*
616	* @returns Error string.
617	* @param hostRc Host error to return error string for.
618	*/
619	/* static */
620	Utf8Str GuestDnDSource::i_hostErrorToString(int hostRc)
621	{
622	Utf8Str strError;
623
624	switch (hostRc)
625	{
626	case VERR_ACCESS_DENIED:
627	strError += Utf8StrFmt(tr("For one or more host files or directories selected for transferring to the guest your host "
628	"user does not have the appropriate access rights for. Please make sure that all selected "
629	"elements can be accessed and that your host user has the appropriate rights."));
630	break;
631
632	case VERR_DISK_FULL:
633	strError += Utf8StrFmt(tr("Host disk ran out of space (disk is full)."));
634	break;
635
636	case VERR_NOT_FOUND:
637	/* Should not happen due to file locking on the host, but anyway ... */
638	strError += Utf8StrFmt(tr("One or more host files or directories selected for transferring to the host were not"
639	"found on the host anymore. This can be the case if the host files were moved and/or"
640	"altered while the drag and drop operation was in progress."));
641	break;
642
643	case VERR_SHARING_VIOLATION:
644	strError += Utf8StrFmt(tr("One or more host files or directories selected for transferring to the guest were locked. "
645	"Please make sure that all selected elements can be accessed and that your host user has "
646	"the appropriate rights."));
647	break;
648
649	default:
650	strError += Utf8StrFmt(tr("Drag and drop error from host (%Rrc)"), hostRc);
651	break;
652	}
653
654	return strError;
655	}
656
657	/**
658	* Resets all internal data and state.
659	*/
660	void GuestDnDSource::i_reset(void)
661	{
662	LogRel2(("DnD: Source reset\n"));
663
664	mData.mRecvCtx.reset();
665
666	m_fIsPending = false;
667
668	/* Unregister ourselves from the DnD manager. */
669	GuestDnDInst()->unregisterSource(this);
670	}
671
672	#ifdef VBOX_WITH_DRAG_AND_DROP_GH
673
674	/**
675	* Handles receiving a send data header from the guest.
676	*
677	* @returns VBox status code.
678	* @param pCtx Receive context to use.
679	* @param pDataHdr Pointer to send data header from the guest.
680	*/
681	int GuestDnDSource::i_onReceiveDataHdr(GuestDnDRecvCtx *pCtx, PVBOXDNDSNDDATAHDR pDataHdr)
682	{
683	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
684	AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
685
686	LogRel2(("DnD: Receiving %RU64 bytes total data (%RU32 bytes meta data, %RU64 objects) from guest ...\n",
687	pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects));
688
689	AssertReturn(pDataHdr->cbTotal >= pDataHdr->cbMeta, VERR_INVALID_PARAMETER);
690
691	pCtx->Meta.cbAnnounced = pDataHdr->cbMeta;
692	pCtx->cbExtra = pDataHdr->cbTotal - pDataHdr->cbMeta;
693
694	Assert(pCtx->Transfer.cObjToProcess == 0); /* Sanity. */
695	Assert(pCtx->Transfer.cObjProcessed == 0);
696
697	pCtx->Transfer.reset();
698
699	pCtx->Transfer.cObjToProcess = pDataHdr->cObjects;
700
701	/** @todo Handle compression type. */
702	/** @todo Handle checksum type. */
703
704	LogFlowFuncLeave();
705	return VINF_SUCCESS;
706	}
707
708	/**
709	* Main function for receiving data from the guest.
710	*
711	* @returns VBox status code.
712	* @param pCtx Receive context to use.
713	* @param pSndData Pointer to send data block from the guest.
714	*/
715	int GuestDnDSource::i_onReceiveData(GuestDnDRecvCtx *pCtx, PVBOXDNDSNDDATA pSndData)
716	{
717	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
718	AssertPtrReturn(pSndData, VERR_INVALID_POINTER);
719
720	int vrc = VINF_SUCCESS;
721
722	try
723	{
724	GuestDnDTransferRecvData *pTransfer = &pCtx->Transfer;
725
726	size_t cbData;
727	void *pvData;
728	size_t cbTotalAnnounced;
729	size_t cbMetaAnnounced;
730
731	if (m_pState->m_uProtocolVersion < 3)
732	{
733	cbData = pSndData->u.v1.cbData;
734	pvData = pSndData->u.v1.pvData;
735
736	/* Sends the total data size to receive for every data chunk. */
737	cbTotalAnnounced = pSndData->u.v1.cbTotalSize;
738
739	/* Meta data size always is cbData, meaning there cannot be an
740	* extended data chunk transfer by sending further data. */
741	cbMetaAnnounced = cbData;
742	}
743	else
744	{
745	cbData = pSndData->u.v3.cbData;
746	pvData = pSndData->u.v3.pvData;
747
748	/* Note: Data sizes get initialized in i_onReceiveDataHdr().
749	* So just use the set values here. */
750	cbTotalAnnounced = pCtx->getTotalAnnounced();
751	cbMetaAnnounced = pCtx->Meta.cbAnnounced;
752	}
753
754	if (cbData > cbTotalAnnounced)
755	{
756	AssertMsgFailed(("Incoming data size invalid: cbData=%zu, cbTotal=%zu\n", cbData, cbTotalAnnounced));
757	vrc = VERR_INVALID_PARAMETER;
758	}
759	else if ( cbTotalAnnounced == 0
760	\|\| cbTotalAnnounced < cbMetaAnnounced)
761	{
762	AssertMsgFailed(("cbTotal (%zu) is smaller than cbMeta (%zu)\n", cbTotalAnnounced, cbMetaAnnounced));
763	vrc = VERR_INVALID_PARAMETER;
764	}
765
766	if (RT_FAILURE(vrc))
767	return vrc;
768
769	AssertReturn(cbData <= mData.mcbBlockSize, VERR_BUFFER_OVERFLOW);
770
771	const size_t cbMetaRecv = pCtx->Meta.add(pvData, cbData);
772	AssertReturn(cbMetaRecv <= pCtx->Meta.cbData, VERR_BUFFER_OVERFLOW);
773
774	LogFlowThisFunc(("cbData=%zu, cbMetaRecv=%zu, cbMetaAnnounced=%zu, cbTotalAnnounced=%zu\n",
775	cbData, cbMetaRecv, cbMetaAnnounced, cbTotalAnnounced));
776
777	LogRel2(("DnD: %RU8%% of meta data complete (%zu/%zu bytes)\n",
778	(uint8_t)(cbMetaRecv * 100 / RT_MAX(cbMetaAnnounced, 1)), cbMetaRecv, cbMetaAnnounced));
779
780	/*
781	* (Meta) Data transfer complete?
782	*/
783	if (cbMetaAnnounced == cbMetaRecv)
784	{
785	LogRel2(("DnD: Receiving meta data complete\n"));
786
787	if (DnDMIMENeedsDropDir(pCtx->strFmtRecv.c_str(), pCtx->strFmtRecv.length()))
788	{
789	vrc = DnDTransferListInitEx(&pTransfer->List,
790	DnDDroppedFilesGetDirAbs(&pTransfer->DroppedFiles), DNDTRANSFERLISTFMT_NATIVE);
791	if (RT_SUCCESS(vrc))
792	vrc = DnDTransferListAppendRootsFromBuffer(&pTransfer->List, DNDTRANSFERLISTFMT_URI,
793	(const char *)pCtx->Meta.pvData, pCtx->Meta.cbData,
794	DND_PATH_SEPARATOR_STR, DNDTRANSFERLIST_FLAGS_NONE);
795	/* Validation. */
796	if (RT_SUCCESS(vrc))
797	{
798	uint64_t cRoots = DnDTransferListGetRootCount(&pTransfer->List);
799
800	LogRel2(("DnD: Received %RU64 root entries from guest\n", cRoots));
801
802	if ( cRoots == 0
803	\|\| cRoots > pTransfer->cObjToProcess)
804	{
805	LogRel(("DnD: Number of root entries invalid / mismatch: Got %RU64, expected %RU64\n",
806	cRoots, pTransfer->cObjToProcess));
807	vrc = VERR_INVALID_PARAMETER;
808	}
809	}
810
811	if (RT_SUCCESS(vrc))
812	{
813	/* Update our process with the data we already received. */
814	vrc = updateProgress(pCtx, pCtx->pState, cbMetaAnnounced);
815	AssertRC(vrc);
816	}
817
818	if (RT_FAILURE(vrc))
819	LogRel(("DnD: Error building root entry list, vrc=%Rrc\n", vrc));
820	}
821	else /* Raw data. */
822	{
823	vrc = updateProgress(pCtx, pCtx->pState, cbData);
824	AssertRC(vrc);
825	}
826
827	if (RT_FAILURE(vrc))
828	LogRel(("DnD: Error receiving meta data, vrc=%Rrc\n", vrc));
829	}
830	}
831	catch (std::bad_alloc &)
832	{
833	vrc = VERR_NO_MEMORY;
834	}
835
836	LogFlowFuncLeaveRC(vrc);
837	return vrc;
838	}
839
840
841	int GuestDnDSource::i_onReceiveDir(GuestDnDRecvCtx pCtx, const char pszPath, uint32_t cbPath, uint32_t fMode)
842	{
843	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
844	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
845	AssertReturn(cbPath, VERR_INVALID_PARAMETER);
846
847	LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x\n", pszPath, cbPath, fMode));
848
849	const PDNDTRANSFEROBJECT pObj = &pCtx->Transfer.ObjCur;
850	const PDNDDROPPEDFILES pDF = &pCtx->Transfer.DroppedFiles;
851
852	int vrc = DnDTransferObjectInitEx(pObj, DNDTRANSFEROBJTYPE_DIRECTORY, DnDDroppedFilesGetDirAbs(pDF), pszPath);
853	if (RT_SUCCESS(vrc))
854	{
855	const char *pcszPathAbs = DnDTransferObjectGetSourcePath(pObj);
856	AssertPtr(pcszPathAbs);
857
858	vrc = RTDirCreateFullPath(pcszPathAbs, fMode);
859	if (RT_SUCCESS(vrc))
860	{
861	pCtx->Transfer.cObjProcessed++;
862	if (pCtx->Transfer.cObjProcessed <= pCtx->Transfer.cObjToProcess)
863	vrc = DnDDroppedFilesAddDir(pDF, pcszPathAbs);
864	else
865	vrc = VERR_TOO_MUCH_DATA;
866
867	DnDTransferObjectDestroy(pObj);
868
869	if (RT_FAILURE(vrc))
870	LogRel2(("DnD: Created guest directory '%s' on host\n", pcszPathAbs));
871	}
872	else
873	LogRel(("DnD: Error creating guest directory '%s' on host, vrc=%Rrc\n", pcszPathAbs, vrc));
874	}
875
876	if (RT_FAILURE(vrc))
877	LogRel(("DnD: Receiving guest directory '%s' failed with vrc=%Rrc\n", pszPath, vrc));
878
879	LogFlowFuncLeaveRC(vrc);
880	return vrc;
881	}
882
883	/**
884	* Receives a file header from the guest.
885	*
886	* @returns VBox status code.
887	* @param pCtx Receive context to use.
888	* @param pszPath File path of file to use.
889	* @param cbPath Size (in bytes, including terminator) of file path.
890	* @param cbSize File size (in bytes) to receive.
891	* @param fMode File mode to use.
892	* @param fFlags Additional receive flags; not used yet.
893	*/
894	int GuestDnDSource::i_onReceiveFileHdr(GuestDnDRecvCtx pCtx, const char pszPath, uint32_t cbPath,
895	uint64_t cbSize, uint32_t fMode, uint32_t fFlags)
896	{
897	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
898	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
899	AssertReturn(cbPath, VERR_INVALID_PARAMETER);
900	AssertReturn(fMode, VERR_INVALID_PARAMETER);
901	/* fFlags are optional. */
902
903	RT_NOREF(fFlags);
904
905	LogFlowFunc(("pszPath=%s, cbPath=%RU32, cbSize=%RU64, fMode=0x%x, fFlags=0x%x\n", pszPath, cbPath, cbSize, fMode, fFlags));
906
907	AssertMsgReturn(cbSize <= pCtx->cbExtra,
908	("File size (%RU64) exceeds extra size to transfer (%RU64)\n", cbSize, pCtx->cbExtra), VERR_INVALID_PARAMETER);
909	AssertMsgReturn( pCtx->isComplete() == false
910	&& pCtx->Transfer.cObjToProcess,
911	("Data transfer already complete, bailing out\n"), VERR_INVALID_PARAMETER);
912
913	int vrc = VINF_SUCCESS;
914
915	do
916	{
917	const PDNDTRANSFEROBJECT pObj = &pCtx->Transfer.ObjCur;
918
919	if ( DnDTransferObjectIsOpen(pObj)
920	&& !DnDTransferObjectIsComplete(pObj))
921	{
922	AssertMsgFailed(("Object '%s' not complete yet\n", DnDTransferObjectGetSourcePath(pObj)));
923	vrc = VERR_WRONG_ORDER;
924	break;
925	}
926
927	const PDNDDROPPEDFILES pDF = &pCtx->Transfer.DroppedFiles;
928
929	vrc = DnDTransferObjectInitEx(pObj, DNDTRANSFEROBJTYPE_FILE, DnDDroppedFilesGetDirAbs(pDF), pszPath);
930	AssertRCBreak(vrc);
931
932	const char *pcszSource = DnDTransferObjectGetSourcePath(pObj);
933	AssertPtrBreakStmt(pcszSource, VERR_INVALID_POINTER);
934
935	/** @todo Add sparse file support based on fFlags? (Use Open(..., fFlags \| SPARSE). */
936	vrc = DnDTransferObjectOpen(pObj, RTFILE_O_CREATE_REPLACE \| RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE,
937	(fMode & RTFS_UNIX_MASK) \| RTFS_UNIX_IRUSR \| RTFS_UNIX_IWUSR, DNDTRANSFEROBJECT_FLAGS_NONE);
938	if (RT_FAILURE(vrc))
939	{
940	LogRel(("DnD: Error opening/creating guest file '%s' on host, vrc=%Rrc\n", pcszSource, vrc));
941	break;
942	}
943
944	/* Note: Protocol v1 does not send any file sizes, so always 0. */
945	if (m_pState->m_uProtocolVersion >= 2)
946	vrc = DnDTransferObjectSetSize(pObj, cbSize);
947
948	/** @todo Unescape path before printing. */
949	LogRel2(("DnD: Transferring guest file '%s' to host (%RU64 bytes, mode %#x)\n",
950	pcszSource, DnDTransferObjectGetSize(pObj), DnDTransferObjectGetMode(pObj)));
951
952	/** @todo Set progress object title to current file being transferred? */
953
954	if (DnDTransferObjectIsComplete(pObj)) /* 0-byte file? We're done already. */
955	{
956	LogRel2(("DnD: Transferring guest file '%s' (0 bytes) to host complete\n", pcszSource));
957
958	pCtx->Transfer.cObjProcessed++;
959	if (pCtx->Transfer.cObjProcessed <= pCtx->Transfer.cObjToProcess)
960	{
961	/* Add for having a proper rollback. */
962	vrc = DnDDroppedFilesAddFile(pDF, pcszSource);
963	}
964	else
965	vrc = VERR_TOO_MUCH_DATA;
966
967	DnDTransferObjectDestroy(pObj);
968	}
969
970	} while (0);
971
972	if (RT_FAILURE(vrc))
973	LogRel(("DnD: Error receiving guest file header, vrc=%Rrc\n", vrc));
974
975	LogFlowFuncLeaveRC(vrc);
976	return vrc;
977	}
978
979	/**
980	* Receives file data from the guest.
981	*
982	* @returns VBox status code.
983	* @param pCtx Receive context to use.
984	* @param pvData Pointer to file data received from the guest.
985	* @param pCtx Size (in bytes) of file data received from the guest.
986	*/
987	int GuestDnDSource::i_onReceiveFileData(GuestDnDRecvCtx pCtx, const void pvData, uint32_t cbData)
988	{
989	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
990	AssertPtrReturn(pvData, VERR_INVALID_POINTER);
991	AssertReturn(cbData, VERR_INVALID_PARAMETER);
992
993	int vrc = VINF_SUCCESS;
994
995	LogFlowFunc(("pvData=%p, cbData=%RU32, cbBlockSize=%RU32\n", pvData, cbData, mData.mcbBlockSize));
996
997	/*
998	* Sanity checking.
999	*/
1000	if (cbData > mData.mcbBlockSize)
1001	return VERR_INVALID_PARAMETER;
1002
1003	do
1004	{
1005	const PDNDTRANSFEROBJECT pObj = &pCtx->Transfer.ObjCur;
1006
1007	const char *pcszSource = DnDTransferObjectGetSourcePath(pObj);
1008	AssertPtrBreakStmt(pcszSource, VERR_INVALID_POINTER);
1009
1010	AssertMsgReturn(DnDTransferObjectIsOpen(pObj),
1011	("Object '%s' not open (anymore)\n", pcszSource), VERR_WRONG_ORDER);
1012	AssertMsgReturn(DnDTransferObjectIsComplete(pObj) == false,
1013	("Object '%s' already marked as complete\n", pcszSource), VERR_WRONG_ORDER);
1014
1015	uint32_t cbWritten;
1016	vrc = DnDTransferObjectWrite(pObj, pvData, cbData, &cbWritten);
1017	if (RT_FAILURE(vrc))
1018	LogRel(("DnD: Error writing guest file data for '%s', vrc=%Rrc\n", pcszSource, vrc));
1019
1020	Assert(cbWritten <= cbData);
1021	if (cbWritten < cbData)
1022	{
1023	LogRel(("DnD: Only written %RU32 of %RU32 bytes of guest file '%s' -- disk full?\n",
1024	cbWritten, cbData, pcszSource));
1025	vrc = VERR_IO_GEN_FAILURE; /** @todo Find a better vrc. */
1026	break;
1027	}
1028
1029	vrc = updateProgress(pCtx, pCtx->pState, cbWritten);
1030	AssertRCBreak(vrc);
1031
1032	if (DnDTransferObjectIsComplete(pObj))
1033	{
1034	LogRel2(("DnD: Transferring guest file '%s' to host complete\n", pcszSource));
1035
1036	pCtx->Transfer.cObjProcessed++;
1037	if (pCtx->Transfer.cObjProcessed > pCtx->Transfer.cObjToProcess)
1038	vrc = VERR_TOO_MUCH_DATA;
1039
1040	DnDTransferObjectDestroy(pObj);
1041	}
1042
1043	} while (0);
1044
1045	if (RT_FAILURE(vrc))
1046	LogRel(("DnD: Error receiving guest file data, vrc=%Rrc\n", vrc));
1047
1048	LogFlowFuncLeaveRC(vrc);
1049	return vrc;
1050	}
1051	#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1052
1053	/**
1054	* Main function to receive DnD data from the guest.
1055	*
1056	* @returns VBox status code.
1057	* @param pCtx Receive context to use.
1058	* @param msTimeout Timeout (in ms) to wait for receiving data.
1059	*/
1060	int GuestDnDSource::i_receiveData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout)
1061	{
1062	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1063
1064	/* Sanity. */
1065	AssertMsgReturn(pCtx->enmAction,
1066	("Action to perform is none when it shouldn't\n"), VERR_INVALID_PARAMETER);
1067	AssertMsgReturn(pCtx->strFmtReq.isNotEmpty(),
1068	("Requested format from host is empty when it shouldn't\n"), VERR_INVALID_PARAMETER);
1069
1070	/*
1071	* Do we need to receive a different format than initially requested?
1072	*
1073	* For example, receiving a file link as "text/plain" requires still to receive
1074	* the file from the guest as "text/uri-list" first, then pointing to
1075	* the file path on the host in the "text/plain" data returned.
1076	*/
1077
1078	bool fFoundFormat = true; /* Whether we've found a common format between host + guest. */
1079
1080	LogFlowFunc(("strFmtReq=%s, strFmtRecv=%s, enmAction=0x%x\n",
1081	pCtx->strFmtReq.c_str(), pCtx->strFmtRecv.c_str(), pCtx->enmAction));
1082
1083	/* Plain text wanted? */
1084	if ( pCtx->strFmtReq.equalsIgnoreCase("text/plain")
1085	\|\| pCtx->strFmtReq.equalsIgnoreCase("text/plain;charset=utf-8"))
1086	{
1087	/* Did the guest offer a file? Receive a file instead. */
1088	if (GuestDnD::isFormatInFormatList("text/uri-list", pCtx->lstFmtOffered))
1089	pCtx->strFmtRecv = "text/uri-list";
1090	/* Guest only offers (plain) text. */
1091	else
1092	pCtx->strFmtRecv = "text/plain;charset=utf-8";
1093
1094	/** @todo Add more conversions here. */
1095	}
1096	/* File(s) wanted? */
1097	else if (pCtx->strFmtReq.equalsIgnoreCase("text/uri-list"))
1098	{
1099	/* Does the guest support sending files? */
1100	if (GuestDnD::isFormatInFormatList("text/uri-list", pCtx->lstFmtOffered))
1101	pCtx->strFmtRecv = "text/uri-list";
1102	else /* Bail out. */
1103	fFoundFormat = false;
1104	}
1105
1106	int vrc = VINF_SUCCESS;
1107
1108	if (fFoundFormat)
1109	{
1110	if (!pCtx->strFmtRecv.equals(pCtx->strFmtReq))
1111	LogRel2(("DnD: Requested data in format '%s', receiving in intermediate format '%s' now\n",
1112	pCtx->strFmtReq.c_str(), pCtx->strFmtRecv.c_str()));
1113
1114	/*
1115	* Call the appropriate receive handler based on the data format to handle.
1116	*/
1117	bool fURIData = DnDMIMENeedsDropDir(pCtx->strFmtRecv.c_str(), pCtx->strFmtRecv.length());
1118	if (fURIData)
1119	vrc = i_receiveTransferData(pCtx, msTimeout);
1120	else
1121	vrc = i_receiveRawData(pCtx, msTimeout);
1122	}
1123	else /* Just inform the user (if verbose release logging is enabled). */
1124	{
1125	LogRel(("DnD: The guest does not support format '%s':\n", pCtx->strFmtReq.c_str()));
1126	LogRel(("DnD: Guest offered the following formats:\n"));
1127	for (size_t i = 0; i < pCtx->lstFmtOffered.size(); i++)
1128	LogRel(("DnD:\tFormat #%zu: %s\n", i, pCtx->lstFmtOffered.at(i).c_str()));
1129
1130	vrc = VERR_NOT_SUPPORTED;
1131	}
1132
1133	if (RT_FAILURE(vrc))
1134	{
1135	LogRel(("DnD: Receiving data from guest failed with %Rrc\n", vrc));
1136
1137	/* Let the guest side know first. */
1138	sendCancel();
1139
1140	/* Reset state. */
1141	i_reset();
1142	}
1143
1144	LogFlowFuncLeaveRC(vrc);
1145	return vrc;
1146	}
1147
1148	/**
1149	* Receives raw (meta) data from the guest.
1150	*
1151	* @returns VBox status code.
1152	* @param pCtx Receive context to use.
1153	* @param msTimeout Timeout (in ms) to wait for receiving data.
1154	*/
1155	int GuestDnDSource::i_receiveRawData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout)
1156	{
1157	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1158
1159	int vrc;
1160
1161	LogFlowFuncEnter();
1162
1163	GuestDnDState *pState = pCtx->pState;
1164	AssertPtr(pCtx->pState);
1165
1166	GuestDnD *pInst = GuestDnDInst();
1167	if (!pInst)
1168	return VERR_INVALID_POINTER;
1169
1170	#define REGISTER_CALLBACK(x) do { \
1171	vrc = pState->setCallback(x, i_receiveRawDataCallback, pCtx); \
1172	if (RT_FAILURE(vrc)) \
1173	return vrc; \
1174	} while (0)
1175
1176	#define UNREGISTER_CALLBACK(x) do { \
1177	int vrc2 = pState->setCallback(x, NULL); \
1178	AssertRC(vrc2); \
1179	} while (0)
1180
1181	/*
1182	* Register callbacks.
1183	*/
1184	REGISTER_CALLBACK(GUEST_DND_FN_CONNECT);
1185	REGISTER_CALLBACK(GUEST_DND_FN_DISCONNECT);
1186	REGISTER_CALLBACK(GUEST_DND_FN_EVT_ERROR);
1187	if (m_pState->m_uProtocolVersion >= 3)
1188	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA_HDR);
1189	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA);
1190
1191	do
1192	{
1193	/*
1194	* Receive the raw data.
1195	*/
1196	GuestDnDMsg Msg;
1197	Msg.setType(HOST_DND_FN_GH_EVT_DROPPED);
1198	if (m_pState->m_uProtocolVersion >= 3)
1199	Msg.appendUInt32(0); /** @todo ContextID not used yet. */
1200	Msg.appendPointer((void*)pCtx->strFmtRecv.c_str(), (uint32_t)pCtx->strFmtRecv.length() + 1);
1201	Msg.appendUInt32((uint32_t)pCtx->strFmtRecv.length() + 1);
1202	Msg.appendUInt32(pCtx->enmAction);
1203
1204	/* Make the initial call to the guest by telling that we initiated the "dropped" event on
1205	* the host and therefore now waiting for the actual raw data. */
1206	vrc = pInst->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
1207	if (RT_SUCCESS(vrc))
1208	{
1209	vrc = waitForEvent(&pCtx->EventCallback, pCtx->pState, msTimeout);
1210	if (RT_SUCCESS(vrc))
1211	vrc = pCtx->pState->setProgress(100, DND_PROGRESS_COMPLETE, VINF_SUCCESS);
1212	}
1213
1214	} while (0);
1215
1216	/*
1217	* Unregister callbacks.
1218	*/
1219	UNREGISTER_CALLBACK(GUEST_DND_FN_CONNECT);
1220	UNREGISTER_CALLBACK(GUEST_DND_FN_DISCONNECT);
1221	UNREGISTER_CALLBACK(GUEST_DND_FN_EVT_ERROR);
1222	if (m_pState->m_uProtocolVersion >= 3)
1223	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA_HDR);
1224	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA);
1225
1226	#undef REGISTER_CALLBACK
1227	#undef UNREGISTER_CALLBACK
1228
1229	if (RT_FAILURE(vrc))
1230	{
1231	if (vrc == VERR_CANCELLED) /* Transfer was cancelled by the host. */
1232	{
1233	/*
1234	* Now that we've cleaned up tell the guest side to cancel.
1235	* This does not imply we're waiting for the guest to react, as the
1236	* host side never must depend on anything from the guest.
1237	*/
1238	int vrc2 = sendCancel();
1239	AssertRC(vrc2);
1240
1241	vrc2 = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
1242	AssertRC(vrc2);
1243	}
1244	else if (vrc != VERR_DND_GUEST_ERROR) /* Guest-side error are already handled in the callback. */
1245	{
1246	int vrc2 = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR,
1247	vrc, GuestDnDSource::i_hostErrorToString(vrc));
1248	AssertRC(vrc2);
1249	}
1250
1251	vrc = VINF_SUCCESS; /* The error was handled by the setProgress() calls above. */
1252	}
1253
1254	LogFlowFuncLeaveRC(vrc);
1255	return vrc;
1256	}
1257
1258	/**
1259	* Receives transfer data (files / directories / ...) from the guest.
1260	*
1261	* @returns VBox status code.
1262	* @param pCtx Receive context to use.
1263	* @param msTimeout Timeout (in ms) to wait for receiving data.
1264	*/
1265	int GuestDnDSource::i_receiveTransferData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout)
1266	{
1267	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1268
1269	int vrc;
1270
1271	LogFlowFuncEnter();
1272
1273	GuestDnDState *pState = pCtx->pState;
1274	AssertPtr(pCtx->pState);
1275
1276	GuestDnD *pInst = GuestDnDInst();
1277	if (!pInst)
1278	return VERR_INVALID_POINTER;
1279
1280	#define REGISTER_CALLBACK(x) do { \
1281	vrc = pState->setCallback(x, i_receiveTransferDataCallback, pCtx); \
1282	if (RT_FAILURE(vrc)) \
1283	return vrc; \
1284	} while (0)
1285
1286	#define UNREGISTER_CALLBACK(x) do { \
1287	int vrc2 = pState->setCallback(x, NULL); \
1288	AssertRC(vrc2); \
1289	} while (0)
1290
1291	/*
1292	* Register callbacks.
1293	*/
1294	/* Guest callbacks. */
1295	REGISTER_CALLBACK(GUEST_DND_FN_CONNECT);
1296	REGISTER_CALLBACK(GUEST_DND_FN_DISCONNECT);
1297	REGISTER_CALLBACK(GUEST_DND_FN_EVT_ERROR);
1298	if (m_pState->m_uProtocolVersion >= 3)
1299	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA_HDR);
1300	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA);
1301	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DIR);
1302	if (m_pState->m_uProtocolVersion >= 2)
1303	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_FILE_HDR);
1304	REGISTER_CALLBACK(GUEST_DND_FN_GH_SND_FILE_DATA);
1305
1306	const PDNDDROPPEDFILES pDF = &pCtx->Transfer.DroppedFiles;
1307
1308	do
1309	{
1310	vrc = DnDDroppedFilesOpenTemp(pDF, 0 /* fFlags */);
1311	if (RT_FAILURE(vrc))
1312	{
1313	LogRel(("DnD: Opening dropped files directory '%s' on the host failed with vrc=%Rrc\n",
1314	DnDDroppedFilesGetDirAbs(pDF), vrc));
1315	break;
1316	}
1317
1318	/*
1319	* Receive the transfer list.
1320	*/
1321	GuestDnDMsg Msg;
1322	Msg.setType(HOST_DND_FN_GH_EVT_DROPPED);
1323	if (m_pState->m_uProtocolVersion >= 3)
1324	Msg.appendUInt32(0); /** @todo ContextID not used yet. */
1325	Msg.appendPointer((void*)pCtx->strFmtRecv.c_str(), (uint32_t)pCtx->strFmtRecv.length() + 1);
1326	Msg.appendUInt32((uint32_t)pCtx->strFmtRecv.length() + 1);
1327	Msg.appendUInt32(pCtx->enmAction);
1328
1329	/* Make the initial call to the guest by telling that we initiated the "dropped" event on
1330	* the host and therefore now waiting for the actual URI data. */
1331	vrc = pInst->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
1332	if (RT_SUCCESS(vrc))
1333	{
1334	LogFlowFunc(("Waiting ...\n"));
1335
1336	vrc = waitForEvent(&pCtx->EventCallback, pCtx->pState, msTimeout);
1337	if (RT_SUCCESS(vrc))
1338	vrc = pCtx->pState->setProgress(100, DND_PROGRESS_COMPLETE, VINF_SUCCESS);
1339
1340	LogFlowFunc(("Waiting ended with vrc=%Rrc\n", vrc));
1341	}
1342
1343	} while (0);
1344
1345	/*
1346	* Unregister callbacks.
1347	*/
1348	UNREGISTER_CALLBACK(GUEST_DND_FN_CONNECT);
1349	UNREGISTER_CALLBACK(GUEST_DND_FN_DISCONNECT);
1350	UNREGISTER_CALLBACK(GUEST_DND_FN_EVT_ERROR);
1351	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA_HDR);
1352	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DATA);
1353	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_DIR);
1354	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_FILE_HDR);
1355	UNREGISTER_CALLBACK(GUEST_DND_FN_GH_SND_FILE_DATA);
1356
1357	#undef REGISTER_CALLBACK
1358	#undef UNREGISTER_CALLBACK
1359
1360	if (RT_FAILURE(vrc))
1361	{
1362	int vrc2 = DnDDroppedFilesRollback(pDF);
1363	if (RT_FAILURE(vrc2))
1364	LogRel(("DnD: Deleting left over temporary files failed (%Rrc), please remove directory '%s' manually\n",
1365	vrc2, DnDDroppedFilesGetDirAbs(pDF)));
1366
1367	if (vrc == VERR_CANCELLED)
1368	{
1369	/*
1370	* Now that we've cleaned up tell the guest side to cancel.
1371	* This does not imply we're waiting for the guest to react, as the
1372	* host side never must depend on anything from the guest.
1373	*/
1374	vrc2 = sendCancel();
1375	AssertRC(vrc2);
1376
1377	vrc2 = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
1378	AssertRC(vrc2);
1379
1380	/* Cancelling is not an error, just set success here. */
1381	vrc = VINF_SUCCESS;
1382	}
1383	else if (vrc != VERR_DND_GUEST_ERROR) /* Guest-side error are already handled in the callback. */
1384	{
1385	vrc2 = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR, vrc, GuestDnDSource::i_hostErrorToString(vrc2));
1386	AssertRC(vrc2);
1387	}
1388	}
1389
1390	DnDDroppedFilesClose(pDF);
1391
1392	LogFlowFuncLeaveRC(vrc);
1393	return vrc;
1394	}
1395
1396	/**
1397	* Static HGCM service callback which handles receiving raw data.
1398	*
1399	* @returns VBox status code. Will get sent back to the host service.
1400	* @param uMsg HGCM message ID (function number).
1401	* @param pvParms Pointer to additional message data. Optional and can be NULL.
1402	* @param cbParms Size (in bytes) additional message data. Optional and can be 0.
1403	* @param pvUser User-supplied pointer on callback registration.
1404	*/
1405	/* static */
1406	DECLCALLBACK(int) GuestDnDSource::i_receiveRawDataCallback(uint32_t uMsg, void pvParms, size_t cbParms, void pvUser)
1407	{
1408	GuestDnDRecvCtx pCtx = (GuestDnDRecvCtx )pvUser;
1409	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1410
1411	GuestDnDSource *pThis = pCtx->pSource;
1412	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1413
1414	LogFlowFunc(("pThis=%p, uMsg=%RU32\n", pThis, uMsg));
1415
1416	int vrc = VINF_SUCCESS;
1417
1418	int vrcCallback = VINF_SUCCESS; /* vrc for the callback. */
1419	bool fNotify = false;
1420
1421	switch (uMsg)
1422	{
1423	case GUEST_DND_FN_CONNECT:
1424	/* Nothing to do here (yet). */
1425	break;
1426
1427	case GUEST_DND_FN_DISCONNECT:
1428	vrc = VERR_CANCELLED;
1429	break;
1430
1431	#ifdef VBOX_WITH_DRAG_AND_DROP_GH
1432	case GUEST_DND_FN_GH_SND_DATA_HDR:
1433	{
1434	PVBOXDNDCBSNDDATAHDRDATA pCBData = reinterpret_cast<PVBOXDNDCBSNDDATAHDRDATA>(pvParms);
1435	AssertPtr(pCBData);
1436	AssertReturn(sizeof(VBOXDNDCBSNDDATAHDRDATA) == cbParms, VERR_INVALID_PARAMETER);
1437	AssertReturn(CB_MAGIC_DND_GH_SND_DATA_HDR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1438
1439	vrc = pThis->i_onReceiveDataHdr(pCtx, &pCBData->data);
1440	break;
1441	}
1442	case GUEST_DND_FN_GH_SND_DATA:
1443	{
1444	PVBOXDNDCBSNDDATADATA pCBData = reinterpret_cast<PVBOXDNDCBSNDDATADATA>(pvParms);
1445	AssertPtr(pCBData);
1446	AssertReturn(sizeof(VBOXDNDCBSNDDATADATA) == cbParms, VERR_INVALID_PARAMETER);
1447	AssertReturn(CB_MAGIC_DND_GH_SND_DATA == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1448
1449	vrc = pThis->i_onReceiveData(pCtx, &pCBData->data);
1450	break;
1451	}
1452	case GUEST_DND_FN_EVT_ERROR:
1453	{
1454	PVBOXDNDCBEVTERRORDATA pCBData = reinterpret_cast<PVBOXDNDCBEVTERRORDATA>(pvParms);
1455	AssertPtr(pCBData);
1456	AssertReturn(sizeof(VBOXDNDCBEVTERRORDATA) == cbParms, VERR_INVALID_PARAMETER);
1457	AssertReturn(CB_MAGIC_DND_EVT_ERROR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1458
1459	pCtx->pState->reset();
1460
1461	if (RT_SUCCESS(pCBData->rc))
1462	{
1463	AssertMsgFailed(("Received guest error with no error code set\n"));
1464	pCBData->rc = VERR_GENERAL_FAILURE; /* Make sure some error is set. */
1465	}
1466	else if (pCBData->rc == VERR_WRONG_ORDER)
1467	vrc = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
1468	else
1469	vrc = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR, pCBData->rc,
1470	GuestDnDSource::i_guestErrorToString(pCBData->rc));
1471
1472	LogRel3(("DnD: Guest reported data transfer error: %Rrc\n", pCBData->rc));
1473
1474	if (RT_SUCCESS(vrc))
1475	vrcCallback = VERR_DND_GUEST_ERROR;
1476	break;
1477	}
1478	#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1479	default:
1480	vrc = VERR_NOT_SUPPORTED;
1481	break;
1482	}
1483
1484	if ( RT_FAILURE(vrc)
1485	\|\| RT_FAILURE(vrcCallback))
1486	{
1487	fNotify = true;
1488	if (RT_SUCCESS(vrcCallback))
1489	vrcCallback = vrc;
1490	}
1491
1492	if (RT_FAILURE(vrc))
1493	{
1494	switch (vrc)
1495	{
1496	case VERR_NO_DATA:
1497	LogRel2(("DnD: Data transfer to host complete\n"));
1498	break;
1499
1500	case VERR_CANCELLED:
1501	LogRel2(("DnD: Data transfer to host canceled\n"));
1502	break;
1503
1504	default:
1505	LogRel(("DnD: Error %Rrc occurred, aborting data transfer to host\n", vrc));
1506	break;
1507	}
1508
1509	/* Unregister this callback. */
1510	AssertPtr(pCtx->pState);
1511	int vrc2 = pCtx->pState->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
1512	AssertRC(vrc2);
1513	}
1514
1515	/* All data processed? */
1516	if (pCtx->isComplete())
1517	fNotify = true;
1518
1519	LogFlowFunc(("cbProcessed=%RU64, cbExtra=%RU64, fNotify=%RTbool, vrcCallback=%Rrc, vrc=%Rrc\n",
1520	pCtx->cbProcessed, pCtx->cbExtra, fNotify, vrcCallback, vrc));
1521
1522	if (fNotify)
1523	{
1524	int vrc2 = pCtx->EventCallback.Notify(vrcCallback);
1525	AssertRC(vrc2);
1526	}
1527
1528	LogFlowFuncLeaveRC(vrc);
1529	return vrc; /* Tell the guest. */
1530	}
1531
1532	/**
1533	* Static HGCM service callback which handles receiving transfer data from the guest.
1534	*
1535	* @returns VBox status code. Will get sent back to the host service.
1536	* @param uMsg HGCM message ID (function number).
1537	* @param pvParms Pointer to additional message data. Optional and can be NULL.
1538	* @param cbParms Size (in bytes) additional message data. Optional and can be 0.
1539	* @param pvUser User-supplied pointer on callback registration.
1540	*/
1541	/* static */
1542	DECLCALLBACK(int) GuestDnDSource::i_receiveTransferDataCallback(uint32_t uMsg, void pvParms, size_t cbParms, void pvUser)
1543	{
1544	GuestDnDRecvCtx pCtx = (GuestDnDRecvCtx )pvUser;
1545	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1546
1547	GuestDnDSource *pThis = pCtx->pSource;
1548	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1549
1550	LogFlowFunc(("pThis=%p, uMsg=%RU32\n", pThis, uMsg));
1551
1552	int vrc = VINF_SUCCESS;
1553
1554	int vrcCallback = VINF_SUCCESS; /* vrc for the callback. */
1555	bool fNotify = false;
1556
1557	switch (uMsg)
1558	{
1559	case GUEST_DND_FN_CONNECT:
1560	/* Nothing to do here (yet). */
1561	break;
1562
1563	case GUEST_DND_FN_DISCONNECT:
1564	vrc = VERR_CANCELLED;
1565	break;
1566
1567	#ifdef VBOX_WITH_DRAG_AND_DROP_GH
1568	case GUEST_DND_FN_GH_SND_DATA_HDR:
1569	{
1570	PVBOXDNDCBSNDDATAHDRDATA pCBData = reinterpret_cast<PVBOXDNDCBSNDDATAHDRDATA>(pvParms);
1571	AssertPtr(pCBData);
1572	AssertReturn(sizeof(VBOXDNDCBSNDDATAHDRDATA) == cbParms, VERR_INVALID_PARAMETER);
1573	AssertReturn(CB_MAGIC_DND_GH_SND_DATA_HDR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1574
1575	vrc = pThis->i_onReceiveDataHdr(pCtx, &pCBData->data);
1576	break;
1577	}
1578	case GUEST_DND_FN_GH_SND_DATA:
1579	{
1580	PVBOXDNDCBSNDDATADATA pCBData = reinterpret_cast<PVBOXDNDCBSNDDATADATA>(pvParms);
1581	AssertPtr(pCBData);
1582	AssertReturn(sizeof(VBOXDNDCBSNDDATADATA) == cbParms, VERR_INVALID_PARAMETER);
1583	AssertReturn(CB_MAGIC_DND_GH_SND_DATA == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1584
1585	vrc = pThis->i_onReceiveData(pCtx, &pCBData->data);
1586	break;
1587	}
1588	case GUEST_DND_FN_GH_SND_DIR:
1589	{
1590	PVBOXDNDCBSNDDIRDATA pCBData = reinterpret_cast<PVBOXDNDCBSNDDIRDATA>(pvParms);
1591	AssertPtr(pCBData);
1592	AssertReturn(sizeof(VBOXDNDCBSNDDIRDATA) == cbParms, VERR_INVALID_PARAMETER);
1593	AssertReturn(CB_MAGIC_DND_GH_SND_DIR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1594
1595	vrc = pThis->i_onReceiveDir(pCtx, pCBData->pszPath, pCBData->cbPath, pCBData->fMode);
1596	break;
1597	}
1598	case GUEST_DND_FN_GH_SND_FILE_HDR:
1599	{
1600	PVBOXDNDCBSNDFILEHDRDATA pCBData = reinterpret_cast<PVBOXDNDCBSNDFILEHDRDATA>(pvParms);
1601	AssertPtr(pCBData);
1602	AssertReturn(sizeof(VBOXDNDCBSNDFILEHDRDATA) == cbParms, VERR_INVALID_PARAMETER);
1603	AssertReturn(CB_MAGIC_DND_GH_SND_FILE_HDR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1604
1605	vrc = pThis->i_onReceiveFileHdr(pCtx, pCBData->pszFilePath, pCBData->cbFilePath,
1606	pCBData->cbSize, pCBData->fMode, pCBData->fFlags);
1607	break;
1608	}
1609	case GUEST_DND_FN_GH_SND_FILE_DATA:
1610	{
1611	PVBOXDNDCBSNDFILEDATADATA pCBData = reinterpret_cast<PVBOXDNDCBSNDFILEDATADATA>(pvParms);
1612	AssertPtr(pCBData);
1613	AssertReturn(sizeof(VBOXDNDCBSNDFILEDATADATA) == cbParms, VERR_INVALID_PARAMETER);
1614	AssertReturn(CB_MAGIC_DND_GH_SND_FILE_DATA == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1615
1616	if (pThis->m_pState->m_uProtocolVersion <= 1)
1617	{
1618	/*
1619	* Notes for protocol v1 (< VBox 5.0):
1620	* - Every time this command is being sent it includes the file header,
1621	* so just process both calls here.
1622	* - There was no information whatsoever about the total file size; the old code only
1623	* appended data to the desired file. So just pass 0 as cbSize.
1624	*/
1625	vrc = pThis->i_onReceiveFileHdr(pCtx, pCBData->u.v1.pszFilePath, pCBData->u.v1.cbFilePath,
1626	0 /* cbSize /, pCBData->u.v1.fMode, 0 / fFlags */);
1627	if (RT_SUCCESS(vrc))
1628	vrc = pThis->i_onReceiveFileData(pCtx, pCBData->pvData, pCBData->cbData);
1629	}
1630	else /* Protocol v2 and up. */
1631	vrc = pThis->i_onReceiveFileData(pCtx, pCBData->pvData, pCBData->cbData);
1632	break;
1633	}
1634	case GUEST_DND_FN_EVT_ERROR:
1635	{
1636	PVBOXDNDCBEVTERRORDATA pCBData = reinterpret_cast<PVBOXDNDCBEVTERRORDATA>(pvParms);
1637	AssertPtr(pCBData);
1638	AssertReturn(sizeof(VBOXDNDCBEVTERRORDATA) == cbParms, VERR_INVALID_PARAMETER);
1639	AssertReturn(CB_MAGIC_DND_EVT_ERROR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
1640
1641	pCtx->pState->reset();
1642
1643	if (RT_SUCCESS(pCBData->rc))
1644	{
1645	AssertMsgFailed(("Received guest error with no error code set\n"));
1646	pCBData->rc = VERR_GENERAL_FAILURE; /* Make sure some error is set. */
1647	}
1648	else if (pCBData->rc == VERR_WRONG_ORDER)
1649	vrc = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
1650	else
1651	vrc = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR, pCBData->rc,
1652	GuestDnDSource::i_guestErrorToString(pCBData->rc));
1653
1654	LogRel3(("DnD: Guest reported file transfer error: %Rrc\n", pCBData->rc));
1655
1656	if (RT_SUCCESS(vrc))
1657	vrcCallback = VERR_DND_GUEST_ERROR;
1658	break;
1659	}
1660	#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1661	default:
1662	vrc = VERR_NOT_SUPPORTED;
1663	break;
1664	}
1665
1666	if ( RT_FAILURE(vrc)
1667	\|\| RT_FAILURE(vrcCallback))
1668	{
1669	fNotify = true;
1670	if (RT_SUCCESS(vrcCallback))
1671	vrcCallback = vrc;
1672	}
1673
1674	if (RT_FAILURE(vrc))
1675	{
1676	switch (vrc)
1677	{
1678	case VERR_NO_DATA:
1679	LogRel2(("DnD: File transfer to host complete\n"));
1680	break;
1681
1682	case VERR_CANCELLED:
1683	LogRel2(("DnD: File transfer to host canceled\n"));
1684	break;
1685
1686	default:
1687	LogRel(("DnD: Error %Rrc occurred, aborting file transfer to host\n", vrc));
1688	break;
1689	}
1690
1691	/* Unregister this callback. */
1692	AssertPtr(pCtx->pState);
1693	int vrc2 = pCtx->pState->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
1694	AssertRC(vrc2);
1695	}
1696
1697	/* All data processed? */
1698	if ( pCtx->Transfer.isComplete()
1699	&& pCtx->isComplete())
1700	fNotify = true;
1701
1702	LogFlowFunc(("cbProcessed=%RU64, cbExtra=%RU64, fNotify=%RTbool, vrcCallback=%Rrc, vrc=%Rrc\n",
1703	pCtx->cbProcessed, pCtx->cbExtra, fNotify, vrcCallback, vrc));
1704
1705	if (fNotify)
1706	{
1707	int vrc2 = pCtx->EventCallback.Notify(
1708	vrcCallback);
1709	AssertRC(vrc2);
1710	}
1711
1712	LogFlowFuncLeaveRC(vrc);
1713	return vrc; /* Tell the guest. */
1714	}
1715

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

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

Download in other formats: