VirtualBox

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

Last change on this file since 161 was 1, checked in by vboxsync, 55 years ago

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