VirtualBox

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

Last change on this file since 7692 was 7607, checked in by vboxsync, 17 years ago

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