VirtualBox

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

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

Add 32 bits host guest memory size restriction here
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.6 KB
Line 
1/* $Id: SystemPropertiesImpl.cpp 22595 2009-08-31 11:54:30Z 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
41// defines
42/////////////////////////////////////////////////////////////////////////////
43
44// constructor / destructor
45/////////////////////////////////////////////////////////////////////////////
46
47DEFINE_EMPTY_CTOR_DTOR (SystemProperties)
48
49HRESULT SystemProperties::FinalConstruct()
50{
51 return S_OK;
52}
53
54void SystemProperties::FinalRelease()
55{
56 uninit ();
57}
58
59// public methods only for internal purposes
60/////////////////////////////////////////////////////////////////////////////
61
62/**
63 * Initializes the system information object.
64 *
65 * @returns COM result indicator
66 */
67HRESULT SystemProperties::init (VirtualBox *aParent)
68{
69 LogFlowThisFunc(("aParent=%p\n", aParent));
70
71 ComAssertRet (aParent, E_FAIL);
72
73 /* Enclose the state transition NotReady->InInit->Ready */
74 AutoInitSpan autoInitSpan(this);
75 AssertReturn(autoInitSpan.isOk(), E_FAIL);
76
77 unconst(mParent) = aParent;
78
79 setDefaultMachineFolder(Utf8Str::Null);
80 setDefaultHardDiskFolder(Utf8Str::Null);
81 setDefaultHardDiskFormat(Utf8Str::Null);
82
83 setRemoteDisplayAuthLibrary(Utf8Str::Null);
84
85 mLogHistoryCount = 3;
86
87 HRESULT rc = S_OK;
88
89 /* Fetch info of all available hd backends. */
90
91 /// @todo NEWMEDIA VDBackendInfo needs to be improved to let us enumerate
92 /// any number of backends
93
94 /// @todo We currently leak memory because it's not actually clear what to
95 /// free in structures returned by VDBackendInfo. Must be fixed ASAP!
96
97 VDBACKENDINFO aVDInfo [100];
98 unsigned cEntries;
99 int vrc = VDBackendInfo (RT_ELEMENTS (aVDInfo), aVDInfo, &cEntries);
100 AssertRC (vrc);
101 if (RT_SUCCESS(vrc))
102 {
103 for (unsigned i = 0; i < cEntries; ++ i)
104 {
105 ComObjPtr<HardDiskFormat> hdf;
106 rc = hdf.createObject();
107 CheckComRCBreakRC (rc);
108
109 rc = hdf->init (&aVDInfo [i]);
110 CheckComRCBreakRC (rc);
111
112 mHardDiskFormats.push_back (hdf);
113 }
114 }
115
116 /* Driver defaults which are OS specific */
117#if defined (RT_OS_WINDOWS)
118# ifdef VBOX_WITH_WINMM
119 mDefaultAudioDriver = AudioDriverType_WinMM;
120# else /* VBOX_WITH_WINMM */
121 mDefaultAudioDriver = AudioDriverType_DirectSound;
122# endif /* !VBOX_WITH_WINMM */
123#elif defined (RT_OS_SOLARIS)
124 mDefaultAudioDriver = AudioDriverType_SolAudio;
125#elif defined (RT_OS_LINUX)
126# if defined (VBOX_WITH_PULSE)
127 /* Check for the pulse library & that the pulse audio daemon is running. */
128 if (RTProcIsRunningByName ("pulseaudio") &&
129 RTLdrIsLoadable ("libpulse.so.0"))
130 mDefaultAudioDriver = AudioDriverType_Pulse;
131 else
132# endif /* VBOX_WITH_PULSE */
133# if defined (VBOX_WITH_ALSA)
134 /* Check if we can load the ALSA library */
135 if (RTLdrIsLoadable ("libasound.so.2"))
136 mDefaultAudioDriver = AudioDriverType_ALSA;
137 else
138# endif /* VBOX_WITH_ALSA */
139 mDefaultAudioDriver = AudioDriverType_OSS;
140#elif defined (RT_OS_DARWIN)
141 mDefaultAudioDriver = AudioDriverType_CoreAudio;
142#elif defined (RT_OS_OS2)
143 mDefaultAudioDriver = AudioDriverType_MMP;
144#elif defined (RT_OS_FREEBSD)
145 mDefaultAudioDriver = AudioDriverType_OSS;
146#else
147 mDefaultAudioDriver = AudioDriverType_Null;
148#endif
149
150 /* Confirm a successful initialization */
151 if (SUCCEEDED(rc))
152 autoInitSpan.setSucceeded();
153
154 return rc;
155}
156
157/**
158 * Uninitializes the instance and sets the ready flag to FALSE.
159 * Called either from FinalRelease() or by the parent when it gets destroyed.
160 */
161void SystemProperties::uninit()
162{
163 LogFlowThisFunc(("\n"));
164
165 /* Enclose the state transition Ready->InUninit->NotReady */
166 AutoUninitSpan autoUninitSpan(this);
167 if (autoUninitSpan.uninitDone())
168 return;
169
170 unconst(mParent).setNull();
171}
172
173// ISystemProperties properties
174/////////////////////////////////////////////////////////////////////////////
175
176
177STDMETHODIMP SystemProperties::COMGETTER(MinGuestRAM)(ULONG *minRAM)
178{
179 if (!minRAM)
180 return E_POINTER;
181
182 AutoCaller autoCaller(this);
183 CheckComRCReturnRC(autoCaller.rc());
184
185 /* no need to lock, this is const */
186 AssertCompile(MM_RAM_MIN_IN_MB >= SchemaDefs::MinGuestRAM);
187 *minRAM = MM_RAM_MIN_IN_MB;
188
189 return S_OK;
190}
191
192STDMETHODIMP SystemProperties::COMGETTER(MaxGuestRAM)(ULONG *maxRAM)
193{
194 if (!maxRAM)
195 return E_POINTER;
196
197 AutoCaller autoCaller(this);
198 CheckComRCReturnRC(autoCaller.rc());
199
200 /* no need to lock, this is const */
201 AssertCompile(MM_RAM_MAX_IN_MB <= SchemaDefs::MaxGuestRAM);
202 ULONG maxRAMSys = MM_RAM_MAX_IN_MB;
203 ULONG maxRAMArch = maxRAMSys;
204#if HC_ARCH_BITS == 32 && !defined(RT_OS_DARWIN)
205# ifdef RT_OS_WINDOWS
206 maxRAMArch = UINT32_C(1500);
207# else
208 maxRAMArch = UINT32_C(2560);
209# endif
210#endif
211 *maxRAM = RT_MIN(maxRAMSys, maxRAMArch);
212
213 return S_OK;
214}
215
216STDMETHODIMP SystemProperties::COMGETTER(MinGuestVRAM)(ULONG *minVRAM)
217{
218 if (!minVRAM)
219 return E_POINTER;
220
221 AutoCaller autoCaller(this);
222 CheckComRCReturnRC(autoCaller.rc());
223
224 /* no need to lock, this is const */
225 *minVRAM = SchemaDefs::MinGuestVRAM;
226
227 return S_OK;
228}
229
230STDMETHODIMP SystemProperties::COMGETTER(MaxGuestVRAM)(ULONG *maxVRAM)
231{
232 if (!maxVRAM)
233 return E_POINTER;
234
235 AutoCaller autoCaller(this);
236 CheckComRCReturnRC(autoCaller.rc());
237
238 /* no need to lock, this is const */
239 *maxVRAM = SchemaDefs::MaxGuestVRAM;
240
241 return S_OK;
242}
243
244STDMETHODIMP SystemProperties::COMGETTER(MinGuestCPUCount)(ULONG *minCPUCount)
245{
246 if (!minCPUCount)
247 return E_POINTER;
248
249 AutoCaller autoCaller(this);
250 CheckComRCReturnRC(autoCaller.rc());
251
252 /* no need to lock, this is const */
253 *minCPUCount = SchemaDefs::MinCPUCount; // VMM_MIN_CPU_COUNT
254
255 return S_OK;
256}
257
258STDMETHODIMP SystemProperties::COMGETTER(MaxGuestCPUCount)(ULONG *maxCPUCount)
259{
260 if (!maxCPUCount)
261 return E_POINTER;
262
263 AutoCaller autoCaller(this);
264 CheckComRCReturnRC(autoCaller.rc());
265
266 /* no need to lock, this is const */
267 *maxCPUCount = SchemaDefs::MaxCPUCount; // VMM_MAX_CPU_COUNT
268
269 return S_OK;
270}
271
272STDMETHODIMP SystemProperties::COMGETTER(MaxGuestMonitors)(ULONG *maxMonitors)
273{
274 if (!maxMonitors)
275 return E_POINTER;
276
277 AutoCaller autoCaller(this);
278 CheckComRCReturnRC(autoCaller.rc());
279
280 /* no need to lock, this is const */
281 *maxMonitors = SchemaDefs::MaxGuestMonitors;
282
283 return S_OK;
284}
285
286STDMETHODIMP SystemProperties::COMGETTER(MaxVDISize)(ULONG64 *maxVDISize)
287{
288 if (!maxVDISize)
289 return E_POINTER;
290
291 AutoCaller autoCaller(this);
292 CheckComRCReturnRC(autoCaller.rc());
293
294 /** The BIOS supports currently 32 bit LBA numbers (implementing the full
295 * 48 bit range is in theory trivial, but the crappy compiler makes things
296 * more difficult). This translates to almost 2 TBytes (to be on the safe
297 * side, the reported limit is 1 MiByte less than that, as the total number
298 * of sectors should fit in 32 bits, too), which should bei enough for
299 * the moment. The virtual ATA disks support complete LBA48 (although for
300 * example iSCSI is also currently limited to 32 bit LBA), so the
301 * theoretical maximum disk size is 128 PiByte. The user interface cannot
302 * cope with this in a reasonable way yet. */
303 /* no need to lock, this is const */
304 *maxVDISize = 2048 * 1024 - 1;
305
306 return S_OK;
307}
308
309STDMETHODIMP SystemProperties::COMGETTER(NetworkAdapterCount)(ULONG *count)
310{
311 if (!count)
312 return E_POINTER;
313
314 AutoCaller autoCaller(this);
315 CheckComRCReturnRC(autoCaller.rc());
316
317 /* no need to lock, this is const */
318 *count = SchemaDefs::NetworkAdapterCount;
319
320 return S_OK;
321}
322
323STDMETHODIMP SystemProperties::COMGETTER(SerialPortCount)(ULONG *count)
324{
325 if (!count)
326 return E_POINTER;
327
328 AutoCaller autoCaller(this);
329 CheckComRCReturnRC(autoCaller.rc());
330
331 /* no need to lock, this is const */
332 *count = SchemaDefs::SerialPortCount;
333
334 return S_OK;
335}
336
337STDMETHODIMP SystemProperties::COMGETTER(ParallelPortCount)(ULONG *count)
338{
339 if (!count)
340 return E_POINTER;
341
342 AutoCaller autoCaller(this);
343 CheckComRCReturnRC(autoCaller.rc());
344
345 /* no need to lock, this is const */
346 *count = SchemaDefs::ParallelPortCount;
347
348 return S_OK;
349}
350
351STDMETHODIMP SystemProperties::COMGETTER(MaxBootPosition)(ULONG *aMaxBootPosition)
352{
353 CheckComArgOutPointerValid(aMaxBootPosition);
354
355 AutoCaller autoCaller(this);
356 CheckComRCReturnRC(autoCaller.rc());
357
358 /* no need to lock, this is const */
359 *aMaxBootPosition = SchemaDefs::MaxBootPosition;
360
361 return S_OK;
362}
363
364STDMETHODIMP SystemProperties::COMGETTER(DefaultMachineFolder) (BSTR *aDefaultMachineFolder)
365{
366 CheckComArgOutPointerValid(aDefaultMachineFolder);
367
368 AutoCaller autoCaller(this);
369 CheckComRCReturnRC(autoCaller.rc());
370
371 AutoReadLock alock(this);
372
373 m_strDefaultMachineFolderFull.cloneTo(aDefaultMachineFolder);
374
375 return S_OK;
376}
377
378STDMETHODIMP SystemProperties::COMSETTER(DefaultMachineFolder) (IN_BSTR aDefaultMachineFolder)
379{
380 AutoCaller autoCaller(this);
381 CheckComRCReturnRC(autoCaller.rc());
382
383 /* VirtualBox::saveSettings() needs a write lock */
384 AutoMultiWriteLock2 alock (mParent, this);
385
386 HRESULT rc = setDefaultMachineFolder (aDefaultMachineFolder);
387 if (SUCCEEDED(rc))
388 rc = mParent->saveSettings();
389
390 return rc;
391}
392
393STDMETHODIMP SystemProperties::COMGETTER(DefaultHardDiskFolder) (BSTR *aDefaultHardDiskFolder)
394{
395 CheckComArgOutPointerValid(aDefaultHardDiskFolder);
396
397 AutoCaller autoCaller(this);
398 CheckComRCReturnRC(autoCaller.rc());
399
400 AutoReadLock alock(this);
401
402 m_strDefaultHardDiskFolderFull.cloneTo(aDefaultHardDiskFolder);
403
404 return S_OK;
405}
406
407STDMETHODIMP SystemProperties::COMSETTER(DefaultHardDiskFolder) (IN_BSTR aDefaultHardDiskFolder)
408{
409 AutoCaller autoCaller(this);
410 CheckComRCReturnRC(autoCaller.rc());
411
412 /* VirtualBox::saveSettings() needs a write lock */
413 AutoMultiWriteLock2 alock (mParent, this);
414
415 HRESULT rc = setDefaultHardDiskFolder (aDefaultHardDiskFolder);
416 if (SUCCEEDED(rc))
417 rc = mParent->saveSettings();
418
419 return rc;
420}
421
422STDMETHODIMP SystemProperties::
423COMGETTER(HardDiskFormats) (ComSafeArrayOut(IHardDiskFormat *, aHardDiskFormats))
424{
425 if (ComSafeArrayOutIsNull(aHardDiskFormats))
426 return E_POINTER;
427
428 AutoCaller autoCaller(this);
429 CheckComRCReturnRC(autoCaller.rc());
430
431 AutoReadLock alock(this);
432
433 SafeIfaceArray<IHardDiskFormat> hardDiskFormats (mHardDiskFormats);
434 hardDiskFormats.detachTo(ComSafeArrayOutArg(aHardDiskFormats));
435
436 return S_OK;
437}
438
439STDMETHODIMP SystemProperties::COMGETTER(DefaultHardDiskFormat) (BSTR *aDefaultHardDiskFormat)
440{
441 CheckComArgOutPointerValid(aDefaultHardDiskFormat);
442
443 AutoCaller autoCaller(this);
444 CheckComRCReturnRC(autoCaller.rc());
445
446 AutoReadLock alock(this);
447
448 m_strDefaultHardDiskFormat.cloneTo(aDefaultHardDiskFormat);
449
450 return S_OK;
451}
452
453STDMETHODIMP SystemProperties::COMSETTER(DefaultHardDiskFormat) (IN_BSTR aDefaultHardDiskFormat)
454{
455 AutoCaller autoCaller(this);
456 CheckComRCReturnRC(autoCaller.rc());
457
458 /* VirtualBox::saveSettings() needs a write lock */
459 AutoMultiWriteLock2 alock (mParent, this);
460
461 HRESULT rc = setDefaultHardDiskFormat (aDefaultHardDiskFormat);
462 if (SUCCEEDED(rc))
463 rc = mParent->saveSettings();
464
465 return rc;
466}
467
468STDMETHODIMP SystemProperties::COMGETTER(RemoteDisplayAuthLibrary) (BSTR *aRemoteDisplayAuthLibrary)
469{
470 CheckComArgOutPointerValid(aRemoteDisplayAuthLibrary);
471
472 AutoCaller autoCaller(this);
473 CheckComRCReturnRC(autoCaller.rc());
474
475 AutoReadLock alock(this);
476
477 m_strRemoteDisplayAuthLibrary.cloneTo(aRemoteDisplayAuthLibrary);
478
479 return S_OK;
480}
481
482STDMETHODIMP SystemProperties::COMSETTER(RemoteDisplayAuthLibrary) (IN_BSTR aRemoteDisplayAuthLibrary)
483{
484 AutoCaller autoCaller(this);
485 CheckComRCReturnRC(autoCaller.rc());
486
487 /* VirtualBox::saveSettings() needs a write lock */
488 AutoMultiWriteLock2 alock (mParent, this);
489
490 HRESULT rc = setRemoteDisplayAuthLibrary (aRemoteDisplayAuthLibrary);
491 if (SUCCEEDED(rc))
492 rc = mParent->saveSettings();
493
494 return rc;
495}
496
497STDMETHODIMP SystemProperties::COMGETTER(WebServiceAuthLibrary) (BSTR *aWebServiceAuthLibrary)
498{
499 CheckComArgOutPointerValid(aWebServiceAuthLibrary);
500
501 AutoCaller autoCaller(this);
502 CheckComRCReturnRC(autoCaller.rc());
503
504 AutoReadLock alock(this);
505
506 m_strWebServiceAuthLibrary.cloneTo(aWebServiceAuthLibrary);
507
508 return S_OK;
509}
510
511STDMETHODIMP SystemProperties::COMSETTER(WebServiceAuthLibrary) (IN_BSTR aWebServiceAuthLibrary)
512{
513 AutoCaller autoCaller(this);
514 CheckComRCReturnRC(autoCaller.rc());
515
516 /* VirtualBox::saveSettings() needs a write lock */
517 AutoMultiWriteLock2 alock (mParent, this);
518
519 HRESULT rc = setWebServiceAuthLibrary (aWebServiceAuthLibrary);
520 if (SUCCEEDED(rc))
521 rc = mParent->saveSettings();
522
523 return rc;
524}
525
526STDMETHODIMP SystemProperties::COMGETTER(LogHistoryCount) (ULONG *count)
527{
528 if (!count)
529 return E_POINTER;
530
531 AutoCaller autoCaller(this);
532 CheckComRCReturnRC(autoCaller.rc());
533
534 AutoReadLock alock(this);
535
536 *count = mLogHistoryCount;
537
538 return S_OK;
539}
540
541STDMETHODIMP SystemProperties::COMSETTER(LogHistoryCount) (ULONG count)
542{
543 AutoCaller autoCaller(this);
544 CheckComRCReturnRC(autoCaller.rc());
545
546 /* VirtualBox::saveSettings() needs a write lock */
547 AutoMultiWriteLock2 alock (mParent, this);
548
549 mLogHistoryCount = count;
550
551 HRESULT rc = mParent->saveSettings();
552
553 return rc;
554}
555
556STDMETHODIMP SystemProperties::COMGETTER(DefaultAudioDriver) (AudioDriverType_T *aAudioDriver)
557{
558 if (!aAudioDriver)
559 return E_POINTER;
560
561 AutoCaller autoCaller(this);
562 CheckComRCReturnRC(autoCaller.rc());
563
564 AutoReadLock alock(this);
565
566 *aAudioDriver = mDefaultAudioDriver;
567
568 return S_OK;
569}
570
571// public methods only for internal purposes
572/////////////////////////////////////////////////////////////////////////////
573
574HRESULT SystemProperties::loadSettings(const settings::SystemProperties &data)
575{
576 AutoCaller autoCaller(this);
577 CheckComRCReturnRC(autoCaller.rc());
578
579 AutoWriteLock alock(this);
580
581 HRESULT rc = S_OK;
582
583 rc = setDefaultMachineFolder(data.strDefaultMachineFolder);
584 CheckComRCReturnRC(rc);
585
586 rc = setDefaultHardDiskFolder(data.strDefaultHardDiskFolder);
587 CheckComRCReturnRC(rc);
588
589 rc = setDefaultHardDiskFormat(data.strDefaultHardDiskFormat);
590 CheckComRCReturnRC(rc);
591
592 rc = setRemoteDisplayAuthLibrary(data.strRemoteDisplayAuthLibrary);
593 CheckComRCReturnRC(rc);
594
595 rc = setWebServiceAuthLibrary(data.strWebServiceAuthLibrary);
596 CheckComRCReturnRC(rc);
597
598 mLogHistoryCount = data.ulLogHistoryCount;
599
600 return S_OK;
601}
602
603HRESULT SystemProperties::saveSettings(settings::SystemProperties &data)
604{
605 AutoCaller autoCaller(this);
606 CheckComRCReturnRC(autoCaller.rc());
607
608 AutoReadLock alock(this);
609
610 data.strDefaultMachineFolder = m_strDefaultMachineFolder;
611 data.strDefaultHardDiskFolder = m_strDefaultHardDiskFolder;
612 data.strDefaultHardDiskFormat = m_strDefaultHardDiskFormat;
613 data.strRemoteDisplayAuthLibrary = m_strRemoteDisplayAuthLibrary;
614 data.strWebServiceAuthLibrary = m_strWebServiceAuthLibrary;
615 data.ulLogHistoryCount = mLogHistoryCount;
616
617 return S_OK;
618}
619
620/**
621 * Rerurns a hard disk format object corresponding to the given format
622 * identifier or null if no such format.
623 *
624 * @param aFormat Format identifier.
625 *
626 * @return ComObjPtr<HardDiskFormat>
627 */
628ComObjPtr<HardDiskFormat> SystemProperties::hardDiskFormat (CBSTR aFormat)
629{
630 ComObjPtr<HardDiskFormat> format;
631
632 AutoCaller autoCaller(this);
633 AssertComRCReturn (autoCaller.rc(), format);
634
635 AutoReadLock alock(this);
636
637 for (HardDiskFormatList::const_iterator it = mHardDiskFormats.begin();
638 it != mHardDiskFormats.end(); ++ it)
639 {
640 /* HardDiskFormat is all const, no need to lock */
641
642 if ((*it)->id().compareIgnoreCase (aFormat) == 0)
643 {
644 format = *it;
645 break;
646 }
647 }
648
649 return format;
650}
651
652// private methods
653/////////////////////////////////////////////////////////////////////////////
654
655HRESULT SystemProperties::setDefaultMachineFolder(const Utf8Str &aPath)
656{
657 Utf8Str path(aPath);
658 if (path.isEmpty())
659 path = "Machines";
660
661 /* get the full file name */
662 Utf8Str folder;
663 int vrc = mParent->calculateFullPath(path, folder);
664 if (RT_FAILURE(vrc))
665 return setError(E_FAIL,
666 tr("Invalid default machine folder '%s' (%Rrc)"),
667 path.raw(),
668 vrc);
669
670 m_strDefaultMachineFolder = path;
671 m_strDefaultMachineFolderFull = folder;
672
673 return S_OK;
674}
675
676HRESULT SystemProperties::setDefaultHardDiskFolder(const Utf8Str &aPath)
677{
678 Utf8Str path(aPath);
679 if (path.isEmpty())
680 path = "HardDisks";
681
682 /* get the full file name */
683 Utf8Str folder;
684 int vrc = mParent->calculateFullPath(path, folder);
685 if (RT_FAILURE(vrc))
686 return setError(E_FAIL,
687 tr("Invalid default hard disk folder '%s' (%Rrc)"),
688 path.raw(),
689 vrc);
690
691 m_strDefaultHardDiskFolder = path;
692 m_strDefaultHardDiskFolderFull = folder;
693
694 return S_OK;
695}
696
697HRESULT SystemProperties::setDefaultHardDiskFormat(const Utf8Str &aFormat)
698{
699 if (!aFormat.isEmpty())
700 m_strDefaultHardDiskFormat = aFormat;
701 else
702 m_strDefaultHardDiskFormat = "VDI";
703
704 return S_OK;
705}
706
707HRESULT SystemProperties::setRemoteDisplayAuthLibrary(const Utf8Str &aPath)
708{
709 if (!aPath.isEmpty())
710 m_strRemoteDisplayAuthLibrary = aPath;
711 else
712 m_strRemoteDisplayAuthLibrary = "VRDPAuth";
713
714 return S_OK;
715}
716
717HRESULT SystemProperties::setWebServiceAuthLibrary(const Utf8Str &aPath)
718{
719 if (!aPath.isEmpty())
720 m_strWebServiceAuthLibrary = aPath;
721 else
722 m_strWebServiceAuthLibrary = "VRDPAuth";
723
724 return S_OK;
725}
726
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