summaryrefslogtreecommitdiffstats
path: root/src/VBox/Main/src-server/UnattendedImpl.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/VBox/Main/src-server/UnattendedImpl.cpp')
-rw-r--r--src/VBox/Main/src-server/UnattendedImpl.cpp4292
1 files changed, 4292 insertions, 0 deletions
diff --git a/src/VBox/Main/src-server/UnattendedImpl.cpp b/src/VBox/Main/src-server/UnattendedImpl.cpp
new file mode 100644
index 00000000..f40e7e68
--- /dev/null
+++ b/src/VBox/Main/src-server/UnattendedImpl.cpp
@@ -0,0 +1,4292 @@
+/* $Id: UnattendedImpl.cpp $ */
+/** @file
+ * Unattended class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2022 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_MAIN_UNATTENDED
+#include "LoggingNew.h"
+#include "VirtualBoxBase.h"
+#include "UnattendedImpl.h"
+#include "UnattendedInstaller.h"
+#include "UnattendedScript.h"
+#include "VirtualBoxImpl.h"
+#include "SystemPropertiesImpl.h"
+#include "MachineImpl.h"
+#include "Global.h"
+#include "StringifyEnums.h"
+
+#include <VBox/err.h>
+#include <iprt/cpp/xml.h>
+#include <iprt/ctype.h>
+#include <iprt/file.h>
+#ifndef RT_OS_WINDOWS
+# include <iprt/formats/mz.h>
+# include <iprt/formats/pecoff.h>
+#endif
+#include <iprt/formats/wim.h>
+#include <iprt/fsvfs.h>
+#include <iprt/inifile.h>
+#include <iprt/locale.h>
+#include <iprt/path.h>
+#include <iprt/vfs.h>
+
+using namespace std;
+
+
+/*********************************************************************************************************************************
+* Structures and Typedefs *
+*********************************************************************************************************************************/
+/**
+ * Controller slot for a DVD drive.
+ *
+ * The slot can be free and needing a drive to be attached along with the ISO
+ * image, or it may already be there and only need mounting the ISO. The
+ * ControllerSlot::fFree member indicates which it is.
+ */
+struct ControllerSlot
+{
+ StorageBus_T enmBus;
+ Utf8Str strControllerName;
+ LONG iPort;
+ LONG iDevice;
+ bool fFree;
+
+ ControllerSlot(StorageBus_T a_enmBus, const Utf8Str &a_rName, LONG a_iPort, LONG a_iDevice, bool a_fFree)
+ : enmBus(a_enmBus), strControllerName(a_rName), iPort(a_iPort), iDevice(a_iDevice), fFree(a_fFree)
+ {}
+
+ bool operator<(const ControllerSlot &rThat) const
+ {
+ if (enmBus == rThat.enmBus)
+ {
+ if (strControllerName == rThat.strControllerName)
+ {
+ if (iPort == rThat.iPort)
+ return iDevice < rThat.iDevice;
+ return iPort < rThat.iPort;
+ }
+ return strControllerName < rThat.strControllerName;
+ }
+
+ /*
+ * Bus comparsion in boot priority order.
+ */
+ /* IDE first. */
+ if (enmBus == StorageBus_IDE)
+ return true;
+ if (rThat.enmBus == StorageBus_IDE)
+ return false;
+ /* SATA next */
+ if (enmBus == StorageBus_SATA)
+ return true;
+ if (rThat.enmBus == StorageBus_SATA)
+ return false;
+ /* SCSI next */
+ if (enmBus == StorageBus_SCSI)
+ return true;
+ if (rThat.enmBus == StorageBus_SCSI)
+ return false;
+ /* numerical */
+ return (int)enmBus < (int)rThat.enmBus;
+ }
+
+ bool operator==(const ControllerSlot &rThat) const
+ {
+ return enmBus == rThat.enmBus
+ && strControllerName == rThat.strControllerName
+ && iPort == rThat.iPort
+ && iDevice == rThat.iDevice;
+ }
+};
+
+/**
+ * Installation disk.
+ *
+ * Used when reconfiguring the VM.
+ */
+typedef struct UnattendedInstallationDisk
+{
+ StorageBus_T enmBusType; /**< @todo nobody is using this... */
+ Utf8Str strControllerName;
+ DeviceType_T enmDeviceType;
+ AccessMode_T enmAccessType;
+ LONG iPort;
+ LONG iDevice;
+ bool fMountOnly;
+ Utf8Str strImagePath;
+ bool fAuxiliary;
+
+ UnattendedInstallationDisk(StorageBus_T a_enmBusType, Utf8Str const &a_rBusName, DeviceType_T a_enmDeviceType,
+ AccessMode_T a_enmAccessType, LONG a_iPort, LONG a_iDevice, bool a_fMountOnly,
+ Utf8Str const &a_rImagePath, bool a_fAuxiliary)
+ : enmBusType(a_enmBusType), strControllerName(a_rBusName), enmDeviceType(a_enmDeviceType), enmAccessType(a_enmAccessType)
+ , iPort(a_iPort), iDevice(a_iDevice), fMountOnly(a_fMountOnly), strImagePath(a_rImagePath), fAuxiliary(a_fAuxiliary)
+ {
+ Assert(strControllerName.length() > 0);
+ }
+
+ UnattendedInstallationDisk(std::list<ControllerSlot>::const_iterator const &itDvdSlot, Utf8Str const &a_rImagePath,
+ bool a_fAuxiliary)
+ : enmBusType(itDvdSlot->enmBus), strControllerName(itDvdSlot->strControllerName), enmDeviceType(DeviceType_DVD)
+ , enmAccessType(AccessMode_ReadOnly), iPort(itDvdSlot->iPort), iDevice(itDvdSlot->iDevice)
+ , fMountOnly(!itDvdSlot->fFree), strImagePath(a_rImagePath), fAuxiliary(a_fAuxiliary)
+ {
+ Assert(strControllerName.length() > 0);
+ }
+} UnattendedInstallationDisk;
+
+
+/**
+ * OS/2 syslevel file header.
+ */
+#pragma pack(1)
+typedef struct OS2SYSLEVELHDR
+{
+ uint16_t uMinusOne; /**< 0x00: UINT16_MAX */
+ char achSignature[8]; /**< 0x02: "SYSLEVEL" */
+ uint8_t abReserved1[5]; /**< 0x0a: Usually zero. Ignore. */
+ uint16_t uSyslevelFileVer; /**< 0x0f: The syslevel file version: 1. */
+ uint8_t abReserved2[16]; /**< 0x11: Zero. Ignore. */
+ uint32_t offTable; /**< 0x21: Offset of the syslevel table. */
+} OS2SYSLEVELHDR;
+#pragma pack()
+AssertCompileSize(OS2SYSLEVELHDR, 0x25);
+
+/**
+ * OS/2 syslevel table entry.
+ */
+#pragma pack(1)
+typedef struct OS2SYSLEVELENTRY
+{
+ uint16_t id; /**< 0x00: ? */
+ uint8_t bEdition; /**< 0x02: The OS/2 edition: 0=standard, 1=extended, x=component defined */
+ uint8_t bVersion; /**< 0x03: 0x45 = 4.5 */
+ uint8_t bModify; /**< 0x04: Lower nibble is added to bVersion, so 0x45 0x02 => 4.52 */
+ uint8_t abReserved1[2]; /**< 0x05: Zero. Ignore. */
+ char achCsdLevel[8]; /**< 0x07: The current CSD level. */
+ char achCsdPrior[8]; /**< 0x0f: The prior CSD level. */
+ char szName[80]; /**< 0x5f: System/component name. */
+ char achId[9]; /**< 0x67: System/component ID. */
+ uint8_t bRefresh; /**< 0x70: Single digit refresh version, ignored if zero. */
+ char szType[9]; /**< 0x71: Some kind of type string. Optional */
+ uint8_t abReserved2[6]; /**< 0x7a: Zero. Ignore. */
+} OS2SYSLEVELENTRY;
+#pragma pack()
+AssertCompileSize(OS2SYSLEVELENTRY, 0x80);
+
+
+
+/**
+ * Concatenate image name and version strings and return.
+ *
+ * A possible output would be "Windows 10 Home (10.0.19041.330 / x64)".
+ *
+ * @returns Name string to use.
+ * @param r_strName String object that can be formatted into and returned.
+ */
+const Utf8Str &WIMImage::formatName(Utf8Str &r_strName) const
+{
+ /* We skip the mFlavor as it's typically part of the description already. */
+
+ if (mVersion.isEmpty() && mArch.isEmpty() && mDefaultLanguage.isEmpty() && mLanguages.size() == 0)
+ return mName;
+
+ r_strName = mName;
+ bool fFirst = true;
+ if (mVersion.isNotEmpty())
+ {
+ r_strName.appendPrintf(fFirst ? " (%s" : " / %s", mVersion.c_str());
+ fFirst = false;
+ }
+ if (mArch.isNotEmpty())
+ {
+ r_strName.appendPrintf(fFirst ? " (%s" : " / %s", mArch.c_str());
+ fFirst = false;
+ }
+ if (mDefaultLanguage.isNotEmpty())
+ {
+ r_strName.appendPrintf(fFirst ? " (%s" : " / %s", mDefaultLanguage.c_str());
+ fFirst = false;
+ }
+ else
+ for (size_t i = 0; i < mLanguages.size(); i++)
+ {
+ r_strName.appendPrintf(fFirst ? " (%s" : " / %s", mLanguages[i].c_str());
+ fFirst = false;
+ }
+ r_strName.append(")");
+ return r_strName;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+/*
+*
+*
+* Implementation Unattended functions
+*
+*/
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+Unattended::Unattended()
+ : mhThreadReconfigureVM(NIL_RTNATIVETHREAD), mfRtcUseUtc(false), mfGuestOs64Bit(false)
+ , mpInstaller(NULL), mpTimeZoneInfo(NULL), mfIsDefaultAuxiliaryBasePath(true), mfDoneDetectIsoOS(false)
+ , mfAvoidUpdatesOverNetwork(false)
+{ }
+
+Unattended::~Unattended()
+{
+ if (mpInstaller)
+ {
+ delete mpInstaller;
+ mpInstaller = NULL;
+ }
+}
+
+HRESULT Unattended::FinalConstruct()
+{
+ return BaseFinalConstruct();
+}
+
+void Unattended::FinalRelease()
+{
+ uninit();
+
+ BaseFinalRelease();
+}
+
+void Unattended::uninit()
+{
+ /* Enclose the state transition Ready->InUninit->NotReady */
+ AutoUninitSpan autoUninitSpan(this);
+ if (autoUninitSpan.uninitDone())
+ return;
+
+ unconst(mParent) = NULL;
+ mMachine.setNull();
+}
+
+/**
+ * Initializes the unattended object.
+ *
+ * @param aParent Pointer to the parent object.
+ */
+HRESULT Unattended::initUnattended(VirtualBox *aParent)
+{
+ LogFlowThisFunc(("aParent=%p\n", aParent));
+ ComAssertRet(aParent, E_INVALIDARG);
+
+ /* Enclose the state transition NotReady->InInit->Ready */
+ AutoInitSpan autoInitSpan(this);
+ AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+ unconst(mParent) = aParent;
+
+ /*
+ * Fill public attributes (IUnattended) with useful defaults.
+ */
+ try
+ {
+ mStrUser = "vboxuser";
+ mStrPassword = "changeme";
+ mfInstallGuestAdditions = false;
+ mfInstallTestExecService = false;
+ midxImage = 1;
+
+ HRESULT hrc = mParent->i_getSystemProperties()->i_getDefaultAdditionsISO(mStrAdditionsIsoPath);
+ ComAssertComRCRet(hrc, hrc);
+ }
+ catch (std::bad_alloc &)
+ {
+ return E_OUTOFMEMORY;
+ }
+
+ /*
+ * Confirm a successful initialization
+ */
+ autoInitSpan.setSucceeded();
+
+ return S_OK;
+}
+
+HRESULT Unattended::detectIsoOS()
+{
+ HRESULT hrc;
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+/** @todo once UDF is implemented properly and we've tested this code a lot
+ * more, replace E_NOTIMPL with E_FAIL. */
+
+ /*
+ * Reset output state before we start
+ */
+ mStrDetectedOSTypeId.setNull();
+ mStrDetectedOSVersion.setNull();
+ mStrDetectedOSFlavor.setNull();
+ mDetectedOSLanguages.clear();
+ mStrDetectedOSHints.setNull();
+ mDetectedImages.clear();
+
+ /*
+ * Open the ISO.
+ */
+ RTVFSFILE hVfsFileIso;
+ int vrc = RTVfsFileOpenNormal(mStrIsoPath.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, &hVfsFileIso);
+ if (RT_FAILURE(vrc))
+ return setErrorBoth(E_NOTIMPL, vrc, tr("Failed to open '%s' (%Rrc)"), mStrIsoPath.c_str(), vrc);
+
+ RTERRINFOSTATIC ErrInfo;
+ RTVFS hVfsIso;
+ vrc = RTFsIso9660VolOpen(hVfsFileIso, 0 /*fFlags*/, &hVfsIso, RTErrInfoInitStatic(&ErrInfo));
+ if (RT_SUCCESS(vrc))
+ {
+ /*
+ * Try do the detection. Repeat for different file system variations (nojoliet, noudf).
+ */
+ hrc = i_innerDetectIsoOS(hVfsIso);
+
+ RTVfsRelease(hVfsIso);
+ if (hrc == S_FALSE) /** @todo Finish the linux and windows detection code. Only OS/2 returns S_OK right now. */
+ hrc = E_NOTIMPL;
+ }
+ else if (RTErrInfoIsSet(&ErrInfo.Core))
+ hrc = setErrorBoth(E_NOTIMPL, vrc, tr("Failed to open '%s' as ISO FS (%Rrc) - %s"),
+ mStrIsoPath.c_str(), vrc, ErrInfo.Core.pszMsg);
+ else
+ hrc = setErrorBoth(E_NOTIMPL, vrc, tr("Failed to open '%s' as ISO FS (%Rrc)"), mStrIsoPath.c_str(), vrc);
+ RTVfsFileRelease(hVfsFileIso);
+
+ /*
+ * Just fake up some windows installation media locale (for <UILanguage>).
+ * Note! The translation here isn't perfect. Feel free to send us a patch.
+ */
+ if (mDetectedOSLanguages.size() == 0)
+ {
+ char szTmp[16];
+ const char *pszFilename = RTPathFilename(mStrIsoPath.c_str());
+ if ( pszFilename
+ && RT_C_IS_ALPHA(pszFilename[0])
+ && RT_C_IS_ALPHA(pszFilename[1])
+ && (pszFilename[2] == '-' || pszFilename[2] == '_') )
+ {
+ szTmp[0] = (char)RT_C_TO_LOWER(pszFilename[0]);
+ szTmp[1] = (char)RT_C_TO_LOWER(pszFilename[1]);
+ szTmp[2] = '-';
+ if (szTmp[0] == 'e' && szTmp[1] == 'n')
+ strcpy(&szTmp[3], "US");
+ else if (szTmp[0] == 'a' && szTmp[1] == 'r')
+ strcpy(&szTmp[3], "SA");
+ else if (szTmp[0] == 'd' && szTmp[1] == 'a')
+ strcpy(&szTmp[3], "DK");
+ else if (szTmp[0] == 'e' && szTmp[1] == 't')
+ strcpy(&szTmp[3], "EE");
+ else if (szTmp[0] == 'e' && szTmp[1] == 'l')
+ strcpy(&szTmp[3], "GR");
+ else if (szTmp[0] == 'h' && szTmp[1] == 'e')
+ strcpy(&szTmp[3], "IL");
+ else if (szTmp[0] == 'j' && szTmp[1] == 'a')
+ strcpy(&szTmp[3], "JP");
+ else if (szTmp[0] == 's' && szTmp[1] == 'v')
+ strcpy(&szTmp[3], "SE");
+ else if (szTmp[0] == 'u' && szTmp[1] == 'k')
+ strcpy(&szTmp[3], "UA");
+ else if (szTmp[0] == 'c' && szTmp[1] == 's')
+ strcpy(szTmp, "cs-CZ");
+ else if (szTmp[0] == 'n' && szTmp[1] == 'o')
+ strcpy(szTmp, "nb-NO");
+ else if (szTmp[0] == 'p' && szTmp[1] == 'p')
+ strcpy(szTmp, "pt-PT");
+ else if (szTmp[0] == 'p' && szTmp[1] == 't')
+ strcpy(szTmp, "pt-BR");
+ else if (szTmp[0] == 'c' && szTmp[1] == 'n')
+ strcpy(szTmp, "zh-CN");
+ else if (szTmp[0] == 'h' && szTmp[1] == 'k')
+ strcpy(szTmp, "zh-HK");
+ else if (szTmp[0] == 't' && szTmp[1] == 'w')
+ strcpy(szTmp, "zh-TW");
+ else if (szTmp[0] == 's' && szTmp[1] == 'r')
+ strcpy(szTmp, "sr-Latn-CS"); /* hmm */
+ else
+ {
+ szTmp[3] = (char)RT_C_TO_UPPER(pszFilename[0]);
+ szTmp[4] = (char)RT_C_TO_UPPER(pszFilename[1]);
+ szTmp[5] = '\0';
+ }
+ }
+ else
+ strcpy(szTmp, "en-US");
+ try
+ {
+ mDetectedOSLanguages.append(szTmp);
+ }
+ catch (std::bad_alloc &)
+ {
+ return E_OUTOFMEMORY;
+ }
+ }
+
+ /** @todo implement actual detection logic. */
+ return hrc;
+}
+
+HRESULT Unattended::i_innerDetectIsoOS(RTVFS hVfsIso)
+{
+ DETECTBUFFER uBuf;
+ mEnmOsType = VBOXOSTYPE_Unknown;
+ HRESULT hrc = i_innerDetectIsoOSWindows(hVfsIso, &uBuf);
+ if (hrc == S_FALSE && mEnmOsType == VBOXOSTYPE_Unknown)
+ hrc = i_innerDetectIsoOSLinux(hVfsIso, &uBuf);
+ if (hrc == S_FALSE && mEnmOsType == VBOXOSTYPE_Unknown)
+ hrc = i_innerDetectIsoOSOs2(hVfsIso, &uBuf);
+ if (hrc == S_FALSE && mEnmOsType == VBOXOSTYPE_Unknown)
+ hrc = i_innerDetectIsoOSFreeBsd(hVfsIso, &uBuf);
+ if (mEnmOsType != VBOXOSTYPE_Unknown)
+ {
+ try { mStrDetectedOSTypeId = Global::OSTypeId(mEnmOsType); }
+ catch (std::bad_alloc &) { hrc = E_OUTOFMEMORY; }
+ }
+ return hrc;
+}
+
+/**
+ * Tries to parse a LANGUAGES element, with the following structure.
+ * @verbatim
+ * <LANGUAGES>
+ * <LANGUAGE>
+ * en-US
+ * </LANGUAGE>
+ * <DEFAULT>
+ * en-US
+ * </DEFAULT>
+ * </LANGUAGES>
+ * @endverbatim
+ *
+ * Will set mLanguages and mDefaultLanguage success.
+ *
+ * @param pElmLanguages Points to the LANGUAGES XML node.
+ * @param rImage Out reference to an WIMImage instance.
+ */
+static void parseLangaguesElement(const xml::ElementNode *pElmLanguages, WIMImage &rImage)
+{
+ /*
+ * The languages.
+ */
+ ElementNodesList children;
+ int cChildren = pElmLanguages->getChildElements(children, "LANGUAGE");
+ if (cChildren == 0)
+ cChildren = pElmLanguages->getChildElements(children, "language");
+ if (cChildren == 0)
+ cChildren = pElmLanguages->getChildElements(children, "Language");
+ for (ElementNodesList::iterator iterator = children.begin(); iterator != children.end(); ++iterator)
+ {
+ const ElementNode * const pElmLanguage = *(iterator);
+ if (pElmLanguage)
+ {
+ const char *pszValue = pElmLanguage->getValue();
+ if (pszValue && *pszValue != '\0')
+ rImage.mLanguages.append(pszValue);
+ }
+ }
+
+ /*
+ * Default language.
+ */
+ const xml::ElementNode *pElmDefault;
+ if ( (pElmDefault = pElmLanguages->findChildElement("DEFAULT")) != NULL
+ || (pElmDefault = pElmLanguages->findChildElement("default")) != NULL
+ || (pElmDefault = pElmLanguages->findChildElement("Default")) != NULL)
+ rImage.mDefaultLanguage = pElmDefault->getValue();
+}
+
+
+/**
+ * Tries to set the image architecture.
+ *
+ * Input examples (x86 and amd64 respectively):
+ * @verbatim
+ * <ARCH>0</ARCH>
+ * <ARCH>9</ARCH>
+ * @endverbatim
+ *
+ * Will set mArch and update mOSType on success.
+ *
+ * @param pElmArch Points to the ARCH XML node.
+ * @param rImage Out reference to an WIMImage instance.
+ */
+static void parseArchElement(const xml::ElementNode *pElmArch, WIMImage &rImage)
+{
+ /* These are from winnt.h */
+ static struct { const char *pszArch; VBOXOSTYPE enmArch; } s_aArches[] =
+ {
+ /* PROCESSOR_ARCHITECTURE_INTEL / [0] = */ { "x86", VBOXOSTYPE_x86 },
+ /* PROCESSOR_ARCHITECTURE_MIPS / [1] = */ { "mips", VBOXOSTYPE_UnknownArch },
+ /* PROCESSOR_ARCHITECTURE_ALPHA / [2] = */ { "alpha", VBOXOSTYPE_UnknownArch },
+ /* PROCESSOR_ARCHITECTURE_PPC / [3] = */ { "ppc", VBOXOSTYPE_UnknownArch },
+ /* PROCESSOR_ARCHITECTURE_SHX / [4] = */ { "shx", VBOXOSTYPE_UnknownArch },
+ /* PROCESSOR_ARCHITECTURE_ARM / [5] = */ { "arm32", VBOXOSTYPE_arm32 },
+ /* PROCESSOR_ARCHITECTURE_IA64 / [6] = */ { "ia64", VBOXOSTYPE_UnknownArch },
+ /* PROCESSOR_ARCHITECTURE_ALPHA64 / [7] = */ { "alpha64", VBOXOSTYPE_UnknownArch },
+ /* PROCESSOR_ARCHITECTURE_MSIL / [8] = */ { "msil", VBOXOSTYPE_UnknownArch },
+ /* PROCESSOR_ARCHITECTURE_AMD64 / [9] = */ { "x64", VBOXOSTYPE_x64 },
+ /* PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 / [10] = */ { "x86-on-x64", VBOXOSTYPE_UnknownArch },
+ /* PROCESSOR_ARCHITECTURE_NEUTRAL / [11] = */ { "noarch", VBOXOSTYPE_UnknownArch },
+ /* PROCESSOR_ARCHITECTURE_ARM64 / [12] = */ { "arm64", VBOXOSTYPE_arm64 },
+ /* PROCESSOR_ARCHITECTURE_ARM32_ON_WIN64/ [13] = */ { "arm32-on-arm64", VBOXOSTYPE_UnknownArch },
+ /* PROCESSOR_ARCHITECTURE_IA32_ON_ARM64 / [14] = */ { "x86-on-arm32", VBOXOSTYPE_UnknownArch },
+ };
+ const char *pszArch = pElmArch->getValue();
+ if (pszArch && *pszArch)
+ {
+ uint32_t uArch;
+ int vrc = RTStrToUInt32Ex(pszArch, NULL, 10 /*uBase*/, &uArch);
+ if ( RT_SUCCESS(vrc)
+ && vrc != VWRN_NUMBER_TOO_BIG
+ && vrc != VWRN_NEGATIVE_UNSIGNED
+ && uArch < RT_ELEMENTS(s_aArches))
+ {
+ rImage.mArch = s_aArches[uArch].pszArch;
+ rImage.mOSType = (VBOXOSTYPE)(s_aArches[uArch].enmArch | (rImage.mOSType & VBOXOSTYPE_OsTypeMask));
+ }
+ else
+ LogRel(("Unattended: bogus ARCH element value: '%s'\n", pszArch));
+ }
+}
+
+/**
+ * Parses XML Node assuming a structure as follows
+ * @verbatim
+ * <VERSION>
+ * <MAJOR>10</MAJOR>
+ * <MINOR>0</MINOR>
+ * <BUILD>19041</BUILD>
+ * <SPBUILD>1</SPBUILD>
+ * </VERSION>
+ * @endverbatim
+ *
+ * Will update mOSType, mEnmOsType as well as setting mVersion on success.
+ *
+ * @param pNode Points to the vesion XML node,
+ * @param image Out reference to an WIMImage instance.
+ */
+static void parseVersionElement(const xml::ElementNode *pNode, WIMImage &image)
+{
+ /* Major part: */
+ const xml::ElementNode *pElmMajor;
+ if ( (pElmMajor = pNode->findChildElement("MAJOR")) != NULL
+ || (pElmMajor = pNode->findChildElement("major")) != NULL
+ || (pElmMajor = pNode->findChildElement("Major")) != NULL)
+ if (pElmMajor)
+ {
+ const char * const pszMajor = pElmMajor->getValue();
+ if (pszMajor && *pszMajor)
+ {
+ /* Minor part: */
+ const ElementNode *pElmMinor;
+ if ( (pElmMinor = pNode->findChildElement("MINOR")) != NULL
+ || (pElmMinor = pNode->findChildElement("minor")) != NULL
+ || (pElmMinor = pNode->findChildElement("Minor")) != NULL)
+ {
+ const char * const pszMinor = pElmMinor->getValue();
+ if (pszMinor && *pszMinor)
+ {
+ /* Build: */
+ const ElementNode *pElmBuild;
+ if ( (pElmBuild = pNode->findChildElement("BUILD")) != NULL
+ || (pElmBuild = pNode->findChildElement("build")) != NULL
+ || (pElmBuild = pNode->findChildElement("Build")) != NULL)
+ {
+ const char * const pszBuild = pElmBuild->getValue();
+ if (pszBuild && *pszBuild)
+ {
+ /* SPBuild: */
+ const ElementNode *pElmSpBuild;
+ if ( ( (pElmSpBuild = pNode->findChildElement("SPBUILD")) != NULL
+ || (pElmSpBuild = pNode->findChildElement("spbuild")) != NULL
+ || (pElmSpBuild = pNode->findChildElement("Spbuild")) != NULL
+ || (pElmSpBuild = pNode->findChildElement("SpBuild")) != NULL)
+ && pElmSpBuild->getValue()
+ && *pElmSpBuild->getValue() != '\0')
+ image.mVersion.printf("%s.%s.%s.%s", pszMajor, pszMinor, pszBuild, pElmSpBuild->getValue());
+ else
+ image.mVersion.printf("%s.%s.%s", pszMajor, pszMinor, pszBuild);
+
+ /*
+ * Convert that to a version windows OS ID (newest first!).
+ */
+ image.mEnmOsType = VBOXOSTYPE_Unknown;
+ if (RTStrVersionCompare(image.mVersion.c_str(), "10.0.22000.0") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_Win11_x64;
+ else if (RTStrVersionCompare(image.mVersion.c_str(), "10.0") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_Win10;
+ else if (RTStrVersionCompare(image.mVersion.c_str(), "6.3") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_Win81;
+ else if (RTStrVersionCompare(image.mVersion.c_str(), "6.2") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_Win8;
+ else if (RTStrVersionCompare(image.mVersion.c_str(), "6.1") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_Win7;
+ else if (RTStrVersionCompare(image.mVersion.c_str(), "6.0") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_WinVista;
+ if (image.mFlavor.contains("server", Utf8Str::CaseInsensitive))
+ {
+ if (RTStrVersionCompare(image.mVersion.c_str(), "10.0.20348") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_Win2k22_x64;
+ else if (RTStrVersionCompare(image.mVersion.c_str(), "10.0.17763") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_Win2k19_x64;
+ else if (RTStrVersionCompare(image.mVersion.c_str(), "10.0") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_Win2k16_x64;
+ else if (RTStrVersionCompare(image.mVersion.c_str(), "6.2") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_Win2k12_x64;
+ else if (RTStrVersionCompare(image.mVersion.c_str(), "6.0") >= 0)
+ image.mEnmOsType = VBOXOSTYPE_Win2k8;
+ }
+ if (image.mEnmOsType != VBOXOSTYPE_Unknown)
+ image.mOSType = (VBOXOSTYPE)( (image.mOSType & VBOXOSTYPE_ArchitectureMask)
+ | (image.mEnmOsType & VBOXOSTYPE_OsTypeMask));
+ return;
+ }
+ }
+ }
+ }
+ }
+ }
+ Log(("Unattended: Warning! Bogus/missing version info for image #%u / %s\n", image.mImageIndex, image.mName.c_str()));
+}
+
+/**
+ * Parses XML tree assuming th following structure
+ * @verbatim
+ * <WIM>
+ * ...
+ * <IMAGE INDEX="1">
+ * ...
+ * <DISPLAYNAME>Windows 10 Home</DISPLAYNAME>
+ * <WINDOWS>
+ * <ARCH>NN</ARCH>
+ * <VERSION>
+ * ...
+ * </VERSION>
+ * <LANGUAGES>
+ * <LANGUAGE>
+ * en-US
+ * </LANGUAGE>
+ * <DEFAULT>
+ * en-US
+ * </DEFAULT>
+ * </LANGUAGES>
+ * </WINDOWS>
+ * </IMAGE>
+ * </WIM>
+ * @endverbatim
+ *
+ * @param pElmRoot Pointer to the root node of the tree,
+ * @param imageList Detected images are appended to this list.
+ */
+static void parseWimXMLData(const xml::ElementNode *pElmRoot, RTCList<WIMImage> &imageList)
+{
+ if (!pElmRoot)
+ return;
+
+ ElementNodesList children;
+ int cChildren = pElmRoot->getChildElements(children, "IMAGE");
+ if (cChildren == 0)
+ cChildren = pElmRoot->getChildElements(children, "image");
+ if (cChildren == 0)
+ cChildren = pElmRoot->getChildElements(children, "Image");
+
+ for (ElementNodesList::iterator iterator = children.begin(); iterator != children.end(); ++iterator)
+ {
+ const ElementNode *pChild = *(iterator);
+ if (!pChild)
+ continue;
+
+ WIMImage newImage;
+
+ if ( !pChild->getAttributeValue("INDEX", &newImage.mImageIndex)
+ && !pChild->getAttributeValue("index", &newImage.mImageIndex)
+ && !pChild->getAttributeValue("Index", &newImage.mImageIndex))
+ continue;
+
+ const ElementNode *pElmName;
+ if ( (pElmName = pChild->findChildElement("DISPLAYNAME")) == NULL
+ && (pElmName = pChild->findChildElement("displayname")) == NULL
+ && (pElmName = pChild->findChildElement("Displayname")) == NULL
+ && (pElmName = pChild->findChildElement("DisplayName")) == NULL
+ /* Early vista images didn't have DISPLAYNAME. */
+ && (pElmName = pChild->findChildElement("NAME")) == NULL
+ && (pElmName = pChild->findChildElement("name")) == NULL
+ && (pElmName = pChild->findChildElement("Name")) == NULL)
+ continue;
+ newImage.mName = pElmName->getValue();
+ if (newImage.mName.isEmpty())
+ continue;
+
+ const ElementNode *pElmWindows;
+ if ( (pElmWindows = pChild->findChildElement("WINDOWS")) != NULL
+ || (pElmWindows = pChild->findChildElement("windows")) != NULL
+ || (pElmWindows = pChild->findChildElement("Windows")) != NULL)
+ {
+ /* Do edition/flags before the version so it can better determin
+ the OS version enum value. Old windows version (vista) typically
+ doesn't have an EDITIONID element, so fall back on the FLAGS element
+ under IMAGE as it is pretty similar (case differences). */
+ const ElementNode *pElmEditionId;
+ if ( (pElmEditionId = pElmWindows->findChildElement("EDITIONID")) != NULL
+ || (pElmEditionId = pElmWindows->findChildElement("editionid")) != NULL
+ || (pElmEditionId = pElmWindows->findChildElement("Editionid")) != NULL
+ || (pElmEditionId = pElmWindows->findChildElement("EditionId")) != NULL
+ || (pElmEditionId = pChild->findChildElement("FLAGS")) != NULL
+ || (pElmEditionId = pChild->findChildElement("flags")) != NULL
+ || (pElmEditionId = pChild->findChildElement("Flags")) != NULL)
+ if ( pElmEditionId->getValue()
+ && *pElmEditionId->getValue() != '\0')
+ newImage.mFlavor = pElmEditionId->getValue();
+
+ const ElementNode *pElmVersion;
+ if ( (pElmVersion = pElmWindows->findChildElement("VERSION")) != NULL
+ || (pElmVersion = pElmWindows->findChildElement("version")) != NULL
+ || (pElmVersion = pElmWindows->findChildElement("Version")) != NULL)
+ parseVersionElement(pElmVersion, newImage);
+
+ /* The ARCH element contains a number from the
+ PROCESSOR_ARCHITECTURE_XXX set of defines in winnt.h: */
+ const ElementNode *pElmArch;
+ if ( (pElmArch = pElmWindows->findChildElement("ARCH")) != NULL
+ || (pElmArch = pElmWindows->findChildElement("arch")) != NULL
+ || (pElmArch = pElmWindows->findChildElement("Arch")) != NULL)
+ parseArchElement(pElmArch, newImage);
+
+ /* Extract languages and default language: */
+ const ElementNode *pElmLang;
+ if ( (pElmLang = pElmWindows->findChildElement("LANGUAGES")) != NULL
+ || (pElmLang = pElmWindows->findChildElement("languages")) != NULL
+ || (pElmLang = pElmWindows->findChildElement("Languages")) != NULL)
+ parseLangaguesElement(pElmLang, newImage);
+ }
+
+
+ imageList.append(newImage);
+ }
+}
+
+/**
+ * Detect Windows ISOs.
+ *
+ * @returns COM status code.
+ * @retval S_OK if detected
+ * @retval S_FALSE if not fully detected.
+ *
+ * @param hVfsIso The ISO file system.
+ * @param pBuf Read buffer.
+ */
+HRESULT Unattended::i_innerDetectIsoOSWindows(RTVFS hVfsIso, DETECTBUFFER *pBuf)
+{
+ /** @todo The 'sources/' path can differ. */
+
+ // globalinstallorder.xml - vista beta2
+ // sources/idwbinfo.txt - ditto.
+ // sources/lang.ini - ditto.
+
+ /*
+ * The install.wim file contains an XML document describing the install
+ * images it contains. This includes all the info we need for a successful
+ * detection.
+ */
+ RTVFSFILE hVfsFile;
+ int vrc = RTVfsFileOpen(hVfsIso, "sources/install.wim", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ WIMHEADERV1 header;
+ size_t cbRead = 0;
+ vrc = RTVfsFileRead(hVfsFile, &header, sizeof(header), &cbRead);
+ if (RT_SUCCESS(vrc) && cbRead == sizeof(header))
+ {
+ /* If the xml data is not compressed, xml data is not empty, and not too big. */
+ if ( (header.XmlData.bFlags & RESHDR_FLAGS_METADATA)
+ && !(header.XmlData.bFlags & RESHDR_FLAGS_COMPRESSED)
+ && header.XmlData.cbOriginal >= 32
+ && header.XmlData.cbOriginal < _32M
+ && header.XmlData.cbOriginal == header.XmlData.cb)
+ {
+ size_t const cbXmlData = (size_t)header.XmlData.cbOriginal;
+ char *pachXmlBuf = (char *)RTMemTmpAlloc(cbXmlData);
+ if (pachXmlBuf)
+ {
+ vrc = RTVfsFileReadAt(hVfsFile, (RTFOFF)header.XmlData.off, pachXmlBuf, cbXmlData, NULL);
+ if (RT_SUCCESS(vrc))
+ {
+ LogRel2(("XML Data (%#zx bytes):\n%32.*Rhxd\n", cbXmlData, cbXmlData, pachXmlBuf));
+
+ /* Parse the XML: */
+ xml::Document doc;
+ xml::XmlMemParser parser;
+ try
+ {
+ RTCString strFileName = "source/install.wim";
+ parser.read(pachXmlBuf, cbXmlData, strFileName, doc);
+ }
+ catch (xml::XmlError &rErr)
+ {
+ LogRel(("Unattended: An error has occured during XML parsing: %s\n", rErr.what()));
+ vrc = VERR_XAR_TOC_XML_PARSE_ERROR;
+ }
+ catch (std::bad_alloc &)
+ {
+ LogRel(("Unattended: std::bad_alloc\n"));
+ vrc = VERR_NO_MEMORY;
+ }
+ catch (...)
+ {
+ LogRel(("Unattended: An unknown error has occured during XML parsing.\n"));
+ vrc = VERR_UNEXPECTED_EXCEPTION;
+ }
+ if (RT_SUCCESS(vrc))
+ {
+ /* Extract the information we need from the XML document: */
+ xml::ElementNode *pElmRoot = doc.getRootElement();
+ if (pElmRoot)
+ {
+ Assert(mDetectedImages.size() == 0);
+ try
+ {
+ mDetectedImages.clear(); /* debugging convenience */
+ parseWimXMLData(pElmRoot, mDetectedImages);
+ }
+ catch (std::bad_alloc &)
+ {
+ vrc = VERR_NO_MEMORY;
+ }
+
+ /*
+ * If we found images, update the detected info attributes.
+ */
+ if (RT_SUCCESS(vrc) && mDetectedImages.size() > 0)
+ {
+ size_t i;
+ for (i = 0; i < mDetectedImages.size(); i++)
+ if (mDetectedImages[i].mImageIndex == midxImage)
+ break;
+ if (i >= mDetectedImages.size())
+ i = 0; /* use the first one if midxImage wasn't found */
+ if (i_updateDetectedAttributeForImage(mDetectedImages[i]))
+ {
+ LogRel2(("Unattended: happy with mDetectedImages[%u]\n", i));
+ mEnmOsType = mDetectedImages[i].mOSType;
+ return S_OK;
+ }
+ }
+ }
+ else
+ LogRel(("Unattended: No root element found in XML Metadata of install.wim\n"));
+ }
+ }
+ else
+ LogRel(("Unattended: Failed during reading XML Metadata out of install.wim\n"));
+ RTMemTmpFree(pachXmlBuf);
+ }
+ else
+ {
+ LogRel(("Unattended: Failed to allocate %#zx bytes for XML Metadata\n", cbXmlData));
+ vrc = VERR_NO_TMP_MEMORY;
+ }
+ }
+ else
+ LogRel(("Unattended: XML Metadata of install.wim is either compressed, empty, or too big (bFlags=%#x cbOriginal=%#RX64 cb=%#RX64)\n",
+ header.XmlData.bFlags, header.XmlData.cbOriginal, header.XmlData.cb));
+ }
+ RTVfsFileRelease(hVfsFile);
+
+ /* Bail out if we ran out of memory here. */
+ if (vrc == VERR_NO_MEMORY || vrc == VERR_NO_TMP_MEMORY)
+ return setErrorBoth(E_OUTOFMEMORY, vrc, tr("Out of memory"));
+ }
+
+ const char *pszVersion = NULL;
+ const char *pszProduct = NULL;
+ /*
+ * Try look for the 'sources/idwbinfo.txt' file containing windows build info.
+ * This file appeared with Vista beta 2 from what we can tell. Before windows 10
+ * it contains easily decodable branch names, after that things goes weird.
+ */
+ vrc = RTVfsFileOpen(hVfsIso, "sources/idwbinfo.txt", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ mEnmOsType = VBOXOSTYPE_WinNT_x64;
+
+ RTINIFILE hIniFile;
+ vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
+ RTVfsFileRelease(hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ vrc = RTIniFileQueryValue(hIniFile, "BUILDINFO", "BuildArch", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_SUCCESS(vrc))
+ {
+ LogRelFlow(("Unattended: sources/idwbinfo.txt: BuildArch=%s\n", pBuf->sz));
+ if ( RTStrNICmp(pBuf->sz, RT_STR_TUPLE("amd64")) == 0
+ || RTStrNICmp(pBuf->sz, RT_STR_TUPLE("x64")) == 0 /* just in case */ )
+ mEnmOsType = VBOXOSTYPE_WinNT_x64;
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("x86")) == 0)
+ mEnmOsType = VBOXOSTYPE_WinNT;
+ else
+ {
+ LogRel(("Unattended: sources/idwbinfo.txt: Unknown: BuildArch=%s\n", pBuf->sz));
+ mEnmOsType = VBOXOSTYPE_WinNT_x64;
+ }
+ }
+
+ vrc = RTIniFileQueryValue(hIniFile, "BUILDINFO", "BuildBranch", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_SUCCESS(vrc))
+ {
+ LogRelFlow(("Unattended: sources/idwbinfo.txt: BuildBranch=%s\n", pBuf->sz));
+ if ( RTStrNICmp(pBuf->sz, RT_STR_TUPLE("vista")) == 0
+ || RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winmain_beta")) == 0)
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_WinVista);
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("lh_sp2rtm")) == 0)
+ {
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_WinVista);
+ pszVersion = "sp2";
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("longhorn_rtm")) == 0)
+ {
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_WinVista);
+ pszVersion = "sp1";
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("win7")) == 0)
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win7);
+ else if ( RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winblue")) == 0
+ || RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winmain_blue")) == 0
+ || RTStrNICmp(pBuf->sz, RT_STR_TUPLE("win81")) == 0 /* not seen, but just in case its out there */ )
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win81);
+ else if ( RTStrNICmp(pBuf->sz, RT_STR_TUPLE("win8")) == 0
+ || RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winmain_win8")) == 0 )
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win8);
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("th1")) == 0)
+ {
+ pszVersion = "1507"; // aka. GA, retroactively 1507
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("th2")) == 0)
+ {
+ pszVersion = "1511"; // aka. threshold 2
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs1_release")) == 0)
+ {
+ pszVersion = "1607"; // aka. anniversay update; rs=redstone
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs2_release")) == 0)
+ {
+ pszVersion = "1703"; // aka. creators update
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs3_release")) == 0)
+ {
+ pszVersion = "1709"; // aka. fall creators update
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs4_release")) == 0)
+ {
+ pszVersion = "1803";
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs5_release")) == 0)
+ {
+ pszVersion = "1809";
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("19h1_release")) == 0)
+ {
+ pszVersion = "1903";
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("19h2_release")) == 0)
+ {
+ pszVersion = "1909"; // ??
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("20h1_release")) == 0)
+ {
+ pszVersion = "2003"; // ??
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("vb_release")) == 0)
+ {
+ pszVersion = "2004"; // ?? vb=Vibranium
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("20h2_release")) == 0)
+ {
+ pszVersion = "2009"; // ??
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("21h1_release")) == 0)
+ {
+ pszVersion = "2103"; // ??
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("21h2_release")) == 0)
+ {
+ pszVersion = "2109"; // ??
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win10);
+ }
+ else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("co_release")) == 0)
+ {
+ pszVersion = "21H2"; // ??
+ mEnmOsType = VBOXOSTYPE_Win11_x64;
+ }
+ else
+ LogRel(("Unattended: sources/idwbinfo.txt: Unknown: BuildBranch=%s\n", pBuf->sz));
+ }
+ RTIniFileRelease(hIniFile);
+ }
+ }
+ bool fClarifyProd = false;
+ if (RT_FAILURE(vrc))
+ {
+ /*
+ * Check a INF file with a DriverVer that is updated with each service pack.
+ * DriverVer=10/01/2002,5.2.3790.3959
+ */
+ vrc = RTVfsFileOpen(hVfsIso, "AMD64/HIVESYS.INF", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ mEnmOsType = VBOXOSTYPE_WinNT_x64;
+ else
+ {
+ vrc = RTVfsFileOpen(hVfsIso, "I386/HIVESYS.INF", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ mEnmOsType = VBOXOSTYPE_WinNT;
+ }
+ if (RT_SUCCESS(vrc))
+ {
+ RTINIFILE hIniFile;
+ vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
+ RTVfsFileRelease(hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ vrc = RTIniFileQueryValue(hIniFile, "Version", "DriverVer", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_SUCCESS(vrc))
+ {
+ LogRelFlow(("Unattended: HIVESYS.INF: DriverVer=%s\n", pBuf->sz));
+ const char *psz = strchr(pBuf->sz, ',');
+ psz = psz ? psz + 1 : pBuf->sz;
+ if (RTStrVersionCompare(psz, "6.0.0") >= 0)
+ LogRel(("Unattended: HIVESYS.INF: unknown: DriverVer=%s\n", psz));
+ else if (RTStrVersionCompare(psz, "5.2.0") >= 0) /* W2K3, XP64 */
+ {
+ fClarifyProd = true;
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win2k3);
+ if (RTStrVersionCompare(psz, "5.2.3790.3959") >= 0)
+ pszVersion = "sp2";
+ else if (RTStrVersionCompare(psz, "5.2.3790.1830") >= 0)
+ pszVersion = "sp1";
+ }
+ else if (RTStrVersionCompare(psz, "5.1.0") >= 0) /* XP */
+ {
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_WinXP);
+ if (RTStrVersionCompare(psz, "5.1.2600.5512") >= 0)
+ pszVersion = "sp3";
+ else if (RTStrVersionCompare(psz, "5.1.2600.2180") >= 0)
+ pszVersion = "sp2";
+ else if (RTStrVersionCompare(psz, "5.1.2600.1105") >= 0)
+ pszVersion = "sp1";
+ }
+ else if (RTStrVersionCompare(psz, "5.0.0") >= 0)
+ {
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win2k);
+ if (RTStrVersionCompare(psz, "5.0.2195.6717") >= 0)
+ pszVersion = "sp4";
+ else if (RTStrVersionCompare(psz, "5.0.2195.5438") >= 0)
+ pszVersion = "sp3";
+ else if (RTStrVersionCompare(psz, "5.0.2195.1620") >= 0)
+ pszVersion = "sp1";
+ }
+ else
+ LogRel(("Unattended: HIVESYS.INF: unknown: DriverVer=%s\n", psz));
+ }
+ RTIniFileRelease(hIniFile);
+ }
+ }
+ }
+ if (RT_FAILURE(vrc) || fClarifyProd)
+ {
+ /*
+ * NT 4 and older does not have DriverVer entries, we consult the PRODSPEC.INI, which
+ * works for NT4 & W2K. It does usually not reflect the service pack.
+ */
+ vrc = RTVfsFileOpen(hVfsIso, "AMD64/PRODSPEC.INI", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ mEnmOsType = VBOXOSTYPE_WinNT_x64;
+ else
+ {
+ vrc = RTVfsFileOpen(hVfsIso, "I386/PRODSPEC.INI", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ mEnmOsType = VBOXOSTYPE_WinNT;
+ }
+ if (RT_SUCCESS(vrc))
+ {
+
+ RTINIFILE hIniFile;
+ vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
+ RTVfsFileRelease(hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ vrc = RTIniFileQueryValue(hIniFile, "Product Specification", "Version", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_SUCCESS(vrc))
+ {
+ LogRelFlow(("Unattended: PRODSPEC.INI: Version=%s\n", pBuf->sz));
+ if (RTStrVersionCompare(pBuf->sz, "5.1") >= 0) /* Shipped with XP + W2K3, but version stuck at 5.0. */
+ LogRel(("Unattended: PRODSPEC.INI: unknown: DriverVer=%s\n", pBuf->sz));
+ else if (RTStrVersionCompare(pBuf->sz, "5.0") >= 0) /* 2000 */
+ {
+ vrc = RTIniFileQueryValue(hIniFile, "Product Specification", "Product", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_SUCCESS(vrc) && RTStrNICmp(pBuf->sz, RT_STR_TUPLE("Windows XP")) == 0)
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_WinXP);
+ else if (RT_SUCCESS(vrc) && RTStrNICmp(pBuf->sz, RT_STR_TUPLE("Windows Server 2003")) == 0)
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win2k3);
+ else
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Win2k);
+
+ if (RT_SUCCESS(vrc) && (strstr(pBuf->sz, "Server") || strstr(pBuf->sz, "server")))
+ pszProduct = "Server";
+ }
+ else if (RTStrVersionCompare(pBuf->sz, "4.0") >= 0) /* NT4 */
+ mEnmOsType = VBOXOSTYPE_WinNT4;
+ else
+ LogRel(("Unattended: PRODSPEC.INI: unknown: DriverVer=%s\n", pBuf->sz));
+
+ vrc = RTIniFileQueryValue(hIniFile, "Product Specification", "ProductType", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_SUCCESS(vrc))
+ pszProduct = strcmp(pBuf->sz, "0") == 0 ? "Workstation" : /* simplification: */ "Server";
+ }
+ RTIniFileRelease(hIniFile);
+ }
+ }
+ if (fClarifyProd)
+ vrc = VINF_SUCCESS;
+ }
+ if (RT_FAILURE(vrc))
+ {
+ /*
+ * NT 3.x we look at the LoadIdentifier (boot manager) string in TXTSETUP.SIF/TXT.
+ */
+ vrc = RTVfsFileOpen(hVfsIso, "I386/TXTSETUP.SIF", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_FAILURE(vrc))
+ vrc = RTVfsFileOpen(hVfsIso, "I386/TXTSETUP.INF", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ mEnmOsType = VBOXOSTYPE_WinNT;
+
+ RTINIFILE hIniFile;
+ vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
+ RTVfsFileRelease(hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ vrc = RTIniFileQueryValue(hIniFile, "SetupData", "ProductType", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_SUCCESS(vrc))
+ pszProduct = strcmp(pBuf->sz, "0") == 0 ? "Workstation" : /* simplification: */ "Server";
+
+ vrc = RTIniFileQueryValue(hIniFile, "SetupData", "LoadIdentifier", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_SUCCESS(vrc))
+ {
+ LogRelFlow(("Unattended: TXTSETUP.SIF: LoadIdentifier=%s\n", pBuf->sz));
+ char *psz = pBuf->sz;
+ while (!RT_C_IS_DIGIT(*psz) && *psz)
+ psz++;
+ char *psz2 = psz;
+ while (RT_C_IS_DIGIT(*psz2) || *psz2 == '.')
+ psz2++;
+ *psz2 = '\0';
+ if (RTStrVersionCompare(psz, "6.0") >= 0)
+ LogRel(("Unattended: TXTSETUP.SIF: unknown: LoadIdentifier=%s\n", pBuf->sz));
+ else if (RTStrVersionCompare(psz, "4.0") >= 0)
+ mEnmOsType = VBOXOSTYPE_WinNT4;
+ else if (RTStrVersionCompare(psz, "3.1") >= 0)
+ {
+ mEnmOsType = VBOXOSTYPE_WinNT3x;
+ pszVersion = psz;
+ }
+ else
+ LogRel(("Unattended: TXTSETUP.SIF: unknown: LoadIdentifier=%s\n", pBuf->sz));
+ }
+ RTIniFileRelease(hIniFile);
+ }
+ }
+ }
+
+ if (pszVersion)
+ try { mStrDetectedOSVersion = pszVersion; }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+ if (pszProduct)
+ try { mStrDetectedOSFlavor = pszProduct; }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+
+ /*
+ * Look for sources/lang.ini and try parse it to get the languages out of it.
+ */
+ /** @todo We could also check sources/??-* and boot/??-* if lang.ini is not
+ * found or unhelpful. */
+ vrc = RTVfsFileOpen(hVfsIso, "sources/lang.ini", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ RTINIFILE hIniFile;
+ vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
+ RTVfsFileRelease(hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ mDetectedOSLanguages.clear();
+
+ uint32_t idxPair;
+ for (idxPair = 0; idxPair < 256; idxPair++)
+ {
+ size_t cbHalf = sizeof(*pBuf) / 2;
+ char *pszKey = pBuf->sz;
+ char *pszValue = &pBuf->sz[cbHalf];
+ vrc = RTIniFileQueryPair(hIniFile, "Available UI Languages", idxPair,
+ pszKey, cbHalf, NULL, pszValue, cbHalf, NULL);
+ if (RT_SUCCESS(vrc))
+ {
+ try
+ {
+ mDetectedOSLanguages.append(pszKey);
+ }
+ catch (std::bad_alloc &)
+ {
+ RTIniFileRelease(hIniFile);
+ return E_OUTOFMEMORY;
+ }
+ }
+ else if (vrc == VERR_NOT_FOUND)
+ break;
+ else
+ Assert(vrc == VERR_BUFFER_OVERFLOW);
+ }
+ if (idxPair == 0)
+ LogRel(("Unattended: Warning! Empty 'Available UI Languages' section in sources/lang.ini\n"));
+ RTIniFileRelease(hIniFile);
+ }
+ }
+
+ return S_FALSE;
+}
+
+/**
+ * Architecture strings for Linux and the like.
+ */
+static struct { const char *pszArch; uint32_t cchArch; VBOXOSTYPE fArch; } const g_aLinuxArches[] =
+{
+ { RT_STR_TUPLE("amd64"), VBOXOSTYPE_x64 },
+ { RT_STR_TUPLE("x86_64"), VBOXOSTYPE_x64 },
+ { RT_STR_TUPLE("x86-64"), VBOXOSTYPE_x64 }, /* just in case */
+ { RT_STR_TUPLE("x64"), VBOXOSTYPE_x64 }, /* ditto */
+
+ { RT_STR_TUPLE("x86"), VBOXOSTYPE_x86 },
+ { RT_STR_TUPLE("i386"), VBOXOSTYPE_x86 },
+ { RT_STR_TUPLE("i486"), VBOXOSTYPE_x86 },
+ { RT_STR_TUPLE("i586"), VBOXOSTYPE_x86 },
+ { RT_STR_TUPLE("i686"), VBOXOSTYPE_x86 },
+ { RT_STR_TUPLE("i786"), VBOXOSTYPE_x86 },
+ { RT_STR_TUPLE("i886"), VBOXOSTYPE_x86 },
+ { RT_STR_TUPLE("i986"), VBOXOSTYPE_x86 },
+};
+
+/**
+ * Detects linux architecture.
+ *
+ * @returns true if detected, false if not.
+ * @param pszArch The architecture string.
+ * @param penmOsType Where to return the arch and type on success.
+ * @param enmBaseOsType The base (x86) OS type to return.
+ */
+static bool detectLinuxArch(const char *pszArch, VBOXOSTYPE *penmOsType, VBOXOSTYPE enmBaseOsType)
+{
+ for (size_t i = 0; i < RT_ELEMENTS(g_aLinuxArches); i++)
+ if (RTStrNICmp(pszArch, g_aLinuxArches[i].pszArch, g_aLinuxArches[i].cchArch) == 0)
+ {
+ *penmOsType = (VBOXOSTYPE)(enmBaseOsType | g_aLinuxArches[i].fArch);
+ return true;
+ }
+ /** @todo check for 'noarch' since source CDs have been seen to use that. */
+ return false;
+}
+
+/**
+ * Detects linux architecture by searching for the architecture substring in @p pszArch.
+ *
+ * @returns true if detected, false if not.
+ * @param pszArch The architecture string.
+ * @param penmOsType Where to return the arch and type on success.
+ * @param enmBaseOsType The base (x86) OS type to return.
+ * @param ppszHit Where to return the pointer to the architecture
+ * specifier. Optional.
+ * @param ppszNext Where to return the pointer to the char
+ * following the architecuture specifier. Optional.
+ */
+static bool detectLinuxArchII(const char *pszArch, VBOXOSTYPE *penmOsType, VBOXOSTYPE enmBaseOsType,
+ char **ppszHit = NULL, char **ppszNext = NULL)
+{
+ for (size_t i = 0; i < RT_ELEMENTS(g_aLinuxArches); i++)
+ {
+ const char *pszHit = RTStrIStr(pszArch, g_aLinuxArches[i].pszArch);
+ if (pszHit != NULL)
+ {
+ if (ppszHit)
+ *ppszHit = (char *)pszHit;
+ if (ppszNext)
+ *ppszNext = (char *)pszHit + g_aLinuxArches[i].cchArch;
+ *penmOsType = (VBOXOSTYPE)(enmBaseOsType | g_aLinuxArches[i].fArch);
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool detectLinuxDistroName(const char *pszOsAndVersion, VBOXOSTYPE *penmOsType, const char **ppszNext)
+{
+ bool fRet = true;
+
+ if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Red")) == 0
+ && !RT_C_IS_ALNUM(pszOsAndVersion[3]))
+
+ {
+ pszOsAndVersion = RTStrStripL(pszOsAndVersion + 3);
+ if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Hat")) == 0
+ && !RT_C_IS_ALNUM(pszOsAndVersion[3]))
+ {
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_RedHat);
+ pszOsAndVersion = RTStrStripL(pszOsAndVersion + 3);
+ }
+ else
+ fRet = false;
+ }
+ else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("OpenSUSE")) == 0
+ && !RT_C_IS_ALNUM(pszOsAndVersion[8]))
+ {
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_OpenSUSE);
+ pszOsAndVersion = RTStrStripL(pszOsAndVersion + 8);
+ }
+ else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Oracle")) == 0
+ && !RT_C_IS_ALNUM(pszOsAndVersion[6]))
+ {
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Oracle);
+ pszOsAndVersion = RTStrStripL(pszOsAndVersion + 6);
+ }
+ else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("CentOS")) == 0
+ && !RT_C_IS_ALNUM(pszOsAndVersion[6]))
+ {
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_RedHat);
+ pszOsAndVersion = RTStrStripL(pszOsAndVersion + 6);
+ }
+ else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Fedora")) == 0
+ && !RT_C_IS_ALNUM(pszOsAndVersion[6]))
+ {
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_FedoraCore);
+ pszOsAndVersion = RTStrStripL(pszOsAndVersion + 6);
+ }
+ else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Ubuntu")) == 0
+ && !RT_C_IS_ALNUM(pszOsAndVersion[6]))
+ {
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Ubuntu);
+ pszOsAndVersion = RTStrStripL(pszOsAndVersion + 6);
+ }
+ else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Linux Mint")) == 0
+ && !RT_C_IS_ALNUM(pszOsAndVersion[10]))
+ {
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Ubuntu);
+ pszOsAndVersion = RTStrStripL(pszOsAndVersion + 10);
+ }
+ else if ( ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Xubuntu")) == 0
+ || RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Kubuntu")) == 0
+ || RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Lubuntu")) == 0)
+ && !RT_C_IS_ALNUM(pszOsAndVersion[7]))
+ {
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Ubuntu);
+ pszOsAndVersion = RTStrStripL(pszOsAndVersion + 7);
+ }
+ else if ( RTStrNICmp(pszOsAndVersion, RT_STR_TUPLE("Debian")) == 0
+ && !RT_C_IS_ALNUM(pszOsAndVersion[6]))
+ {
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Debian);
+ pszOsAndVersion = RTStrStripL(pszOsAndVersion + 6);
+ }
+ else
+ fRet = false;
+
+ /*
+ * Skip forward till we get a number.
+ */
+ if (ppszNext)
+ {
+ *ppszNext = pszOsAndVersion;
+ char ch;
+ for (const char *pszVersion = pszOsAndVersion; (ch = *pszVersion) != '\0'; pszVersion++)
+ if (RT_C_IS_DIGIT(ch))
+ {
+ *ppszNext = pszVersion;
+ break;
+ }
+ }
+ return fRet;
+}
+
+static bool detectLinuxDistroNameII(const char *pszOsAndVersion, VBOXOSTYPE *penmOsType, const char **ppszNext)
+{
+ bool fRet = true;
+ if ( RTStrIStr(pszOsAndVersion, "RedHat") != NULL
+ || RTStrIStr(pszOsAndVersion, "Red Hat") != NULL)
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_RedHat);
+ else if (RTStrIStr(pszOsAndVersion, "Oracle") != NULL)
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Oracle);
+ else if (RTStrIStr(pszOsAndVersion, "CentOS") != NULL)
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_RedHat);
+ else if (RTStrIStr(pszOsAndVersion, "Fedora") != NULL)
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_FedoraCore);
+ else if (RTStrIStr(pszOsAndVersion, "Ubuntu") != NULL)
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Ubuntu);
+ else if (RTStrIStr(pszOsAndVersion, "Mint") != NULL)
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Ubuntu);
+ else if (RTStrIStr(pszOsAndVersion, "Debian"))
+ *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_Debian);
+ else
+ fRet = false;
+
+ /*
+ * Skip forward till we get a number.
+ */
+ if (ppszNext)
+ {
+ *ppszNext = pszOsAndVersion;
+ char ch;
+ for (const char *pszVersion = pszOsAndVersion; (ch = *pszVersion) != '\0'; pszVersion++)
+ if (RT_C_IS_DIGIT(ch))
+ {
+ *ppszNext = pszVersion;
+ break;
+ }
+ }
+ return fRet;
+}
+
+
+/**
+ * Helps detecting linux distro flavor by finding substring position of non numerical
+ * part of the disk name.
+ *
+ * @returns true if detected, false if not.
+ * @param pszDiskName Name of the disk as it is read from .disk/info or
+ * README.diskdefines file.
+ * @param poffVersion String position where first numerical character is
+ * found. We use substring upto this position as OS flavor
+ */
+static bool detectLinuxDistroFlavor(const char *pszDiskName, size_t *poffVersion)
+{
+ Assert(poffVersion);
+ if (!pszDiskName)
+ return false;
+ char ch;
+ while ((ch = *pszDiskName) != '\0' && !RT_C_IS_DIGIT(ch))
+ {
+ ++pszDiskName;
+ *poffVersion += 1;
+ }
+ return true;
+}
+
+/**
+ * Detect Linux distro ISOs.
+ *
+ * @returns COM status code.
+ * @retval S_OK if detected
+ * @retval S_FALSE if not fully detected.
+ *
+ * @param hVfsIso The ISO file system.
+ * @param pBuf Read buffer.
+ */
+HRESULT Unattended::i_innerDetectIsoOSLinux(RTVFS hVfsIso, DETECTBUFFER *pBuf)
+{
+ /*
+ * Redhat and derivatives may have a .treeinfo (ini-file style) with useful info
+ * or at least a barebone .discinfo file.
+ */
+
+ /*
+ * Start with .treeinfo: https://release-engineering.github.io/productmd/treeinfo-1.0.html
+ */
+ RTVFSFILE hVfsFile;
+ int vrc = RTVfsFileOpen(hVfsIso, ".treeinfo", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ RTINIFILE hIniFile;
+ vrc = RTIniFileCreateFromVfsFile(&hIniFile, hVfsFile, RTINIFILE_F_READONLY);
+ RTVfsFileRelease(hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ /* Try figure the architecture first (like with windows). */
+ vrc = RTIniFileQueryValue(hIniFile, "tree", "arch", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_FAILURE(vrc) || !pBuf->sz[0])
+ vrc = RTIniFileQueryValue(hIniFile, "general", "arch", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_FAILURE(vrc))
+ LogRel(("Unattended: .treeinfo: No 'arch' property.\n"));
+ else
+ {
+ LogRelFlow(("Unattended: .treeinfo: arch=%s\n", pBuf->sz));
+ if (detectLinuxArch(pBuf->sz, &mEnmOsType, VBOXOSTYPE_RedHat))
+ {
+ /* Try figure the release name, it doesn't have to be redhat. */
+ vrc = RTIniFileQueryValue(hIniFile, "release", "name", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_FAILURE(vrc) || !pBuf->sz[0])
+ vrc = RTIniFileQueryValue(hIniFile, "product", "name", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_FAILURE(vrc) || !pBuf->sz[0])
+ vrc = RTIniFileQueryValue(hIniFile, "general", "family", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_SUCCESS(vrc))
+ {
+ LogRelFlow(("Unattended: .treeinfo: name/family=%s\n", pBuf->sz));
+ if (!detectLinuxDistroName(pBuf->sz, &mEnmOsType, NULL))
+ {
+ LogRel(("Unattended: .treeinfo: Unknown: name/family='%s', assuming Red Hat\n", pBuf->sz));
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_RedHat);
+ }
+ }
+
+ /* Try figure the version. */
+ vrc = RTIniFileQueryValue(hIniFile, "release", "version", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_FAILURE(vrc) || !pBuf->sz[0])
+ vrc = RTIniFileQueryValue(hIniFile, "product", "version", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_FAILURE(vrc) || !pBuf->sz[0])
+ vrc = RTIniFileQueryValue(hIniFile, "general", "version", pBuf->sz, sizeof(*pBuf), NULL);
+ if (RT_SUCCESS(vrc))
+ {
+ LogRelFlow(("Unattended: .treeinfo: version=%s\n", pBuf->sz));
+ try { mStrDetectedOSVersion = RTStrStrip(pBuf->sz); }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+
+ size_t cchVersionPosition = 0;
+ if (detectLinuxDistroFlavor(pBuf->sz, &cchVersionPosition))
+ {
+ try { mStrDetectedOSFlavor = Utf8Str(pBuf->sz, cchVersionPosition); }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+ }
+ }
+ }
+ else
+ LogRel(("Unattended: .treeinfo: Unknown: arch='%s'\n", pBuf->sz));
+ }
+
+ RTIniFileRelease(hIniFile);
+ }
+
+ if (mEnmOsType != VBOXOSTYPE_Unknown)
+ return S_FALSE;
+ }
+
+ /*
+ * Try .discinfo next: https://release-engineering.github.io/productmd/discinfo-1.0.html
+ * We will probably need additional info here...
+ */
+ vrc = RTVfsFileOpen(hVfsIso, ".discinfo", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ size_t cchIgn;
+ vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(*pBuf) - 1, &cchIgn);
+ pBuf->sz[RT_SUCCESS(vrc) ? cchIgn : 0] = '\0';
+ RTVfsFileRelease(hVfsFile);
+
+ /* Parse and strip the first 5 lines. */
+ const char *apszLines[5];
+ char *psz = pBuf->sz;
+ for (unsigned i = 0; i < RT_ELEMENTS(apszLines); i++)
+ {
+ apszLines[i] = psz;
+ if (*psz)
+ {
+ char *pszEol = (char *)strchr(psz, '\n');
+ if (!pszEol)
+ psz = strchr(psz, '\0');
+ else
+ {
+ *pszEol = '\0';
+ apszLines[i] = RTStrStrip(psz);
+ psz = pszEol + 1;
+ }
+ }
+ }
+
+ /* Do we recognize the architecture? */
+ LogRelFlow(("Unattended: .discinfo: arch=%s\n", apszLines[2]));
+ if (detectLinuxArch(apszLines[2], &mEnmOsType, VBOXOSTYPE_RedHat))
+ {
+ /* Do we recognize the release string? */
+ LogRelFlow(("Unattended: .discinfo: product+version=%s\n", apszLines[1]));
+ const char *pszVersion = NULL;
+ if (!detectLinuxDistroName(apszLines[1], &mEnmOsType, &pszVersion))
+ LogRel(("Unattended: .discinfo: Unknown: release='%s'\n", apszLines[1]));
+
+ if (*pszVersion)
+ {
+ LogRelFlow(("Unattended: .discinfo: version=%s\n", pszVersion));
+ try { mStrDetectedOSVersion = RTStrStripL(pszVersion); }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+
+ /* CentOS likes to call their release 'Final' without mentioning the actual version
+ number (e.g. CentOS-4.7-x86_64-binDVD.iso), so we need to go look elsewhere.
+ This is only important for centos 4.x and 3.x releases. */
+ if (RTStrNICmp(pszVersion, RT_STR_TUPLE("Final")) == 0)
+ {
+ static const char * const s_apszDirs[] = { "CentOS/RPMS/", "RedHat/RPMS", "Server", "Workstation" };
+ for (unsigned iDir = 0; iDir < RT_ELEMENTS(s_apszDirs); iDir++)
+ {
+ RTVFSDIR hVfsDir;
+ vrc = RTVfsDirOpen(hVfsIso, s_apszDirs[iDir], 0, &hVfsDir);
+ if (RT_FAILURE(vrc))
+ continue;
+ char szRpmDb[128];
+ char szReleaseRpm[128];
+ szRpmDb[0] = '\0';
+ szReleaseRpm[0] = '\0';
+ for (;;)
+ {
+ RTDIRENTRYEX DirEntry;
+ size_t cbDirEntry = sizeof(DirEntry);
+ vrc = RTVfsDirReadEx(hVfsDir, &DirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING);
+ if (RT_FAILURE(vrc))
+ break;
+
+ /* redhat-release-4WS-2.4.i386.rpm
+ centos-release-4-7.x86_64.rpm, centos-release-4-4.3.i386.rpm
+ centos-release-5-3.el5.centos.1.x86_64.rpm */
+ if ( (psz = strstr(DirEntry.szName, "-release-")) != NULL
+ || (psz = strstr(DirEntry.szName, "-RELEASE-")) != NULL)
+ {
+ psz += 9;
+ if (RT_C_IS_DIGIT(*psz))
+ RTStrCopy(szReleaseRpm, sizeof(szReleaseRpm), psz);
+ }
+ /* rpmdb-redhat-4WS-2.4.i386.rpm,
+ rpmdb-CentOS-4.5-0.20070506.i386.rpm,
+ rpmdb-redhat-3.9-0.20070703.i386.rpm. */
+ else if ( ( RTStrStartsWith(DirEntry.szName, "rpmdb-")
+ || RTStrStartsWith(DirEntry.szName, "RPMDB-"))
+ && RT_C_IS_DIGIT(DirEntry.szName[6]) )
+ RTStrCopy(szRpmDb, sizeof(szRpmDb), &DirEntry.szName[6]);
+ }
+ RTVfsDirRelease(hVfsDir);
+
+ /* Did we find anything relvant? */
+ psz = szRpmDb;
+ if (!RT_C_IS_DIGIT(*psz))
+ psz = szReleaseRpm;
+ if (RT_C_IS_DIGIT(*psz))
+ {
+ /* Convert '-' to '.' and strip stuff which doesn't look like a version string. */
+ char *pszCur = psz + 1;
+ for (char ch = *pszCur; ch != '\0'; ch = *++pszCur)
+ if (ch == '-')
+ *pszCur = '.';
+ else if (ch != '.' && !RT_C_IS_DIGIT(ch))
+ {
+ *pszCur = '\0';
+ break;
+ }
+ while (&pszCur[-1] != psz && pszCur[-1] == '.')
+ *--pszCur = '\0';
+
+ /* Set it and stop looking. */
+ try { mStrDetectedOSVersion = psz; }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+ break;
+ }
+ }
+ }
+ }
+ size_t cchVersionPosition = 0;
+ if (detectLinuxDistroFlavor(apszLines[1], &cchVersionPosition))
+ {
+ try { mStrDetectedOSFlavor = Utf8Str(apszLines[1], cchVersionPosition); }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+ }
+ }
+ else
+ LogRel(("Unattended: .discinfo: Unknown: arch='%s'\n", apszLines[2]));
+
+ if (mEnmOsType != VBOXOSTYPE_Unknown)
+ return S_FALSE;
+ }
+
+ /*
+ * Ubuntu has a README.diskdefines file on their ISO (already on 4.10 / warty warthog).
+ * Example content:
+ * #define DISKNAME Ubuntu 4.10 "Warty Warthog" - Preview amd64 Binary-1
+ * #define TYPE binary
+ * #define TYPEbinary 1
+ * #define ARCH amd64
+ * #define ARCHamd64 1
+ * #define DISKNUM 1
+ * #define DISKNUM1 1
+ * #define TOTALNUM 1
+ * #define TOTALNUM1 1
+ */
+ vrc = RTVfsFileOpen(hVfsIso, "README.diskdefines", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ size_t cchIgn;
+ vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(*pBuf) - 1, &cchIgn);
+ pBuf->sz[RT_SUCCESS(vrc) ? cchIgn : 0] = '\0';
+ RTVfsFileRelease(hVfsFile);
+
+ /* Find the DISKNAME and ARCH defines. */
+ const char *pszDiskName = NULL;
+ const char *pszArch = NULL;
+ char *psz = pBuf->sz;
+ for (unsigned i = 0; *psz != '\0'; i++)
+ {
+ while (RT_C_IS_BLANK(*psz))
+ psz++;
+
+ /* Match #define: */
+ static const char s_szDefine[] = "#define";
+ if ( strncmp(psz, s_szDefine, sizeof(s_szDefine) - 1) == 0
+ && RT_C_IS_BLANK(psz[sizeof(s_szDefine) - 1]))
+ {
+ psz = &psz[sizeof(s_szDefine) - 1];
+ while (RT_C_IS_BLANK(*psz))
+ psz++;
+
+ /* Match the identifier: */
+ char *pszIdentifier = psz;
+ if (RT_C_IS_ALPHA(*psz) || *psz == '_')
+ {
+ do
+ psz++;
+ while (RT_C_IS_ALNUM(*psz) || *psz == '_');
+ size_t cchIdentifier = (size_t)(psz - pszIdentifier);
+
+ /* Skip to the value. */
+ while (RT_C_IS_BLANK(*psz))
+ psz++;
+ char *pszValue = psz;
+
+ /* Skip to EOL and strip the value. */
+ char *pszEol = psz = strchr(psz, '\n');
+ if (psz)
+ *psz++ = '\0';
+ else
+ pszEol = strchr(pszValue, '\0');
+ while (pszEol > pszValue && RT_C_IS_SPACE(pszEol[-1]))
+ *--pszEol = '\0';
+
+ LogRelFlow(("Unattended: README.diskdefines: %.*s=%s\n", cchIdentifier, pszIdentifier, pszValue));
+
+ /* Do identifier matching: */
+ if (cchIdentifier == sizeof("DISKNAME") - 1 && strncmp(pszIdentifier, RT_STR_TUPLE("DISKNAME")) == 0)
+ pszDiskName = pszValue;
+ else if (cchIdentifier == sizeof("ARCH") - 1 && strncmp(pszIdentifier, RT_STR_TUPLE("ARCH")) == 0)
+ pszArch = pszValue;
+ else
+ continue;
+ if (pszDiskName == NULL || pszArch == NULL)
+ continue;
+ break;
+ }
+ }
+
+ /* Next line: */
+ psz = strchr(psz, '\n');
+ if (!psz)
+ break;
+ psz++;
+ }
+
+ /* Did we find both of them? */
+ if (pszDiskName && pszArch)
+ {
+ if (detectLinuxArch(pszArch, &mEnmOsType, VBOXOSTYPE_Ubuntu))
+ {
+ const char *pszVersion = NULL;
+ if (detectLinuxDistroName(pszDiskName, &mEnmOsType, &pszVersion))
+ {
+ LogRelFlow(("Unattended: README.diskdefines: version=%s\n", pszVersion));
+ try { mStrDetectedOSVersion = RTStrStripL(pszVersion); }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+
+ size_t cchVersionPosition = 0;
+ if (detectLinuxDistroFlavor(pszDiskName, &cchVersionPosition))
+ {
+ try { mStrDetectedOSFlavor = Utf8Str(pszDiskName, cchVersionPosition); }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+ }
+ }
+ else
+ LogRel(("Unattended: README.diskdefines: Unknown: diskname='%s'\n", pszDiskName));
+ }
+ else
+ LogRel(("Unattended: README.diskdefines: Unknown: arch='%s'\n", pszArch));
+ }
+ else
+ LogRel(("Unattended: README.diskdefines: Did not find both DISKNAME and ARCH. :-/\n"));
+
+ if (mEnmOsType != VBOXOSTYPE_Unknown)
+ return S_FALSE;
+ }
+
+ /*
+ * All of the debian based distro versions I checked have a single line ./disk/info
+ * file. Only info I could find related to .disk folder is:
+ * https://lists.debian.org/debian-cd/2004/01/msg00069.html
+ *
+ * Some example content from several install ISOs is as follows:
+ * Ubuntu 4.10 "Warty Warthog" - Preview amd64 Binary-1 (20041020)
+ * Linux Mint 20.3 "Una" - Release amd64 20220104
+ * Debian GNU/Linux 11.2.0 "Bullseye" - Official amd64 NETINST 20211218-11:12
+ * Debian GNU/Linux 9.13.0 "Stretch" - Official amd64 DVD Binary-1 20200718-11:07
+ * Xubuntu 20.04.2.0 LTS "Focal Fossa" - Release amd64 (20210209.1)
+ * Ubuntu 17.10 "Artful Aardvark" - Release amd64 (20180105.1)
+ * Ubuntu 16.04.6 LTS "Xenial Xerus" - Release i386 (20190227.1)
+ * Debian GNU/Linux 8.11.1 "Jessie" - Official amd64 CD Binary-1 20190211-02:10
+ * Kali GNU/Linux 2021.3a "Kali-last-snapshot" - Official amd64 BD Binary-1 with firmware 20211015-16:55
+ * Official Debian GNU/Linux Live 10.10.0 cinnamon 2021-06-19T12:13
+ */
+ vrc = RTVfsFileOpen(hVfsIso, ".disk/info", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ size_t cchIgn;
+ vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(*pBuf) - 1, &cchIgn);
+ pBuf->sz[RT_SUCCESS(vrc) ? cchIgn : 0] = '\0';
+
+ pBuf->sz[sizeof(*pBuf) - 1] = '\0';
+ RTVfsFileRelease(hVfsFile);
+
+ char *psz = pBuf->sz;
+ char *pszDiskName = psz;
+ char *pszArch = NULL;
+
+ /* Only care about the first line of the file even if it is multi line and assume disk name ended with ' - '.*/
+ psz = RTStrStr(pBuf->sz, " - ");
+ if (psz && memchr(pBuf->sz, '\n', (size_t)(psz - pBuf->sz)) == NULL)
+ {
+ *psz = '\0';
+ psz += 3;
+ if (*psz)
+ pszArch = psz;
+ }
+
+ /* Some Debian Live ISO's have info file content as follows:
+ * Official Debian GNU/Linux Live 10.10.0 cinnamon 2021-06-19T12:13
+ * thus pszArch stays empty. Try Volume Id (label) if we get lucky and get architecture from that. */
+ if (!pszArch)
+ {
+ char szVolumeId[128];
+ vrc = RTVfsQueryLabel(hVfsIso, false /*fAlternative*/, szVolumeId, sizeof(szVolumeId), NULL);
+ if (RT_SUCCESS(vrc))
+ {
+ if (!detectLinuxArchII(szVolumeId, &mEnmOsType, VBOXOSTYPE_Ubuntu))
+ LogRel(("Unattended: .disk/info: Unknown: arch='%s'\n", szVolumeId));
+ }
+ else
+ LogRel(("Unattended: .disk/info No Volume Label found\n"));
+ }
+ else
+ {
+ if (!detectLinuxArchII(pszArch, &mEnmOsType, VBOXOSTYPE_Ubuntu))
+ LogRel(("Unattended: .disk/info: Unknown: arch='%s'\n", pszArch));
+ }
+
+ if (pszDiskName)
+ {
+ const char *pszVersion = NULL;
+ if (detectLinuxDistroNameII(pszDiskName, &mEnmOsType, &pszVersion))
+ {
+ LogRelFlow(("Unattended: .disk/info: version=%s\n", pszVersion));
+ try { mStrDetectedOSVersion = RTStrStripL(pszVersion); }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+
+ size_t cchVersionPosition = 0;
+ if (detectLinuxDistroFlavor(pszDiskName, &cchVersionPosition))
+ {
+ try { mStrDetectedOSFlavor = Utf8Str(pszDiskName, cchVersionPosition); }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+ }
+ }
+ else
+ LogRel(("Unattended: .disk/info: Unknown: diskname='%s'\n", pszDiskName));
+ }
+
+ if (mEnmOsType == VBOXOSTYPE_Unknown)
+ LogRel(("Unattended: .disk/info: Did not find DISKNAME or/and ARCH. :-/\n"));
+ else
+ return S_FALSE;
+ }
+
+ /*
+ * Fedora live iso should be recognizable from the primary volume ID (the
+ * joliet one is usually truncated). We set fAlternative = true here to
+ * get the primary volume ID.
+ */
+ char szVolumeId[128];
+ vrc = RTVfsQueryLabel(hVfsIso, true /*fAlternative*/, szVolumeId, sizeof(szVolumeId), NULL);
+ if (RT_SUCCESS(vrc) && RTStrStartsWith(szVolumeId, "Fedora-"))
+ return i_innerDetectIsoOSLinuxFedora(hVfsIso, pBuf, &szVolumeId[sizeof("Fedora-") - 1]);
+ return S_FALSE;
+}
+
+
+/**
+ * Continues working a Fedora ISO image after the caller found a "Fedora-*"
+ * volume ID.
+ *
+ * Sample Volume IDs:
+ * - Fedora-WS-Live-34-1-2 (joliet: Fedora-WS-Live-3)
+ * - Fedora-S-dvd-x86_64-34 (joliet: Fedora-S-dvd-x86)
+ * - Fedora-WS-dvd-i386-25 (joliet: Fedora-WS-dvd-i3)
+ */
+HRESULT Unattended::i_innerDetectIsoOSLinuxFedora(RTVFS hVfsIso, DETECTBUFFER *pBuf, char *pszVolId)
+{
+ char * const pszFlavor = pszVolId;
+ char * psz = pszVolId;
+
+ /* The volume id may or may not include an arch, component.
+ We ASSUME that it includes a numeric part with the version, or at least
+ part of it. */
+ char *pszVersion = NULL;
+ char *pszArch = NULL;
+ if (detectLinuxArchII(psz, &mEnmOsType, VBOXOSTYPE_FedoraCore, &pszArch, &pszVersion))
+ {
+ while (*pszVersion == '-')
+ pszVersion++;
+ *pszArch = '\0';
+ }
+ else
+ {
+ mEnmOsType = (VBOXOSTYPE)(VBOXOSTYPE_FedoraCore | VBOXOSTYPE_UnknownArch);
+
+ char ch;
+ while ((ch = *psz) != '\0' && (!RT_C_IS_DIGIT(ch) || !RT_C_IS_PUNCT(psz[-1])))
+ psz++;
+ if (ch != '\0')
+ pszVersion = psz;
+ }
+
+ /*
+ * Replace '-' with '.' in the version part and use it as the version.
+ */
+ if (pszVersion)
+ {
+ psz = pszVersion;
+ while ((psz = strchr(psz, '-')) != NULL)
+ *psz++ = '.';
+ try { mStrDetectedOSVersion = RTStrStrip(pszVersion); }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+
+ *pszVersion = '\0'; /* don't include in flavor */
+ }
+
+ /*
+ * Split up the pre-arch/version bits into words and use them as the flavor.
+ */
+ psz = pszFlavor;
+ while ((psz = strchr(psz, '-')) != NULL)
+ *psz++ = ' ';
+ try { mStrDetectedOSFlavor = RTStrStrip(pszFlavor); }
+ catch (std::bad_alloc &) { return E_OUTOFMEMORY; }
+
+ /*
+ * If we don't have an architecture, we look at the vmlinuz file as the x86
+ * and AMD64 versions starts with a MZ+PE header giving the architecture.
+ */
+ if ((mEnmOsType & VBOXOSTYPE_ArchitectureMask) == VBOXOSTYPE_UnknownArch)
+ {
+ static const char * const s_apszVmLinuz[] = { "images/pxeboot/vmlinuz", "isolinux/vmlinuz" };
+ for (size_t i = 0; i < RT_ELEMENTS(s_apszVmLinuz); i++)
+ {
+ RTVFSFILE hVfsFileLinuz = NIL_RTVFSFILE;
+ int vrc = RTVfsFileOpen(hVfsIso, s_apszVmLinuz[i], RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
+ &hVfsFileLinuz);
+ if (RT_SUCCESS(vrc))
+ {
+ /* DOS signature: */
+ PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)&pBuf->ab[0];
+ AssertCompile(sizeof(*pBuf) > sizeof(*pDosHdr));
+ vrc = RTVfsFileReadAt(hVfsFileLinuz, 0, pDosHdr, sizeof(*pDosHdr), NULL);
+ if (RT_SUCCESS(vrc) && pDosHdr->e_magic == IMAGE_DOS_SIGNATURE)
+ {
+ /* NT signature - only need magic + file header, so use the 64 version for better debugging: */
+ PIMAGE_NT_HEADERS64 pNtHdrs = (PIMAGE_NT_HEADERS64)&pBuf->ab[0];
+ vrc = RTVfsFileReadAt(hVfsFileLinuz, pDosHdr->e_lfanew, pNtHdrs, sizeof(*pNtHdrs), NULL);
+ AssertCompile(sizeof(*pBuf) > sizeof(*pNtHdrs));
+ if (RT_SUCCESS(vrc) && pNtHdrs->Signature == IMAGE_NT_SIGNATURE)
+ {
+ if (pNtHdrs->FileHeader.Machine == IMAGE_FILE_MACHINE_I386)
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & ~VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_x86);
+ else if (pNtHdrs->FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64)
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & ~VBOXOSTYPE_ArchitectureMask) | VBOXOSTYPE_x64);
+ else
+ AssertFailed();
+ }
+ }
+
+ RTVfsFileRelease(hVfsFileLinuz);
+ if ((mEnmOsType & VBOXOSTYPE_ArchitectureMask) != VBOXOSTYPE_UnknownArch)
+ break;
+ }
+ }
+ }
+
+ /*
+ * If that failed, look for other files that gives away the arch.
+ */
+ if ((mEnmOsType & VBOXOSTYPE_ArchitectureMask) == VBOXOSTYPE_UnknownArch)
+ {
+ static struct { const char *pszFile; VBOXOSTYPE fArch; } const s_aArchSpecificFiles[] =
+ {
+ { "EFI/BOOT/grubaa64.efi", VBOXOSTYPE_arm64 },
+ { "EFI/BOOT/BOOTAA64.EFI", VBOXOSTYPE_arm64 },
+ };
+ PRTFSOBJINFO pObjInfo = (PRTFSOBJINFO)&pBuf->ab[0];
+ AssertCompile(sizeof(*pBuf) > sizeof(*pObjInfo));
+ for (size_t i = 0; i < RT_ELEMENTS(s_aArchSpecificFiles); i++)
+ {
+ int vrc = RTVfsQueryPathInfo(hVfsIso, s_aArchSpecificFiles[i].pszFile, pObjInfo,
+ RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
+ if (RT_SUCCESS(vrc) && RTFS_IS_FILE(pObjInfo->Attr.fMode))
+ {
+ mEnmOsType = (VBOXOSTYPE)((mEnmOsType & ~VBOXOSTYPE_ArchitectureMask) | s_aArchSpecificFiles[i].fArch);
+ break;
+ }
+ }
+ }
+
+ /*
+ * If we like, we could parse grub.conf to look for fullly spelled out
+ * flavor, though the menu items typically only contains the major version
+ * number, so little else to add, really.
+ */
+
+ return (mEnmOsType & VBOXOSTYPE_ArchitectureMask) != VBOXOSTYPE_UnknownArch ? S_OK : S_FALSE;
+}
+
+
+/**
+ * Detect OS/2 installation ISOs.
+ *
+ * Mainly aiming at ACP2/MCP2 as that's what we currently use in our testing.
+ *
+ * @returns COM status code.
+ * @retval S_OK if detected
+ * @retval S_FALSE if not fully detected.
+ *
+ * @param hVfsIso The ISO file system.
+ * @param pBuf Read buffer.
+ */
+HRESULT Unattended::i_innerDetectIsoOSOs2(RTVFS hVfsIso, DETECTBUFFER *pBuf)
+{
+ /*
+ * The OS2SE20.SRC contains the location of the tree with the diskette
+ * images, typically "\OS2IMAGE".
+ */
+ RTVFSFILE hVfsFile;
+ int vrc = RTVfsFileOpen(hVfsIso, "OS2SE20.SRC", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ size_t cbRead = 0;
+ vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(pBuf->sz) - 1, &cbRead);
+ RTVfsFileRelease(hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ pBuf->sz[cbRead] = '\0';
+ RTStrStrip(pBuf->sz);
+ vrc = RTStrValidateEncoding(pBuf->sz);
+ if (RT_SUCCESS(vrc))
+ LogRelFlow(("Unattended: OS2SE20.SRC=%s\n", pBuf->sz));
+ else
+ LogRel(("Unattended: OS2SE20.SRC invalid encoding: %Rrc, %.*Rhxs\n", vrc, cbRead, pBuf->sz));
+ }
+ else
+ LogRel(("Unattended: Error reading OS2SE20.SRC: %\n", vrc));
+ }
+ /*
+ * ArcaOS has dropped the file, assume it's \OS2IMAGE and see if it's there.
+ */
+ else if (vrc == VERR_FILE_NOT_FOUND)
+ RTStrCopy(pBuf->sz, sizeof(pBuf->sz), "\\OS2IMAGE");
+ else
+ return S_FALSE;
+
+ /*
+ * Check that the directory directory exists and has a DISK_0 under it
+ * with an OS2LDR on it.
+ */
+ size_t const cchOs2Image = strlen(pBuf->sz);
+ vrc = RTPathAppend(pBuf->sz, sizeof(pBuf->sz), "DISK_0/OS2LDR");
+ RTFSOBJINFO ObjInfo = {0};
+ vrc = RTVfsQueryPathInfo(hVfsIso, pBuf->sz, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
+ if (vrc == VERR_FILE_NOT_FOUND)
+ {
+ RTStrCat(pBuf->sz, sizeof(pBuf->sz), "."); /* eCS 2.0 image includes the dot from the 8.3 name. */
+ vrc = RTVfsQueryPathInfo(hVfsIso, pBuf->sz, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
+ }
+ if ( RT_FAILURE(vrc)
+ || !RTFS_IS_FILE(ObjInfo.Attr.fMode))
+ {
+ LogRel(("Unattended: RTVfsQueryPathInfo(, '%s' (from OS2SE20.SRC),) -> %Rrc, fMode=%#x\n",
+ pBuf->sz, vrc, ObjInfo.Attr.fMode));
+ return S_FALSE;
+ }
+
+ /*
+ * So, it's some kind of OS/2 2.x or later ISO alright.
+ */
+ mEnmOsType = VBOXOSTYPE_OS2;
+ mStrDetectedOSHints.printf("OS2SE20.SRC=%.*s", cchOs2Image, pBuf->sz);
+
+ /*
+ * ArcaOS ISOs seems to have a AOSBOOT dir on them.
+ * This contains a ARCANOAE.FLG file with content we can use for the version:
+ * ArcaOS 5.0.7 EN
+ * Built 2021-12-07 18:34:34
+ * We drop the "ArcaOS" bit, as it's covered by mEnmOsType. Then we pull up
+ * the second line.
+ *
+ * Note! Yet to find a way to do unattended install of ArcaOS, as it comes
+ * with no CD-boot floppy images, only simple .PF archive files for
+ * unpacking onto the ram disk or whatever. Modifying these is
+ * possible (ibsen's aPLib v0.36 compression with some simple custom
+ * headers), but it would probably be a royal pain. Could perhaps
+ * cook something from OS2IMAGE\DISK_0 thru 3...
+ */
+ vrc = RTVfsQueryPathInfo(hVfsIso, "AOSBOOT", &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
+ if ( RT_SUCCESS(vrc)
+ && RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
+ {
+ mEnmOsType = VBOXOSTYPE_ArcaOS;
+
+ /* Read the version file: */
+ vrc = RTVfsFileOpen(hVfsIso, "SYS/ARCANOAE.FLG", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ size_t cbRead = 0;
+ vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(pBuf->sz) - 1, &cbRead);
+ RTVfsFileRelease(hVfsFile);
+ pBuf->sz[cbRead] = '\0';
+ if (RT_SUCCESS(vrc))
+ {
+ /* Strip the OS name: */
+ char *pszVersion = RTStrStrip(pBuf->sz);
+ static char s_szArcaOS[] = "ArcaOS";
+ if (RTStrStartsWith(pszVersion, s_szArcaOS))
+ pszVersion = RTStrStripL(pszVersion + sizeof(s_szArcaOS) - 1);
+
+ /* Pull up the 2nd line if it, condensing the \r\n into a single space. */
+ char *pszNewLine = strchr(pszVersion, '\n');
+ if (pszNewLine && RTStrStartsWith(pszNewLine + 1, "Built 20"))
+ {
+ size_t offRemove = 0;
+ while (RT_C_IS_SPACE(pszNewLine[-1 - (ssize_t)offRemove]))
+ offRemove++;
+ if (offRemove > 0)
+ {
+ pszNewLine -= offRemove;
+ memmove(pszNewLine, pszNewLine + offRemove, strlen(pszNewLine + offRemove) - 1);
+ }
+ *pszNewLine = ' ';
+ }
+
+ /* Drop any additional lines: */
+ pszNewLine = strchr(pszVersion, '\n');
+ if (pszNewLine)
+ *pszNewLine = '\0';
+ RTStrStripR(pszVersion);
+
+ /* Done (hope it makes some sense). */
+ mStrDetectedOSVersion = pszVersion;
+ }
+ else
+ LogRel(("Unattended: failed to read AOSBOOT/ARCANOAE.FLG: %Rrc\n", vrc));
+ }
+ else
+ LogRel(("Unattended: failed to open AOSBOOT/ARCANOAE.FLG for reading: %Rrc\n", vrc));
+ }
+ /*
+ * Similarly, eCS has an ECS directory and it typically contains a
+ * ECS_INST.FLG file with the version info. Content differs a little:
+ * eComStation 2.0 EN_US Thu May 13 10:27:54 pm 2010
+ * Built on ECS60441318
+ * Here we drop the "eComStation" bit and leave the 2nd line as it.
+ *
+ * Note! At least 2.0 has a DISKIMGS folder with what looks like boot
+ * disks, so we could probably get something going here without
+ * needing to write an OS2 boot sector...
+ */
+ else
+ {
+ vrc = RTVfsQueryPathInfo(hVfsIso, "ECS", &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
+ if ( RT_SUCCESS(vrc)
+ && RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
+ {
+ mEnmOsType = VBOXOSTYPE_ECS;
+
+ /* Read the version file: */
+ vrc = RTVfsFileOpen(hVfsIso, "ECS/ECS_INST.FLG", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ size_t cbRead = 0;
+ vrc = RTVfsFileRead(hVfsFile, pBuf->sz, sizeof(pBuf->sz) - 1, &cbRead);
+ RTVfsFileRelease(hVfsFile);
+ pBuf->sz[cbRead] = '\0';
+ if (RT_SUCCESS(vrc))
+ {
+ /* Strip the OS name: */
+ char *pszVersion = RTStrStrip(pBuf->sz);
+ static char s_szECS[] = "eComStation";
+ if (RTStrStartsWith(pszVersion, s_szECS))
+ pszVersion = RTStrStripL(pszVersion + sizeof(s_szECS) - 1);
+
+ /* Drop any additional lines: */
+ char *pszNewLine = strchr(pszVersion, '\n');
+ if (pszNewLine)
+ *pszNewLine = '\0';
+ RTStrStripR(pszVersion);
+
+ /* Done (hope it makes some sense). */
+ mStrDetectedOSVersion = pszVersion;
+ }
+ else
+ LogRel(("Unattended: failed to read ECS/ECS_INST.FLG: %Rrc\n", vrc));
+ }
+ else
+ LogRel(("Unattended: failed to open ECS/ECS_INST.FLG for reading: %Rrc\n", vrc));
+ }
+ else
+ {
+ /*
+ * Official IBM OS/2 builds doesn't have any .FLG file on them,
+ * so need to pry the information out in some other way. Best way
+ * is to read the SYSLEVEL.OS2 file, which is typically on disk #2,
+ * though on earlier versions (warp3) it was disk #1.
+ */
+ vrc = RTPathJoin(pBuf->sz, sizeof(pBuf->sz), strchr(mStrDetectedOSHints.c_str(), '=') + 1,
+ "/DISK_2/SYSLEVEL.OS2");
+ if (RT_SUCCESS(vrc))
+ {
+ vrc = RTVfsFileOpen(hVfsIso, pBuf->sz, RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (vrc == VERR_FILE_NOT_FOUND)
+ {
+ RTPathJoin(pBuf->sz, sizeof(pBuf->sz), strchr(mStrDetectedOSHints.c_str(), '=') + 1, "/DISK_1/SYSLEVEL.OS2");
+ vrc = RTVfsFileOpen(hVfsIso, pBuf->sz, RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ }
+ if (RT_SUCCESS(vrc))
+ {
+ RT_ZERO(pBuf->ab);
+ size_t cbRead = 0;
+ vrc = RTVfsFileRead(hVfsFile, pBuf->ab, sizeof(pBuf->ab), &cbRead);
+ RTVfsFileRelease(hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ /* Check the header. */
+ OS2SYSLEVELHDR const *pHdr = (OS2SYSLEVELHDR const *)&pBuf->ab[0];
+ if ( pHdr->uMinusOne == UINT16_MAX
+ && pHdr->uSyslevelFileVer == 1
+ && memcmp(pHdr->achSignature, RT_STR_TUPLE("SYSLEVEL")) == 0
+ && pHdr->offTable < cbRead
+ && pHdr->offTable + sizeof(OS2SYSLEVELENTRY) <= cbRead)
+ {
+ OS2SYSLEVELENTRY *pEntry = (OS2SYSLEVELENTRY *)&pBuf->ab[pHdr->offTable];
+ if ( RT_SUCCESS(RTStrValidateEncodingEx(pEntry->szName, sizeof(pEntry->szName),
+ RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED))
+ && RT_SUCCESS(RTStrValidateEncodingEx(pEntry->achCsdLevel, sizeof(pEntry->achCsdLevel), 0))
+ && pEntry->bVersion != 0
+ && ((pEntry->bVersion >> 4) & 0xf) < 10
+ && (pEntry->bVersion & 0xf) < 10
+ && pEntry->bModify < 10
+ && pEntry->bRefresh < 10)
+ {
+ /* Flavor: */
+ char *pszName = RTStrStrip(pEntry->szName);
+ if (pszName)
+ mStrDetectedOSFlavor = pszName;
+
+ /* Version: */
+ if (pEntry->bRefresh != 0)
+ mStrDetectedOSVersion.printf("%d.%d%d.%d", pEntry->bVersion >> 4, pEntry->bVersion & 0xf,
+ pEntry->bModify, pEntry->bRefresh);
+ else
+ mStrDetectedOSVersion.printf("%d.%d%d", pEntry->bVersion >> 4, pEntry->bVersion & 0xf,
+ pEntry->bModify);
+ pEntry->achCsdLevel[sizeof(pEntry->achCsdLevel) - 1] = '\0';
+ char *pszCsd = RTStrStrip(pEntry->achCsdLevel);
+ if (*pszCsd != '\0')
+ {
+ mStrDetectedOSVersion.append(' ');
+ mStrDetectedOSVersion.append(pszCsd);
+ }
+ if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "4.50") >= 0)
+ mEnmOsType = VBOXOSTYPE_OS2Warp45;
+ else if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "4.00") >= 0)
+ mEnmOsType = VBOXOSTYPE_OS2Warp4;
+ else if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "3.00") >= 0)
+ mEnmOsType = VBOXOSTYPE_OS2Warp3;
+ }
+ else
+ LogRel(("Unattended: bogus SYSLEVEL.OS2 file entry: %.128Rhxd\n", pEntry));
+ }
+ else
+ LogRel(("Unattended: bogus SYSLEVEL.OS2 file header: uMinusOne=%#x uSyslevelFileVer=%#x achSignature=%.8Rhxs offTable=%#x vs cbRead=%#zx\n",
+ pHdr->uMinusOne, pHdr->uSyslevelFileVer, pHdr->achSignature, pHdr->offTable, cbRead));
+ }
+ else
+ LogRel(("Unattended: failed to read SYSLEVEL.OS2: %Rrc\n", vrc));
+ }
+ else
+ LogRel(("Unattended: failed to open '%s' for reading: %Rrc\n", pBuf->sz, vrc));
+ }
+ }
+ }
+
+ /** @todo language detection? */
+
+ /*
+ * Only tested ACP2, so only return S_OK for it.
+ */
+ if ( mEnmOsType == VBOXOSTYPE_OS2Warp45
+ && RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "4.52") >= 0
+ && mStrDetectedOSFlavor.contains("Server", RTCString::CaseInsensitive))
+ return S_OK;
+
+ return S_FALSE;
+}
+
+
+/**
+ * Detect FreeBSD distro ISOs.
+ *
+ * @returns COM status code.
+ * @retval S_OK if detected
+ * @retval S_FALSE if not fully detected.
+ *
+ * @param hVfsIso The ISO file system.
+ * @param pBuf Read buffer.
+ */
+HRESULT Unattended::i_innerDetectIsoOSFreeBsd(RTVFS hVfsIso, DETECTBUFFER *pBuf)
+{
+ RT_NOREF(pBuf);
+
+ /*
+ * FreeBSD since 10.0 has a .profile file in the root which can be used to determine that this is FreeBSD
+ * along with the version.
+ */
+
+ RTVFSFILE hVfsFile;
+ HRESULT hrc = S_FALSE;
+ int vrc = RTVfsFileOpen(hVfsIso, ".profile", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
+ if (RT_SUCCESS(vrc))
+ {
+ static const uint8_t s_abFreeBsdHdr[] = "# $FreeBSD: releng/";
+ char abRead[32];
+
+ vrc = RTVfsFileRead(hVfsFile, &abRead[0], sizeof(abRead), NULL /*pcbRead*/);
+ if ( RT_SUCCESS(vrc)
+ && !memcmp(&abRead[0], &s_abFreeBsdHdr[0], sizeof(s_abFreeBsdHdr) - 1)) /* Skip terminator */
+ {
+ abRead[sizeof(abRead) - 1] = '\0';
+
+ /* Detect the architecture using the volume label. */
+ char szVolumeId[128];
+ size_t cchVolumeId;
+ vrc = RTVfsQueryLabel(hVfsIso, false /*fAlternative*/, szVolumeId, 128, &cchVolumeId);
+ if (RT_SUCCESS(vrc))
+ {
+ /* Can re-use the Linux code here. */
+ if (!detectLinuxArchII(szVolumeId, &mEnmOsType, VBOXOSTYPE_FreeBSD))
+ LogRel(("Unattended/FBSD: Unknown: arch='%s'\n", szVolumeId));
+
+ /* Detect the version from the string coming after the needle in .profile. */
+ AssertCompile(sizeof(s_abFreeBsdHdr) - 1 < sizeof(abRead));
+
+ char *pszVersionStart = &abRead[sizeof(s_abFreeBsdHdr) - 1];
+ char *pszVersionEnd = pszVersionStart;
+
+ while (RT_C_IS_DIGIT(*pszVersionEnd))
+ pszVersionEnd++;
+ if (*pszVersionEnd == '.')
+ {
+ pszVersionEnd++; /* Skip the . */
+
+ while (RT_C_IS_DIGIT(*pszVersionEnd))
+ pszVersionEnd++;
+
+ /* Terminate the version string. */
+ *pszVersionEnd = '\0';
+
+ try { mStrDetectedOSVersion = pszVersionStart; }
+ catch (std::bad_alloc &) { hrc = E_OUTOFMEMORY; }
+ }
+ else
+ LogRel(("Unattended/FBSD: Unknown: version='%s'\n", &abRead[0]));
+ }
+ else
+ {
+ LogRel(("Unattended/FBSD: No Volume Label found\n"));
+ mEnmOsType = VBOXOSTYPE_FreeBSD;
+ }
+
+ hrc = S_OK;
+ }
+
+ RTVfsFileRelease(hVfsFile);
+ }
+
+ return hrc;
+}
+
+
+HRESULT Unattended::prepare()
+{
+ LogFlow(("Unattended::prepare: enter\n"));
+
+ /*
+ * Must have a machine.
+ */
+ ComPtr<Machine> ptrMachine;
+ Guid MachineUuid;
+ {
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ ptrMachine = mMachine;
+ if (ptrMachine.isNull())
+ return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("No machine associated with this IUnatteded instance"));
+ MachineUuid = mMachineUuid;
+ }
+
+ /*
+ * Before we write lock ourselves, we must get stuff from Machine and
+ * VirtualBox because their locks have higher priorities than ours.
+ */
+ Utf8Str strGuestOsTypeId;
+ Utf8Str strMachineName;
+ Utf8Str strDefaultAuxBasePath;
+ HRESULT hrc;
+ try
+ {
+ Bstr bstrTmp;
+ hrc = ptrMachine->COMGETTER(OSTypeId)(bstrTmp.asOutParam());
+ if (SUCCEEDED(hrc))
+ {
+ strGuestOsTypeId = bstrTmp;
+ hrc = ptrMachine->COMGETTER(Name)(bstrTmp.asOutParam());
+ if (SUCCEEDED(hrc))
+ strMachineName = bstrTmp;
+ }
+ int vrc = ptrMachine->i_calculateFullPath(Utf8StrFmt("Unattended-%RTuuid-", MachineUuid.raw()), strDefaultAuxBasePath);
+ if (RT_FAILURE(vrc))
+ return setErrorBoth(E_FAIL, vrc);
+ }
+ catch (std::bad_alloc &)
+ {
+ return E_OUTOFMEMORY;
+ }
+ bool const fIs64Bit = i_isGuestOSArchX64(strGuestOsTypeId);
+
+ BOOL fRtcUseUtc = FALSE;
+ hrc = ptrMachine->COMGETTER(RTCUseUTC)(&fRtcUseUtc);
+ if (FAILED(hrc))
+ return hrc;
+
+ FirmwareType_T enmFirmware = FirmwareType_BIOS;
+ hrc = ptrMachine->COMGETTER(FirmwareType)(&enmFirmware);
+ if (FAILED(hrc))
+ return hrc;
+
+ /*
+ * Write lock this object and set attributes we got from IMachine.
+ */
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+ mStrGuestOsTypeId = strGuestOsTypeId;
+ mfGuestOs64Bit = fIs64Bit;
+ mfRtcUseUtc = RT_BOOL(fRtcUseUtc);
+ menmFirmwareType = enmFirmware;
+
+ /*
+ * Do some state checks.
+ */
+ if (mpInstaller != NULL)
+ return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("The prepare method has been called (must call done to restart)"));
+ if ((Machine *)ptrMachine != (Machine *)mMachine)
+ return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("The 'machine' while we were using it - please don't do that"));
+
+ /*
+ * Check if the specified ISOs and files exist.
+ */
+ if (!RTFileExists(mStrIsoPath.c_str()))
+ return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate the installation ISO file '%s'"),
+ mStrIsoPath.c_str());
+ if (mfInstallGuestAdditions && !RTFileExists(mStrAdditionsIsoPath.c_str()))
+ return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate the Guest Additions ISO file '%s'"),
+ mStrAdditionsIsoPath.c_str());
+ if (mfInstallTestExecService && !RTFileExists(mStrValidationKitIsoPath.c_str()))
+ return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate the validation kit ISO file '%s'"),
+ mStrValidationKitIsoPath.c_str());
+ if (mStrScriptTemplatePath.isNotEmpty() && !RTFileExists(mStrScriptTemplatePath.c_str()))
+ return setErrorBoth(E_FAIL, VERR_FILE_NOT_FOUND, tr("Could not locate unattended installation script template '%s'"),
+ mStrScriptTemplatePath.c_str());
+
+ /*
+ * Do media detection if it haven't been done yet.
+ */
+ if (!mfDoneDetectIsoOS)
+ {
+ hrc = detectIsoOS();
+ if (FAILED(hrc) && hrc != E_NOTIMPL)
+ return hrc;
+ }
+
+ /*
+ * We can now check midxImage against mDetectedImages, since the latter is
+ * populated during the detectIsoOS call. We ignore midxImage if no images
+ * were detected, assuming that it's not relevant or used for different purposes.
+ */
+ if (mDetectedImages.size() > 0)
+ {
+ bool fImageFound = false;
+ for (size_t i = 0; i < mDetectedImages.size(); ++i)
+ if (midxImage == mDetectedImages[i].mImageIndex)
+ {
+ i_updateDetectedAttributeForImage(mDetectedImages[i]);
+ fImageFound = true;
+ break;
+ }
+ if (!fImageFound)
+ return setErrorBoth(E_FAIL, VERR_NOT_FOUND, tr("imageIndex value %u not found in detectedImageIndices"), midxImage);
+ }
+
+ /*
+ * Get the ISO's detect guest OS type info and make it's a known one (just
+ * in case the above step doesn't work right).
+ */
+ uint32_t const idxIsoOSType = Global::getOSTypeIndexFromId(mStrDetectedOSTypeId.c_str());
+ VBOXOSTYPE const enmIsoOSType = idxIsoOSType < Global::cOSTypes ? Global::sOSTypes[idxIsoOSType].osType : VBOXOSTYPE_Unknown;
+ if ((enmIsoOSType & VBOXOSTYPE_OsTypeMask) == VBOXOSTYPE_Unknown)
+ return setError(E_FAIL, tr("The supplied ISO file does not contain an OS currently supported for unattended installation"));
+
+ /*
+ * Get the VM's configured guest OS type info.
+ */
+ uint32_t const idxMachineOSType = Global::getOSTypeIndexFromId(mStrGuestOsTypeId.c_str());
+ VBOXOSTYPE const enmMachineOSType = idxMachineOSType < Global::cOSTypes
+ ? Global::sOSTypes[idxMachineOSType].osType : VBOXOSTYPE_Unknown;
+
+ /*
+ * Check that the detected guest OS type for the ISO is compatible with
+ * that of the VM, boardly speaking.
+ */
+ if (idxMachineOSType != idxIsoOSType)
+ {
+ /* Check that the architecture is compatible: */
+ if ( (enmIsoOSType & VBOXOSTYPE_ArchitectureMask) != (enmMachineOSType & VBOXOSTYPE_ArchitectureMask)
+ && ( (enmIsoOSType & VBOXOSTYPE_ArchitectureMask) != VBOXOSTYPE_x86
+ || (enmMachineOSType & VBOXOSTYPE_ArchitectureMask) != VBOXOSTYPE_x64))
+ return setError(E_FAIL, tr("The supplied ISO file is incompatible with the guest OS type of the VM: CPU architecture mismatch"));
+
+ /** @todo check BIOS/EFI requirement */
+ }
+
+ /*
+ * Do some default property stuff and check other properties.
+ */
+ try
+ {
+ char szTmp[128];
+
+ if (mStrLocale.isEmpty())
+ {
+ int vrc = RTLocaleQueryNormalizedBaseLocaleName(szTmp, sizeof(szTmp));
+ if ( RT_SUCCESS(vrc)
+ && RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(szTmp))
+ mStrLocale.assign(szTmp, 5);
+ else
+ mStrLocale = "en_US";
+ Assert(RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(mStrLocale));
+ }
+
+ if (mStrLanguage.isEmpty())
+ {
+ if (mDetectedOSLanguages.size() > 0)
+ mStrLanguage = mDetectedOSLanguages[0];
+ else
+ mStrLanguage.assign(mStrLocale).findReplace('_', '-');
+ }
+
+ if (mStrCountry.isEmpty())
+ {
+ int vrc = RTLocaleQueryUserCountryCode(szTmp);
+ if (RT_SUCCESS(vrc))
+ mStrCountry = szTmp;
+ else if ( mStrLocale.isNotEmpty()
+ && RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(mStrLocale))
+ mStrCountry.assign(mStrLocale, 3, 2);
+ else
+ mStrCountry = "US";
+ }
+
+ if (mStrTimeZone.isEmpty())
+ {
+ int vrc = RTTimeZoneGetCurrent(szTmp, sizeof(szTmp));
+ if ( RT_SUCCESS(vrc)
+ && strcmp(szTmp, "localtime") != 0 /* Typcial solaris TZ that isn't very helpful. */)
+ mStrTimeZone = szTmp;
+ else
+ mStrTimeZone = "Etc/UTC";
+ Assert(mStrTimeZone.isNotEmpty());
+ }
+ mpTimeZoneInfo = RTTimeZoneGetInfoByUnixName(mStrTimeZone.c_str());
+ if (!mpTimeZoneInfo)
+ mpTimeZoneInfo = RTTimeZoneGetInfoByWindowsName(mStrTimeZone.c_str());
+ Assert(mpTimeZoneInfo || mStrTimeZone != "Etc/UTC");
+ if (!mpTimeZoneInfo)
+ LogRel(("Unattended::prepare: warning: Unknown time zone '%s'\n", mStrTimeZone.c_str()));
+
+ if (mStrHostname.isEmpty())
+ {
+ /* Mangle the VM name into a valid hostname. */
+ for (size_t i = 0; i < strMachineName.length(); i++)
+ {
+ char ch = strMachineName[i];
+ if ( (unsigned)ch < 127
+ && RT_C_IS_ALNUM(ch))
+ mStrHostname.append(ch);
+ else if (mStrHostname.isNotEmpty() && RT_C_IS_PUNCT(ch) && !mStrHostname.endsWith("-"))
+ mStrHostname.append('-');
+ }
+ if (mStrHostname.length() == 0)
+ mStrHostname.printf("%RTuuid-vm", MachineUuid.raw());
+ else if (mStrHostname.length() < 3)
+ mStrHostname.append("-vm");
+ mStrHostname.append(".myguest.virtualbox.org");
+ }
+
+ if (mStrAuxiliaryBasePath.isEmpty())
+ {
+ mStrAuxiliaryBasePath = strDefaultAuxBasePath;
+ mfIsDefaultAuxiliaryBasePath = true;
+ }
+ }
+ catch (std::bad_alloc &)
+ {
+ return E_OUTOFMEMORY;
+ }
+
+ /*
+ * Instatiate the guest installer matching the ISO.
+ */
+ mpInstaller = UnattendedInstaller::createInstance(enmIsoOSType, mStrDetectedOSTypeId, mStrDetectedOSVersion,
+ mStrDetectedOSFlavor, mStrDetectedOSHints, this);
+ if (mpInstaller != NULL)
+ {
+ hrc = mpInstaller->initInstaller();
+ if (SUCCEEDED(hrc))
+ {
+ /*
+ * Do the script preps (just reads them).
+ */
+ hrc = mpInstaller->prepareUnattendedScripts();
+ if (SUCCEEDED(hrc))
+ {
+ LogFlow(("Unattended::prepare: returns S_OK\n"));
+ return S_OK;
+ }
+ }
+
+ /* Destroy the installer instance. */
+ delete mpInstaller;
+ mpInstaller = NULL;
+ }
+ else
+ hrc = setErrorBoth(E_FAIL, VERR_NOT_FOUND,
+ tr("Unattended installation is not supported for guest type '%s'"), mStrGuestOsTypeId.c_str());
+ LogRelFlow(("Unattended::prepare: failed with %Rhrc\n", hrc));
+ return hrc;
+}
+
+HRESULT Unattended::constructMedia()
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+ LogFlow(("===========================================================\n"));
+ LogFlow(("Call Unattended::constructMedia()\n"));
+
+ if (mpInstaller == NULL)
+ return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, "prepare() not yet called");
+
+ return mpInstaller->prepareMedia();
+}
+
+HRESULT Unattended::reconfigureVM()
+{
+ LogFlow(("===========================================================\n"));
+ LogFlow(("Call Unattended::reconfigureVM()\n"));
+
+ /*
+ * Interrogate VirtualBox/IGuestOSType before we lock stuff and create ordering issues.
+ */
+ StorageBus_T enmRecommendedStorageBus = StorageBus_IDE;
+ {
+ Bstr bstrGuestOsTypeId;
+ Bstr bstrDetectedOSTypeId;
+ {
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ if (mpInstaller == NULL)
+ return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("prepare() not yet called"));
+ bstrGuestOsTypeId = mStrGuestOsTypeId;
+ bstrDetectedOSTypeId = mStrDetectedOSTypeId;
+ }
+ ComPtr<IGuestOSType> ptrGuestOSType;
+ HRESULT hrc = mParent->GetGuestOSType(bstrGuestOsTypeId.raw(), ptrGuestOSType.asOutParam());
+ if (SUCCEEDED(hrc))
+ {
+ if (!ptrGuestOSType.isNull())
+ hrc = ptrGuestOSType->COMGETTER(RecommendedDVDStorageBus)(&enmRecommendedStorageBus);
+ }
+ if (FAILED(hrc))
+ return hrc;
+
+ /* If the detected guest OS type differs, log a warning if their DVD storage
+ bus recommendations differ. */
+ if (bstrGuestOsTypeId != bstrDetectedOSTypeId)
+ {
+ StorageBus_T enmRecommendedStorageBus2 = StorageBus_IDE;
+ hrc = mParent->GetGuestOSType(bstrDetectedOSTypeId.raw(), ptrGuestOSType.asOutParam());
+ if (SUCCEEDED(hrc) && !ptrGuestOSType.isNull())
+ hrc = ptrGuestOSType->COMGETTER(RecommendedDVDStorageBus)(&enmRecommendedStorageBus2);
+ if (FAILED(hrc))
+ return hrc;
+
+ if (enmRecommendedStorageBus != enmRecommendedStorageBus2)
+ LogRel(("Unattended::reconfigureVM: DVD storage bus recommendations differs for the VM and the ISO guest OS types: VM: %s (%ls), ISO: %s (%ls)\n",
+ ::stringifyStorageBus(enmRecommendedStorageBus), bstrGuestOsTypeId.raw(),
+ ::stringifyStorageBus(enmRecommendedStorageBus2), bstrDetectedOSTypeId.raw() ));
+ }
+ }
+
+ /*
+ * Take write lock (for lock order reasons, write lock our parent object too)
+ * then make sure we're the only caller of this method.
+ */
+ AutoMultiWriteLock2 alock(mMachine, this COMMA_LOCKVAL_SRC_POS);
+ HRESULT hrc;
+ if (mhThreadReconfigureVM == NIL_RTNATIVETHREAD)
+ {
+ RTNATIVETHREAD const hNativeSelf = RTThreadNativeSelf();
+ mhThreadReconfigureVM = hNativeSelf;
+
+ /*
+ * Create a new session, lock the machine and get the session machine object.
+ * Do the locking without pinning down the write locks, just to be on the safe side.
+ */
+ ComPtr<ISession> ptrSession;
+ try
+ {
+ hrc = ptrSession.createInprocObject(CLSID_Session);
+ }
+ catch (std::bad_alloc &)
+ {
+ hrc = E_OUTOFMEMORY;
+ }
+ if (SUCCEEDED(hrc))
+ {
+ alock.release();
+ hrc = mMachine->LockMachine(ptrSession, LockType_Shared);
+ alock.acquire();
+ if (SUCCEEDED(hrc))
+ {
+ ComPtr<IMachine> ptrSessionMachine;
+ hrc = ptrSession->COMGETTER(Machine)(ptrSessionMachine.asOutParam());
+ if (SUCCEEDED(hrc))
+ {
+ /*
+ * Hand the session to the inner work and let it do it job.
+ */
+ try
+ {
+ hrc = i_innerReconfigureVM(alock, enmRecommendedStorageBus, ptrSessionMachine);
+ }
+ catch (...)
+ {
+ hrc = E_UNEXPECTED;
+ }
+ }
+
+ /* Paranoia: release early in case we it a bump below. */
+ Assert(mhThreadReconfigureVM == hNativeSelf);
+ mhThreadReconfigureVM = NIL_RTNATIVETHREAD;
+
+ /*
+ * While unlocking the machine we'll have to drop the locks again.
+ */
+ alock.release();
+
+ ptrSessionMachine.setNull();
+ HRESULT hrc2 = ptrSession->UnlockMachine();
+ AssertLogRelMsg(SUCCEEDED(hrc2), ("UnlockMachine -> %Rhrc\n", hrc2));
+
+ ptrSession.setNull();
+
+ alock.acquire();
+ }
+ else
+ mhThreadReconfigureVM = NIL_RTNATIVETHREAD;
+ }
+ else
+ mhThreadReconfigureVM = NIL_RTNATIVETHREAD;
+ }
+ else
+ hrc = setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("reconfigureVM running on other thread"));
+ return hrc;
+}
+
+
+HRESULT Unattended::i_innerReconfigureVM(AutoMultiWriteLock2 &rAutoLock, StorageBus_T enmRecommendedStorageBus,
+ ComPtr<IMachine> const &rPtrSessionMachine)
+{
+ if (mpInstaller == NULL)
+ return setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("prepare() not yet called"));
+
+ // Fetch all available storage controllers
+ com::SafeIfaceArray<IStorageController> arrayOfControllers;
+ HRESULT hrc = rPtrSessionMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(arrayOfControllers));
+ AssertComRCReturn(hrc, hrc);
+
+ /*
+ * Figure out where the images are to be mounted, adding controllers/ports as needed.
+ */
+ std::vector<UnattendedInstallationDisk> vecInstallationDisks;
+ if (mpInstaller->isAuxiliaryFloppyNeeded())
+ {
+ hrc = i_reconfigureFloppy(arrayOfControllers, vecInstallationDisks, rPtrSessionMachine, rAutoLock);
+ if (FAILED(hrc))
+ return hrc;
+ }
+
+ hrc = i_reconfigureIsos(arrayOfControllers, vecInstallationDisks, rPtrSessionMachine, rAutoLock, enmRecommendedStorageBus);
+ if (FAILED(hrc))
+ return hrc;
+
+ /*
+ * Mount the images.
+ */
+ for (size_t idxImage = 0; idxImage < vecInstallationDisks.size(); idxImage++)
+ {
+ UnattendedInstallationDisk const *pImage = &vecInstallationDisks.at(idxImage);
+ Assert(pImage->strImagePath.isNotEmpty());
+ hrc = i_attachImage(pImage, rPtrSessionMachine, rAutoLock);
+ if (FAILED(hrc))
+ return hrc;
+ }
+
+ /*
+ * Set the boot order.
+ *
+ * ASSUME that the HD isn't bootable when we start out, but it will be what
+ * we boot from after the first stage of the installation is done. Setting
+ * it first prevents endless reboot cylces.
+ */
+ /** @todo consider making 100% sure the disk isn't bootable (edit partition
+ * table active bits and EFI stuff). */
+ Assert( mpInstaller->getBootableDeviceType() == DeviceType_DVD
+ || mpInstaller->getBootableDeviceType() == DeviceType_Floppy);
+ hrc = rPtrSessionMachine->SetBootOrder(1, DeviceType_HardDisk);
+ if (SUCCEEDED(hrc))
+ hrc = rPtrSessionMachine->SetBootOrder(2, mpInstaller->getBootableDeviceType());
+ if (SUCCEEDED(hrc))
+ hrc = rPtrSessionMachine->SetBootOrder(3, mpInstaller->getBootableDeviceType() == DeviceType_DVD
+ ? DeviceType_Floppy : DeviceType_DVD);
+ if (FAILED(hrc))
+ return hrc;
+
+ /*
+ * Essential step.
+ *
+ * HACK ALERT! We have to release the lock here or we'll get into trouble with
+ * the VirtualBox lock (via i_saveHardware/NetworkAdaptger::i_hasDefaults/VirtualBox::i_findGuestOSType).
+ */
+ if (SUCCEEDED(hrc))
+ {
+ rAutoLock.release();
+ hrc = rPtrSessionMachine->SaveSettings();
+ rAutoLock.acquire();
+ }
+
+ return hrc;
+}
+
+/**
+ * Makes sure we've got a floppy drive attached to a floppy controller, adding
+ * the auxiliary floppy image to the installation disk vector.
+ *
+ * @returns COM status code.
+ * @param rControllers The existing controllers.
+ * @param rVecInstallatationDisks The list of image to mount.
+ * @param rPtrSessionMachine The session machine smart pointer.
+ * @param rAutoLock The lock.
+ */
+HRESULT Unattended::i_reconfigureFloppy(com::SafeIfaceArray<IStorageController> &rControllers,
+ std::vector<UnattendedInstallationDisk> &rVecInstallatationDisks,
+ ComPtr<IMachine> const &rPtrSessionMachine,
+ AutoMultiWriteLock2 &rAutoLock)
+{
+ Assert(mpInstaller->isAuxiliaryFloppyNeeded());
+
+ /*
+ * Look for a floppy controller with a primary drive (A:) we can "insert"
+ * the auxiliary floppy image. Add a controller and/or a drive if necessary.
+ */
+ bool fFoundPort0Dev0 = false;
+ Bstr bstrControllerName;
+ Utf8Str strControllerName;
+
+ for (size_t i = 0; i < rControllers.size(); ++i)
+ {
+ StorageBus_T enmStorageBus;
+ HRESULT hrc = rControllers[i]->COMGETTER(Bus)(&enmStorageBus);
+ AssertComRCReturn(hrc, hrc);
+ if (enmStorageBus == StorageBus_Floppy)
+ {
+
+ /*
+ * Found a floppy controller.
+ */
+ hrc = rControllers[i]->COMGETTER(Name)(bstrControllerName.asOutParam());
+ AssertComRCReturn(hrc, hrc);
+
+ /*
+ * Check the attchments to see if we've got a device 0 attached on port 0.
+ *
+ * While we're at it we eject flppies from all floppy drives we encounter,
+ * we don't want any confusion at boot or during installation.
+ */
+ com::SafeIfaceArray<IMediumAttachment> arrayOfMediumAttachments;
+ hrc = rPtrSessionMachine->GetMediumAttachmentsOfController(bstrControllerName.raw(),
+ ComSafeArrayAsOutParam(arrayOfMediumAttachments));
+ AssertComRCReturn(hrc, hrc);
+ strControllerName = bstrControllerName;
+ AssertLogRelReturn(strControllerName.isNotEmpty(), setErrorBoth(E_UNEXPECTED, VERR_INTERNAL_ERROR_2));
+
+ for (size_t j = 0; j < arrayOfMediumAttachments.size(); j++)
+ {
+ LONG iPort = -1;
+ hrc = arrayOfMediumAttachments[j]->COMGETTER(Port)(&iPort);
+ AssertComRCReturn(hrc, hrc);
+
+ LONG iDevice = -1;
+ hrc = arrayOfMediumAttachments[j]->COMGETTER(Device)(&iDevice);
+ AssertComRCReturn(hrc, hrc);
+
+ DeviceType_T enmType;
+ hrc = arrayOfMediumAttachments[j]->COMGETTER(Type)(&enmType);
+ AssertComRCReturn(hrc, hrc);
+
+ if (enmType == DeviceType_Floppy)
+ {
+ ComPtr<IMedium> ptrMedium;
+ hrc = arrayOfMediumAttachments[j]->COMGETTER(Medium)(ptrMedium.asOutParam());
+ AssertComRCReturn(hrc, hrc);
+
+ if (ptrMedium.isNotNull())
+ {
+ ptrMedium.setNull();
+ rAutoLock.release();
+ hrc = rPtrSessionMachine->UnmountMedium(bstrControllerName.raw(), iPort, iDevice, TRUE /*fForce*/);
+ rAutoLock.acquire();
+ }
+
+ if (iPort == 0 && iDevice == 0)
+ fFoundPort0Dev0 = true;
+ }
+ else if (iPort == 0 && iDevice == 0)
+ return setError(E_FAIL,
+ tr("Found non-floppy device attached to port 0 device 0 on the floppy controller '%ls'"),
+ bstrControllerName.raw());
+ }
+ }
+ }
+
+ /*
+ * Add a floppy controller if we need to.
+ */
+ if (strControllerName.isEmpty())
+ {
+ bstrControllerName = strControllerName = "Floppy";
+ ComPtr<IStorageController> ptrControllerIgnored;
+ HRESULT hrc = rPtrSessionMachine->AddStorageController(bstrControllerName.raw(), StorageBus_Floppy,
+ ptrControllerIgnored.asOutParam());
+ LogRelFunc(("Machine::addStorageController(Floppy) -> %Rhrc \n", hrc));
+ if (FAILED(hrc))
+ return hrc;
+ }
+
+ /*
+ * Adding a floppy drive (if needed) and mounting the auxiliary image is
+ * done later together with the ISOs.
+ */
+ rVecInstallatationDisks.push_back(UnattendedInstallationDisk(StorageBus_Floppy, strControllerName,
+ DeviceType_Floppy, AccessMode_ReadWrite,
+ 0, 0,
+ fFoundPort0Dev0 /*fMountOnly*/,
+ mpInstaller->getAuxiliaryFloppyFilePath(), false));
+ return S_OK;
+}
+
+/**
+ * Reconfigures DVD drives of the VM to mount all the ISOs we need.
+ *
+ * This will umount all DVD media.
+ *
+ * @returns COM status code.
+ * @param rControllers The existing controllers.
+ * @param rVecInstallatationDisks The list of image to mount.
+ * @param rPtrSessionMachine The session machine smart pointer.
+ * @param rAutoLock The lock.
+ * @param enmRecommendedStorageBus The recommended storage bus type for adding
+ * DVD drives on.
+ */
+HRESULT Unattended::i_reconfigureIsos(com::SafeIfaceArray<IStorageController> &rControllers,
+ std::vector<UnattendedInstallationDisk> &rVecInstallatationDisks,
+ ComPtr<IMachine> const &rPtrSessionMachine,
+ AutoMultiWriteLock2 &rAutoLock, StorageBus_T enmRecommendedStorageBus)
+{
+ /*
+ * Enumerate the attachements of every controller, looking for DVD drives,
+ * ASSUMEING all drives are bootable.
+ *
+ * Eject the medium from all the drives (don't want any confusion) and look
+ * for the recommended storage bus in case we need to add more drives.
+ */
+ HRESULT hrc;
+ std::list<ControllerSlot> lstControllerDvdSlots;
+ Utf8Str strRecommendedControllerName; /* non-empty if recommended bus found. */
+ Utf8Str strControllerName;
+ Bstr bstrControllerName;
+ for (size_t i = 0; i < rControllers.size(); ++i)
+ {
+ hrc = rControllers[i]->COMGETTER(Name)(bstrControllerName.asOutParam());
+ AssertComRCReturn(hrc, hrc);
+ strControllerName = bstrControllerName;
+
+ /* Look for recommended storage bus. */
+ StorageBus_T enmStorageBus;
+ hrc = rControllers[i]->COMGETTER(Bus)(&enmStorageBus);
+ AssertComRCReturn(hrc, hrc);
+ if (enmStorageBus == enmRecommendedStorageBus)
+ {
+ strRecommendedControllerName = bstrControllerName;
+ AssertLogRelReturn(strControllerName.isNotEmpty(), setErrorBoth(E_UNEXPECTED, VERR_INTERNAL_ERROR_2));
+ }
+
+ /* Scan the controller attachments. */
+ com::SafeIfaceArray<IMediumAttachment> arrayOfMediumAttachments;
+ hrc = rPtrSessionMachine->GetMediumAttachmentsOfController(bstrControllerName.raw(),
+ ComSafeArrayAsOutParam(arrayOfMediumAttachments));
+ AssertComRCReturn(hrc, hrc);
+
+ for (size_t j = 0; j < arrayOfMediumAttachments.size(); j++)
+ {
+ DeviceType_T enmType;
+ hrc = arrayOfMediumAttachments[j]->COMGETTER(Type)(&enmType);
+ AssertComRCReturn(hrc, hrc);
+ if (enmType == DeviceType_DVD)
+ {
+ LONG iPort = -1;
+ hrc = arrayOfMediumAttachments[j]->COMGETTER(Port)(&iPort);
+ AssertComRCReturn(hrc, hrc);
+
+ LONG iDevice = -1;
+ hrc = arrayOfMediumAttachments[j]->COMGETTER(Device)(&iDevice);
+ AssertComRCReturn(hrc, hrc);
+
+ /* Remeber it. */
+ lstControllerDvdSlots.push_back(ControllerSlot(enmStorageBus, strControllerName, iPort, iDevice, false /*fFree*/));
+
+ /* Eject the medium, if any. */
+ ComPtr<IMedium> ptrMedium;
+ hrc = arrayOfMediumAttachments[j]->COMGETTER(Medium)(ptrMedium.asOutParam());
+ AssertComRCReturn(hrc, hrc);
+ if (ptrMedium.isNotNull())
+ {
+ ptrMedium.setNull();
+
+ rAutoLock.release();
+ hrc = rPtrSessionMachine->UnmountMedium(bstrControllerName.raw(), iPort, iDevice, TRUE /*fForce*/);
+ rAutoLock.acquire();
+ }
+ }
+ }
+ }
+
+ /*
+ * How many drives do we need? Add more if necessary.
+ */
+ ULONG cDvdDrivesNeeded = 0;
+ if (mpInstaller->isAuxiliaryIsoNeeded())
+ cDvdDrivesNeeded++;
+ if (mpInstaller->isOriginalIsoNeeded())
+ cDvdDrivesNeeded++;
+#if 0 /* These are now in the AUX VISO. */
+ if (mpInstaller->isAdditionsIsoNeeded())
+ cDvdDrivesNeeded++;
+ if (mpInstaller->isValidationKitIsoNeeded())
+ cDvdDrivesNeeded++;
+#endif
+ Assert(cDvdDrivesNeeded > 0);
+ if (cDvdDrivesNeeded > lstControllerDvdSlots.size())
+ {
+ /* Do we need to add the recommended controller? */
+ if (strRecommendedControllerName.isEmpty())
+ {
+ switch (enmRecommendedStorageBus)
+ {
+ case StorageBus_IDE: strRecommendedControllerName = "IDE"; break;
+ case StorageBus_SATA: strRecommendedControllerName = "SATA"; break;
+ case StorageBus_SCSI: strRecommendedControllerName = "SCSI"; break;
+ case StorageBus_SAS: strRecommendedControllerName = "SAS"; break;
+ case StorageBus_USB: strRecommendedControllerName = "USB"; break;
+ case StorageBus_PCIe: strRecommendedControllerName = "PCIe"; break;
+ default:
+ return setError(E_FAIL, tr("Support for recommended storage bus %d not implemented"),
+ (int)enmRecommendedStorageBus);
+ }
+ ComPtr<IStorageController> ptrControllerIgnored;
+ hrc = rPtrSessionMachine->AddStorageController(Bstr(strRecommendedControllerName).raw(), enmRecommendedStorageBus,
+ ptrControllerIgnored.asOutParam());
+ LogRelFunc(("Machine::addStorageController(%s) -> %Rhrc \n", strRecommendedControllerName.c_str(), hrc));
+ if (FAILED(hrc))
+ return hrc;
+ }
+
+ /* Add free controller slots, maybe raising the port limit on the controller if we can. */
+ hrc = i_findOrCreateNeededFreeSlots(strRecommendedControllerName, enmRecommendedStorageBus, rPtrSessionMachine,
+ cDvdDrivesNeeded, lstControllerDvdSlots);
+ if (FAILED(hrc))
+ return hrc;
+ if (cDvdDrivesNeeded > lstControllerDvdSlots.size())
+ {
+ /* We could in many cases create another controller here, but it's not worth the effort. */
+ return setError(E_FAIL, tr("Not enough free slots on controller '%s' to add %u DVD drive(s)", "",
+ cDvdDrivesNeeded - lstControllerDvdSlots.size()),
+ strRecommendedControllerName.c_str(), cDvdDrivesNeeded - lstControllerDvdSlots.size());
+ }
+ Assert(cDvdDrivesNeeded == lstControllerDvdSlots.size());
+ }
+
+ /*
+ * Sort the DVD slots in boot order.
+ */
+ lstControllerDvdSlots.sort();
+
+ /*
+ * Prepare ISO mounts.
+ *
+ * Boot order depends on bootFromAuxiliaryIso() and we must grab DVD slots
+ * according to the boot order.
+ */
+ std::list<ControllerSlot>::const_iterator itDvdSlot = lstControllerDvdSlots.begin();
+ if (mpInstaller->isAuxiliaryIsoNeeded() && mpInstaller->bootFromAuxiliaryIso())
+ {
+ rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, mpInstaller->getAuxiliaryIsoFilePath(), true));
+ ++itDvdSlot;
+ }
+
+ if (mpInstaller->isOriginalIsoNeeded())
+ {
+ rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, i_getIsoPath(), false));
+ ++itDvdSlot;
+ }
+
+ if (mpInstaller->isAuxiliaryIsoNeeded() && !mpInstaller->bootFromAuxiliaryIso())
+ {
+ rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, mpInstaller->getAuxiliaryIsoFilePath(), true));
+ ++itDvdSlot;
+ }
+
+#if 0 /* These are now in the AUX VISO. */
+ if (mpInstaller->isAdditionsIsoNeeded())
+ {
+ rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, i_getAdditionsIsoPath(), false));
+ ++itDvdSlot;
+ }
+
+ if (mpInstaller->isValidationKitIsoNeeded())
+ {
+ rVecInstallatationDisks.push_back(UnattendedInstallationDisk(itDvdSlot, i_getValidationKitIsoPath(), false));
+ ++itDvdSlot;
+ }
+#endif
+
+ return S_OK;
+}
+
+/**
+ * Used to find more free slots for DVD drives during VM reconfiguration.
+ *
+ * This may modify the @a portCount property of the given controller.
+ *
+ * @returns COM status code.
+ * @param rStrControllerName The name of the controller to find/create
+ * free slots on.
+ * @param enmStorageBus The storage bus type.
+ * @param rPtrSessionMachine Reference to the session machine.
+ * @param cSlotsNeeded Total slots needed (including those we've
+ * already found).
+ * @param rDvdSlots The slot collection for DVD drives to add
+ * free slots to as we find/create them.
+ */
+HRESULT Unattended::i_findOrCreateNeededFreeSlots(const Utf8Str &rStrControllerName, StorageBus_T enmStorageBus,
+ ComPtr<IMachine> const &rPtrSessionMachine, uint32_t cSlotsNeeded,
+ std::list<ControllerSlot> &rDvdSlots)
+{
+ Assert(cSlotsNeeded > rDvdSlots.size());
+
+ /*
+ * Get controlleer stats.
+ */
+ ComPtr<IStorageController> pController;
+ HRESULT hrc = rPtrSessionMachine->GetStorageControllerByName(Bstr(rStrControllerName).raw(), pController.asOutParam());
+ AssertComRCReturn(hrc, hrc);
+
+ ULONG cMaxDevicesPerPort = 1;
+ hrc = pController->COMGETTER(MaxDevicesPerPortCount)(&cMaxDevicesPerPort);
+ AssertComRCReturn(hrc, hrc);
+ AssertLogRelReturn(cMaxDevicesPerPort > 0, E_UNEXPECTED);
+
+ ULONG cPorts = 0;
+ hrc = pController->COMGETTER(PortCount)(&cPorts);
+ AssertComRCReturn(hrc, hrc);
+
+ /*
+ * Get the attachment list and turn into an internal list for lookup speed.
+ */
+ com::SafeIfaceArray<IMediumAttachment> arrayOfMediumAttachments;
+ hrc = rPtrSessionMachine->GetMediumAttachmentsOfController(Bstr(rStrControllerName).raw(),
+ ComSafeArrayAsOutParam(arrayOfMediumAttachments));
+ AssertComRCReturn(hrc, hrc);
+
+ std::vector<ControllerSlot> arrayOfUsedSlots;
+ for (size_t i = 0; i < arrayOfMediumAttachments.size(); i++)
+ {
+ LONG iPort = -1;
+ hrc = arrayOfMediumAttachments[i]->COMGETTER(Port)(&iPort);
+ AssertComRCReturn(hrc, hrc);
+
+ LONG iDevice = -1;
+ hrc = arrayOfMediumAttachments[i]->COMGETTER(Device)(&iDevice);
+ AssertComRCReturn(hrc, hrc);
+
+ arrayOfUsedSlots.push_back(ControllerSlot(enmStorageBus, Utf8Str::Empty, iPort, iDevice, false /*fFree*/));
+ }
+
+ /*
+ * Iterate thru all possible slots, adding those not found in arrayOfUsedSlots.
+ */
+ for (int32_t iPort = 0; iPort < (int32_t)cPorts; iPort++)
+ for (int32_t iDevice = 0; iDevice < (int32_t)cMaxDevicesPerPort; iDevice++)
+ {
+ bool fFound = false;
+ for (size_t i = 0; i < arrayOfUsedSlots.size(); i++)
+ if ( arrayOfUsedSlots[i].iPort == iPort
+ && arrayOfUsedSlots[i].iDevice == iDevice)
+ {
+ fFound = true;
+ break;
+ }
+ if (!fFound)
+ {
+ rDvdSlots.push_back(ControllerSlot(enmStorageBus, rStrControllerName, iPort, iDevice, true /*fFree*/));
+ if (rDvdSlots.size() >= cSlotsNeeded)
+ return S_OK;
+ }
+ }
+
+ /*
+ * Okay we still need more ports. See if increasing the number of controller
+ * ports would solve it.
+ */
+ ULONG cMaxPorts = 1;
+ hrc = pController->COMGETTER(MaxPortCount)(&cMaxPorts);
+ AssertComRCReturn(hrc, hrc);
+ if (cMaxPorts <= cPorts)
+ return S_OK;
+ size_t cNewPortsNeeded = (cSlotsNeeded - rDvdSlots.size() + cMaxDevicesPerPort - 1) / cMaxDevicesPerPort;
+ if (cPorts + cNewPortsNeeded > cMaxPorts)
+ return S_OK;
+
+ /*
+ * Raise the port count and add the free slots we've just created.
+ */
+ hrc = pController->COMSETTER(PortCount)(cPorts + (ULONG)cNewPortsNeeded);
+ AssertComRCReturn(hrc, hrc);
+ int32_t const cPortsNew = (int32_t)(cPorts + cNewPortsNeeded);
+ for (int32_t iPort = (int32_t)cPorts; iPort < cPortsNew; iPort++)
+ for (int32_t iDevice = 0; iDevice < (int32_t)cMaxDevicesPerPort; iDevice++)
+ {
+ rDvdSlots.push_back(ControllerSlot(enmStorageBus, rStrControllerName, iPort, iDevice, true /*fFree*/));
+ if (rDvdSlots.size() >= cSlotsNeeded)
+ return S_OK;
+ }
+
+ /* We should not get here! */
+ AssertLogRelFailedReturn(E_UNEXPECTED);
+}
+
+HRESULT Unattended::done()
+{
+ LogFlow(("Unattended::done\n"));
+ if (mpInstaller)
+ {
+ LogRelFlow(("Unattended::done: Deleting installer object (%p)\n", mpInstaller));
+ delete mpInstaller;
+ mpInstaller = NULL;
+ }
+ return S_OK;
+}
+
+HRESULT Unattended::getIsoPath(com::Utf8Str &isoPath)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ isoPath = mStrIsoPath;
+ return S_OK;
+}
+
+HRESULT Unattended::setIsoPath(const com::Utf8Str &isoPath)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrIsoPath = isoPath;
+ mfDoneDetectIsoOS = false;
+ return S_OK;
+}
+
+HRESULT Unattended::getUser(com::Utf8Str &user)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ user = mStrUser;
+ return S_OK;
+}
+
+
+HRESULT Unattended::setUser(const com::Utf8Str &user)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrUser = user;
+ return S_OK;
+}
+
+HRESULT Unattended::getPassword(com::Utf8Str &password)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ password = mStrPassword;
+ return S_OK;
+}
+
+HRESULT Unattended::setPassword(const com::Utf8Str &password)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrPassword = password;
+ return S_OK;
+}
+
+HRESULT Unattended::getFullUserName(com::Utf8Str &fullUserName)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ fullUserName = mStrFullUserName;
+ return S_OK;
+}
+
+HRESULT Unattended::setFullUserName(const com::Utf8Str &fullUserName)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrFullUserName = fullUserName;
+ return S_OK;
+}
+
+HRESULT Unattended::getProductKey(com::Utf8Str &productKey)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ productKey = mStrProductKey;
+ return S_OK;
+}
+
+HRESULT Unattended::setProductKey(const com::Utf8Str &productKey)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrProductKey = productKey;
+ return S_OK;
+}
+
+HRESULT Unattended::getAdditionsIsoPath(com::Utf8Str &additionsIsoPath)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ additionsIsoPath = mStrAdditionsIsoPath;
+ return S_OK;
+}
+
+HRESULT Unattended::setAdditionsIsoPath(const com::Utf8Str &additionsIsoPath)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrAdditionsIsoPath = additionsIsoPath;
+ return S_OK;
+}
+
+HRESULT Unattended::getInstallGuestAdditions(BOOL *installGuestAdditions)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ *installGuestAdditions = mfInstallGuestAdditions;
+ return S_OK;
+}
+
+HRESULT Unattended::setInstallGuestAdditions(BOOL installGuestAdditions)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mfInstallGuestAdditions = installGuestAdditions != FALSE;
+ return S_OK;
+}
+
+HRESULT Unattended::getValidationKitIsoPath(com::Utf8Str &aValidationKitIsoPath)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aValidationKitIsoPath = mStrValidationKitIsoPath;
+ return S_OK;
+}
+
+HRESULT Unattended::setValidationKitIsoPath(const com::Utf8Str &aValidationKitIsoPath)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrValidationKitIsoPath = aValidationKitIsoPath;
+ return S_OK;
+}
+
+HRESULT Unattended::getInstallTestExecService(BOOL *aInstallTestExecService)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ *aInstallTestExecService = mfInstallTestExecService;
+ return S_OK;
+}
+
+HRESULT Unattended::setInstallTestExecService(BOOL aInstallTestExecService)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mfInstallTestExecService = aInstallTestExecService != FALSE;
+ return S_OK;
+}
+
+HRESULT Unattended::getTimeZone(com::Utf8Str &aTimeZone)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aTimeZone = mStrTimeZone;
+ return S_OK;
+}
+
+HRESULT Unattended::setTimeZone(const com::Utf8Str &aTimezone)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrTimeZone = aTimezone;
+ return S_OK;
+}
+
+HRESULT Unattended::getLocale(com::Utf8Str &aLocale)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aLocale = mStrLocale;
+ return S_OK;
+}
+
+HRESULT Unattended::setLocale(const com::Utf8Str &aLocale)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ if ( aLocale.isEmpty() /* use default */
+ || ( aLocale.length() == 5
+ && RT_C_IS_LOWER(aLocale[0])
+ && RT_C_IS_LOWER(aLocale[1])
+ && aLocale[2] == '_'
+ && RT_C_IS_UPPER(aLocale[3])
+ && RT_C_IS_UPPER(aLocale[4])) )
+ {
+ mStrLocale = aLocale;
+ return S_OK;
+ }
+ return setError(E_INVALIDARG, tr("Expected two lower cased letters, an underscore, and two upper cased letters"));
+}
+
+HRESULT Unattended::getLanguage(com::Utf8Str &aLanguage)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aLanguage = mStrLanguage;
+ return S_OK;
+}
+
+HRESULT Unattended::setLanguage(const com::Utf8Str &aLanguage)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrLanguage = aLanguage;
+ return S_OK;
+}
+
+HRESULT Unattended::getCountry(com::Utf8Str &aCountry)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aCountry = mStrCountry;
+ return S_OK;
+}
+
+HRESULT Unattended::setCountry(const com::Utf8Str &aCountry)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ if ( aCountry.isEmpty()
+ || ( aCountry.length() == 2
+ && RT_C_IS_UPPER(aCountry[0])
+ && RT_C_IS_UPPER(aCountry[1])) )
+ {
+ mStrCountry = aCountry;
+ return S_OK;
+ }
+ return setError(E_INVALIDARG, tr("Expected two upper cased letters"));
+}
+
+HRESULT Unattended::getProxy(com::Utf8Str &aProxy)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aProxy = mStrProxy; /// @todo turn schema map into string or something.
+ return S_OK;
+}
+
+HRESULT Unattended::setProxy(const com::Utf8Str &aProxy)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ if (aProxy.isEmpty())
+ {
+ /* set default proxy */
+ /** @todo BUGBUG! implement this */
+ }
+ else if (aProxy.equalsIgnoreCase("none"))
+ {
+ /* clear proxy config */
+ mStrProxy.setNull();
+ }
+ else
+ {
+ /** @todo Parse and set proxy config into a schema map or something along those lines. */
+ /** @todo BUGBUG! implement this */
+ // return E_NOTIMPL;
+ mStrProxy = aProxy;
+ }
+ return S_OK;
+}
+
+HRESULT Unattended::getPackageSelectionAdjustments(com::Utf8Str &aPackageSelectionAdjustments)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aPackageSelectionAdjustments = RTCString::join(mPackageSelectionAdjustments, ";");
+ return S_OK;
+}
+
+HRESULT Unattended::setPackageSelectionAdjustments(const com::Utf8Str &aPackageSelectionAdjustments)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ if (aPackageSelectionAdjustments.isEmpty())
+ mPackageSelectionAdjustments.clear();
+ else
+ {
+ RTCList<RTCString, RTCString *> arrayStrSplit = aPackageSelectionAdjustments.split(";");
+ for (size_t i = 0; i < arrayStrSplit.size(); i++)
+ {
+ if (arrayStrSplit[i].equals("minimal"))
+ { /* okay */ }
+ else
+ return setError(E_INVALIDARG, tr("Unknown keyword: %s"), arrayStrSplit[i].c_str());
+ }
+ mPackageSelectionAdjustments = arrayStrSplit;
+ }
+ return S_OK;
+}
+
+HRESULT Unattended::getHostname(com::Utf8Str &aHostname)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aHostname = mStrHostname;
+ return S_OK;
+}
+
+HRESULT Unattended::setHostname(const com::Utf8Str &aHostname)
+{
+ /*
+ * Validate input.
+ */
+ if (aHostname.length() > (aHostname.endsWith(".") ? 254U : 253U))
+ return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
+ tr("Hostname '%s' is %zu bytes long, max is 253 (excluding trailing dot)", "", aHostname.length()),
+ aHostname.c_str(), aHostname.length());
+ size_t cLabels = 0;
+ const char *pszSrc = aHostname.c_str();
+ for (;;)
+ {
+ size_t cchLabel = 1;
+ char ch = *pszSrc++;
+ if (RT_C_IS_ALNUM(ch))
+ {
+ cLabels++;
+ while ((ch = *pszSrc++) != '.' && ch != '\0')
+ {
+ if (RT_C_IS_ALNUM(ch) || ch == '-')
+ {
+ if (cchLabel < 63)
+ cchLabel++;
+ else
+ return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
+ tr("Invalid hostname '%s' - label %u is too long, max is 63."),
+ aHostname.c_str(), cLabels);
+ }
+ else
+ return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
+ tr("Invalid hostname '%s' - illegal char '%c' at position %zu"),
+ aHostname.c_str(), ch, pszSrc - aHostname.c_str() - 1);
+ }
+ if (cLabels == 1 && cchLabel < 2)
+ return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
+ tr("Invalid hostname '%s' - the name part must be at least two characters long"),
+ aHostname.c_str());
+ if (ch == '\0')
+ break;
+ }
+ else if (ch != '\0')
+ return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
+ tr("Invalid hostname '%s' - illegal lead char '%c' at position %zu"),
+ aHostname.c_str(), ch, pszSrc - aHostname.c_str() - 1);
+ else
+ return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
+ tr("Invalid hostname '%s' - trailing dot not permitted"), aHostname.c_str());
+ }
+ if (cLabels < 2)
+ return setErrorBoth(E_INVALIDARG, VERR_INVALID_NAME,
+ tr("Incomplete hostname '%s' - must include both a name and a domain"), aHostname.c_str());
+
+ /*
+ * Make the change.
+ */
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrHostname = aHostname;
+ return S_OK;
+}
+
+HRESULT Unattended::getAuxiliaryBasePath(com::Utf8Str &aAuxiliaryBasePath)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aAuxiliaryBasePath = mStrAuxiliaryBasePath;
+ return S_OK;
+}
+
+HRESULT Unattended::setAuxiliaryBasePath(const com::Utf8Str &aAuxiliaryBasePath)
+{
+ if (aAuxiliaryBasePath.isEmpty())
+ return setError(E_INVALIDARG, tr("Empty base path is not allowed"));
+ if (!RTPathStartsWithRoot(aAuxiliaryBasePath.c_str()))
+ return setError(E_INVALIDARG, tr("Base path must be absolute"));
+
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrAuxiliaryBasePath = aAuxiliaryBasePath;
+ mfIsDefaultAuxiliaryBasePath = mStrAuxiliaryBasePath.isEmpty();
+ return S_OK;
+}
+
+HRESULT Unattended::getImageIndex(ULONG *index)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ *index = midxImage;
+ return S_OK;
+}
+
+HRESULT Unattended::setImageIndex(ULONG index)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+
+ /* Validate the selection if detection was done already: */
+ if (mDetectedImages.size() > 0)
+ {
+ for (size_t i = 0; i < mDetectedImages.size(); i++)
+ if (mDetectedImages[i].mImageIndex == index)
+ {
+ midxImage = index;
+ i_updateDetectedAttributeForImage(mDetectedImages[i]);
+ return S_OK;
+ }
+ LogRel(("Unattended: Setting invalid index=%u\n", index)); /** @todo fail? */
+ }
+
+ midxImage = index;
+ return S_OK;
+}
+
+HRESULT Unattended::getMachine(ComPtr<IMachine> &aMachine)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ return mMachine.queryInterfaceTo(aMachine.asOutParam());
+}
+
+HRESULT Unattended::setMachine(const ComPtr<IMachine> &aMachine)
+{
+ /*
+ * Lookup the VM so we can safely get the Machine instance.
+ * (Don't want to test how reliable XPCOM and COM are with finding
+ * the local object instance when a client passes a stub back.)
+ */
+ Bstr bstrUuidMachine;
+ HRESULT hrc = aMachine->COMGETTER(Id)(bstrUuidMachine.asOutParam());
+ if (SUCCEEDED(hrc))
+ {
+ Guid UuidMachine(bstrUuidMachine);
+ ComObjPtr<Machine> ptrMachine;
+ hrc = mParent->i_findMachine(UuidMachine, false /*fPermitInaccessible*/, true /*aSetError*/, &ptrMachine);
+ if (SUCCEEDED(hrc))
+ {
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER,
+ tr("Cannot change after prepare() has been called")));
+ mMachine = ptrMachine;
+ mMachineUuid = UuidMachine;
+ if (mfIsDefaultAuxiliaryBasePath)
+ mStrAuxiliaryBasePath.setNull();
+ hrc = S_OK;
+ }
+ }
+ return hrc;
+}
+
+HRESULT Unattended::getScriptTemplatePath(com::Utf8Str &aScriptTemplatePath)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ if ( mStrScriptTemplatePath.isNotEmpty()
+ || mpInstaller == NULL)
+ aScriptTemplatePath = mStrScriptTemplatePath;
+ else
+ aScriptTemplatePath = mpInstaller->getTemplateFilePath();
+ return S_OK;
+}
+
+HRESULT Unattended::setScriptTemplatePath(const com::Utf8Str &aScriptTemplatePath)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrScriptTemplatePath = aScriptTemplatePath;
+ return S_OK;
+}
+
+HRESULT Unattended::getPostInstallScriptTemplatePath(com::Utf8Str &aPostInstallScriptTemplatePath)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ if ( mStrPostInstallScriptTemplatePath.isNotEmpty()
+ || mpInstaller == NULL)
+ aPostInstallScriptTemplatePath = mStrPostInstallScriptTemplatePath;
+ else
+ aPostInstallScriptTemplatePath = mpInstaller->getPostTemplateFilePath();
+ return S_OK;
+}
+
+HRESULT Unattended::setPostInstallScriptTemplatePath(const com::Utf8Str &aPostInstallScriptTemplatePath)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrPostInstallScriptTemplatePath = aPostInstallScriptTemplatePath;
+ return S_OK;
+}
+
+HRESULT Unattended::getPostInstallCommand(com::Utf8Str &aPostInstallCommand)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aPostInstallCommand = mStrPostInstallCommand;
+ return S_OK;
+}
+
+HRESULT Unattended::setPostInstallCommand(const com::Utf8Str &aPostInstallCommand)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrPostInstallCommand = aPostInstallCommand;
+ return S_OK;
+}
+
+HRESULT Unattended::getExtraInstallKernelParameters(com::Utf8Str &aExtraInstallKernelParameters)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ if ( mStrExtraInstallKernelParameters.isNotEmpty()
+ || mpInstaller == NULL)
+ aExtraInstallKernelParameters = mStrExtraInstallKernelParameters;
+ else
+ aExtraInstallKernelParameters = mpInstaller->getDefaultExtraInstallKernelParameters();
+ return S_OK;
+}
+
+HRESULT Unattended::setExtraInstallKernelParameters(const com::Utf8Str &aExtraInstallKernelParameters)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mStrExtraInstallKernelParameters = aExtraInstallKernelParameters;
+ return S_OK;
+}
+
+HRESULT Unattended::getDetectedOSTypeId(com::Utf8Str &aDetectedOSTypeId)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aDetectedOSTypeId = mStrDetectedOSTypeId;
+ return S_OK;
+}
+
+HRESULT Unattended::getDetectedOSVersion(com::Utf8Str &aDetectedOSVersion)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aDetectedOSVersion = mStrDetectedOSVersion;
+ return S_OK;
+}
+
+HRESULT Unattended::getDetectedOSFlavor(com::Utf8Str &aDetectedOSFlavor)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aDetectedOSFlavor = mStrDetectedOSFlavor;
+ return S_OK;
+}
+
+HRESULT Unattended::getDetectedOSLanguages(com::Utf8Str &aDetectedOSLanguages)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aDetectedOSLanguages = RTCString::join(mDetectedOSLanguages, " ");
+ return S_OK;
+}
+
+HRESULT Unattended::getDetectedOSHints(com::Utf8Str &aDetectedOSHints)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aDetectedOSHints = mStrDetectedOSHints;
+ return S_OK;
+}
+
+HRESULT Unattended::getDetectedImageNames(std::vector<com::Utf8Str> &aDetectedImageNames)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aDetectedImageNames.clear();
+ for (size_t i = 0; i < mDetectedImages.size(); ++i)
+ {
+ Utf8Str strTmp;
+ aDetectedImageNames.push_back(mDetectedImages[i].formatName(strTmp));
+ }
+ return S_OK;
+}
+
+HRESULT Unattended::getDetectedImageIndices(std::vector<ULONG> &aDetectedImageIndices)
+{
+ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+ aDetectedImageIndices.clear();
+ for (size_t i = 0; i < mDetectedImages.size(); ++i)
+ aDetectedImageIndices.push_back(mDetectedImages[i].mImageIndex);
+ return S_OK;
+}
+
+HRESULT Unattended::getIsUnattendedInstallSupported(BOOL *aIsUnattendedInstallSupported)
+{
+ /*
+ * Take the initial position that it's not supported, so we can return
+ * right away when we decide it's not possible.
+ */
+ *aIsUnattendedInstallSupported = false;
+
+ /* Unattended is disabled by default if we could not detect OS type. */
+ if (mStrDetectedOSTypeId.isEmpty())
+ return S_OK;
+
+ const VBOXOSTYPE enmOsTypeMasked = (VBOXOSTYPE)(mEnmOsType & VBOXOSTYPE_OsTypeMask);
+
+ /* We require a version to have been detected, except for windows where the
+ field is generally only used for the service pack number at present and
+ will be empty for RTMs isos. */
+ if ( ( enmOsTypeMasked <= VBOXOSTYPE_WinNT
+ || enmOsTypeMasked >= VBOXOSTYPE_OS2)
+ && mStrDetectedOSVersion.isEmpty())
+ return S_OK;
+
+ /*
+ * Sort out things that we know doesn't work. Order by VBOXOSTYPE value.
+ */
+
+ /* We do not support any of the DOS based windows version, nor DOS, in case
+ any of that gets detected (it shouldn't): */
+ if (enmOsTypeMasked >= VBOXOSTYPE_DOS && enmOsTypeMasked < VBOXOSTYPE_WinNT)
+ return S_OK;
+
+ /* Windows NT 3.x doesn't work, also skip unknown windows NT version: */
+ if (enmOsTypeMasked >= VBOXOSTYPE_WinNT && enmOsTypeMasked < VBOXOSTYPE_WinNT4)
+ return S_OK;
+
+ /* For OS/2 we only support OS2 4.5 (actually only 4.52 server has been
+ tested, but we'll get to the others eventually): */
+ if ( enmOsTypeMasked >= VBOXOSTYPE_OS2
+ && enmOsTypeMasked < VBOXOSTYPE_Linux
+ && enmOsTypeMasked != VBOXOSTYPE_OS2Warp45 /* probably works */ )
+ return S_OK;
+
+ /* Old Debians fail since package repos have been move to some other mirror location. */
+ if ( enmOsTypeMasked == VBOXOSTYPE_Debian
+ && RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "9.0") < 0)
+ return S_OK;
+
+ /* Skip all OpenSUSE variants for now. */
+ if (enmOsTypeMasked == VBOXOSTYPE_OpenSUSE)
+ return S_OK;
+
+ if (enmOsTypeMasked == VBOXOSTYPE_Ubuntu)
+ {
+ /* We cannot install Ubuntus older than 11.04. */
+ if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "11.04") < 0)
+ return S_OK;
+ /* Lubuntu, starting with 20.04, has switched to calamares, which cannot be automated. */
+ if ( RTStrIStr(mStrDetectedOSFlavor.c_str(), "lubuntu")
+ && RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "20.04") > 0)
+ return S_OK;
+ }
+
+ /* Earlier than OL 6.4 cannot be installed. OL 6.x fails with unsupported hardware error (CPU family). */
+ if ( enmOsTypeMasked == VBOXOSTYPE_Oracle
+ && RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "6.4") < 0)
+ return S_OK;
+
+ /* Fredora ISOs cannot be installed at present. */
+ if (enmOsTypeMasked == VBOXOSTYPE_FedoraCore)
+ return S_OK;
+
+ /*
+ * Assume the rest works.
+ */
+ *aIsUnattendedInstallSupported = true;
+ return S_OK;
+}
+
+HRESULT Unattended::getAvoidUpdatesOverNetwork(BOOL *aAvoidUpdatesOverNetwork)
+{
+ *aAvoidUpdatesOverNetwork = mfAvoidUpdatesOverNetwork;
+ return S_OK;
+}
+
+HRESULT Unattended::setAvoidUpdatesOverNetwork(BOOL aAvoidUpdatesOverNetwork)
+{
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ AssertReturn(mpInstaller == NULL, setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("Cannot change after prepare() has been called")));
+ mfAvoidUpdatesOverNetwork = RT_BOOL(aAvoidUpdatesOverNetwork);
+ return S_OK;
+}
+
+/*
+ * Getters that the installer and script classes can use.
+ */
+Utf8Str const &Unattended::i_getIsoPath() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrIsoPath;
+}
+
+Utf8Str const &Unattended::i_getUser() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrUser;
+}
+
+Utf8Str const &Unattended::i_getPassword() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrPassword;
+}
+
+Utf8Str const &Unattended::i_getFullUserName() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrFullUserName.isNotEmpty() ? mStrFullUserName : mStrUser;
+}
+
+Utf8Str const &Unattended::i_getProductKey() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrProductKey;
+}
+
+Utf8Str const &Unattended::i_getProxy() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrProxy;
+}
+
+Utf8Str const &Unattended::i_getAdditionsIsoPath() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrAdditionsIsoPath;
+}
+
+bool Unattended::i_getInstallGuestAdditions() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mfInstallGuestAdditions;
+}
+
+Utf8Str const &Unattended::i_getValidationKitIsoPath() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrValidationKitIsoPath;
+}
+
+bool Unattended::i_getInstallTestExecService() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mfInstallTestExecService;
+}
+
+Utf8Str const &Unattended::i_getTimeZone() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrTimeZone;
+}
+
+PCRTTIMEZONEINFO Unattended::i_getTimeZoneInfo() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mpTimeZoneInfo;
+}
+
+Utf8Str const &Unattended::i_getLocale() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrLocale;
+}
+
+Utf8Str const &Unattended::i_getLanguage() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrLanguage;
+}
+
+Utf8Str const &Unattended::i_getCountry() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrCountry;
+}
+
+bool Unattended::i_isMinimalInstallation() const
+{
+ size_t i = mPackageSelectionAdjustments.size();
+ while (i-- > 0)
+ if (mPackageSelectionAdjustments[i].equals("minimal"))
+ return true;
+ return false;
+}
+
+Utf8Str const &Unattended::i_getHostname() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrHostname;
+}
+
+Utf8Str const &Unattended::i_getAuxiliaryBasePath() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrAuxiliaryBasePath;
+}
+
+ULONG Unattended::i_getImageIndex() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return midxImage;
+}
+
+Utf8Str const &Unattended::i_getScriptTemplatePath() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrScriptTemplatePath;
+}
+
+Utf8Str const &Unattended::i_getPostInstallScriptTemplatePath() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrPostInstallScriptTemplatePath;
+}
+
+Utf8Str const &Unattended::i_getPostInstallCommand() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrPostInstallCommand;
+}
+
+Utf8Str const &Unattended::i_getAuxiliaryInstallDir() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ /* Only the installer knows, forward the call. */
+ AssertReturn(mpInstaller != NULL, Utf8Str::Empty);
+ return mpInstaller->getAuxiliaryInstallDir();
+}
+
+Utf8Str const &Unattended::i_getExtraInstallKernelParameters() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrExtraInstallKernelParameters;
+}
+
+bool Unattended::i_isRtcUsingUtc() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mfRtcUseUtc;
+}
+
+bool Unattended::i_isGuestOs64Bit() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mfGuestOs64Bit;
+}
+
+bool Unattended::i_isFirmwareEFI() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return menmFirmwareType != FirmwareType_BIOS;
+}
+
+Utf8Str const &Unattended::i_getDetectedOSVersion()
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mStrDetectedOSVersion;
+}
+
+bool Unattended::i_getAvoidUpdatesOverNetwork() const
+{
+ Assert(isReadLockedOnCurrentThread());
+ return mfAvoidUpdatesOverNetwork;
+}
+
+HRESULT Unattended::i_attachImage(UnattendedInstallationDisk const *pImage, ComPtr<IMachine> const &rPtrSessionMachine,
+ AutoMultiWriteLock2 &rLock)
+{
+ /*
+ * Attach the disk image
+ * HACK ALERT! Temporarily release the Unattended lock.
+ */
+ rLock.release();
+
+ ComPtr<IMedium> ptrMedium;
+ HRESULT hrc = mParent->OpenMedium(Bstr(pImage->strImagePath).raw(),
+ pImage->enmDeviceType,
+ pImage->enmAccessType,
+ true,
+ ptrMedium.asOutParam());
+ LogRelFlowFunc(("VirtualBox::openMedium -> %Rhrc\n", hrc));
+ if (SUCCEEDED(hrc))
+ {
+ if (pImage->fAuxiliary && pImage->strImagePath.endsWith(".viso"))
+ {
+ hrc = ptrMedium->SetProperty(Bstr("UnattendedInstall").raw(), Bstr("1").raw());
+ LogRelFlowFunc(("Medium::SetProperty -> %Rhrc\n", hrc));
+ }
+ if (pImage->fMountOnly)
+ {
+ // mount the opened disk image
+ hrc = rPtrSessionMachine->MountMedium(Bstr(pImage->strControllerName).raw(), pImage->iPort,
+ pImage->iDevice, ptrMedium, TRUE /*fForce*/);
+ LogRelFlowFunc(("Machine::MountMedium -> %Rhrc\n", hrc));
+ }
+ else
+ {
+ //attach the opened disk image to the controller
+ hrc = rPtrSessionMachine->AttachDevice(Bstr(pImage->strControllerName).raw(), pImage->iPort,
+ pImage->iDevice, pImage->enmDeviceType, ptrMedium);
+ LogRelFlowFunc(("Machine::AttachDevice -> %Rhrc\n", hrc));
+ }
+ }
+
+ rLock.acquire();
+ return hrc;
+}
+
+bool Unattended::i_isGuestOSArchX64(Utf8Str const &rStrGuestOsTypeId)
+{
+ ComPtr<IGuestOSType> pGuestOSType;
+ HRESULT hrc = mParent->GetGuestOSType(Bstr(rStrGuestOsTypeId).raw(), pGuestOSType.asOutParam());
+ if (SUCCEEDED(hrc))
+ {
+ BOOL fIs64Bit = FALSE;
+ if (!pGuestOSType.isNull())
+ hrc = pGuestOSType->COMGETTER(Is64Bit)(&fIs64Bit);
+ if (SUCCEEDED(hrc))
+ return fIs64Bit != FALSE;
+ }
+ return false;
+}
+
+
+bool Unattended::i_updateDetectedAttributeForImage(WIMImage const &rImage)
+{
+ bool fRet = true;
+
+ /*
+ * If the image doesn't have a valid value, we don't change it.
+ * This is obviously a little bit bogus, but what can we do...
+ */
+ const char *pszOSTypeId = Global::OSTypeId(rImage.mOSType);
+ if (pszOSTypeId && strcmp(pszOSTypeId, "Other") != 0)
+ mStrDetectedOSTypeId = pszOSTypeId;
+ else
+ fRet = false;
+
+ if (rImage.mVersion.isNotEmpty())
+ mStrDetectedOSVersion = rImage.mVersion;
+ else
+ fRet = false;
+
+ if (rImage.mFlavor.isNotEmpty())
+ mStrDetectedOSFlavor = rImage.mFlavor;
+ else
+ fRet = false;
+
+ if (rImage.mLanguages.size() > 0)
+ mDetectedOSLanguages = rImage.mLanguages;
+ else
+ fRet = false;
+
+ mEnmOsType = rImage.mEnmOsType;
+
+ return fRet;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-29 17:02:28 +0000