ConsoleImpl.cpp@ 14683

Last change on this file since 14683 was 14579, checked in by vboxsync, 16 years ago
Main: VirtualBoxBase::addCaller() now returns E_ACCESSDENIED. Also replaced E_UNEXPECTED with E_FAIL in all Assert* statements (for consistency).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 236.3 KB

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

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

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

Download in other formats: