ConsoleImpl.h@ 94660

Last change on this file since 94660 was 94660, checked in by vboxsync, 3 years ago
doc/manual,Main,Frontends: API changes in preparation for full VM encryption, guarded by VBOX_WITH_FULL_VM_ENCRYPTION (disabled by default) and returning a not supported error for now, bugref:9955
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 50.3 KB

Line
1	/* $Id: ConsoleImpl.h 94660 2022-04-21 08:38:34Z vboxsync $ */
2	/** @file
3	* VBox Console COM Class definition
4	*/
5
6	/*
7	* Copyright (C) 2005-2022 Oracle Corporation
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 (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#ifndef MAIN_INCLUDED_ConsoleImpl_h
19	#define MAIN_INCLUDED_ConsoleImpl_h
20	#ifndef RT_WITHOUT_PRAGMA_ONCE
21	# pragma once
22	#endif
23
24	#include "VirtualBoxBase.h"
25	#include "VBox/com/array.h"
26	#include "EventImpl.h"
27	#include "SecretKeyStore.h"
28	#include "ConsoleWrap.h"
29	#ifdef VBOX_WITH_RECORDING
30	# include "Recording.h"
31	#endif
32	#ifdef VBOX_WITH_CLOUD_NET
33	#include "CloudGateway.h"
34	#endif /* VBOX_WITH_CLOUD_NET */
35
36	class Guest;
37	class Keyboard;
38	class Mouse;
39	class Display;
40	class MachineDebugger;
41	class TeleporterStateSrc;
42	class OUSBDevice;
43	class RemoteUSBDevice;
44	class SharedFolder;
45	class VRDEServerInfo;
46	class EmulatedUSB;
47	class AudioVRDE;
48	#ifdef VBOX_WITH_AUDIO_RECORDING
49	class AudioVideoRec;
50	#endif
51	#ifdef VBOX_WITH_USB_CARDREADER
52	class UsbCardReader;
53	#endif
54	class ConsoleVRDPServer;
55	class VMMDev;
56	class Progress;
57	class BusAssignmentManager;
58	COM_STRUCT_OR_CLASS(IEventListener);
59	#ifdef VBOX_WITH_EXTPACK
60	class ExtPackManager;
61	#endif
62	class VMMDevMouseInterface;
63	class DisplayMouseInterface;
64	class VMPowerUpTask;
65	class VMPowerDownTask;
66	class NvramStore;
67
68	#include <iprt/uuid.h>
69	#include <iprt/memsafer.h>
70	#include <VBox/RemoteDesktop/VRDE.h>
71	#include <VBox/vmm/pdmdrv.h>
72	#ifdef VBOX_WITH_GUEST_PROPS
73	# include <VBox/HostServices/GuestPropertySvc.h> /* For the property notification callback */
74	#endif
75	#ifdef VBOX_WITH_USB
76	# include <VBox/vrdpusb.h>
77	#endif
78
79	#if defined(VBOX_WITH_GUEST_PROPS) \|\| defined(VBOX_WITH_SHARED_CLIPBOARD) \
80	\|\| defined(VBOX_WITH_DRAG_AND_DROP)
81	# include "HGCM.h" /** @todo It should be possible to register a service
82	* extension using a VMMDev callback. */
83	#endif
84
85	struct VUSBIRHCONFIG;
86	typedef struct VUSBIRHCONFIG *PVUSBIRHCONFIG;
87
88	#include <list>
89	#include <vector>
90
91	// defines
92	///////////////////////////////////////////////////////////////////////////////
93
94	/**
95	* Checks the availability of the underlying VM device driver corresponding
96	* to the COM interface (IKeyboard, IMouse, IDisplay, etc.). When the driver is
97	* not available (NULL), sets error info and returns returns E_ACCESSDENIED.
98	* The translatable error message is defined in null context.
99	*
100	* Intended to used only within Console children (i.e. Keyboard, Mouse,
101	* Display, etc.).
102	*
103	* @param drv driver pointer to check (compare it with NULL)
104	*/
105	#define CHECK_CONSOLE_DRV(drv) \
106	do { \
107	if (!!(drv)) {} \
108	else return setError(E_ACCESSDENIED, Console::tr("The console is not powered up (%Rfn)"), __FUNCTION__); \
109	} while (0)
110
111	// Console
112	///////////////////////////////////////////////////////////////////////////////
113
114	class ConsoleMouseInterface
115	{
116	public:
117	virtual ~ConsoleMouseInterface() { }
118	virtual VMMDevMouseInterface *i_getVMMDevMouseInterface(){return NULL;}
119	virtual DisplayMouseInterface *i_getDisplayMouseInterface(){return NULL;}
120	virtual void i_onMouseCapabilityChange(BOOL supportsAbsolute,
121	BOOL supportsRelative,
122	BOOL supportsMT,
123	BOOL needsHostCursor){NOREF(supportsAbsolute); NOREF(supportsRelative); NOREF(supportsMT); NOREF(needsHostCursor);}
124	};
125
126	/** IConsole implementation class */
127	class ATL_NO_VTABLE Console :
128	public ConsoleWrap,
129	public ConsoleMouseInterface
130	{
131
132	public:
133
134	DECLARE_COMMON_CLASS_METHODS(Console)
135
136	HRESULT FinalConstruct();
137	void FinalRelease();
138
139	// public initializers/uninitializers for internal purposes only
140	HRESULT initWithMachine(IMachine aMachine, IInternalMachineControl aControl, LockType_T aLockType);
141	void uninit();
142
143
144	// public methods for internal purposes only
145
146	/*
147	* Note: the following methods do not increase refcount. intended to be
148	* called only by the VM execution thread.
149	*/
150
151	PCVMMR3VTABLE i_getVMMVTable() const RT_NOEXCEPT { return mpVMM; }
152	Guest *i_getGuest() const { return mGuest; }
153	Keyboard *i_getKeyboard() const { return mKeyboard; }
154	Mouse *i_getMouse() const { return mMouse; }
155	Display *i_getDisplay() const { return mDisplay; }
156	MachineDebugger *i_getMachineDebugger() const { return mDebugger; }
157	#ifdef VBOX_WITH_AUDIO_VRDE
158	AudioVRDE *i_getAudioVRDE() const { return mAudioVRDE; }
159	#endif
160	#ifdef VBOX_WITH_RECORDING
161	int i_recordingCreate(void);
162	void i_recordingDestroy(void);
163	int i_recordingEnable(BOOL fEnable, util::AutoWriteLock *pAutoLock);
164	int i_recordingGetSettings(settings::RecordingSettings &Settings);
165	int i_recordingStart(util::AutoWriteLock *pAutoLock = NULL);
166	int i_recordingStop(util::AutoWriteLock *pAutoLock = NULL);
167	# ifdef VBOX_WITH_AUDIO_RECORDING
168	AudioVideoRec *i_recordingGetAudioDrv(void) const { return mRecording.mAudioRec; }
169	# endif
170	RecordingContext *i_recordingGetContext(void) const { return mRecording.mpCtx; }
171	# ifdef VBOX_WITH_AUDIO_RECORDING
172	HRESULT i_recordingSendAudio(const void *pvData, size_t cbData, uint64_t uDurationMs);
173	# endif
174	#endif
175
176	const ComPtr<IMachine> &i_machine() const { return mMachine; }
177	const Bstr &i_getId() const { return mstrUuid; }
178
179	bool i_useHostClipboard() { return mfUseHostClipboard; }
180
181	/** Method is called only from ConsoleVRDPServer */
182	IVRDEServer *i_getVRDEServer() const { return mVRDEServer; }
183
184	ConsoleVRDPServer *i_consoleVRDPServer() const { return mConsoleVRDPServer; }
185
186	HRESULT i_updateMachineState(MachineState_T aMachineState);
187	HRESULT i_getNominalState(MachineState_T &aNominalState);
188	Utf8Str i_getAudioAdapterDeviceName(IAudioAdapter *aAudioAdapter);
189
190	// events from IInternalSessionControl
191	HRESULT i_onNetworkAdapterChange(INetworkAdapter *aNetworkAdapter, BOOL changeAdapter);
192	HRESULT i_onAudioAdapterChange(IAudioAdapter *aAudioAdapter);
193	HRESULT i_onSerialPortChange(ISerialPort *aSerialPort);
194	HRESULT i_onParallelPortChange(IParallelPort *aParallelPort);
195	HRESULT i_onStorageControllerChange(const com::Guid& aMachineId, const com::Utf8Str& aControllerName);
196	HRESULT i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
197	HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
198	HRESULT i_onCPUExecutionCapChange(ULONG aExecutionCap);
199	HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode);
200	HRESULT i_onClipboardFileTransferModeChange(bool aEnabled);
201	HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
202	HRESULT i_onVRDEServerChange(BOOL aRestart);
203	HRESULT i_onRecordingChange(BOOL fEnable);
204	HRESULT i_onUSBControllerChange();
205	HRESULT i_onSharedFolderChange(BOOL aGlobal);
206	HRESULT i_onUSBDeviceAttach(IUSBDevice aDevice, IVirtualBoxErrorInfo aError, ULONG aMaskedIfs,
207	const Utf8Str &aCaptureFilename);
208	HRESULT i_onUSBDeviceDetach(IN_BSTR aId, IVirtualBoxErrorInfo *aError);
209	HRESULT i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
210	HRESULT i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
211	HRESULT i_onExtraDataChange(const Bstr &aMachineId, const Bstr &aKey, const Bstr &aVal);
212
213	HRESULT i_getGuestProperty(const Utf8Str &aName, Utf8Str aValue, LONG64 aTimestamp, Utf8Str *aFlags);
214	HRESULT i_setGuestProperty(const Utf8Str &aName, const Utf8Str &aValue, const Utf8Str &aFlags);
215	HRESULT i_deleteGuestProperty(const Utf8Str &aName);
216	HRESULT i_enumerateGuestProperties(const Utf8Str &aPatterns,
217	std::vector<Utf8Str> &aNames,
218	std::vector<Utf8Str> &aValues,
219	std::vector<LONG64> &aTimestamps,
220	std::vector<Utf8Str> &aFlags);
221	HRESULT i_onlineMergeMedium(IMediumAttachment *aMediumAttachment,
222	ULONG aSourceIdx, ULONG aTargetIdx,
223	IProgress *aProgress);
224	HRESULT i_reconfigureMediumAttachments(const std::vector<ComPtr<IMediumAttachment> > &aAttachments);
225	HRESULT i_onVMProcessPriorityChange(VMProcPriority_T priority);
226	int i_hgcmLoadService(const char pszServiceLibrary, const char pszServiceName);
227	VMMDev *i_getVMMDev() { return m_pVMMDev; }
228
229	#ifdef VBOX_WITH_EXTPACK
230	ExtPackManager *i_getExtPackManager();
231	#endif
232	EventSource *i_getEventSource() { return mEventSource; }
233	#ifdef VBOX_WITH_USB_CARDREADER
234	UsbCardReader *i_getUsbCardReader() { return mUsbCardReader; }
235	#endif
236
237	int i_VRDPClientLogon(uint32_t u32ClientId, const char pszUser, const char pszPassword, const char *pszDomain);
238	void i_VRDPClientStatusChange(uint32_t u32ClientId, const char *pszStatus);
239	void i_VRDPClientConnect(uint32_t u32ClientId);
240	void i_VRDPClientDisconnect(uint32_t u32ClientId, uint32_t fu32Intercepted);
241	void i_VRDPInterceptAudio(uint32_t u32ClientId);
242	void i_VRDPInterceptUSB(uint32_t u32ClientId, void **ppvIntercept);
243	void i_VRDPInterceptClipboard(uint32_t u32ClientId);
244
245	void i_processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList, bool fDescExt);
246	void i_reportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
247	ULONG aCpuKernel, ULONG aCpuIdle,
248	ULONG aMemTotal, ULONG aMemFree,
249	ULONG aMemBalloon, ULONG aMemShared,
250	ULONG aMemCache, ULONG aPageTotal,
251	ULONG aAllocVMM, ULONG aFreeVMM,
252	ULONG aBalloonedVMM, ULONG aSharedVMM,
253	ULONG aVmNetRx, ULONG aVmNetTx)
254	{
255	mControl->ReportVmStatistics(aValidStats, aCpuUser, aCpuKernel, aCpuIdle,
256	aMemTotal, aMemFree, aMemBalloon, aMemShared,
257	aMemCache, aPageTotal, aAllocVMM, aFreeVMM,
258	aBalloonedVMM, aSharedVMM, aVmNetRx, aVmNetTx);
259	}
260	void i_enableVMMStatistics(BOOL aEnable);
261
262	HRESULT i_pause(Reason_T aReason);
263	HRESULT i_resume(Reason_T aReason, AutoWriteLock &alock);
264	HRESULT i_saveState(Reason_T aReason, const ComPtr<IProgress> &aProgress,
265	const ComPtr<ISnapshot> &aSnapshot,
266	const Utf8Str &aStateFilePath, bool fPauseVM, bool &fLeftPaused);
267	HRESULT i_cancelSaveState();
268
269	// callback callers (partly; for some events console callbacks are notified
270	// directly from IInternalSessionControl event handlers declared above)
271	void i_onMousePointerShapeChange(bool fVisible, bool fAlpha,
272	uint32_t xHot, uint32_t yHot,
273	uint32_t width, uint32_t height,
274	const uint8_t *pu8Shape,
275	uint32_t cbShape);
276	void i_onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative,
277	BOOL supportsMT, BOOL needsHostCursor);
278	void i_onStateChange(MachineState_T aMachineState);
279	void i_onAdditionsStateChange();
280	void i_onAdditionsOutdated();
281	void i_onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock);
282	void i_onUSBDeviceStateChange(IUSBDevice *aDevice, bool aAttached,
283	IVirtualBoxErrorInfo *aError);
284	void i_onRuntimeError(BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage);
285	HRESULT i_onShowWindow(BOOL aCheck, BOOL aCanShow, LONG64 aWinId);
286	void i_onVRDEServerInfoChange();
287	HRESULT i_sendACPIMonitorHotPlugEvent();
288
289	static const PDMDRVREG DrvStatusReg;
290
291	static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *pcsz, ...);
292	static HRESULT i_setErrorStaticBoth(HRESULT aResultCode, int vrc, const char *pcsz, ...);
293	HRESULT i_setInvalidMachineStateError();
294
295	static const char *i_storageControllerTypeToStr(StorageControllerType_T enmCtrlType);
296	static HRESULT i_storageBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun);
297	// Called from event listener
298	HRESULT i_onNATRedirectRuleChanged(ULONG ulInstance, BOOL aNatRuleRemove,
299	NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort);
300	HRESULT i_onNATDnsChanged();
301
302	// Mouse interface
303	VMMDevMouseInterface *i_getVMMDevMouseInterface();
304	DisplayMouseInterface *i_getDisplayMouseInterface();
305
306	EmulatedUSB *i_getEmulatedUSB(void) { return mEmulatedUSB; }
307
308	/**
309	* Sets the disk encryption keys.
310	*
311	* @returns COM status code.
312	* @param strCfg The config for the disks.
313	*
314	* @note One line in the config string contains all required data for one disk.
315	* The format for one disk is some sort of comma separated value using
316	* key=value pairs.
317	* There are two keys defined at the moment:
318	* - uuid: The uuid of the base image the key is for (with or without)
319	* the curly braces.
320	* - dek: The data encryption key in base64 encoding
321	*/
322	HRESULT i_setDiskEncryptionKeys(const Utf8Str &strCfg);
323
324
325	#ifdef VBOX_WITH_GUEST_PROPS
326	// VMMDev needs:
327	HRESULT i_pullGuestProperties(ComSafeArrayOut(BSTR, names), ComSafeArrayOut(BSTR, values),
328	ComSafeArrayOut(LONG64, timestamps), ComSafeArrayOut(BSTR, flags));
329	static DECLCALLBACK(int) i_doGuestPropNotification(void pvExtension, uint32_t, void pvParms, uint32_t cbParms);
330	#endif
331
332	private:
333
334	// wrapped IConsole properties
335	HRESULT getMachine(ComPtr<IMachine> &aMachine);
336	HRESULT getState(MachineState_T *aState);
337	HRESULT getGuest(ComPtr<IGuest> &aGuest);
338	HRESULT getKeyboard(ComPtr<IKeyboard> &aKeyboard);
339	HRESULT getMouse(ComPtr<IMouse> &aMouse);
340	HRESULT getDisplay(ComPtr<IDisplay> &aDisplay);
341	HRESULT getDebugger(ComPtr<IMachineDebugger> &aDebugger);
342	HRESULT getUSBDevices(std::vector<ComPtr<IUSBDevice> > &aUSBDevices);
343	HRESULT getRemoteUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aRemoteUSBDevices);
344	HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
345	HRESULT getVRDEServerInfo(ComPtr<IVRDEServerInfo> &aVRDEServerInfo);
346	HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
347	HRESULT getAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttachedPCIDevices);
348	HRESULT getUseHostClipboard(BOOL *aUseHostClipboard);
349	HRESULT setUseHostClipboard(BOOL aUseHostClipboard);
350	HRESULT getEmulatedUSB(ComPtr<IEmulatedUSB> &aEmulatedUSB);
351
352	// wrapped IConsole methods
353	HRESULT powerUp(ComPtr<IProgress> &aProgress);
354	HRESULT powerUpPaused(ComPtr<IProgress> &aProgress);
355	HRESULT powerDown(ComPtr<IProgress> &aProgress);
356	HRESULT reset();
357	HRESULT pause();
358	HRESULT resume();
359	HRESULT powerButton();
360	HRESULT sleepButton();
361	HRESULT getPowerButtonHandled(BOOL *aHandled);
362	HRESULT getGuestEnteredACPIMode(BOOL *aEntered);
363	HRESULT getDeviceActivity(const std::vector<DeviceType_T> &aType,
364	std::vector<DeviceActivity_T> &aActivity);
365	HRESULT attachUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename);
366	HRESULT detachUSBDevice(const com::Guid &aId,
367	ComPtr<IUSBDevice> &aDevice);
368	HRESULT findUSBDeviceByAddress(const com::Utf8Str &aName,
369	ComPtr<IUSBDevice> &aDevice);
370	HRESULT findUSBDeviceById(const com::Guid &aId,
371	ComPtr<IUSBDevice> &aDevice);
372	HRESULT createSharedFolder(const com::Utf8Str &aName,
373	const com::Utf8Str &aHostPath,
374	BOOL aWritable,
375	BOOL aAutomount,
376	const com::Utf8Str &aAutoMountPoint);
377	HRESULT removeSharedFolder(const com::Utf8Str &aName);
378	HRESULT teleport(const com::Utf8Str &aHostname,
379	ULONG aTcpport,
380	const com::Utf8Str &aPassword,
381	ULONG aMaxDowntime,
382	ComPtr<IProgress> &aProgress);
383	HRESULT addEncryptionPassword(const com::Utf8Str &aId, const com::Utf8Str &aPassword,
384	BOOL aClearOnSuspend);
385	HRESULT addEncryptionPasswords(const std::vector<com::Utf8Str> &aIds, const std::vector<com::Utf8Str> &aPasswords,
386	BOOL aClearOnSuspend);
387	HRESULT removeEncryptionPassword(const com::Utf8Str &aId);
388	HRESULT clearAllEncryptionPasswords();
389
390	void notifyNatDnsChange(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice, ULONG ulInstanceMax);
391	Utf8Str VRDPServerErrorToMsg(int vrc);
392
393	/**
394	* Base template for AutoVMCaller and SafeVMPtr. Template arguments
395	* have the same meaning as arguments of Console::addVMCaller().
396	*/
397	template <bool taQuiet = false, bool taAllowNullVM = false>
398	class AutoVMCallerBase
399	{
400	public:
401	AutoVMCallerBase(Console *aThat) : mThat(aThat), mRC(E_FAIL)
402	{
403	Assert(aThat);
404	mRC = aThat->i_addVMCaller(taQuiet, taAllowNullVM);
405	}
406	~AutoVMCallerBase()
407	{
408	doRelease();
409	}
410	/** Decreases the number of callers before the instance is destroyed. */
411	void releaseCaller()
412	{
413	Assert(SUCCEEDED(mRC));
414	doRelease();
415	}
416	/** Restores the number of callers after by #release(). #rc() must be
417	* rechecked to ensure the operation succeeded. */
418	void addYY()
419	{
420	AssertReturnVoid(!SUCCEEDED(mRC));
421	mRC = mThat->i_addVMCaller(taQuiet, taAllowNullVM);
422	}
423	/** Returns the result of Console::addVMCaller() */
424	HRESULT rc() const { return mRC; }
425	/** Shortcut to SUCCEEDED(rc()) */
426	bool isOk() const { return SUCCEEDED(mRC); }
427	protected:
428	Console *mThat;
429	void doRelease()
430	{
431	if (SUCCEEDED(mRC))
432	{
433	mThat->i_releaseVMCaller();
434	mRC = E_FAIL;
435	}
436	}
437	private:
438	HRESULT mRC; /* Whether the caller was added. */
439	DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoVMCallerBase);
440	};
441
442	#if 0
443	/**
444	* Helper class that protects sections of code using the mpUVM pointer by
445	* automatically calling addVMCaller() on construction and
446	* releaseVMCaller() on destruction. Intended for Console methods dealing
447	* with mpUVM. The usage pattern is:
448	* <code>
449	* AutoVMCaller autoVMCaller(this);
450	* if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
451	* ...
452	* VMR3ReqCall (mpUVM, ...
453	* </code>
454	*
455	* @note Temporarily locks the argument for writing.
456	*
457	* @sa SafeVMPtr, SafeVMPtrQuiet
458	* @note Obsolete, use SafeVMPtr
459	*/
460	typedef AutoVMCallerBase<false, false> AutoVMCaller;
461	#endif
462
463	/**
464	* Same as AutoVMCaller but doesn't set extended error info on failure.
465	*
466	* @note Temporarily locks the argument for writing.
467	* @note Obsolete, use SafeVMPtrQuiet
468	*/
469	typedef AutoVMCallerBase<true, false> AutoVMCallerQuiet;
470
471	/**
472	* Same as AutoVMCaller but allows a null VM pointer (to trigger an error
473	* instead of assertion).
474	*
475	* @note Temporarily locks the argument for writing.
476	* @note Obsolete, use SafeVMPtr
477	*/
478	typedef AutoVMCallerBase<false, true> AutoVMCallerWeak;
479
480	/**
481	* Same as AutoVMCaller but doesn't set extended error info on failure
482	* and allows a null VM pointer (to trigger an error instead of
483	* assertion).
484	*
485	* @note Temporarily locks the argument for writing.
486	* @note Obsolete, use SafeVMPtrQuiet
487	*/
488	typedef AutoVMCallerBase<true, true> AutoVMCallerQuietWeak;
489
490	/**
491	* Base template for SafeVMPtr and SafeVMPtrQuiet.
492	*/
493	template<bool taQuiet = false>
494	class SafeVMPtrBase : public AutoVMCallerBase<taQuiet, true>
495	{
496	typedef AutoVMCallerBase<taQuiet, true> Base;
497	public:
498	SafeVMPtrBase(Console *aThat) : Base(aThat), mRC(E_FAIL), mpUVM(NULL), mpVMM(NULL)
499	{
500	if (Base::isOk())
501	mRC = aThat->i_safeVMPtrRetainer(&mpUVM, &mpVMM, taQuiet);
502	}
503	~SafeVMPtrBase()
504	{
505	doRelease();
506	}
507	/** Direct PUVM access. */
508	PUVM rawUVM() const { return mpUVM; }
509	/** Direct PCVMMR3VTABLE access. */
510	PCVMMR3VTABLE vtable() const { return mpVMM; }
511	/** Release the handles. */
512	void release()
513	{
514	Assert(SUCCEEDED(mRC));
515	doRelease();
516	}
517
518	/** The combined result of Console::addVMCaller() and Console::safeVMPtrRetainer */
519	HRESULT rc() const { return Base::isOk()? mRC: Base::rc(); }
520	/** Shortcut to SUCCEEDED(rc()) */
521	bool isOk() const { return SUCCEEDED(mRC) && Base::isOk(); }
522
523	private:
524	void doRelease()
525	{
526	if (SUCCEEDED(mRC))
527	{
528	Base::mThat->i_safeVMPtrReleaser(&mpUVM);
529	mRC = E_FAIL;
530	}
531	Base::doRelease();
532	}
533	HRESULT mRC; /* Whether the VM ptr was retained. */
534	PUVM mpUVM;
535	PCVMMR3VTABLE mpVMM;
536	DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SafeVMPtrBase);
537	};
538
539	public:
540
541	/*
542	* Helper class that safely manages the Console::mpUVM pointer
543	* by calling addVMCaller() on construction and releaseVMCaller() on
544	* destruction. Intended for Console children. The usage pattern is:
545	* <code>
546	* Console::SafeVMPtr ptrVM(mParent);
547	* if (!ptrVM.isOk())
548	* return ptrVM.rc();
549	* ...
550	* VMR3ReqCall(ptrVM.rawUVM(), ...
551	* ...
552	* printf("%p\n", ptrVM.rawUVM());
553	* </code>
554	*
555	* @note Temporarily locks the argument for writing.
556	*
557	* @sa SafeVMPtrQuiet, AutoVMCaller
558	*/
559	typedef SafeVMPtrBase<false> SafeVMPtr;
560
561	/**
562	* A deviation of SafeVMPtr that doesn't set the error info on failure.
563	* Intended for pieces of code that don't need to return the VM access
564	* failure to the caller. The usage pattern is:
565	* <code>
566	* Console::SafeVMPtrQuiet pVM(mParent);
567	* if (pVM.rc())
568	* VMR3ReqCall(pVM, ...
569	* return S_OK;
570	* </code>
571	*
572	* @note Temporarily locks the argument for writing.
573	*
574	* @sa SafeVMPtr, AutoVMCaller
575	*/
576	typedef SafeVMPtrBase<true> SafeVMPtrQuiet;
577
578	class SharedFolderData
579	{
580	public:
581	SharedFolderData()
582	{ }
583
584	SharedFolderData(const Utf8Str &aHostPath,
585	bool aWritable,
586	bool aAutoMount,
587	const Utf8Str &aAutoMountPoint)
588	: m_strHostPath(aHostPath)
589	, m_fWritable(aWritable)
590	, m_fAutoMount(aAutoMount)
591	, m_strAutoMountPoint(aAutoMountPoint)
592	{ }
593
594	/** Copy constructor. */
595	SharedFolderData(const SharedFolderData& aThat)
596	: m_strHostPath(aThat.m_strHostPath)
597	, m_fWritable(aThat.m_fWritable)
598	, m_fAutoMount(aThat.m_fAutoMount)
599	, m_strAutoMountPoint(aThat.m_strAutoMountPoint)
600	{ }
601
602	/** Copy assignment operator. */
603	SharedFolderData &operator=(SharedFolderData const &a_rThat) RT_NOEXCEPT
604	{
605	m_strHostPath = a_rThat.m_strHostPath;
606	m_fWritable = a_rThat.m_fWritable;
607	m_fAutoMount = a_rThat.m_fAutoMount;
608	m_strAutoMountPoint = a_rThat.m_strAutoMountPoint;
609
610	return *this;
611	}
612
613	Utf8Str m_strHostPath;
614	bool m_fWritable;
615	bool m_fAutoMount;
616	Utf8Str m_strAutoMountPoint;
617	};
618
619	/**
620	* Class for managing emulated USB MSDs.
621	*/
622	class USBStorageDevice
623	{
624	public:
625	USBStorageDevice()
626	{ }
627	/** The UUID associated with the USB device. */
628	RTUUID mUuid;
629	/** Port of the storage device. */
630	LONG iPort;
631	};
632
633	typedef std::map<Utf8Str, ComObjPtr<SharedFolder> > SharedFolderMap;
634	typedef std::map<Utf8Str, SharedFolderData> SharedFolderDataMap;
635	typedef std::map<Utf8Str, ComPtr<IMediumAttachment> > MediumAttachmentMap;
636	typedef std::list <USBStorageDevice> USBStorageDeviceList;
637
638	static void i_powerUpThreadTask(VMPowerUpTask *pTask);
639	static void i_powerDownThreadTask(VMPowerDownTask *pTask);
640
641	private:
642
643	typedef std::list <ComObjPtr<OUSBDevice> > USBDeviceList;
644	typedef std::list <ComObjPtr<RemoteUSBDevice> > RemoteUSBDeviceList;
645
646	HRESULT i_loadVMM(void) RT_NOEXCEPT;
647	HRESULT i_addVMCaller(bool aQuiet = false, bool aAllowNullVM = false);
648	void i_releaseVMCaller();
649	HRESULT i_safeVMPtrRetainer(PUVM a_ppUVM, PCVMMR3VTABLE a_ppVMM, bool aQuiet) RT_NOEXCEPT;
650	void i_safeVMPtrReleaser(PUVM *a_ppUVM);
651
652	HRESULT i_consoleInitReleaseLog(const ComPtr<IMachine> aMachine);
653
654	HRESULT i_powerUp(IProgress **aProgress, bool aPaused);
655	HRESULT i_powerDown(IProgress *aProgress = NULL);
656
657	/* Note: FreeBSD needs this whether netflt is used or not. */
658	#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) \|\| defined(RT_OS_FREEBSD))
659	HRESULT i_attachToTapInterface(INetworkAdapter *networkAdapter);
660	HRESULT i_detachFromTapInterface(INetworkAdapter *networkAdapter);
661	#endif
662	HRESULT i_powerDownHostInterfaces();
663
664	HRESULT i_setMachineState(MachineState_T aMachineState, bool aUpdateServer = true);
665	HRESULT i_setMachineStateLocally(MachineState_T aMachineState)
666	{
667	return i_setMachineState(aMachineState, false /* aUpdateServer */);
668	}
669
670	HRESULT i_findSharedFolder(const Utf8Str &strName,
671	ComObjPtr<SharedFolder> &aSharedFolder,
672	bool aSetError = false);
673
674	HRESULT i_fetchSharedFolders(BOOL aGlobal);
675	bool i_findOtherSharedFolder(const Utf8Str &straName,
676	SharedFolderDataMap::const_iterator &aIt);
677
678	HRESULT i_createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData);
679	HRESULT i_removeSharedFolder(const Utf8Str &strName);
680
681	HRESULT i_suspendBeforeConfigChange(PUVM pUVM, PCVMMR3VTABLE pVMM, AutoWriteLock pAlock, bool pfResume);
682	void i_resumeAfterConfigChange(PUVM pUVM, PCVMMR3VTABLE pVMM);
683
684	static DECLCALLBACK(int) i_configConstructor(PUVM pUVM, PVM pVM, PCVMMR3VTABLE pVMM, void *pvConsole);
685	void InsertConfigString(PCFGMNODE pNode, const char pcszName, const char pcszValue);
686	void InsertConfigString(PCFGMNODE pNode, const char *pcszName, const Utf8Str &rStrValue);
687	void InsertConfigString(PCFGMNODE pNode, const char *pcszName, const Bstr &rBstrValue);
688	void InsertConfigPassword(PCFGMNODE pNode, const char *pcszName, const Utf8Str &rStrValue);
689	void InsertConfigBytes(PCFGMNODE pNode, const char pcszName, const void pvBytes, size_t cbBytes);
690	void InsertConfigInteger(PCFGMNODE pNode, const char *pcszName, uint64_t u64Integer);
691	void InsertConfigNode(PCFGMNODE pNode, const char pcszName, PCFGMNODE ppChild);
692	void InsertConfigNodeF(PCFGMNODE pNode, PCFGMNODE ppChild, const char pszNameFormat, ...);
693	void RemoveConfigValue(PCFGMNODE pNode, const char *pcszName);
694	int SetBiosDiskInfo(ComPtr<IMachine> pMachine, PCFGMNODE pCfg, PCFGMNODE pBiosCfg,
695	Bstr controllerName, const char * const s_apszBiosConfig[4]);
696	void i_configAudioDriver(IVirtualBox pVirtualBox, IMachine pMachine, PCFGMNODE pLUN, const char *pszDriverName,
697	bool fAudioEnabledIn, bool fAudioEnabledOut);
698	int i_configConstructorInner(PUVM pUVM, PVM pVM, PCVMMR3VTABLE pVMM, AutoWriteLock *pAlock);
699	int i_configCfgmOverlay(PCFGMNODE pRoot, IVirtualBox pVirtualBox, IMachine pMachine);
700	int i_configDumpAPISettingsTweaks(IVirtualBox pVirtualBox, IMachine pMachine);
701
702	int i_configGraphicsController(PCFGMNODE pDevices,
703	const GraphicsControllerType_T graphicsController,
704	BusAssignmentManager *pBusMgr,
705	const ComPtr<IMachine> &ptrMachine,
706	const ComPtr<IGraphicsAdapter> &ptrGraphicsAdapter,
707	const ComPtr<IBIOSSettings> &ptrBiosSettings,
708	bool fHMEnabled);
709	int i_checkMediumLocation(IMedium pMedium, bool pfUseHostIOCache);
710	int i_unmountMediumFromGuest(PUVM pUVM, PCVMMR3VTABLE pVMM, StorageBus_T enmBus, DeviceType_T enmDevType,
711	const char *pcszDevice, unsigned uInstance, unsigned uLUN,
712	bool fForceUnmount) RT_NOEXCEPT;
713	int i_removeMediumDriverFromVm(PCFGMNODE pCtlInst,
714	const char *pcszDevice,
715	unsigned uInstance,
716	unsigned uLUN,
717	StorageBus_T enmBus,
718	bool fAttachDetach,
719	bool fHotplug,
720	bool fForceUnmount,
721	PUVM pUVM,
722	PCVMMR3VTABLE pVMM,
723	DeviceType_T enmDevType,
724	PCFGMNODE *ppLunL0);
725	int i_configMediumAttachment(const char *pcszDevice,
726	unsigned uInstance,
727	StorageBus_T enmBus,
728	bool fUseHostIOCache,
729	bool fBuiltinIoCache,
730	bool fInsertDiskIntegrityDrv,
731	bool fSetupMerge,
732	unsigned uMergeSource,
733	unsigned uMergeTarget,
734	IMediumAttachment *pMediumAtt,
735	MachineState_T aMachineState,
736	HRESULT *phrc,
737	bool fAttachDetach,
738	bool fForceUnmount,
739	bool fHotplug,
740	PUVM pUVM,
741	PCVMMR3VTABLE pVMM,
742	DeviceType_T *paLedDevType,
743	PCFGMNODE *ppLunL0);
744	int i_configMedium(PCFGMNODE pLunL0,
745	bool fPassthrough,
746	DeviceType_T enmType,
747	bool fUseHostIOCache,
748	bool fBuiltinIoCache,
749	bool fInsertDiskIntegrityDrv,
750	bool fSetupMerge,
751	unsigned uMergeSource,
752	unsigned uMergeTarget,
753	const char *pcszBwGroup,
754	bool fDiscard,
755	bool fNonRotational,
756	ComPtr<IMedium> ptrMedium,
757	MachineState_T aMachineState,
758	HRESULT *phrc);
759	int i_configMediumProperties(PCFGMNODE pCur, IMedium pMedium, bool pfHostIP, bool *pfEncrypted);
760	static DECLCALLBACK(int) i_reconfigureMediumAttachment(Console *pThis,
761	PUVM pUVM,
762	PCVMMR3VTABLE pVMM,
763	const char *pcszDevice,
764	unsigned uInstance,
765	StorageBus_T enmBus,
766	bool fUseHostIOCache,
767	bool fBuiltinIoCache,
768	bool fInsertDiskIntegrityDrv,
769	bool fSetupMerge,
770	unsigned uMergeSource,
771	unsigned uMergeTarget,
772	IMediumAttachment *aMediumAtt,
773	MachineState_T aMachineState,
774	HRESULT *phrc);
775	static DECLCALLBACK(int) i_changeRemovableMedium(Console *pThis,
776	PUVM pUVM,
777	PCVMMR3VTABLE pVMM,
778	const char *pcszDevice,
779	unsigned uInstance,
780	StorageBus_T enmBus,
781	bool fUseHostIOCache,
782	IMediumAttachment *aMediumAtt,
783	bool fForce);
784
785	HRESULT i_attachRawPCIDevices(PUVM pUVM, BusAssignmentManager *BusMgr, PCFGMNODE pDevices);
786	struct LEDSET;
787	typedef struct LEDSET *PLEDSET;
788	PPDMLED *i_getLedSet(uint32_t iLedSet);
789	uint32_t i_allocateDriverLeds(uint32_t cLeds, DeviceType_T enmType, DeviceType_T **ppSubTypes);
790	void i_attachStatusDriver(PCFGMNODE pCtlInst, DeviceType_T enmType,
791	uint32_t uFirst, uint32_t uLast,
792	DeviceType_T **ppaSubTypes,
793	Console::MediumAttachmentMap *pmapMediumAttachments,
794	const char *pcszDevice, unsigned uInstance);
795
796	int i_configNetwork(const char pszDevice, unsigned uInstance, unsigned uLun, INetworkAdapter aNetworkAdapter,
797	PCFGMNODE pCfg, PCFGMNODE pLunL0, PCFGMNODE pInst, bool fAttachDetach, bool fIgnoreConnectFailure,
798	PUVM pUVM, PCVMMR3VTABLE pVMM);
799	int i_configProxy(ComPtr<IVirtualBox> virtualBox, PCFGMNODE pCfg, const char *pcszPrefix, const com::Utf8Str &strIpAddr);
800
801	int i_configSerialPort(PCFGMNODE pInst, PortMode_T ePortMode, const char *pszPath, bool fServer);
802	static DECLCALLBACK(void) i_vmstateChangeCallback(PUVM pUVM, PCVMMR3VTABLE pVMM, VMSTATE enmState,
803	VMSTATE enmOldState, void *pvUser);
804	static DECLCALLBACK(int) i_unplugCpu(Console *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, VMCPUID idCpu);
805	static DECLCALLBACK(int) i_plugCpu(Console *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, VMCPUID idCpu);
806	HRESULT i_doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM, PCVMMR3VTABLE pVMM);
807	HRESULT i_doCPURemove(ULONG aCpu, PUVM pUVM, PCVMMR3VTABLE pVMM);
808	HRESULT i_doCPUAdd(ULONG aCpu, PUVM pUVM, PCVMMR3VTABLE pVMM);
809
810	HRESULT i_doNetworkAdapterChange(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice, unsigned uInstance,
811	unsigned uLun, INetworkAdapter *aNetworkAdapter);
812	static DECLCALLBACK(int) i_changeNetworkAttachment(Console pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, const char pszDevice,
813	unsigned uInstance, unsigned uLun, INetworkAdapter *aNetworkAdapter);
814	static DECLCALLBACK(int) i_changeSerialPortAttachment(Console pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, ISerialPort pSerialPort);
815
816	int i_changeClipboardMode(ClipboardMode_T aClipboardMode);
817	int i_changeClipboardFileTransferMode(bool aEnabled);
818	int i_changeDnDMode(DnDMode_T aDnDMode);
819
820	#ifdef VBOX_WITH_USB
821	HRESULT i_attachUSBDevice(IUSBDevice *aHostDevice, ULONG aMaskedIfs, const Utf8Str &aCaptureFilename);
822	HRESULT i_detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice);
823
824	static DECLCALLBACK(int) i_usbAttachCallback(Console that, PUVM pUVM, PCVMMR3VTABLE pVMM, IUSBDevice aHostDevice,
825	PCRTUUID aUuid, const char aBackend, const char aAddress,
826	PCFGMNODE pRemoteCfg, USBConnectionSpeed_T enmSpeed, ULONG aMaskedIfs,
827	const char *pszCaptureFilename);
828	static DECLCALLBACK(int) i_usbDetachCallback(Console *that, PUVM pUVM, PCVMMR3VTABLE pVMM, PCRTUUID aUuid);
829	static DECLCALLBACK(PREMOTEUSBCALLBACK) i_usbQueryRemoteUsbBackend(void *pvUser, PCRTUUID pUuid, uint32_t idClient);
830
831	/** Interface for the VRDP USB proxy backend to query for a device remote callback table. */
832	REMOTEUSBIF mRemoteUsbIf;
833	#endif
834
835	static DECLCALLBACK(int) i_attachStorageDevice(Console *pThis,
836	PUVM pUVM,
837	PCVMMR3VTABLE pVMM,
838	const char *pcszDevice,
839	unsigned uInstance,
840	StorageBus_T enmBus,
841	bool fUseHostIOCache,
842	IMediumAttachment *aMediumAtt,
843	bool fSilent);
844	static DECLCALLBACK(int) i_detachStorageDevice(Console *pThis,
845	PUVM pUVM,
846	PCVMMR3VTABLE pVMM,
847	const char *pcszDevice,
848	unsigned uInstance,
849	StorageBus_T enmBus,
850	IMediumAttachment *aMediumAtt,
851	bool fSilent);
852	HRESULT i_doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM, PCVMMR3VTABLE pVMM, bool fSilent);
853	HRESULT i_doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM, PCVMMR3VTABLE pVMM, bool fSilent);
854
855	static DECLCALLBACK(int) i_stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser);
856
857	static DECLCALLBACK(void) i_genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL,
858	const char *pszErrorFmt, va_list va);
859
860	void i_atVMRuntimeErrorCallbackF(uint32_t fFatal, const char pszErrorId, const char pszFormat, ...);
861	static DECLCALLBACK(void) i_atVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFatal,
862	const char pszErrorId, const char pszFormat, va_list va);
863
864	HRESULT i_captureUSBDevices(PUVM pUVM);
865	void i_detachAllUSBDevices(bool aDone);
866
867
868	static DECLCALLBACK(int) i_vmm2User_SaveState(PCVMM2USERMETHODS pThis, PUVM pUVM);
869	static DECLCALLBACK(void) i_vmm2User_NotifyEmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
870	static DECLCALLBACK(void) i_vmm2User_NotifyEmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
871	static DECLCALLBACK(void) i_vmm2User_NotifyPdmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM);
872	static DECLCALLBACK(void) i_vmm2User_NotifyPdmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM);
873	static DECLCALLBACK(void) i_vmm2User_NotifyResetTurnedIntoPowerOff(PCVMM2USERMETHODS pThis, PUVM pUVM);
874	static DECLCALLBACK(void *) i_vmm2User_QueryGenericObject(PCVMM2USERMETHODS pThis, PUVM pUVM, PCRTUUID pUuid);
875
876	static DECLCALLBACK(void ) i_drvStatus_QueryInterface(PPDMIBASE pInterface, const char pszIID);
877	static DECLCALLBACK(void) i_drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN);
878	static DECLCALLBACK(int) i_drvStatus_MediumEjected(PPDMIMEDIANOTIFY pInterface, unsigned iLUN);
879	static DECLCALLBACK(void) i_drvStatus_Destruct(PPDMDRVINS pDrvIns);
880	static DECLCALLBACK(int) i_drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
881
882	static DECLCALLBACK(int) i_pdmIfSecKey_KeyRetain(PPDMISECKEY pInterface, const char pszId, const uint8_t *ppbKey,
883	size_t *pcbKey);
884	static DECLCALLBACK(int) i_pdmIfSecKey_KeyRelease(PPDMISECKEY pInterface, const char *pszId);
885	static DECLCALLBACK(int) i_pdmIfSecKey_PasswordRetain(PPDMISECKEY pInterface, const char pszId, const char *ppszPassword);
886	static DECLCALLBACK(int) i_pdmIfSecKey_PasswordRelease(PPDMISECKEY pInterface, const char *pszId);
887
888	static DECLCALLBACK(int) i_pdmIfSecKeyHlp_KeyMissingNotify(PPDMISECKEYHLP pInterface);
889
890	int mcAudioRefs;
891	volatile uint32_t mcVRDPClients;
892	uint32_t mu32SingleRDPClientId; /* The id of a connected client in the single connection mode. */
893	volatile bool mcGuestCredentialsProvided;
894
895	static const char *sSSMConsoleUnit;
896
897	HRESULT i_loadDataFromSavedState();
898	int i_loadStateFileExecInternal(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, uint32_t u32Version);
899
900	static DECLCALLBACK(int) i_saveStateFileExec(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser);
901	static DECLCALLBACK(int) i_loadStateFileExec(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser,
902	uint32_t uVersion, uint32_t uPass);
903
904	#ifdef VBOX_WITH_GUEST_PROPS
905	HRESULT i_doEnumerateGuestProperties(const Utf8Str &aPatterns,
906	std::vector<Utf8Str> &aNames,
907	std::vector<Utf8Str> &aValues,
908	std::vector<LONG64> &aTimestamps,
909	std::vector<Utf8Str> &aFlags);
910
911	void i_guestPropertiesHandleVMReset(void);
912	bool i_guestPropertiesVRDPEnabled(void);
913	void i_guestPropertiesVRDPUpdateLogon(uint32_t u32ClientId, const char pszUser, const char pszDomain);
914	void i_guestPropertiesVRDPUpdateActiveClient(uint32_t u32ClientId);
915	void i_guestPropertiesVRDPUpdateClientAttach(uint32_t u32ClientId, bool fAttached);
916	void i_guestPropertiesVRDPUpdateNameChange(uint32_t u32ClientId, const char *pszName);
917	void i_guestPropertiesVRDPUpdateIPAddrChange(uint32_t u32ClientId, const char *pszIPAddr);
918	void i_guestPropertiesVRDPUpdateLocationChange(uint32_t u32ClientId, const char *pszLocation);
919	void i_guestPropertiesVRDPUpdateOtherInfoChange(uint32_t u32ClientId, const char *pszOtherInfo);
920	void i_guestPropertiesVRDPUpdateDisconnect(uint32_t u32ClientId);
921	#endif
922
923	/** @name Disk encryption support
924	* @{ */
925	HRESULT i_consoleParseDiskEncryption(const char psz, const char *ppszEnd);
926	HRESULT i_configureEncryptionForDisk(const Utf8Str &strId, unsigned *pcDisksConfigured);
927	HRESULT i_clearDiskEncryptionKeysOnAllAttachmentsWithKeyId(const Utf8Str &strId);
928	HRESULT i_initSecretKeyIfOnAllAttachments(void);
929	int i_consoleParseKeyValue(const char psz, const char *ppszEnd,
930	char ppszKey, char ppszVal);
931	void i_removeSecretKeysOnSuspend();
932	/** @} */
933
934	/** @name Teleporter support
935	* @{ */
936	static DECLCALLBACK(int) i_teleporterSrcThreadWrapper(RTTHREAD hThreadSelf, void *pvUser);
937	HRESULT i_teleporterSrc(TeleporterStateSrc *pState);
938	HRESULT i_teleporterSrcReadACK(TeleporterStateSrc pState, const char pszWhich, const char *pszNAckMsg = NULL);
939	HRESULT i_teleporterSrcSubmitCommand(TeleporterStateSrc pState, const char pszCommand, bool fWaitForAck = true);
940	HRESULT i_teleporterTrg(PUVM pUVM, PCVMMR3VTABLE pVMM, IMachine pMachine, Utf8Str pErrorMsg,
941	bool fStartPaused, Progress pProgress, bool pfPowerOffOnFailure);
942	static DECLCALLBACK(int) i_teleporterTrgServeConnection(RTSOCKET Sock, void *pvUser);
943	/** @} */
944
945	bool mSavedStateDataLoaded : 1;
946
947	const ComPtr<IMachine> mMachine;
948	const ComPtr<IInternalMachineControl> mControl;
949
950	const ComPtr<IVRDEServer> mVRDEServer;
951
952	ConsoleVRDPServer * const mConsoleVRDPServer;
953	bool mfVRDEChangeInProcess;
954	bool mfVRDEChangePending;
955	const ComObjPtr<Guest> mGuest;
956	const ComObjPtr<Keyboard> mKeyboard;
957	const ComObjPtr<Mouse> mMouse;
958	const ComObjPtr<Display> mDisplay;
959	const ComObjPtr<MachineDebugger> mDebugger;
960	const ComObjPtr<VRDEServerInfo> mVRDEServerInfo;
961	/** This can safely be used without holding any locks.
962	* An AutoCaller suffices to prevent it being destroy while in use and
963	* internally there is a lock providing the necessary serialization. */
964	const ComObjPtr<EventSource> mEventSource;
965	#ifdef VBOX_WITH_EXTPACK
966	const ComObjPtr<ExtPackManager> mptrExtPackManager;
967	#endif
968	const ComObjPtr<EmulatedUSB> mEmulatedUSB;
969	const ComObjPtr<NvramStore> mptrNvramStore;
970
971	USBDeviceList mUSBDevices;
972	RemoteUSBDeviceList mRemoteUSBDevices;
973
974	SharedFolderDataMap m_mapGlobalSharedFolders;
975	SharedFolderDataMap m_mapMachineSharedFolders;
976	SharedFolderMap m_mapSharedFolders; // the console instances
977
978	/** VMM loader handle. */
979	RTLDRMOD mhModVMM;
980	/** The VMM vtable. */
981	PCVMMR3VTABLE mpVMM;
982	/** The user mode VM handle. */
983	PUVM mpUVM;
984	/** Holds the number of "readonly" mpUVM callers (users). */
985	uint32_t mVMCallers;
986	/** Semaphore posted when the number of mpUVM callers drops to zero. */
987	RTSEMEVENT mVMZeroCallersSem;
988	/** true when Console has entered the mpUVM destruction phase. */
989	bool mVMDestroying : 1;
990	/** true when power down is initiated by vmstateChangeCallback (EMT). */
991	bool mVMPoweredOff : 1;
992	/** true when vmstateChangeCallback shouldn't initiate a power down. */
993	bool mVMIsAlreadyPoweringOff : 1;
994	/** true if we already showed the snapshot folder size warning. */
995	bool mfSnapshotFolderSizeWarningShown : 1;
996	/** true if we already showed the snapshot folder ext4/xfs bug warning. */
997	bool mfSnapshotFolderExt4WarningShown : 1;
998	/** true if we already listed the disk type of the snapshot folder. */
999	bool mfSnapshotFolderDiskTypeShown : 1;
1000	/** true if a USB controller is available (i.e. USB devices can be attached). */
1001	bool mfVMHasUsbController : 1;
1002	/** Shadow of the VBoxInternal2/TurnResetIntoPowerOff extra data setting.
1003	* This is initialized by Console::i_configConstructorInner(). */
1004	bool mfTurnResetIntoPowerOff : 1;
1005	/** true if the VM power off was caused by reset. */
1006	bool mfPowerOffCausedByReset : 1;
1007
1008	/** Pointer to the VMM -> User (that's us) callbacks. */
1009	struct MYVMM2USERMETHODS : public VMM2USERMETHODS
1010	{
1011	Console *pConsole;
1012	/** The in-progress snapshot. */
1013	ISnapshot *pISnapshot;
1014	} *mpVmm2UserMethods;
1015
1016	/** The current network attachment type in the VM.
1017	* This doesn't have to match the network attachment type maintained in the
1018	* NetworkAdapter. This is needed to change the network attachment
1019	* dynamically.
1020	*/
1021	typedef std::vector<NetworkAttachmentType_T> NetworkAttachmentTypeVector;
1022	NetworkAttachmentTypeVector meAttachmentType;
1023
1024	VMMDev * m_pVMMDev;
1025	AudioVRDE * const mAudioVRDE;
1026	#ifdef VBOX_WITH_USB_CARDREADER
1027	UsbCardReader * const mUsbCardReader;
1028	#endif
1029	BusAssignmentManager* mBusMgr;
1030
1031	/** @name LEDs and their management
1032	* @{ */
1033	/** Number of LED sets in use in maLedSets. */
1034	uint32_t mcLedSets;
1035	/** LED sets. */
1036	struct LEDSET
1037	{
1038	PPDMLED *papLeds;
1039	uint32_t cLeds;
1040	DeviceType_T enmType;
1041	DeviceType_T paSubTypes; /< Optionally, device types for each individual LED. Runs parallel to papLeds. /
1042	} maLedSets[32];
1043	/** @} */
1044
1045	MediumAttachmentMap mapMediumAttachments;
1046
1047	/** List of attached USB storage devices. */
1048	USBStorageDeviceList mUSBStorageDevices;
1049
1050	/** Store for secret keys. */
1051	SecretKeyStore * const m_pKeyStore;
1052	/** Number of disks configured for encryption. */
1053	unsigned m_cDisksEncrypted;
1054	/** Number of disks which have the key in the map. */
1055	unsigned m_cDisksPwProvided;
1056
1057	/** Current active port modes of the supported serial ports. */
1058	PortMode_T m_aeSerialPortMode[4];
1059
1060	/** Pointer to the key consumer -> provider (that's us) callbacks. */
1061	struct MYPDMISECKEY : public PDMISECKEY
1062	{
1063	Console *pConsole;
1064	} *mpIfSecKey;
1065
1066	/** Pointer to the key helpers -> provider (that's us) callbacks. */
1067	struct MYPDMISECKEYHLP : public PDMISECKEYHLP
1068	{
1069	Console *pConsole;
1070	} *mpIfSecKeyHlp;
1071
1072	/* Note: FreeBSD needs this whether netflt is used or not. */
1073	#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) \|\| defined(RT_OS_FREEBSD))
1074	Utf8Str maTAPDeviceName[8];
1075	RTFILE maTapFD[8];
1076	#endif
1077
1078	bool mVMStateChangeCallbackDisabled;
1079
1080	bool mfUseHostClipboard;
1081
1082	/** Local machine state value. */
1083	MachineState_T mMachineState;
1084
1085	/** Machine uuid string. */
1086	Bstr mstrUuid;
1087
1088	#ifdef VBOX_WITH_DRAG_AND_DROP
1089	HGCMSVCEXTHANDLE m_hHgcmSvcExtDragAndDrop;
1090	#endif
1091
1092	/** Pointer to the progress object of a live cancelable task.
1093	*
1094	* This is currently only used by Console::Teleport(), but is intended to later
1095	* be used by the live snapshot code path as well. Actions like
1096	* Console::PowerDown, which automatically cancels out the running snapshot /
1097	* teleportation operation, will cancel the teleportation / live snapshot
1098	* operation before starting. */
1099	ComPtr<IProgress> mptrCancelableProgress;
1100
1101	ComPtr<IEventListener> mVmListener;
1102
1103	#ifdef VBOX_WITH_RECORDING
1104	struct Recording
1105	{
1106	Recording()
1107	: mpCtx(NULL)
1108	# ifdef VBOX_WITH_AUDIO_RECORDING
1109	, mAudioRec(NULL)
1110	# endif
1111	{ }
1112
1113	/** The recording context. */
1114	RecordingContext *mpCtx;
1115	# ifdef VBOX_WITH_AUDIO_RECORDING
1116	/** Pointer to capturing audio backend. */
1117	AudioVideoRec * const mAudioRec;
1118	# endif
1119	} mRecording;
1120	#endif /* VBOX_WITH_RECORDING */
1121
1122	#ifdef VBOX_WITH_CLOUD_NET
1123	GatewayInfo mGateway;
1124	#endif /* VBOX_WITH_CLOUD_NET */
1125
1126	friend class VMTask;
1127	friend class ConsoleVRDPServer;
1128	};
1129
1130	#endif /* !MAIN_INCLUDED_ConsoleImpl_h */
1131	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/include/ConsoleImpl.h@ 94660

Download in other formats: