VirtualBoxImpl.cpp@ 14854

Last change on this file since 14854 was 14854, checked in by vboxsync, 16 years ago
Main: rip XML classes out of settings code and move them to independent files and new vboxxml namespace to make them useful outside of the settings context
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 137.9 KB

Line
1	/* $Id: VirtualBoxImpl.cpp 14854 2008-12-01 13:12:56Z vboxsync $ */
2
3	/** @file
4	* Implementation of IVirtualBox in VBoxSVC.
5	*/
6
7	/*
8	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*
18	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
19	* Clara, CA 95054 USA or visit http://www.sun.com if you need
20	* additional information or have any questions.
21	*/
22
23	#include "VirtualBoxImpl.h"
24
25	#include "Global.h"
26	#include "MachineImpl.h"
27	#include "HardDisk2Impl.h"
28	#include "MediumImpl.h"
29	#include "SharedFolderImpl.h"
30	#include "ProgressImpl.h"
31	#include "HostImpl.h"
32	#include "USBControllerImpl.h"
33	#include "SystemPropertiesImpl.h"
34	#include "GuestOSTypeImpl.h"
35	#include "Version.h"
36
37	#include "VirtualBoxXMLUtil.h"
38
39	#include "Logging.h"
40
41	#ifdef RT_OS_WINDOWS
42	# include "win/svchlp.h"
43	#endif
44
45	#include <stdio.h>
46	#include <stdlib.h>
47
48	#include <iprt/path.h>
49	#include <iprt/dir.h>
50	#include <iprt/file.h>
51	#include <iprt/string.h>
52	#include <iprt/uuid.h>
53	#include <iprt/thread.h>
54	#include <iprt/process.h>
55	#include <iprt/env.h>
56	#include <iprt/cpputils.h>
57
58	#include <VBox/err.h>
59	#include <VBox/param.h>
60	#include <VBox/VBoxHDD.h>
61	#include <VBox/VBoxHDD-new.h>
62	#include <VBox/version.h>
63	#include <package-generated.h>
64
65	#include <VBox/com/com.h>
66	#include <VBox/com/array.h>
67
68	#include <algorithm>
69	#include <set>
70	#include <memory> // for auto_ptr
71
72	#include <typeinfo>
73
74	// defines
75	/////////////////////////////////////////////////////////////////////////////
76
77	#define VBOX_GLOBAL_SETTINGS_FILE "VirtualBox.xml"
78
79	// globals
80	/////////////////////////////////////////////////////////////////////////////
81
82	static const char gDefaultGlobalConfig [] =
83	{
84	"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" RTFILE_LINEFEED
85	"<!-- Sun xVM VirtualBox Global Configuration -->" RTFILE_LINEFEED
86	"<VirtualBox xmlns=\"" VBOX_XML_NAMESPACE "\" "
87	"version=\"" VBOX_XML_VERSION_FULL "\">" RTFILE_LINEFEED
88	" <Global>"RTFILE_LINEFEED
89	" <MachineRegistry/>"RTFILE_LINEFEED
90	" <MediaRegistry/>"RTFILE_LINEFEED
91	" <USBDeviceFilters/>"RTFILE_LINEFEED
92	" <SystemProperties/>"RTFILE_LINEFEED
93	" </Global>"RTFILE_LINEFEED
94	"</VirtualBox>"RTFILE_LINEFEED
95	};
96
97	// static
98	Bstr VirtualBox::sVersion;
99
100	// static
101	ULONG VirtualBox::sRevision;
102
103	// static
104	Bstr VirtualBox::sPackageType;
105
106	// static
107	Bstr VirtualBox::sSettingsFormatVersion;
108
109	// constructor / destructor
110	/////////////////////////////////////////////////////////////////////////////
111
112	VirtualBox::VirtualBox()
113	: mAsyncEventThread (NIL_RTTHREAD)
114	, mAsyncEventQ (NULL)
115	{}
116
117	VirtualBox::~VirtualBox() {}
118
119	HRESULT VirtualBox::FinalConstruct()
120	{
121	LogFlowThisFunc (("\n"));
122
123	return init();
124	}
125
126	void VirtualBox::FinalRelease()
127	{
128	LogFlowThisFunc (("\n"));
129
130	uninit();
131	}
132
133	VirtualBox::Data::Data()
134	{
135	}
136
137	// public initializer/uninitializer for internal purposes only
138	/////////////////////////////////////////////////////////////////////////////
139
140	/**
141	* Initializes the VirtualBox object.
142	*
143	* @return COM result code
144	*/
145	HRESULT VirtualBox::init()
146	{
147	/* Enclose the state transition NotReady->InInit->Ready */
148	AutoInitSpan autoInitSpan (this);
149	AssertReturn (autoInitSpan.isOk(), E_FAIL);
150
151	LogFlow (("===========================================================\n"));
152	LogFlowThisFuncEnter();
153
154	if (sVersion.isNull())
155	sVersion = VBOX_VERSION_STRING;
156	sRevision = VBoxSVNRev();
157	if (sPackageType.isNull())
158	sPackageType = VBOX_PACKAGE_STRING;
159	LogFlowThisFunc (("Version: %ls, Package: %ls\n", sVersion.raw(), sPackageType.raw()));
160
161	if (sSettingsFormatVersion.isNull())
162	sSettingsFormatVersion = VBOX_XML_VERSION_FULL;
163	LogFlowThisFunc (("Settings Format Version: %ls\n",
164	sSettingsFormatVersion.raw()));
165
166	/* Get the VirtualBox home directory. */
167	{
168	char homeDir [RTPATH_MAX];
169	int vrc = com::GetVBoxUserHomeDirectory (homeDir, sizeof (homeDir));
170	if (RT_FAILURE (vrc))
171	return setError (E_FAIL,
172	tr ("Could not create the VirtualBox home directory '%s'"
173	"(%Rrc)"),
174	homeDir, vrc);
175
176	unconst (mData.mHomeDir) = homeDir;
177	}
178
179	/* compose the global config file name (always full path) */
180	Utf8StrFmt vboxConfigFile ("%s%c%s", mData.mHomeDir.raw(),
181	RTPATH_DELIMITER, VBOX_GLOBAL_SETTINGS_FILE);
182
183	/* store the config file name */
184	unconst (mData.mCfgFile.mName) = vboxConfigFile;
185
186	/* lock the config file */
187	HRESULT rc = lockConfig();
188	if (SUCCEEDED (rc))
189	{
190	if (!isConfigLocked())
191	{
192	/*
193	* This means the config file not found. This is not fatal --
194	* we just create an empty one.
195	*/
196	RTFILE handle = NIL_RTFILE;
197	int vrc = RTFileOpen (&handle, vboxConfigFile,
198	RTFILE_O_READWRITE \| RTFILE_O_CREATE \|
199	RTFILE_O_DENY_WRITE);
200	if (RT_SUCCESS (vrc))
201	vrc = RTFileWrite (handle,
202	(void *) gDefaultGlobalConfig,
203	sizeof (gDefaultGlobalConfig), NULL);
204	if (RT_FAILURE (vrc))
205	{
206	rc = setError (E_FAIL, tr ("Could not create the default settings file "
207	"'%s' (%Rrc)"),
208	vboxConfigFile.raw(), vrc);
209	}
210	else
211	{
212	mData.mCfgFile.mHandle = handle;
213	/* we do not close the file to simulate lockConfig() */
214	}
215	}
216	}
217
218	if (SUCCEEDED (rc))
219	{
220	try
221	{
222	using namespace settings;
223	using namespace vboxxml;
224
225	/* no concurrent file access is possible in init() so open by handle */
226	File file (mData.mCfgFile.mHandle, vboxConfigFile);
227	XmlTreeBackend tree;
228
229	rc = VirtualBox::loadSettingsTree_FirstTime (tree, file,
230	mData.mSettingsFileVersion);
231	CheckComRCThrowRC (rc);
232
233	Key global = tree.rootKey().key ("Global");
234
235	#ifdef VBOX_WITH_RESOURCE_USAGE_API
236	/* create the performance collector object BEFORE host */
237	unconst (mData.mPerformanceCollector).createObject();
238	rc = mData.mPerformanceCollector->init();
239	ComAssertComRCThrowRC (rc);
240	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
241
242	/* create the host object early, machines will need it */
243	unconst (mData.mHost).createObject();
244	rc = mData.mHost->init (this);
245	ComAssertComRCThrowRC (rc);
246
247	rc = mData.mHost->loadSettings (global);
248	CheckComRCThrowRC (rc);
249
250	/* create the system properties object, someone may need it too */
251	unconst (mData.mSystemProperties).createObject();
252	rc = mData.mSystemProperties->init (this);
253	ComAssertComRCThrowRC (rc);
254
255	rc = mData.mSystemProperties->loadSettings (global);
256	CheckComRCThrowRC (rc);
257
258	/* guest OS type objects, needed by machines */
259	for (size_t i = 0; i < RT_ELEMENTS (Global::sOSTypes); ++ i)
260	{
261	ComObjPtr <GuestOSType> guestOSTypeObj;
262	rc = guestOSTypeObj.createObject();
263	if (SUCCEEDED (rc))
264	{
265	rc = guestOSTypeObj->init (Global::sOSTypes [i].familyId,
266	Global::sOSTypes [i].familyDescription,
267	Global::sOSTypes [i].id,
268	Global::sOSTypes [i].description,
269	Global::sOSTypes [i].osType,
270	Global::sOSTypes [i].is64Bit,
271	Global::sOSTypes [i].recommendedIOAPIC,
272	Global::sOSTypes [i].recommendedVirtEx,
273	Global::sOSTypes [i].recommendedRAM,
274	Global::sOSTypes [i].recommendedVRAM,
275	Global::sOSTypes [i].recommendedHDD,
276	Global::sOSTypes [i].networkAdapterType);
277	if (SUCCEEDED (rc))
278	mData.mGuestOSTypes.push_back (guestOSTypeObj);
279	}
280	ComAssertComRCThrowRC (rc);
281	}
282
283	/* all registered media, needed by machines */
284	rc = loadMedia (global);
285	CheckComRCThrowRC (rc);
286
287	/* machines */
288	rc = loadMachines (global);
289	CheckComRCThrowRC (rc);
290
291	/* check hard disk consistency */
292	/// @todo (r=dmik) add IVirtualBox::cleanupHardDisks() instead or similar
293	// for (HardDiskList::const_iterator it = mData.mHardDisks.begin();
294	// it != mData.mHardDisks.end() && SUCCEEDED (rc);
295	// ++ it)
296	// {
297	// rc = (*it)->checkConsistency();
298	// }
299	// CheckComRCBreakRC ((rc));
300
301	/// @todo (dmik) if successful, check for orphan (unused) diffs
302	// that might be left because of the server crash, and remove
303	// Hmm, is it the same remark as above?..
304	}
305	catch (HRESULT err)
306	{
307	/* we assume that error info is set by the thrower */
308	rc = err;
309	}
310	catch (...)
311	{
312	rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
313	}
314	}
315
316	if (SUCCEEDED (rc))
317	{
318	/* start the client watcher thread */
319	#if defined(RT_OS_WINDOWS)
320	unconst (mWatcherData.mUpdateReq) = ::CreateEvent (NULL, FALSE, FALSE, NULL);
321	#elif defined(RT_OS_OS2)
322	RTSemEventCreate (&unconst (mWatcherData.mUpdateReq));
323	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
324	RTSemEventCreate (&unconst (mWatcherData.mUpdateReq));
325	#else
326	# error "Port me!"
327	#endif
328	int vrc = RTThreadCreate (&unconst (mWatcherData.mThread),
329	ClientWatcher, (void *) this,
330	0, RTTHREADTYPE_MAIN_WORKER,
331	RTTHREADFLAGS_WAITABLE, "Watcher");
332	ComAssertRC (vrc);
333	if (RT_FAILURE (vrc))
334	rc = E_FAIL;
335	}
336
337	if (SUCCEEDED (rc)) do
338	{
339	/* start the async event handler thread */
340	int vrc = RTThreadCreate (&unconst (mAsyncEventThread), AsyncEventHandler,
341	&unconst (mAsyncEventQ),
342	0, RTTHREADTYPE_MAIN_WORKER,
343	RTTHREADFLAGS_WAITABLE, "EventHandler");
344	ComAssertRCBreak (vrc, rc = E_FAIL);
345
346	/* wait until the thread sets mAsyncEventQ */
347	RTThreadUserWait (mAsyncEventThread, RT_INDEFINITE_WAIT);
348	ComAssertBreak (mAsyncEventQ, rc = E_FAIL);
349	}
350	while (0);
351
352	/* Confirm a successful initialization when it's the case */
353	if (SUCCEEDED (rc))
354	autoInitSpan.setSucceeded();
355
356	LogFlowThisFunc (("rc=%08X\n", rc));
357	LogFlowThisFuncLeave();
358	LogFlow (("===========================================================\n"));
359	return rc;
360	}
361
362	void VirtualBox::uninit()
363	{
364	/* Enclose the state transition Ready->InUninit->NotReady */
365	AutoUninitSpan autoUninitSpan (this);
366	if (autoUninitSpan.uninitDone())
367	return;
368
369	LogFlow (("===========================================================\n"));
370	LogFlowThisFuncEnter();
371	LogFlowThisFunc (("initFailed()=%d\n", autoUninitSpan.initFailed()));
372
373	/* tell all our child objects we've been uninitialized */
374
375	LogFlowThisFunc (("Uninitializing machines (%d)...\n", mData.mMachines.size()));
376	if (mData.mMachines.size())
377	{
378	MachineList::iterator it = mData.mMachines.begin();
379	while (it != mData.mMachines.end())
380	(*it++)->uninit();
381	mData.mMachines.clear();
382	}
383
384	/* Uninit all other children still referenced by clients (unregistered
385	* machines, hard disks, DVD/floppy images, server-side progress
386	* operations). */
387	uninitDependentChildren();
388
389	mData.mHardDisk2Map.clear();
390
391	mData.mFloppyImages2.clear();
392	mData.mDVDImages2.clear();
393	mData.mHardDisks2.clear();
394
395	mData.mProgressOperations.clear();
396
397	mData.mGuestOSTypes.clear();
398
399	/* Note that we release singleton children after we've all other children.
400	* In some cases this is important because these other children may use
401	* some resources of the singletons which would prevent them from
402	* uninitializing (as for example, mSystemProperties which owns
403	* HardDiskFormat objects which HardDisk2 objects refer to) */
404	if (mData.mSystemProperties)
405	{
406	mData.mSystemProperties->uninit();
407	unconst (mData.mSystemProperties).setNull();
408	}
409
410	if (mData.mHost)
411	{
412	mData.mHost->uninit();
413	unconst (mData.mHost).setNull();
414	}
415
416	#ifdef VBOX_WITH_RESOURCE_USAGE_API
417	if (mData.mPerformanceCollector)
418	{
419	mData.mPerformanceCollector->uninit();
420	unconst (mData.mPerformanceCollector).setNull();
421	}
422	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
423
424	/* unlock the config file */
425	unlockConfig();
426
427	LogFlowThisFunc (("Releasing callbacks...\n"));
428	if (mData.mCallbacks.size())
429	{
430	/* release all callbacks */
431	LogWarningFunc (("%d unregistered callbacks!\n",
432	mData.mCallbacks.size()));
433	mData.mCallbacks.clear();
434	}
435
436	LogFlowThisFunc (("Terminating the async event handler...\n"));
437	if (mAsyncEventThread != NIL_RTTHREAD)
438	{
439	/* signal to exit the event loop */
440	if (mAsyncEventQ->postEvent (NULL))
441	{
442	/*
443	* Wait for thread termination (only if we've successfully posted
444	* a NULL event!)
445	*/
446	int vrc = RTThreadWait (mAsyncEventThread, 60000, NULL);
447	if (RT_FAILURE (vrc))
448	LogWarningFunc (("RTThreadWait(%RTthrd) -> %Rrc\n",
449	mAsyncEventThread, vrc));
450	}
451	else
452	{
453	AssertMsgFailed (("postEvent(NULL) failed\n"));
454	RTThreadWait (mAsyncEventThread, 0, NULL);
455	}
456
457	unconst (mAsyncEventThread) = NIL_RTTHREAD;
458	unconst (mAsyncEventQ) = NULL;
459	}
460
461	LogFlowThisFunc (("Terminating the client watcher...\n"));
462	if (mWatcherData.mThread != NIL_RTTHREAD)
463	{
464	/* signal the client watcher thread */
465	updateClientWatcher();
466	/* wait for the termination */
467	RTThreadWait (mWatcherData.mThread, RT_INDEFINITE_WAIT, NULL);
468	unconst (mWatcherData.mThread) = NIL_RTTHREAD;
469	}
470	mWatcherData.mProcesses.clear();
471	#if defined(RT_OS_WINDOWS)
472	if (mWatcherData.mUpdateReq != NULL)
473	{
474	::CloseHandle (mWatcherData.mUpdateReq);
475	unconst (mWatcherData.mUpdateReq) = NULL;
476	}
477	#elif defined(RT_OS_OS2)
478	if (mWatcherData.mUpdateReq != NIL_RTSEMEVENT)
479	{
480	RTSemEventDestroy (mWatcherData.mUpdateReq);
481	unconst (mWatcherData.mUpdateReq) = NIL_RTSEMEVENT;
482	}
483	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
484	if (mWatcherData.mUpdateReq != NIL_RTSEMEVENT)
485	{
486	RTSemEventDestroy (mWatcherData.mUpdateReq);
487	unconst (mWatcherData.mUpdateReq) = NIL_RTSEMEVENT;
488	}
489	#else
490	# error "Port me!"
491	#endif
492	/* Unload plugin backends. */
493	VDShutdown();
494
495	LogFlowThisFuncLeave();
496	LogFlow (("===========================================================\n"));
497	}
498
499	// IVirtualBox properties
500	/////////////////////////////////////////////////////////////////////////////
501
502	STDMETHODIMP VirtualBox::COMGETTER(Version) (BSTR *aVersion)
503	{
504	if (!aVersion)
505	return E_INVALIDARG;
506
507	AutoCaller autoCaller (this);
508	CheckComRCReturnRC (autoCaller.rc());
509
510	sVersion.cloneTo (aVersion);
511	return S_OK;
512	}
513
514	STDMETHODIMP VirtualBox::COMGETTER(Revision) (ULONG *aRevision)
515	{
516	if (!aRevision)
517	return E_INVALIDARG;
518
519	AutoCaller autoCaller (this);
520	CheckComRCReturnRC (autoCaller.rc());
521
522	*aRevision = sRevision;
523	return S_OK;
524	}
525
526	STDMETHODIMP VirtualBox::COMGETTER(PackageType) (BSTR *aPackageType)
527	{
528	if (!aPackageType)
529	return E_INVALIDARG;
530
531	AutoCaller autoCaller (this);
532	CheckComRCReturnRC (autoCaller.rc());
533
534	sPackageType.cloneTo (aPackageType);
535	return S_OK;
536	}
537
538	STDMETHODIMP VirtualBox::COMGETTER(HomeFolder) (BSTR *aHomeFolder)
539	{
540	if (!aHomeFolder)
541	return E_POINTER;
542
543	AutoCaller autoCaller (this);
544	CheckComRCReturnRC (autoCaller.rc());
545
546	/* mHomeDir is const and doesn't need a lock */
547	mData.mHomeDir.cloneTo (aHomeFolder);
548	return S_OK;
549	}
550
551	STDMETHODIMP VirtualBox::COMGETTER(SettingsFilePath) (BSTR *aSettingsFilePath)
552	{
553	if (!aSettingsFilePath)
554	return E_INVALIDARG;
555
556	AutoCaller autoCaller (this);
557	CheckComRCReturnRC (autoCaller.rc());
558
559	/* mCfgFile.mName is const and doesn't need a lock */
560	mData.mCfgFile.mName.cloneTo (aSettingsFilePath);
561	return S_OK;
562	}
563
564	STDMETHODIMP VirtualBox::
565	COMGETTER(SettingsFileVersion) (BSTR *aSettingsFileVersion)
566	{
567	if (!aSettingsFileVersion)
568	return E_INVALIDARG;
569
570	AutoCaller autoCaller (this);
571	CheckComRCReturnRC (autoCaller.rc());
572
573	AutoReadLock alock (this);
574
575	mData.mSettingsFileVersion.cloneTo (aSettingsFileVersion);
576	return S_OK;
577	}
578
579	STDMETHODIMP VirtualBox::
580	COMGETTER(SettingsFormatVersion) (BSTR *aSettingsFormatVersion)
581	{
582	if (!aSettingsFormatVersion)
583	return E_INVALIDARG;
584
585	AutoCaller autoCaller (this);
586	CheckComRCReturnRC (autoCaller.rc());
587
588	sSettingsFormatVersion.cloneTo (aSettingsFormatVersion);
589	return S_OK;
590	}
591
592	STDMETHODIMP VirtualBox::COMGETTER(Host) (IHost **aHost)
593	{
594	if (!aHost)
595	return E_POINTER;
596
597	AutoCaller autoCaller (this);
598	CheckComRCReturnRC (autoCaller.rc());
599
600	/* mHost is const, no need to lock */
601	mData.mHost.queryInterfaceTo (aHost);
602	return S_OK;
603	}
604
605	STDMETHODIMP
606	VirtualBox::COMGETTER(SystemProperties) (ISystemProperties **aSystemProperties)
607	{
608	if (!aSystemProperties)
609	return E_POINTER;
610
611	AutoCaller autoCaller (this);
612	CheckComRCReturnRC (autoCaller.rc());
613
614	/* mSystemProperties is const, no need to lock */
615	mData.mSystemProperties.queryInterfaceTo (aSystemProperties);
616	return S_OK;
617	}
618
619	STDMETHODIMP
620	VirtualBox::COMGETTER(Machines2) (ComSafeArrayOut (IMachine *, aMachines))
621	{
622	if (ComSafeArrayOutIsNull (aMachines))
623	return E_POINTER;
624
625	AutoCaller autoCaller (this);
626	CheckComRCReturnRC (autoCaller.rc());
627
628	AutoReadLock alock (this);
629
630	SafeIfaceArray <IMachine> machines (mData.mMachines);
631	machines.detachTo (ComSafeArrayOutArg (aMachines));
632
633	return S_OK;
634	}
635
636	STDMETHODIMP VirtualBox::COMGETTER(HardDisks2) (ComSafeArrayOut (IHardDisk2 *, aHardDisks))
637	{
638	if (ComSafeArrayOutIsNull (aHardDisks))
639	return E_POINTER;
640
641	AutoCaller autoCaller (this);
642	CheckComRCReturnRC (autoCaller.rc());
643
644	AutoReadLock alock (this);
645
646	SafeIfaceArray <IHardDisk2> hardDisks (mData.mHardDisks2);
647	hardDisks.detachTo (ComSafeArrayOutArg (aHardDisks));
648
649	return S_OK;
650	}
651
652	STDMETHODIMP
653	VirtualBox::COMGETTER(DVDImages) (ComSafeArrayOut (IDVDImage2 *, aDVDImages))
654	{
655	if (ComSafeArrayOutIsNull (aDVDImages))
656	return E_POINTER;
657
658	AutoCaller autoCaller (this);
659	CheckComRCReturnRC (autoCaller.rc());
660
661	AutoReadLock alock (this);
662
663	SafeIfaceArray <IDVDImage2> images (mData.mDVDImages2);
664	images.detachTo (ComSafeArrayOutArg (aDVDImages));
665
666	return S_OK;
667	}
668
669	STDMETHODIMP
670	VirtualBox::COMGETTER(FloppyImages) (ComSafeArrayOut (IFloppyImage2 *, aFloppyImages))
671	{
672	if (ComSafeArrayOutIsNull (aFloppyImages))
673	return E_POINTER;
674
675	AutoCaller autoCaller (this);
676	CheckComRCReturnRC (autoCaller.rc());
677
678	AutoReadLock alock (this);
679
680	SafeIfaceArray <IFloppyImage2> images (mData.mFloppyImages2);
681	images.detachTo (ComSafeArrayOutArg (aFloppyImages));
682
683	return S_OK;
684	}
685
686	STDMETHODIMP VirtualBox::COMGETTER(ProgressOperations) (IProgressCollection **aOperations)
687	{
688	if (!aOperations)
689	return E_POINTER;
690
691	AutoCaller autoCaller (this);
692	CheckComRCReturnRC (autoCaller.rc());
693
694	ComObjPtr <ProgressCollection> collection;
695	collection.createObject();
696
697	/* protect mProgressOperations */
698	AutoReadLock safeLock (mSafeLock);
699
700	collection->init (mData.mProgressOperations);
701	collection.queryInterfaceTo (aOperations);
702
703	return S_OK;
704	}
705
706	STDMETHODIMP VirtualBox::COMGETTER(GuestOSTypes) (IGuestOSTypeCollection **aGuestOSTypes)
707	{
708	if (!aGuestOSTypes)
709	return E_POINTER;
710
711	AutoCaller autoCaller (this);
712	CheckComRCReturnRC (autoCaller.rc());
713
714	ComObjPtr <GuestOSTypeCollection> collection;
715	collection.createObject();
716
717	AutoReadLock alock (this);
718	collection->init (mData.mGuestOSTypes);
719	collection.queryInterfaceTo (aGuestOSTypes);
720
721	return S_OK;
722	}
723
724	STDMETHODIMP
725	VirtualBox::COMGETTER(SharedFolders) (ISharedFolderCollection **aSharedFolders)
726	{
727	if (!aSharedFolders)
728	return E_POINTER;
729
730	AutoCaller autoCaller (this);
731	CheckComRCReturnRC (autoCaller.rc());
732
733	return setError (E_NOTIMPL, "Not yet implemented");
734	}
735
736	STDMETHODIMP
737	VirtualBox::COMGETTER(PerformanceCollector) (IPerformanceCollector **aPerformanceCollector)
738	{
739	#ifdef VBOX_WITH_RESOURCE_USAGE_API
740	if (!aPerformanceCollector)
741	return E_POINTER;
742
743	AutoCaller autoCaller (this);
744	CheckComRCReturnRC (autoCaller.rc());
745
746	/* mPerformanceCollector is const, no need to lock */
747	mData.mPerformanceCollector.queryInterfaceTo (aPerformanceCollector);
748
749	return S_OK;
750	#else /* !VBOX_WITH_RESOURCE_USAGE_API */
751	ReturnComNotImplemented();
752	#endif /* !VBOX_WITH_RESOURCE_USAGE_API */
753	}
754
755	// IVirtualBox methods
756	/////////////////////////////////////////////////////////////////////////////
757
758	/** @note Locks mSystemProperties object for reading. */
759	STDMETHODIMP VirtualBox::CreateMachine (INPTR BSTR aName,
760	INPTR BSTR aOsTypeId,
761	INPTR BSTR aBaseFolder,
762	INPTR GUIDPARAM aId,
763	IMachine **aMachine)
764	{
765	LogFlowThisFuncEnter();
766
767	CheckComArgStrNotEmptyOrNull (aName);
768	CheckComArgOutPointerValid (aMachine);
769
770	AutoCaller autoCaller (this);
771	CheckComRCReturnRC (autoCaller.rc());
772
773	/* Compose the settings file name using the following scheme:
774	*
775	* <base_folder>/<machine_name>/<machine_name>.xml
776	*
777	* If a non-null and non-empty base folder is specified, the default
778	* machine folder will be used as a base folder.
779	*/
780	Bstr settingsFile = aBaseFolder;
781	if (settingsFile.isEmpty())
782	{
783	AutoReadLock propsLock (systemProperties());
784	/* we use the non-full folder value below to keep the path relative */
785	settingsFile = systemProperties()->defaultMachineFolder();
786	}
787	settingsFile = Utf8StrFmt ("%ls%c%ls%c%ls.xml",
788	settingsFile.raw(), RTPATH_DELIMITER,
789	aName, RTPATH_DELIMITER, aName);
790
791	HRESULT rc = E_FAIL;
792
793	/* create a new object */
794	ComObjPtr <Machine> machine;
795	rc = machine.createObject();
796	CheckComRCReturnRC (rc);
797
798	/* Create UUID if an empty one was specified. */
799	Guid id = aId;
800	if (id.isEmpty())
801	id.create();
802
803	/* Look for a GuestOSType object */
804	AssertMsg (mData.mGuestOSTypes.size() != 0,
805	("Guest OS types array must be filled"));
806
807	GuestOSType *osType = NULL;
808	if (aOsTypeId != NULL)
809	{
810	for (GuestOSTypeList::const_iterator it = mData.mGuestOSTypes.begin();
811	it != mData.mGuestOSTypes.end(); ++ it)
812	{
813	if ((*it)->id() == aOsTypeId)
814	{
815	osType = *it;
816	break;
817	}
818	}
819
820	if (osType == NULL)
821	return setError (VBOX_E_OBJECT_NOT_FOUND,
822	tr ("Guest OS type '%ls' is invalid"), aOsTypeId);
823	}
824
825	/* initialize the machine object */
826	rc = machine->init (this, settingsFile, Machine::Init_New, aName, osType,
827	TRUE /* aNameSync */, &id);
828	if (SUCCEEDED (rc))
829	{
830	/* set the return value */
831	rc = machine.queryInterfaceTo (aMachine);
832	AssertComRC (rc);
833	}
834
835	LogFlowThisFuncLeave();
836
837	return rc;
838	}
839
840	STDMETHODIMP VirtualBox::CreateLegacyMachine (INPTR BSTR aName,
841	INPTR BSTR aOsTypeId,
842	INPTR BSTR aSettingsFile,
843	INPTR GUIDPARAM aId,
844	IMachine **aMachine)
845	{
846	CheckComArgStrNotEmptyOrNull (aName);
847	CheckComArgStrNotEmptyOrNull (aSettingsFile);
848	CheckComArgOutPointerValid (aMachine);
849
850	AutoCaller autoCaller (this);
851	CheckComRCReturnRC (autoCaller.rc());
852
853	HRESULT rc = E_FAIL;
854
855	Utf8Str settingsFile = aSettingsFile;
856	/* append the default extension if none */
857	if (!RTPathHaveExt (settingsFile))
858	settingsFile = Utf8StrFmt ("%s.xml", settingsFile.raw());
859
860	/* create a new object */
861	ComObjPtr<Machine> machine;
862	rc = machine.createObject();
863	CheckComRCReturnRC (rc);
864
865	/* Create UUID if an empty one was specified. */
866	Guid id = aId;
867	if (id.isEmpty())
868	id.create();
869
870	/* Look for a GuestOSType object */
871	AssertMsg (mData.mGuestOSTypes.size() != 0,
872	("Guest OS types array must be filled"));
873
874	GuestOSType *osType = NULL;
875	if (aOsTypeId != NULL)
876	{
877	for (GuestOSTypeList::const_iterator it = mData.mGuestOSTypes.begin();
878	it != mData.mGuestOSTypes.end(); ++ it)
879	{
880	if ((*it)->id() == aOsTypeId)
881	{
882	osType = *it;
883	break;
884	}
885	}
886
887	if (osType == NULL)
888	return setError (VBOX_E_OBJECT_NOT_FOUND,
889	tr ("Guest OS type '%ls' is invalid"), aOsTypeId);
890	}
891
892	/* initialize the machine object */
893	rc = machine->init (this, Bstr (settingsFile), Machine::Init_New,
894	aName, osType, FALSE /* aNameSync */, &id);
895	if (SUCCEEDED (rc))
896	{
897	/* set the return value */
898	rc = machine.queryInterfaceTo (aMachine);
899	AssertComRC (rc);
900	}
901
902	return rc;
903	}
904
905	STDMETHODIMP VirtualBox::OpenMachine (INPTR BSTR aSettingsFile,
906	IMachine **aMachine)
907	{
908	/* null and empty strings are not allowed as path names */
909	if (!aSettingsFile \|\| !(*aSettingsFile))
910	return E_INVALIDARG;
911
912	if (!aMachine)
913	return E_POINTER;
914
915	AutoCaller autoCaller (this);
916	CheckComRCReturnRC (autoCaller.rc());
917
918	HRESULT rc = E_FAIL;
919
920	/* create a new object */
921	ComObjPtr<Machine> machine;
922	rc = machine.createObject();
923	if (SUCCEEDED (rc))
924	{
925	/* initialize the machine object */
926	rc = machine->init (this, aSettingsFile, Machine::Init_Existing);
927	if (SUCCEEDED (rc))
928	{
929	/* set the return value */
930	rc = machine.queryInterfaceTo (aMachine);
931	ComAssertComRC (rc);
932	}
933	}
934
935	return rc;
936	}
937
938	/** @note Locks objects! */
939	STDMETHODIMP VirtualBox::RegisterMachine (IMachine *aMachine)
940	{
941	if (!aMachine)
942	return E_INVALIDARG;
943
944	AutoCaller autoCaller (this);
945	CheckComRCReturnRC (autoCaller.rc());
946
947	HRESULT rc;
948
949	Bstr name;
950	rc = aMachine->COMGETTER(Name) (name.asOutParam());
951	CheckComRCReturnRC (rc);
952
953	/*
954	* we can safely cast child to Machine * here because only Machine
955	* implementations of IMachine can be among our children
956	*/
957	Machine machine = static_cast <Machine > (getDependentChild (aMachine));
958	if (!machine)
959	{
960	/*
961	* this machine was not created by CreateMachine()
962	* or opened by OpenMachine() or loaded during startup
963	*/
964	return setError (E_FAIL,
965	tr ("The machine named '%ls' is not created within this "
966	"VirtualBox instance"), name.raw());
967	}
968
969	AutoCaller machCaller (machine);
970	ComAssertComRCRetRC (machCaller.rc());
971
972	rc = registerMachine (machine);
973
974	/* fire an event */
975	if (SUCCEEDED (rc))
976	onMachineRegistered (machine->id(), TRUE);
977
978	return rc;
979	}
980
981	/** @note Locks objects! */
982	STDMETHODIMP VirtualBox::GetMachine (INPTR GUIDPARAM aId, IMachine **aMachine)
983	{
984	if (!aMachine)
985	return E_POINTER;
986
987	AutoCaller autoCaller (this);
988	CheckComRCReturnRC (autoCaller.rc());
989
990	ComObjPtr <Machine> machine;
991	HRESULT rc = findMachine (Guid (aId), true /* setError */, &machine);
992
993	/* the below will set aMachine to NULL if machine is null /
994	machine.queryInterfaceTo (aMachine);
995
996	return rc;
997	}
998
999	/** @note Locks this object for reading, then some machine objects for reading. */
1000	STDMETHODIMP VirtualBox::FindMachine (INPTR BSTR aName, IMachine **aMachine)
1001	{
1002	LogFlowThisFuncEnter();
1003	LogFlowThisFunc (("aName=\"%ls\", aMachine={%p}\n", aName, aMachine));
1004
1005	if (!aName)
1006	return E_INVALIDARG;
1007	if (!aMachine)
1008	return E_POINTER;
1009
1010	AutoCaller autoCaller (this);
1011	CheckComRCReturnRC (autoCaller.rc());
1012
1013	/* start with not found */
1014	ComObjPtr <Machine> machine;
1015	MachineList machines;
1016	{
1017	/* take a copy for safe iteration outside the lock */
1018	AutoReadLock alock (this);
1019	machines = mData.mMachines;
1020	}
1021
1022	for (MachineList::iterator it = machines.begin();
1023	!machine && it != machines.end();
1024	++ it)
1025	{
1026	AutoLimitedCaller machCaller (*it);
1027	AssertComRC (machCaller.rc());
1028
1029	/* skip inaccessible machines */
1030	if (machCaller.state() == Machine::Ready)
1031	{
1032	AutoReadLock machLock (*it);
1033	if ((*it)->name() == aName)
1034	machine = *it;
1035	}
1036	}
1037
1038	/* this will set (machine) to NULL if machineObj is null /
1039	machine.queryInterfaceTo (aMachine);
1040
1041	HRESULT rc = machine
1042	? S_OK
1043	: setError (E_INVALIDARG,
1044	tr ("Could not find a registered machine named '%ls'"), aName);
1045
1046	LogFlowThisFunc (("rc=%08X\n", rc));
1047	LogFlowThisFuncLeave();
1048
1049	return rc;
1050	}
1051
1052	/** @note Locks objects! */
1053	STDMETHODIMP VirtualBox::UnregisterMachine (INPTR GUIDPARAM aId,
1054	IMachine **aMachine)
1055	{
1056	Guid id = aId;
1057	if (id.isEmpty())
1058	return E_INVALIDARG;
1059
1060	AutoCaller autoCaller (this);
1061	CheckComRCReturnRC (autoCaller.rc());
1062
1063	AutoWriteLock alock (this);
1064
1065	ComObjPtr <Machine> machine;
1066
1067	HRESULT rc = findMachine (id, true /* setError */, &machine);
1068	CheckComRCReturnRC (rc);
1069
1070	rc = machine->trySetRegistered (FALSE);
1071	CheckComRCReturnRC (rc);
1072
1073	/* remove from the collection of registered machines */
1074	mData.mMachines.remove (machine);
1075
1076	/* save the global registry */
1077	rc = saveSettings();
1078
1079	/* return the unregistered machine to the caller */
1080	machine.queryInterfaceTo (aMachine);
1081
1082	/* fire an event */
1083	onMachineRegistered (id, FALSE);
1084
1085	return rc;
1086	}
1087
1088	STDMETHODIMP VirtualBox::CreateHardDisk2 (INPTR BSTR aFormat,
1089	INPTR BSTR aLocation,
1090	IHardDisk2 **aHardDisk)
1091	{
1092	CheckComArgStrNotEmptyOrNull (aFormat);
1093	CheckComArgOutPointerValid (aHardDisk);
1094
1095	AutoCaller autoCaller (this);
1096	CheckComRCReturnRC (autoCaller.rc());
1097
1098	/* we don't access non-const data members so no need to lock */
1099
1100	Bstr format = aFormat;
1101	if (format.isEmpty())
1102	{
1103	AutoReadLock propsLock (systemProperties());
1104	format = systemProperties()->defaultHardDiskFormat();
1105	}
1106
1107	HRESULT rc = E_FAIL;
1108
1109	ComObjPtr <HardDisk2> hardDisk;
1110	hardDisk.createObject();
1111	rc = hardDisk->init (this, format, aLocation);
1112
1113	if (SUCCEEDED (rc))
1114	hardDisk.queryInterfaceTo (aHardDisk);
1115
1116	return rc;
1117	}
1118
1119	STDMETHODIMP VirtualBox::OpenHardDisk2 (INPTR BSTR aLocation,
1120	IHardDisk2 **aHardDisk)
1121	{
1122	if (!aLocation)
1123	return E_INVALIDARG;
1124	if (!aHardDisk)
1125	return E_POINTER;
1126
1127	AutoCaller autoCaller (this);
1128	CheckComRCReturnRC (autoCaller.rc());
1129
1130	/* we don't access non-const data members so no need to lock */
1131
1132	HRESULT rc = E_FAIL;
1133
1134	ComObjPtr <HardDisk2> hardDisk;
1135	hardDisk.createObject();
1136	rc = hardDisk->init (this, aLocation);
1137
1138	if (SUCCEEDED (rc))
1139	{
1140	rc = registerHardDisk2 (hardDisk);
1141
1142	/* Note that it's important to call uninit() on failure to register
1143	* because the differencing hard disk would have been already associated
1144	* with the parent and this association needs to be broken. */
1145
1146	if (SUCCEEDED (rc))
1147	hardDisk.queryInterfaceTo (aHardDisk);
1148	else
1149	hardDisk->uninit();
1150	}
1151
1152	return rc;
1153	}
1154
1155	STDMETHODIMP VirtualBox::GetHardDisk2 (INPTR GUIDPARAM aId,
1156	IHardDisk2 **aHardDisk)
1157	{
1158	if (!aHardDisk)
1159	return E_POINTER;
1160
1161	AutoCaller autoCaller (this);
1162	CheckComRCReturnRC (autoCaller.rc());
1163
1164	Guid id = aId;
1165	ComObjPtr <HardDisk2> hardDisk;
1166	HRESULT rc = findHardDisk2 (&id, NULL, true /* setError */, &hardDisk);
1167
1168	/* the below will set aHardDisk to NULL if hardDisk is null /
1169	hardDisk.queryInterfaceTo (aHardDisk);
1170
1171	return rc;
1172	}
1173
1174	STDMETHODIMP VirtualBox::FindHardDisk2 (INPTR BSTR aLocation,
1175	IHardDisk2 **aHardDisk)
1176	{
1177	if (!aLocation)
1178	return E_INVALIDARG;
1179	if (!aHardDisk)
1180	return E_POINTER;
1181
1182	AutoCaller autoCaller (this);
1183	CheckComRCReturnRC (autoCaller.rc());
1184
1185	ComObjPtr <HardDisk2> hardDisk;
1186	HRESULT rc = findHardDisk2 (NULL, aLocation, true /* setError */, &hardDisk);
1187
1188	/* the below will set aHardDisk to NULL if hardDisk is null /
1189	hardDisk.queryInterfaceTo (aHardDisk);
1190
1191	return rc;
1192	}
1193
1194	/** @note Doesn't lock anything. */
1195	STDMETHODIMP VirtualBox::OpenDVDImage (INPTR BSTR aLocation, INPTR GUIDPARAM aId,
1196	IDVDImage2 **aDVDImage)
1197	{
1198	/* null and empty strings are not allowed as path names */
1199	if (!aLocation \|\| !(*aLocation))
1200	return E_INVALIDARG;
1201
1202	if (!aDVDImage)
1203	return E_POINTER;
1204
1205	AutoCaller autoCaller (this);
1206	CheckComRCReturnRC (autoCaller.rc());
1207
1208	HRESULT rc = E_FAIL;
1209
1210	Guid id = aId;
1211	/* generate an UUID if not specified */
1212	if (id.isEmpty())
1213	id.create();
1214
1215	ComObjPtr <DVDImage2> image;
1216	image.createObject();
1217	rc = image->init (this, aLocation, id);
1218	if (SUCCEEDED (rc))
1219	{
1220	rc = registerDVDImage (image);
1221
1222	if (SUCCEEDED (rc))
1223	image.queryInterfaceTo (aDVDImage);
1224	}
1225
1226	return rc;
1227	}
1228
1229	/** @note Locks objects! */
1230	STDMETHODIMP VirtualBox::GetDVDImage (INPTR GUIDPARAM aId, IDVDImage2 **aDVDImage)
1231	{
1232	if (!aDVDImage)
1233	return E_POINTER;
1234
1235	AutoCaller autoCaller (this);
1236	CheckComRCReturnRC (autoCaller.rc());
1237
1238	Guid id = aId;
1239	ComObjPtr <DVDImage2> image;
1240	HRESULT rc = findDVDImage2 (&id, NULL, true /* setError */, &image);
1241
1242	/* the below will set aDVDImage to NULL if image is null /
1243	image.queryInterfaceTo (aDVDImage);
1244
1245	return rc;
1246	}
1247
1248	/** @note Locks objects! */
1249	STDMETHODIMP VirtualBox::FindDVDImage (INPTR BSTR aLocation, IDVDImage2 **aDVDImage)
1250	{
1251	if (!aLocation)
1252	return E_INVALIDARG;
1253	if (!aDVDImage)
1254	return E_POINTER;
1255
1256	AutoCaller autoCaller (this);
1257	CheckComRCReturnRC (autoCaller.rc());
1258
1259	ComObjPtr <DVDImage2> image;
1260	HRESULT rc = findDVDImage2 (NULL, aLocation, true /* setError */, &image);
1261
1262	/* the below will set aDVDImage to NULL if dvd is null /
1263	image.queryInterfaceTo (aDVDImage);
1264
1265	return rc;
1266	}
1267
1268	/** @note Doesn't lock anything. */
1269	STDMETHODIMP VirtualBox::OpenFloppyImage (INPTR BSTR aLocation, INPTR GUIDPARAM aId,
1270	IFloppyImage2 **aFloppyImage)
1271	{
1272	/* null and empty strings are not allowed as path names */
1273	if (!aLocation \|\| !(*aLocation))
1274	return E_INVALIDARG;
1275
1276	if (!aFloppyImage)
1277	return E_POINTER;
1278
1279	AutoCaller autoCaller (this);
1280	CheckComRCReturnRC (autoCaller.rc());
1281
1282	HRESULT rc = E_FAIL;
1283
1284	Guid id = aId;
1285	/* generate an UUID if not specified */
1286	if (id.isEmpty())
1287	id.create();
1288
1289	ComObjPtr <FloppyImage2> image;
1290	image.createObject();
1291	rc = image->init (this, aLocation, id);
1292	if (SUCCEEDED (rc))
1293	{
1294	rc = registerFloppyImage (image);
1295
1296	if (SUCCEEDED (rc))
1297	image.queryInterfaceTo (aFloppyImage);
1298	}
1299
1300	return rc;
1301	}
1302
1303	/** @note Locks objects! */
1304	STDMETHODIMP VirtualBox::GetFloppyImage (INPTR GUIDPARAM aId,
1305	IFloppyImage2 **aFloppyImage)
1306	{
1307	if (!aFloppyImage)
1308	return E_POINTER;
1309
1310	AutoCaller autoCaller (this);
1311	CheckComRCReturnRC (autoCaller.rc());
1312
1313	Guid id = aId;
1314	ComObjPtr <FloppyImage2> image;
1315	HRESULT rc = findFloppyImage2 (&id, NULL, true /* setError */, &image);
1316
1317	/* the below will set aFloppyImage to NULL if image is null /
1318	image.queryInterfaceTo (aFloppyImage);
1319
1320	return rc;
1321	}
1322
1323	/** @note Locks objects! */
1324	STDMETHODIMP VirtualBox::FindFloppyImage (INPTR BSTR aLocation,
1325	IFloppyImage2 **aFloppyImage)
1326	{
1327	if (!aLocation)
1328	return E_INVALIDARG;
1329	if (!aFloppyImage)
1330	return E_POINTER;
1331
1332	AutoCaller autoCaller (this);
1333	CheckComRCReturnRC (autoCaller.rc());
1334
1335	ComObjPtr <FloppyImage2> image;
1336	HRESULT rc = findFloppyImage2 (NULL, aLocation, true /* setError */, &image);
1337
1338	/* the below will set aFloppyImage to NULL if img is null /
1339	image.queryInterfaceTo (aFloppyImage);
1340
1341	return rc;
1342	}
1343
1344	/** @note Locks this object for reading. */
1345	STDMETHODIMP VirtualBox::GetGuestOSType (INPTR BSTR aId, IGuestOSType **aType)
1346	{
1347	if (!aType)
1348	return E_INVALIDARG;
1349
1350	AutoCaller autoCaller (this);
1351	CheckComRCReturnRC (autoCaller.rc());
1352
1353	*aType = NULL;
1354
1355	AutoReadLock alock (this);
1356
1357	for (GuestOSTypeList::iterator it = mData.mGuestOSTypes.begin();
1358	it != mData.mGuestOSTypes.end();
1359	++ it)
1360	{
1361	const Bstr &typeId = (*it)->id();
1362	AssertMsg (!!typeId, ("ID must not be NULL"));
1363	if (typeId == aId)
1364	{
1365	(*it).queryInterfaceTo (aType);
1366	break;
1367	}
1368	}
1369
1370	return (*aType) ? S_OK :
1371	setError (E_INVALIDARG,
1372	tr ("'%ls' is not a valid Guest OS type"),
1373	aId);
1374	}
1375
1376	STDMETHODIMP
1377	VirtualBox::CreateSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath, BOOL aWritable)
1378	{
1379	if (!aName \|\| !aHostPath)
1380	return E_INVALIDARG;
1381
1382	AutoCaller autoCaller (this);
1383	CheckComRCReturnRC (autoCaller.rc());
1384
1385	return setError (E_NOTIMPL, "Not yet implemented");
1386	}
1387
1388	STDMETHODIMP VirtualBox::RemoveSharedFolder (INPTR BSTR aName)
1389	{
1390	if (!aName)
1391	return E_INVALIDARG;
1392
1393	AutoCaller autoCaller (this);
1394	CheckComRCReturnRC (autoCaller.rc());
1395
1396	return setError (E_NOTIMPL, "Not yet implemented");
1397	}
1398
1399	/**
1400	* @note Locks this object for reading.
1401	*/
1402	STDMETHODIMP VirtualBox::
1403	GetNextExtraDataKey (INPTR BSTR aKey, BSTR aNextKey, BSTR aNextValue)
1404	{
1405	if (!aNextKey)
1406	return E_POINTER;
1407
1408	AutoCaller autoCaller (this);
1409	CheckComRCReturnRC (autoCaller.rc());
1410
1411	/* start with nothing found */
1412	*aNextKey = NULL;
1413	if (aNextValue)
1414	*aNextValue = NULL;
1415
1416	HRESULT rc = S_OK;
1417
1418	/* serialize file access (prevent writes) */
1419	AutoReadLock alock (this);
1420
1421	try
1422	{
1423	using namespace settings;
1424	using namespace vboxxml;
1425
1426	/* load the settings file (we don't reuse the existing handle but
1427	* request a new one to allow for concurrent multi-threaded reads) */
1428	File file (File::Mode_Read, Utf8Str (mData.mCfgFile.mName));
1429	XmlTreeBackend tree;
1430
1431	rc = VirtualBox::loadSettingsTree_Again (tree, file);
1432	CheckComRCReturnRC (rc);
1433
1434	Key globalNode = tree.rootKey().key ("Global");
1435	Key extraDataNode = globalNode.findKey ("ExtraData");
1436
1437	if (!extraDataNode.isNull())
1438	{
1439	Key::List items = extraDataNode.keys ("ExtraDataItem");
1440	if (items.size())
1441	{
1442	for (Key::List::const_iterator it = items.begin();
1443	it != items.end(); ++ it)
1444	{
1445	Bstr key = (*it).stringValue ("name");
1446
1447	/* if we're supposed to return the first one */
1448	if (aKey == NULL)
1449	{
1450	key.cloneTo (aNextKey);
1451	if (aNextValue)
1452	{
1453	Bstr val = (*it).stringValue ("value");
1454	val.cloneTo (aNextValue);
1455	}
1456	return S_OK;
1457	}
1458
1459	/* did we find the key we're looking for? */
1460	if (key == aKey)
1461	{
1462	++ it;
1463	/* is there another item? */
1464	if (it != items.end())
1465	{
1466	Bstr key = (*it).stringValue ("name");
1467	key.cloneTo (aNextKey);
1468	if (aNextValue)
1469	{
1470	Bstr val = (*it).stringValue ("value");
1471	val.cloneTo (aNextValue);
1472	}
1473	}
1474	/* else it's the last one, arguments are already NULL */
1475	return S_OK;
1476	}
1477	}
1478	}
1479	}
1480
1481	/* Here we are when a) there are no items at all or b) there are items
1482	* but none of them equals to the requested non-NULL key. b) is an
1483	* error as well as a) if the key is non-NULL. When the key is NULL
1484	* (which is the case only when there are no items), we just fall
1485	* through to return NULLs and S_OK. */
1486
1487	if (aKey != NULL)
1488	return setError (E_FAIL,
1489	tr ("Could not find the extra data key '%ls'"), aKey);
1490	}
1491	catch (...)
1492	{
1493	rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
1494	}
1495
1496	return rc;
1497	}
1498
1499	/**
1500	* @note Locks this object for reading.
1501	*/
1502	STDMETHODIMP VirtualBox::GetExtraData (INPTR BSTR aKey, BSTR *aValue)
1503	{
1504	if (!aKey)
1505	return E_INVALIDARG;
1506	if (!aValue)
1507	return E_POINTER;
1508
1509	AutoCaller autoCaller (this);
1510	CheckComRCReturnRC (autoCaller.rc());
1511
1512	/* start with nothing found */
1513	*aValue = NULL;
1514
1515	HRESULT rc = S_OK;
1516
1517	/* serialize file access (prevent writes) */
1518	AutoReadLock alock (this);
1519
1520	try
1521	{
1522	using namespace settings;
1523	using namespace vboxxml;
1524
1525	/* load the settings file (we don't reuse the existing handle but
1526	* request a new one to allow for concurrent multi-threaded reads) */
1527	File file (File::Mode_Read, Utf8Str (mData.mCfgFile.mName));
1528	XmlTreeBackend tree;
1529
1530	rc = VirtualBox::loadSettingsTree_Again (tree, file);
1531	CheckComRCReturnRC (rc);
1532
1533	const Utf8Str key = aKey;
1534
1535	Key globalNode = tree.rootKey().key ("Global");
1536	Key extraDataNode = globalNode.findKey ("ExtraData");
1537
1538	if (!extraDataNode.isNull())
1539	{
1540	/* check if the key exists */
1541	Key::List items = extraDataNode.keys ("ExtraDataItem");
1542	for (Key::List::const_iterator it = items.begin();
1543	it != items.end(); ++ it)
1544	{
1545	if (key == (*it).stringValue ("name"))
1546	{
1547	Bstr val = (*it).stringValue ("value");
1548	val.cloneTo (aValue);
1549	break;
1550	}
1551	}
1552	}
1553	}
1554	catch (...)
1555	{
1556	rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
1557	}
1558
1559	return rc;
1560	}
1561
1562	/**
1563	* @note Locks this object for writing.
1564	*/
1565	STDMETHODIMP VirtualBox::SetExtraData (INPTR BSTR aKey, INPTR BSTR aValue)
1566	{
1567	if (!aKey)
1568	return E_INVALIDARG;
1569
1570	AutoCaller autoCaller (this);
1571	CheckComRCReturnRC (autoCaller.rc());
1572
1573	Guid emptyGuid;
1574
1575	bool changed = false;
1576	HRESULT rc = S_OK;
1577
1578	/* serialize file access (prevent concurrent reads and writes) */
1579	AutoWriteLock alock (this);
1580
1581	try
1582	{
1583	using namespace settings;
1584	using namespace vboxxml;
1585
1586	/* load the settings file */
1587	File file (mData.mCfgFile.mHandle, Utf8Str (mData.mCfgFile.mName));
1588	XmlTreeBackend tree;
1589
1590	rc = VirtualBox::loadSettingsTree_ForUpdate (tree, file);
1591	CheckComRCReturnRC (rc);
1592
1593	const Utf8Str key = aKey;
1594	Bstr oldVal;
1595
1596	Key globalNode = tree.rootKey().key ("Global");
1597	Key extraDataNode = globalNode.createKey ("ExtraData");
1598	Key extraDataItemNode;
1599
1600	Key::List items = extraDataNode.keys ("ExtraDataItem");
1601	for (Key::List::const_iterator it = items.begin();
1602	it != items.end(); ++ it)
1603	{
1604	if (key == (*it).stringValue ("name"))
1605	{
1606	extraDataItemNode = *it;
1607	oldVal = (*it).stringValue ("value");
1608	break;
1609	}
1610	}
1611
1612	/* When no key is found, oldVal is null */
1613	changed = oldVal != aValue;
1614
1615	if (changed)
1616	{
1617	/* ask for permission from all listeners */
1618	Bstr error;
1619	if (!onExtraDataCanChange (Guid::Empty, aKey, aValue, error))
1620	{
1621	const char *sep = error.isEmpty() ? "" : ": ";
1622	const BSTR err = error.isNull() ? (const BSTR) L"" : error.raw();
1623	LogWarningFunc (("Someone vetoed! Change refused%s%ls\n",
1624	sep, err));
1625	return setError (E_ACCESSDENIED,
1626	tr ("Could not set extra data because someone refused "
1627	"the requested change of '%ls' to '%ls'%s%ls"),
1628	aKey, aValue, sep, err);
1629	}
1630
1631	if (aValue != NULL)
1632	{
1633	if (extraDataItemNode.isNull())
1634	{
1635	extraDataItemNode = extraDataNode.appendKey ("ExtraDataItem");
1636	extraDataItemNode.setStringValue ("name", key);
1637	}
1638	extraDataItemNode.setStringValue ("value", Utf8Str (aValue));
1639	}
1640	else
1641	{
1642	/* an old value does for sure exist here (XML schema
1643	* guarantees that "value" may not absent in the
1644	* <ExtraDataItem> element) */
1645	Assert (!extraDataItemNode.isNull());
1646	extraDataItemNode.zap();
1647	}
1648
1649	/* save settings on success */
1650	rc = VirtualBox::saveSettingsTree (tree, file,
1651	mData.mSettingsFileVersion);
1652	CheckComRCReturnRC (rc);
1653	}
1654	}
1655	catch (...)
1656	{
1657	rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
1658	}
1659
1660	/* fire a notification */
1661	if (SUCCEEDED (rc) && changed)
1662	onExtraDataChange (Guid::Empty, aKey, aValue);
1663
1664	return rc;
1665	}
1666
1667	/**
1668	* @note Locks objects!
1669	*/
1670	STDMETHODIMP VirtualBox::OpenSession (ISession *aSession, INPTR GUIDPARAM aMachineId)
1671	{
1672	if (!aSession)
1673	return E_INVALIDARG;
1674
1675	AutoCaller autoCaller (this);
1676	CheckComRCReturnRC (autoCaller.rc());
1677
1678	Guid id = aMachineId;
1679	ComObjPtr <Machine> machine;
1680
1681	HRESULT rc = findMachine (id, true /* setError */, &machine);
1682	CheckComRCReturnRC (rc);
1683
1684	/* check the session state */
1685	SessionState_T state;
1686	rc = aSession->COMGETTER(State) (&state);
1687	CheckComRCReturnRC (rc);
1688
1689	if (state != SessionState_Closed)
1690	return setError (E_INVALIDARG,
1691	tr ("The given session is already open or being opened"));
1692
1693	/* get the IInternalSessionControl interface */
1694	ComPtr <IInternalSessionControl> control = aSession;
1695	ComAssertMsgRet (!!control, ("No IInternalSessionControl interface"),
1696	E_INVALIDARG);
1697
1698	rc = machine->openSession (control);
1699
1700	if (SUCCEEDED (rc))
1701	{
1702	/*
1703	* tell the client watcher thread to update the set of
1704	* machines that have open sessions
1705	*/
1706	updateClientWatcher();
1707
1708	/* fire an event */
1709	onSessionStateChange (aMachineId, SessionState_Open);
1710	}
1711
1712	return rc;
1713	}
1714
1715	/**
1716	* @note Locks objects!
1717	*/
1718	STDMETHODIMP VirtualBox::OpenRemoteSession (ISession *aSession,
1719	INPTR GUIDPARAM aMachineId,
1720	INPTR BSTR aType,
1721	INPTR BSTR aEnvironment,
1722	IProgress **aProgress)
1723	{
1724	if (!aSession \|\| !aType)
1725	return E_INVALIDARG;
1726	if (!aProgress)
1727	return E_POINTER;
1728
1729	AutoCaller autoCaller (this);
1730	CheckComRCReturnRC (autoCaller.rc());
1731
1732	Guid id = aMachineId;
1733	ComObjPtr <Machine> machine;
1734
1735	HRESULT rc = findMachine (id, true /* setError */, &machine);
1736	CheckComRCReturnRC (rc);
1737
1738	/* check the session state */
1739	SessionState_T state;
1740	rc = aSession->COMGETTER(State) (&state);
1741	CheckComRCReturnRC (rc);
1742
1743	if (state != SessionState_Closed)
1744	return setError (E_INVALIDARG,
1745	tr ("The given session is already open or being opened"));
1746
1747	/* get the IInternalSessionControl interface */
1748	ComPtr <IInternalSessionControl> control = aSession;
1749	ComAssertMsgRet (!!control, ("No IInternalSessionControl interface"),
1750	E_INVALIDARG);
1751
1752	/* create a progress object */
1753	ComObjPtr <Progress> progress;
1754	progress.createObject();
1755	progress->init (this, static_cast <IMachine *> (machine),
1756	Bstr (tr ("Spawning session")),
1757	FALSE /* aCancelable */);
1758
1759	rc = machine->openRemoteSession (control, aType, aEnvironment, progress);
1760
1761	if (SUCCEEDED (rc))
1762	{
1763	progress.queryInterfaceTo (aProgress);
1764
1765	/* signal the client watcher thread */
1766	updateClientWatcher();
1767
1768	/* fire an event */
1769	onSessionStateChange (aMachineId, SessionState_Spawning);
1770	}
1771
1772	return rc;
1773	}
1774
1775	/**
1776	* @note Locks objects!
1777	*/
1778	STDMETHODIMP VirtualBox::OpenExistingSession (ISession *aSession,
1779	INPTR GUIDPARAM aMachineId)
1780	{
1781	if (!aSession)
1782	return E_POINTER;
1783
1784	AutoCaller autoCaller (this);
1785	CheckComRCReturnRC (autoCaller.rc());
1786
1787	Guid id = aMachineId;
1788	ComObjPtr <Machine> machine;
1789
1790	HRESULT rc = findMachine (id, true /* setError */, &machine);
1791	CheckComRCReturnRC (rc);
1792
1793	/* check the session state */
1794	SessionState_T state;
1795	rc = aSession->COMGETTER(State) (&state);
1796	CheckComRCReturnRC (rc);
1797
1798	if (state != SessionState_Closed)
1799	return setError (E_INVALIDARG,
1800	tr ("The given session is already open or being opened"));
1801
1802	/* get the IInternalSessionControl interface */
1803	ComPtr <IInternalSessionControl> control = aSession;
1804	ComAssertMsgRet (!!control, ("No IInternalSessionControl interface"),
1805	E_INVALIDARG);
1806
1807	rc = machine->openExistingSession (control);
1808
1809	return rc;
1810	}
1811
1812	/**
1813	* @note Locks this object for writing.
1814	*/
1815	STDMETHODIMP VirtualBox::RegisterCallback (IVirtualBoxCallback *aCallback)
1816	{
1817	LogFlowThisFunc (("aCallback=%p\n", aCallback));
1818
1819	if (!aCallback)
1820	return E_INVALIDARG;
1821
1822	AutoCaller autoCaller (this);
1823	CheckComRCReturnRC (autoCaller.rc());
1824
1825	AutoWriteLock alock (this);
1826	mData.mCallbacks.push_back (CallbackList::value_type (aCallback));
1827
1828	return S_OK;
1829	}
1830
1831	/**
1832	* @note Locks this object for writing.
1833	*/
1834	STDMETHODIMP VirtualBox::UnregisterCallback (IVirtualBoxCallback *aCallback)
1835	{
1836	if (!aCallback)
1837	return E_INVALIDARG;
1838
1839	AutoCaller autoCaller (this);
1840	CheckComRCReturnRC (autoCaller.rc());
1841
1842	HRESULT rc = S_OK;
1843
1844	AutoWriteLock alock (this);
1845
1846	CallbackList::iterator it;
1847	it = std::find (mData.mCallbacks.begin(),
1848	mData.mCallbacks.end(),
1849	CallbackList::value_type (aCallback));
1850	if (it == mData.mCallbacks.end())
1851	rc = E_INVALIDARG;
1852	else
1853	mData.mCallbacks.erase (it);
1854
1855	LogFlowThisFunc (("aCallback=%p, rc=%08X\n", aCallback, rc));
1856	return rc;
1857	}
1858
1859	STDMETHODIMP VirtualBox::WaitForPropertyChange (INPTR BSTR aWhat, ULONG aTimeout,
1860	BSTR aChanged, BSTR aValues)
1861	{
1862	ReturnComNotImplemented();
1863	}
1864
1865	STDMETHODIMP VirtualBox::SaveSettings()
1866	{
1867	AutoCaller autoCaller (this);
1868	CheckComRCReturnRC (autoCaller.rc());
1869
1870	return saveSettings();
1871	}
1872
1873	STDMETHODIMP VirtualBox::SaveSettingsWithBackup (BSTR *aBakFileName)
1874	{
1875	if (!aBakFileName)
1876	return E_POINTER;
1877
1878	AutoCaller autoCaller (this);
1879	CheckComRCReturnRC (autoCaller.rc());
1880
1881	/* saveSettings() needs write lock */
1882	AutoWriteLock alock (this);
1883
1884	/* perform backup only when there was auto-conversion */
1885	if (mData.mSettingsFileVersion != VBOX_XML_VERSION_FULL)
1886	{
1887	Bstr bakFileName;
1888
1889	HRESULT rc = backupSettingsFile (mData.mCfgFile.mName,
1890	mData.mSettingsFileVersion,
1891	bakFileName);
1892	CheckComRCReturnRC (rc);
1893
1894	bakFileName.cloneTo (aBakFileName);
1895	}
1896
1897	return saveSettings();
1898	}
1899
1900	// public methods only for internal purposes
1901	/////////////////////////////////////////////////////////////////////////////
1902
1903	/**
1904	* Posts an event to the event queue that is processed asynchronously
1905	* on a dedicated thread.
1906	*
1907	* Posting events to the dedicated event queue is useful to perform secondary
1908	* actions outside any object locks -- for example, to iterate over a list
1909	* of callbacks and inform them about some change caused by some object's
1910	* method call.
1911	*
1912	* @param event event to post
1913	* (must be allocated using \|new\|, will be deleted automatically
1914	* by the event thread after processing)
1915	*
1916	* @note Doesn't lock any object.
1917	*/
1918	HRESULT VirtualBox::postEvent (Event *event)
1919	{
1920	AutoCaller autoCaller (this);
1921	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
1922
1923	if (autoCaller.state() != Ready)
1924	{
1925	LogWarningFunc (("VirtualBox has been uninitialized (state=%d), "
1926	"the event is discarded!\n",
1927	autoCaller.state()));
1928	return S_OK;
1929	}
1930
1931	AssertReturn (event, E_FAIL);
1932	AssertReturn (mAsyncEventQ, E_FAIL);
1933
1934	if (mAsyncEventQ->postEvent (event))
1935	return S_OK;
1936
1937	return E_FAIL;
1938	}
1939
1940	/**
1941	* Adds a progress to the global collection of pending operations.
1942	* Usually gets called upon progress object initialization.
1943	*
1944	* @param aProgress Operation to add to the collection.
1945	*
1946	* @note Doesn't lock objects.
1947	*/
1948	HRESULT VirtualBox::addProgress (IProgress *aProgress)
1949	{
1950	if (!aProgress)
1951	return E_INVALIDARG;
1952
1953	AutoCaller autoCaller (this);
1954	CheckComRCReturnRC (autoCaller.rc());
1955
1956	Guid id;
1957	HRESULT rc = aProgress->COMGETTER(Id) (id.asOutParam());
1958	AssertComRCReturnRC (rc);
1959
1960	/* protect mProgressOperations */
1961	AutoWriteLock safeLock (mSafeLock);
1962
1963	mData.mProgressOperations.insert (ProgressMap::value_type (id, aProgress));
1964	return S_OK;
1965	}
1966
1967	/**
1968	* Removes the progress from the global collection of pending operations.
1969	* Usually gets called upon progress completion.
1970	*
1971	* @param aId UUID of the progress operation to remove
1972	*
1973	* @note Doesn't lock objects.
1974	*/
1975	HRESULT VirtualBox::removeProgress (INPTR GUIDPARAM aId)
1976	{
1977	AutoCaller autoCaller (this);
1978	CheckComRCReturnRC (autoCaller.rc());
1979
1980	ComPtr <IProgress> progress;
1981
1982	/* protect mProgressOperations */
1983	AutoWriteLock safeLock (mSafeLock);
1984
1985	size_t cnt = mData.mProgressOperations.erase (aId);
1986	Assert (cnt == 1);
1987
1988	return S_OK;
1989	}
1990
1991	#ifdef RT_OS_WINDOWS
1992
1993	struct StartSVCHelperClientData
1994	{
1995	ComObjPtr <VirtualBox> that;
1996	ComObjPtr <Progress> progress;
1997	bool privileged;
1998	VirtualBox::SVCHelperClientFunc func;
1999	void *user;
2000	};
2001
2002	/**
2003	* Helper method to that starts a worker thread that:
2004	* - creates a pipe communication channel using SVCHlpClient;
2005	* - starts a SVC Helper process that will inherit this channel;
2006	* - executes the supplied function by passing it the created SVCHlpClient
2007	* and opened instance to communicate to the Helper process and the given
2008	* Progress object.
2009	*
2010	* The user function is supposed to communicate to the helper process
2011	* using the \a aClient argument to do the requested job and optionally expose
2012	* the progress through the \a aProgress object. The user function should never
2013	* call notifyComplete() on it: this will be done automatically using the
2014	* result code returned by the function.
2015	*
2016	* Before the user function is stared, the communication channel passed to in
2017	* the \a aClient argument, is fully set up, the function should start using
2018	* it's write() and read() methods directly.
2019	*
2020	* The \a aVrc parameter of the user function may be used to return an error
2021	* code if it is related to communication errors (for example, returned by
2022	* the SVCHlpClient members when they fail). In this case, the correct error
2023	* message using this value will be reported to the caller. Note that the
2024	* value of \a aVrc is inspected only if the user function itself returns
2025	* a success.
2026	*
2027	* If a failure happens anywhere before the user function would be normally
2028	* called, it will be called anyway in special "cleanup only" mode indicated
2029	* by \a aClient, \a aProgress and \aVrc arguments set to NULL. In this mode,
2030	* all the function is supposed to do is to cleanup its aUser argument if
2031	* necessary (it's assumed that the ownership of this argument is passed to
2032	* the user function once #startSVCHelperClient() returns a success, thus
2033	* making it responsible for the cleanup).
2034	*
2035	* After the user function returns, the thread will send the SVCHlpMsg::Null
2036	* message to indicate a process termination.
2037	*
2038	* @param aPrivileged \|true\| to start the SVC Helper process as a privileged
2039	* user that can perform administrative tasks
2040	* @param aFunc user function to run
2041	* @param aUser argument to the user function
2042	* @param aProgress progress object that will track operation completion
2043	*
2044	* @note aPrivileged is currently ignored (due to some unsolved problems in
2045	* Vista) and the process will be started as a normal (unprivileged)
2046	* process.
2047	*
2048	* @note Doesn't lock anything.
2049	*/
2050	HRESULT VirtualBox::startSVCHelperClient (bool aPrivileged,
2051	SVCHelperClientFunc aFunc,
2052	void aUser, Progress aProgress)
2053	{
2054	AssertReturn (aFunc, E_POINTER);
2055	AssertReturn (aProgress, E_POINTER);
2056
2057	AutoCaller autoCaller (this);
2058	CheckComRCReturnRC (autoCaller.rc());
2059
2060	/* create the SVCHelperClientThread() argument */
2061	std::auto_ptr <StartSVCHelperClientData>
2062	d (new StartSVCHelperClientData());
2063	AssertReturn (d.get(), E_OUTOFMEMORY);
2064
2065	d->that = this;
2066	d->progress = aProgress;
2067	d->privileged = aPrivileged;
2068	d->func = aFunc;
2069	d->user = aUser;
2070
2071	RTTHREAD tid = NIL_RTTHREAD;
2072	int vrc = RTThreadCreate (&tid, SVCHelperClientThread,
2073	static_cast <void *> (d.get()),
2074	0, RTTHREADTYPE_MAIN_WORKER,
2075	RTTHREADFLAGS_WAITABLE, "SVCHelper");
2076
2077	ComAssertMsgRCRet (vrc, ("Could not create SVCHelper thread (%Rrc)\n", vrc),
2078	E_FAIL);
2079
2080	/* d is now owned by SVCHelperClientThread(), so release it */
2081	d.release();
2082
2083	return S_OK;
2084	}
2085
2086	/**
2087	* Worker thread for startSVCHelperClient().
2088	*/
2089	/* static */
2090	DECLCALLBACK(int)
2091	VirtualBox::SVCHelperClientThread (RTTHREAD aThread, void *aUser)
2092	{
2093	LogFlowFuncEnter();
2094
2095	std::auto_ptr <StartSVCHelperClientData>
2096	d (static_cast <StartSVCHelperClientData *> (aUser));
2097
2098	HRESULT rc = S_OK;
2099	bool userFuncCalled = false;
2100
2101	do
2102	{
2103	AssertBreakStmt (d.get(), rc = E_POINTER);
2104	AssertReturn (!d->progress.isNull(), E_POINTER);
2105
2106	/* protect VirtualBox from uninitialization */
2107	AutoCaller autoCaller (d->that);
2108	if (!autoCaller.isOk())
2109	{
2110	/* it's too late */
2111	rc = autoCaller.rc();
2112	break;
2113	}
2114
2115	int vrc = VINF_SUCCESS;
2116
2117	Guid id;
2118	id.create();
2119	SVCHlpClient client;
2120	vrc = client.create (Utf8StrFmt ("VirtualBox\\SVCHelper\\{%RTuuid}",
2121	id.raw()));
2122	if (RT_FAILURE (vrc))
2123	{
2124	rc = setError (E_FAIL,
2125	tr ("Could not create the communication channel (%Rrc)"), vrc);
2126	break;
2127	}
2128
2129	/* get the path to the executable */
2130	char exePathBuf [RTPATH_MAX];
2131	char *exePath = RTProcGetExecutableName (exePathBuf, RTPATH_MAX);
2132	ComAssertBreak (exePath, E_FAIL);
2133
2134	Utf8Str argsStr = Utf8StrFmt ("/Helper %s", client.name().raw());
2135
2136	LogFlowFunc (("Starting '\"%s\" %s'...\n", exePath, argsStr.raw()));
2137
2138	RTPROCESS pid = NIL_RTPROCESS;
2139
2140	if (d->privileged)
2141	{
2142	/* Attempt to start a privileged process using the Run As dialog */
2143
2144	Bstr file = exePath;
2145	Bstr parameters = argsStr;
2146
2147	SHELLEXECUTEINFO shExecInfo;
2148
2149	shExecInfo.cbSize = sizeof (SHELLEXECUTEINFO);
2150
2151	shExecInfo.fMask = NULL;
2152	shExecInfo.hwnd = NULL;
2153	shExecInfo.lpVerb = L"runas";
2154	shExecInfo.lpFile = file;
2155	shExecInfo.lpParameters = parameters;
2156	shExecInfo.lpDirectory = NULL;
2157	shExecInfo.nShow = SW_NORMAL;
2158	shExecInfo.hInstApp = NULL;
2159
2160	if (!ShellExecuteEx (&shExecInfo))
2161	{
2162	int vrc2 = RTErrConvertFromWin32 (GetLastError());
2163	/* hide excessive details in case of a frequent error
2164	* (pressing the Cancel button to close the Run As dialog) */
2165	if (vrc2 == VERR_CANCELLED)
2166	rc = setError (E_FAIL,
2167	tr ("Operation cancelled by the user"));
2168	else
2169	rc = setError (E_FAIL,
2170	tr ("Could not launch a privileged process '%s' (%Rrc)"),
2171	exePath, vrc2);
2172	break;
2173	}
2174	}
2175	else
2176	{
2177	const char *args[] = { exePath, "/Helper", client.name(), 0 };
2178	vrc = RTProcCreate (exePath, args, RTENV_DEFAULT, 0, &pid);
2179	if (RT_FAILURE (vrc))
2180	{
2181	rc = setError (E_FAIL,
2182	tr ("Could not launch a process '%s' (%Rrc)"), exePath, vrc);
2183	break;
2184	}
2185	}
2186
2187	/* wait for the client to connect */
2188	vrc = client.connect();
2189	if (RT_SUCCESS (vrc))
2190	{
2191	/* start the user supplied function */
2192	rc = d->func (&client, d->progress, d->user, &vrc);
2193	userFuncCalled = true;
2194	}
2195
2196	/* send the termination signal to the process anyway */
2197	{
2198	int vrc2 = client.write (SVCHlpMsg::Null);
2199	if (RT_SUCCESS (vrc))
2200	vrc = vrc2;
2201	}
2202
2203	if (SUCCEEDED (rc) && RT_FAILURE (vrc))
2204	{
2205	rc = setError (E_FAIL,
2206	tr ("Could not operate the communication channel (%Rrc)"), vrc);
2207	break;
2208	}
2209	}
2210	while (0);
2211
2212	if (FAILED (rc) && !userFuncCalled)
2213	{
2214	/* call the user function in the "cleanup only" mode
2215	* to let it free resources passed to in aUser */
2216	d->func (NULL, NULL, d->user, NULL);
2217	}
2218
2219	d->progress->notifyComplete (rc);
2220
2221	LogFlowFuncLeave();
2222	return 0;
2223	}
2224
2225	#endif /* RT_OS_WINDOWS */
2226
2227	/**
2228	* Sends a signal to the client watcher thread to rescan the set of machines
2229	* that have open sessions.
2230	*
2231	* @note Doesn't lock anything.
2232	*/
2233	void VirtualBox::updateClientWatcher()
2234	{
2235	AutoCaller autoCaller (this);
2236	AssertComRCReturn (autoCaller.rc(), (void) 0);
2237
2238	AssertReturn (mWatcherData.mThread != NIL_RTTHREAD, (void) 0);
2239
2240	/* sent an update request */
2241	#if defined(RT_OS_WINDOWS)
2242	::SetEvent (mWatcherData.mUpdateReq);
2243	#elif defined(RT_OS_OS2)
2244	RTSemEventSignal (mWatcherData.mUpdateReq);
2245	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
2246	RTSemEventSignal (mWatcherData.mUpdateReq);
2247	#else
2248	# error "Port me!"
2249	#endif
2250	}
2251
2252	/**
2253	* Adds the given child process ID to the list of processes to be reaped.
2254	* This call should be followed by #updateClientWatcher() to take the effect.
2255	*/
2256	void VirtualBox::addProcessToReap (RTPROCESS pid)
2257	{
2258	AutoCaller autoCaller (this);
2259	AssertComRCReturn (autoCaller.rc(), (void) 0);
2260
2261	/// @todo (dmik) Win32?
2262	#ifndef RT_OS_WINDOWS
2263	AutoWriteLock alock (this);
2264	mWatcherData.mProcesses.push_back (pid);
2265	#endif
2266	}
2267
2268	/** Event for onMachineStateChange(), onMachineDataChange(), onMachineRegistered() */
2269	struct MachineEvent : public VirtualBox::CallbackEvent
2270	{
2271	enum What { DataChanged, StateChanged, Registered };
2272
2273	MachineEvent (VirtualBox *aVB, const Guid &aId)
2274	: CallbackEvent (aVB), what (DataChanged), id (aId)
2275	{}
2276
2277	MachineEvent (VirtualBox *aVB, const Guid &aId, MachineState_T aState)
2278	: CallbackEvent (aVB), what (StateChanged), id (aId)
2279	, state (aState)
2280	{}
2281
2282	MachineEvent (VirtualBox *aVB, const Guid &aId, BOOL aRegistered)
2283	: CallbackEvent (aVB), what (Registered), id (aId)
2284	, registered (aRegistered)
2285	{}
2286
2287	void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback)
2288	{
2289	switch (what)
2290	{
2291	case DataChanged:
2292	LogFlow (("OnMachineDataChange: id={%RTuuid}\n", id.ptr()));
2293	aCallback->OnMachineDataChange (id);
2294	break;
2295
2296	case StateChanged:
2297	LogFlow (("OnMachineStateChange: id={%RTuuid}, state=%d\n",
2298	id.ptr(), state));
2299	aCallback->OnMachineStateChange (id, state);
2300	break;
2301
2302	case Registered:
2303	LogFlow (("OnMachineRegistered: id={%RTuuid}, registered=%d\n",
2304	id.ptr(), registered));
2305	aCallback->OnMachineRegistered (id, registered);
2306	break;
2307	}
2308	}
2309
2310	const What what;
2311
2312	Guid id;
2313	MachineState_T state;
2314	BOOL registered;
2315	};
2316
2317	/**
2318	* @note Doesn't lock any object.
2319	*/
2320	void VirtualBox::onMachineStateChange (const Guid &aId, MachineState_T aState)
2321	{
2322	postEvent (new MachineEvent (this, aId, aState));
2323	}
2324
2325	/**
2326	* @note Doesn't lock any object.
2327	*/
2328	void VirtualBox::onMachineDataChange (const Guid &aId)
2329	{
2330	postEvent (new MachineEvent (this, aId));
2331	}
2332
2333	/**
2334	* @note Locks this object for reading.
2335	*/
2336	BOOL VirtualBox::onExtraDataCanChange (const Guid &aId, INPTR BSTR aKey, INPTR BSTR aValue,
2337	Bstr &aError)
2338	{
2339	LogFlowThisFunc (("machine={%s} aKey={%ls} aValue={%ls}\n",
2340	aId.toString().raw(), aKey, aValue));
2341
2342	AutoCaller autoCaller (this);
2343	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
2344
2345	CallbackList list;
2346	{
2347	AutoReadLock alock (this);
2348	list = mData.mCallbacks;
2349	}
2350
2351	BOOL allowChange = TRUE;
2352	CallbackList::iterator it = list.begin();
2353	while ((it != list.end()) && allowChange)
2354	{
2355	HRESULT rc = (*it++)->OnExtraDataCanChange (aId, aKey, aValue,
2356	aError.asOutParam(), &allowChange);
2357	if (FAILED (rc))
2358	{
2359	/* if a call to this method fails for some reason (for ex., because
2360	* the other side is dead), we ensure allowChange stays true
2361	* (MS COM RPC implementation seems to zero all output vars before
2362	* issuing an IPC call or after a failure, so it's essential
2363	* there) */
2364	allowChange = TRUE;
2365	}
2366	}
2367
2368	LogFlowThisFunc (("allowChange=%RTbool\n", allowChange));
2369	return allowChange;
2370	}
2371
2372	/** Event for onExtraDataChange() */
2373	struct ExtraDataEvent : public VirtualBox::CallbackEvent
2374	{
2375	ExtraDataEvent (VirtualBox *aVB, const Guid &aMachineId,
2376	INPTR BSTR aKey, INPTR BSTR aVal)
2377	: CallbackEvent (aVB), machineId (aMachineId)
2378	, key (aKey), val (aVal)
2379	{}
2380
2381	void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback)
2382	{
2383	LogFlow (("OnExtraDataChange: machineId={%RTuuid}, key='%ls', val='%ls'\n",
2384	machineId.ptr(), key.raw(), val.raw()));
2385	aCallback->OnExtraDataChange (machineId, key, val);
2386	}
2387
2388	Guid machineId;
2389	Bstr key, val;
2390	};
2391
2392	/**
2393	* @note Doesn't lock any object.
2394	*/
2395	void VirtualBox::onExtraDataChange (const Guid &aId, INPTR BSTR aKey, INPTR BSTR aValue)
2396	{
2397	postEvent (new ExtraDataEvent (this, aId, aKey, aValue));
2398	}
2399
2400	/**
2401	* @note Doesn't lock any object.
2402	*/
2403	void VirtualBox::onMachineRegistered (const Guid &aId, BOOL aRegistered)
2404	{
2405	postEvent (new MachineEvent (this, aId, aRegistered));
2406	}
2407
2408	/** Event for onSessionStateChange() */
2409	struct SessionEvent : public VirtualBox::CallbackEvent
2410	{
2411	SessionEvent (VirtualBox *aVB, const Guid &aMachineId, SessionState_T aState)
2412	: CallbackEvent (aVB), machineId (aMachineId), sessionState (aState)
2413	{}
2414
2415	void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback)
2416	{
2417	LogFlow (("OnSessionStateChange: machineId={%RTuuid}, sessionState=%d\n",
2418	machineId.ptr(), sessionState));
2419	aCallback->OnSessionStateChange (machineId, sessionState);
2420	}
2421
2422	Guid machineId;
2423	SessionState_T sessionState;
2424	};
2425
2426	/**
2427	* @note Doesn't lock any object.
2428	*/
2429	void VirtualBox::onSessionStateChange (const Guid &aId, SessionState_T aState)
2430	{
2431	postEvent (new SessionEvent (this, aId, aState));
2432	}
2433
2434	/** Event for onSnapshotTaken(), onSnapshotRemoved() and onSnapshotChange() */
2435	struct SnapshotEvent : public VirtualBox::CallbackEvent
2436	{
2437	enum What { Taken, Discarded, Changed };
2438
2439	SnapshotEvent (VirtualBox *aVB, const Guid &aMachineId, const Guid &aSnapshotId,
2440	What aWhat)
2441	: CallbackEvent (aVB)
2442	, what (aWhat)
2443	, machineId (aMachineId), snapshotId (aSnapshotId)
2444	{}
2445
2446	void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback)
2447	{
2448	switch (what)
2449	{
2450	case Taken:
2451	LogFlow (("OnSnapshotTaken: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
2452	machineId.ptr(), snapshotId.ptr()));
2453	aCallback->OnSnapshotTaken (machineId, snapshotId);
2454	break;
2455
2456	case Discarded:
2457	LogFlow (("OnSnapshotDiscarded: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
2458	machineId.ptr(), snapshotId.ptr()));
2459	aCallback->OnSnapshotDiscarded (machineId, snapshotId);
2460	break;
2461
2462	case Changed:
2463	LogFlow (("OnSnapshotChange: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
2464	machineId.ptr(), snapshotId.ptr()));
2465	aCallback->OnSnapshotChange (machineId, snapshotId);
2466	break;
2467	}
2468	}
2469
2470	const What what;
2471
2472	Guid machineId;
2473	Guid snapshotId;
2474	};
2475
2476	/**
2477	* @note Doesn't lock any object.
2478	*/
2479	void VirtualBox::onSnapshotTaken (const Guid &aMachineId, const Guid &aSnapshotId)
2480	{
2481	postEvent (new SnapshotEvent (this, aMachineId, aSnapshotId, SnapshotEvent::Taken));
2482	}
2483
2484	/**
2485	* @note Doesn't lock any object.
2486	*/
2487	void VirtualBox::onSnapshotDiscarded (const Guid &aMachineId, const Guid &aSnapshotId)
2488	{
2489	postEvent (new SnapshotEvent (this, aMachineId, aSnapshotId, SnapshotEvent::Discarded));
2490	}
2491
2492	/**
2493	* @note Doesn't lock any object.
2494	*/
2495	void VirtualBox::onSnapshotChange (const Guid &aMachineId, const Guid &aSnapshotId)
2496	{
2497	postEvent (new SnapshotEvent (this, aMachineId, aSnapshotId, SnapshotEvent::Changed));
2498	}
2499
2500	/** Event for onGuestPropertyChange() */
2501	struct GuestPropertyEvent : public VirtualBox::CallbackEvent
2502	{
2503	GuestPropertyEvent (VirtualBox *aVBox, const Guid &aMachineId,
2504	INPTR BSTR aName, INPTR BSTR aValue, INPTR BSTR aFlags)
2505	: CallbackEvent (aVBox), machineId (aMachineId)
2506	, name (aName), value (aValue), flags(aFlags)
2507	{}
2508
2509	void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback)
2510	{
2511	LogFlow (("OnGuestPropertyChange: machineId={%RTuuid}, name='%ls', value='%ls', flags='%ls'\n",
2512	machineId.ptr(), name.raw(), value.raw(), flags.raw()));
2513	aCallback->OnGuestPropertyChange (machineId, name, value, flags);
2514	}
2515
2516	Guid machineId;
2517	Bstr name, value, flags;
2518	};
2519
2520	/**
2521	* @note Doesn't lock any object.
2522	*/
2523	void VirtualBox::onGuestPropertyChange (const Guid &aMachineId, INPTR BSTR aName,
2524	INPTR BSTR aValue, INPTR BSTR aFlags)
2525	{
2526	postEvent (new GuestPropertyEvent (this, aMachineId, aName, aValue, aFlags));
2527	}
2528
2529	/**
2530	* @note Locks this object for reading.
2531	*/
2532	ComObjPtr <GuestOSType> VirtualBox::getUnknownOSType()
2533	{
2534	ComObjPtr <GuestOSType> type;
2535
2536	AutoCaller autoCaller (this);
2537	AssertComRCReturn (autoCaller.rc(), type);
2538
2539	AutoReadLock alock (this);
2540
2541	/* unknown type must always be the first */
2542	ComAssertRet (mData.mGuestOSTypes.size() > 0, type);
2543
2544	type = mData.mGuestOSTypes.front();
2545	return type;
2546	}
2547
2548	/**
2549	* Returns the list of opened machines (machines having direct sessions opened
2550	* by client processes) and optionally the list of direct session controls.
2551	*
2552	* @param aMachines Where to put opened machines (will be empty if none).
2553	* @param aControls Where to put direct session controls (optional).
2554	*
2555	* @note The returned lists contain smart pointers. So, clear it as soon as
2556	* it becomes no more necessary to release instances.
2557	*
2558	* @note It can be possible that a session machine from the list has been
2559	* already uninitialized, so do a usual AutoCaller/AutoReadLock sequence
2560	* when accessing unprotected data directly.
2561	*
2562	* @note Locks objects for reading.
2563	*/
2564	void VirtualBox::getOpenedMachines (SessionMachineVector &aMachines,
2565	InternalControlVector aControls /= NULL*/)
2566	{
2567	AutoCaller autoCaller (this);
2568	AssertComRCReturnVoid (autoCaller.rc());
2569
2570	aMachines.clear();
2571	if (aControls)
2572	aControls->clear();
2573
2574	AutoReadLock alock (this);
2575
2576	for (MachineList::iterator it = mData.mMachines.begin();
2577	it != mData.mMachines.end();
2578	++ it)
2579	{
2580	ComObjPtr <SessionMachine> sm;
2581	ComPtr <IInternalSessionControl> ctl;
2582	if ((*it)->isSessionOpen (sm, &ctl))
2583	{
2584	aMachines.push_back (sm);
2585	if (aControls)
2586	aControls->push_back (ctl);
2587	}
2588	}
2589	}
2590
2591	/**
2592	* Searches for a Machine object with the given ID in the collection
2593	* of registered machines.
2594	*
2595	* @param id
2596	* ID of the machine
2597	* @param doSetError
2598	* if TRUE, the appropriate error info is set in case when the machine
2599	* is not found
2600	* @param machine
2601	* where to store the found machine object (can be NULL)
2602	*
2603	* @return
2604	* S_OK when found or E_INVALIDARG when not found
2605	*
2606	* @note Locks this object for reading.
2607	*/
2608	HRESULT VirtualBox::findMachine (const Guid &aId, bool aSetError,
2609	ComObjPtr <Machine> aMachine / = NULL */)
2610	{
2611	AutoCaller autoCaller (this);
2612	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
2613
2614	bool found = false;
2615
2616	{
2617	AutoReadLock alock (this);
2618
2619	for (MachineList::iterator it = mData.mMachines.begin();
2620	!found && it != mData.mMachines.end();
2621	++ it)
2622	{
2623	/* sanity */
2624	AutoLimitedCaller machCaller (*it);
2625	AssertComRC (machCaller.rc());
2626
2627	found = (*it)->id() == aId;
2628	if (found && aMachine)
2629	aMachine = it;
2630	}
2631	}
2632
2633	HRESULT rc = found ? S_OK : E_INVALIDARG;
2634
2635	if (aSetError && !found)
2636	{
2637	setError (E_INVALIDARG,
2638	tr ("Could not find a registered machine with UUID {%RTuuid}"),
2639	aId.raw());
2640	}
2641
2642	return rc;
2643	}
2644
2645	/**
2646	* Searches for a HardDisk object with the given ID or location in the list of
2647	* registered hard disks. If both ID and location are specified, the first
2648	* object that matches either of them (not necessarily both) is returned.
2649	*
2650	* @param aId ID of the hard disk (unused when NULL).
2651	* @param aLocation Full location specification (unused NULL).
2652	* @param aSetError If @c true , the appropriate error info is set in case
2653	* when the hard disk is not found.
2654	* @param aHardDisk Where to store the found hard disk object (can be NULL).
2655	*
2656	* @return S_OK when found or E_INVALIDARG when not found.
2657	*
2658	* @note Locks this object and hard disk objects for reading.
2659	*/
2660	HRESULT VirtualBox::
2661	findHardDisk2 (const Guid *aId, const BSTR aLocation,
2662	bool aSetError, ComObjPtr <HardDisk2> aHardDisk /= NULL*/)
2663	{
2664	AssertReturn (aId \|\| aLocation, E_INVALIDARG);
2665
2666	AutoReadLock alock (this);
2667
2668	/* first, look up by UUID in the map if UUID is provided */
2669	if (aId)
2670	{
2671	HardDisk2Map::const_iterator it = mData.mHardDisk2Map.find (*aId);
2672	if (it != mData.mHardDisk2Map.end())
2673	{
2674	if (aHardDisk)
2675	aHardDisk = (it).second;
2676	return S_OK;
2677	}
2678	}
2679
2680	/* then iterate and search by location */
2681	int result = -1;
2682	if (aLocation)
2683	{
2684	Utf8Str location = aLocation;
2685
2686	for (HardDisk2Map::const_iterator it = mData.mHardDisk2Map.begin();
2687	it != mData.mHardDisk2Map.end();
2688	++ it)
2689	{
2690	const ComObjPtr <HardDisk2> &hd = (*it).second;
2691
2692	HRESULT rc = hd->compareLocationTo (location, result);
2693	CheckComRCReturnRC (rc);
2694
2695	if (result == 0)
2696	{
2697	if (aHardDisk)
2698	*aHardDisk = hd;
2699	break;
2700	}
2701	}
2702	}
2703
2704	HRESULT rc = result == 0 ? S_OK : E_INVALIDARG;
2705
2706	if (aSetError && result != 0)
2707	{
2708	if (aId)
2709	setError (rc, tr ("Could not find a hard disk with UUID {%RTuuid} "
2710	"in the media registry ('%ls')"),
2711	aId->raw(), mData.mCfgFile.mName.raw());
2712	else
2713	setError (rc, tr ("Could not find a hard disk with location '%ls' "
2714	"in the media registry ('%ls')"),
2715	aLocation, mData.mCfgFile.mName.raw());
2716	}
2717
2718	return rc;
2719	}
2720
2721	/**
2722	* Searches for a DVDImage2 object with the given ID or location in the list of
2723	* registered DVD images. If both ID and file path are specified, the first
2724	* object that matches either of them (not necessarily both) is returned.
2725	*
2726	* @param aId ID of the DVD image (unused when NULL).
2727	* @param aLocation Full path to the image file (unused when NULL).
2728	* @param aSetError If @c true, the appropriate error info is set in case when
2729	* the image is not found.
2730	* @param aImage Where to store the found image object (can be NULL).
2731	*
2732	* @return S_OK when found or E_INVALIDARG when not found.
2733	*
2734	* @note Locks this object and image objects for reading.
2735	*/
2736	HRESULT VirtualBox::findDVDImage2 (const Guid *aId, const BSTR aLocation,
2737	bool aSetError,
2738	ComObjPtr <DVDImage2> aImage / = NULL */)
2739	{
2740	AssertReturn (aId \|\| aLocation, E_INVALIDARG);
2741
2742	Utf8Str location;
2743
2744	if (aLocation != NULL)
2745	{
2746	int vrc = calculateFullPath (Utf8Str (aLocation), location);
2747	if (RT_FAILURE (vrc))
2748	return setError (E_FAIL,
2749	tr ("Invalid image file location '%ls' (%Rrc)"),
2750	aLocation, vrc);
2751	}
2752
2753	AutoReadLock alock (this);
2754
2755	bool found = false;
2756
2757	for (DVDImage2List::const_iterator it = mData.mDVDImages2.begin();
2758	it != mData.mDVDImages2.end();
2759	++ it)
2760	{
2761	/* no AutoCaller, registered image life time is bound to this */
2762	AutoReadLock imageLock (*it);
2763
2764	found = (aId && (it)->id() == aId) \|\|
2765	(aLocation != NULL &&
2766	RTPathCompare (location, Utf8Str ((*it)->locationFull())) == 0);
2767	if (found)
2768	{
2769	if (aImage)
2770	aImage = it;
2771	break;
2772	}
2773	}
2774
2775	HRESULT rc = found ? S_OK : E_INVALIDARG;
2776
2777	if (aSetError && !found)
2778	{
2779	if (aId)
2780	setError (rc, tr ("Could not find a CD/DVD image with UUID {%RTuuid} "
2781	"in the media registry ('%ls')"),
2782	aId->raw(), mData.mCfgFile.mName.raw());
2783	else
2784	setError (rc, tr ("Could not find a CD/DVD image with location '%ls' "
2785	"in the media registry ('%ls')"),
2786	aLocation, mData.mCfgFile.mName.raw());
2787	}
2788
2789	return rc;
2790	}
2791
2792	/**
2793	* Searches for a FloppyImage2 object with the given ID or location in the
2794	* collection of registered DVD images. If both ID and file path are specified,
2795	* the first object that matches either of them (not necessarily both) is
2796	* returned.
2797	*
2798	* @param aId ID of the DVD image (unused when NULL).
2799	* @param aLocation Full path to the image file (unused when NULL).
2800	* @param aSetError If @c true, the appropriate error info is set in case when
2801	* the image is not found.
2802	* @param aImage Where to store the found image object (can be NULL).
2803	*
2804	* @return S_OK when found or E_INVALIDARG when not found.
2805	*
2806	* @note Locks this object and image objects for reading.
2807	*/
2808	HRESULT VirtualBox::findFloppyImage2 (const Guid *aId, const BSTR aLocation,
2809	bool aSetError,
2810	ComObjPtr <FloppyImage2> aImage / = NULL */)
2811	{
2812	AssertReturn (aId \|\| aLocation, E_INVALIDARG);
2813
2814	Utf8Str location;
2815
2816	if (aLocation != NULL)
2817	{
2818	int vrc = calculateFullPath (Utf8Str (aLocation), location);
2819	if (RT_FAILURE (vrc))
2820	return setError (E_FAIL,
2821	tr ("Invalid image file location '%ls' (%Rrc)"),
2822	aLocation, vrc);
2823	}
2824
2825	AutoReadLock alock (this);
2826
2827	bool found = false;
2828
2829	for (FloppyImage2List::const_iterator it = mData.mFloppyImages2.begin();
2830	it != mData.mFloppyImages2.end();
2831	++ it)
2832	{
2833	/* no AutoCaller, registered image life time is bound to this */
2834	AutoReadLock imageLock (*it);
2835
2836	found = (aId && (it)->id() == aId) \|\|
2837	(aLocation != NULL &&
2838	RTPathCompare (location, Utf8Str ((*it)->locationFull())) == 0);
2839	if (found)
2840	{
2841	if (aImage)
2842	aImage = it;
2843	break;
2844	}
2845	}
2846
2847	HRESULT rc = found ? S_OK : E_INVALIDARG;
2848
2849	if (aSetError && !found)
2850	{
2851	if (aId)
2852	setError (rc, tr ("Could not find a floppy image with UUID {%RTuuid} "
2853	"in the media registry ('%ls')"),
2854	aId->raw(), mData.mCfgFile.mName.raw());
2855	else
2856	setError (rc, tr ("Could not find a floppy image with location '%ls' "
2857	"in the media registry ('%ls')"),
2858	aLocation, mData.mCfgFile.mName.raw());
2859	}
2860
2861	return rc;
2862	}
2863
2864	/**
2865	* Calculates the absolute path of the given path taking the VirtualBox home
2866	* directory as the current directory.
2867	*
2868	* @param aPath Path to calculate the absolute path for.
2869	* @param aResult Where to put the result (used only on success, can be the
2870	* same Utf8Str instance as passed in @a aPath).
2871	* @return IPRT result.
2872	*
2873	* @note Doesn't lock any object.
2874	*/
2875	int VirtualBox::calculateFullPath (const char *aPath, Utf8Str &aResult)
2876	{
2877	AutoCaller autoCaller (this);
2878	AssertComRCReturn (autoCaller.rc(), VERR_GENERAL_FAILURE);
2879
2880	/* no need to lock since mHomeDir is const */
2881
2882	char folder [RTPATH_MAX];
2883	int vrc = RTPathAbsEx (mData.mHomeDir, aPath, folder, sizeof (folder));
2884	if (RT_SUCCESS (vrc))
2885	aResult = folder;
2886
2887	return vrc;
2888	}
2889
2890	/**
2891	* Tries to calculate the relative path of the given absolute path using the
2892	* directory of the VirtualBox settings file as the base directory.
2893	*
2894	* @param aPath Absolute path to calculate the relative path for.
2895	* @param aResult Where to put the result (used only when it's possible to
2896	* make a relative path from the given absolute path; otherwise
2897	* left untouched).
2898	*
2899	* @note Doesn't lock any object.
2900	*/
2901	void VirtualBox::calculateRelativePath (const char *aPath, Utf8Str &aResult)
2902	{
2903	AutoCaller autoCaller (this);
2904	AssertComRCReturnVoid (autoCaller.rc());
2905
2906	/* no need to lock since mHomeDir is const */
2907
2908	Utf8Str settingsDir = mData.mHomeDir;
2909
2910	if (RTPathStartsWith (aPath, settingsDir))
2911	{
2912	/* when assigning, we create a separate Utf8Str instance because both
2913	* aPath and aResult can point to the same memory location when this
2914	* func is called (if we just do aResult = aPath, aResult will be freed
2915	* first, and since its the same as aPath, an attempt to copy garbage
2916	* will be made. */
2917	aResult = Utf8Str (aPath + settingsDir.length() + 1);
2918	}
2919	}
2920
2921	// private methods
2922	/////////////////////////////////////////////////////////////////////////////
2923
2924	/**
2925	* Checks if there is a hard disk, DVD or floppy image with the given ID or
2926	* location already registered.
2927	*
2928	* On return, sets @aConflict to the string describing the conflicting medium,
2929	* or sets it to @c Null if no conflicting media is found. Returns S_OK in
2930	* either case. A failure is unexpected.
2931	*
2932	* @param aId UUID to check.
2933	* @param aLocation Location to check.
2934	* @param aConflict Where to return parameters of the conflicting medium.
2935	*
2936	* @note Locks this object and media objects for reading.
2937	*/
2938	HRESULT VirtualBox::checkMediaForConflicts2 (const Guid &aId,
2939	const Bstr &aLocation,
2940	Utf8Str &aConflict)
2941	{
2942	aConflict.setNull();
2943
2944	AssertReturn (!aId.isEmpty() && !aLocation.isEmpty(), E_FAIL);
2945
2946	AutoReadLock alock (this);
2947
2948	HRESULT rc = S_OK;
2949
2950	{
2951	ComObjPtr <HardDisk2> hardDisk;
2952	rc = findHardDisk2 (&aId, aLocation, false /* aSetError */, &hardDisk);
2953	if (SUCCEEDED (rc))
2954	{
2955	/* Note: no AutoCaller since bound to this */
2956	AutoReadLock mediaLock (hardDisk);
2957	aConflict = Utf8StrFmt (
2958	tr ("hard disk '%ls' with UUID {%RTuuid}"),
2959	hardDisk->locationFull().raw(), hardDisk->id().raw());
2960	return S_OK;
2961	}
2962	}
2963
2964	{
2965	ComObjPtr <DVDImage2> image;
2966	rc = findDVDImage2 (&aId, aLocation, false /* aSetError */, &image);
2967	if (SUCCEEDED (rc))
2968	{
2969	/* Note: no AutoCaller since bound to this */
2970	AutoReadLock mediaLock (image);
2971	aConflict = Utf8StrFmt (
2972	tr ("CD/DVD image '%ls' with UUID {%RTuuid}"),
2973	image->locationFull().raw(), image->id().raw());
2974	return S_OK;
2975	}
2976	}
2977
2978	{
2979	ComObjPtr <FloppyImage2> image;
2980	rc = findFloppyImage2 (&aId, aLocation, false /* aSetError */, &image);
2981	if (SUCCEEDED (rc))
2982	{
2983	/* Note: no AutoCaller since bound to this */
2984	AutoReadLock mediaLock (image);
2985	aConflict = Utf8StrFmt (
2986	tr ("floppy image '%ls' with UUID {%RTuuid}"),
2987	image->locationFull().raw(), image->id().raw());
2988	return S_OK;
2989	}
2990	}
2991
2992	return S_OK;
2993	}
2994
2995	/**
2996	* Reads in the machine definitions from the configuration loader
2997	* and creates the relevant objects.
2998	*
2999	* @param aGlobal <Global> node.
3000	*
3001	* @note Can be called only from #init().
3002	* @note Doesn't lock anything.
3003	*/
3004	HRESULT VirtualBox::loadMachines (const settings::Key &aGlobal)
3005	{
3006	using namespace settings;
3007
3008	AutoCaller autoCaller (this);
3009	AssertReturn (autoCaller.state() == InInit, E_FAIL);
3010
3011	HRESULT rc = S_OK;
3012
3013	Key::List machines = aGlobal.key ("MachineRegistry").keys ("MachineEntry");
3014	for (Key::List::const_iterator it = machines.begin();
3015	it != machines.end(); ++ it)
3016	{
3017	/* required */
3018	Guid uuid = (*it).value <Guid> ("uuid");
3019	/* required */
3020	Bstr src = (*it).stringValue ("src");
3021
3022	/* create a new machine object */
3023	ComObjPtr <Machine> machine;
3024	rc = machine.createObject();
3025	if (SUCCEEDED (rc))
3026	{
3027	/* initialize the machine object and register it */
3028	rc = machine->init (this, src, Machine::Init_Registered,
3029	NULL, NULL, FALSE, &uuid);
3030	if (SUCCEEDED (rc))
3031	rc = registerMachine (machine);
3032	}
3033	}
3034
3035	return rc;
3036	}
3037
3038	/**
3039	* Reads in the media registration entries from the global settings file
3040	* and creates the relevant objects.
3041	*
3042	* @param aGlobal <Global> node
3043	*
3044	* @note Can be called only from #init().
3045	* @note Doesn't lock anything.
3046	*/
3047	HRESULT VirtualBox::loadMedia (const settings::Key &aGlobal)
3048	{
3049	using namespace settings;
3050
3051	AutoCaller autoCaller (this);
3052	AssertReturn (autoCaller.state() == InInit, E_FAIL);
3053
3054	HRESULT rc = S_OK;
3055
3056	Key registry = aGlobal.key ("MediaRegistry");
3057
3058	const char *kMediaNodes[] = { "HardDisks", "DVDImages", "FloppyImages" };
3059
3060	for (size_t n = 0; n < RT_ELEMENTS (kMediaNodes); ++ n)
3061	{
3062	/* All three media nodes are optional */
3063	Key node = registry.findKey (kMediaNodes [n]);
3064	if (node.isNull())
3065	continue;
3066
3067	if (n == 0)
3068	{
3069	Key::List hardDisks = node.keys ("HardDisk");
3070	for (Key::List::const_iterator it = hardDisks.begin();
3071	it != hardDisks.end(); ++ it)
3072	{
3073	ComObjPtr <HardDisk2> hardDisk;
3074	hardDisk.createObject();
3075	rc = hardDisk->init (this, NULL, *it);
3076	CheckComRCBreakRC (rc);
3077
3078	rc = registerHardDisk2 (hardDisk, false /* aSaveRegistry */);
3079	CheckComRCBreakRC (rc);
3080	}
3081
3082	continue;
3083	}
3084
3085	CheckComRCBreakRC (rc);
3086
3087	Key::List images = node.keys ("Image");
3088	for (Key::List::const_iterator it = images.begin();
3089	it != images.end(); ++ it)
3090	{
3091	switch (n)
3092	{
3093	case 1: /* DVDImages */
3094	{
3095	ComObjPtr <DVDImage2> image;
3096	image.createObject();
3097	rc = image->init (this, *it);
3098	CheckComRCBreakRC (rc);
3099
3100	rc = registerDVDImage (image, false /* aSaveRegistry */);
3101	CheckComRCBreakRC (rc);
3102
3103	break;
3104	}
3105	case 2: /* FloppyImages */
3106	{
3107	ComObjPtr <FloppyImage2> image;
3108	image.createObject();
3109	rc = image->init (this, *it);
3110	CheckComRCBreakRC (rc);
3111
3112	rc = registerFloppyImage (image, false /* aSaveRegistry */);
3113	CheckComRCBreakRC (rc);
3114
3115	break;
3116	}
3117	default:
3118	AssertFailed();
3119	}
3120
3121	CheckComRCBreakRC (rc);
3122	}
3123
3124	CheckComRCBreakRC (rc);
3125	}
3126
3127	return rc;
3128	}
3129
3130	/**
3131	* Helper function to write out the configuration tree.
3132	*
3133	* @note Locks this object for writing and child objects for reading/writing!
3134	*/
3135	HRESULT VirtualBox::saveSettings()
3136	{
3137	AutoCaller autoCaller (this);
3138	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3139
3140	AssertReturn (!!mData.mCfgFile.mName, E_FAIL);
3141
3142	HRESULT rc = S_OK;
3143
3144	/* serialize file access (prevent concurrent reads and writes) */
3145	AutoWriteLock alock (this);
3146
3147	try
3148	{
3149	using namespace settings;
3150	using namespace vboxxml;
3151
3152	/* load the settings file */
3153	File file (mData.mCfgFile.mHandle, Utf8Str (mData.mCfgFile.mName));
3154	XmlTreeBackend tree;
3155
3156	rc = VirtualBox::loadSettingsTree_ForUpdate (tree, file);
3157	CheckComRCThrowRC (rc);
3158
3159	Key global = tree.rootKey().createKey ("Global");
3160
3161	/* machines */
3162	{
3163	/* first, delete the entire machine registry */
3164	Key registryNode = global.findKey ("MachineRegistry");
3165	if (!registryNode.isNull())
3166	registryNode.zap();
3167	/* then, recreate it */
3168	registryNode = global.createKey ("MachineRegistry");
3169
3170	/* write out the machines */
3171	for (MachineList::iterator it = mData.mMachines.begin();
3172	it != mData.mMachines.end();
3173	++ it)
3174	{
3175	Key entryNode = registryNode.appendKey ("MachineEntry");
3176	rc = (*it)->saveRegistryEntry (entryNode);
3177	CheckComRCThrowRC (rc);
3178	}
3179	}
3180
3181	/* media */
3182	{
3183	/* first, delete the entire media registry */
3184	Key registryNode = global.findKey ("MediaRegistry");
3185	if (!registryNode.isNull())
3186	registryNode.zap();
3187	/* then, recreate it */
3188	registryNode = global.createKey ("MediaRegistry");
3189
3190	/* hard disks */
3191	{
3192	Key hardDisksNode = registryNode.createKey ("HardDisks");
3193
3194	for (HardDisk2List::const_iterator it =
3195	mData.mHardDisks2.begin();
3196	it != mData.mHardDisks2.end();
3197	++ it)
3198	{
3199	rc = (*it)->saveSettings (hardDisksNode);
3200	CheckComRCThrowRC (rc);
3201	}
3202	}
3203
3204	/* CD/DVD images */
3205	{
3206	Key imagesNode = registryNode.createKey ("DVDImages");
3207
3208	for (DVDImage2List::const_iterator it =
3209	mData.mDVDImages2.begin();
3210	it != mData.mDVDImages2.end();
3211	++ it)
3212	{
3213	rc = (*it)->saveSettings (imagesNode);
3214	CheckComRCThrowRC (rc);
3215	}
3216	}
3217
3218	/* floppy images */
3219	{
3220	Key imagesNode = registryNode.createKey ("FloppyImages");
3221
3222	for (FloppyImage2List::const_iterator it =
3223	mData.mFloppyImages2.begin();
3224	it != mData.mFloppyImages2.end();
3225	++ it)
3226	{
3227	rc = (*it)->saveSettings (imagesNode);
3228	CheckComRCThrowRC (rc);
3229	}
3230	}
3231	}
3232
3233	/* host data (USB filters) */
3234	rc = mData.mHost->saveSettings (global);
3235	CheckComRCThrowRC (rc);
3236
3237	rc = mData.mSystemProperties->saveSettings (global);
3238	CheckComRCThrowRC (rc);
3239
3240	/* save the settings on success */
3241	rc = VirtualBox::saveSettingsTree (tree, file,
3242	mData.mSettingsFileVersion);
3243	CheckComRCThrowRC (rc);
3244	}
3245	catch (HRESULT err)
3246	{
3247	/* we assume that error info is set by the thrower */
3248	rc = err;
3249	}
3250	catch (...)
3251	{
3252	rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
3253	}
3254
3255	return rc;
3256	}
3257
3258	/**
3259	* Helper to register the machine.
3260	*
3261	* When called during VirtualBox startup, adds the given machine to the
3262	* collection of registered machines. Otherwise tries to mark the machine
3263	* as registered, and, if succeeded, adds it to the collection and
3264	* saves global settings.
3265	*
3266	* @note The caller must have added itself as a caller of the @a aMachine
3267	* object if calls this method not on VirtualBox startup.
3268	*
3269	* @param aMachine machine to register
3270	*
3271	* @note Locks objects!
3272	*/
3273	HRESULT VirtualBox::registerMachine (Machine *aMachine)
3274	{
3275	ComAssertRet (aMachine, E_INVALIDARG);
3276
3277	AutoCaller autoCaller (this);
3278	CheckComRCReturnRC (autoCaller.rc());
3279
3280	AutoWriteLock alock (this);
3281
3282	HRESULT rc = S_OK;
3283
3284	{
3285	ComObjPtr <Machine> m;
3286	rc = findMachine (aMachine->id(), false /* aDoSetError */, &m);
3287	if (SUCCEEDED (rc))
3288	{
3289	/* sanity */
3290	AutoLimitedCaller machCaller (m);
3291	AssertComRC (machCaller.rc());
3292
3293	return setError (E_INVALIDARG,
3294	tr ("Registered machine with UUID {%RTuuid} ('%ls') already exists"),
3295	aMachine->id().raw(), m->settingsFileFull().raw());
3296	}
3297
3298	ComAssertRet (rc == E_INVALIDARG, rc);
3299	rc = S_OK;
3300	}
3301
3302	if (autoCaller.state() != InInit)
3303	{
3304	/* Machine::trySetRegistered() will commit and save machine settings */
3305	rc = aMachine->trySetRegistered (TRUE);
3306	CheckComRCReturnRC (rc);
3307	}
3308
3309	/* add to the collection of registered machines */
3310	mData.mMachines.push_back (aMachine);
3311
3312	if (autoCaller.state() != InInit)
3313	rc = saveSettings();
3314
3315	return rc;
3316	}
3317
3318	/**
3319	* Remembers the given hard disk by storing it in the hard disk registry.
3320	*
3321	* @param aHardDisk Hard disk object to remember.
3322	* @param aSaveRegistry @c true to save hard disk registry to disk (default).
3323	*
3324	* When @a aSaveRegistry is @c true, this operation may fail because of the
3325	* failed #saveSettings() method it calls. In this case, the hard disk object
3326	* will not be remembered. It is therefore the responsibility of the caller to
3327	* call this method as the last step of some action that requires registration
3328	* in order to make sure that only fully functional hard disk objects get
3329	* registered.
3330	*
3331	* @note Locks this object for writing and @a aHardDisk for reading.
3332	*/
3333	HRESULT VirtualBox::registerHardDisk2 (HardDisk2 *aHardDisk,
3334	bool aSaveRegistry /= true/)
3335	{
3336	AssertReturn (aHardDisk != NULL, E_INVALIDARG);
3337
3338	AutoCaller autoCaller (this);
3339	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3340
3341	AutoWriteLock alock (this);
3342
3343	AutoCaller hardDiskCaller (aHardDisk);
3344	AssertComRCReturn (hardDiskCaller.rc(), hardDiskCaller.rc());
3345
3346	AutoReadLock hardDiskLock (aHardDisk);
3347
3348	Utf8Str conflict;
3349	HRESULT rc = checkMediaForConflicts2 (aHardDisk->id(),
3350	aHardDisk->locationFull(),
3351	conflict);
3352	CheckComRCReturnRC (rc);
3353
3354	if (!conflict.isNull())
3355	{
3356	return setError (E_INVALIDARG,
3357	tr ("Cannot register the hard disk '%ls' with UUID {%RTuuid} "
3358	"because a %s already exists in the media registry ('%ls')"),
3359	aHardDisk->locationFull().raw(), aHardDisk->id().raw(),
3360	conflict.raw(), mData.mCfgFile.mName.raw());
3361	}
3362
3363	if (aHardDisk->parent().isNull())
3364	{
3365	/* base (root) hard disk */
3366	mData.mHardDisks2.push_back (aHardDisk);
3367	}
3368
3369	mData.mHardDisk2Map
3370	.insert (HardDisk2Map::value_type (
3371	aHardDisk->id(), HardDisk2Map::mapped_type (aHardDisk)));
3372
3373	if (aSaveRegistry)
3374	{
3375	rc = saveSettings();
3376	if (FAILED (rc))
3377	unregisterHardDisk2 (aHardDisk, false /* aSaveRegistry */);
3378	}
3379
3380	return rc;
3381	}
3382
3383	/**
3384	* Removes the given hard disk from the hard disk registry.
3385	*
3386	* @param aHardDisk Hard disk object to remove.
3387	* @param aSaveRegistry @c true to save hard disk registry to disk (default).
3388	*
3389	* When @a aSaveRegistry is @c true, this operation may fail because of the
3390	* failed #saveSettings() method it calls. In this case, the hard disk object
3391	* will NOT be removed from the registry when this method returns. It is
3392	* therefore the responsibility of the caller to call this method as the first
3393	* step of some action that requires unregistration, before calling uninit() on
3394	* @a aHardDisk.
3395	*
3396	* @note Locks this object for writing and @a aHardDisk for reading.
3397	*/
3398	HRESULT VirtualBox::unregisterHardDisk2 (HardDisk2 *aHardDisk,
3399	bool aSaveRegistry /= true/)
3400	{
3401	AssertReturn (aHardDisk != NULL, E_INVALIDARG);
3402
3403	AutoCaller autoCaller (this);
3404	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3405
3406	AutoWriteLock alock (this);
3407
3408	AutoCaller hardDiskCaller (aHardDisk);
3409	AssertComRCReturn (hardDiskCaller.rc(), hardDiskCaller.rc());
3410
3411	AutoReadLock hardDiskLock (aHardDisk);
3412
3413	size_t cnt = mData.mHardDisk2Map.erase (aHardDisk->id());
3414	Assert (cnt == 1);
3415
3416	if (aHardDisk->parent().isNull())
3417	{
3418	/* base (root) hard disk */
3419	mData.mHardDisks2.remove (aHardDisk);
3420	}
3421
3422	HRESULT rc = S_OK;
3423
3424	if (aSaveRegistry)
3425	{
3426	rc = saveSettings();
3427	if (FAILED (rc))
3428	registerHardDisk2 (aHardDisk, false /* aSaveRegistry */);
3429	}
3430
3431	return rc;
3432	}
3433
3434	/**
3435	* Remembers the given image by storing it in the CD/DVD image registry.
3436	*
3437	* @param aImage Image object to remember.
3438	* @param aSaveRegistry @c true to save the image registry to disk (default).
3439	*
3440	* When @a aSaveRegistry is @c true, this operation may fail because of the
3441	* failed #saveSettings() method it calls. In this case, the image object
3442	* will not be remembered. It is therefore the responsibility of the caller to
3443	* call this method as the last step of some action that requires registration
3444	* in order to make sure that only fully functional image objects get
3445	* registered.
3446	*
3447	* @note Locks this object for writing and @a aImage for reading.
3448	*/
3449	HRESULT VirtualBox::registerDVDImage (DVDImage2 *aImage,
3450	bool aSaveRegistry /= true/)
3451	{
3452	AssertReturn (aImage != NULL, E_INVALIDARG);
3453
3454	AutoCaller autoCaller (this);
3455	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3456
3457	AutoWriteLock alock (this);
3458
3459	AutoCaller imageCaller (aImage);
3460	AssertComRCReturn (imageCaller.rc(), imageCaller.rc());
3461
3462	AutoReadLock imageLock (aImage);
3463
3464	Utf8Str conflict;
3465	HRESULT rc = checkMediaForConflicts2 (aImage->id(), aImage->locationFull(),
3466	conflict);
3467	CheckComRCReturnRC (rc);
3468
3469	if (!conflict.isNull())
3470	{
3471	return setError (E_INVALIDARG,
3472	tr ("Cannot register the CD/DVD image '%ls' with UUID {%RTuuid} "
3473	"because a %s already exists in the media registry ('%ls')"),
3474	aImage->locationFull().raw(), aImage->id().raw(),
3475	conflict.raw(), mData.mCfgFile.mName.raw());
3476	}
3477
3478	/* add to the collection */
3479	mData.mDVDImages2.push_back (aImage);
3480
3481	if (aSaveRegistry)
3482	{
3483	rc = saveSettings();
3484	if (FAILED (rc))
3485	unregisterDVDImage (aImage, false /* aSaveRegistry */);
3486	}
3487
3488	return rc;
3489	}
3490
3491	/**
3492	* Removes the given image from the CD/DVD image registry registry.
3493	*
3494	* @param aImage Image object to remove.
3495	* @param aSaveRegistry @c true to save hard disk registry to disk (default).
3496	*
3497	* When @a aSaveRegistry is @c true, this operation may fail because of the
3498	* failed #saveSettings() method it calls. In this case, the image object
3499	* will NOT be removed from the registry when this method returns. It is
3500	* therefore the responsibility of the caller to call this method as the first
3501	* step of some action that requires unregistration, before calling uninit() on
3502	* @a aImage.
3503	*
3504	* @note Locks this object for writing and @a aImage for reading.
3505	*/
3506	HRESULT VirtualBox::unregisterDVDImage (DVDImage2 *aImage,
3507	bool aSaveRegistry /= true/)
3508	{
3509	AssertReturn (aImage != NULL, E_INVALIDARG);
3510
3511	AutoCaller autoCaller (this);
3512	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3513
3514	AutoWriteLock alock (this);
3515
3516	AutoCaller imageCaller (aImage);
3517	AssertComRCReturn (imageCaller.rc(), imageCaller.rc());
3518
3519	AutoReadLock imageLock (aImage);
3520
3521	mData.mDVDImages2.remove (aImage);
3522
3523	HRESULT rc = S_OK;
3524
3525	if (aSaveRegistry)
3526	{
3527	rc = saveSettings();
3528	if (FAILED (rc))
3529	registerDVDImage (aImage, false /* aSaveRegistry */);
3530	}
3531
3532	return rc;
3533	}
3534
3535	/**
3536	* Remembers the given image by storing it in the floppy image registry.
3537	*
3538	* @param aImage Image object to remember.
3539	* @param aSaveRegistry @c true to save the image registry to disk (default).
3540	*
3541	* When @a aSaveRegistry is @c true, this operation may fail because of the
3542	* failed #saveSettings() method it calls. In this case, the image object
3543	* will not be remembered. It is therefore the responsibility of the caller to
3544	* call this method as the last step of some action that requires registration
3545	* in order to make sure that only fully functional image objects get
3546	* registered.
3547	*
3548	* @note Locks this object for writing and @a aImage for reading.
3549	*/
3550	HRESULT VirtualBox::registerFloppyImage (FloppyImage2 *aImage,
3551	bool aSaveRegistry /= true/)
3552	{
3553	AssertReturn (aImage != NULL, E_INVALIDARG);
3554
3555	AutoCaller autoCaller (this);
3556	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3557
3558	AutoWriteLock alock (this);
3559
3560	AutoCaller imageCaller (aImage);
3561	AssertComRCReturn (imageCaller.rc(), imageCaller.rc());
3562
3563	AutoReadLock imageLock (aImage);
3564
3565	Utf8Str conflict;
3566	HRESULT rc = checkMediaForConflicts2 (aImage->id(), aImage->locationFull(),
3567	conflict);
3568	CheckComRCReturnRC (rc);
3569
3570	if (!conflict.isNull())
3571	{
3572	return setError (E_INVALIDARG,
3573	tr ("Cannot register the floppy image '%ls' with UUID {%RTuuid} "
3574	"because a %s already exists in the media registry ('%ls')"),
3575	aImage->locationFull().raw(), aImage->id().raw(),
3576	conflict.raw(), mData.mCfgFile.mName.raw());
3577	}
3578
3579	/* add to the collection */
3580	mData.mFloppyImages2.push_back (aImage);
3581
3582	if (aSaveRegistry)
3583	{
3584	rc = saveSettings();
3585	if (FAILED (rc))
3586	unregisterFloppyImage (aImage, false /* aSaveRegistry */);
3587	}
3588
3589	return rc;
3590	}
3591
3592	/**
3593	* Removes the given image from the floppy image registry registry.
3594	*
3595	* @param aImage Image object to remove.
3596	* @param aSaveRegistry @c true to save hard disk registry to disk (default).
3597	*
3598	* When @a aSaveRegistry is @c true, this operation may fail because of the
3599	* failed #saveSettings() method it calls. In this case, the image object
3600	* will NOT be removed from the registry when this method returns. It is
3601	* therefore the responsibility of the caller to call this method as the first
3602	* step of some action that requires unregistration, before calling uninit() on
3603	* @a aImage.
3604	*
3605	* @note Locks this object for writing and @a aImage for reading.
3606	*/
3607	HRESULT VirtualBox::unregisterFloppyImage (FloppyImage2 *aImage,
3608	bool aSaveRegistry /= true/)
3609	{
3610	AssertReturn (aImage != NULL, E_INVALIDARG);
3611
3612	AutoCaller autoCaller (this);
3613	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3614
3615	AutoWriteLock alock (this);
3616
3617	AutoCaller imageCaller (aImage);
3618	AssertComRCReturn (imageCaller.rc(), imageCaller.rc());
3619
3620	AutoReadLock imageLock (aImage);
3621
3622	mData.mFloppyImages2.remove (aImage);
3623
3624	HRESULT rc = S_OK;
3625
3626	if (aSaveRegistry)
3627	{
3628	rc = saveSettings();
3629	if (FAILED (rc))
3630	registerFloppyImage (aImage, false /* aSaveRegistry */);
3631	}
3632
3633	return rc;
3634	}
3635
3636	/**
3637	* Attempts to cast from a raw interface pointer to an underlying object.
3638	* On success, @a aTo will contain the object reference. On failure, @a aTo will
3639	* be set to @c null and an extended error info will be returned.
3640	*
3641	* @param aFrom Interface pointer to cast from.
3642	* @param aTo Where to store a reference to the underlying object.
3643	*
3644	* @note Locks this object for reading.
3645	*/
3646	HRESULT VirtualBox::cast (IHardDisk2 *aFrom, ComObjPtr <HardDisk2> &aTo)
3647	{
3648	AssertReturn (aFrom != NULL, E_INVALIDARG);
3649
3650	AutoCaller autoCaller (this);
3651	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3652
3653	AutoReadLock alock (this);
3654
3655	VirtualBoxBase *child = getDependentChild (aFrom);
3656	if (!child)
3657	return setError (E_FAIL, tr ("The given hard disk object is not created "
3658	"within this VirtualBox instance"));
3659
3660	/* we can safely cast child to HardDisk * here because only HardDisk
3661	* implementations of IHardDisk can be among our children */
3662
3663	aTo = static_cast <HardDisk2 *> (child);
3664
3665	return S_OK;
3666	}
3667
3668	/**
3669	* Helper to update the global settings file when the name of some machine
3670	* changes so that file and directory renaming occurs. This method ensures that
3671	* all affected paths in the disk registry are properly updated.
3672	*
3673	* @param aOldPath Old path (full).
3674	* @param aNewPath New path (full).
3675	*
3676	* @note Locks this object + DVD, Floppy and HardDisk children for writing.
3677	*/
3678	HRESULT VirtualBox::updateSettings (const char aOldPath, const char aNewPath)
3679	{
3680	LogFlowThisFunc (("aOldPath={%s} aNewPath={%s}\n", aOldPath, aNewPath));
3681
3682	AssertReturn (aOldPath, E_INVALIDARG);
3683	AssertReturn (aNewPath, E_INVALIDARG);
3684
3685	AutoCaller autoCaller (this);
3686	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3687
3688	AutoWriteLock alock (this);
3689
3690	/* check DVD paths */
3691	for (DVDImage2List::iterator it = mData.mDVDImages2.begin();
3692	it != mData.mDVDImages2.end();
3693	++ it)
3694	{
3695	(*it)->updatePath (aOldPath, aNewPath);
3696	}
3697
3698	/* check Floppy paths */
3699	for (FloppyImage2List::iterator it = mData.mFloppyImages2.begin();
3700	it != mData.mFloppyImages2.end();
3701	++ it)
3702	{
3703	(*it)->updatePath (aOldPath, aNewPath);
3704	}
3705
3706	/* check HardDisk paths */
3707	for (HardDisk2List::const_iterator it = mData.mHardDisks2.begin();
3708	it != mData.mHardDisks2.end();
3709	++ it)
3710	{
3711	(*it)->updatePaths (aOldPath, aNewPath);
3712	}
3713
3714	HRESULT rc = saveSettings();
3715
3716	return rc;
3717	}
3718
3719	/**
3720	* Creates the path to the specified file according to the path information
3721	* present in the file name.
3722	*
3723	* Note that the given file name must contain the full path otherwise the
3724	* extracted relative path will be created based on the current working
3725	* directory which is normally unknown.
3726	*
3727	* @param aFileName Full file name which path needs to be created.
3728	*
3729	* @return Extended error information on failure to create the path.
3730	*/
3731	/* static */
3732	HRESULT VirtualBox::ensureFilePathExists (const char *aFileName)
3733	{
3734	Utf8Str dir = aFileName;
3735	RTPathStripFilename (dir.mutableRaw());
3736	if (!RTDirExists (dir))
3737	{
3738	int vrc = RTDirCreateFullPath (dir, 0777);
3739	if (RT_FAILURE (vrc))
3740	{
3741	return setError (E_FAIL,
3742	tr ("Could not create the directory '%s' (%Rrc)"),
3743	dir.raw(), vrc);
3744	}
3745	}
3746
3747	return S_OK;
3748	}
3749
3750	/**
3751	* Helper method to load the setting tree and turn expected exceptions into
3752	* COM errors, according to arguments.
3753	*
3754	* Note that this method will not catch unexpected errors so it may still
3755	* throw something.
3756	*
3757	* @param aTree Tree to load into settings.
3758	* @param aFile File to load settings from.
3759	* @param aValidate @c @true to enable tree validation.
3760	* @param aCatchLoadErrors @c true to catch exceptions caused by file
3761	* access or validation errors.
3762	* @param aAddDefaults @c true to cause the substitution of default
3763	* values for missing attributes that have
3764	* defaults in the XML schema.
3765	* @param aFormatVersion Where to store the current format version of the
3766	* loaded settings tree (optional, may be NULL).
3767	*/
3768	/* static */
3769	HRESULT VirtualBox::loadSettingsTree (settings::XmlTreeBackend &aTree,
3770	vboxxml::File &aFile,
3771	bool aValidate,
3772	bool aCatchLoadErrors,
3773	bool aAddDefaults,
3774	Utf8Str aFormatVersion / = NULL */)
3775	{
3776	using namespace settings;
3777
3778	try
3779	{
3780	SettingsTreeHelper helper = SettingsTreeHelper();
3781
3782	aTree.setInputResolver (helper);
3783	aTree.setAutoConverter (helper);
3784
3785	aTree.read (aFile, aValidate ? VBOX_XML_SCHEMA : NULL,
3786	aAddDefaults ? XmlTreeBackend::Read_AddDefaults : 0);
3787
3788	aTree.resetAutoConverter();
3789	aTree.resetInputResolver();
3790
3791	/* on success, memorize the current settings file version or set it to
3792	* the most recent version if no settings conversion took place. Note
3793	* that it's not necessary to do it every time we load the settings file
3794	* (i.e. only loadSettingsTree_FirstTime() passes a non-NULL
3795	* aFormatVersion value) because currently we keep the settings
3796	* files locked so that the only legal way to change the format version
3797	* while VirtualBox is running is saveSettingsTree(). */
3798	if (aFormatVersion != NULL)
3799	{
3800	*aFormatVersion = aTree.oldVersion();
3801	if (aFormatVersion->isNull())
3802	*aFormatVersion = VBOX_XML_VERSION_FULL;
3803	}
3804	}
3805	catch (const vboxxml::EIPRTFailure &err)
3806	{
3807	if (!aCatchLoadErrors)
3808	throw;
3809
3810	return setError (E_FAIL,
3811	tr ("Could not load the settings file '%s' (%Rrc)"),
3812	aFile.uri(), err.rc());
3813	}
3814	catch (const XmlTreeBackend::Error &err)
3815	{
3816	Assert (err.what() != NULL);
3817
3818	if (!aCatchLoadErrors)
3819	throw;
3820
3821	return setError (E_FAIL,
3822	tr ("Could not load the settings file '%s'.\n%s"),
3823	aFile.uri(),
3824	err.what() ? err.what() : "Unknown error");
3825	}
3826
3827	return S_OK;
3828	}
3829
3830	/**
3831	* Helper method to save the settings tree and turn expected exceptions to COM
3832	* errors.
3833	*
3834	* Note that this method will not catch unexpected errors so it may still
3835	* throw something.
3836	*
3837	* @param aTree Tree to save.
3838	* @param aFile File to save the tree to.
3839	* @param aFormatVersion Where to store the (recent) format version of the
3840	* saved settings tree on success.
3841	*/
3842	/* static */
3843	HRESULT VirtualBox::saveSettingsTree (settings::TreeBackend &aTree,
3844	vboxxml::File &aFile,
3845	Utf8Str &aFormatVersion)
3846	{
3847	using namespace settings;
3848
3849	try
3850	{
3851	aTree.write (aFile);
3852
3853	/* set the current settings file version to the most recent version on
3854	* success. See also VirtualBox::loadSettingsTree(). */
3855	if (aFormatVersion != VBOX_XML_VERSION_FULL)
3856	aFormatVersion = VBOX_XML_VERSION_FULL;
3857	}
3858	catch (const vboxxml::EIPRTFailure &err)
3859	{
3860	/* this is the only expected exception for now */
3861	return setError (E_FAIL,
3862	tr ("Could not save the settings file '%s' (%Rrc)"),
3863	aFile.uri(), err.rc());
3864	}
3865
3866	return S_OK;
3867	}
3868
3869	/**
3870	* Creates a backup copy of the given settings file by suffixing it with the
3871	* supplied version format string and optionally with numbers from .0 to .9
3872	* if the backup file already exists.
3873	*
3874	* @param aFileName Original settings file name.
3875	* @param aOldFormat Version of the original format.
3876	* @param aBakFileName File name of the created backup copy (only on success).
3877	*/
3878	/* static */
3879	HRESULT VirtualBox::backupSettingsFile (const Bstr &aFileName,
3880	const Utf8Str &aOldFormat,
3881	Bstr &aBakFileName)
3882	{
3883	Utf8Str of = aFileName;
3884	Utf8Str nf = Utf8StrFmt ("%s.%s.bak", of.raw(), aOldFormat.raw());
3885
3886	int vrc = RTFileCopyEx (of, nf, RTFILECOPY_FLAGS_NO_SRC_DENY_WRITE,
3887	NULL, NULL);
3888
3889	/* try progressive suffix from .0 to .9 on failure */
3890	if (vrc == VERR_ALREADY_EXISTS)
3891	{
3892	Utf8Str tmp = nf;
3893	for (int i = 0; i <= 9 && RT_FAILURE (vrc); ++ i)
3894	{
3895	nf = Utf8StrFmt ("%s.%d", tmp.raw(), i);
3896	vrc = RTFileCopyEx (of, nf, RTFILECOPY_FLAGS_NO_SRC_DENY_WRITE,
3897	NULL, NULL);
3898	}
3899	}
3900
3901	if (RT_FAILURE (vrc))
3902	return setError (E_FAIL,
3903	tr ("Could not copy the settings file '%s' to '%s' (%Rrc)"),
3904	of.raw(), nf.raw(), vrc);
3905
3906	aBakFileName = nf;
3907
3908	return S_OK;
3909	}
3910
3911	/**
3912	* Handles unexpected exceptions by turning them into COM errors in release
3913	* builds or by hitting a breakpoint in the release builds.
3914	*
3915	* Usage pattern:
3916	* @code
3917	try
3918	{
3919	// ...
3920	}
3921	catch (LaLalA)
3922	{
3923	// ...
3924	}
3925	catch (...)
3926	{
3927	rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
3928	}
3929	* @endcode
3930	*
3931	* @param RT_SRC_POS_DECL "RT_SRC_POS" macro instantiation.
3932	*/
3933	/* static */
3934	HRESULT VirtualBox::handleUnexpectedExceptions (RT_SRC_POS_DECL)
3935	{
3936	try
3937	{
3938	/* re-throw the current exception */
3939	throw;
3940	}
3941	catch (const std::exception &err)
3942	{
3943	ComAssertMsgFailedPos (("Unexpected exception '%s' (%s)\n",
3944	typeid (err).name(), err.what()),
3945	pszFile, iLine, pszFunction);
3946	return E_FAIL;
3947	}
3948	catch (...)
3949	{
3950	ComAssertMsgFailedPos (("Unknown exception\n"),
3951	pszFile, iLine, pszFunction);
3952	return E_FAIL;
3953	}
3954
3955	/* should not get here */
3956	AssertFailed();
3957	return E_FAIL;
3958	}
3959
3960	/**
3961	* Helper to lock the VirtualBox configuration for write access.
3962	*
3963	* @note This method is not thread safe (must be called only from #init()
3964	* or #uninit()).
3965	*
3966	* @note If the configuration file is not found, the method returns
3967	* S_OK, but subsequent #isConfigLocked() will return FALSE. This is used
3968	* in some places to determine the (valid) situation when no config file
3969	* exists yet, and therefore a new one should be created from scratch.
3970	*/
3971	HRESULT VirtualBox::lockConfig()
3972	{
3973	AutoCaller autoCaller (this);
3974	AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3975	AssertReturn (autoCaller.state() == InInit, E_FAIL);
3976
3977	HRESULT rc = S_OK;
3978
3979	Assert (!isConfigLocked());
3980	if (!isConfigLocked())
3981	{
3982	/* open the associated config file */
3983	int vrc = RTFileOpen (&mData.mCfgFile.mHandle,
3984	Utf8Str (mData.mCfgFile.mName),
3985	RTFILE_O_READWRITE \| RTFILE_O_OPEN \|
3986	RTFILE_O_DENY_WRITE);
3987	if (RT_FAILURE (vrc))
3988	{
3989	mData.mCfgFile.mHandle = NIL_RTFILE;
3990
3991	/*
3992	* It is OK if the file is not found, it will be created by
3993	* init(). Otherwise return an error.
3994	*/
3995	if (vrc != VERR_FILE_NOT_FOUND)
3996	rc = setError (E_FAIL,
3997	tr ("Could not lock the settings file '%ls' (%Rrc)"),
3998	mData.mCfgFile.mName.raw(), vrc);
3999	}
4000
4001	LogFlowThisFunc (("mCfgFile.mName='%ls', mCfgFile.mHandle=%d, rc=%08X\n",
4002	mData.mCfgFile.mName.raw(), mData.mCfgFile.mHandle, rc));
4003	}
4004
4005	return rc;
4006	}
4007
4008	/**
4009	* Helper to unlock the VirtualBox configuration from write access.
4010	*
4011	* @note This method is not thread safe (must be called only from #init()
4012	* or #uninit()).
4013	*/
4014	HRESULT VirtualBox::unlockConfig()
4015	{
4016	AutoCaller autoCaller (this);
4017	AssertComRCReturn (autoCaller.rc(), E_FAIL);
4018	AssertReturn (autoCaller.state() == InUninit, E_FAIL);
4019
4020	HRESULT rc = S_OK;
4021
4022	if (isConfigLocked())
4023	{
4024	RTFileFlush (mData.mCfgFile.mHandle);
4025	RTFileClose (mData.mCfgFile.mHandle);
4026	/** @todo flush the directory too. */
4027	mData.mCfgFile.mHandle = NIL_RTFILE;
4028	LogFlowThisFunc (("\n"));
4029	}
4030
4031	return rc;
4032	}
4033
4034	/**
4035	* Thread function that watches the termination of all client processes
4036	* that have opened sessions using IVirtualBox::OpenSession()
4037	*/
4038	// static
4039	DECLCALLBACK(int) VirtualBox::ClientWatcher (RTTHREAD thread, void *pvUser)
4040	{
4041	LogFlowFuncEnter();
4042
4043	VirtualBox that = (VirtualBox ) pvUser;
4044	Assert (that);
4045
4046	SessionMachineVector machines;
4047	MachineVector spawnedMachines;
4048
4049	size_t cnt = 0;
4050	size_t cntSpawned = 0;
4051
4052	#if defined(RT_OS_WINDOWS)
4053
4054	HRESULT hrc = CoInitializeEx (NULL,
4055	COINIT_MULTITHREADED \| COINIT_DISABLE_OLE1DDE \|
4056	COINIT_SPEED_OVER_MEMORY);
4057	AssertComRC (hrc);
4058
4059	/// @todo (dmik) processes reaping!
4060
4061	HANDLE handles [MAXIMUM_WAIT_OBJECTS];
4062	handles [0] = that->mWatcherData.mUpdateReq;
4063
4064	do
4065	{
4066	AutoCaller autoCaller (that);
4067	/* VirtualBox has been early uninitialized, terminate */
4068	if (!autoCaller.isOk())
4069	break;
4070
4071	do
4072	{
4073	/* release the caller to let uninit() ever proceed */
4074	autoCaller.release();
4075
4076	DWORD rc = ::WaitForMultipleObjects (1 + cnt + cntSpawned,
4077	handles, FALSE, INFINITE);
4078
4079	/* Restore the caller before using VirtualBox. If it fails, this
4080	* means VirtualBox is being uninitialized and we must terminate. */
4081	autoCaller.add();
4082	if (!autoCaller.isOk())
4083	break;
4084
4085	bool update = false;
4086
4087	if (rc == WAIT_OBJECT_0)
4088	{
4089	/* update event is signaled */
4090	update = true;
4091	}
4092	else if (rc > WAIT_OBJECT_0 && rc <= (WAIT_OBJECT_0 + cnt))
4093	{
4094	/* machine mutex is released */
4095	(machines [rc - WAIT_OBJECT_0 - 1])->checkForDeath();
4096	update = true;
4097	}
4098	else if (rc > WAIT_ABANDONED_0 && rc <= (WAIT_ABANDONED_0 + cnt))
4099	{
4100	/* machine mutex is abandoned due to client process termination */
4101	(machines [rc - WAIT_ABANDONED_0 - 1])->checkForDeath();
4102	update = true;
4103	}
4104	else if (rc > WAIT_OBJECT_0 + cnt && rc <= (WAIT_OBJECT_0 + cntSpawned))
4105	{
4106	/* spawned VM process has terminated (normally or abnormally) */
4107	(spawnedMachines [rc - WAIT_OBJECT_0 - cnt - 1])->
4108	checkForSpawnFailure();
4109	update = true;
4110	}
4111
4112	if (update)
4113	{
4114	/* close old process handles */
4115	for (size_t i = 1 + cnt; i < 1 + cnt + cntSpawned; ++ i)
4116	CloseHandle (handles [i]);
4117
4118	AutoReadLock thatLock (that);
4119
4120	/* obtain a new set of opened machines */
4121	cnt = 0;
4122	machines.clear();
4123
4124	for (MachineList::iterator it = that->mData.mMachines.begin();
4125	it != that->mData.mMachines.end(); ++ it)
4126	{
4127	/// @todo handle situations with more than 64 objects
4128	AssertMsgBreak ((1 + cnt) <= MAXIMUM_WAIT_OBJECTS,
4129	("MAXIMUM_WAIT_OBJECTS reached"));
4130
4131	ComObjPtr <SessionMachine> sm;
4132	HANDLE ipcSem;
4133	if ((*it)->isSessionOpenOrClosing (sm, NULL, &ipcSem))
4134	{
4135	machines.push_back (sm);
4136	handles [1 + cnt] = ipcSem;
4137	++ cnt;
4138	}
4139	}
4140
4141	LogFlowFunc (("UPDATE: direct session count = %d\n", cnt));
4142
4143	/* obtain a new set of spawned machines */
4144	cntSpawned = 0;
4145	spawnedMachines.clear();
4146
4147	for (MachineList::iterator it = that->mData.mMachines.begin();
4148	it != that->mData.mMachines.end(); ++ it)
4149	{
4150	/// @todo handle situations with more than 64 objects
4151	AssertMsgBreak ((1 + cnt + cntSpawned) <= MAXIMUM_WAIT_OBJECTS,
4152	("MAXIMUM_WAIT_OBJECTS reached"));
4153
4154	RTPROCESS pid;
4155	if ((*it)->isSessionSpawning (&pid))
4156	{
4157	HANDLE ph = OpenProcess (SYNCHRONIZE, FALSE, pid);
4158	AssertMsg (ph != NULL, ("OpenProcess (pid=%d) failed with %d\n",
4159	pid, GetLastError()));
4160	if (rc == 0)
4161	{
4162	spawnedMachines.push_back (*it);
4163	handles [1 + cnt + cntSpawned] = ph;
4164	++ cntSpawned;
4165	}
4166	}
4167	}
4168
4169	LogFlowFunc (("UPDATE: spawned session count = %d\n", cntSpawned));
4170	}
4171	}
4172	while (true);
4173	}
4174	while (0);
4175
4176	/* close old process handles */
4177	for (size_t i = 1 + cnt; i < 1 + cnt + cntSpawned; ++ i)
4178	CloseHandle (handles [i]);
4179
4180	/* release sets of machines if any */
4181	machines.clear();
4182	spawnedMachines.clear();
4183
4184	::CoUninitialize();
4185
4186	#elif defined (RT_OS_OS2)
4187
4188	/// @todo (dmik) processes reaping!
4189
4190	/* according to PMREF, 64 is the maximum for the muxwait list */
4191	SEMRECORD handles [64];
4192
4193	HMUX muxSem = NULLHANDLE;
4194
4195	do
4196	{
4197	AutoCaller autoCaller (that);
4198	/* VirtualBox has been early uninitialized, terminate */
4199	if (!autoCaller.isOk())
4200	break;
4201
4202	do
4203	{
4204	/* release the caller to let uninit() ever proceed */
4205	autoCaller.release();
4206
4207	int vrc = RTSemEventWait (that->mWatcherData.mUpdateReq, 500);
4208
4209	/* Restore the caller before using VirtualBox. If it fails, this
4210	* means VirtualBox is being uninitialized and we must terminate. */
4211	autoCaller.add();
4212	if (!autoCaller.isOk())
4213	break;
4214
4215	bool update = false;
4216	bool updateSpawned = false;
4217
4218	if (RT_SUCCESS (vrc))
4219	{
4220	/* update event is signaled */
4221	update = true;
4222	updateSpawned = true;
4223	}
4224	else
4225	{
4226	AssertMsg (vrc == VERR_TIMEOUT \|\| vrc == VERR_INTERRUPTED,
4227	("RTSemEventWait returned %Rrc\n", vrc));
4228
4229	/* are there any mutexes? */
4230	if (cnt > 0)
4231	{
4232	/* figure out what's going on with machines */
4233
4234	unsigned long semId = 0;
4235	APIRET arc = ::DosWaitMuxWaitSem (muxSem,
4236	SEM_IMMEDIATE_RETURN, &semId);
4237
4238	if (arc == NO_ERROR)
4239	{
4240	/* machine mutex is normally released */
4241	Assert (semId >= 0 && semId < cnt);
4242	if (semId >= 0 && semId < cnt)
4243	{
4244	#ifdef DEBUG
4245	{
4246	AutoReadLock machineLock (machines [semId]);
4247	LogFlowFunc (("released mutex: machine='%ls'\n",
4248	machines [semId]->name().raw()));
4249	}
4250	#endif
4251	machines [semId]->checkForDeath();
4252	}
4253	update = true;
4254	}
4255	else if (arc == ERROR_SEM_OWNER_DIED)
4256	{
4257	/* machine mutex is abandoned due to client process
4258	* termination; find which mutex is in the Owner Died
4259	* state */
4260	for (size_t i = 0; i < cnt; ++ i)
4261	{
4262	PID pid; TID tid;
4263	unsigned long reqCnt;
4264	arc = DosQueryMutexSem ((HMTX) handles [i].hsemCur, &pid,
4265	&tid, &reqCnt);
4266	if (arc == ERROR_SEM_OWNER_DIED)
4267	{
4268	/* close the dead mutex as asked by PMREF */
4269	::DosCloseMutexSem ((HMTX) handles [i].hsemCur);
4270
4271	Assert (i >= 0 && i < cnt);
4272	if (i >= 0 && i < cnt)
4273	{
4274	#ifdef DEBUG
4275	{
4276	AutoReadLock machineLock (machines [semId]);
4277	LogFlowFunc (("mutex owner dead: machine='%ls'\n",
4278	machines [i]->name().raw()));
4279	}
4280	#endif
4281	machines [i]->checkForDeath();
4282	}
4283	}
4284	}
4285	update = true;
4286	}
4287	else
4288	AssertMsg (arc == ERROR_INTERRUPT \|\| arc == ERROR_TIMEOUT,
4289	("DosWaitMuxWaitSem returned %d\n", arc));
4290	}
4291
4292	/* are there any spawning sessions? */
4293	if (cntSpawned > 0)
4294	{
4295	for (size_t i = 0; i < cntSpawned; ++ i)
4296	updateSpawned \|= (spawnedMachines [i])->
4297	checkForSpawnFailure();
4298	}
4299	}
4300
4301	if (update \|\| updateSpawned)
4302	{
4303	AutoReadLock thatLock (that);
4304
4305	if (update)
4306	{
4307	/* close the old muxsem */
4308	if (muxSem != NULLHANDLE)
4309	::DosCloseMuxWaitSem (muxSem);
4310
4311	/* obtain a new set of opened machines */
4312	cnt = 0;
4313	machines.clear();
4314
4315	for (MachineList::iterator it = that->mData.mMachines.begin();
4316	it != that->mData.mMachines.end(); ++ it)
4317	{
4318	/// @todo handle situations with more than 64 objects
4319	AssertMsg (cnt <= 64 /* according to PMREF */,
4320	("maximum of 64 mutex semaphores reached (%d)",
4321	cnt));
4322
4323	ComObjPtr <SessionMachine> sm;
4324	HMTX ipcSem;
4325	if ((*it)->isSessionOpenOrClosing (sm, NULL, &ipcSem))
4326	{
4327	machines.push_back (sm);
4328	handles [cnt].hsemCur = (HSEM) ipcSem;
4329	handles [cnt].ulUser = cnt;
4330	++ cnt;
4331	}
4332	}
4333
4334	LogFlowFunc (("UPDATE: direct session count = %d\n", cnt));
4335
4336	if (cnt > 0)
4337	{
4338	/* create a new muxsem */
4339	APIRET arc = ::DosCreateMuxWaitSem (NULL, &muxSem, cnt,
4340	handles,
4341	DCMW_WAIT_ANY);
4342	AssertMsg (arc == NO_ERROR,
4343	("DosCreateMuxWaitSem returned %d\n", arc));
4344	NOREF(arc);
4345	}
4346	}
4347
4348	if (updateSpawned)
4349	{
4350	/* obtain a new set of spawned machines */
4351	spawnedMachines.clear();
4352
4353	for (MachineList::iterator it = that->mData.mMachines.begin();
4354	it != that->mData.mMachines.end(); ++ it)
4355	{
4356	if ((*it)->isSessionSpawning())
4357	spawnedMachines.push_back (*it);
4358	}
4359
4360	cntSpawned = spawnedMachines.size();
4361	LogFlowFunc (("UPDATE: spawned session count = %d\n", cntSpawned));
4362	}
4363	}
4364	}
4365	while (true);
4366	}
4367	while (0);
4368
4369	/* close the muxsem */
4370	if (muxSem != NULLHANDLE)
4371	::DosCloseMuxWaitSem (muxSem);
4372
4373	/* release sets of machines if any */
4374	machines.clear();
4375	spawnedMachines.clear();
4376
4377	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
4378
4379	bool update = false;
4380	bool updateSpawned = false;
4381
4382	do
4383	{
4384	AutoCaller autoCaller (that);
4385	if (!autoCaller.isOk())
4386	break;
4387
4388	do
4389	{
4390	/* release the caller to let uninit() ever proceed */
4391	autoCaller.release();
4392
4393	int rc = RTSemEventWait (that->mWatcherData.mUpdateReq, 500);
4394
4395	/*
4396	* Restore the caller before using VirtualBox. If it fails, this
4397	* means VirtualBox is being uninitialized and we must terminate.
4398	*/
4399	autoCaller.add();
4400	if (!autoCaller.isOk())
4401	break;
4402
4403	if (RT_SUCCESS (rc) \|\| update \|\| updateSpawned)
4404	{
4405	/* RT_SUCCESS (rc) means an update event is signaled */
4406
4407	AutoReadLock thatLock (that);
4408
4409	if (RT_SUCCESS (rc) \|\| update)
4410	{
4411	/* obtain a new set of opened machines */
4412	machines.clear();
4413
4414	for (MachineList::iterator it = that->mData.mMachines.begin();
4415	it != that->mData.mMachines.end(); ++ it)
4416	{
4417	ComObjPtr <SessionMachine> sm;
4418	if ((*it)->isSessionOpenOrClosing (sm))
4419	machines.push_back (sm);
4420	}
4421
4422	cnt = machines.size();
4423	LogFlowFunc (("UPDATE: direct session count = %d\n", cnt));
4424	}
4425
4426	if (RT_SUCCESS (rc) \|\| updateSpawned)
4427	{
4428	/* obtain a new set of spawned machines */
4429	spawnedMachines.clear();
4430
4431	for (MachineList::iterator it = that->mData.mMachines.begin();
4432	it != that->mData.mMachines.end(); ++ it)
4433	{
4434	if ((*it)->isSessionSpawning())
4435	spawnedMachines.push_back (*it);
4436	}
4437
4438	cntSpawned = spawnedMachines.size();
4439	LogFlowFunc (("UPDATE: spawned session count = %d\n", cntSpawned));
4440	}
4441	}
4442
4443	update = false;
4444	for (size_t i = 0; i < cnt; ++ i)
4445	update \|= (machines [i])->checkForDeath();
4446
4447	updateSpawned = false;
4448	for (size_t i = 0; i < cntSpawned; ++ i)
4449	updateSpawned \|= (spawnedMachines [i])->checkForSpawnFailure();
4450
4451	/* reap child processes */
4452	{
4453	AutoWriteLock alock (that);
4454	if (that->mWatcherData.mProcesses.size())
4455	{
4456	LogFlowFunc (("UPDATE: child process count = %d\n",
4457	that->mWatcherData.mProcesses.size()));
4458	ClientWatcherData::ProcessList::iterator it =
4459	that->mWatcherData.mProcesses.begin();
4460	while (it != that->mWatcherData.mProcesses.end())
4461	{
4462	RTPROCESS pid = *it;
4463	RTPROCSTATUS status;
4464	int vrc = ::RTProcWait (pid, RTPROCWAIT_FLAGS_NOBLOCK,
4465	&status);
4466	if (vrc == VINF_SUCCESS)
4467	{
4468	LogFlowFunc (("pid %d (%x) was reaped, "
4469	"status=%d, reason=%d\n",
4470	pid, pid, status.iStatus,
4471	status.enmReason));
4472	it = that->mWatcherData.mProcesses.erase (it);
4473	}
4474	else
4475	{
4476	LogFlowFunc (("pid %d (%x) was NOT reaped, vrc=%Rrc\n",
4477	pid, pid, vrc));
4478	if (vrc != VERR_PROCESS_RUNNING)
4479	{
4480	/* remove the process if it is not already running */
4481	it = that->mWatcherData.mProcesses.erase (it);
4482	}
4483	else
4484	++ it;
4485	}
4486	}
4487	}
4488	}
4489	}
4490	while (true);
4491	}
4492	while (0);
4493
4494	/* release sets of machines if any */
4495	machines.clear();
4496	spawnedMachines.clear();
4497
4498	#else
4499	# error "Port me!"
4500	#endif
4501
4502	LogFlowFuncLeave();
4503	return 0;
4504	}
4505
4506	/**
4507	* Thread function that handles custom events posted using #postEvent().
4508	*/
4509	// static
4510	DECLCALLBACK(int) VirtualBox::AsyncEventHandler (RTTHREAD thread, void *pvUser)
4511	{
4512	LogFlowFuncEnter();
4513
4514	AssertReturn (pvUser, VERR_INVALID_POINTER);
4515
4516	// create an event queue for the current thread
4517	EventQueue *eventQ = new EventQueue();
4518	AssertReturn (eventQ, VERR_NO_MEMORY);
4519
4520	// return the queue to the one who created this thread
4521	(static_cast <EventQueue *> (pvUser)) = eventQ;
4522	// signal that we're ready
4523	RTThreadUserSignal (thread);
4524
4525	BOOL ok = TRUE;
4526	Event *event = NULL;
4527
4528	while ((ok = eventQ->waitForEvent (&event)) && event)
4529	eventQ->handleEvent (event);
4530
4531	AssertReturn (ok, VERR_GENERAL_FAILURE);
4532
4533	delete eventQ;
4534
4535	LogFlowFuncLeave();
4536
4537	return 0;
4538	}
4539
4540	////////////////////////////////////////////////////////////////////////////////
4541
4542	/**
4543	* Takes the current list of registered callbacks of the managed VirtualBox
4544	* instance, and calls #handleCallback() for every callback item from the
4545	* list, passing the item as an argument.
4546	*
4547	* @note Locks the managed VirtualBox object for reading but leaves the lock
4548	* before iterating over callbacks and calling their methods.
4549	*/
4550	void *VirtualBox::CallbackEvent::handler()
4551	{
4552	if (mVirtualBox.isNull())
4553	return NULL;
4554
4555	AutoCaller autoCaller (mVirtualBox);
4556	if (!autoCaller.isOk())
4557	{
4558	LogWarningFunc (("VirtualBox has been uninitialized (state=%d), "
4559	"the callback event is discarded!\n",
4560	autoCaller.state()));
4561	/* We don't need mVirtualBox any more, so release it */
4562	mVirtualBox.setNull();
4563	return NULL;
4564	}
4565
4566	CallbackVector callbacks;
4567	{
4568	/* Make a copy to release the lock before iterating */
4569	AutoReadLock alock (mVirtualBox);
4570	callbacks = CallbackVector (mVirtualBox->mData.mCallbacks.begin(),
4571	mVirtualBox->mData.mCallbacks.end());
4572	/* We don't need mVirtualBox any more, so release it */
4573	mVirtualBox.setNull();
4574	}
4575
4576	for (VirtualBox::CallbackVector::const_iterator it = callbacks.begin();
4577	it != callbacks.end(); ++ it)
4578	handleCallback (*it);
4579
4580	return NULL;
4581	}
4582	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/VirtualBoxImpl.cpp@ 14854

Download in other formats: