windows-server-2003/base/ntsetup/textmode/kernel/spdrsif.c

/*++
Copyright (c) 1993 Microsoft Corporation

Module Name:
    spdrsif.c

Abstract:
    Contains all routines involved in reading attributes from the asr.sif
    file and constructing partition records.

Terminology

Restrictions:

Revision History:
    Initial Code                Michael Peterson (v-michpe)     21.Aug.1998
    Code cleanup and changes    Guhan Suriyanarayanan (guhans)  21.Aug.1999

--*/
#include "spprecmp.h"
#pragma hdrstop

// Module identification for debug traces
#define THIS_MODULE L" spdrsif.c"
#define THIS_MODULE_CODE L"S"
#define ASR_NULL_STRING (L"")

//
// Section names and other data used for retrieving information from the
// asr.sif file
//
const PWSTR SIF_ASR_VERSION_SECTION = L"VERSION";
const PWSTR SIF_ASR_SYSTEMS_SECTION = L"SYSTEMS";
const PWSTR SIF_ASRFLAGS_SECTION    = L"ASRFLAGS";
const PWSTR SIF_ASR_BUSES_SECTION = L"BUSES";
const PWSTR SIF_ASR_PARTITIONS_SECTION = L"PARTITIONS";
const PWSTR SIF_ASR_DISKS_SECTION = L"DISKS";
const PWSTR SIF_ASR_MBR_DISKS_SECTION = L"DISKS.MBR";
const PWSTR SIF_ASR_GPT_DISKS_SECTION = L"DISKS.GPT";
const PWSTR SIF_ASR_MBR_PARTITIONS_SECTION = L"PARTITIONS.MBR";
const PWSTR SIF_ASR_GPT_PARTITIONS_SECTION = L"PARTITIONS.GPT";
const PWSTR SIF_ASR_INSTALLFILES_SECTION = L"INSTALLFILES";

const PWSTR SIF_ASR_SIGNATURE_KEY = L"Signature";
const PWSTR SIF_ASR_PROVIDER_KEY = L"Provider";
const PWSTR SIF_ASR_SIFVERSION_KEY = L"ASR-Version";
const PWSTR ASR_SIF_RECOGNISED_SIGNATURE = L"$Windows NT$";
const PWSTR ASR_SIF_RECOGNISED_VERSION = L"1.";

const PWSTR ASR_FLOPPY_DEVICE_ALIAS     = L"%FLOPPY%";
const PWSTR ASR_CDROM_DEVICE_ALIAS      = L"%CDROM%";
const PWSTR ASR_SOURCE_DEVICE_ALIAS     = L"%SETUPSOURCE%";

const PWSTR ASR_SIF_TEMP_DIRECTORY_ALIAS   = L"%TEMP%\\";
const PWSTR ASR_SIF_TMP_DIRECTORY_ALIAS    = L"%TMP%\\";
const PWSTR ASR_SIF_SYSTEM_ROOT_ALIAS      = L"%SystemRoot%\\";

const PWSTR ASR_SIF_SILENT_REPARTITION_VALUE = L"SilentRepartition";

extern const PWSTR ASR_FLOPPY0_DEVICE_PATH;
extern const PWSTR ASR_CDROM0_DEVICE_PATH;
extern const PWSTR ASR_TEMP_DIRECTORY_PATH;
extern ULONG SuiteType;


// Indices for the [SYSTEMS] section.
typedef enum _SIF_SYSTEM_FIELD_INDEX {
    SIF_SYSTEM_NAME = 0,                    // Computer name    (not used in textmode ASR)
    SIF_SYSTEM_PLATFORM,                    // amd64, x86 or ia64
    SIF_SYSTEM_OSVERSION,                   // Windows version
    SIF_SYSTEM_NT_DIRECTORY_NAME,           // Windows directory
    SIF_SYSTEM_PARTITION_AUTOEXTEND_OPTION, // [optional]

    SIF_SYSTEM_PRODUCT_SUITE,               // SKU information

    //
    // Time Zone Information (not used in textmode ASR)
    //
    SIF_SYSTEM_TIMEZONE_INFORMATION,
    SIF_SYSTEM_TIMEZONE_STANDARD_NAME,
    SIF_SYSTEM_TIMEZONE_DAYLIGHT_NAME,

    SIF_SYSTEM_NUMFIELDS                // Must always be last
} SIF_SYSTEM_FIELD_INDEX;

// Indices for the [ASRFLAGS] section.
typedef enum _SIF_ASRFLAGS_FIELD_INDEX {
    SIF_ASRFLAGS_SILENT_REPARTITION_OPTION = 0,
    SIF_ASRFLAGS_NUMFIELDS                // Must always be last
} SIF_ASRFLAGS_FIELD_INDEX;


// Indices for the [BUSES] section.
typedef enum _SIF_BUSES_FIELD_INDEX {
    SIF_BUSES_SYSTEMKEY = 0,
    SIF_BUSES_BUS_TYPE,
    SIF_BUSES_NUMFIELDS                // Must always be last
} SIF_BUSES_FIELD_INDEX;


//
// Indices for the [DISKS.MBR] section.
//
// [DISKS.MBR] format
//
// disk-key = 0.system-key, 1.bus-key, 2.critical-flag,
//              3.disk-signature, 4.bytes-per-sector, 5.total-sectors
//
typedef enum _SIF_MBR_DISK_FIELD_INDEX {
    SIF_MBR_DISK_SYSTEMKEY = 0,
    SIF_MBR_DISK_BUSKEY,
    SIF_MBR_DISK_CRITICAL_FLAG,
    SIF_MBR_DISK_SIGNATURE,
    SIF_MBR_DISK_BYTES_PER_SECTOR,
    SIF_MBR_DISK_SECTORS_PER_TRACK,
    SIF_MBR_DISK_TRACKS_PER_CYLINDER,
    SIF_MBR_DISK_TOTALSECTORS,
    SIF_MBR_DISK_NUMFIELDS                // Must always be last
} SIF_MBR_DISK_FIELD_INDEX;


//
// Indices for the [DISKS.GPT] section.
//
// [DISKS.GPT] format
//
// disk-key = 0.system-key, 1.bus-key, 2.critical-flag, 3.disk-id,
//              4.min-partition-count, 5.bytes-per-sector, 6.total-sectors
//
typedef enum _SIF_GPT_DISK_FIELD_INDEX {
    SIF_GPT_DISK_SYSTEMKEY = 0,
    SIF_GPT_DISK_BUSKEY,
    SIF_GPT_DISK_CRITICAL_FLAG,
    SIF_GPT_DISK_DISK_ID,
    SIF_GPT_DISK_MAX_PTN_COUNT,
    SIF_GPT_DISK_BYTES_PER_SECTOR,
    SIF_GPT_DISK_SECTORS_PER_TRACK,
    SIF_GPT_DISK_TRACKS_PER_CYLINDER,
    SIF_GPT_DISK_TOTALSECTORS,
    SIF_GPT_DISK_NUMFIELDS                // Must always be last
} SIF_GPT_DISK_FIELD_INDEX;


//
// Indices for the [PARTITIONS.MBR] section.
//
// [PARTITIONS.MBR]
//
// partition-key = 0.disk-key, 1.slot-index, 2.boot-sys-flag,
//                 3."volume-guid", 4.active-flag, 5.partition-type,
//                 6.file-system-type, 7.start-sector, 8.sector-count,
//                 9.fs-cluster-size
//
typedef enum _SIF_MBR_PARTITION_FIELD_INDEX {
    SIF_MBR_PARTITION_DISKKEY = 0,
    SIF_MBR_PARTITION_SLOT_INDEX,
    SIF_MBR_PARTITION_SYSBOOT_FLAGS,
    SIF_MBR_PARTITION_VOLUME_GUID,      //optional
    SIF_MBR_PARTITION_ACTIVE_FLAG,
    SIF_MBR_PARTITION_PTN_TYPE,
    SIF_MBR_PARTITION_FS_TYPE,
    SIF_MBR_PARTITION_STARTSECTOR,
    SIF_MBR_PARTITION_SECTORCOUNT,
    SIF_MBR_PARTITION_CLUSTER_SIZE,
    SIF_MBR_PARTITION_NUMFIELDS                // Must always be last
} SIF_MBR_PARTITION_FIELD_INDEX;


//
// Indices for the [PARTITIONS.GPT] section.
//
// [PARTITIONS.GPT]
//
// partition-key = 0.disk-key, 1.slot-index, 2.boot-sys-flag,
//                 3."volume-guid", 4."partition-type-guid", 5."partition-id-guid"
//                 6.gpt-attributes, 7."partition-name", 8.file-system-type,
//                 9.start-sector, 10.sector-count, 11.fs-cluster-size
//
typedef enum _SIF_GPT_PARTITION_FIELD_INDEX {
    SIF_GPT_PARTITION_DISKKEY = 0,
    SIF_GPT_PARTITION_SLOT_INDEX,
    SIF_GPT_PARTITION_SYSBOOT_FLAGS,
    SIF_GPT_PARTITION_VOLUME_GUID,      //optional
    SIF_GPT_PARTITION_TYPE_GUID,
    SIF_GPT_PARTITION_ID_GUID,
    SIF_GPT_PARTITION_GPT_ATTRIBUTES,
    SIF_GPT_PARTITION_NAME,
    SIF_GPT_PARTITION_FS_TYPE,
    SIF_GPT_PARTITION_STARTSECTOR,
    SIF_GPT_PARTITION_SECTORCOUNT,
    SIF_GPT_PARTITION_CLUSTER_SIZE,
    SIF_GPT_PARTITION_NUMFIELDS                // Must always be last
} SIF_GPT_PARTITION_FIELD_INDEX;


// Indices for the [INSTALLFILES] section.
typedef enum _SIF_INSTALLFILE_FIELD_INDEX {
    SIF_INSTALLFILE_SYSTEM_KEY = 0,
    SIF_INSTALLFILE_SOURCE_MEDIA_LABEL,
    SIF_INSTALLFILE_SOURCE_DEVICE,
    SIF_INSTALLFILE_SOURCE_FILE_PATH,
    SIF_INSTALLFILE_DESTFILE,
    SIF_INSTALLFILE_VENDORSTRING,
    SIF_INSTALLFILE_FLAGS,
    SIF_INSTALLFILE_NUMFIELDS        // Must always be last
} SIF_INSTALLFILE_FIELD_INDEX;

// Global
PVOID           Gbl_HandleToDrStateFile;
extern PWSTR    Gbl_SifSourcePath;


// Forward Declarations
VOID
SpAsrDbgDumpInstallFileList(IN PSIF_INSTALLFILE_LIST pList);

PSIF_PARTITION_RECORD_LIST
SpAsrCopyPartitionRecordList(PSIF_PARTITION_RECORD_LIST pSrcList);


///////////////////////////////
// Generic functions for all sections
//

//
// The string returned should not be freed, since it's part of Setup's internal sif
// data structure!
//
PWSTR
SpAsrGetSifDataBySectionAndKey(
    IN const PWSTR Section,
    IN const PWSTR Key,
    IN const ULONG Value,
    IN const BOOLEAN NonNullRequired
    )                               // does not return on error if NonNullRequired is TRUE
{
    PWSTR data = NULL;
    ASSERT(Section && Key);  // debug

    data = SpGetSectionKeyIndex(
        Gbl_HandleToDrStateFile,
        Section,
        Key,
        Value
        );

    if (NonNullRequired) {
        if (!data || !wcscmp(data, ASR_NULL_STRING)) {
            DbgFatalMesg((_asrerr, "SpAsrGetSifDataBySectionAndKey. Data is "
                "NULL. Section:[%ws], Key:[%ws], Value:[%lu]\n",
                Section, Key, Value));
            swprintf(TemporaryBuffer, L"%lu value not specified in %ws "
                L"record %ws", Value, Section, Key);
            SpAsrRaiseFatalErrorWs(SP_SCRN_DR_SIF_BAD_RECORD,
                TemporaryBuffer, Section);
            // does not return
        }
    }

    return data;
}


ULONG
SpAsrGetRecordCount(
    IN PWSTR Section,
    IN ULONG MinimumValid
    )
{
    ULONG count;
    ASSERT(Section);

    count = SpCountLinesInSection(Gbl_HandleToDrStateFile, Section);

    if (count < MinimumValid) {
        DbgFatalMesg((_asrerr, "SpAsrGetRecordCount. No records in [%ws] section.\n",
                             Section));

        swprintf(TemporaryBuffer, L"No records in section");

        SpAsrRaiseFatalErrorWs(SP_SCRN_DR_SIF_BAD_RECORD,
                           TemporaryBuffer,
                           Section);
        // does not return
    }

    return count;
}


PWSTR
SpAsrGetSifKeyBySection(
    IN PWSTR Section,
    IN ULONG Index
    )                           // does not return on error
{
    PWSTR key;
    ULONG count = SpAsrGetRecordCount(Section, 1);

    // is index too big?
    if (Index > count) {
        DbgFatalMesg((_asrerr,
            "SpAsrGetSifKeyBySection. Section [%ws]. Index (%lu) greater than NumRecords (%lu)\n",
            Section,
            Index,
            count
            ));

        swprintf(TemporaryBuffer, L"Index too large: Key not found.");

        SpAsrRaiseFatalErrorWs(SP_SCRN_DR_SIF_BAD_RECORD,
            TemporaryBuffer,
            Section
            );
        // does not return
    }

    key = SpGetKeyName(Gbl_HandleToDrStateFile, Section, Index);

    if (!key || !wcscmp(key, ASR_NULL_STRING)) {

        DbgFatalMesg((_asrerr,
            "SpAsrGetSifKeyBySection. SpGetKeyName failed in Section:[%ws] for Index:%lu.\n",
            Section,
            Index
            ));

        swprintf(TemporaryBuffer, L"%ws key not found for record %lu", Section, Index + 1);

        SpAsrRaiseFatalErrorWs(SP_SCRN_DR_SIF_BAD_RECORD,
            TemporaryBuffer,
            Section
            );
        // does not return
     }

    return key;
}


///////////////////////////////
// [SYSTEMS] section functions
//

#define ASR_PRODUCTSUITES_TO_MATCH ((  VER_SUITE_SMALLBUSINESS               \
                                 | VER_SUITE_ENTERPRISE                  \
                                 | VER_SUITE_BACKOFFICE                  \
                                 | VER_SUITE_COMMUNICATIONS              \
                                 | VER_SUITE_SMALLBUSINESS_RESTRICTED    \
                                 | VER_SUITE_EMBEDDEDNT                  \
                                 | VER_SUITE_DATACENTER                  \
                                 | VER_SUITE_PERSONAL))

//
// This checks to make sure that Windows media being used for the recovery
// is the same SKU as that in asr.sif  (so the user isn't trying to recover
// an ADS installation with a PRO CD, for instance), and that the platform
// of the target machine is the same as that in asr.sif  (so the user isn't
// trying to recover an ia64 with an amd64 or x86 asr.sif, for instance)
//
VOID
SpAsrCheckSystemCompatibility()
{
    PWSTR sifPlatform = NULL;
    WCHAR currentPlatform[10];
    DWORD suiteInSif = 0, currentSuite = 0, productInSif = 0;
    BOOLEAN validSKU = TRUE;

    sifPlatform = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_SYSTEMS_SECTION,
        ASR_SIF_SYSTEM_KEY,
        SIF_SYSTEM_PLATFORM,
        TRUE
        );

    wcscpy(currentPlatform, L"unknown");
#if defined(_X86_)
    wcscpy(currentPlatform, L"x86");
#elif defined(_AMD64_)
    wcscpy(currentPlatform, L"amd64");
#elif defined(_IA64_)
    wcscpy(currentPlatform, L"ia64");
#endif

    if (_wcsicmp(sifPlatform, currentPlatform)) {

        DbgFatalMesg((_asrerr,
            "asr.sif SYSTEM section. Invalid platform [%ws] (does not match the current platform)\n",
            sifPlatform
            ));

        SpAsrRaiseFatalError(
            SP_SCRN_DR_INCOMPATIBLE_MEDIA,
            L"Invalid platform"
            );
    }

    suiteInSif = STRING_TO_HEX(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_SYSTEMS_SECTION,
        ASR_SIF_SYSTEM_KEY,
        SIF_SYSTEM_PRODUCT_SUITE,
        TRUE
        ));

    productInSif = HIWORD(suiteInSif);
    suiteInSif = LOWORD(suiteInSif) & ASR_PRODUCTSUITES_TO_MATCH;

    if (suiteInSif) {
        if (!SuiteType) {
            //
            // SuiteType is set to 0 for PRO and SRV, and so cannot directly be
            // used in SpIsProductSuite().  These are the values that SuiteType
            // seems to be set to:
            //
            // PER  0x200   VER_SUITE_PERSONAL
            // BLA  0x400   VER_SUITE_BLADE
            // PRO  0x0	
            // SRV  0x0
            // ADS  0x2	    VER_SUITE_ENTERPRISE
            // DTC  0x82    VER_SUITE_DATACENTER | VER_SUITE_ENTERPRISE
            //
            //
            //
            // Not sure of the reasoning behind this, but let's make use of this
            // fact (cf SpGetHeaderTextId)
            //

            //
            // Since SuiteType is 0, this must be PRO or SRV.  This can be determined
            // by checking the global AdvancedServer
            //
            validSKU = (AdvancedServer ?
                (
                 ((productInSif == VER_NT_SERVER) ||             // must be SRV
                 (productInSif == VER_NT_DOMAIN_CONTROLLER)) &&  //
                 !(suiteInSif | VER_SUITE_ENTERPRISE)            // and not ADS or DTC
                )
                :
                ( (productInSif == VER_NT_WORKSTATION) &&       // must be PRO
                  !(suiteInSif | VER_SUITE_PERSONAL)            // and not PER
                )
            );
        }
        else if (
            ((productInSif != VER_NT_SERVER) && (productInSif != VER_NT_DOMAIN_CONTROLLER)) ||
            !SpIsProductSuite(suiteInSif)
            ) {
            validSKU = FALSE;
        }
    }

    if (!validSKU) {
        DbgFatalMesg((_asrerr,
            "asr.sif SYSTEM Section. Invalid suite 0x%08x (does not match the current media).\n",
            suiteInSif
            ));

        SpAsrRaiseFatalError(
            SP_SCRN_DR_INCOMPATIBLE_MEDIA,
            L"Invalid version"
            );
    }
}


ULONG
SpAsrGetSystemRecordCount(VOID)   // does not return on error
{
    return SpAsrGetRecordCount(SIF_ASR_SYSTEMS_SECTION, 1);
}


PWSTR
SpAsrGetNtDirectoryPathBySystemKey(IN PWSTR SystemKey)        // does not return on error
{
    return SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_SYSTEMS_SECTION,
        SystemKey,
        SIF_SYSTEM_NT_DIRECTORY_NAME,
        TRUE
        );
}


BOOLEAN
SpAsrGetAutoExtend(IN PWSTR SystemKey)
{
    PWSTR value = NULL;
    ASSERT(SystemKey);

    value = SpGetSectionKeyIndex(
        Gbl_HandleToDrStateFile,
        SIF_ASR_SYSTEMS_SECTION,
        SystemKey,
        SIF_SYSTEM_PARTITION_AUTOEXTEND_OPTION
        );

    if (!value || !wcscmp(value, ASR_NULL_STRING)) {
        DbgErrorMesg((_asrwarn, "Auto-extend not specified, assuming Enabled\n"));
        return TRUE;
    }
    else {
        return (BOOLEAN) STRING_TO_LONG(value);
    }
}


///////////////////////////////
// [ASRFLAGS] section functions
//

BOOLEAN
SpAsrGetSilentRepartitionFlag(IN PWSTR SystemKey)
{
    PWSTR value = NULL;
    ASSERT(SystemKey);

    value = SpGetSectionKeyIndex(
        Gbl_HandleToDrStateFile,
        SIF_ASRFLAGS_SECTION,
        SystemKey,
        SIF_ASRFLAGS_SILENT_REPARTITION_OPTION
        );

    if (value && !_wcsicmp(value, ASR_SIF_SILENT_REPARTITION_VALUE)) {
        DbgErrorMesg((_asrwarn, "SilentRepartition flag is set; will NOT prompt before repartitioning disks!\n"));
        return TRUE;
    }

    DbgStatusMesg((_asrinfo, "SilentRepartition flag not set; will prompt user before repartitioning disks\n"));
    return FALSE;
}


///////////////////////////////
// [VERSION] section functions
//

VOID
SpAsrCheckAsrStateFileVersion()
{
    PWSTR signature = NULL,
        provider = NULL,
        sifVersion = NULL;

    signature = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_VERSION_SECTION,
        SIF_ASR_SIGNATURE_KEY,
        0,
        TRUE
        );

    provider = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_VERSION_SECTION,
        SIF_ASR_PROVIDER_KEY,
        0,
        FALSE
        );     // ProviderName is optional

    sifVersion = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_VERSION_SECTION,
        SIF_ASR_SIFVERSION_KEY,
        0,
        TRUE
        );

    DbgStatusMesg((_asrinfo,
        "Asr Sif Version. sig:[%ws], provider:[%ws], sifVer:[%ws]\n",
        signature,
        provider ? provider : L"",
        sifVersion
        ));

    if (_wcsicmp(signature, ASR_SIF_RECOGNISED_SIGNATURE)) {

        DbgFatalMesg((_asrerr,
            "asr.sif VERSION section. Invalid signature [%ws] (it MUST be $Windows NT$).\n",
            signature
            ));

        SpAsrRaiseFatalError(
            SP_TEXT_DR_STATEFILE_ERROR,
            L"Invalid signature"
            );
    }

    if (_wcsnicmp(sifVersion, ASR_SIF_RECOGNISED_VERSION, wcslen(ASR_SIF_RECOGNISED_VERSION))) {

        DbgFatalMesg((_asrerr,
            "asr.sif VERSION Section. Invalid asr.sif version [%ws] (it MUST be 1.x).\n",
            sifVersion
            ));

        SpAsrRaiseFatalError(
            SP_TEXT_DR_STATEFILE_ERROR,
            L"Invalid version"
            );
    }

    SpAsrCheckSystemCompatibility();
}


/////////////////////////////////
// InstallFiles section functions
//

ULONG
SpAsrGetInstallFilesRecordCount(VOID)         // does not return on error
{
    return SpAsrGetRecordCount(SIF_ASR_INSTALLFILES_SECTION, 0);
}


PSIF_INSTALLFILE_RECORD
SpAsrGetInstallFileRecord(IN PWSTR InstallFileKey, IN PCWSTR SetupSourceDevicePath)
{
    PSIF_INSTALLFILE_RECORD pRec = NULL;
    PWSTR   tempStr = NULL;
    BOOL    isValid = FALSE;

    if (!InstallFileKey) {
        DbgFatalMesg((_asrerr, "SpAsrGetInstallFileRecord. InstallFileKey is NULL\n"));

        SpAsrRaiseFatalErrorWs(
            SP_SCRN_DR_SIF_BAD_RECORD,
            L"InstallFileKey is NULL",
            SIF_ASR_INSTALLFILES_SECTION
            );
    }

    pRec = SpAsrMemAlloc(sizeof(SIF_INSTALLFILE_RECORD), TRUE);

    pRec->SystemKey = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_INSTALLFILES_SECTION,
        InstallFileKey,
        SIF_INSTALLFILE_SYSTEM_KEY,
        TRUE
        );

    pRec->CurrKey = InstallFileKey;

    pRec->SourceMediaExternalLabel = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_INSTALLFILES_SECTION,
        InstallFileKey,
        SIF_INSTALLFILE_SOURCE_MEDIA_LABEL,
        TRUE
        );


    tempStr = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_INSTALLFILES_SECTION,
        InstallFileKey,
        SIF_INSTALLFILE_SOURCE_DEVICE,
        TRUE
        );

    //
    // Check if the device is specified as %FLOPPY%, %CDROM% or %SETUPSOURCE%,
    // and use the full path (\device\floppy0 or \device\CdRom0 or 
    // SetupSourceDevicePath) if so.
    //
    if (!_wcsicmp(tempStr, ASR_FLOPPY_DEVICE_ALIAS)) {
        pRec->DiskDeviceName = SpDupStringW(ASR_FLOPPY0_DEVICE_PATH);
    }
    else if (!_wcsicmp(tempStr, ASR_CDROM_DEVICE_ALIAS)) {
        pRec->DiskDeviceName = SpDupStringW(ASR_CDROM0_DEVICE_PATH);
    }
    else if (!_wcsicmp(tempStr, ASR_SOURCE_DEVICE_ALIAS) && SetupSourceDevicePath) {
        pRec->DiskDeviceName = SpDupStringW(SetupSourceDevicePath);
    }
    else {
        //
        // It wasn't any of the aliases--he's allowed to specify
        // the full device path, so we use it as is.
        //
        pRec->DiskDeviceName = SpDupStringW(tempStr);
    }

    pRec->SourceFilePath = (PWSTR) SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_INSTALLFILES_SECTION,
        InstallFileKey,
        SIF_INSTALLFILE_SOURCE_FILE_PATH,
        TRUE
        );

    tempStr = (PWSTR) SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_INSTALLFILES_SECTION,
        InstallFileKey,
        SIF_INSTALLFILE_DESTFILE,
        TRUE
        );

    //
    //  Set the CopyToDirectory based on the tempStr path
    //
    if (!_wcsnicmp(tempStr, ASR_SIF_TEMP_DIRECTORY_ALIAS, wcslen(ASR_SIF_TEMP_DIRECTORY_ALIAS))) {
        //
        // Begins is %TEMP%\
        //
        pRec->CopyToDirectory = _Temp;
        pRec->DestinationFilePath = SpDupStringW((PWSTR)(&tempStr[wcslen(ASR_SIF_TEMP_DIRECTORY_ALIAS)]));
    }
    else if (!_wcsnicmp(tempStr, ASR_SIF_TMP_DIRECTORY_ALIAS, wcslen(ASR_SIF_TMP_DIRECTORY_ALIAS))) {
        //
        // Begins is %TMP%\
        //
        pRec->CopyToDirectory = _Tmp;
        pRec->DestinationFilePath = SpDupStringW((PWSTR)(&tempStr[wcslen(ASR_SIF_TMP_DIRECTORY_ALIAS)]));
    }
    else if (!_wcsnicmp(tempStr, ASR_SIF_SYSTEM_ROOT_ALIAS, wcslen(ASR_SIF_SYSTEM_ROOT_ALIAS))) {
        //
        // Begins is %SYSTEMROOT%\
        //
        pRec->CopyToDirectory = _SystemRoot;
        pRec->DestinationFilePath = SpDupStringW((PWSTR)(&tempStr[wcslen(ASR_SIF_SYSTEM_ROOT_ALIAS)]));
    }
    else {
        //
        // Not specified, or unknown: use default.
        //
        pRec->CopyToDirectory = _Default;
        pRec->DestinationFilePath = SpDupStringW(tempStr);
    }

    pRec->VendorString = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_INSTALLFILES_SECTION,
        InstallFileKey,
        SIF_INSTALLFILE_VENDORSTRING,
        TRUE
        );

    tempStr = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_INSTALLFILES_SECTION,
        InstallFileKey,
        SIF_INSTALLFILE_FLAGS,
        FALSE
        );
    if (tempStr) {
        pRec->Flags = STRING_TO_HEX(tempStr);
    }

    return pRec;
}


VOID
SpAsrInsertInstallFileRecord(
    IN SIF_INSTALLFILE_LIST *InstallFileList,
    IN PSIF_INSTALLFILE_RECORD pRec
    )
{
    pRec->Next = InstallFileList->First;
    InstallFileList->First = pRec;
    InstallFileList->Count += 1;
}


PSIF_INSTALLFILE_RECORD
SpAsrRemoveInstallFileRecord(IN SIF_INSTALLFILE_LIST *InstallFileList)
{
    PSIF_INSTALLFILE_RECORD pRec = NULL;

    if (InstallFileList->Count > 0) {
        pRec = InstallFileList->First;
        InstallFileList->First = pRec->Next;
        InstallFileList->Count -= 1;
    }

    return pRec;
}


VOID
SpAsrDeleteInstallFileRecord(
    IN OUT PSIF_INSTALLFILE_RECORD pRec
    )
{
    //
    // Free the memory we allocated.  The other fields are pointers to
    // setup's internal inf data structure, we shouldn't free those
    // else they'd get freed twice.
    //
    if (pRec->DiskDeviceName) {
        SpMemFree(pRec->DiskDeviceName);
        pRec->DiskDeviceName = NULL;
    }

    if (pRec->DestinationFilePath) {
        SpMemFree(pRec->DestinationFilePath);
        pRec->DestinationFilePath = NULL;
    }

    SpMemFree(pRec);
    pRec = NULL;
}


PSIF_INSTALLFILE_LIST
SpAsrInit3rdPartyFileList(IN PCWSTR SetupSourceDevicePath)
{
    PSIF_INSTALLFILE_RECORD pRec;
    PSIF_INSTALLFILE_LIST pList = NULL;
    ULONG count, index;

    if ((count = SpAsrGetInstallFilesRecordCount()) == 0) {
        return NULL;
    }

    pList = SpAsrMemAlloc(sizeof(SIF_INSTALLFILE_LIST), TRUE);

    for (index = 0; index < count; index++) {

        pRec = SpAsrGetInstallFileRecord(SpAsrGetSifKeyBySection(SIF_ASR_INSTALLFILES_SECTION, index), SetupSourceDevicePath);
        DbgStatusMesg((_asrinfo, "SpAsrInit3rdPartyFileList. Adding [%ws] to list\n", pRec->SourceFilePath));
        SpAsrInsertInstallFileRecord(pList, pRec);
    }

    return pList;
}



////////////////////////////
// [BUSES] section function
//

STORAGE_BUS_TYPE
SpAsrGetBusType(IN ULONG Index)
{

    STORAGE_BUS_TYPE BusType;

    PWSTR BusKey = SpAsrGetSifKeyBySection(SIF_ASR_BUSES_SECTION, Index);

    BusType = (STORAGE_BUS_TYPE) (STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
            SIF_ASR_BUSES_SECTION,
            BusKey,
            SIF_BUSES_BUS_TYPE,
            TRUE
             )));

    return BusType;
}




////////////////////////////
// [DISKS] section function
//

//
// Returns the total number of disk records (both MBR and GPT)
//
ULONG
SpAsrGetGptDiskRecordCount(VOID)         // does not return on error
{
    static ULONG Count = (ULONG) (-1);

    if ((ULONG) (-1) == Count) {
        Count = SpAsrGetRecordCount(SIF_ASR_GPT_DISKS_SECTION, 0);
    }

    return Count;
}


ULONG
SpAsrGetMbrDiskRecordCount(VOID)         // does not return on error
{
    static ULONG Count = (ULONG) (-1);

    if ((ULONG) (-1) == Count) {
        Count = SpAsrGetRecordCount(SIF_ASR_MBR_DISKS_SECTION, 0);
    }

    return Count;
}

ULONG
SpAsrGetDiskRecordCount(VOID)         // does not return on error
{
    static ULONG Total = (ULONG) (-1);

    if ((ULONG) (-1) == Total ) {
        Total = SpAsrGetMbrDiskRecordCount() + SpAsrGetGptDiskRecordCount();
    }

    return Total;
}



PWSTR
SpAsrGetDiskKey(
    IN PARTITION_STYLE Style,   // GPT or MBR
    IN ULONG Index
    )       // does not return on error
{
    switch (Style) {

    case PARTITION_STYLE_GPT:
        return SpAsrGetSifKeyBySection(SIF_ASR_GPT_DISKS_SECTION, Index);
        break;

    case PARTITION_STYLE_MBR:
        return SpAsrGetSifKeyBySection(SIF_ASR_MBR_DISKS_SECTION, Index);
        break;

    }

    ASSERT(0 && L"Illegal partition style specified");
    return NULL;
}


PSIF_DISK_RECORD
SpAsrGetMbrDiskRecord(
    IN PWSTR DiskKey
    )
{
    PSIF_DISK_RECORD pRec;

    if (!DiskKey) {
        ASSERT(0 && L"SpAsrGetMbrDiskRecord:  DiskKey is NULL!");
        return NULL;
    }

    pRec = SpAsrMemAlloc(sizeof(SIF_DISK_RECORD), TRUE);
    //
    // This is an MBR disk
    //
    pRec->PartitionStyle = PARTITION_STYLE_MBR;

    //
    // [DISKS.MBR] format
    //
    // 0.disk-key = 1.system-key, 2.bus-key, 3.critical-flag,
    //              4.disk-signature, 5.bytes-per-sector, 6.total-sectors
    //

    pRec->CurrDiskKey = DiskKey;

    pRec->SystemKey = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_DISKS_SECTION ,
        DiskKey,
        SIF_MBR_DISK_SYSTEMKEY,
        TRUE
        );

    pRec->BusKey = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_DISKS_SECTION ,
        DiskKey,
        SIF_MBR_DISK_BUSKEY,
        TRUE
        ));
    pRec->BusType = SpAsrGetBusType(pRec->BusKey - 1);   // our key is 1 based, AsrGetBusType index is 0 based

    if (ASRMODE_NORMAL != SpAsrGetAsrMode()) {
        pRec->IsCritical = TRUE;
    }
    else {
        pRec->IsCritical = (STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
            SIF_ASR_MBR_DISKS_SECTION ,
            DiskKey,
            SIF_MBR_DISK_CRITICAL_FLAG,
            TRUE
            ))) ? TRUE : FALSE;
    }

    pRec->SifDiskMbrSignature = STRING_TO_HEX(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_DISKS_SECTION ,
        DiskKey,
        SIF_MBR_DISK_SIGNATURE,
        TRUE
        ));

    pRec->BytesPerSector = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_DISKS_SECTION ,
        DiskKey,
        SIF_MBR_DISK_BYTES_PER_SECTOR,
        TRUE
        ));

    pRec->SectorsPerTrack = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_DISKS_SECTION ,
        DiskKey,
        SIF_MBR_DISK_SECTORS_PER_TRACK,
        TRUE
        ));

    pRec->TracksPerCylinder = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_DISKS_SECTION ,
        DiskKey,
        SIF_MBR_DISK_TRACKS_PER_CYLINDER,
        TRUE
        ));

    pRec->TotalSectors = STRING_TO_LONGLONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_DISKS_SECTION ,
        DiskKey,
        SIF_MBR_DISK_TOTALSECTORS,
        TRUE
        ));

    return pRec;
}


PSIF_DISK_RECORD
SpAsrGetGptDiskRecord(
    IN PWSTR DiskKey
    )
{
    PSIF_DISK_RECORD pRec = NULL;
    PWSTR GuidString = NULL;

    if (!DiskKey) {
        ASSERT(0 && L"SpAsrGetGptDiskRecord:  DiskKey is NULL!");
        return NULL;
    }

    pRec = SpAsrMemAlloc(sizeof(SIF_DISK_RECORD), TRUE);

    pRec->PartitionStyle = PARTITION_STYLE_GPT;

    //
    // [DISKS.GPT] format
    //
    // 0.disk-key = 1.system-key, 2.bus-key, 3.critical-flag, 4.disk-id,
    //              5.min-partition-count, 6.bytes-per-sector, 7.total-sectors
    //

    pRec->CurrDiskKey = DiskKey;

    pRec->SystemKey = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_DISKS_SECTION,
        DiskKey,
        SIF_GPT_DISK_SYSTEMKEY,
        TRUE
        );

    pRec->BusKey = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_DISKS_SECTION ,
        DiskKey,
        SIF_GPT_DISK_BUSKEY,
        TRUE
        ));

    pRec->BusType = SpAsrGetBusType(pRec->BusKey - 1);   // our key is 1 based, AsrGetBusType index is 0 based

    if (ASRMODE_NORMAL != SpAsrGetAsrMode()) {
        pRec->IsCritical = TRUE;
    }
    else {
        pRec->IsCritical = (STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
            SIF_ASR_GPT_DISKS_SECTION ,
            DiskKey,
            SIF_GPT_DISK_CRITICAL_FLAG,
            TRUE
            ))) ? TRUE : FALSE;
    }

    GuidString = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_DISKS_SECTION ,
        DiskKey,
        SIF_GPT_DISK_DISK_ID,
        TRUE
        );
    SpAsrGuidFromString(&(pRec->SifDiskGptId), GuidString);

    pRec->MaxGptPartitionCount = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_DISKS_SECTION ,
        DiskKey,
        SIF_GPT_DISK_MAX_PTN_COUNT,
        TRUE
        ));

    pRec->BytesPerSector = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_DISKS_SECTION ,
        DiskKey,
        SIF_GPT_DISK_BYTES_PER_SECTOR,
        TRUE
        ));

    pRec->SectorsPerTrack = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_DISKS_SECTION ,
        DiskKey,
        SIF_GPT_DISK_SECTORS_PER_TRACK,
        TRUE
        ));

    pRec->TracksPerCylinder = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_DISKS_SECTION ,
        DiskKey,
        SIF_GPT_DISK_TRACKS_PER_CYLINDER,
        TRUE
        ));

    pRec->TotalSectors = STRING_TO_LONGLONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_DISKS_SECTION ,
        DiskKey,
        SIF_GPT_DISK_TOTALSECTORS,
        TRUE
        ));

    return pRec;
}


PSIF_DISK_RECORD
SpAsrGetDiskRecord(
    IN PARTITION_STYLE PartitionStyle,
    IN PWSTR DiskKey
    )
{
    switch (PartitionStyle) {
    case PARTITION_STYLE_MBR:
        return SpAsrGetMbrDiskRecord(DiskKey);
        break;

    case PARTITION_STYLE_GPT:
        return SpAsrGetGptDiskRecord(DiskKey);
        break;
    }

    ASSERT(0 && L"Invalid partition type specified");
    return NULL;

}



PSIF_DISK_RECORD
SpAsrCopyDiskRecord(IN PSIF_DISK_RECORD pInput)
{
    PSIF_DISK_RECORD pRec;

    pRec = SpAsrMemAlloc(sizeof(SIF_DISK_RECORD), TRUE);

    CopyMemory(pRec, pInput, sizeof(SIF_DISK_RECORD));

    pRec->PartitionList = NULL;

    // copy the list of partitions, if any.
    if (pInput->PartitionList) {
        pRec->PartitionList = SpAsrCopyPartitionRecordList(pInput->PartitionList);
    }

    return pRec;
}


////////////////////////////////
// [PARTITIONS] section function
//

ULONG
SpAsrGetMbrPartitionRecordCount(VOID)
{
    return SpAsrGetRecordCount(SIF_ASR_MBR_PARTITIONS_SECTION, 0);
}

ULONG
SpAsrGetGptPartitionRecordCount(VOID)
{
    return SpAsrGetRecordCount(SIF_ASR_GPT_PARTITIONS_SECTION, 0);
}

PWSTR
SpAsrGetMbrPartitionKey(ULONG Index)
{
    return SpAsrGetSifKeyBySection(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        Index);
}


PWSTR
SpAsrGetGptPartitionKey(ULONG Index)
{
    return SpAsrGetSifKeyBySection(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        Index);
}


PWSTR
SpAsrGetDiskKeyByMbrPartitionKey(IN PWSTR PartitionKey)
{
    return SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        PartitionKey,
        SIF_MBR_PARTITION_DISKKEY,
        TRUE);
}


PWSTR
SpAsrGetDiskKeyByGptPartitionKey(IN PWSTR PartitionKey)
{
    return SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_DISKKEY,
        TRUE);
}

ULONGLONG
SpAsrGetSectorCountByMbrDiskKey(
    IN PWSTR DiskKey
    )
{
    return STRING_TO_ULONGLONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_DISKS_SECTION,
        DiskKey,
        SIF_MBR_DISK_TOTALSECTORS,
        FALSE
        ));
}

ULONGLONG
SpAsrGetSectorCountByGptDiskKey(
    IN PWSTR DiskKey
    )
{
    return STRING_TO_ULONGLONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_DISKS_SECTION,
        DiskKey,
        SIF_GPT_DISK_TOTALSECTORS,
        FALSE
        ));
}


//
// Reads in a partition record from the [PARTITIONS.MBR] section.
//
// [PARTITIONS.MBR]
//
// partition-key = 0.disk-key, 1.slot-index, 2.boot-sys-flag,
//                 3."volume-guid", 4.active-flag, 5.partition-type,
//                 6.file-system-type, 7.start-sector, 8.sector-count
//
PSIF_PARTITION_RECORD
SpAsrGetMbrPartitionRecord(IN PWSTR PartitionKey)
{
    PSIF_PARTITION_RECORD pRec = NULL;
    ULONG bytesPerSector = 0;
    ULONG ntSysMask = 0;

    //
    // PartitionKey better not be null
    //
    if (!PartitionKey) {
        DbgErrorMesg((_asrwarn, "SpAsrGetPartitionRecord. PartitionKey is NULL\n"));
        ASSERT(0 && L"Partition key is NULL");
        return NULL;
    }

    pRec = SpAsrMemAlloc(sizeof(SIF_PARTITION_RECORD), TRUE);

    //
    // Read in the fields
    //
    pRec->CurrPartKey = PartitionKey;
    pRec->PartitionStyle = PARTITION_STYLE_MBR;

    pRec->DiskKey = SpAsrGetDiskKeyByMbrPartitionKey(PartitionKey);

    pRec->PartitionTableEntryIndex = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        PartitionKey,
        SIF_MBR_PARTITION_SLOT_INDEX,
        TRUE
        ));

    pRec->PartitionFlag = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        PartitionKey,
        SIF_MBR_PARTITION_SYSBOOT_FLAGS,
        TRUE
        ));

    pRec->VolumeGuid = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        PartitionKey,
        SIF_MBR_PARTITION_VOLUME_GUID,
        FALSE
        );

    pRec->ActiveFlag = (UCHAR) STRING_TO_HEX(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        PartitionKey,
        SIF_MBR_PARTITION_ACTIVE_FLAG,
        TRUE
        ));

    pRec->PartitionType = (UCHAR) STRING_TO_HEX(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        PartitionKey,
        SIF_MBR_PARTITION_PTN_TYPE,
        TRUE
        ));

    pRec->FileSystemType = (UCHAR) STRING_TO_HEX(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        PartitionKey,
        SIF_MBR_PARTITION_FS_TYPE,
        TRUE
        ));

    pRec->StartSector = STRING_TO_LONGLONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        PartitionKey,
        SIF_MBR_PARTITION_STARTSECTOR,
        TRUE
        ));

    pRec->SectorCount = STRING_TO_LONGLONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        PartitionKey,
        SIF_MBR_PARTITION_SECTORCOUNT,
        TRUE
        ));

    pRec->ClusterSize = (DWORD) STRING_TO_HEX(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_PARTITIONS_SECTION,
        PartitionKey,
        SIF_MBR_PARTITION_CLUSTER_SIZE,
        TRUE
        ));

    if (SpAsrIsBootPartitionRecord(pRec->PartitionFlag)) {

        // do not free!
        PWSTR ntDirPath = SpAsrGetNtDirectoryPathBySystemKey(ASR_SIF_SYSTEM_KEY);

        if (!SpAsrIsValidBootDrive(ntDirPath)) {

            SpAsrRaiseFatalErrorWs(SP_SCRN_DR_SIF_BAD_RECORD,
                L"ASSERT FAILURE: Improperly formed NT Directory Name",
                SIF_ASR_MBR_PARTITIONS_SECTION
                );
            // does not return
        }

        pRec->NtDirectoryName = SpAsrMemAlloc((SpGetMaxNtDirLen()*sizeof(WCHAR)), TRUE);

        wcsncpy(pRec->NtDirectoryName, ntDirPath + 2, wcslen(ntDirPath) - 2);
    }
    else {
        pRec->NtDirectoryName = NULL;
    }

    bytesPerSector = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_MBR_DISKS_SECTION ,
        pRec->DiskKey,
        SIF_MBR_DISK_BYTES_PER_SECTOR,
        TRUE
        ));

    pRec->SizeMB = SpAsrConvertSectorsToMB(pRec->SectorCount, bytesPerSector);

    return pRec;
}


PSIF_PARTITION_RECORD
SpAsrGetGptPartitionRecord(IN PWSTR PartitionKey)
{
    PSIF_PARTITION_RECORD pRec = NULL;
    ULONG bytesPerSector = 0;
    ULONG ntSysMask = 0;
    PWSTR GuidString = NULL;

    if (!PartitionKey) {

        DbgErrorMesg((_asrwarn, "SpAsrGetPartitionRecord. PartitionKey is NULL\n"));

        ASSERT(0 && L"Partition key is NULL");

        return NULL;
    }

    pRec = SpAsrMemAlloc(sizeof(SIF_PARTITION_RECORD), TRUE);

    //
    // Read in the fields
    //
    pRec->CurrPartKey = PartitionKey;
    pRec->PartitionStyle = PARTITION_STYLE_GPT;

    pRec->DiskKey = SpAsrGetDiskKeyByGptPartitionKey(PartitionKey);

    pRec->PartitionTableEntryIndex = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_SLOT_INDEX,
        TRUE
        ));

    pRec->PartitionFlag = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_SYSBOOT_FLAGS,
        TRUE
        ));

    pRec->VolumeGuid = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_VOLUME_GUID,
        FALSE
        );

    GuidString = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_TYPE_GUID,
        FALSE
        );
    SpAsrGuidFromString(&(pRec->PartitionTypeGuid), GuidString);

    GuidString = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_ID_GUID,
        FALSE
        );
    SpAsrGuidFromString(&(pRec->PartitionIdGuid), GuidString);

    pRec->PartitionName = SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_NAME,
        FALSE
        );

    pRec->GptAttributes = STRING_TO_LONGLONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_GPT_ATTRIBUTES,
        TRUE
        ));

    pRec->FileSystemType = (UCHAR) STRING_TO_HEX(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_FS_TYPE,
        TRUE
        ));

    pRec->StartSector = STRING_TO_LONGLONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_STARTSECTOR,
        TRUE
        ));

    pRec->SectorCount = STRING_TO_LONGLONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_SECTORCOUNT,
        TRUE
        ));


    pRec->ClusterSize = (DWORD) STRING_TO_HEX(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_PARTITIONS_SECTION,
        PartitionKey,
        SIF_GPT_PARTITION_CLUSTER_SIZE,
        TRUE
        ));

    if (SpAsrIsBootPartitionRecord(pRec->PartitionFlag)) {

        // do not free!
        PWSTR ntDirPath = SpAsrGetNtDirectoryPathBySystemKey(ASR_SIF_SYSTEM_KEY);

        if (!SpAsrIsValidBootDrive(ntDirPath)) {

            SpAsrRaiseFatalErrorWs(SP_SCRN_DR_SIF_BAD_RECORD,
                L"ASSERT FAILURE: Improperly formed NT Directory Name",
                SIF_ASR_GPT_PARTITIONS_SECTION
                );
            // does not return
        }


        pRec->NtDirectoryName = SpAsrMemAlloc((SpGetMaxNtDirLen()*sizeof(WCHAR)), TRUE);

        wcsncpy(pRec->NtDirectoryName, ntDirPath + 2, wcslen(ntDirPath) - 2);

    }
    else {
        pRec->NtDirectoryName = NULL;
    }

    bytesPerSector = STRING_TO_ULONG(SpAsrGetSifDataBySectionAndKey(
        SIF_ASR_GPT_DISKS_SECTION ,
        pRec->DiskKey,
        SIF_GPT_DISK_BYTES_PER_SECTOR,
        TRUE
        ));

    pRec->SizeMB = SpAsrConvertSectorsToMB(pRec->SectorCount, bytesPerSector);

    return pRec;
}


PSIF_PARTITION_RECORD
SpAsrCopyPartitionRecord(IN PSIF_PARTITION_RECORD pInput)
{
    PSIF_PARTITION_RECORD pRec = NULL;

    if (!pInput) {
        ASSERT(0 && L"SpAsrCopyPartitionRecord: Invalid NULL input parameter");
        return NULL;
    }

    pRec = SpAsrMemAlloc(sizeof(SIF_PARTITION_RECORD), TRUE);
    //
    // Won't return if pRec is NULL
    //
    ASSERT(pRec);

    //
    // Copy the record over
    //
    CopyMemory(pRec, pInput, sizeof(SIF_PARTITION_RECORD));

    //
    // And allocate space for the directory name
    //
    pRec->NtDirectoryName = NULL;
    if (
        SpAsrIsBootPartitionRecord(pRec->PartitionFlag)  &&
        pInput->NtDirectoryName
        ) {

        pRec->NtDirectoryName = SpAsrMemAlloc(
            (wcslen(pInput->NtDirectoryName) + 1) * sizeof(WCHAR),
            TRUE
            );
        //
        // Won't return NULL
        //
        ASSERT(pRec->NtDirectoryName);

        wcscpy(pRec->NtDirectoryName, pInput->NtDirectoryName);
    }

    return pRec;
}


VOID
SpAsrInsertPartitionRecord(
    IN PSIF_PARTITION_RECORD_LIST pList,
    IN PSIF_PARTITION_RECORD pRec
    )
/*++
Description:

    Inserts a partition record into a list of partition records.  Partition
    records are ordered in ascending order by start sector.  That is, the
    partition record with the lowest numbered start sector will be the first
    partition record in the list.

Arguments:

    pList   The list into which the record is to be inserted.

    pRec    The record to insert.

Returns:

    None.
--*/
{
    SIF_PARTITION_RECORD *curr = NULL, *prev = NULL;

    ASSERT(pList && pRec);

    // set the initial conditions.
    pRec->Next = NULL;
    pRec->Prev = NULL;

    pList->ElementCount += 1;


    // special Case I:  Insert into an empty list.
    if( pList->ElementCount == 1 ) {
        pList->First = pList->Last = pRec;
        return;
    }


    // Special Case II: pRec must be inserted before the first element.
    if( pRec->StartSector < pList->First->StartSector ) {
        pRec->Next = pList->First;
        pList->First = pRec;
        pRec->Next->Prev = pRec;
        return;
    }


    // Special Case III:  pRec must be appended after the last element
    // because pRec's start sector is greater than the last element
    // on the list (which, by construction, must have the largest
    // start sector).
    //
    if( pList->Last->StartSector < pRec->StartSector ) {
        pRec->Prev = pList->Last;
        pList->Last->Next = pRec;
        pList->Last = pRec;
        return;
    }

    // If we're here, then pRec's start sector must be greater than
    // the start sector of the first element on the list but less than
    // the start sector of the list's last element.  We walk the list
    // to find the insertion point, i.e., immediately before the first
    // element in the list whose start sector is greater than that of
    // pRec's.
    curr = prev = pList->First;
    while (pRec->StartSector > curr->StartSector && curr->Next) {
        prev = curr;
        curr = curr->Next;
    }


    // insert pRec between curr and prev
    pRec->Next = curr;
    pRec->Prev = prev;

    curr->Prev = pRec;
    prev->Next = pRec;

    ASSERT (pRec->Prev->Next == pRec);
    ASSERT (pRec->Next->Prev == pRec);
}


VOID
SpAsrRemovePartitionRecord(
    IN PSIF_PARTITION_RECORD_LIST pList,
    IN PSIF_PARTITION_RECORD pRec
    )
/*++

  Description:
    Unhook a partition record from a list of partition records.

--*/
{
    ASSERT(pList && pRec);

    // unhook it from the list.
    if (pRec->Prev) {
        pRec->Prev->Next = pRec->Next;
    }

    if (pRec->Next) {
        pRec->Next->Prev = pRec->Prev;
    }

    // was this the first record in the list?
    if (pList->First == pRec) {
        pList->First = pRec->Next;
    }

    // or the last record?
    if (pList->Last == pRec) {
        pList->Last = pRec->Prev;
    }

    pRec->Next = pRec->Prev = NULL;
}


PSIF_PARTITION_RECORD
SpAsrPopNextPartitionRecord(IN PSIF_PARTITION_RECORD_LIST pList)
{
    PSIF_PARTITION_RECORD poppedRecord = NULL;

    if (!pList) {
//        ASSERT(0 && L"Trying to pop records off of a NULL list");
        return NULL;
    }

    // get the first node in the list
    if (poppedRecord = pList->First) {

        // advance the First pointer to the next node
        if (pList->First = pList->First->Next) {

            // and make the Prev of the new first-node be NULL
            pList->First->Prev = NULL;
        }

        pList->ElementCount -= 1;

        // the poppedRecord is not part of the list any more
        poppedRecord->Next = NULL;
        poppedRecord->Prev = NULL;
    }

    return poppedRecord;
}


PSIF_PARTITION_RECORD_LIST
SpAsrCopyPartitionRecordList(PSIF_PARTITION_RECORD_LIST pSrcList)
{
    PSIF_PARTITION_RECORD_LIST pDestList = NULL;
    PSIF_PARTITION_RECORD pRec = NULL, pNew = NULL;

    if (!pSrcList) {
        ASSERT(0 && L"SpAsrCopyPartitionRecordList:  Invalid NULL input parameter");
        return NULL;
    }

    pDestList = SpAsrMemAlloc(sizeof(SIF_PARTITION_RECORD_LIST), TRUE);
    //
    // Won't return if pDestList is NULL.
    //
    ASSERT(pDestList);

    pRec = pSrcList->First;
    while (pRec) {

        pNew = SpAsrCopyPartitionRecord(pRec);
        ASSERT(pNew);

        SpAsrInsertPartitionRecord(pDestList, pNew);

        pRec = pRec->Next;
    }

    pDestList->TotalMbRequired = pSrcList->TotalMbRequired;

    return pDestList;
}



VOID
SpAsrCheckAsrSifVersion()
{

    return;
}


//
// Debug routines
//
#if 0
VOID
SpAsrDbgDumpSystemRecord(IN PWSTR Key)
{

    PWSTR osVer = SpAsrGetSifDataBySectionAndKey(SIF_ASR_SYSTEMS_SECTION,
                                               Key,
                                               SIF_SYSTEM_OSVERSION,
                                               FALSE);

    DbgMesg((_asrinfo,
        "Key:%ws = SysName:[%ws], OsVer:[%ws], NtDir:[%ws], AutoExt:[%ws]\n",
        Key,
        SpAsrGetSifDataBySectionAndKey(SIF_ASR_SYSTEMS_SECTION, Key, SIF_SYSTEM_NAME, TRUE),
        osVer? osVer : L"",
        SpAsrGetNtDirectoryPathBySystemKey(Key),
        SpAsrGetAutoExtend(Key)
        ));
}


VOID
SpAsrDbgDumpSystemRecords(VOID)
{
    ULONG index, count = SpAsrGetSystemRecordCount();
    DbgStatusMesg((_asrinfo, "----- Dumping [SYSTEM] Section (%lu Records): -----\n", count));
    for (index = 0; index < count; index++) {
        SpAsrDbgDumpSystemRecord(SpAsrGetSifKeyBySection(SIF_ASR_SYSTEMS_SECTION, index));
    }
    DbgStatusMesg((_asrinfo, "----- End of [SYSTEM] Section (%lu Records) -----\n", count));
}


VOID
SpAsrDbgDumpDiskRecord(IN PWSTR Key)
{
    PSIF_DISK_RECORD pRec = NULL;

    if (!Key) {
        return;
    }

    pRec = SpAsrGetDiskRecord(Key);
    if (!pRec) {
        return;
    }

    DbgMesg((_asrinfo,
        "Key:[%ws] = Sys:[%ws] SifDskNum:[%ws], SifDskSig:0x%lx, ScSz:%lu, TtlSc:%I64u",
        pRec->CurrDiskKey,
        pRec->SystemKey,
        pRec->SifDiskSignature,
        pRec->BytesPerSector,
        pRec->TotalSectors
        ));


    if (pRec->ExtendedPartitionStartSector > -1) {
        KdPrintEx((_asrinfo, ", extSS:%I64u, extSC:%I64u",
                    pRec->ExtendedPartitionStartSector,
                    pRec->ExtendedPartitionSectorCount));
    }

    KdPrintEx((_asrinfo, "\n"));
    SpMemFree(pRec);
}


VOID
SpAsrDbgDumpDiskRecords(VOID)
{
    ULONG index, count = SpAsrGetMbrDiskRecordCount();
    DbgStatusMesg((_asrinfo, "----- Dumping [DISK.MBR] Section (%lu Records): -----\n", count));
    for (index = 0; index < count; index++) {
        SpAsrDbgDumpDiskRecord(SpAsrGetSifKeyBySection(SIF_ASR_MBR_DISKS_SECTION , index));
    }
    DbgStatusMesg((_asrinfo, "----- End of [DISK.MBR] Section (%lu Records) -----\n", count));

    count = SpAsrGetGptDiskRecordCount();
    DbgStatusMesg((_asrinfo, "----- Dumping [DISK.GPT] Section (%lu Records): -----\n", count));
    for (index = 0; index < count; index++) {
        SpAsrDbgDumpDiskRecord(SpAsrGetSifKeyBySection(SIF_ASR_GPT_DISKS_SECTION , index));
    }
    DbgStatusMesg((_asrinfo, "----- End of [DISK.GPT] Section (%lu Records) -----\n", count));
}


VOID
SpAsrDbgDumpPartitionRecord(IN PARTITION_STYLE PartitinStyle, IN PWSTR Key)
{
    PSIF_PARTITION_RECORD pRec =  SpAsrGetPartitionRecord(Key);

    DbgMesg((_asrinfo,
        "Key:[%ws] = Dsk %ws, ntDir:[%ws], volGd:[%ws], actv:0x%x, type:0x%x, fs:0x%x boot:%ws, sys:%ws, SS:%I64u SC:%I64u sz:%I64u\n",
        pRec->CurrPartKey,
        pRec->DiskKey,
        SpAsrIsBootPartitionRecord(pRec->PartitionFlag) ? pRec->NtDirectoryName : L"n/a",
        pRec->VolumeGuid ? pRec->VolumeGuid : L"n/a",
        pRec->ActiveFlag,
        pRec->PartitionType,
        pRec->FileSystemType,
        SpAsrIsBootPartitionRecord(pRec->PartitionFlag) ? "Y" : "N",
        SpAsrIsSystemPartitionRecord(pRec->PartitionFlag) ? "Y" : "N",
        pRec->StartSector,
        pRec->SectorCount,
        pRec->SizeMB
        ));

    SpMemFree(pRec);
}


VOID
SpAsrDbgDumpPartitionList(IN PSIF_PARTITION_RECORD_LIST pList)
{
    PSIF_PARTITION_RECORD pRec;
    ASSERT(pList);
    DbgStatusMesg((_asrinfo, "----- Dumping Partition List: -----\n"));

    pRec = pList->First;
    while (pRec) {
        SpAsrDbgDumpPartitionRecord(pRec->CurrPartKey);
        pRec = pRec->Next;
    }
    DbgStatusMesg((_asrinfo, "----- End of Partition List -----\n"));
}


VOID
SpAsrDbgDumpPartitionRecords(VOID)
{
    ULONG index, count = SpAsrGetPartitionRecordCount();
    DbgStatusMesg((_asrinfo, "----- Dumping [PARTITION] Section (%lu Records): -----\n", count));
    for (index = 0; index < count; index++) {
        SpAsrDbgDumpPartitionRecord(SpAsrGetSifKeyBySection(SIF_ASR_MBR_PARTITIONS_SECTION, index));
    }
    DbgStatusMesg((_asrinfo, "----- End of [PARTITION] Section (%lu Records) -----\n", count));
}


VOID
SpAsrDbgDumpInstallFileRecord(IN PWSTR Key)
{
    PSIF_INSTALLFILE_RECORD pRec = SpAsrGetInstallFileRecord(Key,NULL);

    DbgMesg((_asrinfo,
        "Key:[%ws] = SysKey:[%ws], MediaLabel:[%ws], Media:[%ws], Src:[%ws], Dest:[%ws], Vendor:[%ws]",
        Key,
        pRec->SystemKey,
        pRec->SourceMediaExternalLabel,
        pRec->DiskDeviceName,
        pRec->SourceFilePath,
        pRec->DestinationFilePath,
        pRec->VendorString
        ));

    SpMemFree(pRec);
}

VOID
SpAsrDbgDumpInstallFileRecords(VOID)
{
    ULONG index, count = SpAsrGetInstallFilesRecordCount();
    DbgStatusMesg((_asrinfo, "----- Dumping [INSTALLFILE] Section (%lu Records): -----\n", count));
    for (index = 0; index < count; index++) {
        SpAsrDbgDumpInstallFileRecord(SpAsrGetSifKeyBySection(SIF_ASR_INSTALLFILES_SECTION, index));
    }
    DbgStatusMesg((_asrinfo, "----- End of [INSTALLFILE] Section (%lu Records) -----\n", count));
}

VOID
SpAsrDbgDumpInstallFileList(IN PSIF_INSTALLFILE_LIST pList)
{
    PSIF_INSTALLFILE_RECORD pRec;

    if (pList == NULL) {
        DbgStatusMesg((_asrinfo, "No 3rd party files are specified.\n"));
    }
    else {
        DbgStatusMesg((_asrinfo, "----- Dumping Install-file List: -----\n"));
        pRec = pList->First;
        while (pRec) {
            SpAsrDbgDumpInstallFileRecord(pRec->CurrKey);
            pRec = pRec->Next;
        }
        DbgStatusMesg((_asrinfo, "----- End of Install-file List -----\n"));
    }
}

VOID
SpAsrDbgTestSifFunctions(VOID)
{
    SpAsrDbgDumpSystemRecords();
    SpAsrDbgDumpDiskRecords();
    SpAsrDbgDumpPartitionRecords();
    SpAsrDbgDumpInstallFileRecords();
}
#endif // Debug routines