UnattendedImpl.cpp@ 101052

最後變更在這個檔案從101052是 101035,由 vboxsync 提交於 19 月前
Initial commit (based draft v2 / on patch v5) for implementing platform architecture support for x86 and ARM. bugref:10384
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 169.6 KB

行
1	/* $Id: UnattendedImpl.cpp 101035 2023-09-07 08:59:15Z 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.alldomusa.eu.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	while (*psz != '\0')
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	ComPtr<IPlatform> pPlatform;
2512	hrc = ptrMachine->COMGETTER(Platform)(pPlatform.asOutParam());
2513	AssertComRCReturn(hrc, hrc);
2514
2515	BOOL fRtcUseUtc = FALSE;
2516	hrc = pPlatform->COMGETTER(RTCUseUTC)(&fRtcUseUtc);
2517	if (FAILED(hrc))
2518	return hrc;
2519
2520	ComPtr<IFirmwareSettings> pFirmwareSettings;
2521	hrc = ptrMachine->COMGETTER(FirmwareSettings)(pFirmwareSettings.asOutParam());
2522	AssertComRCReturn(hrc, hrc);
2523
2524	FirmwareType_T enmFirmware = FirmwareType_BIOS;
2525	hrc = pFirmwareSettings->COMGETTER(FirmwareType)(&enmFirmware);
2526	if (FAILED(hrc))
2527	return hrc;
2528
2529	/*
2530	* Write lock this object and set attributes we got from IMachine.
2531	*/
2532	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2533
2534	mStrGuestOsTypeId = strGuestOsTypeId;
2535	mfGuestOs64Bit = fIs64Bit;
2536	mfRtcUseUtc = RT_BOOL(fRtcUseUtc);
2537	menmFirmwareType = enmFirmware;
2538
2539	/*
2540	* Do some state checks.
2541	*/
2542	if (mpInstaller != NULL)
2543	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("The prepare method has been called (must call done to restart)"));
2544	if ((Machine )ptrMachine != (Machine )mMachine)
2545	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("The 'machine' while we were using it - please don't do that"));
2546
2547	/*
2548	* Check if the specified ISOs and files exist.
2549	*/
2550	if (!RTFileExists(mStrIsoPath.c_str()))
2551	return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate the installation ISO file '%s'"),
2552	mStrIsoPath.c_str());
2553	if (mfInstallGuestAdditions && !RTFileExists(mStrAdditionsIsoPath.c_str()))
2554	return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate the Guest Additions ISO file '%s'"),
2555	mStrAdditionsIsoPath.c_str());
2556	if (mfInstallTestExecService && !RTFileExists(mStrValidationKitIsoPath.c_str()))
2557	return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate the validation kit ISO file '%s'"),
2558	mStrValidationKitIsoPath.c_str());
2559	if (mStrScriptTemplatePath.isNotEmpty() && !RTFileExists(mStrScriptTemplatePath.c_str()))
2560	return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate unattended installation script template '%s'"),
2561	mStrScriptTemplatePath.c_str());
2562
2563	/*
2564	* Do media detection if it haven't been done yet.
2565	*/
2566	if (!mfDoneDetectIsoOS)
2567	{
2568	hrc = detectIsoOS();
2569	if (FAILED(hrc) && hrc != E_NOTIMPL)
2570	return hrc;
2571	}
2572
2573	/*
2574	* We can now check midxImage against mDetectedImages, since the latter is
2575	* populated during the detectIsoOS call. We ignore midxImage if no images
2576	* were detected, assuming that it's not relevant or used for different purposes.
2577	*/
2578	if (mDetectedImages.size() > 0)
2579	{
2580	bool fImageFound = false;
2581	for (size_t i = 0; i < mDetectedImages.size(); ++i)
2582	if (midxImage == mDetectedImages[i].mImageIndex)
2583	{
2584	i_updateDetectedAttributeForImage(mDetectedImages[i]);
2585	fImageFound = true;
2586	break;
2587	}
2588	if (!fImageFound)
2589	return setErrorBoth(E_FAIL, VERR_NOT_FOUND, tr("imageIndex value %u not found in detectedImageIndices"), midxImage);
2590	}
2591
2592	/*
2593	* Get the ISO's detect guest OS type info and make it's a known one (just
2594	* in case the above step doesn't work right).
2595	*/
2596	uint32_t const idxIsoOSType = Global::getOSTypeIndexFromId(mStrDetectedOSTypeId.c_str());
2597	VBOXOSTYPE const enmIsoOSType = idxIsoOSType < Global::cOSTypes ? Global::sOSTypes[idxIsoOSType].osType : VBOXOSTYPE_Unknown;
2598	if ((enmIsoOSType & VBOXOSTYPE_OsTypeMask) == VBOXOSTYPE_Unknown)
2599	return setError(E_FAIL, tr("The supplied ISO file does not contain an OS currently supported for unattended installation"));
2600
2601	/*
2602	* Get the VM's configured guest OS type info.
2603	*/
2604	uint32_t const idxMachineOSType = Global::getOSTypeIndexFromId(mStrGuestOsTypeId.c_str());
2605	VBOXOSTYPE const enmMachineOSType = idxMachineOSType < Global::cOSTypes
2606	? Global::sOSTypes[idxMachineOSType].osType : VBOXOSTYPE_Unknown;
2607
2608	/*
2609	* Check that the detected guest OS type for the ISO is compatible with
2610	* that of the VM, boardly speaking.
2611	*/
2612	if (idxMachineOSType != idxIsoOSType)
2613	{
2614	/* Check that the architecture is compatible: */
2615	if ( (enmIsoOSType & VBOXOSTYPE_ArchitectureMask) != (enmMachineOSType & VBOXOSTYPE_ArchitectureMask)
2616	&& ( (enmIsoOSType & VBOXOSTYPE_ArchitectureMask) != VBOXOSTYPE_x86
2617	\|\| (enmMachineOSType & VBOXOSTYPE_ArchitectureMask) != VBOXOSTYPE_x64))
2618	return setError(E_FAIL, tr("The supplied ISO file is incompatible with the guest OS type of the VM: CPU architecture mismatch"));
2619
2620	/** @todo check BIOS/EFI requirement */
2621	}
2622
2623	/*
2624	* Do some default property stuff and check other properties.
2625	*/
2626	try
2627	{
2628	char szTmp[128];
2629
2630	if (mStrLocale.isEmpty())
2631	{
2632	int vrc = RTLocaleQueryNormalizedBaseLocaleName(szTmp, sizeof(szTmp));
2633	if ( RT_SUCCESS(vrc)
2634	&& RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(szTmp))
2635	mStrLocale.assign(szTmp, 5);
2636	else
2637	mStrLocale = "en_US";
2638	Assert(RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(mStrLocale));
2639	}
2640
2641	if (mStrLanguage.isEmpty())
2642	{
2643	if (mDetectedOSLanguages.size() > 0)
2644	mStrLanguage = mDetectedOSLanguages[0];
2645	else
2646	mStrLanguage.assign(mStrLocale).findReplace('_', '-');
2647	}
2648
2649	if (mStrCountry.isEmpty())
2650	{
2651	int vrc = RTLocaleQueryUserCountryCode(szTmp);
2652	if (RT_SUCCESS(vrc))
2653	mStrCountry = szTmp;
2654	else if ( mStrLocale.isNotEmpty()
2655	&& RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(mStrLocale))
2656	mStrCountry.assign(mStrLocale, 3, 2);
2657	else
2658	mStrCountry = "US";
2659	}
2660
2661	if (mStrTimeZone.isEmpty())
2662	{
2663	int vrc = RTTimeZoneGetCurrent(szTmp, sizeof(szTmp));
2664	if ( RT_SUCCESS(vrc)
2665	&& strcmp(szTmp, "localtime") != 0 /* Typcial solaris TZ that isn't very helpful. */)
2666	mStrTimeZone = szTmp;
2667	else
2668	mStrTimeZone = "Etc/UTC";
2669	Assert(mStrTimeZone.isNotEmpty());
2670	}
2671	mpTimeZoneInfo = RTTimeZoneGetInfoByUnixName(mStrTimeZone.c_str());
2672	if (!mpTimeZoneInfo)
2673	mpTimeZoneInfo = RTTimeZoneGetInfoByWindowsName(mStrTimeZone.c_str());
2674	Assert(mpTimeZoneInfo \|\| mStrTimeZone != "Etc/UTC");
2675	if (!mpTimeZoneInfo)
2676	LogRel(("Unattended::prepare: warning: Unknown time zone '%s'\n", mStrTimeZone.c_str()));
2677
2678	if (mStrHostname.isEmpty())
2679	{
2680	/* Mangle the VM name into a valid hostname. */
2681	for (size_t i = 0; i < strMachineName.length(); i++)
2682	{
2683	char ch = strMachineName[i];
2684	if ( (unsigned)ch < 127
2685	&& RT_C_IS_ALNUM(ch))
2686	mStrHostname.append(ch);
2687	else if (mStrHostname.isNotEmpty() && RT_C_IS_PUNCT(ch) && !mStrHostname.endsWith("-"))
2688	mStrHostname.append('-');
2689	}
2690	if (mStrHostname.length() == 0)
2691	mStrHostname.printf("%RTuuid-vm", MachineUuid.raw());
2692	else if (mStrHostname.length() < 3)
2693	mStrHostname.append("-vm");
2694	mStrHostname.append(".myguest.virtualbox.org");
2695	}
2696
2697	if (mStrAuxiliaryBasePath.isEmpty())
2698	{
2699	mStrAuxiliaryBasePath = strDefaultAuxBasePath;
2700	mfIsDefaultAuxiliaryBasePath = true;
2701	}
2702	}
2703	catch (std::bad_alloc &)
2704	{
2705	return E_OUTOFMEMORY;
2706	}
2707
2708	/*
2709	* Instatiate the guest installer matching the ISO.
2710	*/
2711	mpInstaller = UnattendedInstaller::createInstance(enmIsoOSType, mStrDetectedOSTypeId, mStrDetectedOSVersion,
2712	mStrDetectedOSFlavor, mStrDetectedOSHints, this);
2713	if (mpInstaller != NULL)
2714	{
2715	hrc = mpInstaller->initInstaller();
2716	if (SUCCEEDED(hrc))
2717	{
2718	/*
2719	* Do the script preps (just reads them).
2720	*/
2721	hrc = mpInstaller->prepareUnattendedScripts();
2722	if (SUCCEEDED(hrc))
2723	{
2724	LogFlow(("Unattended::prepare: returns S_OK\n"));
2725	return S_OK;
2726	}
2727	}
2728
2729	/* Destroy the installer instance. */
2730	delete mpInstaller;
2731	mpInstaller = NULL;
2732	}
2733	else
2734	hrc = setErrorBoth(E_FAIL, VERR_NOT_FOUND,
2735	tr("Unattended installation is not supported for guest type '%s'"), mStrGuestOsTypeId.c_str());
2736	LogRelFlow(("Unattended::prepare: failed with %Rhrc\n", hrc));
2737	return hrc;
2738	}
2739
2740	HRESULT Unattended::constructMedia()
2741	{
2742	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2743
2744	LogFlow(("===========================================================\n"));
2745	LogFlow(("Call Unattended::constructMedia()\n"));
2746
2747	if (mpInstaller == NULL)
2748	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, "prepare() not yet called");
2749
2750	return mpInstaller->prepareMedia();
2751	}
2752
2753	HRESULT Unattended::reconfigureVM()
2754	{
2755	LogFlow(("===========================================================\n"));
2756	LogFlow(("Call Unattended::reconfigureVM()\n"));
2757
2758	/*
2759	* Interrogate VirtualBox/IGuestOSType before we lock stuff and create ordering issues.
2760	*/
2761	StorageBus_T enmRecommendedStorageBus = StorageBus_IDE;
2762	{
2763	Bstr bstrGuestOsTypeId;
2764	Bstr bstrDetectedOSTypeId;
2765	{
2766	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2767	if (mpInstaller == NULL)
2768	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("prepare() not yet called"));
2769	bstrGuestOsTypeId = mStrGuestOsTypeId;
2770	bstrDetectedOSTypeId = mStrDetectedOSTypeId;
2771	}
2772	ComPtr<IGuestOSType> ptrGuestOSType;
2773	HRESULT hrc = mParent->GetGuestOSType(bstrGuestOsTypeId.raw(), ptrGuestOSType.asOutParam());
2774	if (SUCCEEDED(hrc))
2775	{
2776	if (!ptrGuestOSType.isNull())
2777	hrc = ptrGuestOSType->COMGETTER(RecommendedDVDStorageBus)(&enmRecommendedStorageBus);
2778	}
2779	if (FAILED(hrc))
2780	return hrc;
2781
2782	/* If the detected guest OS type differs, log a warning if their DVD storage
2783	bus recommendations differ. */
2784	if (bstrGuestOsTypeId != bstrDetectedOSTypeId)
2785	{
2786	StorageBus_T enmRecommendedStorageBus2 = StorageBus_IDE;
2787	hrc = mParent->GetGuestOSType(bstrDetectedOSTypeId.raw(), ptrGuestOSType.asOutParam());
2788	if (SUCCEEDED(hrc) && !ptrGuestOSType.isNull())
2789	hrc = ptrGuestOSType->COMGETTER(RecommendedDVDStorageBus)(&enmRecommendedStorageBus2);
2790	if (FAILED(hrc))
2791	return hrc;
2792
2793	if (enmRecommendedStorageBus != enmRecommendedStorageBus2)
2794	LogRel(("Unattended::reconfigureVM: DVD storage bus recommendations differs for the VM and the ISO guest OS types: VM: %s (%ls), ISO: %s (%ls)\n",
2795	::stringifyStorageBus(enmRecommendedStorageBus), bstrGuestOsTypeId.raw(),
2796	::stringifyStorageBus(enmRecommendedStorageBus2), bstrDetectedOSTypeId.raw() ));
2797	}
2798	}
2799
2800	/*
2801	* Take write lock (for lock order reasons, write lock our parent object too)
2802	* then make sure we're the only caller of this method.
2803	*/
2804	AutoMultiWriteLock2 alock(mMachine, this COMMA_LOCKVAL_SRC_POS);
2805	HRESULT hrc;
2806	if (mhThreadReconfigureVM == NIL_RTNATIVETHREAD)
2807	{
2808	RTNATIVETHREAD const hNativeSelf = RTThreadNativeSelf();
2809	mhThreadReconfigureVM = hNativeSelf;
2810
2811	/*
2812	* Create a new session, lock the machine and get the session machine object.
2813	* Do the locking without pinning down the write locks, just to be on the safe side.
2814	*/
2815	ComPtr<ISession> ptrSession;
2816	try
2817	{
2818	hrc = ptrSession.createInprocObject(CLSID_Session);
2819	}
2820	catch (std::bad_alloc &)
2821	{
2822	hrc = E_OUTOFMEMORY;
2823	}
2824	if (SUCCEEDED(hrc))
2825	{
2826	alock.release();
2827	hrc = mMachine->LockMachine(ptrSession, LockType_Shared);
2828	alock.acquire();
2829	if (SUCCEEDED(hrc))
2830	{
2831	ComPtr<IMachine> ptrSessionMachine;
2832	hrc = ptrSession->COMGETTER(Machine)(ptrSessionMachine.asOutParam());
2833	if (SUCCEEDED(hrc))
2834	{
2835	/*
2836	* Hand the session to the inner work and let it do it job.
2837	*/
2838	try
2839	{
2840	hrc = i_innerReconfigureVM(alock, enmRecommendedStorageBus, ptrSessionMachine);
2841	}
2842	catch (...)
2843	{
2844	hrc = E_UNEXPECTED;
2845	}
2846	}
2847
2848	/* Paranoia: release early in case we it a bump below. */
2849	Assert(mhThreadReconfigureVM == hNativeSelf);
2850	mhThreadReconfigureVM = NIL_RTNATIVETHREAD;
2851
2852	/*
2853	* While unlocking the machine we'll have to drop the locks again.
2854	*/
2855	alock.release();
2856
2857	ptrSessionMachine.setNull();
2858	HRESULT hrc2 = ptrSession->UnlockMachine();
2859	AssertLogRelMsg(SUCCEEDED(hrc2), ("UnlockMachine -> %Rhrc\n", hrc2));
2860
2861	ptrSession.setNull();
2862
2863	alock.acquire();
2864	}
2865	else
2866	mhThreadReconfigureVM = NIL_RTNATIVETHREAD;
2867	}
2868	else
2869	mhThreadReconfigureVM = NIL_RTNATIVETHREAD;
2870	}
2871	else
2872	hrc = setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("reconfigureVM running on other thread"));
2873	return hrc;
2874	}
2875
2876
2877	HRESULT Unattended::i_innerReconfigureVM(AutoMultiWriteLock2 &rAutoLock, StorageBus_T enmRecommendedStorageBus,
2878	ComPtr<IMachine> const &rPtrSessionMachine)
2879	{
2880	if (mpInstaller == NULL)
2881	return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("prepare() not yet called"));
2882
2883	// Fetch all available storage controllers
2884	com::SafeIfaceArray<IStorageController> arrayOfControllers;
2885	HRESULT hrc = rPtrSessionMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(arrayOfControllers));
2886	AssertComRCReturn(hrc, hrc);
2887
2888	/*
2889	* Figure out where the images are to be mounted, adding controllers/ports as needed.
2890	*/
2891	std::vector<UnattendedInstallationDisk> vecInstallationDisks;
2892	if (mpInstaller->isAuxiliaryFloppyNeeded())
2893	{
2894	hrc = i_reconfigureFloppy(arrayOfControllers, vecInstallationDisks, rPtrSessionMachine, rAutoLock);
2895	if (FAILED(hrc))
2896	return hrc;
2897	}
2898
2899	hrc = i_reconfigureIsos(arrayOfControllers, vecInstallationDisks, rPtrSessionMachine, rAutoLock, enmRecommendedStorageBus);
2900	if (FAILED(hrc))
2901	return hrc;
2902
2903	/*
2904	* Mount the images.
2905	*/
2906	for (size_t idxImage = 0; idxImage < vecInstallationDisks.size(); idxImage++)
2907	{
2908	UnattendedInstallationDisk const *pImage = &vecInstallationDisks.at(idxImage);
2909	Assert(pImage->strImagePath.isNotEmpty());
2910	hrc = i_attachImage(pImage, rPtrSessionMachine, rAutoLock);
2911	if (FAILED(hrc))
2912	return hrc;
2913	}
2914
2915	/*
2916	* Set the boot order.
2917	*
2918	* ASSUME that the HD isn't bootable when we start out, but it will be what
2919	* we boot from after the first stage of the installation is done. Setting
2920	* it first prevents endless reboot cylces.
2921	*/
2922	/** @todo consider making 100% sure the disk isn't bootable (edit partition
2923	* table active bits and EFI stuff). */
2924	Assert( mpInstaller->getBootableDeviceType() == DeviceType_DVD
2925	\|\| mpInstaller->getBootableDeviceType() == DeviceType_Floppy);
2926	hrc = rPtrSessionMachine->SetBootOrder(1, DeviceType_HardDisk);
2927	if (SUCCEEDED(hrc))
2928	hrc = rPtrSessionMachine->SetBootOrder(2, mpInstaller->getBootableDeviceType());
2929	if (SUCCEEDED(hrc))
2930	hrc = rPtrSessionMachine->SetBootOrder(3, mpInstaller->getBootableDeviceType() == DeviceType_DVD
2931	? DeviceType_Floppy : DeviceType_DVD);
2932	if (FAILED(hrc))
2933	return hrc;
2934
2935	/*
2936	* Essential step.
2937	*
2938	* HACK ALERT! We have to release the lock here or we'll get into trouble with
2939	* the VirtualBox lock (via i_saveHardware/NetworkAdaptger::i_hasDefaults/VirtualBox::i_findGuestOSType).
2940	*/
2941	if (SUCCEEDED(hrc))
2942	{
2943	rAutoLock.release();
2944	hrc = rPtrSessionMachine->SaveSettings();
2945	rAutoLock.acquire();
2946	}
2947
2948	return hrc;
2949	}
2950
2951	/**
2952	* Makes sure we've got a floppy drive attached to a floppy controller, adding
2953	* the auxiliary floppy image to the installation disk vector.
2954	*
2955	* @returns COM status code.
2956	* @param rControllers The existing controllers.
2957	* @param rVecInstallatationDisks The list of image to mount.
2958	* @param rPtrSessionMachine The session machine smart pointer.
2959	* @param rAutoLock The lock.
2960	*/
2961	HRESULT Unattended::i_reconfigureFloppy(com::SafeIfaceArray<IStorageController> &rControllers,
2962	std::vector<UnattendedInstallationDisk> &rVecInstallatationDisks,
2963	ComPtr<IMachine> const &rPtrSessionMachine,
2964	AutoMultiWriteLock2 &rAutoLock)
2965	{
2966	Assert(mpInstaller->isAuxiliaryFloppyNeeded());
2967
2968	/*
2969	* Look for a floppy controller with a primary drive (A:) we can "insert"
2970	* the auxiliary floppy image. Add a controller and/or a drive if necessary.
2971	*/
2972	bool fFoundPort0Dev0 = false;
2973	Bstr bstrControllerName;
2974	Utf8Str strControllerName;
2975
2976	for (size_t i = 0; i < rControllers.size(); ++i)
2977	{
2978	StorageBus_T enmStorageBus;
2979	HRESULT hrc = rControllers[i]->COMGETTER(Bus)(&enmStorageBus);
2980	AssertComRCReturn(hrc, hrc);
2981	if (enmStorageBus == StorageBus_Floppy)
2982	{
2983
2984	/*
2985	* Found a floppy controller.
2986	*/
2987	hrc = rControllers[i]->COMGETTER(Name)(bstrControllerName.asOutParam());
2988	AssertComRCReturn(hrc, hrc);
2989
2990	/*
2991	* Check the attchments to see if we've got a device 0 attached on port 0.
2992	*
2993	* While we're at it we eject flppies from all floppy drives we encounter,
2994	* we don't want any confusion at boot or during installation.
2995	*/
2996	com::SafeIfaceArray<IMediumAttachment> arrayOfMediumAttachments;
2997	hrc = rPtrSessionMachine->GetMediumAttachmentsOfController(bstrControllerName.raw(),
2998	ComSafeArrayAsOutParam(arrayOfMediumAttachments));
2999	AssertComRCReturn(hrc, hrc);
3000	strControllerName = bstrControllerName;
3001	AssertLogRelReturn(strControllerName.isNotEmpty(), setErrorBoth(E_UNEXPECTED, VERR_INTERNAL_ERROR_2));
3002
3003	for (size_t j = 0; j < arrayOfMediumAttachments.size(); j++)
3004	{
3005	LONG iPort = -1;
3006	hrc = arrayOfMediumAttachments[j]->COMGETTER(Port)(&iPort);
3007	AssertComRCReturn(hrc, hrc);
3008
3009	LONG iDevice = -1;
3010	hrc = arrayOfMediumAttachments[j]->COMGETTER(Device)(&iDevice);
3011	AssertComRCReturn(hrc, hrc);
3012
3013	DeviceType_T enmType;
3014	hrc = arrayOfMediumAttachments[j]->COMGETTER(Type)(&enmType);
3015	AssertComRCReturn(hrc, hrc);
3016
3017	if (enmType == DeviceType_Floppy)
3018	{
3019	ComPtr<IMedium> ptrMedium;
3020	hrc = arrayOfMediumAttachments[j]->COMGETTER(Medium)(ptrMedium.asOutParam());
3021	AssertComRCReturn(hrc, hrc);
3022
3023	if (ptrMedium.isNotNull())
3024	{
3025	ptrMedium.setNull();
3026	rAutoLock.release();
3027	hrc = rPtrSessionMachine->UnmountMedium(bstrControllerName.raw(), iPort, iDevice, TRUE /fForce/);
3028	rAutoLock.acquire();
3029	}
3030
3031	if (iPort == 0 && iDevice == 0)
3032	fFoundPort0Dev0 = true;
3033	}
3034	else if (iPort == 0 && iDevice == 0)
3035	return setError(E_FAIL,
3036	tr("Found non-floppy device attached to port 0 device 0 on the floppy controller '%ls'"),
3037	bstrControllerName.raw());
3038	}
3039	}
3040	}
3041
3042	/*
3043	* Add a floppy controller if we need to.
3044	*/
3045	if (strControllerName.isEmpty())
3046	{
3047	bstrControllerName = strControllerName = "Floppy";
3048	ComPtr<IStorageController> ptrControllerIgnored;
3049	HRESULT hrc = rPtrSessionMachine->AddStorageController(bstrControllerName.raw(), StorageBus_Floppy,
3050	ptrControllerIgnored.asOutParam());
3051	LogRelFunc(("Machine::addStorageController(Floppy) -> %Rhrc \n", hrc));
3052	if (FAILED(hrc))
3053	return hrc;
3054	}
3055
3056	/*
3057	* Adding a floppy drive (if needed) and mounting the auxiliary image is
3058	* done later together with the ISOs.
3059	*/
3060	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(StorageBus_Floppy, strControllerName,
3061	DeviceType_Floppy, AccessMode_ReadWrite,
3062	0, 0,
3063	fFoundPort0Dev0 /fMountOnly/,
3064	mpInstaller->getAuxiliaryFloppyFilePath(), false));
3065	return S_OK;
3066	}
3067
3068	/**
3069	* Reconfigures DVD drives of the VM to mount all the ISOs we need.
3070	*
3071	* This will umount all DVD media.
3072	*
3073	* @returns COM status code.
3074	* @param rControllers The existing controllers.
3075	* @param rVecInstallatationDisks The list of image to mount.
3076	* @param rPtrSessionMachine The session machine smart pointer.
3077	* @param rAutoLock The lock.
3078	* @param enmRecommendedStorageBus The recommended storage bus type for adding
3079	* DVD drives on.
3080	*/
3081	HRESULT Unattended::i_reconfigureIsos(com::SafeIfaceArray<IStorageController> &rControllers,
3082	std::vector<UnattendedInstallationDisk> &rVecInstallatationDisks,
3083	ComPtr<IMachine> const &rPtrSessionMachine,
3084	AutoMultiWriteLock2 &rAutoLock, StorageBus_T enmRecommendedStorageBus)
3085	{
3086	/*
3087	* Enumerate the attachements of every controller, looking for DVD drives,
3088	* ASSUMEING all drives are bootable.
3089	*
3090	* Eject the medium from all the drives (don't want any confusion) and look
3091	* for the recommended storage bus in case we need to add more drives.
3092	*/
3093	HRESULT hrc;
3094	std::list<ControllerSlot> lstControllerDvdSlots;
3095	Utf8Str strRecommendedControllerName; /* non-empty if recommended bus found. */
3096	Utf8Str strControllerName;
3097	Bstr bstrControllerName;
3098	for (size_t i = 0; i < rControllers.size(); ++i)
3099	{
3100	hrc = rControllers[i]->COMGETTER(Name)(bstrControllerName.asOutParam());
3101	AssertComRCReturn(hrc, hrc);
3102	strControllerName = bstrControllerName;
3103
3104	/* Look for recommended storage bus. */
3105	StorageBus_T enmStorageBus;
3106	hrc = rControllers[i]->COMGETTER(Bus)(&enmStorageBus);
3107	AssertComRCReturn(hrc, hrc);
3108	if (enmStorageBus == enmRecommendedStorageBus)
3109	{
3110	strRecommendedControllerName = bstrControllerName;
3111	AssertLogRelReturn(strControllerName.isNotEmpty(), setErrorBoth(E_UNEXPECTED, VERR_INTERNAL_ERROR_2));
3112	}
3113
3114	/* Scan the controller attachments. */
3115	com::SafeIfaceArray<IMediumAttachment> arrayOfMediumAttachments;
3116	hrc = rPtrSessionMachine->GetMediumAttachmentsOfController(bstrControllerName.raw(),
3117	ComSafeArrayAsOutParam(arrayOfMediumAttachments));
3118	AssertComRCReturn(hrc, hrc);
3119
3120	for (size_t j = 0; j < arrayOfMediumAttachments.size(); j++)
3121	{
3122	DeviceType_T enmType;
3123	hrc = arrayOfMediumAttachments[j]->COMGETTER(Type)(&enmType);
3124	AssertComRCReturn(hrc, hrc);
3125	if (enmType == DeviceType_DVD)
3126	{
3127	LONG iPort = -1;
3128	hrc = arrayOfMediumAttachments[j]->COMGETTER(Port)(&iPort);
3129	AssertComRCReturn(hrc, hrc);
3130
3131	LONG iDevice = -1;
3132	hrc = arrayOfMediumAttachments[j]->COMGETTER(Device)(&iDevice);
3133	AssertComRCReturn(hrc, hrc);
3134
3135	/* Remeber it. */
3136	lstControllerDvdSlots.push_back(ControllerSlot(enmStorageBus, strControllerName, iPort, iDevice, false /fFree/));
3137
3138	/* Eject the medium, if any. */
3139	ComPtr<IMedium> ptrMedium;
3140	hrc = arrayOfMediumAttachments[j]->COMGETTER(Medium)(ptrMedium.asOutParam());
3141	AssertComRCReturn(hrc, hrc);
3142	if (ptrMedium.isNotNull())
3143	{
3144	ptrMedium.setNull();
3145
3146	rAutoLock.release();
3147	hrc = rPtrSessionMachine->UnmountMedium(bstrControllerName.raw(), iPort, iDevice, TRUE /fForce/);
3148	rAutoLock.acquire();
3149	}
3150	}
3151	}
3152	}
3153
3154	/*
3155	* How many drives do we need? Add more if necessary.
3156	*/
3157	ULONG cDvdDrivesNeeded = 0;
3158	if (mpInstaller->isAuxiliaryIsoNeeded())
3159	cDvdDrivesNeeded++;
3160	if (mpInstaller->isOriginalIsoNeeded())
3161	cDvdDrivesNeeded++;
3162	#if 0 /* These are now in the AUX VISO. */
3163	if (mpInstaller->isAdditionsIsoNeeded())
3164	cDvdDrivesNeeded++;
3165	if (mpInstaller->isValidationKitIsoNeeded())
3166	cDvdDrivesNeeded++;
3167	#endif
3168	Assert(cDvdDrivesNeeded > 0);
3169	if (cDvdDrivesNeeded > lstControllerDvdSlots.size())
3170	{
3171	/* Do we need to add the recommended controller? */
3172	if (strRecommendedControllerName.isEmpty())
3173	{
3174	switch (enmRecommendedStorageBus)
3175	{
3176	case StorageBus_IDE: strRecommendedControllerName = "IDE"; break;
3177	case StorageBus_SATA: strRecommendedControllerName = "SATA"; break;
3178	case StorageBus_SCSI: strRecommendedControllerName = "SCSI"; break;
3179	case StorageBus_SAS: strRecommendedControllerName = "SAS"; break;
3180	case StorageBus_USB: strRecommendedControllerName = "USB"; break;
3181	case StorageBus_PCIe: strRecommendedControllerName = "PCIe"; break;
3182	default:
3183	return setError(E_FAIL, tr("Support for recommended storage bus %d not implemented"),
3184	(int)enmRecommendedStorageBus);
3185	}
3186	ComPtr<IStorageController> ptrControllerIgnored;
3187	hrc = rPtrSessionMachine->AddStorageController(Bstr(strRecommendedControllerName).raw(), enmRecommendedStorageBus,
3188	ptrControllerIgnored.asOutParam());
3189	LogRelFunc(("Machine::addStorageController(%s) -> %Rhrc \n", strRecommendedControllerName.c_str(), hrc));
3190	if (FAILED(hrc))
3191	return hrc;
3192	}
3193
3194	/* Add free controller slots, maybe raising the port limit on the controller if we can. */
3195	hrc = i_findOrCreateNeededFreeSlots(strRecommendedControllerName, enmRecommendedStorageBus, rPtrSessionMachine,
3196	cDvdDrivesNeeded, lstControllerDvdSlots);
3197	if (FAILED(hrc))
3198	return hrc;
3199	if (cDvdDrivesNeeded > lstControllerDvdSlots.size())
3200	{
3201	/* We could in many cases create another controller here, but it's not worth the effort. */
3202	return setError(E_FAIL, tr("Not enough free slots on controller '%s' to add %u DVD drive(s)", "",
3203	cDvdDrivesNeeded - lstControllerDvdSlots.size()),
3204	strRecommendedControllerName.c_str(), cDvdDrivesNeeded - lstControllerDvdSlots.size());
3205	}
3206	Assert(cDvdDrivesNeeded == lstControllerDvdSlots.size());
3207	}
3208
3209	/*
3210	* Sort the DVD slots in boot order.
3211	*/
3212	lstControllerDvdSlots.sort();
3213
3214	/*
3215	* Prepare ISO mounts.
3216	*
3217	* Boot order depends on bootFromAuxiliaryIso() and we must grab DVD slots
3218	* according to the boot order.
3219	*/
3220	std::list<ControllerSlot>::const_iterator itDvdSlot = lstControllerDvdSlots.begin();
3221	if (mpInstaller->isAuxiliaryIsoNeeded() && mpInstaller->bootFromAuxiliaryIso())
3222	{
3223	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, mpInstaller->getAuxiliaryIsoFilePath(), true));
3224	++itDvdSlot;
3225	}
3226
3227	if (mpInstaller->isOriginalIsoNeeded())
3228	{
3229	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, i_getIsoPath(), false));
3230	++itDvdSlot;
3231	}
3232
3233	if (mpInstaller->isAuxiliaryIsoNeeded() && !mpInstaller->bootFromAuxiliaryIso())
3234	{
3235	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, mpInstaller->getAuxiliaryIsoFilePath(), true));
3236	++itDvdSlot;
3237	}
3238
3239	#if 0 /* These are now in the AUX VISO. */
3240	if (mpInstaller->isAdditionsIsoNeeded())
3241	{
3242	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, i_getAdditionsIsoPath(), false));
3243	++itDvdSlot;
3244	}
3245
3246	if (mpInstaller->isValidationKitIsoNeeded())
3247	{
3248	rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, i_getValidationKitIsoPath(), false));
3249	++itDvdSlot;
3250	}
3251	#endif
3252
3253	return S_OK;
3254	}
3255
3256	/**
3257	* Used to find more free slots for DVD drives during VM reconfiguration.
3258	*
3259	* This may modify the @a portCount property of the given controller.
3260	*
3261	* @returns COM status code.
3262	* @param rStrControllerName The name of the controller to find/create
3263	* free slots on.
3264	* @param enmStorageBus The storage bus type.
3265	* @param rPtrSessionMachine Reference to the session machine.
3266	* @param cSlotsNeeded Total slots needed (including those we've
3267	* already found).
3268	* @param rDvdSlots The slot collection for DVD drives to add
3269	* free slots to as we find/create them.
3270	*/
3271	HRESULT Unattended::i_findOrCreateNeededFreeSlots(const Utf8Str &rStrControllerName, StorageBus_T enmStorageBus,
3272	ComPtr<IMachine> const &rPtrSessionMachine, uint32_t cSlotsNeeded,
3273	std::list<ControllerSlot> &rDvdSlots)
3274	{
3275	Assert(cSlotsNeeded > rDvdSlots.size());
3276
3277	/*
3278	* Get controlleer stats.
3279	*/
3280	ComPtr<IStorageController> pController;
3281	HRESULT hrc = rPtrSessionMachine->GetStorageControllerByName(Bstr(rStrControllerName).raw(), pController.asOutParam());
3282	AssertComRCReturn(hrc, hrc);
3283
3284	ULONG cMaxDevicesPerPort = 1;
3285	hrc = pController->COMGETTER(MaxDevicesPerPortCount)(&cMaxDevicesPerPort);
3286	AssertComRCReturn(hrc, hrc);
3287	AssertLogRelReturn(cMaxDevicesPerPort > 0, E_UNEXPECTED);
3288
3289	ULONG cPorts = 0;
3290	hrc = pController->COMGETTER(PortCount)(&cPorts);
3291	AssertComRCReturn(hrc, hrc);
3292
3293	/*
3294	* Get the attachment list and turn into an internal list for lookup speed.
3295	*/
3296	com::SafeIfaceArray<IMediumAttachment> arrayOfMediumAttachments;
3297	hrc = rPtrSessionMachine->GetMediumAttachmentsOfController(Bstr(rStrControllerName).raw(),
3298	ComSafeArrayAsOutParam(arrayOfMediumAttachments));
3299	AssertComRCReturn(hrc, hrc);
3300
3301	std::vector<ControllerSlot> arrayOfUsedSlots;
3302	for (size_t i = 0; i < arrayOfMediumAttachments.size(); i++)
3303	{
3304	LONG iPort = -1;
3305	hrc = arrayOfMediumAttachments[i]->COMGETTER(Port)(&iPort);
3306	AssertComRCReturn(hrc, hrc);
3307
3308	LONG iDevice = -1;
3309	hrc = arrayOfMediumAttachments[i]->COMGETTER(Device)(&iDevice);
3310	AssertComRCReturn(hrc, hrc);
3311
3312	arrayOfUsedSlots.push_back(ControllerSlot(enmStorageBus, Utf8Str::Empty, iPort, iDevice, false /fFree/));
3313	}
3314
3315	/*
3316	* Iterate thru all possible slots, adding those not found in arrayOfUsedSlots.
3317	*/
3318	for (int32_t iPort = 0; iPort < (int32_t)cPorts; iPort++)
3319	for (int32_t iDevice = 0; iDevice < (int32_t)cMaxDevicesPerPort; iDevice++)
3320	{
3321	bool fFound = false;
3322	for (size_t i = 0; i < arrayOfUsedSlots.size(); i++)
3323	if ( arrayOfUsedSlots[i].iPort == iPort
3324	&& arrayOfUsedSlots[i].iDevice == iDevice)
3325	{
3326	fFound = true;
3327	break;
3328	}
3329	if (!fFound)
3330	{
3331	rDvdSlots.push_back(ControllerSlot(enmStorageBus, rStrControllerName, iPort, iDevice, true /fFree/));
3332	if (rDvdSlots.size() >= cSlotsNeeded)
3333	return S_OK;
3334	}
3335	}
3336
3337	/*
3338	* Okay we still need more ports. See if increasing the number of controller
3339	* ports would solve it.
3340	*/
3341	ULONG cMaxPorts = 1;
3342	hrc = pController->COMGETTER(MaxPortCount)(&cMaxPorts);
3343	AssertComRCReturn(hrc, hrc);
3344	if (cMaxPorts <= cPorts)
3345	return S_OK;
3346	size_t cNewPortsNeeded = (cSlotsNeeded - rDvdSlots.size() + cMaxDevicesPerPort - 1) / cMaxDevicesPerPort;
3347	if (cPorts + cNewPortsNeeded > cMaxPorts)
3348	return S_OK;
3349
3350	/*
3351	* Raise the port count and add the free slots we've just created.
3352	*/
3353	hrc = pController->COMSETTER(PortCount)(cPorts + (ULONG)cNewPortsNeeded);
3354	AssertComRCReturn(hrc, hrc);
3355	int32_t const cPortsNew = (int32_t)(cPorts + cNewPortsNeeded);
3356	for (int32_t iPort = (int32_t)cPorts; iPort < cPortsNew; iPort++)
3357	for (int32_t iDevice = 0; iDevice < (int32_t)cMaxDevicesPerPort; iDevice++)
3358	{
3359	rDvdSlots.push_back(ControllerSlot(enmStorageBus, rStrControllerName, iPort, iDevice, true /fFree/));
3360	if (rDvdSlots.size() >= cSlotsNeeded)
3361	return S_OK;
3362	}
3363
3364	/* We should not get here! */
3365	AssertLogRelFailedReturn(E_UNEXPECTED);
3366	}
3367
3368	HRESULT Unattended::done()
3369	{
3370	LogFlow(("Unattended::done\n"));
3371	if (mpInstaller)
3372	{
3373	LogRelFlow(("Unattended::done: Deleting installer object (%p)\n", mpInstaller));
3374	delete mpInstaller;
3375	mpInstaller = NULL;
3376	}
3377	return S_OK;
3378	}
3379
3380	HRESULT Unattended::getIsoPath(com::Utf8Str &isoPath)
3381	{
3382	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3383	isoPath = mStrIsoPath;
3384	return S_OK;
3385	}
3386
3387	HRESULT Unattended::setIsoPath(const com::Utf8Str &isoPath)
3388	{
3389	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3390	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3391	mStrIsoPath = isoPath;
3392	mfDoneDetectIsoOS = false;
3393	return S_OK;
3394	}
3395
3396	HRESULT Unattended::getUser(com::Utf8Str &user)
3397	{
3398	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3399	user = mStrUser;
3400	return S_OK;
3401	}
3402
3403
3404	HRESULT Unattended::setUser(const com::Utf8Str &user)
3405	{
3406	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3407	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3408	mStrUser = user;
3409	return S_OK;
3410	}
3411
3412	HRESULT Unattended::getPassword(com::Utf8Str &password)
3413	{
3414	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3415	password = mStrPassword;
3416	return S_OK;
3417	}
3418
3419	HRESULT Unattended::setPassword(const com::Utf8Str &password)
3420	{
3421	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3422	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3423	mStrPassword = password;
3424	return S_OK;
3425	}
3426
3427	HRESULT Unattended::getFullUserName(com::Utf8Str &fullUserName)
3428	{
3429	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3430	fullUserName = mStrFullUserName;
3431	return S_OK;
3432	}
3433
3434	HRESULT Unattended::setFullUserName(const com::Utf8Str &fullUserName)
3435	{
3436	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3437	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3438	mStrFullUserName = fullUserName;
3439	return S_OK;
3440	}
3441
3442	HRESULT Unattended::getProductKey(com::Utf8Str &productKey)
3443	{
3444	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3445	productKey = mStrProductKey;
3446	return S_OK;
3447	}
3448
3449	HRESULT Unattended::setProductKey(const com::Utf8Str &productKey)
3450	{
3451	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3452	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3453	mStrProductKey = productKey;
3454	return S_OK;
3455	}
3456
3457	HRESULT Unattended::getAdditionsIsoPath(com::Utf8Str &additionsIsoPath)
3458	{
3459	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3460	additionsIsoPath = mStrAdditionsIsoPath;
3461	return S_OK;
3462	}
3463
3464	HRESULT Unattended::setAdditionsIsoPath(const com::Utf8Str &additionsIsoPath)
3465	{
3466	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3467	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3468	mStrAdditionsIsoPath = additionsIsoPath;
3469	return S_OK;
3470	}
3471
3472	HRESULT Unattended::getInstallGuestAdditions(BOOL *installGuestAdditions)
3473	{
3474	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3475	*installGuestAdditions = mfInstallGuestAdditions;
3476	return S_OK;
3477	}
3478
3479	HRESULT Unattended::setInstallGuestAdditions(BOOL installGuestAdditions)
3480	{
3481	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3482	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3483	mfInstallGuestAdditions = installGuestAdditions != FALSE;
3484	return S_OK;
3485	}
3486
3487	HRESULT Unattended::getValidationKitIsoPath(com::Utf8Str &aValidationKitIsoPath)
3488	{
3489	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3490	aValidationKitIsoPath = mStrValidationKitIsoPath;
3491	return S_OK;
3492	}
3493
3494	HRESULT Unattended::setValidationKitIsoPath(const com::Utf8Str &aValidationKitIsoPath)
3495	{
3496	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3497	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3498	mStrValidationKitIsoPath = aValidationKitIsoPath;
3499	return S_OK;
3500	}
3501
3502	HRESULT Unattended::getInstallTestExecService(BOOL *aInstallTestExecService)
3503	{
3504	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3505	*aInstallTestExecService = mfInstallTestExecService;
3506	return S_OK;
3507	}
3508
3509	HRESULT Unattended::setInstallTestExecService(BOOL aInstallTestExecService)
3510	{
3511	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3512	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3513	mfInstallTestExecService = aInstallTestExecService != FALSE;
3514	return S_OK;
3515	}
3516
3517	HRESULT Unattended::getTimeZone(com::Utf8Str &aTimeZone)
3518	{
3519	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3520	aTimeZone = mStrTimeZone;
3521	return S_OK;
3522	}
3523
3524	HRESULT Unattended::setTimeZone(const com::Utf8Str &aTimezone)
3525	{
3526	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3527	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3528	mStrTimeZone = aTimezone;
3529	return S_OK;
3530	}
3531
3532	HRESULT Unattended::getLocale(com::Utf8Str &aLocale)
3533	{
3534	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3535	aLocale = mStrLocale;
3536	return S_OK;
3537	}
3538
3539	HRESULT Unattended::setLocale(const com::Utf8Str &aLocale)
3540	{
3541	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3542	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3543	if ( aLocale.isEmpty() /* use default */
3544	\|\| ( aLocale.length() == 5
3545	&& RT_C_IS_LOWER(aLocale[0])
3546	&& RT_C_IS_LOWER(aLocale[1])
3547	&& aLocale[2] == '_'
3548	&& RT_C_IS_UPPER(aLocale[3])
3549	&& RT_C_IS_UPPER(aLocale[4])) )
3550	{
3551	mStrLocale = aLocale;
3552	return S_OK;
3553	}
3554	return setError(E_INVALIDARG, tr("Expected two lower cased letters, an underscore, and two upper cased letters"));
3555	}
3556
3557	HRESULT Unattended::getLanguage(com::Utf8Str &aLanguage)
3558	{
3559	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3560	aLanguage = mStrLanguage;
3561	return S_OK;
3562	}
3563
3564	HRESULT Unattended::setLanguage(const com::Utf8Str &aLanguage)
3565	{
3566	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3567	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3568	mStrLanguage = aLanguage;
3569	return S_OK;
3570	}
3571
3572	HRESULT Unattended::getCountry(com::Utf8Str &aCountry)
3573	{
3574	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3575	aCountry = mStrCountry;
3576	return S_OK;
3577	}
3578
3579	HRESULT Unattended::setCountry(const com::Utf8Str &aCountry)
3580	{
3581	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3582	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3583	if ( aCountry.isEmpty()
3584	\|\| ( aCountry.length() == 2
3585	&& RT_C_IS_UPPER(aCountry[0])
3586	&& RT_C_IS_UPPER(aCountry[1])) )
3587	{
3588	mStrCountry = aCountry;
3589	return S_OK;
3590	}
3591	return setError(E_INVALIDARG, tr("Expected two upper cased letters"));
3592	}
3593
3594	HRESULT Unattended::getProxy(com::Utf8Str &aProxy)
3595	{
3596	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3597	aProxy = mStrProxy; /// @todo turn schema map into string or something.
3598	return S_OK;
3599	}
3600
3601	HRESULT Unattended::setProxy(const com::Utf8Str &aProxy)
3602	{
3603	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3604	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3605	if (aProxy.isEmpty())
3606	{
3607	/* set default proxy */
3608	/** @todo BUGBUG! implement this */
3609	}
3610	else if (aProxy.equalsIgnoreCase("none"))
3611	{
3612	/* clear proxy config */
3613	mStrProxy.setNull();
3614	}
3615	else
3616	{
3617	/** @todo Parse and set proxy config into a schema map or something along those lines. */
3618	/** @todo BUGBUG! implement this */
3619	// return E_NOTIMPL;
3620	mStrProxy = aProxy;
3621	}
3622	return S_OK;
3623	}
3624
3625	HRESULT Unattended::getPackageSelectionAdjustments(com::Utf8Str &aPackageSelectionAdjustments)
3626	{
3627	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3628	aPackageSelectionAdjustments = RTCString::join(mPackageSelectionAdjustments, ";");
3629	return S_OK;
3630	}
3631
3632	HRESULT Unattended::setPackageSelectionAdjustments(const com::Utf8Str &aPackageSelectionAdjustments)
3633	{
3634	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3635	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3636	if (aPackageSelectionAdjustments.isEmpty())
3637	mPackageSelectionAdjustments.clear();
3638	else
3639	{
3640	RTCList<RTCString, RTCString *> arrayStrSplit = aPackageSelectionAdjustments.split(";");
3641	for (size_t i = 0; i < arrayStrSplit.size(); i++)
3642	{
3643	if (arrayStrSplit[i].equals("minimal"))
3644	{ /* okay */ }
3645	else
3646	return setError(E_INVALIDARG, tr("Unknown keyword: %s"), arrayStrSplit[i].c_str());
3647	}
3648	mPackageSelectionAdjustments = arrayStrSplit;
3649	}
3650	return S_OK;
3651	}
3652
3653	HRESULT Unattended::getHostname(com::Utf8Str &aHostname)
3654	{
3655	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3656	aHostname = mStrHostname;
3657	return S_OK;
3658	}
3659
3660	HRESULT Unattended::setHostname(const com::Utf8Str &aHostname)
3661	{
3662	/*
3663	* Validate input.
3664	*/
3665	if (aHostname.length() > (aHostname.endsWith(".") ? 254U : 253U))
3666	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3667	tr("Hostname '%s' is %zu bytes long, max is 253 (excluding trailing dot)", "", aHostname.length()),
3668	aHostname.c_str(), aHostname.length());
3669	size_t cLabels = 0;
3670	const char *pszSrc = aHostname.c_str();
3671	for (;;)
3672	{
3673	size_t cchLabel = 1;
3674	char ch = *pszSrc++;
3675	if (RT_C_IS_ALNUM(ch))
3676	{
3677	cLabels++;
3678	while ((ch = *pszSrc++) != '.' && ch != '\0')
3679	{
3680	if (RT_C_IS_ALNUM(ch) \|\| ch == '-')
3681	{
3682	if (cchLabel < 63)
3683	cchLabel++;
3684	else
3685	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3686	tr("Invalid hostname '%s' - label %u is too long, max is 63."),
3687	aHostname.c_str(), cLabels);
3688	}
3689	else
3690	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3691	tr("Invalid hostname '%s' - illegal char '%c' at position %zu"),
3692	aHostname.c_str(), ch, pszSrc - aHostname.c_str() - 1);
3693	}
3694	if (cLabels == 1 && cchLabel < 2)
3695	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3696	tr("Invalid hostname '%s' - the name part must be at least two characters long"),
3697	aHostname.c_str());
3698	if (ch == '\0')
3699	break;
3700	}
3701	else if (ch != '\0')
3702	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3703	tr("Invalid hostname '%s' - illegal lead char '%c' at position %zu"),
3704	aHostname.c_str(), ch, pszSrc - aHostname.c_str() - 1);
3705	else
3706	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3707	tr("Invalid hostname '%s' - trailing dot not permitted"), aHostname.c_str());
3708	}
3709	if (cLabels < 2)
3710	return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
3711	tr("Incomplete hostname '%s' - must include both a name and a domain"), aHostname.c_str());
3712
3713	/*
3714	* Make the change.
3715	*/
3716	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3717	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3718	mStrHostname = aHostname;
3719	return S_OK;
3720	}
3721
3722	HRESULT Unattended::getAuxiliaryBasePath(com::Utf8Str &aAuxiliaryBasePath)
3723	{
3724	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3725	aAuxiliaryBasePath = mStrAuxiliaryBasePath;
3726	return S_OK;
3727	}
3728
3729	HRESULT Unattended::setAuxiliaryBasePath(const com::Utf8Str &aAuxiliaryBasePath)
3730	{
3731	if (aAuxiliaryBasePath.isEmpty())
3732	return setError(E_INVALIDARG, tr("Empty base path is not allowed"));
3733	if (!RTPathStartsWithRoot(aAuxiliaryBasePath.c_str()))
3734	return setError(E_INVALIDARG, tr("Base path must be absolute"));
3735
3736	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3737	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3738	mStrAuxiliaryBasePath = aAuxiliaryBasePath;
3739	mfIsDefaultAuxiliaryBasePath = mStrAuxiliaryBasePath.isEmpty();
3740	return S_OK;
3741	}
3742
3743	HRESULT Unattended::getImageIndex(ULONG *index)
3744	{
3745	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3746	*index = midxImage;
3747	return S_OK;
3748	}
3749
3750	HRESULT Unattended::setImageIndex(ULONG index)
3751	{
3752	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3753	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3754
3755	/* Validate the selection if detection was done already: */
3756	if (mDetectedImages.size() > 0)
3757	{
3758	for (size_t i = 0; i < mDetectedImages.size(); i++)
3759	if (mDetectedImages[i].mImageIndex == index)
3760	{
3761	midxImage = index;
3762	i_updateDetectedAttributeForImage(mDetectedImages[i]);
3763	return S_OK;
3764	}
3765	LogRel(("Unattended: Setting invalid index=%u\n", index)); /** @todo fail? */
3766	}
3767
3768	midxImage = index;
3769	return S_OK;
3770	}
3771
3772	HRESULT Unattended::getMachine(ComPtr<IMachine> &aMachine)
3773	{
3774	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3775	return mMachine.queryInterfaceTo(aMachine.asOutParam());
3776	}
3777
3778	HRESULT Unattended::setMachine(const ComPtr<IMachine> &aMachine)
3779	{
3780	/*
3781	* Lookup the VM so we can safely get the Machine instance.
3782	* (Don't want to test how reliable XPCOM and COM are with finding
3783	* the local object instance when a client passes a stub back.)
3784	*/
3785	Bstr bstrUuidMachine;
3786	HRESULT hrc = aMachine->COMGETTER(Id)(bstrUuidMachine.asOutParam());
3787	if (SUCCEEDED(hrc))
3788	{
3789	Guid UuidMachine(bstrUuidMachine);
3790	ComObjPtr<Machine> ptrMachine;
3791	hrc = mParent->i_findMachine(UuidMachine, false /fPermitInaccessible/, true /aSetError/, &ptrMachine);
3792	if (SUCCEEDED(hrc))
3793	{
3794	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3795	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER,
3796	tr("Cannot change after prepare() has been called")));
3797	mMachine = ptrMachine;
3798	mMachineUuid = UuidMachine;
3799	if (mfIsDefaultAuxiliaryBasePath)
3800	mStrAuxiliaryBasePath.setNull();
3801	hrc = S_OK;
3802	}
3803	}
3804	return hrc;
3805	}
3806
3807	HRESULT Unattended::getScriptTemplatePath(com::Utf8Str &aScriptTemplatePath)
3808	{
3809	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3810	if ( mStrScriptTemplatePath.isNotEmpty()
3811	\|\| mpInstaller == NULL)
3812	aScriptTemplatePath = mStrScriptTemplatePath;
3813	else
3814	aScriptTemplatePath = mpInstaller->getTemplateFilePath();
3815	return S_OK;
3816	}
3817
3818	HRESULT Unattended::setScriptTemplatePath(const com::Utf8Str &aScriptTemplatePath)
3819	{
3820	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3821	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3822	mStrScriptTemplatePath = aScriptTemplatePath;
3823	return S_OK;
3824	}
3825
3826	HRESULT Unattended::getPostInstallScriptTemplatePath(com::Utf8Str &aPostInstallScriptTemplatePath)
3827	{
3828	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3829	if ( mStrPostInstallScriptTemplatePath.isNotEmpty()
3830	\|\| mpInstaller == NULL)
3831	aPostInstallScriptTemplatePath = mStrPostInstallScriptTemplatePath;
3832	else
3833	aPostInstallScriptTemplatePath = mpInstaller->getPostTemplateFilePath();
3834	return S_OK;
3835	}
3836
3837	HRESULT Unattended::setPostInstallScriptTemplatePath(const com::Utf8Str &aPostInstallScriptTemplatePath)
3838	{
3839	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3840	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3841	mStrPostInstallScriptTemplatePath = aPostInstallScriptTemplatePath;
3842	return S_OK;
3843	}
3844
3845	HRESULT Unattended::getPostInstallCommand(com::Utf8Str &aPostInstallCommand)
3846	{
3847	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3848	aPostInstallCommand = mStrPostInstallCommand;
3849	return S_OK;
3850	}
3851
3852	HRESULT Unattended::setPostInstallCommand(const com::Utf8Str &aPostInstallCommand)
3853	{
3854	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3855	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3856	mStrPostInstallCommand = aPostInstallCommand;
3857	return S_OK;
3858	}
3859
3860	HRESULT Unattended::getExtraInstallKernelParameters(com::Utf8Str &aExtraInstallKernelParameters)
3861	{
3862	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3863	if ( mStrExtraInstallKernelParameters.isNotEmpty()
3864	\|\| mpInstaller == NULL)
3865	aExtraInstallKernelParameters = mStrExtraInstallKernelParameters;
3866	else
3867	aExtraInstallKernelParameters = mpInstaller->getDefaultExtraInstallKernelParameters();
3868	return S_OK;
3869	}
3870
3871	HRESULT Unattended::setExtraInstallKernelParameters(const com::Utf8Str &aExtraInstallKernelParameters)
3872	{
3873	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3874	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
3875	mStrExtraInstallKernelParameters = aExtraInstallKernelParameters;
3876	return S_OK;
3877	}
3878
3879	HRESULT Unattended::getDetectedOSTypeId(com::Utf8Str &aDetectedOSTypeId)
3880	{
3881	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3882	aDetectedOSTypeId = mStrDetectedOSTypeId;
3883	return S_OK;
3884	}
3885
3886	HRESULT Unattended::getDetectedOSVersion(com::Utf8Str &aDetectedOSVersion)
3887	{
3888	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3889	aDetectedOSVersion = mStrDetectedOSVersion;
3890	return S_OK;
3891	}
3892
3893	HRESULT Unattended::getDetectedOSFlavor(com::Utf8Str &aDetectedOSFlavor)
3894	{
3895	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3896	aDetectedOSFlavor = mStrDetectedOSFlavor;
3897	return S_OK;
3898	}
3899
3900	HRESULT Unattended::getDetectedOSLanguages(com::Utf8Str &aDetectedOSLanguages)
3901	{
3902	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3903	aDetectedOSLanguages = RTCString::join(mDetectedOSLanguages, " ");
3904	return S_OK;
3905	}
3906
3907	HRESULT Unattended::getDetectedOSHints(com::Utf8Str &aDetectedOSHints)
3908	{
3909	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3910	aDetectedOSHints = mStrDetectedOSHints;
3911	return S_OK;
3912	}
3913
3914	HRESULT Unattended::getDetectedImageNames(std::vector<com::Utf8Str> &aDetectedImageNames)
3915	{
3916	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3917	aDetectedImageNames.clear();
3918	for (size_t i = 0; i < mDetectedImages.size(); ++i)
3919	{
3920	Utf8Str strTmp;
3921	aDetectedImageNames.push_back(mDetectedImages[i].formatName(strTmp));
3922	}
3923	return S_OK;
3924	}
3925
3926	HRESULT Unattended::getDetectedImageIndices(std::vector<ULONG> &aDetectedImageIndices)
3927	{
3928	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3929	aDetectedImageIndices.clear();
3930	for (size_t i = 0; i < mDetectedImages.size(); ++i)
3931	aDetectedImageIndices.push_back(mDetectedImages[i].mImageIndex);
3932	return S_OK;
3933	}
3934
3935	HRESULT Unattended::getIsUnattendedInstallSupported(BOOL *aIsUnattendedInstallSupported)
3936	{
3937	/*
3938	* Take the initial position that it's not supported, so we can return
3939	* right away when we decide it's not possible.
3940	*/
3941	*aIsUnattendedInstallSupported = false;
3942
3943	/* Unattended is disabled by default if we could not detect OS type. */
3944	if (mStrDetectedOSTypeId.isEmpty())
3945	return S_OK;
3946
3947	const VBOXOSTYPE enmOsTypeMasked = (VBOXOSTYPE)(mEnmOsType & VBOXOSTYPE_OsTypeMask);
3948
3949	/* We require a version to have been detected, except for windows where the
3950	field is generally only used for the service pack number at present and
3951	will be empty for RTMs isos. */
3952	if ( ( enmOsTypeMasked <= VBOXOSTYPE_WinNT
3953	\|\| enmOsTypeMasked >= VBOXOSTYPE_OS2)
3954	&& mStrDetectedOSVersion.isEmpty())
3955	return S_OK;
3956
3957	/*
3958	* Sort out things that we know doesn't work. Order by VBOXOSTYPE value.
3959	*/
3960
3961	/* We do not support any of the DOS based windows version, nor DOS, in case
3962	any of that gets detected (it shouldn't): */
3963	if (enmOsTypeMasked >= VBOXOSTYPE_DOS && enmOsTypeMasked < VBOXOSTYPE_WinNT)
3964	return S_OK;
3965
3966	/* Windows NT 3.x doesn't work, also skip unknown windows NT version: */
3967	if (enmOsTypeMasked >= VBOXOSTYPE_WinNT && enmOsTypeMasked < VBOXOSTYPE_WinNT4)
3968	return S_OK;
3969
3970	/* For OS/2 we only support OS2 4.5 (actually only 4.52 server has been
3971	tested, but we'll get to the others eventually): */
3972	if ( enmOsTypeMasked >= VBOXOSTYPE_OS2
3973	&& enmOsTypeMasked < VBOXOSTYPE_Linux
3974	&& enmOsTypeMasked != VBOXOSTYPE_OS2Warp45 /* probably works */ )
3975	return S_OK;
3976
3977	/* Old Debians fail since package repos have been move to some other mirror location. */
3978	if ( enmOsTypeMasked == VBOXOSTYPE_Debian
3979	&& RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "9.0") < 0)
3980	return S_OK;
3981
3982	/* Skip all OpenSUSE variants for now. */
3983	if (enmOsTypeMasked == VBOXOSTYPE_OpenSUSE)
3984	return S_OK;
3985
3986	if (enmOsTypeMasked == VBOXOSTYPE_Ubuntu)
3987	{
3988	/* We cannot install Ubuntus older than 11.04. */
3989	if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "11.04") < 0)
3990	return S_OK;
3991	/* Lubuntu, starting with 20.04, has switched to calamares, which cannot be automated. */
3992	if ( RTStrIStr(mStrDetectedOSFlavor.c_str(), "lubuntu")
3993	&& RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "20.04") > 0)
3994	return S_OK;
3995	}
3996
3997	/* Earlier than OL 6.4 cannot be installed. OL 6.x fails with unsupported hardware error (CPU family). */
3998	if ( enmOsTypeMasked == VBOXOSTYPE_Oracle
3999	&& RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "6.4") < 0)
4000	return S_OK;
4001
4002	/* Fredora ISOs cannot be installed at present. */
4003	if (enmOsTypeMasked == VBOXOSTYPE_FedoraCore)
4004	return S_OK;
4005
4006	/*
4007	* Assume the rest works.
4008	*/
4009	*aIsUnattendedInstallSupported = true;
4010	return S_OK;
4011	}
4012
4013	HRESULT Unattended::getAvoidUpdatesOverNetwork(BOOL *aAvoidUpdatesOverNetwork)
4014	{
4015	*aAvoidUpdatesOverNetwork = mfAvoidUpdatesOverNetwork;
4016	return S_OK;
4017	}
4018
4019	HRESULT Unattended::setAvoidUpdatesOverNetwork(BOOL aAvoidUpdatesOverNetwork)
4020	{
4021	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4022	AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
4023	mfAvoidUpdatesOverNetwork = RT_BOOL(aAvoidUpdatesOverNetwork);
4024	return S_OK;
4025	}
4026
4027	/*
4028	* Getters that the installer and script classes can use.
4029	*/
4030	Utf8Str const &Unattended::i_getIsoPath() const
4031	{
4032	Assert(isReadLockedOnCurrentThread());
4033	return mStrIsoPath;
4034	}
4035
4036	Utf8Str const &Unattended::i_getUser() const
4037	{
4038	Assert(isReadLockedOnCurrentThread());
4039	return mStrUser;
4040	}
4041
4042	Utf8Str const &Unattended::i_getPassword() const
4043	{
4044	Assert(isReadLockedOnCurrentThread());
4045	return mStrPassword;
4046	}
4047
4048	Utf8Str const &Unattended::i_getFullUserName() const
4049	{
4050	Assert(isReadLockedOnCurrentThread());
4051	return mStrFullUserName.isNotEmpty() ? mStrFullUserName : mStrUser;
4052	}
4053
4054	Utf8Str const &Unattended::i_getProductKey() const
4055	{
4056	Assert(isReadLockedOnCurrentThread());
4057	return mStrProductKey;
4058	}
4059
4060	Utf8Str const &Unattended::i_getProxy() const
4061	{
4062	Assert(isReadLockedOnCurrentThread());
4063	return mStrProxy;
4064	}
4065
4066	Utf8Str const &Unattended::i_getAdditionsIsoPath() const
4067	{
4068	Assert(isReadLockedOnCurrentThread());
4069	return mStrAdditionsIsoPath;
4070	}
4071
4072	bool Unattended::i_getInstallGuestAdditions() const
4073	{
4074	Assert(isReadLockedOnCurrentThread());
4075	return mfInstallGuestAdditions;
4076	}
4077
4078	Utf8Str const &Unattended::i_getValidationKitIsoPath() const
4079	{
4080	Assert(isReadLockedOnCurrentThread());
4081	return mStrValidationKitIsoPath;
4082	}
4083
4084	bool Unattended::i_getInstallTestExecService() const
4085	{
4086	Assert(isReadLockedOnCurrentThread());
4087	return mfInstallTestExecService;
4088	}
4089
4090	Utf8Str const &Unattended::i_getTimeZone() const
4091	{
4092	Assert(isReadLockedOnCurrentThread());
4093	return mStrTimeZone;
4094	}
4095
4096	PCRTTIMEZONEINFO Unattended::i_getTimeZoneInfo() const
4097	{
4098	Assert(isReadLockedOnCurrentThread());
4099	return mpTimeZoneInfo;
4100	}
4101
4102	Utf8Str const &Unattended::i_getLocale() const
4103	{
4104	Assert(isReadLockedOnCurrentThread());
4105	return mStrLocale;
4106	}
4107
4108	Utf8Str const &Unattended::i_getLanguage() const
4109	{
4110	Assert(isReadLockedOnCurrentThread());
4111	return mStrLanguage;
4112	}
4113
4114	Utf8Str const &Unattended::i_getCountry() const
4115	{
4116	Assert(isReadLockedOnCurrentThread());
4117	return mStrCountry;
4118	}
4119
4120	bool Unattended::i_isMinimalInstallation() const
4121	{
4122	size_t i = mPackageSelectionAdjustments.size();
4123	while (i-- > 0)
4124	if (mPackageSelectionAdjustments[i].equals("minimal"))
4125	return true;
4126	return false;
4127	}
4128
4129	Utf8Str const &Unattended::i_getHostname() const
4130	{
4131	Assert(isReadLockedOnCurrentThread());
4132	return mStrHostname;
4133	}
4134
4135	Utf8Str const &Unattended::i_getAuxiliaryBasePath() const
4136	{
4137	Assert(isReadLockedOnCurrentThread());
4138	return mStrAuxiliaryBasePath;
4139	}
4140
4141	ULONG Unattended::i_getImageIndex() const
4142	{
4143	Assert(isReadLockedOnCurrentThread());
4144	return midxImage;
4145	}
4146
4147	Utf8Str const &Unattended::i_getScriptTemplatePath() const
4148	{
4149	Assert(isReadLockedOnCurrentThread());
4150	return mStrScriptTemplatePath;
4151	}
4152
4153	Utf8Str const &Unattended::i_getPostInstallScriptTemplatePath() const
4154	{
4155	Assert(isReadLockedOnCurrentThread());
4156	return mStrPostInstallScriptTemplatePath;
4157	}
4158
4159	Utf8Str const &Unattended::i_getPostInstallCommand() const
4160	{
4161	Assert(isReadLockedOnCurrentThread());
4162	return mStrPostInstallCommand;
4163	}
4164
4165	Utf8Str const &Unattended::i_getAuxiliaryInstallDir() const
4166	{
4167	Assert(isReadLockedOnCurrentThread());
4168	/* Only the installer knows, forward the call. */
4169	AssertReturn(mpInstaller != NULL, Utf8Str::Empty);
4170	return mpInstaller->getAuxiliaryInstallDir();
4171	}
4172
4173	Utf8Str const &Unattended::i_getExtraInstallKernelParameters() const
4174	{
4175	Assert(isReadLockedOnCurrentThread());
4176	return mStrExtraInstallKernelParameters;
4177	}
4178
4179	bool Unattended::i_isRtcUsingUtc() const
4180	{
4181	Assert(isReadLockedOnCurrentThread());
4182	return mfRtcUseUtc;
4183	}
4184
4185	bool Unattended::i_isGuestOs64Bit() const
4186	{
4187	Assert(isReadLockedOnCurrentThread());
4188	return mfGuestOs64Bit;
4189	}
4190
4191	bool Unattended::i_isFirmwareEFI() const
4192	{
4193	Assert(isReadLockedOnCurrentThread());
4194	return menmFirmwareType != FirmwareType_BIOS;
4195	}
4196
4197	Utf8Str const &Unattended::i_getDetectedOSVersion()
4198	{
4199	Assert(isReadLockedOnCurrentThread());
4200	return mStrDetectedOSVersion;
4201	}
4202
4203	bool Unattended::i_getAvoidUpdatesOverNetwork() const
4204	{
4205	Assert(isReadLockedOnCurrentThread());
4206	return mfAvoidUpdatesOverNetwork;
4207	}
4208
4209	HRESULT Unattended::i_attachImage(UnattendedInstallationDisk const *pImage, ComPtr<IMachine> const &rPtrSessionMachine,
4210	AutoMultiWriteLock2 &rLock)
4211	{
4212	/*
4213	* Attach the disk image
4214	* HACK ALERT! Temporarily release the Unattended lock.
4215	*/
4216	rLock.release();
4217
4218	ComPtr<IMedium> ptrMedium;
4219	HRESULT hrc = mParent->OpenMedium(Bstr(pImage->strImagePath).raw(),
4220	pImage->enmDeviceType,
4221	pImage->enmAccessType,
4222	true,
4223	ptrMedium.asOutParam());
4224	LogRelFlowFunc(("VirtualBox::openMedium -> %Rhrc\n", hrc));
4225	if (SUCCEEDED(hrc))
4226	{
4227	if (pImage->fAuxiliary && pImage->strImagePath.endsWith(".viso"))
4228	{
4229	hrc = ptrMedium->SetProperty(Bstr("UnattendedInstall").raw(), Bstr("1").raw());
4230	LogRelFlowFunc(("Medium::SetProperty -> %Rhrc\n", hrc));
4231	}
4232	if (pImage->fMountOnly)
4233	{
4234	// mount the opened disk image
4235	hrc = rPtrSessionMachine->MountMedium(Bstr(pImage->strControllerName).raw(), pImage->iPort,
4236	pImage->iDevice, ptrMedium, TRUE /fForce/);
4237	LogRelFlowFunc(("Machine::MountMedium -> %Rhrc\n", hrc));
4238	}
4239	else
4240	{
4241	//attach the opened disk image to the controller
4242	hrc = rPtrSessionMachine->AttachDevice(Bstr(pImage->strControllerName).raw(), pImage->iPort,
4243	pImage->iDevice, pImage->enmDeviceType, ptrMedium);
4244	LogRelFlowFunc(("Machine::AttachDevice -> %Rhrc\n", hrc));
4245	}
4246	}
4247
4248	rLock.acquire();
4249	return hrc;
4250	}
4251
4252	bool Unattended::i_isGuestOSArchX64(Utf8Str const &rStrGuestOsTypeId)
4253	{
4254	ComPtr<IGuestOSType> pGuestOSType;
4255	HRESULT hrc = mParent->GetGuestOSType(Bstr(rStrGuestOsTypeId).raw(), pGuestOSType.asOutParam());
4256	if (SUCCEEDED(hrc))
4257	{
4258	BOOL fIs64Bit = FALSE;
4259	if (!pGuestOSType.isNull())
4260	hrc = pGuestOSType->COMGETTER(Is64Bit)(&fIs64Bit);
4261	if (SUCCEEDED(hrc))
4262	return fIs64Bit != FALSE;
4263	}
4264	return false;
4265	}
4266
4267
4268	bool Unattended::i_updateDetectedAttributeForImage(WIMImage const &rImage)
4269	{
4270	bool fRet = true;
4271
4272	/*
4273	* If the image doesn't have a valid value, we don't change it.
4274	* This is obviously a little bit bogus, but what can we do...
4275	*/
4276	const char *pszOSTypeId = Global::OSTypeId(rImage.mOSType);
4277	if (pszOSTypeId && strcmp(pszOSTypeId, "Other") != 0)
4278	mStrDetectedOSTypeId = pszOSTypeId;
4279	else
4280	fRet = false;
4281
4282	if (rImage.mVersion.isNotEmpty())
4283	mStrDetectedOSVersion = rImage.mVersion;
4284	else
4285	fRet = false;
4286
4287	if (rImage.mFlavor.isNotEmpty())
4288	mStrDetectedOSFlavor = rImage.mFlavor;
4289	else
4290	fRet = false;
4291
4292	if (rImage.mLanguages.size() > 0)
4293	mDetectedOSLanguages = rImage.mLanguages;
4294	else
4295	fRet = false;
4296
4297	mEnmOsType = rImage.mEnmOsType;
4298
4299	return fRet;
4300	}

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

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

以其他格式下載: