UnattendedImpl.cpp@ 93585

最後變更在這個檔案從93585是 93585,由 vboxsync 提交於 3 年前
Main/Unattended: Correction to r149171, only make detectIsoOS return E_NOTIMPL when i_innerDetectIsoOS return S_FALSE. Since the previous we return S_OK when i_innerDetectIsoOSWindows is happy with the install.wim XML parsing output. bugref:9781
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 148.5 KB

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

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

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

以其他格式下載: