MachineImpl.cpp@ 104956

Last change on this file since 104956 was 103085, checked in by vboxsync, 10 months ago
Main,FE/VBoxManage,FE/VirtualBox,ValidationKit: Allow setting the primary VM execution engine to make it easier to force particular engine for testing, bugref:10583
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 581.2 KB

Line
1	/* $Id: MachineImpl.cpp 103085 2024-01-26 16:17:43Z vboxsync $ */
2	/** @file
3	* Implementation of IMachine in VBoxSVC.
4	*/
5
6	/*
7	* Copyright (C) 2004-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	#define LOG_GROUP LOG_GROUP_MAIN_MACHINE
29
30	/* Make sure all the stdint.h macros are included - must come first! */
31	#ifndef __STDC_LIMIT_MACROS
32	# define __STDC_LIMIT_MACROS
33	#endif
34	#ifndef __STDC_CONSTANT_MACROS
35	# define __STDC_CONSTANT_MACROS
36	#endif
37
38	#include "LoggingNew.h"
39	#include "VirtualBoxImpl.h"
40	#include "MachineImpl.h"
41	#include "SnapshotImpl.h"
42	#include "ClientToken.h"
43	#include "ProgressImpl.h"
44	#include "ProgressProxyImpl.h"
45	#include "MediumAttachmentImpl.h"
46	#include "MediumImpl.h"
47	#include "MediumLock.h"
48	#include "USBControllerImpl.h"
49	#include "USBDeviceFiltersImpl.h"
50	#include "HostImpl.h"
51	#include "SharedFolderImpl.h"
52	#include "GuestOSTypeImpl.h"
53	#include "VirtualBoxErrorInfoImpl.h"
54	#include "StorageControllerImpl.h"
55	#include "DisplayImpl.h"
56	#include "DisplayUtils.h"
57	#include "MachineImplCloneVM.h"
58	#include "AutostartDb.h"
59	#include "SystemPropertiesImpl.h"
60	#include "StorageControllerImpl.h"
61	#include "MachineImplMoveVM.h"
62	#include "ExtPackManagerImpl.h"
63	#include "MachineLaunchVMCommonWorker.h"
64	#include "CryptoUtils.h"
65
66	// generated header
67	#include "VBoxEvents.h"
68
69	#ifdef VBOX_WITH_USB
70	# include "USBProxyService.h"
71	#endif
72
73	#include "AutoCaller.h"
74	#include "HashedPw.h"
75	#include "Performance.h"
76	#include "StringifyEnums.h"
77
78	#include <iprt/asm.h>
79	#include <iprt/path.h>
80	#include <iprt/dir.h>
81	#include <iprt/env.h>
82	#include <iprt/lockvalidator.h>
83	#include <iprt/memsafer.h>
84	#include <iprt/process.h>
85	#include <iprt/cpp/utils.h>
86	#include <iprt/cpp/xml.h> /* xml::XmlFileWriter::s_pszSuff. /
87	#include <iprt/sha.h>
88	#include <iprt/string.h>
89	#include <iprt/ctype.h>
90
91	#include <VBox/com/array.h>
92	#include <VBox/com/list.h>
93	#include <VBox/VBoxCryptoIf.h>
94
95	#include <VBox/err.h>
96	#include <VBox/param.h>
97	#include <VBox/settings.h>
98	#include <VBox/VMMDev.h>
99	#include <VBox/vmm/ssm.h>
100
101	#ifdef VBOX_WITH_GUEST_PROPS
102	# include <VBox/HostServices/GuestPropertySvc.h>
103	# include <VBox/com/array.h>
104	#endif
105
106	#ifdef VBOX_WITH_SHARED_CLIPBOARD
107	# include <VBox/HostServices/VBoxClipboardSvc.h>
108	#endif
109
110	#include "VBox/com/MultiResult.h"
111
112	#include <algorithm>
113
114	#ifdef VBOX_WITH_DTRACE_R3_MAIN
115	# include "dtrace/VBoxAPI.h"
116	#endif
117
118	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
119	# define HOSTSUFF_EXE ".exe"
120	#else /* !RT_OS_WINDOWS */
121	# define HOSTSUFF_EXE ""
122	#endif /* !RT_OS_WINDOWS */
123
124	// defines / prototypes
125	/////////////////////////////////////////////////////////////////////////////
126
127	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
128	# define BUF_DATA_SIZE _64K
129
130	enum CipherMode
131	{
132	CipherModeGcm = 0,
133	CipherModeCtr,
134	CipherModeXts,
135	CipherModeMax
136	};
137
138	enum AesSize
139	{
140	Aes128 = 0,
141	Aes256,
142	AesMax
143	};
144
145	const char *g_apszCipher[AesMax][CipherModeMax] =
146	{
147	{"AES-GCM128", "AES-CTR128", "AES-XTS128-PLAIN64"},
148	{"AES-GCM256", "AES-CTR256", "AES-XTS256-PLAIN64"}
149	};
150	const char *g_apszCipherAlgo[AesMax] = {"AES-128", "AES-256"};
151
152	static const char getCipherString(const char pszAlgo, const int iMode)
153	{
154	if (iMode >= CipherModeMax)
155	return pszAlgo;
156
157	for (int i = 0; i < AesMax; i++)
158	{
159	if (strcmp(pszAlgo, g_apszCipherAlgo[i]) == 0)
160	return g_apszCipher[i][iMode];
161	}
162	return pszAlgo;
163	}
164
165	static const char getCipherStringWithoutMode(const char pszAlgo)
166	{
167	for (int i = 0; i < AesMax; i++)
168	{
169	for (int j = 0; j < CipherModeMax; j++)
170	{
171	if (strcmp(pszAlgo, g_apszCipher[i][j]) == 0)
172	return g_apszCipherAlgo[i];
173	}
174	}
175	return pszAlgo;
176	}
177	#endif
178
179	/////////////////////////////////////////////////////////////////////////////
180	// Machine::Data structure
181	/////////////////////////////////////////////////////////////////////////////
182
183	Machine::Data::Data()
184	{
185	mRegistered = FALSE;
186	pMachineConfigFile = NULL;
187	/* Contains hints on what has changed when the user is using the VM (config
188	* changes, running the VM, ...). This is used to decide if a config needs
189	* to be written to disk. */
190	flModifications = 0;
191	/* VM modification usually also trigger setting the current state to
192	* "Modified". Although this is not always the case. An e.g. is the VM
193	* initialization phase or when snapshot related data is changed. The
194	* actually behavior is controlled by the following flag. */
195	m_fAllowStateModification = false;
196	mAccessible = FALSE;
197	/* mUuid is initialized in Machine::init() */
198
199	mMachineState = MachineState_PoweredOff;
200	RTTimeNow(&mLastStateChange);
201
202	mMachineStateDeps = 0;
203	mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
204	mMachineStateChangePending = 0;
205
206	mCurrentStateModified = TRUE;
207	mGuestPropertiesModified = FALSE;
208
209	mSession.mPID = NIL_RTPROCESS;
210	mSession.mLockType = LockType_Null;
211	mSession.mState = SessionState_Unlocked;
212
213	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
214	mpKeyStore = NULL;
215	#endif
216	}
217
218	Machine::Data::~Data()
219	{
220	if (mMachineStateDepsSem != NIL_RTSEMEVENTMULTI)
221	{
222	RTSemEventMultiDestroy(mMachineStateDepsSem);
223	mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
224	}
225	if (pMachineConfigFile)
226	{
227	delete pMachineConfigFile;
228	pMachineConfigFile = NULL;
229	}
230	}
231
232	/////////////////////////////////////////////////////////////////////////////
233	// Machine::HWData structure
234	/////////////////////////////////////////////////////////////////////////////
235
236	Machine::HWData::HWData()
237	{
238	/* default values for a newly created machine for x86. */
239	mHWVersion.printf("%d", SchemaDefs::DefaultHardwareVersion);
240	mMemorySize = 128;
241	mCPUCount = 1;
242	mCPUHotPlugEnabled = false;
243	mMemoryBalloonSize = 0;
244	mPageFusionEnabled = false;
245	mCpuExecutionCap = 100; /* Maximum CPU execution cap by default. */
246	mCpuIdPortabilityLevel = 0;
247	mCpuProfile = "host";
248
249	/* default boot order: floppy - DVD - HDD */
250	mBootOrder[0] = DeviceType_Floppy;
251	mBootOrder[1] = DeviceType_DVD;
252	mBootOrder[2] = DeviceType_HardDisk;
253	for (size_t i = 3; i < RT_ELEMENTS(mBootOrder); ++i)
254	mBootOrder[i] = DeviceType_Null;
255
256	mClipboardMode = ClipboardMode_Disabled;
257	mClipboardFileTransfersEnabled = FALSE;
258
259	mDnDMode = DnDMode_Disabled;
260
261	mKeyboardHIDType = KeyboardHIDType_PS2Keyboard;
262	mPointingHIDType = PointingHIDType_PS2Mouse;
263	mParavirtProvider = ParavirtProvider_Default;
264	mEmulatedUSBCardReaderEnabled = FALSE;
265
266	for (size_t i = 0; i < RT_ELEMENTS(mCPUAttached); ++i)
267	mCPUAttached[i] = false;
268
269	mIOCacheEnabled = true;
270	mIOCacheSize = 5; /* 5MB */
271	}
272
273	Machine::HWData::~HWData()
274	{
275	}
276
277	/////////////////////////////////////////////////////////////////////////////
278	// Machine class
279	/////////////////////////////////////////////////////////////////////////////
280
281	// constructor / destructor
282	/////////////////////////////////////////////////////////////////////////////
283
284	Machine::Machine() :
285	#ifdef VBOX_WITH_RESOURCE_USAGE_API
286	mCollectorGuest(NULL),
287	#endif
288	mPeer(NULL),
289	mParent(NULL),
290	mSerialPorts(),
291	mParallelPorts(),
292	uRegistryNeedsSaving(0)
293	{}
294
295	Machine::~Machine()
296	{}
297
298	HRESULT Machine::FinalConstruct()
299	{
300	LogFlowThisFunc(("\n"));
301	return BaseFinalConstruct();
302	}
303
304	void Machine::FinalRelease()
305	{
306	LogFlowThisFunc(("\n"));
307	uninit();
308	BaseFinalRelease();
309	}
310
311	/**
312	* Initializes a new machine instance; this init() variant creates a new, empty machine.
313	* This gets called from VirtualBox::CreateMachine().
314	*
315	* @param aParent Associated parent object.
316	* @param strConfigFile Local file system path to the VM settings (can be relative to the VirtualBox config directory).
317	* @param strName Name for the machine.
318	* @param aArchitecture Architecture to use for the machine.
319	* If a valid guest OS type is set via \a aOsType, the guest OS' type will be used instead then.
320	* @param llGroups list of groups for the machine.
321	* @param strOsType OS Type string (stored as is if aOsType is NULL).
322	* @param aOsType OS Type of this machine or NULL.
323	* @param aId UUID for the new machine.
324	* @param fForceOverwrite Whether to overwrite an existing machine settings file.
325	* @param fDirectoryIncludesUUID
326	* Whether the use a special VM directory naming scheme (includes the UUID).
327	* @param aCipher The cipher to encrypt the VM with.
328	* @param aPasswordId The password ID, empty if the VM should not be encrypted.
329	* @param aPassword The password to encrypt the VM with.
330	*
331	* @return Success indicator. if not S_OK, the machine object is invalid.
332	*/
333	HRESULT Machine::init(VirtualBox *aParent,
334	const Utf8Str &strConfigFile,
335	const Utf8Str &strName,
336	PlatformArchitecture_T aArchitecture,
337	const StringsList &llGroups,
338	const Utf8Str &strOsType,
339	GuestOSType *aOsType,
340	const Guid &aId,
341	bool fForceOverwrite,
342	bool fDirectoryIncludesUUID,
343	const com::Utf8Str &aCipher,
344	const com::Utf8Str &aPasswordId,
345	const com::Utf8Str &aPassword)
346	{
347	LogFlowThisFuncEnter();
348	LogFlowThisFunc(("(Init_New) aConfigFile='%s'\n", strConfigFile.c_str()));
349
350	#ifndef VBOX_WITH_FULL_VM_ENCRYPTION
351	RT_NOREF(aCipher);
352	if (aPassword.isNotEmpty() \|\| aPasswordId.isNotEmpty())
353	return setError(VBOX_E_NOT_SUPPORTED, tr("Full VM encryption is not available with this build"));
354	#endif
355
356	/* Enclose the state transition NotReady->InInit->Ready */
357	AutoInitSpan autoInitSpan(this);
358	AssertReturn(autoInitSpan.isOk(), E_FAIL);
359
360	HRESULT hrc = initImpl(aParent, strConfigFile);
361	if (FAILED(hrc)) return hrc;
362
363	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
364	com::Utf8Str strSsmKeyId;
365	com::Utf8Str strSsmKeyStore;
366	com::Utf8Str strNVRAMKeyId;
367	com::Utf8Str strNVRAMKeyStore;
368
369	if (aPassword.isNotEmpty() && aPasswordId.isNotEmpty())
370	{
371	/* Resolve the cryptographic interface. */
372	PCVBOXCRYPTOIF pCryptoIf = NULL;
373	hrc = aParent->i_retainCryptoIf(&pCryptoIf);
374	if (SUCCEEDED(hrc))
375	{
376	CipherMode aenmMode[] = {CipherModeGcm, CipherModeGcm, CipherModeGcm, CipherModeCtr};
377	com::Utf8Str *astrKeyId[] = {&mData->mstrKeyId, &strSsmKeyId, &strNVRAMKeyId, &mData->mstrLogKeyId};
378	com::Utf8Str *astrKeyStore[] = {&mData->mstrKeyStore, &strSsmKeyStore, &strNVRAMKeyStore, &mData->mstrLogKeyStore};
379
380	for (uint32_t i = 0; i < RT_ELEMENTS(astrKeyId); i++)
381	{
382	const char *pszCipher = getCipherString(aCipher.c_str(), aenmMode[i]);
383	if (!pszCipher)
384	{
385	hrc = setError(VBOX_E_NOT_SUPPORTED,
386	tr("The cipher '%s' is not supported"), aCipher.c_str());
387	break;
388	}
389
390	VBOXCRYPTOCTX hCryptoCtx;
391	int vrc = pCryptoIf->pfnCryptoCtxCreate(pszCipher, aPassword.c_str(), &hCryptoCtx);
392	if (RT_FAILURE(vrc))
393	{
394	hrc = setErrorBoth(E_FAIL, vrc, tr("New key store creation failed, (%Rrc)"), vrc);
395	break;
396	}
397
398	char *pszKeyStore;
399	vrc = pCryptoIf->pfnCryptoCtxSave(hCryptoCtx, &pszKeyStore);
400	int vrc2 = pCryptoIf->pfnCryptoCtxDestroy(hCryptoCtx);
401	AssertRC(vrc2);
402
403	if (RT_FAILURE(vrc))
404	{
405	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Saving the key store failed, (%Rrc)"), vrc);
406	break;
407	}
408
409	*(astrKeyStore[i]) = pszKeyStore;
410	RTMemFree(pszKeyStore);
411	*(astrKeyId[i]) = aPasswordId;
412	}
413
414	HRESULT hrc2 = aParent->i_releaseCryptoIf(pCryptoIf);
415	Assert(hrc2 == S_OK); RT_NOREF(hrc2);
416
417	if (FAILED(hrc))
418	return hrc; /* Error is set. */
419	}
420	else
421	return hrc; /* Error is set. */
422	}
423	#endif
424
425	hrc = i_tryCreateMachineConfigFile(fForceOverwrite);
426	if (FAILED(hrc)) return hrc;
427
428	if (SUCCEEDED(hrc))
429	{
430	// create an empty machine config
431	mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
432
433	hrc = initDataAndChildObjects();
434	}
435
436	if (SUCCEEDED(hrc))
437	{
438	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
439	mSSData->strStateKeyId = strSsmKeyId;
440	mSSData->strStateKeyStore = strSsmKeyStore;
441	#endif
442
443	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
444	mData->mAccessible = TRUE;
445
446	unconst(mData->mUuid) = aId;
447
448	mUserData->s.strName = strName;
449
450	if (llGroups.size())
451	mUserData->s.llGroups = llGroups;
452
453	mUserData->s.fDirectoryIncludesUUID = fDirectoryIncludesUUID;
454	// the "name sync" flag determines whether the machine directory gets renamed along
455	// with the machine file; say so if the settings file name is the same as the
456	// settings file parent directory (machine directory)
457	mUserData->s.fNameSync = i_isInOwnDir();
458
459	// initialize the default snapshots folder
460	hrc = COMSETTER(SnapshotFolder)(NULL);
461	AssertComRC(hrc);
462
463	/* Use the platform architecture which was handed-in by default. */
464	PlatformArchitecture_T enmPlatformArch = aArchitecture;
465
466	if (aOsType)
467	{
468	/* Store OS type */
469	mUserData->s.strOsType = aOsType->i_id();
470
471	/* Use the platform architecture of the found guest OS type. */
472	enmPlatformArch = aOsType->i_platformArchitecture();
473	}
474	else if (!strOsType.isEmpty())
475	{
476	/* Store OS type */
477	mUserData->s.strOsType = strOsType;
478	}
479
480	/* Set the platform architecture first before applying the defaults below. */
481	hrc = mPlatform->i_initArchitecture(enmPlatformArch);
482	if (FAILED(hrc)) return hrc;
483
484	/* Apply platform defaults. */
485	mPlatform->i_applyDefaults(aOsType);
486	i_platformPropertiesUpdate();
487
488	/* Apply firmware defaults. */
489	mFirmwareSettings->i_applyDefaults(aOsType);
490
491	/* Apply TPM defaults. */
492	mTrustedPlatformModule->i_applyDefaults(aOsType);
493
494	/* Apply recording defaults. */
495	mRecordingSettings->i_applyDefaults();
496
497	/* Apply network adapters defaults */
498	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
499	mNetworkAdapters[slot]->i_applyDefaults(aOsType);
500
501	/* Apply serial port defaults */
502	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
503	mSerialPorts[slot]->i_applyDefaults(aOsType);
504
505	/* Apply parallel port defaults */
506	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
507	mParallelPorts[slot]->i_applyDefaults();
508
509	/* Enable the VMMDev testing feature for bootsector VMs: */
510	if (aOsType && aOsType->i_id() == GUEST_OS_ID_STR_X64("VBoxBS"))
511	mData->pMachineConfigFile->mapExtraDataItems["VBoxInternal/Devices/VMMDev/0/Config/TestingEnabled"] = "1";
512
513	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
514	hrc = mNvramStore->i_updateEncryptionSettings(strNVRAMKeyId, strNVRAMKeyStore);
515	#endif
516	if (SUCCEEDED(hrc))
517	{
518	/* At this point the changing of the current state modification
519	* flag is allowed. */
520	i_allowStateModification();
521
522	/* commit all changes made during the initialization */
523	i_commit();
524	}
525	}
526
527	/* Confirm a successful initialization when it's the case */
528	if (SUCCEEDED(hrc))
529	{
530	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
531	if (aPassword.isNotEmpty() && aPasswordId.isNotEmpty())
532	{
533	size_t cbPassword = aPassword.length() + 1;
534	uint8_t pbPassword = (uint8_t )aPassword.c_str();
535	mData->mpKeyStore->addSecretKey(aPasswordId, pbPassword, cbPassword);
536	}
537	#endif
538
539	if (mData->mAccessible)
540	autoInitSpan.setSucceeded();
541	else
542	autoInitSpan.setLimited();
543	}
544
545	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool, hrc=%08X\n",
546	!!mUserData ? mUserData->s.strName.c_str() : "NULL",
547	mData->mRegistered,
548	mData->mAccessible,
549	hrc));
550
551	LogFlowThisFuncLeave();
552
553	return hrc;
554	}
555
556	/**
557	* Initializes a new instance with data from machine XML (formerly Init_Registered).
558	* Gets called in two modes:
559	*
560	* -- from VirtualBox::initMachines() during VirtualBox startup; in that case, the
561	* UUID is specified and we mark the machine as "registered";
562	*
563	* -- from the public VirtualBox::OpenMachine() API, in which case the UUID is NULL
564	* and the machine remains unregistered until RegisterMachine() is called.
565	*
566	* @param aParent Associated parent object
567	* @param strConfigFile Local file system path to the VM settings file (can
568	* be relative to the VirtualBox config directory).
569	* @param aId UUID of the machine or NULL (see above).
570	* @param strPassword Password for decrypting the config
571	*
572	* @return Success indicator. if not S_OK, the machine object is invalid
573	*/
574	HRESULT Machine::initFromSettings(VirtualBox *aParent,
575	const Utf8Str &strConfigFile,
576	const Guid *aId,
577	const com::Utf8Str &strPassword)
578	{
579	LogFlowThisFuncEnter();
580	LogFlowThisFunc(("(Init_Registered) aConfigFile='%s\n", strConfigFile.c_str()));
581
582	PCVBOXCRYPTOIF pCryptoIf = NULL;
583	#ifndef VBOX_WITH_FULL_VM_ENCRYPTION
584	if (strPassword.isNotEmpty())
585	return setError(VBOX_E_NOT_SUPPORTED, tr("Full VM encryption is not available with this build"));
586	#else
587	if (strPassword.isNotEmpty())
588	{
589	/* Get at the crpytographic interface. */
590	HRESULT hrc = aParent->i_retainCryptoIf(&pCryptoIf);
591	if (FAILED(hrc))
592	return hrc; /* Error is set. */
593	}
594	#endif
595
596	/* Enclose the state transition NotReady->InInit->Ready */
597	AutoInitSpan autoInitSpan(this);
598	AssertReturn(autoInitSpan.isOk(), E_FAIL);
599
600	HRESULT hrc = initImpl(aParent, strConfigFile);
601	if (FAILED(hrc)) return hrc;
602
603	if (aId)
604	{
605	// loading a registered VM:
606	unconst(mData->mUuid) = *aId;
607	mData->mRegistered = TRUE;
608	// now load the settings from XML:
609	hrc = i_registeredInit();
610	// this calls initDataAndChildObjects() and loadSettings()
611	}
612	else
613	{
614	// opening an unregistered VM (VirtualBox::OpenMachine()):
615	hrc = initDataAndChildObjects();
616	if (SUCCEEDED(hrc))
617	{
618	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
619	mData->mAccessible = TRUE;
620
621	try
622	{
623	// load and parse machine XML; this will throw on XML or logic errors
624	mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull,
625	pCryptoIf,
626	strPassword.c_str());
627
628	// reject VM UUID duplicates, they can happen if someone
629	// tries to register an already known VM config again
630	if (aParent->i_findMachine(mData->pMachineConfigFile->uuid,
631	true /* fPermitInaccessible */,
632	false /* aDoSetError */,
633	NULL) != VBOX_E_OBJECT_NOT_FOUND)
634	{
635	throw setError(E_FAIL,
636	tr("Trying to open a VM config '%s' which has the same UUID as an existing virtual machine"),
637	mData->m_strConfigFile.c_str());
638	}
639
640	// use UUID from machine config
641	unconst(mData->mUuid) = mData->pMachineConfigFile->uuid;
642
643	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
644	// No exception is thrown if config is encrypted, allowing us to get the uuid and the encryption fields.
645	// We fill in the encryptions fields, and the rest will be filled in if all data parsed.
646	mData->mstrKeyId = mData->pMachineConfigFile->strKeyId;
647	mData->mstrKeyStore = mData->pMachineConfigFile->strKeyStore;
648	#endif
649
650	if (mData->pMachineConfigFile->enmParseState == settings::MachineConfigFile::ParseState_PasswordError)
651	{
652	// We just set the inaccessible state and fill the error info allowing the caller
653	// to register the machine with encrypted config even if the password is incorrect
654	mData->mAccessible = FALSE;
655
656	/* fetch the current error info */
657	mData->mAccessError = com::ErrorInfo();
658
659	setError(VBOX_E_PASSWORD_INCORRECT,
660	tr("Decryption of the machine {%RTuuid} failed. Incorrect or unknown password"),
661	mData->pMachineConfigFile->uuid.raw());
662	}
663	else
664	{
665	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
666	if (strPassword.isNotEmpty())
667	{
668	size_t cbKey = strPassword.length() + 1; /* Include terminator */
669	const uint8_t pbKey = (const uint8_t )strPassword.c_str();
670	mData->mpKeyStore->addSecretKey(mData->mstrKeyId, pbKey, cbKey);
671	}
672	#endif
673
674	hrc = i_loadMachineDataFromSettings(mData->pMachineConfigFile, NULL / puuidRegistry */);
675	if (FAILED(hrc)) throw hrc;
676
677	/* At this point the changing of the current state modification
678	* flag is allowed. */
679	i_allowStateModification();
680
681	i_commit();
682	}
683	}
684	catch (HRESULT err)
685	{
686	/* we assume that error info is set by the thrower */
687	hrc = err;
688	}
689	catch (...)
690	{
691	hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
692	}
693	}
694	}
695
696	/* Confirm a successful initialization when it's the case */
697	if (SUCCEEDED(hrc))
698	{
699	if (mData->mAccessible)
700	autoInitSpan.setSucceeded();
701	else
702	{
703	autoInitSpan.setLimited();
704
705	// uninit media from this machine's media registry, or else
706	// reloading the settings will fail
707	mParent->i_unregisterMachineMedia(i_getId());
708	}
709	}
710
711	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
712	if (pCryptoIf)
713	{
714	HRESULT hrc2 = aParent->i_releaseCryptoIf(pCryptoIf);
715	Assert(hrc2 == S_OK); RT_NOREF(hrc2);
716	}
717	#endif
718
719	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool hrc=%08X\n",
720	!!mUserData ? mUserData->s.strName.c_str() : "NULL", mData->mRegistered, mData->mAccessible, hrc));
721
722	LogFlowThisFuncLeave();
723
724	return hrc;
725	}
726
727	/**
728	* Initializes a new instance from a machine config that is already in memory
729	* (import OVF case). Since we are importing, the UUID in the machine
730	* config is ignored and we always generate a fresh one.
731	*
732	* @param aParent Associated parent object.
733	* @param strName Name for the new machine; this overrides what is specified in config.
734	* @param strSettingsFilename File name of .vbox file.
735	* @param config Machine configuration loaded and parsed from XML.
736	*
737	* @return Success indicator. if not S_OK, the machine object is invalid
738	*/
739	HRESULT Machine::init(VirtualBox *aParent,
740	const Utf8Str &strName,
741	const Utf8Str &strSettingsFilename,
742	const settings::MachineConfigFile &config)
743	{
744	LogFlowThisFuncEnter();
745
746	/* Enclose the state transition NotReady->InInit->Ready */
747	AutoInitSpan autoInitSpan(this);
748	AssertReturn(autoInitSpan.isOk(), E_FAIL);
749
750	HRESULT hrc = initImpl(aParent, strSettingsFilename);
751	if (FAILED(hrc)) return hrc;
752
753	hrc = i_tryCreateMachineConfigFile(false /* fForceOverwrite */);
754	if (FAILED(hrc)) return hrc;
755
756	hrc = initDataAndChildObjects();
757	if (SUCCEEDED(hrc))
758	{
759	// set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
760	mData->mAccessible = TRUE;
761
762	// create empty machine config for instance data
763	mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
764
765	// generate fresh UUID, ignore machine config
766	unconst(mData->mUuid).create();
767
768	hrc = i_loadMachineDataFromSettings(config, &mData->mUuid); // puuidRegistry: initialize media with this registry ID
769
770	// override VM name as well, it may be different
771	mUserData->s.strName = strName;
772
773	if (SUCCEEDED(hrc))
774	{
775	/* At this point the changing of the current state modification
776	* flag is allowed. */
777	i_allowStateModification();
778
779	/* commit all changes made during the initialization */
780	i_commit();
781	}
782	}
783
784	/* Confirm a successful initialization when it's the case */
785	if (SUCCEEDED(hrc))
786	{
787	if (mData->mAccessible)
788	autoInitSpan.setSucceeded();
789	else
790	{
791	/* Ignore all errors from unregistering, they would destroy
792	- * the more interesting error information we already have,
793	- * pinpointing the issue with the VM config. */
794	ErrorInfoKeeper eik;
795
796	autoInitSpan.setLimited();
797
798	// uninit media from this machine's media registry, or else
799	// reloading the settings will fail
800	mParent->i_unregisterMachineMedia(i_getId());
801	}
802	}
803
804	LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool hrc=%08X\n",
805	!!mUserData ? mUserData->s.strName.c_str() : "NULL", mData->mRegistered, mData->mAccessible, hrc));
806
807	LogFlowThisFuncLeave();
808
809	return hrc;
810	}
811
812	/**
813	* Shared code between the various init() implementations.
814	*
815	* @returns HRESULT
816	* @param aParent The VirtualBox object.
817	* @param strConfigFile Settings file.
818	*/
819	HRESULT Machine::initImpl(VirtualBox *aParent,
820	const Utf8Str &strConfigFile)
821	{
822	LogFlowThisFuncEnter();
823
824	AssertReturn(aParent, E_INVALIDARG);
825	AssertReturn(!strConfigFile.isEmpty(), E_INVALIDARG);
826
827	HRESULT hrc = S_OK;
828
829	/* share the parent weakly */
830	unconst(mParent) = aParent;
831
832	/* allocate the essential machine data structure (the rest will be
833	* allocated later by initDataAndChildObjects() */
834	mData.allocate();
835
836	/* memorize the config file name (as provided) */
837	mData->m_strConfigFile = strConfigFile;
838
839	/* get the full file name */
840	int vrc1 = mParent->i_calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
841	if (RT_FAILURE(vrc1))
842	return setErrorBoth(VBOX_E_FILE_ERROR, vrc1,
843	tr("Invalid machine settings file name '%s' (%Rrc)"),
844	strConfigFile.c_str(),
845	vrc1);
846
847	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
848	/** @todo Only create when the machine is going to be encrypted. */
849	/* Non-pageable memory is not accessible for non-VM process */
850	mData->mpKeyStore = new SecretKeyStore(false /* fKeyBufNonPageable */);
851	AssertReturn(mData->mpKeyStore, E_OUTOFMEMORY);
852	#endif
853
854	LogFlowThisFuncLeave();
855
856	return hrc;
857	}
858
859	/**
860	* Tries to create a machine settings file in the path stored in the machine
861	* instance data. Used when a new machine is created to fail gracefully if
862	* the settings file could not be written (e.g. because machine dir is read-only).
863	* @return
864	*/
865	HRESULT Machine::i_tryCreateMachineConfigFile(bool fForceOverwrite)
866	{
867	HRESULT hrc = S_OK;
868
869	// when we create a new machine, we must be able to create the settings file
870	RTFILE f = NIL_RTFILE;
871	int vrc = RTFileOpen(&f, mData->m_strConfigFileFull.c_str(), RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
872	if ( RT_SUCCESS(vrc)
873	\|\| vrc == VERR_SHARING_VIOLATION
874	)
875	{
876	if (RT_SUCCESS(vrc))
877	RTFileClose(f);
878	if (!fForceOverwrite)
879	hrc = setError(VBOX_E_FILE_ERROR, tr("Machine settings file '%s' already exists"), mData->m_strConfigFileFull.c_str());
880	else
881	{
882	/* try to delete the config file, as otherwise the creation
883	* of a new settings file will fail. */
884	i_deleteFile(mData->m_strConfigFileFull.c_str(), false /* fIgnoreFailures */, tr("existing settings file"));
885	}
886	}
887	else if ( vrc != VERR_FILE_NOT_FOUND
888	&& vrc != VERR_PATH_NOT_FOUND
889	)
890	hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Invalid machine settings file name '%s' (%Rrc)"),
891	mData->m_strConfigFileFull.c_str(), vrc);
892	return hrc;
893	}
894
895	/**
896	* Initializes the registered machine by loading the settings file.
897	* This method is separated from #init() in order to make it possible to
898	* retry the operation after VirtualBox startup instead of refusing to
899	* startup the whole VirtualBox server in case if the settings file of some
900	* registered VM is invalid or inaccessible.
901	*
902	* @note Must be always called from this object's write lock
903	* (unless called from #init() that doesn't need any locking).
904	* @note Locks the mUSBController method for writing.
905	* @note Subclasses must not call this method.
906	*/
907	HRESULT Machine::i_registeredInit()
908	{
909	AssertReturn(!i_isSessionMachine(), E_FAIL);
910	AssertReturn(!i_isSnapshotMachine(), E_FAIL);
911	AssertReturn(mData->mUuid.isValid(), E_FAIL);
912	AssertReturn(!mData->mAccessible, E_FAIL);
913
914	HRESULT hrc = initDataAndChildObjects();
915	if (SUCCEEDED(hrc))
916	{
917	/* Temporarily reset the registered flag in order to let setters
918	* potentially called from loadSettings() succeed (isMutable() used in
919	* all setters will return FALSE for a Machine instance if mRegistered
920	* is TRUE). */
921	mData->mRegistered = FALSE;
922
923	PCVBOXCRYPTOIF pCryptoIf = NULL;
924	SecretKey *pKey = NULL;
925	const char *pszPassword = NULL;
926	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
927	/* Resolve password and cryptographic support interface if machine is encrypted. */
928	if (mData->mstrKeyId.isNotEmpty())
929	{
930	/* Get at the crpytographic interface. */
931	hrc = mParent->i_retainCryptoIf(&pCryptoIf);
932	if (SUCCEEDED(hrc))
933	{
934	int vrc = mData->mpKeyStore->retainSecretKey(mData->mstrKeyId, &pKey);
935	if (RT_SUCCESS(vrc))
936	pszPassword = (const char *)pKey->getKeyBuffer();
937	else
938	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to retain key for key ID '%s' with %Rrc"),
939	mData->mstrKeyId.c_str(), vrc);
940	}
941	}
942	#else
943	RT_NOREF(pKey);
944	#endif
945
946	if (SUCCEEDED(hrc))
947	{
948	try
949	{
950	// load and parse machine XML; this will throw on XML or logic errors
951	mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull,
952	pCryptoIf, pszPassword);
953
954	if (mData->mUuid != mData->pMachineConfigFile->uuid)
955	throw setError(E_FAIL,
956	tr("Machine UUID {%RTuuid} in '%s' doesn't match its UUID {%s} in the registry file '%s'"),
957	mData->pMachineConfigFile->uuid.raw(),
958	mData->m_strConfigFileFull.c_str(),
959	mData->mUuid.toString().c_str(),
960	mParent->i_settingsFilePath().c_str());
961
962	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
963	// If config is encrypted, no exception is thrown allowing us to get the uuid and the encryption fields.
964	// We fill in the encryptions fields, and the rest will be filled in if all data parsed
965	mData->mstrKeyId = mData->pMachineConfigFile->strKeyId;
966	mData->mstrKeyStore = mData->pMachineConfigFile->strKeyStore;
967
968	if (mData->pMachineConfigFile->enmParseState == settings::MachineConfigFile::ParseState_PasswordError)
969	hrc = setError(VBOX_E_PASSWORD_INCORRECT,
970	tr("Config decryption of the machine {%RTuuid} failed. Incorrect or unknown password"),
971	mData->pMachineConfigFile->uuid.raw());
972	else
973	#endif
974	hrc = i_loadMachineDataFromSettings(mData->pMachineConfigFile, NULL / const Guid puuidRegistry /);
975	if (FAILED(hrc)) throw hrc;
976	}
977	catch (HRESULT err)
978	{
979	/* we assume that error info is set by the thrower */
980	hrc = err;
981	}
982	catch (...)
983	{
984	hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
985	}
986
987	/* Restore the registered flag (even on failure) */
988	mData->mRegistered = TRUE;
989	}
990
991	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
992	if (pCryptoIf)
993	mParent->i_releaseCryptoIf(pCryptoIf);
994	if (pKey)
995	mData->mpKeyStore->releaseSecretKey(mData->mstrKeyId);
996	#endif
997	}
998
999	if (SUCCEEDED(hrc))
1000	{
1001	/* Set mAccessible to TRUE only if we successfully locked and loaded
1002	* the settings file */
1003	mData->mAccessible = TRUE;
1004
1005	/* commit all changes made during loading the settings file */
1006	i_commit(); /// @todo r=dj why do we need a commit during init?!? this is very expensive
1007	/// @todo r=klaus for some reason the settings loading logic backs up
1008	// the settings, and therefore a commit is needed. Should probably be changed.
1009	}
1010	else
1011	{
1012	/* If the machine is registered, then, instead of returning a
1013	* failure, we mark it as inaccessible and set the result to
1014	* success to give it a try later */
1015
1016	/* fetch the current error info */
1017	mData->mAccessError = com::ErrorInfo();
1018	Log1Warning(("Machine {%RTuuid} is inaccessible! [%ls]\n", mData->mUuid.raw(), mData->mAccessError.getText().raw()));
1019
1020	/* rollback all changes */
1021	i_rollback(false /* aNotify */);
1022
1023	// uninit media from this machine's media registry, or else
1024	// reloading the settings will fail
1025	mParent->i_unregisterMachineMedia(i_getId());
1026
1027	/* uninitialize the common part to make sure all data is reset to
1028	* default (null) values */
1029	uninitDataAndChildObjects();
1030
1031	hrc = S_OK;
1032	}
1033
1034	return hrc;
1035	}
1036
1037	/**
1038	* Uninitializes the instance.
1039	* Called either from FinalRelease() or by the parent when it gets destroyed.
1040	*
1041	* @note The caller of this method must make sure that this object
1042	* a) doesn't have active callers on the current thread and b) is not locked
1043	* by the current thread; otherwise uninit() will hang either a) due to
1044	* AutoUninitSpan waiting for a number of calls to drop to zero or b) due to
1045	* a dead-lock caused by this thread waiting for all callers on the other
1046	* threads are done but preventing them from doing so by holding a lock.
1047	*/
1048	void Machine::uninit()
1049	{
1050	LogFlowThisFuncEnter();
1051
1052	Assert(!isWriteLockOnCurrentThread());
1053
1054	Assert(!uRegistryNeedsSaving);
1055	if (uRegistryNeedsSaving)
1056	{
1057	AutoCaller autoCaller(this);
1058	if (SUCCEEDED(autoCaller.hrc()))
1059	{
1060	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1061	i_saveSettings(NULL, alock, Machine::SaveS_Force);
1062	}
1063	}
1064
1065	/* Enclose the state transition Ready->InUninit->NotReady */
1066	AutoUninitSpan autoUninitSpan(this);
1067	if (autoUninitSpan.uninitDone())
1068	return;
1069
1070	Assert(!i_isSnapshotMachine());
1071	Assert(!i_isSessionMachine());
1072	Assert(!!mData);
1073
1074	LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
1075	LogFlowThisFunc(("mRegistered=%d\n", mData->mRegistered));
1076
1077	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1078
1079	if (!mData->mSession.mMachine.isNull())
1080	{
1081	/* Theoretically, this can only happen if the VirtualBox server has been
1082	* terminated while there were clients running that owned open direct
1083	* sessions. Since in this case we are definitely called by
1084	* VirtualBox::uninit(), we may be sure that SessionMachine::uninit()
1085	* won't happen on the client watcher thread (because it has a
1086	* VirtualBox caller for the duration of the
1087	* SessionMachine::i_checkForDeath() call, so that VirtualBox::uninit()
1088	* cannot happen until the VirtualBox caller is released). This is
1089	* important, because SessionMachine::uninit() cannot correctly operate
1090	* after we return from this method (it expects the Machine instance is
1091	* still valid). We'll call it ourselves below.
1092	*/
1093	Log1WarningThisFunc(("Session machine is not NULL (%p), the direct session is still open!\n",
1094	(SessionMachine*)mData->mSession.mMachine));
1095
1096	if (Global::IsOnlineOrTransient(mData->mMachineState))
1097	{
1098	Log1WarningThisFunc(("Setting state to Aborted!\n"));
1099	/* set machine state using SessionMachine reimplementation */
1100	static_cast<Machine*>(mData->mSession.mMachine)->i_setMachineState(MachineState_Aborted);
1101	}
1102
1103	/*
1104	* Uninitialize SessionMachine using public uninit() to indicate
1105	* an unexpected uninitialization.
1106	*/
1107	mData->mSession.mMachine->uninit();
1108	/* SessionMachine::uninit() must set mSession.mMachine to null */
1109	Assert(mData->mSession.mMachine.isNull());
1110	}
1111
1112	// uninit media from this machine's media registry, if they're still there
1113	Guid uuidMachine(i_getId());
1114
1115	/* the lock is no more necessary (SessionMachine is uninitialized) */
1116	alock.release();
1117
1118	/* XXX This will fail with
1119	* "cannot be closed because it is still attached to 1 virtual machines"
1120	* because at this point we did not call uninitDataAndChildObjects() yet
1121	* and therefore also removeBackReference() for all these media was not called! */
1122
1123	if (uuidMachine.isValid() && !uuidMachine.isZero()) // can be empty if we're called from a failure of Machine::init
1124	mParent->i_unregisterMachineMedia(uuidMachine);
1125
1126	// has machine been modified?
1127	if (mData->flModifications)
1128	{
1129	Log1WarningThisFunc(("Discarding unsaved settings changes!\n"));
1130	i_rollback(false /* aNotify */);
1131	}
1132
1133	if (mData->mAccessible)
1134	uninitDataAndChildObjects();
1135
1136	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
1137	if (mData->mpKeyStore != NULL)
1138	delete mData->mpKeyStore;
1139	#endif
1140
1141	/* free the essential data structure last */
1142	mData.free();
1143
1144	LogFlowThisFuncLeave();
1145	}
1146
1147	// Wrapped IMachine properties
1148	/////////////////////////////////////////////////////////////////////////////
1149	HRESULT Machine::getParent(ComPtr<IVirtualBox> &aParent)
1150	{
1151	/* mParent is constant during life time, no need to lock */
1152	ComObjPtr<VirtualBox> pVirtualBox(mParent);
1153	aParent = pVirtualBox;
1154
1155	return S_OK;
1156	}
1157
1158	HRESULT Machine::getPlatform(ComPtr<IPlatform> &aPlatform)
1159	{
1160	/* mPlatform is constant during life time, no need to lock */
1161	ComObjPtr<Platform> pPlatform(mPlatform);
1162	aPlatform = pPlatform;
1163
1164	return S_OK;
1165	}
1166
1167	HRESULT Machine::getAccessible(BOOL *aAccessible)
1168	{
1169	/* In some cases (medium registry related), it is necessary to be able to
1170	* go through the list of all machines. Happens when an inaccessible VM
1171	* has a sensible medium registry. */
1172	AutoReadLock mllock(mParent->i_getMachinesListLockHandle() COMMA_LOCKVAL_SRC_POS);
1173	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1174
1175	HRESULT hrc = S_OK;
1176
1177	if (!mData->mAccessible)
1178	{
1179	/* try to initialize the VM once more if not accessible */
1180
1181	AutoReinitSpan autoReinitSpan(this);
1182	AssertReturn(autoReinitSpan.isOk(), E_FAIL);
1183
1184	#ifdef DEBUG
1185	LogFlowThisFunc(("Dumping media backreferences\n"));
1186	mParent->i_dumpAllBackRefs();
1187	#endif
1188
1189	if (mData->pMachineConfigFile)
1190	{
1191	// reset the XML file to force loadSettings() (called from i_registeredInit())
1192	// to parse it again; the file might have changed
1193	delete mData->pMachineConfigFile;
1194	mData->pMachineConfigFile = NULL;
1195	}
1196
1197	hrc = i_registeredInit();
1198
1199	if (SUCCEEDED(hrc) && mData->mAccessible)
1200	{
1201	autoReinitSpan.setSucceeded();
1202
1203	/* make sure interesting parties will notice the accessibility
1204	* state change */
1205	mParent->i_onMachineStateChanged(mData->mUuid, mData->mMachineState);
1206	mParent->i_onMachineDataChanged(mData->mUuid);
1207	}
1208	}
1209
1210	if (SUCCEEDED(hrc))
1211	*aAccessible = mData->mAccessible;
1212
1213	LogFlowThisFuncLeave();
1214
1215	return hrc;
1216	}
1217
1218	HRESULT Machine::getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError)
1219	{
1220	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1221
1222	if (mData->mAccessible \|\| !mData->mAccessError.isBasicAvailable())
1223	{
1224	/* return shortly */
1225	aAccessError = NULL;
1226	return S_OK;
1227	}
1228
1229	HRESULT hrc = S_OK;
1230
1231	ComObjPtr<VirtualBoxErrorInfo> errorInfo;
1232	hrc = errorInfo.createObject();
1233	if (SUCCEEDED(hrc))
1234	{
1235	errorInfo->init(mData->mAccessError.getResultCode(),
1236	mData->mAccessError.getInterfaceID().ref(),
1237	Utf8Str(mData->mAccessError.getComponent()).c_str(),
1238	Utf8Str(mData->mAccessError.getText()));
1239	aAccessError = errorInfo;
1240	}
1241
1242	return hrc;
1243	}
1244
1245	HRESULT Machine::getName(com::Utf8Str &aName)
1246	{
1247	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1248
1249	aName = mUserData->s.strName;
1250
1251	return S_OK;
1252	}
1253
1254	HRESULT Machine::setName(const com::Utf8Str &aName)
1255	{
1256	// prohibit setting a UUID only as the machine name, or else it can
1257	// never be found by findMachine()
1258	Guid test(aName);
1259
1260	if (test.isValid())
1261	return setError(E_INVALIDARG, tr("A machine cannot have a UUID as its name"));
1262
1263	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1264
1265	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
1266	if (FAILED(hrc)) return hrc;
1267
1268	i_setModified(IsModified_MachineData);
1269	mUserData.backup();
1270	mUserData->s.strName = aName;
1271
1272	return S_OK;
1273	}
1274
1275	HRESULT Machine::getDescription(com::Utf8Str &aDescription)
1276	{
1277	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1278
1279	aDescription = mUserData->s.strDescription;
1280
1281	return S_OK;
1282	}
1283
1284	HRESULT Machine::setDescription(const com::Utf8Str &aDescription)
1285	{
1286	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1287
1288	// this can be done in principle in any state as it doesn't affect the VM
1289	// significantly, but play safe by not messing around while complex
1290	// activities are going on
1291	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
1292	if (FAILED(hrc)) return hrc;
1293
1294	i_setModified(IsModified_MachineData);
1295	mUserData.backup();
1296	mUserData->s.strDescription = aDescription;
1297
1298	return S_OK;
1299	}
1300
1301	HRESULT Machine::getId(com::Guid &aId)
1302	{
1303	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1304
1305	aId = mData->mUuid;
1306
1307	return S_OK;
1308	}
1309
1310	HRESULT Machine::getGroups(std::vector<com::Utf8Str> &aGroups)
1311	{
1312	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1313	aGroups.resize(mUserData->s.llGroups.size());
1314	size_t i = 0;
1315	for (StringsList::const_iterator
1316	it = mUserData->s.llGroups.begin();
1317	it != mUserData->s.llGroups.end();
1318	++it, ++i)
1319	aGroups[i] = (*it);
1320
1321	return S_OK;
1322	}
1323
1324	HRESULT Machine::setGroups(const std::vector<com::Utf8Str> &aGroups)
1325	{
1326	StringsList llGroups;
1327	HRESULT hrc = mParent->i_convertMachineGroups(aGroups, &llGroups);
1328	if (FAILED(hrc))
1329	return hrc;
1330
1331	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1332
1333	hrc = i_checkStateDependency(MutableOrSavedStateDep);
1334	if (FAILED(hrc)) return hrc;
1335
1336	i_setModified(IsModified_MachineData);
1337	mUserData.backup();
1338	mUserData->s.llGroups = llGroups;
1339
1340	mParent->i_onMachineGroupsChanged(mData->mUuid);
1341	return S_OK;
1342	}
1343
1344	HRESULT Machine::getOSTypeId(com::Utf8Str &aOSTypeId)
1345	{
1346	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1347
1348	aOSTypeId = mUserData->s.strOsType;
1349
1350	return S_OK;
1351	}
1352
1353	HRESULT Machine::setOSTypeId(const com::Utf8Str &aOSTypeId)
1354	{
1355	/* look up the object by Id to check it is valid */
1356	ComObjPtr<GuestOSType> pGuestOSType;
1357	mParent->i_findGuestOSType(aOSTypeId, pGuestOSType);
1358
1359	/* when setting, always use the "etalon" value for consistency -- lookup
1360	* by ID is case-insensitive and the input value may have different case */
1361	Utf8Str osTypeId = !pGuestOSType.isNull() ? pGuestOSType->i_id() : aOSTypeId;
1362
1363	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1364
1365	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1366	if (FAILED(hrc)) return hrc;
1367
1368	i_setModified(IsModified_MachineData);
1369	mUserData.backup();
1370	mUserData->s.strOsType = osTypeId;
1371
1372	return S_OK;
1373	}
1374
1375	HRESULT Machine::getKeyboardHIDType(KeyboardHIDType_T *aKeyboardHIDType)
1376	{
1377	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1378
1379	*aKeyboardHIDType = mHWData->mKeyboardHIDType;
1380
1381	return S_OK;
1382	}
1383
1384	HRESULT Machine::setKeyboardHIDType(KeyboardHIDType_T aKeyboardHIDType)
1385	{
1386	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1387
1388	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1389	if (FAILED(hrc)) return hrc;
1390
1391	i_setModified(IsModified_MachineData);
1392	mHWData.backup();
1393	mHWData->mKeyboardHIDType = aKeyboardHIDType;
1394
1395	return S_OK;
1396	}
1397
1398	HRESULT Machine::getPointingHIDType(PointingHIDType_T *aPointingHIDType)
1399	{
1400	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1401
1402	*aPointingHIDType = mHWData->mPointingHIDType;
1403
1404	return S_OK;
1405	}
1406
1407	HRESULT Machine::setPointingHIDType(PointingHIDType_T aPointingHIDType)
1408	{
1409	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1410
1411	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1412	if (FAILED(hrc)) return hrc;
1413
1414	i_setModified(IsModified_MachineData);
1415	mHWData.backup();
1416	mHWData->mPointingHIDType = aPointingHIDType;
1417
1418	return S_OK;
1419	}
1420
1421	HRESULT Machine::getParavirtDebug(com::Utf8Str &aParavirtDebug)
1422	{
1423	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1424
1425	aParavirtDebug = mHWData->mParavirtDebug;
1426	return S_OK;
1427	}
1428
1429	HRESULT Machine::setParavirtDebug(const com::Utf8Str &aParavirtDebug)
1430	{
1431	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1432
1433	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1434	if (FAILED(hrc)) return hrc;
1435
1436	/** @todo Parse/validate options? */
1437	if (aParavirtDebug != mHWData->mParavirtDebug)
1438	{
1439	i_setModified(IsModified_MachineData);
1440	mHWData.backup();
1441	mHWData->mParavirtDebug = aParavirtDebug;
1442	}
1443
1444	return S_OK;
1445	}
1446
1447	HRESULT Machine::getParavirtProvider(ParavirtProvider_T *aParavirtProvider)
1448	{
1449	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1450
1451	*aParavirtProvider = mHWData->mParavirtProvider;
1452
1453	return S_OK;
1454	}
1455
1456	HRESULT Machine::setParavirtProvider(ParavirtProvider_T aParavirtProvider)
1457	{
1458	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1459
1460	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1461	if (FAILED(hrc)) return hrc;
1462
1463	if (aParavirtProvider != mHWData->mParavirtProvider)
1464	{
1465	i_setModified(IsModified_MachineData);
1466	mHWData.backup();
1467	mHWData->mParavirtProvider = aParavirtProvider;
1468	}
1469
1470	return S_OK;
1471	}
1472
1473	HRESULT Machine::getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider)
1474	{
1475	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1476
1477	*aParavirtProvider = mHWData->mParavirtProvider;
1478	switch (mHWData->mParavirtProvider)
1479	{
1480	case ParavirtProvider_None:
1481	case ParavirtProvider_HyperV:
1482	case ParavirtProvider_KVM:
1483	case ParavirtProvider_Minimal:
1484	break;
1485
1486	/* Resolve dynamic provider types to the effective types. */
1487	default:
1488	{
1489	ComObjPtr<GuestOSType> pGuestOSType;
1490	HRESULT hrc2 = mParent->i_findGuestOSType(mUserData->s.strOsType,
1491	pGuestOSType);
1492	if (FAILED(hrc2) \|\| pGuestOSType.isNull())
1493	{
1494	*aParavirtProvider = ParavirtProvider_None;
1495	break;
1496	}
1497
1498	Utf8Str guestTypeFamilyId = pGuestOSType->i_familyId();
1499	bool fOsXGuest = guestTypeFamilyId == "MacOS";
1500
1501	switch (mHWData->mParavirtProvider)
1502	{
1503	case ParavirtProvider_Legacy:
1504	{
1505	if (fOsXGuest)
1506	*aParavirtProvider = ParavirtProvider_Minimal;
1507	else
1508	*aParavirtProvider = ParavirtProvider_None;
1509	break;
1510	}
1511
1512	case ParavirtProvider_Default:
1513	{
1514	Assert(strlen(GUEST_OS_ID_STR_X64("")) > 0);
1515	if (fOsXGuest)
1516	*aParavirtProvider = ParavirtProvider_Minimal;
1517	else if ( mUserData->s.strOsType == GUEST_OS_ID_STR_X64("Windows11")
1518	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X86("Windows10")
1519	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X64("Windows10")
1520	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X86("Windows81")
1521	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X64("Windows81")
1522	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X86("Windows8")
1523	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X64("Windows8")
1524	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X86("Windows7")
1525	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X64("Windows7")
1526	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X86("WindowsVista")
1527	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X64("WindowsVista")
1528	\|\| ( ( mUserData->s.strOsType.startsWith("Windows202")
1529	\|\| mUserData->s.strOsType.startsWith("Windows201"))
1530	&& mUserData->s.strOsType.endsWith(GUEST_OS_ID_STR_X64("")))
1531	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X86("Windows2012")
1532	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X64("Windows2012")
1533	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X86("Windows2008")
1534	\|\| mUserData->s.strOsType == GUEST_OS_ID_STR_X64("Windows2008"))
1535	*aParavirtProvider = ParavirtProvider_HyperV;
1536	else if ( guestTypeFamilyId == "Linux"
1537	&& mUserData->s.strOsType != GUEST_OS_ID_STR_X86("Linux22") // Linux22 and Linux24{_64} excluded as they're too old
1538	&& mUserData->s.strOsType != GUEST_OS_ID_STR_X86("Linux24") // to have any KVM paravirtualization support.
1539	&& mUserData->s.strOsType != GUEST_OS_ID_STR_X64("Linux24"))
1540	*aParavirtProvider = ParavirtProvider_KVM;
1541	else
1542	*aParavirtProvider = ParavirtProvider_None;
1543	break;
1544	}
1545
1546	default: AssertFailedBreak(); /* Shut up MSC. */
1547	}
1548	break;
1549	}
1550	}
1551
1552	Assert( *aParavirtProvider == ParavirtProvider_None
1553	\|\| *aParavirtProvider == ParavirtProvider_Minimal
1554	\|\| *aParavirtProvider == ParavirtProvider_HyperV
1555	\|\| *aParavirtProvider == ParavirtProvider_KVM);
1556	return S_OK;
1557	}
1558
1559	HRESULT Machine::getHardwareVersion(com::Utf8Str &aHardwareVersion)
1560	{
1561	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1562
1563	aHardwareVersion = mHWData->mHWVersion;
1564
1565	return S_OK;
1566	}
1567
1568	HRESULT Machine::setHardwareVersion(const com::Utf8Str &aHardwareVersion)
1569	{
1570	/* check known version */
1571	Utf8Str hwVersion = aHardwareVersion;
1572	if ( hwVersion.compare("1") != 0
1573	&& hwVersion.compare("2") != 0) // VBox 2.1.x and later (VMMDev heap)
1574	return setError(E_INVALIDARG,
1575	tr("Invalid hardware version: %s\n"), aHardwareVersion.c_str());
1576
1577	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1578
1579	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1580	if (FAILED(hrc)) return hrc;
1581
1582	i_setModified(IsModified_MachineData);
1583	mHWData.backup();
1584	mHWData->mHWVersion = aHardwareVersion;
1585
1586	return S_OK;
1587	}
1588
1589	HRESULT Machine::getHardwareUUID(com::Guid &aHardwareUUID)
1590	{
1591	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1592
1593	if (!mHWData->mHardwareUUID.isZero())
1594	aHardwareUUID = mHWData->mHardwareUUID;
1595	else
1596	aHardwareUUID = mData->mUuid;
1597
1598	return S_OK;
1599	}
1600
1601	HRESULT Machine::setHardwareUUID(const com::Guid &aHardwareUUID)
1602	{
1603	if (!aHardwareUUID.isValid())
1604	return E_INVALIDARG;
1605
1606	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1607
1608	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1609	if (FAILED(hrc)) return hrc;
1610
1611	i_setModified(IsModified_MachineData);
1612	mHWData.backup();
1613	if (aHardwareUUID == mData->mUuid)
1614	mHWData->mHardwareUUID.clear();
1615	else
1616	mHWData->mHardwareUUID = aHardwareUUID;
1617
1618	return S_OK;
1619	}
1620
1621	HRESULT Machine::getMemorySize(ULONG *aMemorySize)
1622	{
1623	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1624
1625	*aMemorySize = mHWData->mMemorySize;
1626
1627	return S_OK;
1628	}
1629
1630	HRESULT Machine::setMemorySize(ULONG aMemorySize)
1631	{
1632	/* check RAM limits */
1633	if ( aMemorySize < MM_RAM_MIN_IN_MB
1634	\|\| aMemorySize > MM_RAM_MAX_IN_MB
1635	)
1636	return setError(E_INVALIDARG,
1637	tr("Invalid RAM size: %lu MB (must be in range [%lu, %lu] MB)"),
1638	aMemorySize, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
1639
1640	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1641
1642	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1643	if (FAILED(hrc)) return hrc;
1644
1645	i_setModified(IsModified_MachineData);
1646	mHWData.backup();
1647	mHWData->mMemorySize = aMemorySize;
1648
1649	return S_OK;
1650	}
1651
1652	HRESULT Machine::getCPUCount(ULONG *aCPUCount)
1653	{
1654	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1655
1656	*aCPUCount = mHWData->mCPUCount;
1657
1658	return S_OK;
1659	}
1660
1661	HRESULT Machine::setCPUCount(ULONG aCPUCount)
1662	{
1663	/* check CPU limits */
1664	if ( aCPUCount < SchemaDefs::MinCPUCount
1665	\|\| aCPUCount > SchemaDefs::MaxCPUCount
1666	)
1667	return setError(E_INVALIDARG,
1668	tr("Invalid virtual CPU count: %lu (must be in range [%lu, %lu])"),
1669	aCPUCount, SchemaDefs::MinCPUCount, SchemaDefs::MaxCPUCount);
1670
1671	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1672
1673	/* We cant go below the current number of CPUs attached if hotplug is enabled*/
1674	if (mHWData->mCPUHotPlugEnabled)
1675	{
1676	for (unsigned idx = aCPUCount; idx < SchemaDefs::MaxCPUCount; idx++)
1677	{
1678	if (mHWData->mCPUAttached[idx])
1679	return setError(E_INVALIDARG,
1680	tr("There is still a CPU attached to socket %lu."
1681	"Detach the CPU before removing the socket"),
1682	aCPUCount, idx+1);
1683	}
1684	}
1685
1686	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1687	if (FAILED(hrc)) return hrc;
1688
1689	i_setModified(IsModified_MachineData);
1690	mHWData.backup();
1691	mHWData->mCPUCount = aCPUCount;
1692
1693	return S_OK;
1694	}
1695
1696	HRESULT Machine::getCPUExecutionCap(ULONG *aCPUExecutionCap)
1697	{
1698	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1699
1700	*aCPUExecutionCap = mHWData->mCpuExecutionCap;
1701
1702	return S_OK;
1703	}
1704
1705	HRESULT Machine::setCPUExecutionCap(ULONG aCPUExecutionCap)
1706	{
1707	/* check throttle limits */
1708	if ( aCPUExecutionCap < 1
1709	\|\| aCPUExecutionCap > 100
1710	)
1711	return setError(E_INVALIDARG,
1712	tr("Invalid CPU execution cap value: %lu (must be in range [%lu, %lu])"),
1713	aCPUExecutionCap, 1, 100);
1714
1715	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1716
1717	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
1718	if (FAILED(hrc)) return hrc;
1719
1720	alock.release();
1721	hrc = i_onCPUExecutionCapChange(aCPUExecutionCap);
1722	alock.acquire();
1723	if (FAILED(hrc)) return hrc;
1724
1725	i_setModified(IsModified_MachineData);
1726	mHWData.backup();
1727	mHWData->mCpuExecutionCap = aCPUExecutionCap;
1728
1729	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
1730	if (Global::IsOnline(mData->mMachineState))
1731	i_saveSettings(NULL, alock);
1732
1733	return S_OK;
1734	}
1735
1736	HRESULT Machine::getCPUHotPlugEnabled(BOOL *aCPUHotPlugEnabled)
1737	{
1738	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1739
1740	*aCPUHotPlugEnabled = mHWData->mCPUHotPlugEnabled;
1741
1742	return S_OK;
1743	}
1744
1745	HRESULT Machine::setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled)
1746	{
1747	HRESULT hrc = S_OK;
1748
1749	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1750
1751	hrc = i_checkStateDependency(MutableStateDep);
1752	if (FAILED(hrc)) return hrc;
1753
1754	if (mHWData->mCPUHotPlugEnabled != aCPUHotPlugEnabled)
1755	{
1756	if (aCPUHotPlugEnabled)
1757	{
1758	i_setModified(IsModified_MachineData);
1759	mHWData.backup();
1760
1761	/* Add the amount of CPUs currently attached */
1762	for (unsigned i = 0; i < mHWData->mCPUCount; ++i)
1763	mHWData->mCPUAttached[i] = true;
1764	}
1765	else
1766	{
1767	/*
1768	* We can disable hotplug only if the amount of maximum CPUs is equal
1769	* to the amount of attached CPUs
1770	*/
1771	unsigned cCpusAttached = 0;
1772	unsigned iHighestId = 0;
1773
1774	for (unsigned i = 0; i < SchemaDefs::MaxCPUCount; ++i)
1775	{
1776	if (mHWData->mCPUAttached[i])
1777	{
1778	cCpusAttached++;
1779	iHighestId = i;
1780	}
1781	}
1782
1783	if ( (cCpusAttached != mHWData->mCPUCount)
1784	\|\| (iHighestId >= mHWData->mCPUCount))
1785	return setError(E_INVALIDARG,
1786	tr("CPU hotplugging can't be disabled because the maximum number of CPUs is not equal to the amount of CPUs attached"));
1787
1788	i_setModified(IsModified_MachineData);
1789	mHWData.backup();
1790	}
1791	}
1792
1793	mHWData->mCPUHotPlugEnabled = aCPUHotPlugEnabled;
1794
1795	return hrc;
1796	}
1797
1798	HRESULT Machine::getCPUIDPortabilityLevel(ULONG *aCPUIDPortabilityLevel)
1799	{
1800	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1801
1802	*aCPUIDPortabilityLevel = mHWData->mCpuIdPortabilityLevel;
1803
1804	return S_OK;
1805	}
1806
1807	HRESULT Machine::setCPUIDPortabilityLevel(ULONG aCPUIDPortabilityLevel)
1808	{
1809	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1810
1811	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1812	if (SUCCEEDED(hrc))
1813	{
1814	i_setModified(IsModified_MachineData);
1815	mHWData.backup();
1816	mHWData->mCpuIdPortabilityLevel = aCPUIDPortabilityLevel;
1817	}
1818	return hrc;
1819	}
1820
1821	HRESULT Machine::getCPUProfile(com::Utf8Str &aCPUProfile)
1822	{
1823	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1824	aCPUProfile = mHWData->mCpuProfile;
1825	return S_OK;
1826	}
1827
1828	HRESULT Machine::setCPUProfile(const com::Utf8Str &aCPUProfile)
1829	{
1830	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1831	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1832	if (SUCCEEDED(hrc))
1833	{
1834	i_setModified(IsModified_MachineData);
1835	mHWData.backup();
1836	/* Empty equals 'host'. */
1837	if (aCPUProfile.isNotEmpty())
1838	mHWData->mCpuProfile = aCPUProfile;
1839	else
1840	mHWData->mCpuProfile = "host";
1841	}
1842	return hrc;
1843	}
1844
1845	HRESULT Machine::getEmulatedUSBCardReaderEnabled(BOOL *aEmulatedUSBCardReaderEnabled)
1846	{
1847	#ifdef VBOX_WITH_USB_CARDREADER
1848	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1849
1850	*aEmulatedUSBCardReaderEnabled = mHWData->mEmulatedUSBCardReaderEnabled;
1851
1852	return S_OK;
1853	#else
1854	NOREF(aEmulatedUSBCardReaderEnabled);
1855	return E_NOTIMPL;
1856	#endif
1857	}
1858
1859	HRESULT Machine::setEmulatedUSBCardReaderEnabled(BOOL aEmulatedUSBCardReaderEnabled)
1860	{
1861	#ifdef VBOX_WITH_USB_CARDREADER
1862	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1863
1864	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
1865	if (FAILED(hrc)) return hrc;
1866
1867	i_setModified(IsModified_MachineData);
1868	mHWData.backup();
1869	mHWData->mEmulatedUSBCardReaderEnabled = aEmulatedUSBCardReaderEnabled;
1870
1871	return S_OK;
1872	#else
1873	NOREF(aEmulatedUSBCardReaderEnabled);
1874	return E_NOTIMPL;
1875	#endif
1876	}
1877
1878	/** @todo this method should not be public */
1879	HRESULT Machine::getMemoryBalloonSize(ULONG *aMemoryBalloonSize)
1880	{
1881	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1882
1883	*aMemoryBalloonSize = mHWData->mMemoryBalloonSize;
1884
1885	return S_OK;
1886	}
1887
1888	/**
1889	* Set the memory balloon size.
1890	*
1891	* This method is also called from IGuest::COMSETTER(MemoryBalloonSize) so
1892	* we have to make sure that we never call IGuest from here.
1893	*/
1894	HRESULT Machine::setMemoryBalloonSize(ULONG aMemoryBalloonSize)
1895	{
1896	/* This must match GMMR0Init; currently we only support memory ballooning on all 64-bit hosts except Mac OS X */
1897	#if HC_ARCH_BITS == 64 && (defined(RT_OS_WINDOWS) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD))
1898	/* check limits */
1899	if (aMemoryBalloonSize >= VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize))
1900	return setError(E_INVALIDARG,
1901	tr("Invalid memory balloon size: %lu MB (must be in range [%lu, %lu] MB)"),
1902	aMemoryBalloonSize, 0, VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize));
1903
1904	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1905
1906	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
1907	if (FAILED(hrc)) return hrc;
1908
1909	i_setModified(IsModified_MachineData);
1910	mHWData.backup();
1911	mHWData->mMemoryBalloonSize = aMemoryBalloonSize;
1912
1913	return S_OK;
1914	#else
1915	NOREF(aMemoryBalloonSize);
1916	return setError(E_NOTIMPL, tr("Memory ballooning is only supported on 64-bit hosts"));
1917	#endif
1918	}
1919
1920	HRESULT Machine::getPageFusionEnabled(BOOL *aPageFusionEnabled)
1921	{
1922	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1923
1924	*aPageFusionEnabled = mHWData->mPageFusionEnabled;
1925	return S_OK;
1926	}
1927
1928	HRESULT Machine::setPageFusionEnabled(BOOL aPageFusionEnabled)
1929	{
1930	#ifdef VBOX_WITH_PAGE_SHARING
1931	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1932
1933	HRESULT hrc = i_checkStateDependency(MutableStateDep);
1934	if (FAILED(hrc)) return hrc;
1935
1936	/** @todo must support changes for running vms and keep this in sync with IGuest. */
1937	i_setModified(IsModified_MachineData);
1938	mHWData.backup();
1939	mHWData->mPageFusionEnabled = aPageFusionEnabled;
1940	return S_OK;
1941	#else
1942	NOREF(aPageFusionEnabled);
1943	return setError(E_NOTIMPL, tr("Page fusion is only supported on 64-bit hosts"));
1944	#endif
1945	}
1946
1947	HRESULT Machine::getFirmwareSettings(ComPtr<IFirmwareSettings> &aFirmwareSettings)
1948	{
1949	/* mFirmwareSettings is constant during life time, no need to lock */
1950	aFirmwareSettings = mFirmwareSettings;
1951
1952	return S_OK;
1953	}
1954
1955	HRESULT Machine::getTrustedPlatformModule(ComPtr<ITrustedPlatformModule> &aTrustedPlatformModule)
1956	{
1957	/* mTrustedPlatformModule is constant during life time, no need to lock */
1958	aTrustedPlatformModule = mTrustedPlatformModule;
1959
1960	return S_OK;
1961	}
1962
1963	HRESULT Machine::getNonVolatileStore(ComPtr<INvramStore> &aNvramStore)
1964	{
1965	/* mNvramStore is constant during life time, no need to lock */
1966	aNvramStore = mNvramStore;
1967
1968	return S_OK;
1969	}
1970
1971	HRESULT Machine::getRecordingSettings(ComPtr<IRecordingSettings> &aRecordingSettings)
1972	{
1973	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1974
1975	aRecordingSettings = mRecordingSettings;
1976
1977	return S_OK;
1978	}
1979
1980	HRESULT Machine::getGraphicsAdapter(ComPtr<IGraphicsAdapter> &aGraphicsAdapter)
1981	{
1982	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1983
1984	aGraphicsAdapter = mGraphicsAdapter;
1985
1986	return S_OK;
1987	}
1988
1989	HRESULT Machine::getSnapshotFolder(com::Utf8Str &aSnapshotFolder)
1990	{
1991	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1992
1993	i_calculateFullPath(mUserData->s.strSnapshotFolder, aSnapshotFolder);
1994
1995	return S_OK;
1996	}
1997
1998	HRESULT Machine::setSnapshotFolder(const com::Utf8Str &aSnapshotFolder)
1999	{
2000	/** @todo (r=dmik):
2001	* 1. Allow to change the name of the snapshot folder containing snapshots
2002	* 2. Rename the folder on disk instead of just changing the property
2003	* value (to be smart and not to leave garbage). Note that it cannot be
2004	* done here because the change may be rolled back. Thus, the right
2005	* place is #saveSettings().
2006	*/
2007
2008	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2009
2010	HRESULT hrc = i_checkStateDependency(MutableStateDep);
2011	if (FAILED(hrc)) return hrc;
2012
2013	if (!mData->mCurrentSnapshot.isNull())
2014	return setError(E_FAIL,
2015	tr("The snapshot folder of a machine with snapshots cannot be changed (please delete all snapshots first)"));
2016
2017	Utf8Str strSnapshotFolder(aSnapshotFolder); // keep original
2018
2019	if (strSnapshotFolder.isEmpty())
2020	strSnapshotFolder = "Snapshots";
2021	int vrc = i_calculateFullPath(strSnapshotFolder, strSnapshotFolder);
2022	if (RT_FAILURE(vrc))
2023	return setErrorBoth(E_FAIL, vrc,
2024	tr("Invalid snapshot folder '%s' (%Rrc)"),
2025	strSnapshotFolder.c_str(), vrc);
2026
2027	i_setModified(IsModified_MachineData);
2028	mUserData.backup();
2029
2030	i_copyPathRelativeToMachine(strSnapshotFolder, mUserData->s.strSnapshotFolder);
2031
2032	return S_OK;
2033	}
2034
2035	HRESULT Machine::getMediumAttachments(std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments)
2036	{
2037	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2038
2039	aMediumAttachments.resize(mMediumAttachments->size());
2040	size_t i = 0;
2041	for (MediumAttachmentList::const_iterator
2042	it = mMediumAttachments->begin();
2043	it != mMediumAttachments->end();
2044	++it, ++i)
2045	aMediumAttachments[i] = *it;
2046
2047	return S_OK;
2048	}
2049
2050	HRESULT Machine::getVRDEServer(ComPtr<IVRDEServer> &aVRDEServer)
2051	{
2052	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2053
2054	Assert(!!mVRDEServer);
2055
2056	aVRDEServer = mVRDEServer;
2057
2058	return S_OK;
2059	}
2060
2061	HRESULT Machine::getAudioSettings(ComPtr<IAudioSettings> &aAudioSettings)
2062	{
2063	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2064
2065	aAudioSettings = mAudioSettings;
2066
2067	return S_OK;
2068	}
2069
2070	HRESULT Machine::getUSBControllers(std::vector<ComPtr<IUSBController> > &aUSBControllers)
2071	{
2072	#ifdef VBOX_WITH_VUSB
2073	clearError();
2074	MultiResult hrcMult(S_OK);
2075
2076	# ifdef VBOX_WITH_USB
2077	hrcMult = mParent->i_host()->i_checkUSBProxyService();
2078	if (FAILED(hrcMult)) return hrcMult;
2079	# endif
2080
2081	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2082
2083	aUSBControllers.resize(mUSBControllers->size());
2084	size_t i = 0;
2085	for (USBControllerList::const_iterator
2086	it = mUSBControllers->begin();
2087	it != mUSBControllers->end();
2088	++it, ++i)
2089	aUSBControllers[i] = *it;
2090
2091	return S_OK;
2092	#else
2093	/* Note: The GUI depends on this method returning E_NOTIMPL with no
2094	* extended error info to indicate that USB is simply not available
2095	* (w/o treating it as a failure), for example, as in OSE */
2096	NOREF(aUSBControllers);
2097	ReturnComNotImplemented();
2098	#endif /* VBOX_WITH_VUSB */
2099	}
2100
2101	HRESULT Machine::getUSBDeviceFilters(ComPtr<IUSBDeviceFilters> &aUSBDeviceFilters)
2102	{
2103	#ifdef VBOX_WITH_VUSB
2104	clearError();
2105	MultiResult hrcMult(S_OK);
2106
2107	# ifdef VBOX_WITH_USB
2108	hrcMult = mParent->i_host()->i_checkUSBProxyService();
2109	if (FAILED(hrcMult)) return hrcMult;
2110	# endif
2111
2112	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2113
2114	aUSBDeviceFilters = mUSBDeviceFilters;
2115	return hrcMult;
2116	#else
2117	/* Note: The GUI depends on this method returning E_NOTIMPL with no
2118	* extended error info to indicate that USB is simply not available
2119	* (w/o treating it as a failure), for example, as in OSE */
2120	NOREF(aUSBDeviceFilters);
2121	ReturnComNotImplemented();
2122	#endif /* VBOX_WITH_VUSB */
2123	}
2124
2125	HRESULT Machine::getSettingsFilePath(com::Utf8Str &aSettingsFilePath)
2126	{
2127	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2128
2129	aSettingsFilePath = mData->m_strConfigFileFull;
2130
2131	return S_OK;
2132	}
2133
2134	HRESULT Machine::getSettingsAuxFilePath(com::Utf8Str &aSettingsFilePath)
2135	{
2136	RT_NOREF(aSettingsFilePath);
2137	ReturnComNotImplemented();
2138	}
2139
2140	HRESULT Machine::getSettingsModified(BOOL *aSettingsModified)
2141	{
2142	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2143
2144	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
2145	if (FAILED(hrc)) return hrc;
2146
2147	if (!mData->pMachineConfigFile->fileExists())
2148	// this is a new machine, and no config file exists yet:
2149	*aSettingsModified = TRUE;
2150	else
2151	*aSettingsModified = (mData->flModifications != 0);
2152
2153	return S_OK;
2154	}
2155
2156	HRESULT Machine::getSessionState(SessionState_T *aSessionState)
2157	{
2158	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2159
2160	*aSessionState = mData->mSession.mState;
2161
2162	return S_OK;
2163	}
2164
2165	HRESULT Machine::getSessionName(com::Utf8Str &aSessionName)
2166	{
2167	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2168
2169	aSessionName = mData->mSession.mName;
2170
2171	return S_OK;
2172	}
2173
2174	HRESULT Machine::getSessionPID(ULONG *aSessionPID)
2175	{
2176	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2177
2178	*aSessionPID = mData->mSession.mPID;
2179
2180	return S_OK;
2181	}
2182
2183	HRESULT Machine::getState(MachineState_T *aState)
2184	{
2185	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2186
2187	*aState = mData->mMachineState;
2188	Assert(mData->mMachineState != MachineState_Null);
2189
2190	return S_OK;
2191	}
2192
2193	HRESULT Machine::getLastStateChange(LONG64 *aLastStateChange)
2194	{
2195	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2196
2197	*aLastStateChange = RTTimeSpecGetMilli(&mData->mLastStateChange);
2198
2199	return S_OK;
2200	}
2201
2202	HRESULT Machine::getStateFilePath(com::Utf8Str &aStateFilePath)
2203	{
2204	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2205
2206	aStateFilePath = mSSData->strStateFilePath;
2207
2208	return S_OK;
2209	}
2210
2211	HRESULT Machine::getLogFolder(com::Utf8Str &aLogFolder)
2212	{
2213	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2214
2215	i_getLogFolder(aLogFolder);
2216
2217	return S_OK;
2218	}
2219
2220	HRESULT Machine::getCurrentSnapshot(ComPtr<ISnapshot> &aCurrentSnapshot)
2221	{
2222	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2223
2224	aCurrentSnapshot = mData->mCurrentSnapshot;
2225
2226	return S_OK;
2227	}
2228
2229	HRESULT Machine::getSnapshotCount(ULONG *aSnapshotCount)
2230	{
2231	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2232
2233	*aSnapshotCount = mData->mFirstSnapshot.isNull()
2234	? 0
2235	: mData->mFirstSnapshot->i_getAllChildrenCount() + 1;
2236
2237	return S_OK;
2238	}
2239
2240	HRESULT Machine::getCurrentStateModified(BOOL *aCurrentStateModified)
2241	{
2242	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2243
2244	/* Note: for machines with no snapshots, we always return FALSE
2245	* (mData->mCurrentStateModified will be TRUE in this case, for historical
2246	* reasons :) */
2247
2248	*aCurrentStateModified = mData->mFirstSnapshot.isNull()
2249	? FALSE
2250	: mData->mCurrentStateModified;
2251
2252	return S_OK;
2253	}
2254
2255	HRESULT Machine::getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders)
2256	{
2257	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2258
2259	aSharedFolders.resize(mHWData->mSharedFolders.size());
2260	size_t i = 0;
2261	for (std::list<ComObjPtr<SharedFolder> >::const_iterator
2262	it = mHWData->mSharedFolders.begin();
2263	it != mHWData->mSharedFolders.end();
2264	++it, ++i)
2265	aSharedFolders[i] = *it;
2266
2267	return S_OK;
2268	}
2269
2270	HRESULT Machine::getClipboardMode(ClipboardMode_T *aClipboardMode)
2271	{
2272	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2273
2274	*aClipboardMode = mHWData->mClipboardMode;
2275
2276	return S_OK;
2277	}
2278
2279	HRESULT Machine::setClipboardMode(ClipboardMode_T aClipboardMode)
2280	{
2281	HRESULT hrc = S_OK;
2282
2283	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2284
2285	hrc = i_checkStateDependency(MutableOrRunningStateDep);
2286	if (FAILED(hrc)) return hrc;
2287
2288	alock.release();
2289	hrc = i_onClipboardModeChange(aClipboardMode);
2290	alock.acquire();
2291	if (FAILED(hrc)) return hrc;
2292
2293	i_setModified(IsModified_MachineData);
2294	mHWData.backup();
2295	mHWData->mClipboardMode = aClipboardMode;
2296
2297	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
2298	if (Global::IsOnline(mData->mMachineState))
2299	i_saveSettings(NULL, alock);
2300
2301	return S_OK;
2302	}
2303
2304	HRESULT Machine::getClipboardFileTransfersEnabled(BOOL *aEnabled)
2305	{
2306	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2307
2308	*aEnabled = mHWData->mClipboardFileTransfersEnabled;
2309
2310	return S_OK;
2311	}
2312
2313	HRESULT Machine::setClipboardFileTransfersEnabled(BOOL aEnabled)
2314	{
2315	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2316
2317	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
2318	if (FAILED(hrc)) return hrc;
2319
2320	alock.release();
2321	hrc = i_onClipboardFileTransferModeChange(aEnabled);
2322	alock.acquire();
2323	if (FAILED(hrc)) return hrc;
2324
2325	i_setModified(IsModified_MachineData);
2326	mHWData.backup();
2327	mHWData->mClipboardFileTransfersEnabled = aEnabled;
2328
2329	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
2330	if (Global::IsOnline(mData->mMachineState))
2331	i_saveSettings(NULL, alock);
2332
2333	return S_OK;
2334	}
2335
2336	HRESULT Machine::getDnDMode(DnDMode_T *aDnDMode)
2337	{
2338	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2339
2340	*aDnDMode = mHWData->mDnDMode;
2341
2342	return S_OK;
2343	}
2344
2345	HRESULT Machine::setDnDMode(DnDMode_T aDnDMode)
2346	{
2347	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2348
2349	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
2350	if (FAILED(hrc)) return hrc;
2351
2352	alock.release();
2353	hrc = i_onDnDModeChange(aDnDMode);
2354
2355	alock.acquire();
2356	if (FAILED(hrc)) return hrc;
2357
2358	i_setModified(IsModified_MachineData);
2359	mHWData.backup();
2360	mHWData->mDnDMode = aDnDMode;
2361
2362	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
2363	if (Global::IsOnline(mData->mMachineState))
2364	i_saveSettings(NULL, alock);
2365
2366	return S_OK;
2367	}
2368
2369	HRESULT Machine::getStorageControllers(std::vector<ComPtr<IStorageController> > &aStorageControllers)
2370	{
2371	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2372
2373	aStorageControllers.resize(mStorageControllers->size());
2374	size_t i = 0;
2375	for (StorageControllerList::const_iterator
2376	it = mStorageControllers->begin();
2377	it != mStorageControllers->end();
2378	++it, ++i)
2379	aStorageControllers[i] = *it;
2380
2381	return S_OK;
2382	}
2383
2384	HRESULT Machine::getTeleporterEnabled(BOOL *aEnabled)
2385	{
2386	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2387
2388	*aEnabled = mUserData->s.fTeleporterEnabled;
2389
2390	return S_OK;
2391	}
2392
2393	HRESULT Machine::setTeleporterEnabled(BOOL aTeleporterEnabled)
2394	{
2395	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2396
2397	/* Only allow it to be set to true when PoweredOff or Aborted.
2398	(Clearing it is always permitted.) */
2399	if ( aTeleporterEnabled
2400	&& mData->mRegistered
2401	&& ( !i_isSessionMachine()
2402	\|\| ( mData->mMachineState != MachineState_PoweredOff
2403	&& mData->mMachineState != MachineState_Teleported
2404	&& mData->mMachineState != MachineState_Aborted
2405	)
2406	)
2407	)
2408	return setError(VBOX_E_INVALID_VM_STATE,
2409	tr("The machine is not powered off (state is %s)"),
2410	Global::stringifyMachineState(mData->mMachineState));
2411
2412	i_setModified(IsModified_MachineData);
2413	mUserData.backup();
2414	mUserData->s.fTeleporterEnabled = !! aTeleporterEnabled;
2415
2416	return S_OK;
2417	}
2418
2419	HRESULT Machine::getTeleporterPort(ULONG *aTeleporterPort)
2420	{
2421	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2422
2423	*aTeleporterPort = (ULONG)mUserData->s.uTeleporterPort;
2424
2425	return S_OK;
2426	}
2427
2428	HRESULT Machine::setTeleporterPort(ULONG aTeleporterPort)
2429	{
2430	if (aTeleporterPort >= _64K)
2431	return setError(E_INVALIDARG, tr("Invalid port number %d"), aTeleporterPort);
2432
2433	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2434
2435	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
2436	if (FAILED(hrc)) return hrc;
2437
2438	i_setModified(IsModified_MachineData);
2439	mUserData.backup();
2440	mUserData->s.uTeleporterPort = (uint32_t)aTeleporterPort;
2441
2442	return S_OK;
2443	}
2444
2445	HRESULT Machine::getTeleporterAddress(com::Utf8Str &aTeleporterAddress)
2446	{
2447	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2448
2449	aTeleporterAddress = mUserData->s.strTeleporterAddress;
2450
2451	return S_OK;
2452	}
2453
2454	HRESULT Machine::setTeleporterAddress(const com::Utf8Str &aTeleporterAddress)
2455	{
2456	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2457
2458	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
2459	if (FAILED(hrc)) return hrc;
2460
2461	i_setModified(IsModified_MachineData);
2462	mUserData.backup();
2463	mUserData->s.strTeleporterAddress = aTeleporterAddress;
2464
2465	return S_OK;
2466	}
2467
2468	HRESULT Machine::getTeleporterPassword(com::Utf8Str &aTeleporterPassword)
2469	{
2470	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2471	aTeleporterPassword = mUserData->s.strTeleporterPassword;
2472
2473	return S_OK;
2474	}
2475
2476	HRESULT Machine::setTeleporterPassword(const com::Utf8Str &aTeleporterPassword)
2477	{
2478	/*
2479	* Hash the password first.
2480	*/
2481	com::Utf8Str aT = aTeleporterPassword;
2482
2483	if (!aT.isEmpty())
2484	{
2485	if (VBoxIsPasswordHashed(&aT))
2486	return setError(E_INVALIDARG, tr("Cannot set an already hashed password, only plain text password please"));
2487	VBoxHashPassword(&aT);
2488	}
2489
2490	/*
2491	* Do the update.
2492	*/
2493	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2494	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
2495	if (SUCCEEDED(hrc))
2496	{
2497	i_setModified(IsModified_MachineData);
2498	mUserData.backup();
2499	mUserData->s.strTeleporterPassword = aT;
2500	}
2501
2502	return hrc;
2503	}
2504
2505	HRESULT Machine::getIOCacheEnabled(BOOL *aIOCacheEnabled)
2506	{
2507	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2508
2509	*aIOCacheEnabled = mHWData->mIOCacheEnabled;
2510
2511	return S_OK;
2512	}
2513
2514	HRESULT Machine::setIOCacheEnabled(BOOL aIOCacheEnabled)
2515	{
2516	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2517
2518	HRESULT hrc = i_checkStateDependency(MutableStateDep);
2519	if (FAILED(hrc)) return hrc;
2520
2521	i_setModified(IsModified_MachineData);
2522	mHWData.backup();
2523	mHWData->mIOCacheEnabled = aIOCacheEnabled;
2524
2525	return S_OK;
2526	}
2527
2528	HRESULT Machine::getIOCacheSize(ULONG *aIOCacheSize)
2529	{
2530	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2531
2532	*aIOCacheSize = mHWData->mIOCacheSize;
2533
2534	return S_OK;
2535	}
2536
2537	HRESULT Machine::setIOCacheSize(ULONG aIOCacheSize)
2538	{
2539	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2540
2541	HRESULT hrc = i_checkStateDependency(MutableStateDep);
2542	if (FAILED(hrc)) return hrc;
2543
2544	i_setModified(IsModified_MachineData);
2545	mHWData.backup();
2546	mHWData->mIOCacheSize = aIOCacheSize;
2547
2548	return S_OK;
2549	}
2550
2551	HRESULT Machine::getStateKeyId(com::Utf8Str &aKeyId)
2552	{
2553	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2554
2555	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
2556	aKeyId = mSSData->strStateKeyId;
2557	#else
2558	aKeyId = com::Utf8Str::Empty;
2559	#endif
2560
2561	return S_OK;
2562	}
2563
2564	HRESULT Machine::getStateKeyStore(com::Utf8Str &aKeyStore)
2565	{
2566	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2567
2568	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
2569	aKeyStore = mSSData->strStateKeyStore;
2570	#else
2571	aKeyStore = com::Utf8Str::Empty;
2572	#endif
2573
2574	return S_OK;
2575	}
2576
2577	HRESULT Machine::getLogKeyId(com::Utf8Str &aKeyId)
2578	{
2579	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2580
2581	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
2582	aKeyId = mData->mstrLogKeyId;
2583	#else
2584	aKeyId = com::Utf8Str::Empty;
2585	#endif
2586
2587	return S_OK;
2588	}
2589
2590	HRESULT Machine::getLogKeyStore(com::Utf8Str &aKeyStore)
2591	{
2592	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2593
2594	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
2595	aKeyStore = mData->mstrLogKeyStore;
2596	#else
2597	aKeyStore = com::Utf8Str::Empty;
2598	#endif
2599
2600	return S_OK;
2601	}
2602
2603	HRESULT Machine::getGuestDebugControl(ComPtr<IGuestDebugControl> &aGuestDebugControl)
2604	{
2605	mGuestDebugControl.queryInterfaceTo(aGuestDebugControl.asOutParam());
2606
2607	return S_OK;
2608	}
2609
2610
2611	/**
2612	* @note Locks objects!
2613	*/
2614	HRESULT Machine::lockMachine(const ComPtr<ISession> &aSession,
2615	LockType_T aLockType)
2616	{
2617	/* check the session state */
2618	SessionState_T state;
2619	HRESULT hrc = aSession->COMGETTER(State)(&state);
2620	if (FAILED(hrc)) return hrc;
2621
2622	if (state != SessionState_Unlocked)
2623	return setError(VBOX_E_INVALID_OBJECT_STATE,
2624	tr("The given session is busy"));
2625
2626	// get the client's IInternalSessionControl interface
2627	ComPtr<IInternalSessionControl> pSessionControl = aSession;
2628	ComAssertMsgRet(!!pSessionControl, (tr("No IInternalSessionControl interface")),
2629	E_INVALIDARG);
2630
2631	// session name (only used in some code paths)
2632	Utf8Str strSessionName;
2633
2634	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2635
2636	if (!mData->mRegistered)
2637	return setError(E_UNEXPECTED,
2638	tr("The machine '%s' is not registered"),
2639	mUserData->s.strName.c_str());
2640
2641	LogFlowThisFunc(("mSession.mState=%s\n", ::stringifySessionState(mData->mSession.mState)));
2642
2643	SessionState_T oldState = mData->mSession.mState;
2644	/* Hack: in case the session is closing and there is a progress object
2645	* which allows waiting for the session to be closed, take the opportunity
2646	* and do a limited wait (max. 1 second). This helps a lot when the system
2647	* is busy and thus session closing can take a little while. */
2648	if ( mData->mSession.mState == SessionState_Unlocking
2649	&& mData->mSession.mProgress)
2650	{
2651	alock.release();
2652	mData->mSession.mProgress->WaitForCompletion(1000);
2653	alock.acquire();
2654	LogFlowThisFunc(("after waiting: mSession.mState=%s\n", ::stringifySessionState(mData->mSession.mState)));
2655	}
2656
2657	// try again now
2658	if ( (mData->mSession.mState == SessionState_Locked) // machine is write-locked already
2659	// (i.e. session machine exists)
2660	&& (aLockType == LockType_Shared) // caller wants a shared link to the
2661	// existing session that holds the write lock:
2662	)
2663	{
2664	// OK, share the session... we are now dealing with three processes:
2665	// 1) VBoxSVC (where this code runs);
2666	// 2) process C: the caller's client process (who wants a shared session);
2667	// 3) process W: the process which already holds the write lock on the machine (write-locking session)
2668
2669	// copy pointers to W (the write-locking session) before leaving lock (these must not be NULL)
2670	ComPtr<IInternalSessionControl> pSessionW = mData->mSession.mDirectControl;
2671	ComAssertRet(!pSessionW.isNull(), E_FAIL);
2672	ComObjPtr<SessionMachine> pSessionMachine = mData->mSession.mMachine;
2673	AssertReturn(!pSessionMachine.isNull(), E_FAIL);
2674
2675	/*
2676	* Release the lock before calling the client process. It's safe here
2677	* since the only thing to do after we get the lock again is to add
2678	* the remote control to the list (which doesn't directly influence
2679	* anything).
2680	*/
2681	alock.release();
2682
2683	// get the console of the session holding the write lock (this is a remote call)
2684	ComPtr<IConsole> pConsoleW;
2685	if (mData->mSession.mLockType == LockType_VM)
2686	{
2687	LogFlowThisFunc(("Calling GetRemoteConsole()...\n"));
2688	hrc = pSessionW->COMGETTER(RemoteConsole)(pConsoleW.asOutParam());
2689	LogFlowThisFunc(("GetRemoteConsole() returned %08X\n", hrc));
2690	if (FAILED(hrc))
2691	// the failure may occur w/o any error info (from RPC), so provide one
2692	return setError(VBOX_E_VM_ERROR, tr("Failed to get a console object from the direct session (%Rhrc)"), hrc);
2693	ComAssertRet(!pConsoleW.isNull(), E_FAIL);
2694	}
2695
2696	// share the session machine and W's console with the caller's session
2697	LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
2698	hrc = pSessionControl->AssignRemoteMachine(pSessionMachine, pConsoleW);
2699	LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", hrc));
2700
2701	if (FAILED(hrc))
2702	// the failure may occur w/o any error info (from RPC), so provide one
2703	return setError(VBOX_E_VM_ERROR, tr("Failed to assign the machine to the session (%Rhrc)"), hrc);
2704	alock.acquire();
2705
2706	// need to revalidate the state after acquiring the lock again
2707	if (mData->mSession.mState != SessionState_Locked)
2708	{
2709	pSessionControl->Uninitialize();
2710	return setError(VBOX_E_INVALID_SESSION_STATE,
2711	tr("The machine '%s' was unlocked unexpectedly while attempting to share its session"),
2712	mUserData->s.strName.c_str());
2713	}
2714
2715	// add the caller's session to the list
2716	mData->mSession.mRemoteControls.push_back(pSessionControl);
2717	}
2718	else if ( mData->mSession.mState == SessionState_Locked
2719	\|\| mData->mSession.mState == SessionState_Unlocking
2720	)
2721	{
2722	// sharing not permitted, or machine still unlocking:
2723	return setError(VBOX_E_INVALID_OBJECT_STATE,
2724	tr("The machine '%s' is already locked for a session (or being unlocked)"),
2725	mUserData->s.strName.c_str());
2726	}
2727	else
2728	{
2729	// machine is not locked: then write-lock the machine (create the session machine)
2730
2731	// must not be busy
2732	AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
2733
2734	// get the caller's session PID
2735	RTPROCESS pid = NIL_RTPROCESS;
2736	AssertCompile(sizeof(ULONG) == sizeof(RTPROCESS));
2737	pSessionControl->COMGETTER(PID)((ULONG*)&pid);
2738	Assert(pid != NIL_RTPROCESS);
2739
2740	bool fLaunchingVMProcess = (mData->mSession.mState == SessionState_Spawning);
2741
2742	if (fLaunchingVMProcess)
2743	{
2744	if (mData->mSession.mPID == NIL_RTPROCESS)
2745	{
2746	// two or more clients racing for a lock, the one which set the
2747	// session state to Spawning will win, the others will get an
2748	// error as we can't decide here if waiting a little would help
2749	// (only for shared locks this would avoid an error)
2750	return setError(VBOX_E_INVALID_OBJECT_STATE,
2751	tr("The machine '%s' already has a lock request pending"),
2752	mUserData->s.strName.c_str());
2753	}
2754
2755	// this machine is awaiting for a spawning session to be opened:
2756	// then the calling process must be the one that got started by
2757	// LaunchVMProcess()
2758
2759	LogFlowThisFunc(("mSession.mPID=%d(0x%x)\n", mData->mSession.mPID, mData->mSession.mPID));
2760	LogFlowThisFunc(("session.pid=%d(0x%x)\n", pid, pid));
2761
2762	#if defined(VBOX_WITH_HARDENING) && defined(RT_OS_WINDOWS)
2763	/* Hardened windows builds spawns three processes when a VM is
2764	launched, the 3rd one is the one that will end up here. */
2765	RTPROCESS pidParent;
2766	int vrc = RTProcQueryParent(pid, &pidParent);
2767	if (RT_SUCCESS(vrc))
2768	vrc = RTProcQueryParent(pidParent, &pidParent);
2769	if ( (RT_SUCCESS(vrc) && mData->mSession.mPID == pidParent)
2770	\|\| vrc == VERR_ACCESS_DENIED)
2771	{
2772	LogFlowThisFunc(("mSession.mPID => %d(%#x) - windows hardening stub\n", mData->mSession.mPID, pid));
2773	mData->mSession.mPID = pid;
2774	}
2775	#endif
2776
2777	if (mData->mSession.mPID != pid)
2778	return setError(E_ACCESSDENIED,
2779	tr("An unexpected process (PID=0x%08X) has tried to lock the "
2780	"machine '%s', while only the process started by LaunchVMProcess (PID=0x%08X) is allowed"),
2781	pid, mUserData->s.strName.c_str(), mData->mSession.mPID);
2782	}
2783
2784	// create the mutable SessionMachine from the current machine
2785	ComObjPtr<SessionMachine> sessionMachine;
2786	sessionMachine.createObject();
2787	hrc = sessionMachine->init(this);
2788	AssertComRC(hrc);
2789
2790	/* NOTE: doing return from this function after this point but
2791	* before the end is forbidden since it may call SessionMachine::uninit()
2792	* (through the ComObjPtr's destructor) which requests the VirtualBox write
2793	* lock while still holding the Machine lock in alock so that a deadlock
2794	* is possible due to the wrong lock order. */
2795
2796	if (SUCCEEDED(hrc))
2797	{
2798	/*
2799	* Set the session state to Spawning to protect against subsequent
2800	* attempts to open a session and to unregister the machine after
2801	* we release the lock.
2802	*/
2803	SessionState_T origState = mData->mSession.mState;
2804	mData->mSession.mState = SessionState_Spawning;
2805
2806	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
2807	/* Get the client token ID to be passed to the client process */
2808	Utf8Str strTokenId;
2809	sessionMachine->i_getTokenId(strTokenId);
2810	Assert(!strTokenId.isEmpty());
2811	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
2812	/* Get the client token to be passed to the client process */
2813	ComPtr<IToken> pToken(sessionMachine->i_getToken());
2814	/* The token is now "owned" by pToken, fix refcount */
2815	if (!pToken.isNull())
2816	pToken->Release();
2817	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
2818
2819	/*
2820	* Release the lock before calling the client process -- it will call
2821	* Machine/SessionMachine methods. Releasing the lock here is quite safe
2822	* because the state is Spawning, so that LaunchVMProcess() and
2823	* LockMachine() calls will fail. This method, called before we
2824	* acquire the lock again, will fail because of the wrong PID.
2825	*
2826	* Note that mData->mSession.mRemoteControls accessed outside
2827	* the lock may not be modified when state is Spawning, so it's safe.
2828	*/
2829	alock.release();
2830
2831	LogFlowThisFunc(("Calling AssignMachine()...\n"));
2832	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
2833	hrc = pSessionControl->AssignMachine(sessionMachine, aLockType, Bstr(strTokenId).raw());
2834	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
2835	hrc = pSessionControl->AssignMachine(sessionMachine, aLockType, pToken);
2836	/* Now the token is owned by the client process. */
2837	pToken.setNull();
2838	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
2839	LogFlowThisFunc(("AssignMachine() returned %08X\n", hrc));
2840
2841	/* The failure may occur w/o any error info (from RPC), so provide one */
2842	if (FAILED(hrc))
2843	setError(VBOX_E_VM_ERROR, tr("Failed to assign the machine to the session (%Rhrc)"), hrc);
2844
2845	// get session name, either to remember or to compare against
2846	// the already known session name.
2847	{
2848	Bstr bstrSessionName;
2849	HRESULT hrc2 = aSession->COMGETTER(Name)(bstrSessionName.asOutParam());
2850	if (SUCCEEDED(hrc2))
2851	strSessionName = bstrSessionName;
2852	}
2853
2854	if ( SUCCEEDED(hrc)
2855	&& fLaunchingVMProcess
2856	)
2857	{
2858	/* complete the remote session initialization */
2859
2860	/* get the console from the direct session */
2861	ComPtr<IConsole> console;
2862	hrc = pSessionControl->COMGETTER(RemoteConsole)(console.asOutParam());
2863	ComAssertComRC(hrc);
2864
2865	if (SUCCEEDED(hrc) && !console)
2866	{
2867	ComAssert(!!console);
2868	hrc = E_FAIL;
2869	}
2870
2871	/* assign machine & console to the remote session */
2872	if (SUCCEEDED(hrc))
2873	{
2874	/*
2875	* after LaunchVMProcess(), the first and the only
2876	* entry in remoteControls is that remote session
2877	*/
2878	LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
2879	hrc = mData->mSession.mRemoteControls.front()->AssignRemoteMachine(sessionMachine, console);
2880	LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", hrc));
2881
2882	/* The failure may occur w/o any error info (from RPC), so provide one */
2883	if (FAILED(hrc))
2884	setError(VBOX_E_VM_ERROR,
2885	tr("Failed to assign the machine to the remote session (%Rhrc)"), hrc);
2886	}
2887
2888	if (FAILED(hrc))
2889	pSessionControl->Uninitialize();
2890	}
2891
2892	/* acquire the lock again */
2893	alock.acquire();
2894
2895	/* Restore the session state */
2896	mData->mSession.mState = origState;
2897	}
2898
2899	// finalize spawning anyway (this is why we don't return on errors above)
2900	if (fLaunchingVMProcess)
2901	{
2902	Assert(mData->mSession.mName == strSessionName \|\| FAILED(hrc));
2903	/* Note that the progress object is finalized later */
2904	/** @todo Consider checking mData->mSession.mProgress for cancellation
2905	* around here. */
2906
2907	/* We don't reset mSession.mPID here because it is necessary for
2908	* SessionMachine::uninit() to reap the child process later. */
2909
2910	if (FAILED(hrc))
2911	{
2912	/* Close the remote session, remove the remote control from the list
2913	* and reset session state to Closed (@note keep the code in sync
2914	* with the relevant part in checkForSpawnFailure()). */
2915
2916	Assert(mData->mSession.mRemoteControls.size() == 1);
2917	if (mData->mSession.mRemoteControls.size() == 1)
2918	{
2919	ErrorInfoKeeper eik;
2920	mData->mSession.mRemoteControls.front()->Uninitialize();
2921	}
2922
2923	mData->mSession.mRemoteControls.clear();
2924	mData->mSession.mState = SessionState_Unlocked;
2925	}
2926	}
2927	else
2928	{
2929	/* memorize PID of the directly opened session */
2930	if (SUCCEEDED(hrc))
2931	mData->mSession.mPID = pid;
2932	}
2933
2934	if (SUCCEEDED(hrc))
2935	{
2936	mData->mSession.mLockType = aLockType;
2937	/* memorize the direct session control and cache IUnknown for it */
2938	mData->mSession.mDirectControl = pSessionControl;
2939	mData->mSession.mState = SessionState_Locked;
2940	if (!fLaunchingVMProcess)
2941	mData->mSession.mName = strSessionName;
2942	/* associate the SessionMachine with this Machine */
2943	mData->mSession.mMachine = sessionMachine;
2944
2945	/* request an IUnknown pointer early from the remote party for later
2946	* identity checks (it will be internally cached within mDirectControl
2947	* at least on XPCOM) */
2948	ComPtr<IUnknown> unk = mData->mSession.mDirectControl;
2949	NOREF(unk);
2950
2951	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
2952	if (aLockType == LockType_VM)
2953	{
2954	/* get the console from the direct session */
2955	ComPtr<IConsole> console;
2956	hrc = pSessionControl->COMGETTER(RemoteConsole)(console.asOutParam());
2957	ComAssertComRC(hrc);
2958	/* send passswords to console */
2959	for (SecretKeyStore::SecretKeyMap::iterator it = mData->mpKeyStore->begin();
2960	it != mData->mpKeyStore->end();
2961	++it)
2962	{
2963	SecretKey *pKey = it->second;
2964	pKey->retain();
2965	console->AddEncryptionPassword(Bstr(it->first).raw(),
2966	Bstr((const char*)pKey->getKeyBuffer()).raw(),
2967	TRUE);
2968	pKey->release();
2969	}
2970
2971	}
2972	#endif
2973	}
2974
2975	/* Release the lock since SessionMachine::uninit() locks VirtualBox which
2976	* would break the lock order */
2977	alock.release();
2978
2979	/* uninitialize the created session machine on failure */
2980	if (FAILED(hrc))
2981	sessionMachine->uninit();
2982	}
2983
2984	if (SUCCEEDED(hrc))
2985	{
2986	/*
2987	* tell the client watcher thread to update the set of
2988	* machines that have open sessions
2989	*/
2990	mParent->i_updateClientWatcher();
2991
2992	if (oldState != SessionState_Locked)
2993	/* fire an event */
2994	mParent->i_onSessionStateChanged(i_getId(), SessionState_Locked);
2995	}
2996
2997	return hrc;
2998	}
2999
3000	/**
3001	* @note Locks objects!
3002	*/
3003	HRESULT Machine::launchVMProcess(const ComPtr<ISession> &aSession,
3004	const com::Utf8Str &aName,
3005	const std::vector<com::Utf8Str> &aEnvironmentChanges,
3006	ComPtr<IProgress> &aProgress)
3007	{
3008	Utf8Str strFrontend(aName);
3009	/* "emergencystop" doesn't need the session, so skip the checks/interface
3010	* retrieval. This code doesn't quite fit in here, but introducing a
3011	* special API method would be even more effort, and would require explicit
3012	* support by every API client. It's better to hide the feature a bit. */
3013	if (strFrontend != "emergencystop")
3014	CheckComArgNotNull(aSession);
3015
3016	HRESULT hrc = S_OK;
3017	if (strFrontend.isEmpty())
3018	{
3019	Bstr bstrFrontend;
3020	hrc = COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
3021	if (FAILED(hrc))
3022	return hrc;
3023	strFrontend = bstrFrontend;
3024	if (strFrontend.isEmpty())
3025	{
3026	ComPtr<ISystemProperties> systemProperties;
3027	hrc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
3028	if (FAILED(hrc))
3029	return hrc;
3030	hrc = systemProperties->COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
3031	if (FAILED(hrc))
3032	return hrc;
3033	strFrontend = bstrFrontend;
3034	}
3035	/* paranoia - emergencystop is not a valid default */
3036	if (strFrontend == "emergencystop")
3037	strFrontend = Utf8Str::Empty;
3038	}
3039	/* default frontend: Qt GUI */
3040	if (strFrontend.isEmpty())
3041	strFrontend = "GUI/Qt";
3042
3043	if (strFrontend != "emergencystop")
3044	{
3045	/* check the session state */
3046	SessionState_T state;
3047	hrc = aSession->COMGETTER(State)(&state);
3048	if (FAILED(hrc))
3049	return hrc;
3050
3051	if (state != SessionState_Unlocked)
3052	return setError(VBOX_E_INVALID_OBJECT_STATE,
3053	tr("The given session is busy"));
3054
3055	/* get the IInternalSessionControl interface */
3056	ComPtr<IInternalSessionControl> control(aSession);
3057	ComAssertMsgRet(!control.isNull(),
3058	("No IInternalSessionControl interface"),
3059	E_INVALIDARG);
3060
3061	/* get the teleporter enable state for the progress object init. */
3062	BOOL fTeleporterEnabled;
3063	hrc = COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
3064	if (FAILED(hrc))
3065	return hrc;
3066
3067	/* create a progress object */
3068	ComObjPtr<ProgressProxy> progress;
3069	progress.createObject();
3070	hrc = progress->init(mParent,
3071	static_cast<IMachine*>(this),
3072	Bstr(tr("Starting VM")).raw(),
3073	TRUE /* aCancelable */,
3074	fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
3075	BstrFmt(tr("Creating process for virtual machine \"%s\" (%s)"),
3076	mUserData->s.strName.c_str(), strFrontend.c_str()).raw(),
3077	2 /* uFirstOperationWeight */,
3078	fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
3079	if (SUCCEEDED(hrc))
3080	{
3081	hrc = i_launchVMProcess(control, strFrontend, aEnvironmentChanges, progress);
3082	if (SUCCEEDED(hrc))
3083	{
3084	aProgress = progress;
3085
3086	/* signal the client watcher thread */
3087	mParent->i_updateClientWatcher();
3088
3089	/* fire an event */
3090	mParent->i_onSessionStateChanged(i_getId(), SessionState_Spawning);
3091	}
3092	}
3093	}
3094	else
3095	{
3096	/* no progress object - either instant success or failure */
3097	aProgress = NULL;
3098
3099	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3100
3101	if (mData->mSession.mState != SessionState_Locked)
3102	return setError(VBOX_E_INVALID_OBJECT_STATE,
3103	tr("The machine '%s' is not locked by a session"),
3104	mUserData->s.strName.c_str());
3105
3106	/* must have a VM process associated - do not kill normal API clients
3107	* with an open session */
3108	if (!Global::IsOnline(mData->mMachineState))
3109	return setError(VBOX_E_INVALID_OBJECT_STATE,
3110	tr("The machine '%s' does not have a VM process"),
3111	mUserData->s.strName.c_str());
3112
3113	/* forcibly terminate the VM process */
3114	if (mData->mSession.mPID != NIL_RTPROCESS)
3115	RTProcTerminate(mData->mSession.mPID);
3116
3117	/* signal the client watcher thread, as most likely the client has
3118	* been terminated */
3119	mParent->i_updateClientWatcher();
3120	}
3121
3122	return hrc;
3123	}
3124
3125	HRESULT Machine::setBootOrder(ULONG aPosition, DeviceType_T aDevice)
3126	{
3127	if (aPosition < 1 \|\| aPosition > SchemaDefs::MaxBootPosition)
3128	return setError(E_INVALIDARG,
3129	tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3130	aPosition, SchemaDefs::MaxBootPosition);
3131
3132	if (aDevice == DeviceType_USB)
3133	return setError(E_NOTIMPL,
3134	tr("Booting from USB device is currently not supported"));
3135
3136	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3137
3138	HRESULT hrc = i_checkStateDependency(MutableStateDep);
3139	if (FAILED(hrc)) return hrc;
3140
3141	i_setModified(IsModified_MachineData);
3142	mHWData.backup();
3143	mHWData->mBootOrder[aPosition - 1] = aDevice;
3144
3145	return S_OK;
3146	}
3147
3148	HRESULT Machine::getBootOrder(ULONG aPosition, DeviceType_T *aDevice)
3149	{
3150	if (aPosition < 1 \|\| aPosition > SchemaDefs::MaxBootPosition)
3151	return setError(E_INVALIDARG,
3152	tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3153	aPosition, SchemaDefs::MaxBootPosition);
3154
3155	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3156
3157	*aDevice = mHWData->mBootOrder[aPosition - 1];
3158
3159	return S_OK;
3160	}
3161
3162	HRESULT Machine::attachDevice(const com::Utf8Str &aName,
3163	LONG aControllerPort,
3164	LONG aDevice,
3165	DeviceType_T aType,
3166	const ComPtr<IMedium> &aMedium)
3167	{
3168	IMedium *aM = aMedium;
3169	LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d aType=%d aMedium=%p\n",
3170	aName.c_str(), aControllerPort, aDevice, aType, aM));
3171
3172	// request the host lock first, since might be calling Host methods for getting host drives;
3173	// next, protect the media tree all the while we're in here, as well as our member variables
3174	AutoMultiWriteLock2 alock(mParent->i_host(), this COMMA_LOCKVAL_SRC_POS);
3175	AutoWriteLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
3176
3177	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
3178	if (FAILED(hrc)) return hrc;
3179
3180	/// @todo NEWMEDIA implicit machine registration
3181	if (!mData->mRegistered)
3182	return setError(VBOX_E_INVALID_OBJECT_STATE,
3183	tr("Cannot attach storage devices to an unregistered machine"));
3184
3185	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3186
3187	/* Check for an existing controller. */
3188	ComObjPtr<StorageController> ctl;
3189	hrc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
3190	if (FAILED(hrc)) return hrc;
3191
3192	StorageControllerType_T ctrlType;
3193	hrc = ctl->COMGETTER(ControllerType)(&ctrlType);
3194	if (FAILED(hrc))
3195	return setError(E_FAIL, tr("Could not get type of controller '%s'"), aName.c_str());
3196
3197	bool fSilent = false;
3198
3199	/* Check whether the flag to allow silent storage attachment reconfiguration is set. */
3200	Utf8Str const strReconfig = i_getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
3201	if ( mData->mMachineState == MachineState_Paused
3202	&& strReconfig == "1")
3203	fSilent = true;
3204
3205	/* Check that the controller can do hot-plugging if we attach the device while the VM is running. */
3206	bool fHotplug = false;
3207	if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
3208	fHotplug = true;
3209
3210	if (fHotplug && !i_isControllerHotplugCapable(ctrlType))
3211	return setError(VBOX_E_INVALID_VM_STATE,
3212	tr("Controller '%s' does not support hot-plugging"),
3213	aName.c_str());
3214
3215	// check that the port and device are not out of range
3216	hrc = ctl->i_checkPortAndDeviceValid(aControllerPort, aDevice);
3217	if (FAILED(hrc)) return hrc;
3218
3219	/* check if the device slot is already busy */
3220	MediumAttachment pAttachTemp = i_findAttachment(mMediumAttachments.data(),
3221	aName,
3222	aControllerPort,
3223	aDevice);
3224	if (pAttachTemp)
3225	{
3226	Medium *pMedium = pAttachTemp->i_getMedium();
3227	if (pMedium)
3228	{
3229	AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
3230	return setError(VBOX_E_OBJECT_IN_USE,
3231	tr("Medium '%s' is already attached to port %d, device %d of controller '%s' of this virtual machine"),
3232	pMedium->i_getLocationFull().c_str(),
3233	aControllerPort,
3234	aDevice,
3235	aName.c_str());
3236	}
3237	else
3238	return setError(VBOX_E_OBJECT_IN_USE,
3239	tr("Device is already attached to port %d, device %d of controller '%s' of this virtual machine"),
3240	aControllerPort, aDevice, aName.c_str());
3241	}
3242
3243	ComObjPtr<Medium> medium = static_cast<Medium*>(aM);
3244	if (aMedium && medium.isNull())
3245	return setError(E_INVALIDARG, tr("The given medium pointer is invalid"));
3246
3247	AutoCaller mediumCaller(medium);
3248	if (FAILED(mediumCaller.hrc())) return mediumCaller.hrc();
3249
3250	AutoWriteLock mediumLock(medium COMMA_LOCKVAL_SRC_POS);
3251
3252	pAttachTemp = i_findAttachment(*mMediumAttachments.data(), medium);
3253	if ( pAttachTemp
3254	&& !medium.isNull()
3255	&& ( medium->i_getType() != MediumType_Readonly
3256	\|\| medium->i_getDeviceType() != DeviceType_DVD)
3257	)
3258	return setError(VBOX_E_OBJECT_IN_USE,
3259	tr("Medium '%s' is already attached to this virtual machine"),
3260	medium->i_getLocationFull().c_str());
3261
3262	if (!medium.isNull())
3263	{
3264	MediumType_T mtype = medium->i_getType();
3265	// MediumType_Readonly is also new, but only applies to DVDs and floppies.
3266	// For DVDs it's not written to the config file, so needs no global config
3267	// version bump. For floppies it's a new attribute "type", which is ignored
3268	// by older VirtualBox version, so needs no global config version bump either.
3269	// For hard disks this type is not accepted.
3270	if (mtype == MediumType_MultiAttach)
3271	{
3272	// This type is new with VirtualBox 4.0 and therefore requires settings
3273	// version 1.11 in the settings backend. Unfortunately it is not enough to do
3274	// the usual routine in MachineConfigFile::bumpSettingsVersionIfNeeded() for
3275	// two reasons: The medium type is a property of the media registry tree, which
3276	// can reside in the global config file (for pre-4.0 media); we would therefore
3277	// possibly need to bump the global config version. We don't want to do that though
3278	// because that might make downgrading to pre-4.0 impossible.
3279	// As a result, we can only use these two new types if the medium is NOT in the
3280	// global registry:
3281	const Guid &uuidGlobalRegistry = mParent->i_getGlobalRegistryId();
3282	if ( medium->i_isInRegistry(uuidGlobalRegistry)
3283	\|\| !mData->pMachineConfigFile->canHaveOwnMediaRegistry()
3284	)
3285	return setError(VBOX_E_INVALID_OBJECT_STATE,
3286	tr("Cannot attach medium '%s': the media type 'MultiAttach' can only be attached "
3287	"to machines that were created with VirtualBox 4.0 or later"),
3288	medium->i_getLocationFull().c_str());
3289	}
3290	}
3291
3292	bool fIndirect = false;
3293	if (!medium.isNull())
3294	fIndirect = medium->i_isReadOnly();
3295	bool associate = true;
3296
3297	do
3298	{
3299	if ( aType == DeviceType_HardDisk
3300	&& mMediumAttachments.isBackedUp())
3301	{
3302	const MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
3303
3304	/* check if the medium was attached to the VM before we started
3305	* changing attachments in which case the attachment just needs to
3306	* be restored */
3307	pAttachTemp = i_findAttachment(oldAtts, medium);
3308	if (pAttachTemp)
3309	{
3310	AssertReturn(!fIndirect, E_FAIL);
3311
3312	/* see if it's the same bus/channel/device */
3313	if (pAttachTemp->i_matches(aName, aControllerPort, aDevice))
3314	{
3315	/* the simplest case: restore the whole attachment
3316	* and return, nothing else to do */
3317	mMediumAttachments->push_back(pAttachTemp);
3318
3319	/* Reattach the medium to the VM. */
3320	if (fHotplug \|\| fSilent)
3321	{
3322	mediumLock.release();
3323	treeLock.release();
3324	alock.release();
3325
3326	MediumLockList *pMediumLockList(new MediumLockList());
3327
3328	hrc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
3329	medium /* pToLockWrite */,
3330	false /* fMediumLockWriteAll */,
3331	NULL,
3332	*pMediumLockList);
3333	alock.acquire();
3334	if (FAILED(hrc))
3335	delete pMediumLockList;
3336	else
3337	{
3338	Assert(mData->mSession.mLockedMedia.IsLocked());
3339	mData->mSession.mLockedMedia.Unlock();
3340	alock.release();
3341	hrc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
3342	mData->mSession.mLockedMedia.Lock();
3343	alock.acquire();
3344	}
3345	alock.release();
3346
3347	if (SUCCEEDED(hrc))
3348	{
3349	hrc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
3350	/* Remove lock list in case of error. */
3351	if (FAILED(hrc))
3352	{
3353	mData->mSession.mLockedMedia.Unlock();
3354	mData->mSession.mLockedMedia.Remove(pAttachTemp);
3355	mData->mSession.mLockedMedia.Lock();
3356	}
3357	}
3358	}
3359
3360	return S_OK;
3361	}
3362
3363	/* bus/channel/device differ; we need a new attachment object,
3364	* but don't try to associate it again */
3365	associate = false;
3366	break;
3367	}
3368	}
3369
3370	/* go further only if the attachment is to be indirect */
3371	if (!fIndirect)
3372	break;
3373
3374	/* perform the so called smart attachment logic for indirect
3375	* attachments. Note that smart attachment is only applicable to base
3376	* hard disks. */
3377
3378	if (medium->i_getParent().isNull())
3379	{
3380	/* first, investigate the backup copy of the current hard disk
3381	* attachments to make it possible to re-attach existing diffs to
3382	* another device slot w/o losing their contents */
3383	if (mMediumAttachments.isBackedUp())
3384	{
3385	const MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
3386
3387	MediumAttachmentList::const_iterator foundIt = oldAtts.end();
3388	uint32_t foundLevel = 0;
3389
3390	for (MediumAttachmentList::const_iterator
3391	it = oldAtts.begin();
3392	it != oldAtts.end();
3393	++it)
3394	{
3395	uint32_t level = 0;
3396	MediumAttachment pAttach = it;
3397	ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
3398	Assert(!pMedium.isNull() \|\| pAttach->i_getType() != DeviceType_HardDisk);
3399	if (pMedium.isNull())
3400	continue;
3401
3402	if (pMedium->i_getBase(&level) == medium)
3403	{
3404	/* skip the hard disk if its currently attached (we
3405	* cannot attach the same hard disk twice) */
3406	if (i_findAttachment(*mMediumAttachments.data(),
3407	pMedium))
3408	continue;
3409
3410	/* matched device, channel and bus (i.e. attached to the
3411	* same place) will win and immediately stop the search;
3412	* otherwise the attachment that has the youngest
3413	* descendant of medium will be used
3414	*/
3415	if (pAttach->i_matches(aName, aControllerPort, aDevice))
3416	{
3417	/* the simplest case: restore the whole attachment
3418	* and return, nothing else to do */
3419	mMediumAttachments->push_back(*it);
3420
3421	/* Reattach the medium to the VM. */
3422	if (fHotplug \|\| fSilent)
3423	{
3424	mediumLock.release();
3425	treeLock.release();
3426	alock.release();
3427
3428	MediumLockList *pMediumLockList(new MediumLockList());
3429
3430	hrc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
3431	medium /* pToLockWrite */,
3432	false /* fMediumLockWriteAll */,
3433	NULL,
3434	*pMediumLockList);
3435	alock.acquire();
3436	if (FAILED(hrc))
3437	delete pMediumLockList;
3438	else
3439	{
3440	Assert(mData->mSession.mLockedMedia.IsLocked());
3441	mData->mSession.mLockedMedia.Unlock();
3442	alock.release();
3443	hrc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
3444	mData->mSession.mLockedMedia.Lock();
3445	alock.acquire();
3446	}
3447	alock.release();
3448
3449	if (SUCCEEDED(hrc))
3450	{
3451	hrc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
3452	/* Remove lock list in case of error. */
3453	if (FAILED(hrc))
3454	{
3455	mData->mSession.mLockedMedia.Unlock();
3456	mData->mSession.mLockedMedia.Remove(pAttachTemp);
3457	mData->mSession.mLockedMedia.Lock();
3458	}
3459	}
3460	}
3461
3462	return S_OK;
3463	}
3464	else if ( foundIt == oldAtts.end()
3465	\|\| level > foundLevel /* prefer younger */
3466	)
3467	{
3468	foundIt = it;
3469	foundLevel = level;
3470	}
3471	}
3472	}
3473
3474	if (foundIt != oldAtts.end())
3475	{
3476	/* use the previously attached hard disk */
3477	medium = (*foundIt)->i_getMedium();
3478	mediumCaller.attach(medium);
3479	if (FAILED(mediumCaller.hrc())) return mediumCaller.hrc();
3480	mediumLock.attach(medium);
3481	/* not implicit, doesn't require association with this VM */
3482	fIndirect = false;
3483	associate = false;
3484	/* go right to the MediumAttachment creation */
3485	break;
3486	}
3487	}
3488
3489	/* must give up the medium lock and medium tree lock as below we
3490	* go over snapshots, which needs a lock with higher lock order. */
3491	mediumLock.release();
3492	treeLock.release();
3493
3494	/* then, search through snapshots for the best diff in the given
3495	* hard disk's chain to base the new diff on */
3496
3497	ComObjPtr<Medium> base;
3498	ComObjPtr<Snapshot> snap = mData->mCurrentSnapshot;
3499	while (snap)
3500	{
3501	AutoReadLock snapLock(snap COMMA_LOCKVAL_SRC_POS);
3502
3503	const MediumAttachmentList &snapAtts = *snap->i_getSnapshotMachine()->mMediumAttachments.data();
3504
3505	MediumAttachment *pAttachFound = NULL;
3506	uint32_t foundLevel = 0;
3507
3508	for (MediumAttachmentList::const_iterator
3509	it = snapAtts.begin();
3510	it != snapAtts.end();
3511	++it)
3512	{
3513	MediumAttachment pAttach = it;
3514	ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
3515	Assert(!pMedium.isNull() \|\| pAttach->i_getType() != DeviceType_HardDisk);
3516	if (pMedium.isNull())
3517	continue;
3518
3519	uint32_t level = 0;
3520	if (pMedium->i_getBase(&level) == medium)
3521	{
3522	/* matched device, channel and bus (i.e. attached to the
3523	* same place) will win and immediately stop the search;
3524	* otherwise the attachment that has the youngest
3525	* descendant of medium will be used
3526	*/
3527	if ( pAttach->i_getDevice() == aDevice
3528	&& pAttach->i_getPort() == aControllerPort
3529	&& pAttach->i_getControllerName() == aName
3530	)
3531	{
3532	pAttachFound = pAttach;
3533	break;
3534	}
3535	else if ( !pAttachFound
3536	\|\| level > foundLevel /* prefer younger */
3537	)
3538	{
3539	pAttachFound = pAttach;
3540	foundLevel = level;
3541	}
3542	}
3543	}
3544
3545	if (pAttachFound)
3546	{
3547	base = pAttachFound->i_getMedium();
3548	break;
3549	}
3550
3551	snap = snap->i_getParent();
3552	}
3553
3554	/* re-lock medium tree and the medium, as we need it below */
3555	treeLock.acquire();
3556	mediumLock.acquire();
3557
3558	/* found a suitable diff, use it as a base */
3559	if (!base.isNull())
3560	{
3561	medium = base;
3562	mediumCaller.attach(medium);
3563	if (FAILED(mediumCaller.hrc())) return mediumCaller.hrc();
3564	mediumLock.attach(medium);
3565	}
3566	}
3567
3568	Utf8Str strFullSnapshotFolder;
3569	i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
3570
3571	ComObjPtr<Medium> diff;
3572	diff.createObject();
3573	// store this diff in the same registry as the parent
3574	Guid uuidRegistryParent;
3575	if (!medium->i_getFirstRegistryMachineId(uuidRegistryParent))
3576	{
3577	// parent image has no registry: this can happen if we're attaching a new immutable
3578	// image that has not yet been attached (medium then points to the base and we're
3579	// creating the diff image for the immutable, and the parent is not yet registered);
3580	// put the parent in the machine registry then
3581	mediumLock.release();
3582	treeLock.release();
3583	alock.release();
3584	i_addMediumToRegistry(medium);
3585	alock.acquire();
3586	treeLock.acquire();
3587	mediumLock.acquire();
3588	medium->i_getFirstRegistryMachineId(uuidRegistryParent);
3589	}
3590	hrc = diff->init(mParent,
3591	medium->i_getPreferredDiffFormat(),
3592	strFullSnapshotFolder.append(RTPATH_SLASH_STR),
3593	uuidRegistryParent,
3594	DeviceType_HardDisk);
3595	if (FAILED(hrc)) return hrc;
3596
3597	/* Apply the normal locking logic to the entire chain. */
3598	MediumLockList *pMediumLockList(new MediumLockList());
3599	mediumLock.release();
3600	treeLock.release();
3601	hrc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
3602	diff /* pToLockWrite */,
3603	false /* fMediumLockWriteAll */,
3604	medium,
3605	*pMediumLockList);
3606	treeLock.acquire();
3607	mediumLock.acquire();
3608	if (SUCCEEDED(hrc))
3609	{
3610	mediumLock.release();
3611	treeLock.release();
3612	hrc = pMediumLockList->Lock();
3613	treeLock.acquire();
3614	mediumLock.acquire();
3615	if (FAILED(hrc))
3616	setError(hrc,
3617	tr("Could not lock medium when creating diff '%s'"),
3618	diff->i_getLocationFull().c_str());
3619	else
3620	{
3621	/* will release the lock before the potentially lengthy
3622	* operation, so protect with the special state */
3623	MachineState_T oldState = mData->mMachineState;
3624	i_setMachineState(MachineState_SettingUp);
3625
3626	mediumLock.release();
3627	treeLock.release();
3628	alock.release();
3629
3630	hrc = medium->i_createDiffStorage(diff,
3631	medium->i_getPreferredDiffVariant(),
3632	pMediumLockList,
3633	NULL /* aProgress */,
3634	true /* aWait */,
3635	false /* aNotify */);
3636
3637	alock.acquire();
3638	treeLock.acquire();
3639	mediumLock.acquire();
3640
3641	i_setMachineState(oldState);
3642	}
3643	}
3644
3645	/* Unlock the media and free the associated memory. */
3646	delete pMediumLockList;
3647
3648	if (FAILED(hrc)) return hrc;
3649
3650	/* use the created diff for the actual attachment */
3651	medium = diff;
3652	mediumCaller.attach(medium);
3653	if (FAILED(mediumCaller.hrc())) return mediumCaller.hrc();
3654	mediumLock.attach(medium);
3655	}
3656	while (0);
3657
3658	ComObjPtr<MediumAttachment> attachment;
3659	attachment.createObject();
3660	hrc = attachment->init(this,
3661	medium,
3662	aName,
3663	aControllerPort,
3664	aDevice,
3665	aType,
3666	fIndirect,
3667	false /* fPassthrough */,
3668	false /* fTempEject */,
3669	false /* fNonRotational */,
3670	false /* fDiscard */,
3671	fHotplug \|\| ctrlType == StorageControllerType_USB /* fHotPluggable */,
3672	Utf8Str::Empty);
3673	if (FAILED(hrc)) return hrc;
3674
3675	if (associate && !medium.isNull())
3676	{
3677	// as the last step, associate the medium to the VM
3678	hrc = medium->i_addBackReference(mData->mUuid);
3679	// here we can fail because of Deleting, or being in process of creating a Diff
3680	if (FAILED(hrc)) return hrc;
3681
3682	mediumLock.release();
3683	treeLock.release();
3684	alock.release();
3685	i_addMediumToRegistry(medium);
3686	alock.acquire();
3687	treeLock.acquire();
3688	mediumLock.acquire();
3689	}
3690
3691	/* success: finally remember the attachment */
3692	i_setModified(IsModified_Storage);
3693	mMediumAttachments.backup();
3694	mMediumAttachments->push_back(attachment);
3695
3696	mediumLock.release();
3697	treeLock.release();
3698	alock.release();
3699
3700	if (fHotplug \|\| fSilent)
3701	{
3702	if (!medium.isNull())
3703	{
3704	MediumLockList *pMediumLockList(new MediumLockList());
3705
3706	hrc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
3707	medium /* pToLockWrite */,
3708	false /* fMediumLockWriteAll */,
3709	NULL,
3710	*pMediumLockList);
3711	alock.acquire();
3712	if (FAILED(hrc))
3713	delete pMediumLockList;
3714	else
3715	{
3716	Assert(mData->mSession.mLockedMedia.IsLocked());
3717	mData->mSession.mLockedMedia.Unlock();
3718	alock.release();
3719	hrc = mData->mSession.mLockedMedia.Insert(attachment, pMediumLockList);
3720	mData->mSession.mLockedMedia.Lock();
3721	alock.acquire();
3722	}
3723	alock.release();
3724	}
3725
3726	if (SUCCEEDED(hrc))
3727	{
3728	hrc = i_onStorageDeviceChange(attachment, FALSE /* aRemove */, fSilent);
3729	/* Remove lock list in case of error. */
3730	if (FAILED(hrc))
3731	{
3732	mData->mSession.mLockedMedia.Unlock();
3733	mData->mSession.mLockedMedia.Remove(attachment);
3734	mData->mSession.mLockedMedia.Lock();
3735	}
3736	}
3737	}
3738
3739	/* Save modified registries, but skip this machine as it's the caller's
3740	* job to save its settings like all other settings changes. */
3741	mParent->i_unmarkRegistryModified(i_getId());
3742	mParent->i_saveModifiedRegistries();
3743
3744	if (SUCCEEDED(hrc))
3745	{
3746	if (fIndirect && medium != aM)
3747	mParent->i_onMediumConfigChanged(medium);
3748	mParent->i_onStorageDeviceChanged(attachment, FALSE, fSilent);
3749	}
3750
3751	return hrc;
3752	}
3753
3754	HRESULT Machine::detachDevice(const com::Utf8Str &aName, LONG aControllerPort,
3755	LONG aDevice)
3756	{
3757	LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d\n", aName.c_str(), aControllerPort, aDevice));
3758
3759	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3760
3761	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
3762	if (FAILED(hrc)) return hrc;
3763
3764	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3765
3766	/* Check for an existing controller. */
3767	ComObjPtr<StorageController> ctl;
3768	hrc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
3769	if (FAILED(hrc)) return hrc;
3770
3771	StorageControllerType_T ctrlType;
3772	hrc = ctl->COMGETTER(ControllerType)(&ctrlType);
3773	if (FAILED(hrc))
3774	return setError(E_FAIL, tr("Could not get type of controller '%s'"), aName.c_str());
3775
3776	bool fSilent = false;
3777	Utf8Str strReconfig;
3778
3779	/* Check whether the flag to allow silent storage attachment reconfiguration is set. */
3780	strReconfig = i_getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
3781	if ( mData->mMachineState == MachineState_Paused
3782	&& strReconfig == "1")
3783	fSilent = true;
3784
3785	/* Check that the controller can do hot-plugging if we detach the device while the VM is running. */
3786	bool fHotplug = false;
3787	if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
3788	fHotplug = true;
3789
3790	if (fHotplug && !i_isControllerHotplugCapable(ctrlType))
3791	return setError(VBOX_E_INVALID_VM_STATE,
3792	tr("Controller '%s' does not support hot-plugging"),
3793	aName.c_str());
3794
3795	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
3796	aName,
3797	aControllerPort,
3798	aDevice);
3799	if (!pAttach)
3800	return setError(VBOX_E_OBJECT_NOT_FOUND,
3801	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
3802	aDevice, aControllerPort, aName.c_str());
3803
3804	if (fHotplug && !pAttach->i_getHotPluggable())
3805	return setError(VBOX_E_NOT_SUPPORTED,
3806	tr("The device slot %d on port %d of controller '%s' does not support hot-plugging"),
3807	aDevice, aControllerPort, aName.c_str());
3808
3809	/*
3810	* The VM has to detach the device before we delete any implicit diffs.
3811	* If this fails we can roll back without loosing data.
3812	*/
3813	if (fHotplug \|\| fSilent)
3814	{
3815	alock.release();
3816	hrc = i_onStorageDeviceChange(pAttach, TRUE /* aRemove */, fSilent);
3817	alock.acquire();
3818	}
3819	if (FAILED(hrc)) return hrc;
3820
3821	/* If we are here everything went well and we can delete the implicit now. */
3822	hrc = i_detachDevice(pAttach, alock, NULL /* pSnapshot */);
3823
3824	alock.release();
3825
3826	/* Save modified registries, but skip this machine as it's the caller's
3827	* job to save its settings like all other settings changes. */
3828	mParent->i_unmarkRegistryModified(i_getId());
3829	mParent->i_saveModifiedRegistries();
3830
3831	if (SUCCEEDED(hrc))
3832	mParent->i_onStorageDeviceChanged(pAttach, TRUE, fSilent);
3833
3834	return hrc;
3835	}
3836
3837	HRESULT Machine::passthroughDevice(const com::Utf8Str &aName, LONG aControllerPort,
3838	LONG aDevice, BOOL aPassthrough)
3839	{
3840	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aPassthrough=%d\n",
3841	aName.c_str(), aControllerPort, aDevice, aPassthrough));
3842
3843	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3844
3845	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
3846	if (FAILED(hrc)) return hrc;
3847
3848	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3849
3850	/* Check for an existing controller. */
3851	ComObjPtr<StorageController> ctl;
3852	hrc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
3853	if (FAILED(hrc)) return hrc;
3854
3855	StorageControllerType_T ctrlType;
3856	hrc = ctl->COMGETTER(ControllerType)(&ctrlType);
3857	if (FAILED(hrc))
3858	return setError(E_FAIL,
3859	tr("Could not get type of controller '%s'"),
3860	aName.c_str());
3861
3862	bool fSilent = false;
3863	Utf8Str strReconfig;
3864
3865	/* Check whether the flag to allow silent storage attachment reconfiguration is set. */
3866	strReconfig = i_getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
3867	if ( mData->mMachineState == MachineState_Paused
3868	&& strReconfig == "1")
3869	fSilent = true;
3870
3871	/* Check that the controller can do hot-plugging if we detach the device while the VM is running. */
3872	bool fHotplug = false;
3873	if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
3874	fHotplug = true;
3875
3876	if (fHotplug && !i_isControllerHotplugCapable(ctrlType))
3877	return setError(VBOX_E_INVALID_VM_STATE,
3878	tr("Controller '%s' does not support hot-plugging which is required to change the passthrough setting while the VM is running"),
3879	aName.c_str());
3880
3881	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
3882	aName,
3883	aControllerPort,
3884	aDevice);
3885	if (!pAttach)
3886	return setError(VBOX_E_OBJECT_NOT_FOUND,
3887	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
3888	aDevice, aControllerPort, aName.c_str());
3889
3890
3891	i_setModified(IsModified_Storage);
3892	mMediumAttachments.backup();
3893
3894	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
3895
3896	if (pAttach->i_getType() != DeviceType_DVD)
3897	return setError(E_INVALIDARG,
3898	tr("Setting passthrough rejected as the device attached to device slot %d on port %d of controller '%s' is not a DVD"),
3899	aDevice, aControllerPort, aName.c_str());
3900
3901	bool fValueChanged = pAttach->i_getPassthrough() != (aPassthrough != 0);
3902
3903	pAttach->i_updatePassthrough(!!aPassthrough);
3904
3905	attLock.release();
3906	alock.release();
3907	hrc = i_onStorageDeviceChange(pAttach, FALSE /* aRemove /, FALSE / aSilent */);
3908	if (SUCCEEDED(hrc) && fValueChanged)
3909	mParent->i_onStorageDeviceChanged(pAttach, FALSE, FALSE);
3910
3911	return hrc;
3912	}
3913
3914	HRESULT Machine::temporaryEjectDevice(const com::Utf8Str &aName, LONG aControllerPort,
3915	LONG aDevice, BOOL aTemporaryEject)
3916	{
3917
3918	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aTemporaryEject=%d\n",
3919	aName.c_str(), aControllerPort, aDevice, aTemporaryEject));
3920
3921	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3922
3923	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
3924	if (FAILED(hrc)) return hrc;
3925
3926	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
3927	aName,
3928	aControllerPort,
3929	aDevice);
3930	if (!pAttach)
3931	return setError(VBOX_E_OBJECT_NOT_FOUND,
3932	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
3933	aDevice, aControllerPort, aName.c_str());
3934
3935
3936	i_setModified(IsModified_Storage);
3937	mMediumAttachments.backup();
3938
3939	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
3940
3941	if (pAttach->i_getType() != DeviceType_DVD)
3942	return setError(E_INVALIDARG,
3943	tr("Setting temporary eject flag rejected as the device attached to device slot %d on port %d of controller '%s' is not a DVD"),
3944	aDevice, aControllerPort, aName.c_str());
3945	pAttach->i_updateTempEject(!!aTemporaryEject);
3946
3947	return S_OK;
3948	}
3949
3950	HRESULT Machine::nonRotationalDevice(const com::Utf8Str &aName, LONG aControllerPort,
3951	LONG aDevice, BOOL aNonRotational)
3952	{
3953
3954	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aNonRotational=%d\n",
3955	aName.c_str(), aControllerPort, aDevice, aNonRotational));
3956
3957	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3958
3959	HRESULT hrc = i_checkStateDependency(MutableStateDep);
3960	if (FAILED(hrc)) return hrc;
3961
3962	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3963
3964	if (Global::IsOnlineOrTransient(mData->mMachineState))
3965	return setError(VBOX_E_INVALID_VM_STATE,
3966	tr("Invalid machine state: %s"),
3967	Global::stringifyMachineState(mData->mMachineState));
3968
3969	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
3970	aName,
3971	aControllerPort,
3972	aDevice);
3973	if (!pAttach)
3974	return setError(VBOX_E_OBJECT_NOT_FOUND,
3975	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
3976	aDevice, aControllerPort, aName.c_str());
3977
3978
3979	i_setModified(IsModified_Storage);
3980	mMediumAttachments.backup();
3981
3982	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
3983
3984	if (pAttach->i_getType() != DeviceType_HardDisk)
3985	return setError(E_INVALIDARG,
3986	tr("Setting the non-rotational medium flag rejected as the device attached to device slot %d on port %d of controller '%s' is not a hard disk"),
3987	aDevice, aControllerPort, aName.c_str());
3988	pAttach->i_updateNonRotational(!!aNonRotational);
3989
3990	return S_OK;
3991	}
3992
3993	HRESULT Machine::setAutoDiscardForDevice(const com::Utf8Str &aName, LONG aControllerPort,
3994	LONG aDevice, BOOL aDiscard)
3995	{
3996
3997	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aDiscard=%d\n",
3998	aName.c_str(), aControllerPort, aDevice, aDiscard));
3999
4000	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4001
4002	HRESULT hrc = i_checkStateDependency(MutableStateDep);
4003	if (FAILED(hrc)) return hrc;
4004
4005	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4006
4007	if (Global::IsOnlineOrTransient(mData->mMachineState))
4008	return setError(VBOX_E_INVALID_VM_STATE,
4009	tr("Invalid machine state: %s"),
4010	Global::stringifyMachineState(mData->mMachineState));
4011
4012	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4013	aName,
4014	aControllerPort,
4015	aDevice);
4016	if (!pAttach)
4017	return setError(VBOX_E_OBJECT_NOT_FOUND,
4018	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4019	aDevice, aControllerPort, aName.c_str());
4020
4021
4022	i_setModified(IsModified_Storage);
4023	mMediumAttachments.backup();
4024
4025	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4026
4027	if (pAttach->i_getType() != DeviceType_HardDisk)
4028	return setError(E_INVALIDARG,
4029	tr("Setting the discard medium flag rejected as the device attached to device slot %d on port %d of controller '%s' is not a hard disk"),
4030	aDevice, aControllerPort, aName.c_str());
4031	pAttach->i_updateDiscard(!!aDiscard);
4032
4033	return S_OK;
4034	}
4035
4036	HRESULT Machine::setHotPluggableForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4037	LONG aDevice, BOOL aHotPluggable)
4038	{
4039	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aHotPluggable=%d\n",
4040	aName.c_str(), aControllerPort, aDevice, aHotPluggable));
4041
4042	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4043
4044	HRESULT hrc = i_checkStateDependency(MutableStateDep);
4045	if (FAILED(hrc)) return hrc;
4046
4047	AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4048
4049	if (Global::IsOnlineOrTransient(mData->mMachineState))
4050	return setError(VBOX_E_INVALID_VM_STATE,
4051	tr("Invalid machine state: %s"),
4052	Global::stringifyMachineState(mData->mMachineState));
4053
4054	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4055	aName,
4056	aControllerPort,
4057	aDevice);
4058	if (!pAttach)
4059	return setError(VBOX_E_OBJECT_NOT_FOUND,
4060	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4061	aDevice, aControllerPort, aName.c_str());
4062
4063	/* Check for an existing controller. */
4064	ComObjPtr<StorageController> ctl;
4065	hrc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
4066	if (FAILED(hrc)) return hrc;
4067
4068	StorageControllerType_T ctrlType;
4069	hrc = ctl->COMGETTER(ControllerType)(&ctrlType);
4070	if (FAILED(hrc))
4071	return setError(E_FAIL,
4072	tr("Could not get type of controller '%s'"),
4073	aName.c_str());
4074
4075	if (!i_isControllerHotplugCapable(ctrlType))
4076	return setError(VBOX_E_NOT_SUPPORTED,
4077	tr("Controller '%s' does not support changing the hot-pluggable device flag"),
4078	aName.c_str());
4079
4080	/* silently ignore attempts to modify the hot-plug status of USB devices */
4081	if (ctrlType == StorageControllerType_USB)
4082	return S_OK;
4083
4084	i_setModified(IsModified_Storage);
4085	mMediumAttachments.backup();
4086
4087	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4088
4089	if (pAttach->i_getType() == DeviceType_Floppy)
4090	return setError(E_INVALIDARG,
4091	tr("Setting the hot-pluggable device flag rejected as the device attached to device slot %d on port %d of controller '%s' is a floppy drive"),
4092	aDevice, aControllerPort, aName.c_str());
4093	pAttach->i_updateHotPluggable(!!aHotPluggable);
4094
4095	return S_OK;
4096	}
4097
4098	HRESULT Machine::setNoBandwidthGroupForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4099	LONG aDevice)
4100	{
4101	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4102	aName.c_str(), aControllerPort, aDevice));
4103
4104	return setBandwidthGroupForDevice(aName, aControllerPort, aDevice, NULL);
4105	}
4106
4107	HRESULT Machine::setBandwidthGroupForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4108	LONG aDevice, const ComPtr<IBandwidthGroup> &aBandwidthGroup)
4109	{
4110	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4111	aName.c_str(), aControllerPort, aDevice));
4112
4113	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4114
4115	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
4116	if (FAILED(hrc)) return hrc;
4117
4118	if (Global::IsOnlineOrTransient(mData->mMachineState))
4119	return setError(VBOX_E_INVALID_VM_STATE,
4120	tr("Invalid machine state: %s"),
4121	Global::stringifyMachineState(mData->mMachineState));
4122
4123	MediumAttachment pAttach = i_findAttachment(mMediumAttachments.data(),
4124	aName,
4125	aControllerPort,
4126	aDevice);
4127	if (!pAttach)
4128	return setError(VBOX_E_OBJECT_NOT_FOUND,
4129	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4130	aDevice, aControllerPort, aName.c_str());
4131
4132
4133	i_setModified(IsModified_Storage);
4134	mMediumAttachments.backup();
4135
4136	IBandwidthGroup *iB = aBandwidthGroup;
4137	ComObjPtr<BandwidthGroup> group = static_cast<BandwidthGroup*>(iB);
4138	if (aBandwidthGroup && group.isNull())
4139	return setError(E_INVALIDARG, tr("The given bandwidth group pointer is invalid"));
4140
4141	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4142
4143	const Utf8Str strBandwidthGroupOld = pAttach->i_getBandwidthGroup();
4144	if (strBandwidthGroupOld.isNotEmpty())
4145	{
4146	/* Get the bandwidth group object and release it - this must not fail. */
4147	ComObjPtr<BandwidthGroup> pBandwidthGroupOld;
4148	hrc = i_getBandwidthGroup(strBandwidthGroupOld, pBandwidthGroupOld, false);
4149	Assert(SUCCEEDED(hrc));
4150
4151	pBandwidthGroupOld->i_release();
4152	pAttach->i_updateBandwidthGroup(Utf8Str::Empty);
4153	}
4154
4155	if (!group.isNull())
4156	{
4157	group->i_reference();
4158	pAttach->i_updateBandwidthGroup(group->i_getName());
4159	}
4160
4161	return S_OK;
4162	}
4163
4164	HRESULT Machine::attachDeviceWithoutMedium(const com::Utf8Str &aName,
4165	LONG aControllerPort,
4166	LONG aDevice,
4167	DeviceType_T aType)
4168	{
4169	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aType=%d\n",
4170	aName.c_str(), aControllerPort, aDevice, aType));
4171
4172	return attachDevice(aName, aControllerPort, aDevice, aType, NULL);
4173	}
4174
4175
4176	HRESULT Machine::unmountMedium(const com::Utf8Str &aName,
4177	LONG aControllerPort,
4178	LONG aDevice,
4179	BOOL aForce)
4180	{
4181	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d",
4182	aName.c_str(), aControllerPort, aForce));
4183
4184	return mountMedium(aName, aControllerPort, aDevice, NULL, aForce);
4185	}
4186
4187	HRESULT Machine::mountMedium(const com::Utf8Str &aName,
4188	LONG aControllerPort,
4189	LONG aDevice,
4190	const ComPtr<IMedium> &aMedium,
4191	BOOL aForce)
4192	{
4193	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aForce=%d\n",
4194	aName.c_str(), aControllerPort, aDevice, aForce));
4195
4196	// request the host lock first, since might be calling Host methods for getting host drives;
4197	// next, protect the media tree all the while we're in here, as well as our member variables
4198	AutoMultiWriteLock3 multiLock(mParent->i_host()->lockHandle(),
4199	this->lockHandle(),
4200	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
4201
4202	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
4203	if (FAILED(hrc)) return hrc;
4204
4205	ComObjPtr<MediumAttachment> pAttach = i_findAttachment(*mMediumAttachments.data(),
4206	aName,
4207	aControllerPort,
4208	aDevice);
4209	if (pAttach.isNull())
4210	return setError(VBOX_E_OBJECT_NOT_FOUND,
4211	tr("No drive attached to device slot %d on port %d of controller '%s'"),
4212	aDevice, aControllerPort, aName.c_str());
4213
4214	/* Remember previously mounted medium. The medium before taking the
4215	* backup is not necessarily the same thing. */
4216	ComObjPtr<Medium> oldmedium;
4217	oldmedium = pAttach->i_getMedium();
4218
4219	IMedium *iM = aMedium;
4220	ComObjPtr<Medium> pMedium = static_cast<Medium*>(iM);
4221	if (aMedium && pMedium.isNull())
4222	return setError(E_INVALIDARG, tr("The given medium pointer is invalid"));
4223
4224	/* Check if potential medium is already mounted */
4225	if (pMedium == oldmedium)
4226	return S_OK;
4227
4228	AutoCaller mediumCaller(pMedium);
4229	if (FAILED(mediumCaller.hrc())) return mediumCaller.hrc();
4230
4231	AutoWriteLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
4232	if (pMedium)
4233	{
4234	DeviceType_T mediumType = pAttach->i_getType();
4235	switch (mediumType)
4236	{
4237	case DeviceType_DVD:
4238	case DeviceType_Floppy:
4239	break;
4240
4241	default:
4242	return setError(VBOX_E_INVALID_OBJECT_STATE,
4243	tr("The device at port %d, device %d of controller '%s' of this virtual machine is not removeable"),
4244	aControllerPort,
4245	aDevice,
4246	aName.c_str());
4247	}
4248	}
4249
4250	i_setModified(IsModified_Storage);
4251	mMediumAttachments.backup();
4252
4253	{
4254	// The backup operation makes the pAttach reference point to the
4255	// old settings. Re-get the correct reference.
4256	pAttach = i_findAttachment(*mMediumAttachments.data(),
4257	aName,
4258	aControllerPort,
4259	aDevice);
4260	if (!oldmedium.isNull())
4261	oldmedium->i_removeBackReference(mData->mUuid);
4262	if (!pMedium.isNull())
4263	{
4264	pMedium->i_addBackReference(mData->mUuid);
4265
4266	mediumLock.release();
4267	multiLock.release();
4268	i_addMediumToRegistry(pMedium);
4269	multiLock.acquire();
4270	mediumLock.acquire();
4271	}
4272
4273	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4274	pAttach->i_updateMedium(pMedium);
4275	}
4276
4277	i_setModified(IsModified_Storage);
4278
4279	mediumLock.release();
4280	multiLock.release();
4281	hrc = i_onMediumChange(pAttach, aForce);
4282	multiLock.acquire();
4283	mediumLock.acquire();
4284
4285	/* On error roll back this change only. */
4286	if (FAILED(hrc))
4287	{
4288	if (!pMedium.isNull())
4289	pMedium->i_removeBackReference(mData->mUuid);
4290	pAttach = i_findAttachment(*mMediumAttachments.data(),
4291	aName,
4292	aControllerPort,
4293	aDevice);
4294	/* If the attachment is gone in the meantime, bail out. */
4295	if (pAttach.isNull())
4296	return hrc;
4297	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4298	if (!oldmedium.isNull())
4299	oldmedium->i_addBackReference(mData->mUuid);
4300	pAttach->i_updateMedium(oldmedium);
4301	}
4302
4303	mediumLock.release();
4304	multiLock.release();
4305
4306	/* Save modified registries, but skip this machine as it's the caller's
4307	* job to save its settings like all other settings changes. */
4308	mParent->i_unmarkRegistryModified(i_getId());
4309	mParent->i_saveModifiedRegistries();
4310
4311	return hrc;
4312	}
4313	HRESULT Machine::getMedium(const com::Utf8Str &aName,
4314	LONG aControllerPort,
4315	LONG aDevice,
4316	ComPtr<IMedium> &aMedium)
4317	{
4318	LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4319	aName.c_str(), aControllerPort, aDevice));
4320
4321	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4322
4323	aMedium = NULL;
4324
4325	ComObjPtr<MediumAttachment> pAttach = i_findAttachment(*mMediumAttachments.data(),
4326	aName,
4327	aControllerPort,
4328	aDevice);
4329	if (pAttach.isNull())
4330	return setError(VBOX_E_OBJECT_NOT_FOUND,
4331	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4332	aDevice, aControllerPort, aName.c_str());
4333
4334	aMedium = pAttach->i_getMedium();
4335
4336	return S_OK;
4337	}
4338
4339	HRESULT Machine::getSerialPort(ULONG aSlot, ComPtr<ISerialPort> &aPort)
4340	{
4341	if (aSlot < RT_ELEMENTS(mSerialPorts))
4342	{
4343	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4344	mSerialPorts[aSlot].queryInterfaceTo(aPort.asOutParam());
4345	return S_OK;
4346	}
4347	return setError(E_INVALIDARG, tr("Serial port slot %RU32 is out of bounds (max %zu)"), aSlot, RT_ELEMENTS(mSerialPorts));
4348	}
4349
4350	HRESULT Machine::getParallelPort(ULONG aSlot, ComPtr<IParallelPort> &aPort)
4351	{
4352	if (aSlot < RT_ELEMENTS(mParallelPorts))
4353	{
4354	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4355	mParallelPorts[aSlot].queryInterfaceTo(aPort.asOutParam());
4356	return S_OK;
4357	}
4358	return setError(E_INVALIDARG, tr("Parallel port slot %RU32 is out of bounds (max %zu)"), aSlot, RT_ELEMENTS(mParallelPorts));
4359	}
4360
4361
4362	HRESULT Machine::getNetworkAdapter(ULONG aSlot, ComPtr<INetworkAdapter> &aAdapter)
4363	{
4364	/* Do not assert if slot is out of range, just return the advertised
4365	status. testdriver/vbox.py triggers this in logVmInfo. */
4366	if (aSlot >= mNetworkAdapters.size())
4367	return setError(E_INVALIDARG,
4368	tr("No network adapter in slot %RU32 (total %RU32 adapters)", "", mNetworkAdapters.size()),
4369	aSlot, mNetworkAdapters.size());
4370
4371	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4372
4373	mNetworkAdapters[aSlot].queryInterfaceTo(aAdapter.asOutParam());
4374
4375	return S_OK;
4376	}
4377
4378	HRESULT Machine::getExtraDataKeys(std::vector<com::Utf8Str> &aKeys)
4379	{
4380	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4381
4382	aKeys.resize(mData->pMachineConfigFile->mapExtraDataItems.size());
4383	size_t i = 0;
4384	for (settings::StringsMap::const_iterator
4385	it = mData->pMachineConfigFile->mapExtraDataItems.begin();
4386	it != mData->pMachineConfigFile->mapExtraDataItems.end();
4387	++it, ++i)
4388	aKeys[i] = it->first;
4389
4390	return S_OK;
4391	}
4392
4393	/**
4394	* @note Locks this object for reading.
4395	*/
4396	HRESULT Machine::getExtraData(const com::Utf8Str &aKey,
4397	com::Utf8Str &aValue)
4398	{
4399	/* start with nothing found */
4400	aValue = "";
4401
4402	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4403
4404	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(aKey);
4405	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4406	// found:
4407	aValue = it->second; // source is a Utf8Str
4408
4409	/* return the result to caller (may be empty) */
4410	return S_OK;
4411	}
4412
4413	/**
4414	* @note Locks mParent for writing + this object for writing.
4415	*/
4416	HRESULT Machine::setExtraData(const com::Utf8Str &aKey, const com::Utf8Str &aValue)
4417	{
4418	/* Because control characters in aKey have caused problems in the settings
4419	* they are rejected unless the key should be deleted. */
4420	if (!aValue.isEmpty())
4421	{
4422	for (size_t i = 0; i < aKey.length(); ++i)
4423	{
4424	char ch = aKey[i];
4425	if (RTLocCIsCntrl(ch))
4426	return E_INVALIDARG;
4427	}
4428	}
4429
4430	Utf8Str strOldValue; // empty
4431
4432	// locking note: we only hold the read lock briefly to look up the old value,
4433	// then release it and call the onExtraCanChange callbacks. There is a small
4434	// chance of a race insofar as the callback might be called twice if two callers
4435	// change the same key at the same time, but that's a much better solution
4436	// than the deadlock we had here before. The actual changing of the extradata
4437	// is then performed under the write lock and race-free.
4438
4439	// look up the old value first; if nothing has changed then we need not do anything
4440	{
4441	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); // hold read lock only while looking up
4442
4443	// For snapshots don't even think about allowing changes, extradata
4444	// is global for a machine, so there is nothing snapshot specific.
4445	if (i_isSnapshotMachine())
4446	return setError(VBOX_E_INVALID_VM_STATE,
4447	tr("Cannot set extradata for a snapshot"));
4448
4449	// check if the right IMachine instance is used
4450	if (mData->mRegistered && !i_isSessionMachine())
4451	return setError(VBOX_E_INVALID_VM_STATE,
4452	tr("Cannot set extradata for an immutable machine"));
4453
4454	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(aKey);
4455	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4456	strOldValue = it->second;
4457	}
4458
4459	bool fChanged;
4460	if ((fChanged = (strOldValue != aValue)))
4461	{
4462	// ask for permission from all listeners outside the locks;
4463	// i_onExtraDataCanChange() only briefly requests the VirtualBox
4464	// lock to copy the list of callbacks to invoke
4465	Bstr bstrError;
4466	if (!mParent->i_onExtraDataCanChange(mData->mUuid, aKey, aValue, bstrError))
4467	{
4468	const char *sep = bstrError.isEmpty() ? "" : ": ";
4469	Log1WarningFunc(("Someone vetoed! Change refused%s%ls\n", sep, bstrError.raw()));
4470	return setError(E_ACCESSDENIED,
4471	tr("Could not set extra data because someone refused the requested change of '%s' to '%s'%s%ls"),
4472	aKey.c_str(),
4473	aValue.c_str(),
4474	sep,
4475	bstrError.raw());
4476	}
4477
4478	// data is changing and change not vetoed: then write it out under the lock
4479	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4480
4481	if (aValue.isEmpty())
4482	mData->pMachineConfigFile->mapExtraDataItems.erase(aKey);
4483	else
4484	mData->pMachineConfigFile->mapExtraDataItems[aKey] = aValue;
4485	// creates a new key if needed
4486
4487	bool fNeedsGlobalSaveSettings = false;
4488	// This saving of settings is tricky: there is no "old state" for the
4489	// extradata items at all (unlike all other settings), so the old/new
4490	// settings comparison would give a wrong result!
4491	i_saveSettings(&fNeedsGlobalSaveSettings, alock, SaveS_Force);
4492
4493	if (fNeedsGlobalSaveSettings)
4494	{
4495	// save the global settings; for that we should hold only the VirtualBox lock
4496	alock.release();
4497	AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
4498	mParent->i_saveSettings();
4499	}
4500	}
4501
4502	// fire notification outside the lock
4503	if (fChanged)
4504	mParent->i_onExtraDataChanged(mData->mUuid, aKey, aValue);
4505
4506	return S_OK;
4507	}
4508
4509	HRESULT Machine::setSettingsFilePath(const com::Utf8Str &aSettingsFilePath, ComPtr<IProgress> &aProgress)
4510	{
4511	aProgress = NULL;
4512	NOREF(aSettingsFilePath);
4513	ReturnComNotImplemented();
4514	}
4515
4516	HRESULT Machine::saveSettings()
4517	{
4518	AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
4519
4520	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
4521	if (FAILED(hrc)) return hrc;
4522
4523	/* the settings file path may never be null */
4524	ComAssertRet(!mData->m_strConfigFileFull.isEmpty(), E_FAIL);
4525
4526	/* save all VM data excluding snapshots */
4527	bool fNeedsGlobalSaveSettings = false;
4528	hrc = i_saveSettings(&fNeedsGlobalSaveSettings, mlock);
4529	mlock.release();
4530
4531	if (SUCCEEDED(hrc) && fNeedsGlobalSaveSettings)
4532	{
4533	// save the global settings; for that we should hold only the VirtualBox lock
4534	AutoWriteLock vlock(mParent COMMA_LOCKVAL_SRC_POS);
4535	hrc = mParent->i_saveSettings();
4536	}
4537
4538	return hrc;
4539	}
4540
4541
4542	HRESULT Machine::discardSettings()
4543	{
4544	/*
4545	* We need to take the machine list lock here as well as the machine one
4546	* or we'll get into trouble should any media stuff require rolling back.
4547	*
4548	* Details:
4549	*
4550	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Wrong locking order! [uId=00007ff6853f6c34 thrd=ALIEN-1]
4551	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Lock: s 000000000259ef40 RTCritSectRw-3 srec=000000000259f150 cls=4-LISTOFMACHINES/any [s]
4552	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other lock: 00000000025ec710 RTCritSectRw-158 own=ALIEN-1 r=1 cls=5-MACHINEOBJECT/any pos={MachineImpl.cpp(5085) Machine::discardSettings 00007ff6853f6ce4} [x]
4553	* 11:06:01.934284 00:00:05.805182 ALIEN-1 My class: class=0000000000d5eb10 4-LISTOFMACHINES created={AutoLock.cpp(98) util::InitAutoLockSystem 00007ff6853f571f} sub-class=any
4554	* 11:06:01.934284 00:00:05.805182 ALIEN-1 My class: Prior: #00: 2-VIRTUALBOXOBJECT, manually , 4 lookups
4555	* 11:06:01.934284 00:00:05.805182 ALIEN-1 My class: #01: 3-HOSTOBJECT, manually , 0 lookups
4556	* 11:06:01.934284 00:00:05.805182 ALIEN-1 My class: Hash Stats: 3 hits, 1 misses
4557	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other class: class=0000000000d5ecd0 5-MACHINEOBJECT created={AutoLock.cpp(98) util::InitAutoLockSystem 00007ff6853f571f} sub-class=any
4558	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other class: Prior: #00: 2-VIRTUALBOXOBJECT, manually , 2 lookups
4559	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other class: #01: 3-HOSTOBJECT, manually , 6 lookups
4560	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other class: #02: 4-LISTOFMACHINES, manually , 5 lookups
4561	* 11:06:01.934284 00:00:05.805182 ALIEN-1 Other class: Hash Stats: 10 hits, 3 misses
4562	* 11:06:01.934284 00:00:05.805182 ALIEN-1 ---- start of lock stack for 000000000259d2d0 ALIEN-1 - 2 entries ----
4563	* 11:06:01.934284 00:00:05.805182 ALIEN-1 #00: 00000000025ec710 RTCritSectRw-158 own=ALIEN-1 r=2 cls=5-MACHINEOBJECT/any pos={MachineImpl.cpp(11705) Machine::i_rollback 00007ff6853f6ce4} [x/r]
4564	* 11:06:01.934284 00:00:05.805182 ALIEN-1 #01: 00000000025ec710 RTCritSectRw-158 own=ALIEN-1 r=1 cls=5-MACHINEOBJECT/any pos={MachineImpl.cpp(5085) Machine::discardSettings 00007ff6853f6ce4} [x] (*)
4565	* 11:06:01.934284 00:00:05.805182 ALIEN-1 ---- end of lock stack ----
4566	* 0:005> k
4567	* # Child-SP RetAddr Call Site
4568	* 00 00000000`0287bc90 00007ffc`8c0bc8dc VBoxRT!rtLockValComplainPanic+0x23 [e:\vbox\svn\trunk\src\vbox\runtime\common\misc\lockvalidator.cpp @ 807]
4569	* 01 00000000`0287bcc0 00007ffc`8c0bc083 VBoxRT!rtLockValidatorStackWrongOrder+0xac [e:\vbox\svn\trunk\src\vbox\runtime\common\misc\lockvalidator.cpp @ 2149]
4570	* 02 00000000`0287bd10 00007ffc`8c0bbfc3 VBoxRT!rtLockValidatorStackCheckLockingOrder2+0x93 [e:\vbox\svn\trunk\src\vbox\runtime\common\misc\lockvalidator.cpp @ 2227]
4571	* 03 00000000`0287bdd0 00007ffc`8c0bf3c0 VBoxRT!rtLockValidatorStackCheckLockingOrder+0x523 [e:\vbox\svn\trunk\src\vbox\runtime\common\misc\lockvalidator.cpp @ 2406]
4572	* 04 00000000`0287be40 00007ffc`8c180de4 VBoxRT!RTLockValidatorRecSharedCheckOrder+0x210 [e:\vbox\svn\trunk\src\vbox\runtime\common\misc\lockvalidator.cpp @ 3607]
4573	* 05 00000000`0287be90 00007ffc`8c1819b8 VBoxRT!rtCritSectRwEnterShared+0x1a4 [e:\vbox\svn\trunk\src\vbox\runtime\generic\critsectrw-generic.cpp @ 222]
4574	* 06 00000000`0287bf60 00007ff6`853f5e78 VBoxRT!RTCritSectRwEnterSharedDebug+0x58 [e:\vbox\svn\trunk\src\vbox\runtime\generic\critsectrw-generic.cpp @ 428]
4575	* 07 00000000`0287bfb0 00007ff6`853f6c34 VBoxSVC!util::RWLockHandle::lockRead+0x58 [e:\vbox\svn\trunk\src\vbox\main\glue\autolock.cpp @ 245]
4576	* 08 00000000`0287c000 00007ff6`853f68a1 VBoxSVC!util::AutoReadLock::callLockImpl+0x64 [e:\vbox\svn\trunk\src\vbox\main\glue\autolock.cpp @ 552]
4577	* 09 00000000`0287c040 00007ff6`853f6a59 VBoxSVC!util::AutoLockBase::callLockOnAllHandles+0xa1 [e:\vbox\svn\trunk\src\vbox\main\glue\autolock.cpp @ 455]
4578	* 0a 00000000`0287c0a0 00007ff6`85038fdb VBoxSVC!util::AutoLockBase::acquire+0x89 [e:\vbox\svn\trunk\src\vbox\main\glue\autolock.cpp @ 500]
4579	* 0b 00000000`0287c0d0 00007ff6`85216dcf VBoxSVC!util::AutoReadLock::AutoReadLock+0x7b [e:\vbox\svn\trunk\include\vbox\com\autolock.h @ 370]
4580	* 0c 00000000`0287c120 00007ff6`8521cf08 VBoxSVC!VirtualBox::i_findMachine+0x14f [e:\vbox\svn\trunk\src\vbox\main\src-server\virtualboximpl.cpp @ 3216]
4581	* 0d 00000000`0287c260 00007ff6`8517a4b0 VBoxSVC!VirtualBox::i_markRegistryModified+0xa8 [e:\vbox\svn\trunk\src\vbox\main\src-server\virtualboximpl.cpp @ 4697]
4582	* 0e 00000000`0287c2f0 00007ff6`8517fac0 VBoxSVC!Medium::i_markRegistriesModified+0x170 [e:\vbox\svn\trunk\src\vbox\main\src-server\mediumimpl.cpp @ 4056]
4583	* 0f 00000000`0287c500 00007ff6`8511ca9d VBoxSVC!Medium::i_deleteStorage+0xb90 [e:\vbox\svn\trunk\src\vbox\main\src-server\mediumimpl.cpp @ 5114]
4584	* 10 00000000`0287cad0 00007ff6`8511ef0e VBoxSVC!Machine::i_deleteImplicitDiffs+0x11ed [e:\vbox\svn\trunk\src\vbox\main\src-server\machineimpl.cpp @ 11117]
4585	* 11 00000000`0287d2e0 00007ff6`8511f896 VBoxSVC!Machine::i_rollbackMedia+0x42e [e:\vbox\svn\trunk\src\vbox\main\src-server\machineimpl.cpp @ 11657]
4586	* 12 00000000`0287d3c0 00007ff6`850fd17a VBoxSVC!Machine::i_rollback+0x6a6 [e:\vbox\svn\trunk\src\vbox\main\src-server\machineimpl.cpp @ 11786]
4587	* 13 00000000`0287d710 00007ff6`85342dbe VBoxSVC!Machine::discardSettings+0x9a [e:\vbox\svn\trunk\src\vbox\main\src-server\machineimpl.cpp @ 5096]
4588	* 14 00000000`0287d790 00007ffc`c06813ff VBoxSVC!MachineWrap::DiscardSettings+0x16e [e:\vbox\svn\trunk\out\win.amd64\debug\obj\vboxapiwrap\machinewrap.cpp @ 9171]
4589	*
4590	*/
4591	AutoReadLock alockMachines(mParent->i_getMachinesListLockHandle() COMMA_LOCKVAL_SRC_POS);
4592	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4593
4594	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
4595	if (FAILED(hrc)) return hrc;
4596
4597	/*
4598	* during this rollback, the session will be notified if data has
4599	* been actually changed
4600	*/
4601	i_rollback(true /* aNotify */);
4602
4603	return S_OK;
4604	}
4605
4606	/** @note Locks objects! */
4607	HRESULT Machine::unregister(AutoCaller &autoCaller,
4608	CleanupMode_T aCleanupMode,
4609	std::vector<ComPtr<IMedium> > &aMedia)
4610	{
4611	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4612
4613	Guid id(i_getId());
4614
4615	if (mData->mSession.mState != SessionState_Unlocked)
4616	return setError(VBOX_E_INVALID_OBJECT_STATE,
4617	tr("Cannot unregister the machine '%s' while it is locked"),
4618	mUserData->s.strName.c_str());
4619
4620	// wait for state dependents to drop to zero
4621	i_ensureNoStateDependencies(alock);
4622
4623	if (!mData->mAccessible)
4624	{
4625	// inaccessible machines can only be unregistered; uninitialize ourselves
4626	// here because currently there may be no unregistered that are inaccessible
4627	// (this state combination is not supported). Note releasing the caller and
4628	// leaving the lock before calling uninit()
4629	alock.release();
4630	autoCaller.release();
4631
4632	uninit();
4633
4634	mParent->i_unregisterMachine(this, CleanupMode_UnregisterOnly, id);
4635	// calls VirtualBox::i_saveSettings()
4636
4637	return S_OK;
4638	}
4639
4640	HRESULT hrc = S_OK;
4641	mData->llFilesToDelete.clear();
4642
4643	if (!mSSData->strStateFilePath.isEmpty())
4644	mData->llFilesToDelete.push_back(mSSData->strStateFilePath);
4645
4646	Utf8Str strNVRAMFile = mNvramStore->i_getNonVolatileStorageFile();
4647	if (!strNVRAMFile.isEmpty() && RTFileExists(strNVRAMFile.c_str()))
4648	mData->llFilesToDelete.push_back(strNVRAMFile);
4649
4650	// This list collects the medium objects from all medium attachments
4651	// which we will detach from the machine and its snapshots, in a specific
4652	// order which allows for closing all media without getting "media in use"
4653	// errors, simply by going through the list from the front to the back:
4654	// 1) first media from machine attachments (these have the "leaf" attachments with snapshots
4655	// and must be closed before the parent media from the snapshots, or closing the parents
4656	// will fail because they still have children);
4657	// 2) media from the youngest snapshots followed by those from the parent snapshots until
4658	// the root ("first") snapshot of the machine.
4659	MediaList llMedia;
4660
4661	if ( !mMediumAttachments.isNull() // can be NULL if machine is inaccessible
4662	&& mMediumAttachments->size()
4663	)
4664	{
4665	// we have media attachments: detach them all and add the Medium objects to our list
4666	i_detachAllMedia(alock, NULL /* pSnapshot */, aCleanupMode, llMedia);
4667	}
4668
4669	if (mData->mFirstSnapshot)
4670	{
4671	// add the media from the medium attachments of the snapshots to
4672	// llMedia as well, after the "main" machine media;
4673	// Snapshot::uninitAll() calls Machine::detachAllMedia() for each
4674	// snapshot machine, depth first.
4675
4676	// Snapshot::beginDeletingSnapshot() asserts if the machine state is not this
4677	MachineState_T oldState = mData->mMachineState;
4678	mData->mMachineState = MachineState_DeletingSnapshot;
4679
4680	// make a copy of the first snapshot reference so the refcount does not
4681	// drop to 0 in beginDeletingSnapshot, which sets pFirstSnapshot to 0
4682	// (would hang due to the AutoCaller voodoo)
4683	ComObjPtr<Snapshot> pFirstSnapshot = mData->mFirstSnapshot;
4684
4685	// GO!
4686	pFirstSnapshot->i_uninitAll(alock, aCleanupMode, llMedia, mData->llFilesToDelete);
4687
4688	mData->mMachineState = oldState;
4689	}
4690
4691	if (FAILED(hrc))
4692	{
4693	i_rollbackMedia();
4694	return hrc;
4695	}
4696
4697	// commit all the media changes made above
4698	i_commitMedia();
4699
4700	mData->mRegistered = false;
4701
4702	// machine lock no longer needed
4703	alock.release();
4704
4705	/* Make sure that the settings of the current VM are not saved, because
4706	* they are rather crippled at this point to meet the cleanup expectations
4707	* and there's no point destroying the VM config on disk just because. */
4708	mParent->i_unmarkRegistryModified(id);
4709
4710	// return media to caller
4711	aMedia.resize(llMedia.size());
4712	size_t i = 0;
4713	for (MediaList::const_iterator
4714	it = llMedia.begin();
4715	it != llMedia.end();
4716	++it, ++i)
4717	(*it).queryInterfaceTo(aMedia[i].asOutParam());
4718
4719	mParent->i_unregisterMachine(this, aCleanupMode, id);
4720	// calls VirtualBox::i_saveSettings() and VirtualBox::saveModifiedRegistries()
4721
4722	return S_OK;
4723	}
4724
4725	/**
4726	* Task record for deleting a machine config.
4727	*/
4728	class Machine::DeleteConfigTask
4729	: public Machine::Task
4730	{
4731	public:
4732	DeleteConfigTask(Machine *m,
4733	Progress *p,
4734	const Utf8Str &t,
4735	const RTCList<ComPtr<IMedium> > &llMedia,
4736	const StringsList &llFilesToDelete)
4737	: Task(m, p, t),
4738	m_llMedia(llMedia),
4739	m_llFilesToDelete(llFilesToDelete)
4740	{}
4741
4742	private:
4743	void handler()
4744	{
4745	try
4746	{
4747	m_pMachine->i_deleteConfigHandler(*this);
4748	}
4749	catch (...)
4750	{
4751	LogRel(("Some exception in the function Machine::i_deleteConfigHandler()\n"));
4752	}
4753	}
4754
4755	RTCList<ComPtr<IMedium> > m_llMedia;
4756	StringsList m_llFilesToDelete;
4757
4758	friend void Machine::i_deleteConfigHandler(DeleteConfigTask &task);
4759	};
4760
4761	/**
4762	* Task thread implementation for SessionMachine::DeleteConfig(), called from
4763	* SessionMachine::taskHandler().
4764	*
4765	* @note Locks this object for writing.
4766	*
4767	* @param task
4768	*/
4769	void Machine::i_deleteConfigHandler(DeleteConfigTask &task)
4770	{
4771	LogFlowThisFuncEnter();
4772
4773	AutoCaller autoCaller(this);
4774	LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
4775	if (FAILED(autoCaller.hrc()))
4776	{
4777	/* we might have been uninitialized because the session was accidentally
4778	* closed by the client, so don't assert */
4779	HRESULT hrc = setError(E_FAIL, tr("The session has been accidentally closed"));
4780	task.m_pProgress->i_notifyComplete(hrc);
4781	LogFlowThisFuncLeave();
4782	return;
4783	}
4784
4785	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4786
4787	HRESULT hrc;
4788	try
4789	{
4790	ULONG uLogHistoryCount = 3;
4791	ComPtr<ISystemProperties> systemProperties;
4792	hrc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
4793	if (FAILED(hrc)) throw hrc;
4794
4795	if (!systemProperties.isNull())
4796	{
4797	hrc = systemProperties->COMGETTER(LogHistoryCount)(&uLogHistoryCount);
4798	if (FAILED(hrc)) throw hrc;
4799	}
4800
4801	MachineState_T oldState = mData->mMachineState;
4802	i_setMachineState(MachineState_SettingUp);
4803	alock.release();
4804	for (size_t i = 0; i < task.m_llMedia.size(); ++i)
4805	{
4806	ComObjPtr<Medium> pMedium = (Medium)(IMedium)(task.m_llMedia.at(i));
4807	{
4808	AutoCaller mac(pMedium);
4809	if (FAILED(mac.hrc())) throw mac.hrc();
4810	Utf8Str strLocation = pMedium->i_getLocationFull();
4811	LogFunc(("Deleting file %s\n", strLocation.c_str()));
4812	hrc = task.m_pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), strLocation.c_str()).raw(), 1);
4813	if (FAILED(hrc)) throw hrc;
4814	}
4815	if (pMedium->i_isMediumFormatFile())
4816	{
4817	ComPtr<IProgress> pProgress2;
4818	hrc = pMedium->DeleteStorage(pProgress2.asOutParam());
4819	if (FAILED(hrc)) throw hrc;
4820	hrc = task.m_pProgress->WaitForOtherProgressCompletion(pProgress2, 0 /* indefinite wait */);
4821	if (FAILED(hrc)) throw hrc;
4822	}
4823
4824	/* Close the medium, deliberately without checking the return
4825	* code, and without leaving any trace in the error info, as
4826	* a failure here is a very minor issue, which shouldn't happen
4827	* as above we even managed to delete the medium. */
4828	{
4829	ErrorInfoKeeper eik;
4830	pMedium->Close();
4831	}
4832	}
4833	i_setMachineState(oldState);
4834	alock.acquire();
4835
4836	// delete the files pushed on the task list by Machine::Delete()
4837	// (this includes saved states of the machine and snapshots and
4838	// medium storage files from the IMedium list passed in, and the
4839	// machine XML file)
4840	for (StringsList::const_iterator
4841	it = task.m_llFilesToDelete.begin();
4842	it != task.m_llFilesToDelete.end();
4843	++it)
4844	{
4845	const Utf8Str &strFile = *it;
4846	LogFunc(("Deleting file %s\n", strFile.c_str()));
4847	hrc = task.m_pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()).raw(), 1);
4848	if (FAILED(hrc)) throw hrc;
4849	i_deleteFile(strFile);
4850	}
4851
4852	hrc = task.m_pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")).raw(), 1);
4853	if (FAILED(hrc)) throw hrc;
4854
4855	/* delete the settings only when the file actually exists */
4856	if (mData->pMachineConfigFile->fileExists())
4857	{
4858	/* Delete any backup or uncommitted XML files. Ignore failures.
4859	See the fSafe parameter of xml::XmlFileWriter::write for details. */
4860	/** @todo Find a way to avoid referring directly to iprt/xml.h here. */
4861	Utf8StrFmt otherXml("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszTmpSuff);
4862	i_deleteFile(otherXml, true /* fIgnoreFailures */);
4863	otherXml.printf("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszPrevSuff);
4864	i_deleteFile(otherXml, true /* fIgnoreFailures */);
4865
4866	/* delete the Logs folder, nothing important should be left
4867	* there (we don't check for errors because the user might have
4868	* some private files there that we don't want to delete) */
4869	Utf8Str logFolder;
4870	getLogFolder(logFolder);
4871	Assert(logFolder.length());
4872	if (RTDirExists(logFolder.c_str()))
4873	{
4874	/* Delete all VBox.log[.N] files from the Logs folder
4875	* (this must be in sync with the rotation logic in
4876	* Console::powerUpThread()). Also, delete the VBox.png[.N]
4877	* files that may have been created by the GUI. */
4878	Utf8StrFmt log("%s%cVBox.log", logFolder.c_str(), RTPATH_DELIMITER);
4879	i_deleteFile(log, true /* fIgnoreFailures */);
4880	log.printf("%s%cVBox.png", logFolder.c_str(), RTPATH_DELIMITER);
4881	i_deleteFile(log, true /* fIgnoreFailures */);
4882	for (ULONG i = uLogHistoryCount; i > 0; i--)
4883	{
4884	log.printf("%s%cVBox.log.%u", logFolder.c_str(), RTPATH_DELIMITER, i);
4885	i_deleteFile(log, true /* fIgnoreFailures */);
4886	log.printf("%s%cVBox.png.%u", logFolder.c_str(), RTPATH_DELIMITER, i);
4887	i_deleteFile(log, true /* fIgnoreFailures */);
4888	}
4889	log.printf("%s%cVBoxUI.log", logFolder.c_str(), RTPATH_DELIMITER);
4890	i_deleteFile(log, true /* fIgnoreFailures */);
4891	#if defined(RT_OS_WINDOWS)
4892	log.printf("%s%cVBoxStartup.log", logFolder.c_str(), RTPATH_DELIMITER);
4893	i_deleteFile(log, true /* fIgnoreFailures */);
4894	log.printf("%s%cVBoxHardening.log", logFolder.c_str(), RTPATH_DELIMITER);
4895	i_deleteFile(log, true /* fIgnoreFailures */);
4896	#endif
4897
4898	RTDirRemove(logFolder.c_str());
4899	}
4900
4901	/* delete the Snapshots folder, nothing important should be left
4902	* there (we don't check for errors because the user might have
4903	* some private files there that we don't want to delete) */
4904	Utf8Str strFullSnapshotFolder;
4905	i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
4906	Assert(!strFullSnapshotFolder.isEmpty());
4907	if (RTDirExists(strFullSnapshotFolder.c_str()))
4908	RTDirRemove(strFullSnapshotFolder.c_str());
4909
4910	// delete the directory that contains the settings file, but only
4911	// if it matches the VM name
4912	Utf8Str settingsDir;
4913	if (i_isInOwnDir(&settingsDir))
4914	RTDirRemove(settingsDir.c_str());
4915	}
4916
4917	alock.release();
4918
4919	mParent->i_saveModifiedRegistries();
4920	}
4921	catch (HRESULT hrcXcpt)
4922	{
4923	hrc = hrcXcpt;
4924	}
4925
4926	task.m_pProgress->i_notifyComplete(hrc);
4927
4928	LogFlowThisFuncLeave();
4929	}
4930
4931	HRESULT Machine::deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia, ComPtr<IProgress> &aProgress)
4932	{
4933	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4934
4935	HRESULT hrc = i_checkStateDependency(MutableStateDep);
4936	if (FAILED(hrc)) return hrc;
4937
4938	if (mData->mRegistered)
4939	return setError(VBOX_E_INVALID_VM_STATE,
4940	tr("Cannot delete settings of a registered machine"));
4941
4942	// collect files to delete
4943	StringsList llFilesToDelete(mData->llFilesToDelete); // saved states and NVRAM files pushed here by Unregister()
4944	// machine config file
4945	if (mData->pMachineConfigFile->fileExists())
4946	llFilesToDelete.push_back(mData->m_strConfigFileFull);
4947	// backup of machine config file
4948	Utf8Str strTmp(mData->m_strConfigFileFull);
4949	strTmp.append("-prev");
4950	if (RTFileExists(strTmp.c_str()))
4951	llFilesToDelete.push_back(strTmp);
4952
4953	RTCList<ComPtr<IMedium> > llMedia;
4954	for (size_t i = 0; i < aMedia.size(); ++i)
4955	{
4956	IMedium *pIMedium(aMedia[i]);
4957	ComObjPtr<Medium> pMedium = static_cast<Medium*>(pIMedium);
4958	if (pMedium.isNull())
4959	return setError(E_INVALIDARG, tr("The given medium pointer with index %d is invalid"), i);
4960	SafeArray<BSTR> ids;
4961	hrc = pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids));
4962	if (FAILED(hrc)) return hrc;
4963	/* At this point the medium should not have any back references
4964	* anymore. If it has it is attached to another VM and must not
4965	* deleted. */
4966	if (ids.size() < 1)
4967	llMedia.append(pMedium);
4968	}
4969
4970	ComObjPtr<Progress> pProgress;
4971	pProgress.createObject();
4972	hrc = pProgress->init(i_getVirtualBox(),
4973	static_cast<IMachine>(this) / aInitiator */,
4974	tr("Deleting files"),
4975	true /* fCancellable */,
4976	(ULONG)(1 + llMedia.size() + llFilesToDelete.size() + 1), // cOperations
4977	tr("Collecting file inventory"));
4978	if (FAILED(hrc))
4979	return hrc;
4980
4981	/* create and start the task on a separate thread (note that it will not
4982	* start working until we release alock) */
4983	DeleteConfigTask *pTask = new DeleteConfigTask(this, pProgress, "DeleteVM", llMedia, llFilesToDelete);
4984	hrc = pTask->createThread();
4985	pTask = NULL;
4986	if (FAILED(hrc))
4987	return hrc;
4988
4989	pProgress.queryInterfaceTo(aProgress.asOutParam());
4990
4991	LogFlowFuncLeave();
4992
4993	return S_OK;
4994	}
4995
4996	HRESULT Machine::findSnapshot(const com::Utf8Str &aNameOrId, ComPtr<ISnapshot> &aSnapshot)
4997	{
4998	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4999
5000	ComObjPtr<Snapshot> pSnapshot;
5001	HRESULT hrc;
5002
5003	if (aNameOrId.isEmpty())
5004	// null case (caller wants root snapshot): i_findSnapshotById() handles this
5005	hrc = i_findSnapshotById(Guid(), pSnapshot, true /* aSetError */);
5006	else
5007	{
5008	Guid uuid(aNameOrId);
5009	if (uuid.isValid())
5010	hrc = i_findSnapshotById(uuid, pSnapshot, true /* aSetError */);
5011	else
5012	hrc = i_findSnapshotByName(aNameOrId, pSnapshot, true /* aSetError */);
5013	}
5014	pSnapshot.queryInterfaceTo(aSnapshot.asOutParam());
5015
5016	return hrc;
5017	}
5018
5019	HRESULT Machine::createSharedFolder(const com::Utf8Str &aName, const com::Utf8Str &aHostPath, BOOL aWritable,
5020	BOOL aAutomount, const com::Utf8Str &aAutoMountPoint)
5021	{
5022	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5023
5024	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
5025	if (FAILED(hrc)) return hrc;
5026
5027	ComObjPtr<SharedFolder> sharedFolder;
5028	hrc = i_findSharedFolder(aName, sharedFolder, false /* aSetError */);
5029	if (SUCCEEDED(hrc))
5030	return setError(VBOX_E_OBJECT_IN_USE,
5031	tr("Shared folder named '%s' already exists"),
5032	aName.c_str());
5033
5034	sharedFolder.createObject();
5035	hrc = sharedFolder->init(i_getMachine(),
5036	aName,
5037	aHostPath,
5038	!!aWritable,
5039	!!aAutomount,
5040	aAutoMountPoint,
5041	true /* fFailOnError */);
5042	if (FAILED(hrc)) return hrc;
5043
5044	i_setModified(IsModified_SharedFolders);
5045	mHWData.backup();
5046	mHWData->mSharedFolders.push_back(sharedFolder);
5047
5048	/* inform the direct session if any */
5049	alock.release();
5050	i_onSharedFolderChange();
5051
5052	return S_OK;
5053	}
5054
5055	HRESULT Machine::removeSharedFolder(const com::Utf8Str &aName)
5056	{
5057	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5058
5059	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
5060	if (FAILED(hrc)) return hrc;
5061
5062	ComObjPtr<SharedFolder> sharedFolder;
5063	hrc = i_findSharedFolder(aName, sharedFolder, true /* aSetError */);
5064	if (FAILED(hrc)) return hrc;
5065
5066	i_setModified(IsModified_SharedFolders);
5067	mHWData.backup();
5068	mHWData->mSharedFolders.remove(sharedFolder);
5069
5070	/* inform the direct session if any */
5071	alock.release();
5072	i_onSharedFolderChange();
5073
5074	return S_OK;
5075	}
5076
5077	HRESULT Machine::canShowConsoleWindow(BOOL *aCanShow)
5078	{
5079	/* start with No */
5080	*aCanShow = FALSE;
5081
5082	ComPtr<IInternalSessionControl> directControl;
5083	{
5084	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5085
5086	if (mData->mSession.mState != SessionState_Locked)
5087	return setError(VBOX_E_INVALID_VM_STATE,
5088	tr("Machine is not locked for session (session state: %s)"),
5089	Global::stringifySessionState(mData->mSession.mState));
5090
5091	if (mData->mSession.mLockType == LockType_VM)
5092	directControl = mData->mSession.mDirectControl;
5093	}
5094
5095	/* ignore calls made after #OnSessionEnd() is called */
5096	if (!directControl)
5097	return S_OK;
5098
5099	LONG64 dummy;
5100	return directControl->OnShowWindow(TRUE /* aCheck */, aCanShow, &dummy);
5101	}
5102
5103	HRESULT Machine::showConsoleWindow(LONG64 *aWinId)
5104	{
5105	ComPtr<IInternalSessionControl> directControl;
5106	{
5107	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5108
5109	if (mData->mSession.mState != SessionState_Locked)
5110	return setError(E_FAIL,
5111	tr("Machine is not locked for session (session state: %s)"),
5112	Global::stringifySessionState(mData->mSession.mState));
5113
5114	if (mData->mSession.mLockType == LockType_VM)
5115	directControl = mData->mSession.mDirectControl;
5116	}
5117
5118	/* ignore calls made after #OnSessionEnd() is called */
5119	if (!directControl)
5120	return S_OK;
5121
5122	BOOL dummy;
5123	return directControl->OnShowWindow(FALSE /* aCheck */, &dummy, aWinId);
5124	}
5125
5126	#ifdef VBOX_WITH_GUEST_PROPS
5127	/**
5128	* Look up a guest property in VBoxSVC's internal structures.
5129	*/
5130	HRESULT Machine::i_getGuestPropertyFromService(const com::Utf8Str &aName,
5131	com::Utf8Str &aValue,
5132	LONG64 *aTimestamp,
5133	com::Utf8Str &aFlags) const
5134	{
5135	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5136
5137	HWData::GuestPropertyMap::const_iterator it = mHWData->mGuestProperties.find(aName);
5138	if (it != mHWData->mGuestProperties.end())
5139	{
5140	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
5141	aValue = it->second.strValue;
5142	*aTimestamp = it->second.mTimestamp;
5143	GuestPropWriteFlags(it->second.mFlags, szFlags);
5144	aFlags = Utf8Str(szFlags);
5145	}
5146
5147	return S_OK;
5148	}
5149
5150	/**
5151	* Query the VM that a guest property belongs to for the property.
5152	* @returns E_ACCESSDENIED if the VM process is not available or not
5153	* currently handling queries and the lookup should then be done in
5154	* VBoxSVC.
5155	*/
5156	HRESULT Machine::i_getGuestPropertyFromVM(const com::Utf8Str &aName,
5157	com::Utf8Str &aValue,
5158	LONG64 *aTimestamp,
5159	com::Utf8Str &aFlags) const
5160	{
5161	HRESULT hrc = S_OK;
5162	Bstr bstrValue;
5163	Bstr bstrFlags;
5164
5165	ComPtr<IInternalSessionControl> directControl;
5166	{
5167	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5168	if (mData->mSession.mLockType == LockType_VM)
5169	directControl = mData->mSession.mDirectControl;
5170	}
5171
5172	/* ignore calls made after #OnSessionEnd() is called */
5173	if (!directControl)
5174	hrc = E_ACCESSDENIED;
5175	else
5176	hrc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr::Empty.raw(), Bstr::Empty.raw(),
5177	0 /* accessMode */,
5178	bstrValue.asOutParam(), aTimestamp, bstrFlags.asOutParam());
5179
5180	aValue = bstrValue;
5181	aFlags = bstrFlags;
5182
5183	return hrc;
5184	}
5185	#endif // VBOX_WITH_GUEST_PROPS
5186
5187	HRESULT Machine::getGuestProperty(const com::Utf8Str &aName,
5188	com::Utf8Str &aValue,
5189	LONG64 *aTimestamp,
5190	com::Utf8Str &aFlags)
5191	{
5192	#ifndef VBOX_WITH_GUEST_PROPS
5193	ReturnComNotImplemented();
5194	#else // VBOX_WITH_GUEST_PROPS
5195
5196	HRESULT hrc = i_getGuestPropertyFromVM(aName, aValue, aTimestamp, aFlags);
5197
5198	if (hrc == E_ACCESSDENIED)
5199	/* The VM is not running or the service is not (yet) accessible */
5200	hrc = i_getGuestPropertyFromService(aName, aValue, aTimestamp, aFlags);
5201	return hrc;
5202	#endif // VBOX_WITH_GUEST_PROPS
5203	}
5204
5205	HRESULT Machine::getGuestPropertyValue(const com::Utf8Str &aProperty, com::Utf8Str &aValue)
5206	{
5207	LONG64 dummyTimestamp;
5208	com::Utf8Str dummyFlags;
5209	return getGuestProperty(aProperty, aValue, &dummyTimestamp, dummyFlags);
5210
5211	}
5212	HRESULT Machine::getGuestPropertyTimestamp(const com::Utf8Str &aProperty, LONG64 *aValue)
5213	{
5214	com::Utf8Str dummyFlags;
5215	com::Utf8Str dummyValue;
5216	return getGuestProperty(aProperty, dummyValue, aValue, dummyFlags);
5217	}
5218
5219	#ifdef VBOX_WITH_GUEST_PROPS
5220	/**
5221	* Set a guest property in VBoxSVC's internal structures.
5222	*/
5223	HRESULT Machine::i_setGuestPropertyToService(const com::Utf8Str &aName, const com::Utf8Str &aValue,
5224	const com::Utf8Str &aFlags, bool fDelete)
5225	{
5226	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5227	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
5228	if (FAILED(hrc)) return hrc;
5229
5230	try
5231	{
5232	uint32_t fFlags = GUEST_PROP_F_NILFLAG;
5233	if (aFlags.length() && RT_FAILURE(GuestPropValidateFlags(aFlags.c_str(), &fFlags)))
5234	return setError(E_INVALIDARG, tr("Invalid guest property flag values: '%s'"), aFlags.c_str());
5235
5236	if (fFlags & (GUEST_PROP_F_TRANSIENT \| GUEST_PROP_F_TRANSRESET))
5237	return setError(E_INVALIDARG, tr("Properties with TRANSIENT or TRANSRESET flag cannot be set or modified if VM is not running"));
5238
5239	HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.find(aName);
5240	if (it == mHWData->mGuestProperties.end())
5241	{
5242	if (!fDelete)
5243	{
5244	i_setModified(IsModified_MachineData);
5245	mHWData.backupEx();
5246
5247	RTTIMESPEC time;
5248	HWData::GuestProperty prop;
5249	prop.strValue = aValue;
5250	prop.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
5251	prop.mFlags = fFlags;
5252	mHWData->mGuestProperties[aName] = prop;
5253	}
5254	}
5255	else
5256	{
5257	if (it->second.mFlags & (GUEST_PROP_F_RDONLYHOST))
5258	{
5259	hrc = setError(E_ACCESSDENIED, tr("The property '%s' cannot be changed by the host"), aName.c_str());
5260	}
5261	else
5262	{
5263	i_setModified(IsModified_MachineData);
5264	mHWData.backupEx();
5265
5266	/* The backupEx() operation invalidates our iterator,
5267	* so get a new one. */
5268	it = mHWData->mGuestProperties.find(aName);
5269	Assert(it != mHWData->mGuestProperties.end());
5270
5271	if (!fDelete)
5272	{
5273	RTTIMESPEC time;
5274	it->second.strValue = aValue;
5275	it->second.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
5276	it->second.mFlags = fFlags;
5277	}
5278	else
5279	mHWData->mGuestProperties.erase(it);
5280	}
5281	}
5282
5283	if (SUCCEEDED(hrc))
5284	{
5285	alock.release();
5286
5287	mParent->i_onGuestPropertyChanged(mData->mUuid, aName, aValue, aFlags, fDelete);
5288	}
5289	}
5290	catch (std::bad_alloc &)
5291	{
5292	hrc = E_OUTOFMEMORY;
5293	}
5294
5295	return hrc;
5296	}
5297
5298	/**
5299	* Set a property on the VM that that property belongs to.
5300	* @returns E_ACCESSDENIED if the VM process is not available or not
5301	* currently handling queries and the setting should then be done in
5302	* VBoxSVC.
5303	*/
5304	HRESULT Machine::i_setGuestPropertyToVM(const com::Utf8Str &aName, const com::Utf8Str &aValue,
5305	const com::Utf8Str &aFlags, bool fDelete)
5306	{
5307	HRESULT hrc;
5308
5309	try
5310	{
5311	ComPtr<IInternalSessionControl> directControl;
5312	{
5313	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5314	if (mData->mSession.mLockType == LockType_VM)
5315	directControl = mData->mSession.mDirectControl;
5316	}
5317
5318	Bstr dummy1; /* will not be changed (setter) */
5319	Bstr dummy2; /* will not be changed (setter) */
5320	LONG64 dummy64;
5321	if (!directControl)
5322	hrc = E_ACCESSDENIED;
5323	else
5324	/** @todo Fix when adding DeleteGuestProperty(), see defect. */
5325	hrc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr(aValue).raw(), Bstr(aFlags).raw(),
5326	fDelete ? 2 : 1 /* accessMode */,
5327	dummy1.asOutParam(), &dummy64, dummy2.asOutParam());
5328	}
5329	catch (std::bad_alloc &)
5330	{
5331	hrc = E_OUTOFMEMORY;
5332	}
5333
5334	return hrc;
5335	}
5336	#endif // VBOX_WITH_GUEST_PROPS
5337
5338	HRESULT Machine::setGuestProperty(const com::Utf8Str &aProperty, const com::Utf8Str &aValue,
5339	const com::Utf8Str &aFlags)
5340	{
5341	#ifndef VBOX_WITH_GUEST_PROPS
5342	ReturnComNotImplemented();
5343	#else // VBOX_WITH_GUEST_PROPS
5344
5345	int vrc = GuestPropValidateName(aProperty.c_str(), aProperty.length() + 1 /* '\0' */);
5346	AssertRCReturn(vrc, setErrorBoth(E_INVALIDARG, vrc));
5347
5348	vrc = GuestPropValidateValue(aValue.c_str(), aValue.length() + 1 /* '\0' */);
5349	AssertRCReturn(vrc, setErrorBoth(E_INVALIDARG, vrc));
5350
5351	HRESULT hrc = i_setGuestPropertyToVM(aProperty, aValue, aFlags, /* fDelete = */ false);
5352	if (hrc == E_ACCESSDENIED)
5353	/* The VM is not running or the service is not (yet) accessible */
5354	hrc = i_setGuestPropertyToService(aProperty, aValue, aFlags, /* fDelete = */ false);
5355	return hrc;
5356	#endif // VBOX_WITH_GUEST_PROPS
5357	}
5358
5359	HRESULT Machine::setGuestPropertyValue(const com::Utf8Str &aProperty, const com::Utf8Str &aValue)
5360	{
5361	return setGuestProperty(aProperty, aValue, "");
5362	}
5363
5364	HRESULT Machine::deleteGuestProperty(const com::Utf8Str &aName)
5365	{
5366	#ifndef VBOX_WITH_GUEST_PROPS
5367	ReturnComNotImplemented();
5368	#else // VBOX_WITH_GUEST_PROPS
5369	HRESULT hrc = i_setGuestPropertyToVM(aName, "", "", /* fDelete = */ true);
5370	if (hrc == E_ACCESSDENIED)
5371	/* The VM is not running or the service is not (yet) accessible */
5372	hrc = i_setGuestPropertyToService(aName, "", "", /* fDelete = */ true);
5373	return hrc;
5374	#endif // VBOX_WITH_GUEST_PROPS
5375	}
5376
5377	#ifdef VBOX_WITH_GUEST_PROPS
5378	/**
5379	* Enumerate the guest properties in VBoxSVC's internal structures.
5380	*/
5381	HRESULT Machine::i_enumerateGuestPropertiesInService(const com::Utf8Str &aPatterns,
5382	std::vector<com::Utf8Str> &aNames,
5383	std::vector<com::Utf8Str> &aValues,
5384	std::vector<LONG64> &aTimestamps,
5385	std::vector<com::Utf8Str> &aFlags)
5386	{
5387	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5388	Utf8Str strPatterns(aPatterns);
5389
5390	/*
5391	* Look for matching patterns and build up a list.
5392	*/
5393	HWData::GuestPropertyMap propMap;
5394	for (HWData::GuestPropertyMap::const_iterator
5395	it = mHWData->mGuestProperties.begin();
5396	it != mHWData->mGuestProperties.end();
5397	++it)
5398	{
5399	if ( strPatterns.isEmpty()
5400	\|\| RTStrSimplePatternMultiMatch(strPatterns.c_str(),
5401	RTSTR_MAX,
5402	it->first.c_str(),
5403	RTSTR_MAX,
5404	NULL)
5405	)
5406	propMap.insert(*it);
5407	}
5408
5409	alock.release();
5410
5411	/*
5412	* And build up the arrays for returning the property information.
5413	*/
5414	size_t cEntries = propMap.size();
5415
5416	aNames.resize(cEntries);
5417	aValues.resize(cEntries);
5418	aTimestamps.resize(cEntries);
5419	aFlags.resize(cEntries);
5420
5421	size_t i = 0;
5422	for (HWData::GuestPropertyMap::const_iterator
5423	it = propMap.begin();
5424	it != propMap.end();
5425	++it, ++i)
5426	{
5427	aNames[i] = it->first;
5428	int vrc = GuestPropValidateName(aNames[i].c_str(), aNames[i].length() + 1 /* '\0' */);
5429	AssertRCReturn(vrc, setErrorBoth(E_INVALIDARG /bad choice for internal error/, vrc));
5430
5431	aValues[i] = it->second.strValue;
5432	vrc = GuestPropValidateValue(aValues[i].c_str(), aValues[i].length() + 1 /* '\0' */);
5433	AssertRCReturn(vrc, setErrorBoth(E_INVALIDARG /bad choice for internal error/, vrc));
5434
5435	aTimestamps[i] = it->second.mTimestamp;
5436
5437	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
5438	GuestPropWriteFlags(it->second.mFlags, szFlags);
5439	aFlags[i] = szFlags;
5440	}
5441
5442	return S_OK;
5443	}
5444
5445	/**
5446	* Enumerate the properties managed by a VM.
5447	* @returns E_ACCESSDENIED if the VM process is not available or not
5448	* currently handling queries and the setting should then be done in
5449	* VBoxSVC.
5450	*/
5451	HRESULT Machine::i_enumerateGuestPropertiesOnVM(const com::Utf8Str &aPatterns,
5452	std::vector<com::Utf8Str> &aNames,
5453	std::vector<com::Utf8Str> &aValues,
5454	std::vector<LONG64> &aTimestamps,
5455	std::vector<com::Utf8Str> &aFlags)
5456	{
5457	HRESULT hrc;
5458	ComPtr<IInternalSessionControl> directControl;
5459	{
5460	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5461	if (mData->mSession.mLockType == LockType_VM)
5462	directControl = mData->mSession.mDirectControl;
5463	}
5464
5465	com::SafeArray<BSTR> bNames;
5466	com::SafeArray<BSTR> bValues;
5467	com::SafeArray<LONG64> bTimestamps;
5468	com::SafeArray<BSTR> bFlags;
5469
5470	if (!directControl)
5471	hrc = E_ACCESSDENIED;
5472	else
5473	hrc = directControl->EnumerateGuestProperties(Bstr(aPatterns).raw(),
5474	ComSafeArrayAsOutParam(bNames),
5475	ComSafeArrayAsOutParam(bValues),
5476	ComSafeArrayAsOutParam(bTimestamps),
5477	ComSafeArrayAsOutParam(bFlags));
5478	size_t i;
5479	aNames.resize(bNames.size());
5480	for (i = 0; i < bNames.size(); ++i)
5481	aNames[i] = Utf8Str(bNames[i]);
5482	aValues.resize(bValues.size());
5483	for (i = 0; i < bValues.size(); ++i)
5484	aValues[i] = Utf8Str(bValues[i]);
5485	aTimestamps.resize(bTimestamps.size());
5486	for (i = 0; i < bTimestamps.size(); ++i)
5487	aTimestamps[i] = bTimestamps[i];
5488	aFlags.resize(bFlags.size());
5489	for (i = 0; i < bFlags.size(); ++i)
5490	aFlags[i] = Utf8Str(bFlags[i]);
5491
5492	return hrc;
5493	}
5494	#endif // VBOX_WITH_GUEST_PROPS
5495	HRESULT Machine::enumerateGuestProperties(const com::Utf8Str &aPatterns,
5496	std::vector<com::Utf8Str> &aNames,
5497	std::vector<com::Utf8Str> &aValues,
5498	std::vector<LONG64> &aTimestamps,
5499	std::vector<com::Utf8Str> &aFlags)
5500	{
5501	#ifndef VBOX_WITH_GUEST_PROPS
5502	ReturnComNotImplemented();
5503	#else // VBOX_WITH_GUEST_PROPS
5504
5505	HRESULT hrc = i_enumerateGuestPropertiesOnVM(aPatterns, aNames, aValues, aTimestamps, aFlags);
5506
5507	if (hrc == E_ACCESSDENIED)
5508	/* The VM is not running or the service is not (yet) accessible */
5509	hrc = i_enumerateGuestPropertiesInService(aPatterns, aNames, aValues, aTimestamps, aFlags);
5510	return hrc;
5511	#endif // VBOX_WITH_GUEST_PROPS
5512	}
5513
5514	HRESULT Machine::getMediumAttachmentsOfController(const com::Utf8Str &aName,
5515	std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments)
5516	{
5517	MediumAttachmentList atts;
5518
5519	HRESULT hrc = i_getMediumAttachmentsOfController(aName, atts);
5520	if (FAILED(hrc)) return hrc;
5521
5522	aMediumAttachments.resize(atts.size());
5523	size_t i = 0;
5524	for (MediumAttachmentList::const_iterator
5525	it = atts.begin();
5526	it != atts.end();
5527	++it, ++i)
5528	(*it).queryInterfaceTo(aMediumAttachments[i].asOutParam());
5529
5530	return S_OK;
5531	}
5532
5533	HRESULT Machine::getMediumAttachment(const com::Utf8Str &aName,
5534	LONG aControllerPort,
5535	LONG aDevice,
5536	ComPtr<IMediumAttachment> &aAttachment)
5537	{
5538	LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d\n",
5539	aName.c_str(), aControllerPort, aDevice));
5540
5541	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5542
5543	aAttachment = NULL;
5544
5545	ComObjPtr<MediumAttachment> pAttach = i_findAttachment(*mMediumAttachments.data(),
5546	aName,
5547	aControllerPort,
5548	aDevice);
5549	if (pAttach.isNull())
5550	return setError(VBOX_E_OBJECT_NOT_FOUND,
5551	tr("No storage device attached to device slot %d on port %d of controller '%s'"),
5552	aDevice, aControllerPort, aName.c_str());
5553
5554	pAttach.queryInterfaceTo(aAttachment.asOutParam());
5555
5556	return S_OK;
5557	}
5558
5559
5560	HRESULT Machine::addStorageController(const com::Utf8Str &aName,
5561	StorageBus_T aConnectionType,
5562	ComPtr<IStorageController> &aController)
5563	{
5564	if ( (aConnectionType <= StorageBus_Null)
5565	\|\| (aConnectionType > StorageBus_VirtioSCSI))
5566	return setError(E_INVALIDARG,
5567	tr("Invalid connection type: %d"),
5568	aConnectionType);
5569
5570	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5571
5572	HRESULT hrc = i_checkStateDependency(MutableStateDep);
5573	if (FAILED(hrc)) return hrc;
5574
5575	/* try to find one with the name first. */
5576	ComObjPtr<StorageController> ctrl;
5577
5578	hrc = i_getStorageControllerByName(aName, ctrl, false /* aSetError */);
5579	if (SUCCEEDED(hrc))
5580	return setError(VBOX_E_OBJECT_IN_USE,
5581	tr("Storage controller named '%s' already exists"),
5582	aName.c_str());
5583
5584	ctrl.createObject();
5585
5586	/* get a new instance number for the storage controller */
5587	ULONG ulInstance = 0;
5588	bool fBootable = true;
5589	for (StorageControllerList::const_iterator
5590	it = mStorageControllers->begin();
5591	it != mStorageControllers->end();
5592	++it)
5593	{
5594	if ((*it)->i_getStorageBus() == aConnectionType)
5595	{
5596	ULONG ulCurInst = (*it)->i_getInstance();
5597
5598	if (ulCurInst >= ulInstance)
5599	ulInstance = ulCurInst + 1;
5600
5601	/* Only one controller of each type can be marked as bootable. */
5602	if ((*it)->i_getBootable())
5603	fBootable = false;
5604	}
5605	}
5606
5607	hrc = ctrl->init(this, aName, aConnectionType, ulInstance, fBootable);
5608	if (FAILED(hrc)) return hrc;
5609
5610	i_setModified(IsModified_Storage);
5611	mStorageControllers.backup();
5612	mStorageControllers->push_back(ctrl);
5613
5614	ctrl.queryInterfaceTo(aController.asOutParam());
5615
5616	/* inform the direct session if any */
5617	alock.release();
5618	i_onStorageControllerChange(i_getId(), aName);
5619
5620	return S_OK;
5621	}
5622
5623	HRESULT Machine::getStorageControllerByName(const com::Utf8Str &aName,
5624	ComPtr<IStorageController> &aStorageController)
5625	{
5626	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5627
5628	ComObjPtr<StorageController> ctrl;
5629
5630	HRESULT hrc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
5631	if (SUCCEEDED(hrc))
5632	ctrl.queryInterfaceTo(aStorageController.asOutParam());
5633
5634	return hrc;
5635	}
5636
5637	HRESULT Machine::getStorageControllerByInstance(StorageBus_T aConnectionType,
5638	ULONG aInstance,
5639	ComPtr<IStorageController> &aStorageController)
5640	{
5641	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5642
5643	for (StorageControllerList::const_iterator
5644	it = mStorageControllers->begin();
5645	it != mStorageControllers->end();
5646	++it)
5647	{
5648	if ( (*it)->i_getStorageBus() == aConnectionType
5649	&& (*it)->i_getInstance() == aInstance)
5650	{
5651	(*it).queryInterfaceTo(aStorageController.asOutParam());
5652	return S_OK;
5653	}
5654	}
5655
5656	return setError(VBOX_E_OBJECT_NOT_FOUND,
5657	tr("Could not find a storage controller with instance number '%lu'"),
5658	aInstance);
5659	}
5660
5661	HRESULT Machine::setStorageControllerBootable(const com::Utf8Str &aName, BOOL aBootable)
5662	{
5663	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5664
5665	HRESULT hrc = i_checkStateDependency(MutableStateDep);
5666	if (FAILED(hrc)) return hrc;
5667
5668	ComObjPtr<StorageController> ctrl;
5669
5670	hrc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
5671	if (SUCCEEDED(hrc))
5672	{
5673	/* Ensure that only one controller of each type is marked as bootable. */
5674	if (aBootable == TRUE)
5675	{
5676	for (StorageControllerList::const_iterator
5677	it = mStorageControllers->begin();
5678	it != mStorageControllers->end();
5679	++it)
5680	{
5681	ComObjPtr<StorageController> aCtrl = (*it);
5682
5683	if ( (aCtrl->i_getName() != aName)
5684	&& aCtrl->i_getBootable() == TRUE
5685	&& aCtrl->i_getStorageBus() == ctrl->i_getStorageBus()
5686	&& aCtrl->i_getControllerType() == ctrl->i_getControllerType())
5687	{
5688	aCtrl->i_setBootable(FALSE);
5689	break;
5690	}
5691	}
5692	}
5693
5694	if (SUCCEEDED(hrc))
5695	{
5696	ctrl->i_setBootable(aBootable);
5697	i_setModified(IsModified_Storage);
5698	}
5699	}
5700
5701	if (SUCCEEDED(hrc))
5702	{
5703	/* inform the direct session if any */
5704	alock.release();
5705	i_onStorageControllerChange(i_getId(), aName);
5706	}
5707
5708	return hrc;
5709	}
5710
5711	HRESULT Machine::removeStorageController(const com::Utf8Str &aName)
5712	{
5713	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5714
5715	HRESULT hrc = i_checkStateDependency(MutableStateDep);
5716	if (FAILED(hrc)) return hrc;
5717
5718	ComObjPtr<StorageController> ctrl;
5719	hrc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
5720	if (FAILED(hrc)) return hrc;
5721
5722	MediumAttachmentList llDetachedAttachments;
5723	{
5724	/* find all attached devices to the appropriate storage controller and detach them all */
5725	// make a temporary list because detachDevice invalidates iterators into
5726	// mMediumAttachments
5727	MediumAttachmentList llAttachments2 = *mMediumAttachments.data();
5728
5729	for (MediumAttachmentList::const_iterator
5730	it = llAttachments2.begin();
5731	it != llAttachments2.end();
5732	++it)
5733	{
5734	MediumAttachment pAttachTemp = it;
5735
5736	AutoCaller localAutoCaller(pAttachTemp);
5737	if (FAILED(localAutoCaller.hrc())) return localAutoCaller.hrc();
5738
5739	AutoReadLock local_alock(pAttachTemp COMMA_LOCKVAL_SRC_POS);
5740
5741	if (pAttachTemp->i_getControllerName() == aName)
5742	{
5743	llDetachedAttachments.push_back(pAttachTemp);
5744	hrc = i_detachDevice(pAttachTemp, alock, NULL);
5745	if (FAILED(hrc)) return hrc;
5746	}
5747	}
5748	}
5749
5750	/* send event about detached devices before removing parent controller */
5751	for (MediumAttachmentList::const_iterator
5752	it = llDetachedAttachments.begin();
5753	it != llDetachedAttachments.end();
5754	++it)
5755	{
5756	mParent->i_onStorageDeviceChanged(*it, TRUE, FALSE);
5757	}
5758
5759	/* We can remove it now. */
5760	i_setModified(IsModified_Storage);
5761	mStorageControllers.backup();
5762
5763	ctrl->i_unshare();
5764
5765	mStorageControllers->remove(ctrl);
5766
5767	/* inform the direct session if any */
5768	alock.release();
5769	i_onStorageControllerChange(i_getId(), aName);
5770
5771	return S_OK;
5772	}
5773
5774	HRESULT Machine::addUSBController(const com::Utf8Str &aName, USBControllerType_T aType,
5775	ComPtr<IUSBController> &aController)
5776	{
5777	if ( (aType <= USBControllerType_Null)
5778	\|\| (aType >= USBControllerType_Last))
5779	return setError(E_INVALIDARG,
5780	tr("Invalid USB controller type: %d"),
5781	aType);
5782
5783	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5784
5785	HRESULT hrc = i_checkStateDependency(MutableStateDep);
5786	if (FAILED(hrc)) return hrc;
5787
5788	/* try to find one with the same type first. */
5789	ComObjPtr<USBController> ctrl;
5790
5791	hrc = i_getUSBControllerByName(aName, ctrl, false /* aSetError */);
5792	if (SUCCEEDED(hrc))
5793	return setError(VBOX_E_OBJECT_IN_USE,
5794	tr("USB controller named '%s' already exists"),
5795	aName.c_str());
5796
5797	/* Check that we don't exceed the maximum number of USB controllers for the given type. */
5798	ChipsetType_T enmChipsetType;
5799	hrc = mPlatform->getChipsetType(&enmChipsetType);
5800	if (FAILED(hrc))
5801	return hrc;
5802
5803	ULONG maxInstances;
5804	hrc = mPlatformProperties->GetMaxInstancesOfUSBControllerType(enmChipsetType, aType, &maxInstances);
5805	if (FAILED(hrc))
5806	return hrc;
5807
5808	ULONG cInstances = i_getUSBControllerCountByType(aType);
5809	if (cInstances >= maxInstances)
5810	return setError(E_INVALIDARG,
5811	tr("Too many USB controllers of this type"));
5812
5813	ctrl.createObject();
5814
5815	hrc = ctrl->init(this, aName, aType);
5816	if (FAILED(hrc)) return hrc;
5817
5818	i_setModified(IsModified_USB);
5819	mUSBControllers.backup();
5820	mUSBControllers->push_back(ctrl);
5821
5822	ctrl.queryInterfaceTo(aController.asOutParam());
5823
5824	/* inform the direct session if any */
5825	alock.release();
5826	i_onUSBControllerChange();
5827
5828	return S_OK;
5829	}
5830
5831	HRESULT Machine::getUSBControllerByName(const com::Utf8Str &aName, ComPtr<IUSBController> &aController)
5832	{
5833	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5834
5835	ComObjPtr<USBController> ctrl;
5836
5837	HRESULT hrc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
5838	if (SUCCEEDED(hrc))
5839	ctrl.queryInterfaceTo(aController.asOutParam());
5840
5841	return hrc;
5842	}
5843
5844	HRESULT Machine::getUSBControllerCountByType(USBControllerType_T aType,
5845	ULONG *aControllers)
5846	{
5847	if ( (aType <= USBControllerType_Null)
5848	\|\| (aType >= USBControllerType_Last))
5849	return setError(E_INVALIDARG,
5850	tr("Invalid USB controller type: %d"),
5851	aType);
5852
5853	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5854
5855	ComObjPtr<USBController> ctrl;
5856
5857	*aControllers = i_getUSBControllerCountByType(aType);
5858
5859	return S_OK;
5860	}
5861
5862	HRESULT Machine::removeUSBController(const com::Utf8Str &aName)
5863	{
5864
5865	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5866
5867	HRESULT hrc = i_checkStateDependency(MutableStateDep);
5868	if (FAILED(hrc)) return hrc;
5869
5870	ComObjPtr<USBController> ctrl;
5871	hrc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
5872	if (FAILED(hrc)) return hrc;
5873
5874	i_setModified(IsModified_USB);
5875	mUSBControllers.backup();
5876
5877	ctrl->i_unshare();
5878
5879	mUSBControllers->remove(ctrl);
5880
5881	/* inform the direct session if any */
5882	alock.release();
5883	i_onUSBControllerChange();
5884
5885	return S_OK;
5886	}
5887
5888	HRESULT Machine::querySavedGuestScreenInfo(ULONG aScreenId,
5889	ULONG *aOriginX,
5890	ULONG *aOriginY,
5891	ULONG *aWidth,
5892	ULONG *aHeight,
5893	BOOL *aEnabled)
5894	{
5895	uint32_t u32OriginX= 0;
5896	uint32_t u32OriginY= 0;
5897	uint32_t u32Width = 0;
5898	uint32_t u32Height = 0;
5899	uint16_t u16Flags = 0;
5900
5901	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
5902	SsmStream SavedStateStream(mParent, mData->mpKeyStore, mSSData->strStateKeyId, mSSData->strStateKeyStore);
5903	#else
5904	SsmStream SavedStateStream(mParent, NULL /pKeyStore/, Utf8Str::Empty, Utf8Str::Empty);
5905	#endif
5906	int vrc = readSavedGuestScreenInfo(SavedStateStream, mSSData->strStateFilePath, aScreenId,
5907	&u32OriginX, &u32OriginY, &u32Width, &u32Height, &u16Flags);
5908	if (RT_FAILURE(vrc))
5909	{
5910	#ifdef RT_OS_WINDOWS
5911	/* HACK: GUI sets *pfEnabled to 'true' and expects it to stay so if the API fails.
5912	* This works with XPCOM. But Windows COM sets all output parameters to zero.
5913	* So just assign fEnable to TRUE again.
5914	* The right fix would be to change GUI API wrappers to make sure that parameters
5915	* are changed only if API succeeds.
5916	*/
5917	*aEnabled = TRUE;
5918	#endif
5919	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
5920	tr("Saved guest size is not available (%Rrc)"),
5921	vrc);
5922	}
5923
5924	*aOriginX = u32OriginX;
5925	*aOriginY = u32OriginY;
5926	*aWidth = u32Width;
5927	*aHeight = u32Height;
5928	*aEnabled = (u16Flags & VBVA_SCREEN_F_DISABLED) == 0;
5929
5930	return S_OK;
5931	}
5932
5933	HRESULT Machine::readSavedThumbnailToArray(ULONG aScreenId, BitmapFormat_T aBitmapFormat,
5934	ULONG aWidth, ULONG aHeight, std::vector<BYTE> &aData)
5935	{
5936	if (aScreenId != 0)
5937	return E_NOTIMPL;
5938
5939	if ( aBitmapFormat != BitmapFormat_BGR0
5940	&& aBitmapFormat != BitmapFormat_BGRA
5941	&& aBitmapFormat != BitmapFormat_RGBA
5942	&& aBitmapFormat != BitmapFormat_PNG)
5943	return setError(E_NOTIMPL,
5944	tr("Unsupported saved thumbnail format 0x%08X"), aBitmapFormat);
5945
5946	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5947
5948	uint8_t *pu8Data = NULL;
5949	uint32_t cbData = 0;
5950	uint32_t u32Width = 0;
5951	uint32_t u32Height = 0;
5952
5953	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
5954	SsmStream SavedStateStream(mParent, mData->mpKeyStore, mSSData->strStateKeyId, mSSData->strStateKeyStore);
5955	#else
5956	SsmStream SavedStateStream(mParent, NULL /pKeyStore/, Utf8Str::Empty, Utf8Str::Empty);
5957	#endif
5958	int vrc = readSavedDisplayScreenshot(SavedStateStream, mSSData->strStateFilePath, 0 /* u32Type */,
5959	&pu8Data, &cbData, &u32Width, &u32Height);
5960	if (RT_FAILURE(vrc))
5961	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
5962	tr("Saved thumbnail data is not available (%Rrc)"),
5963	vrc);
5964
5965	HRESULT hrc = S_OK;
5966
5967	*aWidth = u32Width;
5968	*aHeight = u32Height;
5969
5970	if (cbData > 0)
5971	{
5972	/* Convert pixels to the format expected by the API caller. */
5973	if (aBitmapFormat == BitmapFormat_BGR0)
5974	{
5975	/* [0] B, [1] G, [2] R, [3] 0. */
5976	aData.resize(cbData);
5977	memcpy(&aData.front(), pu8Data, cbData);
5978	}
5979	else if (aBitmapFormat == BitmapFormat_BGRA)
5980	{
5981	/* [0] B, [1] G, [2] R, [3] A. */
5982	aData.resize(cbData);
5983	for (uint32_t i = 0; i < cbData; i += 4)
5984	{
5985	aData[i] = pu8Data[i];
5986	aData[i + 1] = pu8Data[i + 1];
5987	aData[i + 2] = pu8Data[i + 2];
5988	aData[i + 3] = 0xff;
5989	}
5990	}
5991	else if (aBitmapFormat == BitmapFormat_RGBA)
5992	{
5993	/* [0] R, [1] G, [2] B, [3] A. */
5994	aData.resize(cbData);
5995	for (uint32_t i = 0; i < cbData; i += 4)
5996	{
5997	aData[i] = pu8Data[i + 2];
5998	aData[i + 1] = pu8Data[i + 1];
5999	aData[i + 2] = pu8Data[i];
6000	aData[i + 3] = 0xff;
6001	}
6002	}
6003	else if (aBitmapFormat == BitmapFormat_PNG)
6004	{
6005	uint8_t *pu8PNG = NULL;
6006	uint32_t cbPNG = 0;
6007	uint32_t cxPNG = 0;
6008	uint32_t cyPNG = 0;
6009
6010	vrc = DisplayMakePNG(pu8Data, u32Width, u32Height, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
6011
6012	if (RT_SUCCESS(vrc))
6013	{
6014	aData.resize(cbPNG);
6015	if (cbPNG)
6016	memcpy(&aData.front(), pu8PNG, cbPNG);
6017	}
6018	else
6019	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not convert saved thumbnail to PNG (%Rrc)"), vrc);
6020
6021	RTMemFree(pu8PNG);
6022	}
6023	}
6024
6025	freeSavedDisplayScreenshot(pu8Data);
6026
6027	return hrc;
6028	}
6029
6030	HRESULT Machine::querySavedScreenshotInfo(ULONG aScreenId,
6031	ULONG *aWidth,
6032	ULONG *aHeight,
6033	std::vector<BitmapFormat_T> &aBitmapFormats)
6034	{
6035	if (aScreenId != 0)
6036	return E_NOTIMPL;
6037
6038	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6039
6040	uint8_t *pu8Data = NULL;
6041	uint32_t cbData = 0;
6042	uint32_t u32Width = 0;
6043	uint32_t u32Height = 0;
6044
6045	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
6046	SsmStream SavedStateStream(mParent, mData->mpKeyStore, mSSData->strStateKeyId, mSSData->strStateKeyStore);
6047	#else
6048	SsmStream SavedStateStream(mParent, NULL /pKeyStore/, Utf8Str::Empty, Utf8Str::Empty);
6049	#endif
6050	int vrc = readSavedDisplayScreenshot(SavedStateStream, mSSData->strStateFilePath, 1 /* u32Type */,
6051	&pu8Data, &cbData, &u32Width, &u32Height);
6052
6053	if (RT_FAILURE(vrc))
6054	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
6055	tr("Saved screenshot data is not available (%Rrc)"),
6056	vrc);
6057
6058	*aWidth = u32Width;
6059	*aHeight = u32Height;
6060	aBitmapFormats.resize(1);
6061	aBitmapFormats[0] = BitmapFormat_PNG;
6062
6063	freeSavedDisplayScreenshot(pu8Data);
6064
6065	return S_OK;
6066	}
6067
6068	HRESULT Machine::readSavedScreenshotToArray(ULONG aScreenId,
6069	BitmapFormat_T aBitmapFormat,
6070	ULONG *aWidth,
6071	ULONG *aHeight,
6072	std::vector<BYTE> &aData)
6073	{
6074	if (aScreenId != 0)
6075	return E_NOTIMPL;
6076
6077	if (aBitmapFormat != BitmapFormat_PNG)
6078	return E_NOTIMPL;
6079
6080	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6081
6082	uint8_t *pu8Data = NULL;
6083	uint32_t cbData = 0;
6084	uint32_t u32Width = 0;
6085	uint32_t u32Height = 0;
6086
6087	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
6088	SsmStream SavedStateStream(mParent, mData->mpKeyStore, mSSData->strStateKeyId, mSSData->strStateKeyStore);
6089	#else
6090	SsmStream SavedStateStream(mParent, NULL /pKeyStore/, Utf8Str::Empty, Utf8Str::Empty);
6091	#endif
6092	int vrc = readSavedDisplayScreenshot(SavedStateStream, mSSData->strStateFilePath, 1 /* u32Type */,
6093	&pu8Data, &cbData, &u32Width, &u32Height);
6094
6095	if (RT_FAILURE(vrc))
6096	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
6097	tr("Saved screenshot thumbnail data is not available (%Rrc)"),
6098	vrc);
6099
6100	*aWidth = u32Width;
6101	*aHeight = u32Height;
6102
6103	aData.resize(cbData);
6104	if (cbData)
6105	memcpy(&aData.front(), pu8Data, cbData);
6106
6107	freeSavedDisplayScreenshot(pu8Data);
6108
6109	return S_OK;
6110	}
6111
6112	HRESULT Machine::hotPlugCPU(ULONG aCpu)
6113	{
6114	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6115
6116	if (!mHWData->mCPUHotPlugEnabled)
6117	return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
6118
6119	if (aCpu >= mHWData->mCPUCount)
6120	return setError(E_INVALIDARG, tr("CPU id exceeds number of possible CPUs [0:%lu]"), mHWData->mCPUCount-1);
6121
6122	if (mHWData->mCPUAttached[aCpu])
6123	return setError(VBOX_E_OBJECT_IN_USE, tr("CPU %lu is already attached"), aCpu);
6124
6125	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
6126	if (FAILED(hrc)) return hrc;
6127
6128	alock.release();
6129	hrc = i_onCPUChange(aCpu, false);
6130	alock.acquire();
6131	if (FAILED(hrc)) return hrc;
6132
6133	i_setModified(IsModified_MachineData);
6134	mHWData.backup();
6135	mHWData->mCPUAttached[aCpu] = true;
6136
6137	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
6138	if (Global::IsOnline(mData->mMachineState))
6139	i_saveSettings(NULL, alock);
6140
6141	return S_OK;
6142	}
6143
6144	HRESULT Machine::hotUnplugCPU(ULONG aCpu)
6145	{
6146	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6147
6148	if (!mHWData->mCPUHotPlugEnabled)
6149	return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
6150
6151	if (aCpu >= SchemaDefs::MaxCPUCount)
6152	return setError(E_INVALIDARG,
6153	tr("CPU index exceeds maximum CPU count (must be in range [0:%lu])"),
6154	SchemaDefs::MaxCPUCount);
6155
6156	if (!mHWData->mCPUAttached[aCpu])
6157	return setError(VBOX_E_OBJECT_NOT_FOUND, tr("CPU %lu is not attached"), aCpu);
6158
6159	/* CPU 0 can't be detached */
6160	if (aCpu == 0)
6161	return setError(E_INVALIDARG, tr("It is not possible to detach CPU 0"));
6162
6163	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
6164	if (FAILED(hrc)) return hrc;
6165
6166	alock.release();
6167	hrc = i_onCPUChange(aCpu, true);
6168	alock.acquire();
6169	if (FAILED(hrc)) return hrc;
6170
6171	i_setModified(IsModified_MachineData);
6172	mHWData.backup();
6173	mHWData->mCPUAttached[aCpu] = false;
6174
6175	/** Save settings if online - @todo why is this required? -- @bugref{6818} */
6176	if (Global::IsOnline(mData->mMachineState))
6177	i_saveSettings(NULL, alock);
6178
6179	return S_OK;
6180	}
6181
6182	HRESULT Machine::getCPUStatus(ULONG aCpu, BOOL *aAttached)
6183	{
6184	*aAttached = false;
6185
6186	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6187
6188	/* If hotplug is enabled the CPU is always enabled. */
6189	if (!mHWData->mCPUHotPlugEnabled)
6190	{
6191	if (aCpu < mHWData->mCPUCount)
6192	*aAttached = true;
6193	}
6194	else
6195	{
6196	if (aCpu < SchemaDefs::MaxCPUCount)
6197	*aAttached = mHWData->mCPUAttached[aCpu];
6198	}
6199
6200	return S_OK;
6201	}
6202
6203	HRESULT Machine::queryLogFilename(ULONG aIdx, com::Utf8Str &aFilename)
6204	{
6205	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6206
6207	Utf8Str log = i_getLogFilename(aIdx);
6208	if (!RTFileExists(log.c_str()))
6209	log.setNull();
6210	aFilename = log;
6211
6212	return S_OK;
6213	}
6214
6215	HRESULT Machine::readLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, std::vector<BYTE> &aData)
6216	{
6217	if (aSize < 0)
6218	return setError(E_INVALIDARG, tr("The size argument (%lld) is negative"), aSize);
6219
6220	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6221
6222	HRESULT hrc = S_OK;
6223	Utf8Str log = i_getLogFilename(aIdx);
6224
6225	/* do not unnecessarily hold the lock while doing something which does
6226	* not need the lock and potentially takes a long time. */
6227	alock.release();
6228
6229	/* Limit the chunk size to 512K. Gives good performance over (XP)COM, and
6230	* keeps the SOAP reply size under 1M for the webservice (we're using
6231	* base64 encoded strings for binary data for years now, avoiding the
6232	* expansion of each byte array element to approx. 25 bytes of XML. */
6233	size_t cbData = (size_t)RT_MIN(aSize, _512K);
6234	aData.resize(cbData);
6235
6236	int vrc = VINF_SUCCESS;
6237	RTVFSIOSTREAM hVfsIosLog = NIL_RTVFSIOSTREAM;
6238
6239	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
6240	if (mData->mstrLogKeyId.isNotEmpty() && mData->mstrLogKeyStore.isNotEmpty())
6241	{
6242	PCVBOXCRYPTOIF pCryptoIf = NULL;
6243	hrc = i_getVirtualBox()->i_retainCryptoIf(&pCryptoIf);
6244	if (SUCCEEDED(hrc))
6245	{
6246	alock.acquire();
6247
6248	SecretKey *pKey = NULL;
6249	vrc = mData->mpKeyStore->retainSecretKey(mData->mstrLogKeyId, &pKey);
6250	alock.release();
6251
6252	if (RT_SUCCESS(vrc))
6253	{
6254	vrc = RTVfsIoStrmOpenNormal(log.c_str(), RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE, &hVfsIosLog);
6255	if (RT_SUCCESS(vrc))
6256	{
6257	RTVFSIOSTREAM hVfsIosLogDec = NIL_RTVFSIOSTREAM;
6258	vrc = pCryptoIf->pfnCryptoIoStrmFromVfsIoStrmDecrypt(hVfsIosLog, mData->mstrLogKeyStore.c_str(),
6259	(const char *)pKey->getKeyBuffer(), &hVfsIosLogDec);
6260	if (RT_SUCCESS(vrc))
6261	{
6262	RTVfsIoStrmRelease(hVfsIosLog);
6263	hVfsIosLog = hVfsIosLogDec;
6264	}
6265	}
6266
6267	pKey->release();
6268	}
6269
6270	i_getVirtualBox()->i_releaseCryptoIf(pCryptoIf);
6271	}
6272	}
6273	else
6274	vrc = RTVfsIoStrmOpenNormal(log.c_str(), RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE, &hVfsIosLog);
6275	#else
6276	vrc = RTVfsIoStrmOpenNormal(log.c_str(), RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE, &hVfsIosLog);
6277	#endif
6278	if (RT_SUCCESS(vrc))
6279	{
6280	vrc = RTVfsIoStrmReadAt(hVfsIosLog, aOffset,
6281	cbData ? &aData.front() : NULL, cbData,
6282	true /fBlocking/, &cbData);
6283	if (RT_SUCCESS(vrc))
6284	aData.resize(cbData);
6285	else
6286	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not read log file '%s' (%Rrc)"), log.c_str(), vrc);
6287
6288	RTVfsIoStrmRelease(hVfsIosLog);
6289	}
6290	else
6291	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not open log file '%s' (%Rrc)"), log.c_str(), vrc);
6292
6293	if (FAILED(hrc))
6294	aData.resize(0);
6295
6296	return hrc;
6297	}
6298
6299
6300	/**
6301	* Currently this method doesn't attach device to the running VM,
6302	* just makes sure it's plugged on next VM start.
6303	*/
6304	HRESULT Machine::attachHostPCIDevice(LONG aHostAddress, LONG aDesiredGuestAddress, BOOL /* aTryToUnbind */)
6305	{
6306	// lock scope
6307	{
6308	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6309
6310	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6311	if (FAILED(hrc)) return hrc;
6312
6313	ChipsetType_T aChipset = ChipsetType_PIIX3;
6314	hrc = mPlatform->COMGETTER(ChipsetType)(&aChipset);
6315	if (FAILED(hrc)) return hrc;
6316
6317	if (aChipset != ChipsetType_ICH9) /** @todo BUGBUG ASSUMES x86! */
6318	{
6319	return setError(E_INVALIDARG,
6320	tr("Host PCI attachment only supported with ICH9 chipset"));
6321	}
6322
6323	// check if device with this host PCI address already attached
6324	for (HWData::PCIDeviceAssignmentList::const_iterator
6325	it = mHWData->mPCIDeviceAssignments.begin();
6326	it != mHWData->mPCIDeviceAssignments.end();
6327	++it)
6328	{
6329	LONG iHostAddress = -1;
6330	ComPtr<PCIDeviceAttachment> pAttach;
6331	pAttach = *it;
6332	pAttach->COMGETTER(HostAddress)(&iHostAddress);
6333	if (iHostAddress == aHostAddress)
6334	return setError(E_INVALIDARG,
6335	tr("Device with host PCI address already attached to this VM"));
6336	}
6337
6338	ComObjPtr<PCIDeviceAttachment> pda;
6339	char name[32];
6340
6341	RTStrPrintf(name, sizeof(name), "host%02x:%02x.%x", (aHostAddress>>8) & 0xff,
6342	(aHostAddress & 0xf8) >> 3, aHostAddress & 7);
6343	pda.createObject();
6344	pda->init(this, name, aHostAddress, aDesiredGuestAddress, TRUE);
6345	i_setModified(IsModified_MachineData);
6346	mHWData.backup();
6347	mHWData->mPCIDeviceAssignments.push_back(pda);
6348	}
6349
6350	return S_OK;
6351	}
6352
6353	/**
6354	* Currently this method doesn't detach device from the running VM,
6355	* just makes sure it's not plugged on next VM start.
6356	*/
6357	HRESULT Machine::detachHostPCIDevice(LONG aHostAddress)
6358	{
6359	ComObjPtr<PCIDeviceAttachment> pAttach;
6360	bool fRemoved = false;
6361	HRESULT hrc;
6362
6363	// lock scope
6364	{
6365	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6366
6367	hrc = i_checkStateDependency(MutableStateDep);
6368	if (FAILED(hrc)) return hrc;
6369
6370	for (HWData::PCIDeviceAssignmentList::const_iterator
6371	it = mHWData->mPCIDeviceAssignments.begin();
6372	it != mHWData->mPCIDeviceAssignments.end();
6373	++it)
6374	{
6375	LONG iHostAddress = -1;
6376	pAttach = *it;
6377	pAttach->COMGETTER(HostAddress)(&iHostAddress);
6378	if (iHostAddress != -1 && iHostAddress == aHostAddress)
6379	{
6380	i_setModified(IsModified_MachineData);
6381	mHWData.backup();
6382	mHWData->mPCIDeviceAssignments.remove(pAttach);
6383	fRemoved = true;
6384	break;
6385	}
6386	}
6387	}
6388
6389
6390	/* Fire event outside of the lock */
6391	if (fRemoved)
6392	{
6393	Assert(!pAttach.isNull());
6394	ComPtr<IEventSource> es;
6395	hrc = mParent->COMGETTER(EventSource)(es.asOutParam());
6396	Assert(SUCCEEDED(hrc));
6397	Bstr mid;
6398	hrc = this->COMGETTER(Id)(mid.asOutParam());
6399	Assert(SUCCEEDED(hrc));
6400	::FireHostPCIDevicePlugEvent(es, mid.raw(), false /* unplugged /, true / success */, pAttach, NULL);
6401	}
6402
6403	return fRemoved ? S_OK : setError(VBOX_E_OBJECT_NOT_FOUND,
6404	tr("No host PCI device %08x attached"),
6405	aHostAddress
6406	);
6407	}
6408
6409	HRESULT Machine::getPCIDeviceAssignments(std::vector<ComPtr<IPCIDeviceAttachment> > &aPCIDeviceAssignments)
6410	{
6411	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6412
6413	aPCIDeviceAssignments.resize(mHWData->mPCIDeviceAssignments.size());
6414	size_t i = 0;
6415	for (std::list<ComObjPtr<PCIDeviceAttachment> >::const_iterator
6416	it = mHWData->mPCIDeviceAssignments.begin();
6417	it != mHWData->mPCIDeviceAssignments.end();
6418	++it, ++i)
6419	(*it).queryInterfaceTo(aPCIDeviceAssignments[i].asOutParam());
6420
6421	return S_OK;
6422	}
6423
6424	HRESULT Machine::getBandwidthControl(ComPtr<IBandwidthControl> &aBandwidthControl)
6425	{
6426	mBandwidthControl.queryInterfaceTo(aBandwidthControl.asOutParam());
6427
6428	return S_OK;
6429	}
6430
6431	HRESULT Machine::getTracingEnabled(BOOL *aTracingEnabled)
6432	{
6433	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6434
6435	*aTracingEnabled = mHWData->mDebugging.fTracingEnabled;
6436
6437	return S_OK;
6438	}
6439
6440	HRESULT Machine::setTracingEnabled(BOOL aTracingEnabled)
6441	{
6442	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6443	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6444	if (SUCCEEDED(hrc))
6445	{
6446	hrc = mHWData.backupEx();
6447	if (SUCCEEDED(hrc))
6448	{
6449	i_setModified(IsModified_MachineData);
6450	mHWData->mDebugging.fTracingEnabled = aTracingEnabled != FALSE;
6451	}
6452	}
6453	return hrc;
6454	}
6455
6456	HRESULT Machine::getTracingConfig(com::Utf8Str &aTracingConfig)
6457	{
6458	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6459	aTracingConfig = mHWData->mDebugging.strTracingConfig;
6460	return S_OK;
6461	}
6462
6463	HRESULT Machine::setTracingConfig(const com::Utf8Str &aTracingConfig)
6464	{
6465	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6466	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6467	if (SUCCEEDED(hrc))
6468	{
6469	hrc = mHWData.backupEx();
6470	if (SUCCEEDED(hrc))
6471	{
6472	mHWData->mDebugging.strTracingConfig = aTracingConfig;
6473	if (SUCCEEDED(hrc))
6474	i_setModified(IsModified_MachineData);
6475	}
6476	}
6477	return hrc;
6478	}
6479
6480	HRESULT Machine::getAllowTracingToAccessVM(BOOL *aAllowTracingToAccessVM)
6481	{
6482	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6483
6484	*aAllowTracingToAccessVM = mHWData->mDebugging.fAllowTracingToAccessVM;
6485
6486	return S_OK;
6487	}
6488
6489	HRESULT Machine::setAllowTracingToAccessVM(BOOL aAllowTracingToAccessVM)
6490	{
6491	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6492	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6493	if (SUCCEEDED(hrc))
6494	{
6495	hrc = mHWData.backupEx();
6496	if (SUCCEEDED(hrc))
6497	{
6498	i_setModified(IsModified_MachineData);
6499	mHWData->mDebugging.fAllowTracingToAccessVM = aAllowTracingToAccessVM != FALSE;
6500	}
6501	}
6502	return hrc;
6503	}
6504
6505	HRESULT Machine::getAutostartEnabled(BOOL *aAutostartEnabled)
6506	{
6507	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6508
6509	*aAutostartEnabled = mHWData->mAutostart.fAutostartEnabled;
6510
6511	return S_OK;
6512	}
6513
6514	HRESULT Machine::setAutostartEnabled(BOOL aAutostartEnabled)
6515	{
6516	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6517
6518	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
6519	if ( SUCCEEDED(hrc)
6520	&& mHWData->mAutostart.fAutostartEnabled != !!aAutostartEnabled)
6521	{
6522	AutostartDb *autostartDb = mParent->i_getAutostartDb();
6523	int vrc;
6524
6525	if (aAutostartEnabled)
6526	vrc = autostartDb->addAutostartVM(mUserData->s.strName.c_str());
6527	else
6528	vrc = autostartDb->removeAutostartVM(mUserData->s.strName.c_str());
6529
6530	if (RT_SUCCESS(vrc))
6531	{
6532	hrc = mHWData.backupEx();
6533	if (SUCCEEDED(hrc))
6534	{
6535	i_setModified(IsModified_MachineData);
6536	mHWData->mAutostart.fAutostartEnabled = aAutostartEnabled != FALSE;
6537	}
6538	}
6539	else if (vrc == VERR_NOT_SUPPORTED)
6540	hrc = setError(VBOX_E_NOT_SUPPORTED,
6541	tr("The VM autostart feature is not supported on this platform"));
6542	else if (vrc == VERR_PATH_NOT_FOUND)
6543	hrc = setError(E_FAIL,
6544	tr("The path to the autostart database is not set"));
6545	else
6546	hrc = setError(E_UNEXPECTED,
6547	aAutostartEnabled ?
6548	tr("Adding machine '%s' to the autostart database failed with %Rrc") :
6549	tr("Removing machine '%s' from the autostart database failed with %Rrc"),
6550	mUserData->s.strName.c_str(), vrc);
6551	}
6552	return hrc;
6553	}
6554
6555	HRESULT Machine::getAutostartDelay(ULONG *aAutostartDelay)
6556	{
6557	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6558
6559	*aAutostartDelay = mHWData->mAutostart.uAutostartDelay;
6560
6561	return S_OK;
6562	}
6563
6564	HRESULT Machine::setAutostartDelay(ULONG aAutostartDelay)
6565	{
6566	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6567	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
6568	if (SUCCEEDED(hrc))
6569	{
6570	hrc = mHWData.backupEx();
6571	if (SUCCEEDED(hrc))
6572	{
6573	i_setModified(IsModified_MachineData);
6574	mHWData->mAutostart.uAutostartDelay = aAutostartDelay;
6575	}
6576	}
6577	return hrc;
6578	}
6579
6580	HRESULT Machine::getAutostopType(AutostopType_T *aAutostopType)
6581	{
6582	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6583
6584	*aAutostopType = mHWData->mAutostart.enmAutostopType;
6585
6586	return S_OK;
6587	}
6588
6589	HRESULT Machine::setAutostopType(AutostopType_T aAutostopType)
6590	{
6591	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6592	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
6593	if ( SUCCEEDED(hrc)
6594	&& mHWData->mAutostart.enmAutostopType != aAutostopType)
6595	{
6596	AutostartDb *autostartDb = mParent->i_getAutostartDb();
6597	int vrc;
6598
6599	if (aAutostopType != AutostopType_Disabled)
6600	vrc = autostartDb->addAutostopVM(mUserData->s.strName.c_str());
6601	else
6602	vrc = autostartDb->removeAutostopVM(mUserData->s.strName.c_str());
6603
6604	if (RT_SUCCESS(vrc))
6605	{
6606	hrc = mHWData.backupEx();
6607	if (SUCCEEDED(hrc))
6608	{
6609	i_setModified(IsModified_MachineData);
6610	mHWData->mAutostart.enmAutostopType = aAutostopType;
6611	}
6612	}
6613	else if (vrc == VERR_NOT_SUPPORTED)
6614	hrc = setError(VBOX_E_NOT_SUPPORTED,
6615	tr("The VM autostop feature is not supported on this platform"));
6616	else if (vrc == VERR_PATH_NOT_FOUND)
6617	hrc = setError(E_FAIL,
6618	tr("The path to the autostart database is not set"));
6619	else
6620	hrc = setError(E_UNEXPECTED,
6621	aAutostopType != AutostopType_Disabled ?
6622	tr("Adding machine '%s' to the autostop database failed with %Rrc") :
6623	tr("Removing machine '%s' from the autostop database failed with %Rrc"),
6624	mUserData->s.strName.c_str(), vrc);
6625	}
6626	return hrc;
6627	}
6628
6629	HRESULT Machine::getDefaultFrontend(com::Utf8Str &aDefaultFrontend)
6630	{
6631	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6632
6633	aDefaultFrontend = mHWData->mDefaultFrontend;
6634
6635	return S_OK;
6636	}
6637
6638	HRESULT Machine::setDefaultFrontend(const com::Utf8Str &aDefaultFrontend)
6639	{
6640	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6641	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
6642	if (SUCCEEDED(hrc))
6643	{
6644	hrc = mHWData.backupEx();
6645	if (SUCCEEDED(hrc))
6646	{
6647	i_setModified(IsModified_MachineData);
6648	mHWData->mDefaultFrontend = aDefaultFrontend;
6649	}
6650	}
6651	return hrc;
6652	}
6653
6654	HRESULT Machine::getIcon(std::vector<BYTE> &aIcon)
6655	{
6656	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6657	size_t cbIcon = mUserData->s.ovIcon.size();
6658	aIcon.resize(cbIcon);
6659	if (cbIcon)
6660	memcpy(&aIcon.front(), &mUserData->s.ovIcon[0], cbIcon);
6661	return S_OK;
6662	}
6663
6664	HRESULT Machine::setIcon(const std::vector<BYTE> &aIcon)
6665	{
6666	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6667	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
6668	if (SUCCEEDED(hrc))
6669	{
6670	i_setModified(IsModified_MachineData);
6671	mUserData.backup();
6672	size_t cbIcon = aIcon.size();
6673	mUserData->s.ovIcon.resize(cbIcon);
6674	if (cbIcon)
6675	memcpy(&mUserData->s.ovIcon[0], &aIcon.front(), cbIcon);
6676	}
6677	return hrc;
6678	}
6679
6680	HRESULT Machine::getUSBProxyAvailable(BOOL *aUSBProxyAvailable)
6681	{
6682	#ifdef VBOX_WITH_USB
6683	*aUSBProxyAvailable = true;
6684	#else
6685	*aUSBProxyAvailable = false;
6686	#endif
6687	return S_OK;
6688	}
6689
6690	HRESULT Machine::getVMProcessPriority(VMProcPriority_T *aVMProcessPriority)
6691	{
6692	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6693
6694	*aVMProcessPriority = mUserData->s.enmVMPriority;
6695
6696	return S_OK;
6697	}
6698
6699	HRESULT Machine::setVMProcessPriority(VMProcPriority_T aVMProcessPriority)
6700	{
6701	RT_NOREF(aVMProcessPriority);
6702	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6703	HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
6704	if (SUCCEEDED(hrc))
6705	{
6706	hrc = mUserData.backupEx();
6707	if (SUCCEEDED(hrc))
6708	{
6709	i_setModified(IsModified_MachineData);
6710	mUserData->s.enmVMPriority = aVMProcessPriority;
6711	}
6712	}
6713	alock.release();
6714	if (SUCCEEDED(hrc))
6715	hrc = i_onVMProcessPriorityChange(aVMProcessPriority);
6716	return hrc;
6717	}
6718
6719	HRESULT Machine::getVMExecutionEngine(VMExecutionEngine_T *aVMExecutionEngine)
6720	{
6721	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6722
6723	*aVMExecutionEngine = mUserData->s.enmExecEngine;
6724
6725	return S_OK;
6726	}
6727
6728	HRESULT Machine::setVMExecutionEngine(VMExecutionEngine_T aVMExecutionEngine)
6729	{
6730	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6731	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
6732	if (SUCCEEDED(hrc))
6733	{
6734	hrc = mUserData.backupEx();
6735	if (SUCCEEDED(hrc))
6736	{
6737	i_setModified(IsModified_MachineData);
6738	mUserData->s.enmExecEngine = aVMExecutionEngine;
6739	}
6740	}
6741	return hrc;
6742	}
6743
6744	HRESULT Machine::cloneTo(const ComPtr<IMachine> &aTarget, CloneMode_T aMode, const std::vector<CloneOptions_T> &aOptions,
6745	ComPtr<IProgress> &aProgress)
6746	{
6747	ComObjPtr<Progress> pP;
6748	Progress *ppP = pP;
6749	IProgress iP = static_cast<IProgress >(ppP);
6750	IProgress **pProgress = &iP;
6751
6752	IMachine *pTarget = aTarget;
6753
6754	/* Convert the options. */
6755	RTCList<CloneOptions_T> optList;
6756	if (aOptions.size())
6757	for (size_t i = 0; i < aOptions.size(); ++i)
6758	optList.append(aOptions[i]);
6759
6760	if (optList.contains(CloneOptions_Link))
6761	{
6762	if (!i_isSnapshotMachine())
6763	return setError(E_INVALIDARG,
6764	tr("Linked clone can only be created from a snapshot"));
6765	if (aMode != CloneMode_MachineState)
6766	return setError(E_INVALIDARG,
6767	tr("Linked clone can only be created for a single machine state"));
6768	}
6769	AssertReturn(!(optList.contains(CloneOptions_KeepAllMACs) && optList.contains(CloneOptions_KeepNATMACs)), E_INVALIDARG);
6770
6771	MachineCloneVM pWorker = new MachineCloneVM(this, static_cast<Machine>(pTarget), aMode, optList);
6772
6773	HRESULT hrc = pWorker->start(pProgress);
6774
6775	pP = static_cast<Progress >(pProgress);
6776	pP.queryInterfaceTo(aProgress.asOutParam());
6777
6778	return hrc;
6779
6780	}
6781
6782	HRESULT Machine::moveTo(const com::Utf8Str &aTargetPath,
6783	const com::Utf8Str &aType,
6784	ComPtr<IProgress> &aProgress)
6785	{
6786	LogFlowThisFuncEnter();
6787
6788	ComObjPtr<Progress> ptrProgress;
6789	HRESULT hrc = ptrProgress.createObject();
6790	if (SUCCEEDED(hrc))
6791	{
6792	com::Utf8Str strDefaultPath;
6793	if (aTargetPath.isEmpty())
6794	i_calculateFullPath(".", strDefaultPath);
6795
6796	/* Initialize our worker task */
6797	MachineMoveVM *pTask = NULL;
6798	try
6799	{
6800	pTask = new MachineMoveVM(this, aTargetPath.isEmpty() ? strDefaultPath : aTargetPath, aType, ptrProgress);
6801	}
6802	catch (std::bad_alloc &)
6803	{
6804	return E_OUTOFMEMORY;
6805	}
6806
6807	hrc = pTask->init();//no exceptions are thrown
6808
6809	if (SUCCEEDED(hrc))
6810	{
6811	hrc = pTask->createThread();
6812	pTask = NULL; /* Consumed by createThread(). */
6813	if (SUCCEEDED(hrc))
6814	ptrProgress.queryInterfaceTo(aProgress.asOutParam());
6815	else
6816	setError(hrc, tr("Failed to create a worker thread for the MachineMoveVM task"));
6817	}
6818	else
6819	delete pTask;
6820	}
6821
6822	LogFlowThisFuncLeave();
6823	return hrc;
6824
6825	}
6826
6827	HRESULT Machine::saveState(ComPtr<IProgress> &aProgress)
6828	{
6829	NOREF(aProgress);
6830	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6831
6832	// This check should always fail.
6833	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6834	if (FAILED(hrc)) return hrc;
6835
6836	AssertFailedReturn(E_NOTIMPL);
6837	}
6838
6839	HRESULT Machine::adoptSavedState(const com::Utf8Str &aSavedStateFile)
6840	{
6841	NOREF(aSavedStateFile);
6842	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6843
6844	// This check should always fail.
6845	HRESULT hrc = i_checkStateDependency(MutableStateDep);
6846	if (FAILED(hrc)) return hrc;
6847
6848	AssertFailedReturn(E_NOTIMPL);
6849	}
6850
6851	HRESULT Machine::discardSavedState(BOOL aFRemoveFile)
6852	{
6853	NOREF(aFRemoveFile);
6854	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6855
6856	// This check should always fail.
6857	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
6858	if (FAILED(hrc)) return hrc;
6859
6860	AssertFailedReturn(E_NOTIMPL);
6861	}
6862
6863	// public methods for internal purposes
6864	/////////////////////////////////////////////////////////////////////////////
6865
6866	/**
6867	* Adds the given IsModified_* flag to the dirty flags of the machine.
6868	* This must be called either during i_loadSettings or under the machine write lock.
6869	* @param fl Flag
6870	* @param fAllowStateModification If state modifications are allowed.
6871	*/
6872	void Machine::i_setModified(uint32_t fl, bool fAllowStateModification /* = true */)
6873	{
6874	mData->flModifications \|= fl;
6875	if (fAllowStateModification && i_isStateModificationAllowed())
6876	mData->mCurrentStateModified = true;
6877	}
6878
6879	/**
6880	* Adds the given IsModified_* flag to the dirty flags of the machine, taking
6881	* care of the write locking.
6882	*
6883	* @param fModification The flag to add.
6884	* @param fAllowStateModification If state modifications are allowed.
6885	*/
6886	void Machine::i_setModifiedLock(uint32_t fModification, bool fAllowStateModification /* = true */)
6887	{
6888	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6889	i_setModified(fModification, fAllowStateModification);
6890	}
6891
6892	/**
6893	* Saves the registry entry of this machine to the given configuration node.
6894	*
6895	* @param data Machine registry data.
6896	*
6897	* @note locks this object for reading.
6898	*/
6899	HRESULT Machine::i_saveRegistryEntry(settings::MachineRegistryEntry &data)
6900	{
6901	AutoLimitedCaller autoCaller(this);
6902	AssertComRCReturnRC(autoCaller.hrc());
6903
6904	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6905
6906	data.uuid = mData->mUuid;
6907	data.strSettingsFile = mData->m_strConfigFile;
6908
6909	return S_OK;
6910	}
6911
6912	/**
6913	* Calculates the absolute path of the given path taking the directory of the
6914	* machine settings file as the current directory.
6915	*
6916	* @param strPath Path to calculate the absolute path for.
6917	* @param aResult Where to put the result (used only on success, can be the
6918	* same Utf8Str instance as passed in @a aPath).
6919	* @return IPRT result.
6920	*
6921	* @note Locks this object for reading.
6922	*/
6923	int Machine::i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult)
6924	{
6925	AutoCaller autoCaller(this);
6926	AssertComRCReturn(autoCaller.hrc(), Global::vboxStatusCodeFromCOM(autoCaller.hrc()));
6927
6928	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6929
6930	AssertReturn(!mData->m_strConfigFileFull.isEmpty(), VERR_GENERAL_FAILURE);
6931
6932	Utf8Str strSettingsDir = mData->m_strConfigFileFull;
6933
6934	strSettingsDir.stripFilename();
6935	char szFolder[RTPATH_MAX];
6936	size_t cbFolder = sizeof(szFolder);
6937	int vrc = RTPathAbsEx(strSettingsDir.c_str(), strPath.c_str(), RTPATH_STR_F_STYLE_HOST, szFolder, &cbFolder);
6938	if (RT_SUCCESS(vrc))
6939	aResult = szFolder;
6940
6941	return vrc;
6942	}
6943
6944	/**
6945	* Copies strSource to strTarget, making it relative to the machine folder
6946	* if it is a subdirectory thereof, or simply copying it otherwise.
6947	*
6948	* @param strSource Path to evaluate and copy.
6949	* @param strTarget Buffer to receive target path.
6950	*
6951	* @note Locks this object for reading.
6952	*/
6953	void Machine::i_copyPathRelativeToMachine(const Utf8Str &strSource,
6954	Utf8Str &strTarget)
6955	{
6956	AutoCaller autoCaller(this);
6957	AssertComRCReturn(autoCaller.hrc(), (void)0);
6958
6959	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6960
6961	AssertReturnVoid(!mData->m_strConfigFileFull.isEmpty());
6962	// use strTarget as a temporary buffer to hold the machine settings dir
6963	strTarget = mData->m_strConfigFileFull;
6964	strTarget.stripFilename();
6965	if (RTPathStartsWith(strSource.c_str(), strTarget.c_str()))
6966	{
6967	// is relative: then append what's left
6968	strTarget = strSource.substr(strTarget.length() + 1); // skip '/'
6969	// for empty paths (only possible for subdirs) use "." to avoid
6970	// triggering default settings for not present config attributes.
6971	if (strTarget.isEmpty())
6972	strTarget = ".";
6973	}
6974	else
6975	// is not relative: then overwrite
6976	strTarget = strSource;
6977	}
6978
6979	/**
6980	* Returns the full path to the machine's log folder in the
6981	* \a aLogFolder argument.
6982	*/
6983	void Machine::i_getLogFolder(Utf8Str &aLogFolder)
6984	{
6985	AutoCaller autoCaller(this);
6986	AssertComRCReturnVoid(autoCaller.hrc());
6987
6988	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6989
6990	char szTmp[RTPATH_MAX];
6991	int vrc = RTEnvGetEx(RTENV_DEFAULT, "VBOX_USER_VMLOGDIR", szTmp, sizeof(szTmp), NULL);
6992	if (RT_SUCCESS(vrc))
6993	{
6994	if (szTmp[0] && !mUserData.isNull())
6995	{
6996	char szTmp2[RTPATH_MAX];
6997	vrc = RTPathAbs(szTmp, szTmp2, sizeof(szTmp2));
6998	if (RT_SUCCESS(vrc))
6999	aLogFolder.printf("%s%c%s",
7000	szTmp2,
7001	RTPATH_DELIMITER,
7002	mUserData->s.strName.c_str()); // path/to/logfolder/vmname
7003	}
7004	else
7005	vrc = VERR_PATH_IS_RELATIVE;
7006	}
7007
7008	if (RT_FAILURE(vrc))
7009	{
7010	// fallback if VBOX_USER_LOGHOME is not set or invalid
7011	aLogFolder = mData->m_strConfigFileFull; // path/to/machinesfolder/vmname/vmname.vbox
7012	aLogFolder.stripFilename(); // path/to/machinesfolder/vmname
7013	aLogFolder.append(RTPATH_DELIMITER);
7014	aLogFolder.append("Logs"); // path/to/machinesfolder/vmname/Logs
7015	}
7016	}
7017
7018	/**
7019	* Returns the full path to the machine's log file for an given index.
7020	*/
7021	Utf8Str Machine::i_getLogFilename(ULONG idx)
7022	{
7023	Utf8Str logFolder;
7024	getLogFolder(logFolder);
7025	Assert(logFolder.length());
7026
7027	Utf8Str log;
7028	if (idx == 0)
7029	log.printf("%s%cVBox.log", logFolder.c_str(), RTPATH_DELIMITER);
7030	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7031	else if (idx == 1)
7032	log.printf("%s%cVBoxHardening.log", logFolder.c_str(), RTPATH_DELIMITER);
7033	else
7034	log.printf("%s%cVBox.log.%u", logFolder.c_str(), RTPATH_DELIMITER, idx - 1);
7035	#else
7036	else
7037	log.printf("%s%cVBox.log.%u", logFolder.c_str(), RTPATH_DELIMITER, idx);
7038	#endif
7039	return log;
7040	}
7041
7042	/**
7043	* Returns the full path to the machine's hardened log file.
7044	*/
7045	Utf8Str Machine::i_getHardeningLogFilename(void)
7046	{
7047	Utf8Str strFilename;
7048	getLogFolder(strFilename);
7049	Assert(strFilename.length());
7050	strFilename.append(RTPATH_SLASH_STR "VBoxHardening.log");
7051	return strFilename;
7052	}
7053
7054	/**
7055	* Returns the default NVRAM filename based on the location of the VM config.
7056	* Note that this is a relative path.
7057	*/
7058	Utf8Str Machine::i_getDefaultNVRAMFilename()
7059	{
7060	AutoCaller autoCaller(this);
7061	AssertComRCReturn(autoCaller.hrc(), Utf8Str::Empty);
7062
7063	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7064
7065	if (i_isSnapshotMachine())
7066	return Utf8Str::Empty;
7067
7068	Utf8Str strNVRAMFilePath = mData->m_strConfigFileFull;
7069	strNVRAMFilePath.stripPath();
7070	strNVRAMFilePath.stripSuffix();
7071	strNVRAMFilePath += ".nvram";
7072
7073	return strNVRAMFilePath;
7074	}
7075
7076	/**
7077	* Returns the NVRAM filename for a new snapshot. This intentionally works
7078	* similarly to the saved state file naming. Note that this is usually
7079	* a relative path, unless the snapshot folder is absolute.
7080	*/
7081	Utf8Str Machine::i_getSnapshotNVRAMFilename()
7082	{
7083	AutoCaller autoCaller(this);
7084	AssertComRCReturn(autoCaller.hrc(), Utf8Str::Empty);
7085
7086	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7087
7088	RTTIMESPEC ts;
7089	RTTimeNow(&ts);
7090	RTTIME time;
7091	RTTimeExplode(&time, &ts);
7092
7093	Utf8Str strNVRAMFilePath = mUserData->s.strSnapshotFolder;
7094	strNVRAMFilePath += RTPATH_DELIMITER;
7095	strNVRAMFilePath.appendPrintf("%04d-%02u-%02uT%02u-%02u-%02u-%09uZ.nvram",
7096	time.i32Year, time.u8Month, time.u8MonthDay,
7097	time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond);
7098
7099	return strNVRAMFilePath;
7100	}
7101
7102	/**
7103	* Returns the version of the settings file.
7104	*/
7105	SettingsVersion_T Machine::i_getSettingsVersion(void)
7106	{
7107	AutoCaller autoCaller(this);
7108	AssertComRCReturn(autoCaller.hrc(), SettingsVersion_Null);
7109
7110	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7111
7112	return mData->pMachineConfigFile->getSettingsVersion();
7113	}
7114
7115	/**
7116	* Composes a unique saved state filename based on the current system time. The filename is
7117	* granular to the second so this will work so long as no more than one snapshot is taken on
7118	* a machine per second.
7119	*
7120	* Before version 4.1, we used this formula for saved state files:
7121	* Utf8StrFmt("%s%c{%RTuuid}.sav", strFullSnapshotFolder.c_str(), RTPATH_DELIMITER, mData->mUuid.raw())
7122	* which no longer works because saved state files can now be shared between the saved state of the
7123	* "saved" machine and an online snapshot, and the following would cause problems:
7124	* 1) save machine
7125	* 2) create online snapshot from that machine state --> reusing saved state file
7126	* 3) save machine again --> filename would be reused, breaking the online snapshot
7127	*
7128	* So instead we now use a timestamp.
7129	*
7130	* @param strStateFilePath
7131	*/
7132
7133	void Machine::i_composeSavedStateFilename(Utf8Str &strStateFilePath)
7134	{
7135	AutoCaller autoCaller(this);
7136	AssertComRCReturnVoid(autoCaller.hrc());
7137
7138	{
7139	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7140	i_calculateFullPath(mUserData->s.strSnapshotFolder, strStateFilePath);
7141	}
7142
7143	RTTIMESPEC ts;
7144	RTTimeNow(&ts);
7145	RTTIME time;
7146	RTTimeExplode(&time, &ts);
7147
7148	strStateFilePath += RTPATH_DELIMITER;
7149	strStateFilePath.appendPrintf("%04d-%02u-%02uT%02u-%02u-%02u-%09uZ.sav",
7150	time.i32Year, time.u8Month, time.u8MonthDay,
7151	time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond);
7152	}
7153
7154	/**
7155	* Returns whether at least one USB controller is present for the VM.
7156	*/
7157	bool Machine::i_isUSBControllerPresent()
7158	{
7159	AutoCaller autoCaller(this);
7160	AssertComRCReturn(autoCaller.hrc(), false);
7161
7162	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7163
7164	return (mUSBControllers->size() > 0);
7165	}
7166
7167
7168	/**
7169	* @note Locks this object for writing, calls the client process
7170	* (inside the lock).
7171	*/
7172	HRESULT Machine::i_launchVMProcess(IInternalSessionControl *aControl,
7173	const Utf8Str &strFrontend,
7174	const std::vector<com::Utf8Str> &aEnvironmentChanges,
7175	ProgressProxy *aProgress)
7176	{
7177	LogFlowThisFuncEnter();
7178
7179	AssertReturn(aControl, E_FAIL);
7180	AssertReturn(aProgress, E_FAIL);
7181	AssertReturn(!strFrontend.isEmpty(), E_FAIL);
7182
7183	AutoCaller autoCaller(this);
7184	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
7185
7186	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7187
7188	if (!mData->mRegistered)
7189	return setError(E_UNEXPECTED,
7190	tr("The machine '%s' is not registered"),
7191	mUserData->s.strName.c_str());
7192
7193	LogFlowThisFunc(("mSession.mState=%s\n", ::stringifySessionState(mData->mSession.mState)));
7194
7195	/* The process started when launching a VM with separate UI/VM processes is always
7196	* the UI process, i.e. needs special handling as it won't claim the session. */
7197	bool fSeparate = strFrontend.endsWith("separate", Utf8Str::CaseInsensitive);
7198
7199	if (fSeparate)
7200	{
7201	if (mData->mSession.mState != SessionState_Unlocked && mData->mSession.mName != "headless")
7202	return setError(VBOX_E_INVALID_OBJECT_STATE,
7203	tr("The machine '%s' is in a state which is incompatible with launching a separate UI process"),
7204	mUserData->s.strName.c_str());
7205	}
7206	else
7207	{
7208	if ( mData->mSession.mState == SessionState_Locked
7209	\|\| mData->mSession.mState == SessionState_Spawning
7210	\|\| mData->mSession.mState == SessionState_Unlocking)
7211	return setError(VBOX_E_INVALID_OBJECT_STATE,
7212	tr("The machine '%s' is already locked by a session (or being locked or unlocked)"),
7213	mUserData->s.strName.c_str());
7214
7215	/* may not be busy */
7216	AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
7217	}
7218
7219	/* Hardening logging */
7220	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7221	Utf8Str strSupHardeningLogArg("--sup-hardening-log=");
7222	{
7223	Utf8Str strHardeningLogFile = i_getHardeningLogFilename();
7224	int vrc2 = VERR_IPE_UNINITIALIZED_STATUS;
7225	i_deleteFile(strHardeningLogFile, false /* fIgnoreFailures /, tr("hardening log file"), &vrc2); / ignoring return code */
7226	if (vrc2 == VERR_PATH_NOT_FOUND \|\| vrc2 == VERR_FILE_NOT_FOUND)
7227	{
7228	Utf8Str strStartupLogDir = strHardeningLogFile;
7229	strStartupLogDir.stripFilename();
7230	RTDirCreateFullPath(strStartupLogDir.c_str(), 0755); /** @todo add a variant for creating the path to a
7231	file without stripping the file. */
7232	}
7233	strSupHardeningLogArg.append(strHardeningLogFile);
7234
7235	/* Remove legacy log filename to avoid confusion. */
7236	Utf8Str strOldStartupLogFile;
7237	getLogFolder(strOldStartupLogFile);
7238	strOldStartupLogFile.append(RTPATH_SLASH_STR "VBoxStartup.log");
7239	i_deleteFile(strOldStartupLogFile, true /* fIgnoreFailures */);
7240	}
7241	#else
7242	Utf8Str strSupHardeningLogArg;
7243	#endif
7244
7245	Utf8Str strAppOverride;
7246	#ifdef RT_OS_DARWIN /* Avoid Launch Services confusing this with the selector by using a helper app. */
7247	strAppOverride = i_getExtraData(Utf8Str("VBoxInternal2/VirtualBoxVMAppOverride"));
7248	#endif
7249
7250	bool fUseVBoxSDS = false;
7251	Utf8Str strCanonicalName;
7252	if (false)
7253	{ }
7254	#ifdef VBOX_WITH_QTGUI
7255	else if ( !strFrontend.compare("gui", Utf8Str::CaseInsensitive)
7256	\|\| !strFrontend.compare("GUI/Qt", Utf8Str::CaseInsensitive)
7257	\|\| !strFrontend.compare("separate", Utf8Str::CaseInsensitive)
7258	\|\| !strFrontend.compare("gui/separate", Utf8Str::CaseInsensitive)
7259	\|\| !strFrontend.compare("GUI/Qt/separate", Utf8Str::CaseInsensitive))
7260	{
7261	strCanonicalName = "GUI/Qt";
7262	fUseVBoxSDS = true;
7263	}
7264	#endif
7265	#ifdef VBOX_WITH_VBOXSDL
7266	else if ( !strFrontend.compare("sdl", Utf8Str::CaseInsensitive)
7267	\|\| !strFrontend.compare("GUI/SDL", Utf8Str::CaseInsensitive)
7268	\|\| !strFrontend.compare("sdl/separate", Utf8Str::CaseInsensitive)
7269	\|\| !strFrontend.compare("GUI/SDL/separate", Utf8Str::CaseInsensitive))
7270	{
7271	strCanonicalName = "GUI/SDL";
7272	fUseVBoxSDS = true;
7273	}
7274	#endif
7275	#ifdef VBOX_WITH_HEADLESS
7276	else if ( !strFrontend.compare("headless", Utf8Str::CaseInsensitive)
7277	\|\| !strFrontend.compare("capture", Utf8Str::CaseInsensitive)
7278	\|\| !strFrontend.compare("vrdp", Utf8Str::CaseInsensitive) /* Deprecated. Same as headless. */)
7279	{
7280	strCanonicalName = "headless";
7281	}
7282	#endif
7283	else
7284	return setError(E_INVALIDARG, tr("Invalid frontend name: '%s'"), strFrontend.c_str());
7285
7286	Utf8Str idStr = mData->mUuid.toString();
7287	Utf8Str const &strMachineName = mUserData->s.strName;
7288	RTPROCESS pid = NIL_RTPROCESS;
7289
7290	#if !defined(VBOX_WITH_SDS) \|\| !defined(RT_OS_WINDOWS)
7291	RT_NOREF(fUseVBoxSDS);
7292	#else
7293	DWORD idCallerSession = ~(DWORD)0;
7294	if (fUseVBoxSDS)
7295	{
7296	/*
7297	* The VBoxSDS should be used for process launching the VM with
7298	* GUI only if the caller and the VBoxSDS are in different Windows
7299	* sessions and the caller in the interactive one.
7300	*/
7301	fUseVBoxSDS = false;
7302
7303	/* Get windows session of the current process. The process token used
7304	due to several reasons:
7305	1. The token is absent for the current thread except someone set it
7306	for us.
7307	2. Needs to get the id of the session where the process is started.
7308	We only need to do this once, though. */
7309	static DWORD s_idCurrentSession = ~(DWORD)0;
7310	DWORD idCurrentSession = s_idCurrentSession;
7311	if (idCurrentSession == ~(DWORD)0)
7312	{
7313	HANDLE hCurrentProcessToken = NULL;
7314	if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY \| TOKEN_READ, &hCurrentProcessToken))
7315	{
7316	DWORD cbIgn = 0;
7317	if (GetTokenInformation(hCurrentProcessToken, TokenSessionId, &idCurrentSession, sizeof(idCurrentSession), &cbIgn))
7318	s_idCurrentSession = idCurrentSession;
7319	else
7320	{
7321	idCurrentSession = ~(DWORD)0;
7322	LogRelFunc(("GetTokenInformation/TokenSessionId on self failed: %u\n", GetLastError()));
7323	}
7324	CloseHandle(hCurrentProcessToken);
7325	}
7326	else
7327	LogRelFunc(("OpenProcessToken/self failed: %u\n", GetLastError()));
7328	}
7329
7330	/* get the caller's session */
7331	HRESULT hrc = CoImpersonateClient();
7332	if (SUCCEEDED(hrc))
7333	{
7334	HANDLE hCallerThreadToken;
7335	if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY \| TOKEN_READ,
7336	FALSE /* OpenAsSelf - for impersonation at SecurityIdentification level */,
7337	&hCallerThreadToken))
7338	{
7339	SetLastError(NO_ERROR);
7340	DWORD cbIgn = 0;
7341	if (GetTokenInformation(hCallerThreadToken, TokenSessionId, &idCallerSession, sizeof(DWORD), &cbIgn))
7342	{
7343	/* Only need to use SDS if the session ID differs: */
7344	if (idCurrentSession != idCallerSession)
7345	{
7346	fUseVBoxSDS = false;
7347
7348	/* Obtain the groups the access token belongs to so we can see if the session is interactive: */
7349	DWORD cbTokenGroups = 0;
7350	PTOKEN_GROUPS pTokenGroups = NULL;
7351	if ( !GetTokenInformation(hCallerThreadToken, TokenGroups, pTokenGroups, 0, &cbTokenGroups)
7352	&& GetLastError() == ERROR_INSUFFICIENT_BUFFER)
7353	pTokenGroups = (PTOKEN_GROUPS)RTMemTmpAllocZ(cbTokenGroups);
7354	if (GetTokenInformation(hCallerThreadToken, TokenGroups, pTokenGroups, cbTokenGroups, &cbTokenGroups))
7355	{
7356	/* Well-known interactive SID: SECURITY_INTERACTIVE_RID, S-1-5-4: */
7357	SID_IDENTIFIER_AUTHORITY sidIdNTAuthority = SECURITY_NT_AUTHORITY;
7358	PSID pInteractiveSid = NULL;
7359	if (AllocateAndInitializeSid(&sidIdNTAuthority, 1, 4, 0, 0, 0, 0, 0, 0, 0, &pInteractiveSid))
7360	{
7361	/* Iterate over the groups looking for the interactive SID: */
7362	fUseVBoxSDS = false;
7363	for (DWORD dwIndex = 0; dwIndex < pTokenGroups->GroupCount; dwIndex++)
7364	if (EqualSid(pTokenGroups->Groups[dwIndex].Sid, pInteractiveSid))
7365	{
7366	fUseVBoxSDS = true;
7367	break;
7368	}
7369	FreeSid(pInteractiveSid);
7370	}
7371	}
7372	else
7373	LogRelFunc(("GetTokenInformation/TokenGroups failed: %u\n", GetLastError()));
7374	RTMemTmpFree(pTokenGroups);
7375	}
7376	}
7377	else
7378	LogRelFunc(("GetTokenInformation/TokenSessionId failed: %u\n", GetLastError()));
7379	CloseHandle(hCallerThreadToken);
7380	}
7381	else
7382	LogRelFunc(("OpenThreadToken/client failed: %u\n", GetLastError()));
7383	CoRevertToSelf();
7384	}
7385	else
7386	LogRelFunc(("CoImpersonateClient failed: %Rhrc\n", hrc));
7387	}
7388	if (fUseVBoxSDS)
7389	{
7390	/* connect to VBoxSDS */
7391	ComPtr<IVirtualBoxSDS> pVBoxSDS;
7392	HRESULT hrc = pVBoxSDS.createLocalObject(CLSID_VirtualBoxSDS);
7393	if (FAILED(hrc))
7394	return setError(hrc, tr("Failed to start the machine '%s'. A connection to VBoxSDS cannot be established"),
7395	strMachineName.c_str());
7396
7397	/* By default the RPC_C_IMP_LEVEL_IDENTIFY is used for impersonation the client. It allows
7398	ACL checking but restricts an access to system objects e.g. files. Call to CoSetProxyBlanket
7399	elevates the impersonation level up to RPC_C_IMP_LEVEL_IMPERSONATE allowing the VBoxSDS
7400	service to access the files. */
7401	hrc = CoSetProxyBlanket(pVBoxSDS,
7402	RPC_C_AUTHN_DEFAULT,
7403	RPC_C_AUTHZ_DEFAULT,
7404	COLE_DEFAULT_PRINCIPAL,
7405	RPC_C_AUTHN_LEVEL_DEFAULT,
7406	RPC_C_IMP_LEVEL_IMPERSONATE,
7407	NULL,
7408	EOAC_DEFAULT);
7409	if (FAILED(hrc))
7410	return setError(hrc, tr("Failed to start the machine '%s'. CoSetProxyBlanket failed"), strMachineName.c_str());
7411
7412	size_t const cEnvVars = aEnvironmentChanges.size();
7413	com::SafeArray<IN_BSTR> aBstrEnvironmentChanges(cEnvVars);
7414	for (size_t i = 0; i < cEnvVars; i++)
7415	aBstrEnvironmentChanges[i] = Bstr(aEnvironmentChanges[i]).raw();
7416
7417	ULONG uPid = 0;
7418	hrc = pVBoxSDS->LaunchVMProcess(Bstr(idStr).raw(), Bstr(strMachineName).raw(), Bstr(strFrontend).raw(),
7419	ComSafeArrayAsInParam(aBstrEnvironmentChanges), Bstr(strSupHardeningLogArg).raw(),
7420	idCallerSession, &uPid);
7421	if (FAILED(hrc))
7422	return setError(hrc, tr("Failed to start the machine '%s'. Process creation failed"), strMachineName.c_str());
7423	pid = (RTPROCESS)uPid;
7424	}
7425	else
7426	#endif /* VBOX_WITH_SDS && RT_OS_WINDOWS */
7427	{
7428	int vrc = MachineLaunchVMCommonWorker(idStr, strMachineName, strFrontend, aEnvironmentChanges, strSupHardeningLogArg,
7429	strAppOverride, 0 /fFlags/, NULL /pvExtraData/, pid);
7430	if (RT_FAILURE(vrc))
7431	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
7432	tr("Could not launch the VM process for the machine '%s' (%Rrc)"), strMachineName.c_str(), vrc);
7433	}
7434
7435	LogRel(("Launched VM: %u pid: %u (%#x) frontend: %s name: %s\n",
7436	idStr.c_str(), pid, pid, strFrontend.c_str(), strMachineName.c_str()));
7437
7438	if (!fSeparate)
7439	{
7440	/*
7441	* Note that we don't release the lock here before calling the client,
7442	* because it doesn't need to call us back if called with a NULL argument.
7443	* Releasing the lock here is dangerous because we didn't prepare the
7444	* launch data yet, but the client we've just started may happen to be
7445	* too fast and call LockMachine() that will fail (because of PID, etc.),
7446	* so that the Machine will never get out of the Spawning session state.
7447	*/
7448
7449	/* inform the session that it will be a remote one */
7450	LogFlowThisFunc(("Calling AssignMachine (NULL)...\n"));
7451	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
7452	HRESULT hrc = aControl->AssignMachine(NULL, LockType_Write, Bstr::Empty.raw());
7453	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
7454	HRESULT hrc = aControl->AssignMachine(NULL, LockType_Write, NULL);
7455	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
7456	LogFlowThisFunc(("AssignMachine (NULL) returned %08X\n", hrc));
7457
7458	if (FAILED(hrc))
7459	{
7460	/* restore the session state */
7461	mData->mSession.mState = SessionState_Unlocked;
7462	alock.release();
7463	mParent->i_addProcessToReap(pid);
7464	/* The failure may occur w/o any error info (from RPC), so provide one */
7465	return setError(VBOX_E_VM_ERROR,
7466	tr("Failed to assign the machine to the session (%Rhrc)"), hrc);
7467	}
7468
7469	/* attach launch data to the machine */
7470	Assert(mData->mSession.mPID == NIL_RTPROCESS);
7471	mData->mSession.mRemoteControls.push_back(aControl);
7472	mData->mSession.mProgress = aProgress;
7473	mData->mSession.mPID = pid;
7474	mData->mSession.mState = SessionState_Spawning;
7475	Assert(strCanonicalName.isNotEmpty());
7476	mData->mSession.mName = strCanonicalName;
7477	}
7478	else
7479	{
7480	/* For separate UI process we declare the launch as completed instantly, as the
7481	* actual headless VM start may or may not come. No point in remembering anything
7482	* yet, as what matters for us is when the headless VM gets started. */
7483	aProgress->i_notifyComplete(S_OK);
7484	}
7485
7486	alock.release();
7487	mParent->i_addProcessToReap(pid);
7488
7489	LogFlowThisFuncLeave();
7490	return S_OK;
7491	}
7492
7493	/**
7494	* Returns @c true if the given session machine instance has an open direct
7495	* session (and optionally also for direct sessions which are closing) and
7496	* returns the session control machine instance if so.
7497	*
7498	* Note that when the method returns @c false, the arguments remain unchanged.
7499	*
7500	* @param aMachine Session machine object.
7501	* @param aControl Direct session control object (optional).
7502	* @param aRequireVM If true then only allow VM sessions.
7503	* @param aAllowClosing If true then additionally a session which is currently
7504	* being closed will also be allowed.
7505	*
7506	* @note locks this object for reading.
7507	*/
7508	bool Machine::i_isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
7509	ComPtr<IInternalSessionControl> aControl /= NULL*/,
7510	bool aRequireVM /= false/,
7511	bool aAllowClosing /= false/)
7512	{
7513	AutoLimitedCaller autoCaller(this);
7514	AssertComRCReturn(autoCaller.hrc(), false);
7515
7516	/* just return false for inaccessible machines */
7517	if (getObjectState().getState() != ObjectState::Ready)
7518	return false;
7519
7520	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7521
7522	if ( ( mData->mSession.mState == SessionState_Locked
7523	&& (!aRequireVM \|\| mData->mSession.mLockType == LockType_VM))
7524	\|\| (aAllowClosing && mData->mSession.mState == SessionState_Unlocking)
7525	)
7526	{
7527	AssertReturn(!mData->mSession.mMachine.isNull(), false);
7528
7529	aMachine = mData->mSession.mMachine;
7530
7531	if (aControl != NULL)
7532	*aControl = mData->mSession.mDirectControl;
7533
7534	return true;
7535	}
7536
7537	return false;
7538	}
7539
7540	/**
7541	* Returns @c true if the given machine has an spawning direct session.
7542	*
7543	* @note locks this object for reading.
7544	*/
7545	bool Machine::i_isSessionSpawning()
7546	{
7547	AutoLimitedCaller autoCaller(this);
7548	AssertComRCReturn(autoCaller.hrc(), false);
7549
7550	/* just return false for inaccessible machines */
7551	if (getObjectState().getState() != ObjectState::Ready)
7552	return false;
7553
7554	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7555
7556	if (mData->mSession.mState == SessionState_Spawning)
7557	return true;
7558
7559	return false;
7560	}
7561
7562	/**
7563	* Called from the client watcher thread to check for unexpected client process
7564	* death during Session_Spawning state (e.g. before it successfully opened a
7565	* direct session).
7566	*
7567	* On Win32 and on OS/2, this method is called only when we've got the
7568	* direct client's process termination notification, so it always returns @c
7569	* true.
7570	*
7571	* On other platforms, this method returns @c true if the client process is
7572	* terminated and @c false if it's still alive.
7573	*
7574	* @note Locks this object for writing.
7575	*/
7576	bool Machine::i_checkForSpawnFailure()
7577	{
7578	AutoCaller autoCaller(this);
7579	if (!autoCaller.isOk())
7580	{
7581	/* nothing to do */
7582	LogFlowThisFunc(("Already uninitialized!\n"));
7583	return true;
7584	}
7585
7586	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7587
7588	if (mData->mSession.mState != SessionState_Spawning)
7589	{
7590	/* nothing to do */
7591	LogFlowThisFunc(("Not spawning any more!\n"));
7592	return true;
7593	}
7594
7595	/* PID not yet initialized, skip check. */
7596	if (mData->mSession.mPID == NIL_RTPROCESS)
7597	return false;
7598
7599	HRESULT hrc = S_OK;
7600	RTPROCSTATUS status;
7601	int vrc = RTProcWait(mData->mSession.mPID, RTPROCWAIT_FLAGS_NOBLOCK, &status);
7602	if (vrc != VERR_PROCESS_RUNNING)
7603	{
7604	Utf8Str strExtraInfo;
7605
7606	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7607	/* If the startup logfile exists and is of non-zero length, tell the
7608	user to look there for more details to encourage them to attach it
7609	when reporting startup issues. */
7610	Utf8Str strHardeningLogFile = i_getHardeningLogFilename();
7611	uint64_t cbStartupLogFile = 0;
7612	int vrc2 = RTFileQuerySizeByPath(strHardeningLogFile.c_str(), &cbStartupLogFile);
7613	if (RT_SUCCESS(vrc2) && cbStartupLogFile > 0)
7614	strExtraInfo.appendPrintf(tr(". More details may be available in '%s'"), strHardeningLogFile.c_str());
7615	#endif
7616
7617	if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_NORMAL)
7618	hrc = setError(E_FAIL,
7619	tr("The virtual machine '%s' has terminated unexpectedly during startup with exit code %d (%#x)%s"),
7620	i_getName().c_str(), status.iStatus, status.iStatus, strExtraInfo.c_str());
7621	else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_SIGNAL)
7622	hrc = setError(E_FAIL,
7623	tr("The virtual machine '%s' has terminated unexpectedly during startup because of signal %d%s"),
7624	i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
7625	else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_ABEND)
7626	hrc = setError(E_FAIL,
7627	tr("The virtual machine '%s' has terminated abnormally (iStatus=%#x)%s"),
7628	i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
7629	else
7630	hrc = setErrorBoth(E_FAIL, vrc,
7631	tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)%s"),
7632	i_getName().c_str(), vrc, strExtraInfo.c_str());
7633	}
7634
7635	if (FAILED(hrc))
7636	{
7637	/* Close the remote session, remove the remote control from the list
7638	* and reset session state to Closed (@note keep the code in sync with
7639	* the relevant part in LockMachine()). */
7640
7641	Assert(mData->mSession.mRemoteControls.size() == 1);
7642	if (mData->mSession.mRemoteControls.size() == 1)
7643	{
7644	ErrorInfoKeeper eik;
7645	mData->mSession.mRemoteControls.front()->Uninitialize();
7646	}
7647
7648	mData->mSession.mRemoteControls.clear();
7649	mData->mSession.mState = SessionState_Unlocked;
7650
7651	/* finalize the progress after setting the state */
7652	if (!mData->mSession.mProgress.isNull())
7653	{
7654	mData->mSession.mProgress->notifyComplete(hrc);
7655	mData->mSession.mProgress.setNull();
7656	}
7657
7658	mData->mSession.mPID = NIL_RTPROCESS;
7659
7660	mParent->i_onSessionStateChanged(mData->mUuid, SessionState_Unlocked);
7661	return true;
7662	}
7663
7664	return false;
7665	}
7666
7667	/**
7668	* Checks whether the machine can be registered. If so, commits and saves
7669	* all settings.
7670	*
7671	* @note Must be called from mParent's write lock. Locks this object and
7672	* children for writing.
7673	*/
7674	HRESULT Machine::i_prepareRegister()
7675	{
7676	AssertReturn(mParent->isWriteLockOnCurrentThread(), E_FAIL);
7677
7678	AutoLimitedCaller autoCaller(this);
7679	AssertComRCReturnRC(autoCaller.hrc());
7680
7681	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7682
7683	/* wait for state dependents to drop to zero */
7684	i_ensureNoStateDependencies(alock);
7685
7686	if (!mData->mAccessible)
7687	return setError(VBOX_E_INVALID_OBJECT_STATE,
7688	tr("The machine '%s' with UUID {%s} is inaccessible and cannot be registered"),
7689	mUserData->s.strName.c_str(),
7690	mData->mUuid.toString().c_str());
7691
7692	AssertReturn(getObjectState().getState() == ObjectState::Ready, E_FAIL);
7693
7694	if (mData->mRegistered)
7695	return setError(VBOX_E_INVALID_OBJECT_STATE,
7696	tr("The machine '%s' with UUID {%s} is already registered"),
7697	mUserData->s.strName.c_str(),
7698	mData->mUuid.toString().c_str());
7699
7700	HRESULT hrc = S_OK;
7701
7702	// Ensure the settings are saved. If we are going to be registered and
7703	// no config file exists yet, create it by calling i_saveSettings() too.
7704	if ( (mData->flModifications)
7705	\|\| (!mData->pMachineConfigFile->fileExists())
7706	)
7707	{
7708	hrc = i_saveSettings(NULL, alock);
7709	// no need to check whether VirtualBox.xml needs saving too since
7710	// we can't have a machine XML file rename pending
7711	if (FAILED(hrc)) return hrc;
7712	}
7713
7714	/* more config checking goes here */
7715
7716	if (SUCCEEDED(hrc))
7717	{
7718	/* we may have had implicit modifications we want to fix on success */
7719	i_commit();
7720
7721	mData->mRegistered = true;
7722	}
7723	else
7724	{
7725	/* we may have had implicit modifications we want to cancel on failure*/
7726	i_rollback(false /* aNotify */);
7727	}
7728
7729	return hrc;
7730	}
7731
7732	/**
7733	* Increases the number of objects dependent on the machine state or on the
7734	* registered state. Guarantees that these two states will not change at least
7735	* until #i_releaseStateDependency() is called.
7736	*
7737	* Depending on the @a aDepType value, additional state checks may be made.
7738	* These checks will set extended error info on failure. See
7739	* #i_checkStateDependency() for more info.
7740	*
7741	* If this method returns a failure, the dependency is not added and the caller
7742	* is not allowed to rely on any particular machine state or registration state
7743	* value and may return the failed result code to the upper level.
7744	*
7745	* @param aDepType Dependency type to add.
7746	* @param aState Current machine state (NULL if not interested).
7747	* @param aRegistered Current registered state (NULL if not interested).
7748	*
7749	* @note Locks this object for writing.
7750	*/
7751	HRESULT Machine::i_addStateDependency(StateDependency aDepType /* = AnyStateDep */,
7752	MachineState_T aState / = NULL */,
7753	BOOL aRegistered / = NULL */)
7754	{
7755	AutoCaller autoCaller(this);
7756	AssertComRCReturnRC(autoCaller.hrc());
7757
7758	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7759
7760	HRESULT hrc = i_checkStateDependency(aDepType);
7761	if (FAILED(hrc)) return hrc;
7762
7763	{
7764	if (mData->mMachineStateChangePending != 0)
7765	{
7766	/* i_ensureNoStateDependencies() is waiting for state dependencies to
7767	* drop to zero so don't add more. It may make sense to wait a bit
7768	* and retry before reporting an error (since the pending state
7769	* transition should be really quick) but let's just assert for
7770	* now to see if it ever happens on practice. */
7771
7772	AssertFailed();
7773
7774	return setError(E_ACCESSDENIED,
7775	tr("Machine state change is in progress. Please retry the operation later."));
7776	}
7777
7778	++mData->mMachineStateDeps;
7779	Assert(mData->mMachineStateDeps != 0 /* overflow */);
7780	}
7781
7782	if (aState)
7783	*aState = mData->mMachineState;
7784	if (aRegistered)
7785	*aRegistered = mData->mRegistered;
7786
7787	return S_OK;
7788	}
7789
7790	/**
7791	* Decreases the number of objects dependent on the machine state.
7792	* Must always complete the #i_addStateDependency() call after the state
7793	* dependency is no more necessary.
7794	*/
7795	void Machine::i_releaseStateDependency()
7796	{
7797	AutoCaller autoCaller(this);
7798	AssertComRCReturnVoid(autoCaller.hrc());
7799
7800	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7801
7802	/* releaseStateDependency() w/o addStateDependency()? */
7803	AssertReturnVoid(mData->mMachineStateDeps != 0);
7804	-- mData->mMachineStateDeps;
7805
7806	if (mData->mMachineStateDeps == 0)
7807	{
7808	/* inform i_ensureNoStateDependencies() that there are no more deps */
7809	if (mData->mMachineStateChangePending != 0)
7810	{
7811	Assert(mData->mMachineStateDepsSem != NIL_RTSEMEVENTMULTI);
7812	RTSemEventMultiSignal (mData->mMachineStateDepsSem);
7813	}
7814	}
7815	}
7816
7817	Utf8Str Machine::i_getExtraData(const Utf8Str &strKey)
7818	{
7819	/* start with nothing found */
7820	Utf8Str strResult("");
7821
7822	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7823
7824	settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(strKey);
7825	if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
7826	// found:
7827	strResult = it->second; // source is a Utf8Str
7828
7829	return strResult;
7830	}
7831
7832	FirmwareType_T Machine::i_getFirmwareType() const
7833	{
7834	return mFirmwareSettings->i_getFirmwareType();
7835	}
7836
7837	// protected methods
7838	/////////////////////////////////////////////////////////////////////////////
7839
7840	/**
7841	* Performs machine state checks based on the @a aDepType value. If a check
7842	* fails, this method will set extended error info, otherwise it will return
7843	* S_OK. It is supposed, that on failure, the caller will immediately return
7844	* the return value of this method to the upper level.
7845	*
7846	* When @a aDepType is AnyStateDep, this method always returns S_OK.
7847	*
7848	* When @a aDepType is MutableStateDep, this method returns S_OK only if the
7849	* current state of this machine object allows to change settings of the
7850	* machine (i.e. the machine is not registered, or registered but not running
7851	* and not saved). It is useful to call this method from Machine setters
7852	* before performing any change.
7853	*
7854	* When @a aDepType is MutableOrSavedStateDep, this method behaves the same
7855	* as for MutableStateDep except that if the machine is saved, S_OK is also
7856	* returned. This is useful in setters which allow changing machine
7857	* properties when it is in the saved state.
7858	*
7859	* When @a aDepType is MutableOrRunningStateDep, this method returns S_OK only
7860	* if the current state of this machine object allows to change runtime
7861	* changeable settings of the machine (i.e. the machine is not registered, or
7862	* registered but either running or not running and not saved). It is useful
7863	* to call this method from Machine setters before performing any changes to
7864	* runtime changeable settings.
7865	*
7866	* When @a aDepType is MutableOrSavedOrRunningStateDep, this method behaves
7867	* the same as for MutableOrRunningStateDep except that if the machine is
7868	* saved, S_OK is also returned. This is useful in setters which allow
7869	* changing runtime and saved state changeable machine properties.
7870	*
7871	* @param aDepType Dependency type to check.
7872	*
7873	* @note Non Machine based classes should use #i_addStateDependency() and
7874	* #i_releaseStateDependency() methods or the smart AutoStateDependency
7875	* template.
7876	*
7877	* @note This method must be called from under this object's read or write
7878	* lock.
7879	*/
7880	HRESULT Machine::i_checkStateDependency(StateDependency aDepType)
7881	{
7882	switch (aDepType)
7883	{
7884	case AnyStateDep:
7885	{
7886	break;
7887	}
7888	case MutableStateDep:
7889	{
7890	if ( mData->mRegistered
7891	&& ( !i_isSessionMachine()
7892	\|\| ( mData->mMachineState != MachineState_Aborted
7893	&& mData->mMachineState != MachineState_Teleported
7894	&& mData->mMachineState != MachineState_PoweredOff
7895	)
7896	)
7897	)
7898	return setError(VBOX_E_INVALID_VM_STATE,
7899	tr("The machine is not mutable (state is %s)"),
7900	Global::stringifyMachineState(mData->mMachineState));
7901	break;
7902	}
7903	case MutableOrSavedStateDep:
7904	{
7905	if ( mData->mRegistered
7906	&& ( !i_isSessionMachine()
7907	\|\| ( mData->mMachineState != MachineState_Aborted
7908	&& mData->mMachineState != MachineState_Teleported
7909	&& mData->mMachineState != MachineState_Saved
7910	&& mData->mMachineState != MachineState_AbortedSaved
7911	&& mData->mMachineState != MachineState_PoweredOff
7912	)
7913	)
7914	)
7915	return setError(VBOX_E_INVALID_VM_STATE,
7916	tr("The machine is not mutable or saved (state is %s)"),
7917	Global::stringifyMachineState(mData->mMachineState));
7918	break;
7919	}
7920	case MutableOrRunningStateDep:
7921	{
7922	if ( mData->mRegistered
7923	&& ( !i_isSessionMachine()
7924	\|\| ( mData->mMachineState != MachineState_Aborted
7925	&& mData->mMachineState != MachineState_Teleported
7926	&& mData->mMachineState != MachineState_PoweredOff
7927	&& !Global::IsOnline(mData->mMachineState)
7928	)
7929	)
7930	)
7931	return setError(VBOX_E_INVALID_VM_STATE,
7932	tr("The machine is not mutable or running (state is %s)"),
7933	Global::stringifyMachineState(mData->mMachineState));
7934	break;
7935	}
7936	case MutableOrSavedOrRunningStateDep:
7937	{
7938	if ( mData->mRegistered
7939	&& ( !i_isSessionMachine()
7940	\|\| ( mData->mMachineState != MachineState_Aborted
7941	&& mData->mMachineState != MachineState_Teleported
7942	&& mData->mMachineState != MachineState_Saved
7943	&& mData->mMachineState != MachineState_AbortedSaved
7944	&& mData->mMachineState != MachineState_PoweredOff
7945	&& !Global::IsOnline(mData->mMachineState)
7946	)
7947	)
7948	)
7949	return setError(VBOX_E_INVALID_VM_STATE,
7950	tr("The machine is not mutable, saved or running (state is %s)"),
7951	Global::stringifyMachineState(mData->mMachineState));
7952	break;
7953	}
7954	}
7955
7956	return S_OK;
7957	}
7958
7959	/**
7960	* Helper to initialize all associated child objects and allocate data
7961	* structures.
7962	*
7963	* This method must be called as a part of the object's initialization procedure
7964	* (usually done in the #init() method).
7965	*
7966	* @note Must be called only from #init() or from #i_registeredInit().
7967	*/
7968	HRESULT Machine::initDataAndChildObjects()
7969	{
7970	AutoCaller autoCaller(this);
7971	AssertComRCReturnRC(autoCaller.hrc());
7972	AssertReturn( getObjectState().getState() == ObjectState::InInit
7973	\|\| getObjectState().getState() == ObjectState::Limited, E_FAIL);
7974
7975	AssertReturn(!mData->mAccessible, E_FAIL);
7976
7977	/* allocate data structures */
7978	mSSData.allocate();
7979	mUserData.allocate();
7980	mHWData.allocate();
7981	mMediumAttachments.allocate();
7982	mStorageControllers.allocate();
7983	mUSBControllers.allocate();
7984
7985	/* create the platform + platform properties objects for this machine */
7986	HRESULT hrc = unconst(mPlatform).createObject();
7987	ComAssertComRCRetRC(hrc);
7988	hrc = mPlatform->init(this);
7989	ComAssertComRCRetRC(hrc);
7990	hrc = unconst(mPlatformProperties).createObject();
7991	ComAssertComRCRetRC(hrc);
7992	hrc = mPlatformProperties->init(mParent);
7993	ComAssertComRCRetRC(hrc);
7994
7995	/* initialize mOSTypeId */
7996	mUserData->s.strOsType = mParent->i_getUnknownOSType()->i_id();
7997
7998	/* create associated firmware settings object */
7999	unconst(mFirmwareSettings).createObject();
8000	mFirmwareSettings->init(this);
8001
8002	/* create associated recording settings object */
8003	unconst(mRecordingSettings).createObject();
8004	mRecordingSettings->init(this);
8005
8006	/* create associated trusted platform module object */
8007	unconst(mTrustedPlatformModule).createObject();
8008	mTrustedPlatformModule->init(this);
8009
8010	/* create associated NVRAM store object */
8011	unconst(mNvramStore).createObject();
8012	mNvramStore->init(this);
8013
8014	/* create the graphics adapter object (always present) */
8015	unconst(mGraphicsAdapter).createObject();
8016	mGraphicsAdapter->init(this);
8017
8018	/* create an associated VRDE object (default is disabled) */
8019	unconst(mVRDEServer).createObject();
8020	mVRDEServer->init(this);
8021
8022	/* create associated serial port objects */
8023	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
8024	{
8025	unconst(mSerialPorts[slot]).createObject();
8026	mSerialPorts[slot]->init(this, slot);
8027	}
8028
8029	/* create associated parallel port objects */
8030	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
8031	{
8032	unconst(mParallelPorts[slot]).createObject();
8033	mParallelPorts[slot]->init(this, slot);
8034	}
8035
8036	/* create the audio settings object */
8037	unconst(mAudioSettings).createObject();
8038	mAudioSettings->init(this);
8039
8040	/* create the USB device filters object (always present) */
8041	unconst(mUSBDeviceFilters).createObject();
8042	mUSBDeviceFilters->init(this);
8043
8044	/* create associated network adapter objects */
8045	ChipsetType_T enmChipsetType;
8046	hrc = mPlatform->getChipsetType(&enmChipsetType);
8047	ComAssertComRC(hrc);
8048
8049	mNetworkAdapters.resize(PlatformProperties::s_getMaxNetworkAdapters(enmChipsetType));
8050	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
8051	{
8052	unconst(mNetworkAdapters[slot]).createObject();
8053	mNetworkAdapters[slot]->init(this, slot);
8054	}
8055
8056	/* create the bandwidth control */
8057	unconst(mBandwidthControl).createObject();
8058	mBandwidthControl->init(this);
8059
8060	/* create the guest debug control object */
8061	unconst(mGuestDebugControl).createObject();
8062	mGuestDebugControl->init(this);
8063
8064	return hrc;
8065	}
8066
8067	/**
8068	* Helper to uninitialize all associated child objects and to free all data
8069	* structures.
8070	*
8071	* This method must be called as a part of the object's uninitialization
8072	* procedure (usually done in the #uninit() method).
8073	*
8074	* @note Must be called only from #uninit() or from #i_registeredInit().
8075	*/
8076	void Machine::uninitDataAndChildObjects()
8077	{
8078	AutoCaller autoCaller(this);
8079	AssertComRCReturnVoid(autoCaller.hrc());
8080	/* Machine object has state = ObjectState::InInit during registeredInit, even if it fails to get settings */
8081	AssertReturnVoid( getObjectState().getState() == ObjectState::InInit
8082	\|\| getObjectState().getState() == ObjectState::InUninit
8083	\|\| getObjectState().getState() == ObjectState::Limited);
8084
8085	/* tell all our other child objects we've been uninitialized */
8086	if (mGuestDebugControl)
8087	{
8088	mGuestDebugControl->uninit();
8089	unconst(mGuestDebugControl).setNull();
8090	}
8091
8092	if (mBandwidthControl)
8093	{
8094	mBandwidthControl->uninit();
8095	unconst(mBandwidthControl).setNull();
8096	}
8097
8098	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
8099	{
8100	if (mNetworkAdapters[slot])
8101	{
8102	mNetworkAdapters[slot]->uninit();
8103	unconst(mNetworkAdapters[slot]).setNull();
8104	}
8105	}
8106
8107	if (mUSBDeviceFilters)
8108	{
8109	mUSBDeviceFilters->uninit();
8110	unconst(mUSBDeviceFilters).setNull();
8111	}
8112
8113	if (mAudioSettings)
8114	{
8115	mAudioSettings->uninit();
8116	unconst(mAudioSettings).setNull();
8117	}
8118
8119	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
8120	{
8121	if (mParallelPorts[slot])
8122	{
8123	mParallelPorts[slot]->uninit();
8124	unconst(mParallelPorts[slot]).setNull();
8125	}
8126	}
8127
8128	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
8129	{
8130	if (mSerialPorts[slot])
8131	{
8132	mSerialPorts[slot]->uninit();
8133	unconst(mSerialPorts[slot]).setNull();
8134	}
8135	}
8136
8137	if (mVRDEServer)
8138	{
8139	mVRDEServer->uninit();
8140	unconst(mVRDEServer).setNull();
8141	}
8142
8143	if (mGraphicsAdapter)
8144	{
8145	mGraphicsAdapter->uninit();
8146	unconst(mGraphicsAdapter).setNull();
8147	}
8148
8149	if (mPlatform)
8150	{
8151	mPlatform->uninit();
8152	unconst(mPlatform).setNull();
8153	}
8154
8155	if (mPlatformProperties)
8156	{
8157	mPlatformProperties->uninit();
8158	unconst(mPlatformProperties).setNull();
8159	}
8160
8161	if (mFirmwareSettings)
8162	{
8163	mFirmwareSettings->uninit();
8164	unconst(mFirmwareSettings).setNull();
8165	}
8166
8167	if (mRecordingSettings)
8168	{
8169	mRecordingSettings->uninit();
8170	unconst(mRecordingSettings).setNull();
8171	}
8172
8173	if (mTrustedPlatformModule)
8174	{
8175	mTrustedPlatformModule->uninit();
8176	unconst(mTrustedPlatformModule).setNull();
8177	}
8178
8179	if (mNvramStore)
8180	{
8181	mNvramStore->uninit();
8182	unconst(mNvramStore).setNull();
8183	}
8184
8185	/* Deassociate media (only when a real Machine or a SnapshotMachine
8186	* instance is uninitialized; SessionMachine instances refer to real
8187	* Machine media). This is necessary for a clean re-initialization of
8188	* the VM after successfully re-checking the accessibility state. Note
8189	* that in case of normal Machine or SnapshotMachine uninitialization (as
8190	* a result of unregistering or deleting the snapshot), outdated media
8191	* attachments will already be uninitialized and deleted, so this
8192	* code will not affect them. */
8193	if ( !mMediumAttachments.isNull()
8194	&& !i_isSessionMachine()
8195	)
8196	{
8197	for (MediumAttachmentList::const_iterator
8198	it = mMediumAttachments->begin();
8199	it != mMediumAttachments->end();
8200	++it)
8201	{
8202	ComObjPtr<Medium> pMedium = (*it)->i_getMedium();
8203	if (pMedium.isNull())
8204	continue;
8205	HRESULT hrc = pMedium->i_removeBackReference(mData->mUuid, i_getSnapshotId());
8206	AssertComRC(hrc);
8207	}
8208	}
8209
8210	if (!i_isSessionMachine() && !i_isSnapshotMachine())
8211	{
8212	// clean up the snapshots list (Snapshot::uninit() will handle the snapshot's children)
8213	if (mData->mFirstSnapshot)
8214	{
8215	// Snapshots tree is protected by machine write lock.
8216	// Otherwise we assert in Snapshot::uninit()
8217	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8218	mData->mFirstSnapshot->uninit();
8219	mData->mFirstSnapshot.setNull();
8220	}
8221
8222	mData->mCurrentSnapshot.setNull();
8223	}
8224
8225	/* free data structures (the essential mData structure is not freed here
8226	* since it may be still in use) */
8227	mMediumAttachments.free();
8228	mStorageControllers.free();
8229	mUSBControllers.free();
8230	mHWData.free();
8231	mUserData.free();
8232	mSSData.free();
8233	}
8234
8235	/**
8236	* Returns a pointer to the Machine object for this machine that acts like a
8237	* parent for complex machine data objects such as shared folders, etc.
8238	*
8239	* For primary Machine objects and for SnapshotMachine objects, returns this
8240	* object's pointer itself. For SessionMachine objects, returns the peer
8241	* (primary) machine pointer.
8242	*/
8243	Machine *Machine::i_getMachine()
8244	{
8245	if (i_isSessionMachine())
8246	return (Machine*)mPeer;
8247	return this;
8248	}
8249
8250	/**
8251	* Makes sure that there are no machine state dependents. If necessary, waits
8252	* for the number of dependents to drop to zero.
8253	*
8254	* Make sure this method is called from under this object's write lock to
8255	* guarantee that no new dependents may be added when this method returns
8256	* control to the caller.
8257	*
8258	* @note Receives a lock to this object for writing. The lock will be released
8259	* while waiting (if necessary).
8260	*
8261	* @warning To be used only in methods that change the machine state!
8262	*/
8263	void Machine::i_ensureNoStateDependencies(AutoWriteLock &alock)
8264	{
8265	AssertReturnVoid(isWriteLockOnCurrentThread());
8266
8267	/* Wait for all state dependents if necessary */
8268	if (mData->mMachineStateDeps != 0)
8269	{
8270	/* lazy semaphore creation */
8271	if (mData->mMachineStateDepsSem == NIL_RTSEMEVENTMULTI)
8272	RTSemEventMultiCreate(&mData->mMachineStateDepsSem);
8273
8274	LogFlowThisFunc(("Waiting for state deps (%d) to drop to zero...\n",
8275	mData->mMachineStateDeps));
8276
8277	++mData->mMachineStateChangePending;
8278
8279	/* reset the semaphore before waiting, the last dependent will signal
8280	* it */
8281	RTSemEventMultiReset(mData->mMachineStateDepsSem);
8282
8283	alock.release();
8284
8285	RTSemEventMultiWait(mData->mMachineStateDepsSem, RT_INDEFINITE_WAIT);
8286
8287	alock.acquire();
8288
8289	-- mData->mMachineStateChangePending;
8290	}
8291	}
8292
8293	/**
8294	* Changes the machine state and informs callbacks.
8295	*
8296	* This method is not intended to fail so it either returns S_OK or asserts (and
8297	* returns a failure).
8298	*
8299	* @note Locks this object for writing.
8300	*/
8301	HRESULT Machine::i_setMachineState(MachineState_T aMachineState)
8302	{
8303	LogFlowThisFuncEnter();
8304	LogFlowThisFunc(("aMachineState=%s\n", ::stringifyMachineState(aMachineState) ));
8305	Assert(aMachineState != MachineState_Null);
8306
8307	AutoCaller autoCaller(this);
8308	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
8309
8310	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8311
8312	/* wait for state dependents to drop to zero */
8313	i_ensureNoStateDependencies(alock);
8314
8315	MachineState_T const enmOldState = mData->mMachineState;
8316	if (enmOldState != aMachineState)
8317	{
8318	mData->mMachineState = aMachineState;
8319	RTTimeNow(&mData->mLastStateChange);
8320
8321	#ifdef VBOX_WITH_DTRACE_R3_MAIN
8322	VBOXAPI_MACHINE_STATE_CHANGED(this, aMachineState, enmOldState, mData->mUuid.toStringCurly().c_str());
8323	#endif
8324	mParent->i_onMachineStateChanged(mData->mUuid, aMachineState);
8325	}
8326
8327	LogFlowThisFuncLeave();
8328	return S_OK;
8329	}
8330
8331	/**
8332	* Searches for a shared folder with the given logical name
8333	* in the collection of shared folders.
8334	*
8335	* @param aName logical name of the shared folder
8336	* @param aSharedFolder where to return the found object
8337	* @param aSetError whether to set the error info if the folder is
8338	* not found
8339	* @return
8340	* S_OK when found or VBOX_E_OBJECT_NOT_FOUND when not found
8341	*
8342	* @note
8343	* must be called from under the object's lock!
8344	*/
8345	HRESULT Machine::i_findSharedFolder(const Utf8Str &aName,
8346	ComObjPtr<SharedFolder> &aSharedFolder,
8347	bool aSetError /* = false */)
8348	{
8349	HRESULT hrc = VBOX_E_OBJECT_NOT_FOUND;
8350	for (HWData::SharedFolderList::const_iterator
8351	it = mHWData->mSharedFolders.begin();
8352	it != mHWData->mSharedFolders.end();
8353	++it)
8354	{
8355	SharedFolder pSF = it;
8356	AutoCaller autoCaller(pSF);
8357	if (pSF->i_getName() == aName)
8358	{
8359	aSharedFolder = pSF;
8360	hrc = S_OK;
8361	break;
8362	}
8363	}
8364
8365	if (aSetError && FAILED(hrc))
8366	setError(hrc, tr("Could not find a shared folder named '%s'"), aName.c_str());
8367
8368	return hrc;
8369	}
8370
8371	/**
8372	* Initializes all machine instance data from the given settings structures
8373	* from XML. The exception is the machine UUID which needs special handling
8374	* depending on the caller's use case, so the caller needs to set that herself.
8375	*
8376	* This gets called in several contexts during machine initialization:
8377	*
8378	* -- When machine XML exists on disk already and needs to be loaded into memory,
8379	* for example, from #i_registeredInit() to load all registered machines on
8380	* VirtualBox startup. In this case, puuidRegistry is NULL because the media
8381	* attached to the machine should be part of some media registry already.
8382	*
8383	* -- During OVF import, when a machine config has been constructed from an
8384	* OVF file. In this case, puuidRegistry is set to the machine UUID to
8385	* ensure that the media listed as attachments in the config (which have
8386	* been imported from the OVF) receive the correct registry ID.
8387	*
8388	* -- During VM cloning.
8389	*
8390	* @param config Machine settings from XML.
8391	* @param puuidRegistry If != NULL, Medium::setRegistryIdIfFirst() gets called with this registry ID
8392	* for each attached medium in the config.
8393	* @return
8394	*/
8395	HRESULT Machine::i_loadMachineDataFromSettings(const settings::MachineConfigFile &config,
8396	const Guid *puuidRegistry)
8397	{
8398	// copy name, description, OS type, teleporter, UTC etc.
8399	mUserData->s = config.machineUserData;
8400
8401	// look up the object by Id to check it is valid
8402	ComObjPtr<GuestOSType> pGuestOSType;
8403	mParent->i_findGuestOSType(mUserData->s.strOsType, pGuestOSType);
8404	if (!pGuestOSType.isNull())
8405	mUserData->s.strOsType = pGuestOSType->i_id();
8406
8407	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
8408	// stateFile encryption (optional)
8409	mSSData->strStateKeyId = config.strStateKeyId;
8410	mSSData->strStateKeyStore = config.strStateKeyStore;
8411	mData->mstrLogKeyId = config.strLogKeyId;
8412	mData->mstrLogKeyStore = config.strLogKeyStore;
8413	#endif
8414
8415	// stateFile (optional)
8416	if (config.strStateFile.isEmpty())
8417	mSSData->strStateFilePath.setNull();
8418	else
8419	{
8420	Utf8Str stateFilePathFull(config.strStateFile);
8421	int vrc = i_calculateFullPath(stateFilePathFull, stateFilePathFull);
8422	if (RT_FAILURE(vrc))
8423	return setErrorBoth(E_FAIL, vrc,
8424	tr("Invalid saved state file path '%s' (%Rrc)"),
8425	config.strStateFile.c_str(),
8426	vrc);
8427	mSSData->strStateFilePath = stateFilePathFull;
8428	}
8429
8430	// snapshot folder needs special processing so set it again
8431	HRESULT hrc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder).raw());
8432	if (FAILED(hrc)) return hrc;
8433
8434	/* Copy the extra data items (config may or may not be the same as
8435	* mData->pMachineConfigFile) if necessary. When loading the XML files
8436	* from disk they are the same, but not for OVF import. */
8437	if (mData->pMachineConfigFile != &config)
8438	mData->pMachineConfigFile->mapExtraDataItems = config.mapExtraDataItems;
8439
8440	/* currentStateModified (optional, default is true) */
8441	mData->mCurrentStateModified = config.fCurrentStateModified;
8442
8443	mData->mLastStateChange = config.timeLastStateChange;
8444
8445	/*
8446	* note: all mUserData members must be assigned prior this point because
8447	* we need to commit changes in order to let mUserData be shared by all
8448	* snapshot machine instances.
8449	*/
8450	mUserData.commitCopy();
8451
8452	// machine registry, if present (must be loaded before snapshots)
8453	if (config.canHaveOwnMediaRegistry())
8454	{
8455	// determine machine folder
8456	Utf8Str strMachineFolder = i_getSettingsFileFull();
8457	strMachineFolder.stripFilename();
8458	hrc = mParent->initMedia(i_getId(), // media registry ID == machine UUID
8459	config.mediaRegistry,
8460	strMachineFolder);
8461	if (FAILED(hrc)) return hrc;
8462	}
8463
8464	/* Snapshot node (optional) */
8465	size_t cRootSnapshots;
8466	if ((cRootSnapshots = config.llFirstSnapshot.size()))
8467	{
8468	// there must be only one root snapshot
8469	Assert(cRootSnapshots == 1);
8470	const settings::Snapshot &snap = config.llFirstSnapshot.front();
8471
8472	hrc = i_loadSnapshot(snap, config.uuidCurrentSnapshot);
8473	if (FAILED(hrc)) return hrc;
8474	}
8475
8476	// hardware data
8477	hrc = i_loadHardware(puuidRegistry, NULL, config.hardwareMachine, &config.debugging, &config.autostart,
8478	config.recordingSettings);
8479	if (FAILED(hrc)) return hrc;
8480
8481	/*
8482	* NOTE: the assignment below must be the last thing to do,
8483	* otherwise it will be not possible to change the settings
8484	* somewhere in the code above because all setters will be
8485	* blocked by i_checkStateDependency(MutableStateDep).
8486	*/
8487
8488	/* set the machine state to either Aborted-Saved, Aborted, or Saved if appropriate */
8489	if (config.fAborted && !mSSData->strStateFilePath.isEmpty())
8490	{
8491	/* no need to use i_setMachineState() during init() */
8492	mData->mMachineState = MachineState_AbortedSaved;
8493	}
8494	else if (config.fAborted)
8495	{
8496	mSSData->strStateFilePath.setNull();
8497
8498	/* no need to use i_setMachineState() during init() */
8499	mData->mMachineState = MachineState_Aborted;
8500	}
8501	else if (!mSSData->strStateFilePath.isEmpty())
8502	{
8503	/* no need to use i_setMachineState() during init() */
8504	mData->mMachineState = MachineState_Saved;
8505	}
8506
8507	// after loading settings, we are no longer different from the XML on disk
8508	mData->flModifications = 0;
8509
8510	return S_OK;
8511	}
8512
8513	/**
8514	* Loads all snapshots starting from the given settings.
8515	*
8516	* @param data snapshot settings.
8517	* @param aCurSnapshotId Current snapshot ID from the settings file.
8518	*/
8519	HRESULT Machine::i_loadSnapshot(const settings::Snapshot &data,
8520	const Guid &aCurSnapshotId)
8521	{
8522	AssertReturn(!i_isSnapshotMachine(), E_FAIL);
8523	AssertReturn(!i_isSessionMachine(), E_FAIL);
8524
8525	HRESULT hrc = S_OK;
8526
8527	std::list<const settings::Snapshot *> llSettingsTodo;
8528	llSettingsTodo.push_back(&data);
8529	std::list<Snapshot *> llParentsTodo;
8530	llParentsTodo.push_back(NULL);
8531
8532	while (llSettingsTodo.size() > 0)
8533	{
8534	const settings::Snapshot *current = llSettingsTodo.front();
8535	llSettingsTodo.pop_front();
8536	Snapshot *pParent = llParentsTodo.front();
8537	llParentsTodo.pop_front();
8538
8539	Utf8Str strStateFile;
8540	if (!current->strStateFile.isEmpty())
8541	{
8542	/* optional */
8543	strStateFile = current->strStateFile;
8544	int vrc = i_calculateFullPath(strStateFile, strStateFile);
8545	if (RT_FAILURE(vrc))
8546	{
8547	setErrorBoth(E_FAIL, vrc,
8548	tr("Invalid saved state file path '%s' (%Rrc)"),
8549	strStateFile.c_str(), vrc);
8550	}
8551	}
8552
8553	/* create a snapshot machine object */
8554	ComObjPtr<SnapshotMachine> pSnapshotMachine;
8555	pSnapshotMachine.createObject();
8556	hrc = pSnapshotMachine->initFromSettings(this,
8557	current->hardware,
8558	&current->debugging,
8559	&current->autostart,
8560	current->recordingSettings,
8561	current->uuid.ref(),
8562	strStateFile);
8563	if (FAILED(hrc)) break;
8564
8565	/* create a snapshot object */
8566	ComObjPtr<Snapshot> pSnapshot;
8567	pSnapshot.createObject();
8568	/* initialize the snapshot */
8569	hrc = pSnapshot->init(mParent, // VirtualBox object
8570	current->uuid,
8571	current->strName,
8572	current->strDescription,
8573	current->timestamp,
8574	pSnapshotMachine,
8575	pParent);
8576	if (FAILED(hrc)) break;
8577
8578	/* memorize the first snapshot if necessary */
8579	if (!mData->mFirstSnapshot)
8580	{
8581	Assert(pParent == NULL);
8582	mData->mFirstSnapshot = pSnapshot;
8583	}
8584
8585	/* memorize the current snapshot when appropriate */
8586	if ( !mData->mCurrentSnapshot
8587	&& pSnapshot->i_getId() == aCurSnapshotId
8588	)
8589	mData->mCurrentSnapshot = pSnapshot;
8590
8591	/* create all children */
8592	std::list<settings::Snapshot>::const_iterator itBegin = current->llChildSnapshots.begin();
8593	std::list<settings::Snapshot>::const_iterator itEnd = current->llChildSnapshots.end();
8594	for (std::list<settings::Snapshot>::const_iterator it = itBegin; it != itEnd; ++it)
8595	{
8596	llSettingsTodo.push_back(&*it);
8597	llParentsTodo.push_back(pSnapshot);
8598	}
8599	}
8600
8601	return hrc;
8602	}
8603
8604	/**
8605	* Loads settings into mHWData.
8606	*
8607	* @param puuidRegistry Registry ID.
8608	* @param puuidSnapshot Snapshot ID
8609	* @param data Reference to the hardware settings.
8610	* @param pDbg Pointer to the debugging settings.
8611	* @param pAutostart Pointer to the autostart settings
8612	* @param recording Reference to recording settings.
8613	*/
8614	HRESULT Machine::i_loadHardware(const Guid *puuidRegistry,
8615	const Guid *puuidSnapshot,
8616	const settings::Hardware &data,
8617	const settings::Debugging *pDbg,
8618	const settings::Autostart *pAutostart,
8619	const settings::RecordingSettings &recording)
8620	{
8621	AssertReturn(!i_isSessionMachine(), E_FAIL);
8622
8623	HRESULT hrc = S_OK;
8624
8625	try
8626	{
8627	ComObjPtr<GuestOSType> pGuestOSType;
8628	mParent->i_findGuestOSType(mUserData->s.strOsType, pGuestOSType);
8629
8630	/* The hardware version attribute (optional). */
8631	mHWData->mHWVersion = data.strVersion;
8632	mHWData->mHardwareUUID = data.uuid;
8633
8634	mHWData->mCPUCount = data.cCPUs;
8635	mHWData->mCPUHotPlugEnabled = data.fCpuHotPlug;
8636	mHWData->mCpuExecutionCap = data.ulCpuExecutionCap;
8637	mHWData->mCpuIdPortabilityLevel = data.uCpuIdPortabilityLevel;
8638	mHWData->mCpuProfile = data.strCpuProfile;
8639
8640	// cpu
8641	if (mHWData->mCPUHotPlugEnabled)
8642	{
8643	for (settings::CpuList::const_iterator
8644	it = data.llCpus.begin();
8645	it != data.llCpus.end();
8646	++it)
8647	{
8648	const settings::Cpu &cpu = *it;
8649
8650	mHWData->mCPUAttached[cpu.ulId] = true;
8651	}
8652	}
8653
8654	mHWData->mMemorySize = data.ulMemorySizeMB;
8655	mHWData->mPageFusionEnabled = data.fPageFusionEnabled;
8656
8657	// boot order
8658	for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mBootOrder); ++i)
8659	{
8660	settings::BootOrderMap::const_iterator it = data.mapBootOrder.find(i);
8661	if (it == data.mapBootOrder.end())
8662	mHWData->mBootOrder[i] = DeviceType_Null;
8663	else
8664	mHWData->mBootOrder[i] = it->second;
8665	}
8666
8667	mHWData->mPointingHIDType = data.pointingHIDType;
8668	mHWData->mKeyboardHIDType = data.keyboardHIDType;
8669	mHWData->mParavirtProvider = data.paravirtProvider;
8670	mHWData->mParavirtDebug = data.strParavirtDebug;
8671	mHWData->mEmulatedUSBCardReaderEnabled = data.fEmulatedUSBCardReader;
8672
8673	/* GraphicsAdapter */
8674	hrc = mGraphicsAdapter->i_loadSettings(data.graphicsAdapter);
8675	if (FAILED(hrc)) return hrc;
8676
8677	/* VRDEServer */
8678	hrc = mVRDEServer->i_loadSettings(data.vrdeSettings);
8679	if (FAILED(hrc)) return hrc;
8680
8681	/* Platform */
8682	hrc = mPlatform->i_loadSettings(data.platformSettings);
8683	if (FAILED(hrc)) return hrc;
8684
8685	i_platformPropertiesUpdate();
8686
8687	/* Firmware */
8688	hrc = mFirmwareSettings->i_loadSettings(data.firmwareSettings);
8689	if (FAILED(hrc)) return hrc;
8690
8691	/* Recording */
8692	hrc = mRecordingSettings->i_loadSettings(recording);
8693	if (FAILED(hrc)) return hrc;
8694
8695	/* Trusted Platform Module */
8696	hrc = mTrustedPlatformModule->i_loadSettings(data.tpmSettings);
8697	if (FAILED(hrc)) return hrc;
8698
8699	hrc = mNvramStore->i_loadSettings(data.nvramSettings);
8700	if (FAILED(hrc)) return hrc;
8701
8702	// Bandwidth control (must come before network adapters)
8703	hrc = mBandwidthControl->i_loadSettings(data.ioSettings);
8704	if (FAILED(hrc)) return hrc;
8705
8706	/* USB controllers */
8707	for (settings::USBControllerList::const_iterator
8708	it = data.usbSettings.llUSBControllers.begin();
8709	it != data.usbSettings.llUSBControllers.end();
8710	++it)
8711	{
8712	const settings::USBController &settingsCtrl = *it;
8713	ComObjPtr<USBController> newCtrl;
8714
8715	newCtrl.createObject();
8716	newCtrl->init(this, settingsCtrl.strName, settingsCtrl.enmType);
8717	mUSBControllers->push_back(newCtrl);
8718	}
8719
8720	/* USB device filters */
8721	hrc = mUSBDeviceFilters->i_loadSettings(data.usbSettings);
8722	if (FAILED(hrc)) return hrc;
8723
8724	// network adapters (establish array size first and apply defaults, to
8725	// ensure reading the same settings as we saved, since the list skips
8726	// adapters having defaults)
8727	size_t const newCount = PlatformProperties::s_getMaxNetworkAdapters(data.platformSettings.chipsetType);
8728	size_t const oldCount = mNetworkAdapters.size();
8729	if (newCount > oldCount)
8730	{
8731	mNetworkAdapters.resize(newCount);
8732	for (size_t slot = oldCount; slot < mNetworkAdapters.size(); ++slot)
8733	{
8734	unconst(mNetworkAdapters[slot]).createObject();
8735	mNetworkAdapters[slot]->init(this, (ULONG)slot);
8736	}
8737	}
8738	else if (newCount < oldCount)
8739	mNetworkAdapters.resize(newCount);
8740	for (unsigned i = 0; i < mNetworkAdapters.size(); i++)
8741	mNetworkAdapters[i]->i_applyDefaults(pGuestOSType);
8742	for (settings::NetworkAdaptersList::const_iterator
8743	it = data.llNetworkAdapters.begin();
8744	it != data.llNetworkAdapters.end();
8745	++it)
8746	{
8747	const settings::NetworkAdapter &nic = *it;
8748
8749	/* slot uniqueness is guaranteed by XML Schema */
8750	AssertBreak(nic.ulSlot < mNetworkAdapters.size());
8751	hrc = mNetworkAdapters[nic.ulSlot]->i_loadSettings(mBandwidthControl, nic);
8752	if (FAILED(hrc)) return hrc;
8753	}
8754
8755	// serial ports (establish defaults first, to ensure reading the same
8756	// settings as we saved, since the list skips ports having defaults)
8757	for (unsigned i = 0; i < RT_ELEMENTS(mSerialPorts); i++)
8758	mSerialPorts[i]->i_applyDefaults(pGuestOSType);
8759	for (settings::SerialPortsList::const_iterator
8760	it = data.llSerialPorts.begin();
8761	it != data.llSerialPorts.end();
8762	++it)
8763	{
8764	const settings::SerialPort &s = *it;
8765
8766	AssertBreak(s.ulSlot < RT_ELEMENTS(mSerialPorts));
8767	hrc = mSerialPorts[s.ulSlot]->i_loadSettings(s);
8768	if (FAILED(hrc)) return hrc;
8769	}
8770
8771	// parallel ports (establish defaults first, to ensure reading the same
8772	// settings as we saved, since the list skips ports having defaults)
8773	for (unsigned i = 0; i < RT_ELEMENTS(mParallelPorts); i++)
8774	mParallelPorts[i]->i_applyDefaults();
8775	for (settings::ParallelPortsList::const_iterator
8776	it = data.llParallelPorts.begin();
8777	it != data.llParallelPorts.end();
8778	++it)
8779	{
8780	const settings::ParallelPort &p = *it;
8781
8782	AssertBreak(p.ulSlot < RT_ELEMENTS(mParallelPorts));
8783	hrc = mParallelPorts[p.ulSlot]->i_loadSettings(p);
8784	if (FAILED(hrc)) return hrc;
8785	}
8786
8787	/* Audio settings */
8788	hrc = mAudioSettings->i_loadSettings(data.audioAdapter);
8789	if (FAILED(hrc)) return hrc;
8790
8791	/* storage controllers */
8792	hrc = i_loadStorageControllers(data.storage, puuidRegistry, puuidSnapshot);
8793	if (FAILED(hrc)) return hrc;
8794
8795	/* Shared folders */
8796	for (settings::SharedFoldersList::const_iterator
8797	it = data.llSharedFolders.begin();
8798	it != data.llSharedFolders.end();
8799	++it)
8800	{
8801	const settings::SharedFolder &sf = *it;
8802
8803	ComObjPtr<SharedFolder> sharedFolder;
8804	/* Check for double entries. Not allowed! */
8805	hrc = i_findSharedFolder(sf.strName, sharedFolder, false /* aSetError */);
8806	if (SUCCEEDED(hrc))
8807	return setError(VBOX_E_OBJECT_IN_USE,
8808	tr("Shared folder named '%s' already exists"),
8809	sf.strName.c_str());
8810
8811	/* Create the new shared folder. Don't break on error. This will be
8812	* reported when the machine starts. */
8813	sharedFolder.createObject();
8814	hrc = sharedFolder->init(i_getMachine(),
8815	sf.strName,
8816	sf.strHostPath,
8817	RT_BOOL(sf.fWritable),
8818	RT_BOOL(sf.fAutoMount),
8819	sf.strAutoMountPoint,
8820	false /* fFailOnError */);
8821	if (FAILED(hrc)) return hrc;
8822	mHWData->mSharedFolders.push_back(sharedFolder);
8823	}
8824
8825	// Clipboard
8826	mHWData->mClipboardMode = data.clipboardMode;
8827	mHWData->mClipboardFileTransfersEnabled = data.fClipboardFileTransfersEnabled ? TRUE : FALSE;
8828
8829	// drag'n'drop
8830	mHWData->mDnDMode = data.dndMode;
8831
8832	// guest settings
8833	mHWData->mMemoryBalloonSize = data.ulMemoryBalloonSize;
8834
8835	// IO settings
8836	mHWData->mIOCacheEnabled = data.ioSettings.fIOCacheEnabled;
8837	mHWData->mIOCacheSize = data.ioSettings.ulIOCacheSize;
8838
8839	// Host PCI devices
8840	for (settings::HostPCIDeviceAttachmentList::const_iterator
8841	it = data.pciAttachments.begin();
8842	it != data.pciAttachments.end();
8843	++it)
8844	{
8845	const settings::HostPCIDeviceAttachment &hpda = *it;
8846	ComObjPtr<PCIDeviceAttachment> pda;
8847
8848	pda.createObject();
8849	pda->i_loadSettings(this, hpda);
8850	mHWData->mPCIDeviceAssignments.push_back(pda);
8851	}
8852
8853	/*
8854	* (The following isn't really real hardware, but it lives in HWData
8855	* for reasons of convenience.)
8856	*/
8857
8858	#ifdef VBOX_WITH_GUEST_PROPS
8859	/* Guest properties (optional) */
8860
8861	/* Only load transient guest properties for configs which have saved
8862	* state, because there shouldn't be any for powered off VMs. The same
8863	* logic applies for snapshots, as offline snapshots shouldn't have
8864	* any such properties. They confuse the code in various places.
8865	* Note: can't rely on the machine state, as it isn't set yet. */
8866	bool fSkipTransientGuestProperties = mSSData->strStateFilePath.isEmpty();
8867	/* apologies for the hacky unconst() usage, but this needs hacking
8868	* actually inconsistent settings into consistency, otherwise there
8869	* will be some corner cases where the inconsistency survives
8870	* surprisingly long without getting fixed, especially for snapshots
8871	* as there are no config changes. */
8872	settings::GuestPropertiesList &llGuestProperties = unconst(data.llGuestProperties);
8873	for (settings::GuestPropertiesList::iterator
8874	it = llGuestProperties.begin();
8875	it != llGuestProperties.end();
8876	/nothing/)
8877	{
8878	const settings::GuestProperty &prop = *it;
8879	uint32_t fFlags = GUEST_PROP_F_NILFLAG;
8880	GuestPropValidateFlags(prop.strFlags.c_str(), &fFlags);
8881	if ( fSkipTransientGuestProperties
8882	&& ( fFlags & GUEST_PROP_F_TRANSIENT
8883	\|\| fFlags & GUEST_PROP_F_TRANSRESET))
8884	{
8885	it = llGuestProperties.erase(it);
8886	continue;
8887	}
8888	HWData::GuestProperty property = { prop.strValue, (LONG64) prop.timestamp, fFlags };
8889	mHWData->mGuestProperties[prop.strName] = property;
8890	++it;
8891	}
8892	#endif /* VBOX_WITH_GUEST_PROPS defined */
8893
8894	hrc = i_loadDebugging(pDbg);
8895	if (FAILED(hrc))
8896	return hrc;
8897
8898	mHWData->mAutostart = *pAutostart;
8899
8900	/* default frontend */
8901	mHWData->mDefaultFrontend = data.strDefaultFrontend;
8902	}
8903	catch (std::bad_alloc &)
8904	{
8905	return E_OUTOFMEMORY;
8906	}
8907
8908	AssertComRC(hrc);
8909	return hrc;
8910	}
8911
8912	/**
8913	* Called from i_loadHardware() to load the debugging settings of the
8914	* machine.
8915	*
8916	* @param pDbg Pointer to the settings.
8917	*/
8918	HRESULT Machine::i_loadDebugging(const settings::Debugging *pDbg)
8919	{
8920	mHWData->mDebugging = *pDbg;
8921	/* no more processing currently required, this will probably change. */
8922
8923	HRESULT hrc = mGuestDebugControl->i_loadSettings(*pDbg);
8924	if (FAILED(hrc)) return hrc;
8925
8926	return S_OK;
8927	}
8928
8929	/**
8930	* Called from i_loadMachineDataFromSettings() for the storage controller data, including media.
8931	*
8932	* @param data storage settings.
8933	* @param puuidRegistry media registry ID to set media to or NULL;
8934	* see Machine::i_loadMachineDataFromSettings()
8935	* @param puuidSnapshot snapshot ID
8936	* @return
8937	*/
8938	HRESULT Machine::i_loadStorageControllers(const settings::Storage &data,
8939	const Guid *puuidRegistry,
8940	const Guid *puuidSnapshot)
8941	{
8942	AssertReturn(!i_isSessionMachine(), E_FAIL);
8943
8944	HRESULT hrc = S_OK;
8945
8946	for (settings::StorageControllersList::const_iterator
8947	it = data.llStorageControllers.begin();
8948	it != data.llStorageControllers.end();
8949	++it)
8950	{
8951	const settings::StorageController &ctlData = *it;
8952
8953	ComObjPtr<StorageController> pCtl;
8954	/* Try to find one with the name first. */
8955	hrc = i_getStorageControllerByName(ctlData.strName, pCtl, false /* aSetError */);
8956	if (SUCCEEDED(hrc))
8957	return setError(VBOX_E_OBJECT_IN_USE,
8958	tr("Storage controller named '%s' already exists"),
8959	ctlData.strName.c_str());
8960
8961	pCtl.createObject();
8962	hrc = pCtl->init(this, ctlData.strName, ctlData.storageBus, ctlData.ulInstance, ctlData.fBootable);
8963	if (FAILED(hrc)) return hrc;
8964
8965	mStorageControllers->push_back(pCtl);
8966
8967	hrc = pCtl->COMSETTER(ControllerType)(ctlData.controllerType);
8968	if (FAILED(hrc)) return hrc;
8969
8970	hrc = pCtl->COMSETTER(PortCount)(ctlData.ulPortCount);
8971	if (FAILED(hrc)) return hrc;
8972
8973	hrc = pCtl->COMSETTER(UseHostIOCache)(ctlData.fUseHostIOCache);
8974	if (FAILED(hrc)) return hrc;
8975
8976	/* Load the attached devices now. */
8977	hrc = i_loadStorageDevices(pCtl, ctlData, puuidRegistry, puuidSnapshot);
8978	if (FAILED(hrc)) return hrc;
8979	}
8980
8981	return S_OK;
8982	}
8983
8984	/**
8985	* Called from i_loadStorageControllers for a controller's devices.
8986	*
8987	* @param aStorageController
8988	* @param data
8989	* @param puuidRegistry media registry ID to set media to or NULL; see
8990	* Machine::i_loadMachineDataFromSettings()
8991	* @param puuidSnapshot pointer to the snapshot ID if this is a snapshot machine
8992	* @return
8993	*/
8994	HRESULT Machine::i_loadStorageDevices(StorageController *aStorageController,
8995	const settings::StorageController &data,
8996	const Guid *puuidRegistry,
8997	const Guid *puuidSnapshot)
8998	{
8999	HRESULT hrc = S_OK;
9000
9001	/* paranoia: detect duplicate attachments */
9002	for (settings::AttachedDevicesList::const_iterator
9003	it = data.llAttachedDevices.begin();
9004	it != data.llAttachedDevices.end();
9005	++it)
9006	{
9007	const settings::AttachedDevice &ad = *it;
9008
9009	for (settings::AttachedDevicesList::const_iterator it2 = it;
9010	it2 != data.llAttachedDevices.end();
9011	++it2)
9012	{
9013	if (it == it2)
9014	continue;
9015
9016	const settings::AttachedDevice &ad2 = *it2;
9017
9018	if ( ad.lPort == ad2.lPort
9019	&& ad.lDevice == ad2.lDevice)
9020	{
9021	return setError(E_FAIL,
9022	tr("Duplicate attachments for storage controller '%s', port %d, device %d of the virtual machine '%s'"),
9023	aStorageController->i_getName().c_str(),
9024	ad.lPort,
9025	ad.lDevice,
9026	mUserData->s.strName.c_str());
9027	}
9028	}
9029	}
9030
9031	for (settings::AttachedDevicesList::const_iterator
9032	it = data.llAttachedDevices.begin();
9033	it != data.llAttachedDevices.end();
9034	++it)
9035	{
9036	const settings::AttachedDevice &dev = *it;
9037	ComObjPtr<Medium> medium;
9038
9039	switch (dev.deviceType)
9040	{
9041	case DeviceType_Floppy:
9042	case DeviceType_DVD:
9043	if (dev.strHostDriveSrc.isNotEmpty())
9044	hrc = mParent->i_host()->i_findHostDriveByName(dev.deviceType, dev.strHostDriveSrc,
9045	false /* fRefresh */, medium);
9046	else
9047	hrc = mParent->i_findRemoveableMedium(dev.deviceType,
9048	dev.uuid,
9049	false /* fRefresh */,
9050	false /* aSetError */,
9051	medium);
9052	if (hrc == VBOX_E_OBJECT_NOT_FOUND)
9053	// This is not an error. The host drive or UUID might have vanished, so just go
9054	// ahead without this removeable medium attachment
9055	hrc = S_OK;
9056	break;
9057
9058	case DeviceType_HardDisk:
9059	{
9060	/* find a hard disk by UUID */
9061	hrc = mParent->i_findHardDiskById(dev.uuid, true /* aDoSetError */, &medium);
9062	if (FAILED(hrc))
9063	{
9064	if (i_isSnapshotMachine())
9065	{
9066	// wrap another error message around the "cannot find hard disk" set by findHardDisk
9067	// so the user knows that the bad disk is in a snapshot somewhere
9068	com::ErrorInfo info;
9069	return setError(E_FAIL,
9070	tr("A differencing image of snapshot {%RTuuid} could not be found. %ls"),
9071	puuidSnapshot->raw(),
9072	info.getText().raw());
9073	}
9074	return hrc;
9075	}
9076
9077	AutoWriteLock hdLock(medium COMMA_LOCKVAL_SRC_POS);
9078
9079	if (medium->i_getType() == MediumType_Immutable)
9080	{
9081	if (i_isSnapshotMachine())
9082	return setError(E_FAIL,
9083	tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
9084	"of the virtual machine '%s' ('%s')"),
9085	medium->i_getLocationFull().c_str(),
9086	dev.uuid.raw(),
9087	puuidSnapshot->raw(),
9088	mUserData->s.strName.c_str(),
9089	mData->m_strConfigFileFull.c_str());
9090
9091	return setError(E_FAIL,
9092	tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
9093	medium->i_getLocationFull().c_str(),
9094	dev.uuid.raw(),
9095	mUserData->s.strName.c_str(),
9096	mData->m_strConfigFileFull.c_str());
9097	}
9098
9099	if (medium->i_getType() == MediumType_MultiAttach)
9100	{
9101	if (i_isSnapshotMachine())
9102	return setError(E_FAIL,
9103	tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
9104	"of the virtual machine '%s' ('%s')"),
9105	medium->i_getLocationFull().c_str(),
9106	dev.uuid.raw(),
9107	puuidSnapshot->raw(),
9108	mUserData->s.strName.c_str(),
9109	mData->m_strConfigFileFull.c_str());
9110
9111	return setError(E_FAIL,
9112	tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
9113	medium->i_getLocationFull().c_str(),
9114	dev.uuid.raw(),
9115	mUserData->s.strName.c_str(),
9116	mData->m_strConfigFileFull.c_str());
9117	}
9118
9119	if ( !i_isSnapshotMachine()
9120	&& medium->i_getChildren().size() != 0
9121	)
9122	return setError(E_FAIL,
9123	tr("Hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s') "
9124	"because it has %d differencing child hard disks"),
9125	medium->i_getLocationFull().c_str(),
9126	dev.uuid.raw(),
9127	mUserData->s.strName.c_str(),
9128	mData->m_strConfigFileFull.c_str(),
9129	medium->i_getChildren().size());
9130
9131	if (i_findAttachment(*mMediumAttachments.data(),
9132	medium))
9133	return setError(E_FAIL,
9134	tr("Hard disk '%s' with UUID {%RTuuid} is already attached to the virtual machine '%s' ('%s')"),
9135	medium->i_getLocationFull().c_str(),
9136	dev.uuid.raw(),
9137	mUserData->s.strName.c_str(),
9138	mData->m_strConfigFileFull.c_str());
9139
9140	break;
9141	}
9142
9143	default:
9144	return setError(E_FAIL,
9145	tr("Controller '%s' port %u unit %u has device with unknown type (%d) - virtual machine '%s' ('%s')"),
9146	data.strName.c_str(), dev.lPort, dev.lDevice, dev.deviceType,
9147	mUserData->s.strName.c_str(), mData->m_strConfigFileFull.c_str());
9148	}
9149
9150	if (FAILED(hrc))
9151	break;
9152
9153	/* Bandwidth groups are loaded at this point. */
9154	ComObjPtr<BandwidthGroup> pBwGroup;
9155
9156	if (!dev.strBwGroup.isEmpty())
9157	{
9158	hrc = mBandwidthControl->i_getBandwidthGroupByName(dev.strBwGroup, pBwGroup, false /* aSetError */);
9159	if (FAILED(hrc))
9160	return setError(E_FAIL,
9161	tr("Device '%s' with unknown bandwidth group '%s' is attached to the virtual machine '%s' ('%s')"),
9162	medium->i_getLocationFull().c_str(),
9163	dev.strBwGroup.c_str(),
9164	mUserData->s.strName.c_str(),
9165	mData->m_strConfigFileFull.c_str());
9166	pBwGroup->i_reference();
9167	}
9168
9169	const Utf8Str controllerName = aStorageController->i_getName();
9170	ComObjPtr<MediumAttachment> pAttachment;
9171	pAttachment.createObject();
9172	hrc = pAttachment->init(this,
9173	medium,
9174	controllerName,
9175	dev.lPort,
9176	dev.lDevice,
9177	dev.deviceType,
9178	false,
9179	dev.fPassThrough,
9180	dev.fTempEject,
9181	dev.fNonRotational,
9182	dev.fDiscard,
9183	dev.fHotPluggable,
9184	pBwGroup.isNull() ? Utf8Str::Empty : pBwGroup->i_getName());
9185	if (FAILED(hrc)) break;
9186
9187	/* associate the medium with this machine and snapshot */
9188	if (!medium.isNull())
9189	{
9190	AutoCaller medCaller(medium);
9191	if (FAILED(medCaller.hrc())) return medCaller.hrc();
9192	AutoWriteLock mlock(medium COMMA_LOCKVAL_SRC_POS);
9193
9194	if (i_isSnapshotMachine())
9195	hrc = medium->i_addBackReference(mData->mUuid, *puuidSnapshot);
9196	else
9197	hrc = medium->i_addBackReference(mData->mUuid);
9198	/* If the medium->addBackReference fails it sets an appropriate
9199	* error message, so no need to do any guesswork here. */
9200
9201	if (puuidRegistry)
9202	// caller wants registry ID to be set on all attached media (OVF import case)
9203	medium->i_addRegistry(*puuidRegistry);
9204	}
9205
9206	if (FAILED(hrc))
9207	break;
9208
9209	/* back up mMediumAttachments to let registeredInit() properly rollback
9210	* on failure (= limited accessibility) */
9211	i_setModified(IsModified_Storage);
9212	mMediumAttachments.backup();
9213	mMediumAttachments->push_back(pAttachment);
9214	}
9215
9216	return hrc;
9217	}
9218
9219	/**
9220	* Returns the snapshot with the given UUID or fails of no such snapshot exists.
9221	*
9222	* @param aId snapshot UUID to find (empty UUID refers the first snapshot)
9223	* @param aSnapshot where to return the found snapshot
9224	* @param aSetError true to set extended error info on failure
9225	*/
9226	HRESULT Machine::i_findSnapshotById(const Guid &aId,
9227	ComObjPtr<Snapshot> &aSnapshot,
9228	bool aSetError /* = false */)
9229	{
9230	AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
9231
9232	if (!mData->mFirstSnapshot)
9233	{
9234	if (aSetError)
9235	return setError(E_FAIL, tr("This machine does not have any snapshots"));
9236	return E_FAIL;
9237	}
9238
9239	if (aId.isZero())
9240	aSnapshot = mData->mFirstSnapshot;
9241	else
9242	aSnapshot = mData->mFirstSnapshot->i_findChildOrSelf(aId.ref());
9243
9244	if (!aSnapshot)
9245	{
9246	if (aSetError)
9247	return setError(E_FAIL,
9248	tr("Could not find a snapshot with UUID {%s}"),
9249	aId.toString().c_str());
9250	return E_FAIL;
9251	}
9252
9253	return S_OK;
9254	}
9255
9256	/**
9257	* Returns the snapshot with the given name or fails of no such snapshot.
9258	*
9259	* @param strName snapshot name to find
9260	* @param aSnapshot where to return the found snapshot
9261	* @param aSetError true to set extended error info on failure
9262	*/
9263	HRESULT Machine::i_findSnapshotByName(const Utf8Str &strName,
9264	ComObjPtr<Snapshot> &aSnapshot,
9265	bool aSetError /* = false */)
9266	{
9267	AssertReturn(!strName.isEmpty(), E_INVALIDARG);
9268
9269	AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
9270
9271	if (!mData->mFirstSnapshot)
9272	{
9273	if (aSetError)
9274	return setError(VBOX_E_OBJECT_NOT_FOUND,
9275	tr("This machine does not have any snapshots"));
9276	return VBOX_E_OBJECT_NOT_FOUND;
9277	}
9278
9279	aSnapshot = mData->mFirstSnapshot->i_findChildOrSelf(strName);
9280
9281	if (!aSnapshot)
9282	{
9283	if (aSetError)
9284	return setError(VBOX_E_OBJECT_NOT_FOUND,
9285	tr("Could not find a snapshot named '%s'"), strName.c_str());
9286	return VBOX_E_OBJECT_NOT_FOUND;
9287	}
9288
9289	return S_OK;
9290	}
9291
9292	/**
9293	* Returns a storage controller object with the given name.
9294	*
9295	* @param aName storage controller name to find
9296	* @param aStorageController where to return the found storage controller
9297	* @param aSetError true to set extended error info on failure
9298	*/
9299	HRESULT Machine::i_getStorageControllerByName(const Utf8Str &aName,
9300	ComObjPtr<StorageController> &aStorageController,
9301	bool aSetError /* = false */)
9302	{
9303	AssertReturn(!aName.isEmpty(), E_INVALIDARG);
9304
9305	for (StorageControllerList::const_iterator
9306	it = mStorageControllers->begin();
9307	it != mStorageControllers->end();
9308	++it)
9309	{
9310	if ((*it)->i_getName() == aName)
9311	{
9312	aStorageController = (*it);
9313	return S_OK;
9314	}
9315	}
9316
9317	if (aSetError)
9318	return setError(VBOX_E_OBJECT_NOT_FOUND,
9319	tr("Could not find a storage controller named '%s'"),
9320	aName.c_str());
9321	return VBOX_E_OBJECT_NOT_FOUND;
9322	}
9323
9324	/**
9325	* Returns a USB controller object with the given name.
9326	*
9327	* @param aName USB controller name to find
9328	* @param aUSBController where to return the found USB controller
9329	* @param aSetError true to set extended error info on failure
9330	*/
9331	HRESULT Machine::i_getUSBControllerByName(const Utf8Str &aName,
9332	ComObjPtr<USBController> &aUSBController,
9333	bool aSetError /* = false */)
9334	{
9335	AssertReturn(!aName.isEmpty(), E_INVALIDARG);
9336
9337	for (USBControllerList::const_iterator
9338	it = mUSBControllers->begin();
9339	it != mUSBControllers->end();
9340	++it)
9341	{
9342	if ((*it)->i_getName() == aName)
9343	{
9344	aUSBController = (*it);
9345	return S_OK;
9346	}
9347	}
9348
9349	if (aSetError)
9350	return setError(VBOX_E_OBJECT_NOT_FOUND,
9351	tr("Could not find a storage controller named '%s'"),
9352	aName.c_str());
9353	return VBOX_E_OBJECT_NOT_FOUND;
9354	}
9355
9356	/**
9357	* Returns the number of USB controller instance of the given type.
9358	*
9359	* @param enmType USB controller type.
9360	*/
9361	ULONG Machine::i_getUSBControllerCountByType(USBControllerType_T enmType)
9362	{
9363	ULONG cCtrls = 0;
9364
9365	for (USBControllerList::const_iterator
9366	it = mUSBControllers->begin();
9367	it != mUSBControllers->end();
9368	++it)
9369	{
9370	if ((*it)->i_getControllerType() == enmType)
9371	cCtrls++;
9372	}
9373
9374	return cCtrls;
9375	}
9376
9377	HRESULT Machine::i_getMediumAttachmentsOfController(const Utf8Str &aName,
9378	MediumAttachmentList &atts)
9379	{
9380	AutoCaller autoCaller(this);
9381	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
9382
9383	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
9384
9385	for (MediumAttachmentList::const_iterator
9386	it = mMediumAttachments->begin();
9387	it != mMediumAttachments->end();
9388	++it)
9389	{
9390	const ComObjPtr<MediumAttachment> &pAtt = *it;
9391	// should never happen, but deal with NULL pointers in the list.
9392	AssertContinue(!pAtt.isNull());
9393
9394	// getControllerName() needs caller+read lock
9395	AutoCaller autoAttCaller(pAtt);
9396	if (FAILED(autoAttCaller.hrc()))
9397	{
9398	atts.clear();
9399	return autoAttCaller.hrc();
9400	}
9401	AutoReadLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
9402
9403	if (pAtt->i_getControllerName() == aName)
9404	atts.push_back(pAtt);
9405	}
9406
9407	return S_OK;
9408	}
9409
9410
9411	/**
9412	* Helper for #i_saveSettings. Cares about renaming the settings directory and
9413	* file if the machine name was changed and about creating a new settings file
9414	* if this is a new machine.
9415	*
9416	* @note Must be never called directly but only from #saveSettings().
9417	*/
9418	HRESULT Machine::i_prepareSaveSettings(bool *pfNeedsGlobalSaveSettings,
9419	bool *pfSettingsFileIsNew)
9420	{
9421	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9422
9423	HRESULT hrc = S_OK;
9424
9425	bool fSettingsFileIsNew = !mData->pMachineConfigFile->fileExists();
9426	/// @todo need to handle primary group change, too
9427
9428	/* attempt to rename the settings file if machine name is changed */
9429	if ( mUserData->s.fNameSync
9430	&& mUserData.isBackedUp()
9431	&& ( mUserData.backedUpData()->s.strName != mUserData->s.strName
9432	\|\| mUserData.backedUpData()->s.llGroups.front() != mUserData->s.llGroups.front())
9433	)
9434	{
9435	bool dirRenamed = false;
9436	bool fileRenamed = false;
9437
9438	Utf8Str configFile, newConfigFile;
9439	Utf8Str configFilePrev, newConfigFilePrev;
9440	Utf8Str NVRAMFile, newNVRAMFile;
9441	Utf8Str configDir, newConfigDir;
9442
9443	do
9444	{
9445	int vrc = VINF_SUCCESS;
9446
9447	Utf8Str name = mUserData.backedUpData()->s.strName;
9448	Utf8Str newName = mUserData->s.strName;
9449	Utf8Str group = mUserData.backedUpData()->s.llGroups.front();
9450	if (group == "/")
9451	group.setNull();
9452	Utf8Str newGroup = mUserData->s.llGroups.front();
9453	if (newGroup == "/")
9454	newGroup.setNull();
9455
9456	configFile = mData->m_strConfigFileFull;
9457
9458	/* first, rename the directory if it matches the group and machine name */
9459	Utf8StrFmt groupPlusName("%s%c%s", group.c_str(), RTPATH_DELIMITER, name.c_str());
9460	/** @todo hack, make somehow use of ComposeMachineFilename */
9461	if (mUserData->s.fDirectoryIncludesUUID)
9462	groupPlusName.appendPrintf(" (%RTuuid)", mData->mUuid.raw());
9463	Utf8StrFmt newGroupPlusName("%s%c%s", newGroup.c_str(), RTPATH_DELIMITER, newName.c_str());
9464	/** @todo hack, make somehow use of ComposeMachineFilename */
9465	if (mUserData->s.fDirectoryIncludesUUID)
9466	newGroupPlusName.appendPrintf(" (%RTuuid)", mData->mUuid.raw());
9467	configDir = configFile;
9468	configDir.stripFilename();
9469	newConfigDir = configDir;
9470	if ( configDir.length() >= groupPlusName.length()
9471	&& !RTPathCompare(configDir.substr(configDir.length() - groupPlusName.length(), groupPlusName.length()).c_str(),
9472	groupPlusName.c_str()))
9473	{
9474	newConfigDir = newConfigDir.substr(0, configDir.length() - groupPlusName.length());
9475	Utf8Str newConfigBaseDir(newConfigDir);
9476	newConfigDir.append(newGroupPlusName);
9477	/* consistency: use \ if appropriate on the platform */
9478	RTPathChangeToDosSlashes(newConfigDir.mutableRaw(), false);
9479	/* new dir and old dir cannot be equal here because of 'if'
9480	* above and because name != newName */
9481	Assert(configDir != newConfigDir);
9482	if (!fSettingsFileIsNew)
9483	{
9484	/* perform real rename only if the machine is not new */
9485	vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
9486	if ( vrc == VERR_FILE_NOT_FOUND
9487	\|\| vrc == VERR_PATH_NOT_FOUND)
9488	{
9489	/* create the parent directory, then retry renaming */
9490	Utf8Str parent(newConfigDir);
9491	parent.stripFilename();
9492	(void)RTDirCreateFullPath(parent.c_str(), 0700);
9493	vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
9494	}
9495	if (RT_FAILURE(vrc))
9496	{
9497	hrc = setErrorBoth(E_FAIL, vrc,
9498	tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
9499	configDir.c_str(),
9500	newConfigDir.c_str(),
9501	vrc);
9502	break;
9503	}
9504	/* delete subdirectories which are no longer needed */
9505	Utf8Str dir(configDir);
9506	dir.stripFilename();
9507	while (dir != newConfigBaseDir && dir != ".")
9508	{
9509	vrc = RTDirRemove(dir.c_str());
9510	if (RT_FAILURE(vrc))
9511	break;
9512	dir.stripFilename();
9513	}
9514	dirRenamed = true;
9515	}
9516	}
9517
9518	newConfigFile.printf("%s%c%s.vbox", newConfigDir.c_str(), RTPATH_DELIMITER, newName.c_str());
9519
9520	/* then try to rename the settings file itself */
9521	if (newConfigFile != configFile)
9522	{
9523	/* get the path to old settings file in renamed directory */
9524	Assert(mData->m_strConfigFileFull == configFile);
9525	configFile.printf("%s%c%s",
9526	newConfigDir.c_str(),
9527	RTPATH_DELIMITER,
9528	RTPathFilename(mData->m_strConfigFileFull.c_str()));
9529	if (!fSettingsFileIsNew)
9530	{
9531	/* perform real rename only if the machine is not new */
9532	vrc = RTFileRename(configFile.c_str(), newConfigFile.c_str(), 0);
9533	if (RT_FAILURE(vrc))
9534	{
9535	hrc = setErrorBoth(E_FAIL, vrc,
9536	tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
9537	configFile.c_str(),
9538	newConfigFile.c_str(),
9539	vrc);
9540	break;
9541	}
9542	fileRenamed = true;
9543	configFilePrev = configFile;
9544	configFilePrev += "-prev";
9545	newConfigFilePrev = newConfigFile;
9546	newConfigFilePrev += "-prev";
9547	RTFileRename(configFilePrev.c_str(), newConfigFilePrev.c_str(), 0);
9548	NVRAMFile = mNvramStore->i_getNonVolatileStorageFile();
9549	if (NVRAMFile.isNotEmpty())
9550	{
9551	// in the NVRAM file path, replace the old directory with the new directory
9552	if (RTPathStartsWith(NVRAMFile.c_str(), configDir.c_str()))
9553	{
9554	Utf8Str strNVRAMFile = NVRAMFile.c_str() + configDir.length();
9555	NVRAMFile = newConfigDir + strNVRAMFile;
9556	}
9557	newNVRAMFile = newConfigFile;
9558	newNVRAMFile.stripSuffix();
9559	newNVRAMFile += ".nvram";
9560	RTFileRename(NVRAMFile.c_str(), newNVRAMFile.c_str(), 0);
9561	}
9562	}
9563	}
9564
9565	// update m_strConfigFileFull amd mConfigFile
9566	mData->m_strConfigFileFull = newConfigFile;
9567	// compute the relative path too
9568	mParent->i_copyPathRelativeToConfig(newConfigFile, mData->m_strConfigFile);
9569
9570	// store the old and new so that VirtualBox::i_saveSettings() can update
9571	// the media registry
9572	if ( mData->mRegistered
9573	&& (configDir != newConfigDir \|\| configFile != newConfigFile))
9574	{
9575	mParent->i_rememberMachineNameChangeForMedia(configDir, newConfigDir);
9576
9577	if (pfNeedsGlobalSaveSettings)
9578	*pfNeedsGlobalSaveSettings = true;
9579	}
9580
9581	// in the saved state file path, replace the old directory with the new directory
9582	if (RTPathStartsWith(mSSData->strStateFilePath.c_str(), configDir.c_str()))
9583	{
9584	Utf8Str strStateFileName = mSSData->strStateFilePath.c_str() + configDir.length();
9585	mSSData->strStateFilePath = newConfigDir + strStateFileName;
9586	}
9587	if (newNVRAMFile.isNotEmpty())
9588	mNvramStore->i_updateNonVolatileStorageFile(newNVRAMFile);
9589
9590	// and do the same thing for the saved state file paths of all the online snapshots and NVRAM files of all snapshots
9591	if (mData->mFirstSnapshot)
9592	{
9593	mData->mFirstSnapshot->i_updateSavedStatePaths(configDir.c_str(),
9594	newConfigDir.c_str());
9595	mData->mFirstSnapshot->i_updateNVRAMPaths(configDir.c_str(),
9596	newConfigDir.c_str());
9597	}
9598	}
9599	while (0);
9600
9601	if (FAILED(hrc))
9602	{
9603	/* silently try to rename everything back */
9604	if (fileRenamed)
9605	{
9606	RTFileRename(newConfigFilePrev.c_str(), configFilePrev.c_str(), 0);
9607	RTFileRename(newConfigFile.c_str(), configFile.c_str(), 0);
9608	if (NVRAMFile.isNotEmpty() && newNVRAMFile.isNotEmpty())
9609	RTFileRename(newNVRAMFile.c_str(), NVRAMFile.c_str(), 0);
9610	}
9611	if (dirRenamed)
9612	RTPathRename(newConfigDir.c_str(), configDir.c_str(), 0);
9613	}
9614
9615	if (FAILED(hrc)) return hrc;
9616	}
9617
9618	if (fSettingsFileIsNew)
9619	{
9620	/* create a virgin config file */
9621	int vrc = VINF_SUCCESS;
9622
9623	/* ensure the settings directory exists */
9624	Utf8Str path(mData->m_strConfigFileFull);
9625	path.stripFilename();
9626	if (!RTDirExists(path.c_str()))
9627	{
9628	vrc = RTDirCreateFullPath(path.c_str(), 0700);
9629	if (RT_FAILURE(vrc))
9630	{
9631	return setErrorBoth(E_FAIL, vrc,
9632	tr("Could not create a directory '%s' to save the settings file (%Rrc)"),
9633	path.c_str(),
9634	vrc);
9635	}
9636	}
9637
9638	/* Note: open flags must correlate with RTFileOpen() in lockConfig() */
9639	path = mData->m_strConfigFileFull;
9640	RTFILE f = NIL_RTFILE;
9641	vrc = RTFileOpen(&f, path.c_str(),
9642	RTFILE_O_READWRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE);
9643	if (RT_FAILURE(vrc))
9644	return setErrorBoth(E_FAIL, vrc,
9645	tr("Could not create the settings file '%s' (%Rrc)"),
9646	path.c_str(),
9647	vrc);
9648	RTFileClose(f);
9649	}
9650	if (pfSettingsFileIsNew)
9651	*pfSettingsFileIsNew = fSettingsFileIsNew;
9652
9653	return hrc;
9654	}
9655
9656	/**
9657	* Saves and commits machine data, user data and hardware data.
9658	*
9659	* Note that on failure, the data remains uncommitted.
9660	*
9661	* @a aFlags may combine the following flags:
9662	*
9663	* - SaveS_ResetCurStateModified: Resets mData->mCurrentStateModified to FALSE.
9664	* Used when saving settings after an operation that makes them 100%
9665	* correspond to the settings from the current snapshot.
9666	* - SaveS_Force: settings will be saved without doing a deep compare of the
9667	* settings structures. This is used when this is called because snapshots
9668	* have changed to avoid the overhead of the deep compare.
9669	*
9670	* @note Must be called from under this object's write lock. Locks children for
9671	* writing.
9672	*
9673	* @param pfNeedsGlobalSaveSettings Optional pointer to a bool that must have been
9674	* initialized to false and that will be set to true by this function if
9675	* the caller must invoke VirtualBox::i_saveSettings() because the global
9676	* settings have changed. This will happen if a machine rename has been
9677	* saved and the global machine and media registries will therefore need
9678	* updating.
9679	* @param alock Reference to the lock for this machine object.
9680	* @param aFlags Flags.
9681	*/
9682	HRESULT Machine::i_saveSettings(bool *pfNeedsGlobalSaveSettings,
9683	AutoWriteLock &alock,
9684	int aFlags /= 0/)
9685	{
9686	LogFlowThisFuncEnter();
9687
9688	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9689
9690	/* make sure child objects are unable to modify the settings while we are
9691	* saving them */
9692	i_ensureNoStateDependencies(alock);
9693
9694	AssertReturn(!i_isSnapshotMachine(),
9695	E_FAIL);
9696
9697	if (!mData->mAccessible)
9698	return setError(VBOX_E_INVALID_VM_STATE,
9699	tr("The machine is not accessible, so cannot save settings"));
9700
9701	HRESULT hrc = S_OK;
9702	PCVBOXCRYPTOIF pCryptoIf = NULL;
9703	const char *pszPassword = NULL;
9704	SecretKey *pKey = NULL;
9705
9706	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
9707	if (mData->mstrKeyId.isNotEmpty())
9708	{
9709	/* VM is going to be encrypted. */
9710	alock.release(); /** @todo Revise the locking. */
9711	hrc = mParent->i_retainCryptoIf(&pCryptoIf);
9712	alock.acquire();
9713	if (FAILED(hrc)) return hrc; /* Error is set. */
9714
9715	int vrc = mData->mpKeyStore->retainSecretKey(mData->mstrKeyId, &pKey);
9716	if (RT_SUCCESS(vrc))
9717	pszPassword = (const char *)pKey->getKeyBuffer();
9718	else
9719	{
9720	mParent->i_releaseCryptoIf(pCryptoIf);
9721	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
9722	tr("Failed to retain VM encryption password using ID '%s' with %Rrc"),
9723	mData->mstrKeyId.c_str(), vrc);
9724	}
9725	}
9726	#else
9727	RT_NOREF(pKey);
9728	#endif
9729
9730	bool fNeedsWrite = false;
9731	bool fSettingsFileIsNew = false;
9732
9733	/* First, prepare to save settings. It will care about renaming the
9734	* settings directory and file if the machine name was changed and about
9735	* creating a new settings file if this is a new machine. */
9736	hrc = i_prepareSaveSettings(pfNeedsGlobalSaveSettings, &fSettingsFileIsNew);
9737	if (FAILED(hrc))
9738	{
9739	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
9740	if (pCryptoIf)
9741	{
9742	alock.release(); /** @todo Revise the locking. */
9743	mParent->i_releaseCryptoIf(pCryptoIf);
9744	alock.acquire();
9745	}
9746	if (pKey)
9747	mData->mpKeyStore->releaseSecretKey(mData->mstrKeyId);
9748	#endif
9749	return hrc;
9750	}
9751
9752	// keep a pointer to the current settings structures
9753	settings::MachineConfigFile *pOldConfig = mData->pMachineConfigFile;
9754	settings::MachineConfigFile *pNewConfig = NULL;
9755
9756	try
9757	{
9758	// make a fresh one to have everyone write stuff into
9759	pNewConfig = new settings::MachineConfigFile(NULL);
9760	pNewConfig->copyBaseFrom(*mData->pMachineConfigFile);
9761	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
9762	pNewConfig->strKeyId = mData->mstrKeyId;
9763	pNewConfig->strKeyStore = mData->mstrKeyStore;
9764	#endif
9765
9766	// now go and copy all the settings data from COM to the settings structures
9767	// (this calls i_saveSettings() on all the COM objects in the machine)
9768	i_copyMachineDataToSettings(*pNewConfig);
9769
9770	if (aFlags & SaveS_ResetCurStateModified)
9771	{
9772	// this gets set by takeSnapshot() (if offline snapshot) and restoreSnapshot()
9773	mData->mCurrentStateModified = FALSE;
9774	fNeedsWrite = true; // always, no need to compare
9775	}
9776	else if (aFlags & SaveS_Force)
9777	{
9778	fNeedsWrite = true; // always, no need to compare
9779	}
9780	else
9781	{
9782	if (!mData->mCurrentStateModified)
9783	{
9784	// do a deep compare of the settings that we just saved with the settings
9785	// previously stored in the config file; this invokes MachineConfigFile::operator==
9786	// which does a deep compare of all the settings, which is expensive but less expensive
9787	// than writing out XML in vain
9788	bool fAnySettingsChanged = !(pNewConfig == pOldConfig);
9789
9790	// could still be modified if any settings changed
9791	mData->mCurrentStateModified = fAnySettingsChanged;
9792
9793	fNeedsWrite = fAnySettingsChanged;
9794	}
9795	else
9796	fNeedsWrite = true;
9797	}
9798
9799	pNewConfig->fCurrentStateModified = !!mData->mCurrentStateModified;
9800
9801	if (fNeedsWrite)
9802	{
9803	// now spit it all out!
9804	pNewConfig->write(mData->m_strConfigFileFull, pCryptoIf, pszPassword);
9805	if (aFlags & SaveS_RemoveBackup)
9806	i_deleteFile(mData->m_strConfigFileFull + "-prev", true /* fIgnoreFailures */);
9807	}
9808
9809	mData->pMachineConfigFile = pNewConfig;
9810	delete pOldConfig;
9811	i_commit();
9812
9813	// after saving settings, we are no longer different from the XML on disk
9814	mData->flModifications = 0;
9815	}
9816	catch (HRESULT err)
9817	{
9818	// we assume that error info is set by the thrower
9819	hrc = err;
9820
9821	// delete any newly created settings file
9822	if (fSettingsFileIsNew)
9823	i_deleteFile(mData->m_strConfigFileFull, true /* fIgnoreFailures */);
9824
9825	// restore old config
9826	delete pNewConfig;
9827	mData->pMachineConfigFile = pOldConfig;
9828	}
9829	catch (...)
9830	{
9831	hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
9832	}
9833
9834	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
9835	if (pCryptoIf)
9836	{
9837	alock.release(); /** @todo Revise the locking. */
9838	mParent->i_releaseCryptoIf(pCryptoIf);
9839	alock.acquire();
9840	}
9841	if (pKey)
9842	mData->mpKeyStore->releaseSecretKey(mData->mstrKeyId);
9843	#endif
9844
9845	if (fNeedsWrite)
9846	{
9847	/* Fire the data change event, even on failure (since we've already
9848	* committed all data). This is done only for SessionMachines because
9849	* mutable Machine instances are always not registered (i.e. private
9850	* to the client process that creates them) and thus don't need to
9851	* inform callbacks. */
9852	if (i_isSessionMachine())
9853	mParent->i_onMachineDataChanged(mData->mUuid);
9854	}
9855
9856	LogFlowThisFunc(("hrc=%08X\n", hrc));
9857	LogFlowThisFuncLeave();
9858	return hrc;
9859	}
9860
9861	/**
9862	* Implementation for saving the machine settings into the given
9863	* settings::MachineConfigFile instance. This copies machine extradata
9864	* from the previous machine config file in the instance data, if any.
9865	*
9866	* This gets called from two locations:
9867	*
9868	* -- Machine::i_saveSettings(), during the regular XML writing;
9869	*
9870	* -- Appliance::buildXMLForOneVirtualSystem(), when a machine gets
9871	* exported to OVF and we write the VirtualBox proprietary XML
9872	* into a <vbox:Machine> tag.
9873	*
9874	* This routine fills all the fields in there, including snapshots, except
9875	* for the following:
9876	*
9877	* -- fCurrentStateModified. There is some special logic associated with that.
9878	*
9879	* The caller can then call MachineConfigFile::write() or do something else
9880	* with it.
9881	*
9882	* Caller must hold the machine lock!
9883	*
9884	* This throws XML errors and HRESULT, so the caller must have a catch block!
9885	*/
9886	void Machine::i_copyMachineDataToSettings(settings::MachineConfigFile &config)
9887	{
9888	// deep copy extradata, being extra careful with self assignment (the STL
9889	// map assignment on Mac OS X clang based Xcode isn't checking)
9890	if (&config != mData->pMachineConfigFile)
9891	config.mapExtraDataItems = mData->pMachineConfigFile->mapExtraDataItems;
9892
9893	config.uuid = mData->mUuid;
9894
9895	// copy name, description, OS type, teleport, UTC etc.
9896	config.machineUserData = mUserData->s;
9897
9898	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
9899	config.strStateKeyId = mSSData->strStateKeyId;
9900	config.strStateKeyStore = mSSData->strStateKeyStore;
9901	config.strLogKeyId = mData->mstrLogKeyId;
9902	config.strLogKeyStore = mData->mstrLogKeyStore;
9903	#endif
9904
9905	if ( mData->mMachineState == MachineState_Saved
9906	\|\| mData->mMachineState == MachineState_AbortedSaved
9907	\|\| mData->mMachineState == MachineState_Restoring
9908	// when doing certain snapshot operations we may or may not have
9909	// a saved state in the current state, so keep everything as is
9910	\|\| ( ( mData->mMachineState == MachineState_Snapshotting
9911	\|\| mData->mMachineState == MachineState_DeletingSnapshot
9912	\|\| mData->mMachineState == MachineState_RestoringSnapshot)
9913	&& (!mSSData->strStateFilePath.isEmpty())
9914	)
9915	)
9916	{
9917	Assert(!mSSData->strStateFilePath.isEmpty());
9918	/* try to make the file name relative to the settings file dir */
9919	i_copyPathRelativeToMachine(mSSData->strStateFilePath, config.strStateFile);
9920	}
9921	else
9922	{
9923	Assert(mSSData->strStateFilePath.isEmpty() \|\| mData->mMachineState == MachineState_Saving);
9924	config.strStateFile.setNull();
9925	}
9926
9927	if (mData->mCurrentSnapshot)
9928	config.uuidCurrentSnapshot = mData->mCurrentSnapshot->i_getId();
9929	else
9930	config.uuidCurrentSnapshot.clear();
9931
9932	config.timeLastStateChange = mData->mLastStateChange;
9933	config.fAborted = (mData->mMachineState == MachineState_Aborted \|\| mData->mMachineState == MachineState_AbortedSaved);
9934	/// @todo Live Migration: config.fTeleported = (mData->mMachineState == MachineState_Teleported);
9935
9936	HRESULT hrc = i_saveHardware(config.hardwareMachine, &config.debugging, &config.autostart, config.recordingSettings);
9937	if (FAILED(hrc)) throw hrc;
9938
9939	// save machine's media registry if this is VirtualBox 4.0 or later
9940	if (config.canHaveOwnMediaRegistry())
9941	{
9942	// determine machine folder
9943	Utf8Str strMachineFolder = i_getSettingsFileFull();
9944	strMachineFolder.stripFilename();
9945	mParent->i_saveMediaRegistry(config.mediaRegistry,
9946	i_getId(), // only media with registry ID == machine UUID
9947	strMachineFolder);
9948	// this throws HRESULT
9949	}
9950
9951	// save snapshots
9952	hrc = i_saveAllSnapshots(config);
9953	if (FAILED(hrc)) throw hrc;
9954	}
9955
9956	/**
9957	* Saves all snapshots of the machine into the given machine config file. Called
9958	* from Machine::buildMachineXML() and SessionMachine::deleteSnapshotHandler().
9959	* @param config
9960	* @return
9961	*/
9962	HRESULT Machine::i_saveAllSnapshots(settings::MachineConfigFile &config)
9963	{
9964	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9965
9966	HRESULT hrc = S_OK;
9967
9968	try
9969	{
9970	config.llFirstSnapshot.clear();
9971
9972	if (mData->mFirstSnapshot)
9973	{
9974	// the settings use a list for "the first snapshot"
9975	config.llFirstSnapshot.push_back(settings::Snapshot::Empty);
9976
9977	// get reference to the snapshot on the list and work on that
9978	// element straight in the list to avoid excessive copying later
9979	hrc = mData->mFirstSnapshot->i_saveSnapshot(config.llFirstSnapshot.back());
9980	if (FAILED(hrc)) throw hrc;
9981	}
9982
9983	// if (mType == IsSessionMachine)
9984	// mParent->onMachineDataChange(mData->mUuid); @todo is this necessary?
9985
9986	}
9987	catch (HRESULT err)
9988	{
9989	/* we assume that error info is set by the thrower */
9990	hrc = err;
9991	}
9992	catch (...)
9993	{
9994	hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
9995	}
9996
9997	return hrc;
9998	}
9999
10000	/**
10001	* Saves the VM hardware configuration. It is assumed that the
10002	* given node is empty.
10003	*
10004	* @param data Reference to the settings object for the hardware config.
10005	* @param pDbg Pointer to the settings object for the debugging config
10006	* which happens to live in mHWData.
10007	* @param pAutostart Pointer to the settings object for the autostart config
10008	* which happens to live in mHWData.
10009	* @param recording Reference to reecording settings.
10010	*/
10011	HRESULT Machine::i_saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
10012	settings::Autostart *pAutostart, settings::RecordingSettings &recording)
10013	{
10014	HRESULT hrc = S_OK;
10015
10016	try
10017	{
10018	/* The hardware version attribute (optional).
10019	Automatically upgrade from 1 to current default hardware version
10020	when there is no saved state. (ugly!) */
10021	if ( mHWData->mHWVersion == "1"
10022	&& mSSData->strStateFilePath.isEmpty()
10023	)
10024	mHWData->mHWVersion.printf("%d", SchemaDefs::DefaultHardwareVersion);
10025
10026	data.strVersion = mHWData->mHWVersion;
10027	data.uuid = mHWData->mHardwareUUID;
10028
10029	// CPU
10030	data.cCPUs = mHWData->mCPUCount;
10031	data.fCpuHotPlug = !!mHWData->mCPUHotPlugEnabled;
10032	data.ulCpuExecutionCap = mHWData->mCpuExecutionCap;
10033	data.uCpuIdPortabilityLevel = mHWData->mCpuIdPortabilityLevel;
10034	data.strCpuProfile = mHWData->mCpuProfile;
10035
10036	data.llCpus.clear();
10037	if (data.fCpuHotPlug)
10038	{
10039	for (unsigned idx = 0; idx < data.cCPUs; ++idx)
10040	{
10041	if (mHWData->mCPUAttached[idx])
10042	{
10043	settings::Cpu cpu;
10044	cpu.ulId = idx;
10045	data.llCpus.push_back(cpu);
10046	}
10047	}
10048	}
10049
10050	// memory
10051	data.ulMemorySizeMB = mHWData->mMemorySize;
10052	data.fPageFusionEnabled = !!mHWData->mPageFusionEnabled;
10053
10054	// HID
10055	data.pointingHIDType = mHWData->mPointingHIDType;
10056	data.keyboardHIDType = mHWData->mKeyboardHIDType;
10057
10058	// paravirt
10059	data.paravirtProvider = mHWData->mParavirtProvider;
10060	data.strParavirtDebug = mHWData->mParavirtDebug;
10061
10062	// emulated USB card reader
10063	data.fEmulatedUSBCardReader = !!mHWData->mEmulatedUSBCardReaderEnabled;
10064
10065	// boot order
10066	data.mapBootOrder.clear();
10067	for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mBootOrder); ++i)
10068	data.mapBootOrder[i] = mHWData->mBootOrder[i];
10069
10070	/* VRDEServer settings (optional) */
10071	hrc = mVRDEServer->i_saveSettings(data.vrdeSettings);
10072	if (FAILED(hrc)) throw hrc;
10073
10074	/* Platform (required) */
10075	hrc = mPlatform->i_saveSettings(data.platformSettings);
10076	if (FAILED(hrc)) return hrc;
10077
10078	/* Firmware settings (required) */
10079	hrc = mFirmwareSettings->i_saveSettings(data.firmwareSettings);
10080	if (FAILED(hrc)) throw hrc;
10081
10082	/* Recording settings. */
10083	hrc = mRecordingSettings->i_saveSettings(recording);
10084	if (FAILED(hrc)) throw hrc;
10085
10086	/* Trusted Platform Module settings (required) */
10087	hrc = mTrustedPlatformModule->i_saveSettings(data.tpmSettings);
10088	if (FAILED(hrc)) throw hrc;
10089
10090	/* NVRAM settings (required) */
10091	hrc = mNvramStore->i_saveSettings(data.nvramSettings);
10092	if (FAILED(hrc)) throw hrc;
10093
10094	/* GraphicsAdapter settings (required) */
10095	hrc = mGraphicsAdapter->i_saveSettings(data.graphicsAdapter);
10096	if (FAILED(hrc)) throw hrc;
10097
10098	/* USB Controller (required) */
10099	data.usbSettings.llUSBControllers.clear();
10100	for (USBControllerList::const_iterator
10101	it = mUSBControllers->begin();
10102	it != mUSBControllers->end();
10103	++it)
10104	{
10105	ComObjPtr<USBController> ctrl = *it;
10106	settings::USBController settingsCtrl;
10107
10108	settingsCtrl.strName = ctrl->i_getName();
10109	settingsCtrl.enmType = ctrl->i_getControllerType();
10110
10111	data.usbSettings.llUSBControllers.push_back(settingsCtrl);
10112	}
10113
10114	/* USB device filters (required) */
10115	hrc = mUSBDeviceFilters->i_saveSettings(data.usbSettings);
10116	if (FAILED(hrc)) throw hrc;
10117
10118	/* Network adapters (required) */
10119	size_t const uMaxNICs =
10120	RT_MIN(PlatformProperties::s_getMaxNetworkAdapters(data.platformSettings.chipsetType), mNetworkAdapters.size());
10121	data.llNetworkAdapters.clear();
10122	/* Write out only the nominal number of network adapters for this
10123	* chipset type. Since Machine::commit() hasn't been called there
10124	* may be extra NIC settings in the vector. */
10125	for (size_t slot = 0; slot < uMaxNICs; ++slot)
10126	{
10127	settings::NetworkAdapter nic;
10128	nic.ulSlot = (uint32_t)slot;
10129	/* paranoia check... must not be NULL, but must not crash either. */
10130	if (mNetworkAdapters[slot])
10131	{
10132	if (mNetworkAdapters[slot]->i_hasDefaults())
10133	continue;
10134
10135	hrc = mNetworkAdapters[slot]->i_saveSettings(nic);
10136	if (FAILED(hrc)) throw hrc;
10137
10138	data.llNetworkAdapters.push_back(nic);
10139	}
10140	}
10141
10142	/* Serial ports */
10143	data.llSerialPorts.clear();
10144	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
10145	{
10146	if (mSerialPorts[slot]->i_hasDefaults())
10147	continue;
10148
10149	settings::SerialPort s;
10150	s.ulSlot = slot;
10151	hrc = mSerialPorts[slot]->i_saveSettings(s);
10152	if (FAILED(hrc)) return hrc;
10153
10154	data.llSerialPorts.push_back(s);
10155	}
10156
10157	/* Parallel ports */
10158	data.llParallelPorts.clear();
10159	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
10160	{
10161	if (mParallelPorts[slot]->i_hasDefaults())
10162	continue;
10163
10164	settings::ParallelPort p;
10165	p.ulSlot = slot;
10166	hrc = mParallelPorts[slot]->i_saveSettings(p);
10167	if (FAILED(hrc)) return hrc;
10168
10169	data.llParallelPorts.push_back(p);
10170	}
10171
10172	/* Audio settings */
10173	hrc = mAudioSettings->i_saveSettings(data.audioAdapter);
10174	if (FAILED(hrc)) return hrc;
10175
10176	hrc = i_saveStorageControllers(data.storage);
10177	if (FAILED(hrc)) return hrc;
10178
10179	/* Shared folders */
10180	data.llSharedFolders.clear();
10181	for (HWData::SharedFolderList::const_iterator
10182	it = mHWData->mSharedFolders.begin();
10183	it != mHWData->mSharedFolders.end();
10184	++it)
10185	{
10186	SharedFolder pSF = it;
10187	AutoCaller sfCaller(pSF);
10188	AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
10189	settings::SharedFolder sf;
10190	sf.strName = pSF->i_getName();
10191	sf.strHostPath = pSF->i_getHostPath();
10192	sf.fWritable = !!pSF->i_isWritable();
10193	sf.fAutoMount = !!pSF->i_isAutoMounted();
10194	sf.strAutoMountPoint = pSF->i_getAutoMountPoint();
10195
10196	data.llSharedFolders.push_back(sf);
10197	}
10198
10199	// clipboard
10200	data.clipboardMode = mHWData->mClipboardMode;
10201	data.fClipboardFileTransfersEnabled = RT_BOOL(mHWData->mClipboardFileTransfersEnabled);
10202
10203	// drag'n'drop
10204	data.dndMode = mHWData->mDnDMode;
10205
10206	/* Guest */
10207	data.ulMemoryBalloonSize = mHWData->mMemoryBalloonSize;
10208
10209	// IO settings
10210	data.ioSettings.fIOCacheEnabled = !!mHWData->mIOCacheEnabled;
10211	data.ioSettings.ulIOCacheSize = mHWData->mIOCacheSize;
10212
10213	/* BandwidthControl (required) */
10214	hrc = mBandwidthControl->i_saveSettings(data.ioSettings);
10215	if (FAILED(hrc)) throw hrc;
10216
10217	/* Host PCI devices */
10218	data.pciAttachments.clear();
10219	for (HWData::PCIDeviceAssignmentList::const_iterator
10220	it = mHWData->mPCIDeviceAssignments.begin();
10221	it != mHWData->mPCIDeviceAssignments.end();
10222	++it)
10223	{
10224	ComObjPtr<PCIDeviceAttachment> pda = *it;
10225	settings::HostPCIDeviceAttachment hpda;
10226
10227	hrc = pda->i_saveSettings(hpda);
10228	if (FAILED(hrc)) throw hrc;
10229
10230	data.pciAttachments.push_back(hpda);
10231	}
10232
10233	// guest properties
10234	data.llGuestProperties.clear();
10235	#ifdef VBOX_WITH_GUEST_PROPS
10236	for (HWData::GuestPropertyMap::const_iterator
10237	it = mHWData->mGuestProperties.begin();
10238	it != mHWData->mGuestProperties.end();
10239	++it)
10240	{
10241	HWData::GuestProperty property = it->second;
10242
10243	/* Remove transient guest properties at shutdown unless we
10244	* are saving state. Note that restoring snapshot intentionally
10245	* keeps them, they will be removed if appropriate once the final
10246	* machine state is set (as crashes etc. need to work). */
10247	if ( ( mData->mMachineState == MachineState_PoweredOff
10248	\|\| mData->mMachineState == MachineState_Aborted
10249	\|\| mData->mMachineState == MachineState_Teleported)
10250	&& (property.mFlags & (GUEST_PROP_F_TRANSIENT \| GUEST_PROP_F_TRANSRESET)))
10251	continue;
10252	settings::GuestProperty prop; /// @todo r=bird: some excellent variable name choices here: 'prop' and 'property'; No 'const' clue either.
10253	prop.strName = it->first;
10254	prop.strValue = property.strValue;
10255	prop.timestamp = (uint64_t)property.mTimestamp;
10256	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
10257	GuestPropWriteFlags(property.mFlags, szFlags);
10258	prop.strFlags = szFlags;
10259
10260	data.llGuestProperties.push_back(prop);
10261	}
10262
10263	/* I presume this doesn't require a backup(). */
10264	mData->mGuestPropertiesModified = FALSE;
10265	#endif /* VBOX_WITH_GUEST_PROPS defined */
10266
10267	hrc = mGuestDebugControl->i_saveSettings(mHWData->mDebugging);
10268	if (FAILED(hrc)) throw hrc;
10269
10270	pDbg = mHWData->mDebugging; /// @todo r=aeichner: Move this to guest debug control. /
10271	*pAutostart = mHWData->mAutostart;
10272
10273	data.strDefaultFrontend = mHWData->mDefaultFrontend;
10274	}
10275	catch (std::bad_alloc &)
10276	{
10277	return E_OUTOFMEMORY;
10278	}
10279
10280	AssertComRC(hrc);
10281	return hrc;
10282	}
10283
10284	/**
10285	* Saves the storage controller configuration.
10286	*
10287	* @param data storage settings.
10288	*/
10289	HRESULT Machine::i_saveStorageControllers(settings::Storage &data)
10290	{
10291	data.llStorageControllers.clear();
10292
10293	for (StorageControllerList::const_iterator
10294	it = mStorageControllers->begin();
10295	it != mStorageControllers->end();
10296	++it)
10297	{
10298	ComObjPtr<StorageController> pCtl = *it;
10299
10300	settings::StorageController ctl;
10301	ctl.strName = pCtl->i_getName();
10302	ctl.controllerType = pCtl->i_getControllerType();
10303	ctl.storageBus = pCtl->i_getStorageBus();
10304	ctl.ulInstance = pCtl->i_getInstance();
10305	ctl.fBootable = pCtl->i_getBootable();
10306
10307	/* Save the port count. */
10308	ULONG portCount;
10309	HRESULT hrc = pCtl->COMGETTER(PortCount)(&portCount);
10310	ComAssertComRCRet(hrc, hrc);
10311	ctl.ulPortCount = portCount;
10312
10313	/* Save fUseHostIOCache */
10314	BOOL fUseHostIOCache;
10315	hrc = pCtl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
10316	ComAssertComRCRet(hrc, hrc);
10317	ctl.fUseHostIOCache = !!fUseHostIOCache;
10318
10319	/* save the devices now. */
10320	hrc = i_saveStorageDevices(pCtl, ctl);
10321	ComAssertComRCRet(hrc, hrc);
10322
10323	data.llStorageControllers.push_back(ctl);
10324	}
10325
10326	return S_OK;
10327	}
10328
10329	/**
10330	* Saves the hard disk configuration.
10331	*/
10332	HRESULT Machine::i_saveStorageDevices(ComObjPtr<StorageController> aStorageController,
10333	settings::StorageController &data)
10334	{
10335	MediumAttachmentList atts;
10336
10337	HRESULT hrc = i_getMediumAttachmentsOfController(aStorageController->i_getName(), atts);
10338	if (FAILED(hrc)) return hrc;
10339
10340	data.llAttachedDevices.clear();
10341	for (MediumAttachmentList::const_iterator
10342	it = atts.begin();
10343	it != atts.end();
10344	++it)
10345	{
10346	settings::AttachedDevice dev;
10347	IMediumAttachment iA = it;
10348	MediumAttachment pAttach = static_cast<MediumAttachment >(iA);
10349	Medium *pMedium = pAttach->i_getMedium();
10350
10351	dev.deviceType = pAttach->i_getType();
10352	dev.lPort = pAttach->i_getPort();
10353	dev.lDevice = pAttach->i_getDevice();
10354	dev.fPassThrough = pAttach->i_getPassthrough();
10355	dev.fHotPluggable = pAttach->i_getHotPluggable();
10356	if (pMedium)
10357	{
10358	if (pMedium->i_isHostDrive())
10359	dev.strHostDriveSrc = pMedium->i_getLocationFull();
10360	else
10361	dev.uuid = pMedium->i_getId();
10362	dev.fTempEject = pAttach->i_getTempEject();
10363	dev.fNonRotational = pAttach->i_getNonRotational();
10364	dev.fDiscard = pAttach->i_getDiscard();
10365	}
10366
10367	dev.strBwGroup = pAttach->i_getBandwidthGroup();
10368
10369	data.llAttachedDevices.push_back(dev);
10370	}
10371
10372	return S_OK;
10373	}
10374
10375	/**
10376	* Saves machine state settings as defined by aFlags
10377	* (SaveSTS_* values).
10378	*
10379	* @param aFlags Combination of SaveSTS_* flags.
10380	*
10381	* @note Locks objects for writing.
10382	*/
10383	HRESULT Machine::i_saveStateSettings(int aFlags)
10384	{
10385	if (aFlags == 0)
10386	return S_OK;
10387
10388	AutoCaller autoCaller(this);
10389	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
10390
10391	/* This object's write lock is also necessary to serialize file access
10392	* (prevent concurrent reads and writes) */
10393	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10394
10395	HRESULT hrc = S_OK;
10396
10397	Assert(mData->pMachineConfigFile);
10398
10399	try
10400	{
10401	if (aFlags & SaveSTS_CurStateModified)
10402	mData->pMachineConfigFile->fCurrentStateModified = true;
10403
10404	if (aFlags & SaveSTS_StateFilePath)
10405	{
10406	if (!mSSData->strStateFilePath.isEmpty())
10407	/* try to make the file name relative to the settings file dir */
10408	i_copyPathRelativeToMachine(mSSData->strStateFilePath, mData->pMachineConfigFile->strStateFile);
10409	else
10410	mData->pMachineConfigFile->strStateFile.setNull();
10411	}
10412
10413	if (aFlags & SaveSTS_StateTimeStamp)
10414	{
10415	Assert( mData->mMachineState != MachineState_Aborted
10416	\|\| mSSData->strStateFilePath.isEmpty());
10417
10418	mData->pMachineConfigFile->timeLastStateChange = mData->mLastStateChange;
10419
10420	mData->pMachineConfigFile->fAborted = (mData->mMachineState == MachineState_Aborted
10421	\|\| mData->mMachineState == MachineState_AbortedSaved);
10422	/// @todo live migration mData->pMachineConfigFile->fTeleported = (mData->mMachineState == MachineState_Teleported);
10423	}
10424
10425	mData->pMachineConfigFile->write(mData->m_strConfigFileFull);
10426	}
10427	catch (...)
10428	{
10429	hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
10430	}
10431
10432	return hrc;
10433	}
10434
10435	/**
10436	* Ensures that the given medium is added to a media registry. If this machine
10437	* was created with 4.0 or later, then the machine registry is used. Otherwise
10438	* the global VirtualBox media registry is used.
10439	*
10440	* Caller must NOT hold machine lock, media tree or any medium locks!
10441	*
10442	* @param pMedium
10443	*/
10444	void Machine::i_addMediumToRegistry(ComObjPtr<Medium> &pMedium)
10445	{
10446	/* Paranoia checks: do not hold machine or media tree locks. */
10447	AssertReturnVoid(!isWriteLockOnCurrentThread());
10448	AssertReturnVoid(!mParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
10449
10450	ComObjPtr<Medium> pBase;
10451	{
10452	AutoReadLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10453	pBase = pMedium->i_getBase();
10454	}
10455
10456	/* Paranoia checks: do not hold medium locks. */
10457	AssertReturnVoid(!pMedium->isWriteLockOnCurrentThread());
10458	AssertReturnVoid(!pBase->isWriteLockOnCurrentThread());
10459
10460	// decide which medium registry to use now that the medium is attached:
10461	Guid uuid;
10462	bool fCanHaveOwnMediaRegistry = mData->pMachineConfigFile->canHaveOwnMediaRegistry();
10463	if (fCanHaveOwnMediaRegistry)
10464	// machine XML is VirtualBox 4.0 or higher:
10465	uuid = i_getId(); // machine UUID
10466	else
10467	uuid = mParent->i_getGlobalRegistryId(); // VirtualBox global registry UUID
10468
10469	if (fCanHaveOwnMediaRegistry && pMedium->i_removeRegistry(mParent->i_getGlobalRegistryId()))
10470	mParent->i_markRegistryModified(mParent->i_getGlobalRegistryId());
10471	if (pMedium->i_addRegistry(uuid))
10472	mParent->i_markRegistryModified(uuid);
10473
10474	/* For more complex hard disk structures it can happen that the base
10475	* medium isn't yet associated with any medium registry. Do that now. */
10476	if (pMedium != pBase)
10477	{
10478	/* Tree lock needed by Medium::addRegistryAll. */
10479	AutoReadLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10480	if (fCanHaveOwnMediaRegistry && pBase->i_removeRegistryAll(mParent->i_getGlobalRegistryId()))
10481	{
10482	treeLock.release();
10483	mParent->i_markRegistryModified(mParent->i_getGlobalRegistryId());
10484	treeLock.acquire();
10485	}
10486	if (pBase->i_addRegistryAll(uuid))
10487	{
10488	treeLock.release();
10489	mParent->i_markRegistryModified(uuid);
10490	}
10491	}
10492	}
10493
10494	/**
10495	* Physically deletes a file belonging to a machine.
10496	*
10497	* @returns HRESULT
10498	* @retval VBOX_E_FILE_ERROR on failure.
10499	* @param strFile File to delete.
10500	* @param fIgnoreFailures Whether to ignore deletion failures. Defaults to \c false.
10501	* VERR_FILE_NOT_FOUND and VERR_PATH_NOT_FOUND always will be ignored.
10502	* @param strWhat File hint which will be used when setting an error. Optional.
10503	* @param prc Where to return IPRT's status code on failure.
10504	* Optional and can be NULL.
10505	*/
10506	HRESULT Machine::i_deleteFile(const Utf8Str &strFile, bool fIgnoreFailures /* = false */,
10507	const Utf8Str &strWhat /* = "" /, int prc /* = NULL */)
10508	{
10509	AssertReturn(strFile.isNotEmpty(), E_INVALIDARG);
10510
10511	HRESULT hrc = S_OK;
10512
10513	LogFunc(("Deleting file '%s'\n", strFile.c_str()));
10514
10515	int vrc = RTFileDelete(strFile.c_str());
10516	if (RT_FAILURE(vrc))
10517	{
10518	if ( !fIgnoreFailures
10519	/* Don't (externally) bitch about stuff which doesn't exist. */
10520	&& ( vrc != VERR_FILE_NOT_FOUND
10521	&& vrc != VERR_PATH_NOT_FOUND
10522	)
10523	)
10524	{
10525	LogRel(("Deleting file '%s' failed: %Rrc\n", strFile.c_str(), vrc));
10526
10527	Utf8StrFmt strError("Error deleting %s '%s' (%Rrc)",
10528	strWhat.isEmpty() ? tr("file") : strWhat.c_str(), strFile.c_str(), vrc);
10529	hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, strError.c_str(), strFile.c_str(), vrc);
10530	}
10531	}
10532
10533	if (prc)
10534	*prc = vrc;
10535	return hrc;
10536	}
10537
10538	/**
10539	* Creates differencing hard disks for all normal hard disks attached to this
10540	* machine and a new set of attachments to refer to created disks.
10541	*
10542	* Used when taking a snapshot or when deleting the current state. Gets called
10543	* from SessionMachine::BeginTakingSnapshot() and SessionMachine::restoreSnapshotHandler().
10544	*
10545	* This method assumes that mMediumAttachments contains the original hard disk
10546	* attachments it needs to create diffs for. On success, these attachments will
10547	* be replaced with the created diffs.
10548	*
10549	* Attachments with non-normal hard disks are left as is.
10550	*
10551	* If @a aOnline is @c false then the original hard disks that require implicit
10552	* diffs will be locked for reading. Otherwise it is assumed that they are
10553	* already locked for writing (when the VM was started). Note that in the latter
10554	* case it is responsibility of the caller to lock the newly created diffs for
10555	* writing if this method succeeds.
10556	*
10557	* @param aProgress Progress object to run (must contain at least as
10558	* many operations left as the number of hard disks
10559	* attached).
10560	* @param aWeight Weight of this operation.
10561	* @param aOnline Whether the VM was online prior to this operation.
10562	*
10563	* @note The progress object is not marked as completed, neither on success nor
10564	* on failure. This is a responsibility of the caller.
10565	*
10566	* @note Locks this object and the media tree for writing.
10567	*/
10568	HRESULT Machine::i_createImplicitDiffs(IProgress *aProgress,
10569	ULONG aWeight,
10570	bool aOnline)
10571	{
10572	LogFlowThisFunc(("aOnline=%d\n", aOnline));
10573
10574	ComPtr<IInternalProgressControl> pProgressControl(aProgress);
10575	AssertReturn(!!pProgressControl, E_INVALIDARG);
10576
10577	AutoCaller autoCaller(this);
10578	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
10579
10580	AutoMultiWriteLock2 alock(this->lockHandle(),
10581	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10582
10583	/* must be in a protective state because we release the lock below */
10584	AssertReturn( mData->mMachineState == MachineState_Snapshotting
10585	\|\| mData->mMachineState == MachineState_OnlineSnapshotting
10586	\|\| mData->mMachineState == MachineState_LiveSnapshotting
10587	\|\| mData->mMachineState == MachineState_RestoringSnapshot
10588	\|\| mData->mMachineState == MachineState_DeletingSnapshot
10589	, E_FAIL);
10590
10591	HRESULT hrc = S_OK;
10592
10593	// use appropriate locked media map (online or offline)
10594	MediumLockListMap lockedMediaOffline;
10595	MediumLockListMap *lockedMediaMap;
10596	if (aOnline)
10597	lockedMediaMap = &mData->mSession.mLockedMedia;
10598	else
10599	lockedMediaMap = &lockedMediaOffline;
10600
10601	try
10602	{
10603	if (!aOnline)
10604	{
10605	/* lock all attached hard disks early to detect "in use"
10606	* situations before creating actual diffs */
10607	for (MediumAttachmentList::const_iterator
10608	it = mMediumAttachments->begin();
10609	it != mMediumAttachments->end();
10610	++it)
10611	{
10612	MediumAttachment pAtt = it;
10613	if (pAtt->i_getType() == DeviceType_HardDisk)
10614	{
10615	Medium *pMedium = pAtt->i_getMedium();
10616	Assert(pMedium);
10617
10618	MediumLockList *pMediumLockList(new MediumLockList());
10619	alock.release();
10620	hrc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
10621	NULL /* pToLockWrite */,
10622	false /* fMediumLockWriteAll */,
10623	NULL,
10624	*pMediumLockList);
10625	alock.acquire();
10626	if (FAILED(hrc))
10627	{
10628	delete pMediumLockList;
10629	throw hrc;
10630	}
10631	hrc = lockedMediaMap->Insert(pAtt, pMediumLockList);
10632	if (FAILED(hrc))
10633	throw setError(hrc, tr("Collecting locking information for all attached media failed"));
10634	}
10635	}
10636
10637	/* Now lock all media. If this fails, nothing is locked. */
10638	alock.release();
10639	hrc = lockedMediaMap->Lock();
10640	alock.acquire();
10641	if (FAILED(hrc))
10642	throw setError(hrc, tr("Locking of attached media failed"));
10643	}
10644
10645	/* remember the current list (note that we don't use backup() since
10646	* mMediumAttachments may be already backed up) */
10647	MediumAttachmentList atts = *mMediumAttachments.data();
10648
10649	/* start from scratch */
10650	mMediumAttachments->clear();
10651
10652	/* go through remembered attachments and create diffs for normal hard
10653	* disks and attach them */
10654	for (MediumAttachmentList::const_iterator
10655	it = atts.begin();
10656	it != atts.end();
10657	++it)
10658	{
10659	MediumAttachment pAtt = it;
10660
10661	DeviceType_T devType = pAtt->i_getType();
10662	Medium *pMedium = pAtt->i_getMedium();
10663
10664	if ( devType != DeviceType_HardDisk
10665	\|\| pMedium == NULL
10666	\|\| pMedium->i_getType() != MediumType_Normal)
10667	{
10668	/* copy the attachment as is */
10669
10670	/** @todo the progress object created in SessionMachine::TakeSnaphot
10671	* only expects operations for hard disks. Later other
10672	* device types need to show up in the progress as well. */
10673	if (devType == DeviceType_HardDisk)
10674	{
10675	if (pMedium == NULL)
10676	pProgressControl->SetNextOperation(Bstr(tr("Skipping attachment without medium")).raw(),
10677	aWeight); // weight
10678	else
10679	pProgressControl->SetNextOperation(BstrFmt(tr("Skipping medium '%s'"),
10680	pMedium->i_getBase()->i_getName().c_str()).raw(),
10681	aWeight); // weight
10682	}
10683
10684	mMediumAttachments->push_back(pAtt);
10685	continue;
10686	}
10687
10688	/* need a diff */
10689	pProgressControl->SetNextOperation(BstrFmt(tr("Creating differencing hard disk for '%s'"),
10690	pMedium->i_getBase()->i_getName().c_str()).raw(),
10691	aWeight); // weight
10692
10693	Utf8Str strFullSnapshotFolder;
10694	i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
10695
10696	ComObjPtr<Medium> diff;
10697	diff.createObject();
10698	// store the diff in the same registry as the parent
10699	// (this cannot fail here because we can't create implicit diffs for
10700	// unregistered images)
10701	Guid uuidRegistryParent;
10702	bool fInRegistry = pMedium->i_getFirstRegistryMachineId(uuidRegistryParent);
10703	Assert(fInRegistry); NOREF(fInRegistry);
10704	hrc = diff->init(mParent,
10705	pMedium->i_getPreferredDiffFormat(),
10706	strFullSnapshotFolder.append(RTPATH_SLASH_STR),
10707	uuidRegistryParent,
10708	DeviceType_HardDisk);
10709	if (FAILED(hrc)) throw hrc;
10710
10711	/** @todo r=bird: How is the locking and diff image cleaned up if we fail before
10712	* the push_back? Looks like we're going to release medium with the
10713	* wrong kind of lock (general issue with if we fail anywhere at all)
10714	* and an orphaned VDI in the snapshots folder. */
10715
10716	/* update the appropriate lock list */
10717	MediumLockList *pMediumLockList;
10718	hrc = lockedMediaMap->Get(pAtt, pMediumLockList);
10719	AssertComRCThrowRC(hrc);
10720	if (aOnline)
10721	{
10722	alock.release();
10723	/* The currently attached medium will be read-only, change
10724	* the lock type to read. */
10725	hrc = pMediumLockList->Update(pMedium, false);
10726	alock.acquire();
10727	AssertComRCThrowRC(hrc);
10728	}
10729
10730	/* release the locks before the potentially lengthy operation */
10731	alock.release();
10732	hrc = pMedium->i_createDiffStorage(diff,
10733	pMedium->i_getPreferredDiffVariant(),
10734	pMediumLockList,
10735	NULL /* aProgress */,
10736	true /* aWait */,
10737	false /* aNotify */);
10738	alock.acquire();
10739	if (FAILED(hrc)) throw hrc;
10740
10741	/* actual lock list update is done in Machine::i_commitMedia */
10742
10743	hrc = diff->i_addBackReference(mData->mUuid);
10744	AssertComRCThrowRC(hrc);
10745
10746	/* add a new attachment */
10747	ComObjPtr<MediumAttachment> attachment;
10748	attachment.createObject();
10749	hrc = attachment->init(this,
10750	diff,
10751	pAtt->i_getControllerName(),
10752	pAtt->i_getPort(),
10753	pAtt->i_getDevice(),
10754	DeviceType_HardDisk,
10755	true /* aImplicit */,
10756	false /* aPassthrough */,
10757	false /* aTempEject */,
10758	pAtt->i_getNonRotational(),
10759	pAtt->i_getDiscard(),
10760	pAtt->i_getHotPluggable(),
10761	pAtt->i_getBandwidthGroup());
10762	if (FAILED(hrc)) throw hrc;
10763
10764	hrc = lockedMediaMap->ReplaceKey(pAtt, attachment);
10765	AssertComRCThrowRC(hrc);
10766	mMediumAttachments->push_back(attachment);
10767	}
10768	}
10769	catch (HRESULT hrcXcpt)
10770	{
10771	hrc = hrcXcpt;
10772	}
10773
10774	/* unlock all hard disks we locked when there is no VM */
10775	if (!aOnline)
10776	{
10777	ErrorInfoKeeper eik;
10778
10779	HRESULT hrc2 = lockedMediaMap->Clear();
10780	AssertComRC(hrc2);
10781	}
10782
10783	return hrc;
10784	}
10785
10786	/**
10787	* Deletes implicit differencing hard disks created either by
10788	* #i_createImplicitDiffs() or by #attachDevice() and rolls back
10789	* mMediumAttachments.
10790	*
10791	* Note that to delete hard disks created by #attachDevice() this method is
10792	* called from #i_rollbackMedia() when the changes are rolled back.
10793	*
10794	* @note Locks this object and the media tree for writing.
10795	*/
10796	HRESULT Machine::i_deleteImplicitDiffs(bool aOnline)
10797	{
10798	LogFlowThisFunc(("aOnline=%d\n", aOnline));
10799
10800	AutoCaller autoCaller(this);
10801	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
10802
10803	AutoMultiWriteLock2 alock(this->lockHandle(),
10804	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10805
10806	/* We absolutely must have backed up state. */
10807	AssertReturn(mMediumAttachments.isBackedUp(), E_FAIL);
10808
10809	/* Check if there are any implicitly created diff images. */
10810	bool fImplicitDiffs = false;
10811	for (MediumAttachmentList::const_iterator
10812	it = mMediumAttachments->begin();
10813	it != mMediumAttachments->end();
10814	++it)
10815	{
10816	const ComObjPtr<MediumAttachment> &pAtt = *it;
10817	if (pAtt->i_isImplicit())
10818	{
10819	fImplicitDiffs = true;
10820	break;
10821	}
10822	}
10823	/* If there is nothing to do, leave early. This saves lots of image locking
10824	* effort. It also avoids a MachineStateChanged event without real reason.
10825	* This is important e.g. when loading a VM config, because there should be
10826	* no events. Otherwise API clients can become thoroughly confused for
10827	* inaccessible VMs (the code for loading VM configs uses this method for
10828	* cleanup if the config makes no sense), as they take such events as an
10829	* indication that the VM is alive, and they would force the VM config to
10830	* be reread, leading to an endless loop. */
10831	if (!fImplicitDiffs)
10832	return S_OK;
10833
10834	HRESULT hrc = S_OK;
10835	MachineState_T oldState = mData->mMachineState;
10836
10837	/* will release the lock before the potentially lengthy operation,
10838	* so protect with the special state (unless already protected) */
10839	if ( oldState != MachineState_Snapshotting
10840	&& oldState != MachineState_OnlineSnapshotting
10841	&& oldState != MachineState_LiveSnapshotting
10842	&& oldState != MachineState_RestoringSnapshot
10843	&& oldState != MachineState_DeletingSnapshot
10844	&& oldState != MachineState_DeletingSnapshotOnline
10845	&& oldState != MachineState_DeletingSnapshotPaused
10846	)
10847	i_setMachineState(MachineState_SettingUp);
10848
10849	// use appropriate locked media map (online or offline)
10850	MediumLockListMap lockedMediaOffline;
10851	MediumLockListMap *lockedMediaMap;
10852	if (aOnline)
10853	lockedMediaMap = &mData->mSession.mLockedMedia;
10854	else
10855	lockedMediaMap = &lockedMediaOffline;
10856
10857	try
10858	{
10859	if (!aOnline)
10860	{
10861	/* lock all attached hard disks early to detect "in use"
10862	* situations before deleting actual diffs */
10863	for (MediumAttachmentList::const_iterator
10864	it = mMediumAttachments->begin();
10865	it != mMediumAttachments->end();
10866	++it)
10867	{
10868	MediumAttachment pAtt = it;
10869	if (pAtt->i_getType() == DeviceType_HardDisk)
10870	{
10871	Medium *pMedium = pAtt->i_getMedium();
10872	Assert(pMedium);
10873
10874	MediumLockList *pMediumLockList(new MediumLockList());
10875	alock.release();
10876	hrc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
10877	NULL /* pToLockWrite */,
10878	false /* fMediumLockWriteAll */,
10879	NULL,
10880	*pMediumLockList);
10881	alock.acquire();
10882
10883	if (FAILED(hrc))
10884	{
10885	delete pMediumLockList;
10886	throw hrc;
10887	}
10888
10889	hrc = lockedMediaMap->Insert(pAtt, pMediumLockList);
10890	if (FAILED(hrc))
10891	throw hrc;
10892	}
10893	}
10894
10895	if (FAILED(hrc))
10896	throw hrc;
10897	} // end of offline
10898
10899	/* Lock lists are now up to date and include implicitly created media */
10900
10901	/* Go through remembered attachments and delete all implicitly created
10902	* diffs and fix up the attachment information */
10903	const MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
10904	MediumAttachmentList implicitAtts;
10905	for (MediumAttachmentList::const_iterator
10906	it = mMediumAttachments->begin();
10907	it != mMediumAttachments->end();
10908	++it)
10909	{
10910	ComObjPtr<MediumAttachment> pAtt = *it;
10911	ComObjPtr<Medium> pMedium = pAtt->i_getMedium();
10912	if (pMedium.isNull())
10913	continue;
10914
10915	// Implicit attachments go on the list for deletion and back references are removed.
10916	if (pAtt->i_isImplicit())
10917	{
10918	/* Deassociate and mark for deletion */
10919	LogFlowThisFunc(("Detaching '%s', pending deletion\n", pAtt->i_getLogName()));
10920	hrc = pMedium->i_removeBackReference(mData->mUuid);
10921	if (FAILED(hrc))
10922	throw hrc;
10923	implicitAtts.push_back(pAtt);
10924	continue;
10925	}
10926
10927	/* Was this medium attached before? */
10928	if (!i_findAttachment(oldAtts, pMedium))
10929	{
10930	/* no: de-associate */
10931	LogFlowThisFunc(("Detaching '%s', no deletion\n", pAtt->i_getLogName()));
10932	hrc = pMedium->i_removeBackReference(mData->mUuid);
10933	if (FAILED(hrc))
10934	throw hrc;
10935	continue;
10936	}
10937	LogFlowThisFunc(("Not detaching '%s'\n", pAtt->i_getLogName()));
10938	}
10939
10940	/* If there are implicit attachments to delete, throw away the lock
10941	* map contents (which will unlock all media) since the medium
10942	* attachments will be rolled back. Below we need to completely
10943	* recreate the lock map anyway since it is infinitely complex to
10944	* do this incrementally (would need reconstructing each attachment
10945	* change, which would be extremely hairy). */
10946	if (implicitAtts.size() != 0)
10947	{
10948	ErrorInfoKeeper eik;
10949
10950	HRESULT hrc2 = lockedMediaMap->Clear();
10951	AssertComRC(hrc2);
10952	}
10953
10954	/* rollback hard disk changes */
10955	mMediumAttachments.rollback();
10956
10957	MultiResult mrc(S_OK);
10958
10959	// Delete unused implicit diffs.
10960	if (implicitAtts.size() != 0)
10961	{
10962	alock.release();
10963
10964	for (MediumAttachmentList::const_iterator
10965	it = implicitAtts.begin();
10966	it != implicitAtts.end();
10967	++it)
10968	{
10969	// Remove medium associated with this attachment.
10970	ComObjPtr<MediumAttachment> pAtt = *it;
10971	Assert(pAtt);
10972	LogFlowThisFunc(("Deleting '%s'\n", pAtt->i_getLogName()));
10973	ComObjPtr<Medium> pMedium = pAtt->i_getMedium();
10974	Assert(pMedium);
10975
10976	hrc = pMedium->i_deleteStorage(NULL /aProgress/, true /aWait/, false /aNotify/);
10977	// continue on delete failure, just collect error messages
10978	AssertMsg(SUCCEEDED(hrc), ("hrc=%Rhrc it=%s hd=%s\n", hrc, pAtt->i_getLogName(),
10979	pMedium->i_getLocationFull().c_str() ));
10980	mrc = hrc;
10981	}
10982	// Clear the list of deleted implicit attachments now, while not
10983	// holding the lock, as it will ultimately trigger Medium::uninit()
10984	// calls which assume that the media tree lock isn't held.
10985	implicitAtts.clear();
10986
10987	alock.acquire();
10988
10989	/* if there is a VM recreate media lock map as mentioned above,
10990	* otherwise it is a waste of time and we leave things unlocked */
10991	if (aOnline)
10992	{
10993	const ComObjPtr<SessionMachine> pMachine = mData->mSession.mMachine;
10994	/* must never be NULL, but better safe than sorry */
10995	if (!pMachine.isNull())
10996	{
10997	alock.release();
10998	hrc = mData->mSession.mMachine->i_lockMedia();
10999	alock.acquire();
11000	if (FAILED(hrc))
11001	throw hrc;
11002	}
11003	}
11004	}
11005	}
11006	catch (HRESULT hrcXcpt)
11007	{
11008	hrc = hrcXcpt;
11009	}
11010
11011	if (mData->mMachineState == MachineState_SettingUp)
11012	i_setMachineState(oldState);
11013
11014	/* unlock all hard disks we locked when there is no VM */
11015	if (!aOnline)
11016	{
11017	ErrorInfoKeeper eik;
11018
11019	HRESULT hrc2 = lockedMediaMap->Clear();
11020	AssertComRC(hrc2);
11021	}
11022
11023	return hrc;
11024	}
11025
11026
11027	/**
11028	* Looks through the given list of media attachments for one with the given parameters
11029	* and returns it, or NULL if not found. The list is a parameter so that backup lists
11030	* can be searched as well if needed.
11031	*
11032	* @param ll
11033	* @param aControllerName
11034	* @param aControllerPort
11035	* @param aDevice
11036	* @return
11037	*/
11038	MediumAttachment *Machine::i_findAttachment(const MediumAttachmentList &ll,
11039	const Utf8Str &aControllerName,
11040	LONG aControllerPort,
11041	LONG aDevice)
11042	{
11043	for (MediumAttachmentList::const_iterator
11044	it = ll.begin();
11045	it != ll.end();
11046	++it)
11047	{
11048	MediumAttachment pAttach = it;
11049	if (pAttach->i_matches(aControllerName, aControllerPort, aDevice))
11050	return pAttach;
11051	}
11052
11053	return NULL;
11054	}
11055
11056	/**
11057	* Looks through the given list of media attachments for one with the given parameters
11058	* and returns it, or NULL if not found. The list is a parameter so that backup lists
11059	* can be searched as well if needed.
11060	*
11061	* @param ll
11062	* @param pMedium
11063	* @return
11064	*/
11065	MediumAttachment *Machine::i_findAttachment(const MediumAttachmentList &ll,
11066	ComObjPtr<Medium> pMedium)
11067	{
11068	for (MediumAttachmentList::const_iterator
11069	it = ll.begin();
11070	it != ll.end();
11071	++it)
11072	{
11073	MediumAttachment pAttach = it;
11074	ComObjPtr<Medium> pMediumThis = pAttach->i_getMedium();
11075	if (pMediumThis == pMedium)
11076	return pAttach;
11077	}
11078
11079	return NULL;
11080	}
11081
11082	/**
11083	* Looks through the given list of media attachments for one with the given parameters
11084	* and returns it, or NULL if not found. The list is a parameter so that backup lists
11085	* can be searched as well if needed.
11086	*
11087	* @param ll
11088	* @param id
11089	* @return
11090	*/
11091	MediumAttachment *Machine::i_findAttachment(const MediumAttachmentList &ll,
11092	Guid &id)
11093	{
11094	for (MediumAttachmentList::const_iterator
11095	it = ll.begin();
11096	it != ll.end();
11097	++it)
11098	{
11099	MediumAttachment pAttach = it;
11100	ComObjPtr<Medium> pMediumThis = pAttach->i_getMedium();
11101	if (pMediumThis->i_getId() == id)
11102	return pAttach;
11103	}
11104
11105	return NULL;
11106	}
11107
11108	/**
11109	* Main implementation for Machine::DetachDevice. This also gets called
11110	* from Machine::prepareUnregister() so it has been taken out for simplicity.
11111	*
11112	* @param pAttach Medium attachment to detach.
11113	* @param writeLock Machine write lock which the caller must have locked once.
11114	* This may be released temporarily in here.
11115	* @param pSnapshot If NULL, then the detachment is for the current machine.
11116	* Otherwise this is for a SnapshotMachine, and this must be
11117	* its snapshot.
11118	* @return
11119	*/
11120	HRESULT Machine::i_detachDevice(MediumAttachment *pAttach,
11121	AutoWriteLock &writeLock,
11122	Snapshot *pSnapshot)
11123	{
11124	ComObjPtr<Medium> oldmedium = pAttach->i_getMedium();
11125	DeviceType_T mediumType = pAttach->i_getType();
11126
11127	LogFlowThisFunc(("Entering, medium of attachment is %s\n", oldmedium ? oldmedium->i_getLocationFull().c_str() : "NULL"));
11128
11129	if (pAttach->i_isImplicit())
11130	{
11131	/* attempt to implicitly delete the implicitly created diff */
11132
11133	/// @todo move the implicit flag from MediumAttachment to Medium
11134	/// and forbid any hard disk operation when it is implicit. Or maybe
11135	/// a special media state for it to make it even more simple.
11136
11137	Assert(mMediumAttachments.isBackedUp());
11138
11139	/* will release the lock before the potentially lengthy operation, so
11140	* protect with the special state */
11141	MachineState_T oldState = mData->mMachineState;
11142	i_setMachineState(MachineState_SettingUp);
11143
11144	writeLock.release();
11145
11146	HRESULT hrc = oldmedium->i_deleteStorage(NULL /aProgress/, true /aWait/, false /aNotify/);
11147
11148	writeLock.acquire();
11149
11150	i_setMachineState(oldState);
11151
11152	if (FAILED(hrc)) return hrc;
11153	}
11154
11155	i_setModified(IsModified_Storage);
11156	mMediumAttachments.backup();
11157	mMediumAttachments->remove(pAttach);
11158
11159	if (!oldmedium.isNull())
11160	{
11161	// if this is from a snapshot, do not defer detachment to i_commitMedia()
11162	if (pSnapshot)
11163	oldmedium->i_removeBackReference(mData->mUuid, pSnapshot->i_getId());
11164	// else if non-hard disk media, do not defer detachment to i_commitMedia() either
11165	else if (mediumType != DeviceType_HardDisk)
11166	oldmedium->i_removeBackReference(mData->mUuid);
11167	}
11168
11169	return S_OK;
11170	}
11171
11172	/**
11173	* Goes thru all media of the given list and
11174	*
11175	* 1) calls i_detachDevice() on each of them for this machine and
11176	* 2) adds all Medium objects found in the process to the given list,
11177	* depending on cleanupMode.
11178	*
11179	* If cleanupMode is CleanupMode_DetachAllReturnHardDisksOnly, this only
11180	* adds hard disks to the list. If it is CleanupMode_Full, this adds all
11181	* media to the list.
11182	* CleanupMode_DetachAllReturnHardDisksAndVMRemovable adds hard disks and
11183	* also removable media if they are located in the VM folder and referenced
11184	* only by this VM (media prepared by unattended installer).
11185	*
11186	* This gets called from Machine::Unregister, both for the actual Machine and
11187	* the SnapshotMachine objects that might be found in the snapshots.
11188	*
11189	* Requires caller and locking. The machine lock must be passed in because it
11190	* will be passed on to i_detachDevice which needs it for temporary unlocking.
11191	*
11192	* @param writeLock Machine lock from top-level caller; this gets passed to
11193	* i_detachDevice.
11194	* @param pSnapshot Must be NULL when called for a "real" Machine or a snapshot
11195	* object if called for a SnapshotMachine.
11196	* @param cleanupMode If DetachAllReturnHardDisksOnly, only hard disk media get
11197	* added to llMedia; if Full, then all media get added;
11198	* otherwise no media get added.
11199	* @param llMedia Caller's list to receive Medium objects which got detached so
11200	* caller can close() them, depending on cleanupMode.
11201	* @return
11202	*/
11203	HRESULT Machine::i_detachAllMedia(AutoWriteLock &writeLock,
11204	Snapshot *pSnapshot,
11205	CleanupMode_T cleanupMode,
11206	MediaList &llMedia)
11207	{
11208	Assert(isWriteLockOnCurrentThread());
11209
11210	HRESULT hrc;
11211
11212	// make a temporary list because i_detachDevice invalidates iterators into
11213	// mMediumAttachments
11214	MediumAttachmentList llAttachments2 = *mMediumAttachments.data();
11215
11216	for (MediumAttachmentList::iterator
11217	it = llAttachments2.begin();
11218	it != llAttachments2.end();
11219	++it)
11220	{
11221	ComObjPtr<MediumAttachment> &pAttach = *it;
11222	ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
11223
11224	if (!pMedium.isNull())
11225	{
11226	AutoCaller mac(pMedium);
11227	if (FAILED(mac.hrc())) return mac.hrc();
11228	AutoReadLock lock(pMedium COMMA_LOCKVAL_SRC_POS);
11229	DeviceType_T devType = pMedium->i_getDeviceType();
11230	size_t cBackRefs = pMedium->i_getMachineBackRefCount();
11231	Utf8Str strMediumLocation = pMedium->i_getLocationFull();
11232	strMediumLocation.stripFilename();
11233	Utf8Str strMachineFolder = i_getSettingsFileFull();
11234	strMachineFolder.stripFilename();
11235	if ( ( cleanupMode == CleanupMode_DetachAllReturnHardDisksOnly
11236	&& devType == DeviceType_HardDisk)
11237	\|\| ( cleanupMode == CleanupMode_DetachAllReturnHardDisksAndVMRemovable
11238	&& ( devType == DeviceType_HardDisk
11239	\|\| ( cBackRefs <= 1
11240	&& strMediumLocation == strMachineFolder
11241	&& *pMedium->i_getFirstMachineBackrefId() == i_getId())))
11242	\|\| (cleanupMode == CleanupMode_Full)
11243	)
11244	{
11245	llMedia.push_back(pMedium);
11246	ComObjPtr<Medium> pParent = pMedium->i_getParent();
11247	/* Not allowed to keep this lock as below we need the parent
11248	* medium lock, and the lock order is parent to child. */
11249	lock.release();
11250	/*
11251	* Search for media which are not attached to any machine, but
11252	* in the chain to an attached disk. Media are only consided
11253	* if they are:
11254	* - have only one child
11255	* - no references to any machines
11256	* - are of normal medium type
11257	*/
11258	while (!pParent.isNull())
11259	{
11260	AutoCaller mac1(pParent);
11261	if (FAILED(mac1.hrc())) return mac1.hrc();
11262	AutoReadLock lock1(pParent COMMA_LOCKVAL_SRC_POS);
11263	if (pParent->i_getChildren().size() == 1)
11264	{
11265	if ( pParent->i_getMachineBackRefCount() == 0
11266	&& pParent->i_getType() == MediumType_Normal
11267	&& find(llMedia.begin(), llMedia.end(), pParent) == llMedia.end())
11268	llMedia.push_back(pParent);
11269	}
11270	else
11271	break;
11272	pParent = pParent->i_getParent();
11273	}
11274	}
11275	}
11276
11277	// real machine: then we need to use the proper method
11278	hrc = i_detachDevice(pAttach, writeLock, pSnapshot);
11279
11280	if (FAILED(hrc))
11281	return hrc;
11282	}
11283
11284	return S_OK;
11285	}
11286
11287	/**
11288	* Perform deferred hard disk detachments.
11289	*
11290	* Does nothing if the hard disk attachment data (mMediumAttachments) is not
11291	* changed (not backed up).
11292	*
11293	* If @a aOnline is @c true then this method will also unlock the old hard
11294	* disks for which the new implicit diffs were created and will lock these new
11295	* diffs for writing.
11296	*
11297	* @param aOnline Whether the VM was online prior to this operation.
11298	*
11299	* @note Locks this object for writing!
11300	*/
11301	void Machine::i_commitMedia(bool aOnline /= false/)
11302	{
11303	AutoCaller autoCaller(this);
11304	AssertComRCReturnVoid(autoCaller.hrc());
11305
11306	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11307
11308	LogFlowThisFunc(("Entering, aOnline=%d\n", aOnline));
11309
11310	HRESULT hrc = S_OK;
11311
11312	/* no attach/detach operations -- nothing to do */
11313	if (!mMediumAttachments.isBackedUp())
11314	return;
11315
11316	MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
11317	bool fMediaNeedsLocking = false;
11318
11319	/* enumerate new attachments */
11320	for (MediumAttachmentList::const_iterator
11321	it = mMediumAttachments->begin();
11322	it != mMediumAttachments->end();
11323	++it)
11324	{
11325	MediumAttachment pAttach = it;
11326
11327	pAttach->i_commit();
11328
11329	Medium *pMedium = pAttach->i_getMedium();
11330	bool fImplicit = pAttach->i_isImplicit();
11331
11332	LogFlowThisFunc(("Examining current medium '%s' (implicit: %d)\n",
11333	(pMedium) ? pMedium->i_getName().c_str() : "NULL",
11334	fImplicit));
11335
11336	/** @todo convert all this Machine-based voodoo to MediumAttachment
11337	* based commit logic. */
11338	if (fImplicit)
11339	{
11340	/* convert implicit attachment to normal */
11341	pAttach->i_setImplicit(false);
11342
11343	if ( aOnline
11344	&& pMedium
11345	&& pAttach->i_getType() == DeviceType_HardDisk
11346	)
11347	{
11348	/* update the appropriate lock list */
11349	MediumLockList *pMediumLockList;
11350	hrc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
11351	AssertComRC(hrc);
11352	if (pMediumLockList)
11353	{
11354	/* unlock if there's a need to change the locking */
11355	if (!fMediaNeedsLocking)
11356	{
11357	Assert(mData->mSession.mLockedMedia.IsLocked());
11358	hrc = mData->mSession.mLockedMedia.Unlock();
11359	AssertComRC(hrc);
11360	fMediaNeedsLocking = true;
11361	}
11362	hrc = pMediumLockList->Update(pMedium->i_getParent(), false);
11363	AssertComRC(hrc);
11364	hrc = pMediumLockList->Append(pMedium, true);
11365	AssertComRC(hrc);
11366	}
11367	}
11368
11369	continue;
11370	}
11371
11372	if (pMedium)
11373	{
11374	/* was this medium attached before? */
11375	for (MediumAttachmentList::iterator
11376	oldIt = oldAtts.begin();
11377	oldIt != oldAtts.end();
11378	++oldIt)
11379	{
11380	MediumAttachment pOldAttach = oldIt;
11381	if (pOldAttach->i_getMedium() == pMedium)
11382	{
11383	LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->i_getName().c_str()));
11384
11385	/* yes: remove from old to avoid de-association */
11386	oldAtts.erase(oldIt);
11387	break;
11388	}
11389	}
11390	}
11391	}
11392
11393	/* enumerate remaining old attachments and de-associate from the
11394	* current machine state */
11395	for (MediumAttachmentList::const_iterator
11396	it = oldAtts.begin();
11397	it != oldAtts.end();
11398	++it)
11399	{
11400	MediumAttachment pAttach = it;
11401	Medium *pMedium = pAttach->i_getMedium();
11402
11403	/* Detach only hard disks, since DVD/floppy media is detached
11404	* instantly in MountMedium. */
11405	if (pAttach->i_getType() == DeviceType_HardDisk && pMedium)
11406	{
11407	LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->i_getName().c_str()));
11408
11409	/* now de-associate from the current machine state */
11410	hrc = pMedium->i_removeBackReference(mData->mUuid);
11411	AssertComRC(hrc);
11412
11413	if (aOnline)
11414	{
11415	/* unlock since medium is not used anymore */
11416	MediumLockList *pMediumLockList;
11417	hrc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
11418	if (RT_UNLIKELY(hrc == VBOX_E_INVALID_OBJECT_STATE))
11419	{
11420	/* this happens for online snapshots, there the attachment
11421	* is changing, but only to a diff image created under
11422	* the old one, so there is no separate lock list */
11423	Assert(!pMediumLockList);
11424	}
11425	else
11426	{
11427	AssertComRC(hrc);
11428	if (pMediumLockList)
11429	{
11430	hrc = mData->mSession.mLockedMedia.Remove(pAttach);
11431	AssertComRC(hrc);
11432	}
11433	}
11434	}
11435	}
11436	}
11437
11438	/* take media locks again so that the locking state is consistent */
11439	if (fMediaNeedsLocking)
11440	{
11441	Assert(aOnline);
11442	hrc = mData->mSession.mLockedMedia.Lock();
11443	AssertComRC(hrc);
11444	}
11445
11446	/* commit the hard disk changes */
11447	mMediumAttachments.commit();
11448
11449	if (i_isSessionMachine())
11450	{
11451	/*
11452	* Update the parent machine to point to the new owner.
11453	* This is necessary because the stored parent will point to the
11454	* session machine otherwise and cause crashes or errors later
11455	* when the session machine gets invalid.
11456	*/
11457	/** @todo Change the MediumAttachment class to behave like any other
11458	* class in this regard by creating peer MediumAttachment
11459	* objects for session machines and share the data with the peer
11460	* machine.
11461	*/
11462	for (MediumAttachmentList::const_iterator
11463	it = mMediumAttachments->begin();
11464	it != mMediumAttachments->end();
11465	++it)
11466	(*it)->i_updateParentMachine(mPeer);
11467
11468	/* attach new data to the primary machine and reshare it */
11469	mPeer->mMediumAttachments.attach(mMediumAttachments);
11470	}
11471
11472	return;
11473	}
11474
11475	/**
11476	* Perform deferred deletion of implicitly created diffs.
11477	*
11478	* Does nothing if the hard disk attachment data (mMediumAttachments) is not
11479	* changed (not backed up).
11480	*
11481	* @note Locks this object for writing!
11482	*/
11483	void Machine::i_rollbackMedia()
11484	{
11485	AutoCaller autoCaller(this);
11486	AssertComRCReturnVoid(autoCaller.hrc());
11487
11488	// AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11489	LogFlowThisFunc(("Entering rollbackMedia\n"));
11490
11491	HRESULT hrc = S_OK;
11492
11493	/* no attach/detach operations -- nothing to do */
11494	if (!mMediumAttachments.isBackedUp())
11495	return;
11496
11497	/* enumerate new attachments */
11498	for (MediumAttachmentList::const_iterator
11499	it = mMediumAttachments->begin();
11500	it != mMediumAttachments->end();
11501	++it)
11502	{
11503	MediumAttachment pAttach = it;
11504	/* Fix up the backrefs for DVD/floppy media. */
11505	if (pAttach->i_getType() != DeviceType_HardDisk)
11506	{
11507	Medium *pMedium = pAttach->i_getMedium();
11508	if (pMedium)
11509	{
11510	hrc = pMedium->i_removeBackReference(mData->mUuid);
11511	AssertComRC(hrc);
11512	}
11513	}
11514
11515	(*it)->i_rollback();
11516
11517	pAttach = *it;
11518	/* Fix up the backrefs for DVD/floppy media. */
11519	if (pAttach->i_getType() != DeviceType_HardDisk)
11520	{
11521	Medium *pMedium = pAttach->i_getMedium();
11522	if (pMedium)
11523	{
11524	hrc = pMedium->i_addBackReference(mData->mUuid);
11525	AssertComRC(hrc);
11526	}
11527	}
11528	}
11529
11530	/** @todo convert all this Machine-based voodoo to MediumAttachment
11531	* based rollback logic. */
11532	i_deleteImplicitDiffs(Global::IsOnline(mData->mMachineState));
11533
11534	return;
11535	}
11536
11537	/**
11538	* Returns true if the settings file is located in the directory named exactly
11539	* as the machine; this means, among other things, that the machine directory
11540	* should be auto-renamed.
11541	*
11542	* @param aSettingsDir if not NULL, the full machine settings file directory
11543	* name will be assigned there.
11544	*
11545	* @note Doesn't lock anything.
11546	* @note Not thread safe (must be called from this object's lock).
11547	*/
11548	bool Machine::i_isInOwnDir(Utf8Str aSettingsDir / = NULL */) const
11549	{
11550	Utf8Str strMachineDirName(mData->m_strConfigFileFull); // path/to/machinesfolder/vmname/vmname.vbox
11551	strMachineDirName.stripFilename(); // path/to/machinesfolder/vmname
11552	if (aSettingsDir)
11553	*aSettingsDir = strMachineDirName;
11554	strMachineDirName.stripPath(); // vmname
11555	Utf8Str strConfigFileOnly(mData->m_strConfigFileFull); // path/to/machinesfolder/vmname/vmname.vbox
11556	strConfigFileOnly.stripPath() // vmname.vbox
11557	.stripSuffix(); // vmname
11558	/** @todo hack, make somehow use of ComposeMachineFilename */
11559	if (mUserData->s.fDirectoryIncludesUUID)
11560	strConfigFileOnly.appendPrintf(" (%RTuuid)", mData->mUuid.raw());
11561
11562	AssertReturn(!strMachineDirName.isEmpty(), false);
11563	AssertReturn(!strConfigFileOnly.isEmpty(), false);
11564
11565	return strMachineDirName == strConfigFileOnly;
11566	}
11567
11568	/**
11569	* Discards all changes to machine settings.
11570	*
11571	* @param aNotify Whether to notify the direct session about changes or not.
11572	*
11573	* @note Locks objects for writing!
11574	*/
11575	void Machine::i_rollback(bool aNotify)
11576	{
11577	AutoCaller autoCaller(this);
11578	AssertComRCReturn(autoCaller.hrc(), (void)0);
11579
11580	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11581
11582	if (!mStorageControllers.isNull())
11583	{
11584	if (mStorageControllers.isBackedUp())
11585	{
11586	/* unitialize all new devices (absent in the backed up list). */
11587	StorageControllerList *backedList = mStorageControllers.backedUpData();
11588	for (StorageControllerList::const_iterator
11589	it = mStorageControllers->begin();
11590	it != mStorageControllers->end();
11591	++it)
11592	{
11593	if ( std::find(backedList->begin(), backedList->end(), *it)
11594	== backedList->end()
11595	)
11596	{
11597	(*it)->uninit();
11598	}
11599	}
11600
11601	/* restore the list */
11602	mStorageControllers.rollback();
11603	}
11604
11605	/* rollback any changes to devices after restoring the list */
11606	if (mData->flModifications & IsModified_Storage)
11607	{
11608	for (StorageControllerList::const_iterator
11609	it = mStorageControllers->begin();
11610	it != mStorageControllers->end();
11611	++it)
11612	{
11613	(*it)->i_rollback();
11614	}
11615	}
11616	}
11617
11618	if (!mUSBControllers.isNull())
11619	{
11620	if (mUSBControllers.isBackedUp())
11621	{
11622	/* unitialize all new devices (absent in the backed up list). */
11623	USBControllerList *backedList = mUSBControllers.backedUpData();
11624	for (USBControllerList::const_iterator
11625	it = mUSBControllers->begin();
11626	it != mUSBControllers->end();
11627	++it)
11628	{
11629	if ( std::find(backedList->begin(), backedList->end(), *it)
11630	== backedList->end()
11631	)
11632	{
11633	(*it)->uninit();
11634	}
11635	}
11636
11637	/* restore the list */
11638	mUSBControllers.rollback();
11639	}
11640
11641	/* rollback any changes to devices after restoring the list */
11642	if (mData->flModifications & IsModified_USB)
11643	{
11644	for (USBControllerList::const_iterator
11645	it = mUSBControllers->begin();
11646	it != mUSBControllers->end();
11647	++it)
11648	{
11649	(*it)->i_rollback();
11650	}
11651	}
11652	}
11653
11654	mUserData.rollback();
11655
11656	mHWData.rollback();
11657
11658	if (mData->flModifications & IsModified_Storage)
11659	i_rollbackMedia();
11660
11661	if (mPlatform)
11662	{
11663	mPlatform->i_rollback();
11664	i_platformPropertiesUpdate();
11665	}
11666
11667	if (mFirmwareSettings)
11668	mFirmwareSettings->i_rollback();
11669
11670	if (mRecordingSettings && (mData->flModifications & IsModified_Recording))
11671	mRecordingSettings->i_rollback();
11672
11673	if (mTrustedPlatformModule)
11674	mTrustedPlatformModule->i_rollback();
11675
11676	if (mNvramStore)
11677	mNvramStore->i_rollback();
11678
11679	if (mGraphicsAdapter && (mData->flModifications & IsModified_GraphicsAdapter))
11680	mGraphicsAdapter->i_rollback();
11681
11682	if (mVRDEServer && (mData->flModifications & IsModified_VRDEServer))
11683	mVRDEServer->i_rollback();
11684
11685	if (mAudioSettings && (mData->flModifications & IsModified_AudioSettings))
11686	mAudioSettings->i_rollback();
11687
11688	if (mUSBDeviceFilters && (mData->flModifications & IsModified_USB))
11689	mUSBDeviceFilters->i_rollback();
11690
11691	if (mBandwidthControl && (mData->flModifications & IsModified_BandwidthControl))
11692	mBandwidthControl->i_rollback();
11693
11694	if (mGuestDebugControl && (mData->flModifications & IsModified_GuestDebugControl))
11695	mGuestDebugControl->i_rollback();
11696
11697	if (mPlatform && (mData->flModifications & IsModified_Platform))
11698	{
11699	ChipsetType_T enmChipset;
11700	HRESULT hrc = mPlatform->getChipsetType(&enmChipset);
11701	ComAssertComRC(hrc);
11702
11703	mNetworkAdapters.resize(PlatformProperties::s_getMaxNetworkAdapters(enmChipset));
11704	}
11705
11706	NetworkAdapterVector networkAdapters(mNetworkAdapters.size());
11707	ComPtr<ISerialPort> serialPorts[RT_ELEMENTS(mSerialPorts)];
11708	ComPtr<IParallelPort> parallelPorts[RT_ELEMENTS(mParallelPorts)];
11709
11710	if (mData->flModifications & IsModified_NetworkAdapters)
11711	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
11712	if ( mNetworkAdapters[slot]
11713	&& mNetworkAdapters[slot]->i_isModified())
11714	{
11715	mNetworkAdapters[slot]->i_rollback();
11716	networkAdapters[slot] = mNetworkAdapters[slot];
11717	}
11718
11719	if (mData->flModifications & IsModified_SerialPorts)
11720	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
11721	if ( mSerialPorts[slot]
11722	&& mSerialPorts[slot]->i_isModified())
11723	{
11724	mSerialPorts[slot]->i_rollback();
11725	serialPorts[slot] = mSerialPorts[slot];
11726	}
11727
11728	if (mData->flModifications & IsModified_ParallelPorts)
11729	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
11730	if ( mParallelPorts[slot]
11731	&& mParallelPorts[slot]->i_isModified())
11732	{
11733	mParallelPorts[slot]->i_rollback();
11734	parallelPorts[slot] = mParallelPorts[slot];
11735	}
11736
11737	if (aNotify)
11738	{
11739	/* inform the direct session about changes */
11740
11741	ComObjPtr<Machine> that = this;
11742	uint32_t flModifications = mData->flModifications;
11743	alock.release();
11744
11745	if (flModifications & IsModified_SharedFolders)
11746	that->i_onSharedFolderChange();
11747
11748	if (flModifications & IsModified_VRDEServer)
11749	that->i_onVRDEServerChange(/* aRestart */ TRUE);
11750	if (flModifications & IsModified_USB)
11751	that->i_onUSBControllerChange();
11752
11753	for (ULONG slot = 0; slot < networkAdapters.size(); ++slot)
11754	if (networkAdapters[slot])
11755	that->i_onNetworkAdapterChange(networkAdapters[slot], FALSE);
11756	for (ULONG slot = 0; slot < RT_ELEMENTS(serialPorts); ++slot)
11757	if (serialPorts[slot])
11758	that->i_onSerialPortChange(serialPorts[slot]);
11759	for (ULONG slot = 0; slot < RT_ELEMENTS(parallelPorts); ++slot)
11760	if (parallelPorts[slot])
11761	that->i_onParallelPortChange(parallelPorts[slot]);
11762
11763	if (flModifications & IsModified_Storage)
11764	{
11765	for (StorageControllerList::const_iterator
11766	it = mStorageControllers->begin();
11767	it != mStorageControllers->end();
11768	++it)
11769	{
11770	that->i_onStorageControllerChange(that->i_getId(), (*it)->i_getName());
11771	}
11772	}
11773
11774	if (flModifications & IsModified_GuestDebugControl)
11775	that->i_onGuestDebugControlChange(mGuestDebugControl);
11776
11777	#if 0
11778	if (flModifications & IsModified_BandwidthControl)
11779	that->onBandwidthControlChange();
11780	#endif
11781	}
11782	}
11783
11784	/**
11785	* Commits all the changes to machine settings.
11786	*
11787	* Note that this operation is supposed to never fail.
11788	*
11789	* @note Locks this object and children for writing.
11790	*/
11791	void Machine::i_commit()
11792	{
11793	AutoCaller autoCaller(this);
11794	AssertComRCReturnVoid(autoCaller.hrc());
11795
11796	AutoCaller peerCaller(mPeer);
11797	AssertComRCReturnVoid(peerCaller.hrc());
11798
11799	AutoMultiWriteLock2 alock(mPeer, this COMMA_LOCKVAL_SRC_POS);
11800
11801	/*
11802	* use safe commit to ensure Snapshot machines (that share mUserData)
11803	* will still refer to a valid memory location
11804	*/
11805	mUserData.commitCopy();
11806
11807	mHWData.commit();
11808
11809	if (mMediumAttachments.isBackedUp())
11810	i_commitMedia(Global::IsOnline(mData->mMachineState));
11811
11812	mPlatform->i_commit();
11813	mFirmwareSettings->i_commit();
11814	mRecordingSettings->i_commit();
11815	mTrustedPlatformModule->i_commit();
11816	mNvramStore->i_commit();
11817	mGraphicsAdapter->i_commit();
11818	mVRDEServer->i_commit();
11819	mAudioSettings->i_commit();
11820	mUSBDeviceFilters->i_commit();
11821	mBandwidthControl->i_commit();
11822	mGuestDebugControl->i_commit();
11823
11824	/* Since mNetworkAdapters is a list which might have been changed (resized)
11825	* without using the Backupable<> template we need to handle the copying
11826	* of the list entries manually, including the creation of peers for the
11827	* new objects. */
11828	ChipsetType_T enmChipset;
11829	HRESULT hrc = mPlatform->getChipsetType(&enmChipset);
11830	ComAssertComRC(hrc);
11831
11832	bool commitNetworkAdapters = false;
11833	size_t const newSize = PlatformProperties::s_getMaxNetworkAdapters(enmChipset);
11834	if (mPeer)
11835	{
11836	size_t const oldSize = mNetworkAdapters.size();
11837	size_t const oldPeerSize = mPeer->mNetworkAdapters.size();
11838
11839	/* commit everything, even the ones which will go away */
11840	for (size_t slot = 0; slot < oldSize; slot++)
11841	mNetworkAdapters[slot]->i_commit();
11842	/* copy over the new entries, creating a peer and uninit the original */
11843	mPeer->mNetworkAdapters.resize(RT_MAX(newSize, oldPeerSize));
11844	/* make sure to have enough room for iterating over the (newly added) slots down below */
11845	if (newSize > oldSize)
11846	{
11847	mNetworkAdapters.resize(newSize);
11848
11849	com::Utf8Str osTypeId;
11850	ComObjPtr<GuestOSType> osType = NULL;
11851	hrc = getOSTypeId(osTypeId);
11852	if (SUCCEEDED(hrc))
11853	hrc = mParent->i_findGuestOSType(Bstr(osTypeId), osType);
11854
11855	for (size_t slot = oldSize; slot < newSize; slot++)
11856	{
11857	mNetworkAdapters[slot].createObject();
11858	mNetworkAdapters[slot]->init(this, (ULONG)slot);
11859	mNetworkAdapters[slot]->i_applyDefaults(SUCCEEDED(hrc) ? osType : NULL);
11860	}
11861	}
11862	for (size_t slot = 0; slot < newSize; slot++)
11863	{
11864	/* look if this adapter has a peer device */
11865	ComObjPtr<NetworkAdapter> peer = mNetworkAdapters[slot]->i_getPeer();
11866	if (!peer)
11867	{
11868	/* no peer means the adapter is a newly created one;
11869	* create a peer owning data this data share it with */
11870	peer.createObject();
11871	peer->init(mPeer, mNetworkAdapters[slot], true /* aReshare */);
11872	}
11873	mPeer->mNetworkAdapters[slot] = peer;
11874	}
11875	/* uninit any no longer needed network adapters */
11876	for (size_t slot = newSize; slot < oldSize; ++slot)
11877	mNetworkAdapters[slot]->uninit();
11878	for (size_t slot = newSize; slot < oldPeerSize; ++slot)
11879	{
11880	if (mPeer->mNetworkAdapters[slot])
11881	mPeer->mNetworkAdapters[slot]->uninit();
11882	}
11883	/* Keep the original network adapter count until this point, so that
11884	* discarding a chipset type change will not lose settings. */
11885	mNetworkAdapters.resize(newSize);
11886	mPeer->mNetworkAdapters.resize(newSize);
11887	}
11888	else
11889	{
11890	/* we have no peer (our parent is the newly created machine);
11891	* just commit changes to the network adapters */
11892	commitNetworkAdapters = true;
11893	}
11894	if (commitNetworkAdapters)
11895	for (size_t slot = 0; slot < mNetworkAdapters.size(); ++slot)
11896	mNetworkAdapters[slot]->i_commit();
11897
11898	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
11899	mSerialPorts[slot]->i_commit();
11900	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
11901	mParallelPorts[slot]->i_commit();
11902
11903	bool commitStorageControllers = false;
11904
11905	if (mStorageControllers.isBackedUp())
11906	{
11907	mStorageControllers.commit();
11908
11909	if (mPeer)
11910	{
11911	/* Commit all changes to new controllers (this will reshare data with
11912	* peers for those who have peers) */
11913	StorageControllerList *newList = new StorageControllerList();
11914	for (StorageControllerList::const_iterator
11915	it = mStorageControllers->begin();
11916	it != mStorageControllers->end();
11917	++it)
11918	{
11919	(*it)->i_commit();
11920
11921	/* look if this controller has a peer device */
11922	ComObjPtr<StorageController> peer = (*it)->i_getPeer();
11923	if (!peer)
11924	{
11925	/* no peer means the device is a newly created one;
11926	* create a peer owning data this device share it with */
11927	peer.createObject();
11928	peer->init(mPeer, it, true / aReshare */);
11929	}
11930	else
11931	{
11932	/* remove peer from the old list */
11933	mPeer->mStorageControllers->remove(peer);
11934	}
11935	/* and add it to the new list */
11936	newList->push_back(peer);
11937	}
11938
11939	/* uninit old peer's controllers that are left */
11940	for (StorageControllerList::const_iterator
11941	it = mPeer->mStorageControllers->begin();
11942	it != mPeer->mStorageControllers->end();
11943	++it)
11944	{
11945	(*it)->uninit();
11946	}
11947
11948	/* attach new list of controllers to our peer */
11949	mPeer->mStorageControllers.attach(newList);
11950	}
11951	else
11952	{
11953	/* we have no peer (our parent is the newly created machine);
11954	* just commit changes to devices */
11955	commitStorageControllers = true;
11956	}
11957	}
11958	else
11959	{
11960	/* the list of controllers itself is not changed,
11961	* just commit changes to controllers themselves */
11962	commitStorageControllers = true;
11963	}
11964
11965	if (commitStorageControllers)
11966	{
11967	for (StorageControllerList::const_iterator
11968	it = mStorageControllers->begin();
11969	it != mStorageControllers->end();
11970	++it)
11971	{
11972	(*it)->i_commit();
11973	}
11974	}
11975
11976	bool commitUSBControllers = false;
11977
11978	if (mUSBControllers.isBackedUp())
11979	{
11980	mUSBControllers.commit();
11981
11982	if (mPeer)
11983	{
11984	/* Commit all changes to new controllers (this will reshare data with
11985	* peers for those who have peers) */
11986	USBControllerList *newList = new USBControllerList();
11987	for (USBControllerList::const_iterator
11988	it = mUSBControllers->begin();
11989	it != mUSBControllers->end();
11990	++it)
11991	{
11992	(*it)->i_commit();
11993
11994	/* look if this controller has a peer device */
11995	ComObjPtr<USBController> peer = (*it)->i_getPeer();
11996	if (!peer)
11997	{
11998	/* no peer means the device is a newly created one;
11999	* create a peer owning data this device share it with */
12000	peer.createObject();
12001	peer->init(mPeer, it, true / aReshare */);
12002	}
12003	else
12004	{
12005	/* remove peer from the old list */
12006	mPeer->mUSBControllers->remove(peer);
12007	}
12008	/* and add it to the new list */
12009	newList->push_back(peer);
12010	}
12011
12012	/* uninit old peer's controllers that are left */
12013	for (USBControllerList::const_iterator
12014	it = mPeer->mUSBControllers->begin();
12015	it != mPeer->mUSBControllers->end();
12016	++it)
12017	{
12018	(*it)->uninit();
12019	}
12020
12021	/* attach new list of controllers to our peer */
12022	mPeer->mUSBControllers.attach(newList);
12023	}
12024	else
12025	{
12026	/* we have no peer (our parent is the newly created machine);
12027	* just commit changes to devices */
12028	commitUSBControllers = true;
12029	}
12030	}
12031	else
12032	{
12033	/* the list of controllers itself is not changed,
12034	* just commit changes to controllers themselves */
12035	commitUSBControllers = true;
12036	}
12037
12038	if (commitUSBControllers)
12039	{
12040	for (USBControllerList::const_iterator
12041	it = mUSBControllers->begin();
12042	it != mUSBControllers->end();
12043	++it)
12044	{
12045	(*it)->i_commit();
12046	}
12047	}
12048
12049	if (i_isSessionMachine())
12050	{
12051	/* attach new data to the primary machine and reshare it */
12052	mPeer->mUserData.attach(mUserData);
12053	mPeer->mHWData.attach(mHWData);
12054	/* mmMediumAttachments is reshared by fixupMedia */
12055	// mPeer->mMediumAttachments.attach(mMediumAttachments);
12056	Assert(mPeer->mMediumAttachments.data() == mMediumAttachments.data());
12057	}
12058	}
12059
12060	/**
12061	* Copies all the hardware data from the given machine.
12062	*
12063	* Currently, only called when the VM is being restored from a snapshot. In
12064	* particular, this implies that the VM is not running during this method's
12065	* call.
12066	*
12067	* @note This method must be called from under this object's lock.
12068	*
12069	* @note This method doesn't call #i_commit(), so all data remains backed up and
12070	* unsaved.
12071	*/
12072	void Machine::i_copyFrom(Machine *aThat)
12073	{
12074	AssertReturnVoid(!i_isSnapshotMachine());
12075	AssertReturnVoid(aThat->i_isSnapshotMachine());
12076
12077	AssertReturnVoid(!Global::IsOnline(mData->mMachineState));
12078
12079	mHWData.assignCopy(aThat->mHWData);
12080
12081	// create copies of all shared folders (mHWData after attaching a copy
12082	// contains just references to original objects)
12083	for (HWData::SharedFolderList::iterator
12084	it = mHWData->mSharedFolders.begin();
12085	it != mHWData->mSharedFolders.end();
12086	++it)
12087	{
12088	ComObjPtr<SharedFolder> folder;
12089	folder.createObject();
12090	HRESULT hrc = folder->initCopy(i_getMachine(), *it);
12091	AssertComRC(hrc);
12092	*it = folder;
12093	}
12094
12095	mPlatform->i_copyFrom(aThat->mPlatform);
12096	i_platformPropertiesUpdate();
12097	mFirmwareSettings->i_copyFrom(aThat->mFirmwareSettings);
12098	mRecordingSettings->i_copyFrom(aThat->mRecordingSettings);
12099	mTrustedPlatformModule->i_copyFrom(aThat->mTrustedPlatformModule);
12100	mNvramStore->i_copyFrom(aThat->mNvramStore);
12101	mGraphicsAdapter->i_copyFrom(aThat->mGraphicsAdapter);
12102	mVRDEServer->i_copyFrom(aThat->mVRDEServer);
12103	mAudioSettings->i_copyFrom(aThat->mAudioSettings);
12104	mUSBDeviceFilters->i_copyFrom(aThat->mUSBDeviceFilters);
12105	mBandwidthControl->i_copyFrom(aThat->mBandwidthControl);
12106	mGuestDebugControl->i_copyFrom(aThat->mGuestDebugControl);
12107
12108	/* create private copies of all controllers */
12109	mStorageControllers.backup();
12110	mStorageControllers->clear();
12111	for (StorageControllerList::const_iterator
12112	it = aThat->mStorageControllers->begin();
12113	it != aThat->mStorageControllers->end();
12114	++it)
12115	{
12116	ComObjPtr<StorageController> ctrl;
12117	ctrl.createObject();
12118	ctrl->initCopy(this, *it);
12119	mStorageControllers->push_back(ctrl);
12120	}
12121
12122	/* create private copies of all USB controllers */
12123	mUSBControllers.backup();
12124	mUSBControllers->clear();
12125	for (USBControllerList::const_iterator
12126	it = aThat->mUSBControllers->begin();
12127	it != aThat->mUSBControllers->end();
12128	++it)
12129	{
12130	ComObjPtr<USBController> ctrl;
12131	ctrl.createObject();
12132	ctrl->initCopy(this, *it);
12133	mUSBControllers->push_back(ctrl);
12134	}
12135
12136	mNetworkAdapters.resize(aThat->mNetworkAdapters.size());
12137	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12138	{
12139	if (mNetworkAdapters[slot].isNotNull())
12140	mNetworkAdapters[slot]->i_copyFrom(aThat->mNetworkAdapters[slot]);
12141	else
12142	{
12143	unconst(mNetworkAdapters[slot]).createObject();
12144	mNetworkAdapters[slot]->initCopy(this, aThat->mNetworkAdapters[slot]);
12145	}
12146	}
12147	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
12148	mSerialPorts[slot]->i_copyFrom(aThat->mSerialPorts[slot]);
12149	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
12150	mParallelPorts[slot]->i_copyFrom(aThat->mParallelPorts[slot]);
12151	}
12152
12153	/**
12154	* Returns whether the given storage controller is hotplug capable.
12155	*
12156	* @returns true if the controller supports hotplugging
12157	* false otherwise.
12158	* @param enmCtrlType The controller type to check for.
12159	*/
12160	bool Machine::i_isControllerHotplugCapable(StorageControllerType_T enmCtrlType)
12161	{
12162	BOOL aHotplugCapable = FALSE;
12163	HRESULT hrc = mPlatformProperties->GetStorageControllerHotplugCapable(enmCtrlType, &aHotplugCapable);
12164	AssertComRC(hrc);
12165
12166	return RT_BOOL(aHotplugCapable);
12167	}
12168
12169	#ifdef VBOX_WITH_RESOURCE_USAGE_API
12170
12171	void Machine::i_getDiskList(MediaList &list)
12172	{
12173	for (MediumAttachmentList::const_iterator
12174	it = mMediumAttachments->begin();
12175	it != mMediumAttachments->end();
12176	++it)
12177	{
12178	MediumAttachment pAttach = it;
12179	/* just in case */
12180	AssertContinue(pAttach);
12181
12182	AutoCaller localAutoCallerA(pAttach);
12183	if (FAILED(localAutoCallerA.hrc())) continue;
12184
12185	AutoReadLock local_alockA(pAttach COMMA_LOCKVAL_SRC_POS);
12186
12187	if (pAttach->i_getType() == DeviceType_HardDisk)
12188	list.push_back(pAttach->i_getMedium());
12189	}
12190	}
12191
12192	void Machine::i_registerMetrics(PerformanceCollector aCollector, Machine aMachine, RTPROCESS pid)
12193	{
12194	AssertReturnVoid(isWriteLockOnCurrentThread());
12195	AssertPtrReturnVoid(aCollector);
12196
12197	pm::CollectorHAL *hal = aCollector->getHAL();
12198	/* Create sub metrics */
12199	pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
12200	"Percentage of processor time spent in user mode by the VM process.");
12201	pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
12202	"Percentage of processor time spent in kernel mode by the VM process.");
12203	pm::SubMetric *ramUsageUsed = new pm::SubMetric("RAM/Usage/Used",
12204	"Size of resident portion of VM process in memory.");
12205	pm::SubMetric *diskUsageUsed = new pm::SubMetric("Disk/Usage/Used",
12206	"Actual size of all VM disks combined.");
12207	pm::SubMetric *machineNetRx = new pm::SubMetric("Net/Rate/Rx",
12208	"Network receive rate.");
12209	pm::SubMetric *machineNetTx = new pm::SubMetric("Net/Rate/Tx",
12210	"Network transmit rate.");
12211	/* Create and register base metrics */
12212	pm::BaseMetric *cpuLoad = new pm::MachineCpuLoadRaw(hal, aMachine, pid,
12213	cpuLoadUser, cpuLoadKernel);
12214	aCollector->registerBaseMetric(cpuLoad);
12215	pm::BaseMetric *ramUsage = new pm::MachineRamUsage(hal, aMachine, pid,
12216	ramUsageUsed);
12217	aCollector->registerBaseMetric(ramUsage);
12218	MediaList disks;
12219	i_getDiskList(disks);
12220	pm::BaseMetric *diskUsage = new pm::MachineDiskUsage(hal, aMachine, disks,
12221	diskUsageUsed);
12222	aCollector->registerBaseMetric(diskUsage);
12223
12224	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
12225	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
12226	new pm::AggregateAvg()));
12227	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
12228	new pm::AggregateMin()));
12229	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
12230	new pm::AggregateMax()));
12231	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
12232	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
12233	new pm::AggregateAvg()));
12234	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
12235	new pm::AggregateMin()));
12236	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
12237	new pm::AggregateMax()));
12238
12239	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
12240	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
12241	new pm::AggregateAvg()));
12242	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
12243	new pm::AggregateMin()));
12244	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
12245	new pm::AggregateMax()));
12246
12247	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed, 0));
12248	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
12249	new pm::AggregateAvg()));
12250	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
12251	new pm::AggregateMin()));
12252	aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
12253	new pm::AggregateMax()));
12254
12255
12256	/* Guest metrics collector */
12257	mCollectorGuest = new pm::CollectorGuest(aMachine, pid);
12258	aCollector->registerGuest(mCollectorGuest);
12259	Log7Func(("{%p}: mCollectorGuest=%p\n", this, mCollectorGuest));
12260
12261	/* Create sub metrics */
12262	pm::SubMetric *guestLoadUser = new pm::SubMetric("Guest/CPU/Load/User",
12263	"Percentage of processor time spent in user mode as seen by the guest.");
12264	pm::SubMetric *guestLoadKernel = new pm::SubMetric("Guest/CPU/Load/Kernel",
12265	"Percentage of processor time spent in kernel mode as seen by the guest.");
12266	pm::SubMetric *guestLoadIdle = new pm::SubMetric("Guest/CPU/Load/Idle",
12267	"Percentage of processor time spent idling as seen by the guest.");
12268
12269	/* The total amount of physical ram is fixed now, but we'll support dynamic guest ram configurations in the future. */
12270	pm::SubMetric *guestMemTotal = new pm::SubMetric("Guest/RAM/Usage/Total", "Total amount of physical guest RAM.");
12271	pm::SubMetric *guestMemFree = new pm::SubMetric("Guest/RAM/Usage/Free", "Free amount of physical guest RAM.");
12272	pm::SubMetric *guestMemBalloon = new pm::SubMetric("Guest/RAM/Usage/Balloon", "Amount of ballooned physical guest RAM.");
12273	pm::SubMetric *guestMemShared = new pm::SubMetric("Guest/RAM/Usage/Shared", "Amount of shared physical guest RAM.");
12274	pm::SubMetric *guestMemCache = new pm::SubMetric(
12275	"Guest/RAM/Usage/Cache", "Total amount of guest (disk) cache memory.");
12276
12277	pm::SubMetric *guestPagedTotal = new pm::SubMetric(
12278	"Guest/Pagefile/Usage/Total", "Total amount of space in the page file.");
12279
12280	/* Create and register base metrics */
12281	pm::BaseMetric *machineNetRate = new pm::MachineNetRate(mCollectorGuest, aMachine,
12282	machineNetRx, machineNetTx);
12283	aCollector->registerBaseMetric(machineNetRate);
12284
12285	pm::BaseMetric *guestCpuLoad = new pm::GuestCpuLoad(mCollectorGuest, aMachine,
12286	guestLoadUser, guestLoadKernel, guestLoadIdle);
12287	aCollector->registerBaseMetric(guestCpuLoad);
12288
12289	pm::BaseMetric *guestCpuMem = new pm::GuestRamUsage(mCollectorGuest, aMachine,
12290	guestMemTotal, guestMemFree,
12291	guestMemBalloon, guestMemShared,
12292	guestMemCache, guestPagedTotal);
12293	aCollector->registerBaseMetric(guestCpuMem);
12294
12295	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, 0));
12296	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateAvg()));
12297	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateMin()));
12298	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateMax()));
12299
12300	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, 0));
12301	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateAvg()));
12302	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateMin()));
12303	aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateMax()));
12304
12305	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, 0));
12306	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateAvg()));
12307	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMin()));
12308	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMax()));
12309
12310	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, 0));
12311	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateAvg()));
12312	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMin()));
12313	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMax()));
12314
12315	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, 0));
12316	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateAvg()));
12317	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMin()));
12318	aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMax()));
12319
12320	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, 0));
12321	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateAvg()));
12322	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMin()));
12323	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMax()));
12324
12325	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, 0));
12326	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateAvg()));
12327	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMin()));
12328	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMax()));
12329
12330	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, 0));
12331	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateAvg()));
12332	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMin()));
12333	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMax()));
12334
12335	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, 0));
12336	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateAvg()));
12337	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMin()));
12338	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMax()));
12339
12340	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, 0));
12341	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateAvg()));
12342	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMin()));
12343	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMax()));
12344
12345	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, 0));
12346	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateAvg()));
12347	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMin()));
12348	aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMax()));
12349	}
12350
12351	void Machine::i_unregisterMetrics(PerformanceCollector aCollector, Machine aMachine)
12352	{
12353	AssertReturnVoid(isWriteLockOnCurrentThread());
12354
12355	if (aCollector)
12356	{
12357	aCollector->unregisterMetricsFor(aMachine);
12358	aCollector->unregisterBaseMetricsFor(aMachine);
12359	}
12360	}
12361
12362	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
12363
12364	/**
12365	* Updates the machine's platform properties based on the current platform architecture.
12366	*
12367	* @note Called internally when committing, rolling back or loading settings.
12368	*/
12369	void Machine::i_platformPropertiesUpdate()
12370	{
12371	if (mPlatform)
12372	{
12373	/* Update architecture for platform properties. */
12374	PlatformArchitecture_T platformArchitecture;
12375	HRESULT hrc = mPlatform->getArchitecture(&platformArchitecture);
12376	ComAssertComRC(hrc);
12377	hrc = mPlatformProperties->i_setArchitecture(platformArchitecture);
12378	ComAssertComRC(hrc);
12379	}
12380	}
12381
12382
12383	////////////////////////////////////////////////////////////////////////////////
12384
12385	DEFINE_EMPTY_CTOR_DTOR(SessionMachine)
12386
12387	HRESULT SessionMachine::FinalConstruct()
12388	{
12389	LogFlowThisFunc(("\n"));
12390
12391	mClientToken = NULL;
12392
12393	return BaseFinalConstruct();
12394	}
12395
12396	void SessionMachine::FinalRelease()
12397	{
12398	LogFlowThisFunc(("\n"));
12399
12400	Assert(!mClientToken);
12401	/* paranoia, should not hang around any more */
12402	if (mClientToken)
12403	{
12404	delete mClientToken;
12405	mClientToken = NULL;
12406	}
12407
12408	uninit(Uninit::Unexpected);
12409
12410	BaseFinalRelease();
12411	}
12412
12413	/**
12414	* @note Must be called only by Machine::LockMachine() from its own write lock.
12415	*/
12416	HRESULT SessionMachine::init(Machine *aMachine)
12417	{
12418	LogFlowThisFuncEnter();
12419	LogFlowThisFunc(("mName={%s}\n", aMachine->mUserData->s.strName.c_str()));
12420
12421	AssertReturn(aMachine, E_INVALIDARG);
12422
12423	AssertReturn(aMachine->lockHandle()->isWriteLockOnCurrentThread(), E_FAIL);
12424
12425	/* Enclose the state transition NotReady->InInit->Ready */
12426	AutoInitSpan autoInitSpan(this);
12427	AssertReturn(autoInitSpan.isOk(), E_FAIL);
12428
12429	HRESULT hrc = S_OK;
12430
12431	RT_ZERO(mAuthLibCtx);
12432
12433	/* create the machine client token */
12434	try
12435	{
12436	mClientToken = new ClientToken(aMachine, this);
12437	if (!mClientToken->isReady())
12438	{
12439	delete mClientToken;
12440	mClientToken = NULL;
12441	hrc = E_FAIL;
12442	}
12443	}
12444	catch (std::bad_alloc &)
12445	{
12446	hrc = E_OUTOFMEMORY;
12447	}
12448	if (FAILED(hrc))
12449	return hrc;
12450
12451	/* memorize the peer Machine */
12452	unconst(mPeer) = aMachine;
12453	/* share the parent pointer */
12454	unconst(mParent) = aMachine->mParent;
12455
12456	/* take the pointers to data to share */
12457	mData.share(aMachine->mData);
12458	mSSData.share(aMachine->mSSData);
12459
12460	mUserData.share(aMachine->mUserData);
12461	mHWData.share(aMachine->mHWData);
12462	mMediumAttachments.share(aMachine->mMediumAttachments);
12463
12464	mStorageControllers.allocate();
12465	for (StorageControllerList::const_iterator
12466	it = aMachine->mStorageControllers->begin();
12467	it != aMachine->mStorageControllers->end();
12468	++it)
12469	{
12470	ComObjPtr<StorageController> ctl;
12471	ctl.createObject();
12472	ctl->init(this, *it);
12473	mStorageControllers->push_back(ctl);
12474	}
12475
12476	mUSBControllers.allocate();
12477	for (USBControllerList::const_iterator
12478	it = aMachine->mUSBControllers->begin();
12479	it != aMachine->mUSBControllers->end();
12480	++it)
12481	{
12482	ComObjPtr<USBController> ctl;
12483	ctl.createObject();
12484	ctl->init(this, *it);
12485	mUSBControllers->push_back(ctl);
12486	}
12487
12488	unconst(mPlatformProperties).createObject();
12489	mPlatformProperties->init(mParent);
12490	unconst(mPlatform).createObject();
12491	mPlatform->init(this, aMachine->mPlatform);
12492
12493	i_platformPropertiesUpdate();
12494
12495	unconst(mFirmwareSettings).createObject();
12496	mFirmwareSettings->init(this, aMachine->mFirmwareSettings);
12497
12498	unconst(mRecordingSettings).createObject();
12499	mRecordingSettings->init(this, aMachine->mRecordingSettings);
12500
12501	unconst(mTrustedPlatformModule).createObject();
12502	mTrustedPlatformModule->init(this, aMachine->mTrustedPlatformModule);
12503
12504	unconst(mNvramStore).createObject();
12505	mNvramStore->init(this, aMachine->mNvramStore);
12506
12507	/* create another GraphicsAdapter object that will be mutable */
12508	unconst(mGraphicsAdapter).createObject();
12509	mGraphicsAdapter->init(this, aMachine->mGraphicsAdapter);
12510	/* create another VRDEServer object that will be mutable */
12511	unconst(mVRDEServer).createObject();
12512	mVRDEServer->init(this, aMachine->mVRDEServer);
12513	/* create another audio settings object that will be mutable */
12514	unconst(mAudioSettings).createObject();
12515	mAudioSettings->init(this, aMachine->mAudioSettings);
12516	/* create a list of serial ports that will be mutable */
12517	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
12518	{
12519	unconst(mSerialPorts[slot]).createObject();
12520	mSerialPorts[slot]->init(this, aMachine->mSerialPorts[slot]);
12521	}
12522	/* create a list of parallel ports that will be mutable */
12523	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
12524	{
12525	unconst(mParallelPorts[slot]).createObject();
12526	mParallelPorts[slot]->init(this, aMachine->mParallelPorts[slot]);
12527	}
12528
12529	/* create another USB device filters object that will be mutable */
12530	unconst(mUSBDeviceFilters).createObject();
12531	mUSBDeviceFilters->init(this, aMachine->mUSBDeviceFilters);
12532
12533	/* create a list of network adapters that will be mutable */
12534	mNetworkAdapters.resize(aMachine->mNetworkAdapters.size());
12535	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12536	{
12537	unconst(mNetworkAdapters[slot]).createObject();
12538	mNetworkAdapters[slot]->init(this, aMachine->mNetworkAdapters[slot]);
12539	}
12540
12541	/* create another bandwidth control object that will be mutable */
12542	unconst(mBandwidthControl).createObject();
12543	mBandwidthControl->init(this, aMachine->mBandwidthControl);
12544
12545	unconst(mGuestDebugControl).createObject();
12546	mGuestDebugControl->init(this, aMachine->mGuestDebugControl);
12547
12548	/* default is to delete saved state on Saved -> PoweredOff transition */
12549	mRemoveSavedState = true;
12550
12551	/* Confirm a successful initialization when it's the case */
12552	autoInitSpan.setSucceeded();
12553
12554	miNATNetworksStarted = 0;
12555
12556	LogFlowThisFuncLeave();
12557	return hrc;
12558	}
12559
12560	/**
12561	* Uninitializes this session object. If the reason is other than
12562	* Uninit::Unexpected, then this method MUST be called from #i_checkForDeath()
12563	* or the client watcher code.
12564	*
12565	* @param aReason uninitialization reason
12566	*
12567	* @note Locks mParent + this object for writing.
12568	*/
12569	void SessionMachine::uninit(Uninit::Reason aReason)
12570	{
12571	LogFlowThisFuncEnter();
12572	LogFlowThisFunc(("reason=%d\n", aReason));
12573
12574	/*
12575	* Strongly reference ourselves to prevent this object deletion after
12576	* mData->mSession.mMachine.setNull() below (which can release the last
12577	* reference and call the destructor). Important: this must be done before
12578	* accessing any members (and before AutoUninitSpan that does it as well).
12579	* This self reference will be released as the very last step on return.
12580	*/
12581	ComObjPtr<SessionMachine> selfRef;
12582	if (aReason != Uninit::Unexpected)
12583	selfRef = this;
12584
12585	/* Enclose the state transition Ready->InUninit->NotReady */
12586	AutoUninitSpan autoUninitSpan(this);
12587	if (autoUninitSpan.uninitDone())
12588	{
12589	LogFlowThisFunc(("Already uninitialized\n"));
12590	LogFlowThisFuncLeave();
12591	return;
12592	}
12593
12594	if (autoUninitSpan.initFailed())
12595	{
12596	/* We've been called by init() because it's failed. It's not really
12597	* necessary (nor it's safe) to perform the regular uninit sequence
12598	* below, the following is enough.
12599	*/
12600	LogFlowThisFunc(("Initialization failed.\n"));
12601	/* destroy the machine client token */
12602	if (mClientToken)
12603	{
12604	delete mClientToken;
12605	mClientToken = NULL;
12606	}
12607	uninitDataAndChildObjects();
12608	mData.free();
12609	unconst(mParent) = NULL;
12610	unconst(mPeer) = NULL;
12611	LogFlowThisFuncLeave();
12612	return;
12613	}
12614
12615	MachineState_T lastState;
12616	{
12617	AutoReadLock tempLock(this COMMA_LOCKVAL_SRC_POS);
12618	lastState = mData->mMachineState;
12619	}
12620	NOREF(lastState);
12621
12622	#ifdef VBOX_WITH_USB
12623	// release all captured USB devices, but do this before requesting the locks below
12624	if (aReason == Uninit::Abnormal && Global::IsOnline(lastState))
12625	{
12626	/* Console::captureUSBDevices() is called in the VM process only after
12627	* setting the machine state to Starting or Restoring.
12628	* Console::detachAllUSBDevices() will be called upon successful
12629	* termination. So, we need to release USB devices only if there was
12630	* an abnormal termination of a running VM.
12631	*
12632	* This is identical to SessionMachine::DetachAllUSBDevices except
12633	* for the aAbnormal argument. */
12634	HRESULT hrc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
12635	AssertComRC(hrc);
12636	NOREF(hrc);
12637
12638	USBProxyService *service = mParent->i_host()->i_usbProxyService();
12639	if (service)
12640	service->detachAllDevicesFromVM(this, true /* aDone /, true / aAbnormal */);
12641	}
12642	#endif /* VBOX_WITH_USB */
12643
12644	// we need to lock this object in uninit() because the lock is shared
12645	// with mPeer (as well as data we modify below). mParent lock is needed
12646	// by several calls to it.
12647	AutoMultiWriteLock2 multilock(mParent, this COMMA_LOCKVAL_SRC_POS);
12648
12649	#ifdef VBOX_WITH_RESOURCE_USAGE_API
12650	/*
12651	* It is safe to call Machine::i_unregisterMetrics() here because
12652	* PerformanceCollector::samplerCallback no longer accesses guest methods
12653	* holding the lock.
12654	*/
12655	i_unregisterMetrics(mParent->i_performanceCollector(), mPeer);
12656	/* The guest must be unregistered after its metrics (@bugref{5949}). */
12657	Log7Func(("{%p}: mCollectorGuest=%p\n", this, mCollectorGuest));
12658	if (mCollectorGuest)
12659	{
12660	mParent->i_performanceCollector()->unregisterGuest(mCollectorGuest);
12661	// delete mCollectorGuest; => CollectorGuestManager::destroyUnregistered()
12662	mCollectorGuest = NULL;
12663	}
12664	#endif
12665
12666	if (aReason == Uninit::Abnormal)
12667	{
12668	Log1WarningThisFunc(("ABNORMAL client termination! (wasBusy=%d)\n", Global::IsOnlineOrTransient(lastState)));
12669
12670	/*
12671	* Move the VM to the 'Aborted' machine state unless we are restoring a
12672	* VM that was in the 'Saved' machine state. In that case, if the VM
12673	* fails before reaching either the 'Restoring' machine state or the
12674	* 'Running' machine state then we set the machine state to
12675	* 'AbortedSaved' in order to preserve the saved state file so that the
12676	* VM can be restored in the future.
12677	*/
12678	if (mData->mMachineState == MachineState_Saved \|\| mData->mMachineState == MachineState_Restoring)
12679	i_setMachineState(MachineState_AbortedSaved);
12680	else if (mData->mMachineState != MachineState_Aborted && mData->mMachineState != MachineState_AbortedSaved)
12681	i_setMachineState(MachineState_Aborted);
12682	}
12683
12684	// any machine settings modified?
12685	if (mData->flModifications)
12686	{
12687	Log1WarningThisFunc(("Discarding unsaved settings changes!\n"));
12688	i_rollback(false /* aNotify */);
12689	}
12690
12691	mData->mSession.mPID = NIL_RTPROCESS;
12692
12693	if (aReason == Uninit::Unexpected)
12694	{
12695	/* Uninitialization didn't come from #i_checkForDeath(), so tell the
12696	* client watcher thread to update the set of machines that have open
12697	* sessions. */
12698	mParent->i_updateClientWatcher();
12699	}
12700
12701	/* uninitialize all remote controls */
12702	if (mData->mSession.mRemoteControls.size())
12703	{
12704	LogFlowThisFunc(("Closing remote sessions (%d):\n",
12705	mData->mSession.mRemoteControls.size()));
12706
12707	/* Always restart a the beginning, since the iterator is invalidated
12708	* by using erase(). */
12709	for (Data::Session::RemoteControlList::iterator
12710	it = mData->mSession.mRemoteControls.begin();
12711	it != mData->mSession.mRemoteControls.end();
12712	it = mData->mSession.mRemoteControls.begin())
12713	{
12714	ComPtr<IInternalSessionControl> pControl = *it;
12715	mData->mSession.mRemoteControls.erase(it);
12716	multilock.release();
12717	LogFlowThisFunc((" Calling remoteControl->Uninitialize()...\n"));
12718	HRESULT hrc = pControl->Uninitialize();
12719	LogFlowThisFunc((" remoteControl->Uninitialize() returned %08X\n", hrc));
12720	if (FAILED(hrc))
12721	Log1WarningThisFunc(("Forgot to close the remote session?\n"));
12722	multilock.acquire();
12723	}
12724	mData->mSession.mRemoteControls.clear();
12725	}
12726
12727	/* Remove all references to the NAT network service. The service will stop
12728	* if all references (also from other VMs) are removed. */
12729	for (; miNATNetworksStarted > 0; miNATNetworksStarted--)
12730	{
12731	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12732	{
12733	BOOL enabled;
12734	HRESULT hrc = mNetworkAdapters[slot]->COMGETTER(Enabled)(&enabled);
12735	if ( FAILED(hrc)
12736	\|\| !enabled)
12737	continue;
12738
12739	NetworkAttachmentType_T type;
12740	hrc = mNetworkAdapters[slot]->COMGETTER(AttachmentType)(&type);
12741	if ( SUCCEEDED(hrc)
12742	&& type == NetworkAttachmentType_NATNetwork)
12743	{
12744	Bstr name;
12745	hrc = mNetworkAdapters[slot]->COMGETTER(NATNetwork)(name.asOutParam());
12746	if (SUCCEEDED(hrc))
12747	{
12748	multilock.release();
12749	Utf8Str strName(name);
12750	LogRel(("VM '%s' stops using NAT network '%s'\n",
12751	mUserData->s.strName.c_str(), strName.c_str()));
12752	mParent->i_natNetworkRefDec(strName);
12753	multilock.acquire();
12754	}
12755	}
12756	}
12757	}
12758
12759	/*
12760	* An expected uninitialization can come only from #i_checkForDeath().
12761	* Otherwise it means that something's gone really wrong (for example,
12762	* the Session implementation has released the VirtualBox reference
12763	* before it triggered #OnSessionEnd(), or before releasing IPC semaphore,
12764	* etc). However, it's also possible, that the client releases the IPC
12765	* semaphore correctly (i.e. before it releases the VirtualBox reference),
12766	* but the VirtualBox release event comes first to the server process.
12767	* This case is practically possible, so we should not assert on an
12768	* unexpected uninit, just log a warning.
12769	*/
12770
12771	if (aReason == Uninit::Unexpected)
12772	Log1WarningThisFunc(("Unexpected SessionMachine uninitialization!\n"));
12773
12774	if (aReason != Uninit::Normal)
12775	{
12776	mData->mSession.mDirectControl.setNull();
12777	}
12778	else
12779	{
12780	/* this must be null here (see #OnSessionEnd()) */
12781	Assert(mData->mSession.mDirectControl.isNull());
12782	Assert(mData->mSession.mState == SessionState_Unlocking);
12783	Assert(!mData->mSession.mProgress.isNull());
12784	}
12785	if (mData->mSession.mProgress)
12786	{
12787	if (aReason == Uninit::Normal)
12788	mData->mSession.mProgress->i_notifyComplete(S_OK);
12789	else
12790	mData->mSession.mProgress->i_notifyComplete(E_FAIL,
12791	COM_IIDOF(ISession),
12792	getComponentName(),
12793	tr("The VM session was aborted"));
12794	mData->mSession.mProgress.setNull();
12795	}
12796
12797	if (mConsoleTaskData.mProgress)
12798	{
12799	Assert(aReason == Uninit::Abnormal);
12800	mConsoleTaskData.mProgress->i_notifyComplete(E_FAIL,
12801	COM_IIDOF(ISession),
12802	getComponentName(),
12803	tr("The VM session was aborted"));
12804	mConsoleTaskData.mProgress.setNull();
12805	}
12806
12807	/* remove the association between the peer machine and this session machine */
12808	Assert( (SessionMachine*)mData->mSession.mMachine == this
12809	\|\| aReason == Uninit::Unexpected);
12810
12811	/* reset the rest of session data */
12812	mData->mSession.mLockType = LockType_Null;
12813	mData->mSession.mMachine.setNull();
12814	mData->mSession.mState = SessionState_Unlocked;
12815	mData->mSession.mName.setNull();
12816
12817	/* destroy the machine client token before leaving the exclusive lock */
12818	if (mClientToken)
12819	{
12820	delete mClientToken;
12821	mClientToken = NULL;
12822	}
12823
12824	/* fire an event */
12825	mParent->i_onSessionStateChanged(mData->mUuid, SessionState_Unlocked);
12826
12827	uninitDataAndChildObjects();
12828
12829	/* free the essential data structure last */
12830	mData.free();
12831
12832	/* release the exclusive lock before setting the below two to NULL */
12833	multilock.release();
12834
12835	unconst(mParent) = NULL;
12836	unconst(mPeer) = NULL;
12837
12838	AuthLibUnload(&mAuthLibCtx);
12839
12840	LogFlowThisFuncLeave();
12841	}
12842
12843	// util::Lockable interface
12844	////////////////////////////////////////////////////////////////////////////////
12845
12846	/**
12847	* Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
12848	* with the primary Machine instance (mPeer).
12849	*/
12850	RWLockHandle *SessionMachine::lockHandle() const
12851	{
12852	AssertReturn(mPeer != NULL, NULL);
12853	return mPeer->lockHandle();
12854	}
12855
12856	// IInternalMachineControl methods
12857	////////////////////////////////////////////////////////////////////////////////
12858
12859	/**
12860	* Passes collected guest statistics to performance collector object
12861	*/
12862	HRESULT SessionMachine::reportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
12863	ULONG aCpuKernel, ULONG aCpuIdle,
12864	ULONG aMemTotal, ULONG aMemFree,
12865	ULONG aMemBalloon, ULONG aMemShared,
12866	ULONG aMemCache, ULONG aPageTotal,
12867	ULONG aAllocVMM, ULONG aFreeVMM,
12868	ULONG aBalloonedVMM, ULONG aSharedVMM,
12869	ULONG aVmNetRx, ULONG aVmNetTx)
12870	{
12871	#ifdef VBOX_WITH_RESOURCE_USAGE_API
12872	if (mCollectorGuest)
12873	mCollectorGuest->updateStats(aValidStats, aCpuUser, aCpuKernel, aCpuIdle,
12874	aMemTotal, aMemFree, aMemBalloon, aMemShared,
12875	aMemCache, aPageTotal, aAllocVMM, aFreeVMM,
12876	aBalloonedVMM, aSharedVMM, aVmNetRx, aVmNetTx);
12877
12878	return S_OK;
12879	#else
12880	NOREF(aValidStats);
12881	NOREF(aCpuUser);
12882	NOREF(aCpuKernel);
12883	NOREF(aCpuIdle);
12884	NOREF(aMemTotal);
12885	NOREF(aMemFree);
12886	NOREF(aMemBalloon);
12887	NOREF(aMemShared);
12888	NOREF(aMemCache);
12889	NOREF(aPageTotal);
12890	NOREF(aAllocVMM);
12891	NOREF(aFreeVMM);
12892	NOREF(aBalloonedVMM);
12893	NOREF(aSharedVMM);
12894	NOREF(aVmNetRx);
12895	NOREF(aVmNetTx);
12896	return E_NOTIMPL;
12897	#endif
12898	}
12899
12900	////////////////////////////////////////////////////////////////////////////////
12901	//
12902	// SessionMachine task records
12903	//
12904	////////////////////////////////////////////////////////////////////////////////
12905
12906	/**
12907	* Task record for saving the machine state.
12908	*/
12909	class SessionMachine::SaveStateTask
12910	: public Machine::Task
12911	{
12912	public:
12913	SaveStateTask(SessionMachine *m,
12914	Progress *p,
12915	const Utf8Str &t,
12916	Reason_T enmReason,
12917	const Utf8Str &strStateFilePath)
12918	: Task(m, p, t),
12919	m_enmReason(enmReason),
12920	m_strStateFilePath(strStateFilePath)
12921	{}
12922
12923	private:
12924	void handler()
12925	{
12926	((SessionMachine )(Machine )m_pMachine)->i_saveStateHandler(*this);
12927	}
12928
12929	Reason_T m_enmReason;
12930	Utf8Str m_strStateFilePath;
12931
12932	friend class SessionMachine;
12933	};
12934
12935	/**
12936	* Task thread implementation for SessionMachine::SaveState(), called from
12937	* SessionMachine::taskHandler().
12938	*
12939	* @note Locks this object for writing.
12940	*
12941	* @param task
12942	*/
12943	void SessionMachine::i_saveStateHandler(SaveStateTask &task)
12944	{
12945	LogFlowThisFuncEnter();
12946
12947	AutoCaller autoCaller(this);
12948	LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
12949	if (FAILED(autoCaller.hrc()))
12950	{
12951	/* we might have been uninitialized because the session was accidentally
12952	* closed by the client, so don't assert */
12953	HRESULT hrc = setError(E_FAIL, tr("The session has been accidentally closed"));
12954	task.m_pProgress->i_notifyComplete(hrc);
12955	LogFlowThisFuncLeave();
12956	return;
12957	}
12958
12959	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12960
12961	HRESULT hrc = S_OK;
12962
12963	try
12964	{
12965	ComPtr<IInternalSessionControl> directControl;
12966	if (mData->mSession.mLockType == LockType_VM)
12967	directControl = mData->mSession.mDirectControl;
12968	if (directControl.isNull())
12969	throw setError(VBOX_E_INVALID_VM_STATE,
12970	tr("Trying to save state without a running VM"));
12971	alock.release();
12972	BOOL fSuspendedBySave;
12973	hrc = directControl->SaveStateWithReason(task.m_enmReason, task.m_pProgress, NULL, Bstr(task.m_strStateFilePath).raw(), task.m_machineStateBackup != MachineState_Paused, &fSuspendedBySave);
12974	Assert(!fSuspendedBySave);
12975	alock.acquire();
12976
12977	AssertStmt( (SUCCEEDED(hrc) && mData->mMachineState == MachineState_Saved)
12978	\|\| (FAILED(hrc) && mData->mMachineState == MachineState_Saving),
12979	throw E_FAIL);
12980
12981	if (SUCCEEDED(hrc))
12982	{
12983	mSSData->strStateFilePath = task.m_strStateFilePath;
12984
12985	/* save all VM settings */
12986	hrc = i_saveSettings(NULL, alock);
12987	// no need to check whether VirtualBox.xml needs saving also since
12988	// we can't have a name change pending at this point
12989	}
12990	else
12991	{
12992	// On failure, set the state to the state we had at the beginning.
12993	i_setMachineState(task.m_machineStateBackup);
12994	i_updateMachineStateOnClient();
12995
12996	// Delete the saved state file (might have been already created).
12997	// No need to check whether this is shared with a snapshot here
12998	// because we certainly created a fresh saved state file here.
12999	i_deleteFile(task.m_strStateFilePath, true /* fIgnoreFailures */);
13000	}
13001	}
13002	catch (HRESULT hrcXcpt)
13003	{
13004	hrc = hrcXcpt;
13005	}
13006
13007	task.m_pProgress->i_notifyComplete(hrc);
13008
13009	LogFlowThisFuncLeave();
13010	}
13011
13012	/**
13013	* @note Locks this object for writing.
13014	*/
13015	HRESULT SessionMachine::saveState(ComPtr<IProgress> &aProgress)
13016	{
13017	return i_saveStateWithReason(Reason_Unspecified, aProgress);
13018	}
13019
13020	HRESULT SessionMachine::i_saveStateWithReason(Reason_T aReason, ComPtr<IProgress> &aProgress)
13021	{
13022	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13023
13024	HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
13025	if (FAILED(hrc)) return hrc;
13026
13027	if ( mData->mMachineState != MachineState_Running
13028	&& mData->mMachineState != MachineState_Paused
13029	)
13030	return setError(VBOX_E_INVALID_VM_STATE,
13031	tr("Cannot save the execution state as the machine is not running or paused (machine state: %s)"),
13032	Global::stringifyMachineState(mData->mMachineState));
13033
13034	ComObjPtr<Progress> pProgress;
13035	pProgress.createObject();
13036	hrc = pProgress->init(i_getVirtualBox(),
13037	static_cast<IMachine >(this) / aInitiator */,
13038	tr("Saving the execution state of the virtual machine"),
13039	FALSE /* aCancelable */);
13040	if (FAILED(hrc))
13041	return hrc;
13042
13043	Utf8Str strStateFilePath;
13044	i_composeSavedStateFilename(strStateFilePath);
13045
13046	/* create and start the task on a separate thread (note that it will not
13047	* start working until we release alock) */
13048	SaveStateTask *pTask = new SaveStateTask(this, pProgress, "SaveState", aReason, strStateFilePath);
13049	hrc = pTask->createThread();
13050	if (FAILED(hrc))
13051	return hrc;
13052
13053	/* set the state to Saving (expected by Session::SaveStateWithReason()) */
13054	i_setMachineState(MachineState_Saving);
13055	i_updateMachineStateOnClient();
13056
13057	pProgress.queryInterfaceTo(aProgress.asOutParam());
13058
13059	return S_OK;
13060	}
13061
13062	/**
13063	* @note Locks this object for writing.
13064	*/
13065	HRESULT SessionMachine::adoptSavedState(const com::Utf8Str &aSavedStateFile)
13066	{
13067	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13068
13069	HRESULT hrc = i_checkStateDependency(MutableStateDep);
13070	if (FAILED(hrc)) return hrc;
13071
13072	if ( mData->mMachineState != MachineState_PoweredOff
13073	&& mData->mMachineState != MachineState_Teleported
13074	&& mData->mMachineState != MachineState_Aborted
13075	)
13076	return setError(VBOX_E_INVALID_VM_STATE,
13077	tr("Cannot adopt the saved machine state as the machine is not in Powered Off, Teleported or Aborted state (machine state: %s)"),
13078	Global::stringifyMachineState(mData->mMachineState));
13079
13080	com::Utf8Str stateFilePathFull;
13081	int vrc = i_calculateFullPath(aSavedStateFile, stateFilePathFull);
13082	if (RT_FAILURE(vrc))
13083	return setErrorBoth(VBOX_E_FILE_ERROR, vrc,
13084	tr("Invalid saved state file path '%s' (%Rrc)"),
13085	aSavedStateFile.c_str(),
13086	vrc);
13087
13088	mSSData->strStateFilePath = stateFilePathFull;
13089
13090	/* The below i_setMachineState() will detect the state transition and will
13091	* update the settings file */
13092
13093	return i_setMachineState(MachineState_Saved);
13094	}
13095
13096	/**
13097	* @note Locks this object for writing.
13098	*/
13099	HRESULT SessionMachine::discardSavedState(BOOL aFRemoveFile)
13100	{
13101	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13102
13103	HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
13104	if (FAILED(hrc)) return hrc;
13105
13106	if ( mData->mMachineState != MachineState_Saved
13107	&& mData->mMachineState != MachineState_AbortedSaved)
13108	return setError(VBOX_E_INVALID_VM_STATE,
13109	tr("Cannot discard the saved state as the machine is not in the Saved or Aborted-Saved state (machine state: %s)"),
13110	Global::stringifyMachineState(mData->mMachineState));
13111
13112	mRemoveSavedState = RT_BOOL(aFRemoveFile);
13113
13114	/*
13115	* Saved -> PoweredOff transition will be detected in the SessionMachine
13116	* and properly handled.
13117	*/
13118	hrc = i_setMachineState(MachineState_PoweredOff);
13119	return hrc;
13120	}
13121
13122
13123	/**
13124	* @note Locks the same as #i_setMachineState() does.
13125	*/
13126	HRESULT SessionMachine::updateState(MachineState_T aState)
13127	{
13128	return i_setMachineState(aState);
13129	}
13130
13131	/**
13132	* @note Locks this object for writing.
13133	*/
13134	HRESULT SessionMachine::beginPowerUp(const ComPtr<IProgress> &aProgress)
13135	{
13136	IProgress *pProgress(aProgress);
13137
13138	LogFlowThisFunc(("aProgress=%p\n", pProgress));
13139
13140	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13141
13142	if (mData->mSession.mState != SessionState_Locked)
13143	return VBOX_E_INVALID_OBJECT_STATE;
13144
13145	if (!mData->mSession.mProgress.isNull())
13146	mData->mSession.mProgress->setOtherProgressObject(pProgress);
13147
13148	/* If we didn't reference the NAT network service yet, add a reference to
13149	* force a start */
13150	if (miNATNetworksStarted < 1)
13151	{
13152	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
13153	{
13154	BOOL enabled;
13155	HRESULT hrc = mNetworkAdapters[slot]->COMGETTER(Enabled)(&enabled);
13156	if ( FAILED(hrc)
13157	\|\| !enabled)
13158	continue;
13159
13160	NetworkAttachmentType_T type;
13161	hrc = mNetworkAdapters[slot]->COMGETTER(AttachmentType)(&type);
13162	if ( SUCCEEDED(hrc)
13163	&& type == NetworkAttachmentType_NATNetwork)
13164	{
13165	Bstr name;
13166	hrc = mNetworkAdapters[slot]->COMGETTER(NATNetwork)(name.asOutParam());
13167	if (SUCCEEDED(hrc))
13168	{
13169	Utf8Str strName(name);
13170	LogRel(("VM '%s' starts using NAT network '%s'\n",
13171	mUserData->s.strName.c_str(), strName.c_str()));
13172	mPeer->lockHandle()->unlockWrite();
13173	mParent->i_natNetworkRefInc(strName);
13174	#ifdef RT_LOCK_STRICT
13175	mPeer->lockHandle()->lockWrite(RT_SRC_POS);
13176	#else
13177	mPeer->lockHandle()->lockWrite();
13178	#endif
13179	}
13180	}
13181	}
13182	miNATNetworksStarted++;
13183	}
13184
13185	LogFlowThisFunc(("returns S_OK.\n"));
13186	return S_OK;
13187	}
13188
13189	/**
13190	* @note Locks this object for writing.
13191	*/
13192	HRESULT SessionMachine::endPowerUp(LONG aResult)
13193	{
13194	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13195
13196	if (mData->mSession.mState != SessionState_Locked)
13197	return VBOX_E_INVALID_OBJECT_STATE;
13198
13199	/* Finalize the LaunchVMProcess progress object. */
13200	if (mData->mSession.mProgress)
13201	{
13202	mData->mSession.mProgress->notifyComplete((HRESULT)aResult);
13203	mData->mSession.mProgress.setNull();
13204	}
13205
13206	if (SUCCEEDED((HRESULT)aResult))
13207	{
13208	#ifdef VBOX_WITH_RESOURCE_USAGE_API
13209	/* The VM has been powered up successfully, so it makes sense
13210	* now to offer the performance metrics for a running machine
13211	* object. Doing it earlier wouldn't be safe. */
13212	i_registerMetrics(mParent->i_performanceCollector(), mPeer,
13213	mData->mSession.mPID);
13214	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
13215	}
13216
13217	return S_OK;
13218	}
13219
13220	/**
13221	* @note Locks this object for writing.
13222	*/
13223	HRESULT SessionMachine::beginPoweringDown(ComPtr<IProgress> &aProgress)
13224	{
13225	LogFlowThisFuncEnter();
13226
13227	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13228
13229	AssertReturn(mConsoleTaskData.mLastState == MachineState_Null,
13230	E_FAIL);
13231
13232	/* create a progress object to track operation completion */
13233	ComObjPtr<Progress> pProgress;
13234	pProgress.createObject();
13235	pProgress->init(i_getVirtualBox(),
13236	static_cast<IMachine >(this) / aInitiator */,
13237	tr("Stopping the virtual machine"),
13238	FALSE /* aCancelable */);
13239
13240	/* fill in the console task data */
13241	mConsoleTaskData.mLastState = mData->mMachineState;
13242	mConsoleTaskData.mProgress = pProgress;
13243
13244	/* set the state to Stopping (this is expected by Console::PowerDown()) */
13245	i_setMachineState(MachineState_Stopping);
13246
13247	pProgress.queryInterfaceTo(aProgress.asOutParam());
13248
13249	return S_OK;
13250	}
13251
13252	/**
13253	* @note Locks this object for writing.
13254	*/
13255	HRESULT SessionMachine::endPoweringDown(LONG aResult,
13256	const com::Utf8Str &aErrMsg)
13257	{
13258	HRESULT const hrcResult = (HRESULT)aResult;
13259	LogFlowThisFuncEnter();
13260
13261	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13262
13263	AssertReturn( ( (SUCCEEDED(hrcResult) && mData->mMachineState == MachineState_PoweredOff)
13264	\|\| (FAILED(hrcResult) && mData->mMachineState == MachineState_Stopping))
13265	&& mConsoleTaskData.mLastState != MachineState_Null,
13266	E_FAIL);
13267
13268	/*
13269	* On failure, set the state to the state we had when BeginPoweringDown()
13270	* was called (this is expected by Console::PowerDown() and the associated
13271	* task). On success the VM process already changed the state to
13272	* MachineState_PoweredOff, so no need to do anything.
13273	*/
13274	if (FAILED(hrcResult))
13275	i_setMachineState(mConsoleTaskData.mLastState);
13276
13277	/* notify the progress object about operation completion */
13278	Assert(mConsoleTaskData.mProgress);
13279	if (SUCCEEDED(hrcResult))
13280	mConsoleTaskData.mProgress->i_notifyComplete(S_OK);
13281	else
13282	{
13283	if (aErrMsg.length())
13284	mConsoleTaskData.mProgress->i_notifyComplete(hrcResult,
13285	COM_IIDOF(ISession),
13286	getComponentName(),
13287	aErrMsg.c_str());
13288	else
13289	mConsoleTaskData.mProgress->i_notifyComplete(hrcResult);
13290	}
13291
13292	/* clear out the temporary saved state data */
13293	mConsoleTaskData.mLastState = MachineState_Null;
13294	mConsoleTaskData.mProgress.setNull();
13295
13296	LogFlowThisFuncLeave();
13297	return S_OK;
13298	}
13299
13300
13301	/**
13302	* Goes through the USB filters of the given machine to see if the given
13303	* device matches any filter or not.
13304	*
13305	* @note Locks the same as USBController::hasMatchingFilter() does.
13306	*/
13307	HRESULT SessionMachine::runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
13308	BOOL *aMatched,
13309	ULONG *aMaskedInterfaces)
13310	{
13311	LogFlowThisFunc(("\n"));
13312
13313	#ifdef VBOX_WITH_USB
13314	*aMatched = mUSBDeviceFilters->i_hasMatchingFilter(aDevice, aMaskedInterfaces);
13315	#else
13316	NOREF(aDevice);
13317	NOREF(aMaskedInterfaces);
13318	*aMatched = FALSE;
13319	#endif
13320
13321	return S_OK;
13322	}
13323
13324	/**
13325	* @note Locks the same as Host::captureUSBDevice() does.
13326	*/
13327	HRESULT SessionMachine::captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename)
13328	{
13329	LogFlowThisFunc(("\n"));
13330
13331	#ifdef VBOX_WITH_USB
13332	/* if captureDeviceForVM() fails, it must have set extended error info */
13333	clearError();
13334	MultiResult hrc = mParent->i_host()->i_checkUSBProxyService();
13335	if (FAILED(hrc) \|\| SUCCEEDED_WARNING(hrc))
13336	return hrc;
13337
13338	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13339	AssertReturn(service, E_FAIL);
13340	return service->captureDeviceForVM(this, aId.ref(), aCaptureFilename);
13341	#else
13342	RT_NOREF(aId, aCaptureFilename);
13343	return E_NOTIMPL;
13344	#endif
13345	}
13346
13347	/**
13348	* @note Locks the same as Host::detachUSBDevice() does.
13349	*/
13350	HRESULT SessionMachine::detachUSBDevice(const com::Guid &aId,
13351	BOOL aDone)
13352	{
13353	LogFlowThisFunc(("\n"));
13354
13355	#ifdef VBOX_WITH_USB
13356	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13357	AssertReturn(service, E_FAIL);
13358	return service->detachDeviceFromVM(this, aId.ref(), !!aDone);
13359	#else
13360	NOREF(aId);
13361	NOREF(aDone);
13362	return E_NOTIMPL;
13363	#endif
13364	}
13365
13366	/**
13367	* Inserts all machine filters to the USB proxy service and then calls
13368	* Host::autoCaptureUSBDevices().
13369	*
13370	* Called by Console from the VM process upon VM startup.
13371	*
13372	* @note Locks what called methods lock.
13373	*/
13374	HRESULT SessionMachine::autoCaptureUSBDevices()
13375	{
13376	LogFlowThisFunc(("\n"));
13377
13378	#ifdef VBOX_WITH_USB
13379	HRESULT hrc = mUSBDeviceFilters->i_notifyProxy(true /* aInsertFilters */);
13380	AssertComRC(hrc);
13381	NOREF(hrc);
13382
13383	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13384	AssertReturn(service, E_FAIL);
13385	return service->autoCaptureDevicesForVM(this);
13386	#else
13387	return S_OK;
13388	#endif
13389	}
13390
13391	/**
13392	* Removes all machine filters from the USB proxy service and then calls
13393	* Host::detachAllUSBDevices().
13394	*
13395	* Called by Console from the VM process upon normal VM termination or by
13396	* SessionMachine::uninit() upon abnormal VM termination (from under the
13397	* Machine/SessionMachine lock).
13398	*
13399	* @note Locks what called methods lock.
13400	*/
13401	HRESULT SessionMachine::detachAllUSBDevices(BOOL aDone)
13402	{
13403	LogFlowThisFunc(("\n"));
13404
13405	#ifdef VBOX_WITH_USB
13406	HRESULT hrc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
13407	AssertComRC(hrc);
13408	NOREF(hrc);
13409
13410	USBProxyService *service = mParent->i_host()->i_usbProxyService();
13411	AssertReturn(service, E_FAIL);
13412	return service->detachAllDevicesFromVM(this, !!aDone, false /* aAbnormal */);
13413	#else
13414	NOREF(aDone);
13415	return S_OK;
13416	#endif
13417	}
13418
13419	/**
13420	* @note Locks this object for writing.
13421	*/
13422	HRESULT SessionMachine::onSessionEnd(const ComPtr<ISession> &aSession,
13423	ComPtr<IProgress> &aProgress)
13424	{
13425	LogFlowThisFuncEnter();
13426
13427	LogFlowThisFunc(("callerstate=%d\n", getObjectState().getState()));
13428	/*
13429	* We don't assert below because it might happen that a non-direct session
13430	* informs us it is closed right after we've been uninitialized -- it's ok.
13431	*/
13432
13433	/* get IInternalSessionControl interface */
13434	ComPtr<IInternalSessionControl> control(aSession);
13435
13436	ComAssertRet(!control.isNull(), E_INVALIDARG);
13437
13438	/* Creating a Progress object requires the VirtualBox lock, and
13439	* thus locking it here is required by the lock order rules. */
13440	AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
13441
13442	if (control == mData->mSession.mDirectControl)
13443	{
13444	/* The direct session is being normally closed by the client process
13445	* ----------------------------------------------------------------- */
13446
13447	/* go to the closing state (essential for all open*Session() calls and
13448	* for #i_checkForDeath()) */
13449	Assert(mData->mSession.mState == SessionState_Locked);
13450	mData->mSession.mState = SessionState_Unlocking;
13451
13452	/* set direct control to NULL to release the remote instance */
13453	mData->mSession.mDirectControl.setNull();
13454	LogFlowThisFunc(("Direct control is set to NULL\n"));
13455
13456	if (mData->mSession.mProgress)
13457	{
13458	/* finalize the progress, someone might wait if a frontend
13459	* closes the session before powering on the VM. */
13460	mData->mSession.mProgress->notifyComplete(E_FAIL,
13461	COM_IIDOF(ISession),
13462	getComponentName(),
13463	tr("The VM session was closed before any attempt to power it on"));
13464	mData->mSession.mProgress.setNull();
13465	}
13466
13467	/* Create the progress object the client will use to wait until
13468	* #i_checkForDeath() is called to uninitialize this session object after
13469	* it releases the IPC semaphore.
13470	* Note! Because we're "reusing" mProgress here, this must be a proxy
13471	* object just like for LaunchVMProcess. */
13472	Assert(mData->mSession.mProgress.isNull());
13473	ComObjPtr<ProgressProxy> progress;
13474	progress.createObject();
13475	ComPtr<IUnknown> pPeer(mPeer);
13476	progress->init(mParent, pPeer,
13477	Bstr(tr("Closing session")).raw(),
13478	FALSE /* aCancelable */);
13479	progress.queryInterfaceTo(aProgress.asOutParam());
13480	mData->mSession.mProgress = progress;
13481	}
13482	else
13483	{
13484	/* the remote session is being normally closed */
13485	bool found = false;
13486	for (Data::Session::RemoteControlList::iterator
13487	it = mData->mSession.mRemoteControls.begin();
13488	it != mData->mSession.mRemoteControls.end();
13489	++it)
13490	{
13491	if (control == *it)
13492	{
13493	found = true;
13494	// This MUST be erase(it), not remove(*it) as the latter
13495	// triggers a very nasty use after free due to the place where
13496	// the value "lives".
13497	mData->mSession.mRemoteControls.erase(it);
13498	break;
13499	}
13500	}
13501	ComAssertMsgRet(found, (tr("The session is not found in the session list!")),
13502	E_INVALIDARG);
13503	}
13504
13505	/* signal the client watcher thread, because the client is going away */
13506	mParent->i_updateClientWatcher();
13507
13508	LogFlowThisFuncLeave();
13509	return S_OK;
13510	}
13511
13512	HRESULT SessionMachine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
13513	std::vector<com::Utf8Str> &aValues,
13514	std::vector<LONG64> &aTimestamps,
13515	std::vector<com::Utf8Str> &aFlags)
13516	{
13517	LogFlowThisFunc(("\n"));
13518
13519	#ifdef VBOX_WITH_GUEST_PROPS
13520	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13521
13522	size_t cEntries = mHWData->mGuestProperties.size();
13523	aNames.resize(cEntries);
13524	aValues.resize(cEntries);
13525	aTimestamps.resize(cEntries);
13526	aFlags.resize(cEntries);
13527
13528	size_t i = 0;
13529	for (HWData::GuestPropertyMap::const_iterator
13530	it = mHWData->mGuestProperties.begin();
13531	it != mHWData->mGuestProperties.end();
13532	++it, ++i)
13533	{
13534	aNames[i] = it->first;
13535	int vrc = GuestPropValidateName(aNames[i].c_str(), aNames[i].length() + 1 /* '\0' */);
13536	AssertRCReturn(vrc, setErrorBoth(E_INVALIDARG /* bad choice */, vrc));
13537
13538	aValues[i] = it->second.strValue;
13539	vrc = GuestPropValidateValue(aValues[i].c_str(), aValues[i].length() + 1 /* '\0' */);
13540	AssertRCReturn(vrc, setErrorBoth(E_INVALIDARG /* bad choice */, vrc));
13541
13542	aTimestamps[i] = it->second.mTimestamp;
13543
13544	/* If it is NULL, keep it NULL. */
13545	if (it->second.mFlags)
13546	{
13547	char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1];
13548	GuestPropWriteFlags(it->second.mFlags, szFlags);
13549	aFlags[i] = szFlags;
13550	}
13551	else
13552	aFlags[i] = "";
13553	}
13554	return S_OK;
13555	#else
13556	ReturnComNotImplemented();
13557	#endif
13558	}
13559
13560	HRESULT SessionMachine::pushGuestProperty(const com::Utf8Str &aName,
13561	const com::Utf8Str &aValue,
13562	LONG64 aTimestamp,
13563	const com::Utf8Str &aFlags,
13564	BOOL fWasDeleted)
13565	{
13566	LogFlowThisFunc(("\n"));
13567
13568	#ifdef VBOX_WITH_GUEST_PROPS
13569	try
13570	{
13571	/*
13572	* Convert input up front.
13573	*/
13574	uint32_t fFlags = GUEST_PROP_F_NILFLAG;
13575	if (aFlags.length())
13576	{
13577	int vrc = GuestPropValidateFlags(aFlags.c_str(), &fFlags);
13578	AssertRCReturn(vrc, E_INVALIDARG);
13579	}
13580
13581	/*
13582	* Now grab the object lock, validate the state and do the update.
13583	*/
13584
13585	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13586
13587	if (!Global::IsOnline(mData->mMachineState))
13588	AssertMsgFailedReturn(("%s\n", ::stringifyMachineState(mData->mMachineState)), VBOX_E_INVALID_VM_STATE);
13589
13590	i_setModified(IsModified_MachineData);
13591	mHWData.backup();
13592
13593	HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.find(aName);
13594	if (it != mHWData->mGuestProperties.end())
13595	{
13596	if (!fWasDeleted)
13597	{
13598	it->second.strValue = aValue;
13599	it->second.mTimestamp = aTimestamp;
13600	it->second.mFlags = fFlags;
13601	}
13602	else
13603	mHWData->mGuestProperties.erase(it);
13604
13605	mData->mGuestPropertiesModified = TRUE;
13606	}
13607	else if (!fWasDeleted)
13608	{
13609	HWData::GuestProperty prop;
13610	prop.strValue = aValue;
13611	prop.mTimestamp = aTimestamp;
13612	prop.mFlags = fFlags;
13613
13614	mHWData->mGuestProperties[aName] = prop;
13615	mData->mGuestPropertiesModified = TRUE;
13616	}
13617
13618	alock.release();
13619
13620	mParent->i_onGuestPropertyChanged(mData->mUuid, aName, aValue, aFlags, fWasDeleted);
13621	}
13622	catch (...)
13623	{
13624	return VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
13625	}
13626	return S_OK;
13627	#else
13628	ReturnComNotImplemented();
13629	#endif
13630	}
13631
13632
13633	HRESULT SessionMachine::lockMedia()
13634	{
13635	AutoMultiWriteLock2 alock(this->lockHandle(),
13636	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
13637
13638	AssertReturn( mData->mMachineState == MachineState_Starting
13639	\|\| mData->mMachineState == MachineState_Restoring
13640	\|\| mData->mMachineState == MachineState_TeleportingIn, E_FAIL);
13641
13642	clearError();
13643	alock.release();
13644	return i_lockMedia();
13645	}
13646
13647	HRESULT SessionMachine::unlockMedia()
13648	{
13649	HRESULT hrc = i_unlockMedia();
13650	return hrc;
13651	}
13652
13653	HRESULT SessionMachine::ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
13654	ComPtr<IMediumAttachment> &aNewAttachment)
13655	{
13656	// request the host lock first, since might be calling Host methods for getting host drives;
13657	// next, protect the media tree all the while we're in here, as well as our member variables
13658	AutoMultiWriteLock3 multiLock(mParent->i_host()->lockHandle(),
13659	this->lockHandle(),
13660	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
13661
13662	IMediumAttachment *iAttach = aAttachment;
13663	ComObjPtr<MediumAttachment> pAttach = static_cast<MediumAttachment *>(iAttach);
13664
13665	Utf8Str ctrlName;
13666	LONG lPort;
13667	LONG lDevice;
13668	bool fTempEject;
13669	{
13670	AutoReadLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13671
13672	/* Need to query the details first, as the IMediumAttachment reference
13673	* might be to the original settings, which we are going to change. */
13674	ctrlName = pAttach->i_getControllerName();
13675	lPort = pAttach->i_getPort();
13676	lDevice = pAttach->i_getDevice();
13677	fTempEject = pAttach->i_getTempEject();
13678	}
13679
13680	if (!fTempEject)
13681	{
13682	/* Remember previously mounted medium. The medium before taking the
13683	* backup is not necessarily the same thing. */
13684	ComObjPtr<Medium> oldmedium;
13685	oldmedium = pAttach->i_getMedium();
13686
13687	i_setModified(IsModified_Storage);
13688	mMediumAttachments.backup();
13689
13690	// The backup operation makes the pAttach reference point to the
13691	// old settings. Re-get the correct reference.
13692	pAttach = i_findAttachment(*mMediumAttachments.data(),
13693	ctrlName,
13694	lPort,
13695	lDevice);
13696
13697	{
13698	AutoCaller autoAttachCaller(this);
13699	if (FAILED(autoAttachCaller.hrc())) return autoAttachCaller.hrc();
13700
13701	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13702	if (!oldmedium.isNull())
13703	oldmedium->i_removeBackReference(mData->mUuid);
13704
13705	pAttach->i_updateMedium(NULL);
13706	pAttach->i_updateEjected();
13707	}
13708
13709	i_setModified(IsModified_Storage);
13710	}
13711	else
13712	{
13713	{
13714	AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13715	pAttach->i_updateEjected();
13716	}
13717	}
13718
13719	pAttach.queryInterfaceTo(aNewAttachment.asOutParam());
13720
13721	return S_OK;
13722	}
13723
13724	HRESULT SessionMachine::authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
13725	com::Utf8Str &aResult)
13726	{
13727	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13728
13729	HRESULT hrc = S_OK;
13730
13731	if (!mAuthLibCtx.hAuthLibrary)
13732	{
13733	/* Load the external authentication library. */
13734	Bstr authLibrary;
13735	mVRDEServer->COMGETTER(AuthLibrary)(authLibrary.asOutParam());
13736
13737	Utf8Str filename = authLibrary;
13738
13739	int vrc = AuthLibLoad(&mAuthLibCtx, filename.c_str());
13740	if (RT_FAILURE(vrc))
13741	hrc = setErrorBoth(E_FAIL, vrc,
13742	tr("Could not load the external authentication library '%s' (%Rrc)"),
13743	filename.c_str(), vrc);
13744	}
13745
13746	/* The auth library might need the machine lock. */
13747	alock.release();
13748
13749	if (FAILED(hrc))
13750	return hrc;
13751
13752	if (aAuthParams[0] == "VRDEAUTH" && aAuthParams.size() == 7)
13753	{
13754	enum VRDEAuthParams
13755	{
13756	parmUuid = 1,
13757	parmGuestJudgement,
13758	parmUser,
13759	parmPassword,
13760	parmDomain,
13761	parmClientId
13762	};
13763
13764	AuthResult result = AuthResultAccessDenied;
13765
13766	Guid uuid(aAuthParams[parmUuid]);
13767	AuthGuestJudgement guestJudgement = (AuthGuestJudgement)aAuthParams[parmGuestJudgement].toUInt32();
13768	uint32_t u32ClientId = aAuthParams[parmClientId].toUInt32();
13769
13770	result = AuthLibAuthenticate(&mAuthLibCtx,
13771	uuid.raw(), guestJudgement,
13772	aAuthParams[parmUser].c_str(),
13773	aAuthParams[parmPassword].c_str(),
13774	aAuthParams[parmDomain].c_str(),
13775	u32ClientId);
13776
13777	/* Hack: aAuthParams[parmPassword] is const but the code believes in writable memory. */
13778	size_t cbPassword = aAuthParams[parmPassword].length();
13779	if (cbPassword)
13780	{
13781	RTMemWipeThoroughly((void )aAuthParams[parmPassword].c_str(), cbPassword, 10 / cPasses */);
13782	memset((void *)aAuthParams[parmPassword].c_str(), 'x', cbPassword);
13783	}
13784
13785	if (result == AuthResultAccessGranted)
13786	aResult = "granted";
13787	else
13788	aResult = "denied";
13789
13790	LogRel(("AUTH: VRDE authentification for user '%s' result '%s'\n",
13791	aAuthParams[parmUser].c_str(), aResult.c_str()));
13792	}
13793	else if (aAuthParams[0] == "VRDEAUTHDISCONNECT" && aAuthParams.size() == 3)
13794	{
13795	enum VRDEAuthDisconnectParams
13796	{
13797	parmUuid = 1,
13798	parmClientId
13799	};
13800
13801	Guid uuid(aAuthParams[parmUuid]);
13802	uint32_t u32ClientId = 0;
13803	AuthLibDisconnect(&mAuthLibCtx, uuid.raw(), u32ClientId);
13804	}
13805	else
13806	{
13807	hrc = E_INVALIDARG;
13808	}
13809
13810	return hrc;
13811	}
13812
13813	// public methods only for internal purposes
13814	/////////////////////////////////////////////////////////////////////////////
13815
13816	#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
13817	/**
13818	* Called from the client watcher thread to check for expected or unexpected
13819	* death of the client process that has a direct session to this machine.
13820	*
13821	* On Win32 and on OS/2, this method is called only when we've got the
13822	* mutex (i.e. the client has either died or terminated normally) so it always
13823	* returns @c true (the client is terminated, the session machine is
13824	* uninitialized).
13825	*
13826	* On other platforms, the method returns @c true if the client process has
13827	* terminated normally or abnormally and the session machine was uninitialized,
13828	* and @c false if the client process is still alive.
13829	*
13830	* @note Locks this object for writing.
13831	*/
13832	bool SessionMachine::i_checkForDeath()
13833	{
13834	Uninit::Reason reason;
13835	bool terminated = false;
13836
13837	/* Enclose autoCaller with a block because calling uninit() from under it
13838	* will deadlock. */
13839	{
13840	AutoCaller autoCaller(this);
13841	if (!autoCaller.isOk())
13842	{
13843	/* return true if not ready, to cause the client watcher to exclude
13844	* the corresponding session from watching */
13845	LogFlowThisFunc(("Already uninitialized!\n"));
13846	return true;
13847	}
13848
13849	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13850
13851	/* Determine the reason of death: if the session state is Closing here,
13852	* everything is fine. Otherwise it means that the client did not call
13853	* OnSessionEnd() before it released the IPC semaphore. This may happen
13854	* either because the client process has abnormally terminated, or
13855	* because it simply forgot to call ISession::Close() before exiting. We
13856	* threat the latter also as an abnormal termination (see
13857	* Session::uninit() for details). */
13858	reason = mData->mSession.mState == SessionState_Unlocking ?
13859	Uninit::Normal :
13860	Uninit::Abnormal;
13861
13862	if (mClientToken)
13863	terminated = mClientToken->release();
13864	} /* AutoCaller block */
13865
13866	if (terminated)
13867	uninit(reason);
13868
13869	return terminated;
13870	}
13871
13872	void SessionMachine::i_getTokenId(Utf8Str &strTokenId)
13873	{
13874	LogFlowThisFunc(("\n"));
13875
13876	strTokenId.setNull();
13877
13878	AutoCaller autoCaller(this);
13879	AssertComRCReturnVoid(autoCaller.hrc());
13880
13881	Assert(mClientToken);
13882	if (mClientToken)
13883	mClientToken->getId(strTokenId);
13884	}
13885	#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
13886	IToken *SessionMachine::i_getToken()
13887	{
13888	LogFlowThisFunc(("\n"));
13889
13890	AutoCaller autoCaller(this);
13891	AssertComRCReturn(autoCaller.hrc(), NULL);
13892
13893	Assert(mClientToken);
13894	if (mClientToken)
13895	return mClientToken->getToken();
13896	else
13897	return NULL;
13898	}
13899	#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
13900
13901	Machine::ClientToken *SessionMachine::i_getClientToken()
13902	{
13903	LogFlowThisFunc(("\n"));
13904
13905	AutoCaller autoCaller(this);
13906	AssertComRCReturn(autoCaller.hrc(), NULL);
13907
13908	return mClientToken;
13909	}
13910
13911
13912	/**
13913	* @note Locks this object for reading.
13914	*/
13915	HRESULT SessionMachine::i_onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter)
13916	{
13917	LogFlowThisFunc(("\n"));
13918
13919	AutoCaller autoCaller(this);
13920	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
13921
13922	ComPtr<IInternalSessionControl> directControl;
13923	{
13924	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13925	if (mData->mSession.mLockType == LockType_VM)
13926	directControl = mData->mSession.mDirectControl;
13927	}
13928
13929	/* ignore notifications sent after #OnSessionEnd() is called */
13930	if (!directControl)
13931	return S_OK;
13932
13933	return directControl->OnNetworkAdapterChange(networkAdapter, changeAdapter);
13934	}
13935
13936	/**
13937	* @note Locks this object for reading.
13938	*/
13939	HRESULT SessionMachine::i_onNATRedirectRuleChanged(ULONG ulSlot, BOOL aNatRuleRemove, const Utf8Str &aRuleName,
13940	NATProtocol_T aProto, const Utf8Str &aHostIp, LONG aHostPort,
13941	const Utf8Str &aGuestIp, LONG aGuestPort)
13942	{
13943	LogFlowThisFunc(("\n"));
13944
13945	AutoCaller autoCaller(this);
13946	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
13947
13948	ComPtr<IInternalSessionControl> directControl;
13949	{
13950	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13951	if (mData->mSession.mLockType == LockType_VM)
13952	directControl = mData->mSession.mDirectControl;
13953	}
13954
13955	/* ignore notifications sent after #OnSessionEnd() is called */
13956	if (!directControl)
13957	return S_OK;
13958	/*
13959	* instead acting like callback we ask IVirtualBox deliver corresponding event
13960	*/
13961
13962	mParent->i_onNatRedirectChanged(i_getId(), ulSlot, RT_BOOL(aNatRuleRemove), aRuleName, aProto, aHostIp,
13963	(uint16_t)aHostPort, aGuestIp, (uint16_t)aGuestPort);
13964	return S_OK;
13965	}
13966
13967	/**
13968	* @note Locks this object for reading.
13969	*/
13970	HRESULT SessionMachine::i_onAudioAdapterChange(IAudioAdapter *audioAdapter)
13971	{
13972	LogFlowThisFunc(("\n"));
13973
13974	AutoCaller autoCaller(this);
13975	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
13976
13977	ComPtr<IInternalSessionControl> directControl;
13978	{
13979	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13980	if (mData->mSession.mLockType == LockType_VM)
13981	directControl = mData->mSession.mDirectControl;
13982	}
13983
13984	/* ignore notifications sent after #OnSessionEnd() is called */
13985	if (!directControl)
13986	return S_OK;
13987
13988	return directControl->OnAudioAdapterChange(audioAdapter);
13989	}
13990
13991	/**
13992	* @note Locks this object for reading.
13993	*/
13994	HRESULT SessionMachine::i_onHostAudioDeviceChange(IHostAudioDevice aDevice, BOOL aNew, AudioDeviceState_T aState, IVirtualBoxErrorInfo aErrInfo)
13995	{
13996	LogFlowThisFunc(("\n"));
13997
13998	AutoCaller autoCaller(this);
13999	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14000
14001	ComPtr<IInternalSessionControl> directControl;
14002	{
14003	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14004	if (mData->mSession.mLockType == LockType_VM)
14005	directControl = mData->mSession.mDirectControl;
14006	}
14007
14008	/* ignore notifications sent after #OnSessionEnd() is called */
14009	if (!directControl)
14010	return S_OK;
14011
14012	return directControl->OnHostAudioDeviceChange(aDevice, aNew, aState, aErrInfo);
14013	}
14014
14015	/**
14016	* @note Locks this object for reading.
14017	*/
14018	HRESULT SessionMachine::i_onSerialPortChange(ISerialPort *serialPort)
14019	{
14020	LogFlowThisFunc(("\n"));
14021
14022	AutoCaller autoCaller(this);
14023	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14024
14025	ComPtr<IInternalSessionControl> directControl;
14026	{
14027	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14028	if (mData->mSession.mLockType == LockType_VM)
14029	directControl = mData->mSession.mDirectControl;
14030	}
14031
14032	/* ignore notifications sent after #OnSessionEnd() is called */
14033	if (!directControl)
14034	return S_OK;
14035
14036	return directControl->OnSerialPortChange(serialPort);
14037	}
14038
14039	/**
14040	* @note Locks this object for reading.
14041	*/
14042	HRESULT SessionMachine::i_onParallelPortChange(IParallelPort *parallelPort)
14043	{
14044	LogFlowThisFunc(("\n"));
14045
14046	AutoCaller autoCaller(this);
14047	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14048
14049	ComPtr<IInternalSessionControl> directControl;
14050	{
14051	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14052	if (mData->mSession.mLockType == LockType_VM)
14053	directControl = mData->mSession.mDirectControl;
14054	}
14055
14056	/* ignore notifications sent after #OnSessionEnd() is called */
14057	if (!directControl)
14058	return S_OK;
14059
14060	return directControl->OnParallelPortChange(parallelPort);
14061	}
14062
14063	/**
14064	* @note Locks this object for reading.
14065	*/
14066	HRESULT SessionMachine::i_onStorageControllerChange(const Guid &aMachineId, const Utf8Str &aControllerName)
14067	{
14068	LogFlowThisFunc(("\n"));
14069
14070	AutoCaller autoCaller(this);
14071	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14072
14073	ComPtr<IInternalSessionControl> directControl;
14074	{
14075	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14076	if (mData->mSession.mLockType == LockType_VM)
14077	directControl = mData->mSession.mDirectControl;
14078	}
14079
14080	mParent->i_onStorageControllerChanged(aMachineId, aControllerName);
14081
14082	/* ignore notifications sent after #OnSessionEnd() is called */
14083	if (!directControl)
14084	return S_OK;
14085
14086	return directControl->OnStorageControllerChange(Bstr(aMachineId.toString()).raw(), Bstr(aControllerName).raw());
14087	}
14088
14089	/**
14090	* @note Locks this object for reading.
14091	*/
14092	HRESULT SessionMachine::i_onMediumChange(IMediumAttachment *aAttachment, BOOL aForce)
14093	{
14094	LogFlowThisFunc(("\n"));
14095
14096	AutoCaller autoCaller(this);
14097	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14098
14099	ComPtr<IInternalSessionControl> directControl;
14100	{
14101	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14102	if (mData->mSession.mLockType == LockType_VM)
14103	directControl = mData->mSession.mDirectControl;
14104	}
14105
14106	mParent->i_onMediumChanged(aAttachment);
14107
14108	/* ignore notifications sent after #OnSessionEnd() is called */
14109	if (!directControl)
14110	return S_OK;
14111
14112	return directControl->OnMediumChange(aAttachment, aForce);
14113	}
14114
14115	HRESULT SessionMachine::i_onVMProcessPriorityChange(VMProcPriority_T aPriority)
14116	{
14117	LogFlowThisFunc(("\n"));
14118
14119	AutoCaller autoCaller(this);
14120	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14121
14122	ComPtr<IInternalSessionControl> directControl;
14123	{
14124	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14125	if (mData->mSession.mLockType == LockType_VM)
14126	directControl = mData->mSession.mDirectControl;
14127	}
14128
14129	/* ignore notifications sent after #OnSessionEnd() is called */
14130	if (!directControl)
14131	return S_OK;
14132
14133	return directControl->OnVMProcessPriorityChange(aPriority);
14134	}
14135
14136	/**
14137	* @note Locks this object for reading.
14138	*/
14139	HRESULT SessionMachine::i_onCPUChange(ULONG aCPU, BOOL aRemove)
14140	{
14141	LogFlowThisFunc(("\n"));
14142
14143	AutoCaller autoCaller(this);
14144	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14145
14146	ComPtr<IInternalSessionControl> directControl;
14147	{
14148	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14149	if (mData->mSession.mLockType == LockType_VM)
14150	directControl = mData->mSession.mDirectControl;
14151	}
14152
14153	/* ignore notifications sent after #OnSessionEnd() is called */
14154	if (!directControl)
14155	return S_OK;
14156
14157	return directControl->OnCPUChange(aCPU, aRemove);
14158	}
14159
14160	HRESULT SessionMachine::i_onCPUExecutionCapChange(ULONG aExecutionCap)
14161	{
14162	LogFlowThisFunc(("\n"));
14163
14164	AutoCaller autoCaller(this);
14165	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14166
14167	ComPtr<IInternalSessionControl> directControl;
14168	{
14169	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14170	if (mData->mSession.mLockType == LockType_VM)
14171	directControl = mData->mSession.mDirectControl;
14172	}
14173
14174	/* ignore notifications sent after #OnSessionEnd() is called */
14175	if (!directControl)
14176	return S_OK;
14177
14178	return directControl->OnCPUExecutionCapChange(aExecutionCap);
14179	}
14180
14181	/**
14182	* @note Locks this object for reading.
14183	*/
14184	HRESULT SessionMachine::i_onVRDEServerChange(BOOL aRestart)
14185	{
14186	LogFlowThisFunc(("\n"));
14187
14188	AutoCaller autoCaller(this);
14189	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14190
14191	ComPtr<IInternalSessionControl> directControl;
14192	{
14193	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14194	if (mData->mSession.mLockType == LockType_VM)
14195	directControl = mData->mSession.mDirectControl;
14196	}
14197
14198	/* ignore notifications sent after #OnSessionEnd() is called */
14199	if (!directControl)
14200	return S_OK;
14201
14202	return directControl->OnVRDEServerChange(aRestart);
14203	}
14204
14205	/**
14206	* @note Locks this object for reading.
14207	*/
14208	HRESULT SessionMachine::i_onRecordingChange(BOOL aEnable)
14209	{
14210	LogFlowThisFunc(("\n"));
14211
14212	AutoCaller autoCaller(this);
14213	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14214
14215	ComPtr<IInternalSessionControl> directControl;
14216	{
14217	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14218	if (mData->mSession.mLockType == LockType_VM)
14219	directControl = mData->mSession.mDirectControl;
14220	}
14221
14222	/* ignore notifications sent after #OnSessionEnd() is called */
14223	if (!directControl)
14224	return S_OK;
14225
14226	return directControl->OnRecordingChange(aEnable);
14227	}
14228
14229	/**
14230	* @note Locks this object for reading.
14231	*/
14232	HRESULT SessionMachine::i_onUSBControllerChange()
14233	{
14234	LogFlowThisFunc(("\n"));
14235
14236	AutoCaller autoCaller(this);
14237	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14238
14239	ComPtr<IInternalSessionControl> directControl;
14240	{
14241	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14242	if (mData->mSession.mLockType == LockType_VM)
14243	directControl = mData->mSession.mDirectControl;
14244	}
14245
14246	/* ignore notifications sent after #OnSessionEnd() is called */
14247	if (!directControl)
14248	return S_OK;
14249
14250	return directControl->OnUSBControllerChange();
14251	}
14252
14253	/**
14254	* @note Locks this object for reading.
14255	*/
14256	HRESULT SessionMachine::i_onSharedFolderChange()
14257	{
14258	LogFlowThisFunc(("\n"));
14259
14260	AutoCaller autoCaller(this);
14261	AssertComRCReturnRC(autoCaller.hrc());
14262
14263	ComPtr<IInternalSessionControl> directControl;
14264	{
14265	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14266	if (mData->mSession.mLockType == LockType_VM)
14267	directControl = mData->mSession.mDirectControl;
14268	}
14269
14270	/* ignore notifications sent after #OnSessionEnd() is called */
14271	if (!directControl)
14272	return S_OK;
14273
14274	return directControl->OnSharedFolderChange(FALSE /* aGlobal */);
14275	}
14276
14277	/**
14278	* @note Locks this object for reading.
14279	*/
14280	HRESULT SessionMachine::i_onClipboardModeChange(ClipboardMode_T aClipboardMode)
14281	{
14282	LogFlowThisFunc(("\n"));
14283
14284	AutoCaller autoCaller(this);
14285	AssertComRCReturnRC(autoCaller.hrc());
14286
14287	ComPtr<IInternalSessionControl> directControl;
14288	{
14289	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14290	if (mData->mSession.mLockType == LockType_VM)
14291	directControl = mData->mSession.mDirectControl;
14292	}
14293
14294	/* ignore notifications sent after #OnSessionEnd() is called */
14295	if (!directControl)
14296	return S_OK;
14297
14298	return directControl->OnClipboardModeChange(aClipboardMode);
14299	}
14300
14301	/**
14302	* @note Locks this object for reading.
14303	*/
14304	HRESULT SessionMachine::i_onClipboardFileTransferModeChange(BOOL aEnable)
14305	{
14306	LogFlowThisFunc(("\n"));
14307
14308	AutoCaller autoCaller(this);
14309	AssertComRCReturnRC(autoCaller.hrc());
14310
14311	ComPtr<IInternalSessionControl> directControl;
14312	{
14313	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14314	if (mData->mSession.mLockType == LockType_VM)
14315	directControl = mData->mSession.mDirectControl;
14316	}
14317
14318	/* ignore notifications sent after #OnSessionEnd() is called */
14319	if (!directControl)
14320	return S_OK;
14321
14322	return directControl->OnClipboardFileTransferModeChange(aEnable);
14323	}
14324
14325	/**
14326	* @note Locks this object for reading.
14327	*/
14328	HRESULT SessionMachine::i_onDnDModeChange(DnDMode_T aDnDMode)
14329	{
14330	LogFlowThisFunc(("\n"));
14331
14332	AutoCaller autoCaller(this);
14333	AssertComRCReturnRC(autoCaller.hrc());
14334
14335	ComPtr<IInternalSessionControl> directControl;
14336	{
14337	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14338	if (mData->mSession.mLockType == LockType_VM)
14339	directControl = mData->mSession.mDirectControl;
14340	}
14341
14342	/* ignore notifications sent after #OnSessionEnd() is called */
14343	if (!directControl)
14344	return S_OK;
14345
14346	return directControl->OnDnDModeChange(aDnDMode);
14347	}
14348
14349	/**
14350	* @note Locks this object for reading.
14351	*/
14352	HRESULT SessionMachine::i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
14353	{
14354	LogFlowThisFunc(("\n"));
14355
14356	AutoCaller autoCaller(this);
14357	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14358
14359	ComPtr<IInternalSessionControl> directControl;
14360	{
14361	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14362	if (mData->mSession.mLockType == LockType_VM)
14363	directControl = mData->mSession.mDirectControl;
14364	}
14365
14366	/* ignore notifications sent after #OnSessionEnd() is called */
14367	if (!directControl)
14368	return S_OK;
14369
14370	return directControl->OnBandwidthGroupChange(aBandwidthGroup);
14371	}
14372
14373	/**
14374	* @note Locks this object for reading.
14375	*/
14376	HRESULT SessionMachine::i_onStorageDeviceChange(IMediumAttachment *aAttachment, BOOL aRemove, BOOL aSilent)
14377	{
14378	LogFlowThisFunc(("\n"));
14379
14380	AutoCaller autoCaller(this);
14381	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14382
14383	ComPtr<IInternalSessionControl> directControl;
14384	{
14385	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14386	if (mData->mSession.mLockType == LockType_VM)
14387	directControl = mData->mSession.mDirectControl;
14388	}
14389
14390	/* ignore notifications sent after #OnSessionEnd() is called */
14391	if (!directControl)
14392	return S_OK;
14393
14394	return directControl->OnStorageDeviceChange(aAttachment, aRemove, aSilent);
14395	}
14396
14397	/**
14398	* @note Locks this object for reading.
14399	*/
14400	HRESULT SessionMachine::i_onGuestDebugControlChange(IGuestDebugControl *guestDebugControl)
14401	{
14402	LogFlowThisFunc(("\n"));
14403
14404	AutoCaller autoCaller(this);
14405	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14406
14407	ComPtr<IInternalSessionControl> directControl;
14408	{
14409	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14410	if (mData->mSession.mLockType == LockType_VM)
14411	directControl = mData->mSession.mDirectControl;
14412	}
14413
14414	/* ignore notifications sent after #OnSessionEnd() is called */
14415	if (!directControl)
14416	return S_OK;
14417
14418	return directControl->OnGuestDebugControlChange(guestDebugControl);
14419	}
14420
14421	/**
14422	* Returns @c true if this machine's USB controller reports it has a matching
14423	* filter for the given USB device and @c false otherwise.
14424	*
14425	* @note locks this object for reading.
14426	*/
14427	bool SessionMachine::i_hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
14428	{
14429	AutoCaller autoCaller(this);
14430	/* silently return if not ready -- this method may be called after the
14431	* direct machine session has been called */
14432	if (!autoCaller.isOk())
14433	return false;
14434
14435	#ifdef VBOX_WITH_USB
14436	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14437
14438	switch (mData->mMachineState)
14439	{
14440	case MachineState_Starting:
14441	case MachineState_Restoring:
14442	case MachineState_TeleportingIn:
14443	case MachineState_Paused:
14444	case MachineState_Running:
14445	/** @todo Live Migration: snapshoting & teleporting. Need to fend things of
14446	* elsewhere... */
14447	alock.release();
14448	return mUSBDeviceFilters->i_hasMatchingFilter(aDevice, aMaskedIfs);
14449	default: break;
14450	}
14451	#else
14452	NOREF(aDevice);
14453	NOREF(aMaskedIfs);
14454	#endif
14455	return false;
14456	}
14457
14458	/**
14459	* @note The calls shall hold no locks. Will temporarily lock this object for reading.
14460	*/
14461	HRESULT SessionMachine::i_onUSBDeviceAttach(IUSBDevice *aDevice,
14462	IVirtualBoxErrorInfo *aError,
14463	ULONG aMaskedIfs,
14464	const com::Utf8Str &aCaptureFilename)
14465	{
14466	LogFlowThisFunc(("\n"));
14467
14468	AutoCaller autoCaller(this);
14469
14470	/* This notification may happen after the machine object has been
14471	* uninitialized (the session was closed), so don't assert. */
14472	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
14473
14474	ComPtr<IInternalSessionControl> directControl;
14475	{
14476	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14477	if (mData->mSession.mLockType == LockType_VM)
14478	directControl = mData->mSession.mDirectControl;
14479	}
14480
14481	/* fail on notifications sent after #OnSessionEnd() is called, it is
14482	* expected by the caller */
14483	if (!directControl)
14484	return E_FAIL;
14485
14486	/* No locks should be held at this point. */
14487	AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
14488	AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
14489
14490	return directControl->OnUSBDeviceAttach(aDevice, aError, aMaskedIfs, Bstr(aCaptureFilename).raw());
14491	}
14492
14493	/**
14494	* @note The calls shall hold no locks. Will temporarily lock this object for reading.
14495	*/
14496	HRESULT SessionMachine::i_onUSBDeviceDetach(IN_BSTR aId,
14497	IVirtualBoxErrorInfo *aError)
14498	{
14499	LogFlowThisFunc(("\n"));
14500
14501	AutoCaller autoCaller(this);
14502
14503	/* This notification may happen after the machine object has been
14504	* uninitialized (the session was closed), so don't assert. */
14505	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
14506
14507	ComPtr<IInternalSessionControl> directControl;
14508	{
14509	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14510	if (mData->mSession.mLockType == LockType_VM)
14511	directControl = mData->mSession.mDirectControl;
14512	}
14513
14514	/* fail on notifications sent after #OnSessionEnd() is called, it is
14515	* expected by the caller */
14516	if (!directControl)
14517	return E_FAIL;
14518
14519	/* No locks should be held at this point. */
14520	AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
14521	AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
14522
14523	return directControl->OnUSBDeviceDetach(aId, aError);
14524	}
14525
14526	// protected methods
14527	/////////////////////////////////////////////////////////////////////////////
14528
14529	/**
14530	* Deletes the given file if it is no longer in use by either the current machine state
14531	* (if the machine is "saved") or any of the machine's snapshots.
14532	*
14533	* Note: This checks mSSData->strStateFilePath, which is shared by the Machine and SessionMachine
14534	* but is different for each SnapshotMachine. When calling this, the order of calling this
14535	* function on the one hand and changing that variable OR the snapshots tree on the other hand
14536	* is therefore critical. I know, it's all rather messy.
14537	*
14538	* @param strStateFile
14539	* @param pSnapshotToIgnore Passed to Snapshot::sharesSavedStateFile(); this snapshot is ignored in
14540	* the test for whether the saved state file is in use.
14541	*/
14542	void SessionMachine::i_releaseSavedStateFile(const Utf8Str &strStateFile,
14543	Snapshot *pSnapshotToIgnore)
14544	{
14545	// it is safe to delete this saved state file if it is not currently in use by the machine ...
14546	if ( (strStateFile.isNotEmpty())
14547	&& (strStateFile != mSSData->strStateFilePath) // session machine's saved state
14548	)
14549	// ... and it must also not be shared with other snapshots
14550	if ( !mData->mFirstSnapshot
14551	\|\| !mData->mFirstSnapshot->i_sharesSavedStateFile(strStateFile, pSnapshotToIgnore)
14552	// this checks the SnapshotMachine's state file paths
14553	)
14554	i_deleteFile(strStateFile, true /* fIgnoreFailures */);
14555	}
14556
14557	/**
14558	* Locks the attached media.
14559	*
14560	* All attached hard disks are locked for writing and DVD/floppy are locked for
14561	* reading. Parents of attached hard disks (if any) are locked for reading.
14562	*
14563	* This method also performs accessibility check of all media it locks: if some
14564	* media is inaccessible, the method will return a failure and a bunch of
14565	* extended error info objects per each inaccessible medium.
14566	*
14567	* Note that this method is atomic: if it returns a success, all media are
14568	* locked as described above; on failure no media is locked at all (all
14569	* succeeded individual locks will be undone).
14570	*
14571	* The caller is responsible for doing the necessary state sanity checks.
14572	*
14573	* The locks made by this method must be undone by calling #unlockMedia() when
14574	* no more needed.
14575	*/
14576	HRESULT SessionMachine::i_lockMedia()
14577	{
14578	AutoCaller autoCaller(this);
14579	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14580
14581	AutoMultiWriteLock2 alock(this->lockHandle(),
14582	&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
14583
14584	/* bail out if trying to lock things with already set up locking */
14585	AssertReturn(mData->mSession.mLockedMedia.IsEmpty(), E_FAIL);
14586
14587	MultiResult hrcMult(S_OK);
14588
14589	/* Collect locking information for all medium objects attached to the VM. */
14590	for (MediumAttachmentList::const_iterator
14591	it = mMediumAttachments->begin();
14592	it != mMediumAttachments->end();
14593	++it)
14594	{
14595	MediumAttachment pAtt = it;
14596	DeviceType_T devType = pAtt->i_getType();
14597	Medium *pMedium = pAtt->i_getMedium();
14598
14599	MediumLockList *pMediumLockList(new MediumLockList());
14600	// There can be attachments without a medium (floppy/dvd), and thus
14601	// it's impossible to create a medium lock list. It still makes sense
14602	// to have the empty medium lock list in the map in case a medium is
14603	// attached later.
14604	if (pMedium != NULL)
14605	{
14606	MediumType_T mediumType = pMedium->i_getType();
14607	bool fIsReadOnlyLock = mediumType == MediumType_Readonly
14608	\|\| mediumType == MediumType_Shareable;
14609	bool fIsVitalImage = (devType == DeviceType_HardDisk);
14610
14611	alock.release();
14612	hrcMult = pMedium->i_createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
14613	!fIsReadOnlyLock ? pMedium : NULL /* pToLockWrite */,
14614	false /* fMediumLockWriteAll */,
14615	NULL,
14616	*pMediumLockList);
14617	alock.acquire();
14618	if (FAILED(hrcMult))
14619	{
14620	delete pMediumLockList;
14621	mData->mSession.mLockedMedia.Clear();
14622	break;
14623	}
14624	}
14625
14626	HRESULT hrc = mData->mSession.mLockedMedia.Insert(pAtt, pMediumLockList);
14627	if (FAILED(hrc))
14628	{
14629	mData->mSession.mLockedMedia.Clear();
14630	hrcMult = setError(hrc, tr("Collecting locking information for all attached media failed"));
14631	break;
14632	}
14633	}
14634
14635	if (SUCCEEDED(hrcMult))
14636	{
14637	/* Now lock all media. If this fails, nothing is locked. */
14638	alock.release();
14639	HRESULT hrc = mData->mSession.mLockedMedia.Lock();
14640	alock.acquire();
14641	if (FAILED(hrc))
14642	hrcMult = setError(hrc,
14643	tr("Locking of attached media failed. A possible reason is that one of the media is attached to a running VM"));
14644	}
14645
14646	return hrcMult;
14647	}
14648
14649	/**
14650	* Undoes the locks made by by #lockMedia().
14651	*/
14652	HRESULT SessionMachine::i_unlockMedia()
14653	{
14654	AutoCaller autoCaller(this);
14655	AssertComRCReturn(autoCaller.hrc(),autoCaller.hrc());
14656
14657	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
14658
14659	/* we may be holding important error info on the current thread;
14660	* preserve it */
14661	ErrorInfoKeeper eik;
14662
14663	HRESULT hrc = mData->mSession.mLockedMedia.Clear();
14664	AssertComRC(hrc);
14665	return hrc;
14666	}
14667
14668	/**
14669	* Helper to change the machine state (reimplementation).
14670	*
14671	* @note Locks this object for writing.
14672	* @note This method must not call i_saveSettings or SaveSettings, otherwise
14673	* it can cause crashes in random places due to unexpectedly committing
14674	* the current settings. The caller is responsible for that. The call
14675	* to saveStateSettings is fine, because this method does not commit.
14676	*/
14677	HRESULT SessionMachine::i_setMachineState(MachineState_T aMachineState)
14678	{
14679	LogFlowThisFuncEnter();
14680
14681	AutoCaller autoCaller(this);
14682	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14683
14684	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
14685
14686	MachineState_T oldMachineState = mData->mMachineState;
14687
14688	AssertMsgReturn(oldMachineState != aMachineState,
14689	("oldMachineState=%s, aMachineState=%s\n",
14690	::stringifyMachineState(oldMachineState), ::stringifyMachineState(aMachineState)),
14691	E_FAIL);
14692
14693	HRESULT hrc = S_OK;
14694
14695	int stsFlags = 0;
14696	bool deleteSavedState = false;
14697
14698	/* detect some state transitions */
14699
14700	if ( ( ( oldMachineState == MachineState_Saved
14701	\|\| oldMachineState == MachineState_AbortedSaved
14702	)
14703	&& aMachineState == MachineState_Restoring
14704	)
14705	\|\| ( ( oldMachineState == MachineState_PoweredOff
14706	\|\| oldMachineState == MachineState_Teleported
14707	\|\| oldMachineState == MachineState_Aborted
14708	)
14709	&& ( aMachineState == MachineState_TeleportingIn
14710	\|\| aMachineState == MachineState_Starting
14711	)
14712	)
14713	)
14714	{
14715	/* The EMT thread is about to start */
14716
14717	/* Nothing to do here for now... */
14718
14719	/// @todo NEWMEDIA don't let mDVDDrive and other children
14720	/// change anything when in the Starting/Restoring state
14721	}
14722	else if ( ( oldMachineState == MachineState_Running
14723	\|\| oldMachineState == MachineState_Paused
14724	\|\| oldMachineState == MachineState_Teleporting
14725	\|\| oldMachineState == MachineState_OnlineSnapshotting
14726	\|\| oldMachineState == MachineState_LiveSnapshotting
14727	\|\| oldMachineState == MachineState_Stuck
14728	\|\| oldMachineState == MachineState_Starting
14729	\|\| oldMachineState == MachineState_Stopping
14730	\|\| oldMachineState == MachineState_Saving
14731	\|\| oldMachineState == MachineState_Restoring
14732	\|\| oldMachineState == MachineState_TeleportingPausedVM
14733	\|\| oldMachineState == MachineState_TeleportingIn
14734	)
14735	&& ( aMachineState == MachineState_PoweredOff
14736	\|\| aMachineState == MachineState_Saved
14737	\|\| aMachineState == MachineState_Teleported
14738	\|\| aMachineState == MachineState_Aborted
14739	\|\| aMachineState == MachineState_AbortedSaved
14740	)
14741	)
14742	{
14743	/* The EMT thread has just stopped, unlock attached media. Note that as
14744	* opposed to locking that is done from Console, we do unlocking here
14745	* because the VM process may have aborted before having a chance to
14746	* properly unlock all media it locked. */
14747
14748	unlockMedia();
14749	}
14750
14751	if (oldMachineState == MachineState_Restoring)
14752	{
14753	if (aMachineState != MachineState_Saved && aMachineState != MachineState_AbortedSaved)
14754	{
14755	/*
14756	* delete the saved state file once the machine has finished
14757	* restoring from it (note that Console sets the state from
14758	* Restoring to AbortedSaved if the VM couldn't restore successfully,
14759	* to give the user an ability to fix an error and retry --
14760	* we keep the saved state file in this case)
14761	*/
14762	deleteSavedState = true;
14763	}
14764	}
14765	else if ( ( oldMachineState == MachineState_Saved
14766	\|\| oldMachineState == MachineState_AbortedSaved
14767	)
14768	&& ( aMachineState == MachineState_PoweredOff
14769	\|\| aMachineState == MachineState_Teleported
14770	)
14771	)
14772	{
14773	/* delete the saved state after SessionMachine::discardSavedState() is called */
14774	deleteSavedState = true;
14775	mData->mCurrentStateModified = TRUE;
14776	stsFlags \|= SaveSTS_CurStateModified;
14777	}
14778	/* failure to reach the restoring state should always go to MachineState_AbortedSaved */
14779	Assert(!(oldMachineState == MachineState_Saved && aMachineState == MachineState_Aborted));
14780
14781	if ( aMachineState == MachineState_Starting
14782	\|\| aMachineState == MachineState_Restoring
14783	\|\| aMachineState == MachineState_TeleportingIn
14784	)
14785	{
14786	/* set the current state modified flag to indicate that the current
14787	* state is no more identical to the state in the
14788	* current snapshot */
14789	if (!mData->mCurrentSnapshot.isNull())
14790	{
14791	mData->mCurrentStateModified = TRUE;
14792	stsFlags \|= SaveSTS_CurStateModified;
14793	}
14794	}
14795
14796	if (deleteSavedState)
14797	{
14798	if (mRemoveSavedState)
14799	{
14800	Assert(!mSSData->strStateFilePath.isEmpty());
14801
14802	// it is safe to delete the saved state file if ...
14803	if ( !mData->mFirstSnapshot // ... we have no snapshots or
14804	\|\| !mData->mFirstSnapshot->i_sharesSavedStateFile(mSSData->strStateFilePath, NULL /* pSnapshotToIgnore */)
14805	// ... none of the snapshots share the saved state file
14806	)
14807	i_deleteFile(mSSData->strStateFilePath, true /* fIgnoreFailures */);
14808	}
14809
14810	mSSData->strStateFilePath.setNull();
14811	stsFlags \|= SaveSTS_StateFilePath;
14812	}
14813
14814	/* redirect to the underlying peer machine */
14815	mPeer->i_setMachineState(aMachineState);
14816
14817	if ( oldMachineState != MachineState_RestoringSnapshot
14818	&& ( aMachineState == MachineState_PoweredOff
14819	\|\| aMachineState == MachineState_Teleported
14820	\|\| aMachineState == MachineState_Aborted
14821	\|\| aMachineState == MachineState_AbortedSaved
14822	\|\| aMachineState == MachineState_Saved))
14823	{
14824	/* the machine has stopped execution
14825	* (or the saved state file was adopted) */
14826	stsFlags \|= SaveSTS_StateTimeStamp;
14827	}
14828
14829	if ( ( oldMachineState == MachineState_PoweredOff
14830	\|\| oldMachineState == MachineState_Aborted
14831	\|\| oldMachineState == MachineState_Teleported
14832	)
14833	&& aMachineState == MachineState_Saved)
14834	{
14835	/* the saved state file was adopted */
14836	Assert(!mSSData->strStateFilePath.isEmpty());
14837	stsFlags \|= SaveSTS_StateFilePath;
14838	}
14839
14840	#ifdef VBOX_WITH_GUEST_PROPS
14841	if ( aMachineState == MachineState_PoweredOff
14842	\|\| aMachineState == MachineState_Aborted
14843	\|\| aMachineState == MachineState_Teleported)
14844	{
14845	/* Make sure any transient guest properties get removed from the
14846	* property store on shutdown. */
14847	BOOL fNeedsSaving = mData->mGuestPropertiesModified;
14848
14849	/* remove it from the settings representation */
14850	settings::GuestPropertiesList &llGuestProperties = mData->pMachineConfigFile->hardwareMachine.llGuestProperties;
14851	for (settings::GuestPropertiesList::iterator
14852	it = llGuestProperties.begin();
14853	it != llGuestProperties.end();
14854	/nothing/)
14855	{
14856	const settings::GuestProperty &prop = *it;
14857	if ( prop.strFlags.contains("TRANSRESET", Utf8Str::CaseInsensitive)
14858	\|\| prop.strFlags.contains("TRANSIENT", Utf8Str::CaseInsensitive))
14859	{
14860	it = llGuestProperties.erase(it);
14861	fNeedsSaving = true;
14862	}
14863	else
14864	{
14865	++it;
14866	}
14867	}
14868
14869	/* Additionally remove it from the HWData representation. Required to
14870	* keep everything in sync, as this is what the API keeps using. */
14871	HWData::GuestPropertyMap &llHWGuestProperties = mHWData->mGuestProperties;
14872	for (HWData::GuestPropertyMap::iterator
14873	it = llHWGuestProperties.begin();
14874	it != llHWGuestProperties.end();
14875	/nothing/)
14876	{
14877	uint32_t fFlags = it->second.mFlags;
14878	if (fFlags & (GUEST_PROP_F_TRANSIENT \| GUEST_PROP_F_TRANSRESET))
14879	{
14880	/* iterator where we need to continue after the erase call
14881	* (C++03 is a fact still, and it doesn't return the iterator
14882	* which would allow continuing) */
14883	HWData::GuestPropertyMap::iterator it2 = it;
14884	++it2;
14885	llHWGuestProperties.erase(it);
14886	it = it2;
14887	fNeedsSaving = true;
14888	}
14889	else
14890	{
14891	++it;
14892	}
14893	}
14894
14895	if (fNeedsSaving)
14896	{
14897	mData->mCurrentStateModified = TRUE;
14898	stsFlags \|= SaveSTS_CurStateModified;
14899	}
14900	}
14901	#endif /* VBOX_WITH_GUEST_PROPS */
14902
14903	hrc = i_saveStateSettings(stsFlags);
14904
14905	if ( ( oldMachineState != MachineState_PoweredOff
14906	&& oldMachineState != MachineState_Aborted
14907	&& oldMachineState != MachineState_Teleported
14908	)
14909	&& ( aMachineState == MachineState_PoweredOff
14910	\|\| aMachineState == MachineState_Aborted
14911	\|\| aMachineState == MachineState_Teleported
14912	)
14913	)
14914	{
14915	/* we've been shut down for any reason */
14916	/* no special action so far */
14917	}
14918
14919	LogFlowThisFunc(("hrc=%Rhrc [%s]\n", hrc, ::stringifyMachineState(mData->mMachineState) ));
14920	LogFlowThisFuncLeave();
14921	return hrc;
14922	}
14923
14924	/**
14925	* Sends the current machine state value to the VM process.
14926	*
14927	* @note Locks this object for reading, then calls a client process.
14928	*/
14929	HRESULT SessionMachine::i_updateMachineStateOnClient()
14930	{
14931	AutoCaller autoCaller(this);
14932	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
14933
14934	ComPtr<IInternalSessionControl> directControl;
14935	{
14936	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14937	AssertReturn(!!mData, E_FAIL);
14938	if (mData->mSession.mLockType == LockType_VM)
14939	directControl = mData->mSession.mDirectControl;
14940
14941	/* directControl may be already set to NULL here in #OnSessionEnd()
14942	* called too early by the direct session process while there is still
14943	* some operation (like deleting the snapshot) in progress. The client
14944	* process in this case is waiting inside Session::close() for the
14945	* "end session" process object to complete, while #uninit() called by
14946	* #i_checkForDeath() on the Watcher thread is waiting for the pending
14947	* operation to complete. For now, we accept this inconsistent behavior
14948	* and simply do nothing here. */
14949
14950	if (mData->mSession.mState == SessionState_Unlocking)
14951	return S_OK;
14952	}
14953
14954	/* ignore notifications sent after #OnSessionEnd() is called */
14955	if (!directControl)
14956	return S_OK;
14957
14958	return directControl->UpdateMachineState(mData->mMachineState);
14959	}
14960
14961
14962	/static/
14963	HRESULT Machine::i_setErrorStatic(HRESULT aResultCode, const char *pcszMsg, ...)
14964	{
14965	va_list args;
14966	va_start(args, pcszMsg);
14967	HRESULT hrc = setErrorInternalV(aResultCode,
14968	getStaticClassIID(),
14969	getStaticComponentName(),
14970	pcszMsg, args,
14971	false /* aWarning */,
14972	true /* aLogIt */);
14973	va_end(args);
14974	return hrc;
14975	}
14976
14977
14978	HRESULT Machine::updateState(MachineState_T aState)
14979	{
14980	NOREF(aState);
14981	ReturnComNotImplemented();
14982	}
14983
14984	HRESULT Machine::beginPowerUp(const ComPtr<IProgress> &aProgress)
14985	{
14986	NOREF(aProgress);
14987	ReturnComNotImplemented();
14988	}
14989
14990	HRESULT Machine::endPowerUp(LONG aResult)
14991	{
14992	NOREF(aResult);
14993	ReturnComNotImplemented();
14994	}
14995
14996	HRESULT Machine::beginPoweringDown(ComPtr<IProgress> &aProgress)
14997	{
14998	NOREF(aProgress);
14999	ReturnComNotImplemented();
15000	}
15001
15002	HRESULT Machine::endPoweringDown(LONG aResult,
15003	const com::Utf8Str &aErrMsg)
15004	{
15005	NOREF(aResult);
15006	NOREF(aErrMsg);
15007	ReturnComNotImplemented();
15008	}
15009
15010	HRESULT Machine::runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
15011	BOOL *aMatched,
15012	ULONG *aMaskedInterfaces)
15013	{
15014	NOREF(aDevice);
15015	NOREF(aMatched);
15016	NOREF(aMaskedInterfaces);
15017	ReturnComNotImplemented();
15018
15019	}
15020
15021	HRESULT Machine::captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename)
15022	{
15023	NOREF(aId); NOREF(aCaptureFilename);
15024	ReturnComNotImplemented();
15025	}
15026
15027	HRESULT Machine::detachUSBDevice(const com::Guid &aId,
15028	BOOL aDone)
15029	{
15030	NOREF(aId);
15031	NOREF(aDone);
15032	ReturnComNotImplemented();
15033	}
15034
15035	HRESULT Machine::autoCaptureUSBDevices()
15036	{
15037	ReturnComNotImplemented();
15038	}
15039
15040	HRESULT Machine::detachAllUSBDevices(BOOL aDone)
15041	{
15042	NOREF(aDone);
15043	ReturnComNotImplemented();
15044	}
15045
15046	HRESULT Machine::onSessionEnd(const ComPtr<ISession> &aSession,
15047	ComPtr<IProgress> &aProgress)
15048	{
15049	NOREF(aSession);
15050	NOREF(aProgress);
15051	ReturnComNotImplemented();
15052	}
15053
15054	HRESULT Machine::finishOnlineMergeMedium()
15055	{
15056	ReturnComNotImplemented();
15057	}
15058
15059	HRESULT Machine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
15060	std::vector<com::Utf8Str> &aValues,
15061	std::vector<LONG64> &aTimestamps,
15062	std::vector<com::Utf8Str> &aFlags)
15063	{
15064	NOREF(aNames);
15065	NOREF(aValues);
15066	NOREF(aTimestamps);
15067	NOREF(aFlags);
15068	ReturnComNotImplemented();
15069	}
15070
15071	HRESULT Machine::pushGuestProperty(const com::Utf8Str &aName,
15072	const com::Utf8Str &aValue,
15073	LONG64 aTimestamp,
15074	const com::Utf8Str &aFlags,
15075	BOOL fWasDeleted)
15076	{
15077	NOREF(aName);
15078	NOREF(aValue);
15079	NOREF(aTimestamp);
15080	NOREF(aFlags);
15081	NOREF(fWasDeleted);
15082	ReturnComNotImplemented();
15083	}
15084
15085	HRESULT Machine::lockMedia()
15086	{
15087	ReturnComNotImplemented();
15088	}
15089
15090	HRESULT Machine::unlockMedia()
15091	{
15092	ReturnComNotImplemented();
15093	}
15094
15095	HRESULT Machine::ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
15096	ComPtr<IMediumAttachment> &aNewAttachment)
15097	{
15098	NOREF(aAttachment);
15099	NOREF(aNewAttachment);
15100	ReturnComNotImplemented();
15101	}
15102
15103	HRESULT Machine::reportVmStatistics(ULONG aValidStats,
15104	ULONG aCpuUser,
15105	ULONG aCpuKernel,
15106	ULONG aCpuIdle,
15107	ULONG aMemTotal,
15108	ULONG aMemFree,
15109	ULONG aMemBalloon,
15110	ULONG aMemShared,
15111	ULONG aMemCache,
15112	ULONG aPagedTotal,
15113	ULONG aMemAllocTotal,
15114	ULONG aMemFreeTotal,
15115	ULONG aMemBalloonTotal,
15116	ULONG aMemSharedTotal,
15117	ULONG aVmNetRx,
15118	ULONG aVmNetTx)
15119	{
15120	NOREF(aValidStats);
15121	NOREF(aCpuUser);
15122	NOREF(aCpuKernel);
15123	NOREF(aCpuIdle);
15124	NOREF(aMemTotal);
15125	NOREF(aMemFree);
15126	NOREF(aMemBalloon);
15127	NOREF(aMemShared);
15128	NOREF(aMemCache);
15129	NOREF(aPagedTotal);
15130	NOREF(aMemAllocTotal);
15131	NOREF(aMemFreeTotal);
15132	NOREF(aMemBalloonTotal);
15133	NOREF(aMemSharedTotal);
15134	NOREF(aVmNetRx);
15135	NOREF(aVmNetTx);
15136	ReturnComNotImplemented();
15137	}
15138
15139	HRESULT Machine::authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
15140	com::Utf8Str &aResult)
15141	{
15142	NOREF(aAuthParams);
15143	NOREF(aResult);
15144	ReturnComNotImplemented();
15145	}
15146
15147	HRESULT Machine::applyDefaults(const com::Utf8Str &aFlags)
15148	{
15149	/* it's assumed the machine already registered. If not, it's a problem of the caller */
15150
15151	AutoCaller autoCaller(this);
15152	AssertComRCReturn(autoCaller.hrc(),autoCaller.hrc());
15153
15154	/* get usb device filters from host, before any writes occurred to avoid deadlock */
15155	ComPtr<IUSBDeviceFilters> usbDeviceFilters;
15156	HRESULT hrc = getUSBDeviceFilters(usbDeviceFilters);
15157	if (FAILED(hrc)) return hrc;
15158
15159	NOREF(aFlags);
15160	com::Utf8Str osTypeId;
15161	ComObjPtr<GuestOSType> osType = NULL;
15162
15163	/* Get the guest os type as a string from the VB. */
15164	hrc = getOSTypeId(osTypeId);
15165	if (FAILED(hrc)) return hrc;
15166
15167	/* Get the os type obj that coresponds, can be used to get
15168	* the defaults for this guest OS. */
15169	hrc = mParent->i_findGuestOSType(Bstr(osTypeId), osType);
15170	if (FAILED(hrc)) return hrc;
15171
15172	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
15173
15174	mPlatform->i_applyDefaults(osType);
15175
15176	/* This one covers IOAPICEnabled. */
15177	mFirmwareSettings->i_applyDefaults(osType);
15178
15179	/* Initialize default record settings. */
15180	mRecordingSettings->i_applyDefaults();
15181
15182	hrc = osType->COMGETTER(RecommendedRAM)(&mHWData->mMemorySize);
15183	if (FAILED(hrc)) return hrc;
15184
15185	hrc = osType->COMGETTER(RecommendedCPUCount)(&mHWData->mCPUCount);
15186	if (FAILED(hrc)) return hrc;
15187
15188	/* Graphics stuff. */
15189	GraphicsControllerType_T graphicsController;
15190	hrc = osType->COMGETTER(RecommendedGraphicsController)(&graphicsController);
15191	if (FAILED(hrc)) return hrc;
15192
15193	hrc = mGraphicsAdapter->COMSETTER(GraphicsControllerType)(graphicsController);
15194	if (FAILED(hrc)) return hrc;
15195
15196	ULONG vramSize;
15197	hrc = osType->COMGETTER(RecommendedVRAM)(&vramSize);
15198	if (FAILED(hrc)) return hrc;
15199
15200	hrc = mGraphicsAdapter->COMSETTER(VRAMSize)(vramSize);
15201	if (FAILED(hrc)) return hrc;
15202
15203	BOOL fAccelerate2DVideoEnabled;
15204	hrc = osType->COMGETTER(Recommended2DVideoAcceleration)(&fAccelerate2DVideoEnabled);
15205	if (FAILED(hrc)) return hrc;
15206
15207	hrc = mGraphicsAdapter->COMSETTER(Accelerate2DVideoEnabled)(fAccelerate2DVideoEnabled);
15208	if (FAILED(hrc)) return hrc;
15209
15210	BOOL fAccelerate3DEnabled;
15211	hrc = osType->COMGETTER(Recommended3DAcceleration)(&fAccelerate3DEnabled);
15212	if (FAILED(hrc)) return hrc;
15213
15214	hrc = mGraphicsAdapter->COMSETTER(Accelerate3DEnabled)(fAccelerate3DEnabled);
15215	if (FAILED(hrc)) return hrc;
15216
15217	/* Apply network adapters defaults */
15218	for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
15219	mNetworkAdapters[slot]->i_applyDefaults(osType);
15220
15221	/* Apply serial port defaults */
15222	for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
15223	mSerialPorts[slot]->i_applyDefaults(osType);
15224
15225	/* Apply parallel port defaults - not OS dependent*/
15226	for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
15227	mParallelPorts[slot]->i_applyDefaults();
15228
15229	/* This one covers the TPM type. */
15230	mTrustedPlatformModule->i_applyDefaults(osType);
15231
15232	/* This one covers secure boot. */
15233	hrc = mNvramStore->i_applyDefaults(osType);
15234	if (FAILED(hrc)) return hrc;
15235
15236	/* Audio stuff. */
15237	hrc = mAudioSettings->i_applyDefaults(osType);
15238	if (FAILED(hrc)) return hrc;
15239
15240	/* Storage Controllers */
15241	StorageControllerType_T hdStorageControllerType;
15242	StorageBus_T hdStorageBusType;
15243	StorageControllerType_T dvdStorageControllerType;
15244	StorageBus_T dvdStorageBusType;
15245	BOOL recommendedFloppy;
15246	ComPtr<IStorageController> floppyController;
15247	ComPtr<IStorageController> hdController;
15248	ComPtr<IStorageController> dvdController;
15249	Utf8Str strFloppyName, strDVDName, strHDName;
15250
15251	/* GUI auto generates controller names using bus type. Do the same*/
15252	strFloppyName = StorageController::i_controllerNameFromBusType(StorageBus_Floppy);
15253
15254	/* Floppy recommended? add one. */
15255	hrc = osType->COMGETTER(RecommendedFloppy(&recommendedFloppy));
15256	if (FAILED(hrc)) return hrc;
15257	if (recommendedFloppy)
15258	{
15259	hrc = addStorageController(strFloppyName, StorageBus_Floppy, floppyController);
15260	if (FAILED(hrc)) return hrc;
15261	}
15262
15263	/* Setup one DVD storage controller. */
15264	hrc = osType->COMGETTER(RecommendedDVDStorageController)(&dvdStorageControllerType);
15265	if (FAILED(hrc)) return hrc;
15266
15267	hrc = osType->COMGETTER(RecommendedDVDStorageBus)(&dvdStorageBusType);
15268	if (FAILED(hrc)) return hrc;
15269
15270	strDVDName = StorageController::i_controllerNameFromBusType(dvdStorageBusType);
15271
15272	hrc = addStorageController(strDVDName, dvdStorageBusType, dvdController);
15273	if (FAILED(hrc)) return hrc;
15274
15275	hrc = dvdController->COMSETTER(ControllerType)(dvdStorageControllerType);
15276	if (FAILED(hrc)) return hrc;
15277
15278	/* Setup one HDD storage controller. */
15279	hrc = osType->COMGETTER(RecommendedHDStorageController)(&hdStorageControllerType);
15280	if (FAILED(hrc)) return hrc;
15281
15282	hrc = osType->COMGETTER(RecommendedHDStorageBus)(&hdStorageBusType);
15283	if (FAILED(hrc)) return hrc;
15284
15285	strHDName = StorageController::i_controllerNameFromBusType(hdStorageBusType);
15286
15287	if (hdStorageBusType != dvdStorageBusType && hdStorageControllerType != dvdStorageControllerType)
15288	{
15289	hrc = addStorageController(strHDName, hdStorageBusType, hdController);
15290	if (FAILED(hrc)) return hrc;
15291
15292	hrc = hdController->COMSETTER(ControllerType)(hdStorageControllerType);
15293	if (FAILED(hrc)) return hrc;
15294	}
15295	else
15296	{
15297	/* The HD controller is the same as DVD: */
15298	hdController = dvdController;
15299	}
15300
15301	/* Limit the AHCI port count if it's used because windows has trouble with
15302	* too many ports and other guest (OS X in particular) may take extra long
15303	* boot: */
15304
15305	// pParent = static_cast<Medium*>(aP)
15306	IStorageController *temp = hdController;
15307	ComObjPtr<StorageController> storageController;
15308	storageController = static_cast<StorageController *>(temp);
15309
15310	// tempHDController = aHDController;
15311	if (hdStorageControllerType == StorageControllerType_IntelAhci)
15312	storageController->COMSETTER(PortCount)(1 + (dvdStorageControllerType == StorageControllerType_IntelAhci));
15313	else if (dvdStorageControllerType == StorageControllerType_IntelAhci)
15314	storageController->COMSETTER(PortCount)(1);
15315
15316	/* VirtioSCSI configures only one port per default -- set two ports here, one for HDD and one for DVD drive. */
15317	if (hdStorageControllerType == StorageControllerType_VirtioSCSI)
15318	{
15319	hrc = storageController->COMSETTER(PortCount)(2);
15320	if (FAILED(hrc)) return hrc;
15321	}
15322
15323	/* USB stuff */
15324
15325	bool ohciEnabled = false;
15326
15327	ComPtr<IUSBController> usbController;
15328	BOOL recommendedUSB3;
15329	BOOL recommendedUSB;
15330	BOOL usbProxyAvailable;
15331
15332	getUSBProxyAvailable(&usbProxyAvailable);
15333	if (FAILED(hrc)) return hrc;
15334
15335	hrc = osType->COMGETTER(RecommendedUSB3)(&recommendedUSB3);
15336	if (FAILED(hrc)) return hrc;
15337	hrc = osType->COMGETTER(RecommendedUSB)(&recommendedUSB);
15338	if (FAILED(hrc)) return hrc;
15339
15340	if (!usbDeviceFilters.isNull() && recommendedUSB3 && usbProxyAvailable)
15341	{
15342	hrc = addUSBController("XHCI", USBControllerType_XHCI, usbController);
15343	if (FAILED(hrc)) return hrc;
15344
15345	/* xHci includes OHCI */
15346	ohciEnabled = true;
15347	}
15348	if ( !ohciEnabled
15349	&& !usbDeviceFilters.isNull() && recommendedUSB && usbProxyAvailable)
15350	{
15351	hrc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
15352	if (FAILED(hrc)) return hrc;
15353	ohciEnabled = true;
15354
15355	hrc = addUSBController("EHCI", USBControllerType_EHCI, usbController);
15356	if (FAILED(hrc)) return hrc;
15357	}
15358
15359	/* Set recommended human interface device types: */
15360	BOOL recommendedUSBHID;
15361	hrc = osType->COMGETTER(RecommendedUSBHID)(&recommendedUSBHID);
15362	if (FAILED(hrc)) return hrc;
15363
15364	if (recommendedUSBHID)
15365	{
15366	mHWData->mKeyboardHIDType = KeyboardHIDType_USBKeyboard;
15367	mHWData->mPointingHIDType = PointingHIDType_USBMouse;
15368	if (!ohciEnabled && !usbDeviceFilters.isNull())
15369	{
15370	hrc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
15371	if (FAILED(hrc)) return hrc;
15372	}
15373	}
15374
15375	BOOL recommendedUSBTablet;
15376	hrc = osType->COMGETTER(RecommendedUSBTablet)(&recommendedUSBTablet);
15377	if (FAILED(hrc)) return hrc;
15378
15379	if (recommendedUSBTablet)
15380	{
15381	mHWData->mPointingHIDType = PointingHIDType_USBTablet;
15382	if (!ohciEnabled && !usbDeviceFilters.isNull())
15383	{
15384	hrc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
15385	if (FAILED(hrc)) return hrc;
15386	}
15387	}
15388
15389	/* Enable the VMMDev testing feature for bootsector VMs: */
15390	if (osTypeId == GUEST_OS_ID_STR_X64("VBoxBS"))
15391	{
15392	hrc = setExtraData("VBoxInternal/Devices/VMMDev/0/Config/TestingEnabled", "1");
15393	if (FAILED(hrc))
15394	return hrc;
15395	}
15396
15397	return S_OK;
15398	}
15399
15400	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
15401	/**
15402	* Task record for change encryption settins.
15403	*/
15404	class Machine::ChangeEncryptionTask
15405	: public Machine::Task
15406	{
15407	public:
15408	ChangeEncryptionTask(Machine *m,
15409	Progress *p,
15410	const Utf8Str &t,
15411	const com::Utf8Str &aCurrentPassword,
15412	const com::Utf8Str &aCipher,
15413	const com::Utf8Str &aNewPassword,
15414	const com::Utf8Str &aNewPasswordId,
15415	const BOOL aForce,
15416	const MediaList &llMedia)
15417	: Task(m, p, t),
15418	mstrNewPassword(aNewPassword),
15419	mstrCurrentPassword(aCurrentPassword),
15420	mstrCipher(aCipher),
15421	mstrNewPasswordId(aNewPasswordId),
15422	mForce(aForce),
15423	mllMedia(llMedia)
15424	{}
15425
15426	~ChangeEncryptionTask()
15427	{
15428	if (mstrNewPassword.length())
15429	RTMemWipeThoroughly(mstrNewPassword.mutableRaw(), mstrNewPassword.length(), 10 /* cPasses */);
15430	if (mstrCurrentPassword.length())
15431	RTMemWipeThoroughly(mstrCurrentPassword.mutableRaw(), mstrCurrentPassword.length(), 10 /* cPasses */);
15432	if (m_pCryptoIf)
15433	{
15434	m_pMachine->i_getVirtualBox()->i_releaseCryptoIf(m_pCryptoIf);
15435	m_pCryptoIf = NULL;
15436	}
15437	}
15438
15439	Utf8Str mstrNewPassword;
15440	Utf8Str mstrCurrentPassword;
15441	Utf8Str mstrCipher;
15442	Utf8Str mstrNewPasswordId;
15443	BOOL mForce;
15444	MediaList mllMedia;
15445	PCVBOXCRYPTOIF m_pCryptoIf;
15446	private:
15447	void handler()
15448	{
15449	try
15450	{
15451	m_pMachine->i_changeEncryptionHandler(*this);
15452	}
15453	catch (...)
15454	{
15455	LogRel(("Some exception in the function Machine::i_changeEncryptionHandler()\n"));
15456	}
15457	}
15458
15459	friend void Machine::i_changeEncryptionHandler(ChangeEncryptionTask &task);
15460	};
15461
15462	/**
15463	* Scans specified directory and fills list by files found
15464	*
15465	* @returns VBox status code.
15466	* @param lstFiles
15467	* @param strDir
15468	* @param filePattern
15469	*/
15470	int Machine::i_findFiles(std::list<com::Utf8Str> &lstFiles, const com::Utf8Str &strDir,
15471	const com::Utf8Str &strPattern)
15472	{
15473	/* To get all entries including subdirectories. */
15474	char pszFilePattern = RTPathJoinA(strDir.c_str(), "");
15475	if (!pszFilePattern)
15476	return VERR_NO_STR_MEMORY;
15477
15478	PRTDIRENTRYEX pDirEntry = NULL;
15479	RTDIR hDir;
15480	size_t cbDirEntry = sizeof(RTDIRENTRYEX);
15481	int vrc = RTDirOpenFiltered(&hDir, pszFilePattern, RTDIRFILTER_WINNT, 0 /fFlags/);
15482	if (RT_SUCCESS(vrc))
15483	{
15484	pDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(sizeof(RTDIRENTRYEX));
15485	if (pDirEntry)
15486	{
15487	while ( (vrc = RTDirReadEx(hDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK))
15488	!= VERR_NO_MORE_FILES)
15489	{
15490	char *pszFilePath = NULL;
15491
15492	if (vrc == VERR_BUFFER_OVERFLOW)
15493	{
15494	/* allocate new buffer. */
15495	RTMemFree(pDirEntry);
15496	pDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(cbDirEntry);
15497	if (!pDirEntry)
15498	{
15499	vrc = VERR_NO_MEMORY;
15500	break;
15501	}
15502	/* Retry. */
15503	vrc = RTDirReadEx(hDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
15504	if (RT_FAILURE(vrc))
15505	break;
15506	}
15507	else if (RT_FAILURE(vrc))
15508	break;
15509
15510	/* Exclude . and .. */
15511	if ( (pDirEntry->szName[0] == '.' && pDirEntry->szName[1] == '\0')
15512	\|\| (pDirEntry->szName[0] == '.' && pDirEntry->szName[1] == '.' && pDirEntry->szName[2] == '\0'))
15513	continue;
15514	if (RTFS_IS_DIRECTORY(pDirEntry->Info.Attr.fMode))
15515	{
15516	char *pszSubDirPath = RTPathJoinA(strDir.c_str(), pDirEntry->szName);
15517	if (!pszSubDirPath)
15518	{
15519	vrc = VERR_NO_STR_MEMORY;
15520	break;
15521	}
15522	vrc = i_findFiles(lstFiles, pszSubDirPath, strPattern);
15523	RTMemFree(pszSubDirPath);
15524	if (RT_FAILURE(vrc))
15525	break;
15526	continue;
15527	}
15528
15529	/* We got the new entry. */
15530	if (!RTFS_IS_FILE(pDirEntry->Info.Attr.fMode))
15531	continue;
15532
15533	if (!RTStrSimplePatternMatch(strPattern.c_str(), pDirEntry->szName))
15534	continue;
15535
15536	/* Prepend the path to the libraries. */
15537	pszFilePath = RTPathJoinA(strDir.c_str(), pDirEntry->szName);
15538	if (!pszFilePath)
15539	{
15540	vrc = VERR_NO_STR_MEMORY;
15541	break;
15542	}
15543
15544	lstFiles.push_back(pszFilePath);
15545	RTStrFree(pszFilePath);
15546	}
15547
15548	RTMemFree(pDirEntry);
15549	}
15550	else
15551	vrc = VERR_NO_MEMORY;
15552
15553	RTDirClose(hDir);
15554	}
15555	else
15556	{
15557	/* On Windows the above immediately signals that there are no
15558	* files matching, while on other platforms enumerating the
15559	* files below fails. Either way: stop searching. */
15560	}
15561
15562	if ( vrc == VERR_NO_MORE_FILES
15563	\|\| vrc == VERR_FILE_NOT_FOUND
15564	\|\| vrc == VERR_PATH_NOT_FOUND)
15565	vrc = VINF_SUCCESS;
15566	RTStrFree(pszFilePattern);
15567	return vrc;
15568	}
15569
15570	/**
15571	* Helper to set up an I/O stream to read or write a possibly encrypted file.
15572	*
15573	* @returns VBox status code.
15574	* @param pszFilename The file to open.
15575	* @param pCryptoIf Pointer to the cryptographic interface if the file should be encrypted or contains encrypted data.
15576	* @param pszKeyStore The keystore if the file should be encrypted or contains encrypted data.
15577	* @param pszPassword The password if the file should be encrypted or contains encrypted data.
15578	* @param fOpen The open flags for the file.
15579	* @param phVfsIos Where to store the handle to the I/O stream on success.
15580	*/
15581	int Machine::i_createIoStreamForFile(const char *pszFilename, PCVBOXCRYPTOIF pCryptoIf,
15582	const char pszKeyStore, const char pszPassword,
15583	uint64_t fOpen, PRTVFSIOSTREAM phVfsIos)
15584	{
15585	RTVFSFILE hVfsFile = NIL_RTVFSFILE;
15586	int vrc = RTVfsFileOpenNormal(pszFilename, fOpen, &hVfsFile);
15587	if (RT_SUCCESS(vrc))
15588	{
15589	if (pCryptoIf)
15590	{
15591	RTVFSFILE hVfsFileCrypto = NIL_RTVFSFILE;
15592	vrc = pCryptoIf->pfnCryptoFileFromVfsFile(hVfsFile, pszKeyStore, pszPassword, &hVfsFileCrypto);
15593	if (RT_SUCCESS(vrc))
15594	{
15595	RTVfsFileRelease(hVfsFile);
15596	hVfsFile = hVfsFileCrypto;
15597	}
15598	}
15599
15600	*phVfsIos = RTVfsFileToIoStream(hVfsFile);
15601	RTVfsFileRelease(hVfsFile);
15602	}
15603
15604	return vrc;
15605	}
15606
15607	/**
15608	* Helper function processing all actions for one component (saved state files,
15609	* NVRAM files, etc). Used by Machine::i_changeEncryptionHandler only.
15610	*
15611	* @param task
15612	* @param strDirectory
15613	* @param strFilePattern
15614	* @param strMagic
15615	* @param strKeyStore
15616	* @param strKeyId
15617	* @return
15618	*/
15619	HRESULT Machine::i_changeEncryptionForComponent(ChangeEncryptionTask &task, const com::Utf8Str strDirectory,
15620	const com::Utf8Str strFilePattern, com::Utf8Str &strKeyStore,
15621	com::Utf8Str &strKeyId, int iCipherMode)
15622	{
15623	bool fDecrypt = task.mstrCurrentPassword.isNotEmpty()
15624	&& task.mstrCipher.isEmpty()
15625	&& task.mstrNewPassword.isEmpty()
15626	&& task.mstrNewPasswordId.isEmpty();
15627	bool fEncrypt = task.mstrCurrentPassword.isEmpty()
15628	&& task.mstrCipher.isNotEmpty()
15629	&& task.mstrNewPassword.isNotEmpty()
15630	&& task.mstrNewPasswordId.isNotEmpty();
15631
15632	/* check if the cipher is changed which causes the reencryption*/
15633
15634	const char *pszTaskCipher = NULL;
15635	if (task.mstrCipher.isNotEmpty())
15636	pszTaskCipher = getCipherString(task.mstrCipher.c_str(), iCipherMode);
15637
15638	if (!task.mForce && !fDecrypt && !fEncrypt)
15639	{
15640	char *pszCipher = NULL;
15641	int vrc = task.m_pCryptoIf->pfnCryptoKeyStoreGetDekFromEncoded(strKeyStore.c_str(),
15642	NULL /pszPassword/,
15643	NULL /ppbKey/,
15644	NULL /pcbKey/,
15645	&pszCipher);
15646	if (RT_SUCCESS(vrc))
15647	{
15648	task.mForce = strcmp(pszTaskCipher, pszCipher) != 0;
15649	RTMemFree(pszCipher);
15650	}
15651	else
15652	return setErrorBoth(E_FAIL, vrc, tr("Obtain cipher for '%s' files failed (%Rrc)"),
15653	strFilePattern.c_str(), vrc);
15654	}
15655
15656	/* Only the password needs to be changed */
15657	if (!task.mForce && !fDecrypt && !fEncrypt)
15658	{
15659	Assert(task.m_pCryptoIf);
15660
15661	VBOXCRYPTOCTX hCryptoCtx;
15662	int vrc = task.m_pCryptoIf->pfnCryptoCtxLoad(strKeyStore.c_str(), task.mstrCurrentPassword.c_str(), &hCryptoCtx);
15663	if (RT_FAILURE(vrc))
15664	return setErrorBoth(E_FAIL, vrc, tr("Loading old key store for '%s' files failed, (%Rrc)"),
15665	strFilePattern.c_str(), vrc);
15666	vrc = task.m_pCryptoIf->pfnCryptoCtxPasswordChange(hCryptoCtx, task.mstrNewPassword.c_str());
15667	if (RT_FAILURE(vrc))
15668	return setErrorBoth(E_FAIL, vrc, tr("Changing the password for '%s' files failed, (%Rrc)"),
15669	strFilePattern.c_str(), vrc);
15670
15671	char *pszKeyStore = NULL;
15672	vrc = task.m_pCryptoIf->pfnCryptoCtxSave(hCryptoCtx, &pszKeyStore);
15673	task.m_pCryptoIf->pfnCryptoCtxDestroy(hCryptoCtx);
15674	if (RT_FAILURE(vrc))
15675	return setErrorBoth(E_FAIL, vrc, tr("Saving the key store for '%s' files failed, (%Rrc)"),
15676	strFilePattern.c_str(), vrc);
15677	strKeyStore = pszKeyStore;
15678	RTMemFree(pszKeyStore);
15679	strKeyId = task.mstrNewPasswordId;
15680	return S_OK;
15681	}
15682
15683	/* Reencryption required */
15684	HRESULT hrc = S_OK;
15685	int vrc = VINF_SUCCESS;
15686
15687	std::list<com::Utf8Str> lstFiles;
15688	if (SUCCEEDED(hrc))
15689	{
15690	vrc = i_findFiles(lstFiles, strDirectory, strFilePattern);
15691	if (RT_FAILURE(vrc))
15692	hrc = setErrorBoth(E_FAIL, vrc, tr("Getting file list for '%s' files failed, (%Rrc)"), strFilePattern.c_str(), vrc);
15693	}
15694	com::Utf8Str strNewKeyStore;
15695	if (SUCCEEDED(hrc))
15696	{
15697	if (!fDecrypt)
15698	{
15699	VBOXCRYPTOCTX hCryptoCtx;
15700	vrc = task.m_pCryptoIf->pfnCryptoCtxCreate(pszTaskCipher, task.mstrNewPassword.c_str(), &hCryptoCtx);
15701	if (RT_FAILURE(vrc))
15702	return setErrorBoth(E_FAIL, vrc, tr("Create new key store for '%s' files failed, (%Rrc)"),
15703	strFilePattern.c_str(), vrc);
15704
15705	char *pszKeyStore = NULL;
15706	vrc = task.m_pCryptoIf->pfnCryptoCtxSave(hCryptoCtx, &pszKeyStore);
15707	task.m_pCryptoIf->pfnCryptoCtxDestroy(hCryptoCtx);
15708	if (RT_FAILURE(vrc))
15709	return setErrorBoth(E_FAIL, vrc, tr("Saving the new key store for '%s' files failed, (%Rrc)"),
15710	strFilePattern.c_str(), vrc);
15711	strNewKeyStore = pszKeyStore;
15712	RTMemFree(pszKeyStore);
15713	}
15714
15715	for (std::list<com::Utf8Str>::iterator it = lstFiles.begin();
15716	it != lstFiles.end();
15717	++it)
15718	{
15719	RTVFSIOSTREAM hVfsIosOld = NIL_RTVFSIOSTREAM;
15720	RTVFSIOSTREAM hVfsIosNew = NIL_RTVFSIOSTREAM;
15721
15722	uint64_t fOpenForRead = RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE;
15723	uint64_t fOpenForWrite = RTFILE_O_READWRITE \| RTFILE_O_OPEN_CREATE \| RTFILE_O_DENY_WRITE;
15724
15725	vrc = i_createIoStreamForFile((*it).c_str(),
15726	fEncrypt ? NULL : task.m_pCryptoIf,
15727	fEncrypt ? NULL : strKeyStore.c_str(),
15728	fEncrypt ? NULL : task.mstrCurrentPassword.c_str(),
15729	fOpenForRead, &hVfsIosOld);
15730	if (RT_SUCCESS(vrc))
15731	{
15732	vrc = i_createIoStreamForFile((*it + ".tmp").c_str(),
15733	fDecrypt ? NULL : task.m_pCryptoIf,
15734	fDecrypt ? NULL : strNewKeyStore.c_str(),
15735	fDecrypt ? NULL : task.mstrNewPassword.c_str(),
15736	fOpenForWrite, &hVfsIosNew);
15737	if (RT_FAILURE(vrc))
15738	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening file '%s' failed, (%Rrc)"),
15739	(*it + ".tmp").c_str(), vrc);
15740	}
15741	else
15742	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening file '%s' failed, (%Rrc)"), (*it).c_str(), vrc);
15743
15744	if (RT_SUCCESS(vrc))
15745	{
15746	vrc = RTVfsUtilPumpIoStreams(hVfsIosOld, hVfsIosNew, BUF_DATA_SIZE);
15747	if (RT_FAILURE(vrc))
15748	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Changing encryption of the file '%s' failed with %Rrc"),
15749	(*it).c_str(), vrc);
15750	}
15751
15752	if (hVfsIosOld != NIL_RTVFSIOSTREAM)
15753	RTVfsIoStrmRelease(hVfsIosOld);
15754	if (hVfsIosNew != NIL_RTVFSIOSTREAM)
15755	RTVfsIoStrmRelease(hVfsIosNew);
15756	}
15757	}
15758
15759	if (SUCCEEDED(hrc))
15760	{
15761	for (std::list<com::Utf8Str>::iterator it = lstFiles.begin();
15762	it != lstFiles.end();
15763	++it)
15764	{
15765	vrc = RTFileRename((it + ".tmp").c_str(), (it).c_str(), RTPATHRENAME_FLAGS_REPLACE);
15766	if (RT_FAILURE(vrc))
15767	{
15768	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Renaming the file '%s' failed, (%Rrc)"), (*it + ".tmp").c_str(), vrc);
15769	break;
15770	}
15771	}
15772	}
15773
15774	if (SUCCEEDED(hrc))
15775	{
15776	strKeyStore = strNewKeyStore;
15777	strKeyId = task.mstrNewPasswordId;
15778	}
15779
15780	return hrc;
15781	}
15782
15783	/**
15784	* Task thread implementation for Machine::changeEncryption(), called from
15785	* Machine::taskHandler().
15786	*
15787	* @note Locks this object for writing.
15788	*
15789	* @param task
15790	* @return
15791	*/
15792	void Machine::i_changeEncryptionHandler(ChangeEncryptionTask &task)
15793	{
15794	LogFlowThisFuncEnter();
15795
15796	AutoCaller autoCaller(this);
15797	LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
15798	if (FAILED(autoCaller.hrc()))
15799	{
15800	/* we might have been uninitialized because the session was accidentally
15801	* closed by the client, so don't assert */
15802	HRESULT hrc = setError(E_FAIL, tr("The session has been accidentally closed"));
15803	task.m_pProgress->i_notifyComplete(hrc);
15804	LogFlowThisFuncLeave();
15805	return;
15806	}
15807
15808	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
15809
15810	HRESULT hrc = S_OK;
15811	com::Utf8Str strOldKeyId = mData->mstrKeyId;
15812	com::Utf8Str strOldKeyStore = mData->mstrKeyStore;
15813	try
15814	{
15815	hrc = this->i_getVirtualBox()->i_retainCryptoIf(&task.m_pCryptoIf);
15816	if (FAILED(hrc))
15817	throw hrc;
15818
15819	if (task.mstrCurrentPassword.isEmpty())
15820	{
15821	if (mData->mstrKeyStore.isNotEmpty())
15822	throw setError(VBOX_E_PASSWORD_INCORRECT,
15823	tr("The password given for the encrypted VM is incorrect"));
15824	}
15825	else
15826	{
15827	if (mData->mstrKeyStore.isEmpty())
15828	throw setError(VBOX_E_INVALID_OBJECT_STATE,
15829	tr("The VM is not configured for encryption"));
15830	hrc = checkEncryptionPassword(task.mstrCurrentPassword);
15831	if (hrc == VBOX_E_PASSWORD_INCORRECT)
15832	throw setError(VBOX_E_PASSWORD_INCORRECT,
15833	tr("The password to decrypt the VM is incorrect"));
15834	}
15835
15836	if (task.mstrCipher.isNotEmpty())
15837	{
15838	if ( task.mstrNewPassword.isEmpty()
15839	&& task.mstrNewPasswordId.isEmpty()
15840	&& task.mstrCurrentPassword.isNotEmpty())
15841	{
15842	/* An empty password and password ID will default to the current password. */
15843	task.mstrNewPassword = task.mstrCurrentPassword;
15844	}
15845	else if (task.mstrNewPassword.isEmpty())
15846	throw setError(VBOX_E_OBJECT_NOT_FOUND,
15847	tr("A password must be given for the VM encryption"));
15848	else if (task.mstrNewPasswordId.isEmpty())
15849	throw setError(VBOX_E_INVALID_OBJECT_STATE,
15850	tr("A valid identifier for the password must be given"));
15851	}
15852	else if (task.mstrNewPasswordId.isNotEmpty() \|\| task.mstrNewPassword.isNotEmpty())
15853	throw setError(VBOX_E_INVALID_OBJECT_STATE,
15854	tr("The password and password identifier must be empty if the output should be unencrypted"));
15855
15856	/*
15857	* Save config.
15858	* Must be first operation to prevent making encrypted copies
15859	* for old version of the config file.
15860	*/
15861	int fSave = Machine::SaveS_Force;
15862	if (task.mstrNewPassword.isNotEmpty())
15863	{
15864	VBOXCRYPTOCTX hCryptoCtx;
15865
15866	int vrc = VINF_SUCCESS;
15867	if (task.mForce \|\| task.mstrCurrentPassword.isEmpty() \|\| task.mstrCipher.isNotEmpty())
15868	{
15869	vrc = task.m_pCryptoIf->pfnCryptoCtxCreate(getCipherString(task.mstrCipher.c_str(), CipherModeGcm),
15870	task.mstrNewPassword.c_str(), &hCryptoCtx);
15871	if (RT_FAILURE(vrc))
15872	throw setErrorBoth(E_FAIL, vrc, tr("New key store creation failed, (%Rrc)"), vrc);
15873	}
15874	else
15875	{
15876	vrc = task.m_pCryptoIf->pfnCryptoCtxLoad(mData->mstrKeyStore.c_str(),
15877	task.mstrCurrentPassword.c_str(),
15878	&hCryptoCtx);
15879	if (RT_FAILURE(vrc))
15880	throw setErrorBoth(E_FAIL, vrc, tr("Loading old key store failed, (%Rrc)"), vrc);
15881	vrc = task.m_pCryptoIf->pfnCryptoCtxPasswordChange(hCryptoCtx, task.mstrNewPassword.c_str());
15882	if (RT_FAILURE(vrc))
15883	throw setErrorBoth(E_FAIL, vrc, tr("Changing the password failed, (%Rrc)"), vrc);
15884	}
15885
15886	char *pszKeyStore;
15887	vrc = task.m_pCryptoIf->pfnCryptoCtxSave(hCryptoCtx, &pszKeyStore);
15888	task.m_pCryptoIf->pfnCryptoCtxDestroy(hCryptoCtx);
15889	if (RT_FAILURE(vrc))
15890	throw setErrorBoth(E_FAIL, vrc, tr("Saving the key store failed, (%Rrc)"), vrc);
15891	mData->mstrKeyStore = pszKeyStore;
15892	RTStrFree(pszKeyStore);
15893	mData->mstrKeyId = task.mstrNewPasswordId;
15894	size_t cbPassword = task.mstrNewPassword.length() + 1;
15895	uint8_t pbPassword = (uint8_t )task.mstrNewPassword.c_str();
15896	mData->mpKeyStore->deleteSecretKey(task.mstrNewPasswordId);
15897	mData->mpKeyStore->addSecretKey(task.mstrNewPasswordId, pbPassword, cbPassword);
15898	mNvramStore->i_addPassword(task.mstrNewPasswordId, task.mstrNewPassword);
15899
15900	/*
15901	* Remove backuped config after saving because it can contain
15902	* unencrypted version of the config
15903	*/
15904	fSave \|= Machine::SaveS_RemoveBackup;
15905	}
15906	else
15907	{
15908	mData->mstrKeyId.setNull();
15909	mData->mstrKeyStore.setNull();
15910	}
15911
15912	Bstr bstrCurrentPassword(task.mstrCurrentPassword);
15913	Bstr bstrCipher(getCipherString(task.mstrCipher.c_str(), CipherModeXts));
15914	Bstr bstrNewPassword(task.mstrNewPassword);
15915	Bstr bstrNewPasswordId(task.mstrNewPasswordId);
15916	/* encrypt media */
15917	alock.release();
15918	for (MediaList::iterator it = task.mllMedia.begin();
15919	it != task.mllMedia.end();
15920	++it)
15921	{
15922	ComPtr<IProgress> pProgress1;
15923	hrc = (*it)->ChangeEncryption(bstrCurrentPassword.raw(), bstrCipher.raw(),
15924	bstrNewPassword.raw(), bstrNewPasswordId.raw(),
15925	pProgress1.asOutParam());
15926	if (FAILED(hrc)) throw hrc;
15927	hrc = task.m_pProgress->WaitForOtherProgressCompletion(pProgress1, 0 /* indefinite wait */);
15928	if (FAILED(hrc)) throw hrc;
15929	}
15930	alock.acquire();
15931
15932	task.m_pProgress->SetNextOperation(Bstr(tr("Change encryption of the SAV files")).raw(), 1);
15933
15934	Utf8Str strFullSnapshotFolder;
15935	i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
15936
15937	/* .sav files (main and snapshots) */
15938	hrc = i_changeEncryptionForComponent(task, strFullSnapshotFolder, "*.sav",
15939	mSSData->strStateKeyStore, mSSData->strStateKeyId, CipherModeGcm);
15940	if (FAILED(hrc))
15941	/* the helper function already sets error object */
15942	throw hrc;
15943
15944	task.m_pProgress->SetNextOperation(Bstr(tr("Change encryption of the NVRAM files")).raw(), 1);
15945
15946	/* .nvram files */
15947	com::Utf8Str strNVRAMKeyId;
15948	com::Utf8Str strNVRAMKeyStore;
15949	hrc = mNvramStore->i_getEncryptionSettings(strNVRAMKeyId, strNVRAMKeyStore);
15950	if (FAILED(hrc))
15951	throw setError(hrc, tr("Getting NVRAM encryption settings failed (%Rhrc)"), hrc);
15952
15953	Utf8Str strMachineFolder;
15954	i_calculateFullPath(".", strMachineFolder);
15955
15956	hrc = i_changeEncryptionForComponent(task, strMachineFolder, "*.nvram", strNVRAMKeyStore, strNVRAMKeyId, CipherModeGcm);
15957	if (FAILED(hrc))
15958	/* the helper function already sets error object */
15959	throw hrc;
15960
15961	hrc = mNvramStore->i_updateEncryptionSettings(strNVRAMKeyId, strNVRAMKeyStore);
15962	if (FAILED(hrc))
15963	throw setError(hrc, tr("Setting NVRAM encryption settings failed (%Rhrc)"), hrc);
15964
15965	task.m_pProgress->SetNextOperation(Bstr(tr("Change encryption of log files")).raw(), 1);
15966
15967	/* .log files */
15968	com::Utf8Str strLogFolder;
15969	i_getLogFolder(strLogFolder);
15970	hrc = i_changeEncryptionForComponent(task, strLogFolder, "VBox.log*",
15971	mData->mstrLogKeyStore, mData->mstrLogKeyId, CipherModeCtr);
15972	if (FAILED(hrc))
15973	/* the helper function already sets error object */
15974	throw hrc;
15975
15976	task.m_pProgress->SetNextOperation(Bstr(tr("Change encryption of the config file")).raw(), 1);
15977
15978	i_saveSettings(NULL, alock, fSave);
15979	}
15980	catch (HRESULT hrcXcpt)
15981	{
15982	hrc = hrcXcpt;
15983	mData->mstrKeyId = strOldKeyId;
15984	mData->mstrKeyStore = strOldKeyStore;
15985	}
15986
15987	task.m_pProgress->i_notifyComplete(hrc);
15988
15989	LogFlowThisFuncLeave();
15990	}
15991	#endif /!VBOX_WITH_FULL_VM_ENCRYPTION/
15992
15993	HRESULT Machine::changeEncryption(const com::Utf8Str &aCurrentPassword,
15994	const com::Utf8Str &aCipher,
15995	const com::Utf8Str &aNewPassword,
15996	const com::Utf8Str &aNewPasswordId,
15997	BOOL aForce,
15998	ComPtr<IProgress> &aProgress)
15999	{
16000	LogFlowFuncEnter();
16001
16002	#ifndef VBOX_WITH_FULL_VM_ENCRYPTION
16003	RT_NOREF(aCurrentPassword, aCipher, aNewPassword, aNewPasswordId, aForce, aProgress);
16004	return setError(VBOX_E_NOT_SUPPORTED, tr("Full VM encryption is not available with this build"));
16005	#else
16006	/* make the VM accessible */
16007	if (!mData->mAccessible)
16008	{
16009	if ( aCurrentPassword.isEmpty()
16010	\|\| mData->mstrKeyId.isEmpty())
16011	return setError(E_ACCESSDENIED, tr("Machine is inaccessible"));
16012
16013	HRESULT hrc = addEncryptionPassword(mData->mstrKeyId, aCurrentPassword);
16014	if (FAILED(hrc))
16015	return hrc;
16016	}
16017
16018	AutoLimitedCaller autoCaller(this);
16019	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
16020
16021	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
16022
16023	/* define media to be change encryption */
16024
16025	MediaList llMedia;
16026	for (MediumAttachmentList::iterator
16027	it = mMediumAttachments->begin();
16028	it != mMediumAttachments->end();
16029	++it)
16030	{
16031	ComObjPtr<MediumAttachment> &pAttach = *it;
16032	ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
16033
16034	if (!pMedium.isNull())
16035	{
16036	AutoCaller mac(pMedium);
16037	if (FAILED(mac.hrc())) return mac.hrc();
16038	AutoReadLock lock(pMedium COMMA_LOCKVAL_SRC_POS);
16039	DeviceType_T devType = pMedium->i_getDeviceType();
16040	if (devType == DeviceType_HardDisk)
16041	{
16042	/*
16043	* We need to move to last child because the Medium::changeEncryption
16044	* encrypts all chain of specified medium with its parents.
16045	* Also we perform cheking of back reference and children for
16046	* all media in the chain to raise error before we start any action.
16047	* So, we first move into root parent and then we will move to last child
16048	* keeping latter in the list for encryption.
16049	*/
16050
16051	/* move to root parent */
16052	ComObjPtr<Medium> pTmpMedium = pMedium;
16053	while (pTmpMedium.isNotNull())
16054	{
16055	AutoCaller mediumAC(pTmpMedium);
16056	if (FAILED(mediumAC.hrc())) return mediumAC.hrc();
16057	AutoReadLock mlock(pTmpMedium COMMA_LOCKVAL_SRC_POS);
16058
16059	/* Cannot encrypt media which are attached to more than one virtual machine. */
16060	size_t cBackRefs = pTmpMedium->i_getMachineBackRefCount();
16061	if (cBackRefs > 1)
16062	return setError(VBOX_E_INVALID_OBJECT_STATE,
16063	tr("Cannot encrypt medium '%s' because it is attached to %d virtual machines", "", cBackRefs),
16064	pTmpMedium->i_getName().c_str(), cBackRefs);
16065
16066	size_t cChildren = pTmpMedium->i_getChildren().size();
16067	if (cChildren > 1)
16068	return setError(VBOX_E_INVALID_OBJECT_STATE,
16069	tr("Cannot encrypt medium '%s' because it has %d children", "", cChildren),
16070	pTmpMedium->i_getName().c_str(), cChildren);
16071
16072	pTmpMedium = pTmpMedium->i_getParent();
16073	}
16074	/* move to last child */
16075	pTmpMedium = pMedium;
16076	while (pTmpMedium.isNotNull() && pTmpMedium->i_getChildren().size() != 0)
16077	{
16078	AutoCaller mediumAC(pTmpMedium);
16079	if (FAILED(mediumAC.hrc())) return mediumAC.hrc();
16080	AutoReadLock mlock(pTmpMedium COMMA_LOCKVAL_SRC_POS);
16081
16082	/* Cannot encrypt media which are attached to more than one virtual machine. */
16083	size_t cBackRefs = pTmpMedium->i_getMachineBackRefCount();
16084	if (cBackRefs > 1)
16085	return setError(VBOX_E_INVALID_OBJECT_STATE,
16086	tr("Cannot encrypt medium '%s' because it is attached to %d virtual machines", "", cBackRefs),
16087	pTmpMedium->i_getName().c_str(), cBackRefs);
16088
16089	size_t cChildren = pTmpMedium->i_getChildren().size();
16090	if (cChildren > 1)
16091	return setError(VBOX_E_INVALID_OBJECT_STATE,
16092	tr("Cannot encrypt medium '%s' because it has %d children", "", cChildren),
16093	pTmpMedium->i_getName().c_str(), cChildren);
16094
16095	pTmpMedium = pTmpMedium->i_getChildren().front();
16096	}
16097	llMedia.push_back(pTmpMedium);
16098	}
16099	}
16100	}
16101
16102	ComObjPtr<Progress> pProgress;
16103	pProgress.createObject();
16104	HRESULT hrc = pProgress->init(i_getVirtualBox(),
16105	static_cast<IMachine>(this) / aInitiator */,
16106	tr("Change encryption"),
16107	TRUE /* fCancellable */,
16108	(ULONG)(4 + + llMedia.size()), // cOperations
16109	tr("Change encryption of the mediuma"));
16110	if (FAILED(hrc))
16111	return hrc;
16112
16113	/* create and start the task on a separate thread (note that it will not
16114	* start working until we release alock) */
16115	ChangeEncryptionTask *pTask = new ChangeEncryptionTask(this, pProgress, "VM encryption",
16116	aCurrentPassword, aCipher, aNewPassword,
16117	aNewPasswordId, aForce, llMedia);
16118	hrc = pTask->createThread();
16119	pTask = NULL;
16120	if (FAILED(hrc))
16121	return hrc;
16122
16123	pProgress.queryInterfaceTo(aProgress.asOutParam());
16124
16125	LogFlowFuncLeave();
16126
16127	return S_OK;
16128	#endif
16129	}
16130
16131	HRESULT Machine::getEncryptionSettings(com::Utf8Str &aCipher,
16132	com::Utf8Str &aPasswordId)
16133	{
16134	#ifndef VBOX_WITH_FULL_VM_ENCRYPTION
16135	RT_NOREF(aCipher, aPasswordId);
16136	return setError(VBOX_E_NOT_SUPPORTED, tr("Full VM encryption is not available with this build"));
16137	#else
16138	AutoLimitedCaller autoCaller(this);
16139	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
16140
16141	PCVBOXCRYPTOIF pCryptoIf = NULL;
16142	HRESULT hrc = mParent->i_retainCryptoIf(&pCryptoIf);
16143	if (FAILED(hrc)) return hrc; /* Error is set */
16144
16145	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
16146
16147	if (mData->mstrKeyStore.isNotEmpty())
16148	{
16149	char *pszCipher = NULL;
16150	int vrc = pCryptoIf->pfnCryptoKeyStoreGetDekFromEncoded(mData->mstrKeyStore.c_str(), NULL /pszPassword/,
16151	NULL /ppbKey/, NULL /pcbKey/, &pszCipher);
16152	if (RT_SUCCESS(vrc))
16153	{
16154	aCipher = getCipherStringWithoutMode(pszCipher);
16155	RTStrFree(pszCipher);
16156	aPasswordId = mData->mstrKeyId;
16157	}
16158	else
16159	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
16160	tr("Failed to query the encryption settings with %Rrc"),
16161	vrc);
16162	}
16163	else
16164	hrc = setError(VBOX_E_NOT_SUPPORTED, tr("This VM is not encrypted"));
16165
16166	mParent->i_releaseCryptoIf(pCryptoIf);
16167
16168	return hrc;
16169	#endif
16170	}
16171
16172	HRESULT Machine::checkEncryptionPassword(const com::Utf8Str &aPassword)
16173	{
16174	#ifndef VBOX_WITH_FULL_VM_ENCRYPTION
16175	RT_NOREF(aPassword);
16176	return setError(VBOX_E_NOT_SUPPORTED, tr("Full VM encryption is not available with this build"));
16177	#else
16178	AutoLimitedCaller autoCaller(this);
16179	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
16180
16181	PCVBOXCRYPTOIF pCryptoIf = NULL;
16182	HRESULT hrc = mParent->i_retainCryptoIf(&pCryptoIf);
16183	if (FAILED(hrc)) return hrc; /* Error is set */
16184
16185	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
16186
16187	if (mData->mstrKeyStore.isNotEmpty())
16188	{
16189	char *pszCipher = NULL;
16190	uint8_t *pbDek = NULL;
16191	size_t cbDek = 0;
16192	int vrc = pCryptoIf->pfnCryptoKeyStoreGetDekFromEncoded(mData->mstrKeyStore.c_str(), aPassword.c_str(),
16193	&pbDek, &cbDek, &pszCipher);
16194	if (RT_SUCCESS(vrc))
16195	{
16196	RTStrFree(pszCipher);
16197	RTMemSaferFree(pbDek, cbDek);
16198	}
16199	else
16200	hrc = setErrorBoth(VBOX_E_PASSWORD_INCORRECT, vrc,
16201	tr("The password supplied for the encrypted machine is incorrect"));
16202	}
16203	else
16204	hrc = setError(VBOX_E_NOT_SUPPORTED, tr("This VM is not encrypted"));
16205
16206	mParent->i_releaseCryptoIf(pCryptoIf);
16207
16208	return hrc;
16209	#endif
16210	}
16211
16212	HRESULT Machine::addEncryptionPassword(const com::Utf8Str &aId,
16213	const com::Utf8Str &aPassword)
16214	{
16215	#ifndef VBOX_WITH_FULL_VM_ENCRYPTION
16216	RT_NOREF(aId, aPassword);
16217	return setError(VBOX_E_NOT_SUPPORTED, tr("Full VM encryption is not available with this build"));
16218	#else
16219	AutoLimitedCaller autoCaller(this);
16220	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
16221
16222	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
16223
16224	size_t cbPassword = aPassword.length() + 1;
16225	uint8_t pbPassword = (uint8_t )aPassword.c_str();
16226
16227	mData->mpKeyStore->addSecretKey(aId, pbPassword, cbPassword);
16228
16229	if ( mData->mAccessible
16230	&& mData->mSession.mState == SessionState_Locked
16231	&& mData->mSession.mLockType == LockType_VM
16232	&& mData->mSession.mDirectControl != NULL)
16233	{
16234	/* get the console from the direct session */
16235	ComPtr<IConsole> console;
16236	HRESULT hrc = mData->mSession.mDirectControl->COMGETTER(RemoteConsole)(console.asOutParam());
16237	ComAssertComRC(hrc);
16238	/* send passsword to console */
16239	console->AddEncryptionPassword(Bstr(aId).raw(),
16240	Bstr(aPassword).raw(),
16241	TRUE);
16242	}
16243
16244	if (mData->mstrKeyId == aId)
16245	{
16246	HRESULT hrc = checkEncryptionPassword(aPassword);
16247	if (FAILED(hrc))
16248	return hrc;
16249
16250	if (SUCCEEDED(hrc))
16251	{
16252	/*
16253	* Encryption is used and password is correct,
16254	* Reinit the machine if required.
16255	*/
16256	BOOL fAccessible;
16257	alock.release();
16258	getAccessible(&fAccessible);
16259	alock.acquire();
16260	}
16261	}
16262
16263	/*
16264	* Add the password into the NvramStore only after
16265	* the machine becomes accessible and the NvramStore
16266	* contains key id and key store.
16267	*/
16268	if (mNvramStore.isNotNull())
16269	mNvramStore->i_addPassword(aId, aPassword);
16270
16271	return S_OK;
16272	#endif
16273	}
16274
16275	HRESULT Machine::addEncryptionPasswords(const std::vector<com::Utf8Str> &aIds,
16276	const std::vector<com::Utf8Str> &aPasswords)
16277	{
16278	#ifndef VBOX_WITH_FULL_VM_ENCRYPTION
16279	RT_NOREF(aIds, aPasswords);
16280	return setError(VBOX_E_NOT_SUPPORTED, tr("Full VM encryption is not available with this build"));
16281	#else
16282	if (aIds.size() != aPasswords.size())
16283	return setError(E_INVALIDARG, tr("Id and passwords arrays must have the same size"));
16284
16285	HRESULT hrc = S_OK;
16286	for (size_t i = 0; i < aIds.size() && SUCCEEDED(hrc); ++i)
16287	hrc = addEncryptionPassword(aIds[i], aPasswords[i]);
16288
16289	return hrc;
16290	#endif
16291	}
16292
16293	HRESULT Machine::removeEncryptionPassword(AutoCaller &autoCaller, const com::Utf8Str &aId)
16294	{
16295	#ifndef VBOX_WITH_FULL_VM_ENCRYPTION
16296	RT_NOREF(autoCaller, aId);
16297	return setError(VBOX_E_NOT_SUPPORTED, tr("Full VM encryption is not available with this build"));
16298	#else
16299	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
16300
16301	if ( mData->mAccessible
16302	&& mData->mSession.mState == SessionState_Locked
16303	&& mData->mSession.mLockType == LockType_VM
16304	&& mData->mSession.mDirectControl != NULL)
16305	{
16306	/* get the console from the direct session */
16307	ComPtr<IConsole> console;
16308	HRESULT hrc = mData->mSession.mDirectControl->COMGETTER(RemoteConsole)(console.asOutParam());
16309	ComAssertComRC(hrc);
16310	/* send passsword to console */
16311	console->RemoveEncryptionPassword(Bstr(aId).raw());
16312	}
16313
16314	if (mData->mAccessible && mData->mstrKeyStore.isNotEmpty() && mData->mstrKeyId == aId)
16315	{
16316	if (Global::IsOnlineOrTransient(mData->mMachineState))
16317	return setError(VBOX_E_INVALID_VM_STATE, tr("The machine is in online or transient state"));
16318	alock.release();
16319	autoCaller.release();
16320	/* return because all passwords are purged when machine becomes inaccessible; */
16321	return i_setInaccessible();
16322	}
16323
16324	if (mNvramStore.isNotNull())
16325	mNvramStore->i_removePassword(aId);
16326	mData->mpKeyStore->deleteSecretKey(aId);
16327	return S_OK;
16328	#endif
16329	}
16330
16331	HRESULT Machine::clearAllEncryptionPasswords(AutoCaller &autoCaller)
16332	{
16333	#ifndef VBOX_WITH_FULL_VM_ENCRYPTION
16334	RT_NOREF(autoCaller);
16335	return setError(VBOX_E_NOT_SUPPORTED, tr("Full VM encryption is not available with this build"));
16336	#else
16337	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
16338
16339	if (mData->mAccessible && mData->mstrKeyStore.isNotEmpty())
16340	{
16341	if (Global::IsOnlineOrTransient(mData->mMachineState))
16342	return setError(VBOX_E_INVALID_VM_STATE, tr("The machine is in online or transient state"));
16343	alock.release();
16344	autoCaller.release();
16345	/* return because all passwords are purged when machine becomes inaccessible; */
16346	return i_setInaccessible();
16347	}
16348
16349	mNvramStore->i_removeAllPasswords();
16350	mData->mpKeyStore->deleteAllSecretKeys(false, true);
16351	return S_OK;
16352	#endif
16353	}
16354
16355	#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
16356	HRESULT Machine::i_setInaccessible()
16357	{
16358	if (!mData->mAccessible)
16359	return S_OK;
16360
16361	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
16362	VirtualBox *pParent = mParent;
16363	com::Utf8Str strConfigFile = mData->m_strConfigFile;
16364	Guid id(i_getId());
16365
16366	alock.release();
16367
16368	uninit();
16369	HRESULT hrc = initFromSettings(pParent, strConfigFile, &id, com::Utf8Str());
16370
16371	alock.acquire();
16372	mParent->i_onMachineStateChanged(mData->mUuid, mData->mMachineState);
16373	return hrc;
16374	}
16375	#endif
16376
16377	/* This isn't handled entirely by the wrapper generator yet. */
16378	#ifdef VBOX_WITH_XPCOM
16379	NS_DECL_CLASSINFO(SessionMachine)
16380	NS_IMPL_THREADSAFE_ISUPPORTS2_CI(SessionMachine, IMachine, IInternalMachineControl)
16381
16382	NS_DECL_CLASSINFO(SnapshotMachine)
16383	NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SnapshotMachine, IMachine)
16384	#endif

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

source: vbox/trunk/src/VBox/Main/src-server/MachineImpl.cpp@ 104956

Download in other formats: