VirtualBox

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

Last change on this file since 98262 was 98262, checked in by vboxsync, 17 months ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use