VirtualBox

source: vbox/trunk/src/VBox/Main/SystemPropertiesImpl.cpp@ 23257

Last change on this file since 23257 was 23257, checked in by vboxsync, 15 years ago

Main: IHost header cleanup, remove cruft elsewhere
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.1 KB
Line 
1/* $Id: SystemPropertiesImpl.cpp 23257 2009-09-23 13:30:15Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox COM class implementation
6 */
7
8/*
9 * Copyright (C) 2006-2008 Sun Microsystems, Inc.
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20 * Clara, CA 95054 USA or visit http://www.sun.com if you need
21 * additional information or have any questions.
22 */
23
24#include "SystemPropertiesImpl.h"
25#include "VirtualBoxImpl.h"
26#include "MachineImpl.h"
27#include "Logging.h"
28
29// generated header
30#include "SchemaDefs.h"
31
32#include <iprt/path.h>
33#include <iprt/dir.h>
34#include <iprt/process.h>
35#include <iprt/ldr.h>
36
37#include <VBox/err.h>
38#include <VBox/param.h>
39#include <VBox/settings.h>
40#include <VBox/VBoxHDD.h>
41
42// defines
43/////////////////////////////////////////////////////////////////////////////
44
45// constructor / destructor
46/////////////////////////////////////////////////////////////////////////////
47
48DEFINE_EMPTY_CTOR_DTOR (SystemProperties)
49
50HRESULT SystemProperties::FinalConstruct()
51{
52 return S_OK;
53}
54
55void SystemProperties::FinalRelease()
56{
57 uninit ();
58}
59
60// public methods only for internal purposes
61/////////////////////////////////////////////////////////////////////////////
62
63/**
64 * Initializes the system information object.
65 *
66 * @returns COM result indicator
67 */
68HRESULT SystemProperties::init (VirtualBox *aParent)
69{
70 LogFlowThisFunc(("aParent=%p\n", aParent));
71
72 ComAssertRet (aParent, E_FAIL);
73
74 /* Enclose the state transition NotReady->InInit->Ready */
75 AutoInitSpan autoInitSpan(this);
76 AssertReturn(autoInitSpan.isOk(), E_FAIL);
77
78 unconst(mParent) = aParent;
79
80 setDefaultMachineFolder(Utf8Str::Null);
81 setDefaultHardDiskFolder(Utf8Str::Null);
82 setDefaultHardDiskFormat(Utf8Str::Null);
83
84 setRemoteDisplayAuthLibrary(Utf8Str::Null);
85
86 mLogHistoryCount = 3;
87
88 HRESULT rc = S_OK;
89
90 /* Fetch info of all available hd backends. */
91
92 /// @todo NEWMEDIA VDBackendInfo needs to be improved to let us enumerate
93 /// any number of backends
94
95 /// @todo We currently leak memory because it's not actually clear what to
96 /// free in structures returned by VDBackendInfo. Must be fixed ASAP!
97
98 VDBACKENDINFO aVDInfo [100];
99 unsigned cEntries;
100 int vrc = VDBackendInfo (RT_ELEMENTS (aVDInfo), aVDInfo, &cEntries);
101 AssertRC (vrc);
102 if (RT_SUCCESS(vrc))
103 {
104 for (unsigned i = 0; i < cEntries; ++ i)
105 {
106 ComObjPtr<MediumFormat> hdf;
107 rc = hdf.createObject();
108 CheckComRCBreakRC (rc);
109
110 rc = hdf->init (&aVDInfo [i]);
111 CheckComRCBreakRC (rc);
112
113 mMediumFormats.push_back (hdf);
114 }
115 }
116
117 /* Driver defaults which are OS specific */
118#if defined (RT_OS_WINDOWS)
119# ifdef VBOX_WITH_WINMM
120 mDefaultAudioDriver = AudioDriverType_WinMM;
121# else /* VBOX_WITH_WINMM */
122 mDefaultAudioDriver = AudioDriverType_DirectSound;
123# endif /* !VBOX_WITH_WINMM */
124#elif defined (RT_OS_SOLARIS)
125 mDefaultAudioDriver = AudioDriverType_SolAudio;
126#elif defined (RT_OS_LINUX)
127# if defined (VBOX_WITH_PULSE)
128 /* Check for the pulse library & that the pulse audio daemon is running. */
129 if (RTProcIsRunningByName ("pulseaudio") &&
130 RTLdrIsLoadable ("libpulse.so.0"))
131 mDefaultAudioDriver = AudioDriverType_Pulse;
132 else
133# endif /* VBOX_WITH_PULSE */
134# if defined (VBOX_WITH_ALSA)
135 /* Check if we can load the ALSA library */
136 if (RTLdrIsLoadable ("libasound.so.2"))
137 mDefaultAudioDriver = AudioDriverType_ALSA;
138 else
139# endif /* VBOX_WITH_ALSA */
140 mDefaultAudioDriver = AudioDriverType_OSS;
141#elif defined (RT_OS_DARWIN)
142 mDefaultAudioDriver = AudioDriverType_CoreAudio;
143#elif defined (RT_OS_OS2)
144 mDefaultAudioDriver = AudioDriverType_MMP;
145#elif defined (RT_OS_FREEBSD)
146 mDefaultAudioDriver = AudioDriverType_OSS;
147#else
148 mDefaultAudioDriver = AudioDriverType_Null;
149#endif
150
151 /* Confirm a successful initialization */
152 if (SUCCEEDED(rc))
153 autoInitSpan.setSucceeded();
154
155 return rc;
156}
157
158/**
159 * Uninitializes the instance and sets the ready flag to FALSE.
160 * Called either from FinalRelease() or by the parent when it gets destroyed.
161 */
162void SystemProperties::uninit()
163{
164 LogFlowThisFunc(("\n"));
165
166 /* Enclose the state transition Ready->InUninit->NotReady */
167 AutoUninitSpan autoUninitSpan(this);
168 if (autoUninitSpan.uninitDone())
169 return;
170
171 unconst(mParent).setNull();
172}
173
174// ISystemProperties properties
175/////////////////////////////////////////////////////////////////////////////
176
177
178STDMETHODIMP SystemProperties::COMGETTER(MinGuestRAM)(ULONG *minRAM)
179{
180 if (!minRAM)
181 return E_POINTER;
182
183 AutoCaller autoCaller(this);
184 CheckComRCReturnRC(autoCaller.rc());
185
186 /* no need to lock, this is const */
187 AssertCompile(MM_RAM_MIN_IN_MB >= SchemaDefs::MinGuestRAM);
188 *minRAM = MM_RAM_MIN_IN_MB;
189
190 return S_OK;
191}
192
193STDMETHODIMP SystemProperties::COMGETTER(MaxGuestRAM)(ULONG *maxRAM)
194{
195 if (!maxRAM)
196 return E_POINTER;
197
198 AutoCaller autoCaller(this);
199 CheckComRCReturnRC(autoCaller.rc());
200
201 /* no need to lock, this is const */
202 AssertCompile(MM_RAM_MAX_IN_MB <= SchemaDefs::MaxGuestRAM);
203 ULONG maxRAMSys = MM_RAM_MAX_IN_MB;
204 ULONG maxRAMArch = maxRAMSys;
205#if HC_ARCH_BITS == 32 && !defined(RT_OS_DARWIN)
206# ifdef RT_OS_WINDOWS
207 maxRAMArch = UINT32_C(1500);
208# else
209 maxRAMArch = UINT32_C(2560);
210# endif
211#endif
212 *maxRAM = RT_MIN(maxRAMSys, maxRAMArch);
213
214 return S_OK;
215}
216
217STDMETHODIMP SystemProperties::COMGETTER(MinGuestVRAM)(ULONG *minVRAM)
218{
219 if (!minVRAM)
220 return E_POINTER;
221
222 AutoCaller autoCaller(this);
223 CheckComRCReturnRC(autoCaller.rc());
224
225 /* no need to lock, this is const */
226 *minVRAM = SchemaDefs::MinGuestVRAM;
227
228 return S_OK;
229}
230
231STDMETHODIMP SystemProperties::COMGETTER(MaxGuestVRAM)(ULONG *maxVRAM)
232{
233 if (!maxVRAM)
234 return E_POINTER;
235
236 AutoCaller autoCaller(this);
237 CheckComRCReturnRC(autoCaller.rc());
238
239 /* no need to lock, this is const */
240 *maxVRAM = SchemaDefs::MaxGuestVRAM;
241
242 return S_OK;
243}
244
245STDMETHODIMP SystemProperties::COMGETTER(MinGuestCPUCount)(ULONG *minCPUCount)
246{
247 if (!minCPUCount)
248 return E_POINTER;
249
250 AutoCaller autoCaller(this);
251 CheckComRCReturnRC(autoCaller.rc());
252
253 /* no need to lock, this is const */
254 *minCPUCount = SchemaDefs::MinCPUCount; // VMM_MIN_CPU_COUNT
255
256 return S_OK;
257}
258
259STDMETHODIMP SystemProperties::COMGETTER(MaxGuestCPUCount)(ULONG *maxCPUCount)
260{
261 if (!maxCPUCount)
262 return E_POINTER;
263
264 AutoCaller autoCaller(this);
265 CheckComRCReturnRC(autoCaller.rc());
266
267 /* no need to lock, this is const */
268 *maxCPUCount = SchemaDefs::MaxCPUCount; // VMM_MAX_CPU_COUNT
269
270 return S_OK;
271}
272
273STDMETHODIMP SystemProperties::COMGETTER(MaxGuestMonitors)(ULONG *maxMonitors)
274{
275 if (!maxMonitors)
276 return E_POINTER;
277
278 AutoCaller autoCaller(this);
279 CheckComRCReturnRC(autoCaller.rc());
280
281 /* no need to lock, this is const */
282 *maxMonitors = SchemaDefs::MaxGuestMonitors;
283
284 return S_OK;
285}
286
287STDMETHODIMP SystemProperties::COMGETTER(MaxVDISize)(ULONG64 *maxVDISize)
288{
289 if (!maxVDISize)
290 return E_POINTER;
291
292 AutoCaller autoCaller(this);
293 CheckComRCReturnRC(autoCaller.rc());
294
295 /** The BIOS supports currently 32 bit LBA numbers (implementing the full
296 * 48 bit range is in theory trivial, but the crappy compiler makes things
297 * more difficult). This translates to almost 2 TBytes (to be on the safe
298 * side, the reported limit is 1 MiByte less than that, as the total number
299 * of sectors should fit in 32 bits, too), which should bei enough for
300 * the moment. The virtual ATA disks support complete LBA48 (although for
301 * example iSCSI is also currently limited to 32 bit LBA), so the
302 * theoretical maximum disk size is 128 PiByte. The user interface cannot
303 * cope with this in a reasonable way yet. */
304 /* no need to lock, this is const */
305 *maxVDISize = 2048 * 1024 - 1;
306
307 return S_OK;
308}
309
310STDMETHODIMP SystemProperties::COMGETTER(NetworkAdapterCount)(ULONG *count)
311{
312 if (!count)
313 return E_POINTER;
314
315 AutoCaller autoCaller(this);
316 CheckComRCReturnRC(autoCaller.rc());
317
318 /* no need to lock, this is const */
319 *count = SchemaDefs::NetworkAdapterCount;
320
321 return S_OK;
322}
323
324STDMETHODIMP SystemProperties::COMGETTER(SerialPortCount)(ULONG *count)
325{
326 if (!count)
327 return E_POINTER;
328
329 AutoCaller autoCaller(this);
330 CheckComRCReturnRC(autoCaller.rc());
331
332 /* no need to lock, this is const */
333 *count = SchemaDefs::SerialPortCount;
334
335 return S_OK;
336}
337
338STDMETHODIMP SystemProperties::COMGETTER(ParallelPortCount)(ULONG *count)
339{
340 if (!count)
341 return E_POINTER;
342
343 AutoCaller autoCaller(this);
344 CheckComRCReturnRC(autoCaller.rc());
345
346 /* no need to lock, this is const */
347 *count = SchemaDefs::ParallelPortCount;
348
349 return S_OK;
350}
351
352STDMETHODIMP SystemProperties::COMGETTER(MaxBootPosition)(ULONG *aMaxBootPosition)
353{
354 CheckComArgOutPointerValid(aMaxBootPosition);
355
356 AutoCaller autoCaller(this);
357 CheckComRCReturnRC(autoCaller.rc());
358
359 /* no need to lock, this is const */
360 *aMaxBootPosition = SchemaDefs::MaxBootPosition;
361
362 return S_OK;
363}
364
365STDMETHODIMP SystemProperties::GetMaxDevicesPerPortForStorageBus (StorageBus_T aBus, ULONG *aMaxDevicesPerPort)
366{
367 CheckComArgOutPointerValid(aMaxDevicesPerPort);
368
369 AutoCaller autoCaller(this);
370 CheckComRCReturnRC(autoCaller.rc());
371
372 /* no need to lock, this is const */
373 switch (aBus)
374 {
375 case StorageBus_SATA:
376 case StorageBus_SCSI:
377 {
378 /* SATA and both SCSI controllers only support one device per port. */
379 *aMaxDevicesPerPort = 1;
380 break;
381 }
382 case StorageBus_IDE:
383 case StorageBus_Floppy:
384 {
385 /* The IDE and Floppy controllers support 2 devices. One as master
386 * and one as slave (or floppy drive 0 and 1). */
387 *aMaxDevicesPerPort = 2;
388 break;
389 }
390 default:
391 AssertMsgFailed(("Invalid bus type %d\n", aBus));
392 }
393
394 return S_OK;
395}
396
397STDMETHODIMP SystemProperties::GetMinPortCountForStorageBus (StorageBus_T aBus, ULONG *aMinPortCount)
398{
399 CheckComArgOutPointerValid(aMinPortCount);
400
401 AutoCaller autoCaller(this);
402 CheckComRCReturnRC(autoCaller.rc());
403
404 /* no need to lock, this is const */
405 switch (aBus)
406 {
407 case StorageBus_SATA:
408 {
409 *aMinPortCount = 1;
410 break;
411 }
412 case StorageBus_SCSI:
413 {
414 *aMinPortCount = 16;
415 break;
416 }
417 case StorageBus_IDE:
418 {
419 *aMinPortCount = 2;
420 break;
421 }
422 case StorageBus_Floppy:
423 {
424 *aMinPortCount = 1;
425 break;
426 }
427 default:
428 AssertMsgFailed(("Invalid bus type %d\n", aBus));
429 }
430
431 return S_OK;
432}
433
434STDMETHODIMP SystemProperties::GetMaxPortCountForStorageBus (StorageBus_T aBus, ULONG *aMaxPortCount)
435{
436 CheckComArgOutPointerValid(aMaxPortCount);
437
438 AutoCaller autoCaller(this);
439 CheckComRCReturnRC(autoCaller.rc());
440
441 /* no need to lock, this is const */
442 switch (aBus)
443 {
444 case StorageBus_SATA:
445 {
446 *aMaxPortCount = 30;
447 break;
448 }
449 case StorageBus_SCSI:
450 {
451 *aMaxPortCount = 16;
452 break;
453 }
454 case StorageBus_IDE:
455 {
456 *aMaxPortCount = 2;
457 break;
458 }
459 case StorageBus_Floppy:
460 {
461 *aMaxPortCount = 1;
462 break;
463 }
464 default:
465 AssertMsgFailed(("Invalid bus type %d\n", aBus));
466 }
467
468 return S_OK;
469}
470
471STDMETHODIMP SystemProperties::COMGETTER(DefaultMachineFolder) (BSTR *aDefaultMachineFolder)
472{
473 CheckComArgOutPointerValid(aDefaultMachineFolder);
474
475 AutoCaller autoCaller(this);
476 CheckComRCReturnRC(autoCaller.rc());
477
478 AutoReadLock alock(this);
479
480 m_strDefaultMachineFolderFull.cloneTo(aDefaultMachineFolder);
481
482 return S_OK;
483}
484
485STDMETHODIMP SystemProperties::COMSETTER(DefaultMachineFolder) (IN_BSTR aDefaultMachineFolder)
486{
487 AutoCaller autoCaller(this);
488 CheckComRCReturnRC(autoCaller.rc());
489
490 /* VirtualBox::saveSettings() needs a write lock */
491 AutoMultiWriteLock2 alock (mParent, this);
492
493 HRESULT rc = setDefaultMachineFolder (aDefaultMachineFolder);
494 if (SUCCEEDED(rc))
495 rc = mParent->saveSettings();
496
497 return rc;
498}
499
500STDMETHODIMP SystemProperties::COMGETTER(DefaultHardDiskFolder) (BSTR *aDefaultHardDiskFolder)
501{
502 CheckComArgOutPointerValid(aDefaultHardDiskFolder);
503
504 AutoCaller autoCaller(this);
505 CheckComRCReturnRC(autoCaller.rc());
506
507 AutoReadLock alock(this);
508
509 m_strDefaultHardDiskFolderFull.cloneTo(aDefaultHardDiskFolder);
510
511 return S_OK;
512}
513
514STDMETHODIMP SystemProperties::COMSETTER(DefaultHardDiskFolder) (IN_BSTR aDefaultHardDiskFolder)
515{
516 AutoCaller autoCaller(this);
517 CheckComRCReturnRC(autoCaller.rc());
518
519 /* VirtualBox::saveSettings() needs a write lock */
520 AutoMultiWriteLock2 alock (mParent, this);
521
522 HRESULT rc = setDefaultHardDiskFolder (aDefaultHardDiskFolder);
523 if (SUCCEEDED(rc))
524 rc = mParent->saveSettings();
525
526 return rc;
527}
528
529STDMETHODIMP SystemProperties::
530COMGETTER(MediumFormats) (ComSafeArrayOut(IMediumFormat *, aMediumFormats))
531{
532 if (ComSafeArrayOutIsNull(aMediumFormats))
533 return E_POINTER;
534
535 AutoCaller autoCaller(this);
536 CheckComRCReturnRC(autoCaller.rc());
537
538 AutoReadLock alock(this);
539
540 SafeIfaceArray<IMediumFormat> mediumFormats (mMediumFormats);
541 mediumFormats.detachTo(ComSafeArrayOutArg(aMediumFormats));
542
543 return S_OK;
544}
545
546STDMETHODIMP SystemProperties::COMGETTER(DefaultHardDiskFormat) (BSTR *aDefaultHardDiskFormat)
547{
548 CheckComArgOutPointerValid(aDefaultHardDiskFormat);
549
550 AutoCaller autoCaller(this);
551 CheckComRCReturnRC(autoCaller.rc());
552
553 AutoReadLock alock(this);
554
555 m_strDefaultHardDiskFormat.cloneTo(aDefaultHardDiskFormat);
556
557 return S_OK;
558}
559
560STDMETHODIMP SystemProperties::COMSETTER(DefaultHardDiskFormat) (IN_BSTR aDefaultHardDiskFormat)
561{
562 AutoCaller autoCaller(this);
563 CheckComRCReturnRC(autoCaller.rc());
564
565 /* VirtualBox::saveSettings() needs a write lock */
566 AutoMultiWriteLock2 alock (mParent, this);
567
568 HRESULT rc = setDefaultHardDiskFormat (aDefaultHardDiskFormat);
569 if (SUCCEEDED(rc))
570 rc = mParent->saveSettings();
571
572 return rc;
573}
574
575STDMETHODIMP SystemProperties::COMGETTER(RemoteDisplayAuthLibrary) (BSTR *aRemoteDisplayAuthLibrary)
576{
577 CheckComArgOutPointerValid(aRemoteDisplayAuthLibrary);
578
579 AutoCaller autoCaller(this);
580 CheckComRCReturnRC(autoCaller.rc());
581
582 AutoReadLock alock(this);
583
584 m_strRemoteDisplayAuthLibrary.cloneTo(aRemoteDisplayAuthLibrary);
585
586 return S_OK;
587}
588
589STDMETHODIMP SystemProperties::COMSETTER(RemoteDisplayAuthLibrary) (IN_BSTR aRemoteDisplayAuthLibrary)
590{
591 AutoCaller autoCaller(this);
592 CheckComRCReturnRC(autoCaller.rc());
593
594 /* VirtualBox::saveSettings() needs a write lock */
595 AutoMultiWriteLock2 alock (mParent, this);
596
597 HRESULT rc = setRemoteDisplayAuthLibrary (aRemoteDisplayAuthLibrary);
598 if (SUCCEEDED(rc))
599 rc = mParent->saveSettings();
600
601 return rc;
602}
603
604STDMETHODIMP SystemProperties::COMGETTER(WebServiceAuthLibrary) (BSTR *aWebServiceAuthLibrary)
605{
606 CheckComArgOutPointerValid(aWebServiceAuthLibrary);
607
608 AutoCaller autoCaller(this);
609 CheckComRCReturnRC(autoCaller.rc());
610
611 AutoReadLock alock(this);
612
613 m_strWebServiceAuthLibrary.cloneTo(aWebServiceAuthLibrary);
614
615 return S_OK;
616}
617
618STDMETHODIMP SystemProperties::COMSETTER(WebServiceAuthLibrary) (IN_BSTR aWebServiceAuthLibrary)
619{
620 AutoCaller autoCaller(this);
621 CheckComRCReturnRC(autoCaller.rc());
622
623 /* VirtualBox::saveSettings() needs a write lock */
624 AutoMultiWriteLock2 alock (mParent, this);
625
626 HRESULT rc = setWebServiceAuthLibrary (aWebServiceAuthLibrary);
627 if (SUCCEEDED(rc))
628 rc = mParent->saveSettings();
629
630 return rc;
631}
632
633STDMETHODIMP SystemProperties::COMGETTER(LogHistoryCount) (ULONG *count)
634{
635 if (!count)
636 return E_POINTER;
637
638 AutoCaller autoCaller(this);
639 CheckComRCReturnRC(autoCaller.rc());
640
641 AutoReadLock alock(this);
642
643 *count = mLogHistoryCount;
644
645 return S_OK;
646}
647
648STDMETHODIMP SystemProperties::COMSETTER(LogHistoryCount) (ULONG count)
649{
650 AutoCaller autoCaller(this);
651 CheckComRCReturnRC(autoCaller.rc());
652
653 /* VirtualBox::saveSettings() needs a write lock */
654 AutoMultiWriteLock2 alock (mParent, this);
655
656 mLogHistoryCount = count;
657
658 HRESULT rc = mParent->saveSettings();
659
660 return rc;
661}
662
663STDMETHODIMP SystemProperties::COMGETTER(DefaultAudioDriver) (AudioDriverType_T *aAudioDriver)
664{
665 if (!aAudioDriver)
666 return E_POINTER;
667
668 AutoCaller autoCaller(this);
669 CheckComRCReturnRC(autoCaller.rc());
670
671 AutoReadLock alock(this);
672
673 *aAudioDriver = mDefaultAudioDriver;
674
675 return S_OK;
676}
677
678// public methods only for internal purposes
679/////////////////////////////////////////////////////////////////////////////
680
681HRESULT SystemProperties::loadSettings(const settings::SystemProperties &data)
682{
683 AutoCaller autoCaller(this);
684 CheckComRCReturnRC(autoCaller.rc());
685
686 AutoWriteLock alock(this);
687
688 HRESULT rc = S_OK;
689
690 rc = setDefaultMachineFolder(data.strDefaultMachineFolder);
691 CheckComRCReturnRC(rc);
692
693 rc = setDefaultHardDiskFolder(data.strDefaultHardDiskFolder);
694 CheckComRCReturnRC(rc);
695
696 rc = setDefaultHardDiskFormat(data.strDefaultHardDiskFormat);
697 CheckComRCReturnRC(rc);
698
699 rc = setRemoteDisplayAuthLibrary(data.strRemoteDisplayAuthLibrary);
700 CheckComRCReturnRC(rc);
701
702 rc = setWebServiceAuthLibrary(data.strWebServiceAuthLibrary);
703 CheckComRCReturnRC(rc);
704
705 mLogHistoryCount = data.ulLogHistoryCount;
706
707 return S_OK;
708}
709
710HRESULT SystemProperties::saveSettings(settings::SystemProperties &data)
711{
712 AutoCaller autoCaller(this);
713 CheckComRCReturnRC(autoCaller.rc());
714
715 AutoReadLock alock(this);
716
717 data.strDefaultMachineFolder = m_strDefaultMachineFolder;
718 data.strDefaultHardDiskFolder = m_strDefaultHardDiskFolder;
719 data.strDefaultHardDiskFormat = m_strDefaultHardDiskFormat;
720 data.strRemoteDisplayAuthLibrary = m_strRemoteDisplayAuthLibrary;
721 data.strWebServiceAuthLibrary = m_strWebServiceAuthLibrary;
722 data.ulLogHistoryCount = mLogHistoryCount;
723
724 return S_OK;
725}
726
727/**
728 * Returns a medium format object corresponding to the given format
729 * identifier or null if no such format.
730 *
731 * @param aFormat Format identifier.
732 *
733 * @return ComObjPtr<MediumFormat>
734 */
735ComObjPtr<MediumFormat> SystemProperties::mediumFormat (CBSTR aFormat)
736{
737 ComObjPtr<MediumFormat> format;
738
739 AutoCaller autoCaller(this);
740 AssertComRCReturn (autoCaller.rc(), format);
741
742 AutoReadLock alock(this);
743
744 for (MediumFormatList::const_iterator it = mMediumFormats.begin();
745 it != mMediumFormats.end(); ++ it)
746 {
747 /* MediumFormat is all const, no need to lock */
748
749 if ((*it)->id().compareIgnoreCase (aFormat) == 0)
750 {
751 format = *it;
752 break;
753 }
754 }
755
756 return format;
757}
758
759// private methods
760/////////////////////////////////////////////////////////////////////////////
761
762HRESULT SystemProperties::setDefaultMachineFolder(const Utf8Str &aPath)
763{
764 Utf8Str path(aPath);
765 if (path.isEmpty())
766 path = "Machines";
767
768 /* get the full file name */
769 Utf8Str folder;
770 int vrc = mParent->calculateFullPath(path, folder);
771 if (RT_FAILURE(vrc))
772 return setError(E_FAIL,
773 tr("Invalid default machine folder '%s' (%Rrc)"),
774 path.raw(),
775 vrc);
776
777 m_strDefaultMachineFolder = path;
778 m_strDefaultMachineFolderFull = folder;
779
780 return S_OK;
781}
782
783HRESULT SystemProperties::setDefaultHardDiskFolder(const Utf8Str &aPath)
784{
785 Utf8Str path(aPath);
786 if (path.isEmpty())
787 path = "HardDisks";
788
789 /* get the full file name */
790 Utf8Str folder;
791 int vrc = mParent->calculateFullPath(path, folder);
792 if (RT_FAILURE(vrc))
793 return setError(E_FAIL,
794 tr("Invalid default hard disk folder '%s' (%Rrc)"),
795 path.raw(),
796 vrc);
797
798 m_strDefaultHardDiskFolder = path;
799 m_strDefaultHardDiskFolderFull = folder;
800
801 return S_OK;
802}
803
804HRESULT SystemProperties::setDefaultHardDiskFormat(const Utf8Str &aFormat)
805{
806 if (!aFormat.isEmpty())
807 m_strDefaultHardDiskFormat = aFormat;
808 else
809 m_strDefaultHardDiskFormat = "VDI";
810
811 return S_OK;
812}
813
814HRESULT SystemProperties::setRemoteDisplayAuthLibrary(const Utf8Str &aPath)
815{
816 if (!aPath.isEmpty())
817 m_strRemoteDisplayAuthLibrary = aPath;
818 else
819 m_strRemoteDisplayAuthLibrary = "VRDPAuth";
820
821 return S_OK;
822}
823
824HRESULT SystemProperties::setWebServiceAuthLibrary(const Utf8Str &aPath)
825{
826 if (!aPath.isEmpty())
827 m_strWebServiceAuthLibrary = aPath;
828 else
829 m_strWebServiceAuthLibrary = "VRDPAuth";
830
831 return S_OK;
832}
833
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