VirtualBox

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

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

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