ConsoleImpl.cpp@ 21525

Last change on this file since 21525 was 21404, checked in by vboxsync, 15 years ago
IPRT, Main: make ministring throw std::bad_alloc on allocation failure; remove isEmpty() and isNull(), change Main code to using length() instead; second try
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 237.9 KB

Line
1	/* $Id: ConsoleImpl.cpp 21404 2009-07-08 15:19:42Z vboxsync $ */
2
3	/** @file
4	*
5	* VBox Console COM Class implementation
6	*/
7
8	/*
9	* Copyright (C) 2006-2009 Sun Microsystems, Inc.
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20	* Clara, CA 95054 USA or visit http://www.sun.com if you need
21	* additional information or have any questions.
22	*/
23
24	#if defined(RT_OS_WINDOWS)
25	#elif defined(RT_OS_LINUX)
26	# include <errno.h>
27	# include <sys/ioctl.h>
28	# include <sys/poll.h>
29	# include <sys/fcntl.h>
30	# include <sys/types.h>
31	# include <sys/wait.h>
32	# include <net/if.h>
33	# include <linux/if_tun.h>
34	# include <stdio.h>
35	# include <stdlib.h>
36	# include <string.h>
37	#endif
38
39	#include "ConsoleImpl.h"
40
41	#include "Global.h"
42	#include "GuestImpl.h"
43	#include "KeyboardImpl.h"
44	#include "MouseImpl.h"
45	#include "DisplayImpl.h"
46	#include "MachineDebuggerImpl.h"
47	#include "USBDeviceImpl.h"
48	#include "RemoteUSBDeviceImpl.h"
49	#include "SharedFolderImpl.h"
50	#include "AudioSnifferInterface.h"
51	#include "ConsoleVRDPServer.h"
52	#include "VMMDev.h"
53	#include "Version.h"
54	#include "package-generated.h"
55
56	// generated header
57	#include "SchemaDefs.h"
58
59	#include "Logging.h"
60
61	#include <VBox/com/array.h>
62
63	#include <iprt/string.h>
64	#include <iprt/asm.h>
65	#include <iprt/file.h>
66	#include <iprt/path.h>
67	#include <iprt/dir.h>
68	#include <iprt/process.h>
69	#include <iprt/ldr.h>
70	#include <iprt/cpputils.h>
71	#include <iprt/system.h>
72
73	#include <VBox/vmapi.h>
74	#include <VBox/err.h>
75	#include <VBox/param.h>
76	#include <VBox/vusb.h>
77	#include <VBox/mm.h>
78	#include <VBox/ssm.h>
79	#include <VBox/version.h>
80	#ifdef VBOX_WITH_USB
81	# include <VBox/pdmusb.h>
82	#endif
83
84	#include <VBox/VMMDev.h>
85
86	#include <VBox/HostServices/VBoxClipboardSvc.h>
87	#ifdef VBOX_WITH_GUEST_PROPS
88	# include <VBox/HostServices/GuestPropertySvc.h>
89	# include <VBox/com/array.h>
90	#endif
91
92	#include <set>
93	#include <algorithm>
94	#include <memory> // for auto_ptr
95	#include <vector>
96
97
98	// VMTask and friends
99	////////////////////////////////////////////////////////////////////////////////
100
101	/**
102	* Task structure for asynchronous VM operations.
103	*
104	* Once created, the task structure adds itself as a Console caller. This means:
105	*
106	* 1. The user must check for #rc() before using the created structure
107	* (e.g. passing it as a thread function argument). If #rc() returns a
108	* failure, the Console object may not be used by the task (see
109	Console::addCaller() for more details).
110	* 2. On successful initialization, the structure keeps the Console caller
111	* until destruction (to ensure Console remains in the Ready state and won't
112	* be accidentally uninitialized). Forgetting to delete the created task
113	* will lead to Console::uninit() stuck waiting for releasing all added
114	* callers.
115	*
116	* If \a aUsesVMPtr parameter is true, the task structure will also add itself
117	* as a Console::mpVM caller with the same meaning as above. See
118	* Console::addVMCaller() for more info.
119	*/
120	struct VMTask
121	{
122	VMTask (Console *aConsole, bool aUsesVMPtr)
123	: mConsole (aConsole), mCallerAdded (false), mVMCallerAdded (false)
124	{
125	AssertReturnVoid (aConsole);
126	mRC = aConsole->addCaller();
127	if (SUCCEEDED (mRC))
128	{
129	mCallerAdded = true;
130	if (aUsesVMPtr)
131	{
132	mRC = aConsole->addVMCaller();
133	if (SUCCEEDED (mRC))
134	mVMCallerAdded = true;
135	}
136	}
137	}
138
139	~VMTask()
140	{
141	if (mVMCallerAdded)
142	mConsole->releaseVMCaller();
143	if (mCallerAdded)
144	mConsole->releaseCaller();
145	}
146
147	HRESULT rc() const { return mRC; }
148	bool isOk() const { return SUCCEEDED (rc()); }
149
150	/** Releases the Console caller before destruction. Not normally necessary. */
151	void releaseCaller()
152	{
153	AssertReturnVoid (mCallerAdded);
154	mConsole->releaseCaller();
155	mCallerAdded = false;
156	}
157
158	/** Releases the VM caller before destruction. Not normally necessary. */
159	void releaseVMCaller()
160	{
161	AssertReturnVoid (mVMCallerAdded);
162	mConsole->releaseVMCaller();
163	mVMCallerAdded = false;
164	}
165
166	const ComObjPtr <Console> mConsole;
167
168	private:
169
170	HRESULT mRC;
171	bool mCallerAdded : 1;
172	bool mVMCallerAdded : 1;
173	};
174
175	struct VMProgressTask : public VMTask
176	{
177	VMProgressTask (Console aConsole, Progress aProgress, bool aUsesVMPtr)
178	: VMTask (aConsole, aUsesVMPtr), mProgress (aProgress) {}
179
180	const ComObjPtr <Progress> mProgress;
181
182	Utf8Str mErrorMsg;
183	};
184
185	struct VMPowerUpTask : public VMProgressTask
186	{
187	VMPowerUpTask (Console aConsole, Progress aProgress)
188	: VMProgressTask (aConsole, aProgress, false /* aUsesVMPtr */)
189	, mSetVMErrorCallback (NULL), mConfigConstructor (NULL), mStartPaused (false) {}
190
191	PFNVMATERROR mSetVMErrorCallback;
192	PFNCFGMCONSTRUCTOR mConfigConstructor;
193	Utf8Str mSavedStateFile;
194	Console::SharedFolderDataMap mSharedFolders;
195	bool mStartPaused;
196
197	typedef std::list <ComPtr <IHardDisk> > HardDiskList;
198	HardDiskList hardDisks;
199
200	/* array of progress objects for hard disk reset operations */
201	typedef std::list <ComPtr <IProgress> > ProgressList;
202	ProgressList hardDiskProgresses;
203	};
204
205	struct VMSaveTask : public VMProgressTask
206	{
207	VMSaveTask (Console aConsole, Progress aProgress)
208	: VMProgressTask (aConsole, aProgress, true /* aUsesVMPtr */)
209	, mIsSnapshot (false)
210	, mLastMachineState (MachineState_Null) {}
211
212	bool mIsSnapshot;
213	Utf8Str mSavedStateFile;
214	MachineState_T mLastMachineState;
215	ComPtr <IProgress> mServerProgress;
216	};
217
218	// constructor / destructor
219	/////////////////////////////////////////////////////////////////////////////
220
221	Console::Console()
222	: mSavedStateDataLoaded (false)
223	, mConsoleVRDPServer (NULL)
224	, mpVM (NULL)
225	, mVMCallers (0)
226	, mVMZeroCallersSem (NIL_RTSEMEVENT)
227	, mVMDestroying (false)
228	, mVMPoweredOff (false)
229	, meDVDState (DriveState_NotMounted)
230	, meFloppyState (DriveState_NotMounted)
231	, mVMMDev (NULL)
232	, mAudioSniffer (NULL)
233	, mVMStateChangeCallbackDisabled (false)
234	, mMachineState (MachineState_PoweredOff)
235	{}
236
237	Console::~Console()
238	{}
239
240	HRESULT Console::FinalConstruct()
241	{
242	LogFlowThisFunc (("\n"));
243
244	memset(mapFDLeds, 0, sizeof(mapFDLeds));
245	memset(mapIDELeds, 0, sizeof(mapIDELeds));
246	memset(mapSATALeds, 0, sizeof(mapSATALeds));
247	memset(mapSCSILeds, 0, sizeof(mapSCSILeds));
248	memset(mapNetworkLeds, 0, sizeof(mapNetworkLeds));
249	memset(&mapUSBLed, 0, sizeof(mapUSBLed));
250	memset(&mapSharedFolderLed, 0, sizeof(mapSharedFolderLed));
251
252	return S_OK;
253	}
254
255	void Console::FinalRelease()
256	{
257	LogFlowThisFunc (("\n"));
258
259	uninit();
260	}
261
262	// public initializer/uninitializer for internal purposes only
263	/////////////////////////////////////////////////////////////////////////////
264
265	HRESULT Console::init (IMachine aMachine, IInternalMachineControl aControl)
266	{
267	AssertReturn (aMachine && aControl, E_INVALIDARG);
268
269	/* Enclose the state transition NotReady->InInit->Ready */
270	AutoInitSpan autoInitSpan (this);
271	AssertReturn (autoInitSpan.isOk(), E_FAIL);
272
273	LogFlowThisFuncEnter();
274	LogFlowThisFunc(("aMachine=%p, aControl=%p\n", aMachine, aControl));
275
276	HRESULT rc = E_FAIL;
277
278	unconst (mMachine) = aMachine;
279	unconst (mControl) = aControl;
280
281	memset (&mCallbackData, 0, sizeof (mCallbackData));
282
283	/* Cache essential properties and objects */
284
285	rc = mMachine->COMGETTER(State) (&mMachineState);
286	AssertComRCReturnRC (rc);
287
288	#ifdef VBOX_WITH_VRDP
289	rc = mMachine->COMGETTER(VRDPServer) (unconst (mVRDPServer).asOutParam());
290	AssertComRCReturnRC (rc);
291	#endif
292
293	rc = mMachine->COMGETTER(DVDDrive) (unconst (mDVDDrive).asOutParam());
294	AssertComRCReturnRC (rc);
295
296	rc = mMachine->COMGETTER(FloppyDrive) (unconst (mFloppyDrive).asOutParam());
297	AssertComRCReturnRC (rc);
298
299	/* Create associated child COM objects */
300
301	unconst (mGuest).createObject();
302	rc = mGuest->init (this);
303	AssertComRCReturnRC (rc);
304
305	unconst (mKeyboard).createObject();
306	rc = mKeyboard->init (this);
307	AssertComRCReturnRC (rc);
308
309	unconst (mMouse).createObject();
310	rc = mMouse->init (this);
311	AssertComRCReturnRC (rc);
312
313	unconst (mDisplay).createObject();
314	rc = mDisplay->init (this);
315	AssertComRCReturnRC (rc);
316
317	unconst (mRemoteDisplayInfo).createObject();
318	rc = mRemoteDisplayInfo->init (this);
319	AssertComRCReturnRC (rc);
320
321	/* Grab global and machine shared folder lists */
322
323	rc = fetchSharedFolders (true /* aGlobal */);
324	AssertComRCReturnRC (rc);
325	rc = fetchSharedFolders (false /* aGlobal */);
326	AssertComRCReturnRC (rc);
327
328	/* Create other child objects */
329
330	unconst (mConsoleVRDPServer) = new ConsoleVRDPServer (this);
331	AssertReturn (mConsoleVRDPServer, E_FAIL);
332
333	mcAudioRefs = 0;
334	mcVRDPClients = 0;
335	mu32SingleRDPClientId = 0;
336
337	unconst (mVMMDev) = new VMMDev(this);
338	AssertReturn (mVMMDev, E_FAIL);
339
340	unconst (mAudioSniffer) = new AudioSniffer(this);
341	AssertReturn (mAudioSniffer, E_FAIL);
342
343	/* Confirm a successful initialization when it's the case */
344	autoInitSpan.setSucceeded();
345
346	LogFlowThisFuncLeave();
347
348	return S_OK;
349	}
350
351	/**
352	* Uninitializes the Console object.
353	*/
354	void Console::uninit()
355	{
356	LogFlowThisFuncEnter();
357
358	/* Enclose the state transition Ready->InUninit->NotReady */
359	AutoUninitSpan autoUninitSpan (this);
360	if (autoUninitSpan.uninitDone())
361	{
362	LogFlowThisFunc (("Already uninitialized.\n"));
363	LogFlowThisFuncLeave();
364	return;
365	}
366
367	LogFlowThisFunc (("initFailed()=%d\n", autoUninitSpan.initFailed()));
368
369	/*
370	* Uninit all children that use addDependentChild()/removeDependentChild()
371	* in their init()/uninit() methods.
372	*/
373	uninitDependentChildren();
374
375	/* power down the VM if necessary */
376	if (mpVM)
377	{
378	powerDown();
379	Assert (mpVM == NULL);
380	}
381
382	if (mVMZeroCallersSem != NIL_RTSEMEVENT)
383	{
384	RTSemEventDestroy (mVMZeroCallersSem);
385	mVMZeroCallersSem = NIL_RTSEMEVENT;
386	}
387
388	if (mAudioSniffer)
389	{
390	delete mAudioSniffer;
391	unconst (mAudioSniffer) = NULL;
392	}
393
394	if (mVMMDev)
395	{
396	delete mVMMDev;
397	unconst (mVMMDev) = NULL;
398	}
399
400	mGlobalSharedFolders.clear();
401	mMachineSharedFolders.clear();
402
403	mSharedFolders.clear();
404	mRemoteUSBDevices.clear();
405	mUSBDevices.clear();
406
407	if (mRemoteDisplayInfo)
408	{
409	mRemoteDisplayInfo->uninit();
410	unconst (mRemoteDisplayInfo).setNull();;
411	}
412
413	if (mDebugger)
414	{
415	mDebugger->uninit();
416	unconst (mDebugger).setNull();
417	}
418
419	if (mDisplay)
420	{
421	mDisplay->uninit();
422	unconst (mDisplay).setNull();
423	}
424
425	if (mMouse)
426	{
427	mMouse->uninit();
428	unconst (mMouse).setNull();
429	}
430
431	if (mKeyboard)
432	{
433	mKeyboard->uninit();
434	unconst (mKeyboard).setNull();;
435	}
436
437	if (mGuest)
438	{
439	mGuest->uninit();
440	unconst (mGuest).setNull();;
441	}
442
443	if (mConsoleVRDPServer)
444	{
445	delete mConsoleVRDPServer;
446	unconst (mConsoleVRDPServer) = NULL;
447	}
448
449	unconst (mFloppyDrive).setNull();
450	unconst (mDVDDrive).setNull();
451	#ifdef VBOX_WITH_VRDP
452	unconst (mVRDPServer).setNull();
453	#endif
454
455	unconst (mControl).setNull();
456	unconst (mMachine).setNull();
457
458	/* Release all callbacks. Do this after uninitializing the components,
459	* as some of them are well-behaved and unregister their callbacks.
460	* These would trigger error messages complaining about trying to
461	* unregister a non-registered callback. */
462	mCallbacks.clear();
463
464	/* dynamically allocated members of mCallbackData are uninitialized
465	* at the end of powerDown() */
466	Assert (!mCallbackData.mpsc.valid && mCallbackData.mpsc.shape == NULL);
467	Assert (!mCallbackData.mcc.valid);
468	Assert (!mCallbackData.klc.valid);
469
470	LogFlowThisFuncLeave();
471	}
472
473	int Console::VRDPClientLogon (uint32_t u32ClientId, const char pszUser, const char pszPassword, const char *pszDomain)
474	{
475	LogFlowFuncEnter();
476	LogFlowFunc (("%d, %s, %s, %s\n", u32ClientId, pszUser, pszPassword, pszDomain));
477
478	AutoCaller autoCaller (this);
479	if (!autoCaller.isOk())
480	{
481	/* Console has been already uninitialized, deny request */
482	LogRel(("VRDPAUTH: Access denied (Console uninitialized).\n"));
483	LogFlowFuncLeave();
484	return VERR_ACCESS_DENIED;
485	}
486
487	Bstr id;
488	HRESULT hrc = mMachine->COMGETTER (Id) (id.asOutParam());
489	Guid uuid = Guid(id);
490
491	AssertComRCReturn (hrc, VERR_ACCESS_DENIED);
492
493	VRDPAuthType_T authType = VRDPAuthType_Null;
494	hrc = mVRDPServer->COMGETTER(AuthType) (&authType);
495	AssertComRCReturn (hrc, VERR_ACCESS_DENIED);
496
497	ULONG authTimeout = 0;
498	hrc = mVRDPServer->COMGETTER(AuthTimeout) (&authTimeout);
499	AssertComRCReturn (hrc, VERR_ACCESS_DENIED);
500
501	VRDPAuthResult result = VRDPAuthAccessDenied;
502	VRDPAuthGuestJudgement guestJudgement = VRDPAuthGuestNotAsked;
503
504	LogFlowFunc(("Auth type %d\n", authType));
505
506	LogRel (("VRDPAUTH: User: [%s]. Domain: [%s]. Authentication type: [%s]\n",
507	pszUser, pszDomain,
508	authType == VRDPAuthType_Null?
509	"Null":
510	(authType == VRDPAuthType_External?
511	"External":
512	(authType == VRDPAuthType_Guest?
513	"Guest":
514	"INVALID"
515	)
516	)
517	));
518
519	switch (authType)
520	{
521	case VRDPAuthType_Null:
522	{
523	result = VRDPAuthAccessGranted;
524	break;
525	}
526
527	case VRDPAuthType_External:
528	{
529	/* Call the external library. */
530	result = mConsoleVRDPServer->Authenticate (uuid, guestJudgement, pszUser, pszPassword, pszDomain, u32ClientId);
531
532	if (result != VRDPAuthDelegateToGuest)
533	{
534	break;
535	}
536
537	LogRel(("VRDPAUTH: Delegated to guest.\n"));
538
539	LogFlowFunc (("External auth asked for guest judgement\n"));
540	} /* pass through */
541
542	case VRDPAuthType_Guest:
543	{
544	guestJudgement = VRDPAuthGuestNotReacted;
545
546	if (mVMMDev)
547	{
548	/* Issue the request to guest. Assume that the call does not require EMT. It should not. */
549
550	/* Ask the guest to judge these credentials. */
551	uint32_t u32GuestFlags = VMMDEV_SETCREDENTIALS_JUDGE;
552
553	int rc = mVMMDev->getVMMDevPort()->pfnSetCredentials (mVMMDev->getVMMDevPort(),
554	pszUser, pszPassword, pszDomain, u32GuestFlags);
555
556	if (VBOX_SUCCESS (rc))
557	{
558	/* Wait for guest. */
559	rc = mVMMDev->WaitCredentialsJudgement (authTimeout, &u32GuestFlags);
560
561	if (VBOX_SUCCESS (rc))
562	{
563	switch (u32GuestFlags & (VMMDEV_CREDENTIALS_JUDGE_OK \| VMMDEV_CREDENTIALS_JUDGE_DENY \| VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT))
564	{
565	case VMMDEV_CREDENTIALS_JUDGE_DENY: guestJudgement = VRDPAuthGuestAccessDenied; break;
566	case VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT: guestJudgement = VRDPAuthGuestNoJudgement; break;
567	case VMMDEV_CREDENTIALS_JUDGE_OK: guestJudgement = VRDPAuthGuestAccessGranted; break;
568	default:
569	LogFlowFunc (("Invalid guest flags %08X!!!\n", u32GuestFlags)); break;
570	}
571	}
572	else
573	{
574	LogFlowFunc (("Wait for credentials judgement rc = %Rrc!!!\n", rc));
575	}
576
577	LogFlowFunc (("Guest judgement %d\n", guestJudgement));
578	}
579	else
580	{
581	LogFlowFunc (("Could not set credentials rc = %Rrc!!!\n", rc));
582	}
583	}
584
585	if (authType == VRDPAuthType_External)
586	{
587	LogRel(("VRDPAUTH: Guest judgement %d.\n", guestJudgement));
588	LogFlowFunc (("External auth called again with guest judgement = %d\n", guestJudgement));
589	result = mConsoleVRDPServer->Authenticate (uuid, guestJudgement, pszUser, pszPassword, pszDomain, u32ClientId);
590	}
591	else
592	{
593	switch (guestJudgement)
594	{
595	case VRDPAuthGuestAccessGranted:
596	result = VRDPAuthAccessGranted;
597	break;
598	default:
599	result = VRDPAuthAccessDenied;
600	break;
601	}
602	}
603	} break;
604
605	default:
606	AssertFailed();
607	}
608
609	LogFlowFunc (("Result = %d\n", result));
610	LogFlowFuncLeave();
611
612	if (result != VRDPAuthAccessGranted)
613	{
614	/* Reject. */
615	LogRel(("VRDPAUTH: Access denied.\n"));
616	return VERR_ACCESS_DENIED;
617	}
618
619	LogRel(("VRDPAUTH: Access granted.\n"));
620
621	/* Multiconnection check must be made after authentication, so bad clients would not interfere with a good one. */
622	BOOL allowMultiConnection = FALSE;
623	hrc = mVRDPServer->COMGETTER(AllowMultiConnection) (&allowMultiConnection);
624	AssertComRCReturn (hrc, VERR_ACCESS_DENIED);
625
626	BOOL reuseSingleConnection = FALSE;
627	hrc = mVRDPServer->COMGETTER(ReuseSingleConnection) (&reuseSingleConnection);
628	AssertComRCReturn (hrc, VERR_ACCESS_DENIED);
629
630	LogFlowFunc(("allowMultiConnection %d, reuseSingleConnection = %d, mcVRDPClients = %d, mu32SingleRDPClientId = %d\n", allowMultiConnection, reuseSingleConnection, mcVRDPClients, mu32SingleRDPClientId));
631
632	if (allowMultiConnection == FALSE)
633	{
634	/* Note: the 'mcVRDPClients' variable is incremented in ClientConnect callback, which is called when the client
635	* is successfully connected, that is after the ClientLogon callback. Therefore the mcVRDPClients
636	* value is 0 for first client.
637	*/
638	if (mcVRDPClients != 0)
639	{
640	Assert(mcVRDPClients == 1);
641	/* There is a client already.
642	* If required drop the existing client connection and let the connecting one in.
643	*/
644	if (reuseSingleConnection)
645	{
646	LogRel(("VRDPAUTH: Multiple connections are not enabled. Disconnecting existing client.\n"));
647	mConsoleVRDPServer->DisconnectClient (mu32SingleRDPClientId, false);
648	}
649	else
650	{
651	/* Reject. */
652	LogRel(("VRDPAUTH: Multiple connections are not enabled. Access denied.\n"));
653	return VERR_ACCESS_DENIED;
654	}
655	}
656
657	/* Save the connected client id. From now on it will be necessary to disconnect this one. */
658	mu32SingleRDPClientId = u32ClientId;
659	}
660
661	return VINF_SUCCESS;
662	}
663
664	void Console::VRDPClientConnect (uint32_t u32ClientId)
665	{
666	LogFlowFuncEnter();
667
668	AutoCaller autoCaller (this);
669	AssertComRCReturnVoid (autoCaller.rc());
670
671	#ifdef VBOX_WITH_VRDP
672	uint32_t u32Clients = ASMAtomicIncU32(&mcVRDPClients);
673
674	if (u32Clients == 1)
675	{
676	getVMMDev()->getVMMDevPort()->
677	pfnVRDPChange (getVMMDev()->getVMMDevPort(),
678	true, VRDP_EXPERIENCE_LEVEL_FULL); // @todo configurable
679	}
680
681	NOREF(u32ClientId);
682	mDisplay->VideoAccelVRDP (true);
683	#endif /* VBOX_WITH_VRDP */
684
685	LogFlowFuncLeave();
686	return;
687	}
688
689	void Console::VRDPClientDisconnect (uint32_t u32ClientId,
690	uint32_t fu32Intercepted)
691	{
692	LogFlowFuncEnter();
693
694	AutoCaller autoCaller (this);
695	AssertComRCReturnVoid (autoCaller.rc());
696
697	AssertReturnVoid (mConsoleVRDPServer);
698
699	#ifdef VBOX_WITH_VRDP
700	uint32_t u32Clients = ASMAtomicDecU32(&mcVRDPClients);
701
702	if (u32Clients == 0)
703	{
704	getVMMDev()->getVMMDevPort()->
705	pfnVRDPChange (getVMMDev()->getVMMDevPort(),
706	false, 0);
707	}
708
709	mDisplay->VideoAccelVRDP (false);
710	#endif /* VBOX_WITH_VRDP */
711
712	if (fu32Intercepted & VRDP_CLIENT_INTERCEPT_USB)
713	{
714	mConsoleVRDPServer->USBBackendDelete (u32ClientId);
715	}
716
717	#ifdef VBOX_WITH_VRDP
718	if (fu32Intercepted & VRDP_CLIENT_INTERCEPT_CLIPBOARD)
719	{
720	mConsoleVRDPServer->ClipboardDelete (u32ClientId);
721	}
722
723	if (fu32Intercepted & VRDP_CLIENT_INTERCEPT_AUDIO)
724	{
725	mcAudioRefs--;
726
727	if (mcAudioRefs <= 0)
728	{
729	if (mAudioSniffer)
730	{
731	PPDMIAUDIOSNIFFERPORT port = mAudioSniffer->getAudioSnifferPort();
732	if (port)
733	{
734	port->pfnSetup (port, false, false);
735	}
736	}
737	}
738	}
739	#endif /* VBOX_WITH_VRDP */
740
741	Bstr uuid;
742	HRESULT hrc = mMachine->COMGETTER (Id) (uuid.asOutParam());
743	AssertComRC (hrc);
744
745	VRDPAuthType_T authType = VRDPAuthType_Null;
746	hrc = mVRDPServer->COMGETTER(AuthType) (&authType);
747	AssertComRC (hrc);
748
749	if (authType == VRDPAuthType_External)
750	mConsoleVRDPServer->AuthDisconnect (uuid, u32ClientId);
751
752	LogFlowFuncLeave();
753	return;
754	}
755
756	void Console::VRDPInterceptAudio (uint32_t u32ClientId)
757	{
758	LogFlowFuncEnter();
759
760	AutoCaller autoCaller (this);
761	AssertComRCReturnVoid (autoCaller.rc());
762
763	LogFlowFunc (("mAudioSniffer %p, u32ClientId %d.\n",
764	mAudioSniffer, u32ClientId));
765	NOREF(u32ClientId);
766
767	#ifdef VBOX_WITH_VRDP
768	mcAudioRefs++;
769
770	if (mcAudioRefs == 1)
771	{
772	if (mAudioSniffer)
773	{
774	PPDMIAUDIOSNIFFERPORT port = mAudioSniffer->getAudioSnifferPort();
775	if (port)
776	{
777	port->pfnSetup (port, true, true);
778	}
779	}
780	}
781	#endif
782
783	LogFlowFuncLeave();
784	return;
785	}
786
787	void Console::VRDPInterceptUSB (uint32_t u32ClientId, void **ppvIntercept)
788	{
789	LogFlowFuncEnter();
790
791	AutoCaller autoCaller (this);
792	AssertComRCReturnVoid (autoCaller.rc());
793
794	AssertReturnVoid (mConsoleVRDPServer);
795
796	mConsoleVRDPServer->USBBackendCreate (u32ClientId, ppvIntercept);
797
798	LogFlowFuncLeave();
799	return;
800	}
801
802	void Console::VRDPInterceptClipboard (uint32_t u32ClientId)
803	{
804	LogFlowFuncEnter();
805
806	AutoCaller autoCaller (this);
807	AssertComRCReturnVoid (autoCaller.rc());
808
809	AssertReturnVoid (mConsoleVRDPServer);
810
811	#ifdef VBOX_WITH_VRDP
812	mConsoleVRDPServer->ClipboardCreate (u32ClientId);
813	#endif /* VBOX_WITH_VRDP */
814
815	LogFlowFuncLeave();
816	return;
817	}
818
819
820	//static
821	const char *Console::sSSMConsoleUnit = "ConsoleData";
822	//static
823	uint32_t Console::sSSMConsoleVer = 0x00010001;
824
825	/**
826	* Loads various console data stored in the saved state file.
827	* This method does validation of the state file and returns an error info
828	* when appropriate.
829	*
830	* The method does nothing if the machine is not in the Saved file or if
831	* console data from it has already been loaded.
832	*
833	* @note The caller must lock this object for writing.
834	*/
835	HRESULT Console::loadDataFromSavedState()
836	{
837	if (mMachineState != MachineState_Saved \|\| mSavedStateDataLoaded)
838	return S_OK;
839
840	Bstr savedStateFile;
841	HRESULT rc = mMachine->COMGETTER(StateFilePath) (savedStateFile.asOutParam());
842	if (FAILED (rc))
843	return rc;
844
845	PSSMHANDLE ssm;
846	int vrc = SSMR3Open (Utf8Str(savedStateFile), 0, &ssm);
847	if (VBOX_SUCCESS (vrc))
848	{
849	uint32_t version = 0;
850	vrc = SSMR3Seek (ssm, sSSMConsoleUnit, 0 /* iInstance */, &version);
851	if (SSM_VERSION_MAJOR(version) == SSM_VERSION_MAJOR(sSSMConsoleVer))
852	{
853	if (VBOX_SUCCESS (vrc))
854	vrc = loadStateFileExecInternal (ssm, version);
855	else if (vrc == VERR_SSM_UNIT_NOT_FOUND)
856	vrc = VINF_SUCCESS;
857	}
858	else
859	vrc = VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
860
861	SSMR3Close (ssm);
862	}
863
864	if (VBOX_FAILURE (vrc))
865	rc = setError (VBOX_E_FILE_ERROR,
866	tr ("The saved state file '%ls' is invalid (%Rrc). "
867	"Discard the saved state and try again"),
868	savedStateFile.raw(), vrc);
869
870	mSavedStateDataLoaded = true;
871
872	return rc;
873	}
874
875	/**
876	* Callback handler to save various console data to the state file,
877	* called when the user saves the VM state.
878	*
879	* @param pvUser pointer to Console
880	*
881	* @note Locks the Console object for reading.
882	*/
883	//static
884	DECLCALLBACK(void)
885	Console::saveStateFileExec (PSSMHANDLE pSSM, void *pvUser)
886	{
887	LogFlowFunc (("\n"));
888
889	Console that = static_cast <Console > (pvUser);
890	AssertReturnVoid (that);
891
892	AutoCaller autoCaller (that);
893	AssertComRCReturnVoid (autoCaller.rc());
894
895	AutoReadLock alock (that);
896
897	int vrc = SSMR3PutU32 (pSSM, (uint32_t)that->mSharedFolders.size());
898	AssertRC (vrc);
899
900	for (SharedFolderMap::const_iterator it = that->mSharedFolders.begin();
901	it != that->mSharedFolders.end();
902	++ it)
903	{
904	ComObjPtr <SharedFolder> folder = (*it).second;
905	// don't lock the folder because methods we access are const
906
907	Utf8Str name = folder->name();
908	vrc = SSMR3PutU32 (pSSM, (uint32_t)name.length() + 1 /* term. 0 */);
909	AssertRC (vrc);
910	vrc = SSMR3PutStrZ (pSSM, name);
911	AssertRC (vrc);
912
913	Utf8Str hostPath = folder->hostPath();
914	vrc = SSMR3PutU32 (pSSM, (uint32_t)hostPath.length() + 1 /* term. 0 */);
915	AssertRC (vrc);
916	vrc = SSMR3PutStrZ (pSSM, hostPath);
917	AssertRC (vrc);
918
919	vrc = SSMR3PutBool (pSSM, !!folder->writable());
920	AssertRC (vrc);
921	}
922
923	return;
924	}
925
926	/**
927	* Callback handler to load various console data from the state file.
928	* Called when the VM is being restored from the saved state.
929	*
930	* @param pvUser pointer to Console
931	* @param u32Version Console unit version.
932	* Should match sSSMConsoleVer.
933	*
934	* @note Should locks the Console object for writing, if necessary.
935	*/
936	//static
937	DECLCALLBACK(int)
938	Console::loadStateFileExec (PSSMHANDLE pSSM, void *pvUser, uint32_t u32Version)
939	{
940	LogFlowFunc (("\n"));
941
942	if (SSM_VERSION_MAJOR_CHANGED(u32Version, sSSMConsoleVer))
943	return VERR_VERSION_MISMATCH;
944
945	Console that = static_cast <Console > (pvUser);
946	AssertReturn (that, VERR_INVALID_PARAMETER);
947
948	/* Currently, nothing to do when we've been called from VMR3Load. */
949
950	return VINF_SUCCESS;
951	}
952
953	/**
954	* Method to load various console data from the state file.
955	* Called from #loadDataFromSavedState.
956	*
957	* @param pvUser pointer to Console
958	* @param u32Version Console unit version.
959	* Should match sSSMConsoleVer.
960	*
961	* @note Locks the Console object for writing.
962	*/
963	int
964	Console::loadStateFileExecInternal (PSSMHANDLE pSSM, uint32_t u32Version)
965	{
966	AutoCaller autoCaller (this);
967	AssertComRCReturn (autoCaller.rc(), VERR_ACCESS_DENIED);
968
969	AutoWriteLock alock (this);
970
971	AssertReturn (mSharedFolders.size() == 0, VERR_INTERNAL_ERROR);
972
973	uint32_t size = 0;
974	int vrc = SSMR3GetU32 (pSSM, &size);
975	AssertRCReturn (vrc, vrc);
976
977	for (uint32_t i = 0; i < size; ++ i)
978	{
979	Bstr name;
980	Bstr hostPath;
981	bool writable = true;
982
983	uint32_t szBuf = 0;
984	char *buf = NULL;
985
986	vrc = SSMR3GetU32 (pSSM, &szBuf);
987	AssertRCReturn (vrc, vrc);
988	buf = new char [szBuf];
989	vrc = SSMR3GetStrZ (pSSM, buf, szBuf);
990	AssertRC (vrc);
991	name = buf;
992	delete[] buf;
993
994	vrc = SSMR3GetU32 (pSSM, &szBuf);
995	AssertRCReturn (vrc, vrc);
996	buf = new char [szBuf];
997	vrc = SSMR3GetStrZ (pSSM, buf, szBuf);
998	AssertRC (vrc);
999	hostPath = buf;
1000	delete[] buf;
1001
1002	if (u32Version > 0x00010000)
1003	SSMR3GetBool (pSSM, &writable);
1004
1005	ComObjPtr <SharedFolder> sharedFolder;
1006	sharedFolder.createObject();
1007	HRESULT rc = sharedFolder->init (this, name, hostPath, writable);
1008	AssertComRCReturn (rc, VERR_INTERNAL_ERROR);
1009
1010	mSharedFolders.insert (std::make_pair (name, sharedFolder));
1011	}
1012
1013	return VINF_SUCCESS;
1014	}
1015
1016	#ifdef VBOX_WITH_GUEST_PROPS
1017	// static
1018	DECLCALLBACK(int)
1019	Console::doGuestPropNotification (void *pvExtension, uint32_t,
1020	void *pvParms, uint32_t cbParms)
1021	{
1022	using namespace guestProp;
1023
1024	LogFlowFunc (("pvExtension=%p, pvParms=%p, cbParms=%u\n", pvExtension, pvParms, cbParms));
1025	int rc = VINF_SUCCESS;
1026	/* No locking, as this is purely a notification which does not make any
1027	* changes to the object state. */
1028	PHOSTCALLBACKDATA pCBData = reinterpret_cast<PHOSTCALLBACKDATA>(pvParms);
1029	AssertReturn(sizeof(HOSTCALLBACKDATA) == cbParms, VERR_INVALID_PARAMETER);
1030	AssertReturn(HOSTCALLBACKMAGIC == pCBData->u32Magic, VERR_INVALID_PARAMETER);
1031	ComObjPtr <Console> pConsole = reinterpret_cast <Console *> (pvExtension);
1032	LogFlowFunc (("pCBData->pcszName=%s, pCBData->pcszValue=%s, pCBData->pcszFlags=%s\n", pCBData->pcszName, pCBData->pcszValue, pCBData->pcszFlags));
1033	Bstr name(pCBData->pcszName);
1034	Bstr value(pCBData->pcszValue);
1035	Bstr flags(pCBData->pcszFlags);
1036	if ( name.isNull()
1037	\|\| (value.isNull() && (pCBData->pcszValue != NULL))
1038	\|\| (flags.isNull() && (pCBData->pcszFlags != NULL))
1039	)
1040	rc = VERR_NO_MEMORY;
1041	else
1042	{
1043	HRESULT hrc = pConsole->mControl->PushGuestProperty(name, value,
1044	pCBData->u64Timestamp,
1045	flags);
1046	if (FAILED (hrc))
1047	{
1048	LogFunc (("pConsole->mControl->PushGuestProperty failed, hrc=0x%x\n", hrc));
1049	LogFunc (("pCBData->pcszName=%s\n", pCBData->pcszName));
1050	LogFunc (("pCBData->pcszValue=%s\n", pCBData->pcszValue));
1051	LogFunc (("pCBData->pcszFlags=%s\n", pCBData->pcszFlags));
1052	rc = VERR_UNRESOLVED_ERROR; /** @todo translate error code */
1053	}
1054	}
1055	LogFlowFunc (("rc=%Rrc\n", rc));
1056	return rc;
1057	}
1058
1059	HRESULT Console::doEnumerateGuestProperties (CBSTR aPatterns,
1060	ComSafeArrayOut(BSTR, aNames),
1061	ComSafeArrayOut(BSTR, aValues),
1062	ComSafeArrayOut(ULONG64, aTimestamps),
1063	ComSafeArrayOut(BSTR, aFlags))
1064	{
1065	using namespace guestProp;
1066
1067	VBOXHGCMSVCPARM parm[3];
1068
1069	Utf8Str utf8Patterns(aPatterns);
1070	parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
1071	parm[0].u.pointer.addr = utf8Patterns.mutableRaw();
1072	parm[0].u.pointer.size = (uint32_t)utf8Patterns.length() + 1;
1073
1074	/*
1075	* Now things get slightly complicated. Due to a race with the guest adding
1076	* properties, there is no good way to know how much to enlarge a buffer for
1077	* the service to enumerate into. We choose a decent starting size and loop a
1078	* few times, each time retrying with the size suggested by the service plus
1079	* one Kb.
1080	*/
1081	size_t cchBuf = 4096;
1082	Utf8Str Utf8Buf;
1083	int vrc = VERR_BUFFER_OVERFLOW;
1084	for (unsigned i = 0; i < 10 && (VERR_BUFFER_OVERFLOW == vrc); ++i)
1085	{
1086	try
1087	{
1088	Utf8Buf.reserve(cchBuf + 1024);
1089	}
1090	catch(...)
1091	{
1092	return E_OUTOFMEMORY;
1093	}
1094	parm[1].type = VBOX_HGCM_SVC_PARM_PTR;
1095	parm[1].u.pointer.addr = Utf8Buf.mutableRaw();
1096	parm[1].u.pointer.size = (uint32_t)cchBuf + 1024;
1097	vrc = mVMMDev->hgcmHostCall ("VBoxGuestPropSvc", ENUM_PROPS_HOST, 3,
1098	&parm[0]);
1099	Utf8Buf.jolt();
1100	if (parm[2].type != VBOX_HGCM_SVC_PARM_32BIT)
1101	return setError (E_FAIL, tr ("Internal application error"));
1102	cchBuf = parm[2].u.uint32;
1103	}
1104	if (VERR_BUFFER_OVERFLOW == vrc)
1105	return setError (E_UNEXPECTED, tr ("Temporary failure due to guest activity, please retry"));
1106
1107	/*
1108	* Finally we have to unpack the data returned by the service into the safe
1109	* arrays supplied by the caller. We start by counting the number of entries.
1110	*/
1111	const char *pszBuf
1112	= reinterpret_cast<const char *>(parm[1].u.pointer.addr);
1113	unsigned cEntries = 0;
1114	/* The list is terminated by a zero-length string at the end of a set
1115	* of four strings. */
1116	for (size_t i = 0; strlen(pszBuf + i) != 0; )
1117	{
1118	/* We are counting sets of four strings. */
1119	for (unsigned j = 0; j < 4; ++j)
1120	i += strlen(pszBuf + i) + 1;
1121	++cEntries;
1122	}
1123
1124	/*
1125	* And now we create the COM safe arrays and fill them in.
1126	*/
1127	com::SafeArray <BSTR> names(cEntries);
1128	com::SafeArray <BSTR> values(cEntries);
1129	com::SafeArray <ULONG64> timestamps(cEntries);
1130	com::SafeArray <BSTR> flags(cEntries);
1131	size_t iBuf = 0;
1132	/* Rely on the service to have formated the data correctly. */
1133	for (unsigned i = 0; i < cEntries; ++i)
1134	{
1135	size_t cchName = strlen(pszBuf + iBuf);
1136	Bstr(pszBuf + iBuf).detachTo(&names[i]);
1137	iBuf += cchName + 1;
1138	size_t cchValue = strlen(pszBuf + iBuf);
1139	Bstr(pszBuf + iBuf).detachTo(&values[i]);
1140	iBuf += cchValue + 1;
1141	size_t cchTimestamp = strlen(pszBuf + iBuf);
1142	timestamps[i] = RTStrToUInt64(pszBuf + iBuf);
1143	iBuf += cchTimestamp + 1;
1144	size_t cchFlags = strlen(pszBuf + iBuf);
1145	Bstr(pszBuf + iBuf).detachTo(&flags[i]);
1146	iBuf += cchFlags + 1;
1147	}
1148	names.detachTo(ComSafeArrayOutArg (aNames));
1149	values.detachTo(ComSafeArrayOutArg (aValues));
1150	timestamps.detachTo(ComSafeArrayOutArg (aTimestamps));
1151	flags.detachTo(ComSafeArrayOutArg (aFlags));
1152	return S_OK;
1153	}
1154	#endif
1155
1156
1157	// IConsole properties
1158	/////////////////////////////////////////////////////////////////////////////
1159
1160	STDMETHODIMP Console::COMGETTER(Machine) (IMachine **aMachine)
1161	{
1162	CheckComArgOutPointerValid(aMachine);
1163
1164	AutoCaller autoCaller (this);
1165	CheckComRCReturnRC (autoCaller.rc());
1166
1167	/* mMachine is constant during life time, no need to lock */
1168	mMachine.queryInterfaceTo (aMachine);
1169
1170	return S_OK;
1171	}
1172
1173	STDMETHODIMP Console::COMGETTER(State) (MachineState_T *aMachineState)
1174	{
1175	CheckComArgOutPointerValid(aMachineState);
1176
1177	AutoCaller autoCaller (this);
1178	CheckComRCReturnRC (autoCaller.rc());
1179
1180	AutoReadLock alock (this);
1181
1182	/* we return our local state (since it's always the same as on the server) */
1183	*aMachineState = mMachineState;
1184
1185	return S_OK;
1186	}
1187
1188	STDMETHODIMP Console::COMGETTER(Guest) (IGuest **aGuest)
1189	{
1190	CheckComArgOutPointerValid(aGuest);
1191
1192	AutoCaller autoCaller (this);
1193	CheckComRCReturnRC (autoCaller.rc());
1194
1195	/* mGuest is constant during life time, no need to lock */
1196	mGuest.queryInterfaceTo (aGuest);
1197
1198	return S_OK;
1199	}
1200
1201	STDMETHODIMP Console::COMGETTER(Keyboard) (IKeyboard **aKeyboard)
1202	{
1203	CheckComArgOutPointerValid(aKeyboard);
1204
1205	AutoCaller autoCaller (this);
1206	CheckComRCReturnRC (autoCaller.rc());
1207
1208	/* mKeyboard is constant during life time, no need to lock */
1209	mKeyboard.queryInterfaceTo (aKeyboard);
1210
1211	return S_OK;
1212	}
1213
1214	STDMETHODIMP Console::COMGETTER(Mouse) (IMouse **aMouse)
1215	{
1216	CheckComArgOutPointerValid(aMouse);
1217
1218	AutoCaller autoCaller (this);
1219	CheckComRCReturnRC (autoCaller.rc());
1220
1221	/* mMouse is constant during life time, no need to lock */
1222	mMouse.queryInterfaceTo (aMouse);
1223
1224	return S_OK;
1225	}
1226
1227	STDMETHODIMP Console::COMGETTER(Display) (IDisplay **aDisplay)
1228	{
1229	CheckComArgOutPointerValid(aDisplay);
1230
1231	AutoCaller autoCaller (this);
1232	CheckComRCReturnRC (autoCaller.rc());
1233
1234	/* mDisplay is constant during life time, no need to lock */
1235	mDisplay.queryInterfaceTo (aDisplay);
1236
1237	return S_OK;
1238	}
1239
1240	STDMETHODIMP Console::COMGETTER(Debugger) (IMachineDebugger **aDebugger)
1241	{
1242	CheckComArgOutPointerValid(aDebugger);
1243
1244	AutoCaller autoCaller (this);
1245	CheckComRCReturnRC (autoCaller.rc());
1246
1247	/* we need a write lock because of the lazy mDebugger initialization*/
1248	AutoWriteLock alock (this);
1249
1250	/* check if we have to create the debugger object */
1251	if (!mDebugger)
1252	{
1253	unconst (mDebugger).createObject();
1254	mDebugger->init (this);
1255	}
1256
1257	mDebugger.queryInterfaceTo (aDebugger);
1258
1259	return S_OK;
1260	}
1261
1262	STDMETHODIMP Console::COMGETTER(USBDevices) (ComSafeArrayOut (IUSBDevice *, aUSBDevices))
1263	{
1264	CheckComArgOutSafeArrayPointerValid(aUSBDevices);
1265
1266	AutoCaller autoCaller (this);
1267	CheckComRCReturnRC (autoCaller.rc());
1268
1269	AutoReadLock alock (this);
1270
1271	SafeIfaceArray <IUSBDevice> collection (mUSBDevices);
1272	collection.detachTo (ComSafeArrayOutArg(aUSBDevices));
1273
1274	return S_OK;
1275	}
1276
1277	STDMETHODIMP Console::COMGETTER(RemoteUSBDevices) (ComSafeArrayOut (IHostUSBDevice *, aRemoteUSBDevices))
1278	{
1279	CheckComArgOutSafeArrayPointerValid(aRemoteUSBDevices);
1280
1281	AutoCaller autoCaller (this);
1282	CheckComRCReturnRC (autoCaller.rc());
1283
1284	AutoReadLock alock (this);
1285
1286	SafeIfaceArray <IHostUSBDevice> collection (mRemoteUSBDevices);
1287	collection.detachTo (ComSafeArrayOutArg(aRemoteUSBDevices));
1288
1289	return S_OK;
1290	}
1291
1292	STDMETHODIMP Console::COMGETTER(RemoteDisplayInfo) (IRemoteDisplayInfo **aRemoteDisplayInfo)
1293	{
1294	CheckComArgOutPointerValid(aRemoteDisplayInfo);
1295
1296	AutoCaller autoCaller (this);
1297	CheckComRCReturnRC (autoCaller.rc());
1298
1299	/* mDisplay is constant during life time, no need to lock */
1300	mRemoteDisplayInfo.queryInterfaceTo (aRemoteDisplayInfo);
1301
1302	return S_OK;
1303	}
1304
1305	STDMETHODIMP
1306	Console::COMGETTER(SharedFolders) (ComSafeArrayOut (ISharedFolder *, aSharedFolders))
1307	{
1308	CheckComArgOutSafeArrayPointerValid(aSharedFolders);
1309
1310	AutoCaller autoCaller (this);
1311	CheckComRCReturnRC (autoCaller.rc());
1312
1313	/* loadDataFromSavedState() needs a write lock */
1314	AutoWriteLock alock (this);
1315
1316	/* Read console data stored in the saved state file (if not yet done) */
1317	HRESULT rc = loadDataFromSavedState();
1318	CheckComRCReturnRC (rc);
1319
1320	SafeIfaceArray <ISharedFolder> sf (mSharedFolders);
1321	sf.detachTo (ComSafeArrayOutArg(aSharedFolders));
1322
1323	return S_OK;
1324	}
1325
1326
1327	// IConsole methods
1328	/////////////////////////////////////////////////////////////////////////////
1329
1330
1331	STDMETHODIMP Console::PowerUp (IProgress **aProgress)
1332	{
1333	return powerUp (aProgress, false /* aPaused */);
1334	}
1335
1336	STDMETHODIMP Console::PowerUpPaused (IProgress **aProgress)
1337	{
1338	return powerUp (aProgress, true /* aPaused */);
1339	}
1340
1341	STDMETHODIMP Console::PowerDown (IProgress **aProgress)
1342	{
1343	if (aProgress == NULL)
1344	return E_POINTER;
1345
1346	LogFlowThisFuncEnter();
1347	LogFlowThisFunc (("mMachineState=%d\n", mMachineState));
1348
1349	AutoCaller autoCaller (this);
1350	CheckComRCReturnRC (autoCaller.rc());
1351
1352	AutoWriteLock alock (this);
1353
1354	if (!Global::IsActive (mMachineState))
1355	{
1356	/* extra nice error message for a common case */
1357	if (mMachineState == MachineState_Saved)
1358	return setError (VBOX_E_INVALID_VM_STATE,
1359	tr ("Cannot power down a saved virtual machine"));
1360	else if (mMachineState == MachineState_Stopping)
1361	return setError (VBOX_E_INVALID_VM_STATE,
1362	tr ("Virtual machine is being powered down."));
1363	else
1364	return setError(VBOX_E_INVALID_VM_STATE,
1365	tr ("Invalid machine state: %d (must be Running, Paused "
1366	"or Stuck)"),
1367	mMachineState);
1368	}
1369
1370	LogFlowThisFunc (("Initiating SHUTDOWN request...\n"));
1371
1372	/* create an IProgress object to track progress of this operation */
1373	ComObjPtr <Progress> progress;
1374	progress.createObject();
1375	progress->init (static_cast <IConsole *> (this),
1376	Bstr (tr ("Stopping virtual machine")),
1377	FALSE /* aCancelable */);
1378
1379	/* setup task object and thread to carry out the operation asynchronously */
1380	std::auto_ptr <VMProgressTask> task (
1381	new VMProgressTask (this, progress, true /* aUsesVMPtr */));
1382	AssertReturn (task->isOk(), E_FAIL);
1383
1384	int vrc = RTThreadCreate (NULL, Console::powerDownThread,
1385	(void *) task.get(), 0,
1386	RTTHREADTYPE_MAIN_WORKER, 0,
1387	"VMPowerDown");
1388	ComAssertMsgRCRet (vrc,
1389	("Could not create VMPowerDown thread (%Rrc)", vrc), E_FAIL);
1390
1391	/* task is now owned by powerDownThread(), so release it */
1392	task.release();
1393
1394	/* go to Stopping state to forbid state-dependant operations */
1395	setMachineState (MachineState_Stopping);
1396
1397	/* pass the progress to the caller */
1398	progress.queryInterfaceTo (aProgress);
1399
1400	LogFlowThisFuncLeave();
1401
1402	return S_OK;
1403	}
1404
1405	STDMETHODIMP Console::Reset()
1406	{
1407	LogFlowThisFuncEnter();
1408	LogFlowThisFunc (("mMachineState=%d\n", mMachineState));
1409
1410	AutoCaller autoCaller (this);
1411	CheckComRCReturnRC (autoCaller.rc());
1412
1413	AutoWriteLock alock (this);
1414
1415	if (mMachineState != MachineState_Running)
1416	return setError (VBOX_E_INVALID_VM_STATE,
1417	tr ("Invalid machine state: %d)"), mMachineState);
1418
1419	/* protect mpVM */
1420	AutoVMCaller autoVMCaller (this);
1421	CheckComRCReturnRC (autoVMCaller.rc());
1422
1423	/* leave the lock before a VMR3* call (EMT will call us back)! */
1424	alock.leave();
1425
1426	int vrc = VMR3Reset (mpVM);
1427
1428	HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
1429	setError (VBOX_E_VM_ERROR, tr ("Could not reset the machine (%Rrc)"), vrc);
1430
1431	LogFlowThisFunc (("mMachineState=%d, rc=%08X\n", mMachineState, rc));
1432	LogFlowThisFuncLeave();
1433	return rc;
1434	}
1435
1436	STDMETHODIMP Console::Pause()
1437	{
1438	LogFlowThisFuncEnter();
1439
1440	AutoCaller autoCaller (this);
1441	CheckComRCReturnRC (autoCaller.rc());
1442
1443	AutoWriteLock alock (this);
1444
1445	if (mMachineState != MachineState_Running)
1446	return setError (VBOX_E_INVALID_VM_STATE,
1447	tr ("Invalid machine state: %d)"), mMachineState);
1448
1449	/* protect mpVM */
1450	AutoVMCaller autoVMCaller (this);
1451	CheckComRCReturnRC (autoVMCaller.rc());
1452
1453	LogFlowThisFunc (("Sending PAUSE request...\n"));
1454
1455	/* leave the lock before a VMR3* call (EMT will call us back)! */
1456	alock.leave();
1457
1458	int vrc = VMR3Suspend (mpVM);
1459
1460	HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
1461	setError (VBOX_E_VM_ERROR,
1462	tr ("Could not suspend the machine execution (%Rrc)"), vrc);
1463
1464	LogFlowThisFunc (("rc=%08X\n", rc));
1465	LogFlowThisFuncLeave();
1466	return rc;
1467	}
1468
1469	STDMETHODIMP Console::Resume()
1470	{
1471	LogFlowThisFuncEnter();
1472
1473	AutoCaller autoCaller (this);
1474	CheckComRCReturnRC (autoCaller.rc());
1475
1476	AutoWriteLock alock (this);
1477
1478	if (mMachineState != MachineState_Paused)
1479	return setError (VBOX_E_INVALID_VM_STATE,
1480	tr ("Cannot resume the machine as it is not paused "
1481	"(machine state: %d)"), mMachineState);
1482
1483	/* protect mpVM */
1484	AutoVMCaller autoVMCaller (this);
1485	CheckComRCReturnRC (autoVMCaller.rc());
1486
1487	LogFlowThisFunc (("Sending RESUME request...\n"));
1488
1489	/* leave the lock before a VMR3* call (EMT will call us back)! */
1490	alock.leave();
1491
1492	int vrc;
1493	if (VMR3GetState(mpVM) == VMSTATE_CREATED)
1494	vrc = VMR3PowerOn (mpVM); /* (PowerUpPaused) */
1495	else
1496	vrc = VMR3Resume (mpVM);
1497
1498	HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
1499	setError (VBOX_E_VM_ERROR,
1500	tr ("Could not resume the machine execution (%Rrc)"), vrc);
1501
1502	LogFlowThisFunc (("rc=%08X\n", rc));
1503	LogFlowThisFuncLeave();
1504	return rc;
1505	}
1506
1507	STDMETHODIMP Console::PowerButton()
1508	{
1509	LogFlowThisFuncEnter();
1510
1511	AutoCaller autoCaller (this);
1512	CheckComRCReturnRC (autoCaller.rc());
1513
1514	AutoWriteLock alock (this);
1515
1516	if (mMachineState != MachineState_Running)
1517	return setError (VBOX_E_INVALID_VM_STATE,
1518	tr ("Invalid machine state: %d)"), mMachineState);
1519
1520	/* protect mpVM */
1521	AutoVMCaller autoVMCaller (this);
1522	CheckComRCReturnRC (autoVMCaller.rc());
1523
1524	PPDMIBASE pBase;
1525	int vrc = PDMR3QueryDeviceLun (mpVM, "acpi", 0, 0, &pBase);
1526	if (VBOX_SUCCESS (vrc))
1527	{
1528	Assert (pBase);
1529	PPDMIACPIPORT pPort =
1530	(PPDMIACPIPORT) pBase->pfnQueryInterface(pBase, PDMINTERFACE_ACPI_PORT);
1531	vrc = pPort ? pPort->pfnPowerButtonPress(pPort) : VERR_INVALID_POINTER;
1532	}
1533
1534	HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
1535	setError (VBOX_E_PDM_ERROR,
1536	tr ("Controlled power off failed (%Rrc)"), vrc);
1537
1538	LogFlowThisFunc (("rc=%08X\n", rc));
1539	LogFlowThisFuncLeave();
1540	return rc;
1541	}
1542
1543	STDMETHODIMP Console::GetPowerButtonHandled(BOOL *aHandled)
1544	{
1545	LogFlowThisFuncEnter();
1546
1547	CheckComArgOutPointerValid(aHandled);
1548
1549	*aHandled = FALSE;
1550
1551	AutoCaller autoCaller (this);
1552
1553	AutoWriteLock alock (this);
1554
1555	if (mMachineState != MachineState_Running)
1556	return setError (VBOX_E_INVALID_VM_STATE,
1557	tr ("Invalid machine state: %d)"), mMachineState);
1558
1559	/* protect mpVM */
1560	AutoVMCaller autoVMCaller (this);
1561	CheckComRCReturnRC (autoVMCaller.rc());
1562
1563	PPDMIBASE pBase;
1564	int vrc = PDMR3QueryDeviceLun (mpVM, "acpi", 0, 0, &pBase);
1565	bool handled = false;
1566	if (VBOX_SUCCESS (vrc))
1567	{
1568	Assert (pBase);
1569	PPDMIACPIPORT pPort =
1570	(PPDMIACPIPORT) pBase->pfnQueryInterface(pBase, PDMINTERFACE_ACPI_PORT);
1571	vrc = pPort ? pPort->pfnGetPowerButtonHandled(pPort, &handled) : VERR_INVALID_POINTER;
1572	}
1573
1574	HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
1575	setError (VBOX_E_PDM_ERROR,
1576	tr ("Checking if the ACPI Power Button event was handled by the "
1577	"guest OS failed (%Rrc)"), vrc);
1578
1579	*aHandled = handled;
1580
1581	LogFlowThisFunc (("rc=%08X\n", rc));
1582	LogFlowThisFuncLeave();
1583	return rc;
1584	}
1585
1586	STDMETHODIMP Console::GetGuestEnteredACPIMode(BOOL *aEntered)
1587	{
1588	LogFlowThisFuncEnter();
1589
1590	CheckComArgOutPointerValid(aEntered);
1591
1592	*aEntered = FALSE;
1593
1594	AutoCaller autoCaller (this);
1595
1596	AutoWriteLock alock (this);
1597
1598	if (mMachineState != MachineState_Running)
1599	return setError (VBOX_E_INVALID_VM_STATE,
1600	tr ("Invalid machine state %d when checking if the guest entered "
1601	"the ACPI mode)"), mMachineState);
1602
1603	/* protect mpVM */
1604	AutoVMCaller autoVMCaller (this);
1605	CheckComRCReturnRC (autoVMCaller.rc());
1606
1607	PPDMIBASE pBase;
1608	int vrc = PDMR3QueryDeviceLun (mpVM, "acpi", 0, 0, &pBase);
1609	bool entered = false;
1610	if (RT_SUCCESS (vrc))
1611	{
1612	Assert (pBase);
1613	PPDMIACPIPORT pPort =
1614	(PPDMIACPIPORT) pBase->pfnQueryInterface(pBase, PDMINTERFACE_ACPI_PORT);
1615	vrc = pPort ? pPort->pfnGetGuestEnteredACPIMode(pPort, &entered) : VERR_INVALID_POINTER;
1616	}
1617
1618	*aEntered = RT_SUCCESS (vrc) ? entered : false;
1619
1620	LogFlowThisFuncLeave();
1621	return S_OK;
1622	}
1623
1624	STDMETHODIMP Console::SleepButton()
1625	{
1626	LogFlowThisFuncEnter();
1627
1628	AutoCaller autoCaller (this);
1629	CheckComRCReturnRC (autoCaller.rc());
1630
1631	AutoWriteLock alock (this);
1632
1633	if (mMachineState != MachineState_Running)
1634	return setError (VBOX_E_INVALID_VM_STATE,
1635	tr ("Invalid machine state: %d)"), mMachineState);
1636
1637	/* protect mpVM */
1638	AutoVMCaller autoVMCaller (this);
1639	CheckComRCReturnRC (autoVMCaller.rc());
1640
1641	PPDMIBASE pBase;
1642	int vrc = PDMR3QueryDeviceLun (mpVM, "acpi", 0, 0, &pBase);
1643	if (VBOX_SUCCESS (vrc))
1644	{
1645	Assert (pBase);
1646	PPDMIACPIPORT pPort =
1647	(PPDMIACPIPORT) pBase->pfnQueryInterface(pBase, PDMINTERFACE_ACPI_PORT);
1648	vrc = pPort ? pPort->pfnSleepButtonPress(pPort) : VERR_INVALID_POINTER;
1649	}
1650
1651	HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
1652	setError (VBOX_E_PDM_ERROR,
1653	tr ("Sending sleep button event failed (%Rrc)"), vrc);
1654
1655	LogFlowThisFunc (("rc=%08X\n", rc));
1656	LogFlowThisFuncLeave();
1657	return rc;
1658	}
1659
1660	STDMETHODIMP Console::SaveState (IProgress **aProgress)
1661	{
1662	LogFlowThisFuncEnter();
1663	LogFlowThisFunc (("mMachineState=%d\n", mMachineState));
1664
1665	CheckComArgOutPointerValid(aProgress);
1666
1667	AutoCaller autoCaller (this);
1668	CheckComRCReturnRC (autoCaller.rc());
1669
1670	AutoWriteLock alock (this);
1671
1672	if (mMachineState != MachineState_Running &&
1673	mMachineState != MachineState_Paused)
1674	{
1675	return setError (VBOX_E_INVALID_VM_STATE,
1676	tr ("Cannot save the execution state as the machine "
1677	"is not running or paused (machine state: %d)"), mMachineState);
1678	}
1679
1680	/* memorize the current machine state */
1681	MachineState_T lastMachineState = mMachineState;
1682
1683	if (mMachineState == MachineState_Running)
1684	{
1685	HRESULT rc = Pause();
1686	CheckComRCReturnRC (rc);
1687	}
1688
1689	HRESULT rc = S_OK;
1690
1691	/* create a progress object to track operation completion */
1692	ComObjPtr <Progress> progress;
1693	progress.createObject();
1694	progress->init (static_cast <IConsole *> (this),
1695	Bstr (tr ("Saving the execution state of the virtual machine")),
1696	FALSE /* aCancelable */);
1697
1698	bool beganSavingState = false;
1699	bool taskCreationFailed = false;
1700
1701	do
1702	{
1703	/* create a task object early to ensure mpVM protection is successful */
1704	std::auto_ptr <VMSaveTask> task (new VMSaveTask (this, progress));
1705	rc = task->rc();
1706	/*
1707	* If we fail here it means a PowerDown() call happened on another
1708	* thread while we were doing Pause() (which leaves the Console lock).
1709	* We assign PowerDown() a higher precedence than SaveState(),
1710	* therefore just return the error to the caller.
1711	*/
1712	if (FAILED (rc))
1713	{
1714	taskCreationFailed = true;
1715	break;
1716	}
1717
1718	Bstr stateFilePath;
1719
1720	/*
1721	* request a saved state file path from the server
1722	* (this will set the machine state to Saving on the server to block
1723	* others from accessing this machine)
1724	*/
1725	rc = mControl->BeginSavingState (progress, stateFilePath.asOutParam());
1726	CheckComRCBreakRC (rc);
1727
1728	beganSavingState = true;
1729
1730	/* sync the state with the server */
1731	setMachineStateLocally (MachineState_Saving);
1732
1733	/* ensure the directory for the saved state file exists */
1734	{
1735	Utf8Str dir = stateFilePath;
1736	dir.stripFilename();
1737	if (!RTDirExists(dir))
1738	{
1739	int vrc = RTDirCreateFullPath (dir, 0777);
1740	if (VBOX_FAILURE (vrc))
1741	{
1742	rc = setError (VBOX_E_FILE_ERROR,
1743	tr ("Could not create a directory '%s' to save the state to (%Rrc)"),
1744	dir.raw(), vrc);
1745	break;
1746	}
1747	}
1748	}
1749
1750	/* setup task object and thread to carry out the operation asynchronously */
1751	task->mIsSnapshot = false;
1752	task->mSavedStateFile = stateFilePath;
1753	/* set the state the operation thread will restore when it is finished */
1754	task->mLastMachineState = lastMachineState;
1755
1756	/* create a thread to wait until the VM state is saved */
1757	int vrc = RTThreadCreate (NULL, Console::saveStateThread, (void *) task.get(),
1758	0, RTTHREADTYPE_MAIN_WORKER, 0, "VMSave");
1759
1760	ComAssertMsgRCBreak (vrc, ("Could not create VMSave thread (%Rrc)", vrc),
1761	rc = E_FAIL);
1762
1763	/* task is now owned by saveStateThread(), so release it */
1764	task.release();
1765
1766	/* return the progress to the caller */
1767	progress.queryInterfaceTo (aProgress);
1768	}
1769	while (0);
1770
1771	if (FAILED (rc) && !taskCreationFailed)
1772	{
1773	/* preserve existing error info */
1774	ErrorInfoKeeper eik;
1775
1776	if (beganSavingState)
1777	{
1778	/*
1779	* cancel the requested save state procedure.
1780	* This will reset the machine state to the state it had right
1781	* before calling mControl->BeginSavingState().
1782	*/
1783	mControl->EndSavingState (FALSE);
1784	}
1785
1786	if (lastMachineState == MachineState_Running)
1787	{
1788	/* restore the paused state if appropriate */
1789	setMachineStateLocally (MachineState_Paused);
1790	/* restore the running state if appropriate */
1791	Resume();
1792	}
1793	else
1794	setMachineStateLocally (lastMachineState);
1795	}
1796
1797	LogFlowThisFunc (("rc=%08X\n", rc));
1798	LogFlowThisFuncLeave();
1799	return rc;
1800	}
1801
1802	STDMETHODIMP Console::AdoptSavedState (IN_BSTR aSavedStateFile)
1803	{
1804	CheckComArgNotNull(aSavedStateFile);
1805
1806	AutoCaller autoCaller (this);
1807	CheckComRCReturnRC (autoCaller.rc());
1808
1809	AutoWriteLock alock (this);
1810
1811	if (mMachineState != MachineState_PoweredOff &&
1812	mMachineState != MachineState_Aborted)
1813	return setError (VBOX_E_INVALID_VM_STATE,
1814	tr ("Cannot adopt the saved machine state as the machine is "
1815	"not in Powered Off or Aborted state (machine state: %d)"),
1816	mMachineState);
1817
1818	return mControl->AdoptSavedState (aSavedStateFile);
1819	}
1820
1821	STDMETHODIMP Console::ForgetSavedState(BOOL aRemove)
1822	{
1823	AutoCaller autoCaller (this);
1824	CheckComRCReturnRC (autoCaller.rc());
1825
1826	AutoWriteLock alock (this);
1827
1828	if (mMachineState != MachineState_Saved)
1829	return setError (VBOX_E_INVALID_VM_STATE,
1830	tr ("Cannot discard the machine state as the machine is "
1831	"not in the saved state (machine state: %d)"),
1832	mMachineState);
1833
1834	HRESULT rc = S_OK;
1835
1836	rc = mControl->SetRemoveSavedState(aRemove);
1837	CheckComRCReturnRC (rc);
1838
1839	/*
1840	* Saved -> PoweredOff transition will be detected in the SessionMachine
1841	* and properly handled.
1842	*/
1843	rc = setMachineState (MachineState_PoweredOff);
1844
1845	return rc;
1846	}
1847
1848	/** read the value of a LEd. */
1849	inline uint32_t readAndClearLed(PPDMLED pLed)
1850	{
1851	if (!pLed)
1852	return 0;
1853	uint32_t u32 = pLed->Actual.u32 \| pLed->Asserted.u32;
1854	pLed->Asserted.u32 = 0;
1855	return u32;
1856	}
1857
1858	STDMETHODIMP Console::GetDeviceActivity (DeviceType_T aDeviceType,
1859	DeviceActivity_T *aDeviceActivity)
1860	{
1861	CheckComArgNotNull(aDeviceActivity);
1862
1863	AutoCaller autoCaller (this);
1864	CheckComRCReturnRC (autoCaller.rc());
1865
1866	/*
1867	* Note: we don't lock the console object here because
1868	* readAndClearLed() should be thread safe.
1869	*/
1870
1871	/* Get LED array to read */
1872	PDMLEDCORE SumLed = {0};
1873	switch (aDeviceType)
1874	{
1875	case DeviceType_Floppy:
1876	{
1877	for (unsigned i = 0; i < RT_ELEMENTS(mapFDLeds); i++)
1878	SumLed.u32 \|= readAndClearLed(mapFDLeds[i]);
1879	break;
1880	}
1881
1882	case DeviceType_DVD:
1883	{
1884	SumLed.u32 \|= readAndClearLed(mapIDELeds[2]);
1885	break;
1886	}
1887
1888	case DeviceType_HardDisk:
1889	{
1890	SumLed.u32 \|= readAndClearLed(mapIDELeds[0]);
1891	SumLed.u32 \|= readAndClearLed(mapIDELeds[1]);
1892	SumLed.u32 \|= readAndClearLed(mapIDELeds[3]);
1893	for (unsigned i = 0; i < RT_ELEMENTS(mapSATALeds); i++)
1894	SumLed.u32 \|= readAndClearLed(mapSATALeds[i]);
1895	for (unsigned i = 0; i < RT_ELEMENTS(mapSCSILeds); i++)
1896	SumLed.u32 \|= readAndClearLed(mapSCSILeds[i]);
1897	break;
1898	}
1899
1900	case DeviceType_Network:
1901	{
1902	for (unsigned i = 0; i < RT_ELEMENTS(mapNetworkLeds); i++)
1903	SumLed.u32 \|= readAndClearLed(mapNetworkLeds[i]);
1904	break;
1905	}
1906
1907	case DeviceType_USB:
1908	{
1909	for (unsigned i = 0; i < RT_ELEMENTS(mapUSBLed); i++)
1910	SumLed.u32 \|= readAndClearLed(mapUSBLed[i]);
1911	break;
1912	}
1913
1914	case DeviceType_SharedFolder:
1915	{
1916	SumLed.u32 \|= readAndClearLed(mapSharedFolderLed);
1917	break;
1918	}
1919
1920	default:
1921	return setError (E_INVALIDARG,
1922	tr ("Invalid device type: %d"), aDeviceType);
1923	}
1924
1925	/* Compose the result */
1926	switch (SumLed.u32 & (PDMLED_READING \| PDMLED_WRITING))
1927	{
1928	case 0:
1929	*aDeviceActivity = DeviceActivity_Idle;
1930	break;
1931	case PDMLED_READING:
1932	*aDeviceActivity = DeviceActivity_Reading;
1933	break;
1934	case PDMLED_WRITING:
1935	case PDMLED_READING \| PDMLED_WRITING:
1936	*aDeviceActivity = DeviceActivity_Writing;
1937	break;
1938	}
1939
1940	return S_OK;
1941	}
1942
1943	STDMETHODIMP Console::AttachUSBDevice (IN_BSTR aId)
1944	{
1945	#ifdef VBOX_WITH_USB
1946	AutoCaller autoCaller (this);
1947	CheckComRCReturnRC (autoCaller.rc());
1948
1949	AutoWriteLock alock (this);
1950
1951	if (mMachineState != MachineState_Running &&
1952	mMachineState != MachineState_Paused)
1953	return setError (VBOX_E_INVALID_VM_STATE,
1954	tr ("Cannot attach a USB device to the machine which is not "
1955	"running or paused (machine state: %d)"), mMachineState);
1956
1957	/* protect mpVM */
1958	AutoVMCaller autoVMCaller (this);
1959	CheckComRCReturnRC (autoVMCaller.rc());
1960
1961	/* Don't proceed unless we've found the usb controller. */
1962	PPDMIBASE pBase = NULL;
1963	int vrc = PDMR3QueryLun (mpVM, "usb-ohci", 0, 0, &pBase);
1964	if (VBOX_FAILURE (vrc))
1965	return setError (VBOX_E_PDM_ERROR,
1966	tr ("The virtual machine does not have a USB controller"));
1967
1968	/* leave the lock because the USB Proxy service may call us back
1969	* (via onUSBDeviceAttach()) */
1970	alock.leave();
1971
1972	/* Request the device capture */
1973	HRESULT rc = mControl->CaptureUSBDevice (aId);
1974	CheckComRCReturnRC (rc);
1975
1976	return rc;
1977
1978	#else /* !VBOX_WITH_USB */
1979	return setError (VBOX_E_PDM_ERROR,
1980	tr ("The virtual machine does not have a USB controller"));
1981	#endif /* !VBOX_WITH_USB */
1982	}
1983
1984	STDMETHODIMP Console::DetachUSBDevice (IN_BSTR aId, IUSBDevice **aDevice)
1985	{
1986	#ifdef VBOX_WITH_USB
1987	CheckComArgOutPointerValid(aDevice);
1988
1989	AutoCaller autoCaller (this);
1990	CheckComRCReturnRC (autoCaller.rc());
1991
1992	AutoWriteLock alock (this);
1993
1994	/* Find it. */
1995	ComObjPtr <OUSBDevice> device;
1996	USBDeviceList::iterator it = mUSBDevices.begin();
1997	Guid uuid(aId);
1998	while (it != mUSBDevices.end())
1999	{
2000	if ((*it)->id() == uuid)
2001	{
2002	device = *it;
2003	break;
2004	}
2005	++ it;
2006	}
2007
2008	if (!device)
2009	return setError (E_INVALIDARG,
2010	tr ("USB device with UUID {%RTuuid} is not attached to this machine"),
2011	Guid (aId).raw());
2012
2013	/*
2014	* Inform the USB device and USB proxy about what's cooking.
2015	*/
2016	alock.leave();
2017	HRESULT rc2 = mControl->DetachUSBDevice (aId, false /* aDone */);
2018	if (FAILED (rc2))
2019	return rc2;
2020	alock.enter();
2021
2022	/* Request the PDM to detach the USB device. */
2023	HRESULT rc = detachUSBDevice (it);
2024
2025	if (SUCCEEDED (rc))
2026	{
2027	/* leave the lock since we don't need it any more (note though that
2028	* the USB Proxy service must not call us back here) */
2029	alock.leave();
2030
2031	/* Request the device release. Even if it fails, the device will
2032	* remain as held by proxy, which is OK for us (the VM process). */
2033	rc = mControl->DetachUSBDevice (aId, true /* aDone */);
2034	}
2035
2036	return rc;
2037
2038
2039	#else /* !VBOX_WITH_USB */
2040	return setError (VBOX_E_PDM_ERROR,
2041	tr ("The virtual machine does not have a USB controller"));
2042	#endif /* !VBOX_WITH_USB */
2043	}
2044
2045	STDMETHODIMP Console::FindUSBDeviceByAddress(IN_BSTR aAddress, IUSBDevice **aDevice)
2046	{
2047	#ifdef VBOX_WITH_USB
2048	CheckComArgNotNull(aAddress);
2049	CheckComArgOutPointerValid(aDevice);
2050
2051	*aDevice = NULL;
2052
2053	SafeIfaceArray <IUSBDevice> devsvec;
2054	HRESULT rc = COMGETTER(USBDevices) (ComSafeArrayAsOutParam(devsvec));
2055	CheckComRCReturnRC (rc);
2056
2057	for (size_t i = 0; i < devsvec.size(); ++i)
2058	{
2059	Bstr address;
2060	rc = devsvec[i]->COMGETTER(Address) (address.asOutParam());
2061	CheckComRCReturnRC (rc);
2062	if (address == aAddress)
2063	{
2064	ComObjPtr<OUSBDevice> found;
2065	found.createObject();
2066	found->init (devsvec[i]);
2067	return found.queryInterfaceTo (aDevice);
2068	}
2069	}
2070
2071	return setErrorNoLog (VBOX_E_OBJECT_NOT_FOUND, tr (
2072	"Could not find a USB device with address '%ls'"),
2073	aAddress);
2074
2075	#else /* !VBOX_WITH_USB */
2076	return E_NOTIMPL;
2077	#endif /* !VBOX_WITH_USB */
2078	}
2079
2080	STDMETHODIMP Console::FindUSBDeviceById(IN_BSTR aId, IUSBDevice **aDevice)
2081	{
2082	#ifdef VBOX_WITH_USB
2083	CheckComArgExpr(aId, Guid (aId).isEmpty() == false);
2084	CheckComArgOutPointerValid(aDevice);
2085
2086	*aDevice = NULL;
2087
2088	SafeIfaceArray <IUSBDevice> devsvec;
2089	HRESULT rc = COMGETTER(USBDevices) (ComSafeArrayAsOutParam(devsvec));
2090	CheckComRCReturnRC (rc);
2091
2092	for (size_t i = 0; i < devsvec.size(); ++i)
2093	{
2094	Bstr id;
2095	rc = devsvec[i]->COMGETTER(Id) (id.asOutParam());
2096	CheckComRCReturnRC (rc);
2097	if (id == aId)
2098	{
2099	ComObjPtr<OUSBDevice> found;
2100	found.createObject();
2101	found->init(devsvec[i]);
2102	return found.queryInterfaceTo (aDevice);
2103	}
2104	}
2105
2106	return setErrorNoLog (VBOX_E_OBJECT_NOT_FOUND, tr (
2107	"Could not find a USB device with uuid {%RTuuid}"),
2108	Guid (aId).raw());
2109
2110	#else /* !VBOX_WITH_USB */
2111	return E_NOTIMPL;
2112	#endif /* !VBOX_WITH_USB */
2113	}
2114
2115	STDMETHODIMP
2116	Console::CreateSharedFolder (IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable)
2117	{
2118	CheckComArgNotNull(aName);
2119	CheckComArgNotNull(aHostPath);
2120
2121	AutoCaller autoCaller (this);
2122	CheckComRCReturnRC (autoCaller.rc());
2123
2124	AutoWriteLock alock (this);
2125
2126	/// @todo see @todo in AttachUSBDevice() about the Paused state
2127	if (mMachineState == MachineState_Saved)
2128	return setError (VBOX_E_INVALID_VM_STATE,
2129	tr ("Cannot create a transient shared folder on the "
2130	"machine in the saved state"));
2131	if (mMachineState > MachineState_Paused)
2132	return setError (VBOX_E_INVALID_VM_STATE,
2133	tr ("Cannot create a transient shared folder on the "
2134	"machine while it is changing the state (machine state: %d)"),
2135	mMachineState);
2136
2137	ComObjPtr <SharedFolder> sharedFolder;
2138	HRESULT rc = findSharedFolder (aName, sharedFolder, false /* aSetError */);
2139	if (SUCCEEDED (rc))
2140	return setError (VBOX_E_FILE_ERROR,
2141	tr ("Shared folder named '%ls' already exists"), aName);
2142
2143	sharedFolder.createObject();
2144	rc = sharedFolder->init (this, aName, aHostPath, aWritable);
2145	CheckComRCReturnRC (rc);
2146
2147	/* protect mpVM (if not NULL) */
2148	AutoVMCallerQuietWeak autoVMCaller (this);
2149
2150	if (mpVM && autoVMCaller.isOk() && mVMMDev->isShFlActive())
2151	{
2152	/* If the VM is online and supports shared folders, share this folder
2153	* under the specified name. */
2154
2155	/* first, remove the machine or the global folder if there is any */
2156	SharedFolderDataMap::const_iterator it;
2157	if (findOtherSharedFolder (aName, it))
2158	{
2159	rc = removeSharedFolder (aName);
2160	CheckComRCReturnRC (rc);
2161	}
2162
2163	/* second, create the given folder */
2164	rc = createSharedFolder (aName, SharedFolderData (aHostPath, aWritable));
2165	CheckComRCReturnRC (rc);
2166	}
2167
2168	mSharedFolders.insert (std::make_pair (aName, sharedFolder));
2169
2170	/* notify console callbacks after the folder is added to the list */
2171	{
2172	CallbackList::iterator it = mCallbacks.begin();
2173	while (it != mCallbacks.end())
2174	(*it++)->OnSharedFolderChange (Scope_Session);
2175	}
2176
2177	return rc;
2178	}
2179
2180	STDMETHODIMP Console::RemoveSharedFolder (IN_BSTR aName)
2181	{
2182	CheckComArgNotNull(aName);
2183
2184	AutoCaller autoCaller (this);
2185	CheckComRCReturnRC (autoCaller.rc());
2186
2187	AutoWriteLock alock (this);
2188
2189	/// @todo see @todo in AttachUSBDevice() about the Paused state
2190	if (mMachineState == MachineState_Saved)
2191	return setError (VBOX_E_INVALID_VM_STATE,
2192	tr ("Cannot remove a transient shared folder from the "
2193	"machine in the saved state"));
2194	if (mMachineState > MachineState_Paused)
2195	return setError (VBOX_E_INVALID_VM_STATE,
2196	tr ("Cannot remove a transient shared folder from the "
2197	"machine while it is changing the state (machine state: %d)"),
2198	mMachineState);
2199
2200	ComObjPtr <SharedFolder> sharedFolder;
2201	HRESULT rc = findSharedFolder (aName, sharedFolder, true /* aSetError */);
2202	CheckComRCReturnRC (rc);
2203
2204	/* protect mpVM (if not NULL) */
2205	AutoVMCallerQuietWeak autoVMCaller (this);
2206
2207	if (mpVM && autoVMCaller.isOk() && mVMMDev->isShFlActive())
2208	{
2209	/* if the VM is online and supports shared folders, UNshare this
2210	* folder. */
2211
2212	/* first, remove the given folder */
2213	rc = removeSharedFolder (aName);
2214	CheckComRCReturnRC (rc);
2215
2216	/* first, remove the machine or the global folder if there is any */
2217	SharedFolderDataMap::const_iterator it;
2218	if (findOtherSharedFolder (aName, it))
2219	{
2220	rc = createSharedFolder (aName, it->second);
2221	/* don't check rc here because we need to remove the console
2222	* folder from the collection even on failure */
2223	}
2224	}
2225
2226	mSharedFolders.erase (aName);
2227
2228	/* notify console callbacks after the folder is removed to the list */
2229	{
2230	CallbackList::iterator it = mCallbacks.begin();
2231	while (it != mCallbacks.end())
2232	(*it++)->OnSharedFolderChange (Scope_Session);
2233	}
2234
2235	return rc;
2236	}
2237
2238	STDMETHODIMP Console::TakeSnapshot (IN_BSTR aName, IN_BSTR aDescription,
2239	IProgress **aProgress)
2240	{
2241	LogFlowThisFuncEnter();
2242	LogFlowThisFunc (("aName='%ls' mMachineState=%08X\n", aName, mMachineState));
2243
2244	CheckComArgNotNull(aName);
2245	CheckComArgOutPointerValid(aProgress);
2246
2247	AutoCaller autoCaller (this);
2248	CheckComRCReturnRC (autoCaller.rc());
2249
2250	AutoWriteLock alock (this);
2251
2252	if (Global::IsTransient (mMachineState))
2253	{
2254	return setError (VBOX_E_INVALID_VM_STATE,
2255	tr ("Cannot take a snapshot of the machine "
2256	"while it is changing the state (machine state: %d)"),
2257	mMachineState);
2258	}
2259
2260	/* memorize the current machine state */
2261	MachineState_T lastMachineState = mMachineState;
2262
2263	if (mMachineState == MachineState_Running)
2264	{
2265	HRESULT rc = Pause();
2266	CheckComRCReturnRC (rc);
2267	}
2268
2269	HRESULT rc = S_OK;
2270
2271	bool takingSnapshotOnline = mMachineState == MachineState_Paused;
2272
2273	/*
2274	* create a descriptionless VM-side progress object
2275	* (only when creating a snapshot online)
2276	*/
2277	ComObjPtr <Progress> saveProgress;
2278	if (takingSnapshotOnline)
2279	{
2280	saveProgress.createObject();
2281	rc = saveProgress->init (FALSE, 1, Bstr (tr ("Saving the execution state")));
2282	AssertComRCReturn (rc, rc);
2283	}
2284
2285	bool beganTakingSnapshot = false;
2286	bool taskCreationFailed = false;
2287
2288	do
2289	{
2290	/* create a task object early to ensure mpVM protection is successful */
2291	std::auto_ptr <VMSaveTask> task;
2292	if (takingSnapshotOnline)
2293	{
2294	task.reset (new VMSaveTask (this, saveProgress));
2295	rc = task->rc();
2296	/*
2297	* If we fail here it means a PowerDown() call happened on another
2298	* thread while we were doing Pause() (which leaves the Console lock).
2299	* We assign PowerDown() a higher precedence than TakeSnapshot(),
2300	* therefore just return the error to the caller.
2301	*/
2302	if (FAILED (rc))
2303	{
2304	taskCreationFailed = true;
2305	break;
2306	}
2307	}
2308
2309	Bstr stateFilePath;
2310	ComPtr <IProgress> serverProgress;
2311
2312	/*
2313	* request taking a new snapshot object on the server
2314	* (this will set the machine state to Saving on the server to block
2315	* others from accessing this machine)
2316	*/
2317	rc = mControl->BeginTakingSnapshot (this, aName, aDescription,
2318	saveProgress, stateFilePath.asOutParam(),
2319	serverProgress.asOutParam());
2320	if (FAILED (rc))
2321	break;
2322
2323	/*
2324	* state file is non-null only when the VM is paused
2325	* (i.e. creating a snapshot online)
2326	*/
2327	ComAssertBreak (
2328	(!stateFilePath.isNull() && takingSnapshotOnline) \|\|
2329	(stateFilePath.isNull() && !takingSnapshotOnline),
2330	rc = E_FAIL);
2331
2332	beganTakingSnapshot = true;
2333
2334	/* sync the state with the server */
2335	setMachineStateLocally (MachineState_Saving);
2336
2337	/*
2338	* create a combined VM-side progress object and start the save task
2339	* (only when creating a snapshot online)
2340	*/
2341	ComObjPtr <CombinedProgress> combinedProgress;
2342	if (takingSnapshotOnline)
2343	{
2344	combinedProgress.createObject();
2345	rc = combinedProgress->init (static_cast <IConsole *> (this),
2346	Bstr (tr ("Taking snapshot of virtual machine")),
2347	serverProgress, saveProgress);
2348	AssertComRCBreakRC (rc);
2349
2350	/* setup task object and thread to carry out the operation asynchronously */
2351	task->mIsSnapshot = true;
2352	task->mSavedStateFile = stateFilePath;
2353	task->mServerProgress = serverProgress;
2354	/* set the state the operation thread will restore when it is finished */
2355	task->mLastMachineState = lastMachineState;
2356
2357	/* create a thread to wait until the VM state is saved */
2358	int vrc = RTThreadCreate (NULL, Console::saveStateThread, (void *) task.get(),
2359	0, RTTHREADTYPE_MAIN_WORKER, 0, "VMTakeSnap");
2360
2361	ComAssertMsgRCBreak (vrc, ("Could not create VMTakeSnap thread (%Rrc)", vrc),
2362	rc = E_FAIL);
2363
2364	/* task is now owned by saveStateThread(), so release it */
2365	task.release();
2366	}
2367
2368	if (SUCCEEDED (rc))
2369	{
2370	/* return the correct progress to the caller */
2371	if (combinedProgress)
2372	combinedProgress.queryInterfaceTo (aProgress);
2373	else
2374	serverProgress.queryInterfaceTo (aProgress);
2375	}
2376	}
2377	while (0);
2378
2379	if (FAILED (rc) && !taskCreationFailed)
2380	{
2381	/* preserve existing error info */
2382	ErrorInfoKeeper eik;
2383
2384	if (beganTakingSnapshot && takingSnapshotOnline)
2385	{
2386	/*
2387	* cancel the requested snapshot (only when creating a snapshot
2388	* online, otherwise the server will cancel the snapshot itself).
2389	* This will reset the machine state to the state it had right
2390	* before calling mControl->BeginTakingSnapshot().
2391	*/
2392	mControl->EndTakingSnapshot (FALSE);
2393	}
2394
2395	if (lastMachineState == MachineState_Running)
2396	{
2397	/* restore the paused state if appropriate */
2398	setMachineStateLocally (MachineState_Paused);
2399	/* restore the running state if appropriate */
2400	Resume();
2401	}
2402	else
2403	setMachineStateLocally (lastMachineState);
2404	}
2405
2406	LogFlowThisFunc (("rc=%08X\n", rc));
2407	LogFlowThisFuncLeave();
2408	return rc;
2409	}
2410
2411	STDMETHODIMP Console::DiscardSnapshot (IN_BSTR aId, IProgress **aProgress)
2412	{
2413	CheckComArgExpr(aId, Guid (aId).isEmpty() == false);
2414	CheckComArgOutPointerValid(aProgress);
2415
2416	AutoCaller autoCaller (this);
2417	CheckComRCReturnRC (autoCaller.rc());
2418
2419	AutoWriteLock alock (this);
2420
2421	if (Global::IsOnlineOrTransient (mMachineState))
2422	return setError (VBOX_E_INVALID_VM_STATE,
2423	tr ("Cannot discard a snapshot of the running machine "
2424	"(machine state: %d)"),
2425	mMachineState);
2426
2427	MachineState_T machineState = MachineState_Null;
2428	HRESULT rc = mControl->DiscardSnapshot (this, aId, &machineState, aProgress);
2429	CheckComRCReturnRC (rc);
2430
2431	setMachineStateLocally (machineState);
2432	return S_OK;
2433	}
2434
2435	STDMETHODIMP Console::DiscardCurrentState (IProgress **aProgress)
2436	{
2437	AutoCaller autoCaller (this);
2438	CheckComRCReturnRC (autoCaller.rc());
2439
2440	AutoWriteLock alock (this);
2441
2442	if (Global::IsOnlineOrTransient (mMachineState))
2443	return setError (VBOX_E_INVALID_VM_STATE,
2444	tr ("Cannot discard the current state of the running machine "
2445	"(nachine state: %d)"),
2446	mMachineState);
2447
2448	MachineState_T machineState = MachineState_Null;
2449	HRESULT rc = mControl->DiscardCurrentState (this, &machineState, aProgress);
2450	CheckComRCReturnRC (rc);
2451
2452	setMachineStateLocally (machineState);
2453	return S_OK;
2454	}
2455
2456	STDMETHODIMP Console::DiscardCurrentSnapshotAndState (IProgress **aProgress)
2457	{
2458	AutoCaller autoCaller (this);
2459	CheckComRCReturnRC (autoCaller.rc());
2460
2461	AutoWriteLock alock (this);
2462
2463	if (Global::IsOnlineOrTransient (mMachineState))
2464	return setError (VBOX_E_INVALID_VM_STATE,
2465	tr ("Cannot discard the current snapshot and state of the "
2466	"running machine (machine state: %d)"),
2467	mMachineState);
2468
2469	MachineState_T machineState = MachineState_Null;
2470	HRESULT rc =
2471	mControl->DiscardCurrentSnapshotAndState (this, &machineState, aProgress);
2472	CheckComRCReturnRC (rc);
2473
2474	setMachineStateLocally (machineState);
2475	return S_OK;
2476	}
2477
2478	STDMETHODIMP Console::RegisterCallback (IConsoleCallback *aCallback)
2479	{
2480	CheckComArgNotNull(aCallback);
2481
2482	AutoCaller autoCaller (this);
2483	CheckComRCReturnRC (autoCaller.rc());
2484
2485	#if 0 /** @todo r=bird,r=pritesh: must check that the interface id match correct or we might screw up with old code! */
2486	void *dummy;
2487	HRESULT hrc = aCallback->QueryInterface(NS_GET_IID(IConsoleCallback), &dummy);
2488	if (FAILED(hrc))
2489	return hrc;
2490	aCallback->Release();
2491	#endif
2492
2493	AutoWriteLock alock (this);
2494
2495	mCallbacks.push_back (CallbackList::value_type (aCallback));
2496
2497	/* Inform the callback about the current status (for example, the new
2498	* callback must know the current mouse capabilities and the pointer
2499	* shape in order to properly integrate the mouse pointer). */
2500
2501	if (mCallbackData.mpsc.valid)
2502	aCallback->OnMousePointerShapeChange (mCallbackData.mpsc.visible,
2503	mCallbackData.mpsc.alpha,
2504	mCallbackData.mpsc.xHot,
2505	mCallbackData.mpsc.yHot,
2506	mCallbackData.mpsc.width,
2507	mCallbackData.mpsc.height,
2508	mCallbackData.mpsc.shape);
2509	if (mCallbackData.mcc.valid)
2510	aCallback->OnMouseCapabilityChange (mCallbackData.mcc.supportsAbsolute,
2511	mCallbackData.mcc.needsHostCursor);
2512
2513	aCallback->OnAdditionsStateChange();
2514
2515	if (mCallbackData.klc.valid)
2516	aCallback->OnKeyboardLedsChange (mCallbackData.klc.numLock,
2517	mCallbackData.klc.capsLock,
2518	mCallbackData.klc.scrollLock);
2519
2520	/* Note: we don't call OnStateChange for new callbacks because the
2521	* machine state is a) not actually changed on callback registration
2522	* and b) can be always queried from Console. */
2523
2524	return S_OK;
2525	}
2526
2527	STDMETHODIMP Console::UnregisterCallback (IConsoleCallback *aCallback)
2528	{
2529	CheckComArgNotNull(aCallback);
2530
2531	AutoCaller autoCaller (this);
2532	CheckComRCReturnRC (autoCaller.rc());
2533
2534	AutoWriteLock alock (this);
2535
2536	CallbackList::iterator it;
2537	it = std::find (mCallbacks.begin(),
2538	mCallbacks.end(),
2539	CallbackList::value_type (aCallback));
2540	if (it == mCallbacks.end())
2541	return setError (E_INVALIDARG,
2542	tr ("The given callback handler is not registered"));
2543
2544	mCallbacks.erase (it);
2545	return S_OK;
2546	}
2547
2548	// Non-interface public methods
2549	/////////////////////////////////////////////////////////////////////////////
2550
2551	/**
2552	* Called by IInternalSessionControl::OnDVDDriveChange().
2553	*
2554	* @note Locks this object for writing.
2555	*/
2556	HRESULT Console::onDVDDriveChange()
2557	{
2558	LogFlowThisFuncEnter();
2559
2560	AutoCaller autoCaller (this);
2561	AssertComRCReturnRC (autoCaller.rc());
2562
2563	/* doDriveChange() needs a write lock */
2564	AutoWriteLock alock (this);
2565
2566	/* Ignore callbacks when there's no VM around */
2567	if (!mpVM)
2568	return S_OK;
2569
2570	/* protect mpVM */
2571	AutoVMCaller autoVMCaller (this);
2572	CheckComRCReturnRC (autoVMCaller.rc());
2573
2574	/* Get the current DVD state */
2575	HRESULT rc;
2576	DriveState_T eState;
2577
2578	rc = mDVDDrive->COMGETTER (State) (&eState);
2579	ComAssertComRCRetRC (rc);
2580
2581	/* Paranoia */
2582	if ( eState == DriveState_NotMounted
2583	&& meDVDState == DriveState_NotMounted)
2584	{
2585	LogFlowThisFunc (("Returns (NotMounted -> NotMounted)\n"));
2586	return S_OK;
2587	}
2588
2589	/* Get the path string and other relevant properties */
2590	Bstr Path;
2591	bool fPassthrough = false;
2592	switch (eState)
2593	{
2594	case DriveState_ImageMounted:
2595	{
2596	ComPtr <IDVDImage> ImagePtr;
2597	rc = mDVDDrive->GetImage (ImagePtr.asOutParam());
2598	if (SUCCEEDED (rc))
2599	rc = ImagePtr->COMGETTER(Location) (Path.asOutParam());
2600	break;
2601	}
2602
2603	case DriveState_HostDriveCaptured:
2604	{
2605	ComPtr <IHostDVDDrive> DrivePtr;
2606	BOOL enabled;
2607	rc = mDVDDrive->GetHostDrive (DrivePtr.asOutParam());
2608	if (SUCCEEDED (rc))
2609	rc = DrivePtr->COMGETTER (Name) (Path.asOutParam());
2610	if (SUCCEEDED (rc))
2611	rc = mDVDDrive->COMGETTER (Passthrough) (&enabled);
2612	if (SUCCEEDED (rc))
2613	fPassthrough = !!enabled;
2614	break;
2615	}
2616
2617	case DriveState_NotMounted:
2618	break;
2619
2620	default:
2621	AssertMsgFailed (("Invalid DriveState: %d\n", eState));
2622	rc = E_FAIL;
2623	break;
2624	}
2625
2626	AssertComRC (rc);
2627	if (SUCCEEDED (rc))
2628	{
2629	rc = doDriveChange ("piix3ide", 0, 2, eState, &meDVDState,
2630	Utf8Str (Path).raw(), fPassthrough);
2631
2632	/* notify console callbacks on success */
2633	if (SUCCEEDED (rc))
2634	{
2635	CallbackList::iterator it = mCallbacks.begin();
2636	while (it != mCallbacks.end())
2637	(*it++)->OnDVDDriveChange();
2638	}
2639	}
2640
2641	LogFlowThisFunc (("Returns %Rhrc (%#x)\n", rc, rc));
2642	LogFlowThisFuncLeave();
2643	return rc;
2644	}
2645
2646
2647	/**
2648	* Called by IInternalSessionControl::OnFloppyDriveChange().
2649	*
2650	* @note Locks this object for writing.
2651	*/
2652	HRESULT Console::onFloppyDriveChange()
2653	{
2654	LogFlowThisFuncEnter();
2655
2656	AutoCaller autoCaller (this);
2657	AssertComRCReturnRC (autoCaller.rc());
2658
2659	/* doDriveChange() needs a write lock */
2660	AutoWriteLock alock (this);
2661
2662	/* Ignore callbacks when there's no VM around */
2663	if (!mpVM)
2664	return S_OK;
2665
2666	/* protect mpVM */
2667	AutoVMCaller autoVMCaller (this);
2668	CheckComRCReturnRC (autoVMCaller.rc());
2669
2670	/* Get the current floppy state */
2671	HRESULT rc;
2672	DriveState_T eState;
2673
2674	/* If the floppy drive is disabled, we're not interested */
2675	BOOL fEnabled;
2676	rc = mFloppyDrive->COMGETTER (Enabled) (&fEnabled);
2677	ComAssertComRCRetRC (rc);
2678
2679	if (!fEnabled)
2680	return S_OK;
2681
2682	rc = mFloppyDrive->COMGETTER (State) (&eState);
2683	ComAssertComRCRetRC (rc);
2684
2685	Log2 (("onFloppyDriveChange: eState=%d meFloppyState=%d\n", eState, meFloppyState));
2686
2687
2688	/* Paranoia */
2689	if ( eState == DriveState_NotMounted
2690	&& meFloppyState == DriveState_NotMounted)
2691	{
2692	LogFlowThisFunc (("Returns (NotMounted -> NotMounted)\n"));
2693	return S_OK;
2694	}
2695
2696	/* Get the path string and other relevant properties */
2697	Bstr Path;
2698	switch (eState)
2699	{
2700	case DriveState_ImageMounted:
2701	{
2702	ComPtr<IFloppyImage> ImagePtr;
2703	rc = mFloppyDrive->GetImage (ImagePtr.asOutParam());
2704	if (SUCCEEDED (rc))
2705	rc = ImagePtr->COMGETTER(Location) (Path.asOutParam());
2706	break;
2707	}
2708
2709	case DriveState_HostDriveCaptured:
2710	{
2711	ComPtr <IHostFloppyDrive> DrivePtr;
2712	rc = mFloppyDrive->GetHostDrive (DrivePtr.asOutParam());
2713	if (SUCCEEDED (rc))
2714	rc = DrivePtr->COMGETTER (Name) (Path.asOutParam());
2715	break;
2716	}
2717
2718	case DriveState_NotMounted:
2719	break;
2720
2721	default:
2722	AssertMsgFailed (("Invalid DriveState: %d\n", eState));
2723	rc = E_FAIL;
2724	break;
2725	}
2726
2727	AssertComRC (rc);
2728	if (SUCCEEDED (rc))
2729	{
2730	rc = doDriveChange ("i82078", 0, 0, eState, &meFloppyState,
2731	Utf8Str (Path).raw(), false);
2732
2733	/* notify console callbacks on success */
2734	if (SUCCEEDED (rc))
2735	{
2736	CallbackList::iterator it = mCallbacks.begin();
2737	while (it != mCallbacks.end())
2738	(*it++)->OnFloppyDriveChange();
2739	}
2740	}
2741
2742	LogFlowThisFunc (("Returns %Rhrc (%#x)\n", rc, rc));
2743	LogFlowThisFuncLeave();
2744	return rc;
2745	}
2746
2747
2748	/**
2749	* Process a floppy or dvd change.
2750	*
2751	* @returns COM status code.
2752	*
2753	* @param pszDevice The PDM device name.
2754	* @param uInstance The PDM device instance.
2755	* @param uLun The PDM LUN number of the drive.
2756	* @param eState The new state.
2757	* @param peState Pointer to the variable keeping the actual state of the drive.
2758	* This will be both read and updated to eState or other appropriate state.
2759	* @param pszPath The path to the media / drive which is now being mounted / captured.
2760	* If NULL no media or drive is attached and the LUN will be configured with
2761	* the default block driver with no media. This will also be the state if
2762	* mounting / capturing the specified media / drive fails.
2763	* @param fPassthrough Enables using passthrough mode of the host DVD drive if applicable.
2764	*
2765	* @note Locks this object for writing.
2766	*/
2767	HRESULT Console::doDriveChange (const char *pszDevice, unsigned uInstance, unsigned uLun, DriveState_T eState,
2768	DriveState_T peState, const char pszPath, bool fPassthrough)
2769	{
2770	LogFlowThisFunc (("pszDevice=%p:{%s} uInstance=%u uLun=%u eState=%d "
2771	"peState=%p:{%d} pszPath=%p:{%s} fPassthrough=%d\n",
2772	pszDevice, pszDevice, uInstance, uLun, eState,
2773	peState, *peState, pszPath, pszPath, fPassthrough));
2774
2775	AutoCaller autoCaller (this);
2776	AssertComRCReturnRC (autoCaller.rc());
2777
2778	/* We will need to release the write lock before calling EMT */
2779	AutoWriteLock alock (this);
2780
2781	/* protect mpVM */
2782	AutoVMCaller autoVMCaller (this);
2783	CheckComRCReturnRC (autoVMCaller.rc());
2784
2785	/*
2786	* Call worker in EMT, that's faster and safer than doing everything
2787	* using VM3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
2788	* here to make requests from under the lock in order to serialize them.
2789	*/
2790	PVMREQ pReq;
2791	int vrc = VMR3ReqCall (mpVM, VMCPUID_ANY, &pReq, 0 /* no wait! */,
2792	(PFNRT) Console::changeDrive, 8,
2793	this, pszDevice, uInstance, uLun, eState, peState,
2794	pszPath, fPassthrough);
2795	/// @todo (r=dmik) bird, it would be nice to have a special VMR3Req method
2796	// for that purpose, that doesn't return useless VERR_TIMEOUT
2797	if (vrc == VERR_TIMEOUT)
2798	vrc = VINF_SUCCESS;
2799
2800	/* leave the lock before waiting for a result (EMT will call us back!) */
2801	alock.leave();
2802
2803	if (VBOX_SUCCESS (vrc))
2804	{
2805	vrc = VMR3ReqWait (pReq, RT_INDEFINITE_WAIT);
2806	AssertRC (vrc);
2807	if (VBOX_SUCCESS (vrc))
2808	vrc = pReq->iStatus;
2809	}
2810	VMR3ReqFree (pReq);
2811
2812	if (VBOX_SUCCESS (vrc))
2813	{
2814	LogFlowThisFunc (("Returns S_OK\n"));
2815	return S_OK;
2816	}
2817
2818	if (pszPath)
2819	return setError (E_FAIL,
2820	tr ("Could not mount the media/drive '%s' (%Rrc)"), pszPath, vrc);
2821
2822	return setError (E_FAIL,
2823	tr ("Could not unmount the currently mounted media/drive (%Rrc)"), vrc);
2824	}
2825
2826
2827	/**
2828	* Performs the Floppy/DVD change in EMT.
2829	*
2830	* @returns VBox status code.
2831	*
2832	* @param pThis Pointer to the Console object.
2833	* @param pszDevice The PDM device name.
2834	* @param uInstance The PDM device instance.
2835	* @param uLun The PDM LUN number of the drive.
2836	* @param eState The new state.
2837	* @param peState Pointer to the variable keeping the actual state of the drive.
2838	* This will be both read and updated to eState or other appropriate state.
2839	* @param pszPath The path to the media / drive which is now being mounted / captured.
2840	* If NULL no media or drive is attached and the LUN will be configured with
2841	* the default block driver with no media. This will also be the state if
2842	* mounting / capturing the specified media / drive fails.
2843	* @param fPassthrough Enables using passthrough mode of the host DVD drive if applicable.
2844	*
2845	* @thread EMT
2846	* @note Locks the Console object for writing.
2847	*/
2848	DECLCALLBACK(int) Console::changeDrive (Console pThis, const char pszDevice, unsigned uInstance, unsigned uLun,
2849	DriveState_T eState, DriveState_T *peState,
2850	const char *pszPath, bool fPassthrough)
2851	{
2852	LogFlowFunc (("pThis=%p pszDevice=%p:{%s} uInstance=%u uLun=%u eState=%d "
2853	"peState=%p:{%d} pszPath=%p:{%s} fPassthrough=%d\n",
2854	pThis, pszDevice, pszDevice, uInstance, uLun, eState,
2855	peState, *peState, pszPath, pszPath, fPassthrough));
2856
2857	AssertReturn (pThis, VERR_INVALID_PARAMETER);
2858
2859	AssertMsg ( (!strcmp (pszDevice, "i82078") && uLun == 0 && uInstance == 0)
2860	\|\| (!strcmp (pszDevice, "piix3ide") && uLun == 2 && uInstance == 0),
2861	("pszDevice=%s uLun=%d uInstance=%d\n", pszDevice, uLun, uInstance));
2862
2863	AutoCaller autoCaller (pThis);
2864	AssertComRCReturn (autoCaller.rc(), VERR_ACCESS_DENIED);
2865
2866	/* protect mpVM */
2867	AutoVMCaller autoVMCaller (pThis);
2868	CheckComRCReturnRC (autoVMCaller.rc());
2869
2870	PVM pVM = pThis->mpVM;
2871
2872	/*
2873	* Suspend the VM first.
2874	*
2875	* The VM must not be running since it might have pending I/O to
2876	* the drive which is being changed.
2877	*/
2878	bool fResume;
2879	VMSTATE enmVMState = VMR3GetState (pVM);
2880	switch (enmVMState)
2881	{
2882	case VMSTATE_RESETTING:
2883	case VMSTATE_RUNNING:
2884	{
2885	LogFlowFunc (("Suspending the VM...\n"));
2886	/* disable the callback to prevent Console-level state change */
2887	pThis->mVMStateChangeCallbackDisabled = true;
2888	int rc = VMR3Suspend (pVM);
2889	pThis->mVMStateChangeCallbackDisabled = false;
2890	AssertRCReturn (rc, rc);
2891	fResume = true;
2892	break;
2893	}
2894
2895	case VMSTATE_SUSPENDED:
2896	case VMSTATE_CREATED:
2897	case VMSTATE_OFF:
2898	fResume = false;
2899	break;
2900
2901	default:
2902	AssertMsgFailedReturn (("enmVMState=%d\n", enmVMState), VERR_ACCESS_DENIED);
2903	}
2904
2905	int rc = VINF_SUCCESS;
2906	int rcRet = VINF_SUCCESS;
2907
2908	/*
2909	In general locking the object before doing VMR3* calls is quite safe
2910	here, since we're on EMT. Anyway we lock for write after eventually
2911	suspending the vm. The reason is that in the vmstateChangeCallback the
2912	var mVMStateChangeCallbackDisabled is checked under a lock also, which
2913	can lead to an dead lock. The write lock is necessary because we
2914	indirectly modify the meDVDState/meFloppyState members (pointed to by
2915	peState).
2916	*/
2917	AutoWriteLock alock (pThis);
2918
2919	do
2920	{
2921	/*
2922	* Unmount existing media / detach host drive.
2923	*/
2924	PPDMIMOUNT pIMount = NULL;
2925	switch (*peState)
2926	{
2927
2928	case DriveState_ImageMounted:
2929	{
2930	/*
2931	* Resolve the interface.
2932	*/
2933	PPDMIBASE pBase;
2934	rc = PDMR3QueryLun (pVM, pszDevice, uInstance, uLun, &pBase);
2935	if (VBOX_FAILURE (rc))
2936	{
2937	if (rc == VERR_PDM_LUN_NOT_FOUND)
2938	rc = VINF_SUCCESS;
2939	AssertRC (rc);
2940	break;
2941	}
2942
2943	pIMount = (PPDMIMOUNT) pBase->pfnQueryInterface (pBase, PDMINTERFACE_MOUNT);
2944	AssertBreakStmt (pIMount, rc = VERR_INVALID_POINTER);
2945
2946	/*
2947	* Unmount the media.
2948	*/
2949	rc = pIMount->pfnUnmount (pIMount, false);
2950	if (rc == VERR_PDM_MEDIA_NOT_MOUNTED)
2951	rc = VINF_SUCCESS;
2952	break;
2953	}
2954
2955	case DriveState_HostDriveCaptured:
2956	{
2957	rc = PDMR3DeviceDetach (pVM, pszDevice, uInstance, uLun, PDMDEVATT_FLAGS_NOT_HOT_PLUG);
2958	if (rc == VINF_PDM_NO_DRIVER_ATTACHED_TO_LUN)
2959	rc = VINF_SUCCESS;
2960	AssertRC (rc);
2961	break;
2962	}
2963
2964	case DriveState_NotMounted:
2965	break;
2966
2967	default:
2968	AssertMsgFailed (("Invalid *peState: %d\n", peState));
2969	break;
2970	}
2971
2972	if (VBOX_FAILURE (rc))
2973	{
2974	rcRet = rc;
2975	break;
2976	}
2977
2978	/*
2979	* Nothing is currently mounted.
2980	*/
2981	*peState = DriveState_NotMounted;
2982
2983
2984	/*
2985	* Process the HostDriveCaptured state first, as the fallback path
2986	* means mounting the normal block driver without media.
2987	*/
2988	if (eState == DriveState_HostDriveCaptured)
2989	{
2990	/*
2991	* Detach existing driver chain (block).
2992	*/
2993	int rc = PDMR3DeviceDetach (pVM, pszDevice, uInstance, uLun, PDMDEVATT_FLAGS_NOT_HOT_PLUG);
2994	if (VBOX_FAILURE (rc))
2995	{
2996	if (rc == VERR_PDM_LUN_NOT_FOUND)
2997	rc = VINF_SUCCESS;
2998	AssertReleaseRC (rc);
2999	break; /* we're toast */
3000	}
3001	pIMount = NULL;
3002
3003	/*
3004	* Construct a new driver configuration.
3005	*/
3006	PCFGMNODE pInst = CFGMR3GetChildF (CFGMR3GetRoot (pVM), "Devices/%s/%d/", pszDevice, uInstance);
3007	AssertRelease (pInst);
3008	/* nuke anything which might have been left behind. */
3009	CFGMR3RemoveNode (CFGMR3GetChildF (pInst, "LUN#%d", uLun));
3010
3011	/* create a new block driver config */
3012	PCFGMNODE pLunL0;
3013	PCFGMNODE pCfg;
3014	if ( VBOX_SUCCESS (rc = CFGMR3InsertNodeF (pInst, &pLunL0, "LUN#%u", uLun))
3015	&& VBOX_SUCCESS (rc = CFGMR3InsertString (pLunL0, "Driver", !strcmp (pszDevice, "i82078") ? "HostFloppy" : "HostDVD"))
3016	&& VBOX_SUCCESS (rc = CFGMR3InsertNode (pLunL0, "Config", &pCfg))
3017	&& VBOX_SUCCESS (rc = CFGMR3InsertString (pCfg, "Path", pszPath))
3018	&& VBOX_SUCCESS (rc = !strcmp (pszDevice, "i82078") ? VINF_SUCCESS : CFGMR3InsertInteger(pCfg, "Passthrough", fPassthrough)))
3019	{
3020	/*
3021	* Attempt to attach the driver.
3022	*/
3023	rc = PDMR3DeviceAttach (pVM, pszDevice, uInstance, uLun, NULL, PDMDEVATT_FLAGS_NOT_HOT_PLUG);
3024	AssertRC (rc);
3025	}
3026	if (VBOX_FAILURE (rc))
3027	rcRet = rc;
3028	}
3029
3030	/*
3031	* Process the ImageMounted, NotMounted and failed HostDriveCapture cases.
3032	*/
3033	rc = VINF_SUCCESS;
3034	switch (eState)
3035	{
3036	#define RC_CHECK() do { if (VBOX_FAILURE (rc)) { AssertReleaseRC (rc); break; } } while (0)
3037
3038	case DriveState_HostDriveCaptured:
3039	if (VBOX_SUCCESS (rcRet))
3040	break;
3041	/* fallback: umounted block driver. */
3042	pszPath = NULL;
3043	eState = DriveState_NotMounted;
3044	/* fallthru */
3045	case DriveState_ImageMounted:
3046	case DriveState_NotMounted:
3047	{
3048	/*
3049	* Resolve the drive interface / create the driver.
3050	*/
3051	if (!pIMount)
3052	{
3053	PPDMIBASE pBase;
3054	rc = PDMR3QueryLun (pVM, pszDevice, uInstance, uLun, &pBase);
3055	if (rc == VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN)
3056	{
3057	/*
3058	* We have to create it, so we'll do the full config setup and everything.
3059	*/
3060	PCFGMNODE pIdeInst = CFGMR3GetChildF (CFGMR3GetRoot (pVM), "Devices/%s/%d/", pszDevice, uInstance);
3061	AssertRelease (pIdeInst);
3062
3063	/* nuke anything which might have been left behind. */
3064	CFGMR3RemoveNode (CFGMR3GetChildF (pIdeInst, "LUN#%d", uLun));
3065
3066	/* create a new block driver config */
3067	PCFGMNODE pLunL0;
3068	rc = CFGMR3InsertNodeF (pIdeInst, &pLunL0, "LUN#%d", uLun); RC_CHECK();
3069	rc = CFGMR3InsertString (pLunL0, "Driver", "Block"); RC_CHECK();
3070	PCFGMNODE pCfg;
3071	rc = CFGMR3InsertNode (pLunL0, "Config", &pCfg); RC_CHECK();
3072	rc = CFGMR3InsertString (pCfg, "Type", !strcmp (pszDevice, "i82078") ? "Floppy 1.44" : "DVD");
3073	RC_CHECK();
3074	rc = CFGMR3InsertInteger (pCfg, "Mountable", 1); RC_CHECK();
3075
3076	/*
3077	* Attach the driver.
3078	*/
3079	rc = PDMR3DeviceAttach (pVM, pszDevice, uInstance, uLun, &pBase, PDMDEVATT_FLAGS_NOT_HOT_PLUG);
3080	RC_CHECK();
3081	}
3082	else if (VBOX_FAILURE(rc))
3083	{
3084	AssertRC (rc);
3085	return rc;
3086	}
3087
3088	pIMount = (PPDMIMOUNT) pBase->pfnQueryInterface (pBase, PDMINTERFACE_MOUNT);
3089	if (!pIMount)
3090	{
3091	AssertFailed();
3092	return rc;
3093	}
3094	}
3095
3096	/*
3097	* If we've got an image, let's mount it.
3098	*/
3099	if (pszPath && *pszPath)
3100	{
3101	rc = pIMount->pfnMount (pIMount, pszPath, strcmp (pszDevice, "i82078") ? "MediaISO" : "RawImage");
3102	if (VBOX_FAILURE (rc))
3103	eState = DriveState_NotMounted;
3104	}
3105	break;
3106	}
3107
3108	default:
3109	AssertMsgFailed (("Invalid eState: %d\n", eState));
3110	break;
3111
3112	#undef RC_CHECK
3113	}
3114
3115	if (VBOX_FAILURE (rc) && VBOX_SUCCESS (rcRet))
3116	rcRet = rc;
3117
3118	*peState = eState;
3119	}
3120	while (0);
3121
3122	/*
3123	Unlock before resuming because the vmstateChangeCallback problem
3124	described above.
3125	*/
3126	alock.unlock();
3127
3128	/*
3129	* Resume the VM if necessary.
3130	*/
3131	if (fResume)
3132	{
3133	LogFlowFunc (("Resuming the VM...\n"));
3134	/* disable the callback to prevent Console-level state change */
3135	pThis->mVMStateChangeCallbackDisabled = true;
3136	rc = VMR3Resume (pVM);
3137	pThis->mVMStateChangeCallbackDisabled = false;
3138	AssertRC (rc);
3139	if (VBOX_FAILURE (rc))
3140	{
3141	/* too bad, we failed. try to sync the console state with the VMM state */
3142	vmstateChangeCallback (pVM, VMSTATE_SUSPENDED, enmVMState, pThis);
3143	}
3144	/// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
3145	// error (if any) will be hidden from the caller. For proper reporting
3146	// of such multiple errors to the caller we need to enhance the
3147	// IVurtualBoxError interface. For now, give the first error the higher
3148	// priority.
3149	if (VBOX_SUCCESS (rcRet))
3150	rcRet = rc;
3151	}
3152
3153	LogFlowFunc (("Returning %Rrc\n", rcRet));
3154	return rcRet;
3155	}
3156
3157
3158	/**
3159	* Called by IInternalSessionControl::OnNetworkAdapterChange().
3160	*
3161	* @note Locks this object for writing.
3162	*/
3163	HRESULT Console::onNetworkAdapterChange (INetworkAdapter *aNetworkAdapter)
3164	{
3165	LogFlowThisFunc (("\n"));
3166
3167	AutoCaller autoCaller (this);
3168	AssertComRCReturnRC (autoCaller.rc());
3169
3170	AutoWriteLock alock (this);
3171
3172	/* Don't do anything if the VM isn't running */
3173	if (!mpVM)
3174	return S_OK;
3175
3176	/* protect mpVM */
3177	AutoVMCaller autoVMCaller (this);
3178	CheckComRCReturnRC (autoVMCaller.rc());
3179
3180	#ifdef VBOX_DYNAMIC_NET_ATTACH
3181	/* Get the current network attachment type */
3182	HRESULT rc;
3183	NetworkAttachmentType_T eAttachmentType;
3184
3185	rc = aNetworkAdapter->COMGETTER (AttachmentType) (&eAttachmentType);
3186	ComAssertComRCRetRC (rc);
3187	#endif /* VBOX_DYNAMIC_NET_ATTACH */
3188
3189	/* Get the properties we need from the adapter */
3190	BOOL fCableConnected;
3191	#ifdef VBOX_DYNAMIC_NET_ATTACH
3192	rc = aNetworkAdapter->COMGETTER(CableConnected) (&fCableConnected);
3193	#else /* !VBOX_DYNAMIC_NET_ATTACH */
3194	HRESULT rc = aNetworkAdapter->COMGETTER(CableConnected) (&fCableConnected);
3195	#endif /* !VBOX_DYNAMIC_NET_ATTACH */
3196	AssertComRC(rc);
3197	if (SUCCEEDED(rc))
3198	{
3199	ULONG ulInstance;
3200	rc = aNetworkAdapter->COMGETTER(Slot) (&ulInstance);
3201	AssertComRC (rc);
3202	if (SUCCEEDED (rc))
3203	{
3204	/*
3205	* Find the pcnet instance, get the config interface and update
3206	* the link state.
3207	*/
3208	PPDMIBASE pBase;
3209	const char *pszAdapterName = "pcnet";
3210	#ifdef VBOX_WITH_E1000
3211	/*
3212	* Perhaps it would be much wiser to wrap both 'pcnet' and 'e1000'
3213	* into generic 'net' device.
3214	*/
3215	NetworkAdapterType_T adapterType;
3216	rc = aNetworkAdapter->COMGETTER(AdapterType)(&adapterType);
3217	AssertComRC(rc);
3218	if (adapterType == NetworkAdapterType_I82540EM \|\|
3219	adapterType == NetworkAdapterType_I82543GC \|\|
3220	adapterType == NetworkAdapterType_I82545EM)
3221	pszAdapterName = "e1000";
3222	#endif
3223	int vrc = PDMR3QueryDeviceLun (mpVM, pszAdapterName,
3224	(unsigned) ulInstance, 0, &pBase);
3225	ComAssertRC (vrc);
3226	if (VBOX_SUCCESS (vrc))
3227	{
3228	Assert(pBase);
3229	PPDMINETWORKCONFIG pINetCfg = (PPDMINETWORKCONFIG) pBase->
3230	pfnQueryInterface(pBase, PDMINTERFACE_NETWORK_CONFIG);
3231	if (pINetCfg)
3232	{
3233	Log (("Console::onNetworkAdapterChange: setting link state to %d\n",
3234	fCableConnected));
3235	vrc = pINetCfg->pfnSetLinkState (pINetCfg,
3236	fCableConnected ? PDMNETWORKLINKSTATE_UP
3237	: PDMNETWORKLINKSTATE_DOWN);
3238	ComAssertRC (vrc);
3239	}
3240	}
3241
3242	#ifdef VBOX_DYNAMIC_NET_ATTACH
3243	if (VBOX_SUCCESS (vrc) && !(eAttachmentType == meAttachmentType[ulInstance]))
3244	rc = doNetworkAdapterChange(pszAdapterName, ulInstance, 0, aNetworkAdapter);
3245	#endif /* VBOX_DYNAMIC_NET_ATTACH */
3246
3247	if (VBOX_FAILURE (vrc))
3248	rc = E_FAIL;
3249	}
3250	}
3251
3252	/* notify console callbacks on success */
3253	if (SUCCEEDED (rc))
3254	{
3255	CallbackList::iterator it = mCallbacks.begin();
3256	while (it != mCallbacks.end())
3257	(*it++)->OnNetworkAdapterChange (aNetworkAdapter);
3258	}
3259
3260	LogFlowThisFunc (("Leaving rc=%#x\n", rc));
3261	return rc;
3262	}
3263
3264
3265	#ifdef VBOX_DYNAMIC_NET_ATTACH
3266	/**
3267	* Process a network adaptor change.
3268	*
3269	* @returns COM status code.
3270	*
3271	* @param pszDevice The PDM device name.
3272	* @param uInstance The PDM device instance.
3273	* @param uLun The PDM LUN number of the drive.
3274	* @param aNetworkAdapter The network adapter whose attachment needs to be changed
3275	*
3276	* @note Locks this object for writing.
3277	*/
3278	HRESULT Console::doNetworkAdapterChange (const char *pszDevice,
3279	unsigned uInstance,
3280	unsigned uLun,
3281	INetworkAdapter *aNetworkAdapter)
3282	{
3283	LogFlowThisFunc (("pszDevice=%p:{%s} uInstance=%u uLun=%u aNetworkAdapter=%p\n",
3284	pszDevice, pszDevice, uInstance, uLun, aNetworkAdapter));
3285
3286	AutoCaller autoCaller (this);
3287	AssertComRCReturnRC (autoCaller.rc());
3288
3289	/* We will need to release the write lock before calling EMT */
3290	AutoWriteLock alock (this);
3291
3292	/* protect mpVM */
3293	AutoVMCaller autoVMCaller (this);
3294	CheckComRCReturnRC (autoVMCaller.rc());
3295
3296	/*
3297	* Call worker in EMT, that's faster and safer than doing everything
3298	* using VM3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
3299	* here to make requests from under the lock in order to serialize them.
3300	*/
3301	PVMREQ pReq;
3302	int vrc = VMR3ReqCall (mpVM, 0 /idDstCpu/, &pReq, 0 /* no wait! */,
3303	(PFNRT) Console::changeNetworkAttachment, 5,
3304	this, pszDevice, uInstance, uLun, aNetworkAdapter);
3305
3306	/* leave the lock before waiting for a result (EMT will call us back!) */
3307	alock.leave();
3308
3309	if (vrc == VERR_TIMEOUT \|\| VBOX_SUCCESS (vrc))
3310	{
3311	vrc = VMR3ReqWait (pReq, RT_INDEFINITE_WAIT);
3312	AssertRC (vrc);
3313	if (VBOX_SUCCESS (vrc))
3314	vrc = pReq->iStatus;
3315	}
3316	VMR3ReqFree (pReq);
3317
3318	if (VBOX_SUCCESS (vrc))
3319	{
3320	LogFlowThisFunc (("Returns S_OK\n"));
3321	return S_OK;
3322	}
3323
3324	return setError (E_FAIL,
3325	tr ("Could not change the network adaptor attachement type (%Rrc)"), vrc);
3326	}
3327
3328
3329	/**
3330	* Performs the Network Adaptor change in EMT.
3331	*
3332	* @returns VBox status code.
3333	*
3334	* @param pThis Pointer to the Console object.
3335	* @param pszDevice The PDM device name.
3336	* @param uInstance The PDM device instance.
3337	* @param uLun The PDM LUN number of the drive.
3338	* @param aNetworkAdapter The network adapter whose attachment needs to be changed
3339	*
3340	* @thread EMT
3341	* @note Locks the Console object for writing.
3342	*/
3343	DECLCALLBACK(int) Console::changeNetworkAttachment (Console *pThis,
3344	const char *pszDevice,
3345	unsigned uInstance,
3346	unsigned uLun,
3347	INetworkAdapter *aNetworkAdapter)
3348	{
3349	LogFlowFunc (("pThis=%p pszDevice=%p:{%s} uInstance=%u uLun=%u aNetworkAdapter=%p\n",
3350	pThis, pszDevice, pszDevice, uInstance, uLun, aNetworkAdapter));
3351
3352	AssertReturn (pThis, VERR_INVALID_PARAMETER);
3353
3354	AssertMsg ( (!strcmp (pszDevice, "pcnet") && uLun == 0 && uInstance < 8)
3355	\|\| (!strcmp (pszDevice, "e1000") && uLun == 0 && uInstance < 8),
3356	("pszDevice=%s uLun=%d uInstance=%d\n", pszDevice, uLun, uInstance));
3357	Log(("pszDevice=%s uLun=%d uInstance=%d\n", pszDevice, uLun, uInstance));
3358
3359	AutoCaller autoCaller (pThis);
3360	AssertComRCReturn (autoCaller.rc(), VERR_ACCESS_DENIED);
3361
3362	/* protect mpVM */
3363	AutoVMCaller autoVMCaller (pThis);
3364	CheckComRCReturnRC (autoVMCaller.rc());
3365
3366	PVM pVM = pThis->mpVM;
3367
3368	/*
3369	* Suspend the VM first.
3370	*
3371	* The VM must not be running since it might have pending I/O to
3372	* the drive which is being changed.
3373	*/
3374	bool fResume;
3375	VMSTATE enmVMState = VMR3GetState (pVM);
3376	switch (enmVMState)
3377	{
3378	case VMSTATE_RESETTING:
3379	case VMSTATE_RUNNING:
3380	{
3381	LogFlowFunc (("Suspending the VM...\n"));
3382	/* disable the callback to prevent Console-level state change */
3383	pThis->mVMStateChangeCallbackDisabled = true;
3384	int rc = VMR3Suspend (pVM);
3385	pThis->mVMStateChangeCallbackDisabled = false;
3386	AssertRCReturn (rc, rc);
3387	fResume = true;
3388	break;
3389	}
3390
3391	case VMSTATE_SUSPENDED:
3392	case VMSTATE_CREATED:
3393	case VMSTATE_OFF:
3394	fResume = false;
3395	break;
3396
3397	default:
3398	AssertMsgFailedReturn (("enmVMState=%d\n", enmVMState), VERR_ACCESS_DENIED);
3399	}
3400
3401	int rc = VINF_SUCCESS;
3402	int rcRet = VINF_SUCCESS;
3403
3404	PCFGMNODE pCfg = NULL; /* /Devices/Dev/.../Config/ */
3405	PCFGMNODE pLunL0 = NULL; /* /Devices/Dev/0/LUN#0/ */
3406	PCFGMNODE pInst = CFGMR3GetChildF (CFGMR3GetRoot (pVM), "Devices/%s/%d/", pszDevice, uInstance);
3407	AssertRelease (pInst);
3408
3409	/* @todo r=pritesh Need to store the previous network configuration
3410	* and restore it if configNetwork fails, currently not sure if the
3411	* previous atachment will also cleanly reattach with the later one
3412	* failing to attach.
3413	*/
3414	rcRet = configNetwork(pThis, pszDevice, uInstance, uLun, aNetworkAdapter, pCfg, pLunL0, pInst, true);
3415
3416	/*
3417	* Resume the VM if necessary.
3418	*/
3419	if (fResume)
3420	{
3421	LogFlowFunc (("Resuming the VM...\n"));
3422	/* disable the callback to prevent Console-level state change */
3423	pThis->mVMStateChangeCallbackDisabled = true;
3424	rc = VMR3Resume (pVM);
3425	pThis->mVMStateChangeCallbackDisabled = false;
3426	AssertRC (rc);
3427	if (VBOX_FAILURE (rc))
3428	{
3429	/* too bad, we failed. try to sync the console state with the VMM state */
3430	vmstateChangeCallback (pVM, VMSTATE_SUSPENDED, enmVMState, pThis);
3431	}
3432	/// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
3433	// error (if any) will be hidden from the caller. For proper reporting
3434	// of such multiple errors to the caller we need to enhance the
3435	// IVirtualBoxError interface. For now, give the first error the higher
3436	// priority.
3437	if (VBOX_SUCCESS (rcRet))
3438	rcRet = rc;
3439	}
3440
3441	LogFlowFunc (("Returning %Rrc\n", rcRet));
3442	return rcRet;
3443	}
3444	#endif /* VBOX_DYNAMIC_NET_ATTACH */
3445
3446
3447	/**
3448	* Called by IInternalSessionControl::OnSerialPortChange().
3449	*
3450	* @note Locks this object for writing.
3451	*/
3452	HRESULT Console::onSerialPortChange (ISerialPort *aSerialPort)
3453	{
3454	LogFlowThisFunc (("\n"));
3455
3456	AutoCaller autoCaller (this);
3457	AssertComRCReturnRC (autoCaller.rc());
3458
3459	AutoWriteLock alock (this);
3460
3461	/* Don't do anything if the VM isn't running */
3462	if (!mpVM)
3463	return S_OK;
3464
3465	HRESULT rc = S_OK;
3466
3467	/* protect mpVM */
3468	AutoVMCaller autoVMCaller (this);
3469	CheckComRCReturnRC (autoVMCaller.rc());
3470
3471	/* nothing to do so far */
3472
3473	/* notify console callbacks on success */
3474	if (SUCCEEDED (rc))
3475	{
3476	CallbackList::iterator it = mCallbacks.begin();
3477	while (it != mCallbacks.end())
3478	(*it++)->OnSerialPortChange (aSerialPort);
3479	}
3480
3481	LogFlowThisFunc (("Leaving rc=%#x\n", rc));
3482	return rc;
3483	}
3484
3485	/**
3486	* Called by IInternalSessionControl::OnParallelPortChange().
3487	*
3488	* @note Locks this object for writing.
3489	*/
3490	HRESULT Console::onParallelPortChange (IParallelPort *aParallelPort)
3491	{
3492	LogFlowThisFunc (("\n"));
3493
3494	AutoCaller autoCaller (this);
3495	AssertComRCReturnRC (autoCaller.rc());
3496
3497	AutoWriteLock alock (this);
3498
3499	/* Don't do anything if the VM isn't running */
3500	if (!mpVM)
3501	return S_OK;
3502
3503	HRESULT rc = S_OK;
3504
3505	/* protect mpVM */
3506	AutoVMCaller autoVMCaller (this);
3507	CheckComRCReturnRC (autoVMCaller.rc());
3508
3509	/* nothing to do so far */
3510
3511	/* notify console callbacks on success */
3512	if (SUCCEEDED (rc))
3513	{
3514	CallbackList::iterator it = mCallbacks.begin();
3515	while (it != mCallbacks.end())
3516	(*it++)->OnParallelPortChange (aParallelPort);
3517	}
3518
3519	LogFlowThisFunc (("Leaving rc=%#x\n", rc));
3520	return rc;
3521	}
3522
3523	/**
3524	* Called by IInternalSessionControl::OnStorageControllerChange().
3525	*
3526	* @note Locks this object for writing.
3527	*/
3528	HRESULT Console::onStorageControllerChange ()
3529	{
3530	LogFlowThisFunc (("\n"));
3531
3532	AutoCaller autoCaller (this);
3533	AssertComRCReturnRC (autoCaller.rc());
3534
3535	AutoWriteLock alock (this);
3536
3537	/* Don't do anything if the VM isn't running */
3538	if (!mpVM)
3539	return S_OK;
3540
3541	HRESULT rc = S_OK;
3542
3543	/* protect mpVM */
3544	AutoVMCaller autoVMCaller (this);
3545	CheckComRCReturnRC (autoVMCaller.rc());
3546
3547	/* nothing to do so far */
3548
3549	/* notify console callbacks on success */
3550	if (SUCCEEDED (rc))
3551	{
3552	CallbackList::iterator it = mCallbacks.begin();
3553	while (it != mCallbacks.end())
3554	(*it++)->OnStorageControllerChange ();
3555	}
3556
3557	LogFlowThisFunc (("Leaving rc=%#x\n", rc));
3558	return rc;
3559	}
3560
3561	/**
3562	* Called by IInternalSessionControl::OnVRDPServerChange().
3563	*
3564	* @note Locks this object for writing.
3565	*/
3566	HRESULT Console::onVRDPServerChange()
3567	{
3568	AutoCaller autoCaller (this);
3569	AssertComRCReturnRC (autoCaller.rc());
3570
3571	AutoWriteLock alock (this);
3572
3573	HRESULT rc = S_OK;
3574
3575	if (mVRDPServer && mMachineState == MachineState_Running)
3576	{
3577	BOOL vrdpEnabled = FALSE;
3578
3579	rc = mVRDPServer->COMGETTER(Enabled) (&vrdpEnabled);
3580	ComAssertComRCRetRC (rc);
3581
3582	/* VRDP server may call this Console object back from other threads (VRDP INPUT or OUTPUT). */
3583	alock.leave();
3584
3585	if (vrdpEnabled)
3586	{
3587	// If there was no VRDP server started the 'stop' will do nothing.
3588	// However if a server was started and this notification was called,
3589	// we have to restart the server.
3590	mConsoleVRDPServer->Stop ();
3591
3592	if (VBOX_FAILURE(mConsoleVRDPServer->Launch ()))
3593	{
3594	rc = E_FAIL;
3595	}
3596	else
3597	{
3598	mConsoleVRDPServer->EnableConnections ();
3599	}
3600	}
3601	else
3602	{
3603	mConsoleVRDPServer->Stop ();
3604	}
3605
3606	alock.enter();
3607	}
3608
3609	/* notify console callbacks on success */
3610	if (SUCCEEDED (rc))
3611	{
3612	CallbackList::iterator it = mCallbacks.begin();
3613	while (it != mCallbacks.end())
3614	(*it++)->OnVRDPServerChange();
3615	}
3616
3617	return rc;
3618	}
3619
3620	/**
3621	* Called by IInternalSessionControl::OnUSBControllerChange().
3622	*
3623	* @note Locks this object for writing.
3624	*/
3625	HRESULT Console::onUSBControllerChange()
3626	{
3627	LogFlowThisFunc (("\n"));
3628
3629	AutoCaller autoCaller (this);
3630	AssertComRCReturnRC (autoCaller.rc());
3631
3632	AutoWriteLock alock (this);
3633
3634	/* Ignore if no VM is running yet. */
3635	if (!mpVM)
3636	return S_OK;
3637
3638	HRESULT rc = S_OK;
3639
3640	/// @todo (dmik)
3641	// check for the Enabled state and disable virtual USB controller??
3642	// Anyway, if we want to query the machine's USB Controller we need to cache
3643	// it to mUSBController in #init() (as it is done with mDVDDrive).
3644	//
3645	// bird: While the VM supports hot-plugging, I doubt any guest can handle it at this time... :-)
3646	//
3647	// /* protect mpVM */
3648	// AutoVMCaller autoVMCaller (this);
3649	// CheckComRCReturnRC (autoVMCaller.rc());
3650
3651	/* notify console callbacks on success */
3652	if (SUCCEEDED (rc))
3653	{
3654	CallbackList::iterator it = mCallbacks.begin();
3655	while (it != mCallbacks.end())
3656	(*it++)->OnUSBControllerChange();
3657	}
3658
3659	return rc;
3660	}
3661
3662	/**
3663	* Called by IInternalSessionControl::OnSharedFolderChange().
3664	*
3665	* @note Locks this object for writing.
3666	*/
3667	HRESULT Console::onSharedFolderChange (BOOL aGlobal)
3668	{
3669	LogFlowThisFunc (("aGlobal=%RTbool\n", aGlobal));
3670
3671	AutoCaller autoCaller (this);
3672	AssertComRCReturnRC (autoCaller.rc());
3673
3674	AutoWriteLock alock (this);
3675
3676	HRESULT rc = fetchSharedFolders (aGlobal);
3677
3678	/* notify console callbacks on success */
3679	if (SUCCEEDED (rc))
3680	{
3681	CallbackList::iterator it = mCallbacks.begin();
3682	while (it != mCallbacks.end())
3683	(*it++)->OnSharedFolderChange (aGlobal ? (Scope_T) Scope_Global
3684	: (Scope_T) Scope_Machine);
3685	}
3686
3687	return rc;
3688	}
3689
3690	/**
3691	* Called by IInternalSessionControl::OnUSBDeviceAttach() or locally by
3692	* processRemoteUSBDevices() after IInternalMachineControl::RunUSBDeviceFilters()
3693	* returns TRUE for a given remote USB device.
3694	*
3695	* @return S_OK if the device was attached to the VM.
3696	* @return failure if not attached.
3697	*
3698	* @param aDevice
3699	* The device in question.
3700	* @param aMaskedIfs
3701	* The interfaces to hide from the guest.
3702	*
3703	* @note Locks this object for writing.
3704	*/
3705	HRESULT Console::onUSBDeviceAttach (IUSBDevice aDevice, IVirtualBoxErrorInfo aError, ULONG aMaskedIfs)
3706	{
3707	#ifdef VBOX_WITH_USB
3708	LogFlowThisFunc (("aDevice=%p aError=%p\n", aDevice, aError));
3709
3710	AutoCaller autoCaller (this);
3711	ComAssertComRCRetRC (autoCaller.rc());
3712
3713	AutoWriteLock alock (this);
3714
3715	/* protect mpVM (we don't need error info, since it's a callback) */
3716	AutoVMCallerQuiet autoVMCaller (this);
3717	if (FAILED (autoVMCaller.rc()))
3718	{
3719	/* The VM may be no more operational when this message arrives
3720	* (e.g. it may be Saving or Stopping or just PoweredOff) --
3721	* autoVMCaller.rc() will return a failure in this case. */
3722	LogFlowThisFunc (("Attach request ignored (mMachineState=%d).\n",
3723	mMachineState));
3724	return autoVMCaller.rc();
3725	}
3726
3727	if (aError != NULL)
3728	{
3729	/* notify callbacks about the error */
3730	onUSBDeviceStateChange (aDevice, true /* aAttached */, aError);
3731	return S_OK;
3732	}
3733
3734	/* Don't proceed unless there's at least one USB hub. */
3735	if (!PDMR3USBHasHub (mpVM))
3736	{
3737	LogFlowThisFunc (("Attach request ignored (no USB controller).\n"));
3738	return E_FAIL;
3739	}
3740
3741	HRESULT rc = attachUSBDevice (aDevice, aMaskedIfs);
3742	if (FAILED (rc))
3743	{
3744	/* take the current error info */
3745	com::ErrorInfoKeeper eik;
3746	/* the error must be a VirtualBoxErrorInfo instance */
3747	ComPtr <IVirtualBoxErrorInfo> error = eik.takeError();
3748	Assert (!error.isNull());
3749	if (!error.isNull())
3750	{
3751	/* notify callbacks about the error */
3752	onUSBDeviceStateChange (aDevice, true /* aAttached */, error);
3753	}
3754	}
3755
3756	return rc;
3757
3758	#else /* !VBOX_WITH_USB */
3759	return E_FAIL;
3760	#endif /* !VBOX_WITH_USB */
3761	}
3762
3763	/**
3764	* Called by IInternalSessionControl::OnUSBDeviceDetach() and locally by
3765	* processRemoteUSBDevices().
3766	*
3767	* @note Locks this object for writing.
3768	*/
3769	HRESULT Console::onUSBDeviceDetach (IN_BSTR aId,
3770	IVirtualBoxErrorInfo *aError)
3771	{
3772	#ifdef VBOX_WITH_USB
3773	Guid Uuid (aId);
3774	LogFlowThisFunc (("aId={%RTuuid} aError=%p\n", Uuid.raw(), aError));
3775
3776	AutoCaller autoCaller (this);
3777	AssertComRCReturnRC (autoCaller.rc());
3778
3779	AutoWriteLock alock (this);
3780
3781	/* Find the device. */
3782	ComObjPtr <OUSBDevice> device;
3783	USBDeviceList::iterator it = mUSBDevices.begin();
3784	while (it != mUSBDevices.end())
3785	{
3786	LogFlowThisFunc (("it={%RTuuid}\n", (*it)->id().raw()));
3787	if ((*it)->id() == Uuid)
3788	{
3789	device = *it;
3790	break;
3791	}
3792	++ it;
3793	}
3794
3795
3796	if (device.isNull())
3797	{
3798	LogFlowThisFunc (("USB device not found.\n"));
3799
3800	/* The VM may be no more operational when this message arrives
3801	* (e.g. it may be Saving or Stopping or just PoweredOff). Use
3802	* AutoVMCaller to detect it -- AutoVMCaller::rc() will return a
3803	* failure in this case. */
3804
3805	AutoVMCallerQuiet autoVMCaller (this);
3806	if (FAILED (autoVMCaller.rc()))
3807	{
3808	LogFlowThisFunc (("Detach request ignored (mMachineState=%d).\n",
3809	mMachineState));
3810	return autoVMCaller.rc();
3811	}
3812
3813	/* the device must be in the list otherwise */
3814	AssertFailedReturn (E_FAIL);
3815	}
3816
3817	if (aError != NULL)
3818	{
3819	/* notify callback about an error */
3820	onUSBDeviceStateChange (device, false /* aAttached */, aError);
3821	return S_OK;
3822	}
3823
3824	HRESULT rc = detachUSBDevice (it);
3825
3826	if (FAILED (rc))
3827	{
3828	/* take the current error info */
3829	com::ErrorInfoKeeper eik;
3830	/* the error must be a VirtualBoxErrorInfo instance */
3831	ComPtr <IVirtualBoxErrorInfo> error = eik.takeError();
3832	Assert (!error.isNull());
3833	if (!error.isNull())
3834	{
3835	/* notify callbacks about the error */
3836	onUSBDeviceStateChange (device, false /* aAttached */, error);
3837	}
3838	}
3839
3840	return rc;
3841
3842	#else /* !VBOX_WITH_USB */
3843	return E_FAIL;
3844	#endif /* !VBOX_WITH_USB */
3845	}
3846
3847	/**
3848	* @note Temporarily locks this object for writing.
3849	*/
3850	HRESULT Console::getGuestProperty (IN_BSTR aName, BSTR *aValue,
3851	ULONG64 aTimestamp, BSTR aFlags)
3852	{
3853	#if !defined (VBOX_WITH_GUEST_PROPS)
3854	ReturnComNotImplemented();
3855	#else
3856	if (!VALID_PTR (aName))
3857	return E_INVALIDARG;
3858	if (!VALID_PTR (aValue))
3859	return E_POINTER;
3860	if ((aTimestamp != NULL) && !VALID_PTR (aTimestamp))
3861	return E_POINTER;
3862	if ((aFlags != NULL) && !VALID_PTR (aFlags))
3863	return E_POINTER;
3864
3865	AutoCaller autoCaller (this);
3866	AssertComRCReturnRC (autoCaller.rc());
3867
3868	/* protect mpVM (if not NULL) */
3869	AutoVMCallerWeak autoVMCaller (this);
3870	CheckComRCReturnRC (autoVMCaller.rc());
3871
3872	/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
3873	* autoVMCaller, so there is no need to hold a lock of this */
3874
3875	HRESULT rc = E_UNEXPECTED;
3876	using namespace guestProp;
3877
3878	try
3879	{
3880	VBOXHGCMSVCPARM parm[4];
3881	Utf8Str Utf8Name = aName;
3882	char pszBuffer[MAX_VALUE_LEN + MAX_FLAGS_LEN];
3883
3884	parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
3885	parm[0].u.pointer.addr = (void*)Utf8Name.c_str();
3886	/* The + 1 is the null terminator */
3887	parm[0].u.pointer.size = (uint32_t)Utf8Name.length() + 1;
3888	parm[1].type = VBOX_HGCM_SVC_PARM_PTR;
3889	parm[1].u.pointer.addr = pszBuffer;
3890	parm[1].u.pointer.size = sizeof(pszBuffer);
3891	int vrc = mVMMDev->hgcmHostCall ("VBoxGuestPropSvc", GET_PROP_HOST,
3892	4, &parm[0]);
3893	/* The returned string should never be able to be greater than our buffer */
3894	AssertLogRel (vrc != VERR_BUFFER_OVERFLOW);
3895	AssertLogRel (RT_FAILURE(vrc) \|\| VBOX_HGCM_SVC_PARM_64BIT == parm[2].type);
3896	if (RT_SUCCESS (vrc) \|\| (VERR_NOT_FOUND == vrc))
3897	{
3898	rc = S_OK;
3899	if (vrc != VERR_NOT_FOUND)
3900	{
3901	Utf8Str strBuffer(pszBuffer);
3902	strBuffer.cloneTo(aValue);
3903
3904	*aTimestamp = parm[2].u.uint64;
3905
3906	size_t iFlags = strBuffer.length() + 1;
3907	Utf8Str(pszBuffer + iFlags).cloneTo(aFlags);
3908	}
3909	else
3910	aValue = NULL;
3911	}
3912	else
3913	rc = setError (E_UNEXPECTED,
3914	tr ("The service call failed with the error %Rrc"), vrc);
3915	}
3916	catch(std::bad_alloc &e)
3917	{
3918	rc = E_OUTOFMEMORY;
3919	}
3920	return rc;
3921	#endif /* else !defined (VBOX_WITH_GUEST_PROPS) */
3922	}
3923
3924	/**
3925	* @note Temporarily locks this object for writing.
3926	*/
3927	HRESULT Console::setGuestProperty (IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags)
3928	{
3929	#if !defined (VBOX_WITH_GUEST_PROPS)
3930	ReturnComNotImplemented();
3931	#else
3932	if (!VALID_PTR (aName))
3933	return E_INVALIDARG;
3934	if ((aValue != NULL) && !VALID_PTR (aValue))
3935	return E_INVALIDARG;
3936	if ((aFlags != NULL) && !VALID_PTR (aFlags))
3937	return E_INVALIDARG;
3938
3939	AutoCaller autoCaller (this);
3940	AssertComRCReturnRC (autoCaller.rc());
3941
3942	/* protect mpVM (if not NULL) */
3943	AutoVMCallerWeak autoVMCaller (this);
3944	CheckComRCReturnRC (autoVMCaller.rc());
3945
3946	/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
3947	* autoVMCaller, so there is no need to hold a lock of this */
3948
3949	HRESULT rc = E_UNEXPECTED;
3950	using namespace guestProp;
3951
3952	VBOXHGCMSVCPARM parm[3];
3953	Utf8Str Utf8Name = aName;
3954	int vrc = VINF_SUCCESS;
3955
3956	parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
3957	parm[0].u.pointer.addr = (void*)Utf8Name.c_str();
3958	/* The + 1 is the null terminator */
3959	parm[0].u.pointer.size = (uint32_t)Utf8Name.length() + 1;
3960	Utf8Str Utf8Value = aValue;
3961	if (aValue != NULL)
3962	{
3963	parm[1].type = VBOX_HGCM_SVC_PARM_PTR;
3964	parm[1].u.pointer.addr = (void*)Utf8Value.c_str();
3965	/* The + 1 is the null terminator */
3966	parm[1].u.pointer.size = (uint32_t)Utf8Value.length() + 1;
3967	}
3968	Utf8Str Utf8Flags = aFlags;
3969	if (aFlags != NULL)
3970	{
3971	parm[2].type = VBOX_HGCM_SVC_PARM_PTR;
3972	parm[2].u.pointer.addr = (void*)Utf8Flags.c_str();
3973	/* The + 1 is the null terminator */
3974	parm[2].u.pointer.size = (uint32_t)Utf8Flags.length() + 1;
3975	}
3976	if ((aValue != NULL) && (aFlags != NULL))
3977	vrc = mVMMDev->hgcmHostCall ("VBoxGuestPropSvc", SET_PROP_HOST,
3978	3, &parm[0]);
3979	else if (aValue != NULL)
3980	vrc = mVMMDev->hgcmHostCall ("VBoxGuestPropSvc", SET_PROP_VALUE_HOST,
3981	2, &parm[0]);
3982	else
3983	vrc = mVMMDev->hgcmHostCall ("VBoxGuestPropSvc", DEL_PROP_HOST,
3984	1, &parm[0]);
3985	if (RT_SUCCESS (vrc))
3986	rc = S_OK;
3987	else
3988	rc = setError (E_UNEXPECTED,
3989	tr ("The service call failed with the error %Rrc"), vrc);
3990	return rc;
3991	#endif /* else !defined (VBOX_WITH_GUEST_PROPS) */
3992	}
3993
3994
3995	/**
3996	* @note Temporarily locks this object for writing.
3997	*/
3998	HRESULT Console::enumerateGuestProperties (IN_BSTR aPatterns,
3999	ComSafeArrayOut(BSTR, aNames),
4000	ComSafeArrayOut(BSTR, aValues),
4001	ComSafeArrayOut(ULONG64, aTimestamps),
4002	ComSafeArrayOut(BSTR, aFlags))
4003	{
4004	#if !defined (VBOX_WITH_GUEST_PROPS)
4005	ReturnComNotImplemented();
4006	#else
4007	if (!VALID_PTR (aPatterns) && (aPatterns != NULL))
4008	return E_POINTER;
4009	if (ComSafeArrayOutIsNull (aNames))
4010	return E_POINTER;
4011	if (ComSafeArrayOutIsNull (aValues))
4012	return E_POINTER;
4013	if (ComSafeArrayOutIsNull (aTimestamps))
4014	return E_POINTER;
4015	if (ComSafeArrayOutIsNull (aFlags))
4016	return E_POINTER;
4017
4018	AutoCaller autoCaller (this);
4019	AssertComRCReturnRC (autoCaller.rc());
4020
4021	/* protect mpVM (if not NULL) */
4022	AutoVMCallerWeak autoVMCaller (this);
4023	CheckComRCReturnRC (autoVMCaller.rc());
4024
4025	/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
4026	* autoVMCaller, so there is no need to hold a lock of this */
4027
4028	return doEnumerateGuestProperties (aPatterns, ComSafeArrayOutArg(aNames),
4029	ComSafeArrayOutArg(aValues),
4030	ComSafeArrayOutArg(aTimestamps),
4031	ComSafeArrayOutArg(aFlags));
4032	#endif /* else !defined (VBOX_WITH_GUEST_PROPS) */
4033	}
4034
4035	/**
4036	* Gets called by Session::UpdateMachineState()
4037	* (IInternalSessionControl::updateMachineState()).
4038	*
4039	* Must be called only in certain cases (see the implementation).
4040	*
4041	* @note Locks this object for writing.
4042	*/
4043	HRESULT Console::updateMachineState (MachineState_T aMachineState)
4044	{
4045	AutoCaller autoCaller (this);
4046	AssertComRCReturnRC (autoCaller.rc());
4047
4048	AutoWriteLock alock (this);
4049
4050	AssertReturn (mMachineState == MachineState_Saving \|\|
4051	mMachineState == MachineState_Discarding,
4052	E_FAIL);
4053
4054	return setMachineStateLocally (aMachineState);
4055	}
4056
4057	/**
4058	* @note Locks this object for writing.
4059	*/
4060	void Console::onMousePointerShapeChange(bool fVisible, bool fAlpha,
4061	uint32_t xHot, uint32_t yHot,
4062	uint32_t width, uint32_t height,
4063	void *pShape)
4064	{
4065	#if 0
4066	LogFlowThisFuncEnter();
4067	LogFlowThisFunc (("fVisible=%d, fAlpha=%d, xHot = %d, yHot = %d, width=%d, "
4068	"height=%d, shape=%p\n",
4069	fVisible, fAlpha, xHot, yHot, width, height, pShape));
4070	#endif
4071
4072	AutoCaller autoCaller (this);
4073	AssertComRCReturnVoid (autoCaller.rc());
4074
4075	/* We need a write lock because we alter the cached callback data */
4076	AutoWriteLock alock (this);
4077
4078	/* Save the callback arguments */
4079	mCallbackData.mpsc.visible = fVisible;
4080	mCallbackData.mpsc.alpha = fAlpha;
4081	mCallbackData.mpsc.xHot = xHot;
4082	mCallbackData.mpsc.yHot = yHot;
4083	mCallbackData.mpsc.width = width;
4084	mCallbackData.mpsc.height = height;
4085
4086	/* start with not valid */
4087	bool wasValid = mCallbackData.mpsc.valid;
4088	mCallbackData.mpsc.valid = false;
4089
4090	if (pShape != NULL)
4091	{
4092	size_t cb = (width + 7) / 8 * height; /* size of the AND mask */
4093	cb = ((cb + 3) & ~3) + width * 4 * height; /* + gap + size of the XOR mask */
4094	/* try to reuse the old shape buffer if the size is the same */
4095	if (!wasValid)
4096	mCallbackData.mpsc.shape = NULL;
4097	else
4098	if (mCallbackData.mpsc.shape != NULL && mCallbackData.mpsc.shapeSize != cb)
4099	{
4100	RTMemFree (mCallbackData.mpsc.shape);
4101	mCallbackData.mpsc.shape = NULL;
4102	}
4103	if (mCallbackData.mpsc.shape == NULL)
4104	{
4105	mCallbackData.mpsc.shape = (BYTE *) RTMemAllocZ (cb);
4106	AssertReturnVoid (mCallbackData.mpsc.shape);
4107	}
4108	mCallbackData.mpsc.shapeSize = cb;
4109	memcpy (mCallbackData.mpsc.shape, pShape, cb);
4110	}
4111	else
4112	{
4113	if (wasValid && mCallbackData.mpsc.shape != NULL)
4114	RTMemFree (mCallbackData.mpsc.shape);
4115	mCallbackData.mpsc.shape = NULL;
4116	mCallbackData.mpsc.shapeSize = 0;
4117	}
4118
4119	mCallbackData.mpsc.valid = true;
4120
4121	CallbackList::iterator it = mCallbacks.begin();
4122	while (it != mCallbacks.end())
4123	(*it++)->OnMousePointerShapeChange (fVisible, fAlpha, xHot, yHot,
4124	width, height, (BYTE *) pShape);
4125
4126	#if 0
4127	LogFlowThisFuncLeave();
4128	#endif
4129	}
4130
4131	/**
4132	* @note Locks this object for writing.
4133	*/
4134	void Console::onMouseCapabilityChange (BOOL supportsAbsolute, BOOL needsHostCursor)
4135	{
4136	LogFlowThisFunc (("supportsAbsolute=%d needsHostCursor=%d\n",
4137	supportsAbsolute, needsHostCursor));
4138
4139	AutoCaller autoCaller (this);
4140	AssertComRCReturnVoid (autoCaller.rc());
4141
4142	/* We need a write lock because we alter the cached callback data */
4143	AutoWriteLock alock (this);
4144
4145	/* save the callback arguments */
4146	mCallbackData.mcc.supportsAbsolute = supportsAbsolute;
4147	mCallbackData.mcc.needsHostCursor = needsHostCursor;
4148	mCallbackData.mcc.valid = true;
4149
4150	CallbackList::iterator it = mCallbacks.begin();
4151	while (it != mCallbacks.end())
4152	{
4153	Log2(("Console::onMouseCapabilityChange: calling %p\n", (void)it));
4154	(*it++)->OnMouseCapabilityChange (supportsAbsolute, needsHostCursor);
4155	}
4156	}
4157
4158	/**
4159	* @note Locks this object for reading.
4160	*/
4161	void Console::onStateChange (MachineState_T machineState)
4162	{
4163	AutoCaller autoCaller (this);
4164	AssertComRCReturnVoid (autoCaller.rc());
4165
4166	AutoReadLock alock (this);
4167
4168	CallbackList::iterator it = mCallbacks.begin();
4169	while (it != mCallbacks.end())
4170	(*it++)->OnStateChange (machineState);
4171	}
4172
4173	/**
4174	* @note Locks this object for reading.
4175	*/
4176	void Console::onAdditionsStateChange()
4177	{
4178	AutoCaller autoCaller (this);
4179	AssertComRCReturnVoid (autoCaller.rc());
4180
4181	AutoReadLock alock (this);
4182
4183	CallbackList::iterator it = mCallbacks.begin();
4184	while (it != mCallbacks.end())
4185	(*it++)->OnAdditionsStateChange();
4186	}
4187
4188	/**
4189	* @note Locks this object for reading.
4190	*/
4191	void Console::onAdditionsOutdated()
4192	{
4193	AutoCaller autoCaller (this);
4194	AssertComRCReturnVoid (autoCaller.rc());
4195
4196	AutoReadLock alock (this);
4197
4198	/** @todo Use the On-Screen Display feature to report the fact.
4199	* The user should be told to install additions that are
4200	* provided with the current VBox build:
4201	* VBOX_VERSION_MAJOR.VBOX_VERSION_MINOR.VBOX_VERSION_BUILD
4202	*/
4203	}
4204
4205	/**
4206	* @note Locks this object for writing.
4207	*/
4208	void Console::onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock)
4209	{
4210	AutoCaller autoCaller (this);
4211	AssertComRCReturnVoid (autoCaller.rc());
4212
4213	/* We need a write lock because we alter the cached callback data */
4214	AutoWriteLock alock (this);
4215
4216	/* save the callback arguments */
4217	mCallbackData.klc.numLock = fNumLock;
4218	mCallbackData.klc.capsLock = fCapsLock;
4219	mCallbackData.klc.scrollLock = fScrollLock;
4220	mCallbackData.klc.valid = true;
4221
4222	CallbackList::iterator it = mCallbacks.begin();
4223	while (it != mCallbacks.end())
4224	(*it++)->OnKeyboardLedsChange(fNumLock, fCapsLock, fScrollLock);
4225	}
4226
4227	/**
4228	* @note Locks this object for reading.
4229	*/
4230	void Console::onUSBDeviceStateChange (IUSBDevice *aDevice, bool aAttached,
4231	IVirtualBoxErrorInfo *aError)
4232	{
4233	AutoCaller autoCaller (this);
4234	AssertComRCReturnVoid (autoCaller.rc());
4235
4236	AutoReadLock alock (this);
4237
4238	CallbackList::iterator it = mCallbacks.begin();
4239	while (it != mCallbacks.end())
4240	(*it++)->OnUSBDeviceStateChange (aDevice, aAttached, aError);
4241	}
4242
4243	/**
4244	* @note Locks this object for reading.
4245	*/
4246	void Console::onRuntimeError (BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage)
4247	{
4248	AutoCaller autoCaller (this);
4249	AssertComRCReturnVoid (autoCaller.rc());
4250
4251	AutoReadLock alock (this);
4252
4253	CallbackList::iterator it = mCallbacks.begin();
4254	while (it != mCallbacks.end())
4255	(*it++)->OnRuntimeError (aFatal, aErrorID, aMessage);
4256	}
4257
4258	/**
4259	* @note Locks this object for reading.
4260	*/
4261	HRESULT Console::onShowWindow (BOOL aCheck, BOOL aCanShow, ULONG64 aWinId)
4262	{
4263	AssertReturn (aCanShow, E_POINTER);
4264	AssertReturn (aWinId, E_POINTER);
4265
4266	*aCanShow = FALSE;
4267	*aWinId = 0;
4268
4269	AutoCaller autoCaller (this);
4270	AssertComRCReturnRC (autoCaller.rc());
4271
4272	AutoReadLock alock (this);
4273
4274	HRESULT rc = S_OK;
4275	CallbackList::iterator it = mCallbacks.begin();
4276
4277	if (aCheck)
4278	{
4279	while (it != mCallbacks.end())
4280	{
4281	BOOL canShow = FALSE;
4282	rc = (*it++)->OnCanShowWindow (&canShow);
4283	AssertComRC (rc);
4284	if (FAILED (rc) \|\| !canShow)
4285	return rc;
4286	}
4287	*aCanShow = TRUE;
4288	}
4289	else
4290	{
4291	while (it != mCallbacks.end())
4292	{
4293	ULONG64 winId = 0;
4294	rc = (*it++)->OnShowWindow (&winId);
4295	AssertComRC (rc);
4296	if (FAILED (rc))
4297	return rc;
4298	/* only one callback may return non-null winId */
4299	Assert (*aWinId == 0 \|\| winId == 0);
4300	if (*aWinId == 0)
4301	*aWinId = winId;
4302	}
4303	}
4304
4305	return S_OK;
4306	}
4307
4308	// private methods
4309	////////////////////////////////////////////////////////////////////////////////
4310
4311	/**
4312	* Increases the usage counter of the mpVM pointer. Guarantees that
4313	* VMR3Destroy() will not be called on it at least until releaseVMCaller()
4314	* is called.
4315	*
4316	* If this method returns a failure, the caller is not allowed to use mpVM
4317	* and may return the failed result code to the upper level. This method sets
4318	* the extended error info on failure if \a aQuiet is false.
4319	*
4320	* Setting \a aQuiet to true is useful for methods that don't want to return
4321	* the failed result code to the caller when this method fails (e.g. need to
4322	* silently check for the mpVM availability).
4323	*
4324	* When mpVM is NULL but \a aAllowNullVM is true, a corresponding error will be
4325	* returned instead of asserting. Having it false is intended as a sanity check
4326	* for methods that have checked mMachineState and expect mpVM NOT to be NULL.
4327	*
4328	* @param aQuiet true to suppress setting error info
4329	* @param aAllowNullVM true to accept mpVM being NULL and return a failure
4330	* (otherwise this method will assert if mpVM is NULL)
4331	*
4332	* @note Locks this object for writing.
4333	*/
4334	HRESULT Console::addVMCaller (bool aQuiet /* = false */,
4335	bool aAllowNullVM /* = false */)
4336	{
4337	AutoCaller autoCaller (this);
4338	AssertComRCReturnRC (autoCaller.rc());
4339
4340	AutoWriteLock alock (this);
4341
4342	if (mVMDestroying)
4343	{
4344	/* powerDown() is waiting for all callers to finish */
4345	return aQuiet ? E_ACCESSDENIED : setError (E_ACCESSDENIED,
4346	tr ("Virtual machine is being powered down"));
4347	}
4348
4349	if (mpVM == NULL)
4350	{
4351	Assert (aAllowNullVM == true);
4352
4353	/* The machine is not powered up */
4354	return aQuiet ? E_ACCESSDENIED : setError (E_ACCESSDENIED,
4355	tr ("Virtual machine is not powered up"));
4356	}
4357
4358	++ mVMCallers;
4359
4360	return S_OK;
4361	}
4362
4363	/**
4364	* Decreases the usage counter of the mpVM pointer. Must always complete
4365	* the addVMCaller() call after the mpVM pointer is no more necessary.
4366	*
4367	* @note Locks this object for writing.
4368	*/
4369	void Console::releaseVMCaller()
4370	{
4371	AutoCaller autoCaller (this);
4372	AssertComRCReturnVoid (autoCaller.rc());
4373
4374	AutoWriteLock alock (this);
4375
4376	AssertReturnVoid (mpVM != NULL);
4377
4378	Assert (mVMCallers > 0);
4379	-- mVMCallers;
4380
4381	if (mVMCallers == 0 && mVMDestroying)
4382	{
4383	/* inform powerDown() there are no more callers */
4384	RTSemEventSignal (mVMZeroCallersSem);
4385	}
4386	}
4387
4388	/**
4389	* Initialize the release logging facility. In case something
4390	* goes wrong, there will be no release logging. Maybe in the future
4391	* we can add some logic to use different file names in this case.
4392	* Note that the logic must be in sync with Machine::DeleteSettings().
4393	*/
4394	HRESULT Console::consoleInitReleaseLog (const ComPtr <IMachine> aMachine)
4395	{
4396	HRESULT hrc = S_OK;
4397
4398	Bstr logFolder;
4399	hrc = aMachine->COMGETTER(LogFolder) (logFolder.asOutParam());
4400	CheckComRCReturnRC (hrc);
4401
4402	Utf8Str logDir = logFolder;
4403
4404	/* make sure the Logs folder exists */
4405	Assert(logDir.length());
4406	if (!RTDirExists (logDir))
4407	RTDirCreateFullPath (logDir, 0777);
4408
4409	Utf8Str logFile = Utf8StrFmt ("%s%cVBox.log",
4410	logDir.raw(), RTPATH_DELIMITER);
4411	Utf8Str pngFile = Utf8StrFmt ("%s%cVBox.png",
4412	logDir.raw(), RTPATH_DELIMITER);
4413
4414	/*
4415	* Age the old log files
4416	* Rename .(n-1) to .(n), .(n-2) to .(n-1), ..., and the last log file to .1
4417	* Overwrite target files in case they exist.
4418	*/
4419	ComPtr<IVirtualBox> virtualBox;
4420	aMachine->COMGETTER(Parent)(virtualBox.asOutParam());
4421	ComPtr <ISystemProperties> systemProperties;
4422	virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
4423	ULONG uLogHistoryCount = 3;
4424	systemProperties->COMGETTER(LogHistoryCount)(&uLogHistoryCount);
4425	ComPtr <IHost> host;
4426	virtualBox->COMGETTER(Host)(host.asOutParam());
4427	ULONG uHostRamMb = 0, uHostRamAvailMb = 0;
4428	host->COMGETTER(MemorySize)(&uHostRamMb);
4429	host->COMGETTER(MemoryAvailable)(&uHostRamAvailMb);
4430	if (uLogHistoryCount)
4431	{
4432	for (int i = uLogHistoryCount-1; i >= 0; i--)
4433	{
4434	Utf8Str *files[] = { &logFile, &pngFile };
4435	Utf8Str oldName, newName;
4436
4437	for (unsigned int j = 0; j < RT_ELEMENTS (files); ++ j)
4438	{
4439	if (i > 0)
4440	oldName = Utf8StrFmt ("%s.%d", files [j]->raw(), i);
4441	else
4442	oldName = *files [j];
4443	newName = Utf8StrFmt ("%s.%d", files [j]->raw(), i + 1);
4444	/* If the old file doesn't exist, delete the new file (if it
4445	* exists) to provide correct rotation even if the sequence is
4446	* broken */
4447	if ( RTFileRename (oldName, newName, RTFILEMOVE_FLAGS_REPLACE)
4448	== VERR_FILE_NOT_FOUND)
4449	RTFileDelete (newName);
4450	}
4451	}
4452	}
4453
4454	PRTLOGGER loggerRelease;
4455	static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
4456	RTUINT fFlags = RTLOGFLAGS_PREFIX_TIME_PROG;
4457	#if defined (RT_OS_WINDOWS) \|\| defined (RT_OS_OS2)
4458	fFlags \|= RTLOGFLAGS_USECRLF;
4459	#endif
4460	char szError[RTPATH_MAX + 128] = "";
4461	int vrc = RTLogCreateEx(&loggerRelease, fFlags, "all",
4462	"VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups,
4463	RTLOGDEST_FILE, szError, sizeof(szError), logFile.raw());
4464	if (RT_SUCCESS(vrc))
4465	{
4466	/* some introductory information */
4467	RTTIMESPEC timeSpec;
4468	char szTmp[256];
4469	RTTimeSpecToString(RTTimeNow(&timeSpec), szTmp, sizeof(szTmp));
4470	RTLogRelLogger(loggerRelease, 0, ~0U,
4471	"VirtualBox %s r%d %s (%s %s) release log\n"
4472	"Log opened %s\n",
4473	VBOX_VERSION_STRING, VBoxSVNRev (), VBOX_BUILD_TARGET,
4474	__DATE__, __TIME__, szTmp);
4475
4476	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
4477	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
4478	RTLogRelLogger(loggerRelease, 0, ~0U, "OS Product: %s\n", szTmp);
4479	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
4480	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
4481	RTLogRelLogger(loggerRelease, 0, ~0U, "OS Release: %s\n", szTmp);
4482	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
4483	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
4484	RTLogRelLogger(loggerRelease, 0, ~0U, "OS Version: %s\n", szTmp);
4485	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
4486	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
4487	RTLogRelLogger(loggerRelease, 0, ~0U, "OS Service Pack: %s\n", szTmp);
4488	RTLogRelLogger(loggerRelease, 0, ~0U, "Host RAM: %uMB RAM, available: %uMB\n",
4489	uHostRamMb, uHostRamAvailMb);
4490	/* the package type is interesting for Linux distributions */
4491	char szExecName[RTPATH_MAX];
4492	char *pszExecName = RTProcGetExecutableName(szExecName, sizeof(szExecName));
4493	RTLogRelLogger(loggerRelease, 0, ~0U,
4494	"Executable: %s\n"
4495	"Process ID: %u\n"
4496	"Package type: %s"
4497	#ifdef VBOX_OSE
4498	" (OSE)"
4499	#endif
4500	"\n",
4501	pszExecName ? pszExecName : "unknown",
4502	RTProcSelf(),
4503	VBOX_PACKAGE_STRING);
4504
4505	/* register this logger as the release logger */
4506	RTLogRelSetDefaultInstance(loggerRelease);
4507	hrc = S_OK;
4508	}
4509	else
4510	hrc = setError (E_FAIL,
4511	tr ("Failed to open release log (%s, %Rrc)"), szError, vrc);
4512
4513	return hrc;
4514	}
4515
4516	/**
4517	* Common worker for PowerUp and PowerUpPaused.
4518	*
4519	* @returns COM status code.
4520	*
4521	* @param aProgress Where to return the progress object.
4522	* @param aPaused true if PowerUpPaused called.
4523	*
4524	* @todo move down to powerDown();
4525	*/
4526	HRESULT Console::powerUp (IProgress **aProgress, bool aPaused)
4527	{
4528	if (aProgress == NULL)
4529	return E_POINTER;
4530
4531	LogFlowThisFuncEnter();
4532	LogFlowThisFunc (("mMachineState=%d\n", mMachineState));
4533
4534	AutoCaller autoCaller (this);
4535	CheckComRCReturnRC (autoCaller.rc());
4536
4537	AutoWriteLock alock (this);
4538
4539	if (Global::IsOnlineOrTransient (mMachineState))
4540	return setError(VBOX_E_INVALID_VM_STATE,
4541	tr ("Virtual machine is already running or busy "
4542	"(machine state: %d)"), mMachineState);
4543
4544	HRESULT rc = S_OK;
4545
4546	/* the network cards will undergo a quick consistency check */
4547	for (ULONG slot = 0; slot < SchemaDefs::NetworkAdapterCount; slot ++)
4548	{
4549	ComPtr<INetworkAdapter> adapter;
4550	mMachine->GetNetworkAdapter (slot, adapter.asOutParam());
4551	BOOL enabled = FALSE;
4552	adapter->COMGETTER(Enabled) (&enabled);
4553	if (!enabled)
4554	continue;
4555
4556	NetworkAttachmentType_T netattach;
4557	adapter->COMGETTER(AttachmentType)(&netattach);
4558	switch (netattach)
4559	{
4560	case NetworkAttachmentType_Bridged:
4561	{
4562	#ifdef RT_OS_WINDOWS
4563	/* a valid host interface must have been set */
4564	Bstr hostif;
4565	adapter->COMGETTER(HostInterface)(hostif.asOutParam());
4566	if (!hostif)
4567	{
4568	return setError (VBOX_E_HOST_ERROR,
4569	tr ("VM cannot start because host interface networking "
4570	"requires a host interface name to be set"));
4571	}
4572	ComPtr<IVirtualBox> virtualBox;
4573	mMachine->COMGETTER(Parent)(virtualBox.asOutParam());
4574	ComPtr<IHost> host;
4575	virtualBox->COMGETTER(Host)(host.asOutParam());
4576	ComPtr<IHostNetworkInterface> hostInterface;
4577	if (!SUCCEEDED(host->FindHostNetworkInterfaceByName(hostif, hostInterface.asOutParam())))
4578	{
4579	return setError (VBOX_E_HOST_ERROR,
4580	tr ("VM cannot start because the host interface '%ls' "
4581	"does not exist"),
4582	hostif.raw());
4583	}
4584	#endif /* RT_OS_WINDOWS */
4585	break;
4586	}
4587	default:
4588	break;
4589	}
4590	}
4591
4592	/* Read console data stored in the saved state file (if not yet done) */
4593	rc = loadDataFromSavedState();
4594	CheckComRCReturnRC (rc);
4595
4596	/* Check all types of shared folders and compose a single list */
4597	SharedFolderDataMap sharedFolders;
4598	{
4599	/* first, insert global folders */
4600	for (SharedFolderDataMap::const_iterator it = mGlobalSharedFolders.begin();
4601	it != mGlobalSharedFolders.end(); ++ it)
4602	sharedFolders [it->first] = it->second;
4603
4604	/* second, insert machine folders */
4605	for (SharedFolderDataMap::const_iterator it = mMachineSharedFolders.begin();
4606	it != mMachineSharedFolders.end(); ++ it)
4607	sharedFolders [it->first] = it->second;
4608
4609	/* third, insert console folders */
4610	for (SharedFolderMap::const_iterator it = mSharedFolders.begin();
4611	it != mSharedFolders.end(); ++ it)
4612	sharedFolders [it->first] = SharedFolderData(it->second->hostPath(), it->second->writable());
4613	}
4614
4615	Bstr savedStateFile;
4616
4617	/*
4618	* Saved VMs will have to prove that their saved states are kosher.
4619	*/
4620	if (mMachineState == MachineState_Saved)
4621	{
4622	rc = mMachine->COMGETTER(StateFilePath) (savedStateFile.asOutParam());
4623	CheckComRCReturnRC (rc);
4624	ComAssertRet (!!savedStateFile, E_FAIL);
4625	int vrc = SSMR3ValidateFile (Utf8Str (savedStateFile));
4626	if (VBOX_FAILURE (vrc))
4627	return setError (VBOX_E_FILE_ERROR,
4628	tr ("VM cannot start because the saved state file '%ls' is invalid (%Rrc). "
4629	"Discard the saved state prior to starting the VM"),
4630	savedStateFile.raw(), vrc);
4631	}
4632
4633	/* create a progress object to track progress of this operation */
4634	ComObjPtr <Progress> powerupProgress;
4635	powerupProgress.createObject();
4636	Bstr progressDesc;
4637	if (mMachineState == MachineState_Saved)
4638	progressDesc = tr ("Restoring virtual machine");
4639	else
4640	progressDesc = tr ("Starting virtual machine");
4641	rc = powerupProgress->init (static_cast <IConsole *> (this),
4642	progressDesc, FALSE /* aCancelable */);
4643	CheckComRCReturnRC (rc);
4644
4645	/* setup task object and thread to carry out the operation
4646	* asynchronously */
4647
4648	std::auto_ptr <VMPowerUpTask> task (new VMPowerUpTask (this, powerupProgress));
4649	ComAssertComRCRetRC (task->rc());
4650
4651	task->mSetVMErrorCallback = setVMErrorCallback;
4652	task->mConfigConstructor = configConstructor;
4653	task->mSharedFolders = sharedFolders;
4654	task->mStartPaused = aPaused;
4655	if (mMachineState == MachineState_Saved)
4656	task->mSavedStateFile = savedStateFile;
4657
4658	/* Reset differencing hard disks for which autoReset is true */
4659	{
4660	com::SafeIfaceArray <IHardDiskAttachment> atts;
4661	rc = mMachine->
4662	COMGETTER(HardDiskAttachments) (ComSafeArrayAsOutParam (atts));
4663	CheckComRCReturnRC (rc);
4664
4665	for (size_t i = 0; i < atts.size(); ++ i)
4666	{
4667	ComPtr <IHardDisk> hardDisk;
4668	rc = atts [i]->COMGETTER(HardDisk) (hardDisk.asOutParam());
4669	CheckComRCReturnRC (rc);
4670
4671	/* save for later use on the powerup thread */
4672	task->hardDisks.push_back (hardDisk);
4673
4674	/* needs autoreset? */
4675	BOOL autoReset = FALSE;
4676	rc = hardDisk->COMGETTER(AutoReset)(&autoReset);
4677	CheckComRCReturnRC (rc);
4678
4679	if (autoReset)
4680	{
4681	ComPtr <IProgress> resetProgress;
4682	rc = hardDisk->Reset (resetProgress.asOutParam());
4683	CheckComRCReturnRC (rc);
4684
4685	/* save for later use on the powerup thread */
4686	task->hardDiskProgresses.push_back (resetProgress);
4687	}
4688	}
4689	}
4690
4691	rc = consoleInitReleaseLog (mMachine);
4692	CheckComRCReturnRC (rc);
4693
4694	/* pass the progress object to the caller if requested */
4695	if (aProgress)
4696	{
4697	if (task->hardDiskProgresses.size() == 0)
4698	{
4699	/* there are no other operations to track, return the powerup
4700	* progress only */
4701	powerupProgress.queryInterfaceTo (aProgress);
4702	}
4703	else
4704	{
4705	/* create a combined progress object */
4706	ComObjPtr <CombinedProgress> progress;
4707	progress.createObject();
4708	VMPowerUpTask::ProgressList progresses (task->hardDiskProgresses);
4709	progresses.push_back (ComPtr <IProgress> (powerupProgress));
4710	rc = progress->init (static_cast <IConsole *> (this),
4711	progressDesc, progresses.begin(),
4712	progresses.end());
4713	AssertComRCReturnRC (rc);
4714	progress.queryInterfaceTo (aProgress);
4715	}
4716	}
4717
4718	int vrc = RTThreadCreate (NULL, Console::powerUpThread, (void *) task.get(),
4719	0, RTTHREADTYPE_MAIN_WORKER, 0, "VMPowerUp");
4720
4721	ComAssertMsgRCRet (vrc, ("Could not create VMPowerUp thread (%Rrc)", vrc),
4722	E_FAIL);
4723
4724	/* task is now owned by powerUpThread(), so release it */
4725	task.release();
4726
4727	/* finally, set the state: no right to fail in this method afterwards
4728	* since we've already started the thread and it is now responsible for
4729	* any error reporting and appropriate state change! */
4730
4731	if (mMachineState == MachineState_Saved)
4732	setMachineState (MachineState_Restoring);
4733	else
4734	setMachineState (MachineState_Starting);
4735
4736	LogFlowThisFunc (("mMachineState=%d\n", mMachineState));
4737	LogFlowThisFuncLeave();
4738	return S_OK;
4739	}
4740
4741	/**
4742	* Internal power off worker routine.
4743	*
4744	* This method may be called only at certain places with the following meaning
4745	* as shown below:
4746	*
4747	* - if the machine state is either Running or Paused, a normal
4748	* Console-initiated powerdown takes place (e.g. PowerDown());
4749	* - if the machine state is Saving, saveStateThread() has successfully done its
4750	* job;
4751	* - if the machine state is Starting or Restoring, powerUpThread() has failed
4752	* to start/load the VM;
4753	* - if the machine state is Stopping, the VM has powered itself off (i.e. not
4754	* as a result of the powerDown() call).
4755	*
4756	* Calling it in situations other than the above will cause unexpected behavior.
4757	*
4758	* Note that this method should be the only one that destroys mpVM and sets it
4759	* to NULL.
4760	*
4761	* @param aProgress Progress object to run (may be NULL).
4762	*
4763	* @note Locks this object for writing.
4764	*
4765	* @note Never call this method from a thread that called addVMCaller() or
4766	* instantiated an AutoVMCaller object; first call releaseVMCaller() or
4767	* release(). Otherwise it will deadlock.
4768	*/
4769	HRESULT Console::powerDown (Progress aProgress /= NULL*/)
4770	{
4771	LogFlowThisFuncEnter();
4772
4773	AutoCaller autoCaller (this);
4774	AssertComRCReturnRC (autoCaller.rc());
4775
4776	AutoWriteLock alock (this);
4777
4778	/* Total # of steps for the progress object. Must correspond to the
4779	* number of "advance percent count" comments in this method! */
4780	enum { StepCount = 7 };
4781	/* current step */
4782	ULONG step = 0;
4783
4784	HRESULT rc = S_OK;
4785	int vrc = VINF_SUCCESS;
4786
4787	/* sanity */
4788	Assert (mVMDestroying == false);
4789
4790	Assert (mpVM != NULL);
4791
4792	AssertMsg (mMachineState == MachineState_Running \|\|
4793	mMachineState == MachineState_Paused \|\|
4794	mMachineState == MachineState_Stuck \|\|
4795	mMachineState == MachineState_Saving \|\|
4796	mMachineState == MachineState_Starting \|\|
4797	mMachineState == MachineState_Restoring \|\|
4798	mMachineState == MachineState_Stopping,
4799	("Invalid machine state: %d\n", mMachineState));
4800
4801	LogRel (("Console::powerDown(): A request to power off the VM has been "
4802	"issued (mMachineState=%d, InUninit=%d)\n",
4803	mMachineState, autoCaller.state() == InUninit));
4804
4805	/* Check if we need to power off the VM. In case of mVMPoweredOff=true, the
4806	* VM has already powered itself off in vmstateChangeCallback() and is just
4807	* notifying Console about that. In case of Starting or Restoring,
4808	* powerUpThread() is calling us on failure, so the VM is already off at
4809	* that point. */
4810	if (!mVMPoweredOff &&
4811	(mMachineState == MachineState_Starting \|\|
4812	mMachineState == MachineState_Restoring))
4813	mVMPoweredOff = true;
4814
4815	/* go to Stopping state if not already there. Note that we don't go from
4816	* Saving/Restoring to Stopping because vmstateChangeCallback() needs it to
4817	* set the state to Saved on VMSTATE_TERMINATED. In terms of protecting from
4818	* inappropriate operations while leaving the lock below, Saving or
4819	* Restoring should be fine too */
4820	if (mMachineState != MachineState_Saving &&
4821	mMachineState != MachineState_Restoring &&
4822	mMachineState != MachineState_Stopping)
4823	setMachineState (MachineState_Stopping);
4824
4825	/* ----------------------------------------------------------------------
4826	* DONE with necessary state changes, perform the power down actions (it's
4827	* safe to leave the object lock now if needed)
4828	* ---------------------------------------------------------------------- */
4829
4830	/* Stop the VRDP server to prevent new clients connection while VM is being
4831	* powered off. */
4832	if (mConsoleVRDPServer)
4833	{
4834	LogFlowThisFunc (("Stopping VRDP server...\n"));
4835
4836	/* Leave the lock since EMT will call us back as addVMCaller()
4837	* in updateDisplayData(). */
4838	alock.leave();
4839
4840	mConsoleVRDPServer->Stop();
4841
4842	alock.enter();
4843	}
4844
4845	/* advance percent count */
4846	if (aProgress)
4847	aProgress->setCurrentOperationProgress(99 * (++ step) / StepCount );
4848
4849	#ifdef VBOX_WITH_HGCM
4850
4851	# ifdef VBOX_WITH_GUEST_PROPS
4852
4853	/* Save all guest property store entries to the machine XML file */
4854	com::SafeArray <BSTR> namesOut;
4855	com::SafeArray <BSTR> valuesOut;
4856	com::SafeArray <ULONG64> timestampsOut;
4857	com::SafeArray <BSTR> flagsOut;
4858	Bstr pattern("");
4859	if (pattern.isNull())
4860	rc = E_OUTOFMEMORY;
4861	else
4862	rc = doEnumerateGuestProperties (Bstr (""), ComSafeArrayAsOutParam (namesOut),
4863	ComSafeArrayAsOutParam (valuesOut),
4864	ComSafeArrayAsOutParam (timestampsOut),
4865	ComSafeArrayAsOutParam (flagsOut));
4866	if (SUCCEEDED(rc))
4867	{
4868	try
4869	{
4870	std::vector <BSTR> names;
4871	std::vector <BSTR> values;
4872	std::vector <ULONG64> timestamps;
4873	std::vector <BSTR> flags;
4874	for (unsigned i = 0; i < namesOut.size(); ++i)
4875	{
4876	uint32_t fFlags;
4877	guestProp::validateFlags (Utf8Str(flagsOut[i]).raw(), &fFlags);
4878	if ( !( fFlags & guestProp::TRANSIENT)
4879	\|\| (mMachineState == MachineState_Saving)
4880	)
4881	{
4882	names.push_back(namesOut[i]);
4883	values.push_back(valuesOut[i]);
4884	timestamps.push_back(timestampsOut[i]);
4885	flags.push_back(flagsOut[i]);
4886	}
4887	}
4888	com::SafeArray <BSTR> namesIn (names);
4889	com::SafeArray <BSTR> valuesIn (values);
4890	com::SafeArray <ULONG64> timestampsIn (timestamps);
4891	com::SafeArray <BSTR> flagsIn (flags);
4892	if ( namesIn.isNull()
4893	\|\| valuesIn.isNull()
4894	\|\| timestampsIn.isNull()
4895	\|\| flagsIn.isNull()
4896	)
4897	throw std::bad_alloc();
4898	/* PushGuestProperties() calls DiscardSettings(), which calls us back */
4899	alock.leave();
4900	mControl->PushGuestProperties (ComSafeArrayAsInParam (namesIn),
4901	ComSafeArrayAsInParam (valuesIn),
4902	ComSafeArrayAsInParam (timestampsIn),
4903	ComSafeArrayAsInParam (flagsIn));
4904	alock.enter();
4905	}
4906	catch (std::bad_alloc)
4907	{
4908	rc = E_OUTOFMEMORY;
4909	}
4910	}
4911
4912	/* advance percent count */
4913	if (aProgress)
4914	aProgress->setCurrentOperationProgress(99 * (++ step) / StepCount );
4915
4916	# endif /* VBOX_WITH_GUEST_PROPS defined */
4917
4918	/* Shutdown HGCM services before stopping the guest, because they might
4919	* need a cleanup. */
4920	if (mVMMDev)
4921	{
4922	LogFlowThisFunc (("Shutdown HGCM...\n"));
4923
4924	/* Leave the lock since EMT will call us back as addVMCaller() */
4925	alock.leave();
4926
4927	mVMMDev->hgcmShutdown ();
4928
4929	alock.enter();
4930	}
4931
4932	/* advance percent count */
4933	if (aProgress)
4934	aProgress->setCurrentOperationProgress(99 * (++ step) / StepCount );
4935
4936	#endif /* VBOX_WITH_HGCM */
4937
4938	/* ----------------------------------------------------------------------
4939	* Now, wait for all mpVM callers to finish their work if there are still
4940	* some on other threads. NO methods that need mpVM (or initiate other calls
4941	* that need it) may be called after this point
4942	* ---------------------------------------------------------------------- */
4943
4944	if (mVMCallers > 0)
4945	{
4946	/* go to the destroying state to prevent from adding new callers */
4947	mVMDestroying = true;
4948
4949	/* lazy creation */
4950	if (mVMZeroCallersSem == NIL_RTSEMEVENT)
4951	RTSemEventCreate (&mVMZeroCallersSem);
4952
4953	LogFlowThisFunc (("Waiting for mpVM callers (%d) to drop to zero...\n",
4954	mVMCallers));
4955
4956	alock.leave();
4957
4958	RTSemEventWait (mVMZeroCallersSem, RT_INDEFINITE_WAIT);
4959
4960	alock.enter();
4961	}
4962
4963	/* advance percent count */
4964	if (aProgress)
4965	aProgress->setCurrentOperationProgress(99 * (++ step) / StepCount );
4966
4967	vrc = VINF_SUCCESS;
4968
4969	/* Power off the VM if not already done that */
4970	if (!mVMPoweredOff)
4971	{
4972	LogFlowThisFunc (("Powering off the VM...\n"));
4973
4974	/* Leave the lock since EMT will call us back on VMR3PowerOff() */
4975	alock.leave();
4976
4977	vrc = VMR3PowerOff (mpVM);
4978
4979	/* Note that VMR3PowerOff() may fail here (invalid VMSTATE) if the
4980	* VM-(guest-)initiated power off happened in parallel a ms before this
4981	* call. So far, we let this error pop up on the user's side. */
4982
4983	alock.enter();
4984
4985	}
4986	else
4987	{
4988	/* reset the flag for further re-use */
4989	mVMPoweredOff = false;
4990	}
4991
4992	/* advance percent count */
4993	if (aProgress)
4994	aProgress->setCurrentOperationProgress(99 * (++ step) / StepCount );
4995
4996	LogFlowThisFunc (("Ready for VM destruction.\n"));
4997
4998	/* If we are called from Console::uninit(), then try to destroy the VM even
4999	* on failure (this will most likely fail too, but what to do?..) */
5000	if (VBOX_SUCCESS (vrc) \|\| autoCaller.state() == InUninit)
5001	{
5002	/* If the machine has an USB comtroller, release all USB devices
5003	* (symmetric to the code in captureUSBDevices()) */
5004	bool fHasUSBController = false;
5005	{
5006	PPDMIBASE pBase;
5007	int vrc = PDMR3QueryLun (mpVM, "usb-ohci", 0, 0, &pBase);
5008	if (VBOX_SUCCESS (vrc))
5009	{
5010	fHasUSBController = true;
5011	detachAllUSBDevices (false /* aDone */);
5012	}
5013	}
5014
5015	/* Now we've got to destroy the VM as well. (mpVM is not valid beyond
5016	* this point). We leave the lock before calling VMR3Destroy() because
5017	* it will result into calling destructors of drivers associated with
5018	* Console children which may in turn try to lock Console (e.g. by
5019	* instantiating SafeVMPtr to access mpVM). It's safe here because
5020	* mVMDestroying is set which should prevent any activity. */
5021
5022	/* Set mpVM to NULL early just in case if some old code is not using
5023	* addVMCaller()/releaseVMCaller(). */
5024	PVM pVM = mpVM;
5025	mpVM = NULL;
5026
5027	LogFlowThisFunc (("Destroying the VM...\n"));
5028
5029	alock.leave();
5030
5031	vrc = VMR3Destroy (pVM);
5032
5033	/* take the lock again */
5034	alock.enter();
5035
5036	/* advance percent count */
5037	if (aProgress)
5038	aProgress->setCurrentOperationProgress(99 * (++ step) / StepCount );
5039
5040	if (VBOX_SUCCESS (vrc))
5041	{
5042	LogFlowThisFunc (("Machine has been destroyed (mMachineState=%d)\n",
5043	mMachineState));
5044	/* Note: the Console-level machine state change happens on the
5045	* VMSTATE_TERMINATE state change in vmstateChangeCallback(). If
5046	* powerDown() is called from EMT (i.e. from vmstateChangeCallback()
5047	* on receiving VM-initiated VMSTATE_OFF), VMSTATE_TERMINATE hasn't
5048	* occurred yet. This is okay, because mMachineState is already
5049	* Stopping in this case, so any other attempt to call PowerDown()
5050	* will be rejected. */
5051	}
5052	else
5053	{
5054	/* bad bad bad, but what to do? */
5055	mpVM = pVM;
5056	rc = setError (VBOX_E_VM_ERROR,
5057	tr ("Could not destroy the machine. (Error: %Rrc)"), vrc);
5058	}
5059
5060	/* Complete the detaching of the USB devices. */
5061	if (fHasUSBController)
5062	detachAllUSBDevices (true /* aDone */);
5063
5064	/* advance percent count */
5065	if (aProgress)
5066	aProgress->setCurrentOperationProgress(99 * (++ step) / StepCount );
5067	}
5068	else
5069	{
5070	rc = setError (VBOX_E_VM_ERROR,
5071	tr ("Could not power off the machine. (Error: %Rrc)"), vrc);
5072	}
5073
5074	/* Finished with destruction. Note that if something impossible happened and
5075	* we've failed to destroy the VM, mVMDestroying will remain true and
5076	* mMachineState will be something like Stopping, so most Console methods
5077	* will return an error to the caller. */
5078	if (mpVM == NULL)
5079	mVMDestroying = false;
5080
5081	if (SUCCEEDED (rc))
5082	{
5083	/* uninit dynamically allocated members of mCallbackData */
5084	if (mCallbackData.mpsc.valid)
5085	{
5086	if (mCallbackData.mpsc.shape != NULL)
5087	RTMemFree (mCallbackData.mpsc.shape);
5088	}
5089	memset (&mCallbackData, 0, sizeof (mCallbackData));
5090	}
5091
5092	/* complete the progress */
5093	if (aProgress)
5094	aProgress->notifyComplete (rc);
5095
5096	LogFlowThisFuncLeave();
5097	return rc;
5098	}
5099
5100	/**
5101	* @note Locks this object for writing.
5102	*/
5103	HRESULT Console::setMachineState (MachineState_T aMachineState,
5104	bool aUpdateServer /* = true */)
5105	{
5106	AutoCaller autoCaller (this);
5107	AssertComRCReturnRC (autoCaller.rc());
5108
5109	AutoWriteLock alock (this);
5110
5111	HRESULT rc = S_OK;
5112
5113	if (mMachineState != aMachineState)
5114	{
5115	LogFlowThisFunc (("machineState=%d\n", aMachineState));
5116	mMachineState = aMachineState;
5117
5118	/// @todo (dmik)
5119	// possibly, we need to redo onStateChange() using the dedicated
5120	// Event thread, like it is done in VirtualBox. This will make it
5121	// much safer (no deadlocks possible if someone tries to use the
5122	// console from the callback), however, listeners will lose the
5123	// ability to synchronously react to state changes (is it really
5124	// necessary??)
5125	LogFlowThisFunc (("Doing onStateChange()...\n"));
5126	onStateChange (aMachineState);
5127	LogFlowThisFunc (("Done onStateChange()\n"));
5128
5129	if (aUpdateServer)
5130	{
5131	/* Server notification MUST be done from under the lock; otherwise
5132	* the machine state here and on the server might go out of sync
5133	* whihc can lead to various unexpected results (like the machine
5134	* state being >= MachineState_Running on the server, while the
5135	* session state is already SessionState_Closed at the same time
5136	* there).
5137	*
5138	* Cross-lock conditions should be carefully watched out: calling
5139	* UpdateState we will require Machine and SessionMachine locks
5140	* (remember that here we're holding the Console lock here, and also
5141	* all locks that have been entered by the thread before calling
5142	* this method).
5143	*/
5144	LogFlowThisFunc (("Doing mControl->UpdateState()...\n"));
5145	rc = mControl->UpdateState (aMachineState);
5146	LogFlowThisFunc (("mControl->UpdateState()=%08X\n", rc));
5147	}
5148	}
5149
5150	return rc;
5151	}
5152
5153	/**
5154	* Searches for a shared folder with the given logical name
5155	* in the collection of shared folders.
5156	*
5157	* @param aName logical name of the shared folder
5158	* @param aSharedFolder where to return the found object
5159	* @param aSetError whether to set the error info if the folder is
5160	* not found
5161	* @return
5162	* S_OK when found or E_INVALIDARG when not found
5163	*
5164	* @note The caller must lock this object for writing.
5165	*/
5166	HRESULT Console::findSharedFolder (CBSTR aName,
5167	ComObjPtr <SharedFolder> &aSharedFolder,
5168	bool aSetError /* = false */)
5169	{
5170	/* sanity check */
5171	AssertReturn (isWriteLockOnCurrentThread(), E_FAIL);
5172
5173	SharedFolderMap::const_iterator it = mSharedFolders.find (aName);
5174	if (it != mSharedFolders.end())
5175	{
5176	aSharedFolder = it->second;
5177	return S_OK;
5178	}
5179
5180	if (aSetError)
5181	setError (VBOX_E_FILE_ERROR,
5182	tr ("Could not find a shared folder named '%ls'."), aName);
5183
5184	return VBOX_E_FILE_ERROR;
5185	}
5186
5187	/**
5188	* Fetches the list of global or machine shared folders from the server.
5189	*
5190	* @param aGlobal true to fetch global folders.
5191	*
5192	* @note The caller must lock this object for writing.
5193	*/
5194	HRESULT Console::fetchSharedFolders (BOOL aGlobal)
5195	{
5196	/* sanity check */
5197	AssertReturn (AutoCaller (this).state() == InInit \|\|
5198	isWriteLockOnCurrentThread(), E_FAIL);
5199
5200	/* protect mpVM (if not NULL) */
5201	AutoVMCallerQuietWeak autoVMCaller (this);
5202
5203	HRESULT rc = S_OK;
5204
5205	bool online = mpVM && autoVMCaller.isOk() && mVMMDev->isShFlActive();
5206
5207	if (aGlobal)
5208	{
5209	/// @todo grab & process global folders when they are done
5210	}
5211	else
5212	{
5213	SharedFolderDataMap oldFolders;
5214	if (online)
5215	oldFolders = mMachineSharedFolders;
5216
5217	mMachineSharedFolders.clear();
5218
5219	SafeIfaceArray <ISharedFolder> folders;
5220	rc = mMachine->COMGETTER(SharedFolders) (ComSafeArrayAsOutParam(folders));
5221	AssertComRCReturnRC (rc);
5222
5223	for (size_t i = 0; i < folders.size(); ++i)
5224	{
5225	ComPtr <ISharedFolder> folder = folders[i];
5226
5227	Bstr name;
5228	Bstr hostPath;
5229	BOOL writable;
5230
5231	rc = folder->COMGETTER(Name) (name.asOutParam());
5232	CheckComRCBreakRC (rc);
5233	rc = folder->COMGETTER(HostPath) (hostPath.asOutParam());
5234	CheckComRCBreakRC (rc);
5235	rc = folder->COMGETTER(Writable) (&writable);
5236
5237	mMachineSharedFolders.insert (std::make_pair (name, SharedFolderData (hostPath, writable)));
5238
5239	/* send changes to HGCM if the VM is running */
5240	/// @todo report errors as runtime warnings through VMSetError
5241	if (online)
5242	{
5243	SharedFolderDataMap::iterator it = oldFolders.find (name);
5244	if (it == oldFolders.end() \|\| it->second.mHostPath != hostPath)
5245	{
5246	/* a new machine folder is added or
5247	* the existing machine folder is changed */
5248	if (mSharedFolders.find (name) != mSharedFolders.end())
5249	; /* the console folder exists, nothing to do */
5250	else
5251	{
5252	/* remove the old machine folder (when changed)
5253	* or the global folder if any (when new) */
5254	if (it != oldFolders.end() \|\|
5255	mGlobalSharedFolders.find (name) !=
5256	mGlobalSharedFolders.end())
5257	rc = removeSharedFolder (name);
5258	/* create the new machine folder */
5259	rc = createSharedFolder (name, SharedFolderData (hostPath, writable));
5260	}
5261	}
5262	/* forget the processed (or identical) folder */
5263	if (it != oldFolders.end())
5264	oldFolders.erase (it);
5265
5266	rc = S_OK;
5267	}
5268	}
5269
5270	AssertComRCReturnRC (rc);
5271
5272	/* process outdated (removed) folders */
5273	/// @todo report errors as runtime warnings through VMSetError
5274	if (online)
5275	{
5276	for (SharedFolderDataMap::const_iterator it = oldFolders.begin();
5277	it != oldFolders.end(); ++ it)
5278	{
5279	if (mSharedFolders.find (it->first) != mSharedFolders.end())
5280	; /* the console folder exists, nothing to do */
5281	else
5282	{
5283	/* remove the outdated machine folder */
5284	rc = removeSharedFolder (it->first);
5285	/* create the global folder if there is any */
5286	SharedFolderDataMap::const_iterator git =
5287	mGlobalSharedFolders.find (it->first);
5288	if (git != mGlobalSharedFolders.end())
5289	rc = createSharedFolder (git->first, git->second);
5290	}
5291	}
5292
5293	rc = S_OK;
5294	}
5295	}
5296
5297	return rc;
5298	}
5299
5300	/**
5301	* Searches for a shared folder with the given name in the list of machine
5302	* shared folders and then in the list of the global shared folders.
5303	*
5304	* @param aName Name of the folder to search for.
5305	* @param aIt Where to store the pointer to the found folder.
5306	* @return @c true if the folder was found and @c false otherwise.
5307	*
5308	* @note The caller must lock this object for reading.
5309	*/
5310	bool Console::findOtherSharedFolder (IN_BSTR aName,
5311	SharedFolderDataMap::const_iterator &aIt)
5312	{
5313	/* sanity check */
5314	AssertReturn (isWriteLockOnCurrentThread(), false);
5315
5316	/* first, search machine folders */
5317	aIt = mMachineSharedFolders.find (aName);
5318	if (aIt != mMachineSharedFolders.end())
5319	return true;
5320
5321	/* second, search machine folders */
5322	aIt = mGlobalSharedFolders.find (aName);
5323	if (aIt != mGlobalSharedFolders.end())
5324	return true;
5325
5326	return false;
5327	}
5328
5329	/**
5330	* Calls the HGCM service to add a shared folder definition.
5331	*
5332	* @param aName Shared folder name.
5333	* @param aHostPath Shared folder path.
5334	*
5335	* @note Must be called from under AutoVMCaller and when mpVM != NULL!
5336	* @note Doesn't lock anything.
5337	*/
5338	HRESULT Console::createSharedFolder (CBSTR aName, SharedFolderData aData)
5339	{
5340	ComAssertRet (aName && *aName, E_FAIL);
5341	ComAssertRet (aData.mHostPath, E_FAIL);
5342
5343	/* sanity checks */
5344	AssertReturn (mpVM, E_FAIL);
5345	AssertReturn (mVMMDev->isShFlActive(), E_FAIL);
5346
5347	VBOXHGCMSVCPARM parms[SHFL_CPARMS_ADD_MAPPING];
5348	SHFLSTRING pFolderName, pMapName;
5349	size_t cbString;
5350
5351	Log (("Adding shared folder '%ls' -> '%ls'\n", aName, aData.mHostPath.raw()));
5352
5353	cbString = (RTUtf16Len (aData.mHostPath) + 1) * sizeof (RTUTF16);
5354	if (cbString >= UINT16_MAX)
5355	return setError (E_INVALIDARG, tr ("The name is too long"));
5356	pFolderName = (SHFLSTRING *) RTMemAllocZ (sizeof (SHFLSTRING) + cbString);
5357	Assert (pFolderName);
5358	memcpy (pFolderName->String.ucs2, aData.mHostPath, cbString);
5359
5360	pFolderName->u16Size = (uint16_t)cbString;
5361	pFolderName->u16Length = (uint16_t)cbString - sizeof(RTUTF16);
5362
5363	parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
5364	parms[0].u.pointer.addr = pFolderName;
5365	parms[0].u.pointer.size = sizeof (SHFLSTRING) + (uint16_t)cbString;
5366
5367	cbString = (RTUtf16Len (aName) + 1) * sizeof (RTUTF16);
5368	if (cbString >= UINT16_MAX)
5369	{
5370	RTMemFree (pFolderName);
5371	return setError (E_INVALIDARG, tr ("The host path is too long"));
5372	}
5373	pMapName = (SHFLSTRING *) RTMemAllocZ (sizeof(SHFLSTRING) + cbString);
5374	Assert (pMapName);
5375	memcpy (pMapName->String.ucs2, aName, cbString);
5376
5377	pMapName->u16Size = (uint16_t)cbString;
5378	pMapName->u16Length = (uint16_t)cbString - sizeof (RTUTF16);
5379
5380	parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
5381	parms[1].u.pointer.addr = pMapName;
5382	parms[1].u.pointer.size = sizeof (SHFLSTRING) + (uint16_t)cbString;
5383
5384	parms[2].type = VBOX_HGCM_SVC_PARM_32BIT;
5385	parms[2].u.uint32 = aData.mWritable;
5386
5387	int vrc = mVMMDev->hgcmHostCall ("VBoxSharedFolders",
5388	SHFL_FN_ADD_MAPPING,
5389	SHFL_CPARMS_ADD_MAPPING, &parms[0]);
5390	RTMemFree (pFolderName);
5391	RTMemFree (pMapName);
5392
5393	if (VBOX_FAILURE (vrc))
5394	return setError (E_FAIL,
5395	tr ("Could not create a shared folder '%ls' "
5396	"mapped to '%ls' (%Rrc)"),
5397	aName, aData.mHostPath.raw(), vrc);
5398
5399	return S_OK;
5400	}
5401
5402	/**
5403	* Calls the HGCM service to remove the shared folder definition.
5404	*
5405	* @param aName Shared folder name.
5406	*
5407	* @note Must be called from under AutoVMCaller and when mpVM != NULL!
5408	* @note Doesn't lock anything.
5409	*/
5410	HRESULT Console::removeSharedFolder (CBSTR aName)
5411	{
5412	ComAssertRet (aName && *aName, E_FAIL);
5413
5414	/* sanity checks */
5415	AssertReturn (mpVM, E_FAIL);
5416	AssertReturn (mVMMDev->isShFlActive(), E_FAIL);
5417
5418	VBOXHGCMSVCPARM parms;
5419	SHFLSTRING *pMapName;
5420	size_t cbString;
5421
5422	Log (("Removing shared folder '%ls'\n", aName));
5423
5424	cbString = (RTUtf16Len (aName) + 1) * sizeof (RTUTF16);
5425	if (cbString >= UINT16_MAX)
5426	return setError (E_INVALIDARG, tr ("The name is too long"));
5427	pMapName = (SHFLSTRING *) RTMemAllocZ (sizeof (SHFLSTRING) + cbString);
5428	Assert (pMapName);
5429	memcpy (pMapName->String.ucs2, aName, cbString);
5430
5431	pMapName->u16Size = (uint16_t)cbString;
5432	pMapName->u16Length = (uint16_t)cbString - sizeof (RTUTF16);
5433
5434	parms.type = VBOX_HGCM_SVC_PARM_PTR;
5435	parms.u.pointer.addr = pMapName;
5436	parms.u.pointer.size = sizeof (SHFLSTRING) + (uint16_t)cbString;
5437
5438	int vrc = mVMMDev->hgcmHostCall ("VBoxSharedFolders",
5439	SHFL_FN_REMOVE_MAPPING,
5440	1, &parms);
5441	RTMemFree(pMapName);
5442	if (VBOX_FAILURE (vrc))
5443	return setError (E_FAIL,
5444	tr ("Could not remove the shared folder '%ls' (%Rrc)"),
5445	aName, vrc);
5446
5447	return S_OK;
5448	}
5449
5450	/**
5451	* VM state callback function. Called by the VMM
5452	* using its state machine states.
5453	*
5454	* Primarily used to handle VM initiated power off, suspend and state saving,
5455	* but also for doing termination completed work (VMSTATE_TERMINATE).
5456	*
5457	* In general this function is called in the context of the EMT.
5458	*
5459	* @param aVM The VM handle.
5460	* @param aState The new state.
5461	* @param aOldState The old state.
5462	* @param aUser The user argument (pointer to the Console object).
5463	*
5464	* @note Locks the Console object for writing.
5465	*/
5466	DECLCALLBACK(void)
5467	Console::vmstateChangeCallback (PVM aVM, VMSTATE aState, VMSTATE aOldState,
5468	void *aUser)
5469	{
5470	LogFlowFunc (("Changing state from %d to %d (aVM=%p)\n",
5471	aOldState, aState, aVM));
5472
5473	Console that = static_cast <Console > (aUser);
5474	AssertReturnVoid (that);
5475
5476	AutoCaller autoCaller (that);
5477
5478	/* Note that we must let this method proceed even if Console::uninit() has
5479	* been already called. In such case this VMSTATE change is a result of:
5480	* 1) powerDown() called from uninit() itself, or
5481	* 2) VM-(guest-)initiated power off. */
5482	AssertReturnVoid (autoCaller.isOk() \|\|
5483	autoCaller.state() == InUninit);
5484
5485	switch (aState)
5486	{
5487	/*
5488	* The VM has terminated
5489	*/
5490	case VMSTATE_OFF:
5491	{
5492	AutoWriteLock alock (that);
5493
5494	if (that->mVMStateChangeCallbackDisabled)
5495	break;
5496
5497	/* Do we still think that it is running? It may happen if this is a
5498	* VM-(guest-)initiated shutdown/poweroff.
5499	*/
5500	if (that->mMachineState != MachineState_Stopping &&
5501	that->mMachineState != MachineState_Saving &&
5502	that->mMachineState != MachineState_Restoring)
5503	{
5504	LogFlowFunc (("VM has powered itself off but Console still "
5505	"thinks it is running. Notifying.\n"));
5506
5507	/* prevent powerDown() from calling VMR3PowerOff() again */
5508	Assert (that->mVMPoweredOff == false);
5509	that->mVMPoweredOff = true;
5510
5511	/* we are stopping now */
5512	that->setMachineState (MachineState_Stopping);
5513
5514	/* Setup task object and thread to carry out the operation
5515	* asynchronously (if we call powerDown() right here but there
5516	* is one or more mpVM callers (added with addVMCaller()) we'll
5517	* deadlock).
5518	*/
5519	std::auto_ptr <VMProgressTask> task (
5520	new VMProgressTask (that, NULL /* aProgress */,
5521	true /* aUsesVMPtr */));
5522
5523	/* If creating a task is falied, this can currently mean one of
5524	* two: either Console::uninit() has been called just a ms
5525	* before (so a powerDown() call is already on the way), or
5526	* powerDown() itself is being already executed. Just do
5527	* nothing.
5528	*/
5529	if (!task->isOk())
5530	{
5531	LogFlowFunc (("Console is already being uninitialized.\n"));
5532	break;
5533	}
5534
5535	int vrc = RTThreadCreate (NULL, Console::powerDownThread,
5536	(void *) task.get(), 0,
5537	RTTHREADTYPE_MAIN_WORKER, 0,
5538	"VMPowerDown");
5539
5540	AssertMsgRCBreak (vrc,
5541	("Could not create VMPowerDown thread (%Rrc)\n", vrc));
5542
5543	/* task is now owned by powerDownThread(), so release it */
5544	task.release();
5545	}
5546	break;
5547	}
5548
5549	/* The VM has been completely destroyed.
5550	*
5551	* Note: This state change can happen at two points:
5552	* 1) At the end of VMR3Destroy() if it was not called from EMT.
5553	* 2) At the end of vmR3EmulationThread if VMR3Destroy() was
5554	* called by EMT.
5555	*/
5556	case VMSTATE_TERMINATED:
5557	{
5558	AutoWriteLock alock (that);
5559
5560	if (that->mVMStateChangeCallbackDisabled)
5561	break;
5562
5563	/* Terminate host interface networking. If aVM is NULL, we've been
5564	* manually called from powerUpThread() either before calling
5565	* VMR3Create() or after VMR3Create() failed, so no need to touch
5566	* networking.
5567	*/
5568	if (aVM)
5569	that->powerDownHostInterfaces();
5570
5571	/* From now on the machine is officially powered down or remains in
5572	* the Saved state.
5573	*/
5574	switch (that->mMachineState)
5575	{
5576	default:
5577	AssertFailed();
5578	/* fall through */
5579	case MachineState_Stopping:
5580	/* successfully powered down */
5581	that->setMachineState (MachineState_PoweredOff);
5582	break;
5583	case MachineState_Saving:
5584	/* successfully saved (note that the machine is already in
5585	* the Saved state on the server due to EndSavingState()
5586	* called from saveStateThread(), so only change the local
5587	* state) */
5588	that->setMachineStateLocally (MachineState_Saved);
5589	break;
5590	case MachineState_Starting:
5591	/* failed to start, but be patient: set back to PoweredOff
5592	* (for similarity with the below) */
5593	that->setMachineState (MachineState_PoweredOff);
5594	break;
5595	case MachineState_Restoring:
5596	/* failed to load the saved state file, but be patient: set
5597	* back to Saved (to preserve the saved state file) */
5598	that->setMachineState (MachineState_Saved);
5599	break;
5600	}
5601
5602	break;
5603	}
5604
5605	case VMSTATE_SUSPENDED:
5606	{
5607	if (aOldState == VMSTATE_RUNNING)
5608	{
5609	AutoWriteLock alock (that);
5610
5611	if (that->mVMStateChangeCallbackDisabled)
5612	break;
5613
5614	/* Change the machine state from Running to Paused */
5615	Assert (that->mMachineState == MachineState_Running);
5616	that->setMachineState (MachineState_Paused);
5617	}
5618
5619	break;
5620	}
5621
5622	case VMSTATE_RUNNING:
5623	{
5624	if (aOldState == VMSTATE_CREATED \|\|
5625	aOldState == VMSTATE_SUSPENDED)
5626	{
5627	AutoWriteLock alock (that);
5628
5629	if (that->mVMStateChangeCallbackDisabled)
5630	break;
5631
5632	/* Change the machine state from Starting, Restoring or Paused
5633	* to Running */
5634	Assert ( ( ( that->mMachineState == MachineState_Starting
5635	\|\| that->mMachineState == MachineState_Paused)
5636	&& aOldState == VMSTATE_CREATED)
5637	\|\| ( ( that->mMachineState == MachineState_Restoring
5638	\|\| that->mMachineState == MachineState_Paused)
5639	&& aOldState == VMSTATE_SUSPENDED));
5640
5641	that->setMachineState (MachineState_Running);
5642	}
5643
5644	break;
5645	}
5646
5647	case VMSTATE_GURU_MEDITATION:
5648	{
5649	AutoWriteLock alock (that);
5650
5651	if (that->mVMStateChangeCallbackDisabled)
5652	break;
5653
5654	/* Guru respects only running VMs */
5655	Assert (Global::IsOnline (that->mMachineState));
5656
5657	that->setMachineState (MachineState_Stuck);
5658
5659	break;
5660	}
5661
5662	default: /* shut up gcc */
5663	break;
5664	}
5665	}
5666
5667	#ifdef VBOX_WITH_USB
5668
5669	/**
5670	* Sends a request to VMM to attach the given host device.
5671	* After this method succeeds, the attached device will appear in the
5672	* mUSBDevices collection.
5673	*
5674	* @param aHostDevice device to attach
5675	*
5676	* @note Synchronously calls EMT.
5677	* @note Must be called from under this object's lock.
5678	*/
5679	HRESULT Console::attachUSBDevice (IUSBDevice *aHostDevice, ULONG aMaskedIfs)
5680	{
5681	AssertReturn (aHostDevice, E_FAIL);
5682	AssertReturn (isWriteLockOnCurrentThread(), E_FAIL);
5683
5684	/* still want a lock object because we need to leave it */
5685	AutoWriteLock alock (this);
5686
5687	HRESULT hrc;
5688
5689	/*
5690	* Get the address and the Uuid, and call the pfnCreateProxyDevice roothub
5691	* method in EMT (using usbAttachCallback()).
5692	*/
5693	Bstr BstrAddress;
5694	hrc = aHostDevice->COMGETTER (Address) (BstrAddress.asOutParam());
5695	ComAssertComRCRetRC (hrc);
5696
5697	Utf8Str Address (BstrAddress);
5698
5699	Bstr id;
5700	hrc = aHostDevice->COMGETTER (Id) (id.asOutParam());
5701	ComAssertComRCRetRC (hrc);
5702	Guid uuid(id);
5703
5704	BOOL fRemote = FALSE;
5705	hrc = aHostDevice->COMGETTER (Remote) (&fRemote);
5706	ComAssertComRCRetRC (hrc);
5707
5708	/* protect mpVM */
5709	AutoVMCaller autoVMCaller (this);
5710	CheckComRCReturnRC (autoVMCaller.rc());
5711
5712	LogFlowThisFunc (("Proxying USB device '%s' {%RTuuid}...\n",
5713	Address.raw(), uuid.ptr()));
5714
5715	/* leave the lock before a VMR3* call (EMT will call us back)! */
5716	alock.leave();
5717
5718	/** @todo just do everything here and only wrap the PDMR3Usb call. That'll offload some notification stuff from the EMT thread. */
5719	PVMREQ pReq = NULL;
5720	int vrc = VMR3ReqCall (mpVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
5721	(PFNRT) usbAttachCallback, 6, this, aHostDevice, uuid.ptr(), fRemote, Address.raw(), aMaskedIfs);
5722	if (VBOX_SUCCESS (vrc))
5723	vrc = pReq->iStatus;
5724	VMR3ReqFree (pReq);
5725
5726	/* restore the lock */
5727	alock.enter();
5728
5729	/* hrc is S_OK here */
5730
5731	if (VBOX_FAILURE (vrc))
5732	{
5733	LogWarningThisFunc (("Failed to create proxy device for '%s' {%RTuuid} (%Rrc)\n",
5734	Address.raw(), uuid.ptr(), vrc));
5735
5736	switch (vrc)
5737	{
5738	case VERR_VUSB_NO_PORTS:
5739	hrc = setError (E_FAIL,
5740	tr ("Failed to attach the USB device. (No available ports on the USB controller)."));
5741	break;
5742	case VERR_VUSB_USBFS_PERMISSION:
5743	hrc = setError (E_FAIL,
5744	tr ("Not permitted to open the USB device, check usbfs options"));
5745	break;
5746	default:
5747	hrc = setError (E_FAIL,
5748	tr ("Failed to create a proxy device for the USB device. (Error: %Rrc)"), vrc);
5749	break;
5750	}
5751	}
5752
5753	return hrc;
5754	}
5755
5756	/**
5757	* USB device attach callback used by AttachUSBDevice().
5758	* Note that AttachUSBDevice() doesn't return until this callback is executed,
5759	* so we don't use AutoCaller and don't care about reference counters of
5760	* interface pointers passed in.
5761	*
5762	* @thread EMT
5763	* @note Locks the console object for writing.
5764	*/
5765	//static
5766	DECLCALLBACK(int)
5767	Console::usbAttachCallback (Console that, IUSBDevice aHostDevice, PCRTUUID aUuid, bool aRemote, const char *aAddress, ULONG aMaskedIfs)
5768	{
5769	LogFlowFuncEnter();
5770	LogFlowFunc (("that={%p}\n", that));
5771
5772	AssertReturn (that && aUuid, VERR_INVALID_PARAMETER);
5773
5774	void *pvRemoteBackend = NULL;
5775	if (aRemote)
5776	{
5777	RemoteUSBDevice pRemoteUSBDevice = static_cast <RemoteUSBDevice > (aHostDevice);
5778	Guid guid (*aUuid);
5779
5780	pvRemoteBackend = that->consoleVRDPServer ()->USBBackendRequestPointer (pRemoteUSBDevice->clientId (), &guid);
5781	if (!pvRemoteBackend)
5782	return VERR_INVALID_PARAMETER; /* The clientId is invalid then. */
5783	}
5784
5785	USHORT portVersion = 1;
5786	HRESULT hrc = aHostDevice->COMGETTER(PortVersion)(&portVersion);
5787	AssertComRCReturn(hrc, VERR_GENERAL_FAILURE);
5788	Assert(portVersion == 1 \|\| portVersion == 2);
5789
5790	int vrc = PDMR3USBCreateProxyDevice (that->mpVM, aUuid, aRemote, aAddress, pvRemoteBackend,
5791	portVersion == 1 ? VUSB_STDVER_11 : VUSB_STDVER_20, aMaskedIfs);
5792	if (VBOX_SUCCESS (vrc))
5793	{
5794	/* Create a OUSBDevice and add it to the device list */
5795	ComObjPtr <OUSBDevice> device;
5796	device.createObject();
5797	HRESULT hrc = device->init (aHostDevice);
5798	AssertComRC (hrc);
5799
5800	AutoWriteLock alock (that);
5801	that->mUSBDevices.push_back (device);
5802	LogFlowFunc (("Attached device {%RTuuid}\n", device->id().raw()));
5803
5804	/* notify callbacks */
5805	that->onUSBDeviceStateChange (device, true /* aAttached */, NULL);
5806	}
5807
5808	LogFlowFunc (("vrc=%Rrc\n", vrc));
5809	LogFlowFuncLeave();
5810	return vrc;
5811	}
5812
5813	/**
5814	* Sends a request to VMM to detach the given host device. After this method
5815	* succeeds, the detached device will disappear from the mUSBDevices
5816	* collection.
5817	*
5818	* @param aIt Iterator pointing to the device to detach.
5819	*
5820	* @note Synchronously calls EMT.
5821	* @note Must be called from under this object's lock.
5822	*/
5823	HRESULT Console::detachUSBDevice (USBDeviceList::iterator &aIt)
5824	{
5825	AssertReturn (isWriteLockOnCurrentThread(), E_FAIL);
5826
5827	/* still want a lock object because we need to leave it */
5828	AutoWriteLock alock (this);
5829
5830	/* protect mpVM */
5831	AutoVMCaller autoVMCaller (this);
5832	CheckComRCReturnRC (autoVMCaller.rc());
5833
5834	/* if the device is attached, then there must at least one USB hub. */
5835	AssertReturn (PDMR3USBHasHub (mpVM), E_FAIL);
5836
5837	LogFlowThisFunc (("Detaching USB proxy device {%RTuuid}...\n",
5838	(*aIt)->id().raw()));
5839
5840	/* leave the lock before a VMR3* call (EMT will call us back)! */
5841	alock.leave();
5842
5843	PVMREQ pReq;
5844	/** @todo just do everything here and only wrap the PDMR3Usb call. That'll offload some notification stuff from the EMT thread. */
5845	int vrc = VMR3ReqCall (mpVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
5846	(PFNRT) usbDetachCallback, 4,
5847	this, &aIt, (*aIt)->id().raw());
5848	if (VBOX_SUCCESS (vrc))
5849	vrc = pReq->iStatus;
5850	VMR3ReqFree (pReq);
5851
5852	ComAssertRCRet (vrc, E_FAIL);
5853
5854	return S_OK;
5855	}
5856
5857	/**
5858	* USB device detach callback used by DetachUSBDevice().
5859	* Note that DetachUSBDevice() doesn't return until this callback is executed,
5860	* so we don't use AutoCaller and don't care about reference counters of
5861	* interface pointers passed in.
5862	*
5863	* @thread EMT
5864	* @note Locks the console object for writing.
5865	*/
5866	//static
5867	DECLCALLBACK(int)
5868	Console::usbDetachCallback (Console that, USBDeviceList::iterator aIt, PCRTUUID aUuid)
5869	{
5870	LogFlowFuncEnter();
5871	LogFlowFunc (("that={%p}\n", that));
5872
5873	AssertReturn (that && aUuid, VERR_INVALID_PARAMETER);
5874	ComObjPtr <OUSBDevice> device = **aIt;
5875
5876	/*
5877	* If that was a remote device, release the backend pointer.
5878	* The pointer was requested in usbAttachCallback.
5879	*/
5880	BOOL fRemote = FALSE;
5881
5882	HRESULT hrc2 = (**aIt)->COMGETTER (Remote) (&fRemote);
5883	ComAssertComRC (hrc2);
5884
5885	if (fRemote)
5886	{
5887	Guid guid (*aUuid);
5888	that->consoleVRDPServer ()->USBBackendReleasePointer (&guid);
5889	}
5890
5891	int vrc = PDMR3USBDetachDevice (that->mpVM, aUuid);
5892
5893	if (VBOX_SUCCESS (vrc))
5894	{
5895	AutoWriteLock alock (that);
5896
5897	/* Remove the device from the collection */
5898	that->mUSBDevices.erase (*aIt);
5899	LogFlowFunc (("Detached device {%RTuuid}\n", device->id().raw()));
5900
5901	/* notify callbacks */
5902	that->onUSBDeviceStateChange (device, false /* aAttached */, NULL);
5903	}
5904
5905	LogFlowFunc (("vrc=%Rrc\n", vrc));
5906	LogFlowFuncLeave();
5907	return vrc;
5908	}
5909
5910	#endif /* VBOX_WITH_USB */
5911
5912
5913	/**
5914	* Helper function to handle host interface device creation and attachment.
5915	*
5916	* @param networkAdapter the network adapter which attachment should be reset
5917	* @return COM status code
5918	*
5919	* @note The caller must lock this object for writing.
5920	*/
5921	HRESULT Console::attachToBridgedInterface(INetworkAdapter *networkAdapter)
5922	{
5923	#if !defined(RT_OS_LINUX) \|\| defined(VBOX_WITH_NETFLT)
5924	/*
5925	* Nothing to do here.
5926	*
5927	* Note, the reason for this method in the first place a memory / fork
5928	* bug on linux. All this code belongs in DrvTAP and similar places.
5929	*/
5930	NOREF(networkAdapter);
5931	return S_OK;
5932
5933	#else /* RT_OS_LINUX && !VBOX_WITH_NETFLT */
5934
5935	LogFlowThisFunc(("\n"));
5936	/* sanity check */
5937	AssertReturn (isWriteLockOnCurrentThread(), E_FAIL);
5938
5939	# ifdef VBOX_STRICT
5940	/* paranoia */
5941	NetworkAttachmentType_T attachment;
5942	networkAdapter->COMGETTER(AttachmentType)(&attachment);
5943	Assert(attachment == NetworkAttachmentType_Bridged);
5944	# endif /* VBOX_STRICT */
5945
5946	HRESULT rc = S_OK;
5947
5948	ULONG slot = 0;
5949	rc = networkAdapter->COMGETTER(Slot)(&slot);
5950	AssertComRC(rc);
5951
5952	/*
5953	* Allocate a host interface device
5954	*/
5955	int rcVBox = RTFileOpen(&maTapFD[slot], "/dev/net/tun",
5956	RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE \| RTFILE_O_INHERIT);
5957	if (VBOX_SUCCESS(rcVBox))
5958	{
5959	/*
5960	* Set/obtain the tap interface.
5961	*/
5962	struct ifreq IfReq;
5963	memset(&IfReq, 0, sizeof(IfReq));
5964	/* The name of the TAP interface we are using */
5965	Bstr tapDeviceName;
5966	rc = networkAdapter->COMGETTER(HostInterface)(tapDeviceName.asOutParam());
5967	if (FAILED(rc))
5968	tapDeviceName.setNull(); /* Is this necessary? */
5969	if (tapDeviceName.isEmpty())
5970	{
5971	LogRel(("No TAP device name was supplied.\n"));
5972	rc = setError(E_FAIL, tr ("No TAP device name was supplied for the host networking interface"));
5973	}
5974
5975	if (SUCCEEDED(rc))
5976	{
5977	/* If we are using a static TAP device then try to open it. */
5978	Utf8Str str(tapDeviceName);
5979	if (str.length() <= sizeof(IfReq.ifr_name))
5980	strcpy(IfReq.ifr_name, str.raw());
5981	else
5982	memcpy(IfReq.ifr_name, str.raw(), sizeof(IfReq.ifr_name) - 1); /** @todo bitch about names which are too long... */
5983	IfReq.ifr_flags = IFF_TAP \| IFF_NO_PI;
5984	rcVBox = ioctl(maTapFD[slot], TUNSETIFF, &IfReq);
5985	if (rcVBox != 0)
5986	{
5987	LogRel(("Failed to open the host network interface %ls\n", tapDeviceName.raw()));
5988	rc = setError(E_FAIL, tr ("Failed to open the host network interface %ls"),
5989	tapDeviceName.raw());
5990	}
5991	}
5992	if (SUCCEEDED(rc))
5993	{
5994	/*
5995	* Make it pollable.
5996	*/
5997	if (fcntl(maTapFD[slot], F_SETFL, O_NONBLOCK) != -1)
5998	{
5999	Log(("attachToBridgedInterface: %RTfile %ls\n", maTapFD[slot], tapDeviceName.raw()));
6000	/*
6001	* Here is the right place to communicate the TAP file descriptor and
6002	* the host interface name to the server if/when it becomes really
6003	* necessary.
6004	*/
6005	maTAPDeviceName[slot] = tapDeviceName;
6006	rcVBox = VINF_SUCCESS;
6007	}
6008	else
6009	{
6010	int iErr = errno;
6011
6012	LogRel(("Configuration error: Failed to configure /dev/net/tun non blocking. Error: %s\n", strerror(iErr)));
6013	rcVBox = VERR_HOSTIF_BLOCKING;
6014	rc = setError(E_FAIL, tr ("could not set up the host networking device for non blocking access: %s"),
6015	strerror(errno));
6016	}
6017	}
6018	}
6019	else
6020	{
6021	LogRel(("Configuration error: Failed to open /dev/net/tun rc=%Rrc\n", rcVBox));
6022	switch (rcVBox)
6023	{
6024	case VERR_ACCESS_DENIED:
6025	/* will be handled by our caller */
6026	rc = rcVBox;
6027	break;
6028	default:
6029	rc = setError(E_FAIL, tr ("Could not set up the host networking device: %Rrc"), rcVBox);
6030	break;
6031	}
6032	}
6033	/* in case of failure, cleanup. */
6034	if (VBOX_FAILURE(rcVBox) && SUCCEEDED(rc))
6035	{
6036	LogRel(("General failure attaching to host interface\n"));
6037	rc = setError(E_FAIL, tr ("General failure attaching to host interface"));
6038	}
6039	LogFlowThisFunc(("rc=%d\n", rc));
6040	return rc;
6041	#endif /* RT_OS_LINUX */
6042	}
6043
6044	/**
6045	* Helper function to handle detachment from a host interface
6046	*
6047	* @param networkAdapter the network adapter which attachment should be reset
6048	* @return COM status code
6049	*
6050	* @note The caller must lock this object for writing.
6051	*/
6052	HRESULT Console::detachFromBridgedInterface(INetworkAdapter *networkAdapter)
6053	{
6054	#if !defined(RT_OS_LINUX) \|\| defined(VBOX_WITH_NETFLT)
6055	/*
6056	* Nothing to do here.
6057	*/
6058	NOREF(networkAdapter);
6059	return S_OK;
6060
6061	#else /* RT_OS_LINUX */
6062
6063	/* sanity check */
6064	LogFlowThisFunc(("\n"));
6065	AssertReturn (isWriteLockOnCurrentThread(), E_FAIL);
6066
6067	HRESULT rc = S_OK;
6068	# ifdef VBOX_STRICT
6069	/* paranoia */
6070	NetworkAttachmentType_T attachment;
6071	networkAdapter->COMGETTER(AttachmentType)(&attachment);
6072	Assert(attachment == NetworkAttachmentType_Bridged);
6073	# endif /* VBOX_STRICT */
6074
6075	ULONG slot = 0;
6076	rc = networkAdapter->COMGETTER(Slot)(&slot);
6077	AssertComRC(rc);
6078
6079	/* is there an open TAP device? */
6080	if (maTapFD[slot] != NIL_RTFILE)
6081	{
6082	/*
6083	* Close the file handle.
6084	*/
6085	Bstr tapDeviceName, tapTerminateApplication;
6086	bool isStatic = true;
6087	rc = networkAdapter->COMGETTER(HostInterface)(tapDeviceName.asOutParam());
6088	if (FAILED(rc) \|\| tapDeviceName.isEmpty())
6089	{
6090	/* If the name is empty, this is a dynamic TAP device, so close it now,
6091	so that the termination script can remove the interface. Otherwise we still
6092	need the FD to pass to the termination script. */
6093	isStatic = false;
6094	int rcVBox = RTFileClose(maTapFD[slot]);
6095	AssertRC(rcVBox);
6096	maTapFD[slot] = NIL_RTFILE;
6097	}
6098	if (isStatic)
6099	{
6100	/* If we are using a static TAP device, we close it now, after having called the
6101	termination script. */
6102	int rcVBox = RTFileClose(maTapFD[slot]);
6103	AssertRC(rcVBox);
6104	}
6105	/* the TAP device name and handle are no longer valid */
6106	maTapFD[slot] = NIL_RTFILE;
6107	maTAPDeviceName[slot] = "";
6108	}
6109	LogFlowThisFunc(("returning %d\n", rc));
6110	return rc;
6111	#endif /* RT_OS_LINUX */
6112	}
6113
6114
6115	/**
6116	* Called at power down to terminate host interface networking.
6117	*
6118	* @note The caller must lock this object for writing.
6119	*/
6120	HRESULT Console::powerDownHostInterfaces()
6121	{
6122	LogFlowThisFunc (("\n"));
6123
6124	/* sanity check */
6125	AssertReturn (isWriteLockOnCurrentThread(), E_FAIL);
6126
6127	/*
6128	* host interface termination handling
6129	*/
6130	HRESULT rc;
6131	for (ULONG slot = 0; slot < SchemaDefs::NetworkAdapterCount; slot ++)
6132	{
6133	ComPtr<INetworkAdapter> networkAdapter;
6134	rc = mMachine->GetNetworkAdapter(slot, networkAdapter.asOutParam());
6135	CheckComRCBreakRC (rc);
6136
6137	BOOL enabled = FALSE;
6138	networkAdapter->COMGETTER(Enabled) (&enabled);
6139	if (!enabled)
6140	continue;
6141
6142	NetworkAttachmentType_T attachment;
6143	networkAdapter->COMGETTER(AttachmentType)(&attachment);
6144	if (attachment == NetworkAttachmentType_Bridged)
6145	{
6146	HRESULT rc2 = detachFromBridgedInterface(networkAdapter);
6147	if (FAILED(rc2) && SUCCEEDED(rc))
6148	rc = rc2;
6149	}
6150	}
6151
6152	return rc;
6153	}
6154
6155
6156	/**
6157	* Process callback handler for VMR3Load and VMR3Save.
6158	*
6159	* @param pVM The VM handle.
6160	* @param uPercent Completetion precentage (0-100).
6161	* @param pvUser Pointer to the VMProgressTask structure.
6162	* @return VINF_SUCCESS.
6163	*/
6164	/static/ DECLCALLBACK (int)
6165	Console::stateProgressCallback (PVM pVM, unsigned uPercent, void *pvUser)
6166	{
6167	VMProgressTask task = static_cast <VMProgressTask > (pvUser);
6168	AssertReturn (task, VERR_INVALID_PARAMETER);
6169
6170	/* update the progress object */
6171	if (task->mProgress)
6172	task->mProgress->setCurrentOperationProgress(uPercent);
6173
6174	return VINF_SUCCESS;
6175	}
6176
6177	/**
6178	* VM error callback function. Called by the various VM components.
6179	*
6180	* @param pVM VM handle. Can be NULL if an error occurred before
6181	* successfully creating a VM.
6182	* @param pvUser Pointer to the VMProgressTask structure.
6183	* @param rc VBox status code.
6184	* @param pszFormat Printf-like error message.
6185	* @param args Various number of arguments for the error message.
6186	*
6187	* @thread EMT, VMPowerUp...
6188	*
6189	* @note The VMProgressTask structure modified by this callback is not thread
6190	* safe.
6191	*/
6192	/* static */ DECLCALLBACK (void)
6193	Console::setVMErrorCallback (PVM pVM, void *pvUser, int rc, RT_SRC_POS_DECL,
6194	const char *pszFormat, va_list args)
6195	{
6196	VMProgressTask task = static_cast <VMProgressTask > (pvUser);
6197	AssertReturnVoid (task);
6198
6199	/* we ignore RT_SRC_POS_DECL arguments to avoid confusion of end-users */
6200	va_list va2;
6201	va_copy (va2, args); /* Have to make a copy here or GCC will break. */
6202
6203	/* append to the existing error message if any */
6204	if (task->mErrorMsg.length())
6205	task->mErrorMsg = Utf8StrFmt ("%s.\n%N (%Rrc)", task->mErrorMsg.raw(),
6206	pszFormat, &va2, rc, rc);
6207	else
6208	task->mErrorMsg = Utf8StrFmt ("%N (%Rrc)",
6209	pszFormat, &va2, rc, rc);
6210
6211	va_end (va2);
6212	}
6213
6214	/**
6215	* VM runtime error callback function.
6216	* See VMSetRuntimeError for the detailed description of parameters.
6217	*
6218	* @param pVM The VM handle.
6219	* @param pvUser The user argument.
6220	* @param fFlags The action flags. See VMSETRTERR_FLAGS_*.
6221	* @param pszErrorId Error ID string.
6222	* @param pszFormat Error message format string.
6223	* @param va Error message arguments.
6224	* @thread EMT.
6225	*/
6226	/* static */ DECLCALLBACK(void)
6227	Console::setVMRuntimeErrorCallback (PVM pVM, void *pvUser, uint32_t fFlags,
6228	const char *pszErrorId,
6229	const char *pszFormat, va_list va)
6230	{
6231	bool const fFatal = !!(fFlags & VMSETRTERR_FLAGS_FATAL);
6232	LogFlowFuncEnter();
6233
6234	Console that = static_cast <Console > (pvUser);
6235	AssertReturnVoid (that);
6236
6237	Utf8Str message = Utf8StrFmtVA (pszFormat, va);
6238
6239	LogRel (("Console: VM runtime error: fatal=%RTbool, "
6240	"errorID=%s message=\"%s\"\n",
6241	fFatal, pszErrorId, message.raw()));
6242
6243	that->onRuntimeError (BOOL (fFatal), Bstr (pszErrorId), Bstr (message));
6244
6245	LogFlowFuncLeave();
6246	}
6247
6248	/**
6249	* Captures USB devices that match filters of the VM.
6250	* Called at VM startup.
6251	*
6252	* @param pVM The VM handle.
6253	*
6254	* @note The caller must lock this object for writing.
6255	*/
6256	HRESULT Console::captureUSBDevices (PVM pVM)
6257	{
6258	LogFlowThisFunc (("\n"));
6259
6260	/* sanity check */
6261	ComAssertRet (isWriteLockOnCurrentThread(), E_FAIL);
6262
6263	/* If the machine has an USB controller, ask the USB proxy service to
6264	* capture devices */
6265	PPDMIBASE pBase;
6266	int vrc = PDMR3QueryLun (pVM, "usb-ohci", 0, 0, &pBase);
6267	if (VBOX_SUCCESS (vrc))
6268	{
6269	/* leave the lock before calling Host in VBoxSVC since Host may call
6270	* us back from under its lock (e.g. onUSBDeviceAttach()) which would
6271	* produce an inter-process dead-lock otherwise. */
6272	AutoWriteLock alock (this);
6273	alock.leave();
6274
6275	HRESULT hrc = mControl->AutoCaptureUSBDevices();
6276	ComAssertComRCRetRC (hrc);
6277	}
6278	else if ( vrc == VERR_PDM_DEVICE_NOT_FOUND
6279	\|\| vrc == VERR_PDM_DEVICE_INSTANCE_NOT_FOUND)
6280	vrc = VINF_SUCCESS;
6281	else
6282	AssertRC (vrc);
6283
6284	return VBOX_SUCCESS (vrc) ? S_OK : E_FAIL;
6285	}
6286
6287
6288	/**
6289	* Detach all USB device which are attached to the VM for the
6290	* purpose of clean up and such like.
6291	*
6292	* @note The caller must lock this object for writing.
6293	*/
6294	void Console::detachAllUSBDevices (bool aDone)
6295	{
6296	LogFlowThisFunc (("aDone=%RTbool\n", aDone));
6297
6298	/* sanity check */
6299	AssertReturnVoid (isWriteLockOnCurrentThread());
6300
6301	mUSBDevices.clear();
6302
6303	/* leave the lock before calling Host in VBoxSVC since Host may call
6304	* us back from under its lock (e.g. onUSBDeviceAttach()) which would
6305	* produce an inter-process dead-lock otherwise. */
6306	AutoWriteLock alock (this);
6307	alock.leave();
6308
6309	mControl->DetachAllUSBDevices (aDone);
6310	}
6311
6312	/**
6313	* @note Locks this object for writing.
6314	*/
6315	void Console::processRemoteUSBDevices (uint32_t u32ClientId, VRDPUSBDEVICEDESC *pDevList, uint32_t cbDevList)
6316	{
6317	LogFlowThisFuncEnter();
6318	LogFlowThisFunc (("u32ClientId = %d, pDevList=%p, cbDevList = %d\n", u32ClientId, pDevList, cbDevList));
6319
6320	AutoCaller autoCaller (this);
6321	if (!autoCaller.isOk())
6322	{
6323	/* Console has been already uninitialized, deny request */
6324	AssertMsgFailed (("Temporary assertion to prove that it happens, "
6325	"please report to dmik\n"));
6326	LogFlowThisFunc (("Console is already uninitialized\n"));
6327	LogFlowThisFuncLeave();
6328	return;
6329	}
6330
6331	AutoWriteLock alock (this);
6332
6333	/*
6334	* Mark all existing remote USB devices as dirty.
6335	*/
6336	RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
6337	while (it != mRemoteUSBDevices.end())
6338	{
6339	(*it)->dirty (true);
6340	++ it;
6341	}
6342
6343	/*
6344	* Process the pDevList and add devices those are not already in the mRemoteUSBDevices list.
6345	*/
6346	/** @todo (sunlover) REMOTE_USB Strict validation of the pDevList. */
6347	VRDPUSBDEVICEDESC *e = pDevList;
6348
6349	/* The cbDevList condition must be checked first, because the function can
6350	* receive pDevList = NULL and cbDevList = 0 on client disconnect.
6351	*/
6352	while (cbDevList >= 2 && e->oNext)
6353	{
6354	LogFlowThisFunc (("vendor %04X, product %04X, name = %s\n",
6355	e->idVendor, e->idProduct,
6356	e->oProduct? (char *)e + e->oProduct: ""));
6357
6358	bool fNewDevice = true;
6359
6360	it = mRemoteUSBDevices.begin();
6361	while (it != mRemoteUSBDevices.end())
6362	{
6363	if ((*it)->devId () == e->id
6364	&& (*it)->clientId () == u32ClientId)
6365	{
6366	/* The device is already in the list. */
6367	(*it)->dirty (false);
6368	fNewDevice = false;
6369	break;
6370	}
6371
6372	++ it;
6373	}
6374
6375	if (fNewDevice)
6376	{
6377	LogRel(("Remote USB: ++++ Vendor %04X. Product %04X. Name = [%s].\n",
6378	e->idVendor, e->idProduct, e->oProduct? (char *)e + e->oProduct: ""
6379	));
6380
6381	/* Create the device object and add the new device to list. */
6382	ComObjPtr <RemoteUSBDevice> device;
6383	device.createObject();
6384	device->init (u32ClientId, e);
6385
6386	mRemoteUSBDevices.push_back (device);
6387
6388	/* Check if the device is ok for current USB filters. */
6389	BOOL fMatched = FALSE;
6390	ULONG fMaskedIfs = 0;
6391
6392	HRESULT hrc = mControl->RunUSBDeviceFilters(device, &fMatched, &fMaskedIfs);
6393
6394	AssertComRC (hrc);
6395
6396	LogFlowThisFunc (("USB filters return %d %#x\n", fMatched, fMaskedIfs));
6397
6398	if (fMatched)
6399	{
6400	hrc = onUSBDeviceAttach (device, NULL, fMaskedIfs);
6401
6402	/// @todo (r=dmik) warning reporting subsystem
6403
6404	if (hrc == S_OK)
6405	{
6406	LogFlowThisFunc (("Device attached\n"));
6407	device->captured (true);
6408	}
6409	}
6410	}
6411
6412	if (cbDevList < e->oNext)
6413	{
6414	LogWarningThisFunc (("cbDevList %d > oNext %d\n",
6415	cbDevList, e->oNext));
6416	break;
6417	}
6418
6419	cbDevList -= e->oNext;
6420
6421	e = (VRDPUSBDEVICEDESC )((uint8_t )e + e->oNext);
6422	}
6423
6424	/*
6425	* Remove dirty devices, that is those which are not reported by the server anymore.
6426	*/
6427	for (;;)
6428	{
6429	ComObjPtr <RemoteUSBDevice> device;
6430
6431	RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
6432	while (it != mRemoteUSBDevices.end())
6433	{
6434	if ((*it)->dirty ())
6435	{
6436	device = *it;
6437	break;
6438	}
6439
6440	++ it;
6441	}
6442
6443	if (!device)
6444	{
6445	break;
6446	}
6447
6448	USHORT vendorId = 0;
6449	device->COMGETTER(VendorId) (&vendorId);
6450
6451	USHORT productId = 0;
6452	device->COMGETTER(ProductId) (&productId);
6453
6454	Bstr product;
6455	device->COMGETTER(Product) (product.asOutParam());
6456
6457	LogRel(("Remote USB: ---- Vendor %04X. Product %04X. Name = [%ls].\n",
6458	vendorId, productId, product.raw ()
6459	));
6460
6461	/* Detach the device from VM. */
6462	if (device->captured ())
6463	{
6464	Bstr uuid;
6465	device->COMGETTER (Id) (uuid.asOutParam());
6466	onUSBDeviceDetach (uuid, NULL);
6467	}
6468
6469	/* And remove it from the list. */
6470	mRemoteUSBDevices.erase (it);
6471	}
6472
6473	LogFlowThisFuncLeave();
6474	}
6475
6476	/**
6477	* Thread function which starts the VM (also from saved state) and
6478	* track progress.
6479	*
6480	* @param Thread The thread id.
6481	* @param pvUser Pointer to a VMPowerUpTask structure.
6482	* @return VINF_SUCCESS (ignored).
6483	*
6484	* @note Locks the Console object for writing.
6485	*/
6486	/static/
6487	DECLCALLBACK (int) Console::powerUpThread (RTTHREAD Thread, void *pvUser)
6488	{
6489	LogFlowFuncEnter();
6490
6491	std::auto_ptr <VMPowerUpTask> task (static_cast <VMPowerUpTask *> (pvUser));
6492	AssertReturn (task.get(), VERR_INVALID_PARAMETER);
6493
6494	AssertReturn (!task->mConsole.isNull(), VERR_INVALID_PARAMETER);
6495	AssertReturn (!task->mProgress.isNull(), VERR_INVALID_PARAMETER);
6496
6497	#if defined(RT_OS_WINDOWS)
6498	{
6499	/* initialize COM */
6500	HRESULT hrc = CoInitializeEx (NULL,
6501	COINIT_MULTITHREADED \| COINIT_DISABLE_OLE1DDE \|
6502	COINIT_SPEED_OVER_MEMORY);
6503	LogFlowFunc (("CoInitializeEx()=%08X\n", hrc));
6504	}
6505	#endif
6506
6507	HRESULT rc = S_OK;
6508	int vrc = VINF_SUCCESS;
6509
6510	/* Set up a build identifier so that it can be seen from core dumps what
6511	* exact build was used to produce the core. */
6512	static char saBuildID[40];
6513	RTStrPrintf(saBuildID, sizeof(saBuildID), "%s%s%s%s VirtualBox %s r%d %s%s%s%s",
6514	"BU", "IL", "DI", "D", VBOX_VERSION_STRING, VBoxSVNRev (), "BU", "IL", "DI", "D");
6515
6516	ComObjPtr <Console> console = task->mConsole;
6517
6518	/* Note: no need to use addCaller() because VMPowerUpTask does that */
6519
6520	/* The lock is also used as a signal from the task initiator (which
6521	* releases it only after RTThreadCreate()) that we can start the job */
6522	AutoWriteLock alock (console);
6523
6524	/* sanity */
6525	Assert (console->mpVM == NULL);
6526
6527	try
6528	{
6529	/* wait for auto reset ops to complete so that we can successfully lock
6530	* the attached hard disks by calling LockMedia() below */
6531	for (VMPowerUpTask::ProgressList::const_iterator
6532	it = task->hardDiskProgresses.begin();
6533	it != task->hardDiskProgresses.end(); ++ it)
6534	{
6535	HRESULT rc2 = (*it)->WaitForCompletion (-1);
6536	AssertComRC (rc2);
6537	}
6538
6539	/* lock attached media. This method will also check their
6540	* accessibility. Note that the media will be unlocked automatically
6541	* by SessionMachine::setMachineState() when the VM is powered down. */
6542	rc = console->mControl->LockMedia();
6543	CheckComRCThrowRC (rc);
6544
6545	#ifdef VBOX_WITH_VRDP
6546
6547	/* Create the VRDP server. In case of headless operation, this will
6548	* also create the framebuffer, required at VM creation.
6549	*/
6550	ConsoleVRDPServer *server = console->consoleVRDPServer();
6551	Assert (server);
6552
6553	/// @todo (dmik)
6554	// does VRDP server call Console from the other thread?
6555	// Not sure, so leave the lock just in case
6556	alock.leave();
6557	vrc = server->Launch();
6558	alock.enter();
6559
6560	if (VBOX_FAILURE (vrc))
6561	{
6562	Utf8Str errMsg;
6563	switch (vrc)
6564	{
6565	case VERR_NET_ADDRESS_IN_USE:
6566	{
6567	ULONG port = 0;
6568	console->mVRDPServer->COMGETTER(Port) (&port);
6569	errMsg = Utf8StrFmt (tr ("VRDP server port %d is already in use"),
6570	port);
6571	break;
6572	}
6573	case VERR_FILE_NOT_FOUND:
6574	{
6575	errMsg = Utf8StrFmt (tr ("Could not load the VRDP library"));
6576	break;
6577	}
6578	default:
6579	errMsg = Utf8StrFmt (tr ("Failed to launch VRDP server (%Rrc)"),
6580	vrc);
6581	}
6582	LogRel (("Failed to launch VRDP server (%Rrc), error message: '%s'\n",
6583	vrc, errMsg.raw()));
6584	throw setError (E_FAIL, errMsg);
6585	}
6586
6587	#endif /* VBOX_WITH_VRDP */
6588
6589	ComPtr <IMachine> pMachine = console->machine();
6590	ULONG cCpus = 1;
6591	pMachine->COMGETTER(CPUCount)(&cCpus);
6592
6593	/*
6594	* Create the VM
6595	*/
6596	PVM pVM;
6597	/*
6598	* leave the lock since EMT will call Console. It's safe because
6599	* mMachineState is either Starting or Restoring state here.
6600	*/
6601	alock.leave();
6602
6603	vrc = VMR3Create (cCpus, task->mSetVMErrorCallback, task.get(),
6604	task->mConfigConstructor, static_cast <Console *> (console),
6605	&pVM);
6606
6607	alock.enter();
6608
6609	#ifdef VBOX_WITH_VRDP
6610	/* Enable client connections to the server. */
6611	console->consoleVRDPServer()->EnableConnections ();
6612	#endif /* VBOX_WITH_VRDP */
6613
6614	if (VBOX_SUCCESS (vrc))
6615	{
6616	do
6617	{
6618	/*
6619	* Register our load/save state file handlers
6620	*/
6621	vrc = SSMR3RegisterExternal (pVM,
6622	sSSMConsoleUnit, 0 /* iInstance */, sSSMConsoleVer,
6623	0 /* cbGuess */,
6624	NULL, saveStateFileExec, NULL, NULL, loadStateFileExec, NULL,
6625	static_cast <Console *> (console));
6626	AssertRC (vrc);
6627	if (VBOX_FAILURE (vrc))
6628	break;
6629
6630	vrc = static_cast <Console *>(console)->getDisplay()->registerSSM(pVM);
6631	AssertRC (vrc);
6632	if (VBOX_FAILURE (vrc))
6633	break;
6634
6635	/*
6636	* Synchronize debugger settings
6637	*/
6638	MachineDebugger *machineDebugger = console->getMachineDebugger();
6639	if (machineDebugger)
6640	{
6641	machineDebugger->flushQueuedSettings();
6642	}
6643
6644	/*
6645	* Shared Folders
6646	*/
6647	if (console->getVMMDev()->isShFlActive())
6648	{
6649	/// @todo (dmik)
6650	// does the code below call Console from the other thread?
6651	// Not sure, so leave the lock just in case
6652	alock.leave();
6653
6654	for (SharedFolderDataMap::const_iterator
6655	it = task->mSharedFolders.begin();
6656	it != task->mSharedFolders.end();
6657	++ it)
6658	{
6659	rc = console->createSharedFolder ((it).first, (it).second);
6660	CheckComRCBreakRC (rc);
6661	}
6662
6663	/* enter the lock again */
6664	alock.enter();
6665
6666	CheckComRCBreakRC (rc);
6667	}
6668
6669	/*
6670	* Capture USB devices.
6671	*/
6672	rc = console->captureUSBDevices (pVM);
6673	CheckComRCBreakRC (rc);
6674
6675	/* leave the lock before a lengthy operation */
6676	alock.leave();
6677
6678	/* Load saved state? */
6679	if (task->mSavedStateFile.length())
6680	{
6681	LogFlowFunc (("Restoring saved state from '%s'...\n",
6682	task->mSavedStateFile.raw()));
6683
6684	vrc = VMR3Load (pVM, task->mSavedStateFile,
6685	Console::stateProgressCallback,
6686	static_cast <VMProgressTask *> (task.get()));
6687
6688	if (VBOX_SUCCESS (vrc))
6689	{
6690	if (task->mStartPaused)
6691	/* done */
6692	console->setMachineState (MachineState_Paused);
6693	else
6694	{
6695	/* Start/Resume the VM execution */
6696	vrc = VMR3Resume (pVM);
6697	AssertRC (vrc);
6698	}
6699	}
6700
6701	/* Power off in case we failed loading or resuming the VM */
6702	if (VBOX_FAILURE (vrc))
6703	{
6704	int vrc2 = VMR3PowerOff (pVM);
6705	AssertRC (vrc2);
6706	}
6707	}
6708	else if (task->mStartPaused)
6709	/* done */
6710	console->setMachineState (MachineState_Paused);
6711	else
6712	{
6713	/* Power on the VM (i.e. start executing) */
6714	vrc = VMR3PowerOn(pVM);
6715	AssertRC (vrc);
6716	}
6717
6718	/* enter the lock again */
6719	alock.enter();
6720	}
6721	while (0);
6722
6723	/* On failure, destroy the VM */
6724	if (FAILED (rc) \|\| VBOX_FAILURE (vrc))
6725	{
6726	/* preserve existing error info */
6727	ErrorInfoKeeper eik;
6728
6729	/* powerDown() will call VMR3Destroy() and do all necessary
6730	* cleanup (VRDP, USB devices) */
6731	HRESULT rc2 = console->powerDown();
6732	AssertComRC (rc2);
6733	}
6734	else
6735	{
6736	/*
6737	* Deregister the VMSetError callback. This is necessary as the
6738	* pfnVMAtError() function passed to VMR3Create() is supposed to
6739	* be sticky but our error callback isn't.
6740	*/
6741	alock.leave();
6742	VMR3AtErrorDeregister(pVM, task->mSetVMErrorCallback, task.get());
6743	/** @todo register another VMSetError callback? */
6744	alock.enter();
6745	}
6746	}
6747	else
6748	{
6749	/*
6750	* If VMR3Create() failed it has released the VM memory.
6751	*/
6752	console->mpVM = NULL;
6753	}
6754
6755	if (SUCCEEDED (rc) && VBOX_FAILURE (vrc))
6756	{
6757	/* If VMR3Create() or one of the other calls in this function fail,
6758	* an appropriate error message has been set in task->mErrorMsg.
6759	* However since that happens via a callback, the rc status code in
6760	* this function is not updated.
6761	*/
6762	if (!task->mErrorMsg.length())
6763	{
6764	/* If the error message is not set but we've got a failure,
6765	* convert the VBox status code into a meaningfulerror message.
6766	* This becomes unused once all the sources of errors set the
6767	* appropriate error message themselves.
6768	*/
6769	AssertMsgFailed (("Missing error message during powerup for "
6770	"status code %Rrc\n", vrc));
6771	task->mErrorMsg = Utf8StrFmt (
6772	tr ("Failed to start VM execution (%Rrc)"), vrc);
6773	}
6774
6775	/* Set the error message as the COM error.
6776	* Progress::notifyComplete() will pick it up later. */
6777	throw setError (E_FAIL, task->mErrorMsg);
6778	}
6779	}
6780	catch (HRESULT aRC) { rc = aRC; }
6781
6782	if (console->mMachineState == MachineState_Starting \|\|
6783	console->mMachineState == MachineState_Restoring)
6784	{
6785	/* We are still in the Starting/Restoring state. This means one of:
6786	*
6787	* 1) we failed before VMR3Create() was called;
6788	* 2) VMR3Create() failed.
6789	*
6790	* In both cases, there is no need to call powerDown(), but we still
6791	* need to go back to the PoweredOff/Saved state. Reuse
6792	* vmstateChangeCallback() for that purpose.
6793	*/
6794
6795	/* preserve existing error info */
6796	ErrorInfoKeeper eik;
6797
6798	Assert (console->mpVM == NULL);
6799	vmstateChangeCallback (NULL, VMSTATE_TERMINATED, VMSTATE_CREATING,
6800	console);
6801	}
6802
6803	/*
6804	* Evaluate the final result. Note that the appropriate mMachineState value
6805	* is already set by vmstateChangeCallback() in all cases.
6806	*/
6807
6808	/* leave the lock, don't need it any more */
6809	alock.leave();
6810
6811	if (SUCCEEDED (rc))
6812	{
6813	/* Notify the progress object of the success */
6814	task->mProgress->notifyComplete (S_OK);
6815	}
6816	else
6817	{
6818	/* The progress object will fetch the current error info */
6819	task->mProgress->notifyComplete (rc);
6820
6821	LogRel (("Power up failed (vrc=%Rrc, rc=%Rhrc (%#08X))\n", vrc, rc, rc));
6822	}
6823
6824	#if defined(RT_OS_WINDOWS)
6825	/* uninitialize COM */
6826	CoUninitialize();
6827	#endif
6828
6829	LogFlowFuncLeave();
6830
6831	return VINF_SUCCESS;
6832	}
6833
6834
6835	/**
6836	* Reconfigures a VDI.
6837	*
6838	* @param pVM The VM handle.
6839	* @param lInstance The instance of the controller.
6840	* @param enmController The type of the controller.
6841	* @param hda The harddisk attachment.
6842	* @param phrc Where to store com error - only valid if we return VERR_GENERAL_FAILURE.
6843	* @return VBox status code.
6844	*/
6845	static DECLCALLBACK(int) reconfigureHardDisks(PVM pVM, ULONG lInstance,
6846	StorageControllerType_T enmController,
6847	IHardDiskAttachment *hda,
6848	HRESULT *phrc)
6849	{
6850	LogFlowFunc (("pVM=%p hda=%p phrc=%p\n", pVM, hda, phrc));
6851
6852	int rc;
6853	HRESULT hrc;
6854	Bstr bstr;
6855	*phrc = S_OK;
6856	#define RC_CHECK() do { if (VBOX_FAILURE(rc)) { AssertMsgFailed(("rc=%Rrc\n", rc)); return rc; } } while (0)
6857	#define H() do { if (FAILED(hrc)) { AssertMsgFailed(("hrc=%Rhrc (%#x)\n", hrc, hrc)); *phrc = hrc; return VERR_GENERAL_FAILURE; } } while (0)
6858
6859	/*
6860	* Figure out which IDE device this is.
6861	*/
6862	ComPtr<IHardDisk> hardDisk;
6863	hrc = hda->COMGETTER(HardDisk)(hardDisk.asOutParam()); H();
6864	LONG lDev;
6865	hrc = hda->COMGETTER(Device)(&lDev); H();
6866	LONG lPort;
6867	hrc = hda->COMGETTER(Port)(&lPort); H();
6868
6869	int iLUN;
6870	const char *pcszDevice = NULL;
6871	bool fSCSI = false;
6872
6873	switch (enmController)
6874	{
6875	case StorageControllerType_PIIX3:
6876	case StorageControllerType_PIIX4:
6877	case StorageControllerType_ICH6:
6878	{
6879	if (lPort >= 2 \|\| lPort < 0)
6880	{
6881	AssertMsgFailed(("invalid controller channel number: %d\n", lPort));
6882	return VERR_GENERAL_FAILURE;
6883	}
6884
6885	if (lDev >= 2 \|\| lDev < 0)
6886	{
6887	AssertMsgFailed(("invalid controller device number: %d\n", lDev));
6888	return VERR_GENERAL_FAILURE;
6889	}
6890
6891	iLUN = 2*lPort + lDev;
6892	pcszDevice = "piix3ide";
6893	break;
6894	}
6895	case StorageControllerType_IntelAhci:
6896	{
6897	iLUN = lPort;
6898	pcszDevice = "ahci";
6899	break;
6900	}
6901	case StorageControllerType_BusLogic:
6902	{
6903	iLUN = lPort;
6904	pcszDevice = "buslogic";
6905	fSCSI = true;
6906	break;
6907	}
6908	case StorageControllerType_LsiLogic:
6909	{
6910	iLUN = lPort;
6911	pcszDevice = "lsilogicscsi";
6912	fSCSI = true;
6913	break;
6914	}
6915	default:
6916	{
6917	AssertMsgFailed(("invalid disk controller type: %d\n", enmController));
6918	return VERR_GENERAL_FAILURE;
6919	}
6920	}
6921
6922	/** @todo this should be unified with the relevant part of
6923	* Console::configConstructor to avoid inconsistencies. */
6924
6925	/*
6926	* Is there an existing LUN? If not create it.
6927	* We ASSUME that this will NEVER collide with the DVD.
6928	*/
6929	PCFGMNODE pCfg;
6930	PCFGMNODE pLunL1;
6931
6932	/* SCSI has an extra driver between the device and the block driver. */
6933	if (fSCSI)
6934	pLunL1 = CFGMR3GetChildF(CFGMR3GetRoot(pVM), "Devices/%s/%u/LUN#%d/AttachedDriver/AttachedDriver/", pcszDevice, lInstance, iLUN);
6935	else
6936	pLunL1 = CFGMR3GetChildF(CFGMR3GetRoot(pVM), "Devices/%s/%u/LUN#%d/AttachedDriver/", pcszDevice, lInstance, iLUN);
6937
6938	if (!pLunL1)
6939	{
6940	PCFGMNODE pInst = CFGMR3GetChildF(CFGMR3GetRoot(pVM), "Devices/%s/%u/", pcszDevice, lInstance);
6941	AssertReturn(pInst, VERR_INTERNAL_ERROR);
6942
6943	PCFGMNODE pLunL0;
6944	rc = CFGMR3InsertNodeF(pInst, &pLunL0, "LUN#%d", iLUN); RC_CHECK();
6945
6946	if (fSCSI)
6947	{
6948	rc = CFGMR3InsertString(pLunL0, "Driver", "SCSI"); RC_CHECK();
6949	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
6950
6951	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
6952	}
6953
6954	rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
6955	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
6956	rc = CFGMR3InsertString(pCfg, "Type", "HardDisk"); RC_CHECK();
6957	rc = CFGMR3InsertInteger(pCfg, "Mountable", 0); RC_CHECK();
6958
6959	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
6960	rc = CFGMR3InsertString(pLunL1, "Driver", "VD"); RC_CHECK();
6961	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
6962	}
6963	else
6964	{
6965	#ifdef VBOX_STRICT
6966	char *pszDriver;
6967	rc = CFGMR3QueryStringAlloc(pLunL1, "Driver", &pszDriver); RC_CHECK();
6968	Assert(!strcmp(pszDriver, "VD"));
6969	MMR3HeapFree(pszDriver);
6970	#endif
6971
6972	pCfg = CFGMR3GetChild(pLunL1, "Config");
6973	AssertReturn(pCfg, VERR_INTERNAL_ERROR);
6974
6975	/* Here used to be a lot of code checking if things have changed,
6976	* but that's not really worth it, as with snapshots there is always
6977	* some change, so the code was just logging useless information in
6978	* a hard to analyze form. */
6979
6980	/*
6981	* Detach the driver and replace the config node.
6982	*/
6983	rc = PDMR3DeviceDetach(pVM, pcszDevice, 0, iLUN, PDMDEVATT_FLAGS_NOT_HOT_PLUG); RC_CHECK();
6984	CFGMR3RemoveNode(pCfg);
6985	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
6986	}
6987
6988	/*
6989	* Create the driver configuration.
6990	*/
6991	hrc = hardDisk->COMGETTER(Location)(bstr.asOutParam()); H();
6992	LogFlowFunc (("LUN#%d: leaf location '%ls'\n", iLUN, bstr.raw()));
6993	rc = CFGMR3InsertString(pCfg, "Path", Utf8Str(bstr)); RC_CHECK();
6994	hrc = hardDisk->COMGETTER(Format)(bstr.asOutParam()); H();
6995	LogFlowFunc (("LUN#%d: leaf format '%ls'\n", iLUN, bstr.raw()));
6996	rc = CFGMR3InsertString(pCfg, "Format", Utf8Str(bstr)); RC_CHECK();
6997
6998	/* Pass all custom parameters. */
6999	bool fHostIP = true;
7000	SafeArray <BSTR> names;
7001	SafeArray <BSTR> values;
7002	hrc = hardDisk->GetProperties (NULL,
7003	ComSafeArrayAsOutParam (names),
7004	ComSafeArrayAsOutParam (values)); H();
7005
7006	if (names.size() != 0)
7007	{
7008	PCFGMNODE pVDC;
7009	rc = CFGMR3InsertNode (pCfg, "VDConfig", &pVDC); RC_CHECK();
7010	for (size_t i = 0; i < names.size(); ++ i)
7011	{
7012	if (values [i])
7013	{
7014	Utf8Str name = names [i];
7015	Utf8Str value = values [i];
7016	rc = CFGMR3InsertString (pVDC, name, value);
7017	if ( !(name.compare("HostIPStack"))
7018	&& !(value.compare("0")))
7019	fHostIP = false;
7020	}
7021	}
7022	}
7023
7024	/* Create an inversed tree of parents. */
7025	ComPtr<IHardDisk> parentHardDisk = hardDisk;
7026	for (PCFGMNODE pParent = pCfg;;)
7027	{
7028	hrc = parentHardDisk->COMGETTER(Parent)(hardDisk.asOutParam()); H();
7029	if (hardDisk.isNull())
7030	break;
7031
7032	PCFGMNODE pCur;
7033	rc = CFGMR3InsertNode(pParent, "Parent", &pCur); RC_CHECK();
7034	hrc = hardDisk->COMGETTER(Location)(bstr.asOutParam()); H();
7035	rc = CFGMR3InsertString(pCur, "Path", Utf8Str(bstr)); RC_CHECK();
7036
7037	hrc = hardDisk->COMGETTER(Format)(bstr.asOutParam()); H();
7038	rc = CFGMR3InsertString(pCur, "Format", Utf8Str(bstr)); RC_CHECK();
7039
7040	/* Pass all custom parameters. */
7041	SafeArray <BSTR> names;
7042	SafeArray <BSTR> values;
7043	hrc = hardDisk->GetProperties (NULL,
7044	ComSafeArrayAsOutParam (names),
7045	ComSafeArrayAsOutParam (values));H();
7046
7047	if (names.size() != 0)
7048	{
7049	PCFGMNODE pVDC;
7050	rc = CFGMR3InsertNode (pCur, "VDConfig", &pVDC); RC_CHECK();
7051	for (size_t i = 0; i < names.size(); ++ i)
7052	{
7053	if (values [i])
7054	{
7055	Utf8Str name = names [i];
7056	Utf8Str value = values [i];
7057	rc = CFGMR3InsertString (pVDC, name, value);
7058	if ( !(name.compare("HostIPStack"))
7059	&& !(value.compare("0")))
7060	fHostIP = false;
7061	}
7062	}
7063	}
7064
7065
7066	/* Custom code: put marker to not use host IP stack to driver
7067	* configuration node. Simplifies life of DrvVD a bit. */
7068	if (!fHostIP)
7069	{
7070	rc = CFGMR3InsertInteger (pCfg, "HostIPStack", 0); RC_CHECK();
7071	}
7072
7073
7074	/* next */
7075	pParent = pCur;
7076	parentHardDisk = hardDisk;
7077	}
7078
7079	CFGMR3Dump(CFGMR3GetRoot(pVM));
7080
7081	/*
7082	* Attach the new driver.
7083	*/
7084	rc = PDMR3DeviceAttach(pVM, pcszDevice, 0, iLUN, NULL, PDMDEVATT_FLAGS_NOT_HOT_PLUG); RC_CHECK();
7085
7086	LogFlowFunc (("Returns success\n"));
7087	return rc;
7088	}
7089
7090
7091	/**
7092	* Thread for executing the saved state operation.
7093	*
7094	* @param Thread The thread handle.
7095	* @param pvUser Pointer to a VMSaveTask structure.
7096	* @return VINF_SUCCESS (ignored).
7097	*
7098	* @note Locks the Console object for writing.
7099	*/
7100	/static/
7101	DECLCALLBACK (int) Console::saveStateThread (RTTHREAD Thread, void *pvUser)
7102	{
7103	LogFlowFuncEnter();
7104
7105	std::auto_ptr <VMSaveTask> task (static_cast <VMSaveTask *> (pvUser));
7106	AssertReturn (task.get(), VERR_INVALID_PARAMETER);
7107
7108	Assert(task->mSavedStateFile.length());
7109	Assert(!task->mProgress.isNull());
7110
7111	const ComObjPtr <Console> &that = task->mConsole;
7112
7113	/*
7114	* Note: no need to use addCaller() to protect Console or addVMCaller() to
7115	* protect mpVM because VMSaveTask does that
7116	*/
7117
7118	Utf8Str errMsg;
7119	HRESULT rc = S_OK;
7120
7121	if (task->mIsSnapshot)
7122	{
7123	Assert (!task->mServerProgress.isNull());
7124	LogFlowFunc (("Waiting until the server creates differencing VDIs...\n"));
7125
7126	rc = task->mServerProgress->WaitForCompletion (-1);
7127	if (SUCCEEDED (rc))
7128	{
7129	LONG iRc = S_OK;
7130	rc = task->mServerProgress->COMGETTER(ResultCode) (&iRc);
7131	if (SUCCEEDED (rc))
7132	rc = iRc;
7133	}
7134	}
7135
7136	if (SUCCEEDED (rc))
7137	{
7138	LogFlowFunc (("Saving the state to '%s'...\n", task->mSavedStateFile.raw()));
7139
7140	int vrc = VMR3Save (that->mpVM, task->mSavedStateFile,
7141	Console::stateProgressCallback,
7142	static_cast <VMProgressTask *> (task.get()));
7143	if (VBOX_FAILURE (vrc))
7144	{
7145	errMsg = Utf8StrFmt (
7146	Console::tr ("Failed to save the machine state to '%s' (%Rrc)"),
7147	task->mSavedStateFile.raw(), vrc);
7148	rc = E_FAIL;
7149	}
7150	}
7151
7152	/* lock the console once we're going to access it */
7153	AutoWriteLock thatLock (that);
7154
7155	if (SUCCEEDED (rc))
7156	{
7157	if (task->mIsSnapshot)
7158	do
7159	{
7160	LogFlowFunc (("Reattaching new differencing hard disks...\n"));
7161
7162	com::SafeIfaceArray <IHardDiskAttachment> atts;
7163	rc = that->mMachine->
7164	COMGETTER(HardDiskAttachments) (ComSafeArrayAsOutParam (atts));
7165	if (FAILED (rc))
7166	break;
7167	for (size_t i = 0; i < atts.size(); ++ i)
7168	{
7169	PVMREQ pReq;
7170	ComPtr<IStorageController> controller;
7171	BSTR controllerName;
7172	ULONG lInstance;
7173	StorageControllerType_T enmController;
7174
7175	/*
7176	* We can't pass a storage controller object directly
7177	* (g++ complains about not being able to pass non POD types through '...')
7178	* so we have to query needed values here and pass them.
7179	*/
7180	rc = atts[i]->COMGETTER(Controller)(&controllerName);
7181	if (FAILED (rc))
7182	break;
7183
7184	rc = that->mMachine->GetStorageControllerByName(controllerName, controller.asOutParam());
7185	if (FAILED (rc))
7186	break;
7187
7188	rc = controller->COMGETTER(ControllerType)(&enmController);
7189	rc = controller->COMGETTER(Instance)(&lInstance);
7190	/*
7191	* don't leave the lock since reconfigureHardDisks isn't going
7192	* to access Console.
7193	*/
7194	int vrc = VMR3ReqCall (that->mpVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
7195	(PFNRT)reconfigureHardDisks, 5, that->mpVM, lInstance,
7196	enmController, atts [i], &rc);
7197	if (VBOX_SUCCESS (rc))
7198	rc = pReq->iStatus;
7199	VMR3ReqFree (pReq);
7200	if (FAILED (rc))
7201	break;
7202	if (VBOX_FAILURE (vrc))
7203	{
7204	errMsg = Utf8StrFmt (Console::tr ("%Rrc"), vrc);
7205	rc = E_FAIL;
7206	break;
7207	}
7208	}
7209	}
7210	while (0);
7211	}
7212
7213	/* finalize the procedure regardless of the result */
7214	if (task->mIsSnapshot)
7215	{
7216	/*
7217	* finalize the requested snapshot object.
7218	* This will reset the machine state to the state it had right
7219	* before calling mControl->BeginTakingSnapshot().
7220	*/
7221	that->mControl->EndTakingSnapshot (SUCCEEDED (rc));
7222	}
7223	else
7224	{
7225	/*
7226	* finalize the requested save state procedure.
7227	* In case of success, the server will set the machine state to Saved;
7228	* in case of failure it will reset the it to the state it had right
7229	* before calling mControl->BeginSavingState().
7230	*/
7231	that->mControl->EndSavingState (SUCCEEDED (rc));
7232	}
7233
7234	/* synchronize the state with the server */
7235	if (task->mIsSnapshot \|\| FAILED (rc))
7236	{
7237	if (task->mLastMachineState == MachineState_Running)
7238	{
7239	/* restore the paused state if appropriate */
7240	that->setMachineStateLocally (MachineState_Paused);
7241	/* restore the running state if appropriate */
7242	that->Resume();
7243	}
7244	else
7245	that->setMachineStateLocally (task->mLastMachineState);
7246	}
7247	else
7248	{
7249	/*
7250	* The machine has been successfully saved, so power it down
7251	* (vmstateChangeCallback() will set state to Saved on success).
7252	* Note: we release the task's VM caller, otherwise it will
7253	* deadlock.
7254	*/
7255	task->releaseVMCaller();
7256
7257	rc = that->powerDown();
7258	}
7259
7260	/* notify the progress object about operation completion */
7261	if (SUCCEEDED (rc))
7262	task->mProgress->notifyComplete (S_OK);
7263	else
7264	{
7265	if (errMsg.length())
7266	task->mProgress->notifyComplete(rc,
7267	COM_IIDOF(IConsole),
7268	Console::getComponentName(),
7269	errMsg);
7270	else
7271	task->mProgress->notifyComplete (rc);
7272	}
7273
7274	LogFlowFuncLeave();
7275	return VINF_SUCCESS;
7276	}
7277
7278	/**
7279	* Thread for powering down the Console.
7280	*
7281	* @param Thread The thread handle.
7282	* @param pvUser Pointer to the VMTask structure.
7283	* @return VINF_SUCCESS (ignored).
7284	*
7285	* @note Locks the Console object for writing.
7286	*/
7287	/static/
7288	DECLCALLBACK (int) Console::powerDownThread (RTTHREAD Thread, void *pvUser)
7289	{
7290	LogFlowFuncEnter();
7291
7292	std::auto_ptr <VMProgressTask> task (static_cast <VMProgressTask *> (pvUser));
7293	AssertReturn (task.get(), VERR_INVALID_PARAMETER);
7294
7295	AssertReturn (task->isOk(), VERR_GENERAL_FAILURE);
7296
7297	const ComObjPtr <Console> &that = task->mConsole;
7298
7299	/* Note: no need to use addCaller() to protect Console because VMTask does
7300	* that */
7301
7302	/* wait until the method tat started us returns */
7303	AutoWriteLock thatLock (that);
7304
7305	/* release VM caller to avoid the powerDown() deadlock */
7306	task->releaseVMCaller();
7307
7308	that->powerDown (task->mProgress);
7309
7310	LogFlowFuncLeave();
7311	return VINF_SUCCESS;
7312	}
7313
7314	/**
7315	* The Main status driver instance data.
7316	*/
7317	typedef struct DRVMAINSTATUS
7318	{
7319	/** The LED connectors. */
7320	PDMILEDCONNECTORS ILedConnectors;
7321	/** Pointer to the LED ports interface above us. */
7322	PPDMILEDPORTS pLedPorts;
7323	/** Pointer to the array of LED pointers. */
7324	PPDMLED *papLeds;
7325	/** The unit number corresponding to the first entry in the LED array. */
7326	RTUINT iFirstLUN;
7327	/** The unit number corresponding to the last entry in the LED array.
7328	* (The size of the LED array is iLastLUN - iFirstLUN + 1.) */
7329	RTUINT iLastLUN;
7330	} DRVMAINSTATUS, *PDRVMAINSTATUS;
7331
7332
7333	/**
7334	* Notification about a unit which have been changed.
7335	*
7336	* The driver must discard any pointers to data owned by
7337	* the unit and requery it.
7338	*
7339	* @param pInterface Pointer to the interface structure containing the called function pointer.
7340	* @param iLUN The unit number.
7341	*/
7342	DECLCALLBACK(void) Console::drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN)
7343	{
7344	PDRVMAINSTATUS pData = (PDRVMAINSTATUS)(void *)pInterface;
7345	if (iLUN >= pData->iFirstLUN && iLUN <= pData->iLastLUN)
7346	{
7347	PPDMLED pLed;
7348	int rc = pData->pLedPorts->pfnQueryStatusLed(pData->pLedPorts, iLUN, &pLed);
7349	if (VBOX_FAILURE(rc))
7350	pLed = NULL;
7351	ASMAtomicXchgPtr((void * volatile *)&pData->papLeds[iLUN - pData->iFirstLUN], pLed);
7352	Log(("drvStatus_UnitChanged: iLUN=%d pLed=%p\n", iLUN, pLed));
7353	}
7354	}
7355
7356
7357	/**
7358	* Queries an interface to the driver.
7359	*
7360	* @returns Pointer to interface.
7361	* @returns NULL if the interface was not supported by the driver.
7362	* @param pInterface Pointer to this interface structure.
7363	* @param enmInterface The requested interface identification.
7364	*/
7365	DECLCALLBACK(void *) Console::drvStatus_QueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
7366	{
7367	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
7368	PDRVMAINSTATUS pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINSTATUS);
7369	switch (enmInterface)
7370	{
7371	case PDMINTERFACE_BASE:
7372	return &pDrvIns->IBase;
7373	case PDMINTERFACE_LED_CONNECTORS:
7374	return &pDrv->ILedConnectors;
7375	default:
7376	return NULL;
7377	}
7378	}
7379
7380
7381	/**
7382	* Destruct a status driver instance.
7383	*
7384	* @returns VBox status.
7385	* @param pDrvIns The driver instance data.
7386	*/
7387	DECLCALLBACK(void) Console::drvStatus_Destruct(PPDMDRVINS pDrvIns)
7388	{
7389	PDRVMAINSTATUS pData = PDMINS_2_DATA(pDrvIns, PDRVMAINSTATUS);
7390	LogFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
7391	if (pData->papLeds)
7392	{
7393	unsigned iLed = pData->iLastLUN - pData->iFirstLUN + 1;
7394	while (iLed-- > 0)
7395	ASMAtomicXchgPtr((void * volatile *)&pData->papLeds[iLed], NULL);
7396	}
7397	}
7398
7399
7400	/**
7401	* Construct a status driver instance.
7402	*
7403	* @returns VBox status.
7404	* @param pDrvIns The driver instance data.
7405	* If the registration structure is needed, pDrvIns->pDrvReg points to it.
7406	* @param pCfgHandle Configuration node handle for the driver. Use this to obtain the configuration
7407	* of the driver instance. It's also found in pDrvIns->pCfgHandle, but like
7408	* iInstance it's expected to be used a bit in this function.
7409	*/
7410	DECLCALLBACK(int) Console::drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
7411	{
7412	PDRVMAINSTATUS pData = PDMINS_2_DATA(pDrvIns, PDRVMAINSTATUS);
7413	LogFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
7414
7415	/*
7416	* Validate configuration.
7417	*/
7418	if (!CFGMR3AreValuesValid(pCfgHandle, "papLeds\0First\0Last\0"))
7419	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
7420	PPDMIBASE pBaseIgnore;
7421	int rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, &pBaseIgnore);
7422	if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
7423	{
7424	AssertMsgFailed(("Configuration error: Not possible to attach anything to this driver!\n"));
7425	return VERR_PDM_DRVINS_NO_ATTACH;
7426	}
7427
7428	/*
7429	* Data.
7430	*/
7431	pDrvIns->IBase.pfnQueryInterface = Console::drvStatus_QueryInterface;
7432	pData->ILedConnectors.pfnUnitChanged = Console::drvStatus_UnitChanged;
7433
7434	/*
7435	* Read config.
7436	*/
7437	rc = CFGMR3QueryPtr(pCfgHandle, "papLeds", (void **)&pData->papLeds);
7438	if (VBOX_FAILURE(rc))
7439	{
7440	AssertMsgFailed(("Configuration error: Failed to query the \"papLeds\" value! rc=%Rrc\n", rc));
7441	return rc;
7442	}
7443
7444	rc = CFGMR3QueryU32(pCfgHandle, "First", &pData->iFirstLUN);
7445	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
7446	pData->iFirstLUN = 0;
7447	else if (VBOX_FAILURE(rc))
7448	{
7449	AssertMsgFailed(("Configuration error: Failed to query the \"First\" value! rc=%Rrc\n", rc));
7450	return rc;
7451	}
7452
7453	rc = CFGMR3QueryU32(pCfgHandle, "Last", &pData->iLastLUN);
7454	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
7455	pData->iLastLUN = 0;
7456	else if (VBOX_FAILURE(rc))
7457	{
7458	AssertMsgFailed(("Configuration error: Failed to query the \"Last\" value! rc=%Rrc\n", rc));
7459	return rc;
7460	}
7461	if (pData->iFirstLUN > pData->iLastLUN)
7462	{
7463	AssertMsgFailed(("Configuration error: Invalid unit range %u-%u\n", pData->iFirstLUN, pData->iLastLUN));
7464	return VERR_GENERAL_FAILURE;
7465	}
7466
7467	/*
7468	* Get the ILedPorts interface of the above driver/device and
7469	* query the LEDs we want.
7470	*/
7471	pData->pLedPorts = (PPDMILEDPORTS)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_LED_PORTS);
7472	if (!pData->pLedPorts)
7473	{
7474	AssertMsgFailed(("Configuration error: No led ports interface above!\n"));
7475	return VERR_PDM_MISSING_INTERFACE_ABOVE;
7476	}
7477
7478	for (unsigned i = pData->iFirstLUN; i <= pData->iLastLUN; i++)
7479	Console::drvStatus_UnitChanged(&pData->ILedConnectors, i);
7480
7481	return VINF_SUCCESS;
7482	}
7483
7484
7485	/**
7486	* Keyboard driver registration record.
7487	*/
7488	const PDMDRVREG Console::DrvStatusReg =
7489	{
7490	/* u32Version */
7491	PDM_DRVREG_VERSION,
7492	/* szDriverName */
7493	"MainStatus",
7494	/* pszDescription */
7495	"Main status driver (Main as in the API).",
7496	/* fFlags */
7497	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
7498	/* fClass. */
7499	PDM_DRVREG_CLASS_STATUS,
7500	/* cMaxInstances */
7501	~0,
7502	/* cbInstance */
7503	sizeof(DRVMAINSTATUS),
7504	/* pfnConstruct */
7505	Console::drvStatus_Construct,
7506	/* pfnDestruct */
7507	Console::drvStatus_Destruct,
7508	/* pfnIOCtl */
7509	NULL,
7510	/* pfnPowerOn */
7511	NULL,
7512	/* pfnReset */
7513	NULL,
7514	/* pfnSuspend */
7515	NULL,
7516	/* pfnResume */
7517	NULL,
7518	/* pfnDetach */
7519	NULL
7520	};
7521
7522	/**
7523	* Initializing the attachment type for the network adapters
7524	*/
7525	NetworkAttachmentType_T Console::meAttachmentType[] = {};
7526
7527	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/ConsoleImpl.cpp@ 21525

Download in other formats: