ConsoleImpl.cpp@ 794

Last change on this file since 794 was 782, checked in by vboxsync, 18 years ago
Hack to prevent a deadlock between powerdown and EMT.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 243.5 KB

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

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

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

Download in other formats: