/*++

Copyright (c) 2000  Microsoft Corporation

Module Name:

    asrrest.c

Abstract:

    This module contains the following ASR routine:
        AsrRestoreNonCriticalDisks{A|W}

    This routine is called in GUI mode ASR, to reconfigure
    the non-critical storage devices on the target machine.

Notes:

    Naming conventions:
        _AsrpXXX    private ASR Macros
        AsrpXXX     private ASR routines
        AsrXXX      Publically defined and documented routines

Author:

    Guhan Suriyanarayanan (guhans)  27-May-2000

Environment:

    User-mode only.

Revision History:
    
    27-May-2000 guhans  
        Moved AsrRestoreNonCriticalDisks and other restore-time 
        routines from asr.c to asrrest.c

    01-Jan-2000 guhans
        Initial implementation for AsrRestoreNonCriticalDisks
        in asr.c

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


#include <diskguid.h>   // GPT partition type guids
#include <mountmgr.h>   // mountmgr ioctls
#include <winasr.h>     // ASR public routines

#define THIS_MODULE 'R'
#include "asrpriv.h"    // Private ASR definitions and routines


//
// --------
// typedefs and constants used within this module
// --------
//
typedef enum _ASR_SORT_ORDER {
    SortByLength,
    SortByStartingOffset
} ASR_SORT_ORDER;


typedef struct _ASR_REGION_INFO {

    struct _ASR_REGION_INFO *pNext;
    
    LONGLONG    StartingOffset;
    LONGLONG    RegionLength;
    DWORD       Index;

} ASR_REGION_INFO, *PASR_REGION_INFO;

#define ASR_AUTO_EXTEND_MAX_FREE_SPACE_IGNORED (1024 * 1024 * 16)


//
// --------
// function implementations
// --------
//

LONGLONG
AsrpRoundUp(
    IN CONST LONGLONG Number,
    IN CONST LONGLONG Base
    )

/*++

Routine Description:

    Helper function to round-up a number to a multiple of a given base.

Arguments:

    Number - The number to be rounded up.

    Base - The base using which Number is to be rounded-up.

Return Value:

    The first multiple of Base that is greater than or equal to Number.

--*/

{
    if (Number % Base) {
        return (Number + Base - (Number % Base));
    }
    else {
        return Number;        // already a multiple of Base.
    }
}


VOID
AsrpCreatePartitionTable(
    IN OUT PDRIVE_LAYOUT_INFORMATION_EX pDriveLayoutEx,
    IN PASR_PTN_INFO_LIST pPtnInfoList,
    IN DWORD BytesPerSector
    )

/*++

Routine Description:

    This creates a partition table based on the partition information 
    (pPtnInfoList) passed in 

Arguments:

          // needed to convert between sector count and byte offset

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    DWORD index = 0,
        NumEntries = 0;

    PPARTITION_INFORMATION_EX currentPtn = NULL;
    PASR_PTN_INFO               pPtnInfo = NULL;

    MYASSERT(pDriveLayoutEx);
    if (!pDriveLayoutEx || !pPtnInfoList || !(pPtnInfoList->pOffsetHead)) {
        return;
    }

    if (PARTITION_STYLE_GPT == pDriveLayoutEx->PartitionStyle) {
        NumEntries = pDriveLayoutEx->Gpt.MaxPartitionCount;
    }
    else if (PARTITION_STYLE_MBR == pDriveLayoutEx->PartitionStyle) {
        NumEntries = pDriveLayoutEx->PartitionCount;
    }
    else {
        MYASSERT(0 && L"Unrecognised partitioning style (neither MBR nor GPT)");
        return;
    }

    //
    // Zero out the entire partition table first
    //
    for (index = 0; index < NumEntries; index++) {

        currentPtn = &(pDriveLayoutEx->PartitionEntry[index]);

        currentPtn->StartingOffset.QuadPart = 0;
        currentPtn->PartitionLength.QuadPart = 0;

    }

    //
    // Now go through each of the partitions in the list, and add their entry
    // to the partition table (at index = SlotIndex)
    //
    pPtnInfo = pPtnInfoList->pOffsetHead;

    while (pPtnInfo) {

        //
        // For GPT partitions, SlotIndex is 0-based without holes
        //
        currentPtn = &(pDriveLayoutEx->PartitionEntry[pPtnInfo->SlotIndex]);

        MYASSERT(0 == currentPtn->StartingOffset.QuadPart);        // this entry better be empty

        //
        // Convert the StartSector and SectorCount to BYTE-Offset and BYTE-Count ...
        //
        pPtnInfo->PartitionInfo.StartingOffset.QuadPart *= BytesPerSector;
        pPtnInfo->PartitionInfo.PartitionLength.QuadPart *= BytesPerSector;

        //
        // Copy the partition-information struct over
        //
        memcpy(currentPtn, &(pPtnInfo->PartitionInfo), sizeof(PARTITION_INFORMATION_EX));

        currentPtn->RewritePartition = TRUE;
        currentPtn->PartitionStyle = pDriveLayoutEx->PartitionStyle;

        pPtnInfo = pPtnInfo->pOffsetNext;
    }
}


//
//
//
ULONG64
AsrpStringToULong64(
    IN PWSTR String
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    ULONG64 result = 0, base = 10;
    BOOL negative = FALSE, done = FALSE;

    if (!String) {
        return 0;
    }

    if (L'-' == *String) {  // But this is ULONG!
        negative = TRUE;
        String++;
    }

    if (L'0' == *String &&
        (L'x' ==  *(String + 1) || L'X' == *(String + 1))
        ) {
        // Hex
        base = 16;
        String += 2;
    }

    while (!done) {
        done = TRUE;

        if (L'0' <= *String && L'9' >= *String) {
            result = result*base + (*String - L'0');
            String++;
            done = FALSE;
        }
        else if (16==base) {
            if (L'a' <= *String && L'f' >= *String) {
                result = result*base + (*String - L'a') + 10;
                String++;
                done = FALSE;

            }
            else if (L'A' <= *String && L'F' >= *String) {
                result = result*base + (*String - L'A') + 10;
                String++;
                done = FALSE;
            }
        }
    }

    if (negative) {
        result = 0 - result;
    }

    return result;
}


LONGLONG
AsrpStringToLongLong(
    IN PWSTR String
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    LONGLONG result = 0, base = 10;
    BOOL negative = FALSE, done = FALSE;

    if (!String) {
        return 0;
    }

    if (L'-' == *String) {
        negative = TRUE;
        String++;
    }

    if (L'0' == *String &&
        (L'x' ==  *(String + 1) || L'X' == *(String + 1))
        ) {
        // Hex
        base = 16;
        String += 2;
    }

    while (!done) {
        done = TRUE;

        if (L'0' <= *String && L'9' >= *String) {
            result = result*base + (*String - L'0');
            String++;
            done = FALSE;
        }
        else if (16==base) {
            if (L'a' <= *String && L'f' >= *String) {
                result = result*base + (*String - L'a') + 10;
                String++;
                done = FALSE;

            }
            else if (L'A' <= *String && L'F' >= *String) {
                result = result*base + (*String - L'A') + 10;
                String++;
                done = FALSE;
            }
        }
    }

    if (negative) {
        result = 0 - result;
    }

    return result;
}


DWORD
AsrpStringToDword(
    IN PWSTR String
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    DWORD result = 0, base = 10;
    BOOL negative = FALSE, done = FALSE;
    if (!String) {
        return 0;
    }
    if (L'-' == *String) {  // but this is unsigned!
        negative = TRUE;
        String++;
    }
    if (L'0' == *String &&
        (L'x' ==  *(String + 1) || L'X' == *(String + 1))
        ) {
        // Hex
        base = 16;
        String += 2;
    }
    while (!done) {
        done = TRUE;

        if (L'0' <= *String && L'9' >= *String) {
            result = result*base + (*String - L'0');
            String++;
            done = FALSE;
        }
        else if (16==base) {
            if (L'a' <= *String && L'f' >= *String) {
                result = result*base + (*String - L'a') + 10;
                String++;
                done = FALSE;

            }
            else if (L'A' <= *String && L'F' >= *String) {
                result = result*base + (*String - L'A') + 10;
                String++;
                done = FALSE;
            }
        }
    }
    if (negative) {
        result = 0 - result;
    }
    return result;
}


ULONG
AsrpStringToULong(
    IN PWSTR String
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    ULONG result = 0, base = 10;
    BOOL negative = FALSE, done = FALSE;
    if (!String) {
        return 0;
    }
    if (L'-' == *String) {  // but this is unsigned!
        negative = TRUE;
        String++;
    }
    if (L'0' == *String &&
        (L'x' ==  *(String + 1) || L'X' == *(String + 1))
        ) {
        // Hex
        base = 16;
        String += 2;
    }
    while (!done) {
        done = TRUE;

        if (L'0' <= *String && L'9' >= *String) {
            result = result*base + (*String - L'0');
            String++;
            done = FALSE;
        }
        else if (16==base) {
            if (L'a' <= *String && L'f' >= *String) {
                result = result*base + (*String - L'a') + 10;
                String++;
                done = FALSE;

            }
            else if (L'A' <= *String && L'F' >= *String) {
                result = result*base + (*String - L'A') + 10;
                String++;
                done = FALSE;
            }
        }
    }
    if (negative) {
        result = 0 - result;
    }
    return result;
}


VOID
AsrpInsertSortedPartitionLengthOrder(
    IN PASR_PTN_INFO_LIST pPtnInfoList,
    IN PASR_PTN_INFO    pPtnInfo
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{

    PASR_PTN_INFO pPreviousPtn = NULL,
        pCurrentPtn = NULL;


    //
    // Insert this in the sorted PartitionLength order ...
    //
    pCurrentPtn = pPtnInfoList->pLengthHead;
    if (!pCurrentPtn) {
        //
        // First item in the list
        //
        pPtnInfoList->pLengthHead = pPtnInfo;
        pPtnInfoList->pLengthTail = pPtnInfo;
    }
    else {

        while (pCurrentPtn) {

             if (pCurrentPtn->PartitionInfo.PartitionLength.QuadPart
                <= pPtnInfo->PartitionInfo.PartitionLength.QuadPart) {

                pPreviousPtn = pCurrentPtn;
                pCurrentPtn = pCurrentPtn->pLengthNext;
            }

            else {
                //
                // We found the spot, let's add it in.
                //
                if (!pPreviousPtn) {
                    //
                    // This is the first node
                    //
                    pPtnInfoList->pLengthHead = pPtnInfo;
                }
                else {
                    pPreviousPtn->pLengthNext = pPtnInfo;
                }
                pPtnInfo->pLengthNext = pCurrentPtn;
                break;
            }

        }

        if (!pCurrentPtn) {
            //
            // We reached the end and didn't add this node in.
            //
            MYASSERT(pPtnInfoList->pLengthTail == pPreviousPtn);
            pPtnInfoList->pLengthTail = pPtnInfo;
            pPreviousPtn->pLengthNext = pPtnInfo;
        }
    }
}


VOID
AsrpInsertSortedPartitionStartOrder(
    IN PASR_PTN_INFO_LIST pPtnInfoList,
    IN PASR_PTN_INFO    pPtnInfo
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    None
   
--*/

{

    PASR_PTN_INFO pPreviousPtn = NULL,
        pCurrentPtn = NULL;


    //
    // Insert this in the sorted Start-Sector order ...
    //
    pCurrentPtn = pPtnInfoList->pOffsetHead;
    if (!pCurrentPtn) {
        //
        // First item in the list
        //
        pPtnInfoList->pOffsetHead = pPtnInfo;
        pPtnInfoList->pOffsetTail = pPtnInfo;
    }
    else {

        while (pCurrentPtn) {

             if (pCurrentPtn->PartitionInfo.StartingOffset.QuadPart
                <= pPtnInfo->PartitionInfo.StartingOffset.QuadPart) {

                pPreviousPtn = pCurrentPtn;
                pCurrentPtn = pCurrentPtn->pOffsetNext;
            }

            else {
                //
                // We found the spot, let's add it in.
                //
                if (!pPreviousPtn) {
                    //
                    // This is the first node
                    //
                    pPtnInfoList->pOffsetHead = pPtnInfo;
                }
                else {
                    pPreviousPtn->pOffsetNext = pPtnInfo;
                }
                pPtnInfo->pOffsetNext = pCurrentPtn;
                break;
            }

        }

        if (!pCurrentPtn) {
            //
            // We reached the end and didn't add this node in.
            //
            MYASSERT(pPtnInfoList->pOffsetTail == pPreviousPtn);
            pPtnInfoList->pOffsetTail = pPtnInfo;
            pPreviousPtn->pOffsetNext = pPtnInfo;
        }
    }
}


//
// Build the original MBR disk info from the sif file
//
BOOL
AsrpBuildMbrSifDiskList(
    IN  PCWSTR              sifPath,
    OUT PASR_DISK_INFO      *ppSifDiskList,
    OUT PASR_PTN_INFO_LIST  *ppSifMbrPtnList,
    OUT BOOL                *lpAutoExtend
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    HINF hSif = NULL;
    
    INFCONTEXT infSystemContext,
        infDiskContext,
        infBusContext,
        infPtnContext;

    BOOL result = FALSE;

    DWORD reqdSize = 0,
        diskCount = 0,
        status = ERROR_SUCCESS;

    INT tempInt = 0;

    UINT errorLine = 0;

    PASR_DISK_INFO pNewSifDisk = NULL,
        currentDisk = NULL;
    
    PASR_PTN_INFO_LIST pMbrPtnList = NULL;
    
    PASR_PTN_INFO pPtnInfo = NULL;
    
    HANDLE  heapHandle = GetProcessHeap();

    WCHAR tempBuffer[ASR_SIF_ENTRY_MAX_CHARS + 1];

    ZeroMemory(&infSystemContext, sizeof(INFCONTEXT));
    ZeroMemory(&infDiskContext, sizeof(INFCONTEXT));
    ZeroMemory(&infBusContext, sizeof(INFCONTEXT));
    ZeroMemory(&infPtnContext, sizeof(INFCONTEXT));
    ZeroMemory(tempBuffer, sizeof(WCHAR)*(ASR_SIF_ENTRY_MAX_CHARS+1));

    //    *ppSifDiskList = NULL;

    //
    // Open the sif
    //
    hSif = SetupOpenInfFileW(sifPath, NULL, INF_STYLE_WIN4, &errorLine);
    if (NULL == hSif || INVALID_HANDLE_VALUE == hSif) {

        AsrpPrintDbgMsg(_asrerror, 
            "The ASR state file \"%ws\" could not be opened.  Error:%lu.  Line: %lu.\r\n",
            sifPath,
            GetLastError(), 
            errorLine
            );
        
        return FALSE;       // sif file couldn't be opened
    }

    *lpAutoExtend = TRUE; // enable by default
    //
    // Get the AutoExtend value
    //
    result = SetupFindFirstLineW(hSif, ASR_SIF_SYSTEM_SECTION, NULL, &infSystemContext);
    if (!result) {

        AsrpPrintDbgMsg(_asrerror, 
            "The ASR state file \"%ws\" is corrupt (section %ws not be found).\r\n",
            sifPath,
            ASR_SIF_SYSTEM_SECTION
            );
        
        return FALSE;        // no system section
    }
    result = SetupGetIntField(&infSystemContext, 5, (PINT) (lpAutoExtend));
    if (!result) {
        *lpAutoExtend = TRUE;        // TRUE by default
    }

    result = SetupFindFirstLineW(hSif, ASR_SIF_MBR_DISKS_SECTION, NULL, &infDiskContext);
    if (!result) {

        AsrpPrintDbgMsg(_asrinfo, 
            "Section [%ws] is empty.  Assuming no MBR disks.\r\n", 
            ASR_SIF_MBR_DISKS_SECTION
            );

        return TRUE;        // no mbr disks section
    }

    //
    // First, we go through the [DISKS.MBR] section.  At the end of this loop,
    // we'll have a list of all MBR sif-disks.  (*ppSifDiskList will point to
    // a linked list of ASR_DISK_INFO's, one for each disk).
    //
    do {
        ++diskCount;
        //
        // Create a new sif disk for this entry
        //
        pNewSifDisk = (PASR_DISK_INFO) HeapAlloc(
            heapHandle,
            HEAP_ZERO_MEMORY,
            sizeof(ASR_DISK_INFO)
            );
        _AsrpErrExitCode(!pNewSifDisk, status, ERROR_NOT_ENOUGH_MEMORY);

        pNewSifDisk->pNext = *ppSifDiskList;
        *ppSifDiskList = pNewSifDisk;

        //
        // Now fill in the fields in the struct.  Since we zeroed the struct while
        // allocating mem, all pointers in the struct are NULL by default, and
        // all flags in the struct are FALSE.
        //
        pNewSifDisk->pDiskGeometry = (PDISK_GEOMETRY) HeapAlloc(
            heapHandle,
            HEAP_ZERO_MEMORY,
            sizeof(DISK_GEOMETRY)
            );
        _AsrpErrExitCode(!pNewSifDisk->pDiskGeometry, status, ERROR_NOT_ENOUGH_MEMORY);

        pNewSifDisk->pPartition0Ex = (PPARTITION_INFORMATION_EX) HeapAlloc(
            heapHandle,
            HEAP_ZERO_MEMORY,
            sizeof(PARTITION_INFORMATION_EX)
            );
        _AsrpErrExitCode(!pNewSifDisk->pPartition0Ex, status, ERROR_NOT_ENOUGH_MEMORY);

        // This is an MBR disk
        pNewSifDisk->Style = PARTITION_STYLE_MBR;

        //
        // Index 0 is the key to the left of the = sign
        //
        result = SetupGetIntField(&infDiskContext, 0, (PINT) &(pNewSifDisk->SifDiskKey));
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        //
        // Index 1 is the system key, it must be 1.  We ignore it.
        // Index 2 - 6 are the bus key, critical flag, signature,
        //      bytes-per-sector, sector-count
        //
        result = SetupGetIntField(&infDiskContext, 2, (PINT) &(pNewSifDisk->SifBusKey));
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        result = SetupGetIntField(&infDiskContext, 3, (PINT) &(tempInt));
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        pNewSifDisk->IsCritical = (tempInt ? TRUE: FALSE);

        result = SetupGetStringFieldW(&infDiskContext, 4, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?
        
        pNewSifDisk->TempSignature = AsrpStringToDword(tempBuffer);

        result = SetupGetStringFieldW(&infDiskContext, 5, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?
        
        pNewSifDisk->pDiskGeometry->BytesPerSector = AsrpStringToULong(tempBuffer);

        result = SetupGetStringFieldW(&infDiskContext, 6, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        pNewSifDisk->pDiskGeometry->SectorsPerTrack = AsrpStringToULong(tempBuffer);

        result = SetupGetStringFieldW(&infDiskContext, 7, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        pNewSifDisk->pDiskGeometry->TracksPerCylinder = AsrpStringToULong(tempBuffer);

        result = SetupGetStringFieldW(&infDiskContext, 8, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        pNewSifDisk->pPartition0Ex->PartitionLength.QuadPart = AsrpStringToLongLong(tempBuffer);

        // convert from sector count to byte count
        pNewSifDisk->pPartition0Ex->PartitionLength.QuadPart *= pNewSifDisk->pDiskGeometry->BytesPerSector;

        //
        // Get the bus-type related to this disk.  LineByIndex is 0 based, our bus key is 1-based.
        //
        result = SetupGetLineByIndexW(hSif, ASR_SIF_BUSES_SECTION, pNewSifDisk->SifBusKey - 1, &infBusContext);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        result = SetupGetIntField(&infBusContext, 2, (PINT) &(pNewSifDisk->BusType));
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        result = SetupFindNextLine(&infDiskContext, &infDiskContext);

    } while (result);


    AsrpPrintDbgMsg(_asrinfo, 
        "Found %lu records in section [%ws].\r\n", 
        diskCount,
        ASR_SIF_MBR_DISKS_SECTION
        );

    //
    // Now, enumerate all the [PARTITIONS.MBR] section.  This will give us a list
    // of all the partitions (all) the MBR disks contained.
    //
    result = SetupFindFirstLineW(hSif, ASR_SIF_MBR_PARTITIONS_SECTION, NULL, &infPtnContext);
    if (result) {

        DWORD   diskKey = 0;
        //
        // Init the table of partion lists.
        //
        pMbrPtnList = (PASR_PTN_INFO_LIST) HeapAlloc(
            heapHandle,
            HEAP_ZERO_MEMORY,
            sizeof(ASR_PTN_INFO_LIST) * (diskCount + 1)
            );
        _AsrpErrExitCode(!pMbrPtnList, status, ERROR_NOT_ENOUGH_MEMORY);

        // hack.
        // The 0'th entry of our table is not used, since the disk indices
        // begin with 1.  Since we have no other way of keeping track of
        // how big this table is (so that we can free it properly), we can
        // use the 0th entry to store this.
        //
        pMbrPtnList[0].numTotalPtns = diskCount + 1;       // size of table

        do {

            pPtnInfo = (PASR_PTN_INFO) HeapAlloc(
                heapHandle,
                HEAP_ZERO_MEMORY,
                sizeof(ASR_PTN_INFO)
                );
            _AsrpErrExitCode(!pPtnInfo, status, ERROR_NOT_ENOUGH_MEMORY);

            //
            //  Read in the information.  The format of this section is:
            //
            //  [PARTITIONS.MBR]
            //  0.partition-key = 1.disk-key, 2.slot-index, 3.boot-sys-flag,
            //                  4."volume-guid", 5.active-flag, 6.partition-type,
            //                  7.file-system-type, 8.start-sector, 9.sector-count
            //
            result = SetupGetIntField(&infPtnContext, 1, &diskKey);
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            result = SetupGetIntField(&infPtnContext, 2, (PINT) &(pPtnInfo->SlotIndex));
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            result = SetupGetIntField(&infPtnContext, 3, (PINT) &(pPtnInfo->PartitionFlags));
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            result = SetupGetStringFieldW(&infPtnContext, 4, pPtnInfo->szVolumeGuid, ASR_CCH_MAX_VOLUME_GUID, &reqdSize);
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            result = SetupGetIntField(&infPtnContext, 5, (PINT) &tempInt);
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            pPtnInfo->PartitionInfo.Mbr.BootIndicator = (tempInt ? TRUE: FALSE);

                // converting from int to uchar
            result = SetupGetIntField(&infPtnContext, 6, (PINT) &(pPtnInfo->PartitionInfo.Mbr.PartitionType));
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            result = SetupGetIntField(&infPtnContext, 7, (PINT) &(pPtnInfo->FileSystemType));
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            //
            // Note, we read in the start SECTOR and SECTOR count.  We'll convert these to
            // their byte values later (in AsrpCreatePartitionTable)
            //
            result = SetupGetStringFieldW(&infPtnContext, 8, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            pPtnInfo->PartitionInfo.StartingOffset.QuadPart = AsrpStringToLongLong(tempBuffer);

            result = SetupGetStringFieldW(&infPtnContext, 9, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            pPtnInfo->PartitionInfo.PartitionLength.QuadPart = AsrpStringToLongLong(tempBuffer);

            //
            // Add this in the sorted starting-offset order.
            //
            AsrpInsertSortedPartitionStartOrder(&(pMbrPtnList[diskKey]), pPtnInfo);

            //
            // Add this in the sorted partition length order as well.  This isn't really used for
            // MBR disks at present, only for GPT disks.
            //
            AsrpInsertSortedPartitionLengthOrder(&(pMbrPtnList[diskKey]), pPtnInfo);

            (pMbrPtnList[diskKey].numTotalPtns)++;

            if (IsContainerPartition(pPtnInfo->PartitionInfo.Mbr.PartitionType)) {
                (pMbrPtnList[diskKey].numExtendedPtns)++;
            }

            result = SetupFindNextLine(&infPtnContext, &infPtnContext);

        } while (result);

        //
        // Now, we have the table of all the MBR partition lists, and a list of
        // all MBR disks.  The next step is to "assign" the partitions to their respective
        // disks--and update the DriveLayoutEx struct for the disks.
        //
        currentDisk = *(ppSifDiskList);

        while (currentDisk) {
            DWORD           PartitionCount  = 0,
                            count           = 0;

            if (PARTITION_STYLE_MBR != currentDisk->Style) {
                currentDisk = currentDisk->pNext;
                continue;
            }

            PartitionCount = ((pMbrPtnList[currentDisk->SifDiskKey].numExtendedPtns) * 4) + 4;
            currentDisk->sizeDriveLayoutEx = sizeof(DRIVE_LAYOUT_INFORMATION_EX) + (sizeof(PARTITION_INFORMATION_EX)*(PartitionCount-1));

            currentDisk->pDriveLayoutEx = (PDRIVE_LAYOUT_INFORMATION_EX) HeapAlloc(
                heapHandle,
                HEAP_ZERO_MEMORY,
                currentDisk->sizeDriveLayoutEx
                );
            _AsrpErrExitCode(!currentDisk->pDriveLayoutEx, status, ERROR_NOT_ENOUGH_MEMORY);

            //
            // Initialise the DriveLayout struct.
            //
            currentDisk->pDriveLayoutEx->PartitionStyle = PARTITION_STYLE_MBR;
            currentDisk->pDriveLayoutEx->PartitionCount = PartitionCount;
            currentDisk->pDriveLayoutEx->Mbr.Signature = currentDisk->TempSignature;

            AsrpCreatePartitionTable(currentDisk->pDriveLayoutEx,
                &(pMbrPtnList[currentDisk->SifDiskKey]),
                currentDisk->pDiskGeometry->BytesPerSector
                );

            currentDisk = currentDisk->pNext;
        }
    }
    else {

        DWORD count = 0;

        AsrpPrintDbgMsg(_asrinfo, 
            "Section [%ws] is empty.  Assuming MBR disks have no partitions.\r\n", 
            ASR_SIF_MBR_PARTITIONS_SECTION
            );

        //
        // The partitions section is empty.  Initialise each disk's drive layout
        // accordingly
        //
        currentDisk = *ppSifDiskList;

        while (currentDisk) {

            if (PARTITION_STYLE_MBR != currentDisk->Style) {
                currentDisk = currentDisk->pNext;
                continue;
            }

            currentDisk->sizeDriveLayoutEx = sizeof(DRIVE_LAYOUT_INFORMATION_EX) + (sizeof(PARTITION_INFORMATION_EX) * 3);
            currentDisk->pDriveLayoutEx = (PDRIVE_LAYOUT_INFORMATION_EX) HeapAlloc(
                heapHandle,
                HEAP_ZERO_MEMORY,
                currentDisk->sizeDriveLayoutEx
                );
            _AsrpErrExitCode(!currentDisk->pDriveLayoutEx, status, ERROR_NOT_ENOUGH_MEMORY);

            currentDisk->pDriveLayoutEx->PartitionStyle = PARTITION_STYLE_MBR;
            currentDisk->pDriveLayoutEx->PartitionCount = 4;
            currentDisk->pDriveLayoutEx->Mbr.Signature = currentDisk->TempSignature;

            for (count = 0; count < currentDisk->pDriveLayoutEx->PartitionCount ; count++) {
                currentDisk->pDriveLayoutEx->PartitionEntry[count].PartitionStyle = PARTITION_STYLE_MBR;
                currentDisk->pDriveLayoutEx->PartitionEntry[count].RewritePartition = TRUE;

            }

            currentDisk = currentDisk->pNext;
        }
    }

EXIT:

    *ppSifMbrPtnList = pMbrPtnList;

    if ((hSif) && (INVALID_HANDLE_VALUE != hSif)) {
        SetupCloseInfFile(hSif);
        hSif = NULL;
    }

    return (BOOL) (ERROR_SUCCESS == status);
}


//
// Build the original disk info for GPT disks from the sif file
//
BOOL
AsrpBuildGptSifDiskList(
    IN  PCWSTR              sifPath,
    OUT PASR_DISK_INFO      *ppSifDiskList,
    OUT PASR_PTN_INFO_LIST  *ppSifGptPtnList
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    HINF hSif = NULL;

    BOOL result = FALSE;

    DWORD reqdSize = 0,
        diskCount = 0,
        status = ERROR_SUCCESS;

    INFCONTEXT infDiskContext,
        infBusContext,
        infPtnContext;

    INT tempInt = 0;

    UINT errorLine = 0;

    PASR_DISK_INFO pNewSifDisk = NULL,
        currentDisk = NULL;

    HANDLE heapHandle = NULL;

    PASR_PTN_INFO pPtnInfo = NULL;

    RPC_STATUS rpcStatus = RPC_S_OK;

    PASR_PTN_INFO_LIST pGptPtnList = NULL;

    WCHAR tempBuffer[ASR_SIF_ENTRY_MAX_CHARS+1];

    heapHandle = GetProcessHeap();

    ZeroMemory(&infDiskContext, sizeof(INFCONTEXT));
    ZeroMemory(&infBusContext, sizeof(INFCONTEXT));
    ZeroMemory(&infPtnContext, sizeof(INFCONTEXT));
    ZeroMemory(tempBuffer, sizeof(WCHAR)*(ASR_SIF_ENTRY_MAX_CHARS+1));

    //
    // Open the sif
    //
    hSif = SetupOpenInfFileW(sifPath, NULL, INF_STYLE_WIN4, &errorLine);
    if (NULL == hSif || INVALID_HANDLE_VALUE == hSif) {
        
        AsrpPrintDbgMsg(_asrerror, 
            "The ASR state file \"%ws\" could not be opened.  Error:%lu.  Line: %lu.\r\n",
            sifPath,
            GetLastError(), 
            errorLine
            );

        return FALSE;       // sif file couldn't be opened
    }

    result = SetupFindFirstLineW(hSif, ASR_SIF_GPT_DISKS_SECTION, NULL, &infDiskContext);
    if (!result) {

        AsrpPrintDbgMsg(_asrinfo, 
            "Section [%ws] is empty.  Assuming no GPT disks.\r\n", 
            ASR_SIF_GPT_DISKS_SECTION
            );

        return TRUE;        // no disks section
    }

    //
    // First, we go through the [DISKS.GPT] section.  At the end of this loop,
    // we'll have a list of all GPT sif-disks.  (*ppSifDiskList will point to
    // a linked list of ASR_DISK_INFO's, one for each disk).
    //
    do {

        ++diskCount;

        //
        // Create a new sif disk for this entry
        //
        pNewSifDisk = (PASR_DISK_INFO) HeapAlloc(
            heapHandle,
            HEAP_ZERO_MEMORY,
            sizeof(ASR_DISK_INFO)
            );
        _AsrpErrExitCode(!pNewSifDisk, status, ERROR_NOT_ENOUGH_MEMORY);

        pNewSifDisk->pNext = *ppSifDiskList;
        *ppSifDiskList = pNewSifDisk;

        //
        // Now fill in the fields in the struct.  Since we zeroed the struct while
        // allocating mem, all pointers in the struct are NULL by default, and
        // all flags in the struct are FALSE.
        //
        pNewSifDisk->pDiskGeometry = (PDISK_GEOMETRY) HeapAlloc(
            heapHandle,
            HEAP_ZERO_MEMORY,
            sizeof(DISK_GEOMETRY)
            );
        _AsrpErrExitCode(!pNewSifDisk->pDiskGeometry, status, ERROR_NOT_ENOUGH_MEMORY);

        pNewSifDisk->pPartition0Ex = (PPARTITION_INFORMATION_EX) HeapAlloc(
            heapHandle,
            HEAP_ZERO_MEMORY,
            sizeof(PARTITION_INFORMATION_EX)
            );
        _AsrpErrExitCode(!pNewSifDisk->pPartition0Ex, status, ERROR_NOT_ENOUGH_MEMORY);

        // This is a GPT disk
        pNewSifDisk->Style = PARTITION_STYLE_GPT;

        //
        // Index 0 is the key to the left of the = sign
        //
        result = SetupGetIntField(&infDiskContext, 0, (PINT) &(pNewSifDisk->SifDiskKey));
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        //
        // Index 1 is the system key, it must be 1.  We ignore it.
        // Index 2 - 7 are:
        //  2: bus key
        //  3: critical flag
        //  4: disk-guid
        //  5: max-partition-count
        //  6: bytes-per-sector
        //  7: sector-count
        //
        result = SetupGetIntField(&infDiskContext, 2, (PINT) &(pNewSifDisk->SifBusKey)); // BusKey
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        result = SetupGetIntField(&infDiskContext, 3, (PINT) &(tempInt));                // IsCritical
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        pNewSifDisk->IsCritical = (tempInt ? TRUE: FALSE);

        result = SetupGetStringFieldW(&infDiskContext, 4, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize); // DiskGuid
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        result = SetupGetIntField(&infDiskContext, 5, (PINT) &(tempInt));    // MaxPartitionCount
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        //
        //  Allocate a drive layout struct, now that we know the max partition count
        //
        pNewSifDisk->sizeDriveLayoutEx = sizeof(DRIVE_LAYOUT_INFORMATION_EX) + (sizeof(PARTITION_INFORMATION_EX)*(tempInt-1));

        pNewSifDisk->pDriveLayoutEx = (PDRIVE_LAYOUT_INFORMATION_EX) HeapAlloc(
            heapHandle,
            HEAP_ZERO_MEMORY,
            pNewSifDisk->sizeDriveLayoutEx
            );
        _AsrpErrExitCode(!pNewSifDisk->pDriveLayoutEx, status, ERROR_NOT_ENOUGH_MEMORY);

        // This is a GPT disk
        pNewSifDisk->pDriveLayoutEx->PartitionStyle = PARTITION_STYLE_GPT;

        //
        // Set the MaxPartitionCount and DiskGuid fields
        //
        pNewSifDisk->pDriveLayoutEx->Gpt.MaxPartitionCount = tempInt;
        rpcStatus = UuidFromStringW(tempBuffer, &(pNewSifDisk->pDriveLayoutEx->Gpt.DiskId));
        _AsrpErrExitCode((RPC_S_OK != rpcStatus), status, rpcStatus);


        result = SetupGetStringFieldW(&infDiskContext, 6, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        pNewSifDisk->pDiskGeometry->BytesPerSector = AsrpStringToULong(tempBuffer);

        result = SetupGetStringFieldW(&infDiskContext, 7, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?
        pNewSifDisk->pDiskGeometry->SectorsPerTrack = AsrpStringToULong(tempBuffer);

        result = SetupGetStringFieldW(&infDiskContext, 8, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?
        pNewSifDisk->pDiskGeometry->TracksPerCylinder = AsrpStringToULong(tempBuffer);

        result = SetupGetStringFieldW(&infDiskContext, 9, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?
        pNewSifDisk->pPartition0Ex->PartitionLength.QuadPart = AsrpStringToLongLong(tempBuffer);

        // convert from sector count to byte count
        pNewSifDisk->pPartition0Ex->PartitionLength.QuadPart *= pNewSifDisk->pDiskGeometry->BytesPerSector; // TotalBytes

        //
        // Get the bus-type related to this disk.  LineByIndex is 0 based, our bus key is 1-based.
        //
        result = SetupGetLineByIndexW(hSif, ASR_SIF_BUSES_SECTION, pNewSifDisk->SifBusKey - 1, &infBusContext);
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        result = SetupGetIntField(&infBusContext, 2, (PINT) &(pNewSifDisk->BusType)); // bus type
        _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

        result = SetupFindNextLine(&infDiskContext, &infDiskContext);

    } while(result);

    AsrpPrintDbgMsg(_asrinfo, 
        "Found %lu records in section [%ws].\r\n", 
        diskCount,
        ASR_SIF_MBR_DISKS_SECTION
        );


    //
    // Now, enumerate all the [PARTITIONS.GPT] section.  This will give us a list
    // of all the partitions (all) the GPT disks contained.
    //
    result = SetupFindFirstLineW(hSif, ASR_SIF_GPT_PARTITIONS_SECTION, NULL, &infPtnContext);
    if (result) {
        DWORD   diskKey = 0;
        //
        // Init the table of partion lists.
        //
        pGptPtnList = (PASR_PTN_INFO_LIST) HeapAlloc(
            heapHandle,
            HEAP_ZERO_MEMORY,
            sizeof(ASR_PTN_INFO_LIST) * (diskCount + 1)
            );
        _AsrpErrExitCode(!pGptPtnList, status, ERROR_NOT_ENOUGH_MEMORY);

        // hack.
        // The 0'th entry of our table is not used, since the disk indices
        // begin with 1.  Since we have no other way of keeping track of
        // how big this table is (so that we can free it properly), we can
        // use the 0th entry to store this.
        //
        pGptPtnList[0].numTotalPtns = diskCount + 1;       // size of table

        do {

            pPtnInfo = (PASR_PTN_INFO) HeapAlloc(
                heapHandle,
                HEAP_ZERO_MEMORY,
                sizeof(ASR_PTN_INFO)
                );
            _AsrpErrExitCode(!pPtnInfo, status, ERROR_NOT_ENOUGH_MEMORY);
            //
            // This is a GPT partition
            //
            pPtnInfo->PartitionInfo.PartitionStyle = PARTITION_STYLE_GPT;

            //
            // Read in the values.  The format of this section is:
            //
            // [PARTITIONS.GPT]
            // 0.partition-key = 1.disk-key, 2.slot-index, 3.boot-sys-flag,
            //      4."volume-guid", 5."partition-type-guid", 6."partition-id-guid"
            //      7.gpt-attributes, 8."partition-name", 9.file-system-type,
            //      10.start-sector, 11.sector-count
            //
            result = SetupGetIntField(&infPtnContext, 1, &diskKey);  // 1. disk-key
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            result = SetupGetIntField(&infPtnContext, 2, (PINT) &(pPtnInfo->SlotIndex));     // 2. slot-index
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            result = SetupGetIntField(&infPtnContext, 3, (PINT) &(pPtnInfo->PartitionFlags));   // 3. boot-sys-flag
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            result = SetupGetStringFieldW(&infPtnContext, 4, pPtnInfo->szVolumeGuid, ASR_CCH_MAX_VOLUME_GUID, &reqdSize); // volume-guid
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            result = SetupGetStringFieldW(&infPtnContext, 5, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS + 1, &reqdSize);   // partition-type-guid
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            rpcStatus = UuidFromStringW(tempBuffer, &(pPtnInfo->PartitionInfo.Gpt.PartitionType));
            _AsrpErrExitCode((RPC_S_OK != rpcStatus), status, rpcStatus);

            result = SetupGetStringFieldW(&infPtnContext, 6, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS + 1, &reqdSize);
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            rpcStatus = UuidFromStringW(tempBuffer, &(pPtnInfo->PartitionInfo.Gpt.PartitionId));
            _AsrpErrExitCode((RPC_S_OK != rpcStatus), status, rpcStatus);

            //
            // Note, we read in the start SECTOR and SECTOR count.  We'll convert these to
            // their byte values later (in AsrpCreatePartitionTable)
            //
            result = SetupGetStringFieldW(&infPtnContext, 7, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            pPtnInfo->PartitionInfo.Gpt.Attributes = AsrpStringToULong64(tempBuffer);

            result = SetupGetStringFieldW(&infPtnContext, 8,  pPtnInfo->PartitionInfo.Gpt.Name, 36, &reqdSize);
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            result = SetupGetIntField(&infPtnContext, 9, (PINT) &(pPtnInfo->FileSystemType));
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

            //
            // Note, we read in the start SECTOR and SECTOR count.  We'll convert it to the
            // BYTE offset and BYTE length later (in AsrpCreatePartitionTable)
            //
            result = SetupGetStringFieldW(&infPtnContext, 10, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?
            pPtnInfo->PartitionInfo.StartingOffset.QuadPart = AsrpStringToLongLong(tempBuffer);

            result = SetupGetStringFieldW(&infPtnContext, 11, tempBuffer, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
            _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?
            pPtnInfo->PartitionInfo.PartitionLength.QuadPart = AsrpStringToLongLong(tempBuffer);

            //
            // Add this in the sorted partition starting-offset order.
            //
            AsrpInsertSortedPartitionStartOrder(&(pGptPtnList[diskKey]), pPtnInfo);

            //
            // Add this in the sorted partition length order as well.  This is useful
            // later when we try to fit in the partitions on the disk.
            //
            AsrpInsertSortedPartitionLengthOrder(&(pGptPtnList[diskKey]), pPtnInfo);

            (pGptPtnList[diskKey].numTotalPtns)++;

            result = SetupFindNextLine(&infPtnContext, &infPtnContext);

        } while (result);

        //
        // Now, we have the table of all the partition lists, and a list of
        // all disks.  The next task is to update the DriveLayoutEx struct for
        // the disks.
        //
        currentDisk = *(ppSifDiskList);

        while (currentDisk) {

            if (PARTITION_STYLE_GPT != currentDisk->Style) {
                currentDisk = currentDisk->pNext;
                continue;
            }
            //
            // Initialise the DriveLayoutEx struct.
            //
            currentDisk->pDriveLayoutEx->PartitionCount = pGptPtnList[currentDisk->SifDiskKey].numTotalPtns;

            AsrpCreatePartitionTable(currentDisk->pDriveLayoutEx,
                &(pGptPtnList[currentDisk->SifDiskKey]),
                currentDisk->pDiskGeometry->BytesPerSector
                );

            currentDisk = currentDisk->pNext;
        }
    }
    else {

        DWORD count = 0;

        AsrpPrintDbgMsg(_asrinfo, 
            "Section [%ws] is empty.  Assuming GPT disks have no partitions.\r\n", 
            ASR_SIF_GPT_PARTITIONS_SECTION
            );

        //
        // The partitions section is empty.  Initialise each disk's drive layout
        // accordingly
        //
        currentDisk = *ppSifDiskList;

        while (currentDisk) {

            if (PARTITION_STYLE_GPT != currentDisk->Style) {
                currentDisk = currentDisk->pNext;
                continue;
            }

            currentDisk->pDriveLayoutEx->PartitionCount = 0;

            for (count = 0; count < currentDisk->pDriveLayoutEx->Gpt.MaxPartitionCount ; count++) {
                currentDisk->pDriveLayoutEx->PartitionEntry[count].PartitionStyle = PARTITION_STYLE_GPT;
                currentDisk->pDriveLayoutEx->PartitionEntry[count].RewritePartition = TRUE;

            }
            currentDisk = currentDisk->pNext;
        }
    }

EXIT:

    *ppSifGptPtnList = pGptPtnList;

    if ((hSif) && (INVALID_HANDLE_VALUE != hSif)) {
        SetupCloseInfFile(hSif);
        hSif = NULL;
    }

    return (BOOL) (ERROR_SUCCESS == status);
}


//
// Returns
//  TRUE    if pSifDisk and pPhysicalDisk have the exact same partition layout,
//  FALSE   otherwise
//
BOOL
AsrpIsDiskIntact(
    IN PASR_DISK_INFO pSifDisk,
    IN PASR_DISK_INFO pPhysicalDisk
    ) 

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    ULONG index = 0,
        physicalIndex = 0;
    PPARTITION_INFORMATION_EX pSifPtnEx = NULL,
        pPhysicalPtnEx = NULL;

    if (pSifDisk->Style != pPhysicalDisk->Style) {
        return FALSE;           // different partitioning styles
    }

    if (PARTITION_STYLE_MBR == pSifDisk->Style) {
        //
        // For MBR disks, we expect to find the same number of partitions,
        // and the starting-offset and partition-length for each of those
        // partitions must be the same as they were in the sif
        //
        if (pSifDisk->pDriveLayoutEx->Mbr.Signature 
            != pPhysicalDisk->pDriveLayoutEx->Mbr.Signature) {
            return FALSE;       // different signatures
        }

        if (pSifDisk->pDriveLayoutEx->PartitionCount
            != pPhysicalDisk->pDriveLayoutEx->PartitionCount) {
            return FALSE;       // different partition counts
        }


        for (index =0; index < pSifDisk->pDriveLayoutEx->PartitionCount; index++) {

            pSifPtnEx      = &(pSifDisk->pDriveLayoutEx->PartitionEntry[index]);
            pPhysicalPtnEx = &(pPhysicalDisk->pDriveLayoutEx->PartitionEntry[index]);

            if ((pSifPtnEx->StartingOffset.QuadPart != pPhysicalPtnEx->StartingOffset.QuadPart) ||
                (pSifPtnEx->PartitionLength.QuadPart != pPhysicalPtnEx->PartitionLength.QuadPart)
                ) {
                //
                // The partition offset or length didn't match, ie the disk
                // isn't intact
                //
                return FALSE;
            }
        } // for
    }
    else if (PARTITION_STYLE_GPT == pSifDisk->Style) {
        BOOL found = FALSE;
        //
        // For GPT disks, the partitions must have the same partition-Id's, in
        // addition to the start sector and sector count.  We can't rely on their
        // partition table entry order being the same, though--so we have to go
        // through all the partition entries from the beginning ...
        //
        for (index = 0; index < pSifDisk->pDriveLayoutEx->PartitionCount; index++) {

            pSifPtnEx = &(pSifDisk->pDriveLayoutEx->PartitionEntry[index]);

            found = FALSE;
            for (physicalIndex = 0;
                (physicalIndex < pPhysicalDisk->pDriveLayoutEx->PartitionCount)
//                    && (pSifPtnEx->StartingOffset.QuadPart >= pPhysicalDisk->pDriveLayoutEx->PartitionEntry[physicalIndex].StartingOffset.QuadPart) // entries are in ascending order
                    && (!found);
                physicalIndex++) {

                pPhysicalPtnEx = &(pPhysicalDisk->pDriveLayoutEx->PartitionEntry[physicalIndex]);

                if (IsEqualGUID(&(pSifPtnEx->Gpt.PartitionId), &(pPhysicalPtnEx->Gpt.PartitionId)) &&
                    (pSifPtnEx->StartingOffset.QuadPart == pPhysicalPtnEx->StartingOffset.QuadPart) &&
                    (pSifPtnEx->PartitionLength.QuadPart == pPhysicalPtnEx->PartitionLength.QuadPart)
                    ) {
                    //
                    // The partition GUID, offset and length matched, this partition exists
                    //
                    found = TRUE;
                }
            } // for

            if (!found) {
                //
                // At least one partition wasn't found
                //
                return FALSE;
            }
        }
    }

    return TRUE;
}


LONGLONG
AsrpCylinderAlignMbrPartitions(
    IN PASR_DISK_INFO   pSifDisk,
    IN PDRIVE_LAYOUT_INFORMATION_EX pAlignedLayoutEx,
    IN DWORD            StartIndex,      // index in the partitionEntry table to start at
    IN LONGLONG         StartingOffset,
    IN PDISK_GEOMETRY   pPhysicalDiskGeometry
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    LONGLONG nextEnd = 0,
        endingOffset = 0,
        bytesPerTrack = 0,
        bytesPerCylinder = 0,
        currentMax = 0,
        maxEndingOffset = 0;

    DWORD   index = 0,
        tempIndex = 0,
        tempIndex2 = 0;

    PPARTITION_INFORMATION_EX alignedPtn = NULL,
        sifPtn = NULL,
        tempPtn = NULL;

    if (PARTITION_STYLE_MBR != pSifDisk->Style) {
        //
        // This routine only supports MBR disks.  For GPT disks, we don't need to
        // cylinder-align partitions, so this routine shouldn't be called.
        //
        return -1;
    }

    if (0 == pSifDisk->pDriveLayoutEx->PartitionCount) {
        //
        //  (boundary case) No partitions on disk to align
        //
        return 0;
    }

    MYASSERT(AsrpRoundUp(StartIndex,4) == StartIndex);
    MYASSERT(pSifDisk && pAlignedLayoutEx);
    if (!pSifDisk || !pAlignedLayoutEx) {
        return -1;
    }

    bytesPerTrack = pPhysicalDiskGeometry->BytesPerSector * pPhysicalDiskGeometry->SectorsPerTrack;
    bytesPerCylinder = bytesPerTrack * (pPhysicalDiskGeometry->TracksPerCylinder);

    //
    // The first partition entry in each MBR/EBR always starts at the 
    // cylinder-boundary plus one track.  So, add one track to the starting 
    // offset.
    //
    // The exception (there had to be one, of course) is if the first 
    // partition entry in the MBR/EBR itself is a container partition (0x05 or
    // 0x0f), then it starts on the next cylinder.
    //
    if (IsContainerPartition(pSifDisk->pDriveLayoutEx->PartitionEntry[StartIndex].Mbr.PartitionType)) {
        StartingOffset += (bytesPerCylinder);
    }
    else {
        StartingOffset += (bytesPerTrack);
    }


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

        alignedPtn = &(pAlignedLayoutEx->PartitionEntry[index + StartIndex]);
        sifPtn = &(pSifDisk->pDriveLayoutEx->PartitionEntry[index + StartIndex]);

        MYASSERT(PARTITION_STYLE_MBR == sifPtn->PartitionStyle);
        //
        // Set the fields of interest
        //
        alignedPtn->PartitionStyle = PARTITION_STYLE_MBR;
        alignedPtn->RewritePartition = TRUE;

        alignedPtn->Mbr.PartitionType = sifPtn->Mbr.PartitionType;
        alignedPtn->Mbr.BootIndicator = sifPtn->Mbr.BootIndicator;
        alignedPtn->Mbr.RecognizedPartition = sifPtn->Mbr.RecognizedPartition;

        if (PARTITION_ENTRY_UNUSED != sifPtn->Mbr.PartitionType)  {

            alignedPtn->StartingOffset.QuadPart = StartingOffset;
            endingOffset = AsrpRoundUp(sifPtn->PartitionLength.QuadPart + StartingOffset, bytesPerCylinder);

            alignedPtn->PartitionLength.QuadPart = endingOffset - StartingOffset;

            if (IsContainerPartition(alignedPtn->Mbr.PartitionType)) {
                //
                // This is a container partition (0x5 or 0xf), so we have to try and
                // fit the logical drives inside this partition to get the
                // required size of this partition.
                //
                nextEnd = AsrpCylinderAlignMbrPartitions(pSifDisk,
                    pAlignedLayoutEx,
                    StartIndex + 4,
                    StartingOffset,
                    pPhysicalDiskGeometry
                    );

                if (-1 == nextEnd) {
                    //
                    // Propogate error upwards
                    //
                    return nextEnd;
                }

                if (StartIndex < 4) {
                    //
                    // We're dealing with the primary container partition
                    //
                    if (nextEnd > endingOffset) {
                        MYASSERT(AsrpRoundUp(nextEnd, bytesPerCylinder) == nextEnd);
                        alignedPtn->PartitionLength.QuadPart = nextEnd - StartingOffset;
                        endingOffset = nextEnd;
                    }

                    //
                    // If the primary container partition ends beyond cylinder 
                    // 1024, it should be of type 0xf, else it should be of
                    // type 0x5.
                    //
                    if (endingOffset > (1024 * bytesPerCylinder)) {
                        alignedPtn->Mbr.PartitionType = PARTITION_XINT13_EXTENDED;
                    }
                    else {
                        alignedPtn->Mbr.PartitionType = PARTITION_EXTENDED;
                    }
                }
                else {
                    //
                    // We're dealing with a secondary container.  This 
                    // container should only be big enough to hold the
                    // next logical drive.
                    //
                    alignedPtn->Mbr.PartitionType = PARTITION_EXTENDED;

                    tempIndex = (DWORD) AsrpRoundUp((StartIndex + index), 4);
                    currentMax = 0;

                    for (tempIndex2 = 0; tempIndex2 < 4; tempIndex2++) {

                        tempPtn = &(pSifDisk->pDriveLayoutEx->PartitionEntry[tempIndex + tempIndex2]);

                        if ((PARTITION_ENTRY_UNUSED != tempPtn->Mbr.PartitionType) &&
                            !IsContainerPartition(tempPtn->Mbr.PartitionType)
                            ) {
                            
                            if (tempPtn->StartingOffset.QuadPart + tempPtn->PartitionLength.QuadPart
                                > currentMax
                                ) {
                                currentMax = tempPtn->StartingOffset.QuadPart + tempPtn->PartitionLength.QuadPart;
                            }
                        }
                    }

                    if (currentMax > endingOffset) {
                        MYASSERT(AsrpRoundUp(currentMax, bytesPerCylinder) == currentMax);
                        alignedPtn->PartitionLength.QuadPart = currentMax - StartingOffset;
                        endingOffset = currentMax;
                    }

                }

                if (nextEnd > maxEndingOffset) {
                    maxEndingOffset = nextEnd;
                }
            }

            if (endingOffset > maxEndingOffset) {
                maxEndingOffset = endingOffset;
            }

            StartingOffset += (alignedPtn->PartitionLength.QuadPart);
        }
        else {
            alignedPtn->StartingOffset.QuadPart = 0;
            alignedPtn->PartitionLength.QuadPart = 0;
        }
    }

    return maxEndingOffset;
}


VOID
AsrpFreeRegionInfo(
    IN PASR_REGION_INFO RegionInfo
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    PASR_REGION_INFO temp = RegionInfo;
    HANDLE heapHandle = GetProcessHeap();

    while (temp) {
        RegionInfo = temp->pNext;
        _AsrpHeapFree(temp);
        temp = RegionInfo;
    }
}


BOOL
AsrpIsOkayToErasePartition(
    IN PPARTITION_INFORMATION_EX pPartitionInfoEx
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    GUID typeGuid = pPartitionInfoEx->Gpt.PartitionType;

    //
    // For now, this checks the partition type against all the known ("recognised")
    // partition types.  If the partition type is recognised (except the system partition),
    // it's okay to erase it.
    //
    if (IsEqualGUID(&(typeGuid), &(PARTITION_ENTRY_UNUSED_GUID))) {
        return TRUE;
    }

    if (IsEqualGUID(&(typeGuid), &(PARTITION_SYSTEM_GUID))) {
        return FALSE; // Cannot erase EFI system partition.
    }

    if (IsEqualGUID(&(typeGuid), &(PARTITION_MSFT_RESERVED_GUID))) {
        return TRUE;
    }

    if (IsEqualGUID(&(typeGuid), &(PARTITION_BASIC_DATA_GUID))) {
        return TRUE;
    }

    if (IsEqualGUID(&(typeGuid), &(PARTITION_LDM_METADATA_GUID))) {
        return TRUE;
    }

    if (IsEqualGUID(&(typeGuid), &(PARTITION_LDM_DATA_GUID))) {
        return TRUE;
    }

    //
    // It is okay to erase other, unrecognised partitions.
    //
    return TRUE;
}


//
// Checks if it's okay to erase all the partitions on a disk.  Returns TRUE for MBR disks.
// Returns TRUE for GPT disks if all the partitions on it are erasable.  A partition that
// we don't recognise  (including OEM partitions, ESP, etc) is considered non-erasable.
//
BOOL
AsrpIsOkayToEraseDisk(
    IN PASR_DISK_INFO pPhysicalDisk
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    DWORD index;

    if (PARTITION_STYLE_GPT != pPhysicalDisk->pDriveLayoutEx->PartitionStyle) {
        return TRUE;
    }

    for (index = 0; index < pPhysicalDisk->pDriveLayoutEx->PartitionCount; index++) {
        if (!AsrpIsOkayToErasePartition(&(pPhysicalDisk->pDriveLayoutEx->PartitionEntry[index]))) {
            return FALSE;
        }
    }
    return TRUE;
}


BOOL
AsrpInsertSortedRegion(
    IN OUT PASR_REGION_INFO *Head,
    IN LONGLONG StartingOffset,
    IN LONGLONG RegionLength,
    IN DWORD Index,
    IN LONGLONG MaxLength,          // 0 == don't care
    IN ASR_SORT_ORDER SortBy
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    PASR_REGION_INFO previousRegion = NULL,
        newRegion = NULL,
        currentRegion = *Head;

    if (RegionLength < (1024*1024)) {
        return TRUE;
    }
    //
    // Alloc mem for the new region and set the fields of interest
    //
    newRegion = (PASR_REGION_INFO) HeapAlloc(
        GetProcessHeap(),
        HEAP_ZERO_MEMORY,
        sizeof(ASR_REGION_INFO)
        );
    if (!newRegion) {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    newRegion->StartingOffset = StartingOffset;
    newRegion->RegionLength = RegionLength;
    newRegion->Index = Index;
    newRegion->pNext = NULL;

    if (!currentRegion) {
        //
        // First item in the list
        //
        *Head = newRegion;
    }
    else {

        while (currentRegion) {

             if (((SortByLength == SortBy) && (currentRegion->RegionLength <= RegionLength))
                || ((SortByStartingOffset == SortBy) && (currentRegion->StartingOffset <= StartingOffset))
                ) {

                previousRegion = currentRegion;
                currentRegion = currentRegion->pNext;
            }

            else {
                //
                // We found the spot, let's add it in.
                //

                //
                // If this is sorted based on start sectors, make sure there's
                // enough space to add this region in, ie that the regions don't overlap.
                //
                if (SortByStartingOffset == SortBy) {
                    //
                    // Make sure this is after the end of the previous sector
                    //
                    if (previousRegion) {
                        if ((previousRegion->StartingOffset + previousRegion->RegionLength) > StartingOffset) {
                            return FALSE;
                        }
                    }

                    //
                    // And that this ends before the next sector starts
                    //
                    if ((StartingOffset + RegionLength) > (currentRegion->StartingOffset)) {
                        return FALSE;
                    }
                }


                if (!previousRegion) {
                    //
                    // This is the first node
                    //
                    *Head = newRegion;
                }
                else {
                    previousRegion->pNext = newRegion;
                }

                newRegion->pNext = currentRegion;
                break;
            }

        }

        if (!currentRegion) {
            //
            // We reached the end and didn't add this node in.
            //
            MYASSERT(NULL == previousRegion->pNext);

            //
            // Make sure this is after the end of the previous sector
            //
            if (previousRegion && (MaxLength > 0)) {
                if ((previousRegion->StartingOffset + previousRegion->RegionLength) > MaxLength) {
                    return FALSE;
                }
            }

            previousRegion->pNext = newRegion;
        }
    }

    return TRUE;
}


BOOL
AsrpBuildFreeRegionList(
    IN PASR_REGION_INFO PartitionList,
    OUT PASR_REGION_INFO *FreeList,
    IN LONGLONG UsableStartingOffset,
    IN LONGLONG UsableLength
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    PASR_REGION_INFO currentRegion = PartitionList,
        previousRegion = NULL;
    LONGLONG previousEnd = UsableStartingOffset;

    while (currentRegion) {

        if (!AsrpInsertSortedRegion(FreeList,
            previousEnd,                // free region start offset
            currentRegion->StartingOffset - previousEnd,  // free region length,
            0,                          // index--not meaningful for this list
            0,
            SortByLength
            ) ) {

            return FALSE;
        }

        previousEnd = currentRegion->StartingOffset + currentRegion->RegionLength;
        currentRegion = currentRegion->pNext;
    }

    //
    // Add space after the last partition till the end of the disk to
    // our free regions list
    //
    return AsrpInsertSortedRegion(FreeList, // list head
        previousEnd,  // free region start offset
        UsableStartingOffset + UsableLength - previousEnd, // free region length
        0, // slot index in the partition entry table--not meaningful for this list
        0,
        SortByLength
        );
}


//
// Both partitions and regions are sorted by sizes
//
BOOL
AsrpFitPartitionToFreeRegion(
    IN PASR_REGION_INFO PartitionList,
    IN PASR_REGION_INFO FreeRegionList
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    PASR_REGION_INFO partition = PartitionList,
        hole = FreeRegionList;

    while (partition) {

        while (hole && (partition->RegionLength > hole->RegionLength)) {
            hole = hole->pNext;
        }

        if (!hole) {
            //
            // We ran out of holes and have unassigned partitions
            //
            return FALSE;
        }

        partition->StartingOffset = hole->StartingOffset;

        hole->RegionLength -= partition->RegionLength;
        hole->StartingOffset += partition->RegionLength;

        partition = partition->pNext;
    }

    return TRUE;
}


//
// For optimisation purposes, this routine should only be called if:
// PhysicalDisk and SifDisk are both GPT
// PhysicalDisk is bigger than SifDisk
// PhysicalDisk has non-erasable partitions
//
BOOL
AsrpFitGptPartitionsToRegions(
    IN PASR_DISK_INFO SifDisk,
    IN PASR_DISK_INFO PhysicalDisk,
    IN BOOL Commit
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    PASR_REGION_INFO partitionList = NULL,
        collisionList = NULL,
        freeRegionList = NULL;

    LONGLONG StartingUsableOffset = 0,
        UsableLength = 0;

    DWORD index = 0;

    BOOL result = TRUE;

    if ((PARTITION_STYLE_GPT != SifDisk->Style) || (PARTITION_STYLE_GPT != PhysicalDisk->Style)) {
        return TRUE;
    }

    StartingUsableOffset = PhysicalDisk->pDriveLayoutEx->Gpt.StartingUsableOffset.QuadPart;
    UsableLength = PhysicalDisk->pDriveLayoutEx->Gpt.UsableLength.QuadPart;

    //
    // First, go through the existing non-erasable partitions, and add them to our list
    // sorted by start sectors.
    //
    for (index = 0; index < PhysicalDisk->pDriveLayoutEx->PartitionCount; index++) {
        if (!AsrpIsOkayToErasePartition(&(PhysicalDisk->pDriveLayoutEx->PartitionEntry[index]))) {

            PPARTITION_INFORMATION_EX currentPtn = &(PhysicalDisk->pDriveLayoutEx->PartitionEntry[index]);

            if (!AsrpInsertSortedRegion(&partitionList,
                currentPtn->StartingOffset.QuadPart,
                currentPtn->PartitionLength.QuadPart,
                index,
                (StartingUsableOffset + UsableLength),
                SortByStartingOffset
                )) {
                result = FALSE;
                break;
            }
        }
    }

    if (partitionList && result) {
        //
        // Then, go through the sif partitions, and add them to a list, sorted by start sectors.
        // For partitions that cannot be added, add them to another list sorted by sizes
        //
        for (index = 0; index < SifDisk->pDriveLayoutEx->PartitionCount; index++) {
            PPARTITION_INFORMATION_EX currentPtn = &(SifDisk->pDriveLayoutEx->PartitionEntry[index]);

            if (!AsrpInsertSortedRegion(&partitionList,
                currentPtn->StartingOffset.QuadPart,
                currentPtn->PartitionLength.QuadPart,
                index,
                (StartingUsableOffset + UsableLength),
                SortByStartingOffset
                )) {

                if (!AsrpInsertSortedRegion(&collisionList,
                    currentPtn->StartingOffset.QuadPart,
                    currentPtn->PartitionLength.QuadPart,
                    index,
                    0,
                    SortByLength
                    )) {

                    result = FALSE;
                    break;
                }
            }
        }
    }

    if (collisionList && result) {
        //
        // Go through first list and come up with a list of free regions, sorted by sizes
        //
        result = AsrpBuildFreeRegionList(partitionList, &freeRegionList, StartingUsableOffset, UsableLength);

    }


    if (collisionList && result) {
        //
        // Try adding partitions from list 2 to regions from list 3.  If any
        // are left over, return FALSE.
        //
        result = AsrpFitPartitionToFreeRegion(collisionList, freeRegionList);

        if (Commit && result) {
            PASR_REGION_INFO pCurrentRegion = collisionList;
            //
            // Go through the collision list, and update the start sectors of the
            // PartitionEntries in DriveLayoutEx's table.
            //
            while (pCurrentRegion) {

                MYASSERT(SifDisk->pDriveLayoutEx->PartitionEntry[pCurrentRegion->Index].PartitionLength.QuadPart == pCurrentRegion->RegionLength);

                SifDisk->pDriveLayoutEx->PartitionEntry[pCurrentRegion->Index].StartingOffset.QuadPart =
                    pCurrentRegion->StartingOffset;

                pCurrentRegion = pCurrentRegion->pNext;
            }
        }

    }

    AsrpFreeRegionInfo(partitionList);
    AsrpFreeRegionInfo(collisionList);
    AsrpFreeRegionInfo(freeRegionList);

    return result;
}


BOOL
AsrpIsThisDiskABetterFit(
    IN PASR_DISK_INFO CurrentBest,
    IN PASR_DISK_INFO PhysicalDisk,
    IN PASR_DISK_INFO SifDisk,
    IN PDRIVE_LAYOUT_INFORMATION_EX pTempDriveLayoutEx,
    OUT BOOL *IsAligned
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{

    LONGLONG endingOffset;

    if (ARGUMENT_PRESENT(IsAligned)) {
        *IsAligned = FALSE;
    }

    //
    // Make sure the bytes-per-sector values match
    //
    if (PhysicalDisk->pDiskGeometry->BytesPerSector != SifDisk->pDiskGeometry->BytesPerSector) {
        return FALSE;
    }

    if (PhysicalDisk->pPartition0Ex->PartitionLength.QuadPart >=
        SifDisk->pPartition0Ex->PartitionLength.QuadPart) {

        if ((!CurrentBest) ||
            (PhysicalDisk->pPartition0Ex->PartitionLength.QuadPart <
            CurrentBest->pPartition0Ex->PartitionLength.QuadPart)) {

            //
            // This disk is smaller than our current best (or we don't have a 
            // current best).  Now try laying out the partitions to see if 
            // they fit.
            //

            if (PARTITION_STYLE_GPT == SifDisk->Style) {
                //
                // If the disk has no partitions that need to be preserved,
                // we can use all of it.
                if (AsrpIsOkayToEraseDisk(PhysicalDisk)) {
                    return TRUE;
                }
                else {
                    //
                    // This disk has some regions that need to be preserved.  So
                    // we try to fit our partitions in the holes
                    //
                    return AsrpFitGptPartitionsToRegions(SifDisk, PhysicalDisk, FALSE); // No commmit
                }
            }
            else if (PARTITION_STYLE_MBR == SifDisk->Style) {

                if (!pTempDriveLayoutEx) {
                    //
                    // Caller doesn't want to try cylinder-aligning partitions
                    //
                    return TRUE;
                }
                    
                //
                // For MBR disks, the partitions have to be cylinder aligned
                //
                // AsrpCylinderAlignMbrPartitions(,,0,,) returns the ending offset (bytes)
                // of the entries in the MBR.
                //
                endingOffset = AsrpCylinderAlignMbrPartitions(SifDisk,
                    pTempDriveLayoutEx,
                    0,      // starting index--0 for the MBR
                    0,      // starting offset, assume the partitions begin at the start of the disk
                    PhysicalDisk->pDiskGeometry
                    );

                if ((endingOffset != -1) &&
                    (endingOffset <= SifDisk->pPartition0Ex->PartitionLength.QuadPart)
                    ) {

                    if (ARGUMENT_PRESENT(IsAligned)) {
                        *IsAligned = TRUE;
                    }

                    return TRUE;

                }
                else {

                    //
                    // We couldn't fit the partitions on to the disk when we 
                    // tried to cylinder align them.  If the disk geometries
                    // are the same, this may still be okay.
                    //

                    if ((SifDisk->pDiskGeometry->BytesPerSector == PhysicalDisk->pDiskGeometry->BytesPerSector) &&
                        (SifDisk->pDiskGeometry->SectorsPerTrack == PhysicalDisk->pDiskGeometry->SectorsPerTrack) &&
                        (SifDisk->pDiskGeometry->TracksPerCylinder == PhysicalDisk->pDiskGeometry->TracksPerCylinder)
                        ) {

                        return TRUE;
                    }

                    else {
                        return FALSE;
                    }
                }
            }
            else {
                MYASSERT(0 && L"Unrecognised partitioning style (neither MBR nor GPT)");
            }
        }
    }

    return FALSE;
}


//
// Assigns sif-disks to physical disks with matching signatures, if
// any exist.  If the disk is critical, or the partition-layout matches,
// the disk is marked as intact.
//
// Returns
//  FALSE   if a critical disk is absent
//  TRUE    if all critical disks are present
//
BOOL
AsrpAssignBySignature(
    IN OUT PASR_DISK_INFO   pSifDiskList,
    IN OUT PASR_DISK_INFO   pPhysicalDiskList,
    OUT    PULONG           pMaxPartitionCount
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{

    BOOL    result  = TRUE,
            done    = FALSE,
            found   = FALSE,
            isAligned = FALSE;

    PASR_DISK_INFO  sifDisk          = pSifDiskList,
                    physicalDisk     = pPhysicalDiskList;

    PDRIVE_LAYOUT_INFORMATION_EX pAlignedLayoutTemp = NULL;

    ULONG   tableSize = 128;    // start off at a reasonably high size

    HANDLE heapHandle = GetProcessHeap();

    pAlignedLayoutTemp = (PDRIVE_LAYOUT_INFORMATION_EX) HeapAlloc(
        heapHandle,
        HEAP_ZERO_MEMORY,
        sizeof(DRIVE_LAYOUT_INFORMATION) + (tableSize * sizeof(PARTITION_INFORMATION_EX))
        );
    if (!pAlignedLayoutTemp) {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        result = FALSE;
        goto EXIT;
    }


    *pMaxPartitionCount = 0;

    //
    // For now, this is O(n-squared), since both lists are unsorted.
    //
    while (sifDisk && !done) {

        if (!(sifDisk->pDriveLayoutEx) || !(sifDisk->pDriveLayoutEx->Mbr.Signature)) {
            //
            // we won't assign disks with no signature here
            //
            sifDisk = sifDisk->pNext;
            continue;
        }


        if (sifDisk->pDriveLayoutEx->PartitionCount > *pMaxPartitionCount) {
            *pMaxPartitionCount = sifDisk->pDriveLayoutEx->PartitionCount;
        }

        if (sifDisk->pDriveLayoutEx->PartitionCount > tableSize) {
            tableSize = sifDisk->pDriveLayoutEx->PartitionCount + 128;

            _AsrpHeapFree(pAlignedLayoutTemp);
            pAlignedLayoutTemp = (PDRIVE_LAYOUT_INFORMATION_EX) HeapAlloc(
                heapHandle,
                HEAP_ZERO_MEMORY,
                sizeof(DRIVE_LAYOUT_INFORMATION) + (tableSize * sizeof(PARTITION_INFORMATION_EX))
                );
            if (!pAlignedLayoutTemp) {
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                result = FALSE;
                goto EXIT;
            }
        }

        found = FALSE;
        physicalDisk = pPhysicalDiskList;

        while (physicalDisk && !found) {
            //
            // For MBR disks, we use the signature
            // For GPT disks, we use the disk ID
            //
            if (sifDisk->Style == physicalDisk->Style) {

                if ((PARTITION_STYLE_MBR == sifDisk->Style) &&
                    (physicalDisk->pDriveLayoutEx->Mbr.Signature == sifDisk->pDriveLayoutEx->Mbr.Signature)
                    ) {
                    //
                    // MBR disks, signatures match
                    //
                    found = TRUE;

                    AsrpPrintDbgMsg(_asrlog, 
                        "Harddisk %lu matched disk %lu in section [%ws] of the ASR state file.  (MBR signatures 0x%x match).\r\n", 
                        physicalDisk->DeviceNumber, 
                        sifDisk->SifDiskKey,
                        ASR_SIF_MBR_DISKS_SECTION,
                        sifDisk->pDriveLayoutEx->Mbr.Signature
                        );


                }
                else if (
                    (PARTITION_STYLE_GPT == sifDisk->Style) &&
                    IsEqualGUID(&(sifDisk->pDriveLayoutEx->Gpt.DiskId), &(physicalDisk->pDriveLayoutEx->Gpt.DiskId))
                    ) {

                    found = TRUE;

                    AsrpPrintDbgMsg(_asrlog, 
                        "Harddisk %lu matched disk %lu in section [%ws] of the ASR state file.  (GPT Disk-ID's match).\r\n", 
                        physicalDisk->DeviceNumber, 
                        sifDisk->SifDiskKey,
                        ASR_SIF_GPT_DISKS_SECTION
                        );

                }
                else {
                    physicalDisk = physicalDisk->pNext;
                }

            }
            else {
                physicalDisk = physicalDisk->pNext;
            }
        }

        if (sifDisk->IsCritical) {
            if (found) {

                sifDisk->AssignedTo = physicalDisk;
                physicalDisk->AssignedTo = sifDisk;
                
                //
                // We don't check the partition layout on critical disks since they
                // may have been repartitioned in text-mode Setup.
                //
                sifDisk->IsIntact = TRUE;
                sifDisk->AssignedTo->IsIntact = TRUE;
            }
            else {
                //
                // Critical disk was not found.  Fatal error.
                //
                SetLastError(ERROR_DEVICE_NOT_CONNECTED);
                result = FALSE;
                done = TRUE;

                AsrpPrintDbgMsg(_asrerror, 
                    "Critical disk not found (Entry %lu in section [%ws]).\r\n", 
                    sifDisk->SifDiskKey,
                    ((PARTITION_STYLE_MBR == sifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION)
                    );

            }
        }
        else {
            if (found) {
                //
                // We found a disk with matching signature.  Now let's just 
                // make sure that the partitions actually fit on the disk
                // before assigning it
                //
                isAligned = FALSE;
                if ((sifDisk->pDriveLayoutEx->PartitionCount == 0) ||           // disk has no partitions
                    AsrpIsThisDiskABetterFit(NULL, physicalDisk, sifDisk, pAlignedLayoutTemp, &isAligned) // partitions fit on disk
                    ) {

                    sifDisk->AssignedTo = physicalDisk;
                    physicalDisk->AssignedTo = sifDisk;

                    sifDisk->IsAligned = isAligned;
                    physicalDisk->IsAligned = isAligned;

                    if (AsrpIsDiskIntact(sifDisk, physicalDisk)) {
                        sifDisk->IsIntact = TRUE;
                        sifDisk->AssignedTo->IsIntact = TRUE;
                    }
                }
                else {

                    AsrpPrintDbgMsg(_asrlog, 
                        "Harddisk %lu is not big enough to contain the partitions on disk %lu in section [%ws] of the ASR state file.\r\n", 
                        physicalDisk->DeviceNumber, 
                        sifDisk->SifDiskKey,
                        ((PARTITION_STYLE_MBR == sifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION)
                        );

                }
            }
        }

        sifDisk = sifDisk->pNext;

    }   // while


EXIT:
    _AsrpHeapFree(pAlignedLayoutTemp);

   return result;
}


//
// Attempts to assign remaining sif disks to physical disks that
// are on the same bus as the sif disk originally was (ie if
// any other disk on that bus has been assigned, this tries to assign
// this disk to the same bus)
//
BOOL
AsrpAssignByBus(
    IN OUT PASR_DISK_INFO pSifDiskList,
    IN OUT PASR_DISK_INFO pPhysicalDiskList,
    IN PDRIVE_LAYOUT_INFORMATION_EX pTempDriveLayoutEx
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{

    PASR_DISK_INFO  sifDisk = pSifDiskList,
        physicalDisk = NULL,
        currentBest = NULL,
        tempSifDisk = NULL;

    BOOL done = FALSE,
        isAligned = FALSE,
        isAlignedTemp = FALSE;

    ULONG  targetBusId = 0;

    while (sifDisk) {
        //
        // Skip disks that have already found a home, and disks for which
        // we didn't have any bus/group info even on the original system
        //
        if ((NULL != sifDisk->AssignedTo) ||    // already assigned
            (0 == sifDisk->SifBusKey)           // this disk couldn't be grouped
            ) {
           sifDisk = sifDisk->pNext;
           continue;
        }

        //
        // Find another (sif) disk that used to be on the same (sif) bus,
        // and has already been assigned to a physical disk.
        //
        targetBusId = 0;
        tempSifDisk = pSifDiskList;
        done = FALSE;

        while (tempSifDisk && !done) {

            if ((tempSifDisk->SifBusKey == sifDisk->SifBusKey) &&   // same bus
                (tempSifDisk->AssignedTo != NULL)                   // assigned
                ) {
                targetBusId = tempSifDisk->AssignedTo->SifBusKey;   // the physical bus

                //
                // If this physical disk is on an unknown bus,
                // (target id = sifbuskey = 0) then we want to try and look
                // for another disk on the same (sif) bus.  Hence done is
                // TRUE only if targetId != 0
                //
                if (targetBusId) {
                    done = TRUE;
                }
            }

            tempSifDisk = tempSifDisk->pNext;

        }   // while


        if (targetBusId) {      // we found another disk on the same bus
            //
            // Go through the physical disks on the same bus, and try to
            // find the best fit for this disk.  Best fit is the smallest
            // disk on the bus that's big enough for us.
            //
            physicalDisk = pPhysicalDiskList;
            currentBest  = NULL;

            while (physicalDisk) {

                if ((NULL == physicalDisk->AssignedTo) &&       // not assigned
                    (physicalDisk->SifBusKey == targetBusId) && // same bus
                    (AsrpIsThisDiskABetterFit(currentBest, physicalDisk, sifDisk, pTempDriveLayoutEx, &isAlignedTemp))
                    ) {

                    isAligned = isAlignedTemp;
                    currentBest = physicalDisk;
                }

                physicalDisk = physicalDisk->pNext;
            }   // while

            sifDisk->AssignedTo = currentBest;  // may be null if no match was found
            sifDisk->IsAligned = isAligned;

            if (currentBest) {

                currentBest->AssignedTo = sifDisk;
                currentBest->IsAligned = isAligned;

                AsrpPrintDbgMsg(_asrlog, 
                    "Harddisk %lu assigned to disk %lu in section [%ws] of the ASR state file.  (Based on storage bus).\r\n", 
                    currentBest->DeviceNumber, 
                    sifDisk->SifDiskKey,
                    ((PARTITION_STYLE_MBR == sifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION)
                    );

            }
       }

        sifDisk = sifDisk->pNext;
    }   // while sifdisk

    return TRUE;

}


//
// Attempts to assign remaining sif disks to physical disks that
// are on any bus of the same type (SCSI, IDE, etc) as the sif disk
// originally was
//
BOOL
AsrpAssignByBusType(
    IN OUT PASR_DISK_INFO pSifDiskList,
    IN OUT PASR_DISK_INFO pPhysicalDiskList,
    IN PDRIVE_LAYOUT_INFORMATION_EX pTempDriveLayoutEx
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    PASR_DISK_INFO  sifDisk = pSifDiskList,
        physicalDisk = NULL,
        currentBest = NULL;

    STORAGE_BUS_TYPE targetBusType;

    BOOL isAligned = FALSE,
        isAlignedTemp = FALSE;

    while (sifDisk) {
        //
        // Skip disks that have already found a home, and disks for which
        // we didn't have any bus/group info even on the original system
        //
        if ((NULL != sifDisk->AssignedTo) ||     // already assigned
            (BusTypeUnknown == sifDisk->BusType) // this disk couldn't be grouped
            ) {
           sifDisk = sifDisk->pNext;
           continue;
        }

        //
        // Go through the physical disks, and try to
        // find the best fit for this disk.  Best fit is the smallest
        // disk on any bus of the same bus type that's big enough for us.
        //
        physicalDisk = pPhysicalDiskList;
        currentBest  = NULL;

        while (physicalDisk) {

            if ((NULL == physicalDisk->AssignedTo) &&       // not assigned
                (physicalDisk->BusType == sifDisk->BusType) && // same bus type
                (AsrpIsThisDiskABetterFit(currentBest, physicalDisk, sifDisk, pTempDriveLayoutEx, &isAlignedTemp))
                ) {

                isAligned = isAlignedTemp;
                currentBest = physicalDisk;
            }

            physicalDisk = physicalDisk->pNext;
        }   // while

        sifDisk->AssignedTo = currentBest;  // may be null if no match was found
        sifDisk->IsAligned = isAligned;

        if (currentBest) {
            currentBest->AssignedTo = sifDisk;
            currentBest->IsAligned = isAligned;


            AsrpPrintDbgMsg(_asrlog, 
                "Harddisk %lu assigned to disk %lu in section [%ws] of the ASR state file.  (Based on storage bus type).\r\n", 
                currentBest->DeviceNumber, 
                sifDisk->SifDiskKey,
                ((PARTITION_STYLE_MBR == sifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION)
                );

            AsrpAssignByBus(pSifDiskList, pPhysicalDiskList, pTempDriveLayoutEx);
        }

        sifDisk = sifDisk->pNext;
    }   // while sifdisk

    return TRUE;

}


//
// Okay, so by now we've tried putting disks on the same bus, and
// the same bus type.  For disks that didn't fit using either of those
// rules (or for which we didn't have any bus info at all), let's just
// try to fit them where ever possible on the system.
//
BOOL
AsrpAssignRemaining(
    IN OUT PASR_DISK_INFO pSifDiskList,
    IN OUT PASR_DISK_INFO pPhysicalDiskList,
    IN PDRIVE_LAYOUT_INFORMATION_EX pTempDriveLayoutEx
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    PASR_DISK_INFO  sifDisk = pSifDiskList,
        physicalDisk = NULL,
        currentBest = NULL;

    BOOL isAligned = FALSE,
        isAlignedTemp = FALSE;

    while (sifDisk) {
        //
        // Skip disks that have already found a home
        //
        if (NULL != sifDisk->AssignedTo) {
           sifDisk = sifDisk->pNext;
           continue;
        }

        //
        // Go through the physical disks, and try to find the best
        // fit for this disk.  Best fit is the smallest disk anywhere
        // on the system that's big enough for us.
        //
        physicalDisk = pPhysicalDiskList;
        currentBest  = NULL;

        while (physicalDisk) {

            if ((NULL == physicalDisk->AssignedTo) &&       // not assigned
                (AsrpIsThisDiskABetterFit(currentBest, physicalDisk, sifDisk, pTempDriveLayoutEx, &isAlignedTemp))
                ) {

                isAligned = isAlignedTemp;
                currentBest = physicalDisk;
            }

            physicalDisk = physicalDisk->pNext;
        }   // while

        sifDisk->AssignedTo = currentBest;  // may be null if no match was found
        sifDisk->IsAligned = isAligned;

        if (currentBest) {
            currentBest->AssignedTo = sifDisk;
            currentBest->IsAligned = isAligned;

            AsrpPrintDbgMsg(_asrlog, 
                "Harddisk %lu assigned to disk %lu in section [%ws] of the ASR state file.  (Based on size).\r\n", 
                currentBest->DeviceNumber, 
                sifDisk->SifDiskKey,
                ((PARTITION_STYLE_MBR == sifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION)
                );

            AsrpAssignByBus(pSifDiskList, pPhysicalDiskList, pTempDriveLayoutEx);
            AsrpAssignByBusType(pSifDiskList, pPhysicalDiskList, pTempDriveLayoutEx);
        }

        sifDisk = sifDisk->pNext;
    }   // while sifdisk

    return TRUE;

}


BOOL
AsrpIsPartitionExtendible(
    IN CONST UCHAR PartitionType
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    switch (PartitionType) {
    case PARTITION_EXTENDED:

    case PARTITION_IFS:
    
    case PARTITION_XINT13:
    case PARTITION_XINT13_EXTENDED:

        return TRUE;

    default:
        return FALSE;
    }

    return FALSE;

}


BOOL
AsrpAutoExtendMbrPartitions(
    IN PASR_DISK_INFO pSifDisk,
    IN PASR_DISK_INFO pPhysicalDisk,
    IN LONGLONG LastUsedPhysicalDiskOffset
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{

    PDISK_GEOMETRY physicalGeometry = NULL;

    IN PDRIVE_LAYOUT_INFORMATION_EX sifLayout = NULL,
        physicalLayout = NULL;

    LONGLONG MaxSifDiskOffset = 0,
        MaxPhysicalDiskOffset = 0,
        LastUsedSifDiskOffset = 0;

    DWORD count = 0;

    BOOL madeAChange = FALSE;

    //
    // Find the last sector of the disk
    //
    MaxSifDiskOffset = pSifDisk->pPartition0Ex->PartitionLength.QuadPart;

    physicalGeometry = pPhysicalDisk->pDiskGeometry;
    MaxPhysicalDiskOffset = (physicalGeometry->BytesPerSector) *
        (physicalGeometry->SectorsPerTrack) * 
        (physicalGeometry->TracksPerCylinder) *
        (physicalGeometry->Cylinders.QuadPart);

    //
    // Did the old disk have empty space at the end?
    //
    sifLayout = pSifDisk->pDriveLayoutEx;
    for (count = 0; count < sifLayout->PartitionCount; count++) {

        if (((sifLayout->PartitionEntry[count].StartingOffset.QuadPart) + 
                (sifLayout->PartitionEntry[count].PartitionLength.QuadPart))
            > LastUsedSifDiskOffset) {

            LastUsedSifDiskOffset = (sifLayout->PartitionEntry[count].StartingOffset.QuadPart + 
                sifLayout->PartitionEntry[count].PartitionLength.QuadPart);
        }
    }

    if ((LastUsedSifDiskOffset + ASR_AUTO_EXTEND_MAX_FREE_SPACE_IGNORED) >= MaxSifDiskOffset) {
        //
        // No, it didn't.  Extend the last partition.
        //
        physicalLayout = pPhysicalDisk->pDriveLayoutEx;
        for (count = 0; count < physicalLayout->PartitionCount; count++) {

            if (((physicalLayout->PartitionEntry[count].StartingOffset.QuadPart) + 
                    (physicalLayout->PartitionEntry[count].PartitionLength.QuadPart))
                == LastUsedPhysicalDiskOffset
                ) {
                if (AsrpIsPartitionExtendible(physicalLayout->PartitionEntry[count].Mbr.PartitionType)) {

                    physicalLayout->PartitionEntry[count].PartitionLength.QuadPart += 
                        (MaxPhysicalDiskOffset - LastUsedPhysicalDiskOffset);
                    madeAChange = TRUE;
                }
            }
        }
    }

    if (madeAChange) {
        AsrpPrintDbgMsg(_asrlog, 
            "Extended partitions on Harddisk %lu (assigned to disk %lu in section [%ws]).\r\n", 
            pPhysicalDisk->DeviceNumber, 
            pSifDisk->SifDiskKey,
            ((PARTITION_STYLE_MBR == pSifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION)
            );
    }
    else {
        AsrpPrintDbgMsg(_asrinfo, 
            "Did not extend partitions on Harddisk %lu (assigned to disk %lu in section [%ws]).\r\n", 
            pPhysicalDisk->DeviceNumber, 
            pSifDisk->SifDiskKey,
            ((PARTITION_STYLE_MBR == pSifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION)
            );
    }

    return madeAChange;

}

//
// Try to determine which sif disks end up on which physical disk.
//
BOOL
AsrpAssignDisks(
    IN OUT PASR_DISK_INFO pSifDiskList,
    IN OUT PASR_DISK_INFO pPhysicalDiskList,
    IN PASR_PTN_INFO_LIST pSifMbrPtnList,
    IN PASR_PTN_INFO_LIST pSifGptPtnList,
    IN BOOL AllOrNothing,
    IN BOOL AllowAutoExtend
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{

    ULONG maxSifPartitionCount = 0;
    PDRIVE_LAYOUT_INFORMATION_EX pAlignedLayoutTemp = NULL;
    LONGLONG endingOffset = 0;
    BOOL reAlloc = TRUE;
    HANDLE heapHandle = GetProcessHeap();
    PASR_DISK_INFO sifDisk = NULL;
    PASR_PTN_INFO pCurrentPtn = NULL;
    PPARTITION_INFORMATION_EX pCurrentEntry = NULL;
    DWORD index = 0, preserveIndex = 0;

    if (!AsrpAssignBySignature(pSifDiskList, pPhysicalDiskList, &maxSifPartitionCount)) {
        //
        // Critical disks were not found
        //
        return FALSE;
    }

    pAlignedLayoutTemp = (PDRIVE_LAYOUT_INFORMATION_EX) HeapAlloc(
        heapHandle,
        HEAP_ZERO_MEMORY,
        sizeof(DRIVE_LAYOUT_INFORMATION) + (maxSifPartitionCount * sizeof(PARTITION_INFORMATION_EX))
        );
    if (!pAlignedLayoutTemp) {
        return FALSE;
    }

    AsrpAssignByBus(pSifDiskList, pPhysicalDiskList, pAlignedLayoutTemp);

    AsrpAssignByBusType(pSifDiskList, pPhysicalDiskList, pAlignedLayoutTemp);

    AsrpAssignRemaining(pSifDiskList, pPhysicalDiskList, pAlignedLayoutTemp);

    _AsrpHeapFree(pAlignedLayoutTemp);

    //
    // All disks should be assigned by now, we now cylinder-snap
    // the partition boundaries.  If AllOrNothing is TRUE,
    // we return false if any sif-disk couldn't be assigned.
    //
    sifDisk = pSifDiskList;

    while (sifDisk) {

        if (sifDisk->IsIntact || sifDisk->IsCritical) {
            //
            // We won't be re-partitioning critical disks or disks that are 
            // intact, so it's no point trying to cylinder-align them.
            //
            sifDisk = sifDisk->pNext;
            continue;
        }

        if (NULL == sifDisk->AssignedTo) {

            AsrpPrintDbgMsg(_asrlog, 
                "Disk %lu in section [%ws] could not be restored (no matching disks found).\r\n", 
                sifDisk->SifDiskKey,
                ((PARTITION_STYLE_MBR == sifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION)
                );

            //
            // This disk couldn't be assigned.  If AllOrNothing is set, we return
            // FALSE, since we couldn't assign All.
            //
            if (AllOrNothing) {
                SetLastError(ERROR_NOT_FOUND);
                return FALSE;
            }
            else {
                sifDisk = sifDisk->pNext;
                continue;
            }
        }


        if (PARTITION_STYLE_MBR == sifDisk->Style) {
            //
            // Assume that we need to re-allocate mem for the physical disk's
            // partition table.
            //
            reAlloc = TRUE;

            if (sifDisk->AssignedTo->pDriveLayoutEx) {
                if (sifDisk->AssignedTo->pDriveLayoutEx->PartitionCount ==
                    sifDisk->pDriveLayoutEx->PartitionCount) {
                    //
                    // If the physical drive happened to have the same number of
                    // partitions, the drive layout struct is exactly the right
                    // size, so we don't have to re-allocate it.
                    //
                    reAlloc = FALSE;

                    //
                    // consistency check.  If the partition counts are
                    // the same, the size of the drive layout stucts must be the same, too.
                    //
                    MYASSERT(sifDisk->AssignedTo->sizeDriveLayoutEx == sifDisk->sizeDriveLayoutEx);
                }
            }

            if (reAlloc) {
                //
                //  The partition tables are of different sizes
                //
                _AsrpHeapFree(sifDisk->AssignedTo->pDriveLayoutEx);

                sifDisk->AssignedTo->pDriveLayoutEx = (PDRIVE_LAYOUT_INFORMATION_EX) HeapAlloc(
                    heapHandle,
                    HEAP_ZERO_MEMORY,
                    sizeof(DRIVE_LAYOUT_INFORMATION_EX) +
                        ((sifDisk->pDriveLayoutEx->PartitionCount - 1) * sizeof(PARTITION_INFORMATION_EX))
                    );
                if (!sifDisk->AssignedTo->pDriveLayoutEx) {

                    AsrpPrintDbgMsg(_asrerror, "Out of memory.\r\n");
                    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                    return FALSE;
                }
            }

            //
            // Set the fields of interest
            //
            sifDisk->AssignedTo->sizeDriveLayoutEx = sifDisk->sizeDriveLayoutEx;
            sifDisk->AssignedTo->pDriveLayoutEx->PartitionStyle = PARTITION_STYLE_MBR;

            if (sifDisk->IsAligned) {
                sifDisk->AssignedTo->pDriveLayoutEx->PartitionCount = sifDisk->pDriveLayoutEx->PartitionCount;
                sifDisk->AssignedTo->pDriveLayoutEx->Mbr.Signature = sifDisk->pDriveLayoutEx->Mbr.Signature;

                //
                // Cylinder-snap the partition boundaries
                //
                endingOffset = AsrpCylinderAlignMbrPartitions(
                    sifDisk,
                    sifDisk->AssignedTo->pDriveLayoutEx,
                    0,      // starting index--0 for the MBR
                    0,      // starting offset, assume the partitions begin at the start of the disk
                    sifDisk->AssignedTo->pDiskGeometry
                    );

                MYASSERT(endingOffset != -1);
                if (-1 == endingOffset) {

                    AsrpPrintDbgMsg(_asrlog, 
                        "Partitions on disk %lu in section [%ws] could not be restored.\r\n", 
                        sifDisk->SifDiskKey,
                        ASR_SIF_MBR_DISKS_SECTION
                        );

                    if (AllOrNothing) {
                        SetLastError(ERROR_HANDLE_DISK_FULL);
                        return FALSE;
                    }
                    else {
                        sifDisk = sifDisk->pNext;
                        continue;
                    }

                }

                MYASSERT(endingOffset <= sifDisk->AssignedTo->pPartition0Ex->PartitionLength.QuadPart);
                if ((endingOffset) > (sifDisk->AssignedTo->pPartition0Ex->PartitionLength.QuadPart)) {

                    AsrpPrintDbgMsg(_asrlog, 
                        "Partitions on disk %lu in section [%ws] could not be restored.\r\n", 
                        sifDisk->SifDiskKey,
                        ASR_SIF_MBR_DISKS_SECTION
                        );
 
                    if (AllOrNothing) {
                        SetLastError(ERROR_HANDLE_DISK_FULL);
                        return FALSE;
                    }
                    else {
                        sifDisk = sifDisk->pNext;
                        continue;
                    }

                }

                if (AllowAutoExtend) {
                    AsrpAutoExtendMbrPartitions(sifDisk, sifDisk->AssignedTo, endingOffset);
                }

                //
                // Now, we need to go through our partition list, and update the start sector
                // for the partitions in that list.  This is needed since we use the start
                // sector later to assign the volume guids to the partitions.
                //
                pCurrentPtn = pSifMbrPtnList[sifDisk->SifDiskKey].pOffsetHead;
                while (pCurrentPtn) {

                    pCurrentPtn->PartitionInfo.StartingOffset.QuadPart =
                        sifDisk->AssignedTo->pDriveLayoutEx->PartitionEntry[pCurrentPtn->SlotIndex].StartingOffset.QuadPart;

                    pCurrentPtn->PartitionInfo.PartitionLength.QuadPart =
                        sifDisk->AssignedTo->pDriveLayoutEx->PartitionEntry[pCurrentPtn->SlotIndex].PartitionLength.QuadPart;

                    pCurrentPtn = pCurrentPtn->pOffsetNext;
                }
            }
            else {
                //
                // The partitions didn't fit when we cylinder-aligned them.  
                // However, the current disk geometry is identical to the 
                // original disk geometry, so we can recreate the partitions
                // exactly the way they were before.  Let's just copy over
                // the partition layout.
                //
                CopyMemory(sifDisk->AssignedTo->pDriveLayoutEx, 
                    sifDisk->pDriveLayoutEx, 
                    sifDisk->sizeDriveLayoutEx
                    );

                for (index = 0; index < sifDisk->pDriveLayoutEx->PartitionCount; index++) {

                    sifDisk->AssignedTo->pDriveLayoutEx->PartitionEntry[index].RewritePartition = TRUE;

                }
            }

        }
        else if (PARTITION_STYLE_GPT == sifDisk->Style) {
            DWORD sizeNewDriveLayoutEx = 0;
            PDRIVE_LAYOUT_INFORMATION_EX pNewDriveLayoutEx = NULL;

/*

            The MaxPartitionCount values are different for the two disks.  We can't do
            much here, so we'll just ignore it.
          
            if ((PARTITION_STYLE_GPT == sifDisk->AssignedTo->Style) &&
                (sifDisk->pDriveLayoutEx->Gpt.MaxPartitionCount
                > sifDisk->AssignedTo->pDriveLayoutEx->Gpt.MaxPartitionCount)) {

                MYASSERT(0 && L"Not yet implemented: sifdisk MaxPartitionCount > physicalDisk->MaxPartitionCount");
                sifDisk = sifDisk->pNext;
                continue;
            }
*/
            //
            // Allocate a pDriveLayoutEx struct large enough to hold all the partitions on both
            // the sif disk and the physical disk.
            //
            sizeNewDriveLayoutEx =  sizeof(DRIVE_LAYOUT_INFORMATION_EX) +
                (sizeof(PARTITION_INFORMATION_EX) *
                (sifDisk->pDriveLayoutEx->PartitionCount +
                sifDisk->AssignedTo->pDriveLayoutEx->PartitionCount - 1 )
                );

            pNewDriveLayoutEx = (PDRIVE_LAYOUT_INFORMATION_EX) HeapAlloc(
                heapHandle,
                HEAP_ZERO_MEMORY,
                sizeNewDriveLayoutEx
                );
            if (!pNewDriveLayoutEx) {
                return FALSE;
            }

            preserveIndex = 0;
            if (!sifDisk->IsIntact && !AsrpIsOkayToEraseDisk(sifDisk->AssignedTo)) {

                //
                // This disk is not intact, but it has partitions that must be preserved.
                //
                if (!AsrpFitGptPartitionsToRegions(sifDisk, sifDisk->AssignedTo, TRUE)) {

                    AsrpPrintDbgMsg(_asrlog, 
                        "Partitions on disk %lu in section [%ws] could not be restored.\r\n", 
                        sifDisk->SifDiskKey,
                        ASR_SIF_GPT_DISKS_SECTION
                        );
 
                    MYASSERT(0 && L"AsrpFitGptPartitionsToRegions failed for assigned disk");

                    if (AllOrNothing) {
                        SetLastError(ERROR_HANDLE_DISK_FULL);
                        return FALSE;
                    }
                    else {
                        sifDisk = sifDisk->pNext;
                        continue;
                    }

                 }

                //
                // Now, we need to go through our partition list, and update the start sector
                // for the partitions in that list.  This is needed since we use the start
                // sector later to assign the volume guids to the partitions.
                //
                // The start sectors could've changed because the physical disk may have had
                // un-erasable partitions.
                //
                pCurrentPtn = pSifGptPtnList[sifDisk->SifDiskKey].pOffsetHead;
                while (pCurrentPtn) {

                    pCurrentPtn->PartitionInfo.StartingOffset.QuadPart =
                        sifDisk->AssignedTo->pDriveLayoutEx->PartitionEntry[pCurrentPtn->SlotIndex].StartingOffset.QuadPart;

                    pCurrentPtn->PartitionInfo.PartitionLength.QuadPart =
                        sifDisk->AssignedTo->pDriveLayoutEx->PartitionEntry[pCurrentPtn->SlotIndex].PartitionLength.QuadPart;

                    pCurrentPtn = pCurrentPtn->pOffsetNext;

                }


                //
                // Move the non-erasable partitions on the physical disks up to the beginning.
                //
                for (index = 0; index < sifDisk->AssignedTo->pDriveLayoutEx->PartitionCount; index++) {

                    pCurrentEntry = &(sifDisk->AssignedTo->pDriveLayoutEx->PartitionEntry[index]);

                    if (!AsrpIsOkayToErasePartition(pCurrentEntry)) {

                        if (preserveIndex == index) {
                            preserveIndex++;
                            continue;
                        }

                        memmove(&(pNewDriveLayoutEx->PartitionEntry[preserveIndex]),
                            &(sifDisk->AssignedTo->pDriveLayoutEx->PartitionEntry[index]),
                            sizeof(PARTITION_INFORMATION_EX)
                            );
                        preserveIndex++;

                    }
                    else {
                        //
                        // This partition can be erased.
                        //
                        pCurrentEntry->StartingOffset.QuadPart = 0;
                        pCurrentEntry->PartitionLength.QuadPart = 0;
                    }
                }   // for

            }  // if !IsIntact

            //
            // Now that we've copied over entries of interest to the new
            // drivelayoutex struct, we can get rid of the old one.
            //
            _AsrpHeapFree(sifDisk->AssignedTo->pDriveLayoutEx);
            sifDisk->AssignedTo->sizeDriveLayoutEx = sizeNewDriveLayoutEx;
            sifDisk->AssignedTo->pDriveLayoutEx = pNewDriveLayoutEx;

            //
            // Copy over the sif partition table to the physicalDisk
            //
            memcpy(&(sifDisk->AssignedTo->pDriveLayoutEx->PartitionEntry[preserveIndex]),
                &(sifDisk->pDriveLayoutEx->PartitionEntry[0]),
                sizeof(PARTITION_INFORMATION_EX) * (sifDisk->pDriveLayoutEx->PartitionCount)
                );

            sifDisk->AssignedTo->pDriveLayoutEx->PartitionCount = sifDisk->pDriveLayoutEx->PartitionCount + preserveIndex;
            sifDisk->AssignedTo->sizeDriveLayoutEx = sizeof(DRIVE_LAYOUT_INFORMATION_EX) + (sizeof(PARTITION_INFORMATION_EX) * (sifDisk->AssignedTo->pDriveLayoutEx->PartitionCount - 1));

            sifDisk->AssignedTo->pDriveLayoutEx->PartitionStyle = PARTITION_STYLE_GPT;

            memcpy(&(sifDisk->AssignedTo->pDriveLayoutEx->Gpt.DiskId),
                &(sifDisk->pDriveLayoutEx->Gpt.DiskId),
                sizeof(GUID)
                );

        }
        else {
            MYASSERT(0 && L"Unrecognised partitioning style (neither MBR nor GPT)");
        }

        sifDisk = sifDisk->pNext;
    }

    return TRUE;
}


BOOL
AsrpCreateMountPoint(
    IN DWORD DiskNumber,
    IN DWORD PartitionNumber,
    IN PCWSTR szVolumeGuid
    )


/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    PMOUNTMGR_CREATE_POINT_INPUT inputCreatePoint = NULL;
    PMOUNTMGR_MOUNT_POINT inputDeletePoint = NULL;
    PMOUNTMGR_MOUNT_POINTS outputDeletePoint = NULL;
    WCHAR deviceName[ASR_CCH_DEVICE_PATH_FORMAT];
    PMOUNTMGR_MOUNT_POINTS  mountPointsOut  = NULL;

    INT attempt = 0;
    
    DWORD cbName = 0;
    PWSTR lpName = NULL;
    DWORD cbDeletePoint = 0;

    USHORT sizeGuid = 0,
        sizeDeviceName = 0;

    DWORD bytes = 0, index = 0,
        status = ERROR_SUCCESS;

    HANDLE mpHandle = NULL,
        heapHandle = GetProcessHeap();

    BOOL result = TRUE;

    if (!szVolumeGuid || !wcslen(szVolumeGuid)) {
        return TRUE;
    }

    //
    // Open the mount manager
    //
    mpHandle = CreateFileW(
        (PCWSTR) MOUNTMGR_DOS_DEVICE_NAME,      // lpFileName
        GENERIC_READ | GENERIC_WRITE,           // dwDesiredAccess
        FILE_SHARE_READ | FILE_SHARE_WRITE,     // dwShareMode
        NULL,                       // lpSecurityAttributes
        OPEN_EXISTING,              // dwCreationFlags
        FILE_ATTRIBUTE_NORMAL,      // dwFlagsAndAttributes
        INVALID_HANDLE_VALUE        // hTemplateFile
        );
    _AsrpErrExitCode((!mpHandle || INVALID_HANDLE_VALUE == mpHandle), status, GetLastError());

    swprintf(deviceName, ASR_WSZ_DEVICE_PATH_FORMAT, DiskNumber, PartitionNumber);
    
    sizeDeviceName = wcslen(deviceName) * sizeof(WCHAR);
    sizeGuid = wcslen(szVolumeGuid) * sizeof(WCHAR);


    //
    // There is a small window after a partition is created in which the 
    // device-path to it (\Device\HarddiskX\PartitionY) doesn't exist, and
    // a small window in which the device-path is actually pointing to 
    // the wrong object.  (Partmgr first creates the path, <small window>,
    // assigns it to the correct object)
    // 
    // Since this will cause CREATE_POINT to fail later with FILE_NOT_FOUND,
    // lets wait till mountmgr sees the device object.
    //
    result = FALSE;
    while ((!result) && (++attempt < 120)) {

        result = AsrpGetMountPoints(deviceName, sizeDeviceName + sizeof(WCHAR), &mountPointsOut);
        if (!result) {
            Sleep(500);
        }
    }

    outputDeletePoint = (PMOUNTMGR_MOUNT_POINTS) HeapAlloc(
        heapHandle,
        HEAP_ZERO_MEMORY,
        ASR_BUFFER_SIZE
        );
    _AsrpErrExitCode(!outputDeletePoint, status, ERROR_NOT_ENOUGH_MEMORY);

    //
    // The mountmgr assigns a volume-GUID symbolic link (\??\Volume{Guid}) to
    // a basic partition as soon as it's created.  In addition, we will re-
    // create the symbolic link that the partition originally used to have 
    // (as stored in asr.sif).
    //
    // This will lead to the partition having two volume-GUID's at the end.
    // This is wasteful, but generally harmless to the system--however, the 
    // ASR test verification scripts get numerous false hits because of the
    // additional GUID.
    //
    // To fix this, we delete the new mountmgr assigned-GUID before restoring 
    // the original GUID for the partition from asr.sif.  
    //
    if ((result) && (mountPointsOut)) {

        for (index = 0; index < mountPointsOut->NumberOfMountPoints; index++) {

            lpName = (PWSTR) (((LPBYTE)mountPointsOut) + mountPointsOut->MountPoints[index].SymbolicLinkNameOffset);
            cbName = (DWORD) mountPointsOut->MountPoints[index].SymbolicLinkNameLength;

            if (!_AsrpIsVolumeGuid(lpName, cbName)) {
                continue;
            }

            //
            // We found a link that looks like a volume GUID 
            //
            cbDeletePoint = sizeof(MOUNTMGR_MOUNT_POINT) +
                mountPointsOut->MountPoints[index].SymbolicLinkNameLength +
                mountPointsOut->MountPoints[index].UniqueIdLength +
                mountPointsOut->MountPoints[index].DeviceNameLength;

            inputDeletePoint = (PMOUNTMGR_MOUNT_POINT) HeapAlloc(
                heapHandle,
                HEAP_ZERO_MEMORY,
                cbDeletePoint
                );
            _AsrpErrExitCode(!inputDeletePoint, status, ERROR_NOT_ENOUGH_MEMORY);

            //
            // Set the fields to match the current link
            //
            inputDeletePoint->SymbolicLinkNameOffset = 
                sizeof(MOUNTMGR_MOUNT_POINT);
            inputDeletePoint->SymbolicLinkNameLength = 
                mountPointsOut->MountPoints[index].SymbolicLinkNameLength;
            CopyMemory(
                ((LPBYTE)inputDeletePoint) + 
                    inputDeletePoint->SymbolicLinkNameOffset,
                ((LPBYTE)mountPointsOut) + 
                    mountPointsOut->MountPoints[index].SymbolicLinkNameOffset,
                inputDeletePoint->SymbolicLinkNameLength);

            inputDeletePoint->UniqueIdOffset = 
                inputDeletePoint->SymbolicLinkNameOffset + 
                inputDeletePoint->SymbolicLinkNameLength;
            inputDeletePoint->UniqueIdLength = 
                mountPointsOut->MountPoints[index].UniqueIdLength;
            CopyMemory(
                ((LPBYTE)inputDeletePoint) + 
                    inputDeletePoint->UniqueIdOffset,
                ((LPBYTE)mountPointsOut) + 
                    mountPointsOut->MountPoints[index].UniqueIdOffset,
                inputDeletePoint->UniqueIdLength);

            inputDeletePoint->DeviceNameOffset = 
                inputDeletePoint->UniqueIdOffset +
                inputDeletePoint->UniqueIdLength;
            inputDeletePoint->DeviceNameLength = 
                mountPointsOut->MountPoints[index].DeviceNameLength;
            CopyMemory((
                (LPBYTE)inputDeletePoint) + 
                    inputDeletePoint->DeviceNameOffset,
                ((LPBYTE)mountPointsOut) + 
                    mountPointsOut->MountPoints[index].DeviceNameOffset,
                inputDeletePoint->DeviceNameLength);

            //
            // And delete this link ...
            //
            result = DeviceIoControl(
                mpHandle,
                IOCTL_MOUNTMGR_DELETE_POINTS,
                inputDeletePoint,
                cbDeletePoint,
                outputDeletePoint,
                ASR_BUFFER_SIZE,
                &bytes,
                NULL
                );
            //
            // It's okay if the delete fails.
            //

            GetLastError();     // for debug

            _AsrpHeapFree(inputDeletePoint);
        }
    }


    //
    // Alloc the MountMgr points we need
    //
    inputCreatePoint = (PMOUNTMGR_CREATE_POINT_INPUT) HeapAlloc(
        heapHandle,
        HEAP_ZERO_MEMORY,
        sizeof (MOUNTMGR_CREATE_POINT_INPUT) + sizeDeviceName + sizeGuid
        );
    _AsrpErrExitCode(!inputCreatePoint, status, ERROR_NOT_ENOUGH_MEMORY);

    inputDeletePoint = (PMOUNTMGR_MOUNT_POINT) HeapAlloc(
        heapHandle,
        HEAP_ZERO_MEMORY,
        sizeof(MOUNTMGR_MOUNT_POINT) + sizeGuid
        );
    _AsrpErrExitCode(!inputDeletePoint, status, ERROR_NOT_ENOUGH_MEMORY);


    //
    // We should delete this volume guid if some other partition
    // already has it, else we'll get an ALREADY_EXISTS error
    // when we try to create it.
    //
    inputDeletePoint->DeviceNameOffset = 0;
    inputDeletePoint->DeviceNameLength = 0;

    inputDeletePoint->SymbolicLinkNameOffset = sizeof(MOUNTMGR_MOUNT_POINT);
    inputDeletePoint->SymbolicLinkNameLength = sizeGuid;

    CopyMemory((((LPBYTE)inputDeletePoint) + inputDeletePoint->SymbolicLinkNameOffset),
        ((LPBYTE)szVolumeGuid), 
        inputDeletePoint->SymbolicLinkNameLength
        );

    result = DeviceIoControl(
        mpHandle,
        IOCTL_MOUNTMGR_DELETE_POINTS,
        inputDeletePoint,
        sizeof (MOUNTMGR_MOUNT_POINT) + sizeGuid,
        outputDeletePoint,
        ASR_BUFFER_SIZE,
        &bytes,
        NULL
        );
    //
    // It's okay if this fails.
    //
//    _AsrpErrExitCode(!result, status, GetLastError());

    GetLastError();     // for Debug

    //
    // Call IOCTL_MOUNTMGR_CREATE_POINT
    //
    inputCreatePoint->SymbolicLinkNameOffset = sizeof(MOUNTMGR_CREATE_POINT_INPUT);
    inputCreatePoint->SymbolicLinkNameLength = sizeGuid;

    inputCreatePoint->DeviceNameOffset = inputCreatePoint->SymbolicLinkNameOffset + inputCreatePoint->SymbolicLinkNameLength;
    inputCreatePoint->DeviceNameLength = sizeDeviceName;

    CopyMemory(((LPBYTE)inputCreatePoint) + inputCreatePoint->SymbolicLinkNameOffset,
               szVolumeGuid, inputCreatePoint->SymbolicLinkNameLength);

    CopyMemory(((LPBYTE)inputCreatePoint) + inputCreatePoint->DeviceNameOffset,
               deviceName, inputCreatePoint->DeviceNameLength);

    result = DeviceIoControl(
        mpHandle,
        IOCTL_MOUNTMGR_CREATE_POINT,
        inputCreatePoint,
        sizeof (MOUNTMGR_CREATE_POINT_INPUT) + sizeDeviceName + sizeGuid,
        NULL,
        0,
        &bytes,
        NULL
        );
    _AsrpErrExitCode(!result, status, GetLastError());

    //
    // We're done.
    //

EXIT:
    _AsrpCloseHandle(mpHandle);
    _AsrpHeapFree(mountPointsOut);
    _AsrpHeapFree(inputCreatePoint);
    _AsrpHeapFree(inputDeletePoint);
    _AsrpHeapFree(outputDeletePoint);

    return (BOOL) (ERROR_SUCCESS == status);
}


//
// Assigns the volume guid's stored in the partition-list to partitions
// on the physical disk, based on the start sectors
//
BOOL
AsrpAssignVolumeGuids(
    IN PASR_DISK_INFO  pPhysicalDisk,
    IN HANDLE          hDisk,           // open handle to the physical disk
    IN PASR_PTN_INFO   pPtnInfo         // list of partitions--with vol guids ...
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{
    PDRIVE_LAYOUT_INFORMATION_EX pDriveLayoutEx = NULL;
    DWORD sizeDriveLayoutEx = pPhysicalDisk->sizeDriveLayoutEx;

    DWORD index = 0,
        status = ERROR_SUCCESS,
        bytes = 0;

    BOOL result = FALSE,
        found = FALSE;

    PASR_PTN_INFO currentPtn = NULL;

    HANDLE heapHandle = GetProcessHeap();

    //
    // Get the new layout for the physical disk.
    //
    pDriveLayoutEx = (PDRIVE_LAYOUT_INFORMATION_EX) HeapAlloc(
        heapHandle,
        HEAP_ZERO_MEMORY,
        sizeDriveLayoutEx
        );
    _AsrpErrExitCode(!pDriveLayoutEx, status, ERROR_NOT_ENOUGH_MEMORY);

    while (!result) {

        result = DeviceIoControl(
            hDisk,
            IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
            NULL,
            0L,
            pDriveLayoutEx,
            sizeDriveLayoutEx,
            &bytes,
            NULL
            );

        if (!result) {
            status = GetLastError();

            _AsrpHeapFree(pDriveLayoutEx);

            // 
            // If the buffer is of insufficient size, resize the buffer.
            //
            if ((ERROR_MORE_DATA == status) || (ERROR_INSUFFICIENT_BUFFER == status)) {

                status = ERROR_SUCCESS;
                sizeDriveLayoutEx += sizeof(PARTITION_INFORMATION_EX) * 4;

                pDriveLayoutEx = (PDRIVE_LAYOUT_INFORMATION_EX) HeapAlloc(
                    heapHandle,
                    HEAP_ZERO_MEMORY,
                    sizeDriveLayoutEx
                    );
                _AsrpErrExitCode(!pDriveLayoutEx, status, ERROR_NOT_ENOUGH_MEMORY);
            }
            else {

                AsrpPrintDbgMsg(_asrlog, 
                    "The drive layout on Harddisk %lu (%ws) could not be determined (%lu).  The volumes on this disk may not be restored completely.\r\n", 
                    pPhysicalDisk->DeviceNumber,
                    pPhysicalDisk->DevicePath,
                    GetLastError()
                    );

                _AsrpErrExitCode(status, status, GetLastError());
            }
        }
    }

    //
    // We have the drive layout.  Now each partition in our list should have
    // an entry in the partition table.  We use the mount manager to set it's
    // volume guid.
    //
    currentPtn = pPtnInfo;
    result = TRUE;
    while (currentPtn) {

        //
        // We only care about partitions that have a volume-guid
        //
        if ((currentPtn->szVolumeGuid) && 
            (wcslen(currentPtn->szVolumeGuid) > 0)
            ) {
        
            //
            // Go through all the partitions on the disk, and find one that 
            // starts at the offset we expect it to.
            //
            found = FALSE;
            index = 0;

            while (!found && (index < pDriveLayoutEx->PartitionCount)) {

                if (pDriveLayoutEx->PartitionEntry[index].StartingOffset.QuadPart
                    == currentPtn->PartitionInfo.StartingOffset.QuadPart) {
                    //
                    // We found the partition, let's set its GUID now
                    //
                    AsrpCreateMountPoint(
                        pPhysicalDisk->DeviceNumber,    // disk number
                        pDriveLayoutEx->PartitionEntry[index].PartitionNumber, // partition number
                        currentPtn->szVolumeGuid    // volumeGuid
                        );

                    found = TRUE;
                }
                else {
                    index++;
                }
            }

            if (!found) {
                result = FALSE;
            }

        }

        currentPtn = currentPtn->pOffsetNext;
    }

    if (!result) {
        //
        // We didn't find a partition
        //

        AsrpPrintDbgMsg(_asrlog, 
            "One or more partitions on Harddisk %lu (%ws) could not be recreated.  The volumes on this disk may not be restored completely.\r\n", 
            pPhysicalDisk->DeviceNumber,
            pPhysicalDisk->DevicePath
            );

        _AsrpErrExitCode(status, status, ERROR_BAD_DEVICE);
    }


EXIT:
    _AsrpHeapFree(pDriveLayoutEx);

    return (BOOL) (ERROR_SUCCESS == status);
}


//
// Re-partitions the disks
//
BOOL
AsrpRecreateDisks(
    IN PASR_DISK_INFO pSifDiskList,
    IN PASR_PTN_INFO_LIST pSifMbrPtnList,
    IN PASR_PTN_INFO_LIST pSifGptPtnList,
    IN BOOL AllOrNothing
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{


    PASR_DISK_INFO  pSifDisk        = pSifDiskList;

    DWORD           bytesReturned   = 0,
                    status          = ERROR_SUCCESS;

    HANDLE          hDisk           = NULL;

    BOOL            result          = TRUE;

    //
    // For each sif disk that isn't intact, go to the physical
    // disk it's assigned to, and recreate that disk
    //
    while (pSifDisk) {

        if (!(pSifDisk->AssignedTo)) {

            AsrpPrintDbgMsg(_asrinfo, 
                "Not recreating disk %lu in section [%ws] (no matching disk found).\r\n", 
                pSifDisk->SifDiskKey,
                ((PARTITION_STYLE_MBR == pSifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION)
                );

            if (AllOrNothing) {
                return FALSE;
            }
            else {
                pSifDisk = pSifDisk->pNext;
                continue;
            }
        }

        if ((pSifDisk->IsCritical) ||
            (pSifDisk->AssignedTo->IsCritical)) {

            AsrpPrintDbgMsg(_asrinfo, 
                "Not recreating Harddisk %lu (disk %lu in section [%ws]) (critical disk).\r\n", 
                pSifDisk->AssignedTo->DeviceNumber,
                pSifDisk->SifDiskKey,
                ((PARTITION_STYLE_MBR == pSifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION)
                );

            pSifDisk = pSifDisk->pNext;
            continue;
        }

        //
        // Open physical disk
        //
        hDisk = CreateFileW(
            pSifDisk->AssignedTo->DevicePath,   // lpFileName
            GENERIC_WRITE | GENERIC_READ,       // dwDesiredAccess
            FILE_SHARE_READ | FILE_SHARE_WRITE, // dwShareMode
            NULL,           // lpSecurityAttributes
            OPEN_EXISTING,  // dwCreationFlags
            0,              // dwFlagsAndAttributes
            NULL            // hTemplateFile
            );
        if ((!hDisk) || (INVALID_HANDLE_VALUE == hDisk)) {
            //
            // We couldn't open the disk.
            //

            AsrpPrintDbgMsg(_asrlog, 
                "Unable to open Harddisk %lu (%ws) (disk %lu in section [%ws]) (0%lu).\r\n", 
                pSifDisk->AssignedTo->DeviceNumber,
                pSifDisk->AssignedTo->DevicePath,
                pSifDisk->SifDiskKey,
                ((PARTITION_STYLE_MBR == pSifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION),
                GetLastError()
                );

            if (AllOrNothing) {
                return FALSE;
            }
            else {
                pSifDisk = pSifDisk->pNext;
                continue;
            }
        }


        if (!(pSifDisk->IsIntact) &&            // disk is not intact
            (pSifDisk->AssignedTo) &&           // matching physical disk was found
            ((PARTITION_STYLE_MBR == pSifDisk->Style) || (PARTITION_STYLE_GPT == pSifDisk->Style))    // not recognised partitioning style
            ) {

            //
            // Delete the old drive layout
            //
            result = DeviceIoControl(
                hDisk,
                IOCTL_DISK_DELETE_DRIVE_LAYOUT,
                NULL,
                0L,
                NULL,
                0L,
                &bytesReturned,
                NULL
                );
            if (!result) {

                AsrpPrintDbgMsg(_asrlog, 
                    "Unable to delete layout on Harddisk %lu (%ws) (disk %lu in section [%ws]) (%lu).\r\n", 
                    pSifDisk->AssignedTo->DeviceNumber,
                    pSifDisk->AssignedTo->DevicePath,
                    pSifDisk->SifDiskKey,
                    ((PARTITION_STYLE_MBR == pSifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION),
                    GetLastError()
                    );

                GetLastError();
            }

            //
            //  If we're converting an MBR to a GPT, then we need to call
            //  IOCTL_DISK_CREATE_DISK first
            //

            if ((PARTITION_STYLE_GPT == pSifDisk->Style) &&
                (PARTITION_STYLE_MBR == pSifDisk->AssignedTo->Style)) {

                CREATE_DISK CreateDisk;

                CreateDisk.PartitionStyle = PARTITION_STYLE_GPT;
                memcpy(&(CreateDisk.Gpt.DiskId), &(pSifDisk->pDriveLayoutEx->Gpt.DiskId), sizeof(GUID));
                CreateDisk.Gpt.MaxPartitionCount =  pSifDisk->pDriveLayoutEx->Gpt.MaxPartitionCount;

                result = DeviceIoControl(
                    hDisk,
                    IOCTL_DISK_CREATE_DISK,
                    &(CreateDisk),
                    sizeof(CREATE_DISK),
                    NULL,
                    0L,
                    &bytesReturned,
                    NULL
                    );

                if (!result) {
                    //
                    // CREATE_DISK failed
                    //

                    status = GetLastError();
                    AsrpPrintDbgMsg(_asrlog, 
                        "Unable to initialize disk layout on Harddisk %lu (%ws) (disk %lu in section [%ws]) (0%lu).\r\n", 
                        pSifDisk->AssignedTo->DeviceNumber,
                        pSifDisk->AssignedTo->DevicePath,
                        pSifDisk->SifDiskKey,
                        ((PARTITION_STYLE_MBR == pSifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION),
                        GetLastError()
                        );

                    _AsrpCloseHandle(hDisk);
                    SetLastError(status);

                    if (AllOrNothing) {
                        return FALSE;
                    }
                    else {
                        pSifDisk = pSifDisk->pNext;
                        continue;
                    }
                }
            }

            //
            // Set the new drive layout
            //
            result = DeviceIoControl(
                hDisk,
                IOCTL_DISK_SET_DRIVE_LAYOUT_EX,
                pSifDisk->AssignedTo->pDriveLayoutEx,
                pSifDisk->AssignedTo->sizeDriveLayoutEx,
                NULL,
                0L,
                &bytesReturned,
                NULL
                );

            if (!result) {
                //
                // SET_DRIVE_LAYOUT failed
                //
                status = GetLastError();
                AsrpPrintDbgMsg(_asrlog, 
                    "Unable to set drive layout on Harddisk %lu (%ws) (disk %lu in section [%ws]) (0%lu).\r\n", 
                    pSifDisk->AssignedTo->DeviceNumber,
                    pSifDisk->AssignedTo->DevicePath,
                    pSifDisk->SifDiskKey,
                    ((PARTITION_STYLE_MBR == pSifDisk->Style) ? ASR_SIF_MBR_DISKS_SECTION : ASR_SIF_GPT_DISKS_SECTION),
                    GetLastError()
                    );

                _AsrpCloseHandle(hDisk);
                SetLastError(status);

                if (AllOrNothing) {
                    return FALSE;
                }
                else {
                    pSifDisk = pSifDisk->pNext;
                    continue;
                }
            }
        }

        //
        // Now we need to recreate the volumeGuids for each partition
        //
        result = AsrpAssignVolumeGuids(
            pSifDisk->AssignedTo,
            hDisk,
            ((PARTITION_STYLE_MBR == pSifDisk->Style) ?
                (pSifMbrPtnList[pSifDisk->SifDiskKey].pOffsetHead) :
                (pSifGptPtnList[pSifDisk->SifDiskKey].pOffsetHead))
            );

        //
        // We don't care about the result ...
        //
        MYASSERT(result && L"AsrpAssignVolumeGuids failed");

        _AsrpCloseHandle(hDisk);

        //
        // Get the next drive from the drive list.
        //
        pSifDisk = pSifDisk->pNext;
    }

    return TRUE;
}


//
//  Restore Non Critical Disks
//
//
BOOL
AsrpRestoreNonCriticalDisksW(
    IN PCWSTR   lpSifPath,
    IN BOOL     bAllOrNothing
    )

/*++

Routine Description:

    

Arguments:

    

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{

    BOOL    result = FALSE;

    PWSTR   asrSifPath      = NULL;

    //
    // We have two lists of disks--one of all the physical disks
    // currently on the system, and the other constructed from the
    // sif file.  The goal is to reconfigure non-critical disks in
    // the pPhysicalDiskList to match the pSifDiskList
    //
    PASR_DISK_INFO pSifDiskList = NULL,
        pPhysicalDiskList = NULL;

    PASR_PTN_INFO_LIST  pSifMbrPtnList = NULL,
        pSifGptPtnList = NULL;

    DWORD  cchAsrSifPath = 0,
        MaxDeviceNumber = 0,     // not used
        status = ERROR_SUCCESS;

    BOOL    bAutoExtend = FALSE,
        allOrNothing = FALSE;

    HANDLE  heapHandle = GetProcessHeap();

    SetLastError(ERROR_CAN_NOT_COMPLETE);

    if (!AsrIsEnabled()) {
        //
        // If we're not in GUI-mode ASR, we need to open the log files first
        //
        AsrpInitialiseErrorFile();
        AsrpInitialiseLogFile();
    }

    AsrpPrintDbgMsg(_asrlog, "Attempting to restore non-critical disks.\r\n");

    if (!lpSifPath) {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto EXIT;
    }

    cchAsrSifPath = wcslen(lpSifPath);
    //
    // Do a sanity check:  we don't want to allow a file path
    // more than 4096 characters long.
    //
    if (cchAsrSifPath > ASR_SIF_ENTRY_MAX_CHARS) {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto EXIT;
    }

    asrSifPath = (PWSTR) HeapAlloc(
        heapHandle,
        HEAP_ZERO_MEMORY,
        ((cchAsrSifPath + 1) * sizeof(WCHAR))
        );
    _AsrpErrExitCode(!asrSifPath, status, ERROR_NOT_ENOUGH_MEMORY);

    wcsncpy(asrSifPath, lpSifPath, cchAsrSifPath);

    allOrNothing = bAllOrNothing;

    AsrpPrintDbgMsg(_asrlog, "ASR state file: \"%ws\".  AllOrNothing: %lu\r\n",
        asrSifPath, allOrNothing);

    //
    // The function calls are AND'ed below, hence if one fails, the
    // calls after it will not be executed (exactly the behaviour we
    // want).
    //
    result = (

        //
        // Build the original disk info from the sif file
        //
        AsrpBuildMbrSifDiskList(asrSifPath, &pSifDiskList, &pSifMbrPtnList, &bAutoExtend)

        && AsrpBuildGptSifDiskList(asrSifPath, &pSifDiskList, &pSifGptPtnList)

        //
        // Build the list of current disks present on the target machine
        //
        && AsrpInitDiskInformation(&pPhysicalDiskList)

        //
        // Fill in the partition info for the fixed disks on the target machine
        // and remove non-fixed devices
        //
        && AsrpInitLayoutInformation(NULL, pPhysicalDiskList, &MaxDeviceNumber, TRUE, FALSE)

        && AsrpFreeNonFixedMedia(&pPhysicalDiskList)

        //
        // Try to determine which sif disk should end up on which physical disk.
        //
        && AsrpAssignDisks(pSifDiskList, pPhysicalDiskList, pSifMbrPtnList, pSifGptPtnList, allOrNothing, bAutoExtend)

        //
        // Finally, repartition the disks and assign the volume guids
        //
        && AsrpRecreateDisks(pSifDiskList, pSifMbrPtnList, pSifGptPtnList, allOrNothing)
    );

    status = GetLastError();
    AsrpFreeStateInformation(&pSifDiskList, NULL);
    AsrpFreeStateInformation(&pPhysicalDiskList, NULL);
    AsrpFreePartitionList(&pSifMbrPtnList);
    AsrpFreePartitionList(&pSifGptPtnList);
    SetLastError(status);

EXIT:

    status = GetLastError();

    if (result) {
        AsrpPrintDbgMsg(_asrinfo, "Done restoring non-critical disks.\r\n");
    }
    else {
        
        AsrpPrintDbgMsg(_asrerror, "Error restoring non-critical disks.  (0x%x)\r\n", status);
        
        if (ERROR_SUCCESS == status) {
            //
            // We're going to return failure, but we haven't set the LastError to 
            // a failure code.  This is bad, since we have no clue what went wrong.
            //
            // We shouldn't ever get here, because the function returning FALSE above
            // should set the LastError as it sees fit.
            // 
            // But I've added this in just to be safe.  Let's set it to a generic
            // error.
            //
            MYASSERT(0 && L"Returning failure, but LastError is not set");
            status = ERROR_CAN_NOT_COMPLETE;
        }
    }

    if (!AsrIsEnabled()) {
        AsrpCloseLogFiles();
    }

    _AsrpHeapFree(asrSifPath);

    SetLastError(status);
    return result;
}


BOOL
AsrpRestoreTimeZoneInformation(
    IN PCWSTR   lpSifPath
    )
/*++

Routine Description:

    Sets the current time-zone, based on the information stored in the SYSTEMS
    section of the ASR state file.

Arguments:

    lpSifPath - Null-terminated string containing the full path to the ASR
            state file (including file name).

Return Value:

    If the function succeeds, the return value is a nonzero value.

    If the function fails, the return value is zero. To get extended error 
        information, call GetLastError().

--*/

{

    HINF hSif = NULL;

    BOOL result = FALSE;

    DWORD reqdSize = 0,
        status = ERROR_SUCCESS;

    INFCONTEXT infSystemContext;

    TIME_ZONE_INFORMATION TimeZoneInformation;

    WCHAR szTimeZoneInfo[ASR_SIF_ENTRY_MAX_CHARS+1];

    ZeroMemory(&infSystemContext, sizeof(INFCONTEXT));
    ZeroMemory(&TimeZoneInformation, sizeof(TIME_ZONE_INFORMATION));
    ZeroMemory(&szTimeZoneInfo, sizeof(WCHAR)*(ASR_SIF_ENTRY_MAX_CHARS+1));

    //
    // Open the sif
    //
    hSif = SetupOpenInfFileW(lpSifPath, NULL, INF_STYLE_WIN4, NULL);
    if (NULL == hSif || INVALID_HANDLE_VALUE == hSif) {
        return FALSE;       // sif file couldn't be opened
    }

    //
    // Get the TimeZone strings value
    //
    result = SetupFindFirstLineW(hSif, ASR_SIF_SYSTEM_SECTION, NULL, &infSystemContext);
    _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // no system section: corrupt asr.sif?
 
    result = SetupGetStringFieldW(&infSystemContext, 7, szTimeZoneInfo, ASR_SIF_ENTRY_MAX_CHARS+1, &reqdSize);
    _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

    swscanf(szTimeZoneInfo,
        L"%ld %ld %ld %hd-%hd-%hd-%hd %hd:%hd:%hd.%hd %hd-%hd-%hd-%hd %hd:%hd:%hd.%hd",
        &(TimeZoneInformation.Bias),
        &(TimeZoneInformation.StandardBias),
        &(TimeZoneInformation.DaylightBias),

        &(TimeZoneInformation.StandardDate.wYear),
        &(TimeZoneInformation.StandardDate.wMonth),
        &(TimeZoneInformation.StandardDate.wDayOfWeek),
        &(TimeZoneInformation.StandardDate.wDay),

        &(TimeZoneInformation.StandardDate.wHour),
        &(TimeZoneInformation.StandardDate.wMinute),
        &(TimeZoneInformation.StandardDate.wSecond),
        &(TimeZoneInformation.StandardDate.wMilliseconds),

        &(TimeZoneInformation.DaylightDate.wYear),
        &(TimeZoneInformation.DaylightDate.wMonth),
        &(TimeZoneInformation.DaylightDate.wDayOfWeek),
        &(TimeZoneInformation.DaylightDate.wDay),

        &(TimeZoneInformation.DaylightDate.wHour),
        &(TimeZoneInformation.DaylightDate.wMinute),
        &(TimeZoneInformation.DaylightDate.wSecond),
        &(TimeZoneInformation.DaylightDate.wMilliseconds)
        );

    result = SetupGetStringFieldW(&infSystemContext, 8, TimeZoneInformation.StandardName, 32, &reqdSize);
    _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

    result = SetupGetStringFieldW(&infSystemContext, 9, TimeZoneInformation.DaylightName, 32, &reqdSize);
    _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

    result = SetTimeZoneInformation(&TimeZoneInformation);
    if (!result) {
        GetLastError();
    }
    _AsrpErrExitCode(!result, status, ERROR_INVALID_DATA);      // corrupt asr.sif?

EXIT:

    if (ERROR_SUCCESS != status) {
        SetLastError(status);
    }

    return result;
}