SystemPropertiesImpl.cpp@ 56372

Last change on this file since 56372 was 56372, checked in by vboxsync, 9 years ago
ISystemProperties: Added rawModeSupported attribute for querying whether VBOX_WITH_RAW_MODE was defined in the build or not.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.5 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: