VirtualBox

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

Last change on this file since 13836 was 13836, checked in by vboxsync, 16 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette