VirtualBox

Changeset 94079 in vbox for trunk/src/VBox/Main


Ignore:
Timestamp:
Mar 3, 2022 5:10:36 PM (3 years ago)
Author:
vboxsync
Message:

Main/Unattended: ​​bugref:9781. Return false from IUnattended::isUnattendedSupported() for Ubuntus < 11.04.

Location:
trunk/src/VBox/Main
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/include/UnattendedImpl.h

    r94075 r94079  
    4747    WIMImage() : mImageIndex(0), mOSType(VBOXOSTYPE_Unknown) { }
    4848    const Utf8Str &formatName(Utf8Str &r_strName) const;
     49    VBOXOSTYPE mEnmOsType;
    4950};
    5051
    … …  
    143144    Utf8Str         mStrDetectedOSVersion;
    144145    Utf8Str         mStrDetectedOSFlavor;
     146    VBOXOSTYPE      mEnmOsType;
    145147    RTCList<RTCString, RTCString *> mDetectedOSLanguages; /**< (only relevant for windows at the moment) */
    146148    Utf8Str         mStrDetectedOSHints;
    … …  
    249251        uint32_t    au32[1024];
    250252    } DETECTBUFFER;
    251     HRESULT i_innerDetectIsoOSWindows(RTVFS hVfsIso, DETECTBUFFER *puBuf, VBOXOSTYPE *penmOsType);
    252     HRESULT i_innerDetectIsoOSLinux(RTVFS hVfsIso, DETECTBUFFER *puBuf, VBOXOSTYPE *penmOsType);
    253     HRESULT i_innerDetectIsoOSOs2(RTVFS hVfsIso, DETECTBUFFER *puBuf, VBOXOSTYPE *penmOsType);
     253    HRESULT i_innerDetectIsoOSWindows(RTVFS hVfsIso, DETECTBUFFER *puBuf);
     254    HRESULT i_innerDetectIsoOSLinux(RTVFS hVfsIso, DETECTBUFFER *puBuf);
     255    HRESULT i_innerDetectIsoOSOs2(RTVFS hVfsIso, DETECTBUFFER *puBuf);
    254256
    255257    /**

  • trunk/src/VBox/Main/src-server/UnattendedImpl.cpp

    r94078 r94079  
    442442{
    443443    DETECTBUFFER uBuf;
    444     VBOXOSTYPE enmOsType = VBOXOSTYPE_Unknown;
    445     HRESULT hrc = i_innerDetectIsoOSWindows(hVfsIso, &uBuf, &enmOsType);
    446     if (hrc == S_FALSE && enmOsType == VBOXOSTYPE_Unknown)
    447         hrc = i_innerDetectIsoOSLinux(hVfsIso, &uBuf, &enmOsType);
    448     if (hrc == S_FALSE && enmOsType == VBOXOSTYPE_Unknown)
    449         hrc = i_innerDetectIsoOSOs2(hVfsIso, &uBuf, &enmOsType);
    450     if (enmOsType != VBOXOSTYPE_Unknown)
    451     {
    452         try {  mStrDetectedOSTypeId = Global::OSTypeId(enmOsType); }
     444    mEnmOsType = VBOXOSTYPE_Unknown;
     445    HRESULT hrc = i_innerDetectIsoOSWindows(hVfsIso, &uBuf);
     446    if (hrc == S_FALSE && mEnmOsType == VBOXOSTYPE_Unknown)
     447        hrc = i_innerDetectIsoOSLinux(hVfsIso, &uBuf);
     448    if (hrc == S_FALSE && mEnmOsType == VBOXOSTYPE_Unknown)
     449        hrc = i_innerDetectIsoOSOs2(hVfsIso, &uBuf);
     450    if (mEnmOsType != VBOXOSTYPE_Unknown)
     451    {
     452        try {  mStrDetectedOSTypeId = Global::OSTypeId(mEnmOsType); }
    453453        catch (std::bad_alloc &) { hrc = E_OUTOFMEMORY; }
    454454    }
    … …  
    571571 * @endverbatim
    572572 *
    573  * Will update mOSType as well as setting mVersion on success.
     573 * Will update mOSType, mEnmOsType as well as setting mVersion on success.
    574574 *
    575575 * @param   pNode          Points to the vesion XML node,
    … …  
    621621                             * Convert that to a version windows OS ID (newest first!).
    622622                             */
    623                             VBOXOSTYPE enmVersion = VBOXOSTYPE_Unknown;
     623                            image.mEnmOsType = VBOXOSTYPE_Unknown;
    624624                            if (RTStrVersionCompare(image.mVersion.c_str(), "10.0.22000.0") >= 0)
    625                                 enmVersion = VBOXOSTYPE_Win11_x64;
     625                                image.mEnmOsType = VBOXOSTYPE_Win11_x64;
    626626                            else if (RTStrVersionCompare(image.mVersion.c_str(), "10.0") >= 0)
    627                                 enmVersion = VBOXOSTYPE_Win10;
     627                                image.mEnmOsType = VBOXOSTYPE_Win10;
    628628                            else if (RTStrVersionCompare(image.mVersion.c_str(), "6.3") >= 0)
    629                                 enmVersion = VBOXOSTYPE_Win81;
     629                                image.mEnmOsType = VBOXOSTYPE_Win81;
    630630                            else if (RTStrVersionCompare(image.mVersion.c_str(), "6.2") >= 0)
    631                                 enmVersion = VBOXOSTYPE_Win8;
     631                                image.mEnmOsType = VBOXOSTYPE_Win8;
    632632                            else if (RTStrVersionCompare(image.mVersion.c_str(), "6.1") >= 0)
    633                                 enmVersion = VBOXOSTYPE_Win7;
     633                                image.mEnmOsType = VBOXOSTYPE_Win7;
    634634                            else if (RTStrVersionCompare(image.mVersion.c_str(), "6.0") >= 0)
    635                                 enmVersion = VBOXOSTYPE_WinVista;
     635                                image.mEnmOsType = VBOXOSTYPE_WinVista;
    636636                            if (image.mFlavor.contains("server", Utf8Str::CaseInsensitive))
    637637                            {
    638638                                if (RTStrVersionCompare(image.mVersion.c_str(), "10.0.20348") >= 0)
    639                                     enmVersion = VBOXOSTYPE_Win2k22_x64;
     639                                    image.mEnmOsType = VBOXOSTYPE_Win2k22_x64;
    640640                                else if (RTStrVersionCompare(image.mVersion.c_str(), "10.0.17763") >= 0)
    641                                     enmVersion = VBOXOSTYPE_Win2k19_x64;
     641                                    image.mEnmOsType = VBOXOSTYPE_Win2k19_x64;
    642642                                else if (RTStrVersionCompare(image.mVersion.c_str(), "10.0") >= 0)
    643                                     enmVersion = VBOXOSTYPE_Win2k16_x64;
     643                                    image.mEnmOsType = VBOXOSTYPE_Win2k16_x64;
    644644                                else if (RTStrVersionCompare(image.mVersion.c_str(), "6.2") >= 0)
    645                                     enmVersion = VBOXOSTYPE_Win2k12_x64;
     645                                    image.mEnmOsType = VBOXOSTYPE_Win2k12_x64;
    646646                                else if (RTStrVersionCompare(image.mVersion.c_str(), "6.0") >= 0)
    647                                     enmVersion = VBOXOSTYPE_Win2k8;
     647                                    image.mEnmOsType = VBOXOSTYPE_Win2k8;
    648648                            }
    649                             if (enmVersion != VBOXOSTYPE_Unknown)
     649                            if (image.mEnmOsType != VBOXOSTYPE_Unknown)
    650650                                image.mOSType = (VBOXOSTYPE)(  (image.mOSType & VBOXOSTYPE_ArchitectureMask)
    651                                                              | (enmVersion & VBOXOSTYPE_OsTypeMask));
     651                                                             | (image.mEnmOsType & VBOXOSTYPE_OsTypeMask));
    652652                            return;
    653653                        }
    … …  
    785785 * @param   hVfsIso     The ISO file system.
    786786 * @param   pBuf        Read buffer.
    787  * @param   penmOsType  Where to return the OS type.  This is initialized to
    788  *                      VBOXOSTYPE_Unknown.
    789787 */
    790 HRESULT Unattended::i_innerDetectIsoOSWindows(RTVFS hVfsIso, DETECTBUFFER *pBuf, VBOXOSTYPE *penmOsType)
     788HRESULT Unattended::i_innerDetectIsoOSWindows(RTVFS hVfsIso, DETECTBUFFER *pBuf)
    791789{
    792790    /** @todo The 'sources/' path can differ. */
    … …  
    880878                                    {
    881879                                        LogRel2(("Unattended: happy with mDetectedImages[%u]\n", i));
    882                                         *penmOsType = mDetectedImages[i].mOSType;
     880                                        mEnmOsType = mDetectedImages[i].mOSType;
    883881                                        return S_OK;
    884882                                    }
    … …  
    920918    if (RT_SUCCESS(vrc))
    921919    {
    922         *penmOsType = VBOXOSTYPE_WinNT_x64;
     920        mEnmOsType = VBOXOSTYPE_WinNT_x64;
    923921
    924922        RTINIFILE hIniFile;
    … …  
    933931                if (   RTStrNICmp(pBuf->sz, RT_STR_TUPLE("amd64")) == 0
    934932                    || RTStrNICmp(pBuf->sz, RT_STR_TUPLE("x64"))   == 0 /* just in case */ )
    935                     *penmOsType = VBOXOSTYPE_WinNT_x64;
     933                    mEnmOsType = VBOXOSTYPE_WinNT_x64;
    936934                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("x86")) == 0)
    937                     *penmOsType = VBOXOSTYPE_WinNT;
     935                    mEnmOsType = VBOXOSTYPE_WinNT;
    938936                else
    939937                {
    940938                    LogRel(("Unattended: sources/idwbinfo.txt: Unknown: BuildArch=%s\n", pBuf->sz));
    941                     *penmOsType = VBOXOSTYPE_WinNT_x64;
     939                    mEnmOsType = VBOXOSTYPE_WinNT_x64;
    942940                }
    943941            }
    … …  
    949947                if (   RTStrNICmp(pBuf->sz, RT_STR_TUPLE("vista")) == 0
    950948                    || RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winmain_beta")) == 0)
    951                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_WinVista);
     949                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_WinVista);
    952950                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("lh_sp2rtm")) == 0)
    953951                {
    954                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_WinVista);
     952                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_WinVista);
    955953                    pszVersion = "sp2";
    956954                }
    957955                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("longhorn_rtm")) == 0)
    958956                {
    959                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_WinVista);
     957                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_WinVista);
    960958                    pszVersion = "sp1";
    961959                }
    962960                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("win7")) == 0)
    963                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win7);
     961                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win7);
    964962                else if (   RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winblue")) == 0
    965963                         || RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winmain_blue")) == 0
    966964                         || RTStrNICmp(pBuf->sz, RT_STR_TUPLE("win81")) == 0 /* not seen, but just in case its out there */ )
    967                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win81);
     965                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win81);
    968966                else if (   RTStrNICmp(pBuf->sz, RT_STR_TUPLE("win8")) == 0
    969967                         || RTStrNICmp(pBuf->sz, RT_STR_TUPLE("winmain_win8")) == 0 )
    970                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win8);
     968                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win8);
    971969                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("th1")) == 0)
    972970                {
    973971                    pszVersion = "1507";    // aka. GA, retroactively 1507
    974                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     972                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    975973                }
    976974                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("th2")) == 0)
    977975                {
    978976                    pszVersion = "1511";    // aka. threshold 2
    979                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     977                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    980978                }
    981979                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs1_release")) == 0)
    982980                {
    983981                    pszVersion = "1607";    // aka. anniversay update; rs=redstone
    984                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     982                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    985983                }
    986984                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs2_release")) == 0)
    987985                {
    988986                    pszVersion = "1703";    // aka. creators update
    989                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     987                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    990988                }
    991989                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs3_release")) == 0)
    992990                {
    993991                    pszVersion = "1709";    // aka. fall creators update
    994                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     992                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    995993                }
    996994                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs4_release")) == 0)
    997995                {
    998996                    pszVersion = "1803";
    999                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     997                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    1000998                }
    1001999                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("rs5_release")) == 0)
    10021000                {
    10031001                    pszVersion = "1809";
    1004                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     1002                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    10051003                }
    10061004                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("19h1_release")) == 0)
    10071005                {
    10081006                    pszVersion = "1903";
    1009                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     1007                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    10101008                }
    10111009                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("19h2_release")) == 0)
    10121010                {
    10131011                    pszVersion = "1909";    // ??
    1014                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     1012                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    10151013                }
    10161014                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("20h1_release")) == 0)
    10171015                {
    10181016                    pszVersion = "2003";    // ??
    1019                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     1017                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    10201018                }
    10211019                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("vb_release")) == 0)
    10221020                {
    10231021                    pszVersion = "2004";    // ?? vb=Vibranium
    1024                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     1022                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    10251023                }
    10261024                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("20h2_release")) == 0)
    10271025                {
    10281026                    pszVersion = "2009";    // ??
    1029                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     1027                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    10301028                }
    10311029                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("21h1_release")) == 0)
    10321030                {
    10331031                    pszVersion = "2103";    // ??
    1034                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     1032                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    10351033                }
    10361034                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("21h2_release")) == 0)
    10371035                {
    10381036                    pszVersion = "2109";    // ??
    1039                     *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
     1037                    mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win10);
    10401038                }
    10411039                else if (RTStrNICmp(pBuf->sz, RT_STR_TUPLE("co_release")) == 0)
    10421040                {
    10431041                    pszVersion = "21H2";    // ??
    1044                     *penmOsType = VBOXOSTYPE_Win11_x64;
     1042                    mEnmOsType = VBOXOSTYPE_Win11_x64;
    10451043                }
    10461044                else
    … …  
    10591057        vrc = RTVfsFileOpen(hVfsIso, "AMD64/HIVESYS.INF", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
    10601058        if (RT_SUCCESS(vrc))
    1061             *penmOsType = VBOXOSTYPE_WinNT_x64;
     1059            mEnmOsType = VBOXOSTYPE_WinNT_x64;
    10621060        else
    10631061        {
    10641062            vrc = RTVfsFileOpen(hVfsIso, "I386/HIVESYS.INF", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
    10651063            if (RT_SUCCESS(vrc))
    1066                 *penmOsType = VBOXOSTYPE_WinNT;
     1064                mEnmOsType = VBOXOSTYPE_WinNT;
    10671065        }
    10681066        if (RT_SUCCESS(vrc))
    … …  
    10841082                    {
    10851083                        fClarifyProd = true;
    1086                         *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win2k3);
     1084                        mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win2k3);
    10871085                        if (RTStrVersionCompare(psz, "5.2.3790.3959") >= 0)
    10881086                            pszVersion = "sp2";
    … …  
    10921090                    else if (RTStrVersionCompare(psz, "5.1.0") >= 0) /* XP */
    10931091                    {
    1094                         *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_WinXP);
     1092                        mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_WinXP);
    10951093                        if (RTStrVersionCompare(psz, "5.1.2600.5512") >= 0)
    10961094                            pszVersion = "sp3";
    … …  
    11021100                    else if (RTStrVersionCompare(psz, "5.0.0") >= 0)
    11031101                    {
    1104                         *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win2k);
     1102                        mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win2k);
    11051103                        if (RTStrVersionCompare(psz, "5.0.2195.6717") >= 0)
    11061104                            pszVersion = "sp4";
    … …  
    11251123        vrc = RTVfsFileOpen(hVfsIso, "AMD64/PRODSPEC.INI", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
    11261124        if (RT_SUCCESS(vrc))
    1127             *penmOsType = VBOXOSTYPE_WinNT_x64;
     1125            mEnmOsType = VBOXOSTYPE_WinNT_x64;
    11281126        else
    11291127        {
    11301128            vrc = RTVfsFileOpen(hVfsIso, "I386/PRODSPEC.INI", RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
    11311129            if (RT_SUCCESS(vrc))
    1132                 *penmOsType = VBOXOSTYPE_WinNT;
     1130                mEnmOsType = VBOXOSTYPE_WinNT;
    11331131        }
    11341132        if (RT_SUCCESS(vrc))
    … …  
    11501148                        vrc = RTIniFileQueryValue(hIniFile, "Product Specification", "Product", pBuf->sz, sizeof(*pBuf), NULL);
    11511149                        if (RT_SUCCESS(vrc) && RTStrNICmp(pBuf->sz, RT_STR_TUPLE("Windows XP")) == 0)
    1152                             *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_WinXP);
     1150                            mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_WinXP);
    11531151                        else if (RT_SUCCESS(vrc) && RTStrNICmp(pBuf->sz, RT_STR_TUPLE("Windows Server 2003")) == 0)
    1154                             *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win2k3);
     1152                            mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win2k3);
    11551153                        else
    1156                             *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win2k);
     1154                            mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_Win2k);
    11571155
    11581156                        if (RT_SUCCESS(vrc) && (strstr(pBuf->sz, "Server") || strstr(pBuf->sz, "server")))
    … …  
    11601158                    }
    11611159                    else if (RTStrVersionCompare(pBuf->sz, "4.0") >= 0) /* NT4 */
    1162                         *penmOsType = VBOXOSTYPE_WinNT4;
     1160                        mEnmOsType = VBOXOSTYPE_WinNT4;
    11631161                    else
    11641162                        LogRel(("Unattended: PRODSPEC.INI: unknown: DriverVer=%s\n", pBuf->sz));
    … …  
    11841182        if (RT_SUCCESS(vrc))
    11851183        {
    1186             *penmOsType = VBOXOSTYPE_WinNT;
     1184            mEnmOsType = VBOXOSTYPE_WinNT;
    11871185
    11881186            RTINIFILE hIniFile;
    … …  
    12091207                        LogRel(("Unattended: TXTSETUP.SIF: unknown: LoadIdentifier=%s\n", pBuf->sz));
    12101208                    else if (RTStrVersionCompare(psz, "4.0") >= 0)
    1211                         *penmOsType = VBOXOSTYPE_WinNT4;
     1209                        mEnmOsType = VBOXOSTYPE_WinNT4;
    12121210                    else if (RTStrVersionCompare(psz, "3.1") >= 0)
    12131211                    {
    1214                         *penmOsType = VBOXOSTYPE_WinNT3x;
     1212                        mEnmOsType = VBOXOSTYPE_WinNT3x;
    12151213                        pszVersion = psz;
    12161214                    }
    … …  
    14341432 * @param   hVfsIso     The ISO file system.
    14351433 * @param   pBuf        Read buffer.
    1436  * @param   penmOsType  Where to return the OS type.  This is initialized to
    1437  *                      VBOXOSTYPE_Unknown.
    14381434 */
    1439 HRESULT Unattended::i_innerDetectIsoOSLinux(RTVFS hVfsIso, DETECTBUFFER *pBuf, VBOXOSTYPE *penmOsType)
     1435HRESULT Unattended::i_innerDetectIsoOSLinux(RTVFS hVfsIso, DETECTBUFFER *pBuf)
    14401436{
    14411437    /*
    … …  
    14651461            {
    14661462                LogRelFlow(("Unattended: .treeinfo: arch=%s\n", pBuf->sz));
    1467                 if (detectLinuxArch(pBuf->sz, penmOsType, VBOXOSTYPE_RedHat))
     1463                if (detectLinuxArch(pBuf->sz, &mEnmOsType, VBOXOSTYPE_RedHat))
    14681464                {
    14691465                    /* Try figure the release name, it doesn't have to be redhat. */
    … …  
    14761472                    {
    14771473                        LogRelFlow(("Unattended: .treeinfo: name/family=%s\n", pBuf->sz));
    1478                         if (!detectLinuxDistroName(pBuf->sz, penmOsType, NULL))
     1474                        if (!detectLinuxDistroName(pBuf->sz, &mEnmOsType, NULL))
    14791475                        {
    14801476                            LogRel(("Unattended: .treeinfo: Unknown: name/family='%s', assuming Red Hat\n", pBuf->sz));
    1481                             *penmOsType = (VBOXOSTYPE)((*penmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_RedHat);
     1477                            mEnmOsType = (VBOXOSTYPE)((mEnmOsType & VBOXOSTYPE_x64) | VBOXOSTYPE_RedHat);
    14821478                        }
    14831479                    }
    … …  
    15031499        }
    15041500
    1505         if (*penmOsType != VBOXOSTYPE_Unknown)
     1501        if (mEnmOsType != VBOXOSTYPE_Unknown)
    15061502            return S_FALSE;
    15071503    }
    … …  
    15411537        /* Do we recognize the architecture? */
    15421538        LogRelFlow(("Unattended: .discinfo: arch=%s\n", apszLines[2]));
    1543         if (detectLinuxArch(apszLines[2], penmOsType, VBOXOSTYPE_RedHat))
     1539        if (detectLinuxArch(apszLines[2], &mEnmOsType, VBOXOSTYPE_RedHat))
    15441540        {
    15451541            /* Do we recognize the release string? */
    15461542            LogRelFlow(("Unattended: .discinfo: product+version=%s\n", apszLines[1]));
    15471543            const char *pszVersion = NULL;
    1548             if (!detectLinuxDistroName(apszLines[1], penmOsType, &pszVersion))
     1544            if (!detectLinuxDistroName(apszLines[1], &mEnmOsType, &pszVersion))
    15491545                LogRel(("Unattended: .discinfo: Unknown: release='%s'\n", apszLines[1]));
    15501546
    … …  
    16301626            LogRel(("Unattended: .discinfo: Unknown: arch='%s'\n", apszLines[2]));
    16311627
    1632         if (*penmOsType != VBOXOSTYPE_Unknown)
     1628        if (mEnmOsType != VBOXOSTYPE_Unknown)
    16331629            return S_FALSE;
    16341630    }
    … …  
    17211717        if (pszDiskName && pszArch)
    17221718        {
    1723             if (detectLinuxArch(pszArch, penmOsType, VBOXOSTYPE_Ubuntu))
     1719            if (detectLinuxArch(pszArch, &mEnmOsType, VBOXOSTYPE_Ubuntu))
    17241720            {
    17251721                const char *pszVersion = NULL;
    1726                 if (detectLinuxDistroName(pszDiskName, penmOsType, &pszVersion))
     1722                if (detectLinuxDistroName(pszDiskName, &mEnmOsType, &pszVersion))
    17271723                {
    17281724                    LogRelFlow(("Unattended: README.diskdefines: version=%s\n", pszVersion));
    … …  
    17391735            LogRel(("Unattended: README.diskdefines: Did not find both DISKNAME and ARCH. :-/\n"));
    17401736
    1741         if (*penmOsType != VBOXOSTYPE_Unknown)
     1737        if (mEnmOsType != VBOXOSTYPE_Unknown)
    17421738            return S_FALSE;
    17431739    }
    … …  
    17831779        if (pszDiskName && pszArch)
    17841780        {
    1785             if (!detectLinuxArchII(pszArch, penmOsType, VBOXOSTYPE_Ubuntu))
     1781            if (!detectLinuxArchII(pszArch, &mEnmOsType, VBOXOSTYPE_Ubuntu))
    17861782                LogRel(("Unattended: README.diskdefines: Unknown: arch='%s'\n", pszArch));
    17871783
    17881784            const char *pszVersion = NULL;
    1789             if (detectLinuxDistroName(pszDiskName, penmOsType, &pszVersion))
     1785            if (detectLinuxDistroName(pszDiskName, &mEnmOsType, &pszVersion))
    17901786            {
    17911787                LogRelFlow(("Unattended: README.diskdefines: version=%s\n", pszVersion));
    … …  
    17991795            LogRel(("Unattended: README.diskdefines: Did not find both DISKNAME and ARCH. :-/\n"));
    18001796
    1801         if (*penmOsType != VBOXOSTYPE_Unknown)
     1797        if (mEnmOsType != VBOXOSTYPE_Unknown)
    18021798            return S_FALSE;
    18031799    }
    … …  
    18181814 * @param   hVfsIso     The ISO file system.
    18191815 * @param   pBuf        Read buffer.
    1820  * @param   penmOsType  Where to return the OS type.  This is initialized to
    1821  *                      VBOXOSTYPE_Unknown.
    18221816 */
    1823 HRESULT Unattended::i_innerDetectIsoOSOs2(RTVFS hVfsIso, DETECTBUFFER *pBuf, VBOXOSTYPE *penmOsType)
     1817HRESULT Unattended::i_innerDetectIsoOSOs2(RTVFS hVfsIso, DETECTBUFFER *pBuf)
    18241818{
    18251819    /*
    … …  
    18791873     * So, it's some kind of OS/2 2.x or later ISO alright.
    18801874     */
    1881     *penmOsType = VBOXOSTYPE_OS2;
     1875    mEnmOsType = VBOXOSTYPE_OS2;
    18821876    mStrDetectedOSHints.printf("OS2SE20.SRC=%.*s", cchOs2Image, pBuf->sz);
    18831877
    … …  
    18871881     *      ArcaOS 5.0.7 EN
    18881882     *      Built 2021-12-07 18:34:34
    1889      * We drop the "ArcaOS" bit, as it's covered by penmOsType.  Then we pull up
     1883     * We drop the "ArcaOS" bit, as it's covered by mEnmOsType.  Then we pull up
    18901884     * the second line.
    18911885     *
    … …  
    19011895        && RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
    19021896    {
    1903         *penmOsType = VBOXOSTYPE_ArcaOS;
     1897        mEnmOsType = VBOXOSTYPE_ArcaOS;
    19041898
    19051899        /* Read the version file:  */
    … …  
    19661960            && RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
    19671961        {
    1968             *penmOsType = VBOXOSTYPE_ECS;
     1962            mEnmOsType = VBOXOSTYPE_ECS;
    19691963
    19701964            /* Read the version file:  */
    … …  
    20632057                                }
    20642058                                if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "4.50") >= 0)
    2065                                     *penmOsType = VBOXOSTYPE_OS2Warp45;
     2059                                    mEnmOsType = VBOXOSTYPE_OS2Warp45;
    20662060                                else if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "4.00") >= 0)
    2067                                     *penmOsType = VBOXOSTYPE_OS2Warp4;
     2061                                    mEnmOsType = VBOXOSTYPE_OS2Warp4;
    20682062                                else if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "3.00") >= 0)
    2069                                     *penmOsType = VBOXOSTYPE_OS2Warp3;
     2063                                    mEnmOsType = VBOXOSTYPE_OS2Warp3;
    20702064                            }
    20712065                            else
    … …  
    20902084     * Only tested ACP2, so only return S_OK for it.
    20912085     */
    2092     if (   *penmOsType == VBOXOSTYPE_OS2Warp45
     2086    if (   mEnmOsType == VBOXOSTYPE_OS2Warp45
    20932087        && RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "4.52") >= 0
    20942088        && mStrDetectedOSFlavor.contains("Server", RTCString::CaseInsensitive))
    … …  
    35693563        return S_OK;
    35703564    }
     3565    /* We cannot install Ubuntus older than 11.04. */
     3566    if (mEnmOsType == VBOXOSTYPE_Ubuntu || mEnmOsType == VBOXOSTYPE_Ubuntu_x64)
     3567    {
     3568        if (RTStrVersionCompare(mStrDetectedOSVersion.c_str(), "11.04") < 0)
     3569        {
     3570            *aIsUnattendedInstallSupported = false;
     3571            return S_OK;
     3572        }
     3573    }
     3574    *aIsUnattendedInstallSupported = true;
    35713575    return S_OK;
    35723576}
    … …  
    38313835        fRet = false;
    38323836
     3837    mEnmOsType = rImage.mEnmOsType;
     3838
    38333839    return fRet;
    38343840}
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette