VirtualBox

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

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

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