VirtualBox

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

Last change on this file since 70772 was 70766, checked in by vboxsync, 6 years ago

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