SystemPropertiesImpl.cpp@ 76542

最後變更在這個檔案從76542是 76474,由 vboxsync 提交於 6 年前
scm --fix-err-h src/ (bugref:9344)
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 40.5 KB

行
1	/* $Id: SystemPropertiesImpl.cpp 76474 2018-12-25 07:21:57Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.alldomusa.eu.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#include "SystemPropertiesImpl.h"
19	#include "VirtualBoxImpl.h"
20	#include "MachineImpl.h"
21	#ifdef VBOX_WITH_EXTPACK
22	# include "ExtPackManagerImpl.h"
23	#endif
24	#include "AutoCaller.h"
25	#include "Global.h"
26	#include "Logging.h"
27	#include "AutostartDb.h"
28
29	// generated header
30	#include "SchemaDefs.h"
31
32	#include <iprt/dir.h>
33	#include <iprt/ldr.h>
34	#include <iprt/path.h>
35	#include <iprt/string.h>
36	#include <iprt/uri.h>
37	#include <iprt/cpp/utils.h>
38
39	#include <iprt/errcore.h>
40	#include <VBox/param.h>
41	#include <VBox/settings.h>
42	#include <VBox/vd.h>
43
44	// defines
45	/////////////////////////////////////////////////////////////////////////////
46
47	// constructor / destructor
48	/////////////////////////////////////////////////////////////////////////////
49
50	SystemProperties::SystemProperties()
51	: mParent(NULL),
52	m(new settings::SystemProperties)
53	{
54	}
55
56	SystemProperties::~SystemProperties()
57	{
58	delete m;
59	}
60
61
62	HRESULT SystemProperties::FinalConstruct()
63	{
64	return BaseFinalConstruct();
65	}
66
67	void SystemProperties::FinalRelease()
68	{
69	uninit();
70	BaseFinalRelease();
71	}
72
73	// public methods only for internal purposes
74	/////////////////////////////////////////////////////////////////////////////
75
76	/**
77	* Initializes the system information object.
78	*
79	* @returns COM result indicator
80	*/
81	HRESULT SystemProperties::init(VirtualBox *aParent)
82	{
83	LogFlowThisFunc(("aParent=%p\n", aParent));
84
85	ComAssertRet(aParent, E_FAIL);
86
87	/* Enclose the state transition NotReady->InInit->Ready */
88	AutoInitSpan autoInitSpan(this);
89	AssertReturn(autoInitSpan.isOk(), E_FAIL);
90
91	unconst(mParent) = aParent;
92
93	i_setDefaultMachineFolder(Utf8Str::Empty);
94	i_setLoggingLevel(Utf8Str::Empty);
95	i_setDefaultHardDiskFormat(Utf8Str::Empty);
96
97	i_setVRDEAuthLibrary(Utf8Str::Empty);
98	i_setDefaultVRDEExtPack(Utf8Str::Empty);
99
100	m->uLogHistoryCount = 3;
101
102
103	/* On Windows, OS X and Solaris, HW virtualization use isn't exclusive
104	* by default so that VT-x or AMD-V can be shared with other
105	* hypervisors without requiring user intervention.
106	* NB: See also SystemProperties constructor in settings.h
107	*/
108	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_WINDOWS) \|\| defined(RT_OS_SOLARIS)
109	m->fExclusiveHwVirt = false;
110	#else
111	m->fExclusiveHwVirt = true;
112	#endif
113
114	HRESULT rc = S_OK;
115
116	/* Fetch info of all available hd backends. */
117
118	/// @todo NEWMEDIA VDBackendInfo needs to be improved to let us enumerate
119	/// any number of backends
120
121	VDBACKENDINFO aVDInfo[100];
122	unsigned cEntries;
123	int vrc = VDBackendInfo(RT_ELEMENTS(aVDInfo), aVDInfo, &cEntries);
124	AssertRC(vrc);
125	if (RT_SUCCESS(vrc))
126	{
127	for (unsigned i = 0; i < cEntries; ++ i)
128	{
129	ComObjPtr<MediumFormat> hdf;
130	rc = hdf.createObject();
131	if (FAILED(rc)) break;
132
133	rc = hdf->init(&aVDInfo[i]);
134	if (FAILED(rc)) break;
135
136	m_llMediumFormats.push_back(hdf);
137	}
138	}
139
140	/* Confirm a successful initialization */
141	if (SUCCEEDED(rc))
142	autoInitSpan.setSucceeded();
143
144	return rc;
145	}
146
147	/**
148	* Uninitializes the instance and sets the ready flag to FALSE.
149	* Called either from FinalRelease() or by the parent when it gets destroyed.
150	*/
151	void SystemProperties::uninit()
152	{
153	LogFlowThisFunc(("\n"));
154
155	/* Enclose the state transition Ready->InUninit->NotReady */
156	AutoUninitSpan autoUninitSpan(this);
157	if (autoUninitSpan.uninitDone())
158	return;
159
160	unconst(mParent) = NULL;
161	}
162
163	// wrapped ISystemProperties properties
164	/////////////////////////////////////////////////////////////////////////////
165
166	HRESULT SystemProperties::getMinGuestRAM(ULONG *minRAM)
167
168	{
169	/* no need to lock, this is const */
170	AssertCompile(MM_RAM_MIN_IN_MB >= SchemaDefs::MinGuestRAM);
171	*minRAM = MM_RAM_MIN_IN_MB;
172
173	return S_OK;
174	}
175
176	HRESULT SystemProperties::getMaxGuestRAM(ULONG *maxRAM)
177	{
178	/* no need to lock, this is const */
179	AssertCompile(MM_RAM_MAX_IN_MB <= SchemaDefs::MaxGuestRAM);
180	ULONG maxRAMSys = MM_RAM_MAX_IN_MB;
181	ULONG maxRAMArch = maxRAMSys;
182	*maxRAM = RT_MIN(maxRAMSys, maxRAMArch);
183
184	return S_OK;
185	}
186
187	HRESULT SystemProperties::getMinGuestVRAM(ULONG *minVRAM)
188	{
189	/* no need to lock, this is const */
190	*minVRAM = SchemaDefs::MinGuestVRAM;
191
192	return S_OK;
193	}
194
195	HRESULT SystemProperties::getMaxGuestVRAM(ULONG *maxVRAM)
196	{
197	/* no need to lock, this is const */
198	*maxVRAM = SchemaDefs::MaxGuestVRAM;
199
200	return S_OK;
201	}
202
203	HRESULT SystemProperties::getMinGuestCPUCount(ULONG *minCPUCount)
204	{
205	/* no need to lock, this is const */
206	*minCPUCount = SchemaDefs::MinCPUCount; // VMM_MIN_CPU_COUNT
207
208	return S_OK;
209	}
210
211	HRESULT SystemProperties::getMaxGuestCPUCount(ULONG *maxCPUCount)
212	{
213	/* no need to lock, this is const */
214	*maxCPUCount = SchemaDefs::MaxCPUCount; // VMM_MAX_CPU_COUNT
215
216	return S_OK;
217	}
218
219	HRESULT SystemProperties::getMaxGuestMonitors(ULONG *maxMonitors)
220	{
221
222	/* no need to lock, this is const */
223	*maxMonitors = SchemaDefs::MaxGuestMonitors;
224
225	return S_OK;
226	}
227
228
229	HRESULT SystemProperties::getInfoVDSize(LONG64 *infoVDSize)
230	{
231	/*
232	* The BIOS supports currently 32 bit LBA numbers (implementing the full
233	* 48 bit range is in theory trivial, but the crappy compiler makes things
234	* more difficult). This translates to almost 2 TiBytes (to be on the safe
235	* side, the reported limit is 1 MiByte less than that, as the total number
236	* of sectors should fit in 32 bits, too), which should be enough for the
237	* moment. Since the MBR partition tables support only 32bit sector numbers
238	* and thus the BIOS can only boot from disks smaller than 2T this is a
239	* rather hard limit.
240	*
241	* The virtual ATA/SATA disks support complete LBA48, and SCSI supports
242	* LBA64 (almost, more like LBA55 in practice), so the theoretical maximum
243	* disk size is 128 PiByte/16 EiByte. The GUI works nicely with 6 orders
244	* of magnitude, but not with 11..13 orders of magnitude.
245	*/
246	/* no need to lock, this is const */
247	infoVDSize = 2 _1T - _1M;
248
249	return S_OK;
250	}
251
252
253	HRESULT SystemProperties::getSerialPortCount(ULONG *count)
254	{
255	/* no need to lock, this is const */
256	*count = SchemaDefs::SerialPortCount;
257
258	return S_OK;
259	}
260
261
262	HRESULT SystemProperties::getParallelPortCount(ULONG *count)
263	{
264	/* no need to lock, this is const */
265	*count = SchemaDefs::ParallelPortCount;
266
267	return S_OK;
268	}
269
270
271	HRESULT SystemProperties::getMaxBootPosition(ULONG *aMaxBootPosition)
272	{
273	/* no need to lock, this is const */
274	*aMaxBootPosition = SchemaDefs::MaxBootPosition;
275
276	return S_OK;
277	}
278
279
280	HRESULT SystemProperties::getRawModeSupported(BOOL *aRawModeSupported)
281	{
282	#ifdef VBOX_WITH_RAW_MODE
283	*aRawModeSupported = TRUE;
284	#else
285	*aRawModeSupported = FALSE;
286	#endif
287	return S_OK;
288	}
289
290
291	HRESULT SystemProperties::getExclusiveHwVirt(BOOL *aExclusiveHwVirt)
292	{
293	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
294
295	*aExclusiveHwVirt = m->fExclusiveHwVirt;
296
297	return S_OK;
298	}
299
300	HRESULT SystemProperties::setExclusiveHwVirt(BOOL aExclusiveHwVirt)
301	{
302	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
303	m->fExclusiveHwVirt = !!aExclusiveHwVirt;
304	alock.release();
305
306	// VirtualBox::i_saveSettings() needs vbox write lock
307	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
308	HRESULT rc = mParent->i_saveSettings();
309
310	return rc;
311	}
312
313	HRESULT SystemProperties::getMaxNetworkAdapters(ChipsetType_T aChipset, ULONG *aMaxNetworkAdapters)
314	{
315	/* no need for locking, no state */
316	uint32_t uResult = Global::getMaxNetworkAdapters(aChipset);
317	if (uResult == 0)
318	AssertMsgFailed(("Invalid chipset type %d\n", aChipset));
319	*aMaxNetworkAdapters = uResult;
320	return S_OK;
321	}
322
323	HRESULT SystemProperties::getMaxNetworkAdaptersOfType(ChipsetType_T aChipset, NetworkAttachmentType_T aType, ULONG *count)
324	{
325	/* no need for locking, no state */
326	uint32_t uResult = Global::getMaxNetworkAdapters(aChipset);
327	if (uResult == 0)
328	AssertMsgFailed(("Invalid chipset type %d\n", aChipset));
329
330	switch (aType)
331	{
332	case NetworkAttachmentType_NAT:
333	case NetworkAttachmentType_Internal:
334	case NetworkAttachmentType_NATNetwork:
335	/* chipset default is OK */
336	break;
337	case NetworkAttachmentType_Bridged:
338	/* Maybe use current host interface count here? */
339	break;
340	case NetworkAttachmentType_HostOnly:
341	uResult = RT_MIN(uResult, 8);
342	break;
343	default:
344	AssertMsgFailed(("Unhandled attachment type %d\n", aType));
345	}
346
347	*count = uResult;
348
349	return S_OK;
350	}
351
352
353	HRESULT SystemProperties::getMaxDevicesPerPortForStorageBus(StorageBus_T aBus,
354	ULONG *aMaxDevicesPerPort)
355	{
356	/* no need to lock, this is const */
357	switch (aBus)
358	{
359	case StorageBus_SATA:
360	case StorageBus_SCSI:
361	case StorageBus_SAS:
362	case StorageBus_USB:
363	case StorageBus_PCIe:
364	{
365	/* SATA and both SCSI controllers only support one device per port. */
366	*aMaxDevicesPerPort = 1;
367	break;
368	}
369	case StorageBus_IDE:
370	case StorageBus_Floppy:
371	{
372	/* The IDE and Floppy controllers support 2 devices. One as master
373	* and one as slave (or floppy drive 0 and 1). */
374	*aMaxDevicesPerPort = 2;
375	break;
376	}
377	default:
378	AssertMsgFailed(("Invalid bus type %d\n", aBus));
379	}
380
381	return S_OK;
382	}
383
384	HRESULT SystemProperties::getMinPortCountForStorageBus(StorageBus_T aBus,
385	ULONG *aMinPortCount)
386	{
387	/* no need to lock, this is const */
388	switch (aBus)
389	{
390	case StorageBus_SATA:
391	case StorageBus_SAS:
392	case StorageBus_PCIe:
393	{
394	*aMinPortCount = 1;
395	break;
396	}
397	case StorageBus_SCSI:
398	{
399	*aMinPortCount = 16;
400	break;
401	}
402	case StorageBus_IDE:
403	{
404	*aMinPortCount = 2;
405	break;
406	}
407	case StorageBus_Floppy:
408	{
409	*aMinPortCount = 1;
410	break;
411	}
412	case StorageBus_USB:
413	{
414	*aMinPortCount = 8;
415	break;
416	}
417	default:
418	AssertMsgFailed(("Invalid bus type %d\n", aBus));
419	}
420
421	return S_OK;
422	}
423
424	HRESULT SystemProperties::getMaxPortCountForStorageBus(StorageBus_T aBus,
425	ULONG *aMaxPortCount)
426	{
427	/* no need to lock, this is const */
428	switch (aBus)
429	{
430	case StorageBus_SATA:
431	{
432	*aMaxPortCount = 30;
433	break;
434	}
435	case StorageBus_SCSI:
436	{
437	*aMaxPortCount = 16;
438	break;
439	}
440	case StorageBus_IDE:
441	{
442	*aMaxPortCount = 2;
443	break;
444	}
445	case StorageBus_Floppy:
446	{
447	*aMaxPortCount = 1;
448	break;
449	}
450	case StorageBus_SAS:
451	case StorageBus_PCIe:
452	{
453	*aMaxPortCount = 255;
454	break;
455	}
456	case StorageBus_USB:
457	{
458	*aMaxPortCount = 8;
459	break;
460	}
461	default:
462	AssertMsgFailed(("Invalid bus type %d\n", aBus));
463	}
464
465	return S_OK;
466	}
467
468	HRESULT SystemProperties::getMaxInstancesOfStorageBus(ChipsetType_T aChipset,
469	StorageBus_T aBus,
470	ULONG *aMaxInstances)
471	{
472	ULONG cCtrs = 0;
473
474	/* no need to lock, this is const */
475	switch (aBus)
476	{
477	case StorageBus_SATA:
478	case StorageBus_SCSI:
479	case StorageBus_SAS:
480	case StorageBus_PCIe:
481	cCtrs = aChipset == ChipsetType_ICH9 ? 8 : 1;
482	break;
483	case StorageBus_USB:
484	case StorageBus_IDE:
485	case StorageBus_Floppy:
486	{
487	cCtrs = 1;
488	break;
489	}
490	default:
491	AssertMsgFailed(("Invalid bus type %d\n", aBus));
492	}
493
494	*aMaxInstances = cCtrs;
495
496	return S_OK;
497	}
498
499	HRESULT SystemProperties::getDeviceTypesForStorageBus(StorageBus_T aBus,
500	std::vector<DeviceType_T> &aDeviceTypes)
501	{
502	aDeviceTypes.resize(0);
503
504	/* no need to lock, this is const */
505	switch (aBus)
506	{
507	case StorageBus_IDE:
508	case StorageBus_SATA:
509	case StorageBus_SCSI:
510	case StorageBus_SAS:
511	case StorageBus_USB:
512	{
513	aDeviceTypes.resize(2);
514	aDeviceTypes[0] = DeviceType_DVD;
515	aDeviceTypes[1] = DeviceType_HardDisk;
516	break;
517	}
518	case StorageBus_Floppy:
519	{
520	aDeviceTypes.resize(1);
521	aDeviceTypes[0] = DeviceType_Floppy;
522	break;
523	}
524	case StorageBus_PCIe:
525	{
526	aDeviceTypes.resize(1);
527	aDeviceTypes[0] = DeviceType_HardDisk;
528	break;
529	}
530	default:
531	AssertMsgFailed(("Invalid bus type %d\n", aBus));
532	}
533
534	return S_OK;
535	}
536
537	HRESULT SystemProperties::getDefaultIoCacheSettingForStorageController(StorageControllerType_T aControllerType,
538	BOOL *aEnabled)
539	{
540	/* no need to lock, this is const */
541	switch (aControllerType)
542	{
543	case StorageControllerType_LsiLogic:
544	case StorageControllerType_BusLogic:
545	case StorageControllerType_IntelAhci:
546	case StorageControllerType_LsiLogicSas:
547	case StorageControllerType_USB:
548	case StorageControllerType_NVMe:
549	*aEnabled = false;
550	break;
551	case StorageControllerType_PIIX3:
552	case StorageControllerType_PIIX4:
553	case StorageControllerType_ICH6:
554	case StorageControllerType_I82078:
555	*aEnabled = true;
556	break;
557	default:
558	AssertMsgFailed(("Invalid controller type %d\n", aControllerType));
559	}
560	return S_OK;
561	}
562
563	HRESULT SystemProperties::getStorageControllerHotplugCapable(StorageControllerType_T aControllerType,
564	BOOL *aHotplugCapable)
565	{
566	switch (aControllerType)
567	{
568	case StorageControllerType_IntelAhci:
569	case StorageControllerType_USB:
570	*aHotplugCapable = true;
571	break;
572	case StorageControllerType_LsiLogic:
573	case StorageControllerType_LsiLogicSas:
574	case StorageControllerType_BusLogic:
575	case StorageControllerType_NVMe:
576	case StorageControllerType_PIIX3:
577	case StorageControllerType_PIIX4:
578	case StorageControllerType_ICH6:
579	case StorageControllerType_I82078:
580	*aHotplugCapable = false;
581	break;
582	default:
583	AssertMsgFailedReturn(("Invalid controller type %d\n", aControllerType), E_FAIL);
584	}
585
586	return S_OK;
587	}
588
589	HRESULT SystemProperties::getMaxInstancesOfUSBControllerType(ChipsetType_T aChipset,
590	USBControllerType_T aType,
591	ULONG *aMaxInstances)
592	{
593	NOREF(aChipset);
594	ULONG cCtrs = 0;
595
596	/* no need to lock, this is const */
597	switch (aType)
598	{
599	case USBControllerType_OHCI:
600	case USBControllerType_EHCI:
601	case USBControllerType_XHCI:
602	{
603	cCtrs = 1;
604	break;
605	}
606	default:
607	AssertMsgFailed(("Invalid bus type %d\n", aType));
608	}
609
610	*aMaxInstances = cCtrs;
611
612	return S_OK;
613	}
614
615	HRESULT SystemProperties::getDefaultMachineFolder(com::Utf8Str &aDefaultMachineFolder)
616	{
617	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
618	aDefaultMachineFolder = m->strDefaultMachineFolder;
619	return S_OK;
620	}
621
622	HRESULT SystemProperties::setDefaultMachineFolder(const com::Utf8Str &aDefaultMachineFolder)
623	{
624	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
625	HRESULT rc = i_setDefaultMachineFolder(aDefaultMachineFolder);
626	alock.release();
627	if (SUCCEEDED(rc))
628	{
629	// VirtualBox::i_saveSettings() needs vbox write lock
630	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
631	rc = mParent->i_saveSettings();
632	}
633
634	return rc;
635	}
636
637	HRESULT SystemProperties::getLoggingLevel(com::Utf8Str &aLoggingLevel)
638	{
639	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
640
641	aLoggingLevel = m->strLoggingLevel;
642
643	if (aLoggingLevel.isEmpty())
644	aLoggingLevel = VBOXSVC_LOG_DEFAULT;
645
646	return S_OK;
647	}
648
649
650	HRESULT SystemProperties::setLoggingLevel(const com::Utf8Str &aLoggingLevel)
651	{
652	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
653	HRESULT rc = i_setLoggingLevel(aLoggingLevel);
654	alock.release();
655
656	if (SUCCEEDED(rc))
657	{
658	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
659	rc = mParent->i_saveSettings();
660	}
661	else
662	LogRel(("Cannot set passed logging level=%s, or the default one - Error=%Rhrc \n", aLoggingLevel.c_str(), rc));
663
664	return rc;
665	}
666
667	HRESULT SystemProperties::getMediumFormats(std::vector<ComPtr<IMediumFormat> > &aMediumFormats)
668	{
669	MediumFormatList mediumFormats(m_llMediumFormats);
670	aMediumFormats.resize(mediumFormats.size());
671	size_t i = 0;
672	for (MediumFormatList::const_iterator it = mediumFormats.begin(); it != mediumFormats.end(); ++it, ++i)
673	(*it).queryInterfaceTo(aMediumFormats[i].asOutParam());
674	return S_OK;
675	}
676
677	HRESULT SystemProperties::getDefaultHardDiskFormat(com::Utf8Str &aDefaultHardDiskFormat)
678	{
679	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
680	aDefaultHardDiskFormat = m->strDefaultHardDiskFormat;
681	return S_OK;
682	}
683
684
685	HRESULT SystemProperties::setDefaultHardDiskFormat(const com::Utf8Str &aDefaultHardDiskFormat)
686	{
687	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
688	HRESULT rc = i_setDefaultHardDiskFormat(aDefaultHardDiskFormat);
689	alock.release();
690	if (SUCCEEDED(rc))
691	{
692	// VirtualBox::i_saveSettings() needs vbox write lock
693	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
694	rc = mParent->i_saveSettings();
695	}
696
697	return rc;
698	}
699
700	HRESULT SystemProperties::getFreeDiskSpaceWarning(LONG64 *aFreeSpace)
701	{
702	NOREF(aFreeSpace);
703	ReturnComNotImplemented();
704	}
705
706	HRESULT SystemProperties::setFreeDiskSpaceWarning(LONG64 /* aFreeSpace */)
707	{
708	ReturnComNotImplemented();
709	}
710
711	HRESULT SystemProperties::getFreeDiskSpacePercentWarning(ULONG *aFreeSpacePercent)
712	{
713	NOREF(aFreeSpacePercent);
714	ReturnComNotImplemented();
715	}
716
717	HRESULT SystemProperties::setFreeDiskSpacePercentWarning(ULONG /* aFreeSpacePercent */)
718	{
719	ReturnComNotImplemented();
720	}
721
722	HRESULT SystemProperties::getFreeDiskSpaceError(LONG64 *aFreeSpace)
723	{
724	NOREF(aFreeSpace);
725	ReturnComNotImplemented();
726	}
727
728	HRESULT SystemProperties::setFreeDiskSpaceError(LONG64 /* aFreeSpace */)
729	{
730	ReturnComNotImplemented();
731	}
732
733	HRESULT SystemProperties::getFreeDiskSpacePercentError(ULONG *aFreeSpacePercent)
734	{
735	NOREF(aFreeSpacePercent);
736	ReturnComNotImplemented();
737	}
738
739	HRESULT SystemProperties::setFreeDiskSpacePercentError(ULONG /* aFreeSpacePercent */)
740	{
741	ReturnComNotImplemented();
742	}
743
744	HRESULT SystemProperties::getVRDEAuthLibrary(com::Utf8Str &aVRDEAuthLibrary)
745	{
746	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
747
748	aVRDEAuthLibrary = m->strVRDEAuthLibrary;
749
750	return S_OK;
751	}
752
753	HRESULT SystemProperties::setVRDEAuthLibrary(const com::Utf8Str &aVRDEAuthLibrary)
754	{
755	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
756	HRESULT rc = i_setVRDEAuthLibrary(aVRDEAuthLibrary);
757	alock.release();
758	if (SUCCEEDED(rc))
759	{
760	// VirtualBox::i_saveSettings() needs vbox write lock
761	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
762	rc = mParent->i_saveSettings();
763	}
764
765	return rc;
766	}
767
768	HRESULT SystemProperties::getWebServiceAuthLibrary(com::Utf8Str &aWebServiceAuthLibrary)
769	{
770	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
771
772	aWebServiceAuthLibrary = m->strWebServiceAuthLibrary;
773
774	return S_OK;
775	}
776
777	HRESULT SystemProperties::setWebServiceAuthLibrary(const com::Utf8Str &aWebServiceAuthLibrary)
778	{
779	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
780	HRESULT rc = i_setWebServiceAuthLibrary(aWebServiceAuthLibrary);
781	alock.release();
782
783	if (SUCCEEDED(rc))
784	{
785	// VirtualBox::i_saveSettings() needs vbox write lock
786	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
787	rc = mParent->i_saveSettings();
788	}
789
790	return rc;
791	}
792
793	HRESULT SystemProperties::getDefaultVRDEExtPack(com::Utf8Str &aExtPack)
794	{
795	HRESULT hrc = S_OK;
796	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
797	Utf8Str strExtPack(m->strDefaultVRDEExtPack);
798	if (strExtPack.isNotEmpty())
799	{
800	if (strExtPack.equals(VBOXVRDP_KLUDGE_EXTPACK_NAME))
801	hrc = S_OK;
802	else
803	#ifdef VBOX_WITH_EXTPACK
804	hrc = mParent->i_getExtPackManager()->i_checkVrdeExtPack(&strExtPack);
805	#else
806	hrc = setError(E_FAIL, tr("The extension pack '%s' does not exist"), strExtPack.c_str());
807	#endif
808	}
809	else
810	{
811	#ifdef VBOX_WITH_EXTPACK
812	hrc = mParent->i_getExtPackManager()->i_getDefaultVrdeExtPack(&strExtPack);
813	#endif
814	if (strExtPack.isEmpty())
815	{
816	/*
817	* Klugde - check if VBoxVRDP.dll/.so/.dylib is installed.
818	* This is hardcoded uglyness, sorry.
819	*/
820	char szPath[RTPATH_MAX];
821	int vrc = RTPathAppPrivateArch(szPath, sizeof(szPath));
822	if (RT_SUCCESS(vrc))
823	vrc = RTPathAppend(szPath, sizeof(szPath), "VBoxVRDP");
824	if (RT_SUCCESS(vrc))
825	vrc = RTStrCat(szPath, sizeof(szPath), RTLdrGetSuff());
826	if (RT_SUCCESS(vrc) && RTFileExists(szPath))
827	{
828	/* Illegal extpack name, so no conflict. */
829	strExtPack = VBOXVRDP_KLUDGE_EXTPACK_NAME;
830	}
831	}
832	}
833
834	if (SUCCEEDED(hrc))
835	aExtPack = strExtPack;
836
837	return S_OK;
838	}
839
840
841	HRESULT SystemProperties::setDefaultVRDEExtPack(const com::Utf8Str &aExtPack)
842	{
843	HRESULT hrc = S_OK;
844	if (aExtPack.isNotEmpty())
845	{
846	if (aExtPack.equals(VBOXVRDP_KLUDGE_EXTPACK_NAME))
847	hrc = S_OK;
848	else
849	#ifdef VBOX_WITH_EXTPACK
850	hrc = mParent->i_getExtPackManager()->i_checkVrdeExtPack(&aExtPack);
851	#else
852	hrc = setError(E_FAIL, tr("The extension pack '%s' does not exist"), aExtPack.c_str());
853	#endif
854	}
855	if (SUCCEEDED(hrc))
856	{
857	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
858	hrc = i_setDefaultVRDEExtPack(aExtPack);
859	if (SUCCEEDED(hrc))
860	{
861	/* VirtualBox::i_saveSettings() needs the VirtualBox write lock. */
862	alock.release();
863	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
864	hrc = mParent->i_saveSettings();
865	}
866	}
867
868	return hrc;
869	}
870
871
872	HRESULT SystemProperties::getLogHistoryCount(ULONG *count)
873	{
874	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
875
876	*count = m->uLogHistoryCount;
877
878	return S_OK;
879	}
880
881
882	HRESULT SystemProperties::setLogHistoryCount(ULONG count)
883	{
884	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
885	m->uLogHistoryCount = count;
886	alock.release();
887
888	// VirtualBox::i_saveSettings() needs vbox write lock
889	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
890	HRESULT rc = mParent->i_saveSettings();
891
892	return rc;
893	}
894
895	HRESULT SystemProperties::getDefaultAudioDriver(AudioDriverType_T *aAudioDriver)
896	{
897	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
898
899	*aAudioDriver = settings::MachineConfigFile::getHostDefaultAudioDriver();
900
901	return S_OK;
902	}
903
904	HRESULT SystemProperties::getAutostartDatabasePath(com::Utf8Str &aAutostartDbPath)
905	{
906	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
907
908	aAutostartDbPath = m->strAutostartDatabasePath;
909
910	return S_OK;
911	}
912
913	HRESULT SystemProperties::setAutostartDatabasePath(const com::Utf8Str &aAutostartDbPath)
914	{
915	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
916	HRESULT rc = i_setAutostartDatabasePath(aAutostartDbPath);
917	alock.release();
918
919	if (SUCCEEDED(rc))
920	{
921	// VirtualBox::i_saveSettings() needs vbox write lock
922	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
923	rc = mParent->i_saveSettings();
924	}
925
926	return rc;
927	}
928
929	HRESULT SystemProperties::getDefaultAdditionsISO(com::Utf8Str &aDefaultAdditionsISO)
930	{
931	return i_getDefaultAdditionsISO(aDefaultAdditionsISO);
932	}
933
934	HRESULT SystemProperties::setDefaultAdditionsISO(const com::Utf8Str &aDefaultAdditionsISO)
935	{
936	RT_NOREF(aDefaultAdditionsISO);
937	/** @todo not yet implemented, settings handling is missing */
938	ReturnComNotImplemented();
939	#if 0 /* not implemented */
940	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
941	HRESULT rc = i_setDefaultAdditionsISO(aDefaultAdditionsISO);
942	alock.release();
943
944	if (SUCCEEDED(rc))
945	{
946	// VirtualBox::i_saveSettings() needs vbox write lock
947	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
948	rc = mParent->i_saveSettings();
949	}
950
951	return rc;
952	#endif
953	}
954
955	HRESULT SystemProperties::getDefaultFrontend(com::Utf8Str &aDefaultFrontend)
956	{
957	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
958	aDefaultFrontend = m->strDefaultFrontend;
959	return S_OK;
960	}
961
962	HRESULT SystemProperties::setDefaultFrontend(const com::Utf8Str &aDefaultFrontend)
963	{
964	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
965	if (m->strDefaultFrontend == Utf8Str(aDefaultFrontend))
966	return S_OK;
967	HRESULT rc = i_setDefaultFrontend(aDefaultFrontend);
968	alock.release();
969
970	if (SUCCEEDED(rc))
971	{
972	// VirtualBox::i_saveSettings() needs vbox write lock
973	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
974	rc = mParent->i_saveSettings();
975	}
976
977	return rc;
978	}
979
980	HRESULT SystemProperties::getScreenShotFormats(std::vector<BitmapFormat_T> &aBitmapFormats)
981	{
982	aBitmapFormats.push_back(BitmapFormat_BGR0);
983	aBitmapFormats.push_back(BitmapFormat_BGRA);
984	aBitmapFormats.push_back(BitmapFormat_RGBA);
985	aBitmapFormats.push_back(BitmapFormat_PNG);
986	return S_OK;
987	}
988
989	HRESULT SystemProperties::getProxyMode(ProxyMode_T *pProxyMode)
990	{
991	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
992	ProxyMode_T enmMode = *pProxyMode = (ProxyMode_T)m->uProxyMode;
993	AssertMsgReturn(enmMode == ProxyMode_System \|\| enmMode == ProxyMode_NoProxy \|\| enmMode == ProxyMode_Manual,
994	("enmMode=%d\n", enmMode), E_UNEXPECTED);
995	return S_OK;
996	}
997
998	HRESULT SystemProperties::setProxyMode(ProxyMode_T aProxyMode)
999	{
1000	/* Validate input. */
1001	switch (aProxyMode)
1002	{
1003	case ProxyMode_System:
1004	case ProxyMode_NoProxy:
1005	case ProxyMode_Manual:
1006	break;
1007	default:
1008	return setError(E_INVALIDARG, tr("Invalid ProxyMode value: %d"), (int)aProxyMode);
1009	}
1010
1011	/* Set and write out settings. */
1012	{
1013	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1014	m->uProxyMode = aProxyMode;
1015	}
1016	AutoWriteLock alock(mParent COMMA_LOCKVAL_SRC_POS); /* required for saving. */
1017	return mParent->i_saveSettings();
1018	}
1019
1020	HRESULT SystemProperties::getProxyURL(com::Utf8Str &aProxyURL)
1021	{
1022	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1023	aProxyURL = m->strProxyUrl;
1024	return S_OK;
1025	}
1026
1027	HRESULT SystemProperties::setProxyURL(const com::Utf8Str &aProxyURL)
1028	{
1029	/*
1030	* Validate input.
1031	*/
1032	Utf8Str const *pStrProxyUrl = &aProxyURL;
1033	Utf8Str strTmp;
1034	if (pStrProxyUrl->isNotEmpty())
1035	{
1036	/* RTUriParse requires a scheme, so append 'http://' if none seems present: */
1037	if (pStrProxyUrl->find("://") == RTCString::npos)
1038	{
1039	strTmp.printf("http://%s", aProxyURL.c_str());
1040	pStrProxyUrl = &strTmp;
1041	}
1042
1043	/* Use RTUriParse to check the format. There must be a hostname, but nothing
1044	can follow it and the port. */
1045	RTURIPARSED Parsed;
1046	int vrc = RTUriParse(pStrProxyUrl->c_str(), &Parsed);
1047	if (RT_FAILURE(vrc))
1048	return setErrorBoth(E_INVALIDARG, vrc, tr("Failed to parse proxy URL: %Rrc"), vrc);
1049	if ( Parsed.cchAuthorityHost == 0
1050	&& !RTUriIsSchemeMatch(pStrProxyUrl->c_str(), "direct"))
1051	return setError(E_INVALIDARG, tr("Proxy URL must include a hostname"));
1052	if (Parsed.cchPath > 0)
1053	return setError(E_INVALIDARG, tr("Proxy URL must not include a path component (%.*s)"),
1054	Parsed.cchPath, pStrProxyUrl->c_str() + Parsed.offPath);
1055	if (Parsed.cchQuery > 0)
1056	return setError(E_INVALIDARG, tr("Proxy URL must not include a query component (?%.*s)"),
1057	Parsed.cchQuery, pStrProxyUrl->c_str() + Parsed.offQuery);
1058	if (Parsed.cchFragment > 0)
1059	return setError(E_INVALIDARG, tr("Proxy URL must not include a fragment component (#%.*s)"),
1060	Parsed.cchFragment, pStrProxyUrl->c_str() + Parsed.offFragment);
1061	}
1062
1063	/*
1064	* Set and write out settings.
1065	*/
1066	{
1067	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1068	m->strProxyUrl = *pStrProxyUrl;
1069	}
1070	AutoWriteLock alock(mParent COMMA_LOCKVAL_SRC_POS); /* required for saving. */
1071	return mParent->i_saveSettings();
1072	}
1073
1074	// public methods only for internal purposes
1075	/////////////////////////////////////////////////////////////////////////////
1076
1077	HRESULT SystemProperties::i_loadSettings(const settings::SystemProperties &data)
1078	{
1079	AutoCaller autoCaller(this);
1080	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1081
1082	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1083	HRESULT rc = S_OK;
1084	rc = i_setDefaultMachineFolder(data.strDefaultMachineFolder);
1085	if (FAILED(rc)) return rc;
1086
1087	rc = i_setLoggingLevel(data.strLoggingLevel);
1088	if (FAILED(rc)) return rc;
1089
1090	rc = i_setDefaultHardDiskFormat(data.strDefaultHardDiskFormat);
1091	if (FAILED(rc)) return rc;
1092
1093	rc = i_setVRDEAuthLibrary(data.strVRDEAuthLibrary);
1094	if (FAILED(rc)) return rc;
1095
1096	rc = i_setWebServiceAuthLibrary(data.strWebServiceAuthLibrary);
1097	if (FAILED(rc)) return rc;
1098
1099	rc = i_setDefaultVRDEExtPack(data.strDefaultVRDEExtPack);
1100	if (FAILED(rc)) return rc;
1101
1102	m->uLogHistoryCount = data.uLogHistoryCount;
1103	m->fExclusiveHwVirt = data.fExclusiveHwVirt;
1104	m->uProxyMode = data.uProxyMode;
1105	m->strProxyUrl = data.strProxyUrl;
1106
1107	rc = i_setAutostartDatabasePath(data.strAutostartDatabasePath);
1108	if (FAILED(rc)) return rc;
1109
1110	{
1111	/* must ignore errors signalled here, because the guest additions
1112	* file may not exist, and in this case keep the empty string */
1113	ErrorInfoKeeper eik;
1114	(void)i_setDefaultAdditionsISO(data.strDefaultAdditionsISO);
1115	}
1116
1117	rc = i_setDefaultFrontend(data.strDefaultFrontend);
1118	if (FAILED(rc)) return rc;
1119
1120	return S_OK;
1121	}
1122
1123	HRESULT SystemProperties::i_saveSettings(settings::SystemProperties &data)
1124	{
1125	AutoCaller autoCaller(this);
1126	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1127
1128	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1129
1130	data = *m;
1131
1132	return S_OK;
1133	}
1134
1135	/**
1136	* Returns a medium format object corresponding to the given format
1137	* identifier or null if no such format.
1138	*
1139	* @param aFormat Format identifier.
1140	*
1141	* @return ComObjPtr<MediumFormat>
1142	*/
1143	ComObjPtr<MediumFormat> SystemProperties::i_mediumFormat(const Utf8Str &aFormat)
1144	{
1145	ComObjPtr<MediumFormat> format;
1146
1147	AutoCaller autoCaller(this);
1148	AssertComRCReturn (autoCaller.rc(), format);
1149
1150	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1151
1152	for (MediumFormatList::const_iterator it = m_llMediumFormats.begin();
1153	it != m_llMediumFormats.end();
1154	++ it)
1155	{
1156	/* MediumFormat is all const, no need to lock */
1157
1158	if ((*it)->i_getId().compare(aFormat, Utf8Str::CaseInsensitive) == 0)
1159	{
1160	format = *it;
1161	break;
1162	}
1163	}
1164
1165	return format;
1166	}
1167
1168	/**
1169	* Returns a medium format object corresponding to the given file extension or
1170	* null if no such format.
1171	*
1172	* @param aExt File extension.
1173	*
1174	* @return ComObjPtr<MediumFormat>
1175	*/
1176	ComObjPtr<MediumFormat> SystemProperties::i_mediumFormatFromExtension(const Utf8Str &aExt)
1177	{
1178	ComObjPtr<MediumFormat> format;
1179
1180	AutoCaller autoCaller(this);
1181	AssertComRCReturn (autoCaller.rc(), format);
1182
1183	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1184
1185	bool fFound = false;
1186	for (MediumFormatList::const_iterator it = m_llMediumFormats.begin();
1187	it != m_llMediumFormats.end() && !fFound;
1188	++it)
1189	{
1190	/* MediumFormat is all const, no need to lock */
1191	MediumFormat::StrArray aFileList = (*it)->i_getFileExtensions();
1192	for (MediumFormat::StrArray::const_iterator it1 = aFileList.begin();
1193	it1 != aFileList.end();
1194	++it1)
1195	{
1196	if ((*it1).compare(aExt, Utf8Str::CaseInsensitive) == 0)
1197	{
1198	format = *it;
1199	fFound = true;
1200	break;
1201	}
1202	}
1203	}
1204
1205	return format;
1206	}
1207
1208
1209	/**
1210	* VD plugin load
1211	*/
1212	int SystemProperties::i_loadVDPlugin(const char *pszPluginLibrary)
1213	{
1214	return VDPluginLoadFromFilename(pszPluginLibrary);
1215	}
1216
1217	/**
1218	* VD plugin unload
1219	*/
1220	int SystemProperties::i_unloadVDPlugin(const char *pszPluginLibrary)
1221	{
1222	return VDPluginUnloadFromFilename(pszPluginLibrary);
1223	}
1224
1225	/**
1226	* Internally usable version of getDefaultAdditionsISO.
1227	*/
1228	HRESULT SystemProperties::i_getDefaultAdditionsISO(com::Utf8Str &aDefaultAdditionsISO)
1229	{
1230	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1231	if (m->strDefaultAdditionsISO.isNotEmpty())
1232	aDefaultAdditionsISO = m->strDefaultAdditionsISO;
1233	else
1234	{
1235	/* no guest additions, check if it showed up in the mean time */
1236	alock.release();
1237	AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
1238	if (m->strDefaultAdditionsISO.isEmpty())
1239	{
1240	ErrorInfoKeeper eik;
1241	(void)setDefaultAdditionsISO("");
1242	}
1243	aDefaultAdditionsISO = m->strDefaultAdditionsISO;
1244	}
1245	return S_OK;
1246	}
1247
1248	// private methods
1249	/////////////////////////////////////////////////////////////////////////////
1250
1251	/**
1252	* Returns the user's home directory. Wrapper around RTPathUserHome().
1253	* @param strPath
1254	* @return
1255	*/
1256	HRESULT SystemProperties::i_getUserHomeDirectory(Utf8Str &strPath)
1257	{
1258	char szHome[RTPATH_MAX];
1259	int vrc = RTPathUserHome(szHome, sizeof(szHome));
1260	if (RT_FAILURE(vrc))
1261	return setErrorBoth(E_FAIL, vrc,
1262	tr("Cannot determine user home directory (%Rrc)"),
1263	vrc);
1264	strPath = szHome;
1265	return S_OK;
1266	}
1267
1268	/**
1269	* Internal implementation to set the default machine folder. Gets called
1270	* from the public attribute setter as well as loadSettings(). With 4.0,
1271	* the "default default" machine folder has changed, and we now require
1272	* a full path always.
1273	* @param strPath
1274	* @return
1275	*/
1276	HRESULT SystemProperties::i_setDefaultMachineFolder(const Utf8Str &strPath)
1277	{
1278	Utf8Str path(strPath); // make modifiable
1279	if ( path.isEmpty() // used by API calls to reset the default
1280	\|\| path == "Machines" // this value (exactly like this, without path) is stored
1281	// in VirtualBox.xml if user upgrades from before 4.0 and
1282	// has not changed the default machine folder
1283	)
1284	{
1285	// new default with VirtualBox 4.0: "$HOME/VirtualBox VMs"
1286	HRESULT rc = i_getUserHomeDirectory(path);
1287	if (FAILED(rc)) return rc;
1288	path += RTPATH_SLASH_STR "VirtualBox VMs";
1289	}
1290
1291	if (!RTPathStartsWithRoot(path.c_str()))
1292	return setError(E_INVALIDARG,
1293	tr("Given default machine folder '%s' is not fully qualified"),
1294	path.c_str());
1295
1296	m->strDefaultMachineFolder = path;
1297
1298	return S_OK;
1299	}
1300
1301	HRESULT SystemProperties::i_setLoggingLevel(const com::Utf8Str &aLoggingLevel)
1302	{
1303	Utf8Str useLoggingLevel(aLoggingLevel);
1304	if (useLoggingLevel.isEmpty())
1305	useLoggingLevel = VBOXSVC_LOG_DEFAULT;
1306	int rc = RTLogGroupSettings(RTLogRelGetDefaultInstance(), useLoggingLevel.c_str());
1307	// If failed and not the default logging level - try to use the default logging level.
1308	if (RT_FAILURE(rc))
1309	{
1310	// If failed write message to the release log.
1311	LogRel(("Cannot set passed logging level=%s Error=%Rrc \n", useLoggingLevel.c_str(), rc));
1312	// If attempted logging level not the default one then try the default one.
1313	if (!useLoggingLevel.equals(VBOXSVC_LOG_DEFAULT))
1314	{
1315	rc = RTLogGroupSettings(RTLogRelGetDefaultInstance(), VBOXSVC_LOG_DEFAULT);
1316	// If failed report this to the release log.
1317	if (RT_FAILURE(rc))
1318	LogRel(("Cannot set default logging level Error=%Rrc \n", rc));
1319	}
1320	// On any failure - set default level as the one to be stored.
1321	useLoggingLevel = VBOXSVC_LOG_DEFAULT;
1322	}
1323	// Set to passed value or if default used/attempted (even if error condition) use empty string.
1324	m->strLoggingLevel = (useLoggingLevel.equals(VBOXSVC_LOG_DEFAULT) ? "" : useLoggingLevel);
1325	return RT_SUCCESS(rc) ? S_OK : E_FAIL;
1326	}
1327
1328	HRESULT SystemProperties::i_setDefaultHardDiskFormat(const com::Utf8Str &aFormat)
1329	{
1330	if (!aFormat.isEmpty())
1331	m->strDefaultHardDiskFormat = aFormat;
1332	else
1333	m->strDefaultHardDiskFormat = "VDI";
1334
1335	return S_OK;
1336	}
1337
1338	HRESULT SystemProperties::i_setVRDEAuthLibrary(const com::Utf8Str &aPath)
1339	{
1340	if (!aPath.isEmpty())
1341	m->strVRDEAuthLibrary = aPath;
1342	else
1343	m->strVRDEAuthLibrary = "VBoxAuth";
1344
1345	return S_OK;
1346	}
1347
1348	HRESULT SystemProperties::i_setWebServiceAuthLibrary(const com::Utf8Str &aPath)
1349	{
1350	if (!aPath.isEmpty())
1351	m->strWebServiceAuthLibrary = aPath;
1352	else
1353	m->strWebServiceAuthLibrary = "VBoxAuth";
1354
1355	return S_OK;
1356	}
1357
1358	HRESULT SystemProperties::i_setDefaultVRDEExtPack(const com::Utf8Str &aExtPack)
1359	{
1360	m->strDefaultVRDEExtPack = aExtPack;
1361
1362	return S_OK;
1363	}
1364
1365	HRESULT SystemProperties::i_setAutostartDatabasePath(const com::Utf8Str &aPath)
1366	{
1367	HRESULT rc = S_OK;
1368	AutostartDb *autostartDb = this->mParent->i_getAutostartDb();
1369
1370	if (!aPath.isEmpty())
1371	{
1372	/* Update path in the autostart database. */
1373	int vrc = autostartDb->setAutostartDbPath(aPath.c_str());
1374	if (RT_SUCCESS(vrc))
1375	m->strAutostartDatabasePath = aPath;
1376	else
1377	rc = setErrorBoth(E_FAIL, vrc,
1378	tr("Cannot set the autostart database path (%Rrc)"),
1379	vrc);
1380	}
1381	else
1382	{
1383	int vrc = autostartDb->setAutostartDbPath(NULL);
1384	if (RT_SUCCESS(vrc) \|\| vrc == VERR_NOT_SUPPORTED)
1385	m->strAutostartDatabasePath = "";
1386	else
1387	rc = setErrorBoth(E_FAIL, vrc,
1388	tr("Deleting the autostart database path failed (%Rrc)"),
1389	vrc);
1390	}
1391
1392	return rc;
1393	}
1394
1395	HRESULT SystemProperties::i_setDefaultAdditionsISO(const com::Utf8Str &aPath)
1396	{
1397	com::Utf8Str path(aPath);
1398	if (path.isEmpty())
1399	{
1400	char strTemp[RTPATH_MAX];
1401	int vrc = RTPathAppPrivateNoArch(strTemp, sizeof(strTemp));
1402	AssertRC(vrc);
1403	Utf8Str strSrc1 = Utf8Str(strTemp).append("/VBoxGuestAdditions.iso");
1404
1405	vrc = RTPathExecDir(strTemp, sizeof(strTemp));
1406	AssertRC(vrc);
1407	Utf8Str strSrc2 = Utf8Str(strTemp).append("/additions/VBoxGuestAdditions.iso");
1408
1409	vrc = RTPathUserHome(strTemp, sizeof(strTemp));
1410	AssertRC(vrc);
1411	Utf8Str strSrc3 = Utf8StrFmt("%s/VBoxGuestAdditions_%s.iso", strTemp, VirtualBox::i_getVersionNormalized().c_str());
1412
1413	/* Check the standard image locations */
1414	if (RTFileExists(strSrc1.c_str()))
1415	path = strSrc1;
1416	else if (RTFileExists(strSrc2.c_str()))
1417	path = strSrc2;
1418	else if (RTFileExists(strSrc3.c_str()))
1419	path = strSrc3;
1420	else
1421	return setError(E_FAIL,
1422	tr("Cannot determine default Guest Additions ISO location. Most likely they are not available"));
1423	}
1424
1425	if (!RTPathStartsWithRoot(path.c_str()))
1426	return setError(E_INVALIDARG,
1427	tr("Given default machine Guest Additions ISO file '%s' is not fully qualified"),
1428	path.c_str());
1429
1430	if (!RTFileExists(path.c_str()))
1431	return setError(E_INVALIDARG,
1432	tr("Given default machine Guest Additions ISO file '%s' does not exist"),
1433	path.c_str());
1434
1435	m->strDefaultAdditionsISO = path;
1436
1437	return S_OK;
1438	}
1439
1440	HRESULT SystemProperties::i_setDefaultFrontend(const com::Utf8Str &aDefaultFrontend)
1441	{
1442	m->strDefaultFrontend = aDefaultFrontend;
1443
1444	return S_OK;
1445	}
1446

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Main/src-server/SystemPropertiesImpl.cpp@ 76542

以其他格式下載: