VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

source: vbox/trunk/src/VBox/Main/src-server/UnattendedImpl.cpp@ 98103

Last change on this file since 98103 was 98103, checked in by vboxsync, 16 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 169.4 KB

Line
1	/* $Id: UnattendedImpl.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* Unattended class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_MAIN_UNATTENDED
33	#include "LoggingNew.h"
34	#include "VirtualBoxBase.h"
35	#include "UnattendedImpl.h"
36	#include "UnattendedInstaller.h"
37	#include "UnattendedScript.h"
38	#include "VirtualBoxImpl.h"
39	#include "SystemPropertiesImpl.h"
40	#include "MachineImpl.h"
41	#include "Global.h"
42	#include "StringifyEnums.h"
43
44	#include <VBox/err.h>
45	#include <iprt/cpp/xml.h>
46	#include <iprt/ctype.h>
47	#include <iprt/file.h>
48	#ifndef RT_OS_WINDOWS
49	# include <iprt/formats/mz.h>
50	# include <iprt/formats/pecoff.h>
51	#endif
52	#include <iprt/formats/wim.h>
53	#include <iprt/fsvfs.h>
54	#include <iprt/inifile.h>
55	#include <iprt/locale.h>
56	#include <iprt/path.h>
57	#include <iprt/vfs.h>
58
59	using namespace std;
60
61
62	/*********************************************************************************************************************************
63	* Structures and Typedefs *
64	*********************************************************************************************************************************/
65	/**
66	* Controller slot for a DVD drive.
67	*
68	* The slot can be free and needing a drive to be attached along with the ISO
69	* image, or it may already be there and only need mounting the ISO. The
70	* ControllerSlot::fFree member indicates which it is.
71	*/
72	struct ControllerSlot
73	{
74	StorageBus_T enmBus;
75	Utf8Str strControllerName;
76	LONG iPort;
77	LONG iDevice;
78	bool fFree;
79
80	ControllerSlot(StorageBus_T a_enmBus, const Utf8Str &a_rName, LONG a_iPort, LONG a_iDevice, bool a_fFree)
81	: enmBus(a_enmBus), strControllerName(a_rName), iPort(a_iPort), iDevice(a_iDevice), fFree(a_fFree)
82	{}
83
84	bool operator<(const ControllerSlot &rThat) const
85	{
86	if (enmBus == rThat.enmBus)
87	{
88	if (strControllerName == rThat.strControllerName)
89	{
90	if (iPort == rThat.iPort)
91	return iDevice < rThat.iDevice;
92	return iPort < rThat.iPort;
93	}
94	return strControllerName < rThat.strControllerName;
95	}
96
97	/*
98	* Bus comparsion in boot priority order.
99	*/
100	/* IDE first. */
101	if (enmBus == StorageBus_IDE)
102	return true;
103	if (rThat.enmBus == StorageBus_IDE)
104	return false;
105	/* SATA next */
106	if (enmBus == StorageBus_SATA)
107	return true;
108	if (rThat.enmBus == StorageBus_SATA)
109	return false;
110	/* SCSI next */
111	if (enmBus == StorageBus_SCSI)
112	return true;
113	if (rThat.enmBus == StorageBus_SCSI)
114	return false;
115	/* numerical */
116	return (int)enmBus < (int)rThat.enmBus;
117	}
118
119	bool operator==(const ControllerSlot &rThat) const
120	{
121	return enmBus == rThat.enmBus
122	&& strControllerName == rThat.strControllerName
123	&& iPort == rThat.iPort
124	&& iDevice == rThat.iDevice;
125	}
126	};
127
128	/**
129	* Installation disk.
130	*
131	* Used when reconfiguring the VM.
132	*/
133	typedef struct UnattendedInstallationDisk
134	{
135	StorageBus_T enmBusType; /*< @todo nobody is using this... /
136	Utf8Str strControllerName;
137	DeviceType_T enmDeviceType;
138	AccessMode_T enmAccessType;
139	LONG iPort;
140	LONG iDevice;
141	bool fMountOnly;
142	Utf8Str strImagePath;
143	bool fAuxiliary;
144
145	UnattendedInstallationDisk(StorageBus_T a_enmBusType, Utf8Str const &a_rBusName, DeviceType_T a_enmDeviceType,
146	AccessMode_T a_enmAccessType, LONG a_iPort, LONG a_iDevice, bool a_fMountOnly,
147	Utf8Str const &a_rImagePath, bool a_fAuxiliary)
148	: enmBusType(a_enmBusType), strControllerName(a_rBusName), enmDeviceType(a_enmDeviceType), enmAccessType(a_enmAccessType)
149	, iPort(a_iPort), iDevice(a_iDevice), fMountOnly(a_fMountOnly), strImagePath(a_rImagePath), fAuxiliary(a_fAuxiliary)
150	{
151	Assert(strControllerName.length() > 0);
152	}
153
154	UnattendedInstallationDisk(std::list<ControllerSlot>::const_iterator const &itDvdSlot, Utf8Str const &a_rImagePath,
155	bool a_fAuxiliary)
156	: enmBusType(itDvdSlot->enmBus), strControllerName(itDvdSlot->strControllerName), enmDeviceType(DeviceType_DVD)
157	, enmAccessType(AccessMode_ReadOnly), iPort(itDvdSlot->iPort), iDevice(itDvdSlot->iDevice)
158	, fMountOnly(!itDvdSlot->fFree), strImagePath(a_rImagePath), fAuxiliary(a_fAuxiliary)
159	{
160	Assert(strControllerName.length() > 0);
161	}
162	} UnattendedInstallationDisk;
163
164
165	/**
166	* OS/2 syslevel file header.
167	*/
168	#pragma pack(1)
169	typedef struct OS2SYSLEVELHDR
170	{
171	uint16_t uMinusOne; /*< 0x00: UINT16_MAX /
172	char achSignature[8]; /*< 0x02: "SYSLEVEL" /
173	uint8_t abReserved1[5]; /*< 0x0a: Usually zero. Ignore. /
174	uint16_t uSyslevelFileVer; /*< 0x0f: The syslevel file version: 1. /
175	uint8_t abReserved2[16]; /*< 0x11: Zero. Ignore. /
176	uint32_t offTable; /*< 0x21: Offset of the syslevel table. /
177	} OS2SYSLEVELHDR;
178	#pragma pack()
179	AssertCompileSize(OS2SYSLEVELHDR, 0x25);
180
181	/**
182	* OS/2 syslevel table entry.
183	*/
184	#pragma pack(1)
185	typedef struct OS2SYSLEVELENTRY
186	{
187	uint16_t id; /*< 0x00: ? /
188	uint8_t bEdition; /*< 0x02: The OS/2 edition: 0=standard, 1=extended, x=component defined /
189	uint8_t bVersion; /*< 0x03: 0x45 = 4.5 /
190	uint8_t bModify; /*< 0x04: Lower nibble is added to bVersion, so 0x45 0x02 => 4.52 /
191	uint8_t abReserved1[2]; /*< 0x05: Zero. Ignore. /
192	char achCsdLevel[8]; /*< 0x07: The current CSD level. /
193	char achCsdPrior[8]; /*< 0x0f: The prior CSD level. /
194	char szName[80]; /*< 0x5f: System/component name. /
195	char achId[9]; /*< 0x67: System/component ID. /
196	uint8_t bRefresh; /*< 0x70: Single digit refresh version, ignored if zero. /
197	char szType[9]; /*< 0x71: Some kind of type string. Optional /
198	uint8_t abReserved2[6]; /*< 0x7a: Zero. Ignore. /
199	} OS2SYSLEVELENTRY;
200	#pragma pack()
201	AssertCompileSize(OS2SYSLEVELENTRY, 0x80);
202
203
204
205	/**
206	* Concatenate image name and version strings and return.
207	*
208	* A possible output would be "Windows 10 Home (10.0.19041.330 / x64)".
209	*
210	* @returns Name string to use.
211	* @param r_strName String object that can be formatted into and returned.
212	*/
213	const Utf8Str &WIMImage::formatName(Utf8Str &r_strName) const
214	{
215	/* We skip the mFlavor as it's typically part of the description already. */
216
217	if (mVersion.isEmpty() && mArch.isEmpty() && mDefaultLanguage.isEmpty() && mLanguages.size() == 0)
218	return mName;
219
220	r_strName = mName;
221	bool fFirst = true;
222	if (mVersion.isNotEmpty())
223	{
224	r_strName.appendPrintf(fFirst ? " (%s" : " / %s", mVersion.c_str());
225	fFirst = false;
226	}
227	if (mArch.isNotEmpty())
228	{
229	r_strName.appendPrintf(fFirst ? " (%s" : " / %s", mArch.c_str());
230	fFirst = false;
231	}
232	if (mDefaultLanguage.isNotEmpty())
233	{
234	r_strName.appendPrintf(fFirst ? " (%s" : " / %s", mDefaultLanguage.c_str());
235	fFirst = false;
236	}
237	else
238	for (size_t i = 0; i < mLanguages.size(); i++)
239	{
240	r_strName.appendPrintf(fFirst ? " (%s" : " / %s", mLanguages[i].c_str());
241	fFirst = false;
242	}
243	r_strName.append(")");
244	return r_strName;
245	}
246
247
248	//////////////////////////////////////////////////////////////////////////////////////////////////////
249	/*
250	*
251	*
252	* Implementation Unattended functions
253	*
254	*/
255	//////////////////////////////////////////////////////////////////////////////////////////////////////
256
257	Unattended::Unattended()
258	: mhThreadReconfigureVM(NIL_RTNATIVETHREAD), mfRtcUseUtc(false), mfGuestOs64Bit(false)
259	, mpInstaller(NULL), mpTimeZoneInfo(NULL), mfIsDefaultAuxiliaryBasePath(true), mfDoneDetectIsoOS(false)
260	, mfAvoidUpdatesOverNetwork(false)
261	{ }
262
263	Unattended::~Unattended()
264	{
265	if (mpInstaller)
266	{
267	delete mpInstaller;
268	mpInstaller = NULL;
269	}
270	}
271
272	HRESULT Unattended::FinalConstruct()
273	{
274	return BaseFinalConstruct();
275	}
276
277	void Unattended::FinalRelease()
278	{
279	uninit();
280
281	BaseFinalRelease();
282	}
283
284	void Unattended::uninit()
285	{
286	/* Enclose the state transition Ready->InUninit->NotReady */
287	AutoUninitSpan autoUninitSpan(this);
288	if (autoUninitSpan.uninitDone())
289	return;
290
291	unconst(mParent) = NULL;
292	mMachine.setNull();
293	}
294
295	/**
296	* Initializes the unattended object.
297	*
298	* @param aParent Pointer to the parent object.
299	*/
300	HRESULT Unattended::initUnattended(VirtualBox *aParent)
301	{
302	LogFlowThisFunc(("aParent=%p\n", aParent));
303	ComAssertRet(aParent, E_INVALIDARG);
304
305	/* Enclose the state transition NotReady->InInit->Ready */
306	AutoInitSpan autoInitSpan(this);
307	AssertReturn(autoInitSpan.isOk(), E_FAIL);
308
309	unconst(mParent) = aParent;
310
311	/*
312	* Fill public attributes (IUnattended) with useful defaults.
313	*/
314	try
315	{
316	mStrUser = "vboxuser";
317	mStrPassword = "changeme";
318	mfInstallGuestAdditions = false;
319	mfInstallTestExecService = false;
320	midxImage = 1;
321
322	HRESULT hrc = mParent->i_getSystemProperties()->i_getDefaultAdditionsISO(mStrAdditionsIsoPath);
323	ComAssertComRCRet(hrc, hrc);
324	}
325	catch (std::bad_alloc &)
326	{
327	return E_OUTOFMEMORY;
328	}
329
330	/*
331	* Confirm a successful initialization
332	*/
333	autoInitSpan.setSucceeded();
334
335	return S_OK;
336	}
337
338	HRESULT Unattended::detectIsoOS()
339	{
340	HRESULT hrc;
341	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
342
343	/** @todo once UDF is implemented properly and we've tested this code a lot
344	* more, replace E_NOTIMPL with E_FAIL. */
345
346	/*
347	* Reset output state before we start
348	*/
349	mStrDetectedOSTypeId.setNull();
350	mStrDetectedOSVersion.setNull();
351	mStrDetectedOSFlavor.setNull();
352	mDetectedOSLanguages.clear();
353	mStrDetectedOSHints.setNull();
354	mDetectedImages.clear();
355
356	/*
357	* Open the ISO.
358	*/
359	RTVFSFILE hVfsFileIso;
360	int vrc = RTVfsFileOpenNormal(mStrIsoPath.c_str(), RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, &hVfsFileIso);
361	if (RT_FAILURE(vrc))
362	return setErrorBoth(E_NOTIMPL, vrc, tr("Failed to open '%s' (%Rrc)"), mStrIsoPath.c_str(), vrc);
363
364	RTERRINFOSTATIC ErrInfo;
365	RTVFS hVfsIso;
366	vrc = RTFsIso9660VolOpen(hVfsFileIso, 0 /fFlags/, &hVfsIso, RTErrInfoInitStatic(&ErrInfo));
367	if (RT_SUCCESS(vrc))
368	{
369	/*
370	* Try do the detection. Repeat for different file system variations (nojoliet, noudf).
371	*/
372	hrc = i_innerDetectIsoOS(hVfsIso);
373
374	RTVfsRelease(hVfsIso);
375	if (hrc == S_FALSE) /** @todo Finish the linux and windows detection code. Only OS/2 returns S_OK right now. */
376	hrc = E_NOTIMPL;
377	}
378	else if (RTErrInfoIsSet(&ErrInfo.Core))
379	hrc = setErrorBoth(E_NOTIMPL, vrc, tr("Failed to open '%s' as ISO FS (%Rrc) - %s"),
380	mStrIsoPath.c_str(), vrc, ErrInfo.Core.pszMsg);
381	else
382	hrc = setErrorBoth(E_NOTIMPL, vrc, tr("Failed to open '%s' as ISO FS (%Rrc)"), mStrIsoPath.c_str(), vrc);
383	RTVfsFileRelease(hVfsFileIso);
384
385	/*
386	* Just fake up some windows installation media locale (for <UILanguage>).
387	* Note! The translation here isn't perfect. Feel free to send us a patch.
388	*/
389	if (mDetectedOSLanguages.size() == 0)
390	{
391	char szTmp[16];
392	const char *pszFilename = RTPathFilename(mStrIsoPath.c_str());
393	if ( pszFilename
394	&& RT_C_IS_ALPHA(pszFilename[0])
395	&& RT_C_IS_ALPHA(pszFilename[1])
396	&& (pszFilename[2] == '-' \|\| pszFilename[2] == '_') )
397	{
398	szTmp[0] = (char)RT_C_TO_LOWER(pszFilename[0]);
399	szTmp[1] = (char)RT_C_TO_LOWER(pszFilename[1]);
400	szTmp[2] = '-';
401	if (szTmp[0] == 'e' && szTmp[1] == 'n')
402	strcpy(&szTmp[3], "US");
403	else if (szTmp[0] == 'a' && szTmp[1] == 'r')
404	strcpy(&szTmp[3], "SA");
405	else if (szTmp[0] == 'd' && szTmp[1] == 'a')
406	strcpy(&szTmp[3], "DK");
407	else if (szTmp[0] == 'e' && szTmp[1] == 't')
408	strcpy(&szTmp[3], "EE");
409	else if (szTmp[0] == 'e' && szTmp[1] == 'l')
410	strcpy(&szTmp[3], "GR");
411	else if (szTmp[0] == 'h' && szTmp[1] == 'e')
412	strcpy(&szTmp[3], "IL");
413	else if (szTmp[0] == 'j' && szTmp[1] == 'a')
414	strcpy(&szTmp[3], "JP");
415	else if (szTmp[0] == 's' && szTmp[1] == 'v')
416	strcpy(&szTmp[3], "SE");
417	else if (szTmp[0] == 'u' && szTmp[1] == 'k')
418	strcpy(&szTmp[3], "UA");
419	else if (szTmp[0] == 'c' && szTmp[1] == 's')
420	strcpy(szTmp, "cs-CZ");
421	else if (szTmp[0] == 'n' && szTmp[1] == 'o')
422	strcpy(szTmp, "nb-NO");
423	else if (szTmp[0] == 'p' && szTmp[1] == 'p')
424	strcpy(szTmp, "pt-PT");
425	else if (szTmp[0] == 'p' && szTmp[1] == 't')
426	strcpy(szTmp, "pt-BR");
427	else if (szTmp[0] == 'c' && szTmp[1] == 'n')
428	strcpy(szTmp, "zh-CN");
429	else if (szTmp[0] == 'h' && szTmp[1] == 'k')
430	strcpy(szTmp, "zh-HK");
431	else if (szTmp[0] == 't' && szTmp[1] == 'w')
432	strcpy(szTmp, "zh-TW");
433	else if (szTmp[0] == 's' && szTmp[1] == 'r')
434	strcpy(szTmp, "sr-Latn-CS"); /* hmm */
435	else
436	{
437	szTmp[3] = (char)RT_C_TO_UPPER(pszFilename[0]);
438	szTmp[4] = (char)RT_C_TO_UPPER(pszFilename[1]);
439	szTmp[5] = '\0';
440	}
441	}
442	else
443	strcpy(szTmp, "en-US");
444	try
445	{
446	mDetectedOSLanguages.append(szTmp);
447	}
448	catch (std::bad_alloc &)
449	{
450	return E_OUTOFMEMORY;
451	}
452	}
453
454	/** @todo implement actual detection logic. */
455	return hrc;
456	}
457
458	HRESULT Unattended::i_innerDetectIsoOS(RTVFS hVfsIso)
459	{
460	DETECTBUFFER uBuf;
461	mEnmOsType = VBOXOSTYPE_Unknown;
462	HRESULT hrc = i_innerDetectIsoOSWindows(hVfsIso, &uBuf);
463	if (hrc == S_FALSE && mEnmOsType == VBOXOSTYPE_Unknown)
464	hrc = i_innerDetectIsoOSLinux(hVfsIso, &uBuf);
465	if (hrc == S_FALSE && mEnmOsType == VBOXOSTYPE_Unknown)
466	hrc = i_innerDetectIsoOSOs2(hVfsIso, &uBuf);
467	if (hrc == S_FALSE && mEnmOsType == VBOXOSTYPE_Unknown)
468	hrc = i_innerDetectIsoOSFreeBsd(hVfsIso, &uBuf);
469	if (mEnmOsType != VBOXOSTYPE_Unknown)
470	{
471	try { mStrDetectedOSTypeId = Global::OSTypeId(mEnmOsType); }
472	catch (std::bad_alloc &) { hrc = E_OUTOFMEMORY; }
473	}
474	return hrc;
475	}
476
477	/**
478	* Tries to parse a LANGUAGES element, with the following structure.
479	* @verbatim
480	* <LANGUAGES>
481	* <LANGUAGE>
482	* en-US
483	* </LANGUAGE>
484	* <DEFAULT>
485	* en-US
486	* </DEFAULT>
487	* </LANGUAGES>
488	* @endverbatim
489	*
490	* Will set mLanguages and mDefaultLanguage success.
491	*
492	* @param pElmLanguages Points to the LANGUAGES XML node.
493	* @param rImage Out reference to an WIMImage instance.
494	*/
495	static void parseLangaguesElement(const xml::ElementNode *pElmLanguages, WIMImage &rImage)
496	{
497	/*
498	* The languages.
499	*/
500	ElementNodesList children;
501	int cChildren = pElmLanguages->getChildElements(children, "LANGUAGE");
502	if (cChildren == 0)
503	cChildren = pElmLanguages->getChildElements(children, "language");
504	if (cChildren == 0)
505	cChildren = pElmLanguages->getChildElements(children, "Language");
506	for (ElementNodesList::iterator iterator = children.begin(); iterator != children.end(); ++iterator)
507	{
508	const ElementNode * const pElmLanguage = *(iterator);
509	if (pElmLanguage)
510	{
511	const char *pszValue = pElmLanguage->getValue();
512	if (pszValue && *pszValue != '\0')
513	rImage.mLanguages.append(pszValue);
514	}
515	}
516
517	/*
518	* Default language.
519	*/
520	const xml::ElementNode *pElmDefault;
521	if ( (pElmDefault = pElmLanguages->findChildElement("DEFAULT")) != NULL
522	\|\| (pElmDefault = pElmLanguages->findChildElement("default")) != NULL
523	\|\| (pElmDefault = pElmLanguages->findChildElement("Default")) != NULL)
524	rImage.mDefaultLanguage = pElmDefault->getValue();
525	}
526
527
528	/**
529	* Tries to set the image architecture.
530	*
531	* Input examples (x86 and amd64 respectively):
532	* @verbatim
533	* <ARCH>0</ARCH>
534	* <ARCH>9</ARCH>
535	* @endverbatim
536	*
537	* Will set mArch and update mOSType on success.
538	*
539	* @param pElmArch Points to the ARCH XML node.
540	* @param rImage Out reference to an WIMImage instance.
541	*/
542	static void parseArchElement(const xml::ElementNode *pElmArch, WIMImage &rImage)
543	{
544	/* These are from winnt.h */
545	static struct { const char *pszArch; VBOXOSTYPE enmArch; } s_aArches[] =
546	{
547	/* PROCESSOR_ARCHITECTURE_INTEL / [0] = */ { "x86", VBOXOSTYPE_x86 },
548	/* PROCESSOR_ARCHITECTURE_MIPS / [1] = */ { "mips", VBOXOSTYPE_UnknownArch },
549	/* PROCESSOR_ARCHITECTURE_ALPHA / [2] = */ { "alpha", VBOXOSTYPE_UnknownArch },
550	/* PROCESSOR_ARCHITECTURE_PPC / [3] = */ { "ppc", VBOXOSTYPE_UnknownArch },
551	/* PROCESSOR_ARCHITECTURE_SHX / [4] = */ { "shx", VBOXOSTYPE_UnknownArch },
552	/* PROCESSOR_ARCHITECTURE_ARM / [5] = */ { "arm32", VBOXOSTYPE_arm32 },
553	/* PROCESSOR_ARCHITECTURE_IA64 / [6] = */ { "ia64", VBOXOSTYPE_UnknownArch },
554	/* PROCESSOR_ARCHITECTURE_ALPHA64 / [7] = */ { "alpha64", VBOXOSTYPE_UnknownArch },
555	/* PROCESSOR_ARCHITECTURE_MSIL / [8] = */ { "msil", VBOXOSTYPE_UnknownArch },
556	/* PROCESSOR_ARCHITECTURE_AMD64 / [9] = */ { "x64", VBOXOSTYPE_x64 },
557	/* PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 / [10] = */ { "x86-on-x64", VBOXOSTYPE_UnknownArch },
558	/* PROCESSOR_ARCHITECTURE_NEUTRAL / [11] = */ { "noarch", VBOXOSTYPE_UnknownArch },
559	/* PROCESSOR_ARCHITECTURE_ARM64 / [12] = */ { "arm64", VBOXOSTYPE_arm64 },
560	/* PROCESSOR_ARCHITECTURE_ARM32_ON_WIN64/ [13] = */ { "arm32-on-arm64", VBOXOSTYPE_UnknownArch },
561	/* PROCESSOR_ARCHITECTURE_IA32_ON_ARM64 / [14] = */ { "x86-on-arm32", VBOXOSTYPE_UnknownArch },
562	};
563	const char *pszArch = pElmArch->getValue();
564	if (pszArch && *pszArch)
565	{
566	uint32_t uArch;
567	int vrc = RTStrToUInt32Ex(pszArch, NULL, 10 /uBase/, &uArch);
568	if ( RT_SUCCESS(vrc)
569	&& vrc != VWRN_NUMBER_TOO_BIG
570	&& vrc != VWRN_NEGATIVE_UNSIGNED
571	&& uArch < RT_ELEMENTS(s_aArches))
572	{
573	rImage.mArch = s_aArches[uArch].pszArch;
574	rImage.mOSType = (VBOXOSTYPE)(s_aArches[uArch].enmArch \| (rImage.mOSType & VBOXOSTYPE_OsTypeMask));
575	}
576	else
577	LogRel(("Unattended: bogus ARCH element value: '%s'\n", pszArch));
578	}
579	}
580
581	/**
582	* Parses XML Node assuming a structure as follows
583	* @verbatim
584	* <VERSION>
585	* <MAJOR>10</MAJOR>
586	* <MINOR>0</MINOR>
587	* <BUILD>19041</BUILD>
588	* <SPBUILD>1</SPBUILD>
589	* </VERSION>
590	* @endverbatim
591	*
592	* Will update mOSType, mEnmOsType as well as setting mVersion on success.
593	*
594	* @param pNode Points to the vesion XML node,
595	* @param image Out reference to an WIMImage instance.
596	*/
597	static void parseVersionElement(const xml::ElementNode *pNode, WIMImage &image)
598	{
599	/* Major part: */
600	const xml::ElementNode *pElmMajor;
601	if ( (pElmMajor = pNode->findChildElement("MAJOR")) != NULL
602	\|\| (pElmMajor = pNode->findChildElement("major")) != NULL
603	\|\| (pElmMajor = pNode->findChildElement("Major")) != NULL)
604	if (pElmMajor)
605	{
606	const char * const pszMajor = pElmMajor->getValue();
607	if (pszMajor && *pszMajor)
608	{
609	/* Minor part: */
610	const ElementNode *pElmMinor;
611	if ( (pElmMinor = pNode->findChildElement("MINOR")) != NULL
612	\|\| (pElmMinor = pNode->findChildElement("minor")) != NULL
613	\|\| (pElmMinor = pNode->findChildElement("Minor")) != NULL)
614	{
615	const char * const pszMinor = pElmMinor->getValue();
616	if (pszMinor && *pszMinor)
617	{
618	/* Build: */
619	const ElementNode *pElmBuild;
620	if ( (pElmBuild = pNode->findChildElement("BUILD")) != NULL
621	\|\| (pElmBuild = pNode->findChildElement("build")) != NULL
622	\|\| (pElmBuild = pNode->findChildElement("Build")) != NULL)
623	{
624	const char * const pszBuild = pElmBuild->getValue();
625	if (pszBuild && *pszBuild)
626	{
627	/* SPBuild: */
628	const ElementNode *pElmSpBuild;
629	if ( ( (pElmSpBuild = pNode->findChildElement("SPBUILD")) != NULL
630	\|\| (pElmSpBuild = pNode->findChildElement("spbuild")) != NULL
631	\|\| (pElmSpBuild = pNode->findChildElement("Spbuild")) != NULL
632	\|\| (pElmSpBuild = pNode->findChildElement("SpBuild")) != NULL)
633	&& pElmSpBuild->getValue()
634	&& *pElmSpBuild->getValue() != '\0')
635	image.mVersion.printf("%s.%s.%s.%s", pszMajor, pszMinor, pszBuild, pElmSpBuild->getValue());
636	else
637	image.mVersion.printf("%s.%s.%s", pszMajor, pszMinor, pszBuild);
638
639	/*
640	* Convert that to a version windows OS ID (newest first!).
641	*/
642	image.mEnmOsType = VBOXOSTYPE_Unknown;
643	if (RTStrVersionCompare(image.mVersion.c_str(), "10.0.22000.0") >= 0)
644	image.mEnmOsType = VBOXOSTYPE_Win11_x64;
645	else if (RTStrVersionCompare(image.mVersion.c_str(), "10.0") >= 0)
646	image.mEnmOsType = VBOXOSTYPE_Win10;
647	else if (RTStrVersionCompare(image.mVersion.c_str(), "6.3") >= 0)
648	image.mEnmOsType = VBOXOSTYPE_Win81;
649	else if (RTStrVersionCompare(image.mVersion.c_str(), "6.2") >= 0)
650	image.mEnmOsType = VBOXOSTYPE_Win8;
651	else if (RTStrVersionCompare(image.mVersion.c_str(), "6.1") >= 0)
652	image.mEnmOsType = VBOXOSTYPE_Win7;
653	else if (RTStrVersionCompare(image.mVersion.c_str(), "6.0") >= 0)
654	image.mEnmOsType = VBOXOSTYPE_WinVista;
655	if (image.mFlavor.contains("server", Utf8Str::CaseInsensitive))
656	{
657	if (RTStrVersionCompare(image.mVersion.c_str(), "10.0.20348") >= 0)
658	image.mEnmOsType = VBOXOSTYPE_Win2k22_x64;
659	else if (RTStrVersionCompare(image.mVersion.c_str(), "10.0.17763") >= 0)
660	image.mEnmOsType = VBOXOSTYPE_Win2k19_x64;
661	else if (RTStrVersionCompare(image.mVersion.c_str(), "10.0") >= 0)
662	image.mEnmOsType = VBOXOSTYPE_Win2k16_x64;
663	else if (RTStrVersionCompare(image.mVersion.c_str(), "6.2") >= 0)
664	image.mEnmOsType = VBOXOSTYPE_Win2k12_x64;
665	else if (RTStrVersionCompare(image.mVersion.c_str(), "6.0") >= 0)
666	image.mEnmOsType = VBOXOSTYPE_Win2k8;
667	}
668	if (image.mEnmOsType != VBOXOSTYPE_Unknown)
669	image.mOSType = (VBOXOSTYPE)( (image.mOSType & VBOXOSTYPE_ArchitectureMask)
670	\| (image.mEnmOsType & VBOXOSTYPE_OsTypeMask));
671	return;
672	}
673	}
674	}
675	}
676	}
677	}
678	Log(("Unattended: Warning! Bogus/missing version info for image #%u / %s\n", image.mImageIndex, image.mName.c_str()));
679	}
680
681	/**
682	* Parses XML tree assuming th following structure
683	* @verbatim
684	* <WIM>
685	* ...
686	* <IMAGE INDEX="1">
687	* ...
688	* <DISPLAYNAME>Windows 10 Home</DISPLAYNAME>
689	* <WINDOWS>
690	* <ARCH>NN</ARCH>
691	* <VERSION>
692	* ...
693	* </VERSION>
694	* <LANGUAGES>
695	* <LANGUAGE>
696	* en-US
697	* </LANGUAGE>
698	* <DEFAULT>
699	* en-US
700	* </DEFAULT>
701	* </LANGUAGES>
702	* </WINDOWS>
703	* </IMAGE>
704	* </WIM>
705	* @endverbatim
706	*
707	* @param pElmRoot Pointer to the root node of the tree,
708	* @param imageList Detected images are appended to this list.
709	*/
710	static void parseWimXMLData(const xml::ElementNode *pElmRoot, RTCList<WIMImage> &imageList)
711	{
712	if (!pElmRoot)
713	return;
714
715	ElementNodesList children;
716	int cChildren = pElmRoot->getChildElements(children, "IMAGE");
717	if (cChildren == 0)
718	cChildren = pElmRoot->getChildElements(children, "image");
719	if (cChildren == 0)
720	cChildren = pElmRoot->getChildElements(children, "Image");
721
722	for (ElementNodesList::iterator iterator = children.begin(); iterator != children.end(); ++iterator)
723	{
724	const ElementNode pChild = (iterator);
725	if (!pChild)
726	continue;
727
728	WIMImage newImage;
729
730	if ( !pChild->getAttributeValue("INDEX", &newImage.mImageIndex)
731	&& !pChild->getAttributeValue("index", &newImage.mImageIndex)
732	&& !pChild->getAttributeValue("Index", &newImage.mImageIndex))
733	continue;
734
735	const ElementNode *pElmName;
736	if ( (pElmName = pChild->findChildElement("DISPLAYNAME")) == NULL
737	&& (pElmName = pChild->findChildElement("displayname")) == NULL
738	&& (pElmName = pChild->findChildElement("Displayname")) == NULL
739	&& (pElmName = pChild->findChildElement("DisplayName")) == NULL
740	/* Early vista images didn't have DISPLAYNAME. */
741	&& (pElmName = pChild->findChildElement("NAME")) == NULL
742	&& (pElmName = pChild->findChildElement("name")) == NULL
743	&& (pElmName = pChild->findChildElement("Name")) == NULL)
744	continue;
745	newImage.mName = pElmName->getValue();
746	if (newImage.mName.isEmpty())
747	continue;
748
749	const ElementNode *pElmWindows;
750	if ( (pElmWindows = pChild->findChildElement("WINDOWS")) != NULL
751	\|\| (pElmWindows = pChild->findChildElement("windows")) != NULL
752	\|\| (pElmWindows = pChild->findChildElement("Windows")) != NULL)
753	{
754	/* Do edition/flags before the version so it can better determin
755	the OS version enum value. Old windows version (vista) typically
756	doesn't have an EDITIONID element, so fall back on the FLAGS element
757	under IMAGE as it is pretty similar (case differences). */
758	const ElementNode *pElmEditionId;
759	if ( (pElmEditionId = pElmWindows->findChildElement("EDITIONID")) != NULL
760	\|\| (pElmEditionId = pElmWindows->findChildElement("editionid")) != NULL
761	\|\| (pElmEditionId = pElmWindows->findChildElement("Editionid")) != NULL
762	\|\| (pElmEditionId = pElmWindows->findChildElement("EditionId")) != NULL
763	\|\| (pElmEditionId = pChild->findChildElement("FLAGS")) != NULL
764	\|\| (pElmEditionId = pChild->findChildElement("flags")) != NULL
765	\|\| (pElmEditionId = pChild->findChildElement("Flags")) != NULL)
766	if ( pElmEditionId->getValue()
767	&& *pElmEditionId->getValue() != '\0')
768	newImage.mFlavor = pElmEditionId->getValue();
769
770	const ElementNode *pElmVersion;
771	if ( (pElmVersion = pElmWindows->findChildElement("VERSION")) != NULL
772	\|\| (pElmVersion = pElmWindows->findChildElement("version")) != NULL
773	\|\| (pElmVersion = pElmWindows->findChildElement("Version")) != NULL)
774	parseVersionElement(pElmVersion, newImage);
775
776	/* The ARCH element contains a number from the
777	PROCESSOR_ARCHITECTURE_XXX set of defines in winnt.h: */
778	const ElementNode *pElmArch;
779	if ( (pElmArch = pElmWindows->findChildElement("ARCH")) != NULL
780	\|\| (pElmArch = pElmWindows->findChildElement("arch")) != NULL
781	\|\| (pElmArch = pElmWindows->findChildElement("Arch")) != NULL)
782	parseArchElement(pElmArch, newImage);
783
784	/* Extract languages and default language: */
785	const ElementNode *pElmLang;
786	if ( (pElmLang = pElmWindows->findChildElement("LANGUAGES")) != NULL
787	\|\| (pElmLang = pElmWindows->findChildElement("languages")) != NULL
788	\|\| (pElmLang = pElmWindows->findChildElement("Languages")) != NULL)
789	parseLangaguesElement(pElmLang, newImage);
790	}
791
792
793	imageList.append(newImage);
794	}
795	}
796
797	/**
798	* Detect Windows ISOs.
799	*
800	* @returns COM status code.
801	* @retval S_OK if detected
802	* @retval S_FALSE if not fully detected.
803	*
804	* @param hVfsIso The ISO file system.
805	* @param pBuf Read buffer.
806	*/
807	HRESULT Unattended::i_innerDetectIsoOSWindows(RTVFS hVfsIso, DETECTBUFFER *pBuf)
808	{
809	/** @todo The 'sources/' path can differ. */
810
811	// globalinstallorder.xml - vista beta2
812	// sources/idwbinfo.txt - ditto.
813	// sources/lang.ini - ditto.
814
815	/*
816	* The install.wim file contains an XML document describing the install
817	* images it contains. This includes all the info we need for a successful
818	* detection.
819	*/
820	RTVFSFILE hVfsFile;
821	int vrc = RTVfsFileOpen(hVfsIso, "sources/install.wim", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
822	if (RT_SUCCESS(vrc))
823	{
824	WIMHEADERV1 header;
825	size_t cbRead = 0;
826	vrc = RTVfsFileRead(hVfsFile, &header, sizeof(header), &cbRead);
827	if (RT_SUCCESS(vrc) && cbRead == sizeof(header))
828	{
829	/* If the xml data is not compressed, xml data is not empty, and not too big. */
830	if ( (header.XmlData.bFlags & RESHDR_FLAGS_METADATA)
831	&& !(header.XmlData.bFlags & RESHDR_FLAGS_COMPRESSED)
832	&& header.XmlData.cbOriginal >= 32
833	&& header.XmlData.cbOriginal < _32M
834	&& header.XmlData.cbOriginal == header.XmlData.cb)
835	{
836	size_t const cbXmlData = (size_t)header.XmlData.cbOriginal;
837	char pachXmlBuf = (char )RTMemTmpAlloc(cbXmlData);
838	if (pachXmlBuf)
839	{
840	vrc = RTVfsFileReadAt(hVfsFile, (RTFOFF)header.XmlData.off, pachXmlBuf, cbXmlData, NULL);
841	if (RT_SUCCESS(vrc))
842	{
843	LogRel2(("XML Data (%#zx bytes):\n%32.*Rhxd\n", cbXmlData, cbXmlData, pachXmlBuf));
844
845	/* Parse the XML: */
846	xml::Document doc;
847	xml::XmlMemParser parser;
848	try
849	{
850	RTCString strFileName = "source/install.wim";
851	parser.read(pachXmlBuf, cbXmlData, strFileName, doc);
852	}
853	catch (xml::XmlError &rErr)
854	{
855	LogRel(("Unattended: An error has occured during XML parsing: %s\n", rErr.what()));
856	vrc = VERR_XAR_TOC_XML_PARSE_ERROR;
857	}
858	catch (std::bad_alloc &)
859	{
860	LogRel(("Unattended: std::bad_alloc\n"));
861	vrc = VERR_NO_MEMORY;
862	}
863	catch (...)
864	{
865	LogRel(("Unattended: An unknown error has occured during XML parsing.\n"));
866	vrc = VERR_UNEXPECTED_EXCEPTION;
867	}
868	if (RT_SUCCESS(vrc))
869	{
870	/* Extract the information we need from the XML document: */
871	xml::ElementNode *pElmRoot = doc.getRootElement();
872	if (pElmRoot)
873	{
874	Assert(mDetectedImages.size() == 0);
875	try
876	{
877	mDetectedImages.clear(); /* debugging convenience */
878	parseWimXMLData(pElmRoot, mDetectedImages);
879	}
880	catch (std::bad_alloc &)
881	{
882	vrc = VERR_NO_MEMORY;
883	}
884
885	/*
886	* If we found images, update the detected info attributes.
887	*/
888	if (RT_SUCCESS(vrc) && mDetectedImages.size() > 0)
889	{
890	size_t i;
891	for (i = 0; i < mDetectedImages.size(); i++)
892	if (mDetectedImages[i].mImageIndex == midxImage)
893	break;
894	if (i >= mDetectedImages.size())
895	i = 0; /* use the first one if midxImage wasn't found */
896	if (i_updateDetectedAttributeForImage(mDetectedImages[i]))
897	{
898	LogRel2(("Unattended: happy with mDetectedImages[%u]\n", i));
899	mEnmOsType = mDetectedImages[i].mOSType;
900	return S_OK;
901	}
902	}
903	}
904	else
905	LogRel(("Unattended: No root element found in XML Metadata of install.wim\n"));
906	}
907	}
908	else
909	LogRel(("Unattended: Failed during reading XML Metadata out of install.wim\n"));
910	RTMemTmpFree(pachXmlBuf);
911	}
912	else
913	{
914	LogRel(("Unattended: Failed to allocate %#zx bytes for XML Metadata\n", cbXmlData));
915	vrc = VERR_NO_TMP_MEMORY;
916	}
917	}
918	else
919	LogRel(("Unattended: XML Metadata of install.wim is either compressed, empty, or too big (bFlags=%#x cbOriginal=%#RX64 cb=%#RX64)\n",
920	header.XmlData.bFlags, header.XmlData.cbOriginal, header.XmlData.cb));
921	}
922	RTVfsFileRelease(hVfsFile);
923
924	/* Bail out if we ran out of memory here. */
925	if (vrc == VERR_NO_MEMORY \|\| vrc == VERR_NO_TMP_MEMORY)
926	return setErrorBoth(E_OUTOFMEMORY, vrc, tr("Out of memory"));
927	}
928
929	const char *pszVersion = NULL;
930	const char *pszProduct = NULL;
931	/*
932	* Try look for the 'sources/idwbinfo.txt' file containing windows build info.
933	* This file appeared with Vista beta 2 from what we can tell. Before windows 10
934	* it contains easily decodable branch names, after that things goes weird.
935	*/
936	vrc = RTVfsFileOpen(hVfsIso, "sources/idwbinfo.txt", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
937	if (RT_SUCCESS(vrc))
938	{
939	mEnmOsType = VBOXOSTYPE_WinNT_x64;
940
941	RTINIFILE hIniFile;
942	vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
943	RTVfsFileRelease(hVfsFile);
944	if (RT_SUCCESS(vrc))
945	{
946	vrc = RTIniFileQueryValue(hIniFile, "BUILDINFO", "BuildArch", pBuf->sz, sizeof(*pBuf), NULL);
947	if (RT_SUCCESS(vrc))
948	{
949	LogRelFlow(("Unattended: sources/idwbinfo.txt: BuildArch=%s\n", pBuf->sz));
950	if ( RTStrNICmp(pBuf->sz, RT_STR_TUPLE("amd64")) == 0
951	\|\| RTStrNICmp(pBuf->sz, RT_STR_TUPLE("x64")) == 0 /* just in case */ )
952	mEnmOsType = VBOXOSTYPE_WinNT_x64;
953	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("x86")) == 0)
954	mEnmOsType = VBOXOSTYPE_WinNT;
955	else
956	{
957	LogRel(("Unattended: sources/idwbinfo.txt: Unknown: BuildArch=%s\n", pBuf->sz));
958	mEnmOsType = VBOXOSTYPE_WinNT_x64;
959	}
960	}
961
962	vrc = RTIniFileQueryValue(hIniFile, "BUILDINFO", "BuildBranch", pBuf->sz, sizeof(*pBuf), NULL);
963	if (RT_SUCCESS(vrc))
964	{
965	LogRelFlow(("Unattended: sources/idwbinfo.txt: BuildBranch=%s\n", pBuf->sz));
966	if ( RTStrNICmp(pBuf->sz, RT_STR_TUPLE("vista")) == 0
967	\|\| RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winmain_beta")) == 0)
968	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_WinVista);
969	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("lh_sp2rtm")) == 0)
970	{
971	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_WinVista);
972	pszVersion = "sp2";
973	}
974	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("longhorn_rtm")) == 0)
975	{
976	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_WinVista);
977	pszVersion = "sp1";
978	}
979	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("win7")) == 0)
980	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win7);
981	else if ( RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winblue")) == 0
982	\|\| RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winmain_blue")) == 0
983	\|\| RTStrNICmp(pBuf->sz, RT_STR_TUPLE("win81")) == 0 /* not seen, but just in case its out there */ )
984	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win81);
985	else if ( RTStrNICmp(pBuf->sz, RT_STR_TUPLE("win8")) == 0
986	\|\| RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winmain_win8")) == 0 )
987	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win8);
988	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("th1")) == 0)
989	{
990	pszVersion = "1507"; // aka. GA, retroactively 1507
991	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
992	}
993	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("th2")) == 0)
994	{
995	pszVersion = "1511"; // aka. threshold 2
996	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
997	}
998	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs1_release")) == 0)
999	{
1000	pszVersion = "1607"; // aka. anniversay update; rs=redstone
1001	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1002	}
1003	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs2_release")) == 0)
1004	{
1005	pszVersion = "1703"; // aka. creators update
1006	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1007	}
1008	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs3_release")) == 0)
1009	{
1010	pszVersion = "1709"; // aka. fall creators update
1011	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1012	}
1013	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs4_release")) == 0)
1014	{
1015	pszVersion = "1803";
1016	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1017	}
1018	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs5_release")) == 0)
1019	{
1020	pszVersion = "1809";
1021	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1022	}
1023	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("19h1_release")) == 0)
1024	{
1025	pszVersion = "1903";
1026	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1027	}
1028	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("19h2_release")) == 0)
1029	{
1030	pszVersion = "1909"; // ??
1031	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1032	}
1033	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("20h1_release")) == 0)
1034	{
1035	pszVersion = "2003"; // ??
1036	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1037	}
1038	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("vb_release")) == 0)
1039	{
1040	pszVersion = "2004"; // ?? vb=Vibranium
1041	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1042	}
1043	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("20h2_release")) == 0)
1044	{
1045	pszVersion = "2009"; // ??
1046	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1047	}
1048	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("21h1_release")) == 0)
1049	{
1050	pszVersion = "2103"; // ??
1051	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1052	}
1053	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("21h2_release")) == 0)
1054	{
1055	pszVersion = "2109"; // ??
1056	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win10);
1057	}
1058	else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("co_release")) == 0)
1059	{
1060	pszVersion = "21H2"; // ??
1061	mEnmOsType = VBOXOSTYPE_Win11_x64;
1062	}
1063	else
1064	LogRel(("Unattended: sources/idwbinfo.txt: Unknown: BuildBranch=%s\n", pBuf->sz));
1065	}
1066	RTIniFileRelease(hIniFile);
1067	}
1068	}
1069	bool fClarifyProd = false;
1070	if (RT_FAILURE(vrc))
1071	{
1072	/*
1073	* Check a INF file with a DriverVer that is updated with each service pack.
1074	* DriverVer=10/01/2002,5.2.3790.3959
1075	*/
1076	vrc = RTVfsFileOpen(hVfsIso, "AMD64/HIVESYS.INF", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1077	if (RT_SUCCESS(vrc))
1078	mEnmOsType = VBOXOSTYPE_WinNT_x64;
1079	else
1080	{
1081	vrc = RTVfsFileOpen(hVfsIso, "I386/HIVESYS.INF", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1082	if (RT_SUCCESS(vrc))
1083	mEnmOsType = VBOXOSTYPE_WinNT;
1084	}
1085	if (RT_SUCCESS(vrc))
1086	{
1087	RTINIFILE hIniFile;
1088	vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
1089	RTVfsFileRelease(hVfsFile);
1090	if (RT_SUCCESS(vrc))
1091	{
1092	vrc = RTIniFileQueryValue(hIniFile, "Version", "DriverVer", pBuf->sz, sizeof(*pBuf), NULL);
1093	if (RT_SUCCESS(vrc))
1094	{
1095	LogRelFlow(("Unattended: HIVESYS.INF: DriverVer=%s\n", pBuf->sz));
1096	const char *psz = strchr(pBuf->sz, ',');
1097	psz = psz ? psz + 1 : pBuf->sz;
1098	if (RTStrVersionCompare(psz, "6.0.0") >= 0)
1099	LogRel(("Unattended: HIVESYS.INF: unknown: DriverVer=%s\n", psz));
1100	else if (RTStrVersionCompare(psz, "5.2.0") >= 0) /* W2K3, XP64 */
1101	{
1102	fClarifyProd = true;
1103	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win2k3);
1104	if (RTStrVersionCompare(psz, "5.2.3790.3959") >= 0)
1105	pszVersion = "sp2";
1106	else if (RTStrVersionCompare(psz, "5.2.3790.1830") >= 0)
1107	pszVersion = "sp1";
1108	}
1109	else if (RTStrVersionCompare(psz, "5.1.0") >= 0) /* XP */
1110	{
1111	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_WinXP);
1112	if (RTStrVersionCompare(psz, "5.1.2600.5512") >= 0)
1113	pszVersion = "sp3";
1114	else if (RTStrVersionCompare(psz, "5.1.2600.2180") >= 0)
1115	pszVersion = "sp2";
1116	else if (RTStrVersionCompare(psz, "5.1.2600.1105") >= 0)
1117	pszVersion = "sp1";
1118	}
1119	else if (RTStrVersionCompare(psz, "5.0.0") >= 0)
1120	{
1121	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win2k);
1122	if (RTStrVersionCompare(psz, "5.0.2195.6717") >= 0)
1123	pszVersion = "sp4";
1124	else if (RTStrVersionCompare(psz, "5.0.2195.5438") >= 0)
1125	pszVersion = "sp3";
1126	else if (RTStrVersionCompare(psz, "5.0.2195.1620") >= 0)
1127	pszVersion = "sp1";
1128	}
1129	else
1130	LogRel(("Unattended: HIVESYS.INF: unknown: DriverVer=%s\n", psz));
1131	}
1132	RTIniFileRelease(hIniFile);
1133	}
1134	}
1135	}
1136	if (RT_FAILURE(vrc) \|\| fClarifyProd)
1137	{
1138	/*
1139	* NT 4 and older does not have DriverVer entries, we consult the PRODSPEC.INI, which
1140	* works for NT4 & W2K. It does usually not reflect the service pack.
1141	*/
1142	vrc = RTVfsFileOpen(hVfsIso, "AMD64/PRODSPEC.INI", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1143	if (RT_SUCCESS(vrc))
1144	mEnmOsType = VBOXOSTYPE_WinNT_x64;
1145	else
1146	{
1147	vrc = RTVfsFileOpen(hVfsIso, "I386/PRODSPEC.INI", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1148	if (RT_SUCCESS(vrc))
1149	mEnmOsType = VBOXOSTYPE_WinNT;
1150	}
1151	if (RT_SUCCESS(vrc))
1152	{
1153
1154	RTINIFILE hIniFile;
1155	vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
1156	RTVfsFileRelease(hVfsFile);
1157	if (RT_SUCCESS(vrc))
1158	{
1159	vrc = RTIniFileQueryValue(hIniFile, "Product Specification", "Version", pBuf->sz, sizeof(*pBuf), NULL);
1160	if (RT_SUCCESS(vrc))
1161	{
1162	LogRelFlow(("Unattended: PRODSPEC.INI: Version=%s\n", pBuf->sz));
1163	if (RTStrVersionCompare(pBuf->sz, "5.1") >= 0) /* Shipped with XP + W2K3, but version stuck at 5.0. */
1164	LogRel(("Unattended: PRODSPEC.INI: unknown: DriverVer=%s\n", pBuf->sz));
1165	else if (RTStrVersionCompare(pBuf->sz, "5.0") >= 0) /* 2000 */
1166	{
1167	vrc = RTIniFileQueryValue(hIniFile, "Product Specification", "Product", pBuf->sz, sizeof(*pBuf), NULL);
1168	if (RT_SUCCESS(vrc) && RTStrNICmp(pBuf->sz, RT_STR_TUPLE("Windows XP")) == 0)
1169	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_WinXP);
1170	else if (RT_SUCCESS(vrc) && RTStrNICmp(pBuf->sz, RT_STR_TUPLE("Windows Server 2003")) == 0)
1171	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win2k3);
1172	else
1173	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Win2k);
1174
1175	if (RT_SUCCESS(vrc) && (strstr(pBuf->sz, "Server") \|\| strstr(pBuf->sz, "server")))
1176	pszProduct = "Server";
1177	}
1178	else if (RTStrVersionCompare(pBuf->sz, "4.0") >= 0) /* NT4 */
1179	mEnmOsType = VBOXOSTYPE_WinNT4;
1180	else
1181	LogRel(("Unattended: PRODSPEC.INI: unknown: DriverVer=%s\n", pBuf->sz));
1182
1183	vrc = RTIniFileQueryValue(hIniFile, "Product Specification", "ProductType", pBuf->sz, sizeof(*pBuf), NULL);
1184	if (RT_SUCCESS(vrc))
1185	pszProduct = strcmp(pBuf->sz, "0") == 0 ? "Workstation" : /* simplification: */ "Server";
1186	}
1187	RTIniFileRelease(hIniFile);
1188	}
1189	}
1190	if (fClarifyProd)
1191	vrc = VINF_SUCCESS;
1192	}
1193	if (RT_FAILURE(vrc))
1194	{
1195	/*
1196	* NT 3.x we look at the LoadIdentifier (boot manager) string in TXTSETUP.SIF/TXT.
1197	*/
1198	vrc = RTVfsFileOpen(hVfsIso, "I386/TXTSETUP.SIF", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1199	if (RT_FAILURE(vrc))
1200	vrc = RTVfsFileOpen(hVfsIso, "I386/TXTSETUP.INF", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1201	if (RT_SUCCESS(vrc))
1202	{
1203	mEnmOsType = VBOXOSTYPE_WinNT;
1204
1205	RTINIFILE hIniFile;
1206	vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
1207	RTVfsFileRelease(hVfsFile);
1208	if (RT_SUCCESS(vrc))
1209	{
1210	vrc = RTIniFileQueryValue(hIniFile, "SetupData", "ProductType", pBuf->sz, sizeof(*pBuf), NULL);
1211	if (RT_SUCCESS(vrc))
1212	pszProduct = strcmp(pBuf->sz, "0") == 0 ? "Workstation" : /* simplification: */ "Server";
1213
1214	vrc = RTIniFileQueryValue(hIniFile, "SetupData", "LoadIdentifier", pBuf->sz, sizeof(*pBuf), NULL);
1215	if (RT_SUCCESS(vrc))
1216	{
1217	LogRelFlow(("Unattended: TXTSETUP.SIF: LoadIdentifier=%s\n", pBuf->sz));
1218	char *psz = pBuf->sz;
1219	while (!RT_C_IS_DIGIT(psz) && psz)
1220	psz++;
1221	char *psz2 = psz;
1222	while (RT_C_IS_DIGIT(psz2) \|\| psz2 == '.')
1223	psz2++;
1224	*psz2 = '\0';
1225	if (RTStrVersionCompare(psz, "6.0") >= 0)
1226	LogRel(("Unattended: TXTSETUP.SIF: unknown: LoadIdentifier=%s\n", pBuf->sz));
1227	else if (RTStrVersionCompare(psz, "4.0") >= 0)
1228	mEnmOsType = VBOXOSTYPE_WinNT4;
1229	else if (RTStrVersionCompare(psz, "3.1") >= 0)
1230	{
1231	mEnmOsType = VBOXOSTYPE_WinNT3x;
1232	pszVersion = psz;
1233	}
1234	else
1235	LogRel(("Unattended: TXTSETUP.SIF: unknown: LoadIdentifier=%s\n", pBuf->sz));
1236	}
1237	RTIniFileRelease(hIniFile);
1238	}
1239	}
1240	}
1241
1242	if (pszVersion)
1243	try { mStrDetectedOSVersion = pszVersion; }
1244	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1245	if (pszProduct)
1246	try { mStrDetectedOSFlavor = pszProduct; }
1247	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1248
1249	/*
1250	* Look for sources/lang.ini and try parse it to get the languages out of it.
1251	*/
1252	/** @todo We could also check sources/??-* and boot/??-* if lang.ini is not
1253	* found or unhelpful. */
1254	vrc = RTVfsFileOpen(hVfsIso, "sources/lang.ini", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1255	if (RT_SUCCESS(vrc))
1256	{
1257	RTINIFILE hIniFile;
1258	vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
1259	RTVfsFileRelease(hVfsFile);
1260	if (RT_SUCCESS(vrc))
1261	{
1262	mDetectedOSLanguages.clear();
1263
1264	uint32_t idxPair;
1265	for (idxPair = 0; idxPair < 256; idxPair++)
1266	{
1267	size_t cbHalf = sizeof(*pBuf) / 2;
1268	char *pszKey = pBuf->sz;
1269	char *pszValue = &pBuf->sz[cbHalf];
1270	vrc = RTIniFileQueryPair(hIniFile, "Available UI Languages", idxPair,
1271	pszKey, cbHalf, NULL, pszValue, cbHalf, NULL);
1272	if (RT_SUCCESS(vrc))
1273	{
1274	try
1275	{
1276	mDetectedOSLanguages.append(pszKey);
1277	}
1278	catch (std::bad_alloc &)
1279	{
1280	RTIniFileRelease(hIniFile);
1281	return E_OUTOFMEMORY;
1282	}
1283	}
1284	else if (vrc == VERR_NOT_FOUND)
1285	break;
1286	else
1287	Assert(vrc == VERR_BUFFER_OVERFLOW);
1288	}
1289	if (idxPair == 0)
1290	LogRel(("Unattended: Warning! Empty 'Available UI Languages' section in sources/lang.ini\n"));
1291	RTIniFileRelease(hIniFile);
1292	}
1293	}
1294
1295	return S_FALSE;
1296	}
1297
1298	/**
1299	* Architecture strings for Linux and the like.
1300	*/
1301	static struct { const char *pszArch; uint32_t cchArch; VBOXOSTYPE fArch; } const g_aLinuxArches[] =
1302	{
1303	{ RT_STR_TUPLE("amd64"), VBOXOSTYPE_x64 },
1304	{ RT_STR_TUPLE("x86_64"), VBOXOSTYPE_x64 },
1305	{ RT_STR_TUPLE("x86-64"), VBOXOSTYPE_x64 }, /* just in case */
1306	{ RT_STR_TUPLE("x64"), VBOXOSTYPE_x64 }, /* ditto */
1307
1308	{ RT_STR_TUPLE("x86"), VBOXOSTYPE_x86 },
1309	{ RT_STR_TUPLE("i386"), VBOXOSTYPE_x86 },
1310	{ RT_STR_TUPLE("i486"), VBOXOSTYPE_x86 },
1311	{ RT_STR_TUPLE("i586"), VBOXOSTYPE_x86 },
1312	{ RT_STR_TUPLE("i686"), VBOXOSTYPE_x86 },
1313	{ RT_STR_TUPLE("i786"), VBOXOSTYPE_x86 },
1314	{ RT_STR_TUPLE("i886"), VBOXOSTYPE_x86 },
1315	{ RT_STR_TUPLE("i986"), VBOXOSTYPE_x86 },
1316	};
1317
1318	/**
1319	* Detects linux architecture.
1320	*
1321	* @returns true if detected, false if not.
1322	* @param pszArch The architecture string.
1323	* @param penmOsType Where to return the arch and type on success.
1324	* @param enmBaseOsType The base (x86) OS type to return.
1325	*/
1326	static bool detectLinuxArch(const char pszArch, VBOXOSTYPE penmOsType, VBOXOSTYPE enmBaseOsType)
1327	{
1328	for (size_t i = 0; i < RT_ELEMENTS(g_aLinuxArches); i++)
1329	if (RTStrNICmp(pszArch, g_aLinuxArches[i].pszArch, g_aLinuxArches[i].cchArch) == 0)
1330	{
1331	*penmOsType = (VBOXOSTYPE)(enmBaseOsType \| g_aLinuxArches[i].fArch);
1332	return true;
1333	}
1334	/** @todo check for 'noarch' since source CDs have been seen to use that. */
1335	return false;
1336	}
1337
1338	/**
1339	* Detects linux architecture by searching for the architecture substring in @p pszArch.
1340	*
1341	* @returns true if detected, false if not.
1342	* @param pszArch The architecture string.
1343	* @param penmOsType Where to return the arch and type on success.
1344	* @param enmBaseOsType The base (x86) OS type to return.
1345	* @param ppszHit Where to return the pointer to the architecture
1346	* specifier. Optional.
1347	* @param ppszNext Where to return the pointer to the char
1348	* following the architecuture specifier. Optional.
1349	*/
1350	static bool detectLinuxArchII(const char pszArch, VBOXOSTYPE penmOsType, VBOXOSTYPE enmBaseOsType,
1351	char ppszHit = NULL, char ppszNext = NULL)
1352	{
1353	for (size_t i = 0; i < RT_ELEMENTS(g_aLinuxArches); i++)
1354	{
1355	const char *pszHit = RTStrIStr(pszArch, g_aLinuxArches[i].pszArch);
1356	if (pszHit != NULL)
1357	{
1358	if (ppszHit)
1359	ppszHit = (char )pszHit;
1360	if (ppszNext)
1361	ppszNext = (char )pszHit + g_aLinuxArches[i].cchArch;
1362	*penmOsType = (VBOXOSTYPE)(enmBaseOsType \| g_aLinuxArches[i].fArch);
1363	return true;
1364	}
1365	}
1366	return false;
1367	}
1368
1369	static bool detectLinuxDistroName(const char pszOsAndVersion, VBOXOSTYPE penmOsType, const char **ppszNext)
1370	{
1371	bool fRet = true;
1372
1373	if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Red")) == 0
1374	&& !RT_C_IS_ALNUM(pszOsAndVersion[3]))
1375
1376	{
1377	pszOsAndVersion = RTStrStripL(pszOsAndVersion + 3);
1378	if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Hat")) == 0
1379	&& !RT_C_IS_ALNUM(pszOsAndVersion[3]))
1380	{
1381	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_RedHat);
1382	pszOsAndVersion = RTStrStripL(pszOsAndVersion + 3);
1383	}
1384	else
1385	fRet = false;
1386	}
1387	else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("OpenSUSE")) == 0
1388	&& !RT_C_IS_ALNUM(pszOsAndVersion[8]))
1389	{
1390	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_OpenSUSE);
1391	pszOsAndVersion = RTStrStripL(pszOsAndVersion + 8);
1392	}
1393	else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Oracle")) == 0
1394	&& !RT_C_IS_ALNUM(pszOsAndVersion[6]))
1395	{
1396	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Oracle);
1397	pszOsAndVersion = RTStrStripL(pszOsAndVersion + 6);
1398	}
1399	else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("CentOS")) == 0
1400	&& !RT_C_IS_ALNUM(pszOsAndVersion[6]))
1401	{
1402	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_RedHat);
1403	pszOsAndVersion = RTStrStripL(pszOsAndVersion + 6);
1404	}
1405	else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Fedora")) == 0
1406	&& !RT_C_IS_ALNUM(pszOsAndVersion[6]))
1407	{
1408	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_FedoraCore);
1409	pszOsAndVersion = RTStrStripL(pszOsAndVersion + 6);
1410	}
1411	else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Ubuntu")) == 0
1412	&& !RT_C_IS_ALNUM(pszOsAndVersion[6]))
1413	{
1414	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Ubuntu);
1415	pszOsAndVersion = RTStrStripL(pszOsAndVersion + 6);
1416	}
1417	else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Linux Mint")) == 0
1418	&& !RT_C_IS_ALNUM(pszOsAndVersion[10]))
1419	{
1420	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Ubuntu);
1421	pszOsAndVersion = RTStrStripL(pszOsAndVersion + 10);
1422	}
1423	else if ( ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Xubuntu")) == 0
1424	\|\| RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Kubuntu")) == 0
1425	\|\| RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Lubuntu")) == 0)
1426	&& !RT_C_IS_ALNUM(pszOsAndVersion[7]))
1427	{
1428	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Ubuntu);
1429	pszOsAndVersion = RTStrStripL(pszOsAndVersion + 7);
1430	}
1431	else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Debian")) == 0
1432	&& !RT_C_IS_ALNUM(pszOsAndVersion[6]))
1433	{
1434	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Debian);
1435	pszOsAndVersion = RTStrStripL(pszOsAndVersion + 6);
1436	}
1437	else
1438	fRet = false;
1439
1440	/*
1441	* Skip forward till we get a number.
1442	*/
1443	if (ppszNext)
1444	{
1445	*ppszNext = pszOsAndVersion;
1446	char ch;
1447	for (const char pszVersion = pszOsAndVersion; (ch = pszVersion) != '\0'; pszVersion++)
1448	if (RT_C_IS_DIGIT(ch))
1449	{
1450	*ppszNext = pszVersion;
1451	break;
1452	}
1453	}
1454	return fRet;
1455	}
1456
1457	static bool detectLinuxDistroNameII(const char pszOsAndVersion, VBOXOSTYPE penmOsType, const char **ppszNext)
1458	{
1459	bool fRet = true;
1460	if ( RTStrIStr(pszOsAndVersion, "RedHat") != NULL
1461	\|\| RTStrIStr(pszOsAndVersion, "Red Hat") != NULL)
1462	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_RedHat);
1463	else if (RTStrIStr(pszOsAndVersion, "Oracle") != NULL)
1464	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Oracle);
1465	else if (RTStrIStr(pszOsAndVersion, "CentOS") != NULL)
1466	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_RedHat);
1467	else if (RTStrIStr(pszOsAndVersion, "Fedora") != NULL)
1468	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_FedoraCore);
1469	else if (RTStrIStr(pszOsAndVersion, "Ubuntu") != NULL)
1470	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Ubuntu);
1471	else if (RTStrIStr(pszOsAndVersion, "Mint") != NULL)
1472	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Ubuntu);
1473	else if (RTStrIStr(pszOsAndVersion, "Debian"))
1474	penmOsType = (VBOXOSTYPE)((penmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_Debian);
1475	else
1476	fRet = false;
1477
1478	/*
1479	* Skip forward till we get a number.
1480	*/
1481	if (ppszNext)
1482	{
1483	*ppszNext = pszOsAndVersion;
1484	char ch;
1485	for (const char pszVersion = pszOsAndVersion; (ch = pszVersion) != '\0'; pszVersion++)
1486	if (RT_C_IS_DIGIT(ch))
1487	{
1488	*ppszNext = pszVersion;
1489	break;
1490	}
1491	}
1492	return fRet;
1493	}
1494
1495
1496	/**
1497	* Helps detecting linux distro flavor by finding substring position of non numerical
1498	* part of the disk name.
1499	*
1500	* @returns true if detected, false if not.
1501	* @param pszDiskName Name of the disk as it is read from .disk/info or
1502	* README.diskdefines file.
1503	* @param poffVersion String position where first numerical character is
1504	* found. We use substring upto this position as OS flavor
1505	*/
1506	static bool detectLinuxDistroFlavor(const char pszDiskName, size_t poffVersion)
1507	{
1508	Assert(poffVersion);
1509	if (!pszDiskName)
1510	return false;
1511	char ch;
1512	while ((ch = *pszDiskName) != '\0' && !RT_C_IS_DIGIT(ch))
1513	{
1514	++pszDiskName;
1515	*poffVersion += 1;
1516	}
1517	return true;
1518	}
1519
1520	/**
1521	* Detect Linux distro ISOs.
1522	*
1523	* @returns COM status code.
1524	* @retval S_OK if detected
1525	* @retval S_FALSE if not fully detected.
1526	*
1527	* @param hVfsIso The ISO file system.
1528	* @param pBuf Read buffer.
1529	*/
1530	HRESULT Unattended::i_innerDetectIsoOSLinux(RTVFS hVfsIso, DETECTBUFFER *pBuf)
1531	{
1532	/*
1533	* Redhat and derivatives may have a .treeinfo (ini-file style) with useful info
1534	* or at least a barebone .discinfo file.
1535	*/
1536
1537	/*
1538	* Start with .treeinfo: https://release-engineering.github.io/productmd/treeinfo-1.0.html
1539	*/
1540	RTVFSFILE hVfsFile;
1541	int vrc = RTVfsFileOpen(hVfsIso, ".treeinfo", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1542	if (RT_SUCCESS(vrc))
1543	{
1544	RTINIFILE hIniFile;
1545	vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
1546	RTVfsFileRelease(hVfsFile);
1547	if (RT_SUCCESS(vrc))
1548	{
1549	/* Try figure the architecture first (like with windows). */
1550	vrc = RTIniFileQueryValue(hIniFile, "tree", "arch", pBuf->sz, sizeof(*pBuf), NULL);
1551	if (RT_FAILURE(vrc) \|\| !pBuf->sz[0])
1552	vrc = RTIniFileQueryValue(hIniFile, "general", "arch", pBuf->sz, sizeof(*pBuf), NULL);
1553	if (RT_FAILURE(vrc))
1554	LogRel(("Unattended: .treeinfo: No 'arch' property.\n"));
1555	else
1556	{
1557	LogRelFlow(("Unattended: .treeinfo: arch=%s\n", pBuf->sz));
1558	if (detectLinuxArch(pBuf->sz, &mEnmOsType, VBOXOSTYPE_RedHat))
1559	{
1560	/* Try figure the release name, it doesn't have to be redhat. */
1561	vrc = RTIniFileQueryValue(hIniFile, "release", "name", pBuf->sz, sizeof(*pBuf), NULL);
1562	if (RT_FAILURE(vrc) \|\| !pBuf->sz[0])
1563	vrc = RTIniFileQueryValue(hIniFile, "product", "name", pBuf->sz, sizeof(*pBuf), NULL);
1564	if (RT_FAILURE(vrc) \|\| !pBuf->sz[0])
1565	vrc = RTIniFileQueryValue(hIniFile, "general", "family", pBuf->sz, sizeof(*pBuf), NULL);
1566	if (RT_SUCCESS(vrc))
1567	{
1568	LogRelFlow(("Unattended: .treeinfo: name/family=%s\n", pBuf->sz));
1569	if (!detectLinuxDistroName(pBuf->sz, &mEnmOsType, NULL))
1570	{
1571	LogRel(("Unattended: .treeinfo: Unknown: name/family='%s', assuming Red Hat\n", pBuf->sz));
1572	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_RedHat);
1573	}
1574	}
1575
1576	/* Try figure the version. */
1577	vrc = RTIniFileQueryValue(hIniFile, "release", "version", pBuf->sz, sizeof(*pBuf), NULL);
1578	if (RT_FAILURE(vrc) \|\| !pBuf->sz[0])
1579	vrc = RTIniFileQueryValue(hIniFile, "product", "version", pBuf->sz, sizeof(*pBuf), NULL);
1580	if (RT_FAILURE(vrc) \|\| !pBuf->sz[0])
1581	vrc = RTIniFileQueryValue(hIniFile, "general", "version", pBuf->sz, sizeof(*pBuf), NULL);
1582	if (RT_SUCCESS(vrc))
1583	{
1584	LogRelFlow(("Unattended: .treeinfo: version=%s\n", pBuf->sz));
1585	try { mStrDetectedOSVersion = RTStrStrip(pBuf->sz); }
1586	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1587
1588	size_t cchVersionPosition = 0;
1589	if (detectLinuxDistroFlavor(pBuf->sz, &cchVersionPosition))
1590	{
1591	try { mStrDetectedOSFlavor = Utf8Str(pBuf->sz, cchVersionPosition); }
1592	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1593	}
1594	}
1595	}
1596	else
1597	LogRel(("Unattended: .treeinfo: Unknown: arch='%s'\n", pBuf->sz));
1598	}
1599
1600	RTIniFileRelease(hIniFile);
1601	}
1602
1603	if (mEnmOsType != VBOXOSTYPE_Unknown)
1604	return S_FALSE;
1605	}
1606
1607	/*
1608	* Try .discinfo next: https://release-engineering.github.io/productmd/discinfo-1.0.html
1609	* We will probably need additional info here...
1610	*/
1611	vrc = RTVfsFileOpen(hVfsIso, ".discinfo", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1612	if (RT_SUCCESS(vrc))
1613	{
1614	size_t cchIgn;
1615	vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(*pBuf) - 1, &cchIgn);
1616	pBuf->sz[RT_SUCCESS(vrc) ? cchIgn : 0] = '\0';
1617	RTVfsFileRelease(hVfsFile);
1618
1619	/* Parse and strip the first 5 lines. */
1620	const char *apszLines[5];
1621	char *psz = pBuf->sz;
1622	for (unsigned i = 0; i < RT_ELEMENTS(apszLines); i++)
1623	{
1624	apszLines[i] = psz;
1625	if (*psz)
1626	{
1627	char pszEol = (char )strchr(psz, '\n');
1628	if (!pszEol)
1629	psz = strchr(psz, '\0');
1630	else
1631	{
1632	*pszEol = '\0';
1633	apszLines[i] = RTStrStrip(psz);
1634	psz = pszEol + 1;
1635	}
1636	}
1637	}
1638
1639	/* Do we recognize the architecture? */
1640	LogRelFlow(("Unattended: .discinfo: arch=%s\n", apszLines[2]));
1641	if (detectLinuxArch(apszLines[2], &mEnmOsType, VBOXOSTYPE_RedHat))
1642	{
1643	/* Do we recognize the release string? */
1644	LogRelFlow(("Unattended: .discinfo: product+version=%s\n", apszLines[1]));
1645	const char *pszVersion = NULL;
1646	if (!detectLinuxDistroName(apszLines[1], &mEnmOsType, &pszVersion))
1647	LogRel(("Unattended: .discinfo: Unknown: release='%s'\n", apszLines[1]));
1648
1649	if (*pszVersion)
1650	{
1651	LogRelFlow(("Unattended: .discinfo: version=%s\n", pszVersion));
1652	try { mStrDetectedOSVersion = RTStrStripL(pszVersion); }
1653	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1654
1655	/* CentOS likes to call their release 'Final' without mentioning the actual version
1656	number (e.g. CentOS-4.7-x86_64-binDVD.iso), so we need to go look elsewhere.
1657	This is only important for centos 4.x and 3.x releases. */
1658	if (RTStrNICmp(pszVersion, RT_STR_TUPLE("Final")) == 0)
1659	{
1660	static const char * const s_apszDirs[] = { "CentOS/RPMS/", "RedHat/RPMS", "Server", "Workstation" };
1661	for (unsigned iDir = 0; iDir < RT_ELEMENTS(s_apszDirs); iDir++)
1662	{
1663	RTVFSDIR hVfsDir;
1664	vrc = RTVfsDirOpen(hVfsIso, s_apszDirs[iDir], 0, &hVfsDir);
1665	if (RT_FAILURE(vrc))
1666	continue;
1667	char szRpmDb[128];
1668	char szReleaseRpm[128];
1669	szRpmDb[0] = '\0';
1670	szReleaseRpm[0] = '\0';
1671	for (;;)
1672	{
1673	RTDIRENTRYEX DirEntry;
1674	size_t cbDirEntry = sizeof(DirEntry);
1675	vrc = RTVfsDirReadEx(hVfsDir, &DirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING);
1676	if (RT_FAILURE(vrc))
1677	break;
1678
1679	/* redhat-release-4WS-2.4.i386.rpm
1680	centos-release-4-7.x86_64.rpm, centos-release-4-4.3.i386.rpm
1681	centos-release-5-3.el5.centos.1.x86_64.rpm */
1682	if ( (psz = strstr(DirEntry.szName, "-release-")) != NULL
1683	\|\| (psz = strstr(DirEntry.szName, "-RELEASE-")) != NULL)
1684	{
1685	psz += 9;
1686	if (RT_C_IS_DIGIT(*psz))
1687	RTStrCopy(szReleaseRpm, sizeof(szReleaseRpm), psz);
1688	}
1689	/* rpmdb-redhat-4WS-2.4.i386.rpm,
1690	rpmdb-CentOS-4.5-0.20070506.i386.rpm,
1691	rpmdb-redhat-3.9-0.20070703.i386.rpm. */
1692	else if ( ( RTStrStartsWith(DirEntry.szName, "rpmdb-")
1693	\|\| RTStrStartsWith(DirEntry.szName, "RPMDB-"))
1694	&& RT_C_IS_DIGIT(DirEntry.szName[6]) )
1695	RTStrCopy(szRpmDb, sizeof(szRpmDb), &DirEntry.szName[6]);
1696	}
1697	RTVfsDirRelease(hVfsDir);
1698
1699	/* Did we find anything relvant? */
1700	psz = szRpmDb;
1701	if (!RT_C_IS_DIGIT(*psz))
1702	psz = szReleaseRpm;
1703	if (RT_C_IS_DIGIT(*psz))
1704	{
1705	/* Convert '-' to '.' and strip stuff which doesn't look like a version string. */
1706	char *pszCur = psz + 1;
1707	for (char ch = pszCur; ch != '\0'; ch = ++pszCur)
1708	if (ch == '-')
1709	*pszCur = '.';
1710	else if (ch != '.' && !RT_C_IS_DIGIT(ch))
1711	{
1712	*pszCur = '\0';
1713	break;
1714	}
1715	while (&pszCur[-1] != psz && pszCur[-1] == '.')
1716	*--pszCur = '\0';
1717
1718	/* Set it and stop looking. */
1719	try { mStrDetectedOSVersion = psz; }
1720	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1721	break;
1722	}
1723	}
1724	}
1725	}
1726	size_t cchVersionPosition = 0;
1727	if (detectLinuxDistroFlavor(apszLines[1], &cchVersionPosition))
1728	{
1729	try { mStrDetectedOSFlavor = Utf8Str(apszLines[1], cchVersionPosition); }
1730	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1731	}
1732	}
1733	else
1734	LogRel(("Unattended: .discinfo: Unknown: arch='%s'\n", apszLines[2]));
1735
1736	if (mEnmOsType != VBOXOSTYPE_Unknown)
1737	return S_FALSE;
1738	}
1739
1740	/*
1741	* Ubuntu has a README.diskdefines file on their ISO (already on 4.10 / warty warthog).
1742	* Example content:
1743	* #define DISKNAME Ubuntu 4.10 "Warty Warthog" - Preview amd64 Binary-1
1744	* #define TYPE binary
1745	* #define TYPEbinary 1
1746	* #define ARCH amd64
1747	* #define ARCHamd64 1
1748	* #define DISKNUM 1
1749	* #define DISKNUM1 1
1750	* #define TOTALNUM 1
1751	* #define TOTALNUM1 1
1752	*/
1753	vrc = RTVfsFileOpen(hVfsIso, "README.diskdefines", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1754	if (RT_SUCCESS(vrc))
1755	{
1756	size_t cchIgn;
1757	vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(*pBuf) - 1, &cchIgn);
1758	pBuf->sz[RT_SUCCESS(vrc) ? cchIgn : 0] = '\0';
1759	RTVfsFileRelease(hVfsFile);
1760
1761	/* Find the DISKNAME and ARCH defines. */
1762	const char *pszDiskName = NULL;
1763	const char *pszArch = NULL;
1764	char *psz = pBuf->sz;
1765	for (unsigned i = 0; *psz != '\0'; i++)
1766	{
1767	while (RT_C_IS_BLANK(*psz))
1768	psz++;
1769
1770	/* Match #define: */
1771	static const char s_szDefine[] = "#define";
1772	if ( strncmp(psz, s_szDefine, sizeof(s_szDefine) - 1) == 0
1773	&& RT_C_IS_BLANK(psz[sizeof(s_szDefine) - 1]))
1774	{
1775	psz = &psz[sizeof(s_szDefine) - 1];
1776	while (RT_C_IS_BLANK(*psz))
1777	psz++;
1778
1779	/* Match the identifier: */
1780	char *pszIdentifier = psz;
1781	if (RT_C_IS_ALPHA(psz) \|\| psz == '_')
1782	{
1783	do
1784	psz++;
1785	while (RT_C_IS_ALNUM(psz) \|\| psz == '_');
1786	size_t cchIdentifier = (size_t)(psz - pszIdentifier);
1787
1788	/* Skip to the value. */
1789	while (RT_C_IS_BLANK(*psz))
1790	psz++;
1791	char *pszValue = psz;
1792
1793	/* Skip to EOL and strip the value. */
1794	char *pszEol = psz = strchr(psz, '\n');
1795	if (psz)
1796	*psz++ = '\0';
1797	else
1798	pszEol = strchr(pszValue, '\0');
1799	while (pszEol > pszValue && RT_C_IS_SPACE(pszEol[-1]))
1800	*--pszEol = '\0';
1801
1802	LogRelFlow(("Unattended: README.diskdefines: %.*s=%s\n", cchIdentifier, pszIdentifier, pszValue));
1803
1804	/* Do identifier matching: */
1805	if (cchIdentifier == sizeof("DISKNAME") - 1 && strncmp(pszIdentifier, RT_STR_TUPLE("DISKNAME")) == 0)
1806	pszDiskName = pszValue;
1807	else if (cchIdentifier == sizeof("ARCH") - 1 && strncmp(pszIdentifier, RT_STR_TUPLE("ARCH")) == 0)
1808	pszArch = pszValue;
1809	else
1810	continue;
1811	if (pszDiskName == NULL \|\| pszArch == NULL)
1812	continue;
1813	break;
1814	}
1815	}
1816
1817	/* Next line: */
1818	psz = strchr(psz, '\n');
1819	if (!psz)
1820	break;
1821	psz++;
1822	}
1823
1824	/* Did we find both of them? */
1825	if (pszDiskName && pszArch)
1826	{
1827	if (detectLinuxArch(pszArch, &mEnmOsType, VBOXOSTYPE_Ubuntu))
1828	{
1829	const char *pszVersion = NULL;
1830	if (detectLinuxDistroName(pszDiskName, &mEnmOsType, &pszVersion))
1831	{
1832	LogRelFlow(("Unattended: README.diskdefines: version=%s\n", pszVersion));
1833	try { mStrDetectedOSVersion = RTStrStripL(pszVersion); }
1834	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1835
1836	size_t cchVersionPosition = 0;
1837	if (detectLinuxDistroFlavor(pszDiskName, &cchVersionPosition))
1838	{
1839	try { mStrDetectedOSFlavor = Utf8Str(pszDiskName, cchVersionPosition); }
1840	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1841	}
1842	}
1843	else
1844	LogRel(("Unattended: README.diskdefines: Unknown: diskname='%s'\n", pszDiskName));
1845	}
1846	else
1847	LogRel(("Unattended: README.diskdefines: Unknown: arch='%s'\n", pszArch));
1848	}
1849	else
1850	LogRel(("Unattended: README.diskdefines: Did not find both DISKNAME and ARCH. :-/\n"));
1851
1852	if (mEnmOsType != VBOXOSTYPE_Unknown)
1853	return S_FALSE;
1854	}
1855
1856	/*
1857	* All of the debian based distro versions I checked have a single line ./disk/info
1858	* file. Only info I could find related to .disk folder is:
1859	* https://lists.debian.org/debian-cd/2004/01/msg00069.html
1860	*
1861	* Some example content from several install ISOs is as follows:
1862	* Ubuntu 4.10 "Warty Warthog" - Preview amd64 Binary-1 (20041020)
1863	* Linux Mint 20.3 "Una" - Release amd64 20220104
1864	* Debian GNU/Linux 11.2.0 "Bullseye" - Official amd64 NETINST 20211218-11:12
1865	* Debian GNU/Linux 9.13.0 "Stretch" - Official amd64 DVD Binary-1 20200718-11:07
1866	* Xubuntu 20.04.2.0 LTS "Focal Fossa" - Release amd64 (20210209.1)
1867	* Ubuntu 17.10 "Artful Aardvark" - Release amd64 (20180105.1)
1868	* Ubuntu 16.04.6 LTS "Xenial Xerus" - Release i386 (20190227.1)
1869	* Debian GNU/Linux 8.11.1 "Jessie" - Official amd64 CD Binary-1 20190211-02:10
1870	* Kali GNU/Linux 2021.3a "Kali-last-snapshot" - Official amd64 BD Binary-1 with firmware 20211015-16:55
1871	* Official Debian GNU/Linux Live 10.10.0 cinnamon 2021-06-19T12:13
1872	*/
1873	vrc = RTVfsFileOpen(hVfsIso, ".disk/info", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
1874	if (RT_SUCCESS(vrc))
1875	{
1876	size_t cchIgn;
1877	vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(*pBuf) - 1, &cchIgn);
1878	pBuf->sz[RT_SUCCESS(vrc) ? cchIgn : 0] = '\0';
1879
1880	pBuf->sz[sizeof(*pBuf) - 1] = '\0';
1881	RTVfsFileRelease(hVfsFile);
1882
1883	char *psz = pBuf->sz;
1884	char *pszDiskName = psz;
1885	char *pszArch = NULL;
1886
1887	/* Only care about the first line of the file even if it is multi line and assume disk name ended with ' - '.*/
1888	psz = RTStrStr(pBuf->sz, " - ");
1889	if (psz && memchr(pBuf->sz, '\n', (size_t)(psz - pBuf->sz)) == NULL)
1890	{
1891	*psz = '\0';
1892	psz += 3;
1893	if (*psz)
1894	pszArch = psz;
1895	}
1896
1897	/* Some Debian Live ISO's have info file content as follows:
1898	* Official Debian GNU/Linux Live 10.10.0 cinnamon 2021-06-19T12:13
1899	* thus pszArch stays empty. Try Volume Id (label) if we get lucky and get architecture from that. */
1900	if (!pszArch)
1901	{
1902	char szVolumeId[128];
1903	vrc = RTVfsQueryLabel(hVfsIso, false /fAlternative/, szVolumeId, sizeof(szVolumeId), NULL);
1904	if (RT_SUCCESS(vrc))
1905	{
1906	if (!detectLinuxArchII(szVolumeId, &mEnmOsType, VBOXOSTYPE_Ubuntu))
1907	LogRel(("Unattended: .disk/info: Unknown: arch='%s'\n", szVolumeId));
1908	}
1909	else
1910	LogRel(("Unattended: .disk/info No Volume Label found\n"));
1911	}
1912	else
1913	{
1914	if (!detectLinuxArchII(pszArch, &mEnmOsType, VBOXOSTYPE_Ubuntu))
1915	LogRel(("Unattended: .disk/info: Unknown: arch='%s'\n", pszArch));
1916	}
1917
1918	if (pszDiskName)
1919	{
1920	const char *pszVersion = NULL;
1921	if (detectLinuxDistroNameII(pszDiskName, &mEnmOsType, &pszVersion))
1922	{
1923	LogRelFlow(("Unattended: .disk/info: version=%s\n", pszVersion));
1924	try { mStrDetectedOSVersion = RTStrStripL(pszVersion); }
1925	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1926
1927	size_t cchVersionPosition = 0;
1928	if (detectLinuxDistroFlavor(pszDiskName, &cchVersionPosition))
1929	{
1930	try { mStrDetectedOSFlavor = Utf8Str(pszDiskName, cchVersionPosition); }
1931	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
1932	}
1933	}
1934	else
1935	LogRel(("Unattended: .disk/info: Unknown: diskname='%s'\n", pszDiskName));
1936	}
1937
1938	if (mEnmOsType == VBOXOSTYPE_Unknown)
1939	LogRel(("Unattended: .disk/info: Did not find DISKNAME or/and ARCH. :-/\n"));
1940	else
1941	return S_FALSE;
1942	}
1943
1944	/*
1945	* Fedora live iso should be recognizable from the primary volume ID (the
1946	* joliet one is usually truncated). We set fAlternative = true here to
1947	* get the primary volume ID.
1948	*/
1949	char szVolumeId[128];
1950	vrc = RTVfsQueryLabel(hVfsIso, true /fAlternative/, szVolumeId, sizeof(szVolumeId), NULL);
1951	if (RT_SUCCESS(vrc) && RTStrStartsWith(szVolumeId, "Fedora-"))
1952	return i_innerDetectIsoOSLinuxFedora(hVfsIso, pBuf, &szVolumeId[sizeof("Fedora-") - 1]);
1953	return S_FALSE;
1954	}
1955
1956
1957	/**
1958	* Continues working a Fedora ISO image after the caller found a "Fedora-*"
1959	* volume ID.
1960	*
1961	* Sample Volume IDs:
1962	* - Fedora-WS-Live-34-1-2 (joliet: Fedora-WS-Live-3)
1963	* - Fedora-S-dvd-x86_64-34 (joliet: Fedora-S-dvd-x86)
1964	* - Fedora-WS-dvd-i386-25 (joliet: Fedora-WS-dvd-i3)
1965	*/
1966	HRESULT Unattended::i_innerDetectIsoOSLinuxFedora(RTVFS hVfsIso, DETECTBUFFER pBuf, char pszVolId)
1967	{
1968	char * const pszFlavor = pszVolId;
1969	char * psz = pszVolId;
1970
1971	/* The volume id may or may not include an arch, component.
1972	We ASSUME that it includes a numeric part with the version, or at least
1973	part of it. */
1974	char *pszVersion = NULL;
1975	char *pszArch = NULL;
1976	if (detectLinuxArchII(psz, &mEnmOsType, VBOXOSTYPE_FedoraCore, &pszArch, &pszVersion))
1977	{
1978	while (*pszVersion == '-')
1979	pszVersion++;
1980	*pszArch = '\0';
1981	}
1982	else
1983	{
1984	mEnmOsType = (VBOXOSTYPE)(VBOXOSTYPE_FedoraCore \| VBOXOSTYPE_UnknownArch);
1985
1986	char ch;
1987	while ((ch = *psz) != '\0' && (!RT_C_IS_DIGIT(ch) \|\| !RT_C_IS_PUNCT(psz[-1])))
1988	psz++;
1989	if (ch != '\0')
1990	pszVersion = psz;
1991	}
1992
1993	/*
1994	* Replace '-' with '.' in the version part and use it as the version.
1995	*/
1996	if (pszVersion)
1997	{
1998	psz = pszVersion;
1999	while ((psz = strchr(psz, '-')) != NULL)
2000	*psz++ = '.';
2001	try { mStrDetectedOSVersion = RTStrStrip(pszVersion); }
2002	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
2003
2004	pszVersion = '\0'; / don't include in flavor */
2005	}
2006
2007	/*
2008	* Split up the pre-arch/version bits into words and use them as the flavor.
2009	*/
2010	psz = pszFlavor;
2011	while ((psz = strchr(psz, '-')) != NULL)
2012	*psz++ = ' ';
2013	try { mStrDetectedOSFlavor = RTStrStrip(pszFlavor); }
2014	catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
2015
2016	/*
2017	* If we don't have an architecture, we look at the vmlinuz file as the x86
2018	* and AMD64 versions starts with a MZ+PE header giving the architecture.
2019	*/
2020	if ((mEnmOsType & VBOXOSTYPE_ArchitectureMask) == VBOXOSTYPE_UnknownArch)
2021	{
2022	static const char * const s_apszVmLinuz[] = { "images/pxeboot/vmlinuz", "isolinux/vmlinuz" };
2023	for (size_t i = 0; i < RT_ELEMENTS(s_apszVmLinuz); i++)
2024	{
2025	RTVFSFILE hVfsFileLinuz = NIL_RTVFSFILE;
2026	int vrc = RTVfsFileOpen(hVfsIso, s_apszVmLinuz[i], RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE,
2027	&hVfsFileLinuz);
2028	if (RT_SUCCESS(vrc))
2029	{
2030	/* DOS signature: */
2031	PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)&pBuf->ab[0];
2032	AssertCompile(sizeof(pBuf) > sizeof(pDosHdr));
2033	vrc = RTVfsFileReadAt(hVfsFileLinuz, 0, pDosHdr, sizeof(*pDosHdr), NULL);
2034	if (RT_SUCCESS(vrc) && pDosHdr->e_magic == IMAGE_DOS_SIGNATURE)
2035	{
2036	/* NT signature - only need magic + file header, so use the 64 version for better debugging: */
2037	PIMAGE_NT_HEADERS64 pNtHdrs = (PIMAGE_NT_HEADERS64)&pBuf->ab[0];
2038	vrc = RTVfsFileReadAt(hVfsFileLinuz, pDosHdr->e_lfanew, pNtHdrs, sizeof(*pNtHdrs), NULL);
2039	AssertCompile(sizeof(pBuf) > sizeof(pNtHdrs));
2040	if (RT_SUCCESS(vrc) && pNtHdrs->Signature == IMAGE_NT_SIGNATURE)
2041	{
2042	if (pNtHdrs->FileHeader.Machine == IMAGE_FILE_MACHINE_I386)
2043	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & ~VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_x86);
2044	else if (pNtHdrs->FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64)
2045	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & ~VBOXOSTYPE_ArchitectureMask) \| VBOXOSTYPE_x64);
2046	else
2047	AssertFailed();
2048	}
2049	}
2050
2051	RTVfsFileRelease(hVfsFileLinuz);
2052	if ((mEnmOsType & VBOXOSTYPE_ArchitectureMask) != VBOXOSTYPE_UnknownArch)
2053	break;
2054	}
2055	}
2056	}
2057
2058	/*
2059	* If that failed, look for other files that gives away the arch.
2060	*/
2061	if ((mEnmOsType & VBOXOSTYPE_ArchitectureMask) == VBOXOSTYPE_UnknownArch)
2062	{
2063	static struct { const char *pszFile; VBOXOSTYPE fArch; } const s_aArchSpecificFiles[] =
2064	{
2065	{ "EFI/BOOT/grubaa64.efi", VBOXOSTYPE_arm64 },
2066	{ "EFI/BOOT/BOOTAA64.EFI", VBOXOSTYPE_arm64 },
2067	};
2068	PRTFSOBJINFO pObjInfo = (PRTFSOBJINFO)&pBuf->ab[0];
2069	AssertCompile(sizeof(pBuf) > sizeof(pObjInfo));
2070	for (size_t i = 0; i < RT_ELEMENTS(s_aArchSpecificFiles); i++)
2071	{
2072	int vrc = RTVfsQueryPathInfo(hVfsIso, s_aArchSpecificFiles[i].pszFile, pObjInfo,
2073	RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
2074	if (RT_SUCCESS(vrc) && RTFS_IS_FILE(pObjInfo->Attr.fMode))
2075	{
2076	mEnmOsType = (VBOXOSTYPE)((mEnmOsType & ~VBOXOSTYPE_ArchitectureMask) \| s_aArchSpecificFiles[i].fArch);
2077	break;
2078	}
2079	}
2080	}
2081
2082	/*
2083	* If we like, we could parse grub.conf to look for fullly spelled out
2084	* flavor, though the menu items typically only contains the major version
2085	* number, so little else to add, really.
2086	*/
2087
2088	return (mEnmOsType & VBOXOSTYPE_ArchitectureMask) != VBOXOSTYPE_UnknownArch ? S_OK : S_FALSE;
2089	}
2090
2091
2092	/**
2093	* Detect OS/2 installation ISOs.
2094	*
2095	* Mainly aiming at ACP2/MCP2 as that's what we currently use in our testing.
2096	*
2097	* @returns COM status code.
2098	* @retval S_OK if detected
2099	* @retval S_FALSE if not fully detected.
2100	*
2101	* @param hVfsIso The ISO file system.
2102	* @param pBuf Read buffer.
2103	*/
2104	HRESULT Unattended::i_innerDetectIsoOSOs2(RTVFS hVfsIso, DETECTBUFFER *pBuf)
2105	{
2106	/*
2107	* The OS2SE20.SRC contains the location of the tree with the diskette
2108	* images, typically "\OS2IMAGE".
2109	*/
2110	RTVFSFILE hVfsFile;
2111	int vrc = RTVfsFileOpen(hVfsIso, "OS2SE20.SRC", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
2112	if (RT_SUCCESS(vrc))
2113	{
2114	size_t cbRead = 0;
2115	vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(pBuf->sz) - 1, &cbRead);
2116	RTVfsFileRelease(hVfsFile);
2117	if (RT_SUCCESS(vrc))
2118	{
2119	pBuf->sz[cbRead] = '\0';
2120	RTStrStrip(pBuf->sz);
2121	vrc = RTStrValidateEncoding(pBuf->sz);
2122	if (RT_SUCCESS(vrc))
2123	LogRelFlow(("Unattended: OS2SE20.SRC=%s\n", pBuf->sz));
2124	else
2125	LogRel(("Unattended: OS2SE20.SRC invalid encoding: %Rrc, %.*Rhxs\n", vrc, cbRead, pBuf->sz));
2126	}
2127	else
2128	LogRel(("Unattended: Error reading OS2SE20.SRC: %\n", vrc));
2129	}
2130	/*
2131	* ArcaOS has dropped the file, assume it's \OS2IMAGE and see if it's there.
2132	*/
2133	else if (vrc == VERR_FILE_NOT_FOUND)
2134	RTStrCopy(pBuf->sz, sizeof(pBuf->sz), "\\OS2IMAGE");
2135	else
2136	return S_FALSE;
2137
2138	/*
2139	* Check that the directory directory exists and has a DISK_0 under it
2140	* with an OS2LDR on it.
2141	*/
2142	size_t const cchOs2Image = strlen(pBuf->sz);
2143	vrc = RTPathAppend(pBuf->sz, sizeof(pBuf->sz), "DISK_0/OS2LDR");
2144	RTFSOBJINFO ObjInfo = {0};
2145	vrc = RTVfsQueryPathInfo(hVfsIso, pBuf->sz, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
2146	if (vrc == VERR_FILE_NOT_FOUND)
2147	{
2148	RTStrCat(pBuf->sz, sizeof(pBuf->sz), "."); /* eCS 2.0 image includes the dot from the 8.3 name. */
2149	vrc = RTVfsQueryPathInfo(hVfsIso, pBuf->sz, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
2150	}
2151	if ( RT_FAILURE(vrc)
2152	\|\| !RTFS_IS_FILE(ObjInfo.Attr.fMode))
2153	{
2154	LogRel(("Unattended: RTVfsQueryPathInfo(, '%s' (from OS2SE20.SRC),) -> %Rrc, fMode=%#x\n",
2155	pBuf->sz, vrc, ObjInfo.Attr.fMode));
2156	return S_FALSE;
2157	}
2158
2159	/*
2160	* So, it's some kind of OS/2 2.x or later ISO alright.
2161	*/
2162	mEnmOsType = VBOXOSTYPE_OS2;
2163	mStrDetectedOSHints.printf("OS2SE20.SRC=%.*s", cchOs2Image, pBuf->sz);
2164
2165	/*
2166	* ArcaOS ISOs seems to have a AOSBOOT dir on them.
2167	* This contains a ARCANOAE.FLG file with content we can use for the version:
2168	* ArcaOS 5.0.7 EN
2169	* Built 2021-12-07 18:34:34
2170	* We drop the "ArcaOS" bit, as it's covered by mEnmOsType. Then we pull up
2171	* the second line.
2172	*
2173	* Note! Yet to find a way to do unattended install of ArcaOS, as it comes
2174	* with no CD-boot floppy images, only simple .PF archive files for
2175	* unpacking onto the ram disk or whatever. Modifying these is
2176	* possible (ibsen's aPLib v0.36 compression with some simple custom
2177	* headers), but it would probably be a royal pain. Could perhaps
2178	* cook something from OS2IMAGE\DISK_0 thru 3...
2179	*/
2180	vrc = RTVfsQueryPathInfo(hVfsIso, "AOSBOOT", &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
2181	if ( RT_SUCCESS(vrc)
2182	&& RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
2183	{
2184	mEnmOsType = VBOXOSTYPE_ArcaOS;
2185
2186	/* Read the version file: */
2187	vrc = RTVfsFileOpen(hVfsIso, "SYS/ARCANOAE.FLG", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
2188	if (RT_SUCCESS(vrc))
2189	{
2190	size_t cbRead = 0;
2191	vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(pBuf->sz) - 1, &cbRead);
2192	RTVfsFileRelease(hVfsFile);
2193	pBuf->sz[cbRead] = '\0';
2194	if (RT_SUCCESS(vrc))
2195	{
2196	/* Strip the OS name: */
2197	char *pszVersion = RTStrStrip(pBuf->sz);
2198	static char s_szArcaOS[] = "ArcaOS";
2199	if (RTStrStartsWith(pszVersion, s_szArcaOS))
2200	pszVersion = RTStrStripL(pszVersion + sizeof(s_szArcaOS) - 1);
2201
2202	/* Pull up the 2nd line if it, condensing the \r\n into a single space. */
2203	char *pszNewLine = strchr(pszVersion, '\n');
2204	if (pszNewLine && RTStrStartsWith(pszNewLine + 1, "Built 20"))
2205	{
2206	size_t offRemove = 0;
2207	while (RT_C_IS_SPACE(pszNewLine[-1 - (ssize_t)offRemove]))
2208	offRemove++;
2209	if (offRemove > 0)
2210	{
2211	pszNewLine -= offRemove;
2212	memmove(pszNewLine, pszNewLine + offRemove, strlen(pszNewLine + offRemove) - 1);
2213	}
2214	*pszNewLine = ' ';
2215	}
2216
2217	/* Drop any additional lines: */
2218	pszNewLine = strchr(pszVersion, '\n');
2219	if (pszNewLine)
2220	*pszNewLine = '\0';
2221	RTStrStripR(pszVersion);
2222
2223	/* Done (hope it makes some sense). */
2224	mStrDetectedOSVersion = pszVersion;
2225	}
2226	else
2227	LogRel(("Unattended: failed to read AOSBOOT/ARCANOAE.FLG: %Rrc\n", vrc));
2228	}
2229	else
2230	LogRel(("Unattended: failed to open AOSBOOT/ARCANOAE.FLG for reading: %Rrc\n", vrc));
2231	}
2232	/*
2233	* Similarly, eCS has an ECS directory and it typically contains a
2234	* ECS_INST.FLG file with the version info. Content differs a little:
2235	* eComStation 2.0 EN_US Thu May 13 10:27:54 pm 2010
2236	* Built on ECS60441318
2237	* Here we drop the "eComStation" bit and leave the 2nd line as it.
2238	*
2239	* Note! At least 2.0 has a DISKIMGS folder with what looks like boot
2240	* disks, so we could probably get something going here without
2241	* needing to write an OS2 boot sector...
2242	*/
2243	else
2244	{
2245	vrc = RTVfsQueryPathInfo(hVfsIso, "ECS", &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
2246	if ( RT_SUCCESS(vrc)
2247	&& RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
2248	{
2249	mEnmOsType = VBOXOSTYPE_ECS;
2250
2251	/* Read the version file: */
2252	vrc = RTVfsFileOpen(hVfsIso, "ECS/ECS_INST.FLG", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
2253	if (RT_SUCCESS(vrc))
2254	{
2255	size_t cbRead = 0;
2256	vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(pBuf->sz) - 1, &cbRead);
2257	RTVfsFileRelease(hVfsFile);
2258	pBuf->sz[cbRead] = '\0';
2259	if (RT_SUCCESS(vrc))
2260	{
2261	/* Strip the OS name: */
2262	char *pszVersion = RTStrStrip(pBuf->sz);
2263	static char s_szECS[] = "eComStation";
2264	if (RTStrStartsWith(pszVersion, s_szECS))
2265	pszVersion = RTStrStripL(pszVersion + sizeof(s_szECS) - 1);
2266
2267	/* Drop any additional lines: */
2268	char *pszNewLine = strchr(pszVersion, '\n');
2269	if (pszNewLine)
2270	*pszNewLine = '\0';
2271	RTStrStripR(pszVersion);
2272
2273	/* Done (hope it makes some sense). */
2274	mStrDetectedOSVersion = pszVersion;
2275	}
2276	else
2277	LogRel(("Unattended: failed to read ECS/ECS_INST.FLG: %Rrc\n", vrc));
2278	}
2279	else
2280	LogRel(("Unattended: failed to open ECS/ECS_INST.FLG for reading: %Rrc\n", vrc));
2281	}
2282	else
2283	{
2284	/*
2285	* Official IBM OS/2 builds doesn't have any .FLG file on them,
2286	* so need to pry the information out in some other way. Best way
2287	* is to read the SYSLEVEL.OS2 file, which is typically on disk #2,
2288	* though on earlier versions (warp3) it was disk #1.
2289	*/
2290	vrc = RTPathJoin(pBuf->sz, sizeof(pBuf->sz), strchr(mStrDetectedOSHints.c_str(), '=') + 1,
2291	"/DISK_2/SYSLEVEL.OS2");
2292	if (RT_SUCCESS(vrc))
2293	{
2294	vrc = RTVfsFileOpen(hVfsIso, pBuf->sz, RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
2295	if (vrc == VERR_FILE_NOT_FOUND)
2296	{
2297	RTPathJoin(pBuf->sz, sizeof(pBuf->sz), strchr(mStrDetectedOSHints.c_str(), '=') + 1, "/DISK_1/SYSLEVEL.OS2");
2298	vrc = RTVfsFileOpen(hVfsIso, pBuf->sz, RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
2299	}
2300	if (RT_SUCCESS(vrc))
2301	{
2302	RT_ZERO(pBuf->ab);
2303	size_t cbRead = 0;
2304	vrc = RTVfsFileRead(hVfsFile, pBuf->ab, sizeof(pBuf->ab), &cbRead);
2305	RTVfsFileRelease(hVfsFile);
2306	if (RT_SUCCESS(vrc))
2307	{
2308	/* Check the header. */
2309	OS2SYSLEVELHDR const pHdr = (OS2SYSLEVELHDR const )&pBuf->ab[0];
2310	if ( pHdr->uMinusOne == UINT16_MAX
2311	&& pHdr->uSyslevelFileVer == 1
2312	&& memcmp(pHdr->achSignature, RT_STR_TUPLE("SYSLEVEL")) == 0
2313	&& pHdr->offTable < cbRead
2314	&& pHdr->offTable + sizeof(OS2SYSLEVELENTRY) <= cbRead)
2315	{
2316	OS2SYSLEVELENTRY pEntry = (OS2SYSLEVELENTRY )&pBuf->ab[pHdr->offTable];
2317	if ( RT_SUCCESS(RTStrValidateEncodingEx(pEntry->szName, sizeof(pEntry->szName),
2318	RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED))
2319	&& RT_SUCCESS(RTStrValidateEncodingEx(pEntry->achCsdLevel, sizeof(pEntry->achCsdLevel), 0))
2320	&& pEntry->bVersion != 0
2321	&& ((pEntry->bVersion >> 4) & 0xf) < 10
2322	&& (pEntry->bVersion & 0xf) < 10
2323	&& pEntry->bModify < 10
2324	&& pEntry->bRefresh < 10)
2325	{
2326	/* Flavor: */
2327	char *pszName = RTStrStrip(pEntry->szName);
2328	if (pszName)
2329	mStrDetectedOSFlavor = pszName;
2330
2331	/* Version: */
2332	if (pEntry->bRefresh != 0)
2333	mStrDetectedOSVersion.printf("%d.%d%d.%d", pEntry->bVersion >> 4, pEntry->bVersion & 0xf,
2334	pEntry->bModify, pEntry->bRefresh);
2335	else
2336	mStrDetectedOSVersion.printf("%d.%d%d", pEntry->bVersion >> 4, pEntry->bVersion & 0xf,
2337	pEntry->bModify);
2338	pEntry->achCsdLevel[sizeof(pEntry->achCsdLevel) - 1] = '\0';
2339	char *pszCsd = RTStrStrip(pEntry->achCsdLevel);
2340	if (*pszCsd != '\0')
2341	{
2342	mStrDetectedOSVersion.append(' ');
2343	mStrDetectedOSVersion.append(pszCsd);
2344	}
2345	if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "4.50") >= 0)
2346	mEnmOsType = VBOXOSTYPE_OS2Warp45;
2347	else if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "4.00") >= 0)
2348	mEnmOsType = VBOXOSTYPE_OS2Warp4;
2349	else if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "3.00") >= 0)
2350	mEnmOsType = VBOXOSTYPE_OS2Warp3;
2351	}
2352	else
2353	LogRel(("Unattended: bogus SYSLEVEL.OS2 file entry: %.128Rhxd\n", pEntry));
2354	}
2355	else
2356	LogRel(("Unattended: bogus SYSLEVEL.OS2 file header: uMinusOne=%#x uSyslevelFileVer=%#x achSignature=%.8Rhxs offTable=%#x vs cbRead=%#zx\n",
2357	pHdr->uMinusOne, pHdr->uSyslevelFileVer, pHdr->achSignature, pHdr->offTable, cbRead));
2358	}
2359	else
2360	LogRel(("Unattended: failed to read SYSLEVEL.OS2: %Rrc\n", vrc));
2361	}
2362	else
2363	LogRel(("Unattended: failed to open '%s' for reading: %Rrc\n", pBuf->sz, vrc));
2364	}
2365	}
2366	}
2367
2368	/** @todo language detection? */
2369
2370	/*
2371	* Only tested ACP2, so only return S_OK for it.
2372	*/
2373	if ( mEnmOsType == VBOXOSTYPE_OS2Warp45
2374	&& RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "4.52") >= 0
2375	&& mStrDetectedOSFlavor.contains("Server", RTCString::CaseInsensitive))
2376	return S_OK;
2377
2378	return S_FALSE;
2379	}
2380
2381
2382	/**
2383	* Detect FreeBSD distro ISOs.
2384	*
2385	* @returns COM status code.
2386	* @retval S_OK if detected
2387	* @retval S_FALSE if not fully detected.
2388	*
2389	* @param hVfsIso The ISO file system.
2390	* @param pBuf Read buffer.
2391	*/
2392	HRESULT Unattended::i_innerDetectIsoOSFreeBsd(RTVFS hVfsIso, DETECTBUFFER *pBuf)
2393	{
2394	RT_NOREF(pBuf);
2395
2396	/*
2397	* FreeBSD since 10.0 has a .profile file in the root which can be used to determine that this is FreeBSD
2398	* along with the version.
2399	*/
2400
2401	RTVFSFILE hVfsFile;
2402	HRESULT hrc = S_FALSE;
2403	int vrc = RTVfsFileOpen(hVfsIso, ".profile", RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN, &hVfsFile);
2404	if (RT_SUCCESS(vrc))
2405	{
2406	static const uint8_t s_abFreeBsdHdr[] = "# $FreeBSD: releng/";
2407	char abRead[32];
2408
2409	vrc = RTVfsFileRead(hVfsFile, &abRead[0], sizeof(abRead), NULL /pcbRead/);
2410	if ( RT_SUCCESS(vrc)
2411	&& !memcmp(&abRead[0], &s_abFreeBsdHdr[0], sizeof(s_abFreeBsdHdr) - 1)) /* Skip terminator */
2412	{
2413	abRead[sizeof(abRead) - 1] = '\0';
2414
2415	/* Detect the architecture using the volume label. */
2416	char szVolumeId[128];
2417	size_t cchVolumeId;
2418	vrc = RTVfsQueryLabel(hVfsIso, false /fAlternative/, szVolumeId, 128, &cchVolumeId);
2419	if (RT_SUCCESS(vrc))
2420	{
2421	/* Can re-use the Linux code here. */
2422	if (!detectLinuxArchII(szVolumeId, &mEnmOsType, VBOXOSTYPE_FreeBSD))
2423	LogRel(("Unattended/FBSD: Unknown: arch='%s'\n", szVolumeId));
2424
2425	/* Detect the version from the string coming after the needle in .profile. */
2426	AssertCompile(sizeof(s_abFreeBsdHdr) - 1 < sizeof(abRead));
2427
2428	char *pszVersionStart = &abRead[sizeof(s_abFreeBsdHdr) - 1];
2429	char *pszVersionEnd = pszVersionStart;
2430
2431	while (RT_C_IS_DIGIT(*pszVersionEnd))
2432	pszVersionEnd++;
2433	if (*pszVersionEnd == '.')
2434	{
2435	pszVersionEnd++; /* Skip the . */
2436
2437	while (RT_C_IS_DIGIT(*pszVersionEnd))
2438	pszVersionEnd++;
2439
2440	/* Terminate the version string. */
2441	*pszVersionEnd = '\0';
2442
2443	try { mStrDetectedOSVersion = pszVersionStart; }
2444	catch (std::bad_alloc &) { hrc = E_OUTOFMEMORY; }
2445	}
2446	else
2447	LogRel(("Unattended/FBSD: Unknown: version='%s'\n", &abRead[0]));
2448	}
2449	else
2450	{
2451	LogRel(("Unattended/FBSD: No Volume Label found\n"));
2452	mEnmOsType = VBOXOSTYPE_FreeBSD;
2453	}
2454
2455	hrc = S_OK;
2456	}
2457
2458	RTVfsFileRelease(hVfsFile);
2459	}
2460
2461	return hrc;
2462	}
2463
2464
2465	HRESULT Unattended::prepare()
2466	{
2467	LogFlow(("Unattended::prepare: enter\n"));
2468
2469	/*
2470	* Must have a machine.
2471	*/
2472	ComPtr<Machine> ptrMachine;
2473	Guid MachineUuid;
2474	{
2475	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2476	ptrMachine = mMachine;
2477	if (ptrMachine.isNull())
2478	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("No machine associated with this IUnatteded instance"));
2479	MachineUuid = mMachineUuid;
2480	}
2481
2482	/*
2483	* Before we write lock ourselves, we must get stuff from Machine and
2484	* VirtualBox because their locks have higher priorities than ours.
2485	*/
2486	Utf8Str strGuestOsTypeId;
2487	Utf8Str strMachineName;
2488	Utf8Str strDefaultAuxBasePath;
2489	HRESULT hrc;
2490	try
2491	{
2492	Bstr bstrTmp;
2493	hrc = ptrMachine->COMGETTER(OSTypeId)(bstrTmp.asOutParam());
2494	if (SUCCEEDED(hrc))
2495	{
2496	strGuestOsTypeId = bstrTmp;
2497	hrc = ptrMachine->COMGETTER(Name)(bstrTmp.asOutParam());
2498	if (SUCCEEDED(hrc))
2499	strMachineName = bstrTmp;
2500	}
2501	int vrc = ptrMachine->i_calculateFullPath(Utf8StrFmt("Unattended-%RTuuid-", MachineUuid.raw()), strDefaultAuxBasePath);
2502	if (RT_FAILURE(vrc))
2503	return setErrorBoth(E_FAIL, vrc);
2504	}
2505	catch (std::bad_alloc &)
2506	{
2507	return E_OUTOFMEMORY;
2508	}
2509	bool const fIs64Bit = i_isGuestOSArchX64(strGuestOsTypeId);
2510
2511	BOOL fRtcUseUtc = FALSE;
2512	hrc = ptrMachine->COMGETTER(RTCUseUTC)(&fRtcUseUtc);
2513	if (FAILED(hrc))
2514	return hrc;
2515
2516	FirmwareType_T enmFirmware = FirmwareType_BIOS;
2517	hrc = ptrMachine->COMGETTER(FirmwareType)(&enmFirmware);
2518	if (FAILED(hrc))
2519	return hrc;
2520
2521	/*
2522	* Write lock this object and set attributes we got from IMachine.
2523	*/
2524	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2525
2526	mStrGuestOsTypeId = strGuestOsTypeId;
2527	mfGuestOs64Bit = fIs64Bit;
2528	mfRtcUseUtc = RT_BOOL(fRtcUseUtc);
2529	menmFirmwareType = enmFirmware;
2530
2531	/*
2532	* Do some state checks.
2533	*/
2534	if (mpInstaller != NULL)
2535	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("The prepare method has been called (must call done to restart)"));
2536	if ((Machine )ptrMachine != (Machine )mMachine)
2537	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("The 'machine' while we were using it - please don't do that"));
2538
2539	/*
2540	* Check if the specified ISOs and files exist.
2541	*/
2542	if (!RTFileExists(mStrIsoPath.c_str()))
2543	return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate the installation ISO file '%s'"),
2544	mStrIsoPath.c_str());
2545	if (mfInstallGuestAdditions && !RTFileExists(mStrAdditionsIsoPath.c_str()))
2546	return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate the Guest Additions ISO file '%s'"),
2547	mStrAdditionsIsoPath.c_str());
2548	if (mfInstallTestExecService && !RTFileExists(mStrValidationKitIsoPath.c_str()))
2549	return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate the validation kit ISO file '%s'"),
2550	mStrValidationKitIsoPath.c_str());
2551	if (mStrScriptTemplatePath.isNotEmpty() && !RTFileExists(mStrScriptTemplatePath.c_str()))
2552	return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate unattended installation script template '%s'"),
2553	mStrScriptTemplatePath.c_str());
2554
2555	/*
2556	* Do media detection if it haven't been done yet.
2557	*/
2558	if (!mfDoneDetectIsoOS)
2559	{
2560	hrc = detectIsoOS();
2561	if (FAILED(hrc) && hrc != E_NOTIMPL)
2562	return hrc;
2563	}
2564
2565	/*
2566	* We can now check midxImage against mDetectedImages, since the latter is
2567	* populated during the detectIsoOS call. We ignore midxImage if no images
2568	* were detected, assuming that it's not relevant or used for different purposes.
2569	*/
2570	if (mDetectedImages.size() > 0)
2571	{
2572	bool fImageFound = false;
2573	for (size_t i = 0; i < mDetectedImages.size(); ++i)
2574	if (midxImage == mDetectedImages[i].mImageIndex)
2575	{
2576	i_updateDetectedAttributeForImage(mDetectedImages[i]);
2577	fImageFound = true;
2578	break;
2579	}
2580	if (!fImageFound)
2581	return setErrorBoth(E_FAIL, VERR_NOT_FOUND, tr("imageIndex value %u not found in detectedImageIndices"), midxImage);
2582	}
2583
2584	/*
2585	* Get the ISO's detect guest OS type info and make it's a known one (just
2586	* in case the above step doesn't work right).
2587	*/
2588	uint32_t const idxIsoOSType = Global::getOSTypeIndexFromId(mStrDetectedOSTypeId.c_str());
2589	VBOXOSTYPE const enmIsoOSType = idxIsoOSType < Global::cOSTypes ? Global::sOSTypes[idxIsoOSType].osType : VBOXOSTYPE_Unknown;
2590	if ((enmIsoOSType & VBOXOSTYPE_OsTypeMask) == VBOXOSTYPE_Unknown)
2591	return setError(E_FAIL, tr("The supplied ISO file does not contain an OS currently supported for unattended installation"));
2592
2593	/*
2594	* Get the VM's configured guest OS type info.
2595	*/
2596	uint32_t const idxMachineOSType = Global::getOSTypeIndexFromId(mStrGuestOsTypeId.c_str());
2597	VBOXOSTYPE const enmMachineOSType = idxMachineOSType < Global::cOSTypes
2598	? Global::sOSTypes[idxMachineOSType].osType : VBOXOSTYPE_Unknown;
2599
2600	/*
2601	* Check that the detected guest OS type for the ISO is compatible with
2602	* that of the VM, boardly speaking.
2603	*/
2604	if (idxMachineOSType != idxIsoOSType)
2605	{
2606	/* Check that the architecture is compatible: */
2607	if ( (enmIsoOSType & VBOXOSTYPE_ArchitectureMask) != (enmMachineOSType & VBOXOSTYPE_ArchitectureMask)
2608	&& ( (enmIsoOSType & VBOXOSTYPE_ArchitectureMask) != VBOXOSTYPE_x86
2609	\|\| (enmMachineOSType & VBOXOSTYPE_ArchitectureMask) != VBOXOSTYPE_x64))
2610	return setError(E_FAIL, tr("The supplied ISO file is incompatible with the guest OS type of the VM: CPU architecture mismatch"));
2611
2612	/** @todo check BIOS/EFI requirement */
2613	}
2614
2615	/*
2616	* Do some default property stuff and check other properties.
2617	*/
2618	try
2619	{
2620	char szTmp[128];
2621
2622	if (mStrLocale.isEmpty())
2623	{
2624	int vrc = RTLocaleQueryNormalizedBaseLocaleName(szTmp, sizeof(szTmp));
2625	if ( RT_SUCCESS(vrc)
2626	&& RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(szTmp))
2627	mStrLocale.assign(szTmp, 5);
2628	else
2629	mStrLocale = "en_US";
2630	Assert(RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(mStrLocale));
2631	}
2632
2633	if (mStrLanguage.isEmpty())
2634	{
2635	if (mDetectedOSLanguages.size() > 0)
2636	mStrLanguage = mDetectedOSLanguages[0];
2637	else
2638	mStrLanguage.assign(mStrLocale).findReplace('_', '-');
2639	}
2640
2641	if (mStrCountry.isEmpty())
2642	{
2643	int vrc = RTLocaleQueryUserCountryCode(szTmp);
2644	if (RT_SUCCESS(vrc))
2645	mStrCountry = szTmp;
2646	else if ( mStrLocale.isNotEmpty()
2647	&& RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(mStrLocale))
2648	mStrCountry.assign(mStrLocale, 3, 2);
2649	else
2650	mStrCountry = "US";
2651	}
2652
2653	if (mStrTimeZone.isEmpty())
2654	{
2655	int vrc = RTTimeZoneGetCurrent(szTmp, sizeof(szTmp));
2656	if ( RT_SUCCESS(vrc)
2657	&& strcmp(szTmp, "localtime") != 0 /* Typcial solaris TZ that isn't very helpful. */)
2658	mStrTimeZone = szTmp;
2659	else
2660	mStrTimeZone = "Etc/UTC";
2661	Assert(mStrTimeZone.isNotEmpty());
2662	}
2663	mpTimeZoneInfo = RTTimeZoneGetInfoByUnixName(mStrTimeZone.c_str());
2664	if (!mpTimeZoneInfo)
2665	mpTimeZoneInfo = RTTimeZoneGetInfoByWindowsName(mStrTimeZone.c_str());
2666	Assert(mpTimeZoneInfo \|\| mStrTimeZone != "Etc/UTC");
2667	if (!mpTimeZoneInfo)
2668	LogRel(("Unattended::prepare: warning: Unknown time zone '%s'\n", mStrTimeZone.c_str()));
2669
2670	if (mStrHostname.isEmpty())
2671	{
2672	/* Mangle the VM name into a valid hostname. */
2673	for (size_t i = 0; i < strMachineName.length(); i++)
2674	{
2675	char ch = strMachineName[i];
2676	if ( (unsigned)ch < 127
2677	&& RT_C_IS_ALNUM(ch))
2678	mStrHostname.append(ch);
2679	else if (mStrHostname.isNotEmpty() && RT_C_IS_PUNCT(ch) && !mStrHostname.endsWith("-"))
2680	mStrHostname.append('-');
2681	}
2682	if (mStrHostname.length() == 0)
2683	mStrHostname.printf("%RTuuid-vm", MachineUuid.raw());
2684	else if (mStrHostname.length() < 3)
2685	mStrHostname.append("-vm");
2686	mStrHostname.append(".myguest.virtualbox.org");
2687	}
2688
2689	if (mStrAuxiliaryBasePath.isEmpty())
2690	{
2691	mStrAuxiliaryBasePath = strDefaultAuxBasePath;
2692	mfIsDefaultAuxiliaryBasePath = true;
2693	}
2694	}
2695	catch (std::bad_alloc &)
2696	{
2697	return E_OUTOFMEMORY;
2698	}
2699
2700	/*
2701	* Instatiate the guest installer matching the ISO.
2702	*/
2703	mpInstaller = UnattendedInstaller::createInstance(enmIsoOSType, mStrDetectedOSTypeId, mStrDetectedOSVersion,
2704	mStrDetectedOSFlavor, mStrDetectedOSHints, this);
2705	if (mpInstaller != NULL)
2706	{
2707	hrc = mpInstaller->initInstaller();
2708	if (SUCCEEDED(hrc))
2709	{
2710	/*
2711	* Do the script preps (just reads them).
2712	*/
2713	hrc = mpInstaller->prepareUnattendedScripts();
2714	if (SUCCEEDED(hrc))
2715	{
2716	LogFlow(("Unattended::prepare: returns S_OK\n"));
2717	return S_OK;
2718	}
2719	}
2720
2721	/* Destroy the installer instance. */
2722	delete mpInstaller;
2723	mpInstaller = NULL;
2724	}
2725	else
2726	hrc = setErrorBoth(E_FAIL, VERR_NOT_FOUND,
2727	tr("Unattended installation is not supported for guest type '%s'"), mStrGuestOsTypeId.c_str());
2728	LogRelFlow(("Unattended::prepare: failed with %Rhrc\n", hrc));
2729	return hrc;
2730	}
2731
2732	HRESULT Unattended::constructMedia()
2733	{
2734	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2735
2736	LogFlow(("===========================================================\n"));
2737	LogFlow(("Call Unattended::constructMedia()\n"));
2738
2739	if (mpInstaller == NULL)
2740	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, "prepare() not yet called");
2741
2742	return mpInstaller->prepareMedia();
2743	}
2744
2745	HRESULT Unattended::reconfigureVM()
2746	{
2747	LogFlow(("===========================================================\n"));
2748	LogFlow(("Call Unattended::reconfigureVM()\n"));
2749
2750	/*
2751	* Interrogate VirtualBox/IGuestOSType before we lock stuff and create ordering issues.
2752	*/
2753	StorageBus_T enmRecommendedStorageBus = StorageBus_IDE;
2754	{
2755	Bstr bstrGuestOsTypeId;
2756	Bstr bstrDetectedOSTypeId;
2757	{
2758	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2759	if (mpInstaller == NULL)
2760	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("prepare() not yet called"));
2761	bstrGuestOsTypeId = mStrGuestOsTypeId;
2762	bstrDetectedOSTypeId = mStrDetectedOSTypeId;
2763	}
2764	ComPtr<IGuestOSType> ptrGuestOSType;
2765	HRESULT hrc = mParent->GetGuestOSType(bstrGuestOsTypeId.raw(), ptrGuestOSType.asOutParam());
2766	if (SUCCEEDED(hrc))
2767	{
2768	if (!ptrGuestOSType.isNull())
2769	hrc = ptrGuestOSType->COMGETTER(RecommendedDVDStorageBus)(&enmRecommendedStorageBus);
2770	}
2771	if (FAILED(hrc))
2772	return hrc;
2773
2774	/* If the detected guest OS type differs, log a warning if their DVD storage
2775	bus recommendations differ. */
2776	if (bstrGuestOsTypeId != bstrDetectedOSTypeId)
2777	{
2778	StorageBus_T enmRecommendedStorageBus2 = StorageBus_IDE;
2779	hrc = mParent->GetGuestOSType(bstrDetectedOSTypeId.raw(), ptrGuestOSType.asOutParam());
2780	if (SUCCEEDED(hrc) && !ptrGuestOSType.isNull())
2781	hrc = ptrGuestOSType->COMGETTER(RecommendedDVDStorageBus)(&enmRecommendedStorageBus2);
2782	if (FAILED(hrc))
2783	return hrc;
2784
2785	if (enmRecommendedStorageBus != enmRecommendedStorageBus2)
2786	LogRel(("Unattended::reconfigureVM: DVD storage bus recommendations differs for the VM and the ISO guest OS types: VM: %s (%ls), ISO: %s (%ls)\n",
2787	::stringifyStorageBus(enmRecommendedStorageBus), bstrGuestOsTypeId.raw(),
2788	::stringifyStorageBus(enmRecommendedStorageBus2), bstrDetectedOSTypeId.raw() ));
2789	}
2790	}
2791
2792	/*
2793	* Take write lock (for lock order reasons, write lock our parent object too)
2794	* then make sure we're the only caller of this method.
2795	*/
2796	AutoMultiWriteLock2 alock(mMachine, this COMMA_LOCKVAL_SRC_POS);
2797	HRESULT hrc;
2798	if (mhThreadReconfigureVM == NIL_RTNATIVETHREAD)
2799	{
2800	RTNATIVETHREAD const hNativeSelf = RTThreadNativeSelf();
2801	mhThreadReconfigureVM = hNativeSelf;
2802
2803	/*
2804	* Create a new session, lock the machine and get the session machine object.
2805	* Do the locking without pinning down the write locks, just to be on the safe side.
2806	*/
2807	ComPtr<ISession> ptrSession;
2808	try
2809	{
2810	hrc = ptrSession.createInprocObject(CLSID_Session);
2811	}
2812	catch (std::bad_alloc &)
2813	{
2814	hrc = E_OUTOFMEMORY;
2815	}
2816	if (SUCCEEDED(hrc))
2817	{
2818	alock.release();
2819	hrc = mMachine->LockMachine(ptrSession, LockType_Shared);
2820	alock.acquire();
2821	if (SUCCEEDED(hrc))
2822	{
2823	ComPtr<IMachine> ptrSessionMachine;
2824	hrc = ptrSession->COMGETTER(Machine)(ptrSessionMachine.asOutParam());
2825	if (SUCCEEDED(hrc))
2826	{
2827	/*
2828	* Hand the session to the inner work and let it do it job.
2829	*/
2830	try
2831	{
2832	hrc = i_innerReconfigureVM(alock, enmRecommendedStorageBus, ptrSessionMachine);
2833	}
2834	catch (...)
2835	{
2836	hrc = E_UNEXPECTED;
2837	}
2838	}
2839
2840	/* Paranoia: release early in case we it a bump below. */
2841	Assert(mhThreadReconfigureVM == hNativeSelf);
2842	mhThreadReconfigureVM = NIL_RTNATIVETHREAD;
2843
2844	/*
2845	* While unlocking the machine we'll have to drop the locks again.
2846	*/
2847	alock.release();
2848
2849	ptrSessionMachine.setNull();
2850	HRESULT hrc2 = ptrSession->UnlockMachine();
2851	AssertLogRelMsg(SUCCEEDED(hrc2), ("UnlockMachine -> %Rhrc\n", hrc2));
2852
2853	ptrSession.setNull();
2854
2855	alock.acquire();
2856	}
2857	else
2858	mhThreadReconfigureVM = NIL_RTNATIVETHREAD;
2859	}
2860	else
2861	mhThreadReconfigureVM = NIL_RTNATIVETHREAD;
2862	}
2863	else
2864	hrc = setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("reconfigureVM running on other thread"));
2865	return hrc;
2866	}
2867
2868
2869	HRESULT Unattended::i_innerReconfigureVM(AutoMultiWriteLock2 &rAutoLock, StorageBus_T enmRecommendedStorageBus,
2870	ComPtr<IMachine> const &rPtrSessionMachine)
2871	{
2872	if (mpInstaller == NULL)
2873	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("prepare() not yet called"));
2874
2875	// Fetch all available storage controllers
2876	com::SafeIfaceArray<IStorageController> arrayOfControllers;
2877	HRESULT hrc = rPtrSessionMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(arrayOfControllers));
2878	AssertComRCReturn(hrc, hrc);
2879
2880	/*
2881	* Figure out where the images are to be mounted, adding controllers/ports as needed.
2882	*/
2883	std::vector<UnattendedInstallationDisk> vecInstallationDisks;
2884	if (mpInstaller->isAuxiliaryFloppyNeeded())
2885	{
2886	hrc = i_reconfigureFloppy(arrayOfControllers, vecInstallationDisks, rPtrSessionMachine, rAutoLock);
2887	if (FAILED(hrc))
2888	return hrc;
2889	}
2890
2891	hrc = i_reconfigureIsos(arrayOfControllers, vecInstallationDisks, rPtrSessionMachine, rAutoLock, enmRecommendedStorageBus);
2892	if (FAILED(hrc))
2893	return hrc;
2894
2895	/*
2896	* Mount the images.
2897	*/
2898	for (size_t idxImage = 0; idxImage < vecInstallationDisks.size(); idxImage++)
2899	{
2900	UnattendedInstallationDisk const *pImage = &vecInstallationDisks.at(idxImage);
2901	Assert(pImage->strImagePath.isNotEmpty());
2902	hrc = i_attachImage(pImage, rPtrSessionMachine, rAutoLock);
2903	if (FAILED(hrc))
2904	return hrc;
2905	}
2906
2907	/*
2908	* Set the boot order.
2909	*
2910	* ASSUME that the HD isn't bootable when we start out, but it will be what
2911	* we boot from after the first stage of the installation is done. Setting
2912	* it first prevents endless reboot cylces.
2913	*/
2914	/** @todo consider making 100% sure the disk isn't bootable (edit partition
2915	* table active bits and EFI stuff). */
2916	Assert( mpInstaller->getBootableDeviceType() == DeviceType_DVD
2917	\|\| mpInstaller->getBootableDeviceType() == DeviceType_Floppy);
2918	hrc = rPtrSessionMachine->SetBootOrder(1, DeviceType_HardDisk);
2919	if (SUCCEEDED(hrc))
2920	hrc = rPtrSessionMachine->SetBootOrder(2, mpInstaller->getBootableDeviceType());
2921	if (SUCCEEDED(hrc))
2922	hrc = rPtrSessionMachine->SetBootOrder(3, mpInstaller->getBootableDeviceType() == DeviceType_DVD
2923	? DeviceType_Floppy : DeviceType_DVD);
2924	if (FAILED(hrc))
2925	return hrc;
2926
2927	/*
2928	* Essential step.
2929	*
2930	* HACK ALERT! We have to release the lock here or we'll get into trouble with
2931	* the VirtualBox lock (via i_saveHardware/NetworkAdaptger::i_hasDefaults/VirtualBox::i_findGuestOSType).
2932	*/
2933	if (SUCCEEDED(hrc))
2934	{
2935	rAutoLock.release();
2936	hrc = rPtrSessionMachine->SaveSettings();
2937	rAutoLock.acquire();
2938	}
2939
2940	return hrc;
2941	}
2942
2943	/**
2944	* Makes sure we've got a floppy drive attached to a floppy controller, adding
2945	* the auxiliary floppy image to the installation disk vector.
2946	*
2947	* @returns COM status code.
2948	* @param rControllers The existing controllers.
2949	* @param rVecInstallatationDisks The list of image to mount.
2950	* @param rPtrSessionMachine The session machine smart pointer.
2951	* @param rAutoLock The lock.
2952	*/
2953	HRESULT Unattended::i_reconfigureFloppy(com::SafeIfaceArray<IStorageController> &rControllers,
2954	std::vector<UnattendedInstallationDisk> &rVecInstallatationDisks,
2955	ComPtr<IMachine> const &rPtrSessionMachine,
2956	AutoMultiWriteLock2 &rAutoLock)
2957	{
2958	Assert(mpInstaller->isAuxiliaryFloppyNeeded());
2959
2960	/*
2961	* Look for a floppy controller with a primary drive (A:) we can "insert"
2962	* the auxiliary floppy image. Add a controller and/or a drive if necessary.
2963	*/
2964	bool fFoundPort0Dev0 = false;
2965	Bstr bstrControllerName;
2966	Utf8Str strControllerName;
2967
2968	for (size_t i = 0; i < rControllers.size(); ++i)
2969	{
2970	StorageBus_T enmStorageBus;
2971	HRESULT hrc = rControllers[i]->COMGETTER(Bus)(&enmStorageBus);
2972	AssertComRCReturn(hrc, hrc);
2973	if (enmStorageBus == StorageBus_Floppy)
2974	{
2975
2976	/*
2977	* Found a floppy controller.
2978	*/
2979	hrc = rControllers[i]->COMGETTER(Name)(bstrControllerName.asOutParam());
2980	AssertComRCReturn(hrc, hrc);
2981
2982	/*
2983	* Check the attchments to see if we've got a device 0 attached on port 0.
2984	*
2985	* While we're at it we eject flppies from all floppy drives we encounter,
2986	* we don't want any confusion at boot or during installation.
2987	*/
2988	com::SafeIfaceArray<IMediumAttachment> arrayOfMediumAttachments;
2989	hrc = rPtrSessionMachine->GetMediumAttachmentsOfController(bstrControllerName.raw(),
2990	ComSafeArrayAsOutParam(arrayOfMediumAttachments));
2991	AssertComRCReturn(hrc, hrc);
2992	strControllerName = bstrControllerName;
2993	AssertLogRelReturn(strControllerName.isNotEmpty(), setErrorBoth(E_UNEXPECTED, VERR_INTERNAL_ERROR_2));
2994
2995	for (size_t j = 0; j < arrayOfMediumAttachments.size(); j++)
2996	{
2997	LONG iPort = -1;
2998	hrc = arrayOfMediumAttachments[j]->COMGETTER(Port)(&iPort);
2999	AssertComRCReturn(hrc, hrc);
3000
3001	LONG iDevice = -1;
3002	hrc = arrayOfMediumAttachments[j]->COMGETTER(Device)(&iDevice);
3003	AssertComRCReturn(hrc, hrc);
3004
3005	DeviceType_T enmType;
3006	hrc = arrayOfMediumAttachments[j]->COMGETTER(Type)(&enmType);
3007	AssertComRCReturn(hrc, hrc);
3008
3009	if (enmType == DeviceType_Floppy)
3010	{
3011	ComPtr<IMedium> ptrMedium;
3012	hrc = arrayOfMediumAttachments[j]->COMGETTER(Medium)(ptrMedium.asOutParam());
3013	AssertComRCReturn(hrc, hrc);
3014
3015	if (ptrMedium.isNotNull())
3016	{
3017	ptrMedium.setNull();
3018	rAutoLock.release();
3019	hrc = rPtrSessionMachine->UnmountMedium(bstrControllerName.raw(), iPort, iDevice, TRUE /fForce/);
3020	rAutoLock.acquire();
3021	}
3022
3023	if (iPort == 0 && iDevice == 0)
3024	fFoundPort0Dev0 = true;
3025	}
3026	else if (iPort == 0 && iDevice == 0)
3027	return setError(E_FAIL,
3028	tr("Found non-floppy device attached to port 0 device 0 on the floppy controller '%ls'"),
3029	bstrControllerName.raw());
3030	}
3031	}
3032	}
3033
3034	/*
3035	* Add a floppy controller if we need to.
3036	*/
3037	if (strControllerName.isEmpty())
3038	{
3039	bstrControllerName = strControllerName = "Floppy";
3040	ComPtr<IStorageController> ptrControllerIgnored;
3041	HRESULT hrc = rPtrSessionMachine->AddStorageController(bstrControllerName.raw(), StorageBus_Floppy,
3042	ptrControllerIgnored.asOutParam());
3043	LogRelFunc(("Machine::addStorageController(Floppy) -> %Rhrc \n", hrc));
3044	if (FAILED(hrc))
3045	return hrc;
3046	}
3047
3048	/*
3049	* Adding a floppy drive (if needed) and mounting the auxiliary image is
3050	* done later together with the ISOs.
3051	*/
3052	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(StorageBus_Floppy, strControllerName,
3053	DeviceType_Floppy, AccessMode_ReadWrite,
3054	0, 0,
3055	fFoundPort0Dev0 /fMountOnly/,
3056	mpInstaller->getAuxiliaryFloppyFilePath(), false));
3057	return S_OK;
3058	}
3059
3060	/**
3061	* Reconfigures DVD drives of the VM to mount all the ISOs we need.
3062	*
3063	* This will umount all DVD media.
3064	*
3065	* @returns COM status code.
3066	* @param rControllers The existing controllers.
3067	* @param rVecInstallatationDisks The list of image to mount.
3068	* @param rPtrSessionMachine The session machine smart pointer.
3069	* @param rAutoLock The lock.
3070	* @param enmRecommendedStorageBus The recommended storage bus type for adding
3071	* DVD drives on.
3072	*/
3073	HRESULT Unattended::i_reconfigureIsos(com::SafeIfaceArray<IStorageController> &rControllers,
3074	std::vector<UnattendedInstallationDisk> &rVecInstallatationDisks,
3075	ComPtr<IMachine> const &rPtrSessionMachine,
3076	AutoMultiWriteLock2 &rAutoLock, StorageBus_T enmRecommendedStorageBus)
3077	{
3078	/*
3079	* Enumerate the attachements of every controller, looking for DVD drives,
3080	* ASSUMEING all drives are bootable.
3081	*
3082	* Eject the medium from all the drives (don't want any confusion) and look
3083	* for the recommended storage bus in case we need to add more drives.
3084	*/
3085	HRESULT hrc;
3086	std::list<ControllerSlot> lstControllerDvdSlots;
3087	Utf8Str strRecommendedControllerName; /* non-empty if recommended bus found. */
3088	Utf8Str strControllerName;
3089	Bstr bstrControllerName;
3090	for (size_t i = 0; i < rControllers.size(); ++i)
3091	{
3092	hrc = rControllers[i]->COMGETTER(Name)(bstrControllerName.asOutParam());
3093	AssertComRCReturn(hrc, hrc);
3094	strControllerName = bstrControllerName;
3095
3096	/* Look for recommended storage bus. */
3097	StorageBus_T enmStorageBus;
3098	hrc = rControllers[i]->COMGETTER(Bus)(&enmStorageBus);
3099	AssertComRCReturn(hrc, hrc);
3100	if (enmStorageBus == enmRecommendedStorageBus)
3101	{
3102	strRecommendedControllerName = bstrControllerName;
3103	AssertLogRelReturn(strControllerName.isNotEmpty(), setErrorBoth(E_UNEXPECTED, VERR_INTERNAL_ERROR_2));
3104	}
3105
3106	/* Scan the controller attachments. */
3107	com::SafeIfaceArray<IMediumAttachment> arrayOfMediumAttachments;
3108	hrc = rPtrSessionMachine->GetMediumAttachmentsOfController(bstrControllerName.raw(),
3109	ComSafeArrayAsOutParam(arrayOfMediumAttachments));
3110	AssertComRCReturn(hrc, hrc);
3111
3112	for (size_t j = 0; j < arrayOfMediumAttachments.size(); j++)
3113	{
3114	DeviceType_T enmType;
3115	hrc = arrayOfMediumAttachments[j]->COMGETTER(Type)(&enmType);
3116	AssertComRCReturn(hrc, hrc);
3117	if (enmType == DeviceType_DVD)
3118	{
3119	LONG iPort = -1;
3120	hrc = arrayOfMediumAttachments[j]->COMGETTER(Port)(&iPort);
3121	AssertComRCReturn(hrc, hrc);
3122
3123	LONG iDevice = -1;
3124	hrc = arrayOfMediumAttachments[j]->COMGETTER(Device)(&iDevice);
3125	AssertComRCReturn(hrc, hrc);
3126
3127	/* Remeber it. */
3128	lstControllerDvdSlots.push_back(ControllerSlot(enmStorageBus, strControllerName, iPort, iDevice, false /fFree/));
3129
3130	/* Eject the medium, if any. */
3131	ComPtr<IMedium> ptrMedium;
3132	hrc = arrayOfMediumAttachments[j]->COMGETTER(Medium)(ptrMedium.asOutParam());
3133	AssertComRCReturn(hrc, hrc);
3134	if (ptrMedium.isNotNull())
3135	{
3136	ptrMedium.setNull();
3137
3138	rAutoLock.release();
3139	hrc = rPtrSessionMachine->UnmountMedium(bstrControllerName.raw(), iPort, iDevice, TRUE /fForce/);
3140	rAutoLock.acquire();
3141	}
3142	}
3143	}
3144	}
3145
3146	/*
3147	* How many drives do we need? Add more if necessary.
3148	*/
3149	ULONG cDvdDrivesNeeded = 0;
3150	if (mpInstaller->isAuxiliaryIsoNeeded())
3151	cDvdDrivesNeeded++;
3152	if (mpInstaller->isOriginalIsoNeeded())
3153	cDvdDrivesNeeded++;
3154	#if 0 /* These are now in the AUX VISO. */
3155	if (mpInstaller->isAdditionsIsoNeeded())
3156	cDvdDrivesNeeded++;
3157	if (mpInstaller->isValidationKitIsoNeeded())
3158	cDvdDrivesNeeded++;
3159	#endif
3160	Assert(cDvdDrivesNeeded > 0);
3161	if (cDvdDrivesNeeded > lstControllerDvdSlots.size())
3162	{
3163	/* Do we need to add the recommended controller? */
3164	if (strRecommendedControllerName.isEmpty())
3165	{
3166	switch (enmRecommendedStorageBus)
3167	{
3168	case StorageBus_IDE: strRecommendedControllerName = "IDE"; break;
3169	case StorageBus_SATA: strRecommendedControllerName = "SATA"; break;
3170	case StorageBus_SCSI: strRecommendedControllerName = "SCSI"; break;
3171	case StorageBus_SAS: strRecommendedControllerName = "SAS"; break;
3172	case StorageBus_USB: strRecommendedControllerName = "USB"; break;
3173	case StorageBus_PCIe: strRecommendedControllerName = "PCIe"; break;
3174	default:
3175	return setError(E_FAIL, tr("Support for recommended storage bus %d not implemented"),
3176	(int)enmRecommendedStorageBus);
3177	}
3178	ComPtr<IStorageController> ptrControllerIgnored;
3179	hrc = rPtrSessionMachine->AddStorageController(Bstr(strRecommendedControllerName).raw(), enmRecommendedStorageBus,
3180	ptrControllerIgnored.asOutParam());
3181	LogRelFunc(("Machine::addStorageController(%s) -> %Rhrc \n", strRecommendedControllerName.c_str(), hrc));
3182	if (FAILED(hrc))
3183	return hrc;
3184	}
3185
3186	/* Add free controller slots, maybe raising the port limit on the controller if we can. */
3187	hrc = i_findOrCreateNeededFreeSlots(strRecommendedControllerName, enmRecommendedStorageBus, rPtrSessionMachine,
3188	cDvdDrivesNeeded, lstControllerDvdSlots);
3189	if (FAILED(hrc))
3190	return hrc;
3191	if (cDvdDrivesNeeded > lstControllerDvdSlots.size())
3192	{
3193	/* We could in many cases create another controller here, but it's not worth the effort. */
3194	return setError(E_FAIL, tr("Not enough free slots on controller '%s' to add %u DVD drive(s)", "",
3195	cDvdDrivesNeeded - lstControllerDvdSlots.size()),
3196	strRecommendedControllerName.c_str(), cDvdDrivesNeeded - lstControllerDvdSlots.size());
3197	}
3198	Assert(cDvdDrivesNeeded == lstControllerDvdSlots.size());
3199	}
3200
3201	/*
3202	* Sort the DVD slots in boot order.
3203	*/
3204	lstControllerDvdSlots.sort();
3205
3206	/*
3207	* Prepare ISO mounts.
3208	*
3209	* Boot order depends on bootFromAuxiliaryIso() and we must grab DVD slots
3210	* according to the boot order.
3211	*/
3212	std::list<ControllerSlot>::const_iterator itDvdSlot = lstControllerDvdSlots.begin();
3213	if (mpInstaller->isAuxiliaryIsoNeeded() && mpInstaller->bootFromAuxiliaryIso())
3214	{
3215	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, mpInstaller->getAuxiliaryIsoFilePath(), true));
3216	++itDvdSlot;
3217	}
3218
3219	if (mpInstaller->isOriginalIsoNeeded())
3220	{
3221	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, i_getIsoPath(), false));
3222	++itDvdSlot;
3223	}
3224
3225	if (mpInstaller->isAuxiliaryIsoNeeded() && !mpInstaller->bootFromAuxiliaryIso())
3226	{
3227	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, mpInstaller->getAuxiliaryIsoFilePath(), true));
3228	++itDvdSlot;
3229	}
3230
3231	#if 0 /* These are now in the AUX VISO. */
3232	if (mpInstaller->isAdditionsIsoNeeded())
3233	{
3234	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, i_getAdditionsIsoPath(), false));
3235	++itDvdSlot;
3236	}
3237
3238	if (mpInstaller->isValidationKitIsoNeeded())
3239	{
3240	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, i_getValidationKitIsoPath(), false));
3241	++itDvdSlot;
3242	}
3243	#endif
3244
3245	return S_OK;
3246	}
3247
3248	/**
3249	* Used to find more free slots for DVD drives during VM reconfiguration.
3250	*
3251	* This may modify the @a portCount property of the given controller.
3252	*
3253	* @returns COM status code.
3254	* @param rStrControllerName The name of the controller to find/create
3255	* free slots on.
3256	* @param enmStorageBus The storage bus type.
3257	* @param rPtrSessionMachine Reference to the session machine.
3258	* @param cSlotsNeeded Total slots needed (including those we've
3259	* already found).
3260	* @param rDvdSlots The slot collection for DVD drives to add
3261	* free slots to as we find/create them.
3262	*/
3263	HRESULT Unattended::i_findOrCreateNeededFreeSlots(const Utf8Str &rStrControllerName, StorageBus_T enmStorageBus,
3264	ComPtr<IMachine> const &rPtrSessionMachine, uint32_t cSlotsNeeded,
3265	std::list<ControllerSlot> &rDvdSlots)
3266	{
3267	Assert(cSlotsNeeded > rDvdSlots.size());
3268
3269	/*
3270	* Get controlleer stats.
3271	*/
3272	ComPtr<IStorageController> pController;
3273	HRESULT hrc = rPtrSessionMachine->GetStorageControllerByName(Bstr(rStrControllerName).raw(), pController.asOutParam());
3274	AssertComRCReturn(hrc, hrc);
3275
3276	ULONG cMaxDevicesPerPort = 1;
3277	hrc = pController->COMGETTER(MaxDevicesPerPortCount)(&cMaxDevicesPerPort);
3278	AssertComRCReturn(hrc, hrc);
3279	AssertLogRelReturn(cMaxDevicesPerPort > 0, E_UNEXPECTED);
3280
3281	ULONG cPorts = 0;
3282	hrc = pController->COMGETTER(PortCount)(&cPorts);
3283	AssertComRCReturn(hrc, hrc);
3284
3285	/*
3286	* Get the attachment list and turn into an internal list for lookup speed.
3287	*/
3288	com::SafeIfaceArray<IMediumAttachment> arrayOfMediumAttachments;
3289	hrc = rPtrSessionMachine->GetMediumAttachmentsOfController(Bstr(rStrControllerName).raw(),
3290	ComSafeArrayAsOutParam(arrayOfMediumAttachments));
3291	AssertComRCReturn(hrc, hrc);
3292
3293	std::vector<ControllerSlot> arrayOfUsedSlots;
3294	for (size_t i = 0; i < arrayOfMediumAttachments.size(); i++)
3295	{
3296	LONG iPort = -1;
3297	hrc = arrayOfMediumAttachments[i]->COMGETTER(Port)(&iPort);
3298	AssertComRCReturn(hrc, hrc);
3299
3300	LONG iDevice = -1;
3301	hrc = arrayOfMediumAttachments[i]->COMGETTER(Device)(&iDevice);
3302	AssertComRCReturn(hrc, hrc);
3303
3304	arrayOfUsedSlots.push_back(ControllerSlot(enmStorageBus, Utf8Str::Empty, iPort, iDevice, false /fFree/));
3305	}
3306
3307	/*
3308	* Iterate thru all possible slots, adding those not found in arrayOfUsedSlots.
3309	*/
3310	for (int32_t iPort = 0; iPort < (int32_t)cPorts; iPort++)
3311	for (int32_t iDevice = 0; iDevice < (int32_t)cMaxDevicesPerPort; iDevice++)
3312	{
3313	bool fFound = false;
3314	for (size_t i = 0; i < arrayOfUsedSlots.size(); i++)
3315	if ( arrayOfUsedSlots[i].iPort == iPort
3316	&& arrayOfUsedSlots[i].iDevice == iDevice)
3317	{
3318	fFound = true;
3319	break;
3320	}
3321	if (!fFound)
3322	{
3323	rDvdSlots.push_back(ControllerSlot(enmStorageBus, rStrControllerName, iPort, iDevice, true /fFree/));
3324	if (rDvdSlots.size() >= cSlotsNeeded)
3325	return S_OK;
3326	}
3327	}
3328
3329	/*
3330	* Okay we still need more ports. See if increasing the number of controller
3331	* ports would solve it.
3332	*/
3333	ULONG cMaxPorts = 1;
3334	hrc = pController->COMGETTER(MaxPortCount)(&cMaxPorts);
3335	AssertComRCReturn(hrc, hrc);
3336	if (cMaxPorts <= cPorts)
3337	return S_OK;
3338	size_t cNewPortsNeeded = (cSlotsNeeded - rDvdSlots.size() + cMaxDevicesPerPort - 1) / cMaxDevicesPerPort;
3339	if (cPorts + cNewPortsNeeded > cMaxPorts)
3340	return S_OK;
3341
3342	/*
3343	* Raise the port count and add the free slots we've just created.
3344	*/
3345	hrc = pController->COMSETTER(PortCount)(cPorts + (ULONG)cNewPortsNeeded);
3346	AssertComRCReturn(hrc, hrc);
3347	int32_t const cPortsNew = (int32_t)(cPorts + cNewPortsNeeded);
3348	for (int32_t iPort = (int32_t)cPorts; iPort < cPortsNew; iPort++)
3349	for (int32_t iDevice = 0; iDevice < (int32_t)cMaxDevicesPerPort; iDevice++)
3350	{
3351	rDvdSlots.push_back(ControllerSlot(enmStorageBus, rStrControllerName, iPort, iDevice, true /fFree/));
3352	if (rDvdSlots.size() >= cSlotsNeeded)
3353	return S_OK;
3354	}
3355
3356	/* We should not get here! */
3357	AssertLogRelFailedReturn(E_UNEXPECTED);
3358	}
3359
3360	HRESULT Unattended::done()
3361	{
3362	LogFlow(("Unattended::done\n"));
3363	if (mpInstaller)
3364	{
3365	LogRelFlow(("Unattended::done: Deleting installer object (%p)\n", mpInstaller));
3366	delete mpInstaller;
3367	mpInstaller = NULL;
3368	}
3369	return S_OK;
3370	}
3371
3372	HRESULT Unattended::getIsoPath(com::Utf8Str &isoPath)
3373	{
3374	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3375	isoPath = mStrIsoPath;
3376	return S_OK;
3377	}
3378
3379	HRESULT Unattended::setIsoPath(const com::Utf8Str &isoPath)
3380	{
3381	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3382	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3383	mStrIsoPath = isoPath;
3384	mfDoneDetectIsoOS = false;
3385	return S_OK;
3386	}
3387
3388	HRESULT Unattended::getUser(com::Utf8Str &user)
3389	{
3390	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3391	user = mStrUser;
3392	return S_OK;
3393	}
3394
3395
3396	HRESULT Unattended::setUser(const com::Utf8Str &user)
3397	{
3398	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3399	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3400	mStrUser = user;
3401	return S_OK;
3402	}
3403
3404	HRESULT Unattended::getPassword(com::Utf8Str &password)
3405	{
3406	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3407	password = mStrPassword;
3408	return S_OK;
3409	}
3410
3411	HRESULT Unattended::setPassword(const com::Utf8Str &password)
3412	{
3413	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3414	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3415	mStrPassword = password;
3416	return S_OK;
3417	}
3418
3419	HRESULT Unattended::getFullUserName(com::Utf8Str &fullUserName)
3420	{
3421	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3422	fullUserName = mStrFullUserName;
3423	return S_OK;
3424	}
3425
3426	HRESULT Unattended::setFullUserName(const com::Utf8Str &fullUserName)
3427	{
3428	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3429	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3430	mStrFullUserName = fullUserName;
3431	return S_OK;
3432	}
3433
3434	HRESULT Unattended::getProductKey(com::Utf8Str &productKey)
3435	{
3436	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3437	productKey = mStrProductKey;
3438	return S_OK;
3439	}
3440
3441	HRESULT Unattended::setProductKey(const com::Utf8Str &productKey)
3442	{
3443	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3444	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3445	mStrProductKey = productKey;
3446	return S_OK;
3447	}
3448
3449	HRESULT Unattended::getAdditionsIsoPath(com::Utf8Str &additionsIsoPath)
3450	{
3451	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3452	additionsIsoPath = mStrAdditionsIsoPath;
3453	return S_OK;
3454	}
3455
3456	HRESULT Unattended::setAdditionsIsoPath(const com::Utf8Str &additionsIsoPath)
3457	{
3458	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3459	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3460	mStrAdditionsIsoPath = additionsIsoPath;
3461	return S_OK;
3462	}
3463
3464	HRESULT Unattended::getInstallGuestAdditions(BOOL *installGuestAdditions)
3465	{
3466	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3467	*installGuestAdditions = mfInstallGuestAdditions;
3468	return S_OK;
3469	}
3470
3471	HRESULT Unattended::setInstallGuestAdditions(BOOL installGuestAdditions)
3472	{
3473	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3474	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3475	mfInstallGuestAdditions = installGuestAdditions != FALSE;
3476	return S_OK;
3477	}
3478
3479	HRESULT Unattended::getValidationKitIsoPath(com::Utf8Str &aValidationKitIsoPath)
3480	{
3481	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3482	aValidationKitIsoPath = mStrValidationKitIsoPath;
3483	return S_OK;
3484	}
3485
3486	HRESULT Unattended::setValidationKitIsoPath(const com::Utf8Str &aValidationKitIsoPath)
3487	{
3488	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3489	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3490	mStrValidationKitIsoPath = aValidationKitIsoPath;
3491	return S_OK;
3492	}
3493
3494	HRESULT Unattended::getInstallTestExecService(BOOL *aInstallTestExecService)
3495	{
3496	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3497	*aInstallTestExecService = mfInstallTestExecService;
3498	return S_OK;
3499	}
3500
3501	HRESULT Unattended::setInstallTestExecService(BOOL aInstallTestExecService)
3502	{
3503	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3504	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3505	mfInstallTestExecService = aInstallTestExecService != FALSE;
3506	return S_OK;
3507	}
3508
3509	HRESULT Unattended::getTimeZone(com::Utf8Str &aTimeZone)
3510	{
3511	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3512	aTimeZone = mStrTimeZone;
3513	return S_OK;
3514	}
3515
3516	HRESULT Unattended::setTimeZone(const com::Utf8Str &aTimezone)
3517	{
3518	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3519	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3520	mStrTimeZone = aTimezone;
3521	return S_OK;
3522	}
3523
3524	HRESULT Unattended::getLocale(com::Utf8Str &aLocale)
3525	{
3526	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3527	aLocale = mStrLocale;
3528	return S_OK;
3529	}
3530
3531	HRESULT Unattended::setLocale(const com::Utf8Str &aLocale)
3532	{
3533	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3534	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3535	if ( aLocale.isEmpty() /* use default */
3536	\|\| ( aLocale.length() == 5
3537	&& RT_C_IS_LOWER(aLocale[0])
3538	&& RT_C_IS_LOWER(aLocale[1])
3539	&& aLocale[2] == '_'
3540	&& RT_C_IS_UPPER(aLocale[3])
3541	&& RT_C_IS_UPPER(aLocale[4])) )
3542	{
3543	mStrLocale = aLocale;
3544	return S_OK;
3545	}
3546	return setError(E_INVALIDARG, tr("Expected two lower cased letters, an underscore, and two upper cased letters"));
3547	}
3548
3549	HRESULT Unattended::getLanguage(com::Utf8Str &aLanguage)
3550	{
3551	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3552	aLanguage = mStrLanguage;
3553	return S_OK;
3554	}
3555
3556	HRESULT Unattended::setLanguage(const com::Utf8Str &aLanguage)
3557	{
3558	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3559	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3560	mStrLanguage = aLanguage;
3561	return S_OK;
3562	}
3563
3564	HRESULT Unattended::getCountry(com::Utf8Str &aCountry)
3565	{
3566	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3567	aCountry = mStrCountry;
3568	return S_OK;
3569	}
3570
3571	HRESULT Unattended::setCountry(const com::Utf8Str &aCountry)
3572	{
3573	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3574	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3575	if ( aCountry.isEmpty()
3576	\|\| ( aCountry.length() == 2
3577	&& RT_C_IS_UPPER(aCountry[0])
3578	&& RT_C_IS_UPPER(aCountry[1])) )
3579	{
3580	mStrCountry = aCountry;
3581	return S_OK;
3582	}
3583	return setError(E_INVALIDARG, tr("Expected two upper cased letters"));
3584	}
3585
3586	HRESULT Unattended::getProxy(com::Utf8Str &aProxy)
3587	{
3588	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3589	aProxy = mStrProxy; /// @todo turn schema map into string or something.
3590	return S_OK;
3591	}
3592
3593	HRESULT Unattended::setProxy(const com::Utf8Str &aProxy)
3594	{
3595	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3596	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3597	if (aProxy.isEmpty())
3598	{
3599	/* set default proxy */
3600	/** @todo BUGBUG! implement this */
3601	}
3602	else if (aProxy.equalsIgnoreCase("none"))
3603	{
3604	/* clear proxy config */
3605	mStrProxy.setNull();
3606	}
3607	else
3608	{
3609	/** @todo Parse and set proxy config into a schema map or something along those lines. */
3610	/** @todo BUGBUG! implement this */
3611	// return E_NOTIMPL;
3612	mStrProxy = aProxy;
3613	}
3614	return S_OK;
3615	}
3616
3617	HRESULT Unattended::getPackageSelectionAdjustments(com::Utf8Str &aPackageSelectionAdjustments)
3618	{
3619	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3620	aPackageSelectionAdjustments = RTCString::join(mPackageSelectionAdjustments, ";");
3621	return S_OK;
3622	}
3623
3624	HRESULT Unattended::setPackageSelectionAdjustments(const com::Utf8Str &aPackageSelectionAdjustments)
3625	{
3626	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3627	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3628	if (aPackageSelectionAdjustments.isEmpty())
3629	mPackageSelectionAdjustments.clear();
3630	else
3631	{
3632	RTCList<RTCString, RTCString *> arrayStrSplit = aPackageSelectionAdjustments.split(";");
3633	for (size_t i = 0; i < arrayStrSplit.size(); i++)
3634	{
3635	if (arrayStrSplit[i].equals("minimal"))
3636	{ /* okay */ }
3637	else
3638	return setError(E_INVALIDARG, tr("Unknown keyword: %s"), arrayStrSplit[i].c_str());
3639	}
3640	mPackageSelectionAdjustments = arrayStrSplit;
3641	}
3642	return S_OK;
3643	}
3644
3645	HRESULT Unattended::getHostname(com::Utf8Str &aHostname)
3646	{
3647	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3648	aHostname = mStrHostname;
3649	return S_OK;
3650	}
3651
3652	HRESULT Unattended::setHostname(const com::Utf8Str &aHostname)
3653	{
3654	/*
3655	* Validate input.
3656	*/
3657	if (aHostname.length() > (aHostname.endsWith(".") ? 254U : 253U))
3658	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3659	tr("Hostname '%s' is %zu bytes long, max is 253 (excluding trailing dot)", "", aHostname.length()),
3660	aHostname.c_str(), aHostname.length());
3661	size_t cLabels = 0;
3662	const char *pszSrc = aHostname.c_str();
3663	for (;;)
3664	{
3665	size_t cchLabel = 1;
3666	char ch = *pszSrc++;
3667	if (RT_C_IS_ALNUM(ch))
3668	{
3669	cLabels++;
3670	while ((ch = *pszSrc++) != '.' && ch != '\0')
3671	{
3672	if (RT_C_IS_ALNUM(ch) \|\| ch == '-')
3673	{
3674	if (cchLabel < 63)
3675	cchLabel++;
3676	else
3677	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3678	tr("Invalid hostname '%s' - label %u is too long, max is 63."),
3679	aHostname.c_str(), cLabels);
3680	}
3681	else
3682	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3683	tr("Invalid hostname '%s' - illegal char '%c' at position %zu"),
3684	aHostname.c_str(), ch, pszSrc - aHostname.c_str() - 1);
3685	}
3686	if (cLabels == 1 && cchLabel < 2)
3687	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3688	tr("Invalid hostname '%s' - the name part must be at least two characters long"),
3689	aHostname.c_str());
3690	if (ch == '\0')
3691	break;
3692	}
3693	else if (ch != '\0')
3694	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3695	tr("Invalid hostname '%s' - illegal lead char '%c' at position %zu"),
3696	aHostname.c_str(), ch, pszSrc - aHostname.c_str() - 1);
3697	else
3698	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3699	tr("Invalid hostname '%s' - trailing dot not permitted"), aHostname.c_str());
3700	}
3701	if (cLabels < 2)
3702	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3703	tr("Incomplete hostname '%s' - must include both a name and a domain"), aHostname.c_str());
3704
3705	/*
3706	* Make the change.
3707	*/
3708	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3709	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3710	mStrHostname = aHostname;
3711	return S_OK;
3712	}
3713
3714	HRESULT Unattended::getAuxiliaryBasePath(com::Utf8Str &aAuxiliaryBasePath)
3715	{
3716	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3717	aAuxiliaryBasePath = mStrAuxiliaryBasePath;
3718	return S_OK;
3719	}
3720
3721	HRESULT Unattended::setAuxiliaryBasePath(const com::Utf8Str &aAuxiliaryBasePath)
3722	{
3723	if (aAuxiliaryBasePath.isEmpty())
3724	return setError(E_INVALIDARG, tr("Empty base path is not allowed"));
3725	if (!RTPathStartsWithRoot(aAuxiliaryBasePath.c_str()))
3726	return setError(E_INVALIDARG, tr("Base path must be absolute"));
3727
3728	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3729	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3730	mStrAuxiliaryBasePath = aAuxiliaryBasePath;
3731	mfIsDefaultAuxiliaryBasePath = mStrAuxiliaryBasePath.isEmpty();
3732	return S_OK;
3733	}
3734
3735	HRESULT Unattended::getImageIndex(ULONG *index)
3736	{
3737	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3738	*index = midxImage;
3739	return S_OK;
3740	}
3741
3742	HRESULT Unattended::setImageIndex(ULONG index)
3743	{
3744	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3745	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3746
3747	/* Validate the selection if detection was done already: */
3748	if (mDetectedImages.size() > 0)
3749	{
3750	for (size_t i = 0; i < mDetectedImages.size(); i++)
3751	if (mDetectedImages[i].mImageIndex == index)
3752	{
3753	midxImage = index;
3754	i_updateDetectedAttributeForImage(mDetectedImages[i]);
3755	return S_OK;
3756	}
3757	LogRel(("Unattended: Setting invalid index=%u\n", index)); /** @todo fail? */
3758	}
3759
3760	midxImage = index;
3761	return S_OK;
3762	}
3763
3764	HRESULT Unattended::getMachine(ComPtr<IMachine> &aMachine)
3765	{
3766	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3767	return mMachine.queryInterfaceTo(aMachine.asOutParam());
3768	}
3769
3770	HRESULT Unattended::setMachine(const ComPtr<IMachine> &aMachine)
3771	{
3772	/*
3773	* Lookup the VM so we can safely get the Machine instance.
3774	* (Don't want to test how reliable XPCOM and COM are with finding
3775	* the local object instance when a client passes a stub back.)
3776	*/
3777	Bstr bstrUuidMachine;
3778	HRESULT hrc = aMachine->COMGETTER(Id)(bstrUuidMachine.asOutParam());
3779	if (SUCCEEDED(hrc))
3780	{
3781	Guid UuidMachine(bstrUuidMachine);
3782	ComObjPtr<Machine> ptrMachine;
3783	hrc = mParent->i_findMachine(UuidMachine, false /fPermitInaccessible/, true /aSetError/, &ptrMachine);
3784	if (SUCCEEDED(hrc))
3785	{
3786	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3787	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER,
3788	tr("Cannot change after prepare() has been called")));
3789	mMachine = ptrMachine;
3790	mMachineUuid = UuidMachine;
3791	if (mfIsDefaultAuxiliaryBasePath)
3792	mStrAuxiliaryBasePath.setNull();
3793	hrc = S_OK;
3794	}
3795	}
3796	return hrc;
3797	}
3798
3799	HRESULT Unattended::getScriptTemplatePath(com::Utf8Str &aScriptTemplatePath)
3800	{
3801	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3802	if ( mStrScriptTemplatePath.isNotEmpty()
3803	\|\| mpInstaller == NULL)
3804	aScriptTemplatePath = mStrScriptTemplatePath;
3805	else
3806	aScriptTemplatePath = mpInstaller->getTemplateFilePath();
3807	return S_OK;
3808	}
3809
3810	HRESULT Unattended::setScriptTemplatePath(const com::Utf8Str &aScriptTemplatePath)
3811	{
3812	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3813	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3814	mStrScriptTemplatePath = aScriptTemplatePath;
3815	return S_OK;
3816	}
3817
3818	HRESULT Unattended::getPostInstallScriptTemplatePath(com::Utf8Str &aPostInstallScriptTemplatePath)
3819	{
3820	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3821	if ( mStrPostInstallScriptTemplatePath.isNotEmpty()
3822	\|\| mpInstaller == NULL)
3823	aPostInstallScriptTemplatePath = mStrPostInstallScriptTemplatePath;
3824	else
3825	aPostInstallScriptTemplatePath = mpInstaller->getPostTemplateFilePath();
3826	return S_OK;
3827	}
3828
3829	HRESULT Unattended::setPostInstallScriptTemplatePath(const com::Utf8Str &aPostInstallScriptTemplatePath)
3830	{
3831	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3832	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3833	mStrPostInstallScriptTemplatePath = aPostInstallScriptTemplatePath;
3834	return S_OK;
3835	}
3836
3837	HRESULT Unattended::getPostInstallCommand(com::Utf8Str &aPostInstallCommand)
3838	{
3839	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3840	aPostInstallCommand = mStrPostInstallCommand;
3841	return S_OK;
3842	}
3843
3844	HRESULT Unattended::setPostInstallCommand(const com::Utf8Str &aPostInstallCommand)
3845	{
3846	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3847	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3848	mStrPostInstallCommand = aPostInstallCommand;
3849	return S_OK;
3850	}
3851
3852	HRESULT Unattended::getExtraInstallKernelParameters(com::Utf8Str &aExtraInstallKernelParameters)
3853	{
3854	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3855	if ( mStrExtraInstallKernelParameters.isNotEmpty()
3856	\|\| mpInstaller == NULL)
3857	aExtraInstallKernelParameters = mStrExtraInstallKernelParameters;
3858	else
3859	aExtraInstallKernelParameters = mpInstaller->getDefaultExtraInstallKernelParameters();
3860	return S_OK;
3861	}
3862
3863	HRESULT Unattended::setExtraInstallKernelParameters(const com::Utf8Str &aExtraInstallKernelParameters)
3864	{
3865	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3866	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3867	mStrExtraInstallKernelParameters = aExtraInstallKernelParameters;
3868	return S_OK;
3869	}
3870
3871	HRESULT Unattended::getDetectedOSTypeId(com::Utf8Str &aDetectedOSTypeId)
3872	{
3873	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3874	aDetectedOSTypeId = mStrDetectedOSTypeId;
3875	return S_OK;
3876	}
3877
3878	HRESULT Unattended::getDetectedOSVersion(com::Utf8Str &aDetectedOSVersion)
3879	{
3880	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3881	aDetectedOSVersion = mStrDetectedOSVersion;
3882	return S_OK;
3883	}
3884
3885	HRESULT Unattended::getDetectedOSFlavor(com::Utf8Str &aDetectedOSFlavor)
3886	{
3887	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3888	aDetectedOSFlavor = mStrDetectedOSFlavor;
3889	return S_OK;
3890	}
3891
3892	HRESULT Unattended::getDetectedOSLanguages(com::Utf8Str &aDetectedOSLanguages)
3893	{
3894	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3895	aDetectedOSLanguages = RTCString::join(mDetectedOSLanguages, " ");
3896	return S_OK;
3897	}
3898
3899	HRESULT Unattended::getDetectedOSHints(com::Utf8Str &aDetectedOSHints)
3900	{
3901	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3902	aDetectedOSHints = mStrDetectedOSHints;
3903	return S_OK;
3904	}
3905
3906	HRESULT Unattended::getDetectedImageNames(std::vector<com::Utf8Str> &aDetectedImageNames)
3907	{
3908	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3909	aDetectedImageNames.clear();
3910	for (size_t i = 0; i < mDetectedImages.size(); ++i)
3911	{
3912	Utf8Str strTmp;
3913	aDetectedImageNames.push_back(mDetectedImages[i].formatName(strTmp));
3914	}
3915	return S_OK;
3916	}
3917
3918	HRESULT Unattended::getDetectedImageIndices(std::vector<ULONG> &aDetectedImageIndices)
3919	{
3920	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3921	aDetectedImageIndices.clear();
3922	for (size_t i = 0; i < mDetectedImages.size(); ++i)
3923	aDetectedImageIndices.push_back(mDetectedImages[i].mImageIndex);
3924	return S_OK;
3925	}
3926
3927	HRESULT Unattended::getIsUnattendedInstallSupported(BOOL *aIsUnattendedInstallSupported)
3928	{
3929	/*
3930	* Take the initial position that it's not supported, so we can return
3931	* right away when we decide it's not possible.
3932	*/
3933	*aIsUnattendedInstallSupported = false;
3934
3935	/* Unattended is disabled by default if we could not detect OS type. */
3936	if (mStrDetectedOSTypeId.isEmpty())
3937	return S_OK;
3938
3939	const VBOXOSTYPE enmOsTypeMasked = (VBOXOSTYPE)(mEnmOsType & VBOXOSTYPE_OsTypeMask);
3940
3941	/* We require a version to have been detected, except for windows where the
3942	field is generally only used for the service pack number at present and
3943	will be empty for RTMs isos. */
3944	if ( ( enmOsTypeMasked <= VBOXOSTYPE_WinNT
3945	\|\| enmOsTypeMasked >= VBOXOSTYPE_OS2)
3946	&& mStrDetectedOSVersion.isEmpty())
3947	return S_OK;
3948
3949	/*
3950	* Sort out things that we know doesn't work. Order by VBOXOSTYPE value.
3951	*/
3952
3953	/* We do not support any of the DOS based windows version, nor DOS, in case
3954	any of that gets detected (it shouldn't): */
3955	if (enmOsTypeMasked >= VBOXOSTYPE_DOS && enmOsTypeMasked < VBOXOSTYPE_WinNT)
3956	return S_OK;
3957
3958	/* Windows NT 3.x doesn't work, also skip unknown windows NT version: */
3959	if (enmOsTypeMasked >= VBOXOSTYPE_WinNT && enmOsTypeMasked < VBOXOSTYPE_WinNT4)
3960	return S_OK;
3961
3962	/* For OS/2 we only support OS2 4.5 (actually only 4.52 server has been
3963	tested, but we'll get to the others eventually): */
3964	if ( enmOsTypeMasked >= VBOXOSTYPE_OS2
3965	&& enmOsTypeMasked < VBOXOSTYPE_Linux
3966	&& enmOsTypeMasked != VBOXOSTYPE_OS2Warp45 /* probably works */ )
3967	return S_OK;
3968
3969	/* Old Debians fail since package repos have been move to some other mirror location. */
3970	if ( enmOsTypeMasked == VBOXOSTYPE_Debian
3971	&& RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "9.0") < 0)
3972	return S_OK;
3973
3974	/* Skip all OpenSUSE variants for now. */
3975	if (enmOsTypeMasked == VBOXOSTYPE_OpenSUSE)
3976	return S_OK;
3977
3978	if (enmOsTypeMasked == VBOXOSTYPE_Ubuntu)
3979	{
3980	/* We cannot install Ubuntus older than 11.04. */
3981	if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "11.04") < 0)
3982	return S_OK;
3983	/* Lubuntu, starting with 20.04, has switched to calamares, which cannot be automated. */
3984	if ( RTStrIStr(mStrDetectedOSFlavor.c_str(), "lubuntu")
3985	&& RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "20.04") > 0)
3986	return S_OK;
3987	}
3988
3989	/* Earlier than OL 6.4 cannot be installed. OL 6.x fails with unsupported hardware error (CPU family). */
3990	if ( enmOsTypeMasked == VBOXOSTYPE_Oracle
3991	&& RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "6.4") < 0)
3992	return S_OK;
3993
3994	/* Fredora ISOs cannot be installed at present. */
3995	if (enmOsTypeMasked == VBOXOSTYPE_FedoraCore)
3996	return S_OK;
3997
3998	/*
3999	* Assume the rest works.
4000	*/
4001	*aIsUnattendedInstallSupported = true;
4002	return S_OK;
4003	}
4004
4005	HRESULT Unattended::getAvoidUpdatesOverNetwork(BOOL *aAvoidUpdatesOverNetwork)
4006	{
4007	*aAvoidUpdatesOverNetwork = mfAvoidUpdatesOverNetwork;
4008	return S_OK;
4009	}
4010
4011	HRESULT Unattended::setAvoidUpdatesOverNetwork(BOOL aAvoidUpdatesOverNetwork)
4012	{
4013	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4014	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
4015	mfAvoidUpdatesOverNetwork = RT_BOOL(aAvoidUpdatesOverNetwork);
4016	return S_OK;
4017	}
4018
4019	/*
4020	* Getters that the installer and script classes can use.
4021	*/
4022	Utf8Str const &Unattended::i_getIsoPath() const
4023	{
4024	Assert(isReadLockedOnCurrentThread());
4025	return mStrIsoPath;
4026	}
4027
4028	Utf8Str const &Unattended::i_getUser() const
4029	{
4030	Assert(isReadLockedOnCurrentThread());
4031	return mStrUser;
4032	}
4033
4034	Utf8Str const &Unattended::i_getPassword() const
4035	{
4036	Assert(isReadLockedOnCurrentThread());
4037	return mStrPassword;
4038	}
4039
4040	Utf8Str const &Unattended::i_getFullUserName() const
4041	{
4042	Assert(isReadLockedOnCurrentThread());
4043	return mStrFullUserName.isNotEmpty() ? mStrFullUserName : mStrUser;
4044	}
4045
4046	Utf8Str const &Unattended::i_getProductKey() const
4047	{
4048	Assert(isReadLockedOnCurrentThread());
4049	return mStrProductKey;
4050	}
4051
4052	Utf8Str const &Unattended::i_getProxy() const
4053	{
4054	Assert(isReadLockedOnCurrentThread());
4055	return mStrProxy;
4056	}
4057
4058	Utf8Str const &Unattended::i_getAdditionsIsoPath() const
4059	{
4060	Assert(isReadLockedOnCurrentThread());
4061	return mStrAdditionsIsoPath;
4062	}
4063
4064	bool Unattended::i_getInstallGuestAdditions() const
4065	{
4066	Assert(isReadLockedOnCurrentThread());
4067	return mfInstallGuestAdditions;
4068	}
4069
4070	Utf8Str const &Unattended::i_getValidationKitIsoPath() const
4071	{
4072	Assert(isReadLockedOnCurrentThread());
4073	return mStrValidationKitIsoPath;
4074	}
4075
4076	bool Unattended::i_getInstallTestExecService() const
4077	{
4078	Assert(isReadLockedOnCurrentThread());
4079	return mfInstallTestExecService;
4080	}
4081
4082	Utf8Str const &Unattended::i_getTimeZone() const
4083	{
4084	Assert(isReadLockedOnCurrentThread());
4085	return mStrTimeZone;
4086	}
4087
4088	PCRTTIMEZONEINFO Unattended::i_getTimeZoneInfo() const
4089	{
4090	Assert(isReadLockedOnCurrentThread());
4091	return mpTimeZoneInfo;
4092	}
4093
4094	Utf8Str const &Unattended::i_getLocale() const
4095	{
4096	Assert(isReadLockedOnCurrentThread());
4097	return mStrLocale;
4098	}
4099
4100	Utf8Str const &Unattended::i_getLanguage() const
4101	{
4102	Assert(isReadLockedOnCurrentThread());
4103	return mStrLanguage;
4104	}
4105
4106	Utf8Str const &Unattended::i_getCountry() const
4107	{
4108	Assert(isReadLockedOnCurrentThread());
4109	return mStrCountry;
4110	}
4111
4112	bool Unattended::i_isMinimalInstallation() const
4113	{
4114	size_t i = mPackageSelectionAdjustments.size();
4115	while (i-- > 0)
4116	if (mPackageSelectionAdjustments[i].equals("minimal"))
4117	return true;
4118	return false;
4119	}
4120
4121	Utf8Str const &Unattended::i_getHostname() const
4122	{
4123	Assert(isReadLockedOnCurrentThread());
4124	return mStrHostname;
4125	}
4126
4127	Utf8Str const &Unattended::i_getAuxiliaryBasePath() const
4128	{
4129	Assert(isReadLockedOnCurrentThread());
4130	return mStrAuxiliaryBasePath;
4131	}
4132
4133	ULONG Unattended::i_getImageIndex() const
4134	{
4135	Assert(isReadLockedOnCurrentThread());
4136	return midxImage;
4137	}
4138
4139	Utf8Str const &Unattended::i_getScriptTemplatePath() const
4140	{
4141	Assert(isReadLockedOnCurrentThread());
4142	return mStrScriptTemplatePath;
4143	}
4144
4145	Utf8Str const &Unattended::i_getPostInstallScriptTemplatePath() const
4146	{
4147	Assert(isReadLockedOnCurrentThread());
4148	return mStrPostInstallScriptTemplatePath;
4149	}
4150
4151	Utf8Str const &Unattended::i_getPostInstallCommand() const
4152	{
4153	Assert(isReadLockedOnCurrentThread());
4154	return mStrPostInstallCommand;
4155	}
4156
4157	Utf8Str const &Unattended::i_getAuxiliaryInstallDir() const
4158	{
4159	Assert(isReadLockedOnCurrentThread());
4160	/* Only the installer knows, forward the call. */
4161	AssertReturn(mpInstaller != NULL, Utf8Str::Empty);
4162	return mpInstaller->getAuxiliaryInstallDir();
4163	}
4164
4165	Utf8Str const &Unattended::i_getExtraInstallKernelParameters() const
4166	{
4167	Assert(isReadLockedOnCurrentThread());
4168	return mStrExtraInstallKernelParameters;
4169	}
4170
4171	bool Unattended::i_isRtcUsingUtc() const
4172	{
4173	Assert(isReadLockedOnCurrentThread());
4174	return mfRtcUseUtc;
4175	}
4176
4177	bool Unattended::i_isGuestOs64Bit() const
4178	{
4179	Assert(isReadLockedOnCurrentThread());
4180	return mfGuestOs64Bit;
4181	}
4182
4183	bool Unattended::i_isFirmwareEFI() const
4184	{
4185	Assert(isReadLockedOnCurrentThread());
4186	return menmFirmwareType != FirmwareType_BIOS;
4187	}
4188
4189	Utf8Str const &Unattended::i_getDetectedOSVersion()
4190	{
4191	Assert(isReadLockedOnCurrentThread());
4192	return mStrDetectedOSVersion;
4193	}
4194
4195	bool Unattended::i_getAvoidUpdatesOverNetwork() const
4196	{
4197	Assert(isReadLockedOnCurrentThread());
4198	return mfAvoidUpdatesOverNetwork;
4199	}
4200
4201	HRESULT Unattended::i_attachImage(UnattendedInstallationDisk const *pImage, ComPtr<IMachine> const &rPtrSessionMachine,
4202	AutoMultiWriteLock2 &rLock)
4203	{
4204	/*
4205	* Attach the disk image
4206	* HACK ALERT! Temporarily release the Unattended lock.
4207	*/
4208	rLock.release();
4209
4210	ComPtr<IMedium> ptrMedium;
4211	HRESULT hrc = mParent->OpenMedium(Bstr(pImage->strImagePath).raw(),
4212	pImage->enmDeviceType,
4213	pImage->enmAccessType,
4214	true,
4215	ptrMedium.asOutParam());
4216	LogRelFlowFunc(("VirtualBox::openMedium -> %Rhrc\n", hrc));
4217	if (SUCCEEDED(hrc))
4218	{
4219	if (pImage->fAuxiliary && pImage->strImagePath.endsWith(".viso"))
4220	{
4221	hrc = ptrMedium->SetProperty(Bstr("UnattendedInstall").raw(), Bstr("1").raw());
4222	LogRelFlowFunc(("Medium::SetProperty -> %Rhrc\n", hrc));
4223	}
4224	if (pImage->fMountOnly)
4225	{
4226	// mount the opened disk image
4227	hrc = rPtrSessionMachine->MountMedium(Bstr(pImage->strControllerName).raw(), pImage->iPort,
4228	pImage->iDevice, ptrMedium, TRUE /fForce/);
4229	LogRelFlowFunc(("Machine::MountMedium -> %Rhrc\n", hrc));
4230	}
4231	else
4232	{
4233	//attach the opened disk image to the controller
4234	hrc = rPtrSessionMachine->AttachDevice(Bstr(pImage->strControllerName).raw(), pImage->iPort,
4235	pImage->iDevice, pImage->enmDeviceType, ptrMedium);
4236	LogRelFlowFunc(("Machine::AttachDevice -> %Rhrc\n", hrc));
4237	}
4238	}
4239
4240	rLock.acquire();
4241	return hrc;
4242	}
4243
4244	bool Unattended::i_isGuestOSArchX64(Utf8Str const &rStrGuestOsTypeId)
4245	{
4246	ComPtr<IGuestOSType> pGuestOSType;
4247	HRESULT hrc = mParent->GetGuestOSType(Bstr(rStrGuestOsTypeId).raw(), pGuestOSType.asOutParam());
4248	if (SUCCEEDED(hrc))
4249	{
4250	BOOL fIs64Bit = FALSE;
4251	if (!pGuestOSType.isNull())
4252	hrc = pGuestOSType->COMGETTER(Is64Bit)(&fIs64Bit);
4253	if (SUCCEEDED(hrc))
4254	return fIs64Bit != FALSE;
4255	}
4256	return false;
4257	}
4258
4259
4260	bool Unattended::i_updateDetectedAttributeForImage(WIMImage const &rImage)
4261	{
4262	bool fRet = true;
4263
4264	/*
4265	* If the image doesn't have a valid value, we don't change it.
4266	* This is obviously a little bit bogus, but what can we do...
4267	*/
4268	const char *pszOSTypeId = Global::OSTypeId(rImage.mOSType);
4269	if (pszOSTypeId && strcmp(pszOSTypeId, "Other") != 0)
4270	mStrDetectedOSTypeId = pszOSTypeId;
4271	else
4272	fRet = false;
4273
4274	if (rImage.mVersion.isNotEmpty())
4275	mStrDetectedOSVersion = rImage.mVersion;
4276	else
4277	fRet = false;
4278
4279	if (rImage.mFlavor.isNotEmpty())
4280	mStrDetectedOSFlavor = rImage.mFlavor;
4281	else
4282	fRet = false;
4283
4284	if (rImage.mLanguages.size() > 0)
4285	mDetectedOSLanguages = rImage.mLanguages;
4286	else
4287	fRet = false;
4288
4289	mEnmOsType = rImage.mEnmOsType;
4290
4291	return fRet;
4292	}

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

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use